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, ShortCaseLabels) { 1302 FormatStyle Style = getLLVMStyle(); 1303 Style.AllowShortCaseLabelsOnASingleLine = true; 1304 verifyFormat("switch (a) {\n" 1305 "case 1: x = 1; break;\n" 1306 "case 2: return;\n" 1307 "case 3:\n" 1308 "case 4:\n" 1309 "case 5: return;\n" 1310 "case 6: // comment\n" 1311 " return;\n" 1312 "case 7:\n" 1313 " // comment\n" 1314 " return;\n" 1315 "case 8:\n" 1316 " x = 8; // comment\n" 1317 " break;\n" 1318 "default: y = 1; break;\n" 1319 "}", 1320 Style); 1321 verifyFormat("switch (a) {\n" 1322 "case 0: return; // comment\n" 1323 "case 1: break; // comment\n" 1324 "case 2: return;\n" 1325 "// comment\n" 1326 "case 3: return;\n" 1327 "// comment 1\n" 1328 "// comment 2\n" 1329 "// comment 3\n" 1330 "case 4: break; /* comment */\n" 1331 "case 5:\n" 1332 " // comment\n" 1333 " break;\n" 1334 "case 6: /* comment */ x = 1; break;\n" 1335 "case 7: x = /* comment */ 1; break;\n" 1336 "case 8:\n" 1337 " x = 1; /* comment */\n" 1338 " break;\n" 1339 "case 9:\n" 1340 " break; // comment line 1\n" 1341 " // comment line 2\n" 1342 "}", 1343 Style); 1344 EXPECT_EQ("switch (a) {\n" 1345 "case 1:\n" 1346 " x = 8;\n" 1347 " // fall through\n" 1348 "case 2: x = 8;\n" 1349 "// comment\n" 1350 "case 3:\n" 1351 " return; /* comment line 1\n" 1352 " * comment line 2 */\n" 1353 "case 4: i = 8;\n" 1354 "// something else\n" 1355 "#if FOO\n" 1356 "case 5: break;\n" 1357 "#endif\n" 1358 "}", 1359 format("switch (a) {\n" 1360 "case 1: x = 8;\n" 1361 " // fall through\n" 1362 "case 2:\n" 1363 " x = 8;\n" 1364 "// comment\n" 1365 "case 3:\n" 1366 " return; /* comment line 1\n" 1367 " * comment line 2 */\n" 1368 "case 4:\n" 1369 " i = 8;\n" 1370 "// something else\n" 1371 "#if FOO\n" 1372 "case 5: break;\n" 1373 "#endif\n" 1374 "}", 1375 Style)); 1376 EXPECT_EQ("switch (a) {\n" 1377 "case 0:\n" 1378 " return; // long long long long long long long long long long " 1379 "long long comment\n" 1380 " // line\n" 1381 "}", 1382 format("switch (a) {\n" 1383 "case 0: return; // long long long long long long long long " 1384 "long long long long comment line\n" 1385 "}", 1386 Style)); 1387 EXPECT_EQ("switch (a) {\n" 1388 "case 0:\n" 1389 " return; /* long long long long long long long long long long " 1390 "long long comment\n" 1391 " line */\n" 1392 "}", 1393 format("switch (a) {\n" 1394 "case 0: return; /* long long long long long long long long " 1395 "long long long long comment line */\n" 1396 "}", 1397 Style)); 1398 verifyFormat("switch (a) {\n" 1399 "#if FOO\n" 1400 "case 0: return 0;\n" 1401 "#endif\n" 1402 "}", 1403 Style); 1404 verifyFormat("switch (a) {\n" 1405 "case 1: {\n" 1406 "}\n" 1407 "case 2: {\n" 1408 " return;\n" 1409 "}\n" 1410 "case 3: {\n" 1411 " x = 1;\n" 1412 " return;\n" 1413 "}\n" 1414 "case 4:\n" 1415 " if (x)\n" 1416 " return;\n" 1417 "}", 1418 Style); 1419 Style.ColumnLimit = 21; 1420 verifyFormat("switch (a) {\n" 1421 "case 1: x = 1; break;\n" 1422 "case 2: return;\n" 1423 "case 3:\n" 1424 "case 4:\n" 1425 "case 5: return;\n" 1426 "default:\n" 1427 " y = 1;\n" 1428 " break;\n" 1429 "}", 1430 Style); 1431 Style.ColumnLimit = 80; 1432 Style.AllowShortCaseLabelsOnASingleLine = false; 1433 Style.IndentCaseLabels = true; 1434 EXPECT_EQ("switch (n) {\n" 1435 " default /*comments*/:\n" 1436 " return true;\n" 1437 " case 0:\n" 1438 " return false;\n" 1439 "}", 1440 format("switch (n) {\n" 1441 "default/*comments*/:\n" 1442 " return true;\n" 1443 "case 0:\n" 1444 " return false;\n" 1445 "}", 1446 Style)); 1447 Style.AllowShortCaseLabelsOnASingleLine = true; 1448 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1449 Style.BraceWrapping.AfterCaseLabel = true; 1450 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1451 EXPECT_EQ("switch (n)\n" 1452 "{\n" 1453 " case 0:\n" 1454 " {\n" 1455 " return false;\n" 1456 " }\n" 1457 " default:\n" 1458 " {\n" 1459 " return true;\n" 1460 " }\n" 1461 "}", 1462 format("switch (n) {\n" 1463 " case 0: {\n" 1464 " return false;\n" 1465 " }\n" 1466 " default:\n" 1467 " {\n" 1468 " return true;\n" 1469 " }\n" 1470 "}", 1471 Style)); 1472 } 1473 1474 TEST_F(FormatTest, FormatsLabels) { 1475 verifyFormat("void f() {\n" 1476 " some_code();\n" 1477 "test_label:\n" 1478 " some_other_code();\n" 1479 " {\n" 1480 " some_more_code();\n" 1481 " another_label:\n" 1482 " some_more_code();\n" 1483 " }\n" 1484 "}"); 1485 verifyFormat("{\n" 1486 " some_code();\n" 1487 "test_label:\n" 1488 " some_other_code();\n" 1489 "}"); 1490 verifyFormat("{\n" 1491 " some_code();\n" 1492 "test_label:;\n" 1493 " int i = 0;\n" 1494 "}"); 1495 FormatStyle Style = getLLVMStyle(); 1496 Style.IndentGotoLabels = false; 1497 verifyFormat("void f() {\n" 1498 " some_code();\n" 1499 "test_label:\n" 1500 " some_other_code();\n" 1501 " {\n" 1502 " some_more_code();\n" 1503 "another_label:\n" 1504 " some_more_code();\n" 1505 " }\n" 1506 "}", 1507 Style); 1508 verifyFormat("{\n" 1509 " some_code();\n" 1510 "test_label:\n" 1511 " some_other_code();\n" 1512 "}", 1513 Style); 1514 verifyFormat("{\n" 1515 " some_code();\n" 1516 "test_label:;\n" 1517 " int i = 0;\n" 1518 "}"); 1519 } 1520 1521 TEST_F(FormatTest, MultiLineControlStatements) { 1522 FormatStyle Style = getLLVMStyle(); 1523 Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom; 1524 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine; 1525 Style.ColumnLimit = 20; 1526 // Short lines should keep opening brace on same line. 1527 EXPECT_EQ("if (foo) {\n" 1528 " bar();\n" 1529 "}", 1530 format("if(foo){bar();}", Style)); 1531 EXPECT_EQ("if (foo) {\n" 1532 " bar();\n" 1533 "} else {\n" 1534 " baz();\n" 1535 "}", 1536 format("if(foo){bar();}else{baz();}", Style)); 1537 EXPECT_EQ("if (foo && bar) {\n" 1538 " baz();\n" 1539 "}", 1540 format("if(foo&&bar){baz();}", Style)); 1541 EXPECT_EQ("if (foo) {\n" 1542 " bar();\n" 1543 "} else if (baz) {\n" 1544 " quux();\n" 1545 "}", 1546 format("if(foo){bar();}else if(baz){quux();}", Style)); 1547 EXPECT_EQ( 1548 "if (foo) {\n" 1549 " bar();\n" 1550 "} else if (baz) {\n" 1551 " quux();\n" 1552 "} else {\n" 1553 " foobar();\n" 1554 "}", 1555 format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style)); 1556 EXPECT_EQ("for (;;) {\n" 1557 " foo();\n" 1558 "}", 1559 format("for(;;){foo();}")); 1560 EXPECT_EQ("while (1) {\n" 1561 " foo();\n" 1562 "}", 1563 format("while(1){foo();}", Style)); 1564 EXPECT_EQ("switch (foo) {\n" 1565 "case bar:\n" 1566 " return;\n" 1567 "}", 1568 format("switch(foo){case bar:return;}", Style)); 1569 EXPECT_EQ("try {\n" 1570 " foo();\n" 1571 "} catch (...) {\n" 1572 " bar();\n" 1573 "}", 1574 format("try{foo();}catch(...){bar();}", Style)); 1575 EXPECT_EQ("do {\n" 1576 " foo();\n" 1577 "} while (bar &&\n" 1578 " baz);", 1579 format("do{foo();}while(bar&&baz);", Style)); 1580 // Long lines should put opening brace on new line. 1581 EXPECT_EQ("if (foo && bar &&\n" 1582 " baz)\n" 1583 "{\n" 1584 " quux();\n" 1585 "}", 1586 format("if(foo&&bar&&baz){quux();}", Style)); 1587 EXPECT_EQ("if (foo && bar &&\n" 1588 " baz)\n" 1589 "{\n" 1590 " quux();\n" 1591 "}", 1592 format("if (foo && bar &&\n" 1593 " baz) {\n" 1594 " quux();\n" 1595 "}", 1596 Style)); 1597 EXPECT_EQ("if (foo) {\n" 1598 " bar();\n" 1599 "} else if (baz ||\n" 1600 " quux)\n" 1601 "{\n" 1602 " foobar();\n" 1603 "}", 1604 format("if(foo){bar();}else if(baz||quux){foobar();}", Style)); 1605 EXPECT_EQ( 1606 "if (foo) {\n" 1607 " bar();\n" 1608 "} else if (baz ||\n" 1609 " quux)\n" 1610 "{\n" 1611 " foobar();\n" 1612 "} else {\n" 1613 " barbaz();\n" 1614 "}", 1615 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1616 Style)); 1617 EXPECT_EQ("for (int i = 0;\n" 1618 " i < 10; ++i)\n" 1619 "{\n" 1620 " foo();\n" 1621 "}", 1622 format("for(int i=0;i<10;++i){foo();}", Style)); 1623 EXPECT_EQ("while (foo || bar ||\n" 1624 " baz)\n" 1625 "{\n" 1626 " quux();\n" 1627 "}", 1628 format("while(foo||bar||baz){quux();}", Style)); 1629 EXPECT_EQ("switch (\n" 1630 " foo = barbaz)\n" 1631 "{\n" 1632 "case quux:\n" 1633 " return;\n" 1634 "}", 1635 format("switch(foo=barbaz){case quux:return;}", Style)); 1636 EXPECT_EQ("try {\n" 1637 " foo();\n" 1638 "} catch (\n" 1639 " Exception &bar)\n" 1640 "{\n" 1641 " baz();\n" 1642 "}", 1643 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1644 Style.ColumnLimit = 1645 40; // to concentrate at brace wrapping, not line wrap due to column limit 1646 EXPECT_EQ("try {\n" 1647 " foo();\n" 1648 "} catch (Exception &bar) {\n" 1649 " baz();\n" 1650 "}", 1651 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1652 Style.ColumnLimit = 1653 20; // to concentrate at brace wrapping, not line wrap due to column limit 1654 1655 Style.BraceWrapping.BeforeElse = true; 1656 EXPECT_EQ( 1657 "if (foo) {\n" 1658 " bar();\n" 1659 "}\n" 1660 "else if (baz ||\n" 1661 " quux)\n" 1662 "{\n" 1663 " foobar();\n" 1664 "}\n" 1665 "else {\n" 1666 " barbaz();\n" 1667 "}", 1668 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1669 Style)); 1670 1671 Style.BraceWrapping.BeforeCatch = true; 1672 EXPECT_EQ("try {\n" 1673 " foo();\n" 1674 "}\n" 1675 "catch (...) {\n" 1676 " baz();\n" 1677 "}", 1678 format("try{foo();}catch(...){baz();}", Style)); 1679 } 1680 1681 //===----------------------------------------------------------------------===// 1682 // Tests for classes, namespaces, etc. 1683 //===----------------------------------------------------------------------===// 1684 1685 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1686 verifyFormat("class A {};"); 1687 } 1688 1689 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1690 verifyFormat("class A {\n" 1691 "public:\n" 1692 "public: // comment\n" 1693 "protected:\n" 1694 "private:\n" 1695 " void f() {}\n" 1696 "};"); 1697 verifyFormat("export class A {\n" 1698 "public:\n" 1699 "public: // comment\n" 1700 "protected:\n" 1701 "private:\n" 1702 " void f() {}\n" 1703 "};"); 1704 verifyGoogleFormat("class A {\n" 1705 " public:\n" 1706 " protected:\n" 1707 " private:\n" 1708 " void f() {}\n" 1709 "};"); 1710 verifyGoogleFormat("export class A {\n" 1711 " public:\n" 1712 " protected:\n" 1713 " private:\n" 1714 " void f() {}\n" 1715 "};"); 1716 verifyFormat("class A {\n" 1717 "public slots:\n" 1718 " void f1() {}\n" 1719 "public Q_SLOTS:\n" 1720 " void f2() {}\n" 1721 "protected slots:\n" 1722 " void f3() {}\n" 1723 "protected Q_SLOTS:\n" 1724 " void f4() {}\n" 1725 "private slots:\n" 1726 " void f5() {}\n" 1727 "private Q_SLOTS:\n" 1728 " void f6() {}\n" 1729 "signals:\n" 1730 " void g1();\n" 1731 "Q_SIGNALS:\n" 1732 " void g2();\n" 1733 "};"); 1734 1735 // Don't interpret 'signals' the wrong way. 1736 verifyFormat("signals.set();"); 1737 verifyFormat("for (Signals signals : f()) {\n}"); 1738 verifyFormat("{\n" 1739 " signals.set(); // This needs indentation.\n" 1740 "}"); 1741 verifyFormat("void f() {\n" 1742 "label:\n" 1743 " signals.baz();\n" 1744 "}"); 1745 } 1746 1747 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1748 EXPECT_EQ("class A {\n" 1749 "public:\n" 1750 " void f();\n" 1751 "\n" 1752 "private:\n" 1753 " void g() {}\n" 1754 " // test\n" 1755 "protected:\n" 1756 " int h;\n" 1757 "};", 1758 format("class A {\n" 1759 "public:\n" 1760 "void f();\n" 1761 "private:\n" 1762 "void g() {}\n" 1763 "// test\n" 1764 "protected:\n" 1765 "int h;\n" 1766 "};")); 1767 EXPECT_EQ("class A {\n" 1768 "protected:\n" 1769 "public:\n" 1770 " void f();\n" 1771 "};", 1772 format("class A {\n" 1773 "protected:\n" 1774 "\n" 1775 "public:\n" 1776 "\n" 1777 " void f();\n" 1778 "};")); 1779 1780 // Even ensure proper spacing inside macros. 1781 EXPECT_EQ("#define B \\\n" 1782 " class A { \\\n" 1783 " protected: \\\n" 1784 " public: \\\n" 1785 " void f(); \\\n" 1786 " };", 1787 format("#define B \\\n" 1788 " class A { \\\n" 1789 " protected: \\\n" 1790 " \\\n" 1791 " public: \\\n" 1792 " \\\n" 1793 " void f(); \\\n" 1794 " };", 1795 getGoogleStyle())); 1796 // But don't remove empty lines after macros ending in access specifiers. 1797 EXPECT_EQ("#define A private:\n" 1798 "\n" 1799 "int i;", 1800 format("#define A private:\n" 1801 "\n" 1802 "int i;")); 1803 } 1804 1805 TEST_F(FormatTest, FormatsClasses) { 1806 verifyFormat("class A : public B {};"); 1807 verifyFormat("class A : public ::B {};"); 1808 1809 verifyFormat( 1810 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1811 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1812 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1813 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1814 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1815 verifyFormat( 1816 "class A : public B, public C, public D, public E, public F {};"); 1817 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1818 " public C,\n" 1819 " public D,\n" 1820 " public E,\n" 1821 " public F,\n" 1822 " public G {};"); 1823 1824 verifyFormat("class\n" 1825 " ReallyReallyLongClassName {\n" 1826 " int i;\n" 1827 "};", 1828 getLLVMStyleWithColumns(32)); 1829 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1830 " aaaaaaaaaaaaaaaa> {};"); 1831 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1832 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1833 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1834 verifyFormat("template <class R, class C>\n" 1835 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1836 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1837 verifyFormat("class ::A::B {};"); 1838 } 1839 1840 TEST_F(FormatTest, BreakInheritanceStyle) { 1841 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1842 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1843 FormatStyle::BILS_BeforeComma; 1844 verifyFormat("class MyClass : public X {};", 1845 StyleWithInheritanceBreakBeforeComma); 1846 verifyFormat("class MyClass\n" 1847 " : public X\n" 1848 " , public Y {};", 1849 StyleWithInheritanceBreakBeforeComma); 1850 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1851 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1852 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1853 StyleWithInheritanceBreakBeforeComma); 1854 verifyFormat("struct aaaaaaaaaaaaa\n" 1855 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1856 " aaaaaaaaaaaaaaaa> {};", 1857 StyleWithInheritanceBreakBeforeComma); 1858 1859 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1860 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1861 FormatStyle::BILS_AfterColon; 1862 verifyFormat("class MyClass : public X {};", 1863 StyleWithInheritanceBreakAfterColon); 1864 verifyFormat("class MyClass : public X, public Y {};", 1865 StyleWithInheritanceBreakAfterColon); 1866 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1867 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1868 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1869 StyleWithInheritanceBreakAfterColon); 1870 verifyFormat("struct aaaaaaaaaaaaa :\n" 1871 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1872 " aaaaaaaaaaaaaaaa> {};", 1873 StyleWithInheritanceBreakAfterColon); 1874 } 1875 1876 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1877 verifyFormat("class A {\n} a, b;"); 1878 verifyFormat("struct A {\n} a, b;"); 1879 verifyFormat("union A {\n} a;"); 1880 } 1881 1882 TEST_F(FormatTest, FormatsEnum) { 1883 verifyFormat("enum {\n" 1884 " Zero,\n" 1885 " One = 1,\n" 1886 " Two = One + 1,\n" 1887 " Three = (One + Two),\n" 1888 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1889 " Five = (One, Two, Three, Four, 5)\n" 1890 "};"); 1891 verifyGoogleFormat("enum {\n" 1892 " Zero,\n" 1893 " One = 1,\n" 1894 " Two = One + 1,\n" 1895 " Three = (One + Two),\n" 1896 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1897 " Five = (One, Two, Three, Four, 5)\n" 1898 "};"); 1899 verifyFormat("enum Enum {};"); 1900 verifyFormat("enum {};"); 1901 verifyFormat("enum X E {} d;"); 1902 verifyFormat("enum __attribute__((...)) E {} d;"); 1903 verifyFormat("enum __declspec__((...)) E {} d;"); 1904 verifyFormat("enum {\n" 1905 " Bar = Foo<int, int>::value\n" 1906 "};", 1907 getLLVMStyleWithColumns(30)); 1908 1909 verifyFormat("enum ShortEnum { A, B, C };"); 1910 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1911 1912 EXPECT_EQ("enum KeepEmptyLines {\n" 1913 " ONE,\n" 1914 "\n" 1915 " TWO,\n" 1916 "\n" 1917 " THREE\n" 1918 "}", 1919 format("enum KeepEmptyLines {\n" 1920 " ONE,\n" 1921 "\n" 1922 " TWO,\n" 1923 "\n" 1924 "\n" 1925 " THREE\n" 1926 "}")); 1927 verifyFormat("enum E { // comment\n" 1928 " ONE,\n" 1929 " TWO\n" 1930 "};\n" 1931 "int i;"); 1932 1933 FormatStyle EightIndent = getLLVMStyle(); 1934 EightIndent.IndentWidth = 8; 1935 verifyFormat("enum {\n" 1936 " VOID,\n" 1937 " CHAR,\n" 1938 " SHORT,\n" 1939 " INT,\n" 1940 " LONG,\n" 1941 " SIGNED,\n" 1942 " UNSIGNED,\n" 1943 " BOOL,\n" 1944 " FLOAT,\n" 1945 " DOUBLE,\n" 1946 " COMPLEX\n" 1947 "};", 1948 EightIndent); 1949 1950 // Not enums. 1951 verifyFormat("enum X f() {\n" 1952 " a();\n" 1953 " return 42;\n" 1954 "}"); 1955 verifyFormat("enum X Type::f() {\n" 1956 " a();\n" 1957 " return 42;\n" 1958 "}"); 1959 verifyFormat("enum ::X f() {\n" 1960 " a();\n" 1961 " return 42;\n" 1962 "}"); 1963 verifyFormat("enum ns::X f() {\n" 1964 " a();\n" 1965 " return 42;\n" 1966 "}"); 1967 } 1968 1969 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1970 verifyFormat("enum Type {\n" 1971 " One = 0; // These semicolons should be commas.\n" 1972 " Two = 1;\n" 1973 "};"); 1974 verifyFormat("namespace n {\n" 1975 "enum Type {\n" 1976 " One,\n" 1977 " Two, // missing };\n" 1978 " int i;\n" 1979 "}\n" 1980 "void g() {}"); 1981 } 1982 1983 TEST_F(FormatTest, FormatsEnumStruct) { 1984 verifyFormat("enum struct {\n" 1985 " Zero,\n" 1986 " One = 1,\n" 1987 " Two = One + 1,\n" 1988 " Three = (One + Two),\n" 1989 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1990 " Five = (One, Two, Three, Four, 5)\n" 1991 "};"); 1992 verifyFormat("enum struct Enum {};"); 1993 verifyFormat("enum struct {};"); 1994 verifyFormat("enum struct X E {} d;"); 1995 verifyFormat("enum struct __attribute__((...)) E {} d;"); 1996 verifyFormat("enum struct __declspec__((...)) E {} d;"); 1997 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1998 } 1999 2000 TEST_F(FormatTest, FormatsEnumClass) { 2001 verifyFormat("enum class {\n" 2002 " Zero,\n" 2003 " One = 1,\n" 2004 " Two = One + 1,\n" 2005 " Three = (One + Two),\n" 2006 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 2007 " Five = (One, Two, Three, Four, 5)\n" 2008 "};"); 2009 verifyFormat("enum class Enum {};"); 2010 verifyFormat("enum class {};"); 2011 verifyFormat("enum class X E {} d;"); 2012 verifyFormat("enum class __attribute__((...)) E {} d;"); 2013 verifyFormat("enum class __declspec__((...)) E {} d;"); 2014 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 2015 } 2016 2017 TEST_F(FormatTest, FormatsEnumTypes) { 2018 verifyFormat("enum X : int {\n" 2019 " A, // Force multiple lines.\n" 2020 " B\n" 2021 "};"); 2022 verifyFormat("enum X : int { A, B };"); 2023 verifyFormat("enum X : std::uint32_t { A, B };"); 2024 } 2025 2026 TEST_F(FormatTest, FormatsTypedefEnum) { 2027 FormatStyle Style = getLLVMStyle(); 2028 Style.ColumnLimit = 40; 2029 verifyFormat("typedef enum {} EmptyEnum;"); 2030 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 2031 verifyFormat("typedef enum {\n" 2032 " ZERO = 0,\n" 2033 " ONE = 1,\n" 2034 " TWO = 2,\n" 2035 " THREE = 3\n" 2036 "} LongEnum;", 2037 Style); 2038 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2039 Style.BraceWrapping.AfterEnum = true; 2040 verifyFormat("typedef enum {} EmptyEnum;"); 2041 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 2042 verifyFormat("typedef enum\n" 2043 "{\n" 2044 " ZERO = 0,\n" 2045 " ONE = 1,\n" 2046 " TWO = 2,\n" 2047 " THREE = 3\n" 2048 "} LongEnum;", 2049 Style); 2050 } 2051 2052 TEST_F(FormatTest, FormatsNSEnums) { 2053 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 2054 verifyGoogleFormat( 2055 "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }"); 2056 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 2057 " // Information about someDecentlyLongValue.\n" 2058 " someDecentlyLongValue,\n" 2059 " // Information about anotherDecentlyLongValue.\n" 2060 " anotherDecentlyLongValue,\n" 2061 " // Information about aThirdDecentlyLongValue.\n" 2062 " aThirdDecentlyLongValue\n" 2063 "};"); 2064 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n" 2065 " // Information about someDecentlyLongValue.\n" 2066 " someDecentlyLongValue,\n" 2067 " // Information about anotherDecentlyLongValue.\n" 2068 " anotherDecentlyLongValue,\n" 2069 " // Information about aThirdDecentlyLongValue.\n" 2070 " aThirdDecentlyLongValue\n" 2071 "};"); 2072 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 2073 " a = 1,\n" 2074 " b = 2,\n" 2075 " c = 3,\n" 2076 "};"); 2077 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 2078 " a = 1,\n" 2079 " b = 2,\n" 2080 " c = 3,\n" 2081 "};"); 2082 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n" 2083 " a = 1,\n" 2084 " b = 2,\n" 2085 " c = 3,\n" 2086 "};"); 2087 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 2088 " a = 1,\n" 2089 " b = 2,\n" 2090 " c = 3,\n" 2091 "};"); 2092 } 2093 2094 TEST_F(FormatTest, FormatsBitfields) { 2095 verifyFormat("struct Bitfields {\n" 2096 " unsigned sClass : 8;\n" 2097 " unsigned ValueKind : 2;\n" 2098 "};"); 2099 verifyFormat("struct A {\n" 2100 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 2101 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 2102 "};"); 2103 verifyFormat("struct MyStruct {\n" 2104 " uchar data;\n" 2105 " uchar : 8;\n" 2106 " uchar : 8;\n" 2107 " uchar other;\n" 2108 "};"); 2109 } 2110 2111 TEST_F(FormatTest, FormatsNamespaces) { 2112 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 2113 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 2114 2115 verifyFormat("namespace some_namespace {\n" 2116 "class A {};\n" 2117 "void f() { f(); }\n" 2118 "}", 2119 LLVMWithNoNamespaceFix); 2120 verifyFormat("namespace N::inline D {\n" 2121 "class A {};\n" 2122 "void f() { f(); }\n" 2123 "}", 2124 LLVMWithNoNamespaceFix); 2125 verifyFormat("namespace N::inline D::E {\n" 2126 "class A {};\n" 2127 "void f() { f(); }\n" 2128 "}", 2129 LLVMWithNoNamespaceFix); 2130 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n" 2131 "class A {};\n" 2132 "void f() { f(); }\n" 2133 "}", 2134 LLVMWithNoNamespaceFix); 2135 verifyFormat("/* something */ namespace some_namespace {\n" 2136 "class A {};\n" 2137 "void f() { f(); }\n" 2138 "}", 2139 LLVMWithNoNamespaceFix); 2140 verifyFormat("namespace {\n" 2141 "class A {};\n" 2142 "void f() { f(); }\n" 2143 "}", 2144 LLVMWithNoNamespaceFix); 2145 verifyFormat("/* something */ namespace {\n" 2146 "class A {};\n" 2147 "void f() { f(); }\n" 2148 "}", 2149 LLVMWithNoNamespaceFix); 2150 verifyFormat("inline namespace X {\n" 2151 "class A {};\n" 2152 "void f() { f(); }\n" 2153 "}", 2154 LLVMWithNoNamespaceFix); 2155 verifyFormat("/* something */ inline namespace X {\n" 2156 "class A {};\n" 2157 "void f() { f(); }\n" 2158 "}", 2159 LLVMWithNoNamespaceFix); 2160 verifyFormat("export namespace X {\n" 2161 "class A {};\n" 2162 "void f() { f(); }\n" 2163 "}", 2164 LLVMWithNoNamespaceFix); 2165 verifyFormat("using namespace some_namespace;\n" 2166 "class A {};\n" 2167 "void f() { f(); }", 2168 LLVMWithNoNamespaceFix); 2169 2170 // This code is more common than we thought; if we 2171 // layout this correctly the semicolon will go into 2172 // its own line, which is undesirable. 2173 verifyFormat("namespace {};", LLVMWithNoNamespaceFix); 2174 verifyFormat("namespace {\n" 2175 "class A {};\n" 2176 "};", 2177 LLVMWithNoNamespaceFix); 2178 2179 verifyFormat("namespace {\n" 2180 "int SomeVariable = 0; // comment\n" 2181 "} // namespace", 2182 LLVMWithNoNamespaceFix); 2183 EXPECT_EQ("#ifndef HEADER_GUARD\n" 2184 "#define HEADER_GUARD\n" 2185 "namespace my_namespace {\n" 2186 "int i;\n" 2187 "} // my_namespace\n" 2188 "#endif // HEADER_GUARD", 2189 format("#ifndef HEADER_GUARD\n" 2190 " #define HEADER_GUARD\n" 2191 " namespace my_namespace {\n" 2192 "int i;\n" 2193 "} // my_namespace\n" 2194 "#endif // HEADER_GUARD", 2195 LLVMWithNoNamespaceFix)); 2196 2197 EXPECT_EQ("namespace A::B {\n" 2198 "class C {};\n" 2199 "}", 2200 format("namespace A::B {\n" 2201 "class C {};\n" 2202 "}", 2203 LLVMWithNoNamespaceFix)); 2204 2205 FormatStyle Style = getLLVMStyle(); 2206 Style.NamespaceIndentation = FormatStyle::NI_All; 2207 EXPECT_EQ("namespace out {\n" 2208 " int i;\n" 2209 " namespace in {\n" 2210 " int i;\n" 2211 " } // namespace in\n" 2212 "} // namespace out", 2213 format("namespace out {\n" 2214 "int i;\n" 2215 "namespace in {\n" 2216 "int i;\n" 2217 "} // namespace in\n" 2218 "} // namespace out", 2219 Style)); 2220 2221 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2222 EXPECT_EQ("namespace out {\n" 2223 "int i;\n" 2224 "namespace in {\n" 2225 " int i;\n" 2226 "} // namespace in\n" 2227 "} // namespace out", 2228 format("namespace out {\n" 2229 "int i;\n" 2230 "namespace in {\n" 2231 "int i;\n" 2232 "} // namespace in\n" 2233 "} // namespace out", 2234 Style)); 2235 } 2236 2237 TEST_F(FormatTest, NamespaceMacros) { 2238 FormatStyle Style = getLLVMStyle(); 2239 Style.NamespaceMacros.push_back("TESTSUITE"); 2240 2241 verifyFormat("TESTSUITE(A) {\n" 2242 "int foo();\n" 2243 "} // TESTSUITE(A)", 2244 Style); 2245 2246 verifyFormat("TESTSUITE(A, B) {\n" 2247 "int foo();\n" 2248 "} // TESTSUITE(A)", 2249 Style); 2250 2251 // Properly indent according to NamespaceIndentation style 2252 Style.NamespaceIndentation = FormatStyle::NI_All; 2253 verifyFormat("TESTSUITE(A) {\n" 2254 " int foo();\n" 2255 "} // TESTSUITE(A)", 2256 Style); 2257 verifyFormat("TESTSUITE(A) {\n" 2258 " namespace B {\n" 2259 " int foo();\n" 2260 " } // namespace B\n" 2261 "} // TESTSUITE(A)", 2262 Style); 2263 verifyFormat("namespace A {\n" 2264 " TESTSUITE(B) {\n" 2265 " int foo();\n" 2266 " } // TESTSUITE(B)\n" 2267 "} // namespace A", 2268 Style); 2269 2270 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2271 verifyFormat("TESTSUITE(A) {\n" 2272 "TESTSUITE(B) {\n" 2273 " int foo();\n" 2274 "} // TESTSUITE(B)\n" 2275 "} // TESTSUITE(A)", 2276 Style); 2277 verifyFormat("TESTSUITE(A) {\n" 2278 "namespace B {\n" 2279 " int foo();\n" 2280 "} // namespace B\n" 2281 "} // TESTSUITE(A)", 2282 Style); 2283 verifyFormat("namespace A {\n" 2284 "TESTSUITE(B) {\n" 2285 " int foo();\n" 2286 "} // TESTSUITE(B)\n" 2287 "} // namespace A", 2288 Style); 2289 2290 // Properly merge namespace-macros blocks in CompactNamespaces mode 2291 Style.NamespaceIndentation = FormatStyle::NI_None; 2292 Style.CompactNamespaces = true; 2293 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n" 2294 "}} // TESTSUITE(A::B)", 2295 Style); 2296 2297 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2298 "}} // TESTSUITE(out::in)", 2299 format("TESTSUITE(out) {\n" 2300 "TESTSUITE(in) {\n" 2301 "} // TESTSUITE(in)\n" 2302 "} // TESTSUITE(out)", 2303 Style)); 2304 2305 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2306 "}} // TESTSUITE(out::in)", 2307 format("TESTSUITE(out) {\n" 2308 "TESTSUITE(in) {\n" 2309 "} // TESTSUITE(in)\n" 2310 "} // TESTSUITE(out)", 2311 Style)); 2312 2313 // Do not merge different namespaces/macros 2314 EXPECT_EQ("namespace out {\n" 2315 "TESTSUITE(in) {\n" 2316 "} // TESTSUITE(in)\n" 2317 "} // namespace out", 2318 format("namespace out {\n" 2319 "TESTSUITE(in) {\n" 2320 "} // TESTSUITE(in)\n" 2321 "} // namespace out", 2322 Style)); 2323 EXPECT_EQ("TESTSUITE(out) {\n" 2324 "namespace in {\n" 2325 "} // namespace in\n" 2326 "} // TESTSUITE(out)", 2327 format("TESTSUITE(out) {\n" 2328 "namespace in {\n" 2329 "} // namespace in\n" 2330 "} // TESTSUITE(out)", 2331 Style)); 2332 Style.NamespaceMacros.push_back("FOOBAR"); 2333 EXPECT_EQ("TESTSUITE(out) {\n" 2334 "FOOBAR(in) {\n" 2335 "} // FOOBAR(in)\n" 2336 "} // TESTSUITE(out)", 2337 format("TESTSUITE(out) {\n" 2338 "FOOBAR(in) {\n" 2339 "} // FOOBAR(in)\n" 2340 "} // TESTSUITE(out)", 2341 Style)); 2342 } 2343 2344 TEST_F(FormatTest, FormatsCompactNamespaces) { 2345 FormatStyle Style = getLLVMStyle(); 2346 Style.CompactNamespaces = true; 2347 Style.NamespaceMacros.push_back("TESTSUITE"); 2348 2349 verifyFormat("namespace A { namespace B {\n" 2350 "}} // namespace A::B", 2351 Style); 2352 2353 EXPECT_EQ("namespace out { namespace in {\n" 2354 "}} // namespace out::in", 2355 format("namespace out {\n" 2356 "namespace in {\n" 2357 "} // namespace in\n" 2358 "} // namespace out", 2359 Style)); 2360 2361 // Only namespaces which have both consecutive opening and end get compacted 2362 EXPECT_EQ("namespace out {\n" 2363 "namespace in1 {\n" 2364 "} // namespace in1\n" 2365 "namespace in2 {\n" 2366 "} // namespace in2\n" 2367 "} // namespace out", 2368 format("namespace out {\n" 2369 "namespace in1 {\n" 2370 "} // namespace in1\n" 2371 "namespace in2 {\n" 2372 "} // namespace in2\n" 2373 "} // namespace out", 2374 Style)); 2375 2376 EXPECT_EQ("namespace out {\n" 2377 "int i;\n" 2378 "namespace in {\n" 2379 "int j;\n" 2380 "} // namespace in\n" 2381 "int k;\n" 2382 "} // namespace out", 2383 format("namespace out { int i;\n" 2384 "namespace in { int j; } // namespace in\n" 2385 "int k; } // namespace out", 2386 Style)); 2387 2388 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 2389 "}}} // namespace A::B::C\n", 2390 format("namespace A { namespace B {\n" 2391 "namespace C {\n" 2392 "}} // namespace B::C\n" 2393 "} // namespace A\n", 2394 Style)); 2395 2396 Style.ColumnLimit = 40; 2397 EXPECT_EQ("namespace aaaaaaaaaa {\n" 2398 "namespace bbbbbbbbbb {\n" 2399 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 2400 format("namespace aaaaaaaaaa {\n" 2401 "namespace bbbbbbbbbb {\n" 2402 "} // namespace bbbbbbbbbb\n" 2403 "} // namespace aaaaaaaaaa", 2404 Style)); 2405 2406 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 2407 "namespace cccccc {\n" 2408 "}}} // namespace aaaaaa::bbbbbb::cccccc", 2409 format("namespace aaaaaa {\n" 2410 "namespace bbbbbb {\n" 2411 "namespace cccccc {\n" 2412 "} // namespace cccccc\n" 2413 "} // namespace bbbbbb\n" 2414 "} // namespace aaaaaa", 2415 Style)); 2416 Style.ColumnLimit = 80; 2417 2418 // Extra semicolon after 'inner' closing brace prevents merging 2419 EXPECT_EQ("namespace out { namespace in {\n" 2420 "}; } // namespace out::in", 2421 format("namespace out {\n" 2422 "namespace in {\n" 2423 "}; // namespace in\n" 2424 "} // namespace out", 2425 Style)); 2426 2427 // Extra semicolon after 'outer' closing brace is conserved 2428 EXPECT_EQ("namespace out { namespace in {\n" 2429 "}}; // namespace out::in", 2430 format("namespace out {\n" 2431 "namespace in {\n" 2432 "} // namespace in\n" 2433 "}; // namespace out", 2434 Style)); 2435 2436 Style.NamespaceIndentation = FormatStyle::NI_All; 2437 EXPECT_EQ("namespace out { namespace in {\n" 2438 " int i;\n" 2439 "}} // namespace out::in", 2440 format("namespace out {\n" 2441 "namespace in {\n" 2442 "int i;\n" 2443 "} // namespace in\n" 2444 "} // namespace out", 2445 Style)); 2446 EXPECT_EQ("namespace out { namespace mid {\n" 2447 " namespace in {\n" 2448 " int j;\n" 2449 " } // namespace in\n" 2450 " int k;\n" 2451 "}} // namespace out::mid", 2452 format("namespace out { namespace mid {\n" 2453 "namespace in { int j; } // namespace in\n" 2454 "int k; }} // namespace out::mid", 2455 Style)); 2456 2457 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2458 EXPECT_EQ("namespace out { namespace in {\n" 2459 " int i;\n" 2460 "}} // namespace out::in", 2461 format("namespace out {\n" 2462 "namespace in {\n" 2463 "int i;\n" 2464 "} // namespace in\n" 2465 "} // namespace out", 2466 Style)); 2467 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 2468 " int i;\n" 2469 "}}} // namespace out::mid::in", 2470 format("namespace out {\n" 2471 "namespace mid {\n" 2472 "namespace in {\n" 2473 "int i;\n" 2474 "} // namespace in\n" 2475 "} // namespace mid\n" 2476 "} // namespace out", 2477 Style)); 2478 } 2479 2480 TEST_F(FormatTest, FormatsExternC) { 2481 verifyFormat("extern \"C\" {\nint a;"); 2482 verifyFormat("extern \"C\" {}"); 2483 verifyFormat("extern \"C\" {\n" 2484 "int foo();\n" 2485 "}"); 2486 verifyFormat("extern \"C\" int foo() {}"); 2487 verifyFormat("extern \"C\" int foo();"); 2488 verifyFormat("extern \"C\" int foo() {\n" 2489 " int i = 42;\n" 2490 " return i;\n" 2491 "}"); 2492 2493 FormatStyle Style = getLLVMStyle(); 2494 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2495 Style.BraceWrapping.AfterFunction = true; 2496 verifyFormat("extern \"C\" int foo() {}", Style); 2497 verifyFormat("extern \"C\" int foo();", Style); 2498 verifyFormat("extern \"C\" int foo()\n" 2499 "{\n" 2500 " int i = 42;\n" 2501 " return i;\n" 2502 "}", 2503 Style); 2504 2505 Style.BraceWrapping.AfterExternBlock = true; 2506 Style.BraceWrapping.SplitEmptyRecord = false; 2507 verifyFormat("extern \"C\"\n" 2508 "{}", 2509 Style); 2510 verifyFormat("extern \"C\"\n" 2511 "{\n" 2512 " int foo();\n" 2513 "}", 2514 Style); 2515 } 2516 2517 TEST_F(FormatTest, FormatsInlineASM) { 2518 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2519 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2520 verifyFormat( 2521 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2522 " \"cpuid\\n\\t\"\n" 2523 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2524 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2525 " : \"a\"(value));"); 2526 EXPECT_EQ( 2527 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2528 " __asm {\n" 2529 " mov edx,[that] // vtable in edx\n" 2530 " mov eax,methodIndex\n" 2531 " call [edx][eax*4] // stdcall\n" 2532 " }\n" 2533 "}", 2534 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2535 " __asm {\n" 2536 " mov edx,[that] // vtable in edx\n" 2537 " mov eax,methodIndex\n" 2538 " call [edx][eax*4] // stdcall\n" 2539 " }\n" 2540 "}")); 2541 EXPECT_EQ("_asm {\n" 2542 " xor eax, eax;\n" 2543 " cpuid;\n" 2544 "}", 2545 format("_asm {\n" 2546 " xor eax, eax;\n" 2547 " cpuid;\n" 2548 "}")); 2549 verifyFormat("void function() {\n" 2550 " // comment\n" 2551 " asm(\"\");\n" 2552 "}"); 2553 EXPECT_EQ("__asm {\n" 2554 "}\n" 2555 "int i;", 2556 format("__asm {\n" 2557 "}\n" 2558 "int i;")); 2559 } 2560 2561 TEST_F(FormatTest, FormatTryCatch) { 2562 verifyFormat("try {\n" 2563 " throw a * b;\n" 2564 "} catch (int a) {\n" 2565 " // Do nothing.\n" 2566 "} catch (...) {\n" 2567 " exit(42);\n" 2568 "}"); 2569 2570 // Function-level try statements. 2571 verifyFormat("int f() try { return 4; } catch (...) {\n" 2572 " return 5;\n" 2573 "}"); 2574 verifyFormat("class A {\n" 2575 " int a;\n" 2576 " A() try : a(0) {\n" 2577 " } catch (...) {\n" 2578 " throw;\n" 2579 " }\n" 2580 "};\n"); 2581 2582 // Incomplete try-catch blocks. 2583 verifyIncompleteFormat("try {} catch ("); 2584 } 2585 2586 TEST_F(FormatTest, FormatSEHTryCatch) { 2587 verifyFormat("__try {\n" 2588 " int a = b * c;\n" 2589 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2590 " // Do nothing.\n" 2591 "}"); 2592 2593 verifyFormat("__try {\n" 2594 " int a = b * c;\n" 2595 "} __finally {\n" 2596 " // Do nothing.\n" 2597 "}"); 2598 2599 verifyFormat("DEBUG({\n" 2600 " __try {\n" 2601 " } __finally {\n" 2602 " }\n" 2603 "});\n"); 2604 } 2605 2606 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2607 verifyFormat("try {\n" 2608 " f();\n" 2609 "} catch {\n" 2610 " g();\n" 2611 "}"); 2612 verifyFormat("try {\n" 2613 " f();\n" 2614 "} catch (A a) MACRO(x) {\n" 2615 " g();\n" 2616 "} catch (B b) MACRO(x) {\n" 2617 " g();\n" 2618 "}"); 2619 } 2620 2621 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2622 FormatStyle Style = getLLVMStyle(); 2623 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2624 FormatStyle::BS_WebKit}) { 2625 Style.BreakBeforeBraces = BraceStyle; 2626 verifyFormat("try {\n" 2627 " // something\n" 2628 "} catch (...) {\n" 2629 " // something\n" 2630 "}", 2631 Style); 2632 } 2633 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2634 verifyFormat("try {\n" 2635 " // something\n" 2636 "}\n" 2637 "catch (...) {\n" 2638 " // something\n" 2639 "}", 2640 Style); 2641 verifyFormat("__try {\n" 2642 " // something\n" 2643 "}\n" 2644 "__finally {\n" 2645 " // something\n" 2646 "}", 2647 Style); 2648 verifyFormat("@try {\n" 2649 " // something\n" 2650 "}\n" 2651 "@finally {\n" 2652 " // something\n" 2653 "}", 2654 Style); 2655 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2656 verifyFormat("try\n" 2657 "{\n" 2658 " // something\n" 2659 "}\n" 2660 "catch (...)\n" 2661 "{\n" 2662 " // something\n" 2663 "}", 2664 Style); 2665 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 2666 verifyFormat("try\n" 2667 " {\n" 2668 " // something white\n" 2669 " }\n" 2670 "catch (...)\n" 2671 " {\n" 2672 " // something white\n" 2673 " }", 2674 Style); 2675 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2676 verifyFormat("try\n" 2677 " {\n" 2678 " // something\n" 2679 " }\n" 2680 "catch (...)\n" 2681 " {\n" 2682 " // something\n" 2683 " }", 2684 Style); 2685 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2686 Style.BraceWrapping.BeforeCatch = true; 2687 verifyFormat("try {\n" 2688 " // something\n" 2689 "}\n" 2690 "catch (...) {\n" 2691 " // something\n" 2692 "}", 2693 Style); 2694 } 2695 2696 TEST_F(FormatTest, StaticInitializers) { 2697 verifyFormat("static SomeClass SC = {1, 'a'};"); 2698 2699 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2700 " 100000000, " 2701 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2702 2703 // Here, everything other than the "}" would fit on a line. 2704 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2705 " 10000000000000000000000000};"); 2706 EXPECT_EQ("S s = {a,\n" 2707 "\n" 2708 " b};", 2709 format("S s = {\n" 2710 " a,\n" 2711 "\n" 2712 " b\n" 2713 "};")); 2714 2715 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2716 // line. However, the formatting looks a bit off and this probably doesn't 2717 // happen often in practice. 2718 verifyFormat("static int Variable[1] = {\n" 2719 " {1000000000000000000000000000000000000}};", 2720 getLLVMStyleWithColumns(40)); 2721 } 2722 2723 TEST_F(FormatTest, DesignatedInitializers) { 2724 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2725 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2726 " .bbbbbbbbbb = 2,\n" 2727 " .cccccccccc = 3,\n" 2728 " .dddddddddd = 4,\n" 2729 " .eeeeeeeeee = 5};"); 2730 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2731 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2732 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2733 " .ccccccccccccccccccccccccccc = 3,\n" 2734 " .ddddddddddddddddddddddddddd = 4,\n" 2735 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2736 2737 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2738 2739 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2740 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2741 " [2] = bbbbbbbbbb,\n" 2742 " [3] = cccccccccc,\n" 2743 " [4] = dddddddddd,\n" 2744 " [5] = eeeeeeeeee};"); 2745 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2746 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2747 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2748 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2749 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2750 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2751 } 2752 2753 TEST_F(FormatTest, NestedStaticInitializers) { 2754 verifyFormat("static A x = {{{}}};\n"); 2755 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2756 " {init1, init2, init3, init4}}};", 2757 getLLVMStyleWithColumns(50)); 2758 2759 verifyFormat("somes Status::global_reps[3] = {\n" 2760 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2761 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2762 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2763 getLLVMStyleWithColumns(60)); 2764 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2765 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2766 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2767 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2768 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2769 " {rect.fRight - rect.fLeft, rect.fBottom - " 2770 "rect.fTop}};"); 2771 2772 verifyFormat( 2773 "SomeArrayOfSomeType a = {\n" 2774 " {{1, 2, 3},\n" 2775 " {1, 2, 3},\n" 2776 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2777 " 333333333333333333333333333333},\n" 2778 " {1, 2, 3},\n" 2779 " {1, 2, 3}}};"); 2780 verifyFormat( 2781 "SomeArrayOfSomeType a = {\n" 2782 " {{1, 2, 3}},\n" 2783 " {{1, 2, 3}},\n" 2784 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2785 " 333333333333333333333333333333}},\n" 2786 " {{1, 2, 3}},\n" 2787 " {{1, 2, 3}}};"); 2788 2789 verifyFormat("struct {\n" 2790 " unsigned bit;\n" 2791 " const char *const name;\n" 2792 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2793 " {kOsWin, \"Windows\"},\n" 2794 " {kOsLinux, \"Linux\"},\n" 2795 " {kOsCrOS, \"Chrome OS\"}};"); 2796 verifyFormat("struct {\n" 2797 " unsigned bit;\n" 2798 " const char *const name;\n" 2799 "} kBitsToOs[] = {\n" 2800 " {kOsMac, \"Mac\"},\n" 2801 " {kOsWin, \"Windows\"},\n" 2802 " {kOsLinux, \"Linux\"},\n" 2803 " {kOsCrOS, \"Chrome OS\"},\n" 2804 "};"); 2805 } 2806 2807 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2808 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2809 " \\\n" 2810 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2811 } 2812 2813 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2814 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2815 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2816 2817 // Do break defaulted and deleted functions. 2818 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2819 " default;", 2820 getLLVMStyleWithColumns(40)); 2821 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2822 " delete;", 2823 getLLVMStyleWithColumns(40)); 2824 } 2825 2826 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2827 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2828 getLLVMStyleWithColumns(40)); 2829 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2830 getLLVMStyleWithColumns(40)); 2831 EXPECT_EQ("#define Q \\\n" 2832 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2833 " \"aaaaaaaa.cpp\"", 2834 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2835 getLLVMStyleWithColumns(40))); 2836 } 2837 2838 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2839 EXPECT_EQ("# 123 \"A string literal\"", 2840 format(" # 123 \"A string literal\"")); 2841 } 2842 2843 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2844 EXPECT_EQ("#;", format("#;")); 2845 verifyFormat("#\n;\n;\n;"); 2846 } 2847 2848 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2849 EXPECT_EQ("#line 42 \"test\"\n", 2850 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2851 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2852 getLLVMStyleWithColumns(12))); 2853 } 2854 2855 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2856 EXPECT_EQ("#line 42 \"test\"", 2857 format("# \\\n line \\\n 42 \\\n \"test\"")); 2858 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2859 } 2860 2861 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2862 verifyFormat("#define A \\x20"); 2863 verifyFormat("#define A \\ x20"); 2864 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2865 verifyFormat("#define A ''"); 2866 verifyFormat("#define A ''qqq"); 2867 verifyFormat("#define A `qqq"); 2868 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2869 EXPECT_EQ("const char *c = STRINGIFY(\n" 2870 "\\na : b);", 2871 format("const char * c = STRINGIFY(\n" 2872 "\\na : b);")); 2873 2874 verifyFormat("a\r\\"); 2875 verifyFormat("a\v\\"); 2876 verifyFormat("a\f\\"); 2877 } 2878 2879 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2880 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2881 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2882 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2883 // FIXME: We never break before the macro name. 2884 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2885 2886 verifyFormat("#define A A\n#define A A"); 2887 verifyFormat("#define A(X) A\n#define A A"); 2888 2889 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2890 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2891 } 2892 2893 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2894 EXPECT_EQ("// somecomment\n" 2895 "#include \"a.h\"\n" 2896 "#define A( \\\n" 2897 " A, B)\n" 2898 "#include \"b.h\"\n" 2899 "// somecomment\n", 2900 format(" // somecomment\n" 2901 " #include \"a.h\"\n" 2902 "#define A(A,\\\n" 2903 " B)\n" 2904 " #include \"b.h\"\n" 2905 " // somecomment\n", 2906 getLLVMStyleWithColumns(13))); 2907 } 2908 2909 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2910 2911 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2912 EXPECT_EQ("#define A \\\n" 2913 " c; \\\n" 2914 " e;\n" 2915 "f;", 2916 format("#define A c; e;\n" 2917 "f;", 2918 getLLVMStyleWithColumns(14))); 2919 } 2920 2921 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2922 2923 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2924 EXPECT_EQ("int x,\n" 2925 "#define A\n" 2926 " y;", 2927 format("int x,\n#define A\ny;")); 2928 } 2929 2930 TEST_F(FormatTest, HashInMacroDefinition) { 2931 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2932 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2933 verifyFormat("#define A \\\n" 2934 " { \\\n" 2935 " f(#c); \\\n" 2936 " }", 2937 getLLVMStyleWithColumns(11)); 2938 2939 verifyFormat("#define A(X) \\\n" 2940 " void function##X()", 2941 getLLVMStyleWithColumns(22)); 2942 2943 verifyFormat("#define A(a, b, c) \\\n" 2944 " void a##b##c()", 2945 getLLVMStyleWithColumns(22)); 2946 2947 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2948 } 2949 2950 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2951 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2952 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2953 2954 FormatStyle Style = getLLVMStyle(); 2955 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 2956 verifyFormat("#define true ((foo)1)", Style); 2957 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 2958 verifyFormat("#define false((foo)0)", Style); 2959 } 2960 2961 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2962 EXPECT_EQ("#define A b;", format("#define A \\\n" 2963 " \\\n" 2964 " b;", 2965 getLLVMStyleWithColumns(25))); 2966 EXPECT_EQ("#define A \\\n" 2967 " \\\n" 2968 " a; \\\n" 2969 " b;", 2970 format("#define A \\\n" 2971 " \\\n" 2972 " a; \\\n" 2973 " b;", 2974 getLLVMStyleWithColumns(11))); 2975 EXPECT_EQ("#define A \\\n" 2976 " a; \\\n" 2977 " \\\n" 2978 " b;", 2979 format("#define A \\\n" 2980 " a; \\\n" 2981 " \\\n" 2982 " b;", 2983 getLLVMStyleWithColumns(11))); 2984 } 2985 2986 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 2987 verifyIncompleteFormat("#define A :"); 2988 verifyFormat("#define SOMECASES \\\n" 2989 " case 1: \\\n" 2990 " case 2\n", 2991 getLLVMStyleWithColumns(20)); 2992 verifyFormat("#define MACRO(a) \\\n" 2993 " if (a) \\\n" 2994 " f(); \\\n" 2995 " else \\\n" 2996 " g()", 2997 getLLVMStyleWithColumns(18)); 2998 verifyFormat("#define A template <typename T>"); 2999 verifyIncompleteFormat("#define STR(x) #x\n" 3000 "f(STR(this_is_a_string_literal{));"); 3001 verifyFormat("#pragma omp threadprivate( \\\n" 3002 " y)), // expected-warning", 3003 getLLVMStyleWithColumns(28)); 3004 verifyFormat("#d, = };"); 3005 verifyFormat("#if \"a"); 3006 verifyIncompleteFormat("({\n" 3007 "#define b \\\n" 3008 " } \\\n" 3009 " a\n" 3010 "a", 3011 getLLVMStyleWithColumns(15)); 3012 verifyFormat("#define A \\\n" 3013 " { \\\n" 3014 " {\n" 3015 "#define B \\\n" 3016 " } \\\n" 3017 " }", 3018 getLLVMStyleWithColumns(15)); 3019 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 3020 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 3021 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 3022 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 3023 } 3024 3025 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 3026 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 3027 EXPECT_EQ("class A : public QObject {\n" 3028 " Q_OBJECT\n" 3029 "\n" 3030 " A() {}\n" 3031 "};", 3032 format("class A : public QObject {\n" 3033 " Q_OBJECT\n" 3034 "\n" 3035 " A() {\n}\n" 3036 "} ;")); 3037 EXPECT_EQ("MACRO\n" 3038 "/*static*/ int i;", 3039 format("MACRO\n" 3040 " /*static*/ int i;")); 3041 EXPECT_EQ("SOME_MACRO\n" 3042 "namespace {\n" 3043 "void f();\n" 3044 "} // namespace", 3045 format("SOME_MACRO\n" 3046 " namespace {\n" 3047 "void f( );\n" 3048 "} // namespace")); 3049 // Only if the identifier contains at least 5 characters. 3050 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 3051 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 3052 // Only if everything is upper case. 3053 EXPECT_EQ("class A : public QObject {\n" 3054 " Q_Object A() {}\n" 3055 "};", 3056 format("class A : public QObject {\n" 3057 " Q_Object\n" 3058 " A() {\n}\n" 3059 "} ;")); 3060 3061 // Only if the next line can actually start an unwrapped line. 3062 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 3063 format("SOME_WEIRD_LOG_MACRO\n" 3064 "<< SomeThing;")); 3065 3066 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 3067 "(n, buffers))\n", 3068 getChromiumStyle(FormatStyle::LK_Cpp)); 3069 3070 // See PR41483 3071 EXPECT_EQ("/**/ FOO(a)\n" 3072 "FOO(b)", 3073 format("/**/ FOO(a)\n" 3074 "FOO(b)")); 3075 } 3076 3077 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 3078 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 3079 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 3080 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 3081 "class X {};\n" 3082 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 3083 "int *createScopDetectionPass() { return 0; }", 3084 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 3085 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 3086 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 3087 " class X {};\n" 3088 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 3089 " int *createScopDetectionPass() { return 0; }")); 3090 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 3091 // braces, so that inner block is indented one level more. 3092 EXPECT_EQ("int q() {\n" 3093 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 3094 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 3095 " IPC_END_MESSAGE_MAP()\n" 3096 "}", 3097 format("int q() {\n" 3098 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 3099 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 3100 " IPC_END_MESSAGE_MAP()\n" 3101 "}")); 3102 3103 // Same inside macros. 3104 EXPECT_EQ("#define LIST(L) \\\n" 3105 " L(A) \\\n" 3106 " L(B) \\\n" 3107 " L(C)", 3108 format("#define LIST(L) \\\n" 3109 " L(A) \\\n" 3110 " L(B) \\\n" 3111 " L(C)", 3112 getGoogleStyle())); 3113 3114 // These must not be recognized as macros. 3115 EXPECT_EQ("int q() {\n" 3116 " f(x);\n" 3117 " f(x) {}\n" 3118 " f(x)->g();\n" 3119 " f(x)->*g();\n" 3120 " f(x).g();\n" 3121 " f(x) = x;\n" 3122 " f(x) += x;\n" 3123 " f(x) -= x;\n" 3124 " f(x) *= x;\n" 3125 " f(x) /= x;\n" 3126 " f(x) %= x;\n" 3127 " f(x) &= x;\n" 3128 " f(x) |= x;\n" 3129 " f(x) ^= x;\n" 3130 " f(x) >>= x;\n" 3131 " f(x) <<= x;\n" 3132 " f(x)[y].z();\n" 3133 " LOG(INFO) << x;\n" 3134 " ifstream(x) >> x;\n" 3135 "}\n", 3136 format("int q() {\n" 3137 " f(x)\n;\n" 3138 " f(x)\n {}\n" 3139 " f(x)\n->g();\n" 3140 " f(x)\n->*g();\n" 3141 " f(x)\n.g();\n" 3142 " f(x)\n = x;\n" 3143 " f(x)\n += x;\n" 3144 " f(x)\n -= x;\n" 3145 " f(x)\n *= x;\n" 3146 " f(x)\n /= x;\n" 3147 " f(x)\n %= x;\n" 3148 " f(x)\n &= x;\n" 3149 " f(x)\n |= x;\n" 3150 " f(x)\n ^= x;\n" 3151 " f(x)\n >>= x;\n" 3152 " f(x)\n <<= x;\n" 3153 " f(x)\n[y].z();\n" 3154 " LOG(INFO)\n << x;\n" 3155 " ifstream(x)\n >> x;\n" 3156 "}\n")); 3157 EXPECT_EQ("int q() {\n" 3158 " F(x)\n" 3159 " if (1) {\n" 3160 " }\n" 3161 " F(x)\n" 3162 " while (1) {\n" 3163 " }\n" 3164 " F(x)\n" 3165 " G(x);\n" 3166 " F(x)\n" 3167 " try {\n" 3168 " Q();\n" 3169 " } catch (...) {\n" 3170 " }\n" 3171 "}\n", 3172 format("int q() {\n" 3173 "F(x)\n" 3174 "if (1) {}\n" 3175 "F(x)\n" 3176 "while (1) {}\n" 3177 "F(x)\n" 3178 "G(x);\n" 3179 "F(x)\n" 3180 "try { Q(); } catch (...) {}\n" 3181 "}\n")); 3182 EXPECT_EQ("class A {\n" 3183 " A() : t(0) {}\n" 3184 " A(int i) noexcept() : {}\n" 3185 " A(X x)\n" // FIXME: function-level try blocks are broken. 3186 " try : t(0) {\n" 3187 " } catch (...) {\n" 3188 " }\n" 3189 "};", 3190 format("class A {\n" 3191 " A()\n : t(0) {}\n" 3192 " A(int i)\n noexcept() : {}\n" 3193 " A(X x)\n" 3194 " try : t(0) {} catch (...) {}\n" 3195 "};")); 3196 FormatStyle Style = getLLVMStyle(); 3197 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 3198 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 3199 Style.BraceWrapping.AfterFunction = true; 3200 EXPECT_EQ("void f()\n" 3201 "try\n" 3202 "{\n" 3203 "}", 3204 format("void f() try {\n" 3205 "}", 3206 Style)); 3207 EXPECT_EQ("class SomeClass {\n" 3208 "public:\n" 3209 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3210 "};", 3211 format("class SomeClass {\n" 3212 "public:\n" 3213 " SomeClass()\n" 3214 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3215 "};")); 3216 EXPECT_EQ("class SomeClass {\n" 3217 "public:\n" 3218 " SomeClass()\n" 3219 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3220 "};", 3221 format("class SomeClass {\n" 3222 "public:\n" 3223 " SomeClass()\n" 3224 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3225 "};", 3226 getLLVMStyleWithColumns(40))); 3227 3228 verifyFormat("MACRO(>)"); 3229 3230 // Some macros contain an implicit semicolon. 3231 Style = getLLVMStyle(); 3232 Style.StatementMacros.push_back("FOO"); 3233 verifyFormat("FOO(a) int b = 0;"); 3234 verifyFormat("FOO(a)\n" 3235 "int b = 0;", 3236 Style); 3237 verifyFormat("FOO(a);\n" 3238 "int b = 0;", 3239 Style); 3240 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 3241 "int b = 0;", 3242 Style); 3243 verifyFormat("FOO()\n" 3244 "int b = 0;", 3245 Style); 3246 verifyFormat("FOO\n" 3247 "int b = 0;", 3248 Style); 3249 verifyFormat("void f() {\n" 3250 " FOO(a)\n" 3251 " return a;\n" 3252 "}", 3253 Style); 3254 verifyFormat("FOO(a)\n" 3255 "FOO(b)", 3256 Style); 3257 verifyFormat("int a = 0;\n" 3258 "FOO(b)\n" 3259 "int c = 0;", 3260 Style); 3261 verifyFormat("int a = 0;\n" 3262 "int x = FOO(a)\n" 3263 "int b = 0;", 3264 Style); 3265 verifyFormat("void foo(int a) { FOO(a) }\n" 3266 "uint32_t bar() {}", 3267 Style); 3268 } 3269 3270 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 3271 verifyFormat("#define A \\\n" 3272 " f({ \\\n" 3273 " g(); \\\n" 3274 " });", 3275 getLLVMStyleWithColumns(11)); 3276 } 3277 3278 TEST_F(FormatTest, IndentPreprocessorDirectives) { 3279 FormatStyle Style = getLLVMStyle(); 3280 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 3281 Style.ColumnLimit = 40; 3282 verifyFormat("#ifdef _WIN32\n" 3283 "#define A 0\n" 3284 "#ifdef VAR2\n" 3285 "#define B 1\n" 3286 "#include <someheader.h>\n" 3287 "#define MACRO \\\n" 3288 " some_very_long_func_aaaaaaaaaa();\n" 3289 "#endif\n" 3290 "#else\n" 3291 "#define A 1\n" 3292 "#endif", 3293 Style); 3294 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 3295 verifyFormat("#ifdef _WIN32\n" 3296 "# define A 0\n" 3297 "# ifdef VAR2\n" 3298 "# define B 1\n" 3299 "# include <someheader.h>\n" 3300 "# define MACRO \\\n" 3301 " some_very_long_func_aaaaaaaaaa();\n" 3302 "# endif\n" 3303 "#else\n" 3304 "# define A 1\n" 3305 "#endif", 3306 Style); 3307 verifyFormat("#if A\n" 3308 "# define MACRO \\\n" 3309 " void a(int x) { \\\n" 3310 " b(); \\\n" 3311 " c(); \\\n" 3312 " d(); \\\n" 3313 " e(); \\\n" 3314 " f(); \\\n" 3315 " }\n" 3316 "#endif", 3317 Style); 3318 // Comments before include guard. 3319 verifyFormat("// file comment\n" 3320 "// file comment\n" 3321 "#ifndef HEADER_H\n" 3322 "#define HEADER_H\n" 3323 "code();\n" 3324 "#endif", 3325 Style); 3326 // Test with include guards. 3327 verifyFormat("#ifndef HEADER_H\n" 3328 "#define HEADER_H\n" 3329 "code();\n" 3330 "#endif", 3331 Style); 3332 // Include guards must have a #define with the same variable immediately 3333 // after #ifndef. 3334 verifyFormat("#ifndef NOT_GUARD\n" 3335 "# define FOO\n" 3336 "code();\n" 3337 "#endif", 3338 Style); 3339 3340 // Include guards must cover the entire file. 3341 verifyFormat("code();\n" 3342 "code();\n" 3343 "#ifndef NOT_GUARD\n" 3344 "# define NOT_GUARD\n" 3345 "code();\n" 3346 "#endif", 3347 Style); 3348 verifyFormat("#ifndef NOT_GUARD\n" 3349 "# define NOT_GUARD\n" 3350 "code();\n" 3351 "#endif\n" 3352 "code();", 3353 Style); 3354 // Test with trailing blank lines. 3355 verifyFormat("#ifndef HEADER_H\n" 3356 "#define HEADER_H\n" 3357 "code();\n" 3358 "#endif\n", 3359 Style); 3360 // Include guards don't have #else. 3361 verifyFormat("#ifndef NOT_GUARD\n" 3362 "# define NOT_GUARD\n" 3363 "code();\n" 3364 "#else\n" 3365 "#endif", 3366 Style); 3367 verifyFormat("#ifndef NOT_GUARD\n" 3368 "# define NOT_GUARD\n" 3369 "code();\n" 3370 "#elif FOO\n" 3371 "#endif", 3372 Style); 3373 // Non-identifier #define after potential include guard. 3374 verifyFormat("#ifndef FOO\n" 3375 "# define 1\n" 3376 "#endif\n", 3377 Style); 3378 // #if closes past last non-preprocessor line. 3379 verifyFormat("#ifndef FOO\n" 3380 "#define FOO\n" 3381 "#if 1\n" 3382 "int i;\n" 3383 "# define A 0\n" 3384 "#endif\n" 3385 "#endif\n", 3386 Style); 3387 // Don't crash if there is an #elif directive without a condition. 3388 verifyFormat("#if 1\n" 3389 "int x;\n" 3390 "#elif\n" 3391 "int y;\n" 3392 "#else\n" 3393 "int z;\n" 3394 "#endif", 3395 Style); 3396 // FIXME: This doesn't handle the case where there's code between the 3397 // #ifndef and #define but all other conditions hold. This is because when 3398 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 3399 // previous code line yet, so we can't detect it. 3400 EXPECT_EQ("#ifndef NOT_GUARD\n" 3401 "code();\n" 3402 "#define NOT_GUARD\n" 3403 "code();\n" 3404 "#endif", 3405 format("#ifndef NOT_GUARD\n" 3406 "code();\n" 3407 "# define NOT_GUARD\n" 3408 "code();\n" 3409 "#endif", 3410 Style)); 3411 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 3412 // be outside an include guard. Examples are #pragma once and 3413 // #pragma GCC diagnostic, or anything else that does not change the meaning 3414 // of the file if it's included multiple times. 3415 EXPECT_EQ("#ifdef WIN32\n" 3416 "# pragma once\n" 3417 "#endif\n" 3418 "#ifndef HEADER_H\n" 3419 "# define HEADER_H\n" 3420 "code();\n" 3421 "#endif", 3422 format("#ifdef WIN32\n" 3423 "# pragma once\n" 3424 "#endif\n" 3425 "#ifndef HEADER_H\n" 3426 "#define HEADER_H\n" 3427 "code();\n" 3428 "#endif", 3429 Style)); 3430 // FIXME: This does not detect when there is a single non-preprocessor line 3431 // in front of an include-guard-like structure where other conditions hold 3432 // because ScopedLineState hides the line. 3433 EXPECT_EQ("code();\n" 3434 "#ifndef HEADER_H\n" 3435 "#define HEADER_H\n" 3436 "code();\n" 3437 "#endif", 3438 format("code();\n" 3439 "#ifndef HEADER_H\n" 3440 "# define HEADER_H\n" 3441 "code();\n" 3442 "#endif", 3443 Style)); 3444 // Keep comments aligned with #, otherwise indent comments normally. These 3445 // tests cannot use verifyFormat because messUp manipulates leading 3446 // whitespace. 3447 { 3448 const char *Expected = "" 3449 "void f() {\n" 3450 "#if 1\n" 3451 "// Preprocessor aligned.\n" 3452 "# define A 0\n" 3453 " // Code. Separated by blank line.\n" 3454 "\n" 3455 "# define B 0\n" 3456 " // Code. Not aligned with #\n" 3457 "# define C 0\n" 3458 "#endif"; 3459 const char *ToFormat = "" 3460 "void f() {\n" 3461 "#if 1\n" 3462 "// Preprocessor aligned.\n" 3463 "# define A 0\n" 3464 "// Code. Separated by blank line.\n" 3465 "\n" 3466 "# define B 0\n" 3467 " // Code. Not aligned with #\n" 3468 "# define C 0\n" 3469 "#endif"; 3470 EXPECT_EQ(Expected, format(ToFormat, Style)); 3471 EXPECT_EQ(Expected, format(Expected, Style)); 3472 } 3473 // Keep block quotes aligned. 3474 { 3475 const char *Expected = "" 3476 "void f() {\n" 3477 "#if 1\n" 3478 "/* Preprocessor aligned. */\n" 3479 "# define A 0\n" 3480 " /* Code. Separated by blank line. */\n" 3481 "\n" 3482 "# define B 0\n" 3483 " /* Code. Not aligned with # */\n" 3484 "# define C 0\n" 3485 "#endif"; 3486 const char *ToFormat = "" 3487 "void f() {\n" 3488 "#if 1\n" 3489 "/* Preprocessor aligned. */\n" 3490 "# define A 0\n" 3491 "/* Code. Separated by blank line. */\n" 3492 "\n" 3493 "# define B 0\n" 3494 " /* Code. Not aligned with # */\n" 3495 "# define C 0\n" 3496 "#endif"; 3497 EXPECT_EQ(Expected, format(ToFormat, Style)); 3498 EXPECT_EQ(Expected, format(Expected, Style)); 3499 } 3500 // Keep comments aligned with un-indented directives. 3501 { 3502 const char *Expected = "" 3503 "void f() {\n" 3504 "// Preprocessor aligned.\n" 3505 "#define A 0\n" 3506 " // Code. Separated by blank line.\n" 3507 "\n" 3508 "#define B 0\n" 3509 " // Code. Not aligned with #\n" 3510 "#define C 0\n"; 3511 const char *ToFormat = "" 3512 "void f() {\n" 3513 "// Preprocessor aligned.\n" 3514 "#define A 0\n" 3515 "// Code. Separated by blank line.\n" 3516 "\n" 3517 "#define B 0\n" 3518 " // Code. Not aligned with #\n" 3519 "#define C 0\n"; 3520 EXPECT_EQ(Expected, format(ToFormat, Style)); 3521 EXPECT_EQ(Expected, format(Expected, Style)); 3522 } 3523 // Test AfterHash with tabs. 3524 { 3525 FormatStyle Tabbed = Style; 3526 Tabbed.UseTab = FormatStyle::UT_Always; 3527 Tabbed.IndentWidth = 8; 3528 Tabbed.TabWidth = 8; 3529 verifyFormat("#ifdef _WIN32\n" 3530 "#\tdefine A 0\n" 3531 "#\tifdef VAR2\n" 3532 "#\t\tdefine B 1\n" 3533 "#\t\tinclude <someheader.h>\n" 3534 "#\t\tdefine MACRO \\\n" 3535 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3536 "#\tendif\n" 3537 "#else\n" 3538 "#\tdefine A 1\n" 3539 "#endif", 3540 Tabbed); 3541 } 3542 3543 // Regression test: Multiline-macro inside include guards. 3544 verifyFormat("#ifndef HEADER_H\n" 3545 "#define HEADER_H\n" 3546 "#define A() \\\n" 3547 " int i; \\\n" 3548 " int j;\n" 3549 "#endif // HEADER_H", 3550 getLLVMStyleWithColumns(20)); 3551 3552 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3553 // Basic before hash indent tests 3554 verifyFormat("#ifdef _WIN32\n" 3555 " #define A 0\n" 3556 " #ifdef VAR2\n" 3557 " #define B 1\n" 3558 " #include <someheader.h>\n" 3559 " #define MACRO \\\n" 3560 " some_very_long_func_aaaaaaaaaa();\n" 3561 " #endif\n" 3562 "#else\n" 3563 " #define A 1\n" 3564 "#endif", 3565 Style); 3566 verifyFormat("#if A\n" 3567 " #define MACRO \\\n" 3568 " void a(int x) { \\\n" 3569 " b(); \\\n" 3570 " c(); \\\n" 3571 " d(); \\\n" 3572 " e(); \\\n" 3573 " f(); \\\n" 3574 " }\n" 3575 "#endif", 3576 Style); 3577 // Keep comments aligned with indented directives. These 3578 // tests cannot use verifyFormat because messUp manipulates leading 3579 // whitespace. 3580 { 3581 const char *Expected = "void f() {\n" 3582 "// Aligned to preprocessor.\n" 3583 "#if 1\n" 3584 " // Aligned to code.\n" 3585 " int a;\n" 3586 " #if 1\n" 3587 " // Aligned to preprocessor.\n" 3588 " #define A 0\n" 3589 " // Aligned to code.\n" 3590 " int b;\n" 3591 " #endif\n" 3592 "#endif\n" 3593 "}"; 3594 const char *ToFormat = "void f() {\n" 3595 "// Aligned to preprocessor.\n" 3596 "#if 1\n" 3597 "// Aligned to code.\n" 3598 "int a;\n" 3599 "#if 1\n" 3600 "// Aligned to preprocessor.\n" 3601 "#define A 0\n" 3602 "// Aligned to code.\n" 3603 "int b;\n" 3604 "#endif\n" 3605 "#endif\n" 3606 "}"; 3607 EXPECT_EQ(Expected, format(ToFormat, Style)); 3608 EXPECT_EQ(Expected, format(Expected, Style)); 3609 } 3610 { 3611 const char *Expected = "void f() {\n" 3612 "/* Aligned to preprocessor. */\n" 3613 "#if 1\n" 3614 " /* Aligned to code. */\n" 3615 " int a;\n" 3616 " #if 1\n" 3617 " /* Aligned to preprocessor. */\n" 3618 " #define A 0\n" 3619 " /* Aligned to code. */\n" 3620 " int b;\n" 3621 " #endif\n" 3622 "#endif\n" 3623 "}"; 3624 const char *ToFormat = "void f() {\n" 3625 "/* Aligned to preprocessor. */\n" 3626 "#if 1\n" 3627 "/* Aligned to code. */\n" 3628 "int a;\n" 3629 "#if 1\n" 3630 "/* Aligned to preprocessor. */\n" 3631 "#define A 0\n" 3632 "/* Aligned to code. */\n" 3633 "int b;\n" 3634 "#endif\n" 3635 "#endif\n" 3636 "}"; 3637 EXPECT_EQ(Expected, format(ToFormat, Style)); 3638 EXPECT_EQ(Expected, format(Expected, Style)); 3639 } 3640 3641 // Test single comment before preprocessor 3642 verifyFormat("// Comment\n" 3643 "\n" 3644 "#if 1\n" 3645 "#endif", 3646 Style); 3647 } 3648 3649 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3650 verifyFormat("{\n { a #c; }\n}"); 3651 } 3652 3653 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3654 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3655 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3656 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3657 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3658 } 3659 3660 TEST_F(FormatTest, EscapedNewlines) { 3661 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3662 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3663 format("#define A \\\nint i;\\\n int j;", Narrow)); 3664 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3665 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3666 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3667 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3668 3669 FormatStyle AlignLeft = getLLVMStyle(); 3670 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3671 EXPECT_EQ("#define MACRO(x) \\\n" 3672 "private: \\\n" 3673 " int x(int a);\n", 3674 format("#define MACRO(x) \\\n" 3675 "private: \\\n" 3676 " int x(int a);\n", 3677 AlignLeft)); 3678 3679 // CRLF line endings 3680 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3681 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3682 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3683 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3684 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3685 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3686 EXPECT_EQ("#define MACRO(x) \\\r\n" 3687 "private: \\\r\n" 3688 " int x(int a);\r\n", 3689 format("#define MACRO(x) \\\r\n" 3690 "private: \\\r\n" 3691 " int x(int a);\r\n", 3692 AlignLeft)); 3693 3694 FormatStyle DontAlign = getLLVMStyle(); 3695 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3696 DontAlign.MaxEmptyLinesToKeep = 3; 3697 // FIXME: can't use verifyFormat here because the newline before 3698 // "public:" is not inserted the first time it's reformatted 3699 EXPECT_EQ("#define A \\\n" 3700 " class Foo { \\\n" 3701 " void bar(); \\\n" 3702 "\\\n" 3703 "\\\n" 3704 "\\\n" 3705 " public: \\\n" 3706 " void baz(); \\\n" 3707 " };", 3708 format("#define A \\\n" 3709 " class Foo { \\\n" 3710 " void bar(); \\\n" 3711 "\\\n" 3712 "\\\n" 3713 "\\\n" 3714 " public: \\\n" 3715 " void baz(); \\\n" 3716 " };", 3717 DontAlign)); 3718 } 3719 3720 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3721 verifyFormat("#define A \\\n" 3722 " int v( \\\n" 3723 " a); \\\n" 3724 " int i;", 3725 getLLVMStyleWithColumns(11)); 3726 } 3727 3728 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3729 EXPECT_EQ( 3730 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3731 " \\\n" 3732 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3733 "\n" 3734 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3735 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3736 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3737 "\\\n" 3738 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3739 " \n" 3740 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3741 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3742 } 3743 3744 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3745 EXPECT_EQ("int\n" 3746 "#define A\n" 3747 " a;", 3748 format("int\n#define A\na;")); 3749 verifyFormat("functionCallTo(\n" 3750 " someOtherFunction(\n" 3751 " withSomeParameters, whichInSequence,\n" 3752 " areLongerThanALine(andAnotherCall,\n" 3753 "#define A B\n" 3754 " withMoreParamters,\n" 3755 " whichStronglyInfluenceTheLayout),\n" 3756 " andMoreParameters),\n" 3757 " trailing);", 3758 getLLVMStyleWithColumns(69)); 3759 verifyFormat("Foo::Foo()\n" 3760 "#ifdef BAR\n" 3761 " : baz(0)\n" 3762 "#endif\n" 3763 "{\n" 3764 "}"); 3765 verifyFormat("void f() {\n" 3766 " if (true)\n" 3767 "#ifdef A\n" 3768 " f(42);\n" 3769 " x();\n" 3770 "#else\n" 3771 " g();\n" 3772 " x();\n" 3773 "#endif\n" 3774 "}"); 3775 verifyFormat("void f(param1, param2,\n" 3776 " param3,\n" 3777 "#ifdef A\n" 3778 " param4(param5,\n" 3779 "#ifdef A1\n" 3780 " param6,\n" 3781 "#ifdef A2\n" 3782 " param7),\n" 3783 "#else\n" 3784 " param8),\n" 3785 " param9,\n" 3786 "#endif\n" 3787 " param10,\n" 3788 "#endif\n" 3789 " param11)\n" 3790 "#else\n" 3791 " param12)\n" 3792 "#endif\n" 3793 "{\n" 3794 " x();\n" 3795 "}", 3796 getLLVMStyleWithColumns(28)); 3797 verifyFormat("#if 1\n" 3798 "int i;"); 3799 verifyFormat("#if 1\n" 3800 "#endif\n" 3801 "#if 1\n" 3802 "#else\n" 3803 "#endif\n"); 3804 verifyFormat("DEBUG({\n" 3805 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3806 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3807 "});\n" 3808 "#if a\n" 3809 "#else\n" 3810 "#endif"); 3811 3812 verifyIncompleteFormat("void f(\n" 3813 "#if A\n" 3814 ");\n" 3815 "#else\n" 3816 "#endif"); 3817 } 3818 3819 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3820 verifyFormat("#endif\n" 3821 "#if B"); 3822 } 3823 3824 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3825 FormatStyle SingleLine = getLLVMStyle(); 3826 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3827 verifyFormat("#if 0\n" 3828 "#elif 1\n" 3829 "#endif\n" 3830 "void foo() {\n" 3831 " if (test) foo2();\n" 3832 "}", 3833 SingleLine); 3834 } 3835 3836 TEST_F(FormatTest, LayoutBlockInsideParens) { 3837 verifyFormat("functionCall({ int i; });"); 3838 verifyFormat("functionCall({\n" 3839 " int i;\n" 3840 " int j;\n" 3841 "});"); 3842 verifyFormat("functionCall(\n" 3843 " {\n" 3844 " int i;\n" 3845 " int j;\n" 3846 " },\n" 3847 " aaaa, bbbb, cccc);"); 3848 verifyFormat("functionA(functionB({\n" 3849 " int i;\n" 3850 " int j;\n" 3851 " }),\n" 3852 " aaaa, bbbb, cccc);"); 3853 verifyFormat("functionCall(\n" 3854 " {\n" 3855 " int i;\n" 3856 " int j;\n" 3857 " },\n" 3858 " aaaa, bbbb, // comment\n" 3859 " cccc);"); 3860 verifyFormat("functionA(functionB({\n" 3861 " int i;\n" 3862 " int j;\n" 3863 " }),\n" 3864 " aaaa, bbbb, // comment\n" 3865 " cccc);"); 3866 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3867 verifyFormat("functionCall(aaaa, bbbb, {\n" 3868 " int i;\n" 3869 " int j;\n" 3870 "});"); 3871 verifyFormat( 3872 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3873 " {\n" 3874 " int i; // break\n" 3875 " },\n" 3876 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3877 " ccccccccccccccccc));"); 3878 verifyFormat("DEBUG({\n" 3879 " if (a)\n" 3880 " f();\n" 3881 "});"); 3882 } 3883 3884 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3885 EXPECT_EQ("SOME_MACRO { int i; }\n" 3886 "int i;", 3887 format(" SOME_MACRO {int i;} int i;")); 3888 } 3889 3890 TEST_F(FormatTest, LayoutNestedBlocks) { 3891 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3892 " struct s {\n" 3893 " int i;\n" 3894 " };\n" 3895 " s kBitsToOs[] = {{10}};\n" 3896 " for (int i = 0; i < 10; ++i)\n" 3897 " return;\n" 3898 "}"); 3899 verifyFormat("call(parameter, {\n" 3900 " something();\n" 3901 " // Comment using all columns.\n" 3902 " somethingelse();\n" 3903 "});", 3904 getLLVMStyleWithColumns(40)); 3905 verifyFormat("DEBUG( //\n" 3906 " { f(); }, a);"); 3907 verifyFormat("DEBUG( //\n" 3908 " {\n" 3909 " f(); //\n" 3910 " },\n" 3911 " a);"); 3912 3913 EXPECT_EQ("call(parameter, {\n" 3914 " something();\n" 3915 " // Comment too\n" 3916 " // looooooooooong.\n" 3917 " somethingElse();\n" 3918 "});", 3919 format("call(parameter, {\n" 3920 " something();\n" 3921 " // Comment too looooooooooong.\n" 3922 " somethingElse();\n" 3923 "});", 3924 getLLVMStyleWithColumns(29))); 3925 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3926 EXPECT_EQ("DEBUG({ // comment\n" 3927 " int i;\n" 3928 "});", 3929 format("DEBUG({ // comment\n" 3930 "int i;\n" 3931 "});")); 3932 EXPECT_EQ("DEBUG({\n" 3933 " int i;\n" 3934 "\n" 3935 " // comment\n" 3936 " int j;\n" 3937 "});", 3938 format("DEBUG({\n" 3939 " int i;\n" 3940 "\n" 3941 " // comment\n" 3942 " int j;\n" 3943 "});")); 3944 3945 verifyFormat("DEBUG({\n" 3946 " if (a)\n" 3947 " return;\n" 3948 "});"); 3949 verifyGoogleFormat("DEBUG({\n" 3950 " if (a) return;\n" 3951 "});"); 3952 FormatStyle Style = getGoogleStyle(); 3953 Style.ColumnLimit = 45; 3954 verifyFormat("Debug(\n" 3955 " aaaaa,\n" 3956 " {\n" 3957 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 3958 " },\n" 3959 " a);", 3960 Style); 3961 3962 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 3963 3964 verifyNoCrash("^{v^{a}}"); 3965 } 3966 3967 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 3968 EXPECT_EQ("#define MACRO() \\\n" 3969 " Debug(aaa, /* force line break */ \\\n" 3970 " { \\\n" 3971 " int i; \\\n" 3972 " int j; \\\n" 3973 " })", 3974 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 3975 " { int i; int j; })", 3976 getGoogleStyle())); 3977 3978 EXPECT_EQ("#define A \\\n" 3979 " [] { \\\n" 3980 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3981 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 3982 " }", 3983 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3984 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 3985 getGoogleStyle())); 3986 } 3987 3988 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 3989 EXPECT_EQ("{}", format("{}")); 3990 verifyFormat("enum E {};"); 3991 verifyFormat("enum E {}"); 3992 FormatStyle Style = getLLVMStyle(); 3993 Style.SpaceInEmptyBlock = true; 3994 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 3995 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 3996 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 3997 } 3998 3999 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 4000 FormatStyle Style = getLLVMStyle(); 4001 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 4002 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 4003 verifyFormat("FOO_BEGIN\n" 4004 " FOO_ENTRY\n" 4005 "FOO_END", 4006 Style); 4007 verifyFormat("FOO_BEGIN\n" 4008 " NESTED_FOO_BEGIN\n" 4009 " NESTED_FOO_ENTRY\n" 4010 " NESTED_FOO_END\n" 4011 "FOO_END", 4012 Style); 4013 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 4014 " int x;\n" 4015 " x = 1;\n" 4016 "FOO_END(Baz)", 4017 Style); 4018 } 4019 4020 //===----------------------------------------------------------------------===// 4021 // Line break tests. 4022 //===----------------------------------------------------------------------===// 4023 4024 TEST_F(FormatTest, PreventConfusingIndents) { 4025 verifyFormat( 4026 "void f() {\n" 4027 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 4028 " parameter, parameter, parameter)),\n" 4029 " SecondLongCall(parameter));\n" 4030 "}"); 4031 verifyFormat( 4032 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4033 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4034 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4035 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 4036 verifyFormat( 4037 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4038 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 4039 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 4040 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 4041 verifyFormat( 4042 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 4043 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 4044 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 4045 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 4046 verifyFormat("int a = bbbb && ccc &&\n" 4047 " fffff(\n" 4048 "#define A Just forcing a new line\n" 4049 " ddd);"); 4050 } 4051 4052 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 4053 verifyFormat( 4054 "bool aaaaaaa =\n" 4055 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 4056 " bbbbbbbb();"); 4057 verifyFormat( 4058 "bool aaaaaaa =\n" 4059 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 4060 " bbbbbbbb();"); 4061 4062 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 4063 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 4064 " ccccccccc == ddddddddddd;"); 4065 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 4066 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 4067 " ccccccccc == ddddddddddd;"); 4068 verifyFormat( 4069 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 4070 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 4071 " ccccccccc == ddddddddddd;"); 4072 4073 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 4074 " aaaaaa) &&\n" 4075 " bbbbbb && cccccc;"); 4076 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 4077 " aaaaaa) >>\n" 4078 " bbbbbb;"); 4079 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 4080 " SourceMgr.getSpellingColumnNumber(\n" 4081 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 4082 " 1);"); 4083 4084 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4085 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 4086 " cccccc) {\n}"); 4087 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4088 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 4089 " cccccc) {\n}"); 4090 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4091 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 4092 " cccccc) {\n}"); 4093 verifyFormat("b = a &&\n" 4094 " // Comment\n" 4095 " b.c && d;"); 4096 4097 // If the LHS of a comparison is not a binary expression itself, the 4098 // additional linebreak confuses many people. 4099 verifyFormat( 4100 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4101 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 4102 "}"); 4103 verifyFormat( 4104 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4105 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4106 "}"); 4107 verifyFormat( 4108 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 4109 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4110 "}"); 4111 verifyFormat( 4112 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4113 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 4114 "}"); 4115 // Even explicit parentheses stress the precedence enough to make the 4116 // additional break unnecessary. 4117 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4118 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4119 "}"); 4120 // This cases is borderline, but with the indentation it is still readable. 4121 verifyFormat( 4122 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4123 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4124 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 4125 "}", 4126 getLLVMStyleWithColumns(75)); 4127 4128 // If the LHS is a binary expression, we should still use the additional break 4129 // as otherwise the formatting hides the operator precedence. 4130 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4131 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4132 " 5) {\n" 4133 "}"); 4134 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4135 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 4136 " 5) {\n" 4137 "}"); 4138 4139 FormatStyle OnePerLine = getLLVMStyle(); 4140 OnePerLine.BinPackParameters = false; 4141 verifyFormat( 4142 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4143 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4144 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 4145 OnePerLine); 4146 4147 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 4148 " .aaa(aaaaaaaaaaaaa) *\n" 4149 " aaaaaaa +\n" 4150 " aaaaaaa;", 4151 getLLVMStyleWithColumns(40)); 4152 } 4153 4154 TEST_F(FormatTest, ExpressionIndentation) { 4155 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4156 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4157 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4158 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4159 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 4160 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 4161 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4162 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 4163 " ccccccccccccccccccccccccccccccccccccccccc;"); 4164 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4165 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4166 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4167 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4168 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4169 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4170 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4171 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4172 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4173 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4174 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4175 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4176 verifyFormat("if () {\n" 4177 "} else if (aaaaa && bbbbb > // break\n" 4178 " ccccc) {\n" 4179 "}"); 4180 verifyFormat("if () {\n" 4181 "} else if constexpr (aaaaa && bbbbb > // break\n" 4182 " ccccc) {\n" 4183 "}"); 4184 verifyFormat("if () {\n" 4185 "} else if CONSTEXPR (aaaaa && bbbbb > // break\n" 4186 " ccccc) {\n" 4187 "}"); 4188 verifyFormat("if () {\n" 4189 "} else if (aaaaa &&\n" 4190 " bbbbb > // break\n" 4191 " ccccc &&\n" 4192 " ddddd) {\n" 4193 "}"); 4194 4195 // Presence of a trailing comment used to change indentation of b. 4196 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 4197 " b;\n" 4198 "return aaaaaaaaaaaaaaaaaaa +\n" 4199 " b; //", 4200 getLLVMStyleWithColumns(30)); 4201 } 4202 4203 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 4204 // Not sure what the best system is here. Like this, the LHS can be found 4205 // immediately above an operator (everything with the same or a higher 4206 // indent). The RHS is aligned right of the operator and so compasses 4207 // everything until something with the same indent as the operator is found. 4208 // FIXME: Is this a good system? 4209 FormatStyle Style = getLLVMStyle(); 4210 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 4211 verifyFormat( 4212 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4213 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4214 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4215 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4216 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4217 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4218 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4219 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4220 " > ccccccccccccccccccccccccccccccccccccccccc;", 4221 Style); 4222 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4223 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4224 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4225 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4226 Style); 4227 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4228 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4229 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4230 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4231 Style); 4232 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4233 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4234 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4235 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4236 Style); 4237 verifyFormat("if () {\n" 4238 "} else if (aaaaa\n" 4239 " && bbbbb // break\n" 4240 " > ccccc) {\n" 4241 "}", 4242 Style); 4243 verifyFormat("return (a)\n" 4244 " // comment\n" 4245 " + b;", 4246 Style); 4247 verifyFormat( 4248 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4249 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4250 " + cc;", 4251 Style); 4252 4253 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4254 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4255 Style); 4256 4257 // Forced by comments. 4258 verifyFormat( 4259 "unsigned ContentSize =\n" 4260 " sizeof(int16_t) // DWARF ARange version number\n" 4261 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4262 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4263 " + sizeof(int8_t); // Segment Size (in bytes)"); 4264 4265 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 4266 " == boost::fusion::at_c<1>(iiii).second;", 4267 Style); 4268 4269 Style.ColumnLimit = 60; 4270 verifyFormat("zzzzzzzzzz\n" 4271 " = bbbbbbbbbbbbbbbbb\n" 4272 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 4273 Style); 4274 4275 Style.ColumnLimit = 80; 4276 Style.IndentWidth = 4; 4277 Style.TabWidth = 4; 4278 Style.UseTab = FormatStyle::UT_Always; 4279 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4280 Style.AlignOperands = false; 4281 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 4282 "\t&& (someOtherLongishConditionPart1\n" 4283 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 4284 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && " 4285 "(someOtherLongishConditionPart1 || " 4286 "someOtherEvenLongerNestedConditionPart2);", 4287 Style)); 4288 } 4289 4290 TEST_F(FormatTest, EnforcedOperatorWraps) { 4291 // Here we'd like to wrap after the || operators, but a comment is forcing an 4292 // earlier wrap. 4293 verifyFormat("bool x = aaaaa //\n" 4294 " || bbbbb\n" 4295 " //\n" 4296 " || cccc;"); 4297 } 4298 4299 TEST_F(FormatTest, NoOperandAlignment) { 4300 FormatStyle Style = getLLVMStyle(); 4301 Style.AlignOperands = false; 4302 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 4303 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4304 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4305 Style); 4306 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4307 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4308 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4309 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4310 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4311 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4312 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4313 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4314 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4315 " > ccccccccccccccccccccccccccccccccccccccccc;", 4316 Style); 4317 4318 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4319 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4320 " + cc;", 4321 Style); 4322 verifyFormat("int a = aa\n" 4323 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4324 " * cccccccccccccccccccccccccccccccccccc;\n", 4325 Style); 4326 4327 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4328 verifyFormat("return (a > b\n" 4329 " // comment1\n" 4330 " // comment2\n" 4331 " || c);", 4332 Style); 4333 } 4334 4335 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 4336 FormatStyle Style = getLLVMStyle(); 4337 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4338 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4339 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4340 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4341 Style); 4342 } 4343 4344 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 4345 FormatStyle Style = getLLVMStyle(); 4346 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4347 Style.BinPackArguments = false; 4348 Style.ColumnLimit = 40; 4349 verifyFormat("void test() {\n" 4350 " someFunction(\n" 4351 " this + argument + is + quite\n" 4352 " + long + so + it + gets + wrapped\n" 4353 " + but + remains + bin - packed);\n" 4354 "}", 4355 Style); 4356 verifyFormat("void test() {\n" 4357 " someFunction(arg1,\n" 4358 " this + argument + is\n" 4359 " + quite + long + so\n" 4360 " + it + gets + wrapped\n" 4361 " + but + remains + bin\n" 4362 " - packed,\n" 4363 " arg3);\n" 4364 "}", 4365 Style); 4366 verifyFormat("void test() {\n" 4367 " someFunction(\n" 4368 " arg1,\n" 4369 " this + argument + has\n" 4370 " + anotherFunc(nested,\n" 4371 " calls + whose\n" 4372 " + arguments\n" 4373 " + are + also\n" 4374 " + wrapped,\n" 4375 " in + addition)\n" 4376 " + to + being + bin - packed,\n" 4377 " arg3);\n" 4378 "}", 4379 Style); 4380 4381 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4382 verifyFormat("void test() {\n" 4383 " someFunction(\n" 4384 " arg1,\n" 4385 " this + argument + has +\n" 4386 " anotherFunc(nested,\n" 4387 " calls + whose +\n" 4388 " arguments +\n" 4389 " are + also +\n" 4390 " wrapped,\n" 4391 " in + addition) +\n" 4392 " to + being + bin - packed,\n" 4393 " arg3);\n" 4394 "}", 4395 Style); 4396 } 4397 4398 TEST_F(FormatTest, ConstructorInitializers) { 4399 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4400 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 4401 getLLVMStyleWithColumns(45)); 4402 verifyFormat("Constructor()\n" 4403 " : Inttializer(FitsOnTheLine) {}", 4404 getLLVMStyleWithColumns(44)); 4405 verifyFormat("Constructor()\n" 4406 " : Inttializer(FitsOnTheLine) {}", 4407 getLLVMStyleWithColumns(43)); 4408 4409 verifyFormat("template <typename T>\n" 4410 "Constructor() : Initializer(FitsOnTheLine) {}", 4411 getLLVMStyleWithColumns(45)); 4412 4413 verifyFormat( 4414 "SomeClass::Constructor()\n" 4415 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4416 4417 verifyFormat( 4418 "SomeClass::Constructor()\n" 4419 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4420 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 4421 verifyFormat( 4422 "SomeClass::Constructor()\n" 4423 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4424 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4425 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4426 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4427 " : aaaaaaaaaa(aaaaaa) {}"); 4428 4429 verifyFormat("Constructor()\n" 4430 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4431 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4432 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4433 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 4434 4435 verifyFormat("Constructor()\n" 4436 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4437 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4438 4439 verifyFormat("Constructor(int Parameter = 0)\n" 4440 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4441 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 4442 verifyFormat("Constructor()\n" 4443 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4444 "}", 4445 getLLVMStyleWithColumns(60)); 4446 verifyFormat("Constructor()\n" 4447 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4448 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 4449 4450 // Here a line could be saved by splitting the second initializer onto two 4451 // lines, but that is not desirable. 4452 verifyFormat("Constructor()\n" 4453 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4454 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4455 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4456 4457 FormatStyle OnePerLine = getLLVMStyle(); 4458 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4459 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 4460 verifyFormat("SomeClass::Constructor()\n" 4461 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4462 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4463 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4464 OnePerLine); 4465 verifyFormat("SomeClass::Constructor()\n" 4466 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4467 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4468 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4469 OnePerLine); 4470 verifyFormat("MyClass::MyClass(int var)\n" 4471 " : some_var_(var), // 4 space indent\n" 4472 " some_other_var_(var + 1) { // lined up\n" 4473 "}", 4474 OnePerLine); 4475 verifyFormat("Constructor()\n" 4476 " : aaaaa(aaaaaa),\n" 4477 " aaaaa(aaaaaa),\n" 4478 " aaaaa(aaaaaa),\n" 4479 " aaaaa(aaaaaa),\n" 4480 " aaaaa(aaaaaa) {}", 4481 OnePerLine); 4482 verifyFormat("Constructor()\n" 4483 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4484 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4485 OnePerLine); 4486 OnePerLine.BinPackParameters = false; 4487 verifyFormat( 4488 "Constructor()\n" 4489 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4490 " aaaaaaaaaaa().aaa(),\n" 4491 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4492 OnePerLine); 4493 OnePerLine.ColumnLimit = 60; 4494 verifyFormat("Constructor()\n" 4495 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4496 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4497 OnePerLine); 4498 4499 EXPECT_EQ("Constructor()\n" 4500 " : // Comment forcing unwanted break.\n" 4501 " aaaa(aaaa) {}", 4502 format("Constructor() :\n" 4503 " // Comment forcing unwanted break.\n" 4504 " aaaa(aaaa) {}")); 4505 } 4506 4507 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 4508 FormatStyle Style = getLLVMStyle(); 4509 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4510 Style.ColumnLimit = 60; 4511 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4512 Style.AllowAllConstructorInitializersOnNextLine = true; 4513 Style.BinPackParameters = false; 4514 4515 for (int i = 0; i < 4; ++i) { 4516 // Test all combinations of parameters that should not have an effect. 4517 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4518 Style.AllowAllArgumentsOnNextLine = i & 2; 4519 4520 Style.AllowAllConstructorInitializersOnNextLine = true; 4521 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4522 verifyFormat("Constructor()\n" 4523 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4524 Style); 4525 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4526 4527 Style.AllowAllConstructorInitializersOnNextLine = false; 4528 verifyFormat("Constructor()\n" 4529 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4530 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4531 Style); 4532 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4533 4534 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4535 Style.AllowAllConstructorInitializersOnNextLine = true; 4536 verifyFormat("Constructor()\n" 4537 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4538 Style); 4539 4540 Style.AllowAllConstructorInitializersOnNextLine = false; 4541 verifyFormat("Constructor()\n" 4542 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4543 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4544 Style); 4545 4546 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4547 Style.AllowAllConstructorInitializersOnNextLine = true; 4548 verifyFormat("Constructor() :\n" 4549 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4550 Style); 4551 4552 Style.AllowAllConstructorInitializersOnNextLine = false; 4553 verifyFormat("Constructor() :\n" 4554 " aaaaaaaaaaaaaaaaaa(a),\n" 4555 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4556 Style); 4557 } 4558 4559 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4560 // AllowAllConstructorInitializersOnNextLine in all 4561 // BreakConstructorInitializers modes 4562 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4563 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4564 Style.AllowAllConstructorInitializersOnNextLine = false; 4565 verifyFormat("SomeClassWithALongName::Constructor(\n" 4566 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4567 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4568 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4569 Style); 4570 4571 Style.AllowAllConstructorInitializersOnNextLine = true; 4572 verifyFormat("SomeClassWithALongName::Constructor(\n" 4573 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4574 " int bbbbbbbbbbbbb,\n" 4575 " int cccccccccccccccc)\n" 4576 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4577 Style); 4578 4579 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4580 Style.AllowAllConstructorInitializersOnNextLine = false; 4581 verifyFormat("SomeClassWithALongName::Constructor(\n" 4582 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4583 " int bbbbbbbbbbbbb)\n" 4584 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4585 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4586 Style); 4587 4588 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4589 4590 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4591 verifyFormat("SomeClassWithALongName::Constructor(\n" 4592 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4593 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4594 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4595 Style); 4596 4597 Style.AllowAllConstructorInitializersOnNextLine = true; 4598 verifyFormat("SomeClassWithALongName::Constructor(\n" 4599 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4600 " int bbbbbbbbbbbbb,\n" 4601 " int cccccccccccccccc)\n" 4602 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4603 Style); 4604 4605 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4606 Style.AllowAllConstructorInitializersOnNextLine = false; 4607 verifyFormat("SomeClassWithALongName::Constructor(\n" 4608 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4609 " int bbbbbbbbbbbbb)\n" 4610 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4611 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4612 Style); 4613 4614 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4615 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4616 verifyFormat("SomeClassWithALongName::Constructor(\n" 4617 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4618 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4619 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4620 Style); 4621 4622 Style.AllowAllConstructorInitializersOnNextLine = true; 4623 verifyFormat("SomeClassWithALongName::Constructor(\n" 4624 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4625 " int bbbbbbbbbbbbb,\n" 4626 " int cccccccccccccccc) :\n" 4627 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4628 Style); 4629 4630 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4631 Style.AllowAllConstructorInitializersOnNextLine = false; 4632 verifyFormat("SomeClassWithALongName::Constructor(\n" 4633 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4634 " int bbbbbbbbbbbbb) :\n" 4635 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4636 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4637 Style); 4638 } 4639 4640 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4641 FormatStyle Style = getLLVMStyle(); 4642 Style.ColumnLimit = 60; 4643 Style.BinPackArguments = false; 4644 for (int i = 0; i < 4; ++i) { 4645 // Test all combinations of parameters that should not have an effect. 4646 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4647 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4648 4649 Style.AllowAllArgumentsOnNextLine = true; 4650 verifyFormat("void foo() {\n" 4651 " FunctionCallWithReallyLongName(\n" 4652 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4653 "}", 4654 Style); 4655 Style.AllowAllArgumentsOnNextLine = false; 4656 verifyFormat("void foo() {\n" 4657 " FunctionCallWithReallyLongName(\n" 4658 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4659 " bbbbbbbbbbbb);\n" 4660 "}", 4661 Style); 4662 4663 Style.AllowAllArgumentsOnNextLine = true; 4664 verifyFormat("void foo() {\n" 4665 " auto VariableWithReallyLongName = {\n" 4666 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4667 "}", 4668 Style); 4669 Style.AllowAllArgumentsOnNextLine = false; 4670 verifyFormat("void foo() {\n" 4671 " auto VariableWithReallyLongName = {\n" 4672 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4673 " bbbbbbbbbbbb};\n" 4674 "}", 4675 Style); 4676 } 4677 4678 // This parameter should not affect declarations. 4679 Style.BinPackParameters = false; 4680 Style.AllowAllArgumentsOnNextLine = false; 4681 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4682 verifyFormat("void FunctionCallWithReallyLongName(\n" 4683 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4684 Style); 4685 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4686 verifyFormat("void FunctionCallWithReallyLongName(\n" 4687 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4688 " int bbbbbbbbbbbb);", 4689 Style); 4690 } 4691 4692 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4693 FormatStyle Style = getLLVMStyle(); 4694 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4695 4696 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4697 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4698 getStyleWithColumns(Style, 45)); 4699 verifyFormat("Constructor() :\n" 4700 " Initializer(FitsOnTheLine) {}", 4701 getStyleWithColumns(Style, 44)); 4702 verifyFormat("Constructor() :\n" 4703 " Initializer(FitsOnTheLine) {}", 4704 getStyleWithColumns(Style, 43)); 4705 4706 verifyFormat("template <typename T>\n" 4707 "Constructor() : Initializer(FitsOnTheLine) {}", 4708 getStyleWithColumns(Style, 50)); 4709 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4710 verifyFormat( 4711 "SomeClass::Constructor() :\n" 4712 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4713 Style); 4714 4715 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4716 verifyFormat( 4717 "SomeClass::Constructor() :\n" 4718 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4719 Style); 4720 4721 verifyFormat( 4722 "SomeClass::Constructor() :\n" 4723 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4724 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4725 Style); 4726 verifyFormat( 4727 "SomeClass::Constructor() :\n" 4728 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4729 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4730 Style); 4731 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4732 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4733 " aaaaaaaaaa(aaaaaa) {}", 4734 Style); 4735 4736 verifyFormat("Constructor() :\n" 4737 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4738 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4739 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4740 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4741 Style); 4742 4743 verifyFormat("Constructor() :\n" 4744 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4745 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4746 Style); 4747 4748 verifyFormat("Constructor(int Parameter = 0) :\n" 4749 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4750 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4751 Style); 4752 verifyFormat("Constructor() :\n" 4753 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4754 "}", 4755 getStyleWithColumns(Style, 60)); 4756 verifyFormat("Constructor() :\n" 4757 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4758 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4759 Style); 4760 4761 // Here a line could be saved by splitting the second initializer onto two 4762 // lines, but that is not desirable. 4763 verifyFormat("Constructor() :\n" 4764 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4765 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4766 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4767 Style); 4768 4769 FormatStyle OnePerLine = Style; 4770 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4771 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4772 verifyFormat("SomeClass::Constructor() :\n" 4773 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4774 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4775 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4776 OnePerLine); 4777 verifyFormat("SomeClass::Constructor() :\n" 4778 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4779 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4780 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4781 OnePerLine); 4782 verifyFormat("MyClass::MyClass(int var) :\n" 4783 " some_var_(var), // 4 space indent\n" 4784 " some_other_var_(var + 1) { // lined up\n" 4785 "}", 4786 OnePerLine); 4787 verifyFormat("Constructor() :\n" 4788 " aaaaa(aaaaaa),\n" 4789 " aaaaa(aaaaaa),\n" 4790 " aaaaa(aaaaaa),\n" 4791 " aaaaa(aaaaaa),\n" 4792 " aaaaa(aaaaaa) {}", 4793 OnePerLine); 4794 verifyFormat("Constructor() :\n" 4795 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4796 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4797 OnePerLine); 4798 OnePerLine.BinPackParameters = false; 4799 verifyFormat("Constructor() :\n" 4800 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4801 " aaaaaaaaaaa().aaa(),\n" 4802 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4803 OnePerLine); 4804 OnePerLine.ColumnLimit = 60; 4805 verifyFormat("Constructor() :\n" 4806 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4807 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4808 OnePerLine); 4809 4810 EXPECT_EQ("Constructor() :\n" 4811 " // Comment forcing unwanted break.\n" 4812 " aaaa(aaaa) {}", 4813 format("Constructor() :\n" 4814 " // Comment forcing unwanted break.\n" 4815 " aaaa(aaaa) {}", 4816 Style)); 4817 4818 Style.ColumnLimit = 0; 4819 verifyFormat("SomeClass::Constructor() :\n" 4820 " a(a) {}", 4821 Style); 4822 verifyFormat("SomeClass::Constructor() noexcept :\n" 4823 " a(a) {}", 4824 Style); 4825 verifyFormat("SomeClass::Constructor() :\n" 4826 " a(a), b(b), c(c) {}", 4827 Style); 4828 verifyFormat("SomeClass::Constructor() :\n" 4829 " a(a) {\n" 4830 " foo();\n" 4831 " bar();\n" 4832 "}", 4833 Style); 4834 4835 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4836 verifyFormat("SomeClass::Constructor() :\n" 4837 " a(a), b(b), c(c) {\n" 4838 "}", 4839 Style); 4840 verifyFormat("SomeClass::Constructor() :\n" 4841 " a(a) {\n" 4842 "}", 4843 Style); 4844 4845 Style.ColumnLimit = 80; 4846 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4847 Style.ConstructorInitializerIndentWidth = 2; 4848 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style); 4849 verifyFormat("SomeClass::Constructor() :\n" 4850 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4851 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 4852 Style); 4853 4854 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as 4855 // well 4856 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 4857 verifyFormat( 4858 "class SomeClass\n" 4859 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4860 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4861 Style); 4862 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 4863 verifyFormat( 4864 "class SomeClass\n" 4865 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4866 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4867 Style); 4868 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 4869 verifyFormat( 4870 "class SomeClass :\n" 4871 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4872 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4873 Style); 4874 } 4875 4876 #ifndef EXPENSIVE_CHECKS 4877 // Expensive checks enables libstdc++ checking which includes validating the 4878 // state of ranges used in std::priority_queue - this blows out the 4879 // runtime/scalability of the function and makes this test unacceptably slow. 4880 TEST_F(FormatTest, MemoizationTests) { 4881 // This breaks if the memoization lookup does not take \c Indent and 4882 // \c LastSpace into account. 4883 verifyFormat( 4884 "extern CFRunLoopTimerRef\n" 4885 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 4886 " CFTimeInterval interval, CFOptionFlags flags,\n" 4887 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 4888 " CFRunLoopTimerContext *context) {}"); 4889 4890 // Deep nesting somewhat works around our memoization. 4891 verifyFormat( 4892 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4893 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4894 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4895 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4896 " aaaaa())))))))))))))))))))))))))))))))))))))));", 4897 getLLVMStyleWithColumns(65)); 4898 verifyFormat( 4899 "aaaaa(\n" 4900 " aaaaa,\n" 4901 " aaaaa(\n" 4902 " aaaaa,\n" 4903 " aaaaa(\n" 4904 " aaaaa,\n" 4905 " aaaaa(\n" 4906 " aaaaa,\n" 4907 " aaaaa(\n" 4908 " aaaaa,\n" 4909 " aaaaa(\n" 4910 " aaaaa,\n" 4911 " aaaaa(\n" 4912 " aaaaa,\n" 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))))))))))));", 4924 getLLVMStyleWithColumns(65)); 4925 verifyFormat( 4926 "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" 4927 " a),\n" 4928 " a),\n" 4929 " a),\n" 4930 " a),\n" 4931 " a),\n" 4932 " a),\n" 4933 " a),\n" 4934 " a),\n" 4935 " a),\n" 4936 " a),\n" 4937 " a),\n" 4938 " a),\n" 4939 " a),\n" 4940 " a),\n" 4941 " a),\n" 4942 " a),\n" 4943 " a)", 4944 getLLVMStyleWithColumns(65)); 4945 4946 // This test takes VERY long when memoization is broken. 4947 FormatStyle OnePerLine = getLLVMStyle(); 4948 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4949 OnePerLine.BinPackParameters = false; 4950 std::string input = "Constructor()\n" 4951 " : aaaa(a,\n"; 4952 for (unsigned i = 0, e = 80; i != e; ++i) { 4953 input += " a,\n"; 4954 } 4955 input += " a) {}"; 4956 verifyFormat(input, OnePerLine); 4957 } 4958 #endif 4959 4960 TEST_F(FormatTest, BreaksAsHighAsPossible) { 4961 verifyFormat( 4962 "void f() {\n" 4963 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 4964 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 4965 " f();\n" 4966 "}"); 4967 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 4968 " Intervals[i - 1].getRange().getLast()) {\n}"); 4969 } 4970 4971 TEST_F(FormatTest, BreaksFunctionDeclarations) { 4972 // Principially, we break function declarations in a certain order: 4973 // 1) break amongst arguments. 4974 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 4975 " Cccccccccccccc cccccccccccccc);"); 4976 verifyFormat("template <class TemplateIt>\n" 4977 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 4978 " TemplateIt *stop) {}"); 4979 4980 // 2) break after return type. 4981 verifyFormat( 4982 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4983 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 4984 getGoogleStyle()); 4985 4986 // 3) break after (. 4987 verifyFormat( 4988 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 4989 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 4990 getGoogleStyle()); 4991 4992 // 4) break before after nested name specifiers. 4993 verifyFormat( 4994 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4995 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 4996 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 4997 getGoogleStyle()); 4998 4999 // However, there are exceptions, if a sufficient amount of lines can be 5000 // saved. 5001 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 5002 // more adjusting. 5003 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 5004 " Cccccccccccccc cccccccccc,\n" 5005 " Cccccccccccccc cccccccccc,\n" 5006 " Cccccccccccccc cccccccccc,\n" 5007 " Cccccccccccccc cccccccccc);"); 5008 verifyFormat( 5009 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5010 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5011 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5012 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 5013 getGoogleStyle()); 5014 verifyFormat( 5015 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 5016 " Cccccccccccccc cccccccccc,\n" 5017 " Cccccccccccccc cccccccccc,\n" 5018 " Cccccccccccccc cccccccccc,\n" 5019 " Cccccccccccccc cccccccccc,\n" 5020 " Cccccccccccccc cccccccccc,\n" 5021 " Cccccccccccccc cccccccccc);"); 5022 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5023 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5024 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5025 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5026 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 5027 5028 // Break after multi-line parameters. 5029 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5030 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5031 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5032 " bbbb bbbb);"); 5033 verifyFormat("void SomeLoooooooooooongFunction(\n" 5034 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 5035 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5036 " int bbbbbbbbbbbbb);"); 5037 5038 // Treat overloaded operators like other functions. 5039 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5040 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 5041 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5042 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 5043 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5044 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 5045 verifyGoogleFormat( 5046 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 5047 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 5048 verifyGoogleFormat( 5049 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 5050 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 5051 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5052 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 5053 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 5054 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 5055 verifyGoogleFormat( 5056 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 5057 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5058 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 5059 verifyGoogleFormat("template <typename T>\n" 5060 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5061 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 5062 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 5063 5064 FormatStyle Style = getLLVMStyle(); 5065 Style.PointerAlignment = FormatStyle::PAS_Left; 5066 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5067 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 5068 Style); 5069 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 5070 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5071 Style); 5072 } 5073 5074 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 5075 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 5076 // Prefer keeping `::` followed by `operator` together. 5077 EXPECT_EQ("const aaaa::bbbbbbb &\n" 5078 "ccccccccc::operator++() {\n" 5079 " stuff();\n" 5080 "}", 5081 format("const aaaa::bbbbbbb\n" 5082 "&ccccccccc::operator++() { stuff(); }", 5083 getLLVMStyleWithColumns(40))); 5084 } 5085 5086 TEST_F(FormatTest, TrailingReturnType) { 5087 verifyFormat("auto foo() -> int;\n"); 5088 // correct trailing return type spacing 5089 verifyFormat("auto operator->() -> int;\n"); 5090 verifyFormat("auto operator++(int) -> int;\n"); 5091 5092 verifyFormat("struct S {\n" 5093 " auto bar() const -> int;\n" 5094 "};"); 5095 verifyFormat("template <size_t Order, typename T>\n" 5096 "auto load_img(const std::string &filename)\n" 5097 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 5098 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 5099 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 5100 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 5101 verifyFormat("template <typename T>\n" 5102 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 5103 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 5104 5105 // Not trailing return types. 5106 verifyFormat("void f() { auto a = b->c(); }"); 5107 } 5108 5109 TEST_F(FormatTest, DeductionGuides) { 5110 verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;"); 5111 verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;"); 5112 verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;"); 5113 verifyFormat( 5114 "template <class... T>\n" 5115 "array(T &&... t) -> array<std::common_type_t<T...>, sizeof...(T)>;"); 5116 verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;"); 5117 verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;"); 5118 verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;"); 5119 verifyFormat("template <class T> A() -> A<(3 < 2)>;"); 5120 verifyFormat("template <class T> A() -> A<((3) < (2))>;"); 5121 verifyFormat("template <class T> x() -> x<1>;"); 5122 verifyFormat("template <class T> explicit x(T &) -> x<1>;"); 5123 5124 // Ensure not deduction guides. 5125 verifyFormat("c()->f<int>();"); 5126 verifyFormat("x()->foo<1>;"); 5127 verifyFormat("x = p->foo<3>();"); 5128 verifyFormat("x()->x<1>();"); 5129 verifyFormat("x()->x<1>;"); 5130 } 5131 5132 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 5133 // Avoid breaking before trailing 'const' or other trailing annotations, if 5134 // they are not function-like. 5135 FormatStyle Style = getGoogleStyle(); 5136 Style.ColumnLimit = 47; 5137 verifyFormat("void someLongFunction(\n" 5138 " int someLoooooooooooooongParameter) const {\n}", 5139 getLLVMStyleWithColumns(47)); 5140 verifyFormat("LoooooongReturnType\n" 5141 "someLoooooooongFunction() const {}", 5142 getLLVMStyleWithColumns(47)); 5143 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 5144 " const {}", 5145 Style); 5146 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5147 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 5148 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5149 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 5150 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5151 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 5152 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 5153 " aaaaaaaaaaa aaaaa) const override;"); 5154 verifyGoogleFormat( 5155 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5156 " const override;"); 5157 5158 // Even if the first parameter has to be wrapped. 5159 verifyFormat("void someLongFunction(\n" 5160 " int someLongParameter) const {}", 5161 getLLVMStyleWithColumns(46)); 5162 verifyFormat("void someLongFunction(\n" 5163 " int someLongParameter) const {}", 5164 Style); 5165 verifyFormat("void someLongFunction(\n" 5166 " int someLongParameter) override {}", 5167 Style); 5168 verifyFormat("void someLongFunction(\n" 5169 " int someLongParameter) OVERRIDE {}", 5170 Style); 5171 verifyFormat("void someLongFunction(\n" 5172 " int someLongParameter) final {}", 5173 Style); 5174 verifyFormat("void someLongFunction(\n" 5175 " int someLongParameter) FINAL {}", 5176 Style); 5177 verifyFormat("void someLongFunction(\n" 5178 " int parameter) const override {}", 5179 Style); 5180 5181 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 5182 verifyFormat("void someLongFunction(\n" 5183 " int someLongParameter) const\n" 5184 "{\n" 5185 "}", 5186 Style); 5187 5188 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 5189 verifyFormat("void someLongFunction(\n" 5190 " int someLongParameter) const\n" 5191 " {\n" 5192 " }", 5193 Style); 5194 5195 // Unless these are unknown annotations. 5196 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 5197 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5198 " LONG_AND_UGLY_ANNOTATION;"); 5199 5200 // Breaking before function-like trailing annotations is fine to keep them 5201 // close to their arguments. 5202 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5203 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5204 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5205 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5206 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5207 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 5208 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 5209 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 5210 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 5211 5212 verifyFormat( 5213 "void aaaaaaaaaaaaaaaaaa()\n" 5214 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 5215 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 5216 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5217 " __attribute__((unused));"); 5218 verifyGoogleFormat( 5219 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5220 " GUARDED_BY(aaaaaaaaaaaa);"); 5221 verifyGoogleFormat( 5222 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5223 " GUARDED_BY(aaaaaaaaaaaa);"); 5224 verifyGoogleFormat( 5225 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5226 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5227 verifyGoogleFormat( 5228 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5229 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5230 } 5231 5232 TEST_F(FormatTest, FunctionAnnotations) { 5233 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5234 "int OldFunction(const string ¶meter) {}"); 5235 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5236 "string OldFunction(const string ¶meter) {}"); 5237 verifyFormat("template <typename T>\n" 5238 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5239 "string OldFunction(const string ¶meter) {}"); 5240 5241 // Not function annotations. 5242 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5243 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 5244 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 5245 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 5246 verifyFormat("MACRO(abc).function() // wrap\n" 5247 " << abc;"); 5248 verifyFormat("MACRO(abc)->function() // wrap\n" 5249 " << abc;"); 5250 verifyFormat("MACRO(abc)::function() // wrap\n" 5251 " << abc;"); 5252 } 5253 5254 TEST_F(FormatTest, BreaksDesireably) { 5255 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5256 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5257 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 5258 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5259 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 5260 "}"); 5261 5262 verifyFormat( 5263 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5264 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 5265 5266 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5267 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5268 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5269 5270 verifyFormat( 5271 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5272 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5273 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5274 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5275 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 5276 5277 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5278 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5279 5280 verifyFormat( 5281 "void f() {\n" 5282 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 5283 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5284 "}"); 5285 verifyFormat( 5286 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5287 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5288 verifyFormat( 5289 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5290 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5291 verifyFormat( 5292 "aaaaaa(aaa,\n" 5293 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5294 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5295 " aaaa);"); 5296 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5297 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5298 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5299 5300 // Indent consistently independent of call expression and unary operator. 5301 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5302 " dddddddddddddddddddddddddddddd));"); 5303 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5304 " dddddddddddddddddddddddddddddd));"); 5305 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 5306 " dddddddddddddddddddddddddddddd));"); 5307 5308 // This test case breaks on an incorrect memoization, i.e. an optimization not 5309 // taking into account the StopAt value. 5310 verifyFormat( 5311 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5312 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5313 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5314 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5315 5316 verifyFormat("{\n {\n {\n" 5317 " Annotation.SpaceRequiredBefore =\n" 5318 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 5319 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 5320 " }\n }\n}"); 5321 5322 // Break on an outer level if there was a break on an inner level. 5323 EXPECT_EQ("f(g(h(a, // comment\n" 5324 " b, c),\n" 5325 " d, e),\n" 5326 " x, y);", 5327 format("f(g(h(a, // comment\n" 5328 " b, c), d, e), x, y);")); 5329 5330 // Prefer breaking similar line breaks. 5331 verifyFormat( 5332 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 5333 " NSTrackingMouseEnteredAndExited |\n" 5334 " NSTrackingActiveAlways;"); 5335 } 5336 5337 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 5338 FormatStyle NoBinPacking = getGoogleStyle(); 5339 NoBinPacking.BinPackParameters = false; 5340 NoBinPacking.BinPackArguments = true; 5341 verifyFormat("void f() {\n" 5342 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 5343 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5344 "}", 5345 NoBinPacking); 5346 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 5347 " int aaaaaaaaaaaaaaaaaaaa,\n" 5348 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5349 NoBinPacking); 5350 5351 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5352 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5353 " vector<int> bbbbbbbbbbbbbbb);", 5354 NoBinPacking); 5355 // FIXME: This behavior difference is probably not wanted. However, currently 5356 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 5357 // template arguments from BreakBeforeParameter being set because of the 5358 // one-per-line formatting. 5359 verifyFormat( 5360 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5361 " aaaaaaaaaa> aaaaaaaaaa);", 5362 NoBinPacking); 5363 verifyFormat( 5364 "void fffffffffff(\n" 5365 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 5366 " aaaaaaaaaa);"); 5367 } 5368 5369 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 5370 FormatStyle NoBinPacking = getGoogleStyle(); 5371 NoBinPacking.BinPackParameters = false; 5372 NoBinPacking.BinPackArguments = false; 5373 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 5374 " aaaaaaaaaaaaaaaaaaaa,\n" 5375 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 5376 NoBinPacking); 5377 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 5378 " aaaaaaaaaaaaa,\n" 5379 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 5380 NoBinPacking); 5381 verifyFormat( 5382 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5383 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5384 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5385 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5386 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 5387 NoBinPacking); 5388 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5389 " .aaaaaaaaaaaaaaaaaa();", 5390 NoBinPacking); 5391 verifyFormat("void f() {\n" 5392 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5393 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 5394 "}", 5395 NoBinPacking); 5396 5397 verifyFormat( 5398 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5399 " aaaaaaaaaaaa,\n" 5400 " aaaaaaaaaaaa);", 5401 NoBinPacking); 5402 verifyFormat( 5403 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 5404 " ddddddddddddddddddddddddddddd),\n" 5405 " test);", 5406 NoBinPacking); 5407 5408 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5409 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 5410 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 5411 " aaaaaaaaaaaaaaaaaa;", 5412 NoBinPacking); 5413 verifyFormat("a(\"a\"\n" 5414 " \"a\",\n" 5415 " a);"); 5416 5417 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5418 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 5419 " aaaaaaaaa,\n" 5420 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5421 NoBinPacking); 5422 verifyFormat( 5423 "void f() {\n" 5424 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5425 " .aaaaaaa();\n" 5426 "}", 5427 NoBinPacking); 5428 verifyFormat( 5429 "template <class SomeType, class SomeOtherType>\n" 5430 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 5431 NoBinPacking); 5432 } 5433 5434 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 5435 FormatStyle Style = getLLVMStyleWithColumns(15); 5436 Style.ExperimentalAutoDetectBinPacking = true; 5437 EXPECT_EQ("aaa(aaaa,\n" 5438 " aaaa,\n" 5439 " aaaa);\n" 5440 "aaa(aaaa,\n" 5441 " aaaa,\n" 5442 " aaaa);", 5443 format("aaa(aaaa,\n" // one-per-line 5444 " aaaa,\n" 5445 " aaaa );\n" 5446 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5447 Style)); 5448 EXPECT_EQ("aaa(aaaa, aaaa,\n" 5449 " aaaa);\n" 5450 "aaa(aaaa, aaaa,\n" 5451 " aaaa);", 5452 format("aaa(aaaa, aaaa,\n" // bin-packed 5453 " aaaa );\n" 5454 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5455 Style)); 5456 } 5457 5458 TEST_F(FormatTest, FormatsBuilderPattern) { 5459 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 5460 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 5461 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 5462 " .StartsWith(\".init\", ORDER_INIT)\n" 5463 " .StartsWith(\".fini\", ORDER_FINI)\n" 5464 " .StartsWith(\".hash\", ORDER_HASH)\n" 5465 " .Default(ORDER_TEXT);\n"); 5466 5467 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 5468 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 5469 verifyFormat("aaaaaaa->aaaaaaa\n" 5470 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5471 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5472 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5473 verifyFormat( 5474 "aaaaaaa->aaaaaaa\n" 5475 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5476 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5477 verifyFormat( 5478 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 5479 " aaaaaaaaaaaaaa);"); 5480 verifyFormat( 5481 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 5482 " aaaaaa->aaaaaaaaaaaa()\n" 5483 " ->aaaaaaaaaaaaaaaa(\n" 5484 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5485 " ->aaaaaaaaaaaaaaaaa();"); 5486 verifyGoogleFormat( 5487 "void f() {\n" 5488 " someo->Add((new util::filetools::Handler(dir))\n" 5489 " ->OnEvent1(NewPermanentCallback(\n" 5490 " this, &HandlerHolderClass::EventHandlerCBA))\n" 5491 " ->OnEvent2(NewPermanentCallback(\n" 5492 " this, &HandlerHolderClass::EventHandlerCBB))\n" 5493 " ->OnEvent3(NewPermanentCallback(\n" 5494 " this, &HandlerHolderClass::EventHandlerCBC))\n" 5495 " ->OnEvent5(NewPermanentCallback(\n" 5496 " this, &HandlerHolderClass::EventHandlerCBD))\n" 5497 " ->OnEvent6(NewPermanentCallback(\n" 5498 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 5499 "}"); 5500 5501 verifyFormat( 5502 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 5503 verifyFormat("aaaaaaaaaaaaaaa()\n" 5504 " .aaaaaaaaaaaaaaa()\n" 5505 " .aaaaaaaaaaaaaaa()\n" 5506 " .aaaaaaaaaaaaaaa()\n" 5507 " .aaaaaaaaaaaaaaa();"); 5508 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5509 " .aaaaaaaaaaaaaaa()\n" 5510 " .aaaaaaaaaaaaaaa()\n" 5511 " .aaaaaaaaaaaaaaa();"); 5512 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5513 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5514 " .aaaaaaaaaaaaaaa();"); 5515 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 5516 " ->aaaaaaaaaaaaaae(0)\n" 5517 " ->aaaaaaaaaaaaaaa();"); 5518 5519 // Don't linewrap after very short segments. 5520 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5521 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5522 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5523 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5524 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5525 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5526 verifyFormat("aaa()\n" 5527 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5528 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5529 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5530 5531 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5532 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5533 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 5534 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5535 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 5536 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 5537 5538 // Prefer not to break after empty parentheses. 5539 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 5540 " First->LastNewlineOffset);"); 5541 5542 // Prefer not to create "hanging" indents. 5543 verifyFormat( 5544 "return !soooooooooooooome_map\n" 5545 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5546 " .second;"); 5547 verifyFormat( 5548 "return aaaaaaaaaaaaaaaa\n" 5549 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 5550 " .aaaa(aaaaaaaaaaaaaa);"); 5551 // No hanging indent here. 5552 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5553 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5554 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5555 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5556 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5557 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5558 getLLVMStyleWithColumns(60)); 5559 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5560 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5561 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5562 getLLVMStyleWithColumns(59)); 5563 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5564 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5565 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5566 5567 // Dont break if only closing statements before member call 5568 verifyFormat("test() {\n" 5569 " ([]() -> {\n" 5570 " int b = 32;\n" 5571 " return 3;\n" 5572 " }).foo();\n" 5573 "}"); 5574 verifyFormat("test() {\n" 5575 " (\n" 5576 " []() -> {\n" 5577 " int b = 32;\n" 5578 " return 3;\n" 5579 " },\n" 5580 " foo, bar)\n" 5581 " .foo();\n" 5582 "}"); 5583 verifyFormat("test() {\n" 5584 " ([]() -> {\n" 5585 " int b = 32;\n" 5586 " return 3;\n" 5587 " })\n" 5588 " .foo()\n" 5589 " .bar();\n" 5590 "}"); 5591 verifyFormat("test() {\n" 5592 " ([]() -> {\n" 5593 " int b = 32;\n" 5594 " return 3;\n" 5595 " })\n" 5596 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5597 " \"bbbb\");\n" 5598 "}", 5599 getLLVMStyleWithColumns(30)); 5600 } 5601 5602 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5603 verifyFormat( 5604 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5605 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5606 verifyFormat( 5607 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5608 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5609 5610 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5611 " ccccccccccccccccccccccccc) {\n}"); 5612 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5613 " ccccccccccccccccccccccccc) {\n}"); 5614 5615 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5616 " ccccccccccccccccccccccccc) {\n}"); 5617 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5618 " ccccccccccccccccccccccccc) {\n}"); 5619 5620 verifyFormat( 5621 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5622 " ccccccccccccccccccccccccc) {\n}"); 5623 verifyFormat( 5624 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5625 " ccccccccccccccccccccccccc) {\n}"); 5626 5627 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5628 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5629 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5630 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5631 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5632 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5633 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5634 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5635 5636 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5637 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5638 " aaaaaaaaaaaaaaa != aa) {\n}"); 5639 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5640 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5641 " aaaaaaaaaaaaaaa != aa) {\n}"); 5642 } 5643 5644 TEST_F(FormatTest, BreaksAfterAssignments) { 5645 verifyFormat( 5646 "unsigned Cost =\n" 5647 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5648 " SI->getPointerAddressSpaceee());\n"); 5649 verifyFormat( 5650 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5651 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5652 5653 verifyFormat( 5654 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5655 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5656 verifyFormat("unsigned OriginalStartColumn =\n" 5657 " SourceMgr.getSpellingColumnNumber(\n" 5658 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5659 " 1;"); 5660 } 5661 5662 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5663 FormatStyle Style = getLLVMStyle(); 5664 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5665 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5666 Style); 5667 5668 Style.PenaltyBreakAssignment = 20; 5669 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5670 " cccccccccccccccccccccccccc;", 5671 Style); 5672 } 5673 5674 TEST_F(FormatTest, AlignsAfterAssignments) { 5675 verifyFormat( 5676 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5677 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5678 verifyFormat( 5679 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5680 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5681 verifyFormat( 5682 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5683 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5684 verifyFormat( 5685 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5686 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5687 verifyFormat( 5688 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5689 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5690 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5691 } 5692 5693 TEST_F(FormatTest, AlignsAfterReturn) { 5694 verifyFormat( 5695 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5696 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5697 verifyFormat( 5698 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5699 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5700 verifyFormat( 5701 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5702 " aaaaaaaaaaaaaaaaaaaaaa();"); 5703 verifyFormat( 5704 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5705 " aaaaaaaaaaaaaaaaaaaaaa());"); 5706 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5707 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5708 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5709 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5710 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5711 verifyFormat("return\n" 5712 " // true if code is one of a or b.\n" 5713 " code == a || code == b;"); 5714 } 5715 5716 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5717 verifyFormat( 5718 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5719 " aaaaaaaaa aaaaaaa) {}"); 5720 verifyFormat( 5721 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5722 " aaaaaaaaaaa aaaaaaaaa);"); 5723 verifyFormat( 5724 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5725 " aaaaaaaaaaaaaaaaaaaaa));"); 5726 FormatStyle Style = getLLVMStyle(); 5727 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5728 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5729 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5730 Style); 5731 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5732 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5733 Style); 5734 verifyFormat("SomeLongVariableName->someFunction(\n" 5735 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5736 Style); 5737 verifyFormat( 5738 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5739 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5740 Style); 5741 verifyFormat( 5742 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5743 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5744 Style); 5745 verifyFormat( 5746 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5747 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5748 Style); 5749 5750 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5751 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5752 " b));", 5753 Style); 5754 5755 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5756 Style.BinPackArguments = false; 5757 Style.BinPackParameters = false; 5758 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5759 " aaaaaaaaaaa aaaaaaaa,\n" 5760 " aaaaaaaaa aaaaaaa,\n" 5761 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5762 Style); 5763 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5764 " aaaaaaaaaaa aaaaaaaaa,\n" 5765 " aaaaaaaaaaa aaaaaaaaa,\n" 5766 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5767 Style); 5768 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5769 " aaaaaaaaaaaaaaa,\n" 5770 " aaaaaaaaaaaaaaaaaaaaa,\n" 5771 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5772 Style); 5773 verifyFormat( 5774 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5775 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5776 Style); 5777 verifyFormat( 5778 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5779 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5780 Style); 5781 verifyFormat( 5782 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5783 " aaaaaaaaaaaaaaaaaaaaa(\n" 5784 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5785 " aaaaaaaaaaaaaaaa);", 5786 Style); 5787 verifyFormat( 5788 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5789 " aaaaaaaaaaaaaaaaaaaaa(\n" 5790 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5791 " aaaaaaaaaaaaaaaa);", 5792 Style); 5793 } 5794 5795 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5796 FormatStyle Style = getLLVMStyleWithColumns(40); 5797 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5798 " bbbbbbbbbbbbbbbbbbbbbb);", 5799 Style); 5800 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5801 Style.AlignOperands = false; 5802 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5803 " bbbbbbbbbbbbbbbbbbbbbb);", 5804 Style); 5805 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5806 Style.AlignOperands = true; 5807 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5808 " bbbbbbbbbbbbbbbbbbbbbb);", 5809 Style); 5810 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5811 Style.AlignOperands = false; 5812 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5813 " bbbbbbbbbbbbbbbbbbbbbb);", 5814 Style); 5815 } 5816 5817 TEST_F(FormatTest, BreaksConditionalExpressions) { 5818 verifyFormat( 5819 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5820 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5821 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5822 verifyFormat( 5823 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5824 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5825 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5826 verifyFormat( 5827 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5828 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5829 verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5830 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5831 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5832 verifyFormat( 5833 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5834 " : aaaaaaaaaaaaa);"); 5835 verifyFormat( 5836 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5837 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5838 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5839 " aaaaaaaaaaaaa);"); 5840 verifyFormat( 5841 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5842 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5843 " aaaaaaaaaaaaa);"); 5844 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5845 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5846 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5847 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5848 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5849 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5850 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5851 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5852 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5853 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5854 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5855 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5856 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5857 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5858 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5859 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5860 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5861 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5862 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5863 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5864 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5865 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5866 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5867 " : aaaaaaaaaaaaaaaa;"); 5868 verifyFormat( 5869 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5870 " ? aaaaaaaaaaaaaaa\n" 5871 " : aaaaaaaaaaaaaaa;"); 5872 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5873 " aaaaaaaaa\n" 5874 " ? b\n" 5875 " : c);"); 5876 verifyFormat("return aaaa == bbbb\n" 5877 " // comment\n" 5878 " ? aaaa\n" 5879 " : bbbb;"); 5880 verifyFormat("unsigned Indent =\n" 5881 " format(TheLine.First,\n" 5882 " IndentForLevel[TheLine.Level] >= 0\n" 5883 " ? IndentForLevel[TheLine.Level]\n" 5884 " : TheLine * 2,\n" 5885 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5886 getLLVMStyleWithColumns(60)); 5887 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5888 " ? aaaaaaaaaaaaaaa\n" 5889 " : bbbbbbbbbbbbbbb //\n" 5890 " ? ccccccccccccccc\n" 5891 " : ddddddddddddddd;"); 5892 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5893 " ? aaaaaaaaaaaaaaa\n" 5894 " : (bbbbbbbbbbbbbbb //\n" 5895 " ? ccccccccccccccc\n" 5896 " : ddddddddddddddd);"); 5897 verifyFormat( 5898 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5899 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5900 " aaaaaaaaaaaaaaaaaaaaa +\n" 5901 " aaaaaaaaaaaaaaaaaaaaa\n" 5902 " : aaaaaaaaaa;"); 5903 verifyFormat( 5904 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5905 " : aaaaaaaaaaaaaaaaaaaaaa\n" 5906 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5907 5908 FormatStyle NoBinPacking = getLLVMStyle(); 5909 NoBinPacking.BinPackArguments = false; 5910 verifyFormat( 5911 "void f() {\n" 5912 " g(aaa,\n" 5913 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5914 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5915 " ? aaaaaaaaaaaaaaa\n" 5916 " : aaaaaaaaaaaaaaa);\n" 5917 "}", 5918 NoBinPacking); 5919 verifyFormat( 5920 "void f() {\n" 5921 " g(aaa,\n" 5922 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5923 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5924 " ?: aaaaaaaaaaaaaaa);\n" 5925 "}", 5926 NoBinPacking); 5927 5928 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 5929 " // comment.\n" 5930 " ccccccccccccccccccccccccccccccccccccccc\n" 5931 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5932 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 5933 5934 // Assignments in conditional expressions. Apparently not uncommon :-(. 5935 verifyFormat("return a != b\n" 5936 " // comment\n" 5937 " ? a = b\n" 5938 " : a = b;"); 5939 verifyFormat("return a != b\n" 5940 " // comment\n" 5941 " ? a = a != b\n" 5942 " // comment\n" 5943 " ? a = b\n" 5944 " : a\n" 5945 " : a;\n"); 5946 verifyFormat("return a != b\n" 5947 " // comment\n" 5948 " ? a\n" 5949 " : a = a != b\n" 5950 " // comment\n" 5951 " ? a = b\n" 5952 " : a;"); 5953 } 5954 5955 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 5956 FormatStyle Style = getLLVMStyle(); 5957 Style.BreakBeforeTernaryOperators = false; 5958 Style.ColumnLimit = 70; 5959 verifyFormat( 5960 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5961 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5962 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5963 Style); 5964 verifyFormat( 5965 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5966 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5967 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5968 Style); 5969 verifyFormat( 5970 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5971 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5972 Style); 5973 verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n" 5974 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5975 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5976 Style); 5977 verifyFormat( 5978 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 5979 " aaaaaaaaaaaaa);", 5980 Style); 5981 verifyFormat( 5982 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5983 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5984 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5985 " aaaaaaaaaaaaa);", 5986 Style); 5987 verifyFormat( 5988 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5989 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5990 " aaaaaaaaaaaaa);", 5991 Style); 5992 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5993 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5994 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5995 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5996 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5997 Style); 5998 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5999 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6000 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6001 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 6002 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6003 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 6004 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6005 Style); 6006 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6007 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 6008 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6009 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 6010 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6011 Style); 6012 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6013 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6014 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6015 Style); 6016 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 6017 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6018 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6019 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6020 Style); 6021 verifyFormat( 6022 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6023 " aaaaaaaaaaaaaaa :\n" 6024 " aaaaaaaaaaaaaaa;", 6025 Style); 6026 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 6027 " aaaaaaaaa ?\n" 6028 " b :\n" 6029 " c);", 6030 Style); 6031 verifyFormat("unsigned Indent =\n" 6032 " format(TheLine.First,\n" 6033 " IndentForLevel[TheLine.Level] >= 0 ?\n" 6034 " IndentForLevel[TheLine.Level] :\n" 6035 " TheLine * 2,\n" 6036 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 6037 Style); 6038 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 6039 " aaaaaaaaaaaaaaa :\n" 6040 " bbbbbbbbbbbbbbb ? //\n" 6041 " ccccccccccccccc :\n" 6042 " ddddddddddddddd;", 6043 Style); 6044 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 6045 " aaaaaaaaaaaaaaa :\n" 6046 " (bbbbbbbbbbbbbbb ? //\n" 6047 " ccccccccccccccc :\n" 6048 " ddddddddddddddd);", 6049 Style); 6050 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6051 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 6052 " ccccccccccccccccccccccccccc;", 6053 Style); 6054 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6055 " aaaaa :\n" 6056 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 6057 Style); 6058 } 6059 6060 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 6061 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 6062 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 6063 verifyFormat("bool a = true, b = false;"); 6064 6065 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6066 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 6067 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 6068 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 6069 verifyFormat( 6070 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 6071 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 6072 " d = e && f;"); 6073 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 6074 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 6075 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 6076 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 6077 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 6078 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 6079 6080 FormatStyle Style = getGoogleStyle(); 6081 Style.PointerAlignment = FormatStyle::PAS_Left; 6082 Style.DerivePointerAlignment = false; 6083 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6084 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 6085 " *b = bbbbbbbbbbbbbbbbbbb;", 6086 Style); 6087 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 6088 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 6089 Style); 6090 verifyFormat("vector<int*> a, b;", Style); 6091 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 6092 } 6093 6094 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 6095 verifyFormat("arr[foo ? bar : baz];"); 6096 verifyFormat("f()[foo ? bar : baz];"); 6097 verifyFormat("(a + b)[foo ? bar : baz];"); 6098 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 6099 } 6100 6101 TEST_F(FormatTest, AlignsStringLiterals) { 6102 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 6103 " \"short literal\");"); 6104 verifyFormat( 6105 "looooooooooooooooooooooooongFunction(\n" 6106 " \"short literal\"\n" 6107 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 6108 verifyFormat("someFunction(\"Always break between multi-line\"\n" 6109 " \" string literals\",\n" 6110 " and, other, parameters);"); 6111 EXPECT_EQ("fun + \"1243\" /* comment */\n" 6112 " \"5678\";", 6113 format("fun + \"1243\" /* comment */\n" 6114 " \"5678\";", 6115 getLLVMStyleWithColumns(28))); 6116 EXPECT_EQ( 6117 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 6118 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 6119 " \"aaaaaaaaaaaaaaaa\";", 6120 format("aaaaaa =" 6121 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 6122 "aaaaaaaaaaaaaaaaaaaaa\" " 6123 "\"aaaaaaaaaaaaaaaa\";")); 6124 verifyFormat("a = a + \"a\"\n" 6125 " \"a\"\n" 6126 " \"a\";"); 6127 verifyFormat("f(\"a\", \"b\"\n" 6128 " \"c\");"); 6129 6130 verifyFormat( 6131 "#define LL_FORMAT \"ll\"\n" 6132 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 6133 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 6134 6135 verifyFormat("#define A(X) \\\n" 6136 " \"aaaaa\" #X \"bbbbbb\" \\\n" 6137 " \"ccccc\"", 6138 getLLVMStyleWithColumns(23)); 6139 verifyFormat("#define A \"def\"\n" 6140 "f(\"abc\" A \"ghi\"\n" 6141 " \"jkl\");"); 6142 6143 verifyFormat("f(L\"a\"\n" 6144 " L\"b\");"); 6145 verifyFormat("#define A(X) \\\n" 6146 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 6147 " L\"ccccc\"", 6148 getLLVMStyleWithColumns(25)); 6149 6150 verifyFormat("f(@\"a\"\n" 6151 " @\"b\");"); 6152 verifyFormat("NSString s = @\"a\"\n" 6153 " @\"b\"\n" 6154 " @\"c\";"); 6155 verifyFormat("NSString s = @\"a\"\n" 6156 " \"b\"\n" 6157 " \"c\";"); 6158 } 6159 6160 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 6161 FormatStyle Style = getLLVMStyle(); 6162 // No declarations or definitions should be moved to own line. 6163 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 6164 verifyFormat("class A {\n" 6165 " int f() { return 1; }\n" 6166 " int g();\n" 6167 "};\n" 6168 "int f() { return 1; }\n" 6169 "int g();\n", 6170 Style); 6171 6172 // All declarations and definitions should have the return type moved to its 6173 // own 6174 // line. 6175 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 6176 verifyFormat("class E {\n" 6177 " int\n" 6178 " f() {\n" 6179 " return 1;\n" 6180 " }\n" 6181 " int\n" 6182 " g();\n" 6183 "};\n" 6184 "int\n" 6185 "f() {\n" 6186 " return 1;\n" 6187 "}\n" 6188 "int\n" 6189 "g();\n", 6190 Style); 6191 6192 // Top-level definitions, and no kinds of declarations should have the 6193 // return type moved to its own line. 6194 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 6195 verifyFormat("class B {\n" 6196 " int f() { return 1; }\n" 6197 " int g();\n" 6198 "};\n" 6199 "int\n" 6200 "f() {\n" 6201 " return 1;\n" 6202 "}\n" 6203 "int g();\n", 6204 Style); 6205 6206 // Top-level definitions and declarations should have the return type moved 6207 // to its own line. 6208 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 6209 verifyFormat("class C {\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\n" 6218 "g();\n", 6219 Style); 6220 6221 // All definitions should have the return type moved to its own line, but no 6222 // kinds of declarations. 6223 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 6224 verifyFormat("class D {\n" 6225 " int\n" 6226 " f() {\n" 6227 " return 1;\n" 6228 " }\n" 6229 " int g();\n" 6230 "};\n" 6231 "int\n" 6232 "f() {\n" 6233 " return 1;\n" 6234 "}\n" 6235 "int g();\n", 6236 Style); 6237 verifyFormat("const char *\n" 6238 "f(void) {\n" // Break here. 6239 " return \"\";\n" 6240 "}\n" 6241 "const char *bar(void);\n", // No break here. 6242 Style); 6243 verifyFormat("template <class T>\n" 6244 "T *\n" 6245 "f(T &c) {\n" // Break here. 6246 " return NULL;\n" 6247 "}\n" 6248 "template <class T> T *f(T &c);\n", // No break here. 6249 Style); 6250 verifyFormat("class C {\n" 6251 " int\n" 6252 " operator+() {\n" 6253 " return 1;\n" 6254 " }\n" 6255 " int\n" 6256 " operator()() {\n" 6257 " return 1;\n" 6258 " }\n" 6259 "};\n", 6260 Style); 6261 verifyFormat("void\n" 6262 "A::operator()() {}\n" 6263 "void\n" 6264 "A::operator>>() {}\n" 6265 "void\n" 6266 "A::operator+() {}\n" 6267 "void\n" 6268 "A::operator*() {}\n" 6269 "void\n" 6270 "A::operator->() {}\n" 6271 "void\n" 6272 "A::operator void *() {}\n" 6273 "void\n" 6274 "A::operator void &() {}\n" 6275 "void\n" 6276 "A::operator void &&() {}\n" 6277 "void\n" 6278 "A::operator char *() {}\n" 6279 "void\n" 6280 "A::operator[]() {}\n" 6281 "void\n" 6282 "A::operator!() {}\n", 6283 Style); 6284 verifyFormat("constexpr auto\n" 6285 "operator()() const -> reference {}\n" 6286 "constexpr auto\n" 6287 "operator>>() const -> reference {}\n" 6288 "constexpr auto\n" 6289 "operator+() const -> reference {}\n" 6290 "constexpr auto\n" 6291 "operator*() const -> reference {}\n" 6292 "constexpr auto\n" 6293 "operator->() const -> reference {}\n" 6294 "constexpr auto\n" 6295 "operator++() const -> reference {}\n" 6296 "constexpr auto\n" 6297 "operator void *() const -> reference {}\n" 6298 "constexpr auto\n" 6299 "operator void &() const -> reference {}\n" 6300 "constexpr auto\n" 6301 "operator void &&() const -> reference {}\n" 6302 "constexpr auto\n" 6303 "operator char *() const -> reference {}\n" 6304 "constexpr auto\n" 6305 "operator!() const -> reference {}\n" 6306 "constexpr auto\n" 6307 "operator[]() const -> reference {}\n", 6308 Style); 6309 verifyFormat("void *operator new(std::size_t s);", // No break here. 6310 Style); 6311 verifyFormat("void *\n" 6312 "operator new(std::size_t s) {}", 6313 Style); 6314 verifyFormat("void *\n" 6315 "operator delete[](void *ptr) {}", 6316 Style); 6317 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 6318 verifyFormat("const char *\n" 6319 "f(void)\n" // Break here. 6320 "{\n" 6321 " return \"\";\n" 6322 "}\n" 6323 "const char *bar(void);\n", // No break here. 6324 Style); 6325 verifyFormat("template <class T>\n" 6326 "T *\n" // Problem here: no line break 6327 "f(T &c)\n" // Break here. 6328 "{\n" 6329 " return NULL;\n" 6330 "}\n" 6331 "template <class T> T *f(T &c);\n", // No break here. 6332 Style); 6333 verifyFormat("int\n" 6334 "foo(A<bool> a)\n" 6335 "{\n" 6336 " return a;\n" 6337 "}\n", 6338 Style); 6339 verifyFormat("int\n" 6340 "foo(A<8> a)\n" 6341 "{\n" 6342 " return a;\n" 6343 "}\n", 6344 Style); 6345 verifyFormat("int\n" 6346 "foo(A<B<bool>, 8> a)\n" 6347 "{\n" 6348 " return a;\n" 6349 "}\n", 6350 Style); 6351 verifyFormat("int\n" 6352 "foo(A<B<8>, bool> a)\n" 6353 "{\n" 6354 " return a;\n" 6355 "}\n", 6356 Style); 6357 verifyFormat("int\n" 6358 "foo(A<B<bool>, bool> a)\n" 6359 "{\n" 6360 " return a;\n" 6361 "}\n", 6362 Style); 6363 verifyFormat("int\n" 6364 "foo(A<B<8>, 8> a)\n" 6365 "{\n" 6366 " return a;\n" 6367 "}\n", 6368 Style); 6369 6370 Style = getGNUStyle(); 6371 6372 // Test for comments at the end of function declarations. 6373 verifyFormat("void\n" 6374 "foo (int a, /*abc*/ int b) // def\n" 6375 "{\n" 6376 "}\n", 6377 Style); 6378 6379 verifyFormat("void\n" 6380 "foo (int a, /* abc */ int b) /* def */\n" 6381 "{\n" 6382 "}\n", 6383 Style); 6384 6385 // Definitions that should not break after return type 6386 verifyFormat("void foo (int a, int b); // def\n", Style); 6387 verifyFormat("void foo (int a, int b); /* def */\n", Style); 6388 verifyFormat("void foo (int a, int b);\n", Style); 6389 } 6390 6391 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 6392 FormatStyle NoBreak = getLLVMStyle(); 6393 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 6394 FormatStyle Break = getLLVMStyle(); 6395 Break.AlwaysBreakBeforeMultilineStrings = true; 6396 verifyFormat("aaaa = \"bbbb\"\n" 6397 " \"cccc\";", 6398 NoBreak); 6399 verifyFormat("aaaa =\n" 6400 " \"bbbb\"\n" 6401 " \"cccc\";", 6402 Break); 6403 verifyFormat("aaaa(\"bbbb\"\n" 6404 " \"cccc\");", 6405 NoBreak); 6406 verifyFormat("aaaa(\n" 6407 " \"bbbb\"\n" 6408 " \"cccc\");", 6409 Break); 6410 verifyFormat("aaaa(qqq, \"bbbb\"\n" 6411 " \"cccc\");", 6412 NoBreak); 6413 verifyFormat("aaaa(qqq,\n" 6414 " \"bbbb\"\n" 6415 " \"cccc\");", 6416 Break); 6417 verifyFormat("aaaa(qqq,\n" 6418 " L\"bbbb\"\n" 6419 " L\"cccc\");", 6420 Break); 6421 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 6422 " \"bbbb\"));", 6423 Break); 6424 verifyFormat("string s = someFunction(\n" 6425 " \"abc\"\n" 6426 " \"abc\");", 6427 Break); 6428 6429 // As we break before unary operators, breaking right after them is bad. 6430 verifyFormat("string foo = abc ? \"x\"\n" 6431 " \"blah blah blah blah blah blah\"\n" 6432 " : \"y\";", 6433 Break); 6434 6435 // Don't break if there is no column gain. 6436 verifyFormat("f(\"aaaa\"\n" 6437 " \"bbbb\");", 6438 Break); 6439 6440 // Treat literals with escaped newlines like multi-line string literals. 6441 EXPECT_EQ("x = \"a\\\n" 6442 "b\\\n" 6443 "c\";", 6444 format("x = \"a\\\n" 6445 "b\\\n" 6446 "c\";", 6447 NoBreak)); 6448 EXPECT_EQ("xxxx =\n" 6449 " \"a\\\n" 6450 "b\\\n" 6451 "c\";", 6452 format("xxxx = \"a\\\n" 6453 "b\\\n" 6454 "c\";", 6455 Break)); 6456 6457 EXPECT_EQ("NSString *const kString =\n" 6458 " @\"aaaa\"\n" 6459 " @\"bbbb\";", 6460 format("NSString *const kString = @\"aaaa\"\n" 6461 "@\"bbbb\";", 6462 Break)); 6463 6464 Break.ColumnLimit = 0; 6465 verifyFormat("const char *hello = \"hello llvm\";", Break); 6466 } 6467 6468 TEST_F(FormatTest, AlignsPipes) { 6469 verifyFormat( 6470 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6471 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6472 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6473 verifyFormat( 6474 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 6475 " << aaaaaaaaaaaaaaaaaaaa;"); 6476 verifyFormat( 6477 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6478 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6479 verifyFormat( 6480 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 6481 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6482 verifyFormat( 6483 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 6484 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 6485 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 6486 verifyFormat( 6487 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6488 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6489 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6490 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6491 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6492 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6493 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6494 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 6495 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 6496 verifyFormat( 6497 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6498 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6499 verifyFormat( 6500 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 6501 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6502 6503 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 6504 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 6505 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6506 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6507 " aaaaaaaaaaaaaaaaaaaaa)\n" 6508 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6509 verifyFormat("LOG_IF(aaa == //\n" 6510 " bbb)\n" 6511 " << a << b;"); 6512 6513 // But sometimes, breaking before the first "<<" is desirable. 6514 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6515 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 6516 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 6517 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6518 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6519 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 6520 " << BEF << IsTemplate << Description << E->getType();"); 6521 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6522 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6523 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6524 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6525 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6526 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6527 " << aaa;"); 6528 6529 verifyFormat( 6530 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6531 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6532 6533 // Incomplete string literal. 6534 EXPECT_EQ("llvm::errs() << \"\n" 6535 " << a;", 6536 format("llvm::errs() << \"\n<<a;")); 6537 6538 verifyFormat("void f() {\n" 6539 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 6540 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 6541 "}"); 6542 6543 // Handle 'endl'. 6544 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 6545 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6546 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6547 6548 // Handle '\n'. 6549 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 6550 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6551 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 6552 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 6553 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 6554 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 6555 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6556 } 6557 6558 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 6559 verifyFormat("return out << \"somepacket = {\\n\"\n" 6560 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 6561 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 6562 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 6563 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 6564 " << \"}\";"); 6565 6566 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6567 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6568 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 6569 verifyFormat( 6570 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 6571 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 6572 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 6573 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 6574 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 6575 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 6576 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6577 verifyFormat( 6578 "void f() {\n" 6579 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 6580 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 6581 "}"); 6582 6583 // Breaking before the first "<<" is generally not desirable. 6584 verifyFormat( 6585 "llvm::errs()\n" 6586 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6587 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6588 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6589 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6590 getLLVMStyleWithColumns(70)); 6591 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6592 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6593 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6594 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6595 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6596 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6597 getLLVMStyleWithColumns(70)); 6598 6599 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6600 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6601 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6602 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6603 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6604 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 6605 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 6606 " (aaaa + aaaa);", 6607 getLLVMStyleWithColumns(40)); 6608 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 6609 " (aaaaaaa + aaaaa));", 6610 getLLVMStyleWithColumns(40)); 6611 verifyFormat( 6612 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 6613 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 6614 " bbbbbbbbbbbbbbbbbbbbbbb);"); 6615 } 6616 6617 TEST_F(FormatTest, UnderstandsEquals) { 6618 verifyFormat( 6619 "aaaaaaaaaaaaaaaaa =\n" 6620 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6621 verifyFormat( 6622 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6623 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6624 verifyFormat( 6625 "if (a) {\n" 6626 " f();\n" 6627 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6628 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 6629 "}"); 6630 6631 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6632 " 100000000 + 10000000) {\n}"); 6633 } 6634 6635 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 6636 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6637 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 6638 6639 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6640 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 6641 6642 verifyFormat( 6643 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 6644 " Parameter2);"); 6645 6646 verifyFormat( 6647 "ShortObject->shortFunction(\n" 6648 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 6649 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 6650 6651 verifyFormat("loooooooooooooongFunction(\n" 6652 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 6653 6654 verifyFormat( 6655 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 6656 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 6657 6658 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6659 " .WillRepeatedly(Return(SomeValue));"); 6660 verifyFormat("void f() {\n" 6661 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6662 " .Times(2)\n" 6663 " .WillRepeatedly(Return(SomeValue));\n" 6664 "}"); 6665 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 6666 " ccccccccccccccccccccccc);"); 6667 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6668 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6669 " .aaaaa(aaaaa),\n" 6670 " aaaaaaaaaaaaaaaaaaaaa);"); 6671 verifyFormat("void f() {\n" 6672 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6673 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 6674 "}"); 6675 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6676 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6677 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6678 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6679 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6680 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6681 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6682 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6683 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 6684 "}"); 6685 6686 // Here, it is not necessary to wrap at "." or "->". 6687 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 6688 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6689 verifyFormat( 6690 "aaaaaaaaaaa->aaaaaaaaa(\n" 6691 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6692 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 6693 6694 verifyFormat( 6695 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6696 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 6697 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 6698 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6699 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 6700 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6701 6702 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6703 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6704 " .a();"); 6705 6706 FormatStyle NoBinPacking = getLLVMStyle(); 6707 NoBinPacking.BinPackParameters = false; 6708 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6709 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6710 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 6711 " aaaaaaaaaaaaaaaaaaa,\n" 6712 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6713 NoBinPacking); 6714 6715 // If there is a subsequent call, change to hanging indentation. 6716 verifyFormat( 6717 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6718 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 6719 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6720 verifyFormat( 6721 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6722 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 6723 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6724 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6725 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6726 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6727 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6728 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6729 } 6730 6731 TEST_F(FormatTest, WrapsTemplateDeclarations) { 6732 verifyFormat("template <typename T>\n" 6733 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6734 verifyFormat("template <typename T>\n" 6735 "// T should be one of {A, B}.\n" 6736 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6737 verifyFormat( 6738 "template <typename T>\n" 6739 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 6740 verifyFormat("template <typename T>\n" 6741 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 6742 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 6743 verifyFormat( 6744 "template <typename T>\n" 6745 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 6746 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 6747 verifyFormat( 6748 "template <typename T>\n" 6749 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 6750 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 6751 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6752 verifyFormat("template <typename T>\n" 6753 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6754 " int aaaaaaaaaaaaaaaaaaaaaa);"); 6755 verifyFormat( 6756 "template <typename T1, typename T2 = char, typename T3 = char,\n" 6757 " typename T4 = char>\n" 6758 "void f();"); 6759 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 6760 " template <typename> class cccccccccccccccccccccc,\n" 6761 " typename ddddddddddddd>\n" 6762 "class C {};"); 6763 verifyFormat( 6764 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 6765 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6766 6767 verifyFormat("void f() {\n" 6768 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 6769 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 6770 "}"); 6771 6772 verifyFormat("template <typename T> class C {};"); 6773 verifyFormat("template <typename T> void f();"); 6774 verifyFormat("template <typename T> void f() {}"); 6775 verifyFormat( 6776 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6777 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6778 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 6779 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6780 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6781 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 6782 " bbbbbbbbbbbbbbbbbbbbbbbb);", 6783 getLLVMStyleWithColumns(72)); 6784 EXPECT_EQ("static_cast<A< //\n" 6785 " B> *>(\n" 6786 "\n" 6787 ");", 6788 format("static_cast<A<//\n" 6789 " B>*>(\n" 6790 "\n" 6791 " );")); 6792 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6793 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 6794 6795 FormatStyle AlwaysBreak = getLLVMStyle(); 6796 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 6797 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 6798 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 6799 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 6800 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6801 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6802 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 6803 verifyFormat("template <template <typename> class Fooooooo,\n" 6804 " template <typename> class Baaaaaaar>\n" 6805 "struct C {};", 6806 AlwaysBreak); 6807 verifyFormat("template <typename T> // T can be A, B or C.\n" 6808 "struct C {};", 6809 AlwaysBreak); 6810 verifyFormat("template <enum E> class A {\n" 6811 "public:\n" 6812 " E *f();\n" 6813 "};"); 6814 6815 FormatStyle NeverBreak = getLLVMStyle(); 6816 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 6817 verifyFormat("template <typename T> class C {};", NeverBreak); 6818 verifyFormat("template <typename T> void f();", NeverBreak); 6819 verifyFormat("template <typename T> void f() {}", NeverBreak); 6820 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6821 "bbbbbbbbbbbbbbbbbbbb) {}", 6822 NeverBreak); 6823 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6824 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6825 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 6826 NeverBreak); 6827 verifyFormat("template <template <typename> class Fooooooo,\n" 6828 " template <typename> class Baaaaaaar>\n" 6829 "struct C {};", 6830 NeverBreak); 6831 verifyFormat("template <typename T> // T can be A, B or C.\n" 6832 "struct C {};", 6833 NeverBreak); 6834 verifyFormat("template <enum E> class A {\n" 6835 "public:\n" 6836 " E *f();\n" 6837 "};", 6838 NeverBreak); 6839 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 6840 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6841 "bbbbbbbbbbbbbbbbbbbb) {}", 6842 NeverBreak); 6843 } 6844 6845 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 6846 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 6847 Style.ColumnLimit = 60; 6848 EXPECT_EQ("// Baseline - no comments.\n" 6849 "template <\n" 6850 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6851 "void f() {}", 6852 format("// Baseline - no comments.\n" 6853 "template <\n" 6854 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6855 "void f() {}", 6856 Style)); 6857 6858 EXPECT_EQ("template <\n" 6859 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6860 "void f() {}", 6861 format("template <\n" 6862 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6863 "void f() {}", 6864 Style)); 6865 6866 EXPECT_EQ( 6867 "template <\n" 6868 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6869 "void f() {}", 6870 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6871 "void f() {}", 6872 Style)); 6873 6874 EXPECT_EQ( 6875 "template <\n" 6876 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6877 " // multiline\n" 6878 "void f() {}", 6879 format("template <\n" 6880 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6881 " // multiline\n" 6882 "void f() {}", 6883 Style)); 6884 6885 EXPECT_EQ( 6886 "template <typename aaaaaaaaaa<\n" 6887 " bbbbbbbbbbbb>::value> // trailing loooong\n" 6888 "void f() {}", 6889 format( 6890 "template <\n" 6891 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 6892 "void f() {}", 6893 Style)); 6894 } 6895 6896 TEST_F(FormatTest, WrapsTemplateParameters) { 6897 FormatStyle Style = getLLVMStyle(); 6898 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6899 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6900 verifyFormat( 6901 "template <typename... a> struct q {};\n" 6902 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6903 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6904 " y;", 6905 Style); 6906 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6907 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6908 verifyFormat( 6909 "template <typename... a> struct r {};\n" 6910 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6911 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6912 " y;", 6913 Style); 6914 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6915 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6916 verifyFormat("template <typename... a> struct s {};\n" 6917 "extern s<\n" 6918 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6919 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6920 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6921 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6922 " y;", 6923 Style); 6924 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6925 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6926 verifyFormat("template <typename... a> struct t {};\n" 6927 "extern t<\n" 6928 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6929 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6930 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6931 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6932 " y;", 6933 Style); 6934 } 6935 6936 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 6937 verifyFormat( 6938 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6939 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6940 verifyFormat( 6941 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6942 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6943 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6944 6945 // FIXME: Should we have the extra indent after the second break? 6946 verifyFormat( 6947 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6948 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6949 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6950 6951 verifyFormat( 6952 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 6953 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 6954 6955 // Breaking at nested name specifiers is generally not desirable. 6956 verifyFormat( 6957 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6958 " aaaaaaaaaaaaaaaaaaaaaaa);"); 6959 6960 verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 6961 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6962 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6963 " aaaaaaaaaaaaaaaaaaaaa);", 6964 getLLVMStyleWithColumns(74)); 6965 6966 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6967 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6968 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6969 } 6970 6971 TEST_F(FormatTest, UnderstandsTemplateParameters) { 6972 verifyFormat("A<int> a;"); 6973 verifyFormat("A<A<A<int>>> a;"); 6974 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 6975 verifyFormat("bool x = a < 1 || 2 > a;"); 6976 verifyFormat("bool x = 5 < f<int>();"); 6977 verifyFormat("bool x = f<int>() > 5;"); 6978 verifyFormat("bool x = 5 < a<int>::x;"); 6979 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 6980 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 6981 6982 verifyGoogleFormat("A<A<int>> a;"); 6983 verifyGoogleFormat("A<A<A<int>>> a;"); 6984 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 6985 verifyGoogleFormat("A<A<int> > a;"); 6986 verifyGoogleFormat("A<A<A<int> > > a;"); 6987 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 6988 verifyGoogleFormat("A<::A<int>> a;"); 6989 verifyGoogleFormat("A<::A> a;"); 6990 verifyGoogleFormat("A< ::A> a;"); 6991 verifyGoogleFormat("A< ::A<int> > a;"); 6992 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 6993 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 6994 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 6995 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 6996 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 6997 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 6998 6999 verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 7000 7001 // template closer followed by a token that starts with > or = 7002 verifyFormat("bool b = a<1> > 1;"); 7003 verifyFormat("bool b = a<1> >= 1;"); 7004 verifyFormat("int i = a<1> >> 1;"); 7005 FormatStyle Style = getLLVMStyle(); 7006 Style.SpaceBeforeAssignmentOperators = false; 7007 verifyFormat("bool b= a<1> == 1;", Style); 7008 verifyFormat("a<int> = 1;", Style); 7009 verifyFormat("a<int> >>= 1;", Style); 7010 7011 verifyFormat("test >> a >> b;"); 7012 verifyFormat("test << a >> b;"); 7013 7014 verifyFormat("f<int>();"); 7015 verifyFormat("template <typename T> void f() {}"); 7016 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 7017 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 7018 "sizeof(char)>::type>;"); 7019 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 7020 verifyFormat("f(a.operator()<A>());"); 7021 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7022 " .template operator()<A>());", 7023 getLLVMStyleWithColumns(35)); 7024 7025 // Not template parameters. 7026 verifyFormat("return a < b && c > d;"); 7027 verifyFormat("void f() {\n" 7028 " while (a < b && c > d) {\n" 7029 " }\n" 7030 "}"); 7031 verifyFormat("template <typename... Types>\n" 7032 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 7033 7034 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7035 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 7036 getLLVMStyleWithColumns(60)); 7037 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 7038 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 7039 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 7040 } 7041 7042 TEST_F(FormatTest, BitshiftOperatorWidth) { 7043 EXPECT_EQ("int a = 1 << 2; /* foo\n" 7044 " bar */", 7045 format("int a=1<<2; /* foo\n" 7046 " bar */")); 7047 7048 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 7049 " bar */", 7050 format("int b =256>>1 ; /* foo\n" 7051 " bar */")); 7052 } 7053 7054 TEST_F(FormatTest, UnderstandsBinaryOperators) { 7055 verifyFormat("COMPARE(a, ==, b);"); 7056 verifyFormat("auto s = sizeof...(Ts) - 1;"); 7057 } 7058 7059 TEST_F(FormatTest, UnderstandsPointersToMembers) { 7060 verifyFormat("int A::*x;"); 7061 verifyFormat("int (S::*func)(void *);"); 7062 verifyFormat("void f() { int (S::*func)(void *); }"); 7063 verifyFormat("typedef bool *(Class::*Member)() const;"); 7064 verifyFormat("void f() {\n" 7065 " (a->*f)();\n" 7066 " a->*x;\n" 7067 " (a.*f)();\n" 7068 " ((*a).*f)();\n" 7069 " a.*x;\n" 7070 "}"); 7071 verifyFormat("void f() {\n" 7072 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7073 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 7074 "}"); 7075 verifyFormat( 7076 "(aaaaaaaaaa->*bbbbbbb)(\n" 7077 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 7078 FormatStyle Style = getLLVMStyle(); 7079 Style.PointerAlignment = FormatStyle::PAS_Left; 7080 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 7081 } 7082 7083 TEST_F(FormatTest, UnderstandsUnaryOperators) { 7084 verifyFormat("int a = -2;"); 7085 verifyFormat("f(-1, -2, -3);"); 7086 verifyFormat("a[-1] = 5;"); 7087 verifyFormat("int a = 5 + -2;"); 7088 verifyFormat("if (i == -1) {\n}"); 7089 verifyFormat("if (i != -1) {\n}"); 7090 verifyFormat("if (i > -1) {\n}"); 7091 verifyFormat("if (i < -1) {\n}"); 7092 verifyFormat("++(a->f());"); 7093 verifyFormat("--(a->f());"); 7094 verifyFormat("(a->f())++;"); 7095 verifyFormat("a[42]++;"); 7096 verifyFormat("if (!(a->f())) {\n}"); 7097 verifyFormat("if (!+i) {\n}"); 7098 verifyFormat("~&a;"); 7099 7100 verifyFormat("a-- > b;"); 7101 verifyFormat("b ? -a : c;"); 7102 verifyFormat("n * sizeof char16;"); 7103 verifyFormat("n * alignof char16;", getGoogleStyle()); 7104 verifyFormat("sizeof(char);"); 7105 verifyFormat("alignof(char);", getGoogleStyle()); 7106 7107 verifyFormat("return -1;"); 7108 verifyFormat("throw -1;"); 7109 verifyFormat("switch (a) {\n" 7110 "case -1:\n" 7111 " break;\n" 7112 "}"); 7113 verifyFormat("#define X -1"); 7114 verifyFormat("#define X -kConstant"); 7115 7116 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 7117 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 7118 7119 verifyFormat("int a = /* confusing comment */ -1;"); 7120 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 7121 verifyFormat("int a = i /* confusing comment */++;"); 7122 7123 verifyFormat("co_yield -1;"); 7124 verifyFormat("co_return -1;"); 7125 } 7126 7127 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 7128 verifyFormat("if (!aaaaaaaaaa( // break\n" 7129 " aaaaa)) {\n" 7130 "}"); 7131 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 7132 " aaaaa));"); 7133 verifyFormat("*aaa = aaaaaaa( // break\n" 7134 " bbbbbb);"); 7135 } 7136 7137 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 7138 verifyFormat("bool operator<();"); 7139 verifyFormat("bool operator>();"); 7140 verifyFormat("bool operator=();"); 7141 verifyFormat("bool operator==();"); 7142 verifyFormat("bool operator!=();"); 7143 verifyFormat("int operator+();"); 7144 verifyFormat("int operator++();"); 7145 verifyFormat("int operator++(int) volatile noexcept;"); 7146 verifyFormat("bool operator,();"); 7147 verifyFormat("bool operator();"); 7148 verifyFormat("bool operator()();"); 7149 verifyFormat("bool operator[]();"); 7150 verifyFormat("operator bool();"); 7151 verifyFormat("operator int();"); 7152 verifyFormat("operator void *();"); 7153 verifyFormat("operator SomeType<int>();"); 7154 verifyFormat("operator SomeType<int, int>();"); 7155 verifyFormat("operator SomeType<SomeType<int>>();"); 7156 verifyFormat("void *operator new(std::size_t size);"); 7157 verifyFormat("void *operator new[](std::size_t size);"); 7158 verifyFormat("void operator delete(void *ptr);"); 7159 verifyFormat("void operator delete[](void *ptr);"); 7160 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 7161 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 7162 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 7163 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 7164 7165 verifyFormat( 7166 "ostream &operator<<(ostream &OutputStream,\n" 7167 " SomeReallyLongType WithSomeReallyLongValue);"); 7168 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 7169 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 7170 " return left.group < right.group;\n" 7171 "}"); 7172 verifyFormat("SomeType &operator=(const SomeType &S);"); 7173 verifyFormat("f.template operator()<int>();"); 7174 7175 verifyGoogleFormat("operator void*();"); 7176 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 7177 verifyGoogleFormat("operator ::A();"); 7178 7179 verifyFormat("using A::operator+;"); 7180 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 7181 "int i;"); 7182 } 7183 7184 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 7185 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 7186 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 7187 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 7188 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 7189 verifyFormat("Deleted &operator=(const Deleted &) &;"); 7190 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 7191 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 7192 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 7193 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 7194 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 7195 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 7196 verifyFormat("void Fn(T const &) const &;"); 7197 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 7198 verifyFormat("template <typename T>\n" 7199 "void F(T) && = delete;", 7200 getGoogleStyle()); 7201 7202 FormatStyle AlignLeft = getLLVMStyle(); 7203 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 7204 verifyFormat("void A::b() && {}", AlignLeft); 7205 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 7206 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 7207 AlignLeft); 7208 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 7209 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 7210 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 7211 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 7212 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 7213 verifyFormat("auto Function(T) & -> void;", AlignLeft); 7214 verifyFormat("void Fn(T const&) const&;", AlignLeft); 7215 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 7216 7217 FormatStyle Spaces = getLLVMStyle(); 7218 Spaces.SpacesInCStyleCastParentheses = true; 7219 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 7220 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 7221 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 7222 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 7223 7224 Spaces.SpacesInCStyleCastParentheses = false; 7225 Spaces.SpacesInParentheses = true; 7226 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 7227 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", 7228 Spaces); 7229 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 7230 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 7231 7232 FormatStyle BreakTemplate = getLLVMStyle(); 7233 BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 7234 7235 verifyFormat("struct f {\n" 7236 " template <class T>\n" 7237 " int &foo(const std::string &str) &noexcept {}\n" 7238 "};", 7239 BreakTemplate); 7240 7241 verifyFormat("struct f {\n" 7242 " template <class T>\n" 7243 " int &foo(const std::string &str) &&noexcept {}\n" 7244 "};", 7245 BreakTemplate); 7246 7247 verifyFormat("struct f {\n" 7248 " template <class T>\n" 7249 " int &foo(const std::string &str) const &noexcept {}\n" 7250 "};", 7251 BreakTemplate); 7252 7253 verifyFormat("struct f {\n" 7254 " template <class T>\n" 7255 " int &foo(const std::string &str) const &noexcept {}\n" 7256 "};", 7257 BreakTemplate); 7258 7259 verifyFormat("struct f {\n" 7260 " template <class T>\n" 7261 " auto foo(const std::string &str) &&noexcept -> int & {}\n" 7262 "};", 7263 BreakTemplate); 7264 7265 FormatStyle AlignLeftBreakTemplate = getLLVMStyle(); 7266 AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations = 7267 FormatStyle::BTDS_Yes; 7268 AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left; 7269 7270 verifyFormat("struct f {\n" 7271 " template <class T>\n" 7272 " int& foo(const std::string& str) & noexcept {}\n" 7273 "};", 7274 AlignLeftBreakTemplate); 7275 7276 verifyFormat("struct f {\n" 7277 " template <class T>\n" 7278 " int& foo(const std::string& str) && noexcept {}\n" 7279 "};", 7280 AlignLeftBreakTemplate); 7281 7282 verifyFormat("struct f {\n" 7283 " template <class T>\n" 7284 " int& foo(const std::string& str) const& noexcept {}\n" 7285 "};", 7286 AlignLeftBreakTemplate); 7287 7288 verifyFormat("struct f {\n" 7289 " template <class T>\n" 7290 " int& foo(const std::string& str) const&& noexcept {}\n" 7291 "};", 7292 AlignLeftBreakTemplate); 7293 7294 verifyFormat("struct f {\n" 7295 " template <class T>\n" 7296 " auto foo(const std::string& str) && noexcept -> int& {}\n" 7297 "};", 7298 AlignLeftBreakTemplate); 7299 7300 // The `&` in `Type&` should not be confused with a trailing `&` of 7301 // DEPRECATED(reason) member function. 7302 verifyFormat("struct f {\n" 7303 " template <class T>\n" 7304 " DEPRECATED(reason)\n" 7305 " Type &foo(arguments) {}\n" 7306 "};", 7307 BreakTemplate); 7308 7309 verifyFormat("struct f {\n" 7310 " template <class T>\n" 7311 " DEPRECATED(reason)\n" 7312 " Type& foo(arguments) {}\n" 7313 "};", 7314 AlignLeftBreakTemplate); 7315 7316 verifyFormat("void (*foopt)(int) = &func;"); 7317 } 7318 7319 TEST_F(FormatTest, UnderstandsNewAndDelete) { 7320 verifyFormat("void f() {\n" 7321 " A *a = new A;\n" 7322 " A *a = new (placement) A;\n" 7323 " delete a;\n" 7324 " delete (A *)a;\n" 7325 "}"); 7326 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7327 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7328 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7329 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7330 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7331 verifyFormat("delete[] h->p;"); 7332 } 7333 7334 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 7335 verifyFormat("int *f(int *a) {}"); 7336 verifyFormat("int main(int argc, char **argv) {}"); 7337 verifyFormat("Test::Test(int b) : a(b * b) {}"); 7338 verifyIndependentOfContext("f(a, *a);"); 7339 verifyFormat("void g() { f(*a); }"); 7340 verifyIndependentOfContext("int a = b * 10;"); 7341 verifyIndependentOfContext("int a = 10 * b;"); 7342 verifyIndependentOfContext("int a = b * c;"); 7343 verifyIndependentOfContext("int a += b * c;"); 7344 verifyIndependentOfContext("int a -= b * c;"); 7345 verifyIndependentOfContext("int a *= b * c;"); 7346 verifyIndependentOfContext("int a /= b * c;"); 7347 verifyIndependentOfContext("int a = *b;"); 7348 verifyIndependentOfContext("int a = *b * c;"); 7349 verifyIndependentOfContext("int a = b * *c;"); 7350 verifyIndependentOfContext("int a = b * (10);"); 7351 verifyIndependentOfContext("S << b * (10);"); 7352 verifyIndependentOfContext("return 10 * b;"); 7353 verifyIndependentOfContext("return *b * *c;"); 7354 verifyIndependentOfContext("return a & ~b;"); 7355 verifyIndependentOfContext("f(b ? *c : *d);"); 7356 verifyIndependentOfContext("int a = b ? *c : *d;"); 7357 verifyIndependentOfContext("*b = a;"); 7358 verifyIndependentOfContext("a * ~b;"); 7359 verifyIndependentOfContext("a * !b;"); 7360 verifyIndependentOfContext("a * +b;"); 7361 verifyIndependentOfContext("a * -b;"); 7362 verifyIndependentOfContext("a * ++b;"); 7363 verifyIndependentOfContext("a * --b;"); 7364 verifyIndependentOfContext("a[4] * b;"); 7365 verifyIndependentOfContext("a[a * a] = 1;"); 7366 verifyIndependentOfContext("f() * b;"); 7367 verifyIndependentOfContext("a * [self dostuff];"); 7368 verifyIndependentOfContext("int x = a * (a + b);"); 7369 verifyIndependentOfContext("(a *)(a + b);"); 7370 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 7371 verifyIndependentOfContext("int *pa = (int *)&a;"); 7372 verifyIndependentOfContext("return sizeof(int **);"); 7373 verifyIndependentOfContext("return sizeof(int ******);"); 7374 verifyIndependentOfContext("return (int **&)a;"); 7375 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 7376 verifyFormat("void f(Type (*parameter)[10]) {}"); 7377 verifyFormat("void f(Type (¶meter)[10]) {}"); 7378 verifyGoogleFormat("return sizeof(int**);"); 7379 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 7380 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 7381 verifyFormat("auto a = [](int **&, int ***) {};"); 7382 verifyFormat("auto PointerBinding = [](const char *S) {};"); 7383 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 7384 verifyFormat("[](const decltype(*a) &value) {}"); 7385 verifyFormat("decltype(a * b) F();"); 7386 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 7387 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 7388 verifyIndependentOfContext("typedef void (*f)(int *a);"); 7389 verifyIndependentOfContext("int i{a * b};"); 7390 verifyIndependentOfContext("aaa && aaa->f();"); 7391 verifyIndependentOfContext("int x = ~*p;"); 7392 verifyFormat("Constructor() : a(a), area(width * height) {}"); 7393 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 7394 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 7395 verifyFormat("void f() { f(a, c * d); }"); 7396 verifyFormat("void f() { f(new a(), c * d); }"); 7397 verifyFormat("void f(const MyOverride &override);"); 7398 verifyFormat("void f(const MyFinal &final);"); 7399 verifyIndependentOfContext("bool a = f() && override.f();"); 7400 verifyIndependentOfContext("bool a = f() && final.f();"); 7401 7402 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 7403 7404 verifyIndependentOfContext("A<int *> a;"); 7405 verifyIndependentOfContext("A<int **> a;"); 7406 verifyIndependentOfContext("A<int *, int *> a;"); 7407 verifyIndependentOfContext("A<int *[]> a;"); 7408 verifyIndependentOfContext( 7409 "const char *const p = reinterpret_cast<const char *const>(q);"); 7410 verifyIndependentOfContext("A<int **, int **> a;"); 7411 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 7412 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 7413 verifyFormat("for (; a && b;) {\n}"); 7414 verifyFormat("bool foo = true && [] { return false; }();"); 7415 7416 verifyFormat( 7417 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7418 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7419 7420 verifyGoogleFormat("int const* a = &b;"); 7421 verifyGoogleFormat("**outparam = 1;"); 7422 verifyGoogleFormat("*outparam = a * b;"); 7423 verifyGoogleFormat("int main(int argc, char** argv) {}"); 7424 verifyGoogleFormat("A<int*> a;"); 7425 verifyGoogleFormat("A<int**> a;"); 7426 verifyGoogleFormat("A<int*, int*> a;"); 7427 verifyGoogleFormat("A<int**, int**> a;"); 7428 verifyGoogleFormat("f(b ? *c : *d);"); 7429 verifyGoogleFormat("int a = b ? *c : *d;"); 7430 verifyGoogleFormat("Type* t = **x;"); 7431 verifyGoogleFormat("Type* t = *++*x;"); 7432 verifyGoogleFormat("*++*x;"); 7433 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 7434 verifyGoogleFormat("Type* t = x++ * y;"); 7435 verifyGoogleFormat( 7436 "const char* const p = reinterpret_cast<const char* const>(q);"); 7437 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 7438 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 7439 verifyGoogleFormat("template <typename T>\n" 7440 "void f(int i = 0, SomeType** temps = NULL);"); 7441 7442 FormatStyle Left = getLLVMStyle(); 7443 Left.PointerAlignment = FormatStyle::PAS_Left; 7444 verifyFormat("x = *a(x) = *a(y);", Left); 7445 verifyFormat("for (;; *a = b) {\n}", Left); 7446 verifyFormat("return *this += 1;", Left); 7447 verifyFormat("throw *x;", Left); 7448 verifyFormat("delete *x;", Left); 7449 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 7450 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 7451 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 7452 verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left); 7453 verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left); 7454 verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left); 7455 7456 verifyIndependentOfContext("a = *(x + y);"); 7457 verifyIndependentOfContext("a = &(x + y);"); 7458 verifyIndependentOfContext("*(x + y).call();"); 7459 verifyIndependentOfContext("&(x + y)->call();"); 7460 verifyFormat("void f() { &(*I).first; }"); 7461 7462 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 7463 verifyFormat( 7464 "int *MyValues = {\n" 7465 " *A, // Operator detection might be confused by the '{'\n" 7466 " *BB // Operator detection might be confused by previous comment\n" 7467 "};"); 7468 7469 verifyIndependentOfContext("if (int *a = &b)"); 7470 verifyIndependentOfContext("if (int &a = *b)"); 7471 verifyIndependentOfContext("if (a & b[i])"); 7472 verifyIndependentOfContext("if constexpr (a & b[i])"); 7473 verifyIndependentOfContext("if CONSTEXPR (a & b[i])"); 7474 verifyIndependentOfContext("if (a * (b * c))"); 7475 verifyIndependentOfContext("if constexpr (a * (b * c))"); 7476 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))"); 7477 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 7478 verifyIndependentOfContext("if (*b[i])"); 7479 verifyIndependentOfContext("if (int *a = (&b))"); 7480 verifyIndependentOfContext("while (int *a = &b)"); 7481 verifyIndependentOfContext("while (a * (b * c))"); 7482 verifyIndependentOfContext("size = sizeof *a;"); 7483 verifyIndependentOfContext("if (a && (b = c))"); 7484 verifyFormat("void f() {\n" 7485 " for (const int &v : Values) {\n" 7486 " }\n" 7487 "}"); 7488 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 7489 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 7490 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 7491 7492 verifyFormat("#define A (!a * b)"); 7493 verifyFormat("#define MACRO \\\n" 7494 " int *i = a * b; \\\n" 7495 " void f(a *b);", 7496 getLLVMStyleWithColumns(19)); 7497 7498 verifyIndependentOfContext("A = new SomeType *[Length];"); 7499 verifyIndependentOfContext("A = new SomeType *[Length]();"); 7500 verifyIndependentOfContext("T **t = new T *;"); 7501 verifyIndependentOfContext("T **t = new T *();"); 7502 verifyGoogleFormat("A = new SomeType*[Length]();"); 7503 verifyGoogleFormat("A = new SomeType*[Length];"); 7504 verifyGoogleFormat("T** t = new T*;"); 7505 verifyGoogleFormat("T** t = new T*();"); 7506 7507 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 7508 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 7509 verifyFormat("template <bool a, bool b> " 7510 "typename t::if<x && y>::type f() {}"); 7511 verifyFormat("template <int *y> f() {}"); 7512 verifyFormat("vector<int *> v;"); 7513 verifyFormat("vector<int *const> v;"); 7514 verifyFormat("vector<int *const **const *> v;"); 7515 verifyFormat("vector<int *volatile> v;"); 7516 verifyFormat("vector<a * b> v;"); 7517 verifyFormat("foo<b && false>();"); 7518 verifyFormat("foo<b & 1>();"); 7519 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 7520 verifyFormat( 7521 "template <class T, class = typename std::enable_if<\n" 7522 " std::is_integral<T>::value &&\n" 7523 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 7524 "void F();", 7525 getLLVMStyleWithColumns(70)); 7526 verifyFormat("template <class T,\n" 7527 " class = typename std::enable_if<\n" 7528 " std::is_integral<T>::value &&\n" 7529 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 7530 " class U>\n" 7531 "void F();", 7532 getLLVMStyleWithColumns(70)); 7533 verifyFormat( 7534 "template <class T,\n" 7535 " class = typename ::std::enable_if<\n" 7536 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 7537 "void F();", 7538 getGoogleStyleWithColumns(68)); 7539 7540 verifyIndependentOfContext("MACRO(int *i);"); 7541 verifyIndependentOfContext("MACRO(auto *a);"); 7542 verifyIndependentOfContext("MACRO(const A *a);"); 7543 verifyIndependentOfContext("MACRO(A *const a);"); 7544 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 7545 verifyFormat("void f() { f(float{1}, a * a); }"); 7546 // FIXME: Is there a way to make this work? 7547 // verifyIndependentOfContext("MACRO(A *a);"); 7548 7549 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 7550 verifyFormat("return options != nullptr && operator==(*options);"); 7551 7552 EXPECT_EQ("#define OP(x) \\\n" 7553 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7554 " return s << a.DebugString(); \\\n" 7555 " }", 7556 format("#define OP(x) \\\n" 7557 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7558 " return s << a.DebugString(); \\\n" 7559 " }", 7560 getLLVMStyleWithColumns(50))); 7561 7562 // FIXME: We cannot handle this case yet; we might be able to figure out that 7563 // foo<x> d > v; doesn't make sense. 7564 verifyFormat("foo<a<b && c> d> v;"); 7565 7566 FormatStyle PointerMiddle = getLLVMStyle(); 7567 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7568 verifyFormat("delete *x;", PointerMiddle); 7569 verifyFormat("int * x;", PointerMiddle); 7570 verifyFormat("int *[] x;", PointerMiddle); 7571 verifyFormat("template <int * y> f() {}", PointerMiddle); 7572 verifyFormat("int * f(int * a) {}", PointerMiddle); 7573 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7574 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7575 verifyFormat("A<int *> a;", PointerMiddle); 7576 verifyFormat("A<int **> a;", PointerMiddle); 7577 verifyFormat("A<int *, int *> a;", PointerMiddle); 7578 verifyFormat("A<int *[]> a;", PointerMiddle); 7579 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7580 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7581 verifyFormat("T ** t = new T *;", PointerMiddle); 7582 7583 // Member function reference qualifiers aren't binary operators. 7584 verifyFormat("string // break\n" 7585 "operator()() & {}"); 7586 verifyFormat("string // break\n" 7587 "operator()() && {}"); 7588 verifyGoogleFormat("template <typename T>\n" 7589 "auto x() & -> int {}"); 7590 } 7591 7592 TEST_F(FormatTest, UnderstandsAttributes) { 7593 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7594 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7595 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7596 FormatStyle AfterType = getLLVMStyle(); 7597 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7598 verifyFormat("__attribute__((nodebug)) void\n" 7599 "foo() {}\n", 7600 AfterType); 7601 } 7602 7603 TEST_F(FormatTest, UnderstandsSquareAttributes) { 7604 verifyFormat("SomeType s [[unused]] (InitValue);"); 7605 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 7606 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 7607 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 7608 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 7609 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7610 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7611 7612 // Make sure we do not mistake attributes for array subscripts. 7613 verifyFormat("int a() {}\n" 7614 "[[unused]] int b() {}\n"); 7615 verifyFormat("NSArray *arr;\n" 7616 "arr[[Foo() bar]];"); 7617 7618 // On the other hand, we still need to correctly find array subscripts. 7619 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 7620 7621 // Make sure that we do not mistake Objective-C method inside array literals 7622 // as attributes, even if those method names are also keywords. 7623 verifyFormat("@[ [foo bar] ];"); 7624 verifyFormat("@[ [NSArray class] ];"); 7625 verifyFormat("@[ [foo enum] ];"); 7626 7627 // Make sure we do not parse attributes as lambda introducers. 7628 FormatStyle MultiLineFunctions = getLLVMStyle(); 7629 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7630 verifyFormat("[[unused]] int b() {\n" 7631 " return 42;\n" 7632 "}\n", 7633 MultiLineFunctions); 7634 } 7635 7636 TEST_F(FormatTest, UnderstandsEllipsis) { 7637 verifyFormat("int printf(const char *fmt, ...);"); 7638 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 7639 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 7640 7641 FormatStyle PointersLeft = getLLVMStyle(); 7642 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 7643 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 7644 } 7645 7646 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 7647 EXPECT_EQ("int *a;\n" 7648 "int *a;\n" 7649 "int *a;", 7650 format("int *a;\n" 7651 "int* a;\n" 7652 "int *a;", 7653 getGoogleStyle())); 7654 EXPECT_EQ("int* a;\n" 7655 "int* a;\n" 7656 "int* a;", 7657 format("int* a;\n" 7658 "int* a;\n" 7659 "int *a;", 7660 getGoogleStyle())); 7661 EXPECT_EQ("int *a;\n" 7662 "int *a;\n" 7663 "int *a;", 7664 format("int *a;\n" 7665 "int * a;\n" 7666 "int * a;", 7667 getGoogleStyle())); 7668 EXPECT_EQ("auto x = [] {\n" 7669 " int *a;\n" 7670 " int *a;\n" 7671 " int *a;\n" 7672 "};", 7673 format("auto x=[]{int *a;\n" 7674 "int * a;\n" 7675 "int * a;};", 7676 getGoogleStyle())); 7677 } 7678 7679 TEST_F(FormatTest, UnderstandsRvalueReferences) { 7680 verifyFormat("int f(int &&a) {}"); 7681 verifyFormat("int f(int a, char &&b) {}"); 7682 verifyFormat("void f() { int &&a = b; }"); 7683 verifyGoogleFormat("int f(int a, char&& b) {}"); 7684 verifyGoogleFormat("void f() { int&& a = b; }"); 7685 7686 verifyIndependentOfContext("A<int &&> a;"); 7687 verifyIndependentOfContext("A<int &&, int &&> a;"); 7688 verifyGoogleFormat("A<int&&> a;"); 7689 verifyGoogleFormat("A<int&&, int&&> a;"); 7690 7691 // Not rvalue references: 7692 verifyFormat("template <bool B, bool C> class A {\n" 7693 " static_assert(B && C, \"Something is wrong\");\n" 7694 "};"); 7695 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 7696 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 7697 verifyFormat("#define A(a, b) (a && b)"); 7698 } 7699 7700 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 7701 verifyFormat("void f() {\n" 7702 " x[aaaaaaaaa -\n" 7703 " b] = 23;\n" 7704 "}", 7705 getLLVMStyleWithColumns(15)); 7706 } 7707 7708 TEST_F(FormatTest, FormatsCasts) { 7709 verifyFormat("Type *A = static_cast<Type *>(P);"); 7710 verifyFormat("Type *A = (Type *)P;"); 7711 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7712 verifyFormat("int a = (int)(2.0f);"); 7713 verifyFormat("int a = (int)2.0f;"); 7714 verifyFormat("x[(int32)y];"); 7715 verifyFormat("x = (int32)y;"); 7716 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7717 verifyFormat("int a = (int)*b;"); 7718 verifyFormat("int a = (int)2.0f;"); 7719 verifyFormat("int a = (int)~0;"); 7720 verifyFormat("int a = (int)++a;"); 7721 verifyFormat("int a = (int)sizeof(int);"); 7722 verifyFormat("int a = (int)+2;"); 7723 verifyFormat("my_int a = (my_int)2.0f;"); 7724 verifyFormat("my_int a = (my_int)sizeof(int);"); 7725 verifyFormat("return (my_int)aaa;"); 7726 verifyFormat("#define x ((int)-1)"); 7727 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7728 verifyFormat("#define p(q) ((int *)&q)"); 7729 verifyFormat("fn(a)(b) + 1;"); 7730 7731 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7732 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7733 verifyFormat("my_int a = (my_int)~0;"); 7734 verifyFormat("my_int a = (my_int)++a;"); 7735 verifyFormat("my_int a = (my_int)-2;"); 7736 verifyFormat("my_int a = (my_int)1;"); 7737 verifyFormat("my_int a = (my_int *)1;"); 7738 verifyFormat("my_int a = (const my_int)-1;"); 7739 verifyFormat("my_int a = (const my_int *)-1;"); 7740 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7741 verifyFormat("my_int a = (ns::my_int)-2;"); 7742 verifyFormat("case (my_int)ONE:"); 7743 verifyFormat("auto x = (X)this;"); 7744 // Casts in Obj-C style calls used to not be recognized as such. 7745 verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle()); 7746 7747 // FIXME: single value wrapped with paren will be treated as cast. 7748 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7749 7750 verifyFormat("{ (void)F; }"); 7751 7752 // Don't break after a cast's 7753 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7754 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7755 " bbbbbbbbbbbbbbbbbbbbbb);"); 7756 7757 // These are not casts. 7758 verifyFormat("void f(int *) {}"); 7759 verifyFormat("f(foo)->b;"); 7760 verifyFormat("f(foo).b;"); 7761 verifyFormat("f(foo)(b);"); 7762 verifyFormat("f(foo)[b];"); 7763 verifyFormat("[](foo) { return 4; }(bar);"); 7764 verifyFormat("(*funptr)(foo)[4];"); 7765 verifyFormat("funptrs[4](foo)[4];"); 7766 verifyFormat("void f(int *);"); 7767 verifyFormat("void f(int *) = 0;"); 7768 verifyFormat("void f(SmallVector<int>) {}"); 7769 verifyFormat("void f(SmallVector<int>);"); 7770 verifyFormat("void f(SmallVector<int>) = 0;"); 7771 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7772 verifyFormat("int a = sizeof(int) * b;"); 7773 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7774 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7775 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7776 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7777 7778 // These are not casts, but at some point were confused with casts. 7779 verifyFormat("virtual void foo(int *) override;"); 7780 verifyFormat("virtual void foo(char &) const;"); 7781 verifyFormat("virtual void foo(int *a, char *) const;"); 7782 verifyFormat("int a = sizeof(int *) + b;"); 7783 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7784 verifyFormat("bool b = f(g<int>) && c;"); 7785 verifyFormat("typedef void (*f)(int i) func;"); 7786 verifyFormat("void operator++(int) noexcept;"); 7787 verifyFormat("void operator++(int &) noexcept;"); 7788 verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t " 7789 "&) noexcept;"); 7790 verifyFormat( 7791 "void operator delete(std::size_t, const std::nothrow_t &) noexcept;"); 7792 verifyFormat("void operator delete(const std::nothrow_t &) noexcept;"); 7793 verifyFormat("void operator delete(std::nothrow_t &) noexcept;"); 7794 verifyFormat("void operator delete(nothrow_t &) noexcept;"); 7795 verifyFormat("void operator delete(foo &) noexcept;"); 7796 verifyFormat("void operator delete(foo) noexcept;"); 7797 verifyFormat("void operator delete(int) noexcept;"); 7798 verifyFormat("void operator delete(int &) noexcept;"); 7799 verifyFormat("void operator delete(int &) volatile noexcept;"); 7800 verifyFormat("void operator delete(int &) const"); 7801 verifyFormat("void operator delete(int &) = default"); 7802 verifyFormat("void operator delete(int &) = delete"); 7803 verifyFormat("void operator delete(int &) [[noreturn]]"); 7804 verifyFormat("void operator delete(int &) throw();"); 7805 verifyFormat("void operator delete(int &) throw(int);"); 7806 verifyFormat("auto operator delete(int &) -> int;"); 7807 verifyFormat("auto operator delete(int &) override"); 7808 verifyFormat("auto operator delete(int &) final"); 7809 7810 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7811 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7812 // FIXME: The indentation here is not ideal. 7813 verifyFormat( 7814 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7815 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7816 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7817 } 7818 7819 TEST_F(FormatTest, FormatsFunctionTypes) { 7820 verifyFormat("A<bool()> a;"); 7821 verifyFormat("A<SomeType()> a;"); 7822 verifyFormat("A<void (*)(int, std::string)> a;"); 7823 verifyFormat("A<void *(int)>;"); 7824 verifyFormat("void *(*a)(int *, SomeType *);"); 7825 verifyFormat("int (*func)(void *);"); 7826 verifyFormat("void f() { int (*func)(void *); }"); 7827 verifyFormat("template <class CallbackClass>\n" 7828 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7829 7830 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7831 verifyGoogleFormat("void* (*a)(int);"); 7832 verifyGoogleFormat( 7833 "template <class CallbackClass>\n" 7834 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7835 7836 // Other constructs can look somewhat like function types: 7837 verifyFormat("A<sizeof(*x)> a;"); 7838 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7839 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7840 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7841 verifyFormat("int x = f(&h)();"); 7842 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7843 verifyFormat("std::function<\n" 7844 " LooooooooooongTemplatedType<\n" 7845 " SomeType>*(\n" 7846 " LooooooooooooooooongType type)>\n" 7847 " function;", 7848 getGoogleStyleWithColumns(40)); 7849 } 7850 7851 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7852 verifyFormat("A (*foo_)[6];"); 7853 verifyFormat("vector<int> (*foo_)[6];"); 7854 } 7855 7856 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7857 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7858 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7859 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7860 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7861 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7862 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7863 7864 // Different ways of ()-initializiation. 7865 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7866 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7867 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7868 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7869 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7870 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7871 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7872 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7873 7874 // Lambdas should not confuse the variable declaration heuristic. 7875 verifyFormat("LooooooooooooooooongType\n" 7876 " variable(nullptr, [](A *a) {});", 7877 getLLVMStyleWithColumns(40)); 7878 } 7879 7880 TEST_F(FormatTest, BreaksLongDeclarations) { 7881 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7882 " AnotherNameForTheLongType;"); 7883 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7884 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7885 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7886 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7887 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7888 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7889 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7890 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7891 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7892 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7893 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7894 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7895 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7896 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7897 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7898 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7899 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7900 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7901 FormatStyle Indented = getLLVMStyle(); 7902 Indented.IndentWrappedFunctionNames = true; 7903 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7904 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7905 Indented); 7906 verifyFormat( 7907 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7908 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7909 Indented); 7910 verifyFormat( 7911 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7912 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7913 Indented); 7914 verifyFormat( 7915 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7916 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7917 Indented); 7918 7919 // FIXME: Without the comment, this breaks after "(". 7920 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7921 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7922 getGoogleStyle()); 7923 7924 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7925 " int LoooooooooooooooooooongParam2) {}"); 7926 verifyFormat( 7927 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7928 " SourceLocation L, IdentifierIn *II,\n" 7929 " Type *T) {}"); 7930 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7931 "ReallyReaaallyLongFunctionName(\n" 7932 " const std::string &SomeParameter,\n" 7933 " const SomeType<string, SomeOtherTemplateParameter>\n" 7934 " &ReallyReallyLongParameterName,\n" 7935 " const SomeType<string, SomeOtherTemplateParameter>\n" 7936 " &AnotherLongParameterName) {}"); 7937 verifyFormat("template <typename A>\n" 7938 "SomeLoooooooooooooooooooooongType<\n" 7939 " typename some_namespace::SomeOtherType<A>::Type>\n" 7940 "Function() {}"); 7941 7942 verifyGoogleFormat( 7943 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7944 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7945 verifyGoogleFormat( 7946 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7947 " SourceLocation L) {}"); 7948 verifyGoogleFormat( 7949 "some_namespace::LongReturnType\n" 7950 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7951 " int first_long_parameter, int second_parameter) {}"); 7952 7953 verifyGoogleFormat("template <typename T>\n" 7954 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7955 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7956 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7957 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7958 7959 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7960 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7961 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7962 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7963 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7964 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 7965 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7966 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 7967 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 7968 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7969 7970 verifyFormat("template <typename T> // Templates on own line.\n" 7971 "static int // Some comment.\n" 7972 "MyFunction(int a);", 7973 getLLVMStyle()); 7974 } 7975 7976 TEST_F(FormatTest, FormatsArrays) { 7977 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7978 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 7979 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 7980 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 7981 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 7982 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 7983 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7984 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7985 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7986 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 7987 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7988 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7989 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7990 verifyFormat( 7991 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 7992 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7993 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 7994 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 7995 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7996 7997 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 7998 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 7999 verifyFormat( 8000 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 8001 " .aaaaaaa[0]\n" 8002 " .aaaaaaaaaaaaaaaaaaaaaa();"); 8003 verifyFormat("a[::b::c];"); 8004 8005 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 8006 8007 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 8008 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 8009 } 8010 8011 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 8012 verifyFormat("(a)->b();"); 8013 verifyFormat("--a;"); 8014 } 8015 8016 TEST_F(FormatTest, HandlesIncludeDirectives) { 8017 verifyFormat("#include <string>\n" 8018 "#include <a/b/c.h>\n" 8019 "#include \"a/b/string\"\n" 8020 "#include \"string.h\"\n" 8021 "#include \"string.h\"\n" 8022 "#include <a-a>\n" 8023 "#include < path with space >\n" 8024 "#include_next <test.h>" 8025 "#include \"abc.h\" // this is included for ABC\n" 8026 "#include \"some long include\" // with a comment\n" 8027 "#include \"some very long include path\"\n" 8028 "#include <some/very/long/include/path>\n", 8029 getLLVMStyleWithColumns(35)); 8030 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 8031 EXPECT_EQ("#include <a>", format("#include<a>")); 8032 8033 verifyFormat("#import <string>"); 8034 verifyFormat("#import <a/b/c.h>"); 8035 verifyFormat("#import \"a/b/string\""); 8036 verifyFormat("#import \"string.h\""); 8037 verifyFormat("#import \"string.h\""); 8038 verifyFormat("#if __has_include(<strstream>)\n" 8039 "#include <strstream>\n" 8040 "#endif"); 8041 8042 verifyFormat("#define MY_IMPORT <a/b>"); 8043 8044 verifyFormat("#if __has_include(<a/b>)"); 8045 verifyFormat("#if __has_include_next(<a/b>)"); 8046 verifyFormat("#define F __has_include(<a/b>)"); 8047 verifyFormat("#define F __has_include_next(<a/b>)"); 8048 8049 // Protocol buffer definition or missing "#". 8050 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 8051 getLLVMStyleWithColumns(30)); 8052 8053 FormatStyle Style = getLLVMStyle(); 8054 Style.AlwaysBreakBeforeMultilineStrings = true; 8055 Style.ColumnLimit = 0; 8056 verifyFormat("#import \"abc.h\"", Style); 8057 8058 // But 'import' might also be a regular C++ namespace. 8059 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8060 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 8061 } 8062 8063 //===----------------------------------------------------------------------===// 8064 // Error recovery tests. 8065 //===----------------------------------------------------------------------===// 8066 8067 TEST_F(FormatTest, IncompleteParameterLists) { 8068 FormatStyle NoBinPacking = getLLVMStyle(); 8069 NoBinPacking.BinPackParameters = false; 8070 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 8071 " double *min_x,\n" 8072 " double *max_x,\n" 8073 " double *min_y,\n" 8074 " double *max_y,\n" 8075 " double *min_z,\n" 8076 " double *max_z, ) {}", 8077 NoBinPacking); 8078 } 8079 8080 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 8081 verifyFormat("void f() { return; }\n42"); 8082 verifyFormat("void f() {\n" 8083 " if (0)\n" 8084 " return;\n" 8085 "}\n" 8086 "42"); 8087 verifyFormat("void f() { return }\n42"); 8088 verifyFormat("void f() {\n" 8089 " if (0)\n" 8090 " return\n" 8091 "}\n" 8092 "42"); 8093 } 8094 8095 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 8096 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 8097 EXPECT_EQ("void f() {\n" 8098 " if (a)\n" 8099 " return\n" 8100 "}", 8101 format("void f ( ) { if ( a ) return }")); 8102 EXPECT_EQ("namespace N {\n" 8103 "void f()\n" 8104 "}", 8105 format("namespace N { void f() }")); 8106 EXPECT_EQ("namespace N {\n" 8107 "void f() {}\n" 8108 "void g()\n" 8109 "} // namespace N", 8110 format("namespace N { void f( ) { } void g( ) }")); 8111 } 8112 8113 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 8114 verifyFormat("int aaaaaaaa =\n" 8115 " // Overlylongcomment\n" 8116 " b;", 8117 getLLVMStyleWithColumns(20)); 8118 verifyFormat("function(\n" 8119 " ShortArgument,\n" 8120 " LoooooooooooongArgument);\n", 8121 getLLVMStyleWithColumns(20)); 8122 } 8123 8124 TEST_F(FormatTest, IncorrectAccessSpecifier) { 8125 verifyFormat("public:"); 8126 verifyFormat("class A {\n" 8127 "public\n" 8128 " void f() {}\n" 8129 "};"); 8130 verifyFormat("public\n" 8131 "int qwerty;"); 8132 verifyFormat("public\n" 8133 "B {}"); 8134 verifyFormat("public\n" 8135 "{}"); 8136 verifyFormat("public\n" 8137 "B { int x; }"); 8138 } 8139 8140 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 8141 verifyFormat("{"); 8142 verifyFormat("#})"); 8143 verifyNoCrash("(/**/[:!] ?[)."); 8144 } 8145 8146 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 8147 // Found by oss-fuzz: 8148 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 8149 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 8150 Style.ColumnLimit = 60; 8151 verifyNoCrash( 8152 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 8153 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 8154 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 8155 Style); 8156 } 8157 8158 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 8159 verifyFormat("do {\n}"); 8160 verifyFormat("do {\n}\n" 8161 "f();"); 8162 verifyFormat("do {\n}\n" 8163 "wheeee(fun);"); 8164 verifyFormat("do {\n" 8165 " f();\n" 8166 "}"); 8167 } 8168 8169 TEST_F(FormatTest, IncorrectCodeMissingParens) { 8170 verifyFormat("if {\n foo;\n foo();\n}"); 8171 verifyFormat("switch {\n foo;\n foo();\n}"); 8172 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 8173 verifyFormat("while {\n foo;\n foo();\n}"); 8174 verifyFormat("do {\n foo;\n foo();\n} while;"); 8175 } 8176 8177 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 8178 verifyIncompleteFormat("namespace {\n" 8179 "class Foo { Foo (\n" 8180 "};\n" 8181 "} // namespace"); 8182 } 8183 8184 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 8185 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 8186 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 8187 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 8188 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 8189 8190 EXPECT_EQ("{\n" 8191 " {\n" 8192 " breakme(\n" 8193 " qwe);\n" 8194 " }\n", 8195 format("{\n" 8196 " {\n" 8197 " breakme(qwe);\n" 8198 "}\n", 8199 getLLVMStyleWithColumns(10))); 8200 } 8201 8202 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 8203 verifyFormat("int x = {\n" 8204 " avariable,\n" 8205 " b(alongervariable)};", 8206 getLLVMStyleWithColumns(25)); 8207 } 8208 8209 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 8210 verifyFormat("return (a)(b){1, 2, 3};"); 8211 } 8212 8213 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 8214 verifyFormat("vector<int> x{1, 2, 3, 4};"); 8215 verifyFormat("vector<int> x{\n" 8216 " 1,\n" 8217 " 2,\n" 8218 " 3,\n" 8219 " 4,\n" 8220 "};"); 8221 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 8222 verifyFormat("f({1, 2});"); 8223 verifyFormat("auto v = Foo{-1};"); 8224 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 8225 verifyFormat("Class::Class : member{1, 2, 3} {}"); 8226 verifyFormat("new vector<int>{1, 2, 3};"); 8227 verifyFormat("new int[3]{1, 2, 3};"); 8228 verifyFormat("new int{1};"); 8229 verifyFormat("return {arg1, arg2};"); 8230 verifyFormat("return {arg1, SomeType{parameter}};"); 8231 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 8232 verifyFormat("new T{arg1, arg2};"); 8233 verifyFormat("f(MyMap[{composite, key}]);"); 8234 verifyFormat("class Class {\n" 8235 " T member = {arg1, arg2};\n" 8236 "};"); 8237 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 8238 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 8239 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 8240 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 8241 verifyFormat("int a = std::is_integral<int>{} + 0;"); 8242 8243 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8244 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8245 verifyFormat("auto i = decltype(x){};"); 8246 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 8247 verifyFormat("Node n{1, Node{1000}, //\n" 8248 " 2};"); 8249 verifyFormat("Aaaa aaaaaaa{\n" 8250 " {\n" 8251 " aaaa,\n" 8252 " },\n" 8253 "};"); 8254 verifyFormat("class C : public D {\n" 8255 " SomeClass SC{2};\n" 8256 "};"); 8257 verifyFormat("class C : public A {\n" 8258 " class D : public B {\n" 8259 " void f() { int i{2}; }\n" 8260 " };\n" 8261 "};"); 8262 verifyFormat("#define A {a, a},"); 8263 8264 // Avoid breaking between equal sign and opening brace 8265 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 8266 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 8267 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 8268 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 8269 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 8270 " {\"ccccccccccccccccccccc\", 2}};", 8271 AvoidBreakingFirstArgument); 8272 8273 // Binpacking only if there is no trailing comma 8274 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 8275 " cccccccccc, dddddddddd};", 8276 getLLVMStyleWithColumns(50)); 8277 verifyFormat("const Aaaaaa aaaaa = {\n" 8278 " aaaaaaaaaaa,\n" 8279 " bbbbbbbbbbb,\n" 8280 " ccccccccccc,\n" 8281 " ddddddddddd,\n" 8282 "};", 8283 getLLVMStyleWithColumns(50)); 8284 8285 // Cases where distinguising braced lists and blocks is hard. 8286 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 8287 verifyFormat("void f() {\n" 8288 " return; // comment\n" 8289 "}\n" 8290 "SomeType t;"); 8291 verifyFormat("void f() {\n" 8292 " if (a) {\n" 8293 " f();\n" 8294 " }\n" 8295 "}\n" 8296 "SomeType t;"); 8297 8298 // In combination with BinPackArguments = false. 8299 FormatStyle NoBinPacking = getLLVMStyle(); 8300 NoBinPacking.BinPackArguments = false; 8301 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 8302 " bbbbb,\n" 8303 " ccccc,\n" 8304 " ddddd,\n" 8305 " eeeee,\n" 8306 " ffffff,\n" 8307 " ggggg,\n" 8308 " hhhhhh,\n" 8309 " iiiiii,\n" 8310 " jjjjjj,\n" 8311 " kkkkkk};", 8312 NoBinPacking); 8313 verifyFormat("const Aaaaaa aaaaa = {\n" 8314 " aaaaa,\n" 8315 " bbbbb,\n" 8316 " ccccc,\n" 8317 " ddddd,\n" 8318 " eeeee,\n" 8319 " ffffff,\n" 8320 " ggggg,\n" 8321 " hhhhhh,\n" 8322 " iiiiii,\n" 8323 " jjjjjj,\n" 8324 " kkkkkk,\n" 8325 "};", 8326 NoBinPacking); 8327 verifyFormat( 8328 "const Aaaaaa aaaaa = {\n" 8329 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 8330 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 8331 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 8332 "};", 8333 NoBinPacking); 8334 8335 NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 8336 EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n" 8337 " CDDDP83848_BMCR_REGISTER,\n" 8338 " CDDDP83848_BMSR_REGISTER,\n" 8339 " CDDDP83848_RBR_REGISTER};", 8340 format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n" 8341 " CDDDP83848_BMSR_REGISTER,\n" 8342 " CDDDP83848_RBR_REGISTER};", 8343 NoBinPacking)); 8344 8345 // FIXME: The alignment of these trailing comments might be bad. Then again, 8346 // this might be utterly useless in real code. 8347 verifyFormat("Constructor::Constructor()\n" 8348 " : some_value{ //\n" 8349 " aaaaaaa, //\n" 8350 " bbbbbbb} {}"); 8351 8352 // In braced lists, the first comment is always assumed to belong to the 8353 // first element. Thus, it can be moved to the next or previous line as 8354 // appropriate. 8355 EXPECT_EQ("function({// First element:\n" 8356 " 1,\n" 8357 " // Second element:\n" 8358 " 2});", 8359 format("function({\n" 8360 " // First element:\n" 8361 " 1,\n" 8362 " // Second element:\n" 8363 " 2});")); 8364 EXPECT_EQ("std::vector<int> MyNumbers{\n" 8365 " // First element:\n" 8366 " 1,\n" 8367 " // Second element:\n" 8368 " 2};", 8369 format("std::vector<int> MyNumbers{// First element:\n" 8370 " 1,\n" 8371 " // Second element:\n" 8372 " 2};", 8373 getLLVMStyleWithColumns(30))); 8374 // A trailing comma should still lead to an enforced line break and no 8375 // binpacking. 8376 EXPECT_EQ("vector<int> SomeVector = {\n" 8377 " // aaa\n" 8378 " 1,\n" 8379 " 2,\n" 8380 "};", 8381 format("vector<int> SomeVector = { // aaa\n" 8382 " 1, 2, };")); 8383 8384 FormatStyle ExtraSpaces = getLLVMStyle(); 8385 ExtraSpaces.Cpp11BracedListStyle = false; 8386 ExtraSpaces.ColumnLimit = 75; 8387 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 8388 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 8389 verifyFormat("f({ 1, 2 });", ExtraSpaces); 8390 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 8391 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 8392 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 8393 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 8394 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 8395 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 8396 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 8397 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 8398 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 8399 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 8400 verifyFormat("class Class {\n" 8401 " T member = { arg1, arg2 };\n" 8402 "};", 8403 ExtraSpaces); 8404 verifyFormat( 8405 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8406 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 8407 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 8408 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 8409 ExtraSpaces); 8410 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 8411 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 8412 ExtraSpaces); 8413 verifyFormat( 8414 "someFunction(OtherParam,\n" 8415 " BracedList{ // comment 1 (Forcing interesting break)\n" 8416 " param1, param2,\n" 8417 " // comment 2\n" 8418 " param3, param4 });", 8419 ExtraSpaces); 8420 verifyFormat( 8421 "std::this_thread::sleep_for(\n" 8422 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 8423 ExtraSpaces); 8424 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 8425 " aaaaaaa,\n" 8426 " aaaaaaaaaa,\n" 8427 " aaaaa,\n" 8428 " aaaaaaaaaaaaaaa,\n" 8429 " aaa,\n" 8430 " aaaaaaaaaa,\n" 8431 " a,\n" 8432 " aaaaaaaaaaaaaaaaaaaaa,\n" 8433 " aaaaaaaaaaaa,\n" 8434 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 8435 " aaaaaaa,\n" 8436 " a};"); 8437 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 8438 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 8439 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 8440 8441 // Avoid breaking between initializer/equal sign and opening brace 8442 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 8443 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 8444 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8445 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8446 " { \"ccccccccccccccccccccc\", 2 }\n" 8447 "};", 8448 ExtraSpaces); 8449 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 8450 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8451 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8452 " { \"ccccccccccccccccccccc\", 2 }\n" 8453 "};", 8454 ExtraSpaces); 8455 8456 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 8457 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 8458 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 8459 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 8460 8461 FormatStyle SpaceBetweenBraces = getLLVMStyle(); 8462 SpaceBetweenBraces.SpacesInAngles = true; 8463 SpaceBetweenBraces.SpacesInParentheses = true; 8464 SpaceBetweenBraces.SpacesInSquareBrackets = true; 8465 verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces); 8466 verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces); 8467 verifyFormat("vector< int > x{ // comment 1\n" 8468 " 1, 2, 3, 4 };", 8469 SpaceBetweenBraces); 8470 SpaceBetweenBraces.ColumnLimit = 20; 8471 EXPECT_EQ("vector< int > x{\n" 8472 " 1, 2, 3, 4 };", 8473 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8474 SpaceBetweenBraces.ColumnLimit = 24; 8475 EXPECT_EQ("vector< int > x{ 1, 2,\n" 8476 " 3, 4 };", 8477 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8478 EXPECT_EQ("vector< int > x{\n" 8479 " 1,\n" 8480 " 2,\n" 8481 " 3,\n" 8482 " 4,\n" 8483 "};", 8484 format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces)); 8485 verifyFormat("vector< int > x{};", SpaceBetweenBraces); 8486 SpaceBetweenBraces.SpaceInEmptyParentheses = true; 8487 verifyFormat("vector< int > x{ };", SpaceBetweenBraces); 8488 } 8489 8490 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 8491 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8492 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8493 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8494 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8495 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8496 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8497 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 8498 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8499 " 1, 22, 333, 4444, 55555, //\n" 8500 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8501 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8502 verifyFormat( 8503 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8504 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8505 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 8506 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8507 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8508 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8509 " 7777777};"); 8510 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8511 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8512 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8513 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8514 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8515 " // Separating comment.\n" 8516 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8517 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8518 " // Leading comment\n" 8519 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8520 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8521 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8522 " 1, 1, 1, 1};", 8523 getLLVMStyleWithColumns(39)); 8524 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8525 " 1, 1, 1, 1};", 8526 getLLVMStyleWithColumns(38)); 8527 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 8528 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 8529 getLLVMStyleWithColumns(43)); 8530 verifyFormat( 8531 "static unsigned SomeValues[10][3] = {\n" 8532 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 8533 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 8534 verifyFormat("static auto fields = new vector<string>{\n" 8535 " \"aaaaaaaaaaaaa\",\n" 8536 " \"aaaaaaaaaaaaa\",\n" 8537 " \"aaaaaaaaaaaa\",\n" 8538 " \"aaaaaaaaaaaaaa\",\n" 8539 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8540 " \"aaaaaaaaaaaa\",\n" 8541 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8542 "};"); 8543 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 8544 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 8545 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 8546 " 3, cccccccccccccccccccccc};", 8547 getLLVMStyleWithColumns(60)); 8548 8549 // Trailing commas. 8550 verifyFormat("vector<int> x = {\n" 8551 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 8552 "};", 8553 getLLVMStyleWithColumns(39)); 8554 verifyFormat("vector<int> x = {\n" 8555 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 8556 "};", 8557 getLLVMStyleWithColumns(39)); 8558 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8559 " 1, 1, 1, 1,\n" 8560 " /**/ /**/};", 8561 getLLVMStyleWithColumns(39)); 8562 8563 // Trailing comment in the first line. 8564 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 8565 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 8566 " 111111111, 222222222, 3333333333, 444444444, //\n" 8567 " 11111111, 22222222, 333333333, 44444444};"); 8568 // Trailing comment in the last line. 8569 verifyFormat("int aaaaa[] = {\n" 8570 " 1, 2, 3, // comment\n" 8571 " 4, 5, 6 // comment\n" 8572 "};"); 8573 8574 // With nested lists, we should either format one item per line or all nested 8575 // lists one on line. 8576 // FIXME: For some nested lists, we can do better. 8577 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 8578 " {aaaaaaaaaaaaaaaaaaa},\n" 8579 " {aaaaaaaaaaaaaaaaaaaaa},\n" 8580 " {aaaaaaaaaaaaaaaaa}};", 8581 getLLVMStyleWithColumns(60)); 8582 verifyFormat( 8583 "SomeStruct my_struct_array = {\n" 8584 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 8585 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 8586 " {aaa, aaa},\n" 8587 " {aaa, aaa},\n" 8588 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 8589 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 8590 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 8591 8592 // No column layout should be used here. 8593 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 8594 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 8595 8596 verifyNoCrash("a<,"); 8597 8598 // No braced initializer here. 8599 verifyFormat("void f() {\n" 8600 " struct Dummy {};\n" 8601 " f(v);\n" 8602 "}"); 8603 8604 // Long lists should be formatted in columns even if they are nested. 8605 verifyFormat( 8606 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8607 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8608 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8609 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8610 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8611 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 8612 8613 // Allow "single-column" layout even if that violates the column limit. There 8614 // isn't going to be a better way. 8615 verifyFormat("std::vector<int> a = {\n" 8616 " aaaaaaaa,\n" 8617 " aaaaaaaa,\n" 8618 " aaaaaaaa,\n" 8619 " aaaaaaaa,\n" 8620 " aaaaaaaaaa,\n" 8621 " aaaaaaaa,\n" 8622 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 8623 getLLVMStyleWithColumns(30)); 8624 verifyFormat("vector<int> aaaa = {\n" 8625 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8626 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8627 " aaaaaa.aaaaaaa,\n" 8628 " aaaaaa.aaaaaaa,\n" 8629 " aaaaaa.aaaaaaa,\n" 8630 " aaaaaa.aaaaaaa,\n" 8631 "};"); 8632 8633 // Don't create hanging lists. 8634 verifyFormat("someFunction(Param, {List1, List2,\n" 8635 " List3});", 8636 getLLVMStyleWithColumns(35)); 8637 verifyFormat("someFunction(Param, Param,\n" 8638 " {List1, List2,\n" 8639 " List3});", 8640 getLLVMStyleWithColumns(35)); 8641 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 8642 " aaaaaaaaaaaaaaaaaaaaaaa);"); 8643 } 8644 8645 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 8646 FormatStyle DoNotMerge = getLLVMStyle(); 8647 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8648 8649 verifyFormat("void f() { return 42; }"); 8650 verifyFormat("void f() {\n" 8651 " return 42;\n" 8652 "}", 8653 DoNotMerge); 8654 verifyFormat("void f() {\n" 8655 " // Comment\n" 8656 "}"); 8657 verifyFormat("{\n" 8658 "#error {\n" 8659 " int a;\n" 8660 "}"); 8661 verifyFormat("{\n" 8662 " int a;\n" 8663 "#error {\n" 8664 "}"); 8665 verifyFormat("void f() {} // comment"); 8666 verifyFormat("void f() { int a; } // comment"); 8667 verifyFormat("void f() {\n" 8668 "} // comment", 8669 DoNotMerge); 8670 verifyFormat("void f() {\n" 8671 " int a;\n" 8672 "} // comment", 8673 DoNotMerge); 8674 verifyFormat("void f() {\n" 8675 "} // comment", 8676 getLLVMStyleWithColumns(15)); 8677 8678 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 8679 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 8680 8681 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 8682 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 8683 verifyFormat("class C {\n" 8684 " C()\n" 8685 " : iiiiiiii(nullptr),\n" 8686 " kkkkkkk(nullptr),\n" 8687 " mmmmmmm(nullptr),\n" 8688 " nnnnnnn(nullptr) {}\n" 8689 "};", 8690 getGoogleStyle()); 8691 8692 FormatStyle NoColumnLimit = getLLVMStyle(); 8693 NoColumnLimit.ColumnLimit = 0; 8694 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 8695 EXPECT_EQ("class C {\n" 8696 " A() : b(0) {}\n" 8697 "};", 8698 format("class C{A():b(0){}};", NoColumnLimit)); 8699 EXPECT_EQ("A()\n" 8700 " : b(0) {\n" 8701 "}", 8702 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 8703 8704 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 8705 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 8706 FormatStyle::SFS_None; 8707 EXPECT_EQ("A()\n" 8708 " : b(0) {\n" 8709 "}", 8710 format("A():b(0){}", DoNotMergeNoColumnLimit)); 8711 EXPECT_EQ("A()\n" 8712 " : b(0) {\n" 8713 "}", 8714 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 8715 8716 verifyFormat("#define A \\\n" 8717 " void f() { \\\n" 8718 " int i; \\\n" 8719 " }", 8720 getLLVMStyleWithColumns(20)); 8721 verifyFormat("#define A \\\n" 8722 " void f() { int i; }", 8723 getLLVMStyleWithColumns(21)); 8724 verifyFormat("#define A \\\n" 8725 " void f() { \\\n" 8726 " int i; \\\n" 8727 " } \\\n" 8728 " int j;", 8729 getLLVMStyleWithColumns(22)); 8730 verifyFormat("#define A \\\n" 8731 " void f() { int i; } \\\n" 8732 " int j;", 8733 getLLVMStyleWithColumns(23)); 8734 } 8735 8736 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 8737 FormatStyle MergeEmptyOnly = getLLVMStyle(); 8738 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8739 verifyFormat("class C {\n" 8740 " int f() {}\n" 8741 "};", 8742 MergeEmptyOnly); 8743 verifyFormat("class C {\n" 8744 " int f() {\n" 8745 " return 42;\n" 8746 " }\n" 8747 "};", 8748 MergeEmptyOnly); 8749 verifyFormat("int f() {}", MergeEmptyOnly); 8750 verifyFormat("int f() {\n" 8751 " return 42;\n" 8752 "}", 8753 MergeEmptyOnly); 8754 8755 // Also verify behavior when BraceWrapping.AfterFunction = true 8756 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8757 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 8758 verifyFormat("int f() {}", MergeEmptyOnly); 8759 verifyFormat("class C {\n" 8760 " int f() {}\n" 8761 "};", 8762 MergeEmptyOnly); 8763 } 8764 8765 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 8766 FormatStyle MergeInlineOnly = getLLVMStyle(); 8767 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8768 verifyFormat("class C {\n" 8769 " int f() { return 42; }\n" 8770 "};", 8771 MergeInlineOnly); 8772 verifyFormat("int f() {\n" 8773 " return 42;\n" 8774 "}", 8775 MergeInlineOnly); 8776 8777 // SFS_Inline implies SFS_Empty 8778 verifyFormat("class C {\n" 8779 " int f() {}\n" 8780 "};", 8781 MergeInlineOnly); 8782 verifyFormat("int f() {}", MergeInlineOnly); 8783 8784 // Also verify behavior when BraceWrapping.AfterFunction = true 8785 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8786 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8787 verifyFormat("class C {\n" 8788 " int f() { return 42; }\n" 8789 "};", 8790 MergeInlineOnly); 8791 verifyFormat("int f()\n" 8792 "{\n" 8793 " return 42;\n" 8794 "}", 8795 MergeInlineOnly); 8796 8797 // SFS_Inline implies SFS_Empty 8798 verifyFormat("int f() {}", MergeInlineOnly); 8799 verifyFormat("class C {\n" 8800 " int f() {}\n" 8801 "};", 8802 MergeInlineOnly); 8803 } 8804 8805 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8806 FormatStyle MergeInlineOnly = getLLVMStyle(); 8807 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8808 FormatStyle::SFS_InlineOnly; 8809 verifyFormat("class C {\n" 8810 " int f() { return 42; }\n" 8811 "};", 8812 MergeInlineOnly); 8813 verifyFormat("int f() {\n" 8814 " return 42;\n" 8815 "}", 8816 MergeInlineOnly); 8817 8818 // SFS_InlineOnly does not imply SFS_Empty 8819 verifyFormat("class C {\n" 8820 " int f() {}\n" 8821 "};", 8822 MergeInlineOnly); 8823 verifyFormat("int f() {\n" 8824 "}", 8825 MergeInlineOnly); 8826 8827 // Also verify behavior when BraceWrapping.AfterFunction = true 8828 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8829 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8830 verifyFormat("class C {\n" 8831 " int f() { return 42; }\n" 8832 "};", 8833 MergeInlineOnly); 8834 verifyFormat("int f()\n" 8835 "{\n" 8836 " return 42;\n" 8837 "}", 8838 MergeInlineOnly); 8839 8840 // SFS_InlineOnly does not imply SFS_Empty 8841 verifyFormat("int f()\n" 8842 "{\n" 8843 "}", 8844 MergeInlineOnly); 8845 verifyFormat("class C {\n" 8846 " int f() {}\n" 8847 "};", 8848 MergeInlineOnly); 8849 } 8850 8851 TEST_F(FormatTest, SplitEmptyFunction) { 8852 FormatStyle Style = getLLVMStyle(); 8853 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8854 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8855 Style.BraceWrapping.AfterFunction = true; 8856 Style.BraceWrapping.SplitEmptyFunction = false; 8857 Style.ColumnLimit = 40; 8858 8859 verifyFormat("int f()\n" 8860 "{}", 8861 Style); 8862 verifyFormat("int f()\n" 8863 "{\n" 8864 " return 42;\n" 8865 "}", 8866 Style); 8867 verifyFormat("int f()\n" 8868 "{\n" 8869 " // some comment\n" 8870 "}", 8871 Style); 8872 8873 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8874 verifyFormat("int f() {}", Style); 8875 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8876 "{}", 8877 Style); 8878 verifyFormat("int f()\n" 8879 "{\n" 8880 " return 0;\n" 8881 "}", 8882 Style); 8883 8884 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8885 verifyFormat("class Foo {\n" 8886 " int f() {}\n" 8887 "};\n", 8888 Style); 8889 verifyFormat("class Foo {\n" 8890 " int f() { return 0; }\n" 8891 "};\n", 8892 Style); 8893 verifyFormat("class Foo {\n" 8894 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8895 " {}\n" 8896 "};\n", 8897 Style); 8898 verifyFormat("class Foo {\n" 8899 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8900 " {\n" 8901 " return 0;\n" 8902 " }\n" 8903 "};\n", 8904 Style); 8905 8906 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8907 verifyFormat("int f() {}", Style); 8908 verifyFormat("int f() { return 0; }", Style); 8909 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8910 "{}", 8911 Style); 8912 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8913 "{\n" 8914 " return 0;\n" 8915 "}", 8916 Style); 8917 } 8918 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8919 FormatStyle Style = getLLVMStyle(); 8920 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8921 verifyFormat("#ifdef A\n" 8922 "int f() {}\n" 8923 "#else\n" 8924 "int g() {}\n" 8925 "#endif", 8926 Style); 8927 } 8928 8929 TEST_F(FormatTest, SplitEmptyClass) { 8930 FormatStyle Style = getLLVMStyle(); 8931 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8932 Style.BraceWrapping.AfterClass = true; 8933 Style.BraceWrapping.SplitEmptyRecord = false; 8934 8935 verifyFormat("class Foo\n" 8936 "{};", 8937 Style); 8938 verifyFormat("/* something */ class Foo\n" 8939 "{};", 8940 Style); 8941 verifyFormat("template <typename X> class Foo\n" 8942 "{};", 8943 Style); 8944 verifyFormat("class Foo\n" 8945 "{\n" 8946 " Foo();\n" 8947 "};", 8948 Style); 8949 verifyFormat("typedef class Foo\n" 8950 "{\n" 8951 "} Foo_t;", 8952 Style); 8953 } 8954 8955 TEST_F(FormatTest, SplitEmptyStruct) { 8956 FormatStyle Style = getLLVMStyle(); 8957 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8958 Style.BraceWrapping.AfterStruct = true; 8959 Style.BraceWrapping.SplitEmptyRecord = false; 8960 8961 verifyFormat("struct Foo\n" 8962 "{};", 8963 Style); 8964 verifyFormat("/* something */ struct Foo\n" 8965 "{};", 8966 Style); 8967 verifyFormat("template <typename X> struct Foo\n" 8968 "{};", 8969 Style); 8970 verifyFormat("struct Foo\n" 8971 "{\n" 8972 " Foo();\n" 8973 "};", 8974 Style); 8975 verifyFormat("typedef struct Foo\n" 8976 "{\n" 8977 "} Foo_t;", 8978 Style); 8979 // typedef struct Bar {} Bar_t; 8980 } 8981 8982 TEST_F(FormatTest, SplitEmptyUnion) { 8983 FormatStyle Style = getLLVMStyle(); 8984 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8985 Style.BraceWrapping.AfterUnion = true; 8986 Style.BraceWrapping.SplitEmptyRecord = false; 8987 8988 verifyFormat("union Foo\n" 8989 "{};", 8990 Style); 8991 verifyFormat("/* something */ union Foo\n" 8992 "{};", 8993 Style); 8994 verifyFormat("union Foo\n" 8995 "{\n" 8996 " A,\n" 8997 "};", 8998 Style); 8999 verifyFormat("typedef union Foo\n" 9000 "{\n" 9001 "} Foo_t;", 9002 Style); 9003 } 9004 9005 TEST_F(FormatTest, SplitEmptyNamespace) { 9006 FormatStyle Style = getLLVMStyle(); 9007 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9008 Style.BraceWrapping.AfterNamespace = true; 9009 Style.BraceWrapping.SplitEmptyNamespace = false; 9010 9011 verifyFormat("namespace Foo\n" 9012 "{};", 9013 Style); 9014 verifyFormat("/* something */ namespace Foo\n" 9015 "{};", 9016 Style); 9017 verifyFormat("inline namespace Foo\n" 9018 "{};", 9019 Style); 9020 verifyFormat("/* something */ inline namespace Foo\n" 9021 "{};", 9022 Style); 9023 verifyFormat("export namespace Foo\n" 9024 "{};", 9025 Style); 9026 verifyFormat("namespace Foo\n" 9027 "{\n" 9028 "void Bar();\n" 9029 "};", 9030 Style); 9031 } 9032 9033 TEST_F(FormatTest, NeverMergeShortRecords) { 9034 FormatStyle Style = getLLVMStyle(); 9035 9036 verifyFormat("class Foo {\n" 9037 " Foo();\n" 9038 "};", 9039 Style); 9040 verifyFormat("typedef class Foo {\n" 9041 " Foo();\n" 9042 "} Foo_t;", 9043 Style); 9044 verifyFormat("struct Foo {\n" 9045 " Foo();\n" 9046 "};", 9047 Style); 9048 verifyFormat("typedef struct Foo {\n" 9049 " Foo();\n" 9050 "} Foo_t;", 9051 Style); 9052 verifyFormat("union Foo {\n" 9053 " A,\n" 9054 "};", 9055 Style); 9056 verifyFormat("typedef union Foo {\n" 9057 " A,\n" 9058 "} Foo_t;", 9059 Style); 9060 verifyFormat("namespace Foo {\n" 9061 "void Bar();\n" 9062 "};", 9063 Style); 9064 9065 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9066 Style.BraceWrapping.AfterClass = true; 9067 Style.BraceWrapping.AfterStruct = true; 9068 Style.BraceWrapping.AfterUnion = true; 9069 Style.BraceWrapping.AfterNamespace = true; 9070 verifyFormat("class Foo\n" 9071 "{\n" 9072 " Foo();\n" 9073 "};", 9074 Style); 9075 verifyFormat("typedef class Foo\n" 9076 "{\n" 9077 " Foo();\n" 9078 "} Foo_t;", 9079 Style); 9080 verifyFormat("struct Foo\n" 9081 "{\n" 9082 " Foo();\n" 9083 "};", 9084 Style); 9085 verifyFormat("typedef struct Foo\n" 9086 "{\n" 9087 " Foo();\n" 9088 "} Foo_t;", 9089 Style); 9090 verifyFormat("union Foo\n" 9091 "{\n" 9092 " A,\n" 9093 "};", 9094 Style); 9095 verifyFormat("typedef union Foo\n" 9096 "{\n" 9097 " A,\n" 9098 "} Foo_t;", 9099 Style); 9100 verifyFormat("namespace Foo\n" 9101 "{\n" 9102 "void Bar();\n" 9103 "};", 9104 Style); 9105 } 9106 9107 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 9108 // Elaborate type variable declarations. 9109 verifyFormat("struct foo a = {bar};\nint n;"); 9110 verifyFormat("class foo a = {bar};\nint n;"); 9111 verifyFormat("union foo a = {bar};\nint n;"); 9112 9113 // Elaborate types inside function definitions. 9114 verifyFormat("struct foo f() {}\nint n;"); 9115 verifyFormat("class foo f() {}\nint n;"); 9116 verifyFormat("union foo f() {}\nint n;"); 9117 9118 // Templates. 9119 verifyFormat("template <class X> void f() {}\nint n;"); 9120 verifyFormat("template <struct X> void f() {}\nint n;"); 9121 verifyFormat("template <union X> void f() {}\nint n;"); 9122 9123 // Actual definitions... 9124 verifyFormat("struct {\n} n;"); 9125 verifyFormat( 9126 "template <template <class T, class Y>, class Z> class X {\n} n;"); 9127 verifyFormat("union Z {\n int n;\n} x;"); 9128 verifyFormat("class MACRO Z {\n} n;"); 9129 verifyFormat("class MACRO(X) Z {\n} n;"); 9130 verifyFormat("class __attribute__(X) Z {\n} n;"); 9131 verifyFormat("class __declspec(X) Z {\n} n;"); 9132 verifyFormat("class A##B##C {\n} n;"); 9133 verifyFormat("class alignas(16) Z {\n} n;"); 9134 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 9135 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 9136 9137 // Redefinition from nested context: 9138 verifyFormat("class A::B::C {\n} n;"); 9139 9140 // Template definitions. 9141 verifyFormat( 9142 "template <typename F>\n" 9143 "Matcher(const Matcher<F> &Other,\n" 9144 " typename enable_if_c<is_base_of<F, T>::value &&\n" 9145 " !is_same<F, T>::value>::type * = 0)\n" 9146 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 9147 9148 // FIXME: This is still incorrectly handled at the formatter side. 9149 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 9150 verifyFormat("int i = SomeFunction(a<b, a> b);"); 9151 9152 // FIXME: 9153 // This now gets parsed incorrectly as class definition. 9154 // verifyFormat("class A<int> f() {\n}\nint n;"); 9155 9156 // Elaborate types where incorrectly parsing the structural element would 9157 // break the indent. 9158 verifyFormat("if (true)\n" 9159 " class X x;\n" 9160 "else\n" 9161 " f();\n"); 9162 9163 // This is simply incomplete. Formatting is not important, but must not crash. 9164 verifyFormat("class A:"); 9165 } 9166 9167 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 9168 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 9169 format("#error Leave all white!!!!! space* alone!\n")); 9170 EXPECT_EQ( 9171 "#warning Leave all white!!!!! space* alone!\n", 9172 format("#warning Leave all white!!!!! space* alone!\n")); 9173 EXPECT_EQ("#error 1", format(" # error 1")); 9174 EXPECT_EQ("#warning 1", format(" # warning 1")); 9175 } 9176 9177 TEST_F(FormatTest, FormatHashIfExpressions) { 9178 verifyFormat("#if AAAA && BBBB"); 9179 verifyFormat("#if (AAAA && BBBB)"); 9180 verifyFormat("#elif (AAAA && BBBB)"); 9181 // FIXME: Come up with a better indentation for #elif. 9182 verifyFormat( 9183 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 9184 " defined(BBBBBBBB)\n" 9185 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 9186 " defined(BBBBBBBB)\n" 9187 "#endif", 9188 getLLVMStyleWithColumns(65)); 9189 } 9190 9191 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 9192 FormatStyle AllowsMergedIf = getGoogleStyle(); 9193 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 9194 FormatStyle::SIS_WithoutElse; 9195 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 9196 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 9197 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 9198 EXPECT_EQ("if (true) return 42;", 9199 format("if (true)\nreturn 42;", AllowsMergedIf)); 9200 FormatStyle ShortMergedIf = AllowsMergedIf; 9201 ShortMergedIf.ColumnLimit = 25; 9202 verifyFormat("#define A \\\n" 9203 " if (true) return 42;", 9204 ShortMergedIf); 9205 verifyFormat("#define A \\\n" 9206 " f(); \\\n" 9207 " if (true)\n" 9208 "#define B", 9209 ShortMergedIf); 9210 verifyFormat("#define A \\\n" 9211 " f(); \\\n" 9212 " if (true)\n" 9213 "g();", 9214 ShortMergedIf); 9215 verifyFormat("{\n" 9216 "#ifdef A\n" 9217 " // Comment\n" 9218 " if (true) continue;\n" 9219 "#endif\n" 9220 " // Comment\n" 9221 " if (true) continue;\n" 9222 "}", 9223 ShortMergedIf); 9224 ShortMergedIf.ColumnLimit = 33; 9225 verifyFormat("#define A \\\n" 9226 " if constexpr (true) return 42;", 9227 ShortMergedIf); 9228 verifyFormat("#define A \\\n" 9229 " if CONSTEXPR (true) return 42;", 9230 ShortMergedIf); 9231 ShortMergedIf.ColumnLimit = 29; 9232 verifyFormat("#define A \\\n" 9233 " if (aaaaaaaaaa) return 1; \\\n" 9234 " return 2;", 9235 ShortMergedIf); 9236 ShortMergedIf.ColumnLimit = 28; 9237 verifyFormat("#define A \\\n" 9238 " if (aaaaaaaaaa) \\\n" 9239 " return 1; \\\n" 9240 " return 2;", 9241 ShortMergedIf); 9242 verifyFormat("#define A \\\n" 9243 " if constexpr (aaaaaaa) \\\n" 9244 " return 1; \\\n" 9245 " return 2;", 9246 ShortMergedIf); 9247 verifyFormat("#define A \\\n" 9248 " if CONSTEXPR (aaaaaaa) \\\n" 9249 " return 1; \\\n" 9250 " return 2;", 9251 ShortMergedIf); 9252 } 9253 9254 TEST_F(FormatTest, FormatStarDependingOnContext) { 9255 verifyFormat("void f(int *a);"); 9256 verifyFormat("void f() { f(fint * b); }"); 9257 verifyFormat("class A {\n void f(int *a);\n};"); 9258 verifyFormat("class A {\n int *a;\n};"); 9259 verifyFormat("namespace a {\n" 9260 "namespace b {\n" 9261 "class A {\n" 9262 " void f() {}\n" 9263 " int *a;\n" 9264 "};\n" 9265 "} // namespace b\n" 9266 "} // namespace a"); 9267 } 9268 9269 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 9270 verifyFormat("while"); 9271 verifyFormat("operator"); 9272 } 9273 9274 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 9275 // This code would be painfully slow to format if we didn't skip it. 9276 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 9277 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9278 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9279 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9280 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9281 "A(1, 1)\n" 9282 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 9283 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9284 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9285 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9286 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9287 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9288 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9289 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9290 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9291 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 9292 // Deeply nested part is untouched, rest is formatted. 9293 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 9294 format(std::string("int i;\n") + Code + "int j;\n", 9295 getLLVMStyle(), SC_ExpectIncomplete)); 9296 } 9297 9298 //===----------------------------------------------------------------------===// 9299 // Objective-C tests. 9300 //===----------------------------------------------------------------------===// 9301 9302 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 9303 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 9304 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 9305 format("-(NSUInteger)indexOfObject:(id)anObject;")); 9306 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 9307 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 9308 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 9309 format("-(NSInteger)Method3:(id)anObject;")); 9310 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 9311 format("-(NSInteger)Method4:(id)anObject;")); 9312 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 9313 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 9314 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 9315 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 9316 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9317 "forAllCells:(BOOL)flag;", 9318 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9319 "forAllCells:(BOOL)flag;")); 9320 9321 // Very long objectiveC method declaration. 9322 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 9323 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 9324 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 9325 " inRange:(NSRange)range\n" 9326 " outRange:(NSRange)out_range\n" 9327 " outRange1:(NSRange)out_range1\n" 9328 " outRange2:(NSRange)out_range2\n" 9329 " outRange3:(NSRange)out_range3\n" 9330 " outRange4:(NSRange)out_range4\n" 9331 " outRange5:(NSRange)out_range5\n" 9332 " outRange6:(NSRange)out_range6\n" 9333 " outRange7:(NSRange)out_range7\n" 9334 " outRange8:(NSRange)out_range8\n" 9335 " outRange9:(NSRange)out_range9;"); 9336 9337 // When the function name has to be wrapped. 9338 FormatStyle Style = getLLVMStyle(); 9339 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 9340 // and always indents instead. 9341 Style.IndentWrappedFunctionNames = false; 9342 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9343 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 9344 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 9345 "}", 9346 Style); 9347 Style.IndentWrappedFunctionNames = true; 9348 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9349 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 9350 " anotherName:(NSString)dddddddddddddd {\n" 9351 "}", 9352 Style); 9353 9354 verifyFormat("- (int)sum:(vector<int>)numbers;"); 9355 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 9356 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 9357 // protocol lists (but not for template classes): 9358 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 9359 9360 verifyFormat("- (int (*)())foo:(int (*)())f;"); 9361 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 9362 9363 // If there's no return type (very rare in practice!), LLVM and Google style 9364 // agree. 9365 verifyFormat("- foo;"); 9366 verifyFormat("- foo:(int)f;"); 9367 verifyGoogleFormat("- foo:(int)foo;"); 9368 } 9369 9370 TEST_F(FormatTest, BreaksStringLiterals) { 9371 EXPECT_EQ("\"some text \"\n" 9372 "\"other\";", 9373 format("\"some text other\";", getLLVMStyleWithColumns(12))); 9374 EXPECT_EQ("\"some text \"\n" 9375 "\"other\";", 9376 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 9377 EXPECT_EQ( 9378 "#define A \\\n" 9379 " \"some \" \\\n" 9380 " \"text \" \\\n" 9381 " \"other\";", 9382 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 9383 EXPECT_EQ( 9384 "#define A \\\n" 9385 " \"so \" \\\n" 9386 " \"text \" \\\n" 9387 " \"other\";", 9388 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 9389 9390 EXPECT_EQ("\"some text\"", 9391 format("\"some text\"", getLLVMStyleWithColumns(1))); 9392 EXPECT_EQ("\"some text\"", 9393 format("\"some text\"", getLLVMStyleWithColumns(11))); 9394 EXPECT_EQ("\"some \"\n" 9395 "\"text\"", 9396 format("\"some text\"", getLLVMStyleWithColumns(10))); 9397 EXPECT_EQ("\"some \"\n" 9398 "\"text\"", 9399 format("\"some text\"", getLLVMStyleWithColumns(7))); 9400 EXPECT_EQ("\"some\"\n" 9401 "\" tex\"\n" 9402 "\"t\"", 9403 format("\"some text\"", getLLVMStyleWithColumns(6))); 9404 EXPECT_EQ("\"some\"\n" 9405 "\" tex\"\n" 9406 "\" and\"", 9407 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 9408 EXPECT_EQ("\"some\"\n" 9409 "\"/tex\"\n" 9410 "\"/and\"", 9411 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 9412 9413 EXPECT_EQ("variable =\n" 9414 " \"long string \"\n" 9415 " \"literal\";", 9416 format("variable = \"long string literal\";", 9417 getLLVMStyleWithColumns(20))); 9418 9419 EXPECT_EQ("variable = f(\n" 9420 " \"long string \"\n" 9421 " \"literal\",\n" 9422 " short,\n" 9423 " loooooooooooooooooooong);", 9424 format("variable = f(\"long string literal\", short, " 9425 "loooooooooooooooooooong);", 9426 getLLVMStyleWithColumns(20))); 9427 9428 EXPECT_EQ( 9429 "f(g(\"long string \"\n" 9430 " \"literal\"),\n" 9431 " b);", 9432 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 9433 EXPECT_EQ("f(g(\"long string \"\n" 9434 " \"literal\",\n" 9435 " a),\n" 9436 " b);", 9437 format("f(g(\"long string literal\", a), b);", 9438 getLLVMStyleWithColumns(20))); 9439 EXPECT_EQ( 9440 "f(\"one two\".split(\n" 9441 " variable));", 9442 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 9443 EXPECT_EQ("f(\"one two three four five six \"\n" 9444 " \"seven\".split(\n" 9445 " really_looooong_variable));", 9446 format("f(\"one two three four five six seven\"." 9447 "split(really_looooong_variable));", 9448 getLLVMStyleWithColumns(33))); 9449 9450 EXPECT_EQ("f(\"some \"\n" 9451 " \"text\",\n" 9452 " other);", 9453 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 9454 9455 // Only break as a last resort. 9456 verifyFormat( 9457 "aaaaaaaaaaaaaaaaaaaa(\n" 9458 " aaaaaaaaaaaaaaaaaaaa,\n" 9459 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 9460 9461 EXPECT_EQ("\"splitmea\"\n" 9462 "\"trandomp\"\n" 9463 "\"oint\"", 9464 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 9465 9466 EXPECT_EQ("\"split/\"\n" 9467 "\"pathat/\"\n" 9468 "\"slashes\"", 9469 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9470 9471 EXPECT_EQ("\"split/\"\n" 9472 "\"pathat/\"\n" 9473 "\"slashes\"", 9474 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9475 EXPECT_EQ("\"split at \"\n" 9476 "\"spaces/at/\"\n" 9477 "\"slashes.at.any$\"\n" 9478 "\"non-alphanumeric%\"\n" 9479 "\"1111111111characte\"\n" 9480 "\"rs\"", 9481 format("\"split at " 9482 "spaces/at/" 9483 "slashes.at." 9484 "any$non-" 9485 "alphanumeric%" 9486 "1111111111characte" 9487 "rs\"", 9488 getLLVMStyleWithColumns(20))); 9489 9490 // Verify that splitting the strings understands 9491 // Style::AlwaysBreakBeforeMultilineStrings. 9492 EXPECT_EQ("aaaaaaaaaaaa(\n" 9493 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 9494 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 9495 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 9496 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9497 "aaaaaaaaaaaaaaaaaaaaaa\");", 9498 getGoogleStyle())); 9499 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9500 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 9501 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 9502 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9503 "aaaaaaaaaaaaaaaaaaaaaa\";", 9504 getGoogleStyle())); 9505 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9506 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9507 format("llvm::outs() << " 9508 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 9509 "aaaaaaaaaaaaaaaaaaa\";")); 9510 EXPECT_EQ("ffff(\n" 9511 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9512 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9513 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 9514 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9515 getGoogleStyle())); 9516 9517 FormatStyle Style = getLLVMStyleWithColumns(12); 9518 Style.BreakStringLiterals = false; 9519 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 9520 9521 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 9522 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9523 EXPECT_EQ("#define A \\\n" 9524 " \"some \" \\\n" 9525 " \"text \" \\\n" 9526 " \"other\";", 9527 format("#define A \"some text other\";", AlignLeft)); 9528 } 9529 9530 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 9531 EXPECT_EQ("C a = \"some more \"\n" 9532 " \"text\";", 9533 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 9534 } 9535 9536 TEST_F(FormatTest, FullyRemoveEmptyLines) { 9537 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 9538 NoEmptyLines.MaxEmptyLinesToKeep = 0; 9539 EXPECT_EQ("int i = a(b());", 9540 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 9541 } 9542 9543 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 9544 EXPECT_EQ( 9545 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9546 "(\n" 9547 " \"x\t\");", 9548 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9549 "aaaaaaa(" 9550 "\"x\t\");")); 9551 } 9552 9553 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 9554 EXPECT_EQ( 9555 "u8\"utf8 string \"\n" 9556 "u8\"literal\";", 9557 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 9558 EXPECT_EQ( 9559 "u\"utf16 string \"\n" 9560 "u\"literal\";", 9561 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 9562 EXPECT_EQ( 9563 "U\"utf32 string \"\n" 9564 "U\"literal\";", 9565 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 9566 EXPECT_EQ("L\"wide string \"\n" 9567 "L\"literal\";", 9568 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 9569 EXPECT_EQ("@\"NSString \"\n" 9570 "@\"literal\";", 9571 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 9572 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 9573 9574 // This input makes clang-format try to split the incomplete unicode escape 9575 // sequence, which used to lead to a crasher. 9576 verifyNoCrash( 9577 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 9578 getLLVMStyleWithColumns(60)); 9579 } 9580 9581 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 9582 FormatStyle Style = getGoogleStyleWithColumns(15); 9583 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 9584 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 9585 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 9586 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 9587 EXPECT_EQ("u8R\"x(raw literal)x\";", 9588 format("u8R\"x(raw literal)x\";", Style)); 9589 } 9590 9591 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 9592 FormatStyle Style = getLLVMStyleWithColumns(20); 9593 EXPECT_EQ( 9594 "_T(\"aaaaaaaaaaaaaa\")\n" 9595 "_T(\"aaaaaaaaaaaaaa\")\n" 9596 "_T(\"aaaaaaaaaaaa\")", 9597 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 9598 EXPECT_EQ("f(x,\n" 9599 " _T(\"aaaaaaaaaaaa\")\n" 9600 " _T(\"aaa\"),\n" 9601 " z);", 9602 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 9603 9604 // FIXME: Handle embedded spaces in one iteration. 9605 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 9606 // "_T(\"aaaaaaaaaaaaa\")\n" 9607 // "_T(\"aaaaaaaaaaaaa\")\n" 9608 // "_T(\"a\")", 9609 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9610 // getLLVMStyleWithColumns(20))); 9611 EXPECT_EQ( 9612 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9613 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 9614 EXPECT_EQ("f(\n" 9615 "#if !TEST\n" 9616 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9617 "#endif\n" 9618 ");", 9619 format("f(\n" 9620 "#if !TEST\n" 9621 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9622 "#endif\n" 9623 ");")); 9624 EXPECT_EQ("f(\n" 9625 "\n" 9626 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 9627 format("f(\n" 9628 "\n" 9629 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 9630 } 9631 9632 TEST_F(FormatTest, BreaksStringLiteralOperands) { 9633 // In a function call with two operands, the second can be broken with no line 9634 // break before it. 9635 EXPECT_EQ( 9636 "func(a, \"long long \"\n" 9637 " \"long long\");", 9638 format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24))); 9639 // In a function call with three operands, the second must be broken with a 9640 // line break before it. 9641 EXPECT_EQ("func(a,\n" 9642 " \"long long long \"\n" 9643 " \"long\",\n" 9644 " c);", 9645 format("func(a, \"long long long long\", c);", 9646 getLLVMStyleWithColumns(24))); 9647 // In a function call with three operands, the third must be broken with a 9648 // line break before it. 9649 EXPECT_EQ("func(a, b,\n" 9650 " \"long long long \"\n" 9651 " \"long\");", 9652 format("func(a, b, \"long long long long\");", 9653 getLLVMStyleWithColumns(24))); 9654 // In a function call with three operands, both the second and the third must 9655 // be broken with a line break before them. 9656 EXPECT_EQ("func(a,\n" 9657 " \"long long long \"\n" 9658 " \"long\",\n" 9659 " \"long long long \"\n" 9660 " \"long\");", 9661 format("func(a, \"long long long long\", \"long long long long\");", 9662 getLLVMStyleWithColumns(24))); 9663 // In a chain of << with two operands, the second can be broken with no line 9664 // break before it. 9665 EXPECT_EQ("a << \"line line \"\n" 9666 " \"line\";", 9667 format("a << \"line line line\";", getLLVMStyleWithColumns(20))); 9668 // In a chain of << with three operands, the second can be broken with no line 9669 // break before it. 9670 EXPECT_EQ( 9671 "abcde << \"line \"\n" 9672 " \"line line\"\n" 9673 " << c;", 9674 format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20))); 9675 // In a chain of << with three operands, the third must be broken with a line 9676 // break before it. 9677 EXPECT_EQ( 9678 "a << b\n" 9679 " << \"line line \"\n" 9680 " \"line\";", 9681 format("a << b << \"line line line\";", getLLVMStyleWithColumns(20))); 9682 // In a chain of << with three operands, the second can be broken with no line 9683 // break before it and the third must be broken with a line break before it. 9684 EXPECT_EQ("abcd << \"line line \"\n" 9685 " \"line\"\n" 9686 " << \"line line \"\n" 9687 " \"line\";", 9688 format("abcd << \"line line line\" << \"line line line\";", 9689 getLLVMStyleWithColumns(20))); 9690 // In a chain of binary operators with two operands, the second can be broken 9691 // with no line break before it. 9692 EXPECT_EQ( 9693 "abcd + \"line line \"\n" 9694 " \"line line\";", 9695 format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20))); 9696 // In a chain of binary operators with three operands, the second must be 9697 // broken with a line break before it. 9698 EXPECT_EQ("abcd +\n" 9699 " \"line line \"\n" 9700 " \"line line\" +\n" 9701 " e;", 9702 format("abcd + \"line line line line\" + e;", 9703 getLLVMStyleWithColumns(20))); 9704 // In a function call with two operands, with AlignAfterOpenBracket enabled, 9705 // the first must be broken with a line break before it. 9706 FormatStyle Style = getLLVMStyleWithColumns(25); 9707 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 9708 EXPECT_EQ("someFunction(\n" 9709 " \"long long long \"\n" 9710 " \"long\",\n" 9711 " a);", 9712 format("someFunction(\"long long long long\", a);", Style)); 9713 } 9714 9715 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 9716 EXPECT_EQ( 9717 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9718 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9719 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9720 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9721 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9722 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 9723 } 9724 9725 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 9726 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 9727 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 9728 EXPECT_EQ("fffffffffff(g(R\"x(\n" 9729 "multiline raw string literal xxxxxxxxxxxxxx\n" 9730 ")x\",\n" 9731 " a),\n" 9732 " b);", 9733 format("fffffffffff(g(R\"x(\n" 9734 "multiline raw string literal xxxxxxxxxxxxxx\n" 9735 ")x\", a), b);", 9736 getGoogleStyleWithColumns(20))); 9737 EXPECT_EQ("fffffffffff(\n" 9738 " g(R\"x(qqq\n" 9739 "multiline raw string literal xxxxxxxxxxxxxx\n" 9740 ")x\",\n" 9741 " a),\n" 9742 " b);", 9743 format("fffffffffff(g(R\"x(qqq\n" 9744 "multiline raw string literal xxxxxxxxxxxxxx\n" 9745 ")x\", a), b);", 9746 getGoogleStyleWithColumns(20))); 9747 9748 EXPECT_EQ("fffffffffff(R\"x(\n" 9749 "multiline raw string literal xxxxxxxxxxxxxx\n" 9750 ")x\");", 9751 format("fffffffffff(R\"x(\n" 9752 "multiline raw string literal xxxxxxxxxxxxxx\n" 9753 ")x\");", 9754 getGoogleStyleWithColumns(20))); 9755 EXPECT_EQ("fffffffffff(R\"x(\n" 9756 "multiline raw string literal xxxxxxxxxxxxxx\n" 9757 ")x\" + bbbbbb);", 9758 format("fffffffffff(R\"x(\n" 9759 "multiline raw string literal xxxxxxxxxxxxxx\n" 9760 ")x\" + bbbbbb);", 9761 getGoogleStyleWithColumns(20))); 9762 EXPECT_EQ("fffffffffff(\n" 9763 " R\"x(\n" 9764 "multiline raw string literal xxxxxxxxxxxxxx\n" 9765 ")x\" +\n" 9766 " bbbbbb);", 9767 format("fffffffffff(\n" 9768 " R\"x(\n" 9769 "multiline raw string literal xxxxxxxxxxxxxx\n" 9770 ")x\" + bbbbbb);", 9771 getGoogleStyleWithColumns(20))); 9772 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 9773 format("fffffffffff(\n" 9774 " R\"(single line raw string)\" + bbbbbb);")); 9775 } 9776 9777 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 9778 verifyFormat("string a = \"unterminated;"); 9779 EXPECT_EQ("function(\"unterminated,\n" 9780 " OtherParameter);", 9781 format("function( \"unterminated,\n" 9782 " OtherParameter);")); 9783 } 9784 9785 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9786 FormatStyle Style = getLLVMStyle(); 9787 Style.Standard = FormatStyle::LS_Cpp03; 9788 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9789 format("#define x(_a) printf(\"foo\"_a);", Style)); 9790 } 9791 9792 TEST_F(FormatTest, CppLexVersion) { 9793 FormatStyle Style = getLLVMStyle(); 9794 // Formatting of x * y differs if x is a type. 9795 verifyFormat("void foo() { MACRO(a * b); }", Style); 9796 verifyFormat("void foo() { MACRO(int *b); }", Style); 9797 9798 // LLVM style uses latest lexer. 9799 verifyFormat("void foo() { MACRO(char8_t *b); }", Style); 9800 Style.Standard = FormatStyle::LS_Cpp17; 9801 // But in c++17, char8_t isn't a keyword. 9802 verifyFormat("void foo() { MACRO(char8_t * b); }", Style); 9803 } 9804 9805 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9806 9807 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9808 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9809 " \"ddeeefff\");", 9810 format("someFunction(\"aaabbbcccdddeeefff\");", 9811 getLLVMStyleWithColumns(25))); 9812 EXPECT_EQ("someFunction1234567890(\n" 9813 " \"aaabbbcccdddeeefff\");", 9814 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9815 getLLVMStyleWithColumns(26))); 9816 EXPECT_EQ("someFunction1234567890(\n" 9817 " \"aaabbbcccdddeeeff\"\n" 9818 " \"f\");", 9819 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9820 getLLVMStyleWithColumns(25))); 9821 EXPECT_EQ("someFunction1234567890(\n" 9822 " \"aaabbbcccdddeeeff\"\n" 9823 " \"f\");", 9824 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9825 getLLVMStyleWithColumns(24))); 9826 EXPECT_EQ("someFunction(\n" 9827 " \"aaabbbcc ddde \"\n" 9828 " \"efff\");", 9829 format("someFunction(\"aaabbbcc ddde efff\");", 9830 getLLVMStyleWithColumns(25))); 9831 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9832 " \"ddeeefff\");", 9833 format("someFunction(\"aaabbbccc ddeeefff\");", 9834 getLLVMStyleWithColumns(25))); 9835 EXPECT_EQ("someFunction1234567890(\n" 9836 " \"aaabb \"\n" 9837 " \"cccdddeeefff\");", 9838 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9839 getLLVMStyleWithColumns(25))); 9840 EXPECT_EQ("#define A \\\n" 9841 " string s = \\\n" 9842 " \"123456789\" \\\n" 9843 " \"0\"; \\\n" 9844 " int i;", 9845 format("#define A string s = \"1234567890\"; int i;", 9846 getLLVMStyleWithColumns(20))); 9847 EXPECT_EQ("someFunction(\n" 9848 " \"aaabbbcc \"\n" 9849 " \"dddeeefff\");", 9850 format("someFunction(\"aaabbbcc dddeeefff\");", 9851 getLLVMStyleWithColumns(25))); 9852 } 9853 9854 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9855 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9856 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9857 EXPECT_EQ("\"test\"\n" 9858 "\"\\n\"", 9859 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9860 EXPECT_EQ("\"tes\\\\\"\n" 9861 "\"n\"", 9862 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9863 EXPECT_EQ("\"\\\\\\\\\"\n" 9864 "\"\\n\"", 9865 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9866 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9867 EXPECT_EQ("\"\\uff01\"\n" 9868 "\"test\"", 9869 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9870 EXPECT_EQ("\"\\Uff01ff02\"", 9871 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9872 EXPECT_EQ("\"\\x000000000001\"\n" 9873 "\"next\"", 9874 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9875 EXPECT_EQ("\"\\x000000000001next\"", 9876 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9877 EXPECT_EQ("\"\\x000000000001\"", 9878 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9879 EXPECT_EQ("\"test\"\n" 9880 "\"\\000000\"\n" 9881 "\"000001\"", 9882 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9883 EXPECT_EQ("\"test\\000\"\n" 9884 "\"00000000\"\n" 9885 "\"1\"", 9886 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9887 } 9888 9889 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9890 verifyFormat("void f() {\n" 9891 " return g() {}\n" 9892 " void h() {}"); 9893 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9894 "g();\n" 9895 "}"); 9896 } 9897 9898 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9899 verifyFormat( 9900 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9901 } 9902 9903 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9904 verifyFormat("class X {\n" 9905 " void f() {\n" 9906 " }\n" 9907 "};", 9908 getLLVMStyleWithColumns(12)); 9909 } 9910 9911 TEST_F(FormatTest, ConfigurableIndentWidth) { 9912 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9913 EightIndent.IndentWidth = 8; 9914 EightIndent.ContinuationIndentWidth = 8; 9915 verifyFormat("void f() {\n" 9916 " someFunction();\n" 9917 " if (true) {\n" 9918 " f();\n" 9919 " }\n" 9920 "}", 9921 EightIndent); 9922 verifyFormat("class X {\n" 9923 " void f() {\n" 9924 " }\n" 9925 "};", 9926 EightIndent); 9927 verifyFormat("int x[] = {\n" 9928 " call(),\n" 9929 " call()};", 9930 EightIndent); 9931 } 9932 9933 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9934 verifyFormat("double\n" 9935 "f();", 9936 getLLVMStyleWithColumns(8)); 9937 } 9938 9939 TEST_F(FormatTest, ConfigurableUseOfTab) { 9940 FormatStyle Tab = getLLVMStyleWithColumns(42); 9941 Tab.IndentWidth = 8; 9942 Tab.UseTab = FormatStyle::UT_Always; 9943 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9944 9945 EXPECT_EQ("if (aaaaaaaa && // q\n" 9946 " bb)\t\t// w\n" 9947 "\t;", 9948 format("if (aaaaaaaa &&// q\n" 9949 "bb)// w\n" 9950 ";", 9951 Tab)); 9952 EXPECT_EQ("if (aaa && bbb) // w\n" 9953 "\t;", 9954 format("if(aaa&&bbb)// w\n" 9955 ";", 9956 Tab)); 9957 9958 verifyFormat("class X {\n" 9959 "\tvoid f() {\n" 9960 "\t\tsomeFunction(parameter1,\n" 9961 "\t\t\t parameter2);\n" 9962 "\t}\n" 9963 "};", 9964 Tab); 9965 verifyFormat("#define A \\\n" 9966 "\tvoid f() { \\\n" 9967 "\t\tsomeFunction( \\\n" 9968 "\t\t parameter1, \\\n" 9969 "\t\t parameter2); \\\n" 9970 "\t}", 9971 Tab); 9972 verifyFormat("int a;\t // x\n" 9973 "int bbbbbbbb; // x\n", 9974 Tab); 9975 9976 Tab.TabWidth = 4; 9977 Tab.IndentWidth = 8; 9978 verifyFormat("class TabWidth4Indent8 {\n" 9979 "\t\tvoid f() {\n" 9980 "\t\t\t\tsomeFunction(parameter1,\n" 9981 "\t\t\t\t\t\t\t parameter2);\n" 9982 "\t\t}\n" 9983 "};", 9984 Tab); 9985 9986 Tab.TabWidth = 4; 9987 Tab.IndentWidth = 4; 9988 verifyFormat("class TabWidth4Indent4 {\n" 9989 "\tvoid f() {\n" 9990 "\t\tsomeFunction(parameter1,\n" 9991 "\t\t\t\t\t parameter2);\n" 9992 "\t}\n" 9993 "};", 9994 Tab); 9995 9996 Tab.TabWidth = 8; 9997 Tab.IndentWidth = 4; 9998 verifyFormat("class TabWidth8Indent4 {\n" 9999 " void f() {\n" 10000 "\tsomeFunction(parameter1,\n" 10001 "\t\t parameter2);\n" 10002 " }\n" 10003 "};", 10004 Tab); 10005 10006 Tab.TabWidth = 8; 10007 Tab.IndentWidth = 8; 10008 EXPECT_EQ("/*\n" 10009 "\t a\t\tcomment\n" 10010 "\t in multiple lines\n" 10011 " */", 10012 format(" /*\t \t \n" 10013 " \t \t a\t\tcomment\t \t\n" 10014 " \t \t in multiple lines\t\n" 10015 " \t */", 10016 Tab)); 10017 10018 Tab.UseTab = FormatStyle::UT_ForIndentation; 10019 verifyFormat("{\n" 10020 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10021 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10022 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10023 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10024 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10025 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10026 "};", 10027 Tab); 10028 verifyFormat("enum AA {\n" 10029 "\ta1, // Force multiple lines\n" 10030 "\ta2,\n" 10031 "\ta3\n" 10032 "};", 10033 Tab); 10034 EXPECT_EQ("if (aaaaaaaa && // q\n" 10035 " bb) // w\n" 10036 "\t;", 10037 format("if (aaaaaaaa &&// q\n" 10038 "bb)// w\n" 10039 ";", 10040 Tab)); 10041 verifyFormat("class X {\n" 10042 "\tvoid f() {\n" 10043 "\t\tsomeFunction(parameter1,\n" 10044 "\t\t parameter2);\n" 10045 "\t}\n" 10046 "};", 10047 Tab); 10048 verifyFormat("{\n" 10049 "\tQ(\n" 10050 "\t {\n" 10051 "\t\t int a;\n" 10052 "\t\t someFunction(aaaaaaaa,\n" 10053 "\t\t bbbbbbb);\n" 10054 "\t },\n" 10055 "\t p);\n" 10056 "}", 10057 Tab); 10058 EXPECT_EQ("{\n" 10059 "\t/* aaaa\n" 10060 "\t bbbb */\n" 10061 "}", 10062 format("{\n" 10063 "/* aaaa\n" 10064 " bbbb */\n" 10065 "}", 10066 Tab)); 10067 EXPECT_EQ("{\n" 10068 "\t/*\n" 10069 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10070 "\t bbbbbbbbbbbbb\n" 10071 "\t*/\n" 10072 "}", 10073 format("{\n" 10074 "/*\n" 10075 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10076 "*/\n" 10077 "}", 10078 Tab)); 10079 EXPECT_EQ("{\n" 10080 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10081 "\t// bbbbbbbbbbbbb\n" 10082 "}", 10083 format("{\n" 10084 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10085 "}", 10086 Tab)); 10087 EXPECT_EQ("{\n" 10088 "\t/*\n" 10089 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10090 "\t bbbbbbbbbbbbb\n" 10091 "\t*/\n" 10092 "}", 10093 format("{\n" 10094 "\t/*\n" 10095 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10096 "\t*/\n" 10097 "}", 10098 Tab)); 10099 EXPECT_EQ("{\n" 10100 "\t/*\n" 10101 "\n" 10102 "\t*/\n" 10103 "}", 10104 format("{\n" 10105 "\t/*\n" 10106 "\n" 10107 "\t*/\n" 10108 "}", 10109 Tab)); 10110 EXPECT_EQ("{\n" 10111 "\t/*\n" 10112 " asdf\n" 10113 "\t*/\n" 10114 "}", 10115 format("{\n" 10116 "\t/*\n" 10117 " asdf\n" 10118 "\t*/\n" 10119 "}", 10120 Tab)); 10121 10122 Tab.UseTab = FormatStyle::UT_Never; 10123 EXPECT_EQ("/*\n" 10124 " a\t\tcomment\n" 10125 " in multiple lines\n" 10126 " */", 10127 format(" /*\t \t \n" 10128 " \t \t a\t\tcomment\t \t\n" 10129 " \t \t in multiple lines\t\n" 10130 " \t */", 10131 Tab)); 10132 EXPECT_EQ("/* some\n" 10133 " comment */", 10134 format(" \t \t /* some\n" 10135 " \t \t comment */", 10136 Tab)); 10137 EXPECT_EQ("int a; /* some\n" 10138 " comment */", 10139 format(" \t \t int a; /* some\n" 10140 " \t \t comment */", 10141 Tab)); 10142 10143 EXPECT_EQ("int a; /* some\n" 10144 "comment */", 10145 format(" \t \t int\ta; /* some\n" 10146 " \t \t comment */", 10147 Tab)); 10148 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10149 " comment */", 10150 format(" \t \t f(\"\t\t\"); /* some\n" 10151 " \t \t comment */", 10152 Tab)); 10153 EXPECT_EQ("{\n" 10154 " /*\n" 10155 " * Comment\n" 10156 " */\n" 10157 " int i;\n" 10158 "}", 10159 format("{\n" 10160 "\t/*\n" 10161 "\t * Comment\n" 10162 "\t */\n" 10163 "\t int i;\n" 10164 "}", 10165 Tab)); 10166 10167 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10168 Tab.TabWidth = 8; 10169 Tab.IndentWidth = 8; 10170 EXPECT_EQ("if (aaaaaaaa && // q\n" 10171 " bb) // w\n" 10172 "\t;", 10173 format("if (aaaaaaaa &&// q\n" 10174 "bb)// w\n" 10175 ";", 10176 Tab)); 10177 EXPECT_EQ("if (aaa && bbb) // w\n" 10178 "\t;", 10179 format("if(aaa&&bbb)// w\n" 10180 ";", 10181 Tab)); 10182 verifyFormat("class X {\n" 10183 "\tvoid f() {\n" 10184 "\t\tsomeFunction(parameter1,\n" 10185 "\t\t\t parameter2);\n" 10186 "\t}\n" 10187 "};", 10188 Tab); 10189 verifyFormat("#define A \\\n" 10190 "\tvoid f() { \\\n" 10191 "\t\tsomeFunction( \\\n" 10192 "\t\t parameter1, \\\n" 10193 "\t\t parameter2); \\\n" 10194 "\t}", 10195 Tab); 10196 Tab.TabWidth = 4; 10197 Tab.IndentWidth = 8; 10198 verifyFormat("class TabWidth4Indent8 {\n" 10199 "\t\tvoid f() {\n" 10200 "\t\t\t\tsomeFunction(parameter1,\n" 10201 "\t\t\t\t\t\t\t parameter2);\n" 10202 "\t\t}\n" 10203 "};", 10204 Tab); 10205 Tab.TabWidth = 4; 10206 Tab.IndentWidth = 4; 10207 verifyFormat("class TabWidth4Indent4 {\n" 10208 "\tvoid f() {\n" 10209 "\t\tsomeFunction(parameter1,\n" 10210 "\t\t\t\t\t parameter2);\n" 10211 "\t}\n" 10212 "};", 10213 Tab); 10214 Tab.TabWidth = 8; 10215 Tab.IndentWidth = 4; 10216 verifyFormat("class TabWidth8Indent4 {\n" 10217 " void f() {\n" 10218 "\tsomeFunction(parameter1,\n" 10219 "\t\t parameter2);\n" 10220 " }\n" 10221 "};", 10222 Tab); 10223 Tab.TabWidth = 8; 10224 Tab.IndentWidth = 8; 10225 EXPECT_EQ("/*\n" 10226 "\t a\t\tcomment\n" 10227 "\t in multiple lines\n" 10228 " */", 10229 format(" /*\t \t \n" 10230 " \t \t a\t\tcomment\t \t\n" 10231 " \t \t in multiple lines\t\n" 10232 " \t */", 10233 Tab)); 10234 verifyFormat("{\n" 10235 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10236 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10237 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10238 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10239 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10240 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10241 "};", 10242 Tab); 10243 verifyFormat("enum AA {\n" 10244 "\ta1, // Force multiple lines\n" 10245 "\ta2,\n" 10246 "\ta3\n" 10247 "};", 10248 Tab); 10249 EXPECT_EQ("if (aaaaaaaa && // q\n" 10250 " bb) // w\n" 10251 "\t;", 10252 format("if (aaaaaaaa &&// q\n" 10253 "bb)// w\n" 10254 ";", 10255 Tab)); 10256 verifyFormat("class X {\n" 10257 "\tvoid f() {\n" 10258 "\t\tsomeFunction(parameter1,\n" 10259 "\t\t\t parameter2);\n" 10260 "\t}\n" 10261 "};", 10262 Tab); 10263 verifyFormat("{\n" 10264 "\tQ(\n" 10265 "\t {\n" 10266 "\t\t int a;\n" 10267 "\t\t someFunction(aaaaaaaa,\n" 10268 "\t\t\t\t bbbbbbb);\n" 10269 "\t },\n" 10270 "\t p);\n" 10271 "}", 10272 Tab); 10273 EXPECT_EQ("{\n" 10274 "\t/* aaaa\n" 10275 "\t bbbb */\n" 10276 "}", 10277 format("{\n" 10278 "/* aaaa\n" 10279 " bbbb */\n" 10280 "}", 10281 Tab)); 10282 EXPECT_EQ("{\n" 10283 "\t/*\n" 10284 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10285 "\t bbbbbbbbbbbbb\n" 10286 "\t*/\n" 10287 "}", 10288 format("{\n" 10289 "/*\n" 10290 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10291 "*/\n" 10292 "}", 10293 Tab)); 10294 EXPECT_EQ("{\n" 10295 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10296 "\t// bbbbbbbbbbbbb\n" 10297 "}", 10298 format("{\n" 10299 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10300 "}", 10301 Tab)); 10302 EXPECT_EQ("{\n" 10303 "\t/*\n" 10304 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10305 "\t bbbbbbbbbbbbb\n" 10306 "\t*/\n" 10307 "}", 10308 format("{\n" 10309 "\t/*\n" 10310 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10311 "\t*/\n" 10312 "}", 10313 Tab)); 10314 EXPECT_EQ("{\n" 10315 "\t/*\n" 10316 "\n" 10317 "\t*/\n" 10318 "}", 10319 format("{\n" 10320 "\t/*\n" 10321 "\n" 10322 "\t*/\n" 10323 "}", 10324 Tab)); 10325 EXPECT_EQ("{\n" 10326 "\t/*\n" 10327 " asdf\n" 10328 "\t*/\n" 10329 "}", 10330 format("{\n" 10331 "\t/*\n" 10332 " asdf\n" 10333 "\t*/\n" 10334 "}", 10335 Tab)); 10336 EXPECT_EQ("/* some\n" 10337 " comment */", 10338 format(" \t \t /* some\n" 10339 " \t \t comment */", 10340 Tab)); 10341 EXPECT_EQ("int a; /* some\n" 10342 " comment */", 10343 format(" \t \t int a; /* some\n" 10344 " \t \t comment */", 10345 Tab)); 10346 EXPECT_EQ("int a; /* some\n" 10347 "comment */", 10348 format(" \t \t int\ta; /* some\n" 10349 " \t \t comment */", 10350 Tab)); 10351 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10352 " comment */", 10353 format(" \t \t f(\"\t\t\"); /* some\n" 10354 " \t \t comment */", 10355 Tab)); 10356 EXPECT_EQ("{\n" 10357 "\t/*\n" 10358 "\t * Comment\n" 10359 "\t */\n" 10360 "\tint i;\n" 10361 "}", 10362 format("{\n" 10363 "\t/*\n" 10364 "\t * Comment\n" 10365 "\t */\n" 10366 "\t int i;\n" 10367 "}", 10368 Tab)); 10369 Tab.TabWidth = 2; 10370 Tab.IndentWidth = 2; 10371 EXPECT_EQ("{\n" 10372 "\t/* aaaa\n" 10373 "\t\t bbbb */\n" 10374 "}", 10375 format("{\n" 10376 "/* aaaa\n" 10377 "\t bbbb */\n" 10378 "}", 10379 Tab)); 10380 EXPECT_EQ("{\n" 10381 "\t/*\n" 10382 "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10383 "\t\tbbbbbbbbbbbbb\n" 10384 "\t*/\n" 10385 "}", 10386 format("{\n" 10387 "/*\n" 10388 "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10389 "*/\n" 10390 "}", 10391 Tab)); 10392 Tab.AlignConsecutiveAssignments = true; 10393 Tab.AlignConsecutiveDeclarations = true; 10394 Tab.TabWidth = 4; 10395 Tab.IndentWidth = 4; 10396 verifyFormat("class Assign {\n" 10397 "\tvoid f() {\n" 10398 "\t\tint x = 123;\n" 10399 "\t\tint random = 4;\n" 10400 "\t\tstd::string alphabet =\n" 10401 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 10402 "\t}\n" 10403 "};", 10404 Tab); 10405 10406 Tab.UseTab = FormatStyle::UT_AlignWithSpaces; 10407 Tab.TabWidth = 8; 10408 Tab.IndentWidth = 8; 10409 EXPECT_EQ("if (aaaaaaaa && // q\n" 10410 " bb) // w\n" 10411 "\t;", 10412 format("if (aaaaaaaa &&// q\n" 10413 "bb)// w\n" 10414 ";", 10415 Tab)); 10416 EXPECT_EQ("if (aaa && bbb) // w\n" 10417 "\t;", 10418 format("if(aaa&&bbb)// w\n" 10419 ";", 10420 Tab)); 10421 verifyFormat("class X {\n" 10422 "\tvoid f() {\n" 10423 "\t\tsomeFunction(parameter1,\n" 10424 "\t\t parameter2);\n" 10425 "\t}\n" 10426 "};", 10427 Tab); 10428 verifyFormat("#define A \\\n" 10429 "\tvoid f() { \\\n" 10430 "\t\tsomeFunction( \\\n" 10431 "\t\t parameter1, \\\n" 10432 "\t\t parameter2); \\\n" 10433 "\t}", 10434 Tab); 10435 Tab.TabWidth = 4; 10436 Tab.IndentWidth = 8; 10437 verifyFormat("class TabWidth4Indent8 {\n" 10438 "\t\tvoid f() {\n" 10439 "\t\t\t\tsomeFunction(parameter1,\n" 10440 "\t\t\t\t parameter2);\n" 10441 "\t\t}\n" 10442 "};", 10443 Tab); 10444 Tab.TabWidth = 4; 10445 Tab.IndentWidth = 4; 10446 verifyFormat("class TabWidth4Indent4 {\n" 10447 "\tvoid f() {\n" 10448 "\t\tsomeFunction(parameter1,\n" 10449 "\t\t parameter2);\n" 10450 "\t}\n" 10451 "};", 10452 Tab); 10453 Tab.TabWidth = 8; 10454 Tab.IndentWidth = 4; 10455 verifyFormat("class TabWidth8Indent4 {\n" 10456 " void f() {\n" 10457 "\tsomeFunction(parameter1,\n" 10458 "\t parameter2);\n" 10459 " }\n" 10460 "};", 10461 Tab); 10462 Tab.TabWidth = 8; 10463 Tab.IndentWidth = 8; 10464 EXPECT_EQ("/*\n" 10465 " a\t\tcomment\n" 10466 " in multiple lines\n" 10467 " */", 10468 format(" /*\t \t \n" 10469 " \t \t a\t\tcomment\t \t\n" 10470 " \t \t in multiple lines\t\n" 10471 " \t */", 10472 Tab)); 10473 verifyFormat("{\n" 10474 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10475 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10476 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10477 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10478 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10479 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10480 "};", 10481 Tab); 10482 verifyFormat("enum AA {\n" 10483 "\ta1, // Force multiple lines\n" 10484 "\ta2,\n" 10485 "\ta3\n" 10486 "};", 10487 Tab); 10488 EXPECT_EQ("if (aaaaaaaa && // q\n" 10489 " bb) // w\n" 10490 "\t;", 10491 format("if (aaaaaaaa &&// q\n" 10492 "bb)// w\n" 10493 ";", 10494 Tab)); 10495 verifyFormat("class X {\n" 10496 "\tvoid f() {\n" 10497 "\t\tsomeFunction(parameter1,\n" 10498 "\t\t parameter2);\n" 10499 "\t}\n" 10500 "};", 10501 Tab); 10502 verifyFormat("{\n" 10503 "\tQ(\n" 10504 "\t {\n" 10505 "\t\t int a;\n" 10506 "\t\t someFunction(aaaaaaaa,\n" 10507 "\t\t bbbbbbb);\n" 10508 "\t },\n" 10509 "\t p);\n" 10510 "}", 10511 Tab); 10512 EXPECT_EQ("{\n" 10513 "\t/* aaaa\n" 10514 "\t bbbb */\n" 10515 "}", 10516 format("{\n" 10517 "/* aaaa\n" 10518 " bbbb */\n" 10519 "}", 10520 Tab)); 10521 EXPECT_EQ("{\n" 10522 "\t/*\n" 10523 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10524 "\t bbbbbbbbbbbbb\n" 10525 "\t*/\n" 10526 "}", 10527 format("{\n" 10528 "/*\n" 10529 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10530 "*/\n" 10531 "}", 10532 Tab)); 10533 EXPECT_EQ("{\n" 10534 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10535 "\t// bbbbbbbbbbbbb\n" 10536 "}", 10537 format("{\n" 10538 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10539 "}", 10540 Tab)); 10541 EXPECT_EQ("{\n" 10542 "\t/*\n" 10543 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10544 "\t bbbbbbbbbbbbb\n" 10545 "\t*/\n" 10546 "}", 10547 format("{\n" 10548 "\t/*\n" 10549 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10550 "\t*/\n" 10551 "}", 10552 Tab)); 10553 EXPECT_EQ("{\n" 10554 "\t/*\n" 10555 "\n" 10556 "\t*/\n" 10557 "}", 10558 format("{\n" 10559 "\t/*\n" 10560 "\n" 10561 "\t*/\n" 10562 "}", 10563 Tab)); 10564 EXPECT_EQ("{\n" 10565 "\t/*\n" 10566 " asdf\n" 10567 "\t*/\n" 10568 "}", 10569 format("{\n" 10570 "\t/*\n" 10571 " asdf\n" 10572 "\t*/\n" 10573 "}", 10574 Tab)); 10575 EXPECT_EQ("/* some\n" 10576 " comment */", 10577 format(" \t \t /* some\n" 10578 " \t \t comment */", 10579 Tab)); 10580 EXPECT_EQ("int a; /* some\n" 10581 " comment */", 10582 format(" \t \t int a; /* some\n" 10583 " \t \t comment */", 10584 Tab)); 10585 EXPECT_EQ("int a; /* some\n" 10586 "comment */", 10587 format(" \t \t int\ta; /* some\n" 10588 " \t \t comment */", 10589 Tab)); 10590 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10591 " comment */", 10592 format(" \t \t f(\"\t\t\"); /* some\n" 10593 " \t \t comment */", 10594 Tab)); 10595 EXPECT_EQ("{\n" 10596 "\t/*\n" 10597 "\t * Comment\n" 10598 "\t */\n" 10599 "\tint i;\n" 10600 "}", 10601 format("{\n" 10602 "\t/*\n" 10603 "\t * Comment\n" 10604 "\t */\n" 10605 "\t int i;\n" 10606 "}", 10607 Tab)); 10608 Tab.TabWidth = 2; 10609 Tab.IndentWidth = 2; 10610 EXPECT_EQ("{\n" 10611 "\t/* aaaa\n" 10612 "\t bbbb */\n" 10613 "}", 10614 format("{\n" 10615 "/* aaaa\n" 10616 " bbbb */\n" 10617 "}", 10618 Tab)); 10619 EXPECT_EQ("{\n" 10620 "\t/*\n" 10621 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10622 "\t bbbbbbbbbbbbb\n" 10623 "\t*/\n" 10624 "}", 10625 format("{\n" 10626 "/*\n" 10627 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10628 "*/\n" 10629 "}", 10630 Tab)); 10631 Tab.AlignConsecutiveAssignments = true; 10632 Tab.AlignConsecutiveDeclarations = true; 10633 Tab.TabWidth = 4; 10634 Tab.IndentWidth = 4; 10635 verifyFormat("class Assign {\n" 10636 "\tvoid f() {\n" 10637 "\t\tint x = 123;\n" 10638 "\t\tint random = 4;\n" 10639 "\t\tstd::string alphabet =\n" 10640 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 10641 "\t}\n" 10642 "};", 10643 Tab); 10644 } 10645 10646 TEST_F(FormatTest, ZeroTabWidth) { 10647 FormatStyle Tab = getLLVMStyleWithColumns(42); 10648 Tab.IndentWidth = 8; 10649 Tab.UseTab = FormatStyle::UT_Never; 10650 Tab.TabWidth = 0; 10651 EXPECT_EQ("void a(){\n" 10652 " // line starts with '\t'\n" 10653 "};", 10654 format("void a(){\n" 10655 "\t// line starts with '\t'\n" 10656 "};", 10657 Tab)); 10658 10659 EXPECT_EQ("void a(){\n" 10660 " // line starts with '\t'\n" 10661 "};", 10662 format("void a(){\n" 10663 "\t\t// line starts with '\t'\n" 10664 "};", 10665 Tab)); 10666 10667 Tab.UseTab = FormatStyle::UT_ForIndentation; 10668 EXPECT_EQ("void a(){\n" 10669 " // line starts with '\t'\n" 10670 "};", 10671 format("void a(){\n" 10672 "\t// line starts with '\t'\n" 10673 "};", 10674 Tab)); 10675 10676 EXPECT_EQ("void a(){\n" 10677 " // line starts with '\t'\n" 10678 "};", 10679 format("void a(){\n" 10680 "\t\t// line starts with '\t'\n" 10681 "};", 10682 Tab)); 10683 10684 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10685 EXPECT_EQ("void a(){\n" 10686 " // line starts with '\t'\n" 10687 "};", 10688 format("void a(){\n" 10689 "\t// line starts with '\t'\n" 10690 "};", 10691 Tab)); 10692 10693 EXPECT_EQ("void a(){\n" 10694 " // line starts with '\t'\n" 10695 "};", 10696 format("void a(){\n" 10697 "\t\t// line starts with '\t'\n" 10698 "};", 10699 Tab)); 10700 10701 Tab.UseTab = FormatStyle::UT_AlignWithSpaces; 10702 EXPECT_EQ("void a(){\n" 10703 " // line starts with '\t'\n" 10704 "};", 10705 format("void a(){\n" 10706 "\t// line starts with '\t'\n" 10707 "};", 10708 Tab)); 10709 10710 EXPECT_EQ("void a(){\n" 10711 " // line starts with '\t'\n" 10712 "};", 10713 format("void a(){\n" 10714 "\t\t// line starts with '\t'\n" 10715 "};", 10716 Tab)); 10717 10718 Tab.UseTab = FormatStyle::UT_Always; 10719 EXPECT_EQ("void a(){\n" 10720 "// line starts with '\t'\n" 10721 "};", 10722 format("void a(){\n" 10723 "\t// line starts with '\t'\n" 10724 "};", 10725 Tab)); 10726 10727 EXPECT_EQ("void a(){\n" 10728 "// line starts with '\t'\n" 10729 "};", 10730 format("void a(){\n" 10731 "\t\t// line starts with '\t'\n" 10732 "};", 10733 Tab)); 10734 } 10735 10736 TEST_F(FormatTest, CalculatesOriginalColumn) { 10737 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10738 "q\"; /* some\n" 10739 " comment */", 10740 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10741 "q\"; /* some\n" 10742 " comment */", 10743 getLLVMStyle())); 10744 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10745 "/* some\n" 10746 " comment */", 10747 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10748 " /* some\n" 10749 " comment */", 10750 getLLVMStyle())); 10751 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10752 "qqq\n" 10753 "/* some\n" 10754 " comment */", 10755 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10756 "qqq\n" 10757 " /* some\n" 10758 " comment */", 10759 getLLVMStyle())); 10760 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10761 "wwww; /* some\n" 10762 " comment */", 10763 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10764 "wwww; /* some\n" 10765 " comment */", 10766 getLLVMStyle())); 10767 } 10768 10769 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 10770 FormatStyle NoSpace = getLLVMStyle(); 10771 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 10772 10773 verifyFormat("while(true)\n" 10774 " continue;", 10775 NoSpace); 10776 verifyFormat("for(;;)\n" 10777 " continue;", 10778 NoSpace); 10779 verifyFormat("if(true)\n" 10780 " f();\n" 10781 "else if(true)\n" 10782 " f();", 10783 NoSpace); 10784 verifyFormat("do {\n" 10785 " do_something();\n" 10786 "} while(something());", 10787 NoSpace); 10788 verifyFormat("switch(x) {\n" 10789 "default:\n" 10790 " break;\n" 10791 "}", 10792 NoSpace); 10793 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 10794 verifyFormat("size_t x = sizeof(x);", NoSpace); 10795 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 10796 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 10797 verifyFormat("alignas(128) char a[128];", NoSpace); 10798 verifyFormat("size_t x = alignof(MyType);", NoSpace); 10799 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 10800 verifyFormat("int f() throw(Deprecated);", NoSpace); 10801 verifyFormat("typedef void (*cb)(int);", NoSpace); 10802 verifyFormat("T A::operator()();", NoSpace); 10803 verifyFormat("X A::operator++(T);", NoSpace); 10804 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 10805 10806 FormatStyle Space = getLLVMStyle(); 10807 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 10808 10809 verifyFormat("int f ();", Space); 10810 verifyFormat("void f (int a, T b) {\n" 10811 " while (true)\n" 10812 " continue;\n" 10813 "}", 10814 Space); 10815 verifyFormat("if (true)\n" 10816 " f ();\n" 10817 "else if (true)\n" 10818 " f ();", 10819 Space); 10820 verifyFormat("do {\n" 10821 " do_something ();\n" 10822 "} while (something ());", 10823 Space); 10824 verifyFormat("switch (x) {\n" 10825 "default:\n" 10826 " break;\n" 10827 "}", 10828 Space); 10829 verifyFormat("A::A () : a (1) {}", Space); 10830 verifyFormat("void f () __attribute__ ((asdf));", Space); 10831 verifyFormat("*(&a + 1);\n" 10832 "&((&a)[1]);\n" 10833 "a[(b + c) * d];\n" 10834 "(((a + 1) * 2) + 3) * 4;", 10835 Space); 10836 verifyFormat("#define A(x) x", Space); 10837 verifyFormat("#define A (x) x", Space); 10838 verifyFormat("#if defined(x)\n" 10839 "#endif", 10840 Space); 10841 verifyFormat("auto i = std::make_unique<int> (5);", Space); 10842 verifyFormat("size_t x = sizeof (x);", Space); 10843 verifyFormat("auto f (int x) -> decltype (x);", Space); 10844 verifyFormat("int f (T x) noexcept (x.create ());", Space); 10845 verifyFormat("alignas (128) char a[128];", Space); 10846 verifyFormat("size_t x = alignof (MyType);", Space); 10847 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 10848 verifyFormat("int f () throw (Deprecated);", Space); 10849 verifyFormat("typedef void (*cb) (int);", Space); 10850 verifyFormat("T A::operator() ();", Space); 10851 verifyFormat("X A::operator++ (T);", Space); 10852 verifyFormat("auto lambda = [] () { return 0; };", Space); 10853 verifyFormat("int x = int (y);", Space); 10854 10855 FormatStyle SomeSpace = getLLVMStyle(); 10856 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 10857 10858 verifyFormat("[]() -> float {}", SomeSpace); 10859 verifyFormat("[] (auto foo) {}", SomeSpace); 10860 verifyFormat("[foo]() -> int {}", SomeSpace); 10861 verifyFormat("int f();", SomeSpace); 10862 verifyFormat("void f (int a, T b) {\n" 10863 " while (true)\n" 10864 " continue;\n" 10865 "}", 10866 SomeSpace); 10867 verifyFormat("if (true)\n" 10868 " f();\n" 10869 "else if (true)\n" 10870 " f();", 10871 SomeSpace); 10872 verifyFormat("do {\n" 10873 " do_something();\n" 10874 "} while (something());", 10875 SomeSpace); 10876 verifyFormat("switch (x) {\n" 10877 "default:\n" 10878 " break;\n" 10879 "}", 10880 SomeSpace); 10881 verifyFormat("A::A() : a (1) {}", SomeSpace); 10882 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 10883 verifyFormat("*(&a + 1);\n" 10884 "&((&a)[1]);\n" 10885 "a[(b + c) * d];\n" 10886 "(((a + 1) * 2) + 3) * 4;", 10887 SomeSpace); 10888 verifyFormat("#define A(x) x", SomeSpace); 10889 verifyFormat("#define A (x) x", SomeSpace); 10890 verifyFormat("#if defined(x)\n" 10891 "#endif", 10892 SomeSpace); 10893 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 10894 verifyFormat("size_t x = sizeof (x);", SomeSpace); 10895 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 10896 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 10897 verifyFormat("alignas (128) char a[128];", SomeSpace); 10898 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 10899 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 10900 SomeSpace); 10901 verifyFormat("int f() throw (Deprecated);", SomeSpace); 10902 verifyFormat("typedef void (*cb) (int);", SomeSpace); 10903 verifyFormat("T A::operator()();", SomeSpace); 10904 verifyFormat("X A::operator++ (T);", SomeSpace); 10905 verifyFormat("int x = int (y);", SomeSpace); 10906 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 10907 } 10908 10909 TEST_F(FormatTest, SpaceAfterLogicalNot) { 10910 FormatStyle Spaces = getLLVMStyle(); 10911 Spaces.SpaceAfterLogicalNot = true; 10912 10913 verifyFormat("bool x = ! y", Spaces); 10914 verifyFormat("if (! isFailure())", Spaces); 10915 verifyFormat("if (! (a && b))", Spaces); 10916 verifyFormat("\"Error!\"", Spaces); 10917 verifyFormat("! ! x", Spaces); 10918 } 10919 10920 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 10921 FormatStyle Spaces = getLLVMStyle(); 10922 10923 Spaces.SpacesInParentheses = true; 10924 verifyFormat("do_something( ::globalVar );", Spaces); 10925 verifyFormat("call( x, y, z );", Spaces); 10926 verifyFormat("call();", Spaces); 10927 verifyFormat("std::function<void( int, int )> callback;", Spaces); 10928 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 10929 Spaces); 10930 verifyFormat("while ( (bool)1 )\n" 10931 " continue;", 10932 Spaces); 10933 verifyFormat("for ( ;; )\n" 10934 " continue;", 10935 Spaces); 10936 verifyFormat("if ( true )\n" 10937 " f();\n" 10938 "else if ( true )\n" 10939 " f();", 10940 Spaces); 10941 verifyFormat("do {\n" 10942 " do_something( (int)i );\n" 10943 "} while ( something() );", 10944 Spaces); 10945 verifyFormat("switch ( x ) {\n" 10946 "default:\n" 10947 " break;\n" 10948 "}", 10949 Spaces); 10950 10951 Spaces.SpacesInParentheses = false; 10952 Spaces.SpacesInCStyleCastParentheses = true; 10953 verifyFormat("Type *A = ( Type * )P;", Spaces); 10954 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 10955 verifyFormat("x = ( int32 )y;", Spaces); 10956 verifyFormat("int a = ( int )(2.0f);", Spaces); 10957 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 10958 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 10959 verifyFormat("#define x (( int )-1)", Spaces); 10960 10961 // Run the first set of tests again with: 10962 Spaces.SpacesInParentheses = false; 10963 Spaces.SpaceInEmptyParentheses = true; 10964 Spaces.SpacesInCStyleCastParentheses = true; 10965 verifyFormat("call(x, y, z);", Spaces); 10966 verifyFormat("call( );", Spaces); 10967 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10968 verifyFormat("while (( bool )1)\n" 10969 " continue;", 10970 Spaces); 10971 verifyFormat("for (;;)\n" 10972 " continue;", 10973 Spaces); 10974 verifyFormat("if (true)\n" 10975 " f( );\n" 10976 "else if (true)\n" 10977 " f( );", 10978 Spaces); 10979 verifyFormat("do {\n" 10980 " do_something(( int )i);\n" 10981 "} while (something( ));", 10982 Spaces); 10983 verifyFormat("switch (x) {\n" 10984 "default:\n" 10985 " break;\n" 10986 "}", 10987 Spaces); 10988 10989 // Run the first set of tests again with: 10990 Spaces.SpaceAfterCStyleCast = true; 10991 verifyFormat("call(x, y, z);", Spaces); 10992 verifyFormat("call( );", Spaces); 10993 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10994 verifyFormat("while (( bool ) 1)\n" 10995 " continue;", 10996 Spaces); 10997 verifyFormat("for (;;)\n" 10998 " continue;", 10999 Spaces); 11000 verifyFormat("if (true)\n" 11001 " f( );\n" 11002 "else if (true)\n" 11003 " f( );", 11004 Spaces); 11005 verifyFormat("do {\n" 11006 " do_something(( int ) i);\n" 11007 "} while (something( ));", 11008 Spaces); 11009 verifyFormat("switch (x) {\n" 11010 "default:\n" 11011 " break;\n" 11012 "}", 11013 Spaces); 11014 11015 // Run subset of tests again with: 11016 Spaces.SpacesInCStyleCastParentheses = false; 11017 Spaces.SpaceAfterCStyleCast = true; 11018 verifyFormat("while ((bool) 1)\n" 11019 " continue;", 11020 Spaces); 11021 verifyFormat("do {\n" 11022 " do_something((int) i);\n" 11023 "} while (something( ));", 11024 Spaces); 11025 } 11026 11027 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 11028 verifyFormat("int a[5];"); 11029 verifyFormat("a[3] += 42;"); 11030 11031 FormatStyle Spaces = getLLVMStyle(); 11032 Spaces.SpacesInSquareBrackets = true; 11033 // Not lambdas. 11034 verifyFormat("int a[ 5 ];", Spaces); 11035 verifyFormat("a[ 3 ] += 42;", Spaces); 11036 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 11037 verifyFormat("double &operator[](int i) { return 0; }\n" 11038 "int i;", 11039 Spaces); 11040 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 11041 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 11042 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 11043 // Lambdas. 11044 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 11045 verifyFormat("return [ i, args... ] {};", Spaces); 11046 verifyFormat("int foo = [ &bar ]() {};", Spaces); 11047 verifyFormat("int foo = [ = ]() {};", Spaces); 11048 verifyFormat("int foo = [ & ]() {};", Spaces); 11049 verifyFormat("int foo = [ =, &bar ]() {};", Spaces); 11050 verifyFormat("int foo = [ &bar, = ]() {};", Spaces); 11051 } 11052 11053 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) { 11054 FormatStyle NoSpaceStyle = getLLVMStyle(); 11055 verifyFormat("int a[5];", NoSpaceStyle); 11056 verifyFormat("a[3] += 42;", NoSpaceStyle); 11057 11058 verifyFormat("int a[1];", NoSpaceStyle); 11059 verifyFormat("int 1 [a];", NoSpaceStyle); 11060 verifyFormat("int a[1][2];", NoSpaceStyle); 11061 verifyFormat("a[7] = 5;", NoSpaceStyle); 11062 verifyFormat("int a = (f())[23];", NoSpaceStyle); 11063 verifyFormat("f([] {})", NoSpaceStyle); 11064 11065 FormatStyle Space = getLLVMStyle(); 11066 Space.SpaceBeforeSquareBrackets = true; 11067 verifyFormat("int c = []() -> int { return 2; }();\n", Space); 11068 verifyFormat("return [i, args...] {};", Space); 11069 11070 verifyFormat("int a [5];", Space); 11071 verifyFormat("a [3] += 42;", Space); 11072 verifyFormat("constexpr char hello []{\"hello\"};", Space); 11073 verifyFormat("double &operator[](int i) { return 0; }\n" 11074 "int i;", 11075 Space); 11076 verifyFormat("std::unique_ptr<int []> foo() {}", Space); 11077 verifyFormat("int i = a [a][a]->f();", Space); 11078 verifyFormat("int i = (*b) [a]->f();", Space); 11079 11080 verifyFormat("int a [1];", Space); 11081 verifyFormat("int 1 [a];", Space); 11082 verifyFormat("int a [1][2];", Space); 11083 verifyFormat("a [7] = 5;", Space); 11084 verifyFormat("int a = (f()) [23];", Space); 11085 verifyFormat("f([] {})", Space); 11086 } 11087 11088 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 11089 verifyFormat("int a = 5;"); 11090 verifyFormat("a += 42;"); 11091 verifyFormat("a or_eq 8;"); 11092 11093 FormatStyle Spaces = getLLVMStyle(); 11094 Spaces.SpaceBeforeAssignmentOperators = false; 11095 verifyFormat("int a= 5;", Spaces); 11096 verifyFormat("a+= 42;", Spaces); 11097 verifyFormat("a or_eq 8;", Spaces); 11098 } 11099 11100 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 11101 verifyFormat("class Foo : public Bar {};"); 11102 verifyFormat("Foo::Foo() : foo(1) {}"); 11103 verifyFormat("for (auto a : b) {\n}"); 11104 verifyFormat("int x = a ? b : c;"); 11105 verifyFormat("{\n" 11106 "label0:\n" 11107 " int x = 0;\n" 11108 "}"); 11109 verifyFormat("switch (x) {\n" 11110 "case 1:\n" 11111 "default:\n" 11112 "}"); 11113 11114 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 11115 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 11116 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 11117 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 11118 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 11119 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 11120 verifyFormat("{\n" 11121 "label1:\n" 11122 " int x = 0;\n" 11123 "}", 11124 CtorInitializerStyle); 11125 verifyFormat("switch (x) {\n" 11126 "case 1:\n" 11127 "default:\n" 11128 "}", 11129 CtorInitializerStyle); 11130 CtorInitializerStyle.BreakConstructorInitializers = 11131 FormatStyle::BCIS_AfterColon; 11132 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 11133 " aaaaaaaaaaaaaaaa(1),\n" 11134 " bbbbbbbbbbbbbbbb(2) {}", 11135 CtorInitializerStyle); 11136 CtorInitializerStyle.BreakConstructorInitializers = 11137 FormatStyle::BCIS_BeforeComma; 11138 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 11139 " : aaaaaaaaaaaaaaaa(1)\n" 11140 " , bbbbbbbbbbbbbbbb(2) {}", 11141 CtorInitializerStyle); 11142 CtorInitializerStyle.BreakConstructorInitializers = 11143 FormatStyle::BCIS_BeforeColon; 11144 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 11145 " : aaaaaaaaaaaaaaaa(1),\n" 11146 " bbbbbbbbbbbbbbbb(2) {}", 11147 CtorInitializerStyle); 11148 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 11149 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 11150 ": aaaaaaaaaaaaaaaa(1),\n" 11151 " bbbbbbbbbbbbbbbb(2) {}", 11152 CtorInitializerStyle); 11153 11154 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 11155 InheritanceStyle.SpaceBeforeInheritanceColon = false; 11156 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 11157 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 11158 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 11159 verifyFormat("int x = a ? b : c;", InheritanceStyle); 11160 verifyFormat("{\n" 11161 "label2:\n" 11162 " int x = 0;\n" 11163 "}", 11164 InheritanceStyle); 11165 verifyFormat("switch (x) {\n" 11166 "case 1:\n" 11167 "default:\n" 11168 "}", 11169 InheritanceStyle); 11170 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 11171 verifyFormat("class Foooooooooooooooooooooo:\n" 11172 " public aaaaaaaaaaaaaaaaaa,\n" 11173 " public bbbbbbbbbbbbbbbbbb {\n" 11174 "}", 11175 InheritanceStyle); 11176 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 11177 verifyFormat("class Foooooooooooooooooooooo\n" 11178 " : public aaaaaaaaaaaaaaaaaa\n" 11179 " , public bbbbbbbbbbbbbbbbbb {\n" 11180 "}", 11181 InheritanceStyle); 11182 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 11183 verifyFormat("class Foooooooooooooooooooooo\n" 11184 " : public aaaaaaaaaaaaaaaaaa,\n" 11185 " public bbbbbbbbbbbbbbbbbb {\n" 11186 "}", 11187 InheritanceStyle); 11188 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 11189 verifyFormat("class Foooooooooooooooooooooo\n" 11190 ": public aaaaaaaaaaaaaaaaaa,\n" 11191 " public bbbbbbbbbbbbbbbbbb {}", 11192 InheritanceStyle); 11193 11194 FormatStyle ForLoopStyle = getLLVMStyle(); 11195 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 11196 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 11197 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 11198 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 11199 verifyFormat("int x = a ? b : c;", ForLoopStyle); 11200 verifyFormat("{\n" 11201 "label2:\n" 11202 " int x = 0;\n" 11203 "}", 11204 ForLoopStyle); 11205 verifyFormat("switch (x) {\n" 11206 "case 1:\n" 11207 "default:\n" 11208 "}", 11209 ForLoopStyle); 11210 11211 FormatStyle NoSpaceStyle = getLLVMStyle(); 11212 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 11213 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 11214 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 11215 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 11216 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 11217 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 11218 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 11219 verifyFormat("{\n" 11220 "label3:\n" 11221 " int x = 0;\n" 11222 "}", 11223 NoSpaceStyle); 11224 verifyFormat("switch (x) {\n" 11225 "case 1:\n" 11226 "default:\n" 11227 "}", 11228 NoSpaceStyle); 11229 } 11230 11231 TEST_F(FormatTest, AlignConsecutiveMacros) { 11232 FormatStyle Style = getLLVMStyle(); 11233 Style.AlignConsecutiveAssignments = true; 11234 Style.AlignConsecutiveDeclarations = true; 11235 Style.AlignConsecutiveMacros = false; 11236 11237 verifyFormat("#define a 3\n" 11238 "#define bbbb 4\n" 11239 "#define ccc (5)", 11240 Style); 11241 11242 verifyFormat("#define f(x) (x * x)\n" 11243 "#define fff(x, y, z) (x * y + z)\n" 11244 "#define ffff(x, y) (x - y)", 11245 Style); 11246 11247 verifyFormat("#define foo(x, y) (x + y)\n" 11248 "#define bar (5, 6)(2 + 2)", 11249 Style); 11250 11251 verifyFormat("#define a 3\n" 11252 "#define bbbb 4\n" 11253 "#define ccc (5)\n" 11254 "#define f(x) (x * x)\n" 11255 "#define fff(x, y, z) (x * y + z)\n" 11256 "#define ffff(x, y) (x - y)", 11257 Style); 11258 11259 Style.AlignConsecutiveMacros = true; 11260 verifyFormat("#define a 3\n" 11261 "#define bbbb 4\n" 11262 "#define ccc (5)", 11263 Style); 11264 11265 verifyFormat("#define f(x) (x * x)\n" 11266 "#define fff(x, y, z) (x * y + z)\n" 11267 "#define ffff(x, y) (x - y)", 11268 Style); 11269 11270 verifyFormat("#define foo(x, y) (x + y)\n" 11271 "#define bar (5, 6)(2 + 2)", 11272 Style); 11273 11274 verifyFormat("#define a 3\n" 11275 "#define bbbb 4\n" 11276 "#define ccc (5)\n" 11277 "#define f(x) (x * x)\n" 11278 "#define fff(x, y, z) (x * y + z)\n" 11279 "#define ffff(x, y) (x - y)", 11280 Style); 11281 11282 verifyFormat("#define a 5\n" 11283 "#define foo(x, y) (x + y)\n" 11284 "#define CCC (6)\n" 11285 "auto lambda = []() {\n" 11286 " auto ii = 0;\n" 11287 " float j = 0;\n" 11288 " return 0;\n" 11289 "};\n" 11290 "int i = 0;\n" 11291 "float i2 = 0;\n" 11292 "auto v = type{\n" 11293 " i = 1, //\n" 11294 " (i = 2), //\n" 11295 " i = 3 //\n" 11296 "};", 11297 Style); 11298 11299 Style.AlignConsecutiveMacros = false; 11300 Style.ColumnLimit = 20; 11301 11302 verifyFormat("#define a \\\n" 11303 " \"aabbbbbbbbbbbb\"\n" 11304 "#define D \\\n" 11305 " \"aabbbbbbbbbbbb\" \\\n" 11306 " \"ccddeeeeeeeee\"\n" 11307 "#define B \\\n" 11308 " \"QQQQQQQQQQQQQ\" \\\n" 11309 " \"FFFFFFFFFFFFF\" \\\n" 11310 " \"LLLLLLLL\"\n", 11311 Style); 11312 11313 Style.AlignConsecutiveMacros = true; 11314 verifyFormat("#define a \\\n" 11315 " \"aabbbbbbbbbbbb\"\n" 11316 "#define D \\\n" 11317 " \"aabbbbbbbbbbbb\" \\\n" 11318 " \"ccddeeeeeeeee\"\n" 11319 "#define B \\\n" 11320 " \"QQQQQQQQQQQQQ\" \\\n" 11321 " \"FFFFFFFFFFFFF\" \\\n" 11322 " \"LLLLLLLL\"\n", 11323 Style); 11324 } 11325 11326 TEST_F(FormatTest, AlignConsecutiveAssignments) { 11327 FormatStyle Alignment = getLLVMStyle(); 11328 Alignment.AlignConsecutiveMacros = true; 11329 Alignment.AlignConsecutiveAssignments = false; 11330 verifyFormat("int a = 5;\n" 11331 "int oneTwoThree = 123;", 11332 Alignment); 11333 verifyFormat("int a = 5;\n" 11334 "int oneTwoThree = 123;", 11335 Alignment); 11336 11337 Alignment.AlignConsecutiveAssignments = true; 11338 verifyFormat("int a = 5;\n" 11339 "int oneTwoThree = 123;", 11340 Alignment); 11341 verifyFormat("int a = method();\n" 11342 "int oneTwoThree = 133;", 11343 Alignment); 11344 verifyFormat("a &= 5;\n" 11345 "bcd *= 5;\n" 11346 "ghtyf += 5;\n" 11347 "dvfvdb -= 5;\n" 11348 "a /= 5;\n" 11349 "vdsvsv %= 5;\n" 11350 "sfdbddfbdfbb ^= 5;\n" 11351 "dvsdsv |= 5;\n" 11352 "int dsvvdvsdvvv = 123;", 11353 Alignment); 11354 verifyFormat("int i = 1, j = 10;\n" 11355 "something = 2000;", 11356 Alignment); 11357 verifyFormat("something = 2000;\n" 11358 "int i = 1, j = 10;\n", 11359 Alignment); 11360 verifyFormat("something = 2000;\n" 11361 "another = 911;\n" 11362 "int i = 1, j = 10;\n" 11363 "oneMore = 1;\n" 11364 "i = 2;", 11365 Alignment); 11366 verifyFormat("int a = 5;\n" 11367 "int one = 1;\n" 11368 "method();\n" 11369 "int oneTwoThree = 123;\n" 11370 "int oneTwo = 12;", 11371 Alignment); 11372 verifyFormat("int oneTwoThree = 123;\n" 11373 "int oneTwo = 12;\n" 11374 "method();\n", 11375 Alignment); 11376 verifyFormat("int oneTwoThree = 123; // comment\n" 11377 "int oneTwo = 12; // comment", 11378 Alignment); 11379 EXPECT_EQ("int a = 5;\n" 11380 "\n" 11381 "int oneTwoThree = 123;", 11382 format("int a = 5;\n" 11383 "\n" 11384 "int oneTwoThree= 123;", 11385 Alignment)); 11386 EXPECT_EQ("int a = 5;\n" 11387 "int one = 1;\n" 11388 "\n" 11389 "int oneTwoThree = 123;", 11390 format("int a = 5;\n" 11391 "int one = 1;\n" 11392 "\n" 11393 "int oneTwoThree = 123;", 11394 Alignment)); 11395 EXPECT_EQ("int a = 5;\n" 11396 "int one = 1;\n" 11397 "\n" 11398 "int oneTwoThree = 123;\n" 11399 "int oneTwo = 12;", 11400 format("int a = 5;\n" 11401 "int one = 1;\n" 11402 "\n" 11403 "int oneTwoThree = 123;\n" 11404 "int oneTwo = 12;", 11405 Alignment)); 11406 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11407 verifyFormat("#define A \\\n" 11408 " int aaaa = 12; \\\n" 11409 " int b = 23; \\\n" 11410 " int ccc = 234; \\\n" 11411 " int dddddddddd = 2345;", 11412 Alignment); 11413 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11414 verifyFormat("#define A \\\n" 11415 " int aaaa = 12; \\\n" 11416 " int b = 23; \\\n" 11417 " int ccc = 234; \\\n" 11418 " int dddddddddd = 2345;", 11419 Alignment); 11420 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11421 verifyFormat("#define A " 11422 " \\\n" 11423 " int aaaa = 12; " 11424 " \\\n" 11425 " int b = 23; " 11426 " \\\n" 11427 " int ccc = 234; " 11428 " \\\n" 11429 " int dddddddddd = 2345;", 11430 Alignment); 11431 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11432 "k = 4, int l = 5,\n" 11433 " int m = 6) {\n" 11434 " int j = 10;\n" 11435 " otherThing = 1;\n" 11436 "}", 11437 Alignment); 11438 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11439 " int i = 1;\n" 11440 " int j = 2;\n" 11441 " int big = 10000;\n" 11442 "}", 11443 Alignment); 11444 verifyFormat("class C {\n" 11445 "public:\n" 11446 " int i = 1;\n" 11447 " virtual void f() = 0;\n" 11448 "};", 11449 Alignment); 11450 verifyFormat("int i = 1;\n" 11451 "if (SomeType t = getSomething()) {\n" 11452 "}\n" 11453 "int j = 2;\n" 11454 "int big = 10000;", 11455 Alignment); 11456 verifyFormat("int j = 7;\n" 11457 "for (int k = 0; k < N; ++k) {\n" 11458 "}\n" 11459 "int j = 2;\n" 11460 "int big = 10000;\n" 11461 "}", 11462 Alignment); 11463 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11464 verifyFormat("int i = 1;\n" 11465 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11466 " = someLooooooooooooooooongFunction();\n" 11467 "int j = 2;", 11468 Alignment); 11469 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11470 verifyFormat("int i = 1;\n" 11471 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11472 " someLooooooooooooooooongFunction();\n" 11473 "int j = 2;", 11474 Alignment); 11475 11476 verifyFormat("auto lambda = []() {\n" 11477 " auto i = 0;\n" 11478 " return 0;\n" 11479 "};\n" 11480 "int i = 0;\n" 11481 "auto v = type{\n" 11482 " i = 1, //\n" 11483 " (i = 2), //\n" 11484 " i = 3 //\n" 11485 "};", 11486 Alignment); 11487 11488 verifyFormat( 11489 "int i = 1;\n" 11490 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11491 " loooooooooooooooooooooongParameterB);\n" 11492 "int j = 2;", 11493 Alignment); 11494 11495 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 11496 " typename B = very_long_type_name_1,\n" 11497 " typename T_2 = very_long_type_name_2>\n" 11498 "auto foo() {}\n", 11499 Alignment); 11500 verifyFormat("int a, b = 1;\n" 11501 "int c = 2;\n" 11502 "int dd = 3;\n", 11503 Alignment); 11504 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11505 "float b[1][] = {{3.f}};\n", 11506 Alignment); 11507 verifyFormat("for (int i = 0; i < 1; i++)\n" 11508 " int x = 1;\n", 11509 Alignment); 11510 verifyFormat("for (i = 0; i < 1; i++)\n" 11511 " x = 1;\n" 11512 "y = 1;\n", 11513 Alignment); 11514 } 11515 11516 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 11517 FormatStyle Alignment = getLLVMStyle(); 11518 Alignment.AlignConsecutiveMacros = true; 11519 Alignment.AlignConsecutiveDeclarations = false; 11520 verifyFormat("float const a = 5;\n" 11521 "int oneTwoThree = 123;", 11522 Alignment); 11523 verifyFormat("int a = 5;\n" 11524 "float const oneTwoThree = 123;", 11525 Alignment); 11526 11527 Alignment.AlignConsecutiveDeclarations = true; 11528 verifyFormat("float const a = 5;\n" 11529 "int oneTwoThree = 123;", 11530 Alignment); 11531 verifyFormat("int a = method();\n" 11532 "float const oneTwoThree = 133;", 11533 Alignment); 11534 verifyFormat("int i = 1, j = 10;\n" 11535 "something = 2000;", 11536 Alignment); 11537 verifyFormat("something = 2000;\n" 11538 "int i = 1, j = 10;\n", 11539 Alignment); 11540 verifyFormat("float something = 2000;\n" 11541 "double another = 911;\n" 11542 "int i = 1, j = 10;\n" 11543 "const int *oneMore = 1;\n" 11544 "unsigned i = 2;", 11545 Alignment); 11546 verifyFormat("float a = 5;\n" 11547 "int one = 1;\n" 11548 "method();\n" 11549 "const double oneTwoThree = 123;\n" 11550 "const unsigned int oneTwo = 12;", 11551 Alignment); 11552 verifyFormat("int oneTwoThree{0}; // comment\n" 11553 "unsigned oneTwo; // comment", 11554 Alignment); 11555 EXPECT_EQ("float const a = 5;\n" 11556 "\n" 11557 "int oneTwoThree = 123;", 11558 format("float const a = 5;\n" 11559 "\n" 11560 "int oneTwoThree= 123;", 11561 Alignment)); 11562 EXPECT_EQ("float a = 5;\n" 11563 "int one = 1;\n" 11564 "\n" 11565 "unsigned oneTwoThree = 123;", 11566 format("float a = 5;\n" 11567 "int one = 1;\n" 11568 "\n" 11569 "unsigned oneTwoThree = 123;", 11570 Alignment)); 11571 EXPECT_EQ("float a = 5;\n" 11572 "int one = 1;\n" 11573 "\n" 11574 "unsigned oneTwoThree = 123;\n" 11575 "int oneTwo = 12;", 11576 format("float a = 5;\n" 11577 "int one = 1;\n" 11578 "\n" 11579 "unsigned oneTwoThree = 123;\n" 11580 "int oneTwo = 12;", 11581 Alignment)); 11582 // Function prototype alignment 11583 verifyFormat("int a();\n" 11584 "double b();", 11585 Alignment); 11586 verifyFormat("int a(int x);\n" 11587 "double b();", 11588 Alignment); 11589 unsigned OldColumnLimit = Alignment.ColumnLimit; 11590 // We need to set ColumnLimit to zero, in order to stress nested alignments, 11591 // otherwise the function parameters will be re-flowed onto a single line. 11592 Alignment.ColumnLimit = 0; 11593 EXPECT_EQ("int a(int x,\n" 11594 " float y);\n" 11595 "double b(int x,\n" 11596 " double y);", 11597 format("int a(int x,\n" 11598 " float y);\n" 11599 "double b(int x,\n" 11600 " double y);", 11601 Alignment)); 11602 // This ensures that function parameters of function declarations are 11603 // correctly indented when their owning functions are indented. 11604 // The failure case here is for 'double y' to not be indented enough. 11605 EXPECT_EQ("double a(int x);\n" 11606 "int b(int y,\n" 11607 " double z);", 11608 format("double a(int x);\n" 11609 "int b(int y,\n" 11610 " double z);", 11611 Alignment)); 11612 // Set ColumnLimit low so that we induce wrapping immediately after 11613 // the function name and opening paren. 11614 Alignment.ColumnLimit = 13; 11615 verifyFormat("int function(\n" 11616 " int x,\n" 11617 " bool y);", 11618 Alignment); 11619 Alignment.ColumnLimit = OldColumnLimit; 11620 // Ensure function pointers don't screw up recursive alignment 11621 verifyFormat("int a(int x, void (*fp)(int y));\n" 11622 "double b();", 11623 Alignment); 11624 Alignment.AlignConsecutiveAssignments = true; 11625 // Ensure recursive alignment is broken by function braces, so that the 11626 // "a = 1" does not align with subsequent assignments inside the function 11627 // body. 11628 verifyFormat("int func(int a = 1) {\n" 11629 " int b = 2;\n" 11630 " int cc = 3;\n" 11631 "}", 11632 Alignment); 11633 verifyFormat("float something = 2000;\n" 11634 "double another = 911;\n" 11635 "int i = 1, j = 10;\n" 11636 "const int *oneMore = 1;\n" 11637 "unsigned i = 2;", 11638 Alignment); 11639 verifyFormat("int oneTwoThree = {0}; // comment\n" 11640 "unsigned oneTwo = 0; // comment", 11641 Alignment); 11642 // Make sure that scope is correctly tracked, in the absence of braces 11643 verifyFormat("for (int i = 0; i < n; i++)\n" 11644 " j = i;\n" 11645 "double x = 1;\n", 11646 Alignment); 11647 verifyFormat("if (int i = 0)\n" 11648 " j = i;\n" 11649 "double x = 1;\n", 11650 Alignment); 11651 // Ensure operator[] and operator() are comprehended 11652 verifyFormat("struct test {\n" 11653 " long long int foo();\n" 11654 " int operator[](int a);\n" 11655 " double bar();\n" 11656 "};\n", 11657 Alignment); 11658 verifyFormat("struct test {\n" 11659 " long long int foo();\n" 11660 " int operator()(int a);\n" 11661 " double bar();\n" 11662 "};\n", 11663 Alignment); 11664 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 11665 " int const i = 1;\n" 11666 " int * j = 2;\n" 11667 " int big = 10000;\n" 11668 "\n" 11669 " unsigned oneTwoThree = 123;\n" 11670 " int oneTwo = 12;\n" 11671 " method();\n" 11672 " float k = 2;\n" 11673 " int ll = 10000;\n" 11674 "}", 11675 format("void SomeFunction(int parameter= 0) {\n" 11676 " int const i= 1;\n" 11677 " int *j=2;\n" 11678 " int big = 10000;\n" 11679 "\n" 11680 "unsigned oneTwoThree =123;\n" 11681 "int oneTwo = 12;\n" 11682 " method();\n" 11683 "float k= 2;\n" 11684 "int ll=10000;\n" 11685 "}", 11686 Alignment)); 11687 Alignment.AlignConsecutiveAssignments = false; 11688 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11689 verifyFormat("#define A \\\n" 11690 " int aaaa = 12; \\\n" 11691 " float b = 23; \\\n" 11692 " const int ccc = 234; \\\n" 11693 " unsigned dddddddddd = 2345;", 11694 Alignment); 11695 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11696 verifyFormat("#define A \\\n" 11697 " int aaaa = 12; \\\n" 11698 " float b = 23; \\\n" 11699 " const int ccc = 234; \\\n" 11700 " unsigned dddddddddd = 2345;", 11701 Alignment); 11702 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11703 Alignment.ColumnLimit = 30; 11704 verifyFormat("#define A \\\n" 11705 " int aaaa = 12; \\\n" 11706 " float b = 23; \\\n" 11707 " const int ccc = 234; \\\n" 11708 " int dddddddddd = 2345;", 11709 Alignment); 11710 Alignment.ColumnLimit = 80; 11711 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11712 "k = 4, int l = 5,\n" 11713 " int m = 6) {\n" 11714 " const int j = 10;\n" 11715 " otherThing = 1;\n" 11716 "}", 11717 Alignment); 11718 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11719 " int const i = 1;\n" 11720 " int * j = 2;\n" 11721 " int big = 10000;\n" 11722 "}", 11723 Alignment); 11724 verifyFormat("class C {\n" 11725 "public:\n" 11726 " int i = 1;\n" 11727 " virtual void f() = 0;\n" 11728 "};", 11729 Alignment); 11730 verifyFormat("float i = 1;\n" 11731 "if (SomeType t = getSomething()) {\n" 11732 "}\n" 11733 "const unsigned j = 2;\n" 11734 "int big = 10000;", 11735 Alignment); 11736 verifyFormat("float j = 7;\n" 11737 "for (int k = 0; k < N; ++k) {\n" 11738 "}\n" 11739 "unsigned j = 2;\n" 11740 "int big = 10000;\n" 11741 "}", 11742 Alignment); 11743 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11744 verifyFormat("float i = 1;\n" 11745 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11746 " = someLooooooooooooooooongFunction();\n" 11747 "int j = 2;", 11748 Alignment); 11749 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11750 verifyFormat("int i = 1;\n" 11751 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11752 " someLooooooooooooooooongFunction();\n" 11753 "int j = 2;", 11754 Alignment); 11755 11756 Alignment.AlignConsecutiveAssignments = true; 11757 verifyFormat("auto lambda = []() {\n" 11758 " auto ii = 0;\n" 11759 " float j = 0;\n" 11760 " return 0;\n" 11761 "};\n" 11762 "int i = 0;\n" 11763 "float i2 = 0;\n" 11764 "auto v = type{\n" 11765 " i = 1, //\n" 11766 " (i = 2), //\n" 11767 " i = 3 //\n" 11768 "};", 11769 Alignment); 11770 Alignment.AlignConsecutiveAssignments = false; 11771 11772 verifyFormat( 11773 "int i = 1;\n" 11774 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11775 " loooooooooooooooooooooongParameterB);\n" 11776 "int j = 2;", 11777 Alignment); 11778 11779 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 11780 // We expect declarations and assignments to align, as long as it doesn't 11781 // exceed the column limit, starting a new alignment sequence whenever it 11782 // happens. 11783 Alignment.AlignConsecutiveAssignments = true; 11784 Alignment.ColumnLimit = 30; 11785 verifyFormat("float ii = 1;\n" 11786 "unsigned j = 2;\n" 11787 "int someVerylongVariable = 1;\n" 11788 "AnotherLongType ll = 123456;\n" 11789 "VeryVeryLongType k = 2;\n" 11790 "int myvar = 1;", 11791 Alignment); 11792 Alignment.ColumnLimit = 80; 11793 Alignment.AlignConsecutiveAssignments = false; 11794 11795 verifyFormat( 11796 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 11797 " typename LongType, typename B>\n" 11798 "auto foo() {}\n", 11799 Alignment); 11800 verifyFormat("float a, b = 1;\n" 11801 "int c = 2;\n" 11802 "int dd = 3;\n", 11803 Alignment); 11804 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11805 "float b[1][] = {{3.f}};\n", 11806 Alignment); 11807 Alignment.AlignConsecutiveAssignments = true; 11808 verifyFormat("float a, b = 1;\n" 11809 "int c = 2;\n" 11810 "int dd = 3;\n", 11811 Alignment); 11812 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11813 "float b[1][] = {{3.f}};\n", 11814 Alignment); 11815 Alignment.AlignConsecutiveAssignments = false; 11816 11817 Alignment.ColumnLimit = 30; 11818 Alignment.BinPackParameters = false; 11819 verifyFormat("void foo(float a,\n" 11820 " float b,\n" 11821 " int c,\n" 11822 " uint32_t *d) {\n" 11823 " int * e = 0;\n" 11824 " float f = 0;\n" 11825 " double g = 0;\n" 11826 "}\n" 11827 "void bar(ino_t a,\n" 11828 " int b,\n" 11829 " uint32_t *c,\n" 11830 " bool d) {}\n", 11831 Alignment); 11832 Alignment.BinPackParameters = true; 11833 Alignment.ColumnLimit = 80; 11834 11835 // Bug 33507 11836 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 11837 verifyFormat( 11838 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 11839 " static const Version verVs2017;\n" 11840 " return true;\n" 11841 "});\n", 11842 Alignment); 11843 Alignment.PointerAlignment = FormatStyle::PAS_Right; 11844 11845 // See llvm.org/PR35641 11846 Alignment.AlignConsecutiveDeclarations = true; 11847 verifyFormat("int func() { //\n" 11848 " int b;\n" 11849 " unsigned c;\n" 11850 "}", 11851 Alignment); 11852 11853 // See PR37175 11854 FormatStyle Style = getMozillaStyle(); 11855 Style.AlignConsecutiveDeclarations = true; 11856 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 11857 "foo(int a);", 11858 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 11859 } 11860 11861 TEST_F(FormatTest, LinuxBraceBreaking) { 11862 FormatStyle LinuxBraceStyle = getLLVMStyle(); 11863 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 11864 verifyFormat("namespace a\n" 11865 "{\n" 11866 "class A\n" 11867 "{\n" 11868 " void f()\n" 11869 " {\n" 11870 " if (true) {\n" 11871 " a();\n" 11872 " b();\n" 11873 " } else {\n" 11874 " a();\n" 11875 " }\n" 11876 " }\n" 11877 " void g() { return; }\n" 11878 "};\n" 11879 "struct B {\n" 11880 " int x;\n" 11881 "};\n" 11882 "} // namespace a\n", 11883 LinuxBraceStyle); 11884 verifyFormat("enum X {\n" 11885 " Y = 0,\n" 11886 "}\n", 11887 LinuxBraceStyle); 11888 verifyFormat("struct S {\n" 11889 " int Type;\n" 11890 " union {\n" 11891 " int x;\n" 11892 " double y;\n" 11893 " } Value;\n" 11894 " class C\n" 11895 " {\n" 11896 " MyFavoriteType Value;\n" 11897 " } Class;\n" 11898 "}\n", 11899 LinuxBraceStyle); 11900 } 11901 11902 TEST_F(FormatTest, MozillaBraceBreaking) { 11903 FormatStyle MozillaBraceStyle = getLLVMStyle(); 11904 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 11905 MozillaBraceStyle.FixNamespaceComments = false; 11906 verifyFormat("namespace a {\n" 11907 "class A\n" 11908 "{\n" 11909 " void f()\n" 11910 " {\n" 11911 " if (true) {\n" 11912 " a();\n" 11913 " b();\n" 11914 " }\n" 11915 " }\n" 11916 " void g() { return; }\n" 11917 "};\n" 11918 "enum E\n" 11919 "{\n" 11920 " A,\n" 11921 " // foo\n" 11922 " B,\n" 11923 " C\n" 11924 "};\n" 11925 "struct B\n" 11926 "{\n" 11927 " int x;\n" 11928 "};\n" 11929 "}\n", 11930 MozillaBraceStyle); 11931 verifyFormat("struct S\n" 11932 "{\n" 11933 " int Type;\n" 11934 " union\n" 11935 " {\n" 11936 " int x;\n" 11937 " double y;\n" 11938 " } Value;\n" 11939 " class C\n" 11940 " {\n" 11941 " MyFavoriteType Value;\n" 11942 " } Class;\n" 11943 "}\n", 11944 MozillaBraceStyle); 11945 } 11946 11947 TEST_F(FormatTest, StroustrupBraceBreaking) { 11948 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 11949 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11950 verifyFormat("namespace a {\n" 11951 "class A {\n" 11952 " void f()\n" 11953 " {\n" 11954 " if (true) {\n" 11955 " a();\n" 11956 " b();\n" 11957 " }\n" 11958 " }\n" 11959 " void g() { return; }\n" 11960 "};\n" 11961 "struct B {\n" 11962 " int x;\n" 11963 "};\n" 11964 "} // namespace a\n", 11965 StroustrupBraceStyle); 11966 11967 verifyFormat("void foo()\n" 11968 "{\n" 11969 " if (a) {\n" 11970 " a();\n" 11971 " }\n" 11972 " else {\n" 11973 " b();\n" 11974 " }\n" 11975 "}\n", 11976 StroustrupBraceStyle); 11977 11978 verifyFormat("#ifdef _DEBUG\n" 11979 "int foo(int i = 0)\n" 11980 "#else\n" 11981 "int foo(int i = 5)\n" 11982 "#endif\n" 11983 "{\n" 11984 " return i;\n" 11985 "}", 11986 StroustrupBraceStyle); 11987 11988 verifyFormat("void foo() {}\n" 11989 "void bar()\n" 11990 "#ifdef _DEBUG\n" 11991 "{\n" 11992 " foo();\n" 11993 "}\n" 11994 "#else\n" 11995 "{\n" 11996 "}\n" 11997 "#endif", 11998 StroustrupBraceStyle); 11999 12000 verifyFormat("void foobar() { int i = 5; }\n" 12001 "#ifdef _DEBUG\n" 12002 "void bar() {}\n" 12003 "#else\n" 12004 "void bar() { foobar(); }\n" 12005 "#endif", 12006 StroustrupBraceStyle); 12007 } 12008 12009 TEST_F(FormatTest, AllmanBraceBreaking) { 12010 FormatStyle AllmanBraceStyle = getLLVMStyle(); 12011 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 12012 12013 EXPECT_EQ("namespace a\n" 12014 "{\n" 12015 "void f();\n" 12016 "void g();\n" 12017 "} // namespace a\n", 12018 format("namespace a\n" 12019 "{\n" 12020 "void f();\n" 12021 "void g();\n" 12022 "}\n", 12023 AllmanBraceStyle)); 12024 12025 verifyFormat("namespace a\n" 12026 "{\n" 12027 "class A\n" 12028 "{\n" 12029 " void f()\n" 12030 " {\n" 12031 " if (true)\n" 12032 " {\n" 12033 " a();\n" 12034 " b();\n" 12035 " }\n" 12036 " }\n" 12037 " void g() { return; }\n" 12038 "};\n" 12039 "struct B\n" 12040 "{\n" 12041 " int x;\n" 12042 "};\n" 12043 "union C\n" 12044 "{\n" 12045 "};\n" 12046 "} // namespace a", 12047 AllmanBraceStyle); 12048 12049 verifyFormat("void f()\n" 12050 "{\n" 12051 " if (true)\n" 12052 " {\n" 12053 " a();\n" 12054 " }\n" 12055 " else if (false)\n" 12056 " {\n" 12057 " b();\n" 12058 " }\n" 12059 " else\n" 12060 " {\n" 12061 " c();\n" 12062 " }\n" 12063 "}\n", 12064 AllmanBraceStyle); 12065 12066 verifyFormat("void f()\n" 12067 "{\n" 12068 " for (int i = 0; i < 10; ++i)\n" 12069 " {\n" 12070 " a();\n" 12071 " }\n" 12072 " while (false)\n" 12073 " {\n" 12074 " b();\n" 12075 " }\n" 12076 " do\n" 12077 " {\n" 12078 " c();\n" 12079 " } while (false)\n" 12080 "}\n", 12081 AllmanBraceStyle); 12082 12083 verifyFormat("void f(int a)\n" 12084 "{\n" 12085 " switch (a)\n" 12086 " {\n" 12087 " case 0:\n" 12088 " break;\n" 12089 " case 1:\n" 12090 " {\n" 12091 " break;\n" 12092 " }\n" 12093 " case 2:\n" 12094 " {\n" 12095 " }\n" 12096 " break;\n" 12097 " default:\n" 12098 " break;\n" 12099 " }\n" 12100 "}\n", 12101 AllmanBraceStyle); 12102 12103 verifyFormat("enum X\n" 12104 "{\n" 12105 " Y = 0,\n" 12106 "}\n", 12107 AllmanBraceStyle); 12108 verifyFormat("enum X\n" 12109 "{\n" 12110 " Y = 0\n" 12111 "}\n", 12112 AllmanBraceStyle); 12113 12114 verifyFormat("@interface BSApplicationController ()\n" 12115 "{\n" 12116 "@private\n" 12117 " id _extraIvar;\n" 12118 "}\n" 12119 "@end\n", 12120 AllmanBraceStyle); 12121 12122 verifyFormat("#ifdef _DEBUG\n" 12123 "int foo(int i = 0)\n" 12124 "#else\n" 12125 "int foo(int i = 5)\n" 12126 "#endif\n" 12127 "{\n" 12128 " return i;\n" 12129 "}", 12130 AllmanBraceStyle); 12131 12132 verifyFormat("void foo() {}\n" 12133 "void bar()\n" 12134 "#ifdef _DEBUG\n" 12135 "{\n" 12136 " foo();\n" 12137 "}\n" 12138 "#else\n" 12139 "{\n" 12140 "}\n" 12141 "#endif", 12142 AllmanBraceStyle); 12143 12144 verifyFormat("void foobar() { int i = 5; }\n" 12145 "#ifdef _DEBUG\n" 12146 "void bar() {}\n" 12147 "#else\n" 12148 "void bar() { foobar(); }\n" 12149 "#endif", 12150 AllmanBraceStyle); 12151 12152 // This shouldn't affect ObjC blocks.. 12153 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 12154 " // ...\n" 12155 " int i;\n" 12156 "}];", 12157 AllmanBraceStyle); 12158 verifyFormat("void (^block)(void) = ^{\n" 12159 " // ...\n" 12160 " int i;\n" 12161 "};", 12162 AllmanBraceStyle); 12163 // .. or dict literals. 12164 verifyFormat("void f()\n" 12165 "{\n" 12166 " // ...\n" 12167 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 12168 "}", 12169 AllmanBraceStyle); 12170 verifyFormat("void f()\n" 12171 "{\n" 12172 " // ...\n" 12173 " [object someMethod:@{a : @\"b\"}];\n" 12174 "}", 12175 AllmanBraceStyle); 12176 verifyFormat("int f()\n" 12177 "{ // comment\n" 12178 " return 42;\n" 12179 "}", 12180 AllmanBraceStyle); 12181 12182 AllmanBraceStyle.ColumnLimit = 19; 12183 verifyFormat("void f() { int i; }", AllmanBraceStyle); 12184 AllmanBraceStyle.ColumnLimit = 18; 12185 verifyFormat("void f()\n" 12186 "{\n" 12187 " int i;\n" 12188 "}", 12189 AllmanBraceStyle); 12190 AllmanBraceStyle.ColumnLimit = 80; 12191 12192 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 12193 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 12194 FormatStyle::SIS_WithoutElse; 12195 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 12196 verifyFormat("void f(bool b)\n" 12197 "{\n" 12198 " if (b)\n" 12199 " {\n" 12200 " return;\n" 12201 " }\n" 12202 "}\n", 12203 BreakBeforeBraceShortIfs); 12204 verifyFormat("void f(bool b)\n" 12205 "{\n" 12206 " if constexpr (b)\n" 12207 " {\n" 12208 " return;\n" 12209 " }\n" 12210 "}\n", 12211 BreakBeforeBraceShortIfs); 12212 verifyFormat("void f(bool b)\n" 12213 "{\n" 12214 " if CONSTEXPR (b)\n" 12215 " {\n" 12216 " return;\n" 12217 " }\n" 12218 "}\n", 12219 BreakBeforeBraceShortIfs); 12220 verifyFormat("void f(bool b)\n" 12221 "{\n" 12222 " if (b) return;\n" 12223 "}\n", 12224 BreakBeforeBraceShortIfs); 12225 verifyFormat("void f(bool b)\n" 12226 "{\n" 12227 " if constexpr (b) return;\n" 12228 "}\n", 12229 BreakBeforeBraceShortIfs); 12230 verifyFormat("void f(bool b)\n" 12231 "{\n" 12232 " if CONSTEXPR (b) return;\n" 12233 "}\n", 12234 BreakBeforeBraceShortIfs); 12235 verifyFormat("void f(bool b)\n" 12236 "{\n" 12237 " while (b)\n" 12238 " {\n" 12239 " return;\n" 12240 " }\n" 12241 "}\n", 12242 BreakBeforeBraceShortIfs); 12243 } 12244 12245 TEST_F(FormatTest, WhitesmithsBraceBreaking) { 12246 FormatStyle WhitesmithsBraceStyle = getLLVMStyle(); 12247 WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 12248 12249 // Make a few changes to the style for testing purposes 12250 WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine = 12251 FormatStyle::SFS_Empty; 12252 WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 12253 WhitesmithsBraceStyle.ColumnLimit = 0; 12254 12255 // FIXME: this test case can't decide whether there should be a blank line 12256 // after the ~D() line or not. It adds one if one doesn't exist in the test 12257 // and it removes the line if one exists. 12258 /* 12259 verifyFormat("class A;\n" 12260 "namespace B\n" 12261 " {\n" 12262 "class C;\n" 12263 "// Comment\n" 12264 "class D\n" 12265 " {\n" 12266 "public:\n" 12267 " D();\n" 12268 " ~D() {}\n" 12269 "private:\n" 12270 " enum E\n" 12271 " {\n" 12272 " F\n" 12273 " }\n" 12274 " };\n" 12275 " } // namespace B\n", 12276 WhitesmithsBraceStyle); 12277 */ 12278 12279 verifyFormat("namespace a\n" 12280 " {\n" 12281 "class A\n" 12282 " {\n" 12283 " void f()\n" 12284 " {\n" 12285 " if (true)\n" 12286 " {\n" 12287 " a();\n" 12288 " b();\n" 12289 " }\n" 12290 " }\n" 12291 " void g()\n" 12292 " {\n" 12293 " return;\n" 12294 " }\n" 12295 " };\n" 12296 "struct B\n" 12297 " {\n" 12298 " int x;\n" 12299 " };\n" 12300 " } // namespace a", 12301 WhitesmithsBraceStyle); 12302 12303 verifyFormat("void f()\n" 12304 " {\n" 12305 " if (true)\n" 12306 " {\n" 12307 " a();\n" 12308 " }\n" 12309 " else if (false)\n" 12310 " {\n" 12311 " b();\n" 12312 " }\n" 12313 " else\n" 12314 " {\n" 12315 " c();\n" 12316 " }\n" 12317 " }\n", 12318 WhitesmithsBraceStyle); 12319 12320 verifyFormat("void f()\n" 12321 " {\n" 12322 " for (int i = 0; i < 10; ++i)\n" 12323 " {\n" 12324 " a();\n" 12325 " }\n" 12326 " while (false)\n" 12327 " {\n" 12328 " b();\n" 12329 " }\n" 12330 " do\n" 12331 " {\n" 12332 " c();\n" 12333 " } while (false)\n" 12334 " }\n", 12335 WhitesmithsBraceStyle); 12336 12337 // FIXME: the block and the break under case 2 in this test don't get indented 12338 // correctly 12339 /* 12340 verifyFormat("void switchTest1(int a)\n" 12341 " {\n" 12342 " switch (a)\n" 12343 " {\n" 12344 " case 2:\n" 12345 " {\n" 12346 " }\n" 12347 " break;\n" 12348 " }\n" 12349 " }\n", 12350 WhitesmithsBraceStyle); 12351 */ 12352 12353 // FIXME: the block and the break under case 2 in this test don't get indented 12354 // correctly 12355 /* 12356 verifyFormat("void switchTest2(int a)\n" 12357 " {\n" 12358 " switch (a)\n" 12359 " {\n" 12360 " case 0:\n" 12361 " break;\n" 12362 " case 1:\n" 12363 " {\n" 12364 " break;\n" 12365 " }\n" 12366 " case 2:\n" 12367 " {\n" 12368 " }\n" 12369 " break;\n" 12370 " default:\n" 12371 " break;\n" 12372 " }\n" 12373 " }\n", 12374 WhitesmithsBraceStyle); 12375 */ 12376 12377 verifyFormat("enum X\n" 12378 " {\n" 12379 " Y = 0, // testing\n" 12380 " }\n", 12381 WhitesmithsBraceStyle); 12382 12383 verifyFormat("enum X\n" 12384 " {\n" 12385 " Y = 0\n" 12386 " }\n", 12387 WhitesmithsBraceStyle); 12388 verifyFormat("enum X\n" 12389 " {\n" 12390 " Y = 0,\n" 12391 " Z = 1\n" 12392 " };\n", 12393 WhitesmithsBraceStyle); 12394 12395 verifyFormat("@interface BSApplicationController ()\n" 12396 " {\n" 12397 "@private\n" 12398 " id _extraIvar;\n" 12399 " }\n" 12400 "@end\n", 12401 WhitesmithsBraceStyle); 12402 12403 verifyFormat("#ifdef _DEBUG\n" 12404 "int foo(int i = 0)\n" 12405 "#else\n" 12406 "int foo(int i = 5)\n" 12407 "#endif\n" 12408 " {\n" 12409 " return i;\n" 12410 " }", 12411 WhitesmithsBraceStyle); 12412 12413 verifyFormat("void foo() {}\n" 12414 "void bar()\n" 12415 "#ifdef _DEBUG\n" 12416 " {\n" 12417 " foo();\n" 12418 " }\n" 12419 "#else\n" 12420 " {\n" 12421 " }\n" 12422 "#endif", 12423 WhitesmithsBraceStyle); 12424 12425 verifyFormat("void foobar()\n" 12426 " {\n" 12427 " int i = 5;\n" 12428 " }\n" 12429 "#ifdef _DEBUG\n" 12430 "void bar()\n" 12431 " {\n" 12432 " }\n" 12433 "#else\n" 12434 "void bar()\n" 12435 " {\n" 12436 " foobar();\n" 12437 " }\n" 12438 "#endif", 12439 WhitesmithsBraceStyle); 12440 12441 // This shouldn't affect ObjC blocks.. 12442 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 12443 " // ...\n" 12444 " int i;\n" 12445 "}];", 12446 WhitesmithsBraceStyle); 12447 verifyFormat("void (^block)(void) = ^{\n" 12448 " // ...\n" 12449 " int i;\n" 12450 "};", 12451 WhitesmithsBraceStyle); 12452 // .. or dict literals. 12453 verifyFormat("void f()\n" 12454 " {\n" 12455 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 12456 " }", 12457 WhitesmithsBraceStyle); 12458 12459 verifyFormat("int f()\n" 12460 " { // comment\n" 12461 " return 42;\n" 12462 " }", 12463 WhitesmithsBraceStyle); 12464 12465 FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle; 12466 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 12467 FormatStyle::SIS_Always; 12468 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 12469 verifyFormat("void f(bool b)\n" 12470 " {\n" 12471 " if (b)\n" 12472 " {\n" 12473 " return;\n" 12474 " }\n" 12475 " }\n", 12476 BreakBeforeBraceShortIfs); 12477 verifyFormat("void f(bool b)\n" 12478 " {\n" 12479 " if (b) return;\n" 12480 " }\n", 12481 BreakBeforeBraceShortIfs); 12482 verifyFormat("void f(bool b)\n" 12483 " {\n" 12484 " while (b)\n" 12485 " {\n" 12486 " return;\n" 12487 " }\n" 12488 " }\n", 12489 BreakBeforeBraceShortIfs); 12490 } 12491 12492 TEST_F(FormatTest, GNUBraceBreaking) { 12493 FormatStyle GNUBraceStyle = getLLVMStyle(); 12494 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 12495 verifyFormat("namespace a\n" 12496 "{\n" 12497 "class A\n" 12498 "{\n" 12499 " void f()\n" 12500 " {\n" 12501 " int a;\n" 12502 " {\n" 12503 " int b;\n" 12504 " }\n" 12505 " if (true)\n" 12506 " {\n" 12507 " a();\n" 12508 " b();\n" 12509 " }\n" 12510 " }\n" 12511 " void g() { return; }\n" 12512 "}\n" 12513 "} // namespace a", 12514 GNUBraceStyle); 12515 12516 verifyFormat("void f()\n" 12517 "{\n" 12518 " if (true)\n" 12519 " {\n" 12520 " a();\n" 12521 " }\n" 12522 " else if (false)\n" 12523 " {\n" 12524 " b();\n" 12525 " }\n" 12526 " else\n" 12527 " {\n" 12528 " c();\n" 12529 " }\n" 12530 "}\n", 12531 GNUBraceStyle); 12532 12533 verifyFormat("void f()\n" 12534 "{\n" 12535 " for (int i = 0; i < 10; ++i)\n" 12536 " {\n" 12537 " a();\n" 12538 " }\n" 12539 " while (false)\n" 12540 " {\n" 12541 " b();\n" 12542 " }\n" 12543 " do\n" 12544 " {\n" 12545 " c();\n" 12546 " }\n" 12547 " while (false);\n" 12548 "}\n", 12549 GNUBraceStyle); 12550 12551 verifyFormat("void f(int a)\n" 12552 "{\n" 12553 " switch (a)\n" 12554 " {\n" 12555 " case 0:\n" 12556 " break;\n" 12557 " case 1:\n" 12558 " {\n" 12559 " break;\n" 12560 " }\n" 12561 " case 2:\n" 12562 " {\n" 12563 " }\n" 12564 " break;\n" 12565 " default:\n" 12566 " break;\n" 12567 " }\n" 12568 "}\n", 12569 GNUBraceStyle); 12570 12571 verifyFormat("enum X\n" 12572 "{\n" 12573 " Y = 0,\n" 12574 "}\n", 12575 GNUBraceStyle); 12576 12577 verifyFormat("@interface BSApplicationController ()\n" 12578 "{\n" 12579 "@private\n" 12580 " id _extraIvar;\n" 12581 "}\n" 12582 "@end\n", 12583 GNUBraceStyle); 12584 12585 verifyFormat("#ifdef _DEBUG\n" 12586 "int foo(int i = 0)\n" 12587 "#else\n" 12588 "int foo(int i = 5)\n" 12589 "#endif\n" 12590 "{\n" 12591 " return i;\n" 12592 "}", 12593 GNUBraceStyle); 12594 12595 verifyFormat("void foo() {}\n" 12596 "void bar()\n" 12597 "#ifdef _DEBUG\n" 12598 "{\n" 12599 " foo();\n" 12600 "}\n" 12601 "#else\n" 12602 "{\n" 12603 "}\n" 12604 "#endif", 12605 GNUBraceStyle); 12606 12607 verifyFormat("void foobar() { int i = 5; }\n" 12608 "#ifdef _DEBUG\n" 12609 "void bar() {}\n" 12610 "#else\n" 12611 "void bar() { foobar(); }\n" 12612 "#endif", 12613 GNUBraceStyle); 12614 } 12615 12616 TEST_F(FormatTest, WebKitBraceBreaking) { 12617 FormatStyle WebKitBraceStyle = getLLVMStyle(); 12618 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 12619 WebKitBraceStyle.FixNamespaceComments = false; 12620 verifyFormat("namespace a {\n" 12621 "class A {\n" 12622 " void f()\n" 12623 " {\n" 12624 " if (true) {\n" 12625 " a();\n" 12626 " b();\n" 12627 " }\n" 12628 " }\n" 12629 " void g() { return; }\n" 12630 "};\n" 12631 "enum E {\n" 12632 " A,\n" 12633 " // foo\n" 12634 " B,\n" 12635 " C\n" 12636 "};\n" 12637 "struct B {\n" 12638 " int x;\n" 12639 "};\n" 12640 "}\n", 12641 WebKitBraceStyle); 12642 verifyFormat("struct S {\n" 12643 " int Type;\n" 12644 " union {\n" 12645 " int x;\n" 12646 " double y;\n" 12647 " } Value;\n" 12648 " class C {\n" 12649 " MyFavoriteType Value;\n" 12650 " } Class;\n" 12651 "};\n", 12652 WebKitBraceStyle); 12653 } 12654 12655 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 12656 verifyFormat("void f() {\n" 12657 " try {\n" 12658 " } catch (const Exception &e) {\n" 12659 " }\n" 12660 "}\n", 12661 getLLVMStyle()); 12662 } 12663 12664 TEST_F(FormatTest, UnderstandsPragmas) { 12665 verifyFormat("#pragma omp reduction(| : var)"); 12666 verifyFormat("#pragma omp reduction(+ : var)"); 12667 12668 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 12669 "(including parentheses).", 12670 format("#pragma mark Any non-hyphenated or hyphenated string " 12671 "(including parentheses).")); 12672 } 12673 12674 TEST_F(FormatTest, UnderstandPragmaOption) { 12675 verifyFormat("#pragma option -C -A"); 12676 12677 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 12678 } 12679 12680 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 12681 FormatStyle Style = getLLVMStyle(); 12682 Style.ColumnLimit = 20; 12683 12684 // See PR41213 12685 EXPECT_EQ("/*\n" 12686 " *\t9012345\n" 12687 " * /8901\n" 12688 " */", 12689 format("/*\n" 12690 " *\t9012345 /8901\n" 12691 " */", 12692 Style)); 12693 EXPECT_EQ("/*\n" 12694 " *345678\n" 12695 " *\t/8901\n" 12696 " */", 12697 format("/*\n" 12698 " *345678\t/8901\n" 12699 " */", 12700 Style)); 12701 12702 verifyFormat("int a; // the\n" 12703 " // comment", 12704 Style); 12705 EXPECT_EQ("int a; /* first line\n" 12706 " * second\n" 12707 " * line third\n" 12708 " * line\n" 12709 " */", 12710 format("int a; /* first line\n" 12711 " * second\n" 12712 " * line third\n" 12713 " * line\n" 12714 " */", 12715 Style)); 12716 EXPECT_EQ("int a; // first line\n" 12717 " // second\n" 12718 " // line third\n" 12719 " // line", 12720 format("int a; // first line\n" 12721 " // second line\n" 12722 " // third line", 12723 Style)); 12724 12725 Style.PenaltyExcessCharacter = 90; 12726 verifyFormat("int a; // the comment", Style); 12727 EXPECT_EQ("int a; // the comment\n" 12728 " // aaa", 12729 format("int a; // the comment aaa", Style)); 12730 EXPECT_EQ("int a; /* first line\n" 12731 " * second line\n" 12732 " * third line\n" 12733 " */", 12734 format("int a; /* first line\n" 12735 " * second line\n" 12736 " * third line\n" 12737 " */", 12738 Style)); 12739 EXPECT_EQ("int a; // first line\n" 12740 " // second line\n" 12741 " // third line", 12742 format("int a; // first line\n" 12743 " // second line\n" 12744 " // third line", 12745 Style)); 12746 // FIXME: Investigate why this is not getting the same layout as the test 12747 // above. 12748 EXPECT_EQ("int a; /* first line\n" 12749 " * second line\n" 12750 " * third line\n" 12751 " */", 12752 format("int a; /* first line second line third line" 12753 "\n*/", 12754 Style)); 12755 12756 EXPECT_EQ("// foo bar baz bazfoo\n" 12757 "// foo bar foo bar\n", 12758 format("// foo bar baz bazfoo\n" 12759 "// foo bar foo bar\n", 12760 Style)); 12761 EXPECT_EQ("// foo bar baz bazfoo\n" 12762 "// foo bar foo bar\n", 12763 format("// foo bar baz bazfoo\n" 12764 "// foo bar foo bar\n", 12765 Style)); 12766 12767 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 12768 // next one. 12769 EXPECT_EQ("// foo bar baz bazfoo\n" 12770 "// bar foo bar\n", 12771 format("// foo bar baz bazfoo bar\n" 12772 "// foo bar\n", 12773 Style)); 12774 12775 EXPECT_EQ("// foo bar baz bazfoo\n" 12776 "// foo bar baz bazfoo\n" 12777 "// bar foo bar\n", 12778 format("// foo bar baz bazfoo\n" 12779 "// foo bar baz bazfoo bar\n" 12780 "// foo bar\n", 12781 Style)); 12782 12783 EXPECT_EQ("// foo bar baz bazfoo\n" 12784 "// foo bar baz bazfoo\n" 12785 "// bar foo bar\n", 12786 format("// foo bar baz bazfoo\n" 12787 "// foo bar baz bazfoo bar\n" 12788 "// foo bar\n", 12789 Style)); 12790 12791 // Make sure we do not keep protruding characters if strict mode reflow is 12792 // cheaper than keeping protruding characters. 12793 Style.ColumnLimit = 21; 12794 EXPECT_EQ( 12795 "// foo foo foo foo\n" 12796 "// foo foo foo foo\n" 12797 "// foo foo foo foo\n", 12798 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style)); 12799 12800 EXPECT_EQ("int a = /* long block\n" 12801 " comment */\n" 12802 " 42;", 12803 format("int a = /* long block comment */ 42;", Style)); 12804 } 12805 12806 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 12807 for (size_t i = 1; i < Styles.size(); ++i) \ 12808 EXPECT_EQ(Styles[0], Styles[i]) \ 12809 << "Style #" << i << " of " << Styles.size() << " differs from Style #0" 12810 12811 TEST_F(FormatTest, GetsPredefinedStyleByName) { 12812 SmallVector<FormatStyle, 3> Styles; 12813 Styles.resize(3); 12814 12815 Styles[0] = getLLVMStyle(); 12816 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 12817 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 12818 EXPECT_ALL_STYLES_EQUAL(Styles); 12819 12820 Styles[0] = getGoogleStyle(); 12821 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 12822 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 12823 EXPECT_ALL_STYLES_EQUAL(Styles); 12824 12825 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12826 EXPECT_TRUE( 12827 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 12828 EXPECT_TRUE( 12829 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 12830 EXPECT_ALL_STYLES_EQUAL(Styles); 12831 12832 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 12833 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 12834 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 12835 EXPECT_ALL_STYLES_EQUAL(Styles); 12836 12837 Styles[0] = getMozillaStyle(); 12838 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 12839 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 12840 EXPECT_ALL_STYLES_EQUAL(Styles); 12841 12842 Styles[0] = getWebKitStyle(); 12843 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 12844 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 12845 EXPECT_ALL_STYLES_EQUAL(Styles); 12846 12847 Styles[0] = getGNUStyle(); 12848 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 12849 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 12850 EXPECT_ALL_STYLES_EQUAL(Styles); 12851 12852 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 12853 } 12854 12855 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 12856 SmallVector<FormatStyle, 8> Styles; 12857 Styles.resize(2); 12858 12859 Styles[0] = getGoogleStyle(); 12860 Styles[1] = getLLVMStyle(); 12861 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12862 EXPECT_ALL_STYLES_EQUAL(Styles); 12863 12864 Styles.resize(5); 12865 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12866 Styles[1] = getLLVMStyle(); 12867 Styles[1].Language = FormatStyle::LK_JavaScript; 12868 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12869 12870 Styles[2] = getLLVMStyle(); 12871 Styles[2].Language = FormatStyle::LK_JavaScript; 12872 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 12873 "BasedOnStyle: Google", 12874 &Styles[2]) 12875 .value()); 12876 12877 Styles[3] = getLLVMStyle(); 12878 Styles[3].Language = FormatStyle::LK_JavaScript; 12879 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 12880 "Language: JavaScript", 12881 &Styles[3]) 12882 .value()); 12883 12884 Styles[4] = getLLVMStyle(); 12885 Styles[4].Language = FormatStyle::LK_JavaScript; 12886 EXPECT_EQ(0, parseConfiguration("---\n" 12887 "BasedOnStyle: LLVM\n" 12888 "IndentWidth: 123\n" 12889 "---\n" 12890 "BasedOnStyle: Google\n" 12891 "Language: JavaScript", 12892 &Styles[4]) 12893 .value()); 12894 EXPECT_ALL_STYLES_EQUAL(Styles); 12895 } 12896 12897 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 12898 Style.FIELD = false; \ 12899 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 12900 EXPECT_TRUE(Style.FIELD); \ 12901 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 12902 EXPECT_FALSE(Style.FIELD); 12903 12904 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 12905 12906 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 12907 Style.STRUCT.FIELD = false; \ 12908 EXPECT_EQ(0, \ 12909 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 12910 .value()); \ 12911 EXPECT_TRUE(Style.STRUCT.FIELD); \ 12912 EXPECT_EQ(0, \ 12913 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 12914 .value()); \ 12915 EXPECT_FALSE(Style.STRUCT.FIELD); 12916 12917 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 12918 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 12919 12920 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 12921 EXPECT_NE(VALUE, Style.FIELD); \ 12922 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 12923 EXPECT_EQ(VALUE, Style.FIELD) 12924 12925 TEST_F(FormatTest, ParsesConfigurationBools) { 12926 FormatStyle Style = {}; 12927 Style.Language = FormatStyle::LK_Cpp; 12928 CHECK_PARSE_BOOL(AlignOperands); 12929 CHECK_PARSE_BOOL(AlignTrailingComments); 12930 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 12931 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 12932 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 12933 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 12934 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 12935 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 12936 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 12937 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 12938 CHECK_PARSE_BOOL(BinPackArguments); 12939 CHECK_PARSE_BOOL(BinPackParameters); 12940 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 12941 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 12942 CHECK_PARSE_BOOL(BreakStringLiterals); 12943 CHECK_PARSE_BOOL(CompactNamespaces); 12944 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 12945 CHECK_PARSE_BOOL(DeriveLineEnding); 12946 CHECK_PARSE_BOOL(DerivePointerAlignment); 12947 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 12948 CHECK_PARSE_BOOL(DisableFormat); 12949 CHECK_PARSE_BOOL(IndentCaseLabels); 12950 CHECK_PARSE_BOOL(IndentCaseBlocks); 12951 CHECK_PARSE_BOOL(IndentGotoLabels); 12952 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 12953 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 12954 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 12955 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 12956 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 12957 CHECK_PARSE_BOOL(ReflowComments); 12958 CHECK_PARSE_BOOL(SortIncludes); 12959 CHECK_PARSE_BOOL(SortUsingDeclarations); 12960 CHECK_PARSE_BOOL(SpacesInParentheses); 12961 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 12962 CHECK_PARSE_BOOL(SpacesInAngles); 12963 CHECK_PARSE_BOOL(SpacesInConditionalStatement); 12964 CHECK_PARSE_BOOL(SpaceInEmptyBlock); 12965 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 12966 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 12967 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 12968 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 12969 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 12970 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 12971 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 12972 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 12973 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 12974 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 12975 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 12976 CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets); 12977 CHECK_PARSE_BOOL(UseCRLF); 12978 12979 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 12980 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 12981 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 12982 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 12983 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 12984 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 12985 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 12986 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 12987 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 12988 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 12989 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 12990 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody); 12991 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 12992 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 12993 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 12994 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 12995 } 12996 12997 #undef CHECK_PARSE_BOOL 12998 12999 TEST_F(FormatTest, ParsesConfiguration) { 13000 FormatStyle Style = {}; 13001 Style.Language = FormatStyle::LK_Cpp; 13002 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 13003 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 13004 ConstructorInitializerIndentWidth, 1234u); 13005 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 13006 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 13007 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 13008 CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u); 13009 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 13010 PenaltyBreakBeforeFirstCallParameter, 1234u); 13011 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 13012 PenaltyBreakTemplateDeclaration, 1234u); 13013 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 13014 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 13015 PenaltyReturnTypeOnItsOwnLine, 1234u); 13016 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 13017 SpacesBeforeTrailingComments, 1234u); 13018 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 13019 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 13020 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 13021 13022 Style.PointerAlignment = FormatStyle::PAS_Middle; 13023 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 13024 FormatStyle::PAS_Left); 13025 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 13026 FormatStyle::PAS_Right); 13027 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 13028 FormatStyle::PAS_Middle); 13029 // For backward compatibility: 13030 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 13031 FormatStyle::PAS_Left); 13032 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 13033 FormatStyle::PAS_Right); 13034 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 13035 FormatStyle::PAS_Middle); 13036 13037 Style.Standard = FormatStyle::LS_Auto; 13038 CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03); 13039 CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11); 13040 CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14); 13041 CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17); 13042 CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20); 13043 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 13044 CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest); 13045 // Legacy aliases: 13046 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 13047 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest); 13048 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 13049 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 13050 13051 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 13052 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 13053 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 13054 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 13055 FormatStyle::BOS_None); 13056 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 13057 FormatStyle::BOS_All); 13058 // For backward compatibility: 13059 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 13060 FormatStyle::BOS_None); 13061 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 13062 FormatStyle::BOS_All); 13063 13064 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 13065 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 13066 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 13067 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 13068 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 13069 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 13070 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 13071 // For backward compatibility: 13072 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 13073 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 13074 13075 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 13076 CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList, 13077 FormatStyle::BILS_BeforeComma); 13078 CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList, 13079 FormatStyle::BILS_AfterColon); 13080 CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList, 13081 FormatStyle::BILS_BeforeColon); 13082 // For backward compatibility: 13083 CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList, 13084 FormatStyle::BILS_BeforeComma); 13085 13086 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 13087 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 13088 FormatStyle::BAS_Align); 13089 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 13090 FormatStyle::BAS_DontAlign); 13091 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 13092 FormatStyle::BAS_AlwaysBreak); 13093 // For backward compatibility: 13094 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 13095 FormatStyle::BAS_DontAlign); 13096 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 13097 FormatStyle::BAS_Align); 13098 13099 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 13100 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 13101 FormatStyle::ENAS_DontAlign); 13102 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 13103 FormatStyle::ENAS_Left); 13104 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 13105 FormatStyle::ENAS_Right); 13106 // For backward compatibility: 13107 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 13108 FormatStyle::ENAS_Left); 13109 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 13110 FormatStyle::ENAS_Right); 13111 13112 Style.UseTab = FormatStyle::UT_ForIndentation; 13113 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 13114 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 13115 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 13116 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 13117 FormatStyle::UT_ForContinuationAndIndentation); 13118 CHECK_PARSE("UseTab: AlignWithSpaces", UseTab, 13119 FormatStyle::UT_AlignWithSpaces); 13120 // For backward compatibility: 13121 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 13122 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 13123 13124 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 13125 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never", 13126 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 13127 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty", 13128 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty); 13129 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always", 13130 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 13131 // For backward compatibility: 13132 CHECK_PARSE("AllowShortBlocksOnASingleLine: false", 13133 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 13134 CHECK_PARSE("AllowShortBlocksOnASingleLine: true", 13135 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 13136 13137 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 13138 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 13139 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 13140 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 13141 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 13142 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 13143 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 13144 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 13145 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 13146 // For backward compatibility: 13147 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 13148 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 13149 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 13150 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 13151 13152 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 13153 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 13154 FormatStyle::SBPO_Never); 13155 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 13156 FormatStyle::SBPO_Always); 13157 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 13158 FormatStyle::SBPO_ControlStatements); 13159 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 13160 FormatStyle::SBPO_NonEmptyParentheses); 13161 // For backward compatibility: 13162 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 13163 FormatStyle::SBPO_Never); 13164 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 13165 FormatStyle::SBPO_ControlStatements); 13166 13167 Style.ColumnLimit = 123; 13168 FormatStyle BaseStyle = getLLVMStyle(); 13169 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 13170 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 13171 13172 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 13173 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 13174 FormatStyle::BS_Attach); 13175 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 13176 FormatStyle::BS_Linux); 13177 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 13178 FormatStyle::BS_Mozilla); 13179 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 13180 FormatStyle::BS_Stroustrup); 13181 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 13182 FormatStyle::BS_Allman); 13183 CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces, 13184 FormatStyle::BS_Whitesmiths); 13185 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 13186 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 13187 FormatStyle::BS_WebKit); 13188 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 13189 FormatStyle::BS_Custom); 13190 13191 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never; 13192 CHECK_PARSE("BraceWrapping:\n" 13193 " AfterControlStatement: MultiLine", 13194 BraceWrapping.AfterControlStatement, 13195 FormatStyle::BWACS_MultiLine); 13196 CHECK_PARSE("BraceWrapping:\n" 13197 " AfterControlStatement: Always", 13198 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 13199 CHECK_PARSE("BraceWrapping:\n" 13200 " AfterControlStatement: Never", 13201 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 13202 // For backward compatibility: 13203 CHECK_PARSE("BraceWrapping:\n" 13204 " AfterControlStatement: true", 13205 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 13206 CHECK_PARSE("BraceWrapping:\n" 13207 " AfterControlStatement: false", 13208 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 13209 13210 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 13211 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 13212 FormatStyle::RTBS_None); 13213 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 13214 FormatStyle::RTBS_All); 13215 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 13216 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 13217 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 13218 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 13219 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 13220 AlwaysBreakAfterReturnType, 13221 FormatStyle::RTBS_TopLevelDefinitions); 13222 13223 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 13224 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", 13225 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No); 13226 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", 13227 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 13228 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", 13229 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 13230 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", 13231 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 13232 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", 13233 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 13234 13235 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 13236 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 13237 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 13238 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 13239 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 13240 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 13241 AlwaysBreakAfterDefinitionReturnType, 13242 FormatStyle::DRTBS_TopLevel); 13243 13244 Style.NamespaceIndentation = FormatStyle::NI_All; 13245 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 13246 FormatStyle::NI_None); 13247 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 13248 FormatStyle::NI_Inner); 13249 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 13250 FormatStyle::NI_All); 13251 13252 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 13253 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 13254 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 13255 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 13256 AllowShortIfStatementsOnASingleLine, 13257 FormatStyle::SIS_WithoutElse); 13258 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 13259 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 13260 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 13261 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 13262 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 13263 AllowShortIfStatementsOnASingleLine, 13264 FormatStyle::SIS_WithoutElse); 13265 13266 // FIXME: This is required because parsing a configuration simply overwrites 13267 // the first N elements of the list instead of resetting it. 13268 Style.ForEachMacros.clear(); 13269 std::vector<std::string> BoostForeach; 13270 BoostForeach.push_back("BOOST_FOREACH"); 13271 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 13272 std::vector<std::string> BoostAndQForeach; 13273 BoostAndQForeach.push_back("BOOST_FOREACH"); 13274 BoostAndQForeach.push_back("Q_FOREACH"); 13275 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 13276 BoostAndQForeach); 13277 13278 Style.StatementMacros.clear(); 13279 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 13280 std::vector<std::string>{"QUNUSED"}); 13281 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 13282 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 13283 13284 Style.NamespaceMacros.clear(); 13285 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 13286 std::vector<std::string>{"TESTSUITE"}); 13287 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 13288 std::vector<std::string>({"TESTSUITE", "SUITE"})); 13289 13290 Style.IncludeStyle.IncludeCategories.clear(); 13291 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 13292 {"abc/.*", 2, 0}, {".*", 1, 0}}; 13293 CHECK_PARSE("IncludeCategories:\n" 13294 " - Regex: abc/.*\n" 13295 " Priority: 2\n" 13296 " - Regex: .*\n" 13297 " Priority: 1", 13298 IncludeStyle.IncludeCategories, ExpectedCategories); 13299 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 13300 "abc$"); 13301 CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'", 13302 IncludeStyle.IncludeIsMainSourceRegex, "abc$"); 13303 13304 Style.RawStringFormats.clear(); 13305 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 13306 { 13307 FormatStyle::LK_TextProto, 13308 {"pb", "proto"}, 13309 {"PARSE_TEXT_PROTO"}, 13310 /*CanonicalDelimiter=*/"", 13311 "llvm", 13312 }, 13313 { 13314 FormatStyle::LK_Cpp, 13315 {"cc", "cpp"}, 13316 {"C_CODEBLOCK", "CPPEVAL"}, 13317 /*CanonicalDelimiter=*/"cc", 13318 /*BasedOnStyle=*/"", 13319 }, 13320 }; 13321 13322 CHECK_PARSE("RawStringFormats:\n" 13323 " - Language: TextProto\n" 13324 " Delimiters:\n" 13325 " - 'pb'\n" 13326 " - 'proto'\n" 13327 " EnclosingFunctions:\n" 13328 " - 'PARSE_TEXT_PROTO'\n" 13329 " BasedOnStyle: llvm\n" 13330 " - Language: Cpp\n" 13331 " Delimiters:\n" 13332 " - 'cc'\n" 13333 " - 'cpp'\n" 13334 " EnclosingFunctions:\n" 13335 " - 'C_CODEBLOCK'\n" 13336 " - 'CPPEVAL'\n" 13337 " CanonicalDelimiter: 'cc'", 13338 RawStringFormats, ExpectedRawStringFormats); 13339 } 13340 13341 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 13342 FormatStyle Style = {}; 13343 Style.Language = FormatStyle::LK_Cpp; 13344 CHECK_PARSE("Language: Cpp\n" 13345 "IndentWidth: 12", 13346 IndentWidth, 12u); 13347 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 13348 "IndentWidth: 34", 13349 &Style), 13350 ParseError::Unsuitable); 13351 FormatStyle BinPackedTCS = {}; 13352 BinPackedTCS.Language = FormatStyle::LK_JavaScript; 13353 EXPECT_EQ(parseConfiguration("BinPackArguments: true\n" 13354 "InsertTrailingCommas: Wrapped", 13355 &BinPackedTCS), 13356 ParseError::BinPackTrailingCommaConflict); 13357 EXPECT_EQ(12u, Style.IndentWidth); 13358 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 13359 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 13360 13361 Style.Language = FormatStyle::LK_JavaScript; 13362 CHECK_PARSE("Language: JavaScript\n" 13363 "IndentWidth: 12", 13364 IndentWidth, 12u); 13365 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 13366 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 13367 "IndentWidth: 34", 13368 &Style), 13369 ParseError::Unsuitable); 13370 EXPECT_EQ(23u, Style.IndentWidth); 13371 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 13372 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 13373 13374 CHECK_PARSE("BasedOnStyle: LLVM\n" 13375 "IndentWidth: 67", 13376 IndentWidth, 67u); 13377 13378 CHECK_PARSE("---\n" 13379 "Language: JavaScript\n" 13380 "IndentWidth: 12\n" 13381 "---\n" 13382 "Language: Cpp\n" 13383 "IndentWidth: 34\n" 13384 "...\n", 13385 IndentWidth, 12u); 13386 13387 Style.Language = FormatStyle::LK_Cpp; 13388 CHECK_PARSE("---\n" 13389 "Language: JavaScript\n" 13390 "IndentWidth: 12\n" 13391 "---\n" 13392 "Language: Cpp\n" 13393 "IndentWidth: 34\n" 13394 "...\n", 13395 IndentWidth, 34u); 13396 CHECK_PARSE("---\n" 13397 "IndentWidth: 78\n" 13398 "---\n" 13399 "Language: JavaScript\n" 13400 "IndentWidth: 56\n" 13401 "...\n", 13402 IndentWidth, 78u); 13403 13404 Style.ColumnLimit = 123; 13405 Style.IndentWidth = 234; 13406 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 13407 Style.TabWidth = 345; 13408 EXPECT_FALSE(parseConfiguration("---\n" 13409 "IndentWidth: 456\n" 13410 "BreakBeforeBraces: Allman\n" 13411 "---\n" 13412 "Language: JavaScript\n" 13413 "IndentWidth: 111\n" 13414 "TabWidth: 111\n" 13415 "---\n" 13416 "Language: Cpp\n" 13417 "BreakBeforeBraces: Stroustrup\n" 13418 "TabWidth: 789\n" 13419 "...\n", 13420 &Style)); 13421 EXPECT_EQ(123u, Style.ColumnLimit); 13422 EXPECT_EQ(456u, Style.IndentWidth); 13423 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 13424 EXPECT_EQ(789u, Style.TabWidth); 13425 13426 EXPECT_EQ(parseConfiguration("---\n" 13427 "Language: JavaScript\n" 13428 "IndentWidth: 56\n" 13429 "---\n" 13430 "IndentWidth: 78\n" 13431 "...\n", 13432 &Style), 13433 ParseError::Error); 13434 EXPECT_EQ(parseConfiguration("---\n" 13435 "Language: JavaScript\n" 13436 "IndentWidth: 56\n" 13437 "---\n" 13438 "Language: JavaScript\n" 13439 "IndentWidth: 78\n" 13440 "...\n", 13441 &Style), 13442 ParseError::Error); 13443 13444 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 13445 } 13446 13447 #undef CHECK_PARSE 13448 13449 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 13450 FormatStyle Style = {}; 13451 Style.Language = FormatStyle::LK_JavaScript; 13452 Style.BreakBeforeTernaryOperators = true; 13453 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 13454 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 13455 13456 Style.BreakBeforeTernaryOperators = true; 13457 EXPECT_EQ(0, parseConfiguration("---\n" 13458 "BasedOnStyle: Google\n" 13459 "---\n" 13460 "Language: JavaScript\n" 13461 "IndentWidth: 76\n" 13462 "...\n", 13463 &Style) 13464 .value()); 13465 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 13466 EXPECT_EQ(76u, Style.IndentWidth); 13467 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 13468 } 13469 13470 TEST_F(FormatTest, ConfigurationRoundTripTest) { 13471 FormatStyle Style = getLLVMStyle(); 13472 std::string YAML = configurationAsText(Style); 13473 FormatStyle ParsedStyle = {}; 13474 ParsedStyle.Language = FormatStyle::LK_Cpp; 13475 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 13476 EXPECT_EQ(Style, ParsedStyle); 13477 } 13478 13479 TEST_F(FormatTest, WorksFor8bitEncodings) { 13480 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 13481 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 13482 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 13483 "\"\xef\xee\xf0\xf3...\"", 13484 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 13485 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 13486 "\xef\xee\xf0\xf3...\"", 13487 getLLVMStyleWithColumns(12))); 13488 } 13489 13490 TEST_F(FormatTest, HandlesUTF8BOM) { 13491 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 13492 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 13493 format("\xef\xbb\xbf#include <iostream>")); 13494 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 13495 format("\xef\xbb\xbf\n#include <iostream>")); 13496 } 13497 13498 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 13499 #if !defined(_MSC_VER) 13500 13501 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 13502 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 13503 getLLVMStyleWithColumns(35)); 13504 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 13505 getLLVMStyleWithColumns(31)); 13506 verifyFormat("// Однажды в студёную зимнюю пору...", 13507 getLLVMStyleWithColumns(36)); 13508 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 13509 verifyFormat("/* Однажды в студёную зимнюю пору... */", 13510 getLLVMStyleWithColumns(39)); 13511 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 13512 getLLVMStyleWithColumns(35)); 13513 } 13514 13515 TEST_F(FormatTest, SplitsUTF8Strings) { 13516 // Non-printable characters' width is currently considered to be the length in 13517 // bytes in UTF8. The characters can be displayed in very different manner 13518 // (zero-width, single width with a substitution glyph, expanded to their code 13519 // (e.g. "<8d>"), so there's no single correct way to handle them. 13520 EXPECT_EQ("\"aaaaÄ\"\n" 13521 "\"\xc2\x8d\";", 13522 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13523 EXPECT_EQ("\"aaaaaaaÄ\"\n" 13524 "\"\xc2\x8d\";", 13525 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13526 EXPECT_EQ("\"Однажды, в \"\n" 13527 "\"студёную \"\n" 13528 "\"зимнюю \"\n" 13529 "\"пору,\"", 13530 format("\"Однажды, в студёную зимнюю пору,\"", 13531 getLLVMStyleWithColumns(13))); 13532 EXPECT_EQ( 13533 "\"一 二 三 \"\n" 13534 "\"四 五六 \"\n" 13535 "\"七 八 九 \"\n" 13536 "\"十\"", 13537 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 13538 EXPECT_EQ("\"一\t\"\n" 13539 "\"二 \t\"\n" 13540 "\"三 四 \"\n" 13541 "\"五\t\"\n" 13542 "\"六 \t\"\n" 13543 "\"七 \"\n" 13544 "\"八九十\tqq\"", 13545 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 13546 getLLVMStyleWithColumns(11))); 13547 13548 // UTF8 character in an escape sequence. 13549 EXPECT_EQ("\"aaaaaa\"\n" 13550 "\"\\\xC2\x8D\"", 13551 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 13552 } 13553 13554 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 13555 EXPECT_EQ("const char *sssss =\n" 13556 " \"一二三四五六七八\\\n" 13557 " 九 十\";", 13558 format("const char *sssss = \"一二三四五六七八\\\n" 13559 " 九 十\";", 13560 getLLVMStyleWithColumns(30))); 13561 } 13562 13563 TEST_F(FormatTest, SplitsUTF8LineComments) { 13564 EXPECT_EQ("// aaaaÄ\xc2\x8d", 13565 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 13566 EXPECT_EQ("// Я из лесу\n" 13567 "// вышел; был\n" 13568 "// сильный\n" 13569 "// мороз.", 13570 format("// Я из лесу вышел; был сильный мороз.", 13571 getLLVMStyleWithColumns(13))); 13572 EXPECT_EQ("// 一二三\n" 13573 "// 四五六七\n" 13574 "// 八 九\n" 13575 "// 十", 13576 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 13577 } 13578 13579 TEST_F(FormatTest, SplitsUTF8BlockComments) { 13580 EXPECT_EQ("/* Гляжу,\n" 13581 " * поднимается\n" 13582 " * медленно в\n" 13583 " * гору\n" 13584 " * Лошадка,\n" 13585 " * везущая\n" 13586 " * хворосту\n" 13587 " * воз. */", 13588 format("/* Гляжу, поднимается медленно в гору\n" 13589 " * Лошадка, везущая хворосту воз. */", 13590 getLLVMStyleWithColumns(13))); 13591 EXPECT_EQ( 13592 "/* 一二三\n" 13593 " * 四五六七\n" 13594 " * 八 九\n" 13595 " * 十 */", 13596 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 13597 EXPECT_EQ("/* �������� ��������\n" 13598 " * ��������\n" 13599 " * ������-�� */", 13600 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 13601 } 13602 13603 #endif // _MSC_VER 13604 13605 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 13606 FormatStyle Style = getLLVMStyle(); 13607 13608 Style.ConstructorInitializerIndentWidth = 4; 13609 verifyFormat( 13610 "SomeClass::Constructor()\n" 13611 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13612 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13613 Style); 13614 13615 Style.ConstructorInitializerIndentWidth = 2; 13616 verifyFormat( 13617 "SomeClass::Constructor()\n" 13618 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13619 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13620 Style); 13621 13622 Style.ConstructorInitializerIndentWidth = 0; 13623 verifyFormat( 13624 "SomeClass::Constructor()\n" 13625 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13626 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13627 Style); 13628 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 13629 verifyFormat( 13630 "SomeLongTemplateVariableName<\n" 13631 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 13632 Style); 13633 verifyFormat("bool smaller = 1 < " 13634 "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 13635 " " 13636 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 13637 Style); 13638 13639 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 13640 verifyFormat("SomeClass::Constructor() :\n" 13641 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 13642 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 13643 Style); 13644 } 13645 13646 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 13647 FormatStyle Style = getLLVMStyle(); 13648 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 13649 Style.ConstructorInitializerIndentWidth = 4; 13650 verifyFormat("SomeClass::Constructor()\n" 13651 " : a(a)\n" 13652 " , b(b)\n" 13653 " , c(c) {}", 13654 Style); 13655 verifyFormat("SomeClass::Constructor()\n" 13656 " : a(a) {}", 13657 Style); 13658 13659 Style.ColumnLimit = 0; 13660 verifyFormat("SomeClass::Constructor()\n" 13661 " : a(a) {}", 13662 Style); 13663 verifyFormat("SomeClass::Constructor() noexcept\n" 13664 " : a(a) {}", 13665 Style); 13666 verifyFormat("SomeClass::Constructor()\n" 13667 " : a(a)\n" 13668 " , b(b)\n" 13669 " , c(c) {}", 13670 Style); 13671 verifyFormat("SomeClass::Constructor()\n" 13672 " : a(a) {\n" 13673 " foo();\n" 13674 " bar();\n" 13675 "}", 13676 Style); 13677 13678 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 13679 verifyFormat("SomeClass::Constructor()\n" 13680 " : a(a)\n" 13681 " , b(b)\n" 13682 " , c(c) {\n}", 13683 Style); 13684 verifyFormat("SomeClass::Constructor()\n" 13685 " : a(a) {\n}", 13686 Style); 13687 13688 Style.ColumnLimit = 80; 13689 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 13690 Style.ConstructorInitializerIndentWidth = 2; 13691 verifyFormat("SomeClass::Constructor()\n" 13692 " : a(a)\n" 13693 " , b(b)\n" 13694 " , c(c) {}", 13695 Style); 13696 13697 Style.ConstructorInitializerIndentWidth = 0; 13698 verifyFormat("SomeClass::Constructor()\n" 13699 ": a(a)\n" 13700 ", b(b)\n" 13701 ", c(c) {}", 13702 Style); 13703 13704 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 13705 Style.ConstructorInitializerIndentWidth = 4; 13706 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 13707 verifyFormat( 13708 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 13709 Style); 13710 verifyFormat( 13711 "SomeClass::Constructor()\n" 13712 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 13713 Style); 13714 Style.ConstructorInitializerIndentWidth = 4; 13715 Style.ColumnLimit = 60; 13716 verifyFormat("SomeClass::Constructor()\n" 13717 " : aaaaaaaa(aaaaaaaa)\n" 13718 " , aaaaaaaa(aaaaaaaa)\n" 13719 " , aaaaaaaa(aaaaaaaa) {}", 13720 Style); 13721 } 13722 13723 TEST_F(FormatTest, Destructors) { 13724 verifyFormat("void F(int &i) { i.~int(); }"); 13725 verifyFormat("void F(int &i) { i->~int(); }"); 13726 } 13727 13728 TEST_F(FormatTest, FormatsWithWebKitStyle) { 13729 FormatStyle Style = getWebKitStyle(); 13730 13731 // Don't indent in outer namespaces. 13732 verifyFormat("namespace outer {\n" 13733 "int i;\n" 13734 "namespace inner {\n" 13735 " int i;\n" 13736 "} // namespace inner\n" 13737 "} // namespace outer\n" 13738 "namespace other_outer {\n" 13739 "int i;\n" 13740 "}", 13741 Style); 13742 13743 // Don't indent case labels. 13744 verifyFormat("switch (variable) {\n" 13745 "case 1:\n" 13746 "case 2:\n" 13747 " doSomething();\n" 13748 " break;\n" 13749 "default:\n" 13750 " ++variable;\n" 13751 "}", 13752 Style); 13753 13754 // Wrap before binary operators. 13755 EXPECT_EQ("void f()\n" 13756 "{\n" 13757 " if (aaaaaaaaaaaaaaaa\n" 13758 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 13759 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13760 " return;\n" 13761 "}", 13762 format("void f() {\n" 13763 "if (aaaaaaaaaaaaaaaa\n" 13764 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 13765 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13766 "return;\n" 13767 "}", 13768 Style)); 13769 13770 // Allow functions on a single line. 13771 verifyFormat("void f() { return; }", Style); 13772 13773 // Allow empty blocks on a single line and insert a space in empty blocks. 13774 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 13775 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 13776 // However, don't merge non-empty short loops. 13777 EXPECT_EQ("while (true) {\n" 13778 " continue;\n" 13779 "}", 13780 format("while (true) { continue; }", Style)); 13781 13782 // Constructor initializers are formatted one per line with the "," on the 13783 // new line. 13784 verifyFormat("Constructor()\n" 13785 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 13786 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 13787 " aaaaaaaaaaaaaa)\n" 13788 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 13789 "{\n" 13790 "}", 13791 Style); 13792 verifyFormat("SomeClass::Constructor()\n" 13793 " : a(a)\n" 13794 "{\n" 13795 "}", 13796 Style); 13797 EXPECT_EQ("SomeClass::Constructor()\n" 13798 " : a(a)\n" 13799 "{\n" 13800 "}", 13801 format("SomeClass::Constructor():a(a){}", Style)); 13802 verifyFormat("SomeClass::Constructor()\n" 13803 " : a(a)\n" 13804 " , b(b)\n" 13805 " , c(c)\n" 13806 "{\n" 13807 "}", 13808 Style); 13809 verifyFormat("SomeClass::Constructor()\n" 13810 " : a(a)\n" 13811 "{\n" 13812 " foo();\n" 13813 " bar();\n" 13814 "}", 13815 Style); 13816 13817 // Access specifiers should be aligned left. 13818 verifyFormat("class C {\n" 13819 "public:\n" 13820 " int i;\n" 13821 "};", 13822 Style); 13823 13824 // Do not align comments. 13825 verifyFormat("int a; // Do not\n" 13826 "double b; // align comments.", 13827 Style); 13828 13829 // Do not align operands. 13830 EXPECT_EQ("ASSERT(aaaa\n" 13831 " || bbbb);", 13832 format("ASSERT ( aaaa\n||bbbb);", Style)); 13833 13834 // Accept input's line breaks. 13835 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 13836 " || bbbbbbbbbbbbbbb) {\n" 13837 " i++;\n" 13838 "}", 13839 format("if (aaaaaaaaaaaaaaa\n" 13840 "|| bbbbbbbbbbbbbbb) { i++; }", 13841 Style)); 13842 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 13843 " i++;\n" 13844 "}", 13845 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 13846 13847 // Don't automatically break all macro definitions (llvm.org/PR17842). 13848 verifyFormat("#define aNumber 10", Style); 13849 // However, generally keep the line breaks that the user authored. 13850 EXPECT_EQ("#define aNumber \\\n" 13851 " 10", 13852 format("#define aNumber \\\n" 13853 " 10", 13854 Style)); 13855 13856 // Keep empty and one-element array literals on a single line. 13857 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 13858 " copyItems:YES];", 13859 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 13860 "copyItems:YES];", 13861 Style)); 13862 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 13863 " copyItems:YES];", 13864 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 13865 " copyItems:YES];", 13866 Style)); 13867 // FIXME: This does not seem right, there should be more indentation before 13868 // the array literal's entries. Nested blocks have the same problem. 13869 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13870 " @\"a\",\n" 13871 " @\"a\"\n" 13872 "]\n" 13873 " copyItems:YES];", 13874 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13875 " @\"a\",\n" 13876 " @\"a\"\n" 13877 " ]\n" 13878 " copyItems:YES];", 13879 Style)); 13880 EXPECT_EQ( 13881 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13882 " copyItems:YES];", 13883 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13884 " copyItems:YES];", 13885 Style)); 13886 13887 verifyFormat("[self.a b:c c:d];", Style); 13888 EXPECT_EQ("[self.a b:c\n" 13889 " c:d];", 13890 format("[self.a b:c\n" 13891 "c:d];", 13892 Style)); 13893 } 13894 13895 TEST_F(FormatTest, FormatsLambdas) { 13896 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 13897 verifyFormat( 13898 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 13899 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 13900 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 13901 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 13902 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 13903 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 13904 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 13905 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 13906 verifyFormat("int x = f(*+[] {});"); 13907 verifyFormat("void f() {\n" 13908 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 13909 "}\n"); 13910 verifyFormat("void f() {\n" 13911 " other(x.begin(), //\n" 13912 " x.end(), //\n" 13913 " [&](int, int) { return 1; });\n" 13914 "}\n"); 13915 verifyFormat("void f() {\n" 13916 " other.other.other.other.other(\n" 13917 " x.begin(), x.end(),\n" 13918 " [something, rather](int, int, int, int, int, int, int) { " 13919 "return 1; });\n" 13920 "}\n"); 13921 verifyFormat( 13922 "void f() {\n" 13923 " other.other.other.other.other(\n" 13924 " x.begin(), x.end(),\n" 13925 " [something, rather](int, int, int, int, int, int, int) {\n" 13926 " //\n" 13927 " });\n" 13928 "}\n"); 13929 verifyFormat("SomeFunction([]() { // A cool function...\n" 13930 " return 43;\n" 13931 "});"); 13932 EXPECT_EQ("SomeFunction([]() {\n" 13933 "#define A a\n" 13934 " return 43;\n" 13935 "});", 13936 format("SomeFunction([](){\n" 13937 "#define A a\n" 13938 "return 43;\n" 13939 "});")); 13940 verifyFormat("void f() {\n" 13941 " SomeFunction([](decltype(x), A *a) {});\n" 13942 "}"); 13943 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13944 " [](const aaaaaaaaaa &a) { return a; });"); 13945 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 13946 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 13947 "});"); 13948 verifyFormat("Constructor()\n" 13949 " : Field([] { // comment\n" 13950 " int i;\n" 13951 " }) {}"); 13952 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 13953 " return some_parameter.size();\n" 13954 "};"); 13955 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 13956 " [](const string &s) { return s; };"); 13957 verifyFormat("int i = aaaaaa ? 1 //\n" 13958 " : [] {\n" 13959 " return 2; //\n" 13960 " }();"); 13961 verifyFormat("llvm::errs() << \"number of twos is \"\n" 13962 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 13963 " return x == 2; // force break\n" 13964 " });"); 13965 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13966 " [=](int iiiiiiiiiiii) {\n" 13967 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 13968 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 13969 " });", 13970 getLLVMStyleWithColumns(60)); 13971 verifyFormat("SomeFunction({[&] {\n" 13972 " // comment\n" 13973 " },\n" 13974 " [&] {\n" 13975 " // comment\n" 13976 " }});"); 13977 verifyFormat("SomeFunction({[&] {\n" 13978 " // comment\n" 13979 "}});"); 13980 verifyFormat( 13981 "virtual aaaaaaaaaaaaaaaa(\n" 13982 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 13983 " aaaaa aaaaaaaaa);"); 13984 13985 // Lambdas with return types. 13986 verifyFormat("int c = []() -> int { return 2; }();\n"); 13987 verifyFormat("int c = []() -> int * { return 2; }();\n"); 13988 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 13989 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 13990 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 13991 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 13992 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 13993 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 13994 verifyFormat("[a, a]() -> a<1> {};"); 13995 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 13996 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 13997 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 13998 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 13999 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 14000 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 14001 verifyFormat("[]() -> foo<!5> { return {}; };"); 14002 verifyFormat("[]() -> foo<~5> { return {}; };"); 14003 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 14004 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 14005 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 14006 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 14007 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 14008 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 14009 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 14010 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 14011 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 14012 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 14013 verifyFormat("namespace bar {\n" 14014 "// broken:\n" 14015 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 14016 "} // namespace bar"); 14017 verifyFormat("namespace bar {\n" 14018 "// broken:\n" 14019 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 14020 "} // namespace bar"); 14021 verifyFormat("namespace bar {\n" 14022 "// broken:\n" 14023 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 14024 "} // namespace bar"); 14025 verifyFormat("namespace bar {\n" 14026 "// broken:\n" 14027 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 14028 "} // namespace bar"); 14029 verifyFormat("namespace bar {\n" 14030 "// broken:\n" 14031 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 14032 "} // namespace bar"); 14033 verifyFormat("namespace bar {\n" 14034 "// broken:\n" 14035 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 14036 "} // namespace bar"); 14037 verifyFormat("namespace bar {\n" 14038 "// broken:\n" 14039 "auto foo{[]() -> foo<!5> { return {}; }};\n" 14040 "} // namespace bar"); 14041 verifyFormat("namespace bar {\n" 14042 "// broken:\n" 14043 "auto foo{[]() -> foo<~5> { return {}; }};\n" 14044 "} // namespace bar"); 14045 verifyFormat("namespace bar {\n" 14046 "// broken:\n" 14047 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 14048 "} // namespace bar"); 14049 verifyFormat("namespace bar {\n" 14050 "// broken:\n" 14051 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 14052 "} // namespace bar"); 14053 verifyFormat("namespace bar {\n" 14054 "// broken:\n" 14055 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 14056 "} // namespace bar"); 14057 verifyFormat("namespace bar {\n" 14058 "// broken:\n" 14059 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 14060 "} // namespace bar"); 14061 verifyFormat("namespace bar {\n" 14062 "// broken:\n" 14063 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 14064 "} // namespace bar"); 14065 verifyFormat("namespace bar {\n" 14066 "// broken:\n" 14067 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 14068 "} // namespace bar"); 14069 verifyFormat("namespace bar {\n" 14070 "// broken:\n" 14071 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 14072 "} // namespace bar"); 14073 verifyFormat("namespace bar {\n" 14074 "// broken:\n" 14075 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 14076 "} // namespace bar"); 14077 verifyFormat("namespace bar {\n" 14078 "// broken:\n" 14079 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 14080 "} // namespace bar"); 14081 verifyFormat("namespace bar {\n" 14082 "// broken:\n" 14083 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 14084 "} // namespace bar"); 14085 verifyFormat("[]() -> a<1> {};"); 14086 verifyFormat("[]() -> a<1> { ; };"); 14087 verifyFormat("[]() -> a<1> { ; }();"); 14088 verifyFormat("[a, a]() -> a<true> {};"); 14089 verifyFormat("[]() -> a<true> {};"); 14090 verifyFormat("[]() -> a<true> { ; };"); 14091 verifyFormat("[]() -> a<true> { ; }();"); 14092 verifyFormat("[a, a]() -> a<false> {};"); 14093 verifyFormat("[]() -> a<false> {};"); 14094 verifyFormat("[]() -> a<false> { ; };"); 14095 verifyFormat("[]() -> a<false> { ; }();"); 14096 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 14097 verifyFormat("namespace bar {\n" 14098 "auto foo{[]() -> foo<false> { ; }};\n" 14099 "} // namespace bar"); 14100 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 14101 " int j) -> int {\n" 14102 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 14103 "};"); 14104 verifyFormat( 14105 "aaaaaaaaaaaaaaaaaaaaaa(\n" 14106 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 14107 " return aaaaaaaaaaaaaaaaa;\n" 14108 " });", 14109 getLLVMStyleWithColumns(70)); 14110 verifyFormat("[]() //\n" 14111 " -> int {\n" 14112 " return 1; //\n" 14113 "};"); 14114 14115 // Lambdas with explicit template argument lists. 14116 verifyFormat( 14117 "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n"); 14118 14119 // Multiple lambdas in the same parentheses change indentation rules. These 14120 // lambdas are forced to start on new lines. 14121 verifyFormat("SomeFunction(\n" 14122 " []() {\n" 14123 " //\n" 14124 " },\n" 14125 " []() {\n" 14126 " //\n" 14127 " });"); 14128 14129 // A lambda passed as arg0 is always pushed to the next line. 14130 verifyFormat("SomeFunction(\n" 14131 " [this] {\n" 14132 " //\n" 14133 " },\n" 14134 " 1);\n"); 14135 14136 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like 14137 // the arg0 case above. 14138 auto Style = getGoogleStyle(); 14139 Style.BinPackArguments = false; 14140 verifyFormat("SomeFunction(\n" 14141 " a,\n" 14142 " [this] {\n" 14143 " //\n" 14144 " },\n" 14145 " b);\n", 14146 Style); 14147 verifyFormat("SomeFunction(\n" 14148 " a,\n" 14149 " [this] {\n" 14150 " //\n" 14151 " },\n" 14152 " b);\n"); 14153 14154 // A lambda with a very long line forces arg0 to be pushed out irrespective of 14155 // the BinPackArguments value (as long as the code is wide enough). 14156 verifyFormat( 14157 "something->SomeFunction(\n" 14158 " a,\n" 14159 " [this] {\n" 14160 " " 14161 "D0000000000000000000000000000000000000000000000000000000000001();\n" 14162 " },\n" 14163 " b);\n"); 14164 14165 // A multi-line lambda is pulled up as long as the introducer fits on the 14166 // previous line and there are no further args. 14167 verifyFormat("function(1, [this, that] {\n" 14168 " //\n" 14169 "});\n"); 14170 verifyFormat("function([this, that] {\n" 14171 " //\n" 14172 "});\n"); 14173 // FIXME: this format is not ideal and we should consider forcing the first 14174 // arg onto its own line. 14175 verifyFormat("function(a, b, c, //\n" 14176 " d, [this, that] {\n" 14177 " //\n" 14178 " });\n"); 14179 14180 // Multiple lambdas are treated correctly even when there is a short arg0. 14181 verifyFormat("SomeFunction(\n" 14182 " 1,\n" 14183 " [this] {\n" 14184 " //\n" 14185 " },\n" 14186 " [this] {\n" 14187 " //\n" 14188 " },\n" 14189 " 1);\n"); 14190 14191 // More complex introducers. 14192 verifyFormat("return [i, args...] {};"); 14193 14194 // Not lambdas. 14195 verifyFormat("constexpr char hello[]{\"hello\"};"); 14196 verifyFormat("double &operator[](int i) { return 0; }\n" 14197 "int i;"); 14198 verifyFormat("std::unique_ptr<int[]> foo() {}"); 14199 verifyFormat("int i = a[a][a]->f();"); 14200 verifyFormat("int i = (*b)[a]->f();"); 14201 14202 // Other corner cases. 14203 verifyFormat("void f() {\n" 14204 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 14205 " );\n" 14206 "}"); 14207 14208 // Lambdas created through weird macros. 14209 verifyFormat("void f() {\n" 14210 " MACRO((const AA &a) { return 1; });\n" 14211 " MACRO((AA &a) { return 1; });\n" 14212 "}"); 14213 14214 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 14215 " doo_dah();\n" 14216 " doo_dah();\n" 14217 " })) {\n" 14218 "}"); 14219 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 14220 " doo_dah();\n" 14221 " doo_dah();\n" 14222 " })) {\n" 14223 "}"); 14224 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n" 14225 " doo_dah();\n" 14226 " doo_dah();\n" 14227 " })) {\n" 14228 "}"); 14229 verifyFormat("auto lambda = []() {\n" 14230 " int a = 2\n" 14231 "#if A\n" 14232 " + 2\n" 14233 "#endif\n" 14234 " ;\n" 14235 "};"); 14236 14237 // Lambdas with complex multiline introducers. 14238 verifyFormat( 14239 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 14240 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 14241 " -> ::std::unordered_set<\n" 14242 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 14243 " //\n" 14244 " });"); 14245 14246 FormatStyle DoNotMerge = getLLVMStyle(); 14247 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 14248 verifyFormat("auto c = []() {\n" 14249 " return b;\n" 14250 "};", 14251 "auto c = []() { return b; };", DoNotMerge); 14252 verifyFormat("auto c = []() {\n" 14253 "};", 14254 " auto c = []() {};", DoNotMerge); 14255 14256 FormatStyle MergeEmptyOnly = getLLVMStyle(); 14257 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 14258 verifyFormat("auto c = []() {\n" 14259 " return b;\n" 14260 "};", 14261 "auto c = []() {\n" 14262 " return b;\n" 14263 " };", 14264 MergeEmptyOnly); 14265 verifyFormat("auto c = []() {};", 14266 "auto c = []() {\n" 14267 "};", 14268 MergeEmptyOnly); 14269 14270 FormatStyle MergeInline = getLLVMStyle(); 14271 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 14272 verifyFormat("auto c = []() {\n" 14273 " return b;\n" 14274 "};", 14275 "auto c = []() { return b; };", MergeInline); 14276 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 14277 MergeInline); 14278 verifyFormat("function([]() { return b; }, a)", 14279 "function([]() { return b; }, a)", MergeInline); 14280 verifyFormat("function(a, []() { return b; })", 14281 "function(a, []() { return b; })", MergeInline); 14282 14283 // Check option "BraceWrapping.BeforeLambdaBody" and different state of 14284 // AllowShortLambdasOnASingleLine 14285 FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle(); 14286 LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom; 14287 LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true; 14288 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14289 FormatStyle::ShortLambdaStyle::SLS_None; 14290 verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n" 14291 " []()\n" 14292 " {\n" 14293 " return 17;\n" 14294 " });", 14295 LLVMWithBeforeLambdaBody); 14296 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n" 14297 " []()\n" 14298 " {\n" 14299 " });", 14300 LLVMWithBeforeLambdaBody); 14301 verifyFormat("auto fct_SLS_None = []()\n" 14302 "{\n" 14303 " return 17;\n" 14304 "};", 14305 LLVMWithBeforeLambdaBody); 14306 verifyFormat("TwoNestedLambdas_SLS_None(\n" 14307 " []()\n" 14308 " {\n" 14309 " return Call(\n" 14310 " []()\n" 14311 " {\n" 14312 " return 17;\n" 14313 " });\n" 14314 " });", 14315 LLVMWithBeforeLambdaBody); 14316 verifyFormat("void Fct()\n" 14317 "{\n" 14318 " return {[]()\n" 14319 " {\n" 14320 " return 17;\n" 14321 " }};\n" 14322 "}", 14323 LLVMWithBeforeLambdaBody); 14324 14325 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14326 FormatStyle::ShortLambdaStyle::SLS_Empty; 14327 verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n" 14328 " []()\n" 14329 " {\n" 14330 " return 17;\n" 14331 " });", 14332 LLVMWithBeforeLambdaBody); 14333 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});", 14334 LLVMWithBeforeLambdaBody); 14335 verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL" 14336 "ongFunctionName_SLS_Empty(\n" 14337 " []() {});", 14338 LLVMWithBeforeLambdaBody); 14339 verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n" 14340 " []()\n" 14341 " {\n" 14342 " return 17;\n" 14343 " });", 14344 LLVMWithBeforeLambdaBody); 14345 verifyFormat("auto fct_SLS_Empty = []()\n" 14346 "{\n" 14347 " return 17;\n" 14348 "};", 14349 LLVMWithBeforeLambdaBody); 14350 verifyFormat("TwoNestedLambdas_SLS_Empty(\n" 14351 " []()\n" 14352 " {\n" 14353 " return Call([]() {});\n" 14354 " });", 14355 LLVMWithBeforeLambdaBody); 14356 verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n" 14357 " []()\n" 14358 " {\n" 14359 " return Call([]() {});\n" 14360 " });", 14361 LLVMWithBeforeLambdaBody); 14362 verifyFormat( 14363 "FctWithLongLineInLambda_SLS_Empty(\n" 14364 " []()\n" 14365 " {\n" 14366 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14367 " AndShouldNotBeConsiderAsInline,\n" 14368 " LambdaBodyMustBeBreak);\n" 14369 " });", 14370 LLVMWithBeforeLambdaBody); 14371 14372 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14373 FormatStyle::ShortLambdaStyle::SLS_Inline; 14374 verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });", 14375 LLVMWithBeforeLambdaBody); 14376 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});", 14377 LLVMWithBeforeLambdaBody); 14378 verifyFormat("auto fct_SLS_Inline = []()\n" 14379 "{\n" 14380 " return 17;\n" 14381 "};", 14382 LLVMWithBeforeLambdaBody); 14383 verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return " 14384 "17; }); });", 14385 LLVMWithBeforeLambdaBody); 14386 verifyFormat( 14387 "FctWithLongLineInLambda_SLS_Inline(\n" 14388 " []()\n" 14389 " {\n" 14390 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14391 " AndShouldNotBeConsiderAsInline,\n" 14392 " LambdaBodyMustBeBreak);\n" 14393 " });", 14394 LLVMWithBeforeLambdaBody); 14395 verifyFormat("FctWithMultipleParams_SLS_Inline(" 14396 "VeryLongParameterThatShouldAskToBeOnMultiLine,\n" 14397 " []() { return 17; });", 14398 LLVMWithBeforeLambdaBody); 14399 verifyFormat( 14400 "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });", 14401 LLVMWithBeforeLambdaBody); 14402 14403 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14404 FormatStyle::ShortLambdaStyle::SLS_All; 14405 verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });", 14406 LLVMWithBeforeLambdaBody); 14407 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});", 14408 LLVMWithBeforeLambdaBody); 14409 verifyFormat("auto fct_SLS_All = []() { return 17; };", 14410 LLVMWithBeforeLambdaBody); 14411 verifyFormat("FctWithOneParam_SLS_All(\n" 14412 " []()\n" 14413 " {\n" 14414 " // A cool function...\n" 14415 " return 43;\n" 14416 " });", 14417 LLVMWithBeforeLambdaBody); 14418 verifyFormat("FctWithMultipleParams_SLS_All(" 14419 "VeryLongParameterThatShouldAskToBeOnMultiLine,\n" 14420 " []() { return 17; });", 14421 LLVMWithBeforeLambdaBody); 14422 verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });", 14423 LLVMWithBeforeLambdaBody); 14424 verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });", 14425 LLVMWithBeforeLambdaBody); 14426 verifyFormat( 14427 "FctWithLongLineInLambda_SLS_All(\n" 14428 " []()\n" 14429 " {\n" 14430 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14431 " AndShouldNotBeConsiderAsInline,\n" 14432 " LambdaBodyMustBeBreak);\n" 14433 " });", 14434 LLVMWithBeforeLambdaBody); 14435 verifyFormat( 14436 "auto fct_SLS_All = []()\n" 14437 "{\n" 14438 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14439 " AndShouldNotBeConsiderAsInline,\n" 14440 " LambdaBodyMustBeBreak);\n" 14441 "};", 14442 LLVMWithBeforeLambdaBody); 14443 LLVMWithBeforeLambdaBody.BinPackParameters = false; 14444 verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);", 14445 LLVMWithBeforeLambdaBody); 14446 verifyFormat( 14447 "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n" 14448 " FirstParam,\n" 14449 " SecondParam,\n" 14450 " ThirdParam,\n" 14451 " FourthParam);", 14452 LLVMWithBeforeLambdaBody); 14453 verifyFormat("FctWithLongLineInLambda_SLS_All(\n" 14454 " []() { return " 14455 "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n" 14456 " FirstParam,\n" 14457 " SecondParam,\n" 14458 " ThirdParam,\n" 14459 " FourthParam);", 14460 LLVMWithBeforeLambdaBody); 14461 verifyFormat( 14462 "FctWithLongLineInLambda_SLS_All(FirstParam,\n" 14463 " SecondParam,\n" 14464 " ThirdParam,\n" 14465 " FourthParam,\n" 14466 " []() { return SomeValueNotSoLong; });", 14467 LLVMWithBeforeLambdaBody); 14468 verifyFormat("FctWithLongLineInLambda_SLS_All(\n" 14469 " []()\n" 14470 " {\n" 14471 " return " 14472 "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB" 14473 "eConsiderAsInline;\n" 14474 " });", 14475 LLVMWithBeforeLambdaBody); 14476 verifyFormat( 14477 "FctWithLongLineInLambda_SLS_All(\n" 14478 " []()\n" 14479 " {\n" 14480 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14481 " AndShouldNotBeConsiderAsInline,\n" 14482 " LambdaBodyMustBeBreak);\n" 14483 " });", 14484 LLVMWithBeforeLambdaBody); 14485 verifyFormat("FctWithTwoParams_SLS_All(\n" 14486 " []()\n" 14487 " {\n" 14488 " // A cool function...\n" 14489 " return 43;\n" 14490 " },\n" 14491 " 87);", 14492 LLVMWithBeforeLambdaBody); 14493 verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);", 14494 LLVMWithBeforeLambdaBody); 14495 verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });", 14496 LLVMWithBeforeLambdaBody); 14497 verifyFormat( 14498 "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });", 14499 LLVMWithBeforeLambdaBody); 14500 verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; " 14501 "}); }, x);", 14502 LLVMWithBeforeLambdaBody); 14503 verifyFormat("TwoNestedLambdas_SLS_All(\n" 14504 " []()\n" 14505 " {\n" 14506 " // A cool function...\n" 14507 " return Call([]() { return 17; });\n" 14508 " });", 14509 LLVMWithBeforeLambdaBody); 14510 verifyFormat("TwoNestedLambdas_SLS_All(\n" 14511 " []()\n" 14512 " {\n" 14513 " return Call(\n" 14514 " []()\n" 14515 " {\n" 14516 " // A cool function...\n" 14517 " return 17;\n" 14518 " });\n" 14519 " });", 14520 LLVMWithBeforeLambdaBody); 14521 } 14522 14523 TEST_F(FormatTest, EmptyLinesInLambdas) { 14524 verifyFormat("auto lambda = []() {\n" 14525 " x(); //\n" 14526 "};", 14527 "auto lambda = []() {\n" 14528 "\n" 14529 " x(); //\n" 14530 "\n" 14531 "};"); 14532 } 14533 14534 TEST_F(FormatTest, FormatsBlocks) { 14535 FormatStyle ShortBlocks = getLLVMStyle(); 14536 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 14537 verifyFormat("int (^Block)(int, int);", ShortBlocks); 14538 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 14539 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 14540 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 14541 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 14542 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 14543 14544 verifyFormat("foo(^{ bar(); });", ShortBlocks); 14545 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 14546 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 14547 14548 verifyFormat("[operation setCompletionBlock:^{\n" 14549 " [self onOperationDone];\n" 14550 "}];"); 14551 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 14552 " [self onOperationDone];\n" 14553 "}]};"); 14554 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 14555 " f();\n" 14556 "}];"); 14557 verifyFormat("int a = [operation block:^int(int *i) {\n" 14558 " return 1;\n" 14559 "}];"); 14560 verifyFormat("[myObject doSomethingWith:arg1\n" 14561 " aaa:^int(int *a) {\n" 14562 " return 1;\n" 14563 " }\n" 14564 " bbb:f(a * bbbbbbbb)];"); 14565 14566 verifyFormat("[operation setCompletionBlock:^{\n" 14567 " [self.delegate newDataAvailable];\n" 14568 "}];", 14569 getLLVMStyleWithColumns(60)); 14570 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 14571 " NSString *path = [self sessionFilePath];\n" 14572 " if (path) {\n" 14573 " // ...\n" 14574 " }\n" 14575 "});"); 14576 verifyFormat("[[SessionService sharedService]\n" 14577 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14578 " if (window) {\n" 14579 " [self windowDidLoad:window];\n" 14580 " } else {\n" 14581 " [self errorLoadingWindow];\n" 14582 " }\n" 14583 " }];"); 14584 verifyFormat("void (^largeBlock)(void) = ^{\n" 14585 " // ...\n" 14586 "};\n", 14587 getLLVMStyleWithColumns(40)); 14588 verifyFormat("[[SessionService sharedService]\n" 14589 " loadWindowWithCompletionBlock: //\n" 14590 " ^(SessionWindow *window) {\n" 14591 " if (window) {\n" 14592 " [self windowDidLoad:window];\n" 14593 " } else {\n" 14594 " [self errorLoadingWindow];\n" 14595 " }\n" 14596 " }];", 14597 getLLVMStyleWithColumns(60)); 14598 verifyFormat("[myObject doSomethingWith:arg1\n" 14599 " firstBlock:^(Foo *a) {\n" 14600 " // ...\n" 14601 " int i;\n" 14602 " }\n" 14603 " secondBlock:^(Bar *b) {\n" 14604 " // ...\n" 14605 " int i;\n" 14606 " }\n" 14607 " thirdBlock:^Foo(Bar *b) {\n" 14608 " // ...\n" 14609 " int i;\n" 14610 " }];"); 14611 verifyFormat("[myObject doSomethingWith:arg1\n" 14612 " firstBlock:-1\n" 14613 " secondBlock:^(Bar *b) {\n" 14614 " // ...\n" 14615 " int i;\n" 14616 " }];"); 14617 14618 verifyFormat("f(^{\n" 14619 " @autoreleasepool {\n" 14620 " if (a) {\n" 14621 " g();\n" 14622 " }\n" 14623 " }\n" 14624 "});"); 14625 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 14626 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 14627 "};"); 14628 14629 FormatStyle FourIndent = getLLVMStyle(); 14630 FourIndent.ObjCBlockIndentWidth = 4; 14631 verifyFormat("[operation setCompletionBlock:^{\n" 14632 " [self onOperationDone];\n" 14633 "}];", 14634 FourIndent); 14635 } 14636 14637 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 14638 FormatStyle ZeroColumn = getLLVMStyle(); 14639 ZeroColumn.ColumnLimit = 0; 14640 14641 verifyFormat("[[SessionService sharedService] " 14642 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14643 " if (window) {\n" 14644 " [self windowDidLoad:window];\n" 14645 " } else {\n" 14646 " [self errorLoadingWindow];\n" 14647 " }\n" 14648 "}];", 14649 ZeroColumn); 14650 EXPECT_EQ("[[SessionService sharedService]\n" 14651 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14652 " if (window) {\n" 14653 " [self windowDidLoad:window];\n" 14654 " } else {\n" 14655 " [self errorLoadingWindow];\n" 14656 " }\n" 14657 " }];", 14658 format("[[SessionService sharedService]\n" 14659 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14660 " if (window) {\n" 14661 " [self windowDidLoad:window];\n" 14662 " } else {\n" 14663 " [self errorLoadingWindow];\n" 14664 " }\n" 14665 "}];", 14666 ZeroColumn)); 14667 verifyFormat("[myObject doSomethingWith:arg1\n" 14668 " firstBlock:^(Foo *a) {\n" 14669 " // ...\n" 14670 " int i;\n" 14671 " }\n" 14672 " secondBlock:^(Bar *b) {\n" 14673 " // ...\n" 14674 " int i;\n" 14675 " }\n" 14676 " thirdBlock:^Foo(Bar *b) {\n" 14677 " // ...\n" 14678 " int i;\n" 14679 " }];", 14680 ZeroColumn); 14681 verifyFormat("f(^{\n" 14682 " @autoreleasepool {\n" 14683 " if (a) {\n" 14684 " g();\n" 14685 " }\n" 14686 " }\n" 14687 "});", 14688 ZeroColumn); 14689 verifyFormat("void (^largeBlock)(void) = ^{\n" 14690 " // ...\n" 14691 "};", 14692 ZeroColumn); 14693 14694 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 14695 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 14696 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 14697 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 14698 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 14699 " int i;\n" 14700 "};", 14701 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 14702 } 14703 14704 TEST_F(FormatTest, SupportsCRLF) { 14705 EXPECT_EQ("int a;\r\n" 14706 "int b;\r\n" 14707 "int c;\r\n", 14708 format("int a;\r\n" 14709 " int b;\r\n" 14710 " int c;\r\n", 14711 getLLVMStyle())); 14712 EXPECT_EQ("int a;\r\n" 14713 "int b;\r\n" 14714 "int c;\r\n", 14715 format("int a;\r\n" 14716 " int b;\n" 14717 " int c;\r\n", 14718 getLLVMStyle())); 14719 EXPECT_EQ("int a;\n" 14720 "int b;\n" 14721 "int c;\n", 14722 format("int a;\r\n" 14723 " int b;\n" 14724 " int c;\n", 14725 getLLVMStyle())); 14726 EXPECT_EQ("\"aaaaaaa \"\r\n" 14727 "\"bbbbbbb\";\r\n", 14728 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 14729 EXPECT_EQ("#define A \\\r\n" 14730 " b; \\\r\n" 14731 " c; \\\r\n" 14732 " d;\r\n", 14733 format("#define A \\\r\n" 14734 " b; \\\r\n" 14735 " c; d; \r\n", 14736 getGoogleStyle())); 14737 14738 EXPECT_EQ("/*\r\n" 14739 "multi line block comments\r\n" 14740 "should not introduce\r\n" 14741 "an extra carriage return\r\n" 14742 "*/\r\n", 14743 format("/*\r\n" 14744 "multi line block comments\r\n" 14745 "should not introduce\r\n" 14746 "an extra carriage return\r\n" 14747 "*/\r\n")); 14748 EXPECT_EQ("/*\r\n" 14749 "\r\n" 14750 "*/", 14751 format("/*\r\n" 14752 " \r\r\r\n" 14753 "*/")); 14754 14755 FormatStyle style = getLLVMStyle(); 14756 14757 style.DeriveLineEnding = true; 14758 style.UseCRLF = false; 14759 EXPECT_EQ("union FooBarBazQux {\n" 14760 " int foo;\n" 14761 " int bar;\n" 14762 " int baz;\n" 14763 "};", 14764 format("union FooBarBazQux {\r\n" 14765 " int foo;\n" 14766 " int bar;\r\n" 14767 " int baz;\n" 14768 "};", 14769 style)); 14770 style.UseCRLF = true; 14771 EXPECT_EQ("union FooBarBazQux {\r\n" 14772 " int foo;\r\n" 14773 " int bar;\r\n" 14774 " int baz;\r\n" 14775 "};", 14776 format("union FooBarBazQux {\r\n" 14777 " int foo;\n" 14778 " int bar;\r\n" 14779 " int baz;\n" 14780 "};", 14781 style)); 14782 14783 style.DeriveLineEnding = false; 14784 style.UseCRLF = false; 14785 EXPECT_EQ("union FooBarBazQux {\n" 14786 " int foo;\n" 14787 " int bar;\n" 14788 " int baz;\n" 14789 " int qux;\n" 14790 "};", 14791 format("union FooBarBazQux {\r\n" 14792 " int foo;\n" 14793 " int bar;\r\n" 14794 " int baz;\n" 14795 " int qux;\r\n" 14796 "};", 14797 style)); 14798 style.UseCRLF = true; 14799 EXPECT_EQ("union FooBarBazQux {\r\n" 14800 " int foo;\r\n" 14801 " int bar;\r\n" 14802 " int baz;\r\n" 14803 " int qux;\r\n" 14804 "};", 14805 format("union FooBarBazQux {\r\n" 14806 " int foo;\n" 14807 " int bar;\r\n" 14808 " int baz;\n" 14809 " int qux;\n" 14810 "};", 14811 style)); 14812 14813 style.DeriveLineEnding = true; 14814 style.UseCRLF = false; 14815 EXPECT_EQ("union FooBarBazQux {\r\n" 14816 " int foo;\r\n" 14817 " int bar;\r\n" 14818 " int baz;\r\n" 14819 " int qux;\r\n" 14820 "};", 14821 format("union FooBarBazQux {\r\n" 14822 " int foo;\n" 14823 " int bar;\r\n" 14824 " int baz;\n" 14825 " int qux;\r\n" 14826 "};", 14827 style)); 14828 style.UseCRLF = true; 14829 EXPECT_EQ("union FooBarBazQux {\n" 14830 " int foo;\n" 14831 " int bar;\n" 14832 " int baz;\n" 14833 " int qux;\n" 14834 "};", 14835 format("union FooBarBazQux {\r\n" 14836 " int foo;\n" 14837 " int bar;\r\n" 14838 " int baz;\n" 14839 " int qux;\n" 14840 "};", 14841 style)); 14842 } 14843 14844 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 14845 verifyFormat("MY_CLASS(C) {\n" 14846 " int i;\n" 14847 " int j;\n" 14848 "};"); 14849 } 14850 14851 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 14852 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 14853 TwoIndent.ContinuationIndentWidth = 2; 14854 14855 EXPECT_EQ("int i =\n" 14856 " longFunction(\n" 14857 " arg);", 14858 format("int i = longFunction(arg);", TwoIndent)); 14859 14860 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 14861 SixIndent.ContinuationIndentWidth = 6; 14862 14863 EXPECT_EQ("int i =\n" 14864 " longFunction(\n" 14865 " arg);", 14866 format("int i = longFunction(arg);", SixIndent)); 14867 } 14868 14869 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 14870 FormatStyle Style = getLLVMStyle(); 14871 verifyFormat("int Foo::getter(\n" 14872 " //\n" 14873 ") const {\n" 14874 " return foo;\n" 14875 "}", 14876 Style); 14877 verifyFormat("void Foo::setter(\n" 14878 " //\n" 14879 ") {\n" 14880 " foo = 1;\n" 14881 "}", 14882 Style); 14883 } 14884 14885 TEST_F(FormatTest, SpacesInAngles) { 14886 FormatStyle Spaces = getLLVMStyle(); 14887 Spaces.SpacesInAngles = true; 14888 14889 verifyFormat("static_cast< int >(arg);", Spaces); 14890 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 14891 verifyFormat("f< int, float >();", Spaces); 14892 verifyFormat("template <> g() {}", Spaces); 14893 verifyFormat("template < std::vector< int > > f() {}", Spaces); 14894 verifyFormat("std::function< void(int, int) > fct;", Spaces); 14895 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 14896 Spaces); 14897 14898 Spaces.Standard = FormatStyle::LS_Cpp03; 14899 Spaces.SpacesInAngles = true; 14900 verifyFormat("A< A< int > >();", Spaces); 14901 14902 Spaces.SpacesInAngles = false; 14903 verifyFormat("A<A<int> >();", Spaces); 14904 14905 Spaces.Standard = FormatStyle::LS_Cpp11; 14906 Spaces.SpacesInAngles = true; 14907 verifyFormat("A< A< int > >();", Spaces); 14908 14909 Spaces.SpacesInAngles = false; 14910 verifyFormat("A<A<int>>();", Spaces); 14911 } 14912 14913 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 14914 FormatStyle Style = getLLVMStyle(); 14915 Style.SpaceAfterTemplateKeyword = false; 14916 verifyFormat("template<int> void foo();", Style); 14917 } 14918 14919 TEST_F(FormatTest, TripleAngleBrackets) { 14920 verifyFormat("f<<<1, 1>>>();"); 14921 verifyFormat("f<<<1, 1, 1, s>>>();"); 14922 verifyFormat("f<<<a, b, c, d>>>();"); 14923 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 14924 verifyFormat("f<param><<<1, 1>>>();"); 14925 verifyFormat("f<1><<<1, 1>>>();"); 14926 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 14927 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14928 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 14929 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 14930 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 14931 } 14932 14933 TEST_F(FormatTest, MergeLessLessAtEnd) { 14934 verifyFormat("<<"); 14935 EXPECT_EQ("< < <", format("\\\n<<<")); 14936 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14937 "aaallvm::outs() <<"); 14938 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14939 "aaaallvm::outs()\n <<"); 14940 } 14941 14942 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 14943 std::string code = "#if A\n" 14944 "#if B\n" 14945 "a.\n" 14946 "#endif\n" 14947 " a = 1;\n" 14948 "#else\n" 14949 "#endif\n" 14950 "#if C\n" 14951 "#else\n" 14952 "#endif\n"; 14953 EXPECT_EQ(code, format(code)); 14954 } 14955 14956 TEST_F(FormatTest, HandleConflictMarkers) { 14957 // Git/SVN conflict markers. 14958 EXPECT_EQ("int a;\n" 14959 "void f() {\n" 14960 " callme(some(parameter1,\n" 14961 "<<<<<<< text by the vcs\n" 14962 " parameter2),\n" 14963 "||||||| text by the vcs\n" 14964 " parameter2),\n" 14965 " parameter3,\n" 14966 "======= text by the vcs\n" 14967 " parameter2, parameter3),\n" 14968 ">>>>>>> text by the vcs\n" 14969 " otherparameter);\n", 14970 format("int a;\n" 14971 "void f() {\n" 14972 " callme(some(parameter1,\n" 14973 "<<<<<<< text by the vcs\n" 14974 " parameter2),\n" 14975 "||||||| text by the vcs\n" 14976 " parameter2),\n" 14977 " parameter3,\n" 14978 "======= text by the vcs\n" 14979 " parameter2,\n" 14980 " parameter3),\n" 14981 ">>>>>>> text by the vcs\n" 14982 " otherparameter);\n")); 14983 14984 // Perforce markers. 14985 EXPECT_EQ("void f() {\n" 14986 " function(\n" 14987 ">>>> text by the vcs\n" 14988 " parameter,\n" 14989 "==== text by the vcs\n" 14990 " parameter,\n" 14991 "==== text by the vcs\n" 14992 " parameter,\n" 14993 "<<<< text by the vcs\n" 14994 " parameter);\n", 14995 format("void f() {\n" 14996 " function(\n" 14997 ">>>> text by the vcs\n" 14998 " parameter,\n" 14999 "==== text by the vcs\n" 15000 " parameter,\n" 15001 "==== text by the vcs\n" 15002 " parameter,\n" 15003 "<<<< text by the vcs\n" 15004 " parameter);\n")); 15005 15006 EXPECT_EQ("<<<<<<<\n" 15007 "|||||||\n" 15008 "=======\n" 15009 ">>>>>>>", 15010 format("<<<<<<<\n" 15011 "|||||||\n" 15012 "=======\n" 15013 ">>>>>>>")); 15014 15015 EXPECT_EQ("<<<<<<<\n" 15016 "|||||||\n" 15017 "int i;\n" 15018 "=======\n" 15019 ">>>>>>>", 15020 format("<<<<<<<\n" 15021 "|||||||\n" 15022 "int i;\n" 15023 "=======\n" 15024 ">>>>>>>")); 15025 15026 // FIXME: Handle parsing of macros around conflict markers correctly: 15027 EXPECT_EQ("#define Macro \\\n" 15028 "<<<<<<<\n" 15029 "Something \\\n" 15030 "|||||||\n" 15031 "Else \\\n" 15032 "=======\n" 15033 "Other \\\n" 15034 ">>>>>>>\n" 15035 " End int i;\n", 15036 format("#define Macro \\\n" 15037 "<<<<<<<\n" 15038 " Something \\\n" 15039 "|||||||\n" 15040 " Else \\\n" 15041 "=======\n" 15042 " Other \\\n" 15043 ">>>>>>>\n" 15044 " End\n" 15045 "int i;\n")); 15046 } 15047 15048 TEST_F(FormatTest, DisableRegions) { 15049 EXPECT_EQ("int i;\n" 15050 "// clang-format off\n" 15051 " int j;\n" 15052 "// clang-format on\n" 15053 "int k;", 15054 format(" int i;\n" 15055 " // clang-format off\n" 15056 " int j;\n" 15057 " // clang-format on\n" 15058 " int k;")); 15059 EXPECT_EQ("int i;\n" 15060 "/* clang-format off */\n" 15061 " int j;\n" 15062 "/* clang-format on */\n" 15063 "int k;", 15064 format(" int i;\n" 15065 " /* clang-format off */\n" 15066 " int j;\n" 15067 " /* clang-format on */\n" 15068 " int k;")); 15069 15070 // Don't reflow comments within disabled regions. 15071 EXPECT_EQ("// clang-format off\n" 15072 "// long long long long long long line\n" 15073 "/* clang-format on */\n" 15074 "/* long long long\n" 15075 " * long long long\n" 15076 " * line */\n" 15077 "int i;\n" 15078 "/* clang-format off */\n" 15079 "/* long long long long long long line */\n", 15080 format("// clang-format off\n" 15081 "// long long long long long long line\n" 15082 "/* clang-format on */\n" 15083 "/* long long long long long long line */\n" 15084 "int i;\n" 15085 "/* clang-format off */\n" 15086 "/* long long long long long long line */\n", 15087 getLLVMStyleWithColumns(20))); 15088 } 15089 15090 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 15091 format("? ) ="); 15092 verifyNoCrash("#define a\\\n /**/}"); 15093 } 15094 15095 TEST_F(FormatTest, FormatsTableGenCode) { 15096 FormatStyle Style = getLLVMStyle(); 15097 Style.Language = FormatStyle::LK_TableGen; 15098 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 15099 } 15100 15101 TEST_F(FormatTest, ArrayOfTemplates) { 15102 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 15103 format("auto a = new unique_ptr<int > [ 10];")); 15104 15105 FormatStyle Spaces = getLLVMStyle(); 15106 Spaces.SpacesInSquareBrackets = true; 15107 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 15108 format("auto a = new unique_ptr<int > [10];", Spaces)); 15109 } 15110 15111 TEST_F(FormatTest, ArrayAsTemplateType) { 15112 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 15113 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 15114 15115 FormatStyle Spaces = getLLVMStyle(); 15116 Spaces.SpacesInSquareBrackets = true; 15117 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 15118 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 15119 } 15120 15121 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); } 15122 15123 TEST(FormatStyle, GetStyleWithEmptyFileName) { 15124 llvm::vfs::InMemoryFileSystem FS; 15125 auto Style1 = getStyle("file", "", "Google", "", &FS); 15126 ASSERT_TRUE((bool)Style1); 15127 ASSERT_EQ(*Style1, getGoogleStyle()); 15128 } 15129 15130 TEST(FormatStyle, GetStyleOfFile) { 15131 llvm::vfs::InMemoryFileSystem FS; 15132 // Test 1: format file in the same directory. 15133 ASSERT_TRUE( 15134 FS.addFile("/a/.clang-format", 0, 15135 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 15136 ASSERT_TRUE( 15137 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 15138 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 15139 ASSERT_TRUE((bool)Style1); 15140 ASSERT_EQ(*Style1, getLLVMStyle()); 15141 15142 // Test 2.1: fallback to default. 15143 ASSERT_TRUE( 15144 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 15145 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 15146 ASSERT_TRUE((bool)Style2); 15147 ASSERT_EQ(*Style2, getMozillaStyle()); 15148 15149 // Test 2.2: no format on 'none' fallback style. 15150 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 15151 ASSERT_TRUE((bool)Style2); 15152 ASSERT_EQ(*Style2, getNoStyle()); 15153 15154 // Test 2.3: format if config is found with no based style while fallback is 15155 // 'none'. 15156 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 15157 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 15158 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 15159 ASSERT_TRUE((bool)Style2); 15160 ASSERT_EQ(*Style2, getLLVMStyle()); 15161 15162 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 15163 Style2 = getStyle("{}", "a.h", "none", "", &FS); 15164 ASSERT_TRUE((bool)Style2); 15165 ASSERT_EQ(*Style2, getLLVMStyle()); 15166 15167 // Test 3: format file in parent directory. 15168 ASSERT_TRUE( 15169 FS.addFile("/c/.clang-format", 0, 15170 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 15171 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 15172 llvm::MemoryBuffer::getMemBuffer("int i;"))); 15173 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 15174 ASSERT_TRUE((bool)Style3); 15175 ASSERT_EQ(*Style3, getGoogleStyle()); 15176 15177 // Test 4: error on invalid fallback style 15178 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 15179 ASSERT_FALSE((bool)Style4); 15180 llvm::consumeError(Style4.takeError()); 15181 15182 // Test 5: error on invalid yaml on command line 15183 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 15184 ASSERT_FALSE((bool)Style5); 15185 llvm::consumeError(Style5.takeError()); 15186 15187 // Test 6: error on invalid style 15188 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 15189 ASSERT_FALSE((bool)Style6); 15190 llvm::consumeError(Style6.takeError()); 15191 15192 // Test 7: found config file, error on parsing it 15193 ASSERT_TRUE( 15194 FS.addFile("/d/.clang-format", 0, 15195 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 15196 "InvalidKey: InvalidValue"))); 15197 ASSERT_TRUE( 15198 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 15199 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 15200 ASSERT_FALSE((bool)Style7); 15201 llvm::consumeError(Style7.takeError()); 15202 15203 // Test 8: inferred per-language defaults apply. 15204 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 15205 ASSERT_TRUE((bool)StyleTd); 15206 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 15207 } 15208 15209 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 15210 // Column limit is 20. 15211 std::string Code = "Type *a =\n" 15212 " new Type();\n" 15213 "g(iiiii, 0, jjjjj,\n" 15214 " 0, kkkkk, 0, mm);\n" 15215 "int bad = format ;"; 15216 std::string Expected = "auto a = new Type();\n" 15217 "g(iiiii, nullptr,\n" 15218 " jjjjj, nullptr,\n" 15219 " kkkkk, nullptr,\n" 15220 " mm);\n" 15221 "int bad = format ;"; 15222 FileID ID = Context.createInMemoryFile("format.cpp", Code); 15223 tooling::Replacements Replaces = toReplacements( 15224 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 15225 "auto "), 15226 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 15227 "nullptr"), 15228 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 15229 "nullptr"), 15230 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 15231 "nullptr")}); 15232 15233 format::FormatStyle Style = format::getLLVMStyle(); 15234 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 15235 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 15236 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 15237 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 15238 auto Result = applyAllReplacements(Code, *FormattedReplaces); 15239 EXPECT_TRUE(static_cast<bool>(Result)); 15240 EXPECT_EQ(Expected, *Result); 15241 } 15242 15243 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 15244 std::string Code = "#include \"a.h\"\n" 15245 "#include \"c.h\"\n" 15246 "\n" 15247 "int main() {\n" 15248 " return 0;\n" 15249 "}"; 15250 std::string Expected = "#include \"a.h\"\n" 15251 "#include \"b.h\"\n" 15252 "#include \"c.h\"\n" 15253 "\n" 15254 "int main() {\n" 15255 " return 0;\n" 15256 "}"; 15257 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 15258 tooling::Replacements Replaces = toReplacements( 15259 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 15260 "#include \"b.h\"\n")}); 15261 15262 format::FormatStyle Style = format::getLLVMStyle(); 15263 Style.SortIncludes = true; 15264 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 15265 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 15266 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 15267 auto Result = applyAllReplacements(Code, *FormattedReplaces); 15268 EXPECT_TRUE(static_cast<bool>(Result)); 15269 EXPECT_EQ(Expected, *Result); 15270 } 15271 15272 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 15273 EXPECT_EQ("using std::cin;\n" 15274 "using std::cout;", 15275 format("using std::cout;\n" 15276 "using std::cin;", 15277 getGoogleStyle())); 15278 } 15279 15280 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 15281 format::FormatStyle Style = format::getLLVMStyle(); 15282 Style.Standard = FormatStyle::LS_Cpp03; 15283 // cpp03 recognize this string as identifier u8 and literal character 'a' 15284 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 15285 } 15286 15287 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 15288 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 15289 // all modes, including C++11, C++14 and C++17 15290 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 15291 } 15292 15293 TEST_F(FormatTest, DoNotFormatLikelyXml) { 15294 EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle())); 15295 EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle())); 15296 } 15297 15298 TEST_F(FormatTest, StructuredBindings) { 15299 // Structured bindings is a C++17 feature. 15300 // all modes, including C++11, C++14 and C++17 15301 verifyFormat("auto [a, b] = f();"); 15302 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 15303 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 15304 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 15305 EXPECT_EQ("auto const volatile [a, b] = f();", 15306 format("auto const volatile[a, b] = f();")); 15307 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 15308 EXPECT_EQ("auto &[a, b, c] = f();", 15309 format("auto &[ a , b,c ] = f();")); 15310 EXPECT_EQ("auto &&[a, b, c] = f();", 15311 format("auto &&[ a , b,c ] = f();")); 15312 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 15313 EXPECT_EQ("auto const volatile &&[a, b] = f();", 15314 format("auto const volatile &&[a, b] = f();")); 15315 EXPECT_EQ("auto const &&[a, b] = f();", 15316 format("auto const && [a, b] = f();")); 15317 EXPECT_EQ("const auto &[a, b] = f();", 15318 format("const auto & [a, b] = f();")); 15319 EXPECT_EQ("const auto volatile &&[a, b] = f();", 15320 format("const auto volatile &&[a, b] = f();")); 15321 EXPECT_EQ("volatile const auto &&[a, b] = f();", 15322 format("volatile const auto &&[a, b] = f();")); 15323 EXPECT_EQ("const auto &&[a, b] = f();", 15324 format("const auto && [a, b] = f();")); 15325 15326 // Make sure we don't mistake structured bindings for lambdas. 15327 FormatStyle PointerMiddle = getLLVMStyle(); 15328 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 15329 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 15330 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 15331 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 15332 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 15333 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 15334 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 15335 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 15336 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 15337 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 15338 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 15339 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 15340 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 15341 15342 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 15343 format("for (const auto && [a, b] : some_range) {\n}")); 15344 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 15345 format("for (const auto & [a, b] : some_range) {\n}")); 15346 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 15347 format("for (const auto[a, b] : some_range) {\n}")); 15348 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 15349 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 15350 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 15351 EXPECT_EQ("auto const &[x, y](expr);", 15352 format("auto const & [x,y] (expr);")); 15353 EXPECT_EQ("auto const &&[x, y](expr);", 15354 format("auto const && [x,y] (expr);")); 15355 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 15356 EXPECT_EQ("auto const &[x, y]{expr};", 15357 format("auto const & [x,y] {expr};")); 15358 EXPECT_EQ("auto const &&[x, y]{expr};", 15359 format("auto const && [x,y] {expr};")); 15360 15361 format::FormatStyle Spaces = format::getLLVMStyle(); 15362 Spaces.SpacesInSquareBrackets = true; 15363 verifyFormat("auto [ a, b ] = f();", Spaces); 15364 verifyFormat("auto &&[ a, b ] = f();", Spaces); 15365 verifyFormat("auto &[ a, b ] = f();", Spaces); 15366 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 15367 verifyFormat("auto const &[ a, b ] = f();", Spaces); 15368 } 15369 15370 TEST_F(FormatTest, FileAndCode) { 15371 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 15372 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 15373 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 15374 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 15375 EXPECT_EQ(FormatStyle::LK_ObjC, 15376 guessLanguage("foo.h", "@interface Foo\n@end\n")); 15377 EXPECT_EQ( 15378 FormatStyle::LK_ObjC, 15379 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 15380 EXPECT_EQ(FormatStyle::LK_ObjC, 15381 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 15382 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 15383 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 15384 EXPECT_EQ(FormatStyle::LK_ObjC, 15385 guessLanguage("foo", "@interface Foo\n@end\n")); 15386 EXPECT_EQ(FormatStyle::LK_ObjC, 15387 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 15388 EXPECT_EQ( 15389 FormatStyle::LK_ObjC, 15390 guessLanguage("foo.h", 15391 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 15392 EXPECT_EQ( 15393 FormatStyle::LK_Cpp, 15394 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 15395 } 15396 15397 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 15398 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 15399 EXPECT_EQ(FormatStyle::LK_ObjC, 15400 guessLanguage("foo.h", "array[[calculator getIndex]];")); 15401 EXPECT_EQ(FormatStyle::LK_Cpp, 15402 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 15403 EXPECT_EQ( 15404 FormatStyle::LK_Cpp, 15405 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 15406 EXPECT_EQ(FormatStyle::LK_ObjC, 15407 guessLanguage("foo.h", "[[noreturn foo] bar];")); 15408 EXPECT_EQ(FormatStyle::LK_Cpp, 15409 guessLanguage("foo.h", "[[clang::fallthrough]];")); 15410 EXPECT_EQ(FormatStyle::LK_ObjC, 15411 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 15412 EXPECT_EQ(FormatStyle::LK_Cpp, 15413 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 15414 EXPECT_EQ(FormatStyle::LK_Cpp, 15415 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 15416 EXPECT_EQ(FormatStyle::LK_ObjC, 15417 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 15418 EXPECT_EQ(FormatStyle::LK_Cpp, 15419 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 15420 EXPECT_EQ( 15421 FormatStyle::LK_Cpp, 15422 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 15423 EXPECT_EQ( 15424 FormatStyle::LK_Cpp, 15425 guessLanguage("foo.h", 15426 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 15427 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 15428 } 15429 15430 TEST_F(FormatTest, GuessLanguageWithCaret) { 15431 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 15432 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 15433 EXPECT_EQ(FormatStyle::LK_ObjC, 15434 guessLanguage("foo.h", "int(^)(char, float);")); 15435 EXPECT_EQ(FormatStyle::LK_ObjC, 15436 guessLanguage("foo.h", "int(^foo)(char, float);")); 15437 EXPECT_EQ(FormatStyle::LK_ObjC, 15438 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 15439 EXPECT_EQ(FormatStyle::LK_ObjC, 15440 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 15441 EXPECT_EQ( 15442 FormatStyle::LK_ObjC, 15443 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 15444 } 15445 15446 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) { 15447 // ASM symbolic names are identifiers that must be surrounded by [] without 15448 // space in between: 15449 // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands 15450 15451 // Example from https://bugs.llvm.org/show_bug.cgi?id=45108. 15452 verifyFormat(R"(// 15453 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result)); 15454 )"); 15455 15456 // A list of several ASM symbolic names. 15457 verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)"); 15458 15459 // ASM symbolic names in inline ASM with inputs and outputs. 15460 verifyFormat(R"(// 15461 asm("cmoveq %1, %2, %[result]" 15462 : [result] "=r"(result) 15463 : "r"(test), "r"(new), "[result]"(old)); 15464 )"); 15465 15466 // ASM symbolic names in inline ASM with no outputs. 15467 verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)"); 15468 } 15469 15470 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 15471 EXPECT_EQ(FormatStyle::LK_Cpp, 15472 guessLanguage("foo.h", "void f() {\n" 15473 " asm (\"mov %[e], %[d]\"\n" 15474 " : [d] \"=rm\" (d)\n" 15475 " [e] \"rm\" (*e));\n" 15476 "}")); 15477 EXPECT_EQ(FormatStyle::LK_Cpp, 15478 guessLanguage("foo.h", "void f() {\n" 15479 " _asm (\"mov %[e], %[d]\"\n" 15480 " : [d] \"=rm\" (d)\n" 15481 " [e] \"rm\" (*e));\n" 15482 "}")); 15483 EXPECT_EQ(FormatStyle::LK_Cpp, 15484 guessLanguage("foo.h", "void f() {\n" 15485 " __asm (\"mov %[e], %[d]\"\n" 15486 " : [d] \"=rm\" (d)\n" 15487 " [e] \"rm\" (*e));\n" 15488 "}")); 15489 EXPECT_EQ(FormatStyle::LK_Cpp, 15490 guessLanguage("foo.h", "void f() {\n" 15491 " __asm__ (\"mov %[e], %[d]\"\n" 15492 " : [d] \"=rm\" (d)\n" 15493 " [e] \"rm\" (*e));\n" 15494 "}")); 15495 EXPECT_EQ(FormatStyle::LK_Cpp, 15496 guessLanguage("foo.h", "void f() {\n" 15497 " asm (\"mov %[e], %[d]\"\n" 15498 " : [d] \"=rm\" (d),\n" 15499 " [e] \"rm\" (*e));\n" 15500 "}")); 15501 EXPECT_EQ(FormatStyle::LK_Cpp, 15502 guessLanguage("foo.h", "void f() {\n" 15503 " asm volatile (\"mov %[e], %[d]\"\n" 15504 " : [d] \"=rm\" (d)\n" 15505 " [e] \"rm\" (*e));\n" 15506 "}")); 15507 } 15508 15509 TEST_F(FormatTest, GuessLanguageWithChildLines) { 15510 EXPECT_EQ(FormatStyle::LK_Cpp, 15511 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 15512 EXPECT_EQ(FormatStyle::LK_ObjC, 15513 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 15514 EXPECT_EQ( 15515 FormatStyle::LK_Cpp, 15516 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 15517 EXPECT_EQ( 15518 FormatStyle::LK_ObjC, 15519 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 15520 } 15521 15522 TEST_F(FormatTest, TypenameMacros) { 15523 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 15524 15525 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 15526 FormatStyle Google = getGoogleStyleWithColumns(0); 15527 Google.TypenameMacros = TypenameMacros; 15528 verifyFormat("struct foo {\n" 15529 " int bar;\n" 15530 " TAILQ_ENTRY(a) bleh;\n" 15531 "};", 15532 Google); 15533 15534 FormatStyle Macros = getLLVMStyle(); 15535 Macros.TypenameMacros = TypenameMacros; 15536 15537 verifyFormat("STACK_OF(int) a;", Macros); 15538 verifyFormat("STACK_OF(int) *a;", Macros); 15539 verifyFormat("STACK_OF(int const *) *a;", Macros); 15540 verifyFormat("STACK_OF(int *const) *a;", Macros); 15541 verifyFormat("STACK_OF(int, string) a;", Macros); 15542 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 15543 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 15544 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 15545 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 15546 15547 Macros.PointerAlignment = FormatStyle::PAS_Left; 15548 verifyFormat("STACK_OF(int)* a;", Macros); 15549 verifyFormat("STACK_OF(int*)* a;", Macros); 15550 } 15551 15552 TEST_F(FormatTest, AmbersandInLamda) { 15553 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899 15554 FormatStyle AlignStyle = getLLVMStyle(); 15555 AlignStyle.PointerAlignment = FormatStyle::PAS_Left; 15556 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 15557 AlignStyle.PointerAlignment = FormatStyle::PAS_Right; 15558 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 15559 } 15560 15561 TEST_F(FormatTest, SpacesInConditionalStatement) { 15562 FormatStyle Spaces = getLLVMStyle(); 15563 Spaces.SpacesInConditionalStatement = true; 15564 verifyFormat("for ( int i = 0; i; i++ )\n continue;", Spaces); 15565 verifyFormat("if ( !a )\n return;", Spaces); 15566 verifyFormat("if ( a )\n return;", Spaces); 15567 verifyFormat("if constexpr ( a )\n return;", Spaces); 15568 verifyFormat("switch ( a )\ncase 1:\n return;", Spaces); 15569 verifyFormat("while ( a )\n return;", Spaces); 15570 verifyFormat("while ( (a && b) )\n return;", Spaces); 15571 verifyFormat("do {\n} while ( 1 != 0 );", Spaces); 15572 verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces); 15573 // Check that space on the left of "::" is inserted as expected at beginning 15574 // of condition. 15575 verifyFormat("while ( ::func() )\n return;", Spaces); 15576 } 15577 15578 TEST_F(FormatTest, AlternativeOperators) { 15579 // Test case for ensuring alternate operators are not 15580 // combined with their right most neighbour. 15581 verifyFormat("int a and b;"); 15582 verifyFormat("int a and_eq b;"); 15583 verifyFormat("int a bitand b;"); 15584 verifyFormat("int a bitor b;"); 15585 verifyFormat("int a compl b;"); 15586 verifyFormat("int a not b;"); 15587 verifyFormat("int a not_eq b;"); 15588 verifyFormat("int a or b;"); 15589 verifyFormat("int a xor b;"); 15590 verifyFormat("int a xor_eq b;"); 15591 verifyFormat("return this not_eq bitand other;"); 15592 verifyFormat("bool operator not_eq(const X bitand other)"); 15593 15594 verifyFormat("int a and 5;"); 15595 verifyFormat("int a and_eq 5;"); 15596 verifyFormat("int a bitand 5;"); 15597 verifyFormat("int a bitor 5;"); 15598 verifyFormat("int a compl 5;"); 15599 verifyFormat("int a not 5;"); 15600 verifyFormat("int a not_eq 5;"); 15601 verifyFormat("int a or 5;"); 15602 verifyFormat("int a xor 5;"); 15603 verifyFormat("int a xor_eq 5;"); 15604 15605 verifyFormat("int a compl(5);"); 15606 verifyFormat("int a not(5);"); 15607 15608 /* FIXME handle alternate tokens 15609 * https://en.cppreference.com/w/cpp/language/operator_alternative 15610 // alternative tokens 15611 verifyFormat("compl foo();"); // ~foo(); 15612 verifyFormat("foo() <%%>;"); // foo(); 15613 verifyFormat("void foo() <%%>;"); // void foo(){} 15614 verifyFormat("int a <:1:>;"); // int a[1];[ 15615 verifyFormat("%:define ABC abc"); // #define ABC abc 15616 verifyFormat("%:%:"); // ## 15617 */ 15618 } 15619 15620 TEST_F(FormatTest, STLWhileNotDefineChed) { 15621 verifyFormat("#if defined(while)\n" 15622 "#define while EMIT WARNING C4005\n" 15623 "#endif // while"); 15624 } 15625 15626 TEST_F(FormatTest, OperatorSpacing) { 15627 FormatStyle Style = getLLVMStyle(); 15628 Style.PointerAlignment = FormatStyle::PAS_Right; 15629 verifyFormat("Foo::operator*();", Style); 15630 verifyFormat("Foo::operator void *();", Style); 15631 verifyFormat("Foo::operator()(void *);", Style); 15632 verifyFormat("Foo::operator*(void *);", Style); 15633 verifyFormat("Foo::operator*();", Style); 15634 verifyFormat("operator*(int (*)(), class Foo);", Style); 15635 15636 verifyFormat("Foo::operator&();", Style); 15637 verifyFormat("Foo::operator void &();", Style); 15638 verifyFormat("Foo::operator()(void &);", Style); 15639 verifyFormat("Foo::operator&(void &);", Style); 15640 verifyFormat("Foo::operator&();", Style); 15641 verifyFormat("operator&(int (&)(), class Foo);", Style); 15642 15643 verifyFormat("Foo::operator&&();", Style); 15644 verifyFormat("Foo::operator void &&();", Style); 15645 verifyFormat("Foo::operator()(void &&);", Style); 15646 verifyFormat("Foo::operator&&(void &&);", Style); 15647 verifyFormat("Foo::operator&&();", Style); 15648 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15649 15650 Style.PointerAlignment = FormatStyle::PAS_Left; 15651 verifyFormat("Foo::operator*();", Style); 15652 verifyFormat("Foo::operator void*();", Style); 15653 verifyFormat("Foo::operator/*comment*/ void*();", Style); 15654 verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style); 15655 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style); 15656 verifyFormat("Foo::operator()(void*);", Style); 15657 verifyFormat("Foo::operator*(void*);", Style); 15658 verifyFormat("Foo::operator*();", Style); 15659 verifyFormat("operator*(int (*)(), class Foo);", Style); 15660 15661 verifyFormat("Foo::operator&();", Style); 15662 verifyFormat("Foo::operator void&();", Style); 15663 verifyFormat("Foo::operator/*comment*/ void&();", Style); 15664 verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style); 15665 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style); 15666 verifyFormat("Foo::operator()(void&);", Style); 15667 verifyFormat("Foo::operator&(void&);", Style); 15668 verifyFormat("Foo::operator&();", Style); 15669 verifyFormat("operator&(int (&)(), class Foo);", Style); 15670 15671 verifyFormat("Foo::operator&&();", Style); 15672 verifyFormat("Foo::operator void&&();", Style); 15673 verifyFormat("Foo::operator/*comment*/ void&&();", Style); 15674 verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style); 15675 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style); 15676 verifyFormat("Foo::operator()(void&&);", Style); 15677 verifyFormat("Foo::operator&&(void&&);", Style); 15678 verifyFormat("Foo::operator&&();", Style); 15679 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15680 15681 // PR45107 15682 verifyFormat("operator Vector<String>&();", Style); 15683 verifyFormat("operator foo::Bar*();", Style); 15684 verifyFormat("operator const Foo<X>::Bar<Y>*();", Style); 15685 verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();", 15686 Style); 15687 15688 Style.PointerAlignment = FormatStyle::PAS_Middle; 15689 verifyFormat("Foo::operator*();", Style); 15690 verifyFormat("Foo::operator void *();", Style); 15691 verifyFormat("Foo::operator()(void *);", Style); 15692 verifyFormat("Foo::operator*(void *);", Style); 15693 verifyFormat("Foo::operator*();", Style); 15694 verifyFormat("operator*(int (*)(), class Foo);", Style); 15695 15696 verifyFormat("Foo::operator&();", Style); 15697 verifyFormat("Foo::operator void &();", Style); 15698 verifyFormat("Foo::operator()(void &);", Style); 15699 verifyFormat("Foo::operator&(void &);", Style); 15700 verifyFormat("Foo::operator&();", 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 15711 } // namespace 15712 } // namespace format 15713 } // namespace clang 15714