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 { 33 SC_ExpectComplete, 34 SC_ExpectIncomplete, 35 SC_DoNotCheck 36 }; 37 38 std::string format(llvm::StringRef Code, 39 const FormatStyle &Style = getLLVMStyle(), 40 StatusCheck CheckComplete = SC_ExpectComplete) { 41 LLVM_DEBUG(llvm::errs() << "---\n"); 42 LLVM_DEBUG(llvm::errs() << Code << "\n\n"); 43 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size())); 44 FormattingAttemptStatus Status; 45 tooling::Replacements Replaces = 46 reformat(Style, Code, Ranges, "<stdin>", &Status); 47 if (CheckComplete != SC_DoNotCheck) { 48 bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete; 49 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete) 50 << Code << "\n\n"; 51 } 52 ReplacementCount = Replaces.size(); 53 auto Result = applyAllReplacements(Code, Replaces); 54 EXPECT_TRUE(static_cast<bool>(Result)); 55 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); 56 return *Result; 57 } 58 59 FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) { 60 Style.ColumnLimit = ColumnLimit; 61 return Style; 62 } 63 64 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 65 return getStyleWithColumns(getLLVMStyle(), ColumnLimit); 66 } 67 68 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) { 69 return getStyleWithColumns(getGoogleStyle(), ColumnLimit); 70 } 71 72 void verifyFormat(llvm::StringRef Expected, llvm::StringRef Code, 73 const FormatStyle &Style = getLLVMStyle()) { 74 EXPECT_EQ(Expected.str(), format(Expected, Style)) 75 << "Expected code is not stable"; 76 EXPECT_EQ(Expected.str(), format(Code, Style)); 77 if (Style.Language == FormatStyle::LK_Cpp) { 78 // Objective-C++ is a superset of C++, so everything checked for C++ 79 // needs to be checked for Objective-C++ as well. 80 FormatStyle ObjCStyle = Style; 81 ObjCStyle.Language = FormatStyle::LK_ObjC; 82 EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle)); 83 } 84 } 85 86 void verifyFormat(llvm::StringRef Code, 87 const FormatStyle &Style = getLLVMStyle()) { 88 verifyFormat(Code, test::messUp(Code), Style); 89 } 90 91 void verifyIncompleteFormat(llvm::StringRef Code, 92 const FormatStyle &Style = getLLVMStyle()) { 93 EXPECT_EQ(Code.str(), 94 format(test::messUp(Code), Style, SC_ExpectIncomplete)); 95 } 96 97 void verifyGoogleFormat(llvm::StringRef Code) { 98 verifyFormat(Code, getGoogleStyle()); 99 } 100 101 void verifyIndependentOfContext(llvm::StringRef text) { 102 verifyFormat(text); 103 verifyFormat(llvm::Twine("void f() { " + text + " }").str()); 104 } 105 106 /// \brief Verify that clang-format does not crash on the given input. 107 void verifyNoCrash(llvm::StringRef Code, 108 const FormatStyle &Style = getLLVMStyle()) { 109 format(Code, Style, SC_DoNotCheck); 110 } 111 112 int ReplacementCount; 113 }; 114 115 TEST_F(FormatTest, MessUp) { 116 EXPECT_EQ("1 2 3", test::messUp("1 2 3")); 117 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n")); 118 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc")); 119 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc")); 120 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne")); 121 } 122 123 TEST_F(FormatTest, DefaultLLVMStyleIsCpp) { 124 EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language); 125 } 126 127 TEST_F(FormatTest, LLVMStyleOverride) { 128 EXPECT_EQ(FormatStyle::LK_Proto, 129 getLLVMStyle(FormatStyle::LK_Proto).Language); 130 } 131 132 //===----------------------------------------------------------------------===// 133 // Basic function tests. 134 //===----------------------------------------------------------------------===// 135 136 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { 137 EXPECT_EQ(";", format(";")); 138 } 139 140 TEST_F(FormatTest, FormatsGlobalStatementsAt0) { 141 EXPECT_EQ("int i;", format(" int i;")); 142 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;")); 143 EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); 144 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); 145 } 146 147 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { 148 EXPECT_EQ("int i;", format("int\ni;")); 149 } 150 151 TEST_F(FormatTest, FormatsNestedBlockStatements) { 152 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}")); 153 } 154 155 TEST_F(FormatTest, FormatsNestedCall) { 156 verifyFormat("Method(f1, f2(f3));"); 157 verifyFormat("Method(f1(f2, f3()));"); 158 verifyFormat("Method(f1(f2, (f3())));"); 159 } 160 161 TEST_F(FormatTest, NestedNameSpecifiers) { 162 verifyFormat("vector<::Type> v;"); 163 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())"); 164 verifyFormat("static constexpr bool Bar = decltype(bar())::value;"); 165 verifyFormat("bool a = 2 < ::SomeFunction();"); 166 verifyFormat("ALWAYS_INLINE ::std::string getName();"); 167 verifyFormat("some::string getName();"); 168 } 169 170 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { 171 EXPECT_EQ("if (a) {\n" 172 " f();\n" 173 "}", 174 format("if(a){f();}")); 175 EXPECT_EQ(4, ReplacementCount); 176 EXPECT_EQ("if (a) {\n" 177 " f();\n" 178 "}", 179 format("if (a) {\n" 180 " f();\n" 181 "}")); 182 EXPECT_EQ(0, ReplacementCount); 183 EXPECT_EQ("/*\r\n" 184 "\r\n" 185 "*/\r\n", 186 format("/*\r\n" 187 "\r\n" 188 "*/\r\n")); 189 EXPECT_EQ(0, ReplacementCount); 190 } 191 192 TEST_F(FormatTest, RemovesEmptyLines) { 193 EXPECT_EQ("class C {\n" 194 " int i;\n" 195 "};", 196 format("class C {\n" 197 " int i;\n" 198 "\n" 199 "};")); 200 201 // Don't remove empty lines at the start of namespaces or extern "C" blocks. 202 EXPECT_EQ("namespace N {\n" 203 "\n" 204 "int i;\n" 205 "}", 206 format("namespace N {\n" 207 "\n" 208 "int i;\n" 209 "}", 210 getGoogleStyle())); 211 EXPECT_EQ("/* something */ namespace N {\n" 212 "\n" 213 "int i;\n" 214 "}", 215 format("/* something */ namespace N {\n" 216 "\n" 217 "int i;\n" 218 "}", 219 getGoogleStyle())); 220 EXPECT_EQ("inline namespace N {\n" 221 "\n" 222 "int i;\n" 223 "}", 224 format("inline namespace N {\n" 225 "\n" 226 "int i;\n" 227 "}", 228 getGoogleStyle())); 229 EXPECT_EQ("/* something */ inline namespace N {\n" 230 "\n" 231 "int i;\n" 232 "}", 233 format("/* something */ inline namespace N {\n" 234 "\n" 235 "int i;\n" 236 "}", 237 getGoogleStyle())); 238 EXPECT_EQ("export namespace N {\n" 239 "\n" 240 "int i;\n" 241 "}", 242 format("export namespace N {\n" 243 "\n" 244 "int i;\n" 245 "}", 246 getGoogleStyle())); 247 EXPECT_EQ("extern /**/ \"C\" /**/ {\n" 248 "\n" 249 "int i;\n" 250 "}", 251 format("extern /**/ \"C\" /**/ {\n" 252 "\n" 253 "int i;\n" 254 "}", 255 getGoogleStyle())); 256 257 // ...but do keep inlining and removing empty lines for non-block extern "C" 258 // functions. 259 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle()); 260 EXPECT_EQ("extern \"C\" int f() {\n" 261 " int i = 42;\n" 262 " return i;\n" 263 "}", 264 format("extern \"C\" int f() {\n" 265 "\n" 266 " int i = 42;\n" 267 " return i;\n" 268 "}", 269 getGoogleStyle())); 270 271 // Remove empty lines at the beginning and end of blocks. 272 EXPECT_EQ("void f() {\n" 273 "\n" 274 " if (a) {\n" 275 "\n" 276 " f();\n" 277 " }\n" 278 "}", 279 format("void f() {\n" 280 "\n" 281 " if (a) {\n" 282 "\n" 283 " f();\n" 284 "\n" 285 " }\n" 286 "\n" 287 "}", 288 getLLVMStyle())); 289 EXPECT_EQ("void f() {\n" 290 " if (a) {\n" 291 " f();\n" 292 " }\n" 293 "}", 294 format("void f() {\n" 295 "\n" 296 " if (a) {\n" 297 "\n" 298 " f();\n" 299 "\n" 300 " }\n" 301 "\n" 302 "}", 303 getGoogleStyle())); 304 305 // Don't remove empty lines in more complex control statements. 306 EXPECT_EQ("void f() {\n" 307 " if (a) {\n" 308 " f();\n" 309 "\n" 310 " } else if (b) {\n" 311 " f();\n" 312 " }\n" 313 "}", 314 format("void f() {\n" 315 " if (a) {\n" 316 " f();\n" 317 "\n" 318 " } else if (b) {\n" 319 " f();\n" 320 "\n" 321 " }\n" 322 "\n" 323 "}")); 324 325 // Don't remove empty lines before namespace endings. 326 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 327 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 328 EXPECT_EQ("namespace {\n" 329 "int i;\n" 330 "\n" 331 "}", 332 format("namespace {\n" 333 "int i;\n" 334 "\n" 335 "}", LLVMWithNoNamespaceFix)); 336 EXPECT_EQ("namespace {\n" 337 "int i;\n" 338 "}", 339 format("namespace {\n" 340 "int i;\n" 341 "}", LLVMWithNoNamespaceFix)); 342 EXPECT_EQ("namespace {\n" 343 "int i;\n" 344 "\n" 345 "};", 346 format("namespace {\n" 347 "int i;\n" 348 "\n" 349 "};", LLVMWithNoNamespaceFix)); 350 EXPECT_EQ("namespace {\n" 351 "int i;\n" 352 "};", 353 format("namespace {\n" 354 "int i;\n" 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 (a)\n" 430 " if constexpr (b)\n" 431 " if constexpr (c)\n" 432 " g();\n" 433 "h();"); 434 verifyFormat("if constexpr (a)\n" 435 " if constexpr (b) {\n" 436 " f();\n" 437 " }\n" 438 "g();"); 439 440 FormatStyle AllowsMergedIf = getLLVMStyle(); 441 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 442 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 443 FormatStyle::SIS_WithoutElse; 444 verifyFormat("if (a)\n" 445 " // comment\n" 446 " f();", 447 AllowsMergedIf); 448 verifyFormat("{\n" 449 " if (a)\n" 450 " label:\n" 451 " f();\n" 452 "}", 453 AllowsMergedIf); 454 verifyFormat("#define A \\\n" 455 " if (a) \\\n" 456 " label: \\\n" 457 " f()", 458 AllowsMergedIf); 459 verifyFormat("if (a)\n" 460 " ;", 461 AllowsMergedIf); 462 verifyFormat("if (a)\n" 463 " if (b) return;", 464 AllowsMergedIf); 465 466 verifyFormat("if (a) // Can't merge this\n" 467 " f();\n", 468 AllowsMergedIf); 469 verifyFormat("if (a) /* still don't merge */\n" 470 " f();", 471 AllowsMergedIf); 472 verifyFormat("if (a) { // Never merge this\n" 473 " f();\n" 474 "}", 475 AllowsMergedIf); 476 verifyFormat("if (a) { /* Never merge this */\n" 477 " f();\n" 478 "}", 479 AllowsMergedIf); 480 481 AllowsMergedIf.ColumnLimit = 14; 482 verifyFormat("if (a) return;", AllowsMergedIf); 483 verifyFormat("if (aaaaaaaaa)\n" 484 " return;", 485 AllowsMergedIf); 486 487 AllowsMergedIf.ColumnLimit = 13; 488 verifyFormat("if (a)\n return;", AllowsMergedIf); 489 } 490 491 TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) { 492 FormatStyle AllowsMergedIf = getLLVMStyle(); 493 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 494 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 495 FormatStyle::SIS_WithoutElse; 496 verifyFormat("if (a)\n" 497 " f();\n" 498 "else {\n" 499 " g();\n" 500 "}", 501 AllowsMergedIf); 502 verifyFormat("if (a)\n" 503 " f();\n" 504 "else\n" 505 " g();\n", 506 AllowsMergedIf); 507 508 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 509 510 verifyFormat("if (a) f();\n" 511 "else {\n" 512 " g();\n" 513 "}", 514 AllowsMergedIf); 515 verifyFormat("if (a) f();\n" 516 "else {\n" 517 " if (a) f();\n" 518 " else {\n" 519 " g();\n" 520 " }\n" 521 " g();\n" 522 "}", 523 AllowsMergedIf); 524 } 525 526 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) { 527 FormatStyle AllowsMergedLoops = getLLVMStyle(); 528 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true; 529 verifyFormat("while (true) continue;", AllowsMergedLoops); 530 verifyFormat("for (;;) continue;", AllowsMergedLoops); 531 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops); 532 verifyFormat("while (true)\n" 533 " ;", 534 AllowsMergedLoops); 535 verifyFormat("for (;;)\n" 536 " ;", 537 AllowsMergedLoops); 538 verifyFormat("for (;;)\n" 539 " for (;;) continue;", 540 AllowsMergedLoops); 541 verifyFormat("for (;;) // Can't merge this\n" 542 " continue;", 543 AllowsMergedLoops); 544 verifyFormat("for (;;) /* still don't merge */\n" 545 " continue;", 546 AllowsMergedLoops); 547 } 548 549 TEST_F(FormatTest, FormatShortBracedStatements) { 550 FormatStyle AllowSimpleBracedStatements = getLLVMStyle(); 551 AllowSimpleBracedStatements.ColumnLimit = 40; 552 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = true; 553 554 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 555 FormatStyle::SIS_WithoutElse; 556 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 557 558 AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom; 559 AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true; 560 AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false; 561 562 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 563 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 564 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 565 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 566 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 567 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 568 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 569 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 570 verifyFormat("if (true) {\n" 571 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 572 "}", 573 AllowSimpleBracedStatements); 574 verifyFormat("if (true) { //\n" 575 " f();\n" 576 "}", 577 AllowSimpleBracedStatements); 578 verifyFormat("if (true) {\n" 579 " f();\n" 580 " f();\n" 581 "}", 582 AllowSimpleBracedStatements); 583 verifyFormat("if (true) {\n" 584 " f();\n" 585 "} else {\n" 586 " f();\n" 587 "}", 588 AllowSimpleBracedStatements); 589 590 verifyFormat("struct A2 {\n" 591 " int X;\n" 592 "};", 593 AllowSimpleBracedStatements); 594 verifyFormat("typedef struct A2 {\n" 595 " int X;\n" 596 "} A2_t;", 597 AllowSimpleBracedStatements); 598 verifyFormat("template <int> struct A2 {\n" 599 " struct B {};\n" 600 "};", 601 AllowSimpleBracedStatements); 602 603 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 604 FormatStyle::SIS_Never; 605 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 606 verifyFormat("if (true) {\n" 607 " f();\n" 608 "}", 609 AllowSimpleBracedStatements); 610 verifyFormat("if (true) {\n" 611 " f();\n" 612 "} else {\n" 613 " f();\n" 614 "}", 615 AllowSimpleBracedStatements); 616 617 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 618 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 619 verifyFormat("while (true) {\n" 620 " f();\n" 621 "}", 622 AllowSimpleBracedStatements); 623 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 624 verifyFormat("for (;;) {\n" 625 " f();\n" 626 "}", 627 AllowSimpleBracedStatements); 628 629 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 630 FormatStyle::SIS_WithoutElse; 631 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 632 AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement = true; 633 634 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 635 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 636 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 637 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 638 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 639 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 640 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 641 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 642 verifyFormat("if (true)\n" 643 "{\n" 644 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 645 "}", 646 AllowSimpleBracedStatements); 647 verifyFormat("if (true)\n" 648 "{ //\n" 649 " f();\n" 650 "}", 651 AllowSimpleBracedStatements); 652 verifyFormat("if (true)\n" 653 "{\n" 654 " f();\n" 655 " f();\n" 656 "}", 657 AllowSimpleBracedStatements); 658 verifyFormat("if (true)\n" 659 "{\n" 660 " f();\n" 661 "} else\n" 662 "{\n" 663 " f();\n" 664 "}", 665 AllowSimpleBracedStatements); 666 667 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 668 FormatStyle::SIS_Never; 669 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 670 verifyFormat("if (true)\n" 671 "{\n" 672 " f();\n" 673 "}", 674 AllowSimpleBracedStatements); 675 verifyFormat("if (true)\n" 676 "{\n" 677 " f();\n" 678 "} else\n" 679 "{\n" 680 " f();\n" 681 "}", 682 AllowSimpleBracedStatements); 683 684 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 685 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 686 verifyFormat("while (true)\n" 687 "{\n" 688 " f();\n" 689 "}", 690 AllowSimpleBracedStatements); 691 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 692 verifyFormat("for (;;)\n" 693 "{\n" 694 " f();\n" 695 "}", 696 AllowSimpleBracedStatements); 697 } 698 699 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) { 700 FormatStyle Style = getLLVMStyleWithColumns(60); 701 Style.AllowShortBlocksOnASingleLine = true; 702 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 703 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 704 EXPECT_EQ("#define A \\\n" 705 " if (HANDLEwernufrnuLwrmviferuvnierv) \\\n" 706 " { RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; }\n" 707 "X;", 708 format("#define A \\\n" 709 " if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n" 710 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n" 711 " }\n" 712 "X;", 713 Style)); 714 } 715 716 TEST_F(FormatTest, ParseIfElse) { 717 verifyFormat("if (true)\n" 718 " if (true)\n" 719 " if (true)\n" 720 " f();\n" 721 " else\n" 722 " g();\n" 723 " else\n" 724 " h();\n" 725 "else\n" 726 " i();"); 727 verifyFormat("if (true)\n" 728 " if (true)\n" 729 " if (true) {\n" 730 " if (true)\n" 731 " f();\n" 732 " } else {\n" 733 " g();\n" 734 " }\n" 735 " else\n" 736 " h();\n" 737 "else {\n" 738 " i();\n" 739 "}"); 740 verifyFormat("if (true)\n" 741 " if constexpr (true)\n" 742 " if (true) {\n" 743 " if constexpr (true)\n" 744 " f();\n" 745 " } else {\n" 746 " g();\n" 747 " }\n" 748 " else\n" 749 " h();\n" 750 "else {\n" 751 " i();\n" 752 "}"); 753 verifyFormat("void f() {\n" 754 " if (a) {\n" 755 " } else {\n" 756 " }\n" 757 "}"); 758 } 759 760 TEST_F(FormatTest, ElseIf) { 761 verifyFormat("if (a) {\n} else if (b) {\n}"); 762 verifyFormat("if (a)\n" 763 " f();\n" 764 "else if (b)\n" 765 " g();\n" 766 "else\n" 767 " h();"); 768 verifyFormat("if constexpr (a)\n" 769 " f();\n" 770 "else if constexpr (b)\n" 771 " g();\n" 772 "else\n" 773 " h();"); 774 verifyFormat("if (a) {\n" 775 " f();\n" 776 "}\n" 777 "// or else ..\n" 778 "else {\n" 779 " g()\n" 780 "}"); 781 782 verifyFormat("if (a) {\n" 783 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 784 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 785 "}"); 786 verifyFormat("if (a) {\n" 787 "} else if (\n" 788 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 789 "}", 790 getLLVMStyleWithColumns(62)); 791 verifyFormat("if (a) {\n" 792 "} else if constexpr (\n" 793 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 794 "}", 795 getLLVMStyleWithColumns(62)); 796 } 797 798 TEST_F(FormatTest, FormatsForLoop) { 799 verifyFormat( 800 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 801 " ++VeryVeryLongLoopVariable)\n" 802 " ;"); 803 verifyFormat("for (;;)\n" 804 " f();"); 805 verifyFormat("for (;;) {\n}"); 806 verifyFormat("for (;;) {\n" 807 " f();\n" 808 "}"); 809 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 810 811 verifyFormat( 812 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 813 " E = UnwrappedLines.end();\n" 814 " I != E; ++I) {\n}"); 815 816 verifyFormat( 817 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 818 " ++IIIII) {\n}"); 819 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 820 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 821 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 822 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 823 " I = FD->getDeclsInPrototypeScope().begin(),\n" 824 " E = FD->getDeclsInPrototypeScope().end();\n" 825 " I != E; ++I) {\n}"); 826 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n" 827 " I = Container.begin(),\n" 828 " E = Container.end();\n" 829 " I != E; ++I) {\n}", 830 getLLVMStyleWithColumns(76)); 831 832 verifyFormat( 833 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 834 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 835 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 836 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 837 " ++aaaaaaaaaaa) {\n}"); 838 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 839 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n" 840 " ++i) {\n}"); 841 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 842 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 843 "}"); 844 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 845 " aaaaaaaaaa);\n" 846 " iter; ++iter) {\n" 847 "}"); 848 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 849 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 850 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n" 851 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {"); 852 853 // These should not be formatted as Objective-C for-in loops. 854 verifyFormat("for (Foo *x = 0; x != in; x++) {\n}"); 855 verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}"); 856 verifyFormat("Foo *x;\nfor (x in y) {\n}"); 857 verifyFormat("for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}"); 858 859 FormatStyle NoBinPacking = getLLVMStyle(); 860 NoBinPacking.BinPackParameters = false; 861 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 862 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 863 " aaaaaaaaaaaaaaaa,\n" 864 " aaaaaaaaaaaaaaaa,\n" 865 " aaaaaaaaaaaaaaaa);\n" 866 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 867 "}", 868 NoBinPacking); 869 verifyFormat( 870 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 871 " E = UnwrappedLines.end();\n" 872 " I != E;\n" 873 " ++I) {\n}", 874 NoBinPacking); 875 876 FormatStyle AlignLeft = getLLVMStyle(); 877 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 878 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft); 879 } 880 881 TEST_F(FormatTest, RangeBasedForLoops) { 882 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 883 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 884 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 885 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 886 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 887 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 888 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n" 889 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}"); 890 } 891 892 TEST_F(FormatTest, ForEachLoops) { 893 verifyFormat("void f() {\n" 894 " foreach (Item *item, itemlist) {}\n" 895 " Q_FOREACH (Item *item, itemlist) {}\n" 896 " BOOST_FOREACH (Item *item, itemlist) {}\n" 897 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 898 "}"); 899 900 // As function-like macros. 901 verifyFormat("#define foreach(x, y)\n" 902 "#define Q_FOREACH(x, y)\n" 903 "#define BOOST_FOREACH(x, y)\n" 904 "#define UNKNOWN_FOREACH(x, y)\n"); 905 906 // Not as function-like macros. 907 verifyFormat("#define foreach (x, y)\n" 908 "#define Q_FOREACH (x, y)\n" 909 "#define BOOST_FOREACH (x, y)\n" 910 "#define UNKNOWN_FOREACH (x, y)\n"); 911 } 912 913 TEST_F(FormatTest, FormatsWhileLoop) { 914 verifyFormat("while (true) {\n}"); 915 verifyFormat("while (true)\n" 916 " f();"); 917 verifyFormat("while () {\n}"); 918 verifyFormat("while () {\n" 919 " f();\n" 920 "}"); 921 } 922 923 TEST_F(FormatTest, FormatsDoWhile) { 924 verifyFormat("do {\n" 925 " do_something();\n" 926 "} while (something());"); 927 verifyFormat("do\n" 928 " do_something();\n" 929 "while (something());"); 930 } 931 932 TEST_F(FormatTest, FormatsSwitchStatement) { 933 verifyFormat("switch (x) {\n" 934 "case 1:\n" 935 " f();\n" 936 " break;\n" 937 "case kFoo:\n" 938 "case ns::kBar:\n" 939 "case kBaz:\n" 940 " break;\n" 941 "default:\n" 942 " g();\n" 943 " break;\n" 944 "}"); 945 verifyFormat("switch (x) {\n" 946 "case 1: {\n" 947 " f();\n" 948 " break;\n" 949 "}\n" 950 "case 2: {\n" 951 " break;\n" 952 "}\n" 953 "}"); 954 verifyFormat("switch (x) {\n" 955 "case 1: {\n" 956 " f();\n" 957 " {\n" 958 " g();\n" 959 " h();\n" 960 " }\n" 961 " break;\n" 962 "}\n" 963 "}"); 964 verifyFormat("switch (x) {\n" 965 "case 1: {\n" 966 " f();\n" 967 " if (foo) {\n" 968 " g();\n" 969 " h();\n" 970 " }\n" 971 " break;\n" 972 "}\n" 973 "}"); 974 verifyFormat("switch (x) {\n" 975 "case 1: {\n" 976 " f();\n" 977 " g();\n" 978 "} break;\n" 979 "}"); 980 verifyFormat("switch (test)\n" 981 " ;"); 982 verifyFormat("switch (x) {\n" 983 "default: {\n" 984 " // Do nothing.\n" 985 "}\n" 986 "}"); 987 verifyFormat("switch (x) {\n" 988 "// comment\n" 989 "// if 1, do f()\n" 990 "case 1:\n" 991 " f();\n" 992 "}"); 993 verifyFormat("switch (x) {\n" 994 "case 1:\n" 995 " // Do amazing stuff\n" 996 " {\n" 997 " f();\n" 998 " g();\n" 999 " }\n" 1000 " break;\n" 1001 "}"); 1002 verifyFormat("#define A \\\n" 1003 " switch (x) { \\\n" 1004 " case a: \\\n" 1005 " foo = b; \\\n" 1006 " }", 1007 getLLVMStyleWithColumns(20)); 1008 verifyFormat("#define OPERATION_CASE(name) \\\n" 1009 " case OP_name: \\\n" 1010 " return operations::Operation##name\n", 1011 getLLVMStyleWithColumns(40)); 1012 verifyFormat("switch (x) {\n" 1013 "case 1:;\n" 1014 "default:;\n" 1015 " int i;\n" 1016 "}"); 1017 1018 verifyGoogleFormat("switch (x) {\n" 1019 " case 1:\n" 1020 " f();\n" 1021 " break;\n" 1022 " case kFoo:\n" 1023 " case ns::kBar:\n" 1024 " case kBaz:\n" 1025 " break;\n" 1026 " default:\n" 1027 " g();\n" 1028 " break;\n" 1029 "}"); 1030 verifyGoogleFormat("switch (x) {\n" 1031 " case 1: {\n" 1032 " f();\n" 1033 " break;\n" 1034 " }\n" 1035 "}"); 1036 verifyGoogleFormat("switch (test)\n" 1037 " ;"); 1038 1039 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 1040 " case OP_name: \\\n" 1041 " return operations::Operation##name\n"); 1042 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 1043 " // Get the correction operation class.\n" 1044 " switch (OpCode) {\n" 1045 " CASE(Add);\n" 1046 " CASE(Subtract);\n" 1047 " default:\n" 1048 " return operations::Unknown;\n" 1049 " }\n" 1050 "#undef OPERATION_CASE\n" 1051 "}"); 1052 verifyFormat("DEBUG({\n" 1053 " switch (x) {\n" 1054 " case A:\n" 1055 " f();\n" 1056 " break;\n" 1057 " // fallthrough\n" 1058 " case B:\n" 1059 " g();\n" 1060 " break;\n" 1061 " }\n" 1062 "});"); 1063 EXPECT_EQ("DEBUG({\n" 1064 " switch (x) {\n" 1065 " case A:\n" 1066 " f();\n" 1067 " break;\n" 1068 " // On B:\n" 1069 " case B:\n" 1070 " g();\n" 1071 " break;\n" 1072 " }\n" 1073 "});", 1074 format("DEBUG({\n" 1075 " switch (x) {\n" 1076 " case A:\n" 1077 " f();\n" 1078 " break;\n" 1079 " // On B:\n" 1080 " case B:\n" 1081 " g();\n" 1082 " break;\n" 1083 " }\n" 1084 "});", 1085 getLLVMStyle())); 1086 EXPECT_EQ("switch (n) {\n" 1087 "case 0: {\n" 1088 " return false;\n" 1089 "}\n" 1090 "default: {\n" 1091 " return true;\n" 1092 "}\n" 1093 "}", 1094 format("switch (n)\n" 1095 "{\n" 1096 "case 0: {\n" 1097 " return false;\n" 1098 "}\n" 1099 "default: {\n" 1100 " return true;\n" 1101 "}\n" 1102 "}", 1103 getLLVMStyle())); 1104 verifyFormat("switch (a) {\n" 1105 "case (b):\n" 1106 " return;\n" 1107 "}"); 1108 1109 verifyFormat("switch (a) {\n" 1110 "case some_namespace::\n" 1111 " some_constant:\n" 1112 " return;\n" 1113 "}", 1114 getLLVMStyleWithColumns(34)); 1115 1116 FormatStyle Style = getLLVMStyle(); 1117 Style.IndentCaseLabels = true; 1118 Style.AllowShortBlocksOnASingleLine = false; 1119 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1120 Style.BraceWrapping.AfterCaseLabel = true; 1121 Style.BraceWrapping.AfterControlStatement = true; 1122 EXPECT_EQ("switch (n)\n" 1123 "{\n" 1124 " case 0:\n" 1125 " {\n" 1126 " return false;\n" 1127 " }\n" 1128 " default:\n" 1129 " {\n" 1130 " return true;\n" 1131 " }\n" 1132 "}", 1133 format("switch (n) {\n" 1134 " case 0: {\n" 1135 " return false;\n" 1136 " }\n" 1137 " default: {\n" 1138 " return true;\n" 1139 " }\n" 1140 "}", 1141 Style)); 1142 Style.BraceWrapping.AfterCaseLabel = false; 1143 EXPECT_EQ("switch (n)\n" 1144 "{\n" 1145 " case 0: {\n" 1146 " return false;\n" 1147 " }\n" 1148 " default: {\n" 1149 " return true;\n" 1150 " }\n" 1151 "}", 1152 format("switch (n) {\n" 1153 " case 0:\n" 1154 " {\n" 1155 " return false;\n" 1156 " }\n" 1157 " default:\n" 1158 " {\n" 1159 " return true;\n" 1160 " }\n" 1161 "}", 1162 Style)); 1163 } 1164 1165 TEST_F(FormatTest, CaseRanges) { 1166 verifyFormat("switch (x) {\n" 1167 "case 'A' ... 'Z':\n" 1168 "case 1 ... 5:\n" 1169 "case a ... b:\n" 1170 " break;\n" 1171 "}"); 1172 } 1173 1174 TEST_F(FormatTest, ShortCaseLabels) { 1175 FormatStyle Style = getLLVMStyle(); 1176 Style.AllowShortCaseLabelsOnASingleLine = true; 1177 verifyFormat("switch (a) {\n" 1178 "case 1: x = 1; break;\n" 1179 "case 2: return;\n" 1180 "case 3:\n" 1181 "case 4:\n" 1182 "case 5: return;\n" 1183 "case 6: // comment\n" 1184 " return;\n" 1185 "case 7:\n" 1186 " // comment\n" 1187 " return;\n" 1188 "case 8:\n" 1189 " x = 8; // comment\n" 1190 " break;\n" 1191 "default: y = 1; break;\n" 1192 "}", 1193 Style); 1194 verifyFormat("switch (a) {\n" 1195 "case 0: return; // comment\n" 1196 "case 1: break; // comment\n" 1197 "case 2: return;\n" 1198 "// comment\n" 1199 "case 3: return;\n" 1200 "// comment 1\n" 1201 "// comment 2\n" 1202 "// comment 3\n" 1203 "case 4: break; /* comment */\n" 1204 "case 5:\n" 1205 " // comment\n" 1206 " break;\n" 1207 "case 6: /* comment */ x = 1; break;\n" 1208 "case 7: x = /* comment */ 1; break;\n" 1209 "case 8:\n" 1210 " x = 1; /* comment */\n" 1211 " break;\n" 1212 "case 9:\n" 1213 " break; // comment line 1\n" 1214 " // comment line 2\n" 1215 "}", 1216 Style); 1217 EXPECT_EQ("switch (a) {\n" 1218 "case 1:\n" 1219 " x = 8;\n" 1220 " // fall through\n" 1221 "case 2: x = 8;\n" 1222 "// comment\n" 1223 "case 3:\n" 1224 " return; /* comment line 1\n" 1225 " * comment line 2 */\n" 1226 "case 4: i = 8;\n" 1227 "// something else\n" 1228 "#if FOO\n" 1229 "case 5: break;\n" 1230 "#endif\n" 1231 "}", 1232 format("switch (a) {\n" 1233 "case 1: x = 8;\n" 1234 " // fall through\n" 1235 "case 2:\n" 1236 " x = 8;\n" 1237 "// comment\n" 1238 "case 3:\n" 1239 " return; /* comment line 1\n" 1240 " * comment line 2 */\n" 1241 "case 4:\n" 1242 " i = 8;\n" 1243 "// something else\n" 1244 "#if FOO\n" 1245 "case 5: break;\n" 1246 "#endif\n" 1247 "}", 1248 Style)); 1249 EXPECT_EQ("switch (a) {\n" "case 0:\n" 1250 " return; // long long long long long long long long long long long long comment\n" 1251 " // line\n" "}", 1252 format("switch (a) {\n" 1253 "case 0: return; // long long long long long long long long long long long long comment line\n" 1254 "}", 1255 Style)); 1256 EXPECT_EQ("switch (a) {\n" 1257 "case 0:\n" 1258 " return; /* long long long long long long long long long long long long comment\n" 1259 " line */\n" 1260 "}", 1261 format("switch (a) {\n" 1262 "case 0: return; /* long long long long long long long long long long long long comment line */\n" 1263 "}", 1264 Style)); 1265 verifyFormat("switch (a) {\n" 1266 "#if FOO\n" 1267 "case 0: return 0;\n" 1268 "#endif\n" 1269 "}", 1270 Style); 1271 verifyFormat("switch (a) {\n" 1272 "case 1: {\n" 1273 "}\n" 1274 "case 2: {\n" 1275 " return;\n" 1276 "}\n" 1277 "case 3: {\n" 1278 " x = 1;\n" 1279 " return;\n" 1280 "}\n" 1281 "case 4:\n" 1282 " if (x)\n" 1283 " return;\n" 1284 "}", 1285 Style); 1286 Style.ColumnLimit = 21; 1287 verifyFormat("switch (a) {\n" 1288 "case 1: x = 1; break;\n" 1289 "case 2: return;\n" 1290 "case 3:\n" 1291 "case 4:\n" 1292 "case 5: return;\n" 1293 "default:\n" 1294 " y = 1;\n" 1295 " break;\n" 1296 "}", 1297 Style); 1298 Style.ColumnLimit = 80; 1299 Style.AllowShortCaseLabelsOnASingleLine = false; 1300 Style.IndentCaseLabels = true; 1301 EXPECT_EQ("switch (n) {\n" 1302 " default /*comments*/:\n" 1303 " return true;\n" 1304 " case 0:\n" 1305 " return false;\n" 1306 "}", 1307 format("switch (n) {\n" 1308 "default/*comments*/:\n" 1309 " return true;\n" 1310 "case 0:\n" 1311 " return false;\n" 1312 "}", 1313 Style)); 1314 Style.AllowShortCaseLabelsOnASingleLine = true; 1315 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1316 Style.BraceWrapping.AfterCaseLabel = true; 1317 Style.BraceWrapping.AfterControlStatement = true; 1318 EXPECT_EQ("switch (n)\n" 1319 "{\n" 1320 " case 0:\n" 1321 " {\n" 1322 " return false;\n" 1323 " }\n" 1324 " default:\n" 1325 " {\n" 1326 " return true;\n" 1327 " }\n" 1328 "}", 1329 format("switch (n) {\n" 1330 " case 0: {\n" 1331 " return false;\n" 1332 " }\n" 1333 " default:\n" 1334 " {\n" 1335 " return true;\n" 1336 " }\n" 1337 "}", 1338 Style)); 1339 } 1340 1341 TEST_F(FormatTest, FormatsLabels) { 1342 verifyFormat("void f() {\n" 1343 " some_code();\n" 1344 "test_label:\n" 1345 " some_other_code();\n" 1346 " {\n" 1347 " some_more_code();\n" 1348 " another_label:\n" 1349 " some_more_code();\n" 1350 " }\n" 1351 "}"); 1352 verifyFormat("{\n" 1353 " some_code();\n" 1354 "test_label:\n" 1355 " some_other_code();\n" 1356 "}"); 1357 verifyFormat("{\n" 1358 " some_code();\n" 1359 "test_label:;\n" 1360 " int i = 0;\n" 1361 "}"); 1362 } 1363 1364 //===----------------------------------------------------------------------===// 1365 // Tests for classes, namespaces, etc. 1366 //===----------------------------------------------------------------------===// 1367 1368 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1369 verifyFormat("class A {};"); 1370 } 1371 1372 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1373 verifyFormat("class A {\n" 1374 "public:\n" 1375 "public: // comment\n" 1376 "protected:\n" 1377 "private:\n" 1378 " void f() {}\n" 1379 "};"); 1380 verifyFormat("export class A {\n" 1381 "public:\n" 1382 "public: // comment\n" 1383 "protected:\n" 1384 "private:\n" 1385 " void f() {}\n" 1386 "};"); 1387 verifyGoogleFormat("class A {\n" 1388 " public:\n" 1389 " protected:\n" 1390 " private:\n" 1391 " void f() {}\n" 1392 "};"); 1393 verifyGoogleFormat("export class A {\n" 1394 " public:\n" 1395 " protected:\n" 1396 " private:\n" 1397 " void f() {}\n" 1398 "};"); 1399 verifyFormat("class A {\n" 1400 "public slots:\n" 1401 " void f1() {}\n" 1402 "public Q_SLOTS:\n" 1403 " void f2() {}\n" 1404 "protected slots:\n" 1405 " void f3() {}\n" 1406 "protected Q_SLOTS:\n" 1407 " void f4() {}\n" 1408 "private slots:\n" 1409 " void f5() {}\n" 1410 "private Q_SLOTS:\n" 1411 " void f6() {}\n" 1412 "signals:\n" 1413 " void g1();\n" 1414 "Q_SIGNALS:\n" 1415 " void g2();\n" 1416 "};"); 1417 1418 // Don't interpret 'signals' the wrong way. 1419 verifyFormat("signals.set();"); 1420 verifyFormat("for (Signals signals : f()) {\n}"); 1421 verifyFormat("{\n" 1422 " signals.set(); // This needs indentation.\n" 1423 "}"); 1424 verifyFormat("void f() {\n" 1425 "label:\n" 1426 " signals.baz();\n" 1427 "}"); 1428 } 1429 1430 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1431 EXPECT_EQ("class A {\n" 1432 "public:\n" 1433 " void f();\n" 1434 "\n" 1435 "private:\n" 1436 " void g() {}\n" 1437 " // test\n" 1438 "protected:\n" 1439 " int h;\n" 1440 "};", 1441 format("class A {\n" 1442 "public:\n" 1443 "void f();\n" 1444 "private:\n" 1445 "void g() {}\n" 1446 "// test\n" 1447 "protected:\n" 1448 "int h;\n" 1449 "};")); 1450 EXPECT_EQ("class A {\n" 1451 "protected:\n" 1452 "public:\n" 1453 " void f();\n" 1454 "};", 1455 format("class A {\n" 1456 "protected:\n" 1457 "\n" 1458 "public:\n" 1459 "\n" 1460 " void f();\n" 1461 "};")); 1462 1463 // Even ensure proper spacing inside macros. 1464 EXPECT_EQ("#define B \\\n" 1465 " class A { \\\n" 1466 " protected: \\\n" 1467 " public: \\\n" 1468 " void f(); \\\n" 1469 " };", 1470 format("#define B \\\n" 1471 " class A { \\\n" 1472 " protected: \\\n" 1473 " \\\n" 1474 " public: \\\n" 1475 " \\\n" 1476 " void f(); \\\n" 1477 " };", 1478 getGoogleStyle())); 1479 // But don't remove empty lines after macros ending in access specifiers. 1480 EXPECT_EQ("#define A private:\n" 1481 "\n" 1482 "int i;", 1483 format("#define A private:\n" 1484 "\n" 1485 "int i;")); 1486 } 1487 1488 TEST_F(FormatTest, FormatsClasses) { 1489 verifyFormat("class A : public B {};"); 1490 verifyFormat("class A : public ::B {};"); 1491 1492 verifyFormat( 1493 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1494 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1495 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1496 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1497 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1498 verifyFormat( 1499 "class A : public B, public C, public D, public E, public F {};"); 1500 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1501 " public C,\n" 1502 " public D,\n" 1503 " public E,\n" 1504 " public F,\n" 1505 " public G {};"); 1506 1507 verifyFormat("class\n" 1508 " ReallyReallyLongClassName {\n" 1509 " int i;\n" 1510 "};", 1511 getLLVMStyleWithColumns(32)); 1512 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1513 " aaaaaaaaaaaaaaaa> {};"); 1514 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1515 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1516 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1517 verifyFormat("template <class R, class C>\n" 1518 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1519 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1520 verifyFormat("class ::A::B {};"); 1521 } 1522 1523 TEST_F(FormatTest, BreakInheritanceStyle) { 1524 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1525 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1526 FormatStyle::BILS_BeforeComma; 1527 verifyFormat("class MyClass : public X {};", 1528 StyleWithInheritanceBreakBeforeComma); 1529 verifyFormat("class MyClass\n" 1530 " : public X\n" 1531 " , public Y {};", 1532 StyleWithInheritanceBreakBeforeComma); 1533 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1534 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1535 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1536 StyleWithInheritanceBreakBeforeComma); 1537 verifyFormat("struct aaaaaaaaaaaaa\n" 1538 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1539 " aaaaaaaaaaaaaaaa> {};", 1540 StyleWithInheritanceBreakBeforeComma); 1541 1542 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1543 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1544 FormatStyle::BILS_AfterColon; 1545 verifyFormat("class MyClass : public X {};", 1546 StyleWithInheritanceBreakAfterColon); 1547 verifyFormat("class MyClass : public X, public Y {};", 1548 StyleWithInheritanceBreakAfterColon); 1549 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1550 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1551 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1552 StyleWithInheritanceBreakAfterColon); 1553 verifyFormat("struct aaaaaaaaaaaaa :\n" 1554 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1555 " aaaaaaaaaaaaaaaa> {};", 1556 StyleWithInheritanceBreakAfterColon); 1557 } 1558 1559 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1560 verifyFormat("class A {\n} a, b;"); 1561 verifyFormat("struct A {\n} a, b;"); 1562 verifyFormat("union A {\n} a;"); 1563 } 1564 1565 TEST_F(FormatTest, FormatsEnum) { 1566 verifyFormat("enum {\n" 1567 " Zero,\n" 1568 " One = 1,\n" 1569 " Two = One + 1,\n" 1570 " Three = (One + Two),\n" 1571 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1572 " Five = (One, Two, Three, Four, 5)\n" 1573 "};"); 1574 verifyGoogleFormat("enum {\n" 1575 " Zero,\n" 1576 " One = 1,\n" 1577 " Two = One + 1,\n" 1578 " Three = (One + Two),\n" 1579 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1580 " Five = (One, Two, Three, Four, 5)\n" 1581 "};"); 1582 verifyFormat("enum Enum {};"); 1583 verifyFormat("enum {};"); 1584 verifyFormat("enum X E {} d;"); 1585 verifyFormat("enum __attribute__((...)) E {} d;"); 1586 verifyFormat("enum __declspec__((...)) E {} d;"); 1587 verifyFormat("enum {\n" 1588 " Bar = Foo<int, int>::value\n" 1589 "};", 1590 getLLVMStyleWithColumns(30)); 1591 1592 verifyFormat("enum ShortEnum { A, B, C };"); 1593 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1594 1595 EXPECT_EQ("enum KeepEmptyLines {\n" 1596 " ONE,\n" 1597 "\n" 1598 " TWO,\n" 1599 "\n" 1600 " THREE\n" 1601 "}", 1602 format("enum KeepEmptyLines {\n" 1603 " ONE,\n" 1604 "\n" 1605 " TWO,\n" 1606 "\n" 1607 "\n" 1608 " THREE\n" 1609 "}")); 1610 verifyFormat("enum E { // comment\n" 1611 " ONE,\n" 1612 " TWO\n" 1613 "};\n" 1614 "int i;"); 1615 // Not enums. 1616 verifyFormat("enum X f() {\n" 1617 " a();\n" 1618 " return 42;\n" 1619 "}"); 1620 verifyFormat("enum X Type::f() {\n" 1621 " a();\n" 1622 " return 42;\n" 1623 "}"); 1624 verifyFormat("enum ::X f() {\n" 1625 " a();\n" 1626 " return 42;\n" 1627 "}"); 1628 verifyFormat("enum ns::X f() {\n" 1629 " a();\n" 1630 " return 42;\n" 1631 "}"); 1632 } 1633 1634 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1635 verifyFormat("enum Type {\n" 1636 " One = 0; // These semicolons should be commas.\n" 1637 " Two = 1;\n" 1638 "};"); 1639 verifyFormat("namespace n {\n" 1640 "enum Type {\n" 1641 " One,\n" 1642 " Two, // missing };\n" 1643 " int i;\n" 1644 "}\n" 1645 "void g() {}"); 1646 } 1647 1648 TEST_F(FormatTest, FormatsEnumStruct) { 1649 verifyFormat("enum struct {\n" 1650 " Zero,\n" 1651 " One = 1,\n" 1652 " Two = One + 1,\n" 1653 " Three = (One + Two),\n" 1654 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1655 " Five = (One, Two, Three, Four, 5)\n" 1656 "};"); 1657 verifyFormat("enum struct Enum {};"); 1658 verifyFormat("enum struct {};"); 1659 verifyFormat("enum struct X E {} d;"); 1660 verifyFormat("enum struct __attribute__((...)) E {} d;"); 1661 verifyFormat("enum struct __declspec__((...)) E {} d;"); 1662 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1663 } 1664 1665 TEST_F(FormatTest, FormatsEnumClass) { 1666 verifyFormat("enum class {\n" 1667 " Zero,\n" 1668 " One = 1,\n" 1669 " Two = One + 1,\n" 1670 " Three = (One + Two),\n" 1671 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1672 " Five = (One, Two, Three, Four, 5)\n" 1673 "};"); 1674 verifyFormat("enum class Enum {};"); 1675 verifyFormat("enum class {};"); 1676 verifyFormat("enum class X E {} d;"); 1677 verifyFormat("enum class __attribute__((...)) E {} d;"); 1678 verifyFormat("enum class __declspec__((...)) E {} d;"); 1679 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 1680 } 1681 1682 TEST_F(FormatTest, FormatsEnumTypes) { 1683 verifyFormat("enum X : int {\n" 1684 " A, // Force multiple lines.\n" 1685 " B\n" 1686 "};"); 1687 verifyFormat("enum X : int { A, B };"); 1688 verifyFormat("enum X : std::uint32_t { A, B };"); 1689 } 1690 1691 TEST_F(FormatTest, FormatsTypedefEnum) { 1692 FormatStyle Style = getLLVMStyle(); 1693 Style.ColumnLimit = 40; 1694 verifyFormat("typedef enum {} EmptyEnum;"); 1695 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1696 verifyFormat("typedef enum {\n" 1697 " ZERO = 0,\n" 1698 " ONE = 1,\n" 1699 " TWO = 2,\n" 1700 " THREE = 3\n" 1701 "} LongEnum;", 1702 Style); 1703 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1704 Style.BraceWrapping.AfterEnum = true; 1705 verifyFormat("typedef enum {} EmptyEnum;"); 1706 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1707 verifyFormat("typedef enum\n" 1708 "{\n" 1709 " ZERO = 0,\n" 1710 " ONE = 1,\n" 1711 " TWO = 2,\n" 1712 " THREE = 3\n" 1713 "} LongEnum;", 1714 Style); 1715 } 1716 1717 TEST_F(FormatTest, FormatsNSEnums) { 1718 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1719 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 1720 " // Information about someDecentlyLongValue.\n" 1721 " someDecentlyLongValue,\n" 1722 " // Information about anotherDecentlyLongValue.\n" 1723 " anotherDecentlyLongValue,\n" 1724 " // Information about aThirdDecentlyLongValue.\n" 1725 " aThirdDecentlyLongValue\n" 1726 "};"); 1727 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 1728 " a = 1,\n" 1729 " b = 2,\n" 1730 " c = 3,\n" 1731 "};"); 1732 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 1733 " a = 1,\n" 1734 " b = 2,\n" 1735 " c = 3,\n" 1736 "};"); 1737 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 1738 " a = 1,\n" 1739 " b = 2,\n" 1740 " c = 3,\n" 1741 "};"); 1742 } 1743 1744 TEST_F(FormatTest, FormatsBitfields) { 1745 verifyFormat("struct Bitfields {\n" 1746 " unsigned sClass : 8;\n" 1747 " unsigned ValueKind : 2;\n" 1748 "};"); 1749 verifyFormat("struct A {\n" 1750 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 1751 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 1752 "};"); 1753 verifyFormat("struct MyStruct {\n" 1754 " uchar data;\n" 1755 " uchar : 8;\n" 1756 " uchar : 8;\n" 1757 " uchar other;\n" 1758 "};"); 1759 } 1760 1761 TEST_F(FormatTest, FormatsNamespaces) { 1762 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 1763 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 1764 1765 verifyFormat("namespace some_namespace {\n" 1766 "class A {};\n" 1767 "void f() { f(); }\n" 1768 "}", 1769 LLVMWithNoNamespaceFix); 1770 verifyFormat("/* something */ namespace some_namespace {\n" 1771 "class A {};\n" 1772 "void f() { f(); }\n" 1773 "}", 1774 LLVMWithNoNamespaceFix); 1775 verifyFormat("namespace {\n" 1776 "class A {};\n" 1777 "void f() { f(); }\n" 1778 "}", 1779 LLVMWithNoNamespaceFix); 1780 verifyFormat("/* something */ namespace {\n" 1781 "class A {};\n" 1782 "void f() { f(); }\n" 1783 "}", 1784 LLVMWithNoNamespaceFix); 1785 verifyFormat("inline namespace X {\n" 1786 "class A {};\n" 1787 "void f() { f(); }\n" 1788 "}", 1789 LLVMWithNoNamespaceFix); 1790 verifyFormat("/* something */ inline namespace X {\n" 1791 "class A {};\n" 1792 "void f() { f(); }\n" 1793 "}", 1794 LLVMWithNoNamespaceFix); 1795 verifyFormat("export namespace X {\n" 1796 "class A {};\n" 1797 "void f() { f(); }\n" 1798 "}", 1799 LLVMWithNoNamespaceFix); 1800 verifyFormat("using namespace some_namespace;\n" 1801 "class A {};\n" 1802 "void f() { f(); }", 1803 LLVMWithNoNamespaceFix); 1804 1805 // This code is more common than we thought; if we 1806 // layout this correctly the semicolon will go into 1807 // its own line, which is undesirable. 1808 verifyFormat("namespace {};", 1809 LLVMWithNoNamespaceFix); 1810 verifyFormat("namespace {\n" 1811 "class A {};\n" 1812 "};", 1813 LLVMWithNoNamespaceFix); 1814 1815 verifyFormat("namespace {\n" 1816 "int SomeVariable = 0; // comment\n" 1817 "} // namespace", 1818 LLVMWithNoNamespaceFix); 1819 EXPECT_EQ("#ifndef HEADER_GUARD\n" 1820 "#define HEADER_GUARD\n" 1821 "namespace my_namespace {\n" 1822 "int i;\n" 1823 "} // my_namespace\n" 1824 "#endif // HEADER_GUARD", 1825 format("#ifndef HEADER_GUARD\n" 1826 " #define HEADER_GUARD\n" 1827 " namespace my_namespace {\n" 1828 "int i;\n" 1829 "} // my_namespace\n" 1830 "#endif // HEADER_GUARD", 1831 LLVMWithNoNamespaceFix)); 1832 1833 EXPECT_EQ("namespace A::B {\n" 1834 "class C {};\n" 1835 "}", 1836 format("namespace A::B {\n" 1837 "class C {};\n" 1838 "}", 1839 LLVMWithNoNamespaceFix)); 1840 1841 FormatStyle Style = getLLVMStyle(); 1842 Style.NamespaceIndentation = FormatStyle::NI_All; 1843 EXPECT_EQ("namespace out {\n" 1844 " int i;\n" 1845 " namespace in {\n" 1846 " int i;\n" 1847 " } // namespace in\n" 1848 "} // namespace out", 1849 format("namespace out {\n" 1850 "int i;\n" 1851 "namespace in {\n" 1852 "int i;\n" 1853 "} // namespace in\n" 1854 "} // namespace out", 1855 Style)); 1856 1857 Style.NamespaceIndentation = FormatStyle::NI_Inner; 1858 EXPECT_EQ("namespace out {\n" 1859 "int i;\n" 1860 "namespace in {\n" 1861 " int i;\n" 1862 "} // namespace in\n" 1863 "} // namespace out", 1864 format("namespace out {\n" 1865 "int i;\n" 1866 "namespace in {\n" 1867 "int i;\n" 1868 "} // namespace in\n" 1869 "} // namespace out", 1870 Style)); 1871 } 1872 1873 TEST_F(FormatTest, FormatsCompactNamespaces) { 1874 FormatStyle Style = getLLVMStyle(); 1875 Style.CompactNamespaces = true; 1876 1877 verifyFormat("namespace A { namespace B {\n" 1878 "}} // namespace A::B", 1879 Style); 1880 1881 EXPECT_EQ("namespace out { namespace in {\n" 1882 "}} // namespace out::in", 1883 format("namespace out {\n" 1884 "namespace in {\n" 1885 "} // namespace in\n" 1886 "} // namespace out", 1887 Style)); 1888 1889 // Only namespaces which have both consecutive opening and end get compacted 1890 EXPECT_EQ("namespace out {\n" 1891 "namespace in1 {\n" 1892 "} // namespace in1\n" 1893 "namespace in2 {\n" 1894 "} // namespace in2\n" 1895 "} // namespace out", 1896 format("namespace out {\n" 1897 "namespace in1 {\n" 1898 "} // namespace in1\n" 1899 "namespace in2 {\n" 1900 "} // namespace in2\n" 1901 "} // namespace out", 1902 Style)); 1903 1904 EXPECT_EQ("namespace out {\n" 1905 "int i;\n" 1906 "namespace in {\n" 1907 "int j;\n" 1908 "} // namespace in\n" 1909 "int k;\n" 1910 "} // namespace out", 1911 format("namespace out { int i;\n" 1912 "namespace in { int j; } // namespace in\n" 1913 "int k; } // namespace out", 1914 Style)); 1915 1916 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 1917 "}}} // namespace A::B::C\n", 1918 format("namespace A { namespace B {\n" 1919 "namespace C {\n" 1920 "}} // namespace B::C\n" 1921 "} // namespace A\n", 1922 Style)); 1923 1924 Style.ColumnLimit = 40; 1925 EXPECT_EQ("namespace aaaaaaaaaa {\n" 1926 "namespace bbbbbbbbbb {\n" 1927 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 1928 format("namespace aaaaaaaaaa {\n" 1929 "namespace bbbbbbbbbb {\n" 1930 "} // namespace bbbbbbbbbb\n" 1931 "} // namespace aaaaaaaaaa", 1932 Style)); 1933 1934 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 1935 "namespace cccccc {\n" 1936 "}}} // namespace aaaaaa::bbbbbb::cccccc", 1937 format("namespace aaaaaa {\n" 1938 "namespace bbbbbb {\n" 1939 "namespace cccccc {\n" 1940 "} // namespace cccccc\n" 1941 "} // namespace bbbbbb\n" 1942 "} // namespace aaaaaa", 1943 Style)); 1944 Style.ColumnLimit = 80; 1945 1946 // Extra semicolon after 'inner' closing brace prevents merging 1947 EXPECT_EQ("namespace out { namespace in {\n" 1948 "}; } // namespace out::in", 1949 format("namespace out {\n" 1950 "namespace in {\n" 1951 "}; // namespace in\n" 1952 "} // namespace out", 1953 Style)); 1954 1955 // Extra semicolon after 'outer' closing brace is conserved 1956 EXPECT_EQ("namespace out { namespace in {\n" 1957 "}}; // namespace out::in", 1958 format("namespace out {\n" 1959 "namespace in {\n" 1960 "} // namespace in\n" 1961 "}; // namespace out", 1962 Style)); 1963 1964 Style.NamespaceIndentation = FormatStyle::NI_All; 1965 EXPECT_EQ("namespace out { namespace in {\n" 1966 " int i;\n" 1967 "}} // namespace out::in", 1968 format("namespace out {\n" 1969 "namespace in {\n" 1970 "int i;\n" 1971 "} // namespace in\n" 1972 "} // namespace out", 1973 Style)); 1974 EXPECT_EQ("namespace out { namespace mid {\n" 1975 " namespace in {\n" 1976 " int j;\n" 1977 " } // namespace in\n" 1978 " int k;\n" 1979 "}} // namespace out::mid", 1980 format("namespace out { namespace mid {\n" 1981 "namespace in { int j; } // namespace in\n" 1982 "int k; }} // namespace out::mid", 1983 Style)); 1984 1985 Style.NamespaceIndentation = FormatStyle::NI_Inner; 1986 EXPECT_EQ("namespace out { namespace in {\n" 1987 " int i;\n" 1988 "}} // namespace out::in", 1989 format("namespace out {\n" 1990 "namespace in {\n" 1991 "int i;\n" 1992 "} // namespace in\n" 1993 "} // namespace out", 1994 Style)); 1995 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 1996 " int i;\n" 1997 "}}} // namespace out::mid::in", 1998 format("namespace out {\n" 1999 "namespace mid {\n" 2000 "namespace in {\n" 2001 "int i;\n" 2002 "} // namespace in\n" 2003 "} // namespace mid\n" 2004 "} // namespace out", 2005 Style)); 2006 } 2007 2008 TEST_F(FormatTest, FormatsExternC) { 2009 verifyFormat("extern \"C\" {\nint a;"); 2010 verifyFormat("extern \"C\" {}"); 2011 verifyFormat("extern \"C\" {\n" 2012 "int foo();\n" 2013 "}"); 2014 verifyFormat("extern \"C\" int foo() {}"); 2015 verifyFormat("extern \"C\" int foo();"); 2016 verifyFormat("extern \"C\" int foo() {\n" 2017 " int i = 42;\n" 2018 " return i;\n" 2019 "}"); 2020 2021 FormatStyle Style = getLLVMStyle(); 2022 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2023 Style.BraceWrapping.AfterFunction = true; 2024 verifyFormat("extern \"C\" int foo() {}", Style); 2025 verifyFormat("extern \"C\" int foo();", Style); 2026 verifyFormat("extern \"C\" int foo()\n" 2027 "{\n" 2028 " int i = 42;\n" 2029 " return i;\n" 2030 "}", 2031 Style); 2032 2033 Style.BraceWrapping.AfterExternBlock = true; 2034 Style.BraceWrapping.SplitEmptyRecord = false; 2035 verifyFormat("extern \"C\"\n" 2036 "{}", 2037 Style); 2038 verifyFormat("extern \"C\"\n" 2039 "{\n" 2040 " int foo();\n" 2041 "}", 2042 Style); 2043 } 2044 2045 TEST_F(FormatTest, FormatsInlineASM) { 2046 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2047 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2048 verifyFormat( 2049 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2050 " \"cpuid\\n\\t\"\n" 2051 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2052 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2053 " : \"a\"(value));"); 2054 EXPECT_EQ( 2055 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2056 " __asm {\n" 2057 " mov edx,[that] // vtable in edx\n" 2058 " mov eax,methodIndex\n" 2059 " call [edx][eax*4] // stdcall\n" 2060 " }\n" 2061 "}", 2062 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2063 " __asm {\n" 2064 " mov edx,[that] // vtable in edx\n" 2065 " mov eax,methodIndex\n" 2066 " call [edx][eax*4] // stdcall\n" 2067 " }\n" 2068 "}")); 2069 EXPECT_EQ("_asm {\n" 2070 " xor eax, eax;\n" 2071 " cpuid;\n" 2072 "}", 2073 format("_asm {\n" 2074 " xor eax, eax;\n" 2075 " cpuid;\n" 2076 "}")); 2077 verifyFormat("void function() {\n" 2078 " // comment\n" 2079 " asm(\"\");\n" 2080 "}"); 2081 EXPECT_EQ("__asm {\n" 2082 "}\n" 2083 "int i;", 2084 format("__asm {\n" 2085 "}\n" 2086 "int i;")); 2087 } 2088 2089 TEST_F(FormatTest, FormatTryCatch) { 2090 verifyFormat("try {\n" 2091 " throw a * b;\n" 2092 "} catch (int a) {\n" 2093 " // Do nothing.\n" 2094 "} catch (...) {\n" 2095 " exit(42);\n" 2096 "}"); 2097 2098 // Function-level try statements. 2099 verifyFormat("int f() try { return 4; } catch (...) {\n" 2100 " return 5;\n" 2101 "}"); 2102 verifyFormat("class A {\n" 2103 " int a;\n" 2104 " A() try : a(0) {\n" 2105 " } catch (...) {\n" 2106 " throw;\n" 2107 " }\n" 2108 "};\n"); 2109 2110 // Incomplete try-catch blocks. 2111 verifyIncompleteFormat("try {} catch ("); 2112 } 2113 2114 TEST_F(FormatTest, FormatSEHTryCatch) { 2115 verifyFormat("__try {\n" 2116 " int a = b * c;\n" 2117 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2118 " // Do nothing.\n" 2119 "}"); 2120 2121 verifyFormat("__try {\n" 2122 " int a = b * c;\n" 2123 "} __finally {\n" 2124 " // Do nothing.\n" 2125 "}"); 2126 2127 verifyFormat("DEBUG({\n" 2128 " __try {\n" 2129 " } __finally {\n" 2130 " }\n" 2131 "});\n"); 2132 } 2133 2134 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2135 verifyFormat("try {\n" 2136 " f();\n" 2137 "} catch {\n" 2138 " g();\n" 2139 "}"); 2140 verifyFormat("try {\n" 2141 " f();\n" 2142 "} catch (A a) MACRO(x) {\n" 2143 " g();\n" 2144 "} catch (B b) MACRO(x) {\n" 2145 " g();\n" 2146 "}"); 2147 } 2148 2149 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2150 FormatStyle Style = getLLVMStyle(); 2151 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2152 FormatStyle::BS_WebKit}) { 2153 Style.BreakBeforeBraces = BraceStyle; 2154 verifyFormat("try {\n" 2155 " // something\n" 2156 "} catch (...) {\n" 2157 " // something\n" 2158 "}", 2159 Style); 2160 } 2161 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2162 verifyFormat("try {\n" 2163 " // something\n" 2164 "}\n" 2165 "catch (...) {\n" 2166 " // something\n" 2167 "}", 2168 Style); 2169 verifyFormat("__try {\n" 2170 " // something\n" 2171 "}\n" 2172 "__finally {\n" 2173 " // something\n" 2174 "}", 2175 Style); 2176 verifyFormat("@try {\n" 2177 " // something\n" 2178 "}\n" 2179 "@finally {\n" 2180 " // something\n" 2181 "}", 2182 Style); 2183 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2184 verifyFormat("try\n" 2185 "{\n" 2186 " // something\n" 2187 "}\n" 2188 "catch (...)\n" 2189 "{\n" 2190 " // something\n" 2191 "}", 2192 Style); 2193 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2194 verifyFormat("try\n" 2195 " {\n" 2196 " // something\n" 2197 " }\n" 2198 "catch (...)\n" 2199 " {\n" 2200 " // something\n" 2201 " }", 2202 Style); 2203 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2204 Style.BraceWrapping.BeforeCatch = true; 2205 verifyFormat("try {\n" 2206 " // something\n" 2207 "}\n" 2208 "catch (...) {\n" 2209 " // something\n" 2210 "}", 2211 Style); 2212 } 2213 2214 TEST_F(FormatTest, StaticInitializers) { 2215 verifyFormat("static SomeClass SC = {1, 'a'};"); 2216 2217 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2218 " 100000000, " 2219 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2220 2221 // Here, everything other than the "}" would fit on a line. 2222 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2223 " 10000000000000000000000000};"); 2224 EXPECT_EQ("S s = {a,\n" 2225 "\n" 2226 " b};", 2227 format("S s = {\n" 2228 " a,\n" 2229 "\n" 2230 " b\n" 2231 "};")); 2232 2233 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2234 // line. However, the formatting looks a bit off and this probably doesn't 2235 // happen often in practice. 2236 verifyFormat("static int Variable[1] = {\n" 2237 " {1000000000000000000000000000000000000}};", 2238 getLLVMStyleWithColumns(40)); 2239 } 2240 2241 TEST_F(FormatTest, DesignatedInitializers) { 2242 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2243 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2244 " .bbbbbbbbbb = 2,\n" 2245 " .cccccccccc = 3,\n" 2246 " .dddddddddd = 4,\n" 2247 " .eeeeeeeeee = 5};"); 2248 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2249 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2250 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2251 " .ccccccccccccccccccccccccccc = 3,\n" 2252 " .ddddddddddddddddddddddddddd = 4,\n" 2253 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2254 2255 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2256 2257 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2258 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2259 " [2] = bbbbbbbbbb,\n" 2260 " [3] = cccccccccc,\n" 2261 " [4] = dddddddddd,\n" 2262 " [5] = eeeeeeeeee};"); 2263 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2264 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2265 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2266 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2267 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2268 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2269 } 2270 2271 TEST_F(FormatTest, NestedStaticInitializers) { 2272 verifyFormat("static A x = {{{}}};\n"); 2273 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2274 " {init1, init2, init3, init4}}};", 2275 getLLVMStyleWithColumns(50)); 2276 2277 verifyFormat("somes Status::global_reps[3] = {\n" 2278 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2279 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2280 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2281 getLLVMStyleWithColumns(60)); 2282 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2283 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2284 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2285 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2286 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2287 " {rect.fRight - rect.fLeft, rect.fBottom - " 2288 "rect.fTop}};"); 2289 2290 verifyFormat( 2291 "SomeArrayOfSomeType a = {\n" 2292 " {{1, 2, 3},\n" 2293 " {1, 2, 3},\n" 2294 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2295 " 333333333333333333333333333333},\n" 2296 " {1, 2, 3},\n" 2297 " {1, 2, 3}}};"); 2298 verifyFormat( 2299 "SomeArrayOfSomeType a = {\n" 2300 " {{1, 2, 3}},\n" 2301 " {{1, 2, 3}},\n" 2302 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2303 " 333333333333333333333333333333}},\n" 2304 " {{1, 2, 3}},\n" 2305 " {{1, 2, 3}}};"); 2306 2307 verifyFormat("struct {\n" 2308 " unsigned bit;\n" 2309 " const char *const name;\n" 2310 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2311 " {kOsWin, \"Windows\"},\n" 2312 " {kOsLinux, \"Linux\"},\n" 2313 " {kOsCrOS, \"Chrome OS\"}};"); 2314 verifyFormat("struct {\n" 2315 " unsigned bit;\n" 2316 " const char *const name;\n" 2317 "} kBitsToOs[] = {\n" 2318 " {kOsMac, \"Mac\"},\n" 2319 " {kOsWin, \"Windows\"},\n" 2320 " {kOsLinux, \"Linux\"},\n" 2321 " {kOsCrOS, \"Chrome OS\"},\n" 2322 "};"); 2323 } 2324 2325 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2326 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2327 " \\\n" 2328 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2329 } 2330 2331 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2332 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2333 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2334 2335 // Do break defaulted and deleted functions. 2336 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2337 " default;", 2338 getLLVMStyleWithColumns(40)); 2339 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2340 " delete;", 2341 getLLVMStyleWithColumns(40)); 2342 } 2343 2344 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2345 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2346 getLLVMStyleWithColumns(40)); 2347 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2348 getLLVMStyleWithColumns(40)); 2349 EXPECT_EQ("#define Q \\\n" 2350 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2351 " \"aaaaaaaa.cpp\"", 2352 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2353 getLLVMStyleWithColumns(40))); 2354 } 2355 2356 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2357 EXPECT_EQ("# 123 \"A string literal\"", 2358 format(" # 123 \"A string literal\"")); 2359 } 2360 2361 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2362 EXPECT_EQ("#;", format("#;")); 2363 verifyFormat("#\n;\n;\n;"); 2364 } 2365 2366 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2367 EXPECT_EQ("#line 42 \"test\"\n", 2368 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2369 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2370 getLLVMStyleWithColumns(12))); 2371 } 2372 2373 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2374 EXPECT_EQ("#line 42 \"test\"", 2375 format("# \\\n line \\\n 42 \\\n \"test\"")); 2376 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2377 } 2378 2379 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2380 verifyFormat("#define A \\x20"); 2381 verifyFormat("#define A \\ x20"); 2382 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2383 verifyFormat("#define A ''"); 2384 verifyFormat("#define A ''qqq"); 2385 verifyFormat("#define A `qqq"); 2386 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2387 EXPECT_EQ("const char *c = STRINGIFY(\n" 2388 "\\na : b);", 2389 format("const char * c = STRINGIFY(\n" 2390 "\\na : b);")); 2391 2392 verifyFormat("a\r\\"); 2393 verifyFormat("a\v\\"); 2394 verifyFormat("a\f\\"); 2395 } 2396 2397 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2398 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2399 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2400 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2401 // FIXME: We never break before the macro name. 2402 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2403 2404 verifyFormat("#define A A\n#define A A"); 2405 verifyFormat("#define A(X) A\n#define A A"); 2406 2407 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2408 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2409 } 2410 2411 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2412 EXPECT_EQ("// somecomment\n" 2413 "#include \"a.h\"\n" 2414 "#define A( \\\n" 2415 " A, B)\n" 2416 "#include \"b.h\"\n" 2417 "// somecomment\n", 2418 format(" // somecomment\n" 2419 " #include \"a.h\"\n" 2420 "#define A(A,\\\n" 2421 " B)\n" 2422 " #include \"b.h\"\n" 2423 " // somecomment\n", 2424 getLLVMStyleWithColumns(13))); 2425 } 2426 2427 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2428 2429 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2430 EXPECT_EQ("#define A \\\n" 2431 " c; \\\n" 2432 " e;\n" 2433 "f;", 2434 format("#define A c; e;\n" 2435 "f;", 2436 getLLVMStyleWithColumns(14))); 2437 } 2438 2439 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2440 2441 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2442 EXPECT_EQ("int x,\n" 2443 "#define A\n" 2444 " y;", 2445 format("int x,\n#define A\ny;")); 2446 } 2447 2448 TEST_F(FormatTest, HashInMacroDefinition) { 2449 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2450 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2451 verifyFormat("#define A \\\n" 2452 " { \\\n" 2453 " f(#c); \\\n" 2454 " }", 2455 getLLVMStyleWithColumns(11)); 2456 2457 verifyFormat("#define A(X) \\\n" 2458 " void function##X()", 2459 getLLVMStyleWithColumns(22)); 2460 2461 verifyFormat("#define A(a, b, c) \\\n" 2462 " void a##b##c()", 2463 getLLVMStyleWithColumns(22)); 2464 2465 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2466 } 2467 2468 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2469 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2470 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2471 2472 FormatStyle Style = getLLVMStyle(); 2473 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 2474 verifyFormat("#define true ((foo)1)", Style); 2475 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 2476 verifyFormat("#define false((foo)0)", Style); 2477 } 2478 2479 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2480 EXPECT_EQ("#define A b;", format("#define A \\\n" 2481 " \\\n" 2482 " b;", 2483 getLLVMStyleWithColumns(25))); 2484 EXPECT_EQ("#define A \\\n" 2485 " \\\n" 2486 " a; \\\n" 2487 " b;", 2488 format("#define A \\\n" 2489 " \\\n" 2490 " a; \\\n" 2491 " b;", 2492 getLLVMStyleWithColumns(11))); 2493 EXPECT_EQ("#define A \\\n" 2494 " a; \\\n" 2495 " \\\n" 2496 " b;", 2497 format("#define A \\\n" 2498 " a; \\\n" 2499 " \\\n" 2500 " b;", 2501 getLLVMStyleWithColumns(11))); 2502 } 2503 2504 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 2505 verifyIncompleteFormat("#define A :"); 2506 verifyFormat("#define SOMECASES \\\n" 2507 " case 1: \\\n" 2508 " case 2\n", 2509 getLLVMStyleWithColumns(20)); 2510 verifyFormat("#define MACRO(a) \\\n" 2511 " if (a) \\\n" 2512 " f(); \\\n" 2513 " else \\\n" 2514 " g()", 2515 getLLVMStyleWithColumns(18)); 2516 verifyFormat("#define A template <typename T>"); 2517 verifyIncompleteFormat("#define STR(x) #x\n" 2518 "f(STR(this_is_a_string_literal{));"); 2519 verifyFormat("#pragma omp threadprivate( \\\n" 2520 " y)), // expected-warning", 2521 getLLVMStyleWithColumns(28)); 2522 verifyFormat("#d, = };"); 2523 verifyFormat("#if \"a"); 2524 verifyIncompleteFormat("({\n" 2525 "#define b \\\n" 2526 " } \\\n" 2527 " a\n" 2528 "a", 2529 getLLVMStyleWithColumns(15)); 2530 verifyFormat("#define A \\\n" 2531 " { \\\n" 2532 " {\n" 2533 "#define B \\\n" 2534 " } \\\n" 2535 " }", 2536 getLLVMStyleWithColumns(15)); 2537 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 2538 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 2539 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 2540 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 2541 } 2542 2543 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 2544 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 2545 EXPECT_EQ("class A : public QObject {\n" 2546 " Q_OBJECT\n" 2547 "\n" 2548 " A() {}\n" 2549 "};", 2550 format("class A : public QObject {\n" 2551 " Q_OBJECT\n" 2552 "\n" 2553 " A() {\n}\n" 2554 "} ;")); 2555 EXPECT_EQ("MACRO\n" 2556 "/*static*/ int i;", 2557 format("MACRO\n" 2558 " /*static*/ int i;")); 2559 EXPECT_EQ("SOME_MACRO\n" 2560 "namespace {\n" 2561 "void f();\n" 2562 "} // namespace", 2563 format("SOME_MACRO\n" 2564 " namespace {\n" 2565 "void f( );\n" 2566 "} // namespace")); 2567 // Only if the identifier contains at least 5 characters. 2568 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 2569 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 2570 // Only if everything is upper case. 2571 EXPECT_EQ("class A : public QObject {\n" 2572 " Q_Object A() {}\n" 2573 "};", 2574 format("class A : public QObject {\n" 2575 " Q_Object\n" 2576 " A() {\n}\n" 2577 "} ;")); 2578 2579 // Only if the next line can actually start an unwrapped line. 2580 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 2581 format("SOME_WEIRD_LOG_MACRO\n" 2582 "<< SomeThing;")); 2583 2584 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 2585 "(n, buffers))\n", 2586 getChromiumStyle(FormatStyle::LK_Cpp)); 2587 2588 // See PR41483 2589 EXPECT_EQ("/**/ FOO(a)\n" 2590 "FOO(b)", 2591 format("/**/ FOO(a)\n" 2592 "FOO(b)")); 2593 } 2594 2595 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 2596 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2597 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2598 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2599 "class X {};\n" 2600 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2601 "int *createScopDetectionPass() { return 0; }", 2602 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2603 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2604 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2605 " class X {};\n" 2606 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2607 " int *createScopDetectionPass() { return 0; }")); 2608 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 2609 // braces, so that inner block is indented one level more. 2610 EXPECT_EQ("int q() {\n" 2611 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2612 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2613 " IPC_END_MESSAGE_MAP()\n" 2614 "}", 2615 format("int q() {\n" 2616 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2617 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2618 " IPC_END_MESSAGE_MAP()\n" 2619 "}")); 2620 2621 // Same inside macros. 2622 EXPECT_EQ("#define LIST(L) \\\n" 2623 " L(A) \\\n" 2624 " L(B) \\\n" 2625 " L(C)", 2626 format("#define LIST(L) \\\n" 2627 " L(A) \\\n" 2628 " L(B) \\\n" 2629 " L(C)", 2630 getGoogleStyle())); 2631 2632 // These must not be recognized as macros. 2633 EXPECT_EQ("int q() {\n" 2634 " f(x);\n" 2635 " f(x) {}\n" 2636 " f(x)->g();\n" 2637 " f(x)->*g();\n" 2638 " f(x).g();\n" 2639 " f(x) = x;\n" 2640 " f(x) += x;\n" 2641 " f(x) -= x;\n" 2642 " f(x) *= x;\n" 2643 " f(x) /= x;\n" 2644 " f(x) %= x;\n" 2645 " f(x) &= x;\n" 2646 " f(x) |= x;\n" 2647 " f(x) ^= x;\n" 2648 " f(x) >>= x;\n" 2649 " f(x) <<= x;\n" 2650 " f(x)[y].z();\n" 2651 " LOG(INFO) << x;\n" 2652 " ifstream(x) >> x;\n" 2653 "}\n", 2654 format("int q() {\n" 2655 " f(x)\n;\n" 2656 " f(x)\n {}\n" 2657 " f(x)\n->g();\n" 2658 " f(x)\n->*g();\n" 2659 " f(x)\n.g();\n" 2660 " f(x)\n = x;\n" 2661 " f(x)\n += x;\n" 2662 " f(x)\n -= x;\n" 2663 " f(x)\n *= x;\n" 2664 " f(x)\n /= x;\n" 2665 " f(x)\n %= x;\n" 2666 " f(x)\n &= x;\n" 2667 " f(x)\n |= x;\n" 2668 " f(x)\n ^= x;\n" 2669 " f(x)\n >>= x;\n" 2670 " f(x)\n <<= x;\n" 2671 " f(x)\n[y].z();\n" 2672 " LOG(INFO)\n << x;\n" 2673 " ifstream(x)\n >> x;\n" 2674 "}\n")); 2675 EXPECT_EQ("int q() {\n" 2676 " F(x)\n" 2677 " if (1) {\n" 2678 " }\n" 2679 " F(x)\n" 2680 " while (1) {\n" 2681 " }\n" 2682 " F(x)\n" 2683 " G(x);\n" 2684 " F(x)\n" 2685 " try {\n" 2686 " Q();\n" 2687 " } catch (...) {\n" 2688 " }\n" 2689 "}\n", 2690 format("int q() {\n" 2691 "F(x)\n" 2692 "if (1) {}\n" 2693 "F(x)\n" 2694 "while (1) {}\n" 2695 "F(x)\n" 2696 "G(x);\n" 2697 "F(x)\n" 2698 "try { Q(); } catch (...) {}\n" 2699 "}\n")); 2700 EXPECT_EQ("class A {\n" 2701 " A() : t(0) {}\n" 2702 " A(int i) noexcept() : {}\n" 2703 " A(X x)\n" // FIXME: function-level try blocks are broken. 2704 " try : t(0) {\n" 2705 " } catch (...) {\n" 2706 " }\n" 2707 "};", 2708 format("class A {\n" 2709 " A()\n : t(0) {}\n" 2710 " A(int i)\n noexcept() : {}\n" 2711 " A(X x)\n" 2712 " try : t(0) {} catch (...) {}\n" 2713 "};")); 2714 FormatStyle Style = getLLVMStyle(); 2715 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2716 Style.BraceWrapping.AfterControlStatement = true; 2717 Style.BraceWrapping.AfterFunction = true; 2718 EXPECT_EQ("void f()\n" 2719 "try\n" 2720 "{\n" 2721 "}", 2722 format("void f() try {\n" 2723 "}", Style)); 2724 EXPECT_EQ("class SomeClass {\n" 2725 "public:\n" 2726 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2727 "};", 2728 format("class SomeClass {\n" 2729 "public:\n" 2730 " SomeClass()\n" 2731 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2732 "};")); 2733 EXPECT_EQ("class SomeClass {\n" 2734 "public:\n" 2735 " SomeClass()\n" 2736 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2737 "};", 2738 format("class SomeClass {\n" 2739 "public:\n" 2740 " SomeClass()\n" 2741 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2742 "};", 2743 getLLVMStyleWithColumns(40))); 2744 2745 verifyFormat("MACRO(>)"); 2746 2747 // Some macros contain an implicit semicolon. 2748 Style = getLLVMStyle(); 2749 Style.StatementMacros.push_back("FOO"); 2750 verifyFormat("FOO(a) int b = 0;"); 2751 verifyFormat("FOO(a)\n" 2752 "int b = 0;", 2753 Style); 2754 verifyFormat("FOO(a);\n" 2755 "int b = 0;", 2756 Style); 2757 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 2758 "int b = 0;", 2759 Style); 2760 verifyFormat("FOO()\n" 2761 "int b = 0;", 2762 Style); 2763 verifyFormat("FOO\n" 2764 "int b = 0;", 2765 Style); 2766 verifyFormat("void f() {\n" 2767 " FOO(a)\n" 2768 " return a;\n" 2769 "}", 2770 Style); 2771 verifyFormat("FOO(a)\n" 2772 "FOO(b)", 2773 Style); 2774 verifyFormat("int a = 0;\n" 2775 "FOO(b)\n" 2776 "int c = 0;", 2777 Style); 2778 verifyFormat("int a = 0;\n" 2779 "int x = FOO(a)\n" 2780 "int b = 0;", 2781 Style); 2782 verifyFormat("void foo(int a) { FOO(a) }\n" 2783 "uint32_t bar() {}", 2784 Style); 2785 } 2786 2787 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 2788 verifyFormat("#define A \\\n" 2789 " f({ \\\n" 2790 " g(); \\\n" 2791 " });", 2792 getLLVMStyleWithColumns(11)); 2793 } 2794 2795 TEST_F(FormatTest, IndentPreprocessorDirectives) { 2796 FormatStyle Style = getLLVMStyle(); 2797 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 2798 Style.ColumnLimit = 40; 2799 verifyFormat("#ifdef _WIN32\n" 2800 "#define A 0\n" 2801 "#ifdef VAR2\n" 2802 "#define B 1\n" 2803 "#include <someheader.h>\n" 2804 "#define MACRO \\\n" 2805 " some_very_long_func_aaaaaaaaaa();\n" 2806 "#endif\n" 2807 "#else\n" 2808 "#define A 1\n" 2809 "#endif", 2810 Style); 2811 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 2812 verifyFormat("#ifdef _WIN32\n" 2813 "# define A 0\n" 2814 "# ifdef VAR2\n" 2815 "# define B 1\n" 2816 "# include <someheader.h>\n" 2817 "# define MACRO \\\n" 2818 " some_very_long_func_aaaaaaaaaa();\n" 2819 "# endif\n" 2820 "#else\n" 2821 "# define A 1\n" 2822 "#endif", 2823 Style); 2824 verifyFormat("#if A\n" 2825 "# define MACRO \\\n" 2826 " void a(int x) { \\\n" 2827 " b(); \\\n" 2828 " c(); \\\n" 2829 " d(); \\\n" 2830 " e(); \\\n" 2831 " f(); \\\n" 2832 " }\n" 2833 "#endif", 2834 Style); 2835 // Comments before include guard. 2836 verifyFormat("// file comment\n" 2837 "// file comment\n" 2838 "#ifndef HEADER_H\n" 2839 "#define HEADER_H\n" 2840 "code();\n" 2841 "#endif", 2842 Style); 2843 // Test with include guards. 2844 verifyFormat("#ifndef HEADER_H\n" 2845 "#define HEADER_H\n" 2846 "code();\n" 2847 "#endif", 2848 Style); 2849 // Include guards must have a #define with the same variable immediately 2850 // after #ifndef. 2851 verifyFormat("#ifndef NOT_GUARD\n" 2852 "# define FOO\n" 2853 "code();\n" 2854 "#endif", 2855 Style); 2856 2857 // Include guards must cover the entire file. 2858 verifyFormat("code();\n" 2859 "code();\n" 2860 "#ifndef NOT_GUARD\n" 2861 "# define NOT_GUARD\n" 2862 "code();\n" 2863 "#endif", 2864 Style); 2865 verifyFormat("#ifndef NOT_GUARD\n" 2866 "# define NOT_GUARD\n" 2867 "code();\n" 2868 "#endif\n" 2869 "code();", 2870 Style); 2871 // Test with trailing blank lines. 2872 verifyFormat("#ifndef HEADER_H\n" 2873 "#define HEADER_H\n" 2874 "code();\n" 2875 "#endif\n", 2876 Style); 2877 // Include guards don't have #else. 2878 verifyFormat("#ifndef NOT_GUARD\n" 2879 "# define NOT_GUARD\n" 2880 "code();\n" 2881 "#else\n" 2882 "#endif", 2883 Style); 2884 verifyFormat("#ifndef NOT_GUARD\n" 2885 "# define NOT_GUARD\n" 2886 "code();\n" 2887 "#elif FOO\n" 2888 "#endif", 2889 Style); 2890 // Non-identifier #define after potential include guard. 2891 verifyFormat("#ifndef FOO\n" 2892 "# define 1\n" 2893 "#endif\n", 2894 Style); 2895 // #if closes past last non-preprocessor line. 2896 verifyFormat("#ifndef FOO\n" 2897 "#define FOO\n" 2898 "#if 1\n" 2899 "int i;\n" 2900 "# define A 0\n" 2901 "#endif\n" 2902 "#endif\n", 2903 Style); 2904 // FIXME: This doesn't handle the case where there's code between the 2905 // #ifndef and #define but all other conditions hold. This is because when 2906 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 2907 // previous code line yet, so we can't detect it. 2908 EXPECT_EQ("#ifndef NOT_GUARD\n" 2909 "code();\n" 2910 "#define NOT_GUARD\n" 2911 "code();\n" 2912 "#endif", 2913 format("#ifndef NOT_GUARD\n" 2914 "code();\n" 2915 "# define NOT_GUARD\n" 2916 "code();\n" 2917 "#endif", 2918 Style)); 2919 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 2920 // be outside an include guard. Examples are #pragma once and 2921 // #pragma GCC diagnostic, or anything else that does not change the meaning 2922 // of the file if it's included multiple times. 2923 EXPECT_EQ("#ifdef WIN32\n" 2924 "# pragma once\n" 2925 "#endif\n" 2926 "#ifndef HEADER_H\n" 2927 "# define HEADER_H\n" 2928 "code();\n" 2929 "#endif", 2930 format("#ifdef WIN32\n" 2931 "# pragma once\n" 2932 "#endif\n" 2933 "#ifndef HEADER_H\n" 2934 "#define HEADER_H\n" 2935 "code();\n" 2936 "#endif", 2937 Style)); 2938 // FIXME: This does not detect when there is a single non-preprocessor line 2939 // in front of an include-guard-like structure where other conditions hold 2940 // because ScopedLineState hides the line. 2941 EXPECT_EQ("code();\n" 2942 "#ifndef HEADER_H\n" 2943 "#define HEADER_H\n" 2944 "code();\n" 2945 "#endif", 2946 format("code();\n" 2947 "#ifndef HEADER_H\n" 2948 "# define HEADER_H\n" 2949 "code();\n" 2950 "#endif", 2951 Style)); 2952 // Keep comments aligned with #, otherwise indent comments normally. These 2953 // tests cannot use verifyFormat because messUp manipulates leading 2954 // whitespace. 2955 { 2956 const char *Expected = "" 2957 "void f() {\n" 2958 "#if 1\n" 2959 "// Preprocessor aligned.\n" 2960 "# define A 0\n" 2961 " // Code. Separated by blank line.\n" 2962 "\n" 2963 "# define B 0\n" 2964 " // Code. Not aligned with #\n" 2965 "# define C 0\n" 2966 "#endif"; 2967 const char *ToFormat = "" 2968 "void f() {\n" 2969 "#if 1\n" 2970 "// Preprocessor aligned.\n" 2971 "# define A 0\n" 2972 "// Code. Separated by blank line.\n" 2973 "\n" 2974 "# define B 0\n" 2975 " // Code. Not aligned with #\n" 2976 "# define C 0\n" 2977 "#endif"; 2978 EXPECT_EQ(Expected, format(ToFormat, Style)); 2979 EXPECT_EQ(Expected, format(Expected, Style)); 2980 } 2981 // Keep block quotes aligned. 2982 { 2983 const char *Expected = "" 2984 "void f() {\n" 2985 "#if 1\n" 2986 "/* Preprocessor aligned. */\n" 2987 "# define A 0\n" 2988 " /* Code. Separated by blank line. */\n" 2989 "\n" 2990 "# define B 0\n" 2991 " /* Code. Not aligned with # */\n" 2992 "# define C 0\n" 2993 "#endif"; 2994 const char *ToFormat = "" 2995 "void f() {\n" 2996 "#if 1\n" 2997 "/* Preprocessor aligned. */\n" 2998 "# define A 0\n" 2999 "/* Code. Separated by blank line. */\n" 3000 "\n" 3001 "# define B 0\n" 3002 " /* Code. Not aligned with # */\n" 3003 "# define C 0\n" 3004 "#endif"; 3005 EXPECT_EQ(Expected, format(ToFormat, Style)); 3006 EXPECT_EQ(Expected, format(Expected, Style)); 3007 } 3008 // Keep comments aligned with un-indented directives. 3009 { 3010 const char *Expected = "" 3011 "void f() {\n" 3012 "// Preprocessor aligned.\n" 3013 "#define A 0\n" 3014 " // Code. Separated by blank line.\n" 3015 "\n" 3016 "#define B 0\n" 3017 " // Code. Not aligned with #\n" 3018 "#define C 0\n"; 3019 const char *ToFormat = "" 3020 "void f() {\n" 3021 "// Preprocessor aligned.\n" 3022 "#define A 0\n" 3023 "// Code. Separated by blank line.\n" 3024 "\n" 3025 "#define B 0\n" 3026 " // Code. Not aligned with #\n" 3027 "#define C 0\n"; 3028 EXPECT_EQ(Expected, format(ToFormat, Style)); 3029 EXPECT_EQ(Expected, format(Expected, Style)); 3030 } 3031 // Test AfterHash with tabs. 3032 { 3033 FormatStyle Tabbed = Style; 3034 Tabbed.UseTab = FormatStyle::UT_Always; 3035 Tabbed.IndentWidth = 8; 3036 Tabbed.TabWidth = 8; 3037 verifyFormat("#ifdef _WIN32\n" 3038 "#\tdefine A 0\n" 3039 "#\tifdef VAR2\n" 3040 "#\t\tdefine B 1\n" 3041 "#\t\tinclude <someheader.h>\n" 3042 "#\t\tdefine MACRO \\\n" 3043 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3044 "#\tendif\n" 3045 "#else\n" 3046 "#\tdefine A 1\n" 3047 "#endif", 3048 Tabbed); 3049 } 3050 3051 // Regression test: Multiline-macro inside include guards. 3052 verifyFormat("#ifndef HEADER_H\n" 3053 "#define HEADER_H\n" 3054 "#define A() \\\n" 3055 " int i; \\\n" 3056 " int j;\n" 3057 "#endif // HEADER_H", 3058 getLLVMStyleWithColumns(20)); 3059 3060 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3061 // Basic before hash indent tests 3062 verifyFormat("#ifdef _WIN32\n" 3063 " #define A 0\n" 3064 " #ifdef VAR2\n" 3065 " #define B 1\n" 3066 " #include <someheader.h>\n" 3067 " #define MACRO \\\n" 3068 " some_very_long_func_aaaaaaaaaa();\n" 3069 " #endif\n" 3070 "#else\n" 3071 " #define A 1\n" 3072 "#endif", 3073 Style); 3074 verifyFormat("#if A\n" 3075 " #define MACRO \\\n" 3076 " void a(int x) { \\\n" 3077 " b(); \\\n" 3078 " c(); \\\n" 3079 " d(); \\\n" 3080 " e(); \\\n" 3081 " f(); \\\n" 3082 " }\n" 3083 "#endif", 3084 Style); 3085 // Keep comments aligned with indented directives. These 3086 // tests cannot use verifyFormat because messUp manipulates leading 3087 // whitespace. 3088 { 3089 const char *Expected = "void f() {\n" 3090 "// Aligned to preprocessor.\n" 3091 "#if 1\n" 3092 " // Aligned to code.\n" 3093 " int a;\n" 3094 " #if 1\n" 3095 " // Aligned to preprocessor.\n" 3096 " #define A 0\n" 3097 " // Aligned to code.\n" 3098 " int b;\n" 3099 " #endif\n" 3100 "#endif\n" 3101 "}"; 3102 const char *ToFormat = "void f() {\n" 3103 "// Aligned to preprocessor.\n" 3104 "#if 1\n" 3105 "// Aligned to code.\n" 3106 "int a;\n" 3107 "#if 1\n" 3108 "// Aligned to preprocessor.\n" 3109 "#define A 0\n" 3110 "// Aligned to code.\n" 3111 "int b;\n" 3112 "#endif\n" 3113 "#endif\n" 3114 "}"; 3115 EXPECT_EQ(Expected, format(ToFormat, Style)); 3116 EXPECT_EQ(Expected, format(Expected, Style)); 3117 } 3118 { 3119 const char *Expected = "void f() {\n" 3120 "/* Aligned to preprocessor. */\n" 3121 "#if 1\n" 3122 " /* Aligned to code. */\n" 3123 " int a;\n" 3124 " #if 1\n" 3125 " /* Aligned to preprocessor. */\n" 3126 " #define A 0\n" 3127 " /* Aligned to code. */\n" 3128 " int b;\n" 3129 " #endif\n" 3130 "#endif\n" 3131 "}"; 3132 const char *ToFormat = "void f() {\n" 3133 "/* Aligned to preprocessor. */\n" 3134 "#if 1\n" 3135 "/* Aligned to code. */\n" 3136 "int a;\n" 3137 "#if 1\n" 3138 "/* Aligned to preprocessor. */\n" 3139 "#define A 0\n" 3140 "/* Aligned to code. */\n" 3141 "int b;\n" 3142 "#endif\n" 3143 "#endif\n" 3144 "}"; 3145 EXPECT_EQ(Expected, format(ToFormat, Style)); 3146 EXPECT_EQ(Expected, format(Expected, Style)); 3147 } 3148 3149 // Test single comment before preprocessor 3150 verifyFormat("// Comment\n" 3151 "\n" 3152 "#if 1\n" 3153 "#endif", 3154 Style); 3155 } 3156 3157 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3158 verifyFormat("{\n { a #c; }\n}"); 3159 } 3160 3161 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3162 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3163 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3164 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3165 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3166 } 3167 3168 TEST_F(FormatTest, EscapedNewlines) { 3169 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3170 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3171 format("#define A \\\nint i;\\\n int j;", Narrow)); 3172 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3173 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3174 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3175 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3176 3177 FormatStyle AlignLeft = getLLVMStyle(); 3178 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3179 EXPECT_EQ("#define MACRO(x) \\\n" 3180 "private: \\\n" 3181 " int x(int a);\n", 3182 format("#define MACRO(x) \\\n" 3183 "private: \\\n" 3184 " int x(int a);\n", 3185 AlignLeft)); 3186 3187 // CRLF line endings 3188 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3189 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3190 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3191 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3192 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3193 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3194 EXPECT_EQ("#define MACRO(x) \\\r\n" 3195 "private: \\\r\n" 3196 " int x(int a);\r\n", 3197 format("#define MACRO(x) \\\r\n" 3198 "private: \\\r\n" 3199 " int x(int a);\r\n", 3200 AlignLeft)); 3201 3202 FormatStyle DontAlign = getLLVMStyle(); 3203 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3204 DontAlign.MaxEmptyLinesToKeep = 3; 3205 // FIXME: can't use verifyFormat here because the newline before 3206 // "public:" is not inserted the first time it's reformatted 3207 EXPECT_EQ("#define A \\\n" 3208 " class Foo { \\\n" 3209 " void bar(); \\\n" 3210 "\\\n" 3211 "\\\n" 3212 "\\\n" 3213 " public: \\\n" 3214 " void baz(); \\\n" 3215 " };", 3216 format("#define A \\\n" 3217 " class Foo { \\\n" 3218 " void bar(); \\\n" 3219 "\\\n" 3220 "\\\n" 3221 "\\\n" 3222 " public: \\\n" 3223 " void baz(); \\\n" 3224 " };", 3225 DontAlign)); 3226 } 3227 3228 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3229 verifyFormat("#define A \\\n" 3230 " int v( \\\n" 3231 " a); \\\n" 3232 " int i;", 3233 getLLVMStyleWithColumns(11)); 3234 } 3235 3236 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3237 EXPECT_EQ( 3238 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3239 " \\\n" 3240 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3241 "\n" 3242 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3243 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3244 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3245 "\\\n" 3246 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3247 " \n" 3248 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3249 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3250 } 3251 3252 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3253 EXPECT_EQ("int\n" 3254 "#define A\n" 3255 " a;", 3256 format("int\n#define A\na;")); 3257 verifyFormat("functionCallTo(\n" 3258 " someOtherFunction(\n" 3259 " withSomeParameters, whichInSequence,\n" 3260 " areLongerThanALine(andAnotherCall,\n" 3261 "#define A B\n" 3262 " withMoreParamters,\n" 3263 " whichStronglyInfluenceTheLayout),\n" 3264 " andMoreParameters),\n" 3265 " trailing);", 3266 getLLVMStyleWithColumns(69)); 3267 verifyFormat("Foo::Foo()\n" 3268 "#ifdef BAR\n" 3269 " : baz(0)\n" 3270 "#endif\n" 3271 "{\n" 3272 "}"); 3273 verifyFormat("void f() {\n" 3274 " if (true)\n" 3275 "#ifdef A\n" 3276 " f(42);\n" 3277 " x();\n" 3278 "#else\n" 3279 " g();\n" 3280 " x();\n" 3281 "#endif\n" 3282 "}"); 3283 verifyFormat("void f(param1, param2,\n" 3284 " param3,\n" 3285 "#ifdef A\n" 3286 " param4(param5,\n" 3287 "#ifdef A1\n" 3288 " param6,\n" 3289 "#ifdef A2\n" 3290 " param7),\n" 3291 "#else\n" 3292 " param8),\n" 3293 " param9,\n" 3294 "#endif\n" 3295 " param10,\n" 3296 "#endif\n" 3297 " param11)\n" 3298 "#else\n" 3299 " param12)\n" 3300 "#endif\n" 3301 "{\n" 3302 " x();\n" 3303 "}", 3304 getLLVMStyleWithColumns(28)); 3305 verifyFormat("#if 1\n" 3306 "int i;"); 3307 verifyFormat("#if 1\n" 3308 "#endif\n" 3309 "#if 1\n" 3310 "#else\n" 3311 "#endif\n"); 3312 verifyFormat("DEBUG({\n" 3313 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3314 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3315 "});\n" 3316 "#if a\n" 3317 "#else\n" 3318 "#endif"); 3319 3320 verifyIncompleteFormat("void f(\n" 3321 "#if A\n" 3322 ");\n" 3323 "#else\n" 3324 "#endif"); 3325 } 3326 3327 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3328 verifyFormat("#endif\n" 3329 "#if B"); 3330 } 3331 3332 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3333 FormatStyle SingleLine = getLLVMStyle(); 3334 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3335 verifyFormat("#if 0\n" 3336 "#elif 1\n" 3337 "#endif\n" 3338 "void foo() {\n" 3339 " if (test) foo2();\n" 3340 "}", 3341 SingleLine); 3342 } 3343 3344 TEST_F(FormatTest, LayoutBlockInsideParens) { 3345 verifyFormat("functionCall({ int i; });"); 3346 verifyFormat("functionCall({\n" 3347 " int i;\n" 3348 " int j;\n" 3349 "});"); 3350 verifyFormat("functionCall(\n" 3351 " {\n" 3352 " int i;\n" 3353 " int j;\n" 3354 " },\n" 3355 " aaaa, bbbb, cccc);"); 3356 verifyFormat("functionA(functionB({\n" 3357 " int i;\n" 3358 " int j;\n" 3359 " }),\n" 3360 " aaaa, bbbb, cccc);"); 3361 verifyFormat("functionCall(\n" 3362 " {\n" 3363 " int i;\n" 3364 " int j;\n" 3365 " },\n" 3366 " aaaa, bbbb, // comment\n" 3367 " cccc);"); 3368 verifyFormat("functionA(functionB({\n" 3369 " int i;\n" 3370 " int j;\n" 3371 " }),\n" 3372 " aaaa, bbbb, // comment\n" 3373 " cccc);"); 3374 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3375 verifyFormat("functionCall(aaaa, bbbb, {\n" 3376 " int i;\n" 3377 " int j;\n" 3378 "});"); 3379 verifyFormat( 3380 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3381 " {\n" 3382 " int i; // break\n" 3383 " },\n" 3384 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3385 " ccccccccccccccccc));"); 3386 verifyFormat("DEBUG({\n" 3387 " if (a)\n" 3388 " f();\n" 3389 "});"); 3390 } 3391 3392 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3393 EXPECT_EQ("SOME_MACRO { int i; }\n" 3394 "int i;", 3395 format(" SOME_MACRO {int i;} int i;")); 3396 } 3397 3398 TEST_F(FormatTest, LayoutNestedBlocks) { 3399 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3400 " struct s {\n" 3401 " int i;\n" 3402 " };\n" 3403 " s kBitsToOs[] = {{10}};\n" 3404 " for (int i = 0; i < 10; ++i)\n" 3405 " return;\n" 3406 "}"); 3407 verifyFormat("call(parameter, {\n" 3408 " something();\n" 3409 " // Comment using all columns.\n" 3410 " somethingelse();\n" 3411 "});", 3412 getLLVMStyleWithColumns(40)); 3413 verifyFormat("DEBUG( //\n" 3414 " { f(); }, a);"); 3415 verifyFormat("DEBUG( //\n" 3416 " {\n" 3417 " f(); //\n" 3418 " },\n" 3419 " a);"); 3420 3421 EXPECT_EQ("call(parameter, {\n" 3422 " something();\n" 3423 " // Comment too\n" 3424 " // looooooooooong.\n" 3425 " somethingElse();\n" 3426 "});", 3427 format("call(parameter, {\n" 3428 " something();\n" 3429 " // Comment too looooooooooong.\n" 3430 " somethingElse();\n" 3431 "});", 3432 getLLVMStyleWithColumns(29))); 3433 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3434 EXPECT_EQ("DEBUG({ // comment\n" 3435 " int i;\n" 3436 "});", 3437 format("DEBUG({ // comment\n" 3438 "int i;\n" 3439 "});")); 3440 EXPECT_EQ("DEBUG({\n" 3441 " int i;\n" 3442 "\n" 3443 " // comment\n" 3444 " int j;\n" 3445 "});", 3446 format("DEBUG({\n" 3447 " int i;\n" 3448 "\n" 3449 " // comment\n" 3450 " int j;\n" 3451 "});")); 3452 3453 verifyFormat("DEBUG({\n" 3454 " if (a)\n" 3455 " return;\n" 3456 "});"); 3457 verifyGoogleFormat("DEBUG({\n" 3458 " if (a) return;\n" 3459 "});"); 3460 FormatStyle Style = getGoogleStyle(); 3461 Style.ColumnLimit = 45; 3462 verifyFormat("Debug(\n" 3463 " aaaaa,\n" 3464 " {\n" 3465 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 3466 " },\n" 3467 " a);", 3468 Style); 3469 3470 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 3471 3472 verifyNoCrash("^{v^{a}}"); 3473 } 3474 3475 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 3476 EXPECT_EQ("#define MACRO() \\\n" 3477 " Debug(aaa, /* force line break */ \\\n" 3478 " { \\\n" 3479 " int i; \\\n" 3480 " int j; \\\n" 3481 " })", 3482 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 3483 " { int i; int j; })", 3484 getGoogleStyle())); 3485 3486 EXPECT_EQ("#define A \\\n" 3487 " [] { \\\n" 3488 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3489 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 3490 " }", 3491 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3492 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 3493 getGoogleStyle())); 3494 } 3495 3496 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 3497 EXPECT_EQ("{}", format("{}")); 3498 verifyFormat("enum E {};"); 3499 verifyFormat("enum E {}"); 3500 } 3501 3502 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 3503 FormatStyle Style = getLLVMStyle(); 3504 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 3505 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 3506 verifyFormat("FOO_BEGIN\n" 3507 " FOO_ENTRY\n" 3508 "FOO_END", Style); 3509 verifyFormat("FOO_BEGIN\n" 3510 " NESTED_FOO_BEGIN\n" 3511 " NESTED_FOO_ENTRY\n" 3512 " NESTED_FOO_END\n" 3513 "FOO_END", Style); 3514 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 3515 " int x;\n" 3516 " x = 1;\n" 3517 "FOO_END(Baz)", Style); 3518 } 3519 3520 //===----------------------------------------------------------------------===// 3521 // Line break tests. 3522 //===----------------------------------------------------------------------===// 3523 3524 TEST_F(FormatTest, PreventConfusingIndents) { 3525 verifyFormat( 3526 "void f() {\n" 3527 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 3528 " parameter, parameter, parameter)),\n" 3529 " SecondLongCall(parameter));\n" 3530 "}"); 3531 verifyFormat( 3532 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3533 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3534 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3535 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 3536 verifyFormat( 3537 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3538 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 3539 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 3540 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 3541 verifyFormat( 3542 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 3543 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 3544 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 3545 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 3546 verifyFormat("int a = bbbb && ccc &&\n" 3547 " fffff(\n" 3548 "#define A Just forcing a new line\n" 3549 " ddd);"); 3550 } 3551 3552 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 3553 verifyFormat( 3554 "bool aaaaaaa =\n" 3555 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 3556 " bbbbbbbb();"); 3557 verifyFormat( 3558 "bool aaaaaaa =\n" 3559 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 3560 " bbbbbbbb();"); 3561 3562 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3563 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 3564 " ccccccccc == ddddddddddd;"); 3565 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3566 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 3567 " ccccccccc == ddddddddddd;"); 3568 verifyFormat( 3569 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 3570 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 3571 " ccccccccc == ddddddddddd;"); 3572 3573 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3574 " aaaaaa) &&\n" 3575 " bbbbbb && cccccc;"); 3576 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3577 " aaaaaa) >>\n" 3578 " bbbbbb;"); 3579 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 3580 " SourceMgr.getSpellingColumnNumber(\n" 3581 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 3582 " 1);"); 3583 3584 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3585 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 3586 " cccccc) {\n}"); 3587 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3588 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3589 " cccccc) {\n}"); 3590 verifyFormat("b = a &&\n" 3591 " // Comment\n" 3592 " b.c && d;"); 3593 3594 // If the LHS of a comparison is not a binary expression itself, the 3595 // additional linebreak confuses many people. 3596 verifyFormat( 3597 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3598 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 3599 "}"); 3600 verifyFormat( 3601 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3602 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3603 "}"); 3604 verifyFormat( 3605 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 3606 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3607 "}"); 3608 verifyFormat( 3609 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3610 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 3611 "}"); 3612 // Even explicit parentheses stress the precedence enough to make the 3613 // additional break unnecessary. 3614 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3615 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3616 "}"); 3617 // This cases is borderline, but with the indentation it is still readable. 3618 verifyFormat( 3619 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3620 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3621 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 3622 "}", 3623 getLLVMStyleWithColumns(75)); 3624 3625 // If the LHS is a binary expression, we should still use the additional break 3626 // as otherwise the formatting hides the operator precedence. 3627 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3628 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3629 " 5) {\n" 3630 "}"); 3631 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3632 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 3633 " 5) {\n" 3634 "}"); 3635 3636 FormatStyle OnePerLine = getLLVMStyle(); 3637 OnePerLine.BinPackParameters = false; 3638 verifyFormat( 3639 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3640 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3641 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 3642 OnePerLine); 3643 3644 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 3645 " .aaa(aaaaaaaaaaaaa) *\n" 3646 " aaaaaaa +\n" 3647 " aaaaaaa;", 3648 getLLVMStyleWithColumns(40)); 3649 } 3650 3651 TEST_F(FormatTest, ExpressionIndentation) { 3652 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3653 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3654 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3655 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3656 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 3657 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 3658 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3659 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 3660 " ccccccccccccccccccccccccccccccccccccccccc;"); 3661 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3662 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3663 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3664 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3665 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3666 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3667 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3668 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3669 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3670 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3671 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3672 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3673 verifyFormat("if () {\n" 3674 "} else if (aaaaa && bbbbb > // break\n" 3675 " ccccc) {\n" 3676 "}"); 3677 verifyFormat("if () {\n" 3678 "} else if (aaaaa &&\n" 3679 " bbbbb > // break\n" 3680 " ccccc &&\n" 3681 " ddddd) {\n" 3682 "}"); 3683 3684 // Presence of a trailing comment used to change indentation of b. 3685 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 3686 " b;\n" 3687 "return aaaaaaaaaaaaaaaaaaa +\n" 3688 " b; //", 3689 getLLVMStyleWithColumns(30)); 3690 } 3691 3692 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 3693 // Not sure what the best system is here. Like this, the LHS can be found 3694 // immediately above an operator (everything with the same or a higher 3695 // indent). The RHS is aligned right of the operator and so compasses 3696 // everything until something with the same indent as the operator is found. 3697 // FIXME: Is this a good system? 3698 FormatStyle Style = getLLVMStyle(); 3699 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 3700 verifyFormat( 3701 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3702 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3703 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3704 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3705 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3706 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3707 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3708 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3709 " > ccccccccccccccccccccccccccccccccccccccccc;", 3710 Style); 3711 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3712 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3713 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3714 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3715 Style); 3716 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3717 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3718 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3719 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3720 Style); 3721 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3722 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3723 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3724 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3725 Style); 3726 verifyFormat("if () {\n" 3727 "} else if (aaaaa\n" 3728 " && bbbbb // break\n" 3729 " > ccccc) {\n" 3730 "}", 3731 Style); 3732 verifyFormat("return (a)\n" 3733 " // comment\n" 3734 " + b;", 3735 Style); 3736 verifyFormat( 3737 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3738 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3739 " + cc;", 3740 Style); 3741 3742 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3743 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 3744 Style); 3745 3746 // Forced by comments. 3747 verifyFormat( 3748 "unsigned ContentSize =\n" 3749 " sizeof(int16_t) // DWARF ARange version number\n" 3750 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 3751 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 3752 " + sizeof(int8_t); // Segment Size (in bytes)"); 3753 3754 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 3755 " == boost::fusion::at_c<1>(iiii).second;", 3756 Style); 3757 3758 Style.ColumnLimit = 60; 3759 verifyFormat("zzzzzzzzzz\n" 3760 " = bbbbbbbbbbbbbbbbb\n" 3761 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 3762 Style); 3763 3764 Style.ColumnLimit = 80; 3765 Style.IndentWidth = 4; 3766 Style.TabWidth = 4; 3767 Style.UseTab = FormatStyle::UT_Always; 3768 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 3769 Style.AlignOperands = false; 3770 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 3771 "\t&& (someOtherLongishConditionPart1\n" 3772 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 3773 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && (someOtherLongishConditionPart1 || someOtherEvenLongerNestedConditionPart2);", 3774 Style)); 3775 } 3776 3777 TEST_F(FormatTest, EnforcedOperatorWraps) { 3778 // Here we'd like to wrap after the || operators, but a comment is forcing an 3779 // earlier wrap. 3780 verifyFormat("bool x = aaaaa //\n" 3781 " || bbbbb\n" 3782 " //\n" 3783 " || cccc;"); 3784 } 3785 3786 TEST_F(FormatTest, NoOperandAlignment) { 3787 FormatStyle Style = getLLVMStyle(); 3788 Style.AlignOperands = false; 3789 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 3790 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3791 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 3792 Style); 3793 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 3794 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3795 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3796 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3797 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3798 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3799 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3800 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3801 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3802 " > ccccccccccccccccccccccccccccccccccccccccc;", 3803 Style); 3804 3805 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3806 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3807 " + cc;", 3808 Style); 3809 verifyFormat("int a = aa\n" 3810 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3811 " * cccccccccccccccccccccccccccccccccccc;\n", 3812 Style); 3813 3814 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 3815 verifyFormat("return (a > b\n" 3816 " // comment1\n" 3817 " // comment2\n" 3818 " || c);", 3819 Style); 3820 } 3821 3822 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 3823 FormatStyle Style = getLLVMStyle(); 3824 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 3825 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 3826 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3827 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 3828 Style); 3829 } 3830 3831 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 3832 FormatStyle Style = getLLVMStyle(); 3833 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 3834 Style.BinPackArguments = false; 3835 Style.ColumnLimit = 40; 3836 verifyFormat("void test() {\n" 3837 " someFunction(\n" 3838 " this + argument + is + quite\n" 3839 " + long + so + it + gets + wrapped\n" 3840 " + but + remains + bin - packed);\n" 3841 "}", 3842 Style); 3843 verifyFormat("void test() {\n" 3844 " someFunction(arg1,\n" 3845 " this + argument + is\n" 3846 " + quite + long + so\n" 3847 " + it + gets + wrapped\n" 3848 " + but + remains + bin\n" 3849 " - packed,\n" 3850 " arg3);\n" 3851 "}", 3852 Style); 3853 verifyFormat("void test() {\n" 3854 " someFunction(\n" 3855 " arg1,\n" 3856 " this + argument + has\n" 3857 " + anotherFunc(nested,\n" 3858 " calls + whose\n" 3859 " + arguments\n" 3860 " + are + also\n" 3861 " + wrapped,\n" 3862 " in + addition)\n" 3863 " + to + being + bin - packed,\n" 3864 " arg3);\n" 3865 "}", 3866 Style); 3867 3868 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 3869 verifyFormat("void test() {\n" 3870 " someFunction(\n" 3871 " arg1,\n" 3872 " this + argument + has +\n" 3873 " anotherFunc(nested,\n" 3874 " calls + whose +\n" 3875 " arguments +\n" 3876 " are + also +\n" 3877 " wrapped,\n" 3878 " in + addition) +\n" 3879 " to + being + bin - packed,\n" 3880 " arg3);\n" 3881 "}", 3882 Style); 3883 } 3884 3885 TEST_F(FormatTest, ConstructorInitializers) { 3886 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 3887 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 3888 getLLVMStyleWithColumns(45)); 3889 verifyFormat("Constructor()\n" 3890 " : Inttializer(FitsOnTheLine) {}", 3891 getLLVMStyleWithColumns(44)); 3892 verifyFormat("Constructor()\n" 3893 " : Inttializer(FitsOnTheLine) {}", 3894 getLLVMStyleWithColumns(43)); 3895 3896 verifyFormat("template <typename T>\n" 3897 "Constructor() : Initializer(FitsOnTheLine) {}", 3898 getLLVMStyleWithColumns(45)); 3899 3900 verifyFormat( 3901 "SomeClass::Constructor()\n" 3902 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 3903 3904 verifyFormat( 3905 "SomeClass::Constructor()\n" 3906 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 3907 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 3908 verifyFormat( 3909 "SomeClass::Constructor()\n" 3910 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3911 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 3912 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3913 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3914 " : aaaaaaaaaa(aaaaaa) {}"); 3915 3916 verifyFormat("Constructor()\n" 3917 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3918 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3919 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3920 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 3921 3922 verifyFormat("Constructor()\n" 3923 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3924 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 3925 3926 verifyFormat("Constructor(int Parameter = 0)\n" 3927 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 3928 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 3929 verifyFormat("Constructor()\n" 3930 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 3931 "}", 3932 getLLVMStyleWithColumns(60)); 3933 verifyFormat("Constructor()\n" 3934 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3935 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 3936 3937 // Here a line could be saved by splitting the second initializer onto two 3938 // lines, but that is not desirable. 3939 verifyFormat("Constructor()\n" 3940 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 3941 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 3942 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 3943 3944 FormatStyle OnePerLine = getLLVMStyle(); 3945 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 3946 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 3947 verifyFormat("SomeClass::Constructor()\n" 3948 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 3949 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 3950 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 3951 OnePerLine); 3952 verifyFormat("SomeClass::Constructor()\n" 3953 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 3954 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 3955 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 3956 OnePerLine); 3957 verifyFormat("MyClass::MyClass(int var)\n" 3958 " : some_var_(var), // 4 space indent\n" 3959 " some_other_var_(var + 1) { // lined up\n" 3960 "}", 3961 OnePerLine); 3962 verifyFormat("Constructor()\n" 3963 " : aaaaa(aaaaaa),\n" 3964 " aaaaa(aaaaaa),\n" 3965 " aaaaa(aaaaaa),\n" 3966 " aaaaa(aaaaaa),\n" 3967 " aaaaa(aaaaaa) {}", 3968 OnePerLine); 3969 verifyFormat("Constructor()\n" 3970 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 3971 " aaaaaaaaaaaaaaaaaaaaaa) {}", 3972 OnePerLine); 3973 OnePerLine.BinPackParameters = false; 3974 verifyFormat( 3975 "Constructor()\n" 3976 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3977 " aaaaaaaaaaa().aaa(),\n" 3978 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 3979 OnePerLine); 3980 OnePerLine.ColumnLimit = 60; 3981 verifyFormat("Constructor()\n" 3982 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 3983 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 3984 OnePerLine); 3985 3986 EXPECT_EQ("Constructor()\n" 3987 " : // Comment forcing unwanted break.\n" 3988 " aaaa(aaaa) {}", 3989 format("Constructor() :\n" 3990 " // Comment forcing unwanted break.\n" 3991 " aaaa(aaaa) {}")); 3992 } 3993 3994 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 3995 FormatStyle Style = getLLVMStyle(); 3996 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 3997 Style.ColumnLimit = 60; 3998 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 3999 Style.AllowAllConstructorInitializersOnNextLine = true; 4000 Style.BinPackParameters = false; 4001 4002 for (int i = 0; i < 4; ++i) { 4003 // Test all combinations of parameters that should not have an effect. 4004 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4005 Style.AllowAllArgumentsOnNextLine = i & 2; 4006 4007 Style.AllowAllConstructorInitializersOnNextLine = true; 4008 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4009 verifyFormat("Constructor()\n" 4010 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4011 Style); 4012 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4013 4014 Style.AllowAllConstructorInitializersOnNextLine = false; 4015 verifyFormat("Constructor()\n" 4016 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4017 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4018 Style); 4019 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4020 4021 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4022 Style.AllowAllConstructorInitializersOnNextLine = true; 4023 verifyFormat("Constructor()\n" 4024 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4025 Style); 4026 4027 Style.AllowAllConstructorInitializersOnNextLine = false; 4028 verifyFormat("Constructor()\n" 4029 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4030 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4031 Style); 4032 4033 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4034 Style.AllowAllConstructorInitializersOnNextLine = true; 4035 verifyFormat("Constructor() :\n" 4036 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4037 Style); 4038 4039 Style.AllowAllConstructorInitializersOnNextLine = false; 4040 verifyFormat("Constructor() :\n" 4041 " aaaaaaaaaaaaaaaaaa(a),\n" 4042 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4043 Style); 4044 } 4045 4046 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4047 // AllowAllConstructorInitializersOnNextLine in all 4048 // BreakConstructorInitializers modes 4049 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4050 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4051 Style.AllowAllConstructorInitializersOnNextLine = false; 4052 verifyFormat("SomeClassWithALongName::Constructor(\n" 4053 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4054 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4055 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4056 Style); 4057 4058 Style.AllowAllConstructorInitializersOnNextLine = true; 4059 verifyFormat("SomeClassWithALongName::Constructor(\n" 4060 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4061 " int bbbbbbbbbbbbb,\n" 4062 " int cccccccccccccccc)\n" 4063 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4064 Style); 4065 4066 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4067 Style.AllowAllConstructorInitializersOnNextLine = false; 4068 verifyFormat("SomeClassWithALongName::Constructor(\n" 4069 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4070 " int bbbbbbbbbbbbb)\n" 4071 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4072 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4073 Style); 4074 4075 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4076 4077 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4078 verifyFormat("SomeClassWithALongName::Constructor(\n" 4079 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4080 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4081 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4082 Style); 4083 4084 Style.AllowAllConstructorInitializersOnNextLine = true; 4085 verifyFormat("SomeClassWithALongName::Constructor(\n" 4086 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4087 " int bbbbbbbbbbbbb,\n" 4088 " int cccccccccccccccc)\n" 4089 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4090 Style); 4091 4092 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4093 Style.AllowAllConstructorInitializersOnNextLine = false; 4094 verifyFormat("SomeClassWithALongName::Constructor(\n" 4095 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4096 " int bbbbbbbbbbbbb)\n" 4097 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4098 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4099 Style); 4100 4101 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4102 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4103 verifyFormat("SomeClassWithALongName::Constructor(\n" 4104 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4105 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4106 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4107 Style); 4108 4109 Style.AllowAllConstructorInitializersOnNextLine = true; 4110 verifyFormat("SomeClassWithALongName::Constructor(\n" 4111 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4112 " int bbbbbbbbbbbbb,\n" 4113 " int cccccccccccccccc) :\n" 4114 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4115 Style); 4116 4117 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4118 Style.AllowAllConstructorInitializersOnNextLine = false; 4119 verifyFormat("SomeClassWithALongName::Constructor(\n" 4120 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4121 " int bbbbbbbbbbbbb) :\n" 4122 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4123 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4124 Style); 4125 } 4126 4127 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4128 FormatStyle Style = getLLVMStyle(); 4129 Style.ColumnLimit = 60; 4130 Style.BinPackArguments = false; 4131 for (int i = 0; i < 4; ++i) { 4132 // Test all combinations of parameters that should not have an effect. 4133 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4134 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4135 4136 Style.AllowAllArgumentsOnNextLine = true; 4137 verifyFormat("void foo() {\n" 4138 " FunctionCallWithReallyLongName(\n" 4139 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4140 "}", 4141 Style); 4142 Style.AllowAllArgumentsOnNextLine = false; 4143 verifyFormat("void foo() {\n" 4144 " FunctionCallWithReallyLongName(\n" 4145 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4146 " bbbbbbbbbbbb);\n" 4147 "}", 4148 Style); 4149 4150 Style.AllowAllArgumentsOnNextLine = true; 4151 verifyFormat("void foo() {\n" 4152 " auto VariableWithReallyLongName = {\n" 4153 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4154 "}", 4155 Style); 4156 Style.AllowAllArgumentsOnNextLine = false; 4157 verifyFormat("void foo() {\n" 4158 " auto VariableWithReallyLongName = {\n" 4159 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4160 " bbbbbbbbbbbb};\n" 4161 "}", 4162 Style); 4163 } 4164 4165 // This parameter should not affect declarations. 4166 Style.BinPackParameters = false; 4167 Style.AllowAllArgumentsOnNextLine = false; 4168 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4169 verifyFormat("void FunctionCallWithReallyLongName(\n" 4170 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4171 Style); 4172 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4173 verifyFormat("void FunctionCallWithReallyLongName(\n" 4174 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4175 " int bbbbbbbbbbbb);", 4176 Style); 4177 } 4178 4179 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4180 FormatStyle Style = getLLVMStyle(); 4181 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4182 4183 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4184 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4185 getStyleWithColumns(Style, 45)); 4186 verifyFormat("Constructor() :\n" 4187 " Initializer(FitsOnTheLine) {}", 4188 getStyleWithColumns(Style, 44)); 4189 verifyFormat("Constructor() :\n" 4190 " Initializer(FitsOnTheLine) {}", 4191 getStyleWithColumns(Style, 43)); 4192 4193 verifyFormat("template <typename T>\n" 4194 "Constructor() : Initializer(FitsOnTheLine) {}", 4195 getStyleWithColumns(Style, 50)); 4196 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4197 verifyFormat( 4198 "SomeClass::Constructor() :\n" 4199 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4200 Style); 4201 4202 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4203 verifyFormat( 4204 "SomeClass::Constructor() :\n" 4205 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4206 Style); 4207 4208 verifyFormat( 4209 "SomeClass::Constructor() :\n" 4210 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4211 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4212 Style); 4213 verifyFormat( 4214 "SomeClass::Constructor() :\n" 4215 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4216 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4217 Style); 4218 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4219 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4220 " aaaaaaaaaa(aaaaaa) {}", 4221 Style); 4222 4223 verifyFormat("Constructor() :\n" 4224 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4225 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4226 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4227 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4228 Style); 4229 4230 verifyFormat("Constructor() :\n" 4231 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4232 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4233 Style); 4234 4235 verifyFormat("Constructor(int Parameter = 0) :\n" 4236 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4237 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4238 Style); 4239 verifyFormat("Constructor() :\n" 4240 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4241 "}", 4242 getStyleWithColumns(Style, 60)); 4243 verifyFormat("Constructor() :\n" 4244 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4245 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4246 Style); 4247 4248 // Here a line could be saved by splitting the second initializer onto two 4249 // lines, but that is not desirable. 4250 verifyFormat("Constructor() :\n" 4251 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4252 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4253 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4254 Style); 4255 4256 FormatStyle OnePerLine = Style; 4257 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4258 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4259 verifyFormat("SomeClass::Constructor() :\n" 4260 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4261 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4262 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4263 OnePerLine); 4264 verifyFormat("SomeClass::Constructor() :\n" 4265 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4266 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4267 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4268 OnePerLine); 4269 verifyFormat("MyClass::MyClass(int var) :\n" 4270 " some_var_(var), // 4 space indent\n" 4271 " some_other_var_(var + 1) { // lined up\n" 4272 "}", 4273 OnePerLine); 4274 verifyFormat("Constructor() :\n" 4275 " aaaaa(aaaaaa),\n" 4276 " aaaaa(aaaaaa),\n" 4277 " aaaaa(aaaaaa),\n" 4278 " aaaaa(aaaaaa),\n" 4279 " aaaaa(aaaaaa) {}", 4280 OnePerLine); 4281 verifyFormat("Constructor() :\n" 4282 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4283 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4284 OnePerLine); 4285 OnePerLine.BinPackParameters = false; 4286 verifyFormat( 4287 "Constructor() :\n" 4288 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4289 " aaaaaaaaaaa().aaa(),\n" 4290 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4291 OnePerLine); 4292 OnePerLine.ColumnLimit = 60; 4293 verifyFormat("Constructor() :\n" 4294 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4295 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4296 OnePerLine); 4297 4298 EXPECT_EQ("Constructor() :\n" 4299 " // Comment forcing unwanted break.\n" 4300 " aaaa(aaaa) {}", 4301 format("Constructor() :\n" 4302 " // Comment forcing unwanted break.\n" 4303 " aaaa(aaaa) {}", 4304 Style)); 4305 4306 Style.ColumnLimit = 0; 4307 verifyFormat("SomeClass::Constructor() :\n" 4308 " a(a) {}", 4309 Style); 4310 verifyFormat("SomeClass::Constructor() noexcept :\n" 4311 " a(a) {}", 4312 Style); 4313 verifyFormat("SomeClass::Constructor() :\n" 4314 " a(a), b(b), c(c) {}", 4315 Style); 4316 verifyFormat("SomeClass::Constructor() :\n" 4317 " a(a) {\n" 4318 " foo();\n" 4319 " bar();\n" 4320 "}", 4321 Style); 4322 4323 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4324 verifyFormat("SomeClass::Constructor() :\n" 4325 " a(a), b(b), c(c) {\n" 4326 "}", 4327 Style); 4328 verifyFormat("SomeClass::Constructor() :\n" 4329 " a(a) {\n" 4330 "}", 4331 Style); 4332 4333 Style.ColumnLimit = 80; 4334 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4335 Style.ConstructorInitializerIndentWidth = 2; 4336 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", 4337 Style); 4338 verifyFormat("SomeClass::Constructor() :\n" 4339 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4340 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 4341 Style); 4342 4343 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as well 4344 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 4345 verifyFormat("class SomeClass\n" 4346 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4347 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4348 Style); 4349 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 4350 verifyFormat("class SomeClass\n" 4351 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4352 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4353 Style); 4354 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 4355 verifyFormat("class SomeClass :\n" 4356 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4357 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4358 Style); 4359 } 4360 4361 #ifndef EXPENSIVE_CHECKS 4362 // Expensive checks enables libstdc++ checking which includes validating the 4363 // state of ranges used in std::priority_queue - this blows out the 4364 // runtime/scalability of the function and makes this test unacceptably slow. 4365 TEST_F(FormatTest, MemoizationTests) { 4366 // This breaks if the memoization lookup does not take \c Indent and 4367 // \c LastSpace into account. 4368 verifyFormat( 4369 "extern CFRunLoopTimerRef\n" 4370 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 4371 " CFTimeInterval interval, CFOptionFlags flags,\n" 4372 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 4373 " CFRunLoopTimerContext *context) {}"); 4374 4375 // Deep nesting somewhat works around our memoization. 4376 verifyFormat( 4377 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4378 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4379 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4380 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4381 " aaaaa())))))))))))))))))))))))))))))))))))))));", 4382 getLLVMStyleWithColumns(65)); 4383 verifyFormat( 4384 "aaaaa(\n" 4385 " aaaaa,\n" 4386 " aaaaa(\n" 4387 " aaaaa,\n" 4388 " aaaaa(\n" 4389 " aaaaa,\n" 4390 " aaaaa(\n" 4391 " aaaaa,\n" 4392 " aaaaa(\n" 4393 " aaaaa,\n" 4394 " aaaaa(\n" 4395 " aaaaa,\n" 4396 " aaaaa(\n" 4397 " aaaaa,\n" 4398 " aaaaa(\n" 4399 " aaaaa,\n" 4400 " aaaaa(\n" 4401 " aaaaa,\n" 4402 " aaaaa(\n" 4403 " aaaaa,\n" 4404 " aaaaa(\n" 4405 " aaaaa,\n" 4406 " aaaaa(\n" 4407 " aaaaa,\n" 4408 " aaaaa))))))))))));", 4409 getLLVMStyleWithColumns(65)); 4410 verifyFormat( 4411 "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" 4412 " a),\n" 4413 " a),\n" 4414 " a),\n" 4415 " a),\n" 4416 " a),\n" 4417 " a),\n" 4418 " a),\n" 4419 " a),\n" 4420 " a),\n" 4421 " a),\n" 4422 " a),\n" 4423 " a),\n" 4424 " a),\n" 4425 " a),\n" 4426 " a),\n" 4427 " a),\n" 4428 " a)", 4429 getLLVMStyleWithColumns(65)); 4430 4431 // This test takes VERY long when memoization is broken. 4432 FormatStyle OnePerLine = getLLVMStyle(); 4433 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4434 OnePerLine.BinPackParameters = false; 4435 std::string input = "Constructor()\n" 4436 " : aaaa(a,\n"; 4437 for (unsigned i = 0, e = 80; i != e; ++i) { 4438 input += " a,\n"; 4439 } 4440 input += " a) {}"; 4441 verifyFormat(input, OnePerLine); 4442 } 4443 #endif 4444 4445 TEST_F(FormatTest, BreaksAsHighAsPossible) { 4446 verifyFormat( 4447 "void f() {\n" 4448 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 4449 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 4450 " f();\n" 4451 "}"); 4452 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 4453 " Intervals[i - 1].getRange().getLast()) {\n}"); 4454 } 4455 4456 TEST_F(FormatTest, BreaksFunctionDeclarations) { 4457 // Principially, we break function declarations in a certain order: 4458 // 1) break amongst arguments. 4459 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 4460 " Cccccccccccccc cccccccccccccc);"); 4461 verifyFormat("template <class TemplateIt>\n" 4462 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 4463 " TemplateIt *stop) {}"); 4464 4465 // 2) break after return type. 4466 verifyFormat( 4467 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4468 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 4469 getGoogleStyle()); 4470 4471 // 3) break after (. 4472 verifyFormat( 4473 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 4474 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 4475 getGoogleStyle()); 4476 4477 // 4) break before after nested name specifiers. 4478 verifyFormat( 4479 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4480 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 4481 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 4482 getGoogleStyle()); 4483 4484 // However, there are exceptions, if a sufficient amount of lines can be 4485 // saved. 4486 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 4487 // more adjusting. 4488 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4489 " Cccccccccccccc cccccccccc,\n" 4490 " Cccccccccccccc cccccccccc,\n" 4491 " Cccccccccccccc cccccccccc,\n" 4492 " Cccccccccccccc cccccccccc);"); 4493 verifyFormat( 4494 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4495 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4496 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4497 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 4498 getGoogleStyle()); 4499 verifyFormat( 4500 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4501 " Cccccccccccccc cccccccccc,\n" 4502 " Cccccccccccccc cccccccccc,\n" 4503 " Cccccccccccccc cccccccccc,\n" 4504 " Cccccccccccccc cccccccccc,\n" 4505 " Cccccccccccccc cccccccccc,\n" 4506 " Cccccccccccccc cccccccccc);"); 4507 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4508 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4509 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4510 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4511 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 4512 4513 // Break after multi-line parameters. 4514 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4515 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4516 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4517 " bbbb bbbb);"); 4518 verifyFormat("void SomeLoooooooooooongFunction(\n" 4519 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 4520 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4521 " int bbbbbbbbbbbbb);"); 4522 4523 // Treat overloaded operators like other functions. 4524 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4525 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 4526 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4527 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 4528 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4529 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 4530 verifyGoogleFormat( 4531 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 4532 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4533 verifyGoogleFormat( 4534 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 4535 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4536 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4537 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4538 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 4539 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4540 verifyGoogleFormat( 4541 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 4542 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4543 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 4544 verifyGoogleFormat( 4545 "template <typename T>\n" 4546 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4547 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 4548 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 4549 4550 FormatStyle Style = getLLVMStyle(); 4551 Style.PointerAlignment = FormatStyle::PAS_Left; 4552 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4553 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 4554 Style); 4555 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 4556 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4557 Style); 4558 } 4559 4560 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 4561 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 4562 // Prefer keeping `::` followed by `operator` together. 4563 EXPECT_EQ("const aaaa::bbbbbbb &\n" 4564 "ccccccccc::operator++() {\n" 4565 " stuff();\n" 4566 "}", 4567 format("const aaaa::bbbbbbb\n" 4568 "&ccccccccc::operator++() { stuff(); }", 4569 getLLVMStyleWithColumns(40))); 4570 } 4571 4572 TEST_F(FormatTest, TrailingReturnType) { 4573 verifyFormat("auto foo() -> int;\n"); 4574 verifyFormat("struct S {\n" 4575 " auto bar() const -> int;\n" 4576 "};"); 4577 verifyFormat("template <size_t Order, typename T>\n" 4578 "auto load_img(const std::string &filename)\n" 4579 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 4580 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 4581 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 4582 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 4583 verifyFormat("template <typename T>\n" 4584 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 4585 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 4586 4587 // Not trailing return types. 4588 verifyFormat("void f() { auto a = b->c(); }"); 4589 } 4590 4591 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 4592 // Avoid breaking before trailing 'const' or other trailing annotations, if 4593 // they are not function-like. 4594 FormatStyle Style = getGoogleStyle(); 4595 Style.ColumnLimit = 47; 4596 verifyFormat("void someLongFunction(\n" 4597 " int someLoooooooooooooongParameter) const {\n}", 4598 getLLVMStyleWithColumns(47)); 4599 verifyFormat("LoooooongReturnType\n" 4600 "someLoooooooongFunction() const {}", 4601 getLLVMStyleWithColumns(47)); 4602 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 4603 " const {}", 4604 Style); 4605 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4606 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 4607 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4608 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 4609 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4610 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 4611 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 4612 " aaaaaaaaaaa aaaaa) const override;"); 4613 verifyGoogleFormat( 4614 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4615 " const override;"); 4616 4617 // Even if the first parameter has to be wrapped. 4618 verifyFormat("void someLongFunction(\n" 4619 " int someLongParameter) const {}", 4620 getLLVMStyleWithColumns(46)); 4621 verifyFormat("void someLongFunction(\n" 4622 " int someLongParameter) const {}", 4623 Style); 4624 verifyFormat("void someLongFunction(\n" 4625 " int someLongParameter) override {}", 4626 Style); 4627 verifyFormat("void someLongFunction(\n" 4628 " int someLongParameter) OVERRIDE {}", 4629 Style); 4630 verifyFormat("void someLongFunction(\n" 4631 " int someLongParameter) final {}", 4632 Style); 4633 verifyFormat("void someLongFunction(\n" 4634 " int someLongParameter) FINAL {}", 4635 Style); 4636 verifyFormat("void someLongFunction(\n" 4637 " int parameter) const override {}", 4638 Style); 4639 4640 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 4641 verifyFormat("void someLongFunction(\n" 4642 " int someLongParameter) const\n" 4643 "{\n" 4644 "}", 4645 Style); 4646 4647 // Unless these are unknown annotations. 4648 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 4649 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4650 " LONG_AND_UGLY_ANNOTATION;"); 4651 4652 // Breaking before function-like trailing annotations is fine to keep them 4653 // close to their arguments. 4654 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4655 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 4656 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 4657 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 4658 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 4659 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 4660 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 4661 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 4662 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 4663 4664 verifyFormat( 4665 "void aaaaaaaaaaaaaaaaaa()\n" 4666 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 4667 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 4668 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4669 " __attribute__((unused));"); 4670 verifyGoogleFormat( 4671 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4672 " GUARDED_BY(aaaaaaaaaaaa);"); 4673 verifyGoogleFormat( 4674 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4675 " GUARDED_BY(aaaaaaaaaaaa);"); 4676 verifyGoogleFormat( 4677 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 4678 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4679 verifyGoogleFormat( 4680 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 4681 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 4682 } 4683 4684 TEST_F(FormatTest, FunctionAnnotations) { 4685 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4686 "int OldFunction(const string ¶meter) {}"); 4687 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4688 "string OldFunction(const string ¶meter) {}"); 4689 verifyFormat("template <typename T>\n" 4690 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4691 "string OldFunction(const string ¶meter) {}"); 4692 4693 // Not function annotations. 4694 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4695 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 4696 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 4697 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 4698 verifyFormat("MACRO(abc).function() // wrap\n" 4699 " << abc;"); 4700 verifyFormat("MACRO(abc)->function() // wrap\n" 4701 " << abc;"); 4702 verifyFormat("MACRO(abc)::function() // wrap\n" 4703 " << abc;"); 4704 } 4705 4706 TEST_F(FormatTest, BreaksDesireably) { 4707 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 4708 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 4709 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 4710 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4711 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 4712 "}"); 4713 4714 verifyFormat( 4715 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4716 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4717 4718 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4719 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4720 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4721 4722 verifyFormat( 4723 "aaaaaaaa(aaaaaaaaaaaaa,\n" 4724 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4725 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 4726 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4727 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 4728 4729 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4730 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4731 4732 verifyFormat( 4733 "void f() {\n" 4734 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 4735 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 4736 "}"); 4737 verifyFormat( 4738 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4739 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4740 verifyFormat( 4741 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4742 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4743 verifyFormat( 4744 "aaaaaa(aaa,\n" 4745 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4746 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4747 " aaaa);"); 4748 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4749 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4750 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4751 4752 // Indent consistently independent of call expression and unary operator. 4753 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4754 " dddddddddddddddddddddddddddddd));"); 4755 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4756 " dddddddddddddddddddddddddddddd));"); 4757 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 4758 " dddddddddddddddddddddddddddddd));"); 4759 4760 // This test case breaks on an incorrect memoization, i.e. an optimization not 4761 // taking into account the StopAt value. 4762 verifyFormat( 4763 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 4764 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 4765 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 4766 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4767 4768 verifyFormat("{\n {\n {\n" 4769 " Annotation.SpaceRequiredBefore =\n" 4770 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 4771 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 4772 " }\n }\n}"); 4773 4774 // Break on an outer level if there was a break on an inner level. 4775 EXPECT_EQ("f(g(h(a, // comment\n" 4776 " b, c),\n" 4777 " d, e),\n" 4778 " x, y);", 4779 format("f(g(h(a, // comment\n" 4780 " b, c), d, e), x, y);")); 4781 4782 // Prefer breaking similar line breaks. 4783 verifyFormat( 4784 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 4785 " NSTrackingMouseEnteredAndExited |\n" 4786 " NSTrackingActiveAlways;"); 4787 } 4788 4789 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 4790 FormatStyle NoBinPacking = getGoogleStyle(); 4791 NoBinPacking.BinPackParameters = false; 4792 NoBinPacking.BinPackArguments = true; 4793 verifyFormat("void f() {\n" 4794 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 4795 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 4796 "}", 4797 NoBinPacking); 4798 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 4799 " int aaaaaaaaaaaaaaaaaaaa,\n" 4800 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4801 NoBinPacking); 4802 4803 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 4804 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4805 " vector<int> bbbbbbbbbbbbbbb);", 4806 NoBinPacking); 4807 // FIXME: This behavior difference is probably not wanted. However, currently 4808 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 4809 // template arguments from BreakBeforeParameter being set because of the 4810 // one-per-line formatting. 4811 verifyFormat( 4812 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 4813 " aaaaaaaaaa> aaaaaaaaaa);", 4814 NoBinPacking); 4815 verifyFormat( 4816 "void fffffffffff(\n" 4817 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 4818 " aaaaaaaaaa);"); 4819 } 4820 4821 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 4822 FormatStyle NoBinPacking = getGoogleStyle(); 4823 NoBinPacking.BinPackParameters = false; 4824 NoBinPacking.BinPackArguments = false; 4825 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 4826 " aaaaaaaaaaaaaaaaaaaa,\n" 4827 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 4828 NoBinPacking); 4829 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 4830 " aaaaaaaaaaaaa,\n" 4831 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 4832 NoBinPacking); 4833 verifyFormat( 4834 "aaaaaaaa(aaaaaaaaaaaaa,\n" 4835 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4836 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 4837 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4838 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 4839 NoBinPacking); 4840 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 4841 " .aaaaaaaaaaaaaaaaaa();", 4842 NoBinPacking); 4843 verifyFormat("void f() {\n" 4844 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4845 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 4846 "}", 4847 NoBinPacking); 4848 4849 verifyFormat( 4850 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4851 " aaaaaaaaaaaa,\n" 4852 " aaaaaaaaaaaa);", 4853 NoBinPacking); 4854 verifyFormat( 4855 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 4856 " ddddddddddddddddddddddddddddd),\n" 4857 " test);", 4858 NoBinPacking); 4859 4860 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 4861 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 4862 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 4863 " aaaaaaaaaaaaaaaaaa;", 4864 NoBinPacking); 4865 verifyFormat("a(\"a\"\n" 4866 " \"a\",\n" 4867 " a);"); 4868 4869 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 4870 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 4871 " aaaaaaaaa,\n" 4872 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4873 NoBinPacking); 4874 verifyFormat( 4875 "void f() {\n" 4876 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 4877 " .aaaaaaa();\n" 4878 "}", 4879 NoBinPacking); 4880 verifyFormat( 4881 "template <class SomeType, class SomeOtherType>\n" 4882 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 4883 NoBinPacking); 4884 } 4885 4886 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 4887 FormatStyle Style = getLLVMStyleWithColumns(15); 4888 Style.ExperimentalAutoDetectBinPacking = true; 4889 EXPECT_EQ("aaa(aaaa,\n" 4890 " aaaa,\n" 4891 " aaaa);\n" 4892 "aaa(aaaa,\n" 4893 " aaaa,\n" 4894 " aaaa);", 4895 format("aaa(aaaa,\n" // one-per-line 4896 " aaaa,\n" 4897 " aaaa );\n" 4898 "aaa(aaaa, aaaa, aaaa);", // inconclusive 4899 Style)); 4900 EXPECT_EQ("aaa(aaaa, aaaa,\n" 4901 " aaaa);\n" 4902 "aaa(aaaa, aaaa,\n" 4903 " aaaa);", 4904 format("aaa(aaaa, aaaa,\n" // bin-packed 4905 " aaaa );\n" 4906 "aaa(aaaa, aaaa, aaaa);", // inconclusive 4907 Style)); 4908 } 4909 4910 TEST_F(FormatTest, FormatsBuilderPattern) { 4911 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 4912 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 4913 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 4914 " .StartsWith(\".init\", ORDER_INIT)\n" 4915 " .StartsWith(\".fini\", ORDER_FINI)\n" 4916 " .StartsWith(\".hash\", ORDER_HASH)\n" 4917 " .Default(ORDER_TEXT);\n"); 4918 4919 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 4920 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 4921 verifyFormat( 4922 "aaaaaaa->aaaaaaa\n" 4923 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4924 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4925 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 4926 verifyFormat( 4927 "aaaaaaa->aaaaaaa\n" 4928 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4929 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 4930 verifyFormat( 4931 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 4932 " aaaaaaaaaaaaaa);"); 4933 verifyFormat( 4934 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 4935 " aaaaaa->aaaaaaaaaaaa()\n" 4936 " ->aaaaaaaaaaaaaaaa(\n" 4937 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4938 " ->aaaaaaaaaaaaaaaaa();"); 4939 verifyGoogleFormat( 4940 "void f() {\n" 4941 " someo->Add((new util::filetools::Handler(dir))\n" 4942 " ->OnEvent1(NewPermanentCallback(\n" 4943 " this, &HandlerHolderClass::EventHandlerCBA))\n" 4944 " ->OnEvent2(NewPermanentCallback(\n" 4945 " this, &HandlerHolderClass::EventHandlerCBB))\n" 4946 " ->OnEvent3(NewPermanentCallback(\n" 4947 " this, &HandlerHolderClass::EventHandlerCBC))\n" 4948 " ->OnEvent5(NewPermanentCallback(\n" 4949 " this, &HandlerHolderClass::EventHandlerCBD))\n" 4950 " ->OnEvent6(NewPermanentCallback(\n" 4951 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 4952 "}"); 4953 4954 verifyFormat( 4955 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 4956 verifyFormat("aaaaaaaaaaaaaaa()\n" 4957 " .aaaaaaaaaaaaaaa()\n" 4958 " .aaaaaaaaaaaaaaa()\n" 4959 " .aaaaaaaaaaaaaaa()\n" 4960 " .aaaaaaaaaaaaaaa();"); 4961 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 4962 " .aaaaaaaaaaaaaaa()\n" 4963 " .aaaaaaaaaaaaaaa()\n" 4964 " .aaaaaaaaaaaaaaa();"); 4965 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 4966 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 4967 " .aaaaaaaaaaaaaaa();"); 4968 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 4969 " ->aaaaaaaaaaaaaae(0)\n" 4970 " ->aaaaaaaaaaaaaaa();"); 4971 4972 // Don't linewrap after very short segments. 4973 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4974 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4975 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 4976 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4977 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4978 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 4979 verifyFormat("aaa()\n" 4980 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4981 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4982 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 4983 4984 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 4985 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4986 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 4987 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 4988 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 4989 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 4990 4991 // Prefer not to break after empty parentheses. 4992 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 4993 " First->LastNewlineOffset);"); 4994 4995 // Prefer not to create "hanging" indents. 4996 verifyFormat( 4997 "return !soooooooooooooome_map\n" 4998 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4999 " .second;"); 5000 verifyFormat( 5001 "return aaaaaaaaaaaaaaaa\n" 5002 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 5003 " .aaaa(aaaaaaaaaaaaaa);"); 5004 // No hanging indent here. 5005 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5006 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5007 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5008 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5009 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5010 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5011 getLLVMStyleWithColumns(60)); 5012 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5013 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5014 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5015 getLLVMStyleWithColumns(59)); 5016 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5017 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5018 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5019 5020 // Dont break if only closing statements before member call 5021 verifyFormat("test() {\n" 5022 " ([]() -> {\n" 5023 " int b = 32;\n" 5024 " return 3;\n" 5025 " }).foo();\n" 5026 "}"); 5027 verifyFormat("test() {\n" 5028 " (\n" 5029 " []() -> {\n" 5030 " int b = 32;\n" 5031 " return 3;\n" 5032 " },\n" 5033 " foo, bar)\n" 5034 " .foo();\n" 5035 "}"); 5036 verifyFormat("test() {\n" 5037 " ([]() -> {\n" 5038 " int b = 32;\n" 5039 " return 3;\n" 5040 " })\n" 5041 " .foo()\n" 5042 " .bar();\n" 5043 "}"); 5044 verifyFormat("test() {\n" 5045 " ([]() -> {\n" 5046 " int b = 32;\n" 5047 " return 3;\n" 5048 " })\n" 5049 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5050 " \"bbbb\");\n" 5051 "}", 5052 getLLVMStyleWithColumns(30)); 5053 } 5054 5055 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5056 verifyFormat( 5057 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5058 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5059 verifyFormat( 5060 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5061 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5062 5063 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5064 " ccccccccccccccccccccccccc) {\n}"); 5065 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5066 " ccccccccccccccccccccccccc) {\n}"); 5067 5068 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5069 " ccccccccccccccccccccccccc) {\n}"); 5070 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5071 " ccccccccccccccccccccccccc) {\n}"); 5072 5073 verifyFormat( 5074 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5075 " ccccccccccccccccccccccccc) {\n}"); 5076 verifyFormat( 5077 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5078 " ccccccccccccccccccccccccc) {\n}"); 5079 5080 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5081 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5082 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5083 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5084 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5085 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5086 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5087 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5088 5089 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5090 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5091 " aaaaaaaaaaaaaaa != aa) {\n}"); 5092 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5093 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5094 " aaaaaaaaaaaaaaa != aa) {\n}"); 5095 } 5096 5097 TEST_F(FormatTest, BreaksAfterAssignments) { 5098 verifyFormat( 5099 "unsigned Cost =\n" 5100 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5101 " SI->getPointerAddressSpaceee());\n"); 5102 verifyFormat( 5103 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5104 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5105 5106 verifyFormat( 5107 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5108 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5109 verifyFormat("unsigned OriginalStartColumn =\n" 5110 " SourceMgr.getSpellingColumnNumber(\n" 5111 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5112 " 1;"); 5113 } 5114 5115 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5116 FormatStyle Style = getLLVMStyle(); 5117 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5118 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5119 Style); 5120 5121 Style.PenaltyBreakAssignment = 20; 5122 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5123 " cccccccccccccccccccccccccc;", 5124 Style); 5125 } 5126 5127 TEST_F(FormatTest, AlignsAfterAssignments) { 5128 verifyFormat( 5129 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5130 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5131 verifyFormat( 5132 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5133 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5134 verifyFormat( 5135 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5136 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5137 verifyFormat( 5138 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5139 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5140 verifyFormat( 5141 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5142 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5143 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5144 } 5145 5146 TEST_F(FormatTest, AlignsAfterReturn) { 5147 verifyFormat( 5148 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5149 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5150 verifyFormat( 5151 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5152 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5153 verifyFormat( 5154 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5155 " aaaaaaaaaaaaaaaaaaaaaa();"); 5156 verifyFormat( 5157 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5158 " aaaaaaaaaaaaaaaaaaaaaa());"); 5159 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5160 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5161 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5162 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5163 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5164 verifyFormat("return\n" 5165 " // true if code is one of a or b.\n" 5166 " code == a || code == b;"); 5167 } 5168 5169 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5170 verifyFormat( 5171 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5172 " aaaaaaaaa aaaaaaa) {}"); 5173 verifyFormat( 5174 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5175 " aaaaaaaaaaa aaaaaaaaa);"); 5176 verifyFormat( 5177 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5178 " aaaaaaaaaaaaaaaaaaaaa));"); 5179 FormatStyle Style = getLLVMStyle(); 5180 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5181 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5182 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5183 Style); 5184 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5185 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5186 Style); 5187 verifyFormat("SomeLongVariableName->someFunction(\n" 5188 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5189 Style); 5190 verifyFormat( 5191 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5192 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5193 Style); 5194 verifyFormat( 5195 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5196 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5197 Style); 5198 verifyFormat( 5199 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5200 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5201 Style); 5202 5203 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5204 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5205 " b));", 5206 Style); 5207 5208 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5209 Style.BinPackArguments = false; 5210 Style.BinPackParameters = false; 5211 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5212 " aaaaaaaaaaa aaaaaaaa,\n" 5213 " aaaaaaaaa aaaaaaa,\n" 5214 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5215 Style); 5216 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5217 " aaaaaaaaaaa aaaaaaaaa,\n" 5218 " aaaaaaaaaaa aaaaaaaaa,\n" 5219 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5220 Style); 5221 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5222 " aaaaaaaaaaaaaaa,\n" 5223 " aaaaaaaaaaaaaaaaaaaaa,\n" 5224 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5225 Style); 5226 verifyFormat( 5227 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5228 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5229 Style); 5230 verifyFormat( 5231 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5232 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5233 Style); 5234 verifyFormat( 5235 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5236 " aaaaaaaaaaaaaaaaaaaaa(\n" 5237 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5238 " aaaaaaaaaaaaaaaa);", 5239 Style); 5240 verifyFormat( 5241 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5242 " aaaaaaaaaaaaaaaaaaaaa(\n" 5243 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5244 " aaaaaaaaaaaaaaaa);", 5245 Style); 5246 } 5247 5248 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5249 FormatStyle Style = getLLVMStyleWithColumns(40); 5250 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5251 " bbbbbbbbbbbbbbbbbbbbbb);", 5252 Style); 5253 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5254 Style.AlignOperands = false; 5255 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5256 " bbbbbbbbbbbbbbbbbbbbbb);", 5257 Style); 5258 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5259 Style.AlignOperands = true; 5260 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5261 " bbbbbbbbbbbbbbbbbbbbbb);", 5262 Style); 5263 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5264 Style.AlignOperands = false; 5265 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5266 " bbbbbbbbbbbbbbbbbbbbbb);", 5267 Style); 5268 } 5269 5270 TEST_F(FormatTest, BreaksConditionalExpressions) { 5271 verifyFormat( 5272 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5273 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5274 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5275 verifyFormat( 5276 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5277 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5278 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5279 verifyFormat( 5280 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5281 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5282 verifyFormat( 5283 "aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5284 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5285 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5286 verifyFormat( 5287 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5288 " : aaaaaaaaaaaaa);"); 5289 verifyFormat( 5290 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5291 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5292 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5293 " aaaaaaaaaaaaa);"); 5294 verifyFormat( 5295 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5296 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5297 " aaaaaaaaaaaaa);"); 5298 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5299 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5300 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5301 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5302 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5303 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5304 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5305 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5306 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5307 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5308 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5309 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5310 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5311 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5312 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5313 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5314 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5315 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5316 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5317 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5318 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5319 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5320 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5321 " : aaaaaaaaaaaaaaaa;"); 5322 verifyFormat( 5323 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5324 " ? aaaaaaaaaaaaaaa\n" 5325 " : aaaaaaaaaaaaaaa;"); 5326 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5327 " aaaaaaaaa\n" 5328 " ? b\n" 5329 " : c);"); 5330 verifyFormat("return aaaa == bbbb\n" 5331 " // comment\n" 5332 " ? aaaa\n" 5333 " : bbbb;"); 5334 verifyFormat("unsigned Indent =\n" 5335 " format(TheLine.First,\n" 5336 " IndentForLevel[TheLine.Level] >= 0\n" 5337 " ? IndentForLevel[TheLine.Level]\n" 5338 " : TheLine * 2,\n" 5339 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5340 getLLVMStyleWithColumns(60)); 5341 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5342 " ? aaaaaaaaaaaaaaa\n" 5343 " : bbbbbbbbbbbbbbb //\n" 5344 " ? ccccccccccccccc\n" 5345 " : ddddddddddddddd;"); 5346 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5347 " ? aaaaaaaaaaaaaaa\n" 5348 " : (bbbbbbbbbbbbbbb //\n" 5349 " ? ccccccccccccccc\n" 5350 " : ddddddddddddddd);"); 5351 verifyFormat( 5352 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5353 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5354 " aaaaaaaaaaaaaaaaaaaaa +\n" 5355 " aaaaaaaaaaaaaaaaaaaaa\n" 5356 " : aaaaaaaaaa;"); 5357 verifyFormat( 5358 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5359 " : aaaaaaaaaaaaaaaaaaaaaa\n" 5360 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5361 5362 FormatStyle NoBinPacking = getLLVMStyle(); 5363 NoBinPacking.BinPackArguments = false; 5364 verifyFormat( 5365 "void f() {\n" 5366 " g(aaa,\n" 5367 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5368 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5369 " ? aaaaaaaaaaaaaaa\n" 5370 " : aaaaaaaaaaaaaaa);\n" 5371 "}", 5372 NoBinPacking); 5373 verifyFormat( 5374 "void f() {\n" 5375 " g(aaa,\n" 5376 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5377 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5378 " ?: aaaaaaaaaaaaaaa);\n" 5379 "}", 5380 NoBinPacking); 5381 5382 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 5383 " // comment.\n" 5384 " ccccccccccccccccccccccccccccccccccccccc\n" 5385 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5386 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 5387 5388 // Assignments in conditional expressions. Apparently not uncommon :-(. 5389 verifyFormat("return a != b\n" 5390 " // comment\n" 5391 " ? a = b\n" 5392 " : a = b;"); 5393 verifyFormat("return a != b\n" 5394 " // comment\n" 5395 " ? a = a != b\n" 5396 " // comment\n" 5397 " ? a = b\n" 5398 " : a\n" 5399 " : a;\n"); 5400 verifyFormat("return a != b\n" 5401 " // comment\n" 5402 " ? a\n" 5403 " : a = a != b\n" 5404 " // comment\n" 5405 " ? a = b\n" 5406 " : a;"); 5407 } 5408 5409 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 5410 FormatStyle Style = getLLVMStyle(); 5411 Style.BreakBeforeTernaryOperators = false; 5412 Style.ColumnLimit = 70; 5413 verifyFormat( 5414 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5415 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5416 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5417 Style); 5418 verifyFormat( 5419 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5420 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5421 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5422 Style); 5423 verifyFormat( 5424 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5425 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5426 Style); 5427 verifyFormat( 5428 "aaaa(aaaaaaaa, aaaaaaaaaa,\n" 5429 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5430 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5431 Style); 5432 verifyFormat( 5433 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 5434 " aaaaaaaaaaaaa);", 5435 Style); 5436 verifyFormat( 5437 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5438 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5439 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5440 " aaaaaaaaaaaaa);", 5441 Style); 5442 verifyFormat( 5443 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5444 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5445 " aaaaaaaaaaaaa);", 5446 Style); 5447 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5448 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5449 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5450 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5451 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5452 Style); 5453 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5454 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5455 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5456 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5457 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5458 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5459 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5460 Style); 5461 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5462 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 5463 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5464 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5465 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5466 Style); 5467 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5468 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5469 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5470 Style); 5471 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5472 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5473 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5474 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5475 Style); 5476 verifyFormat( 5477 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5478 " aaaaaaaaaaaaaaa :\n" 5479 " aaaaaaaaaaaaaaa;", 5480 Style); 5481 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5482 " aaaaaaaaa ?\n" 5483 " b :\n" 5484 " c);", 5485 Style); 5486 verifyFormat("unsigned Indent =\n" 5487 " format(TheLine.First,\n" 5488 " IndentForLevel[TheLine.Level] >= 0 ?\n" 5489 " IndentForLevel[TheLine.Level] :\n" 5490 " TheLine * 2,\n" 5491 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5492 Style); 5493 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5494 " aaaaaaaaaaaaaaa :\n" 5495 " bbbbbbbbbbbbbbb ? //\n" 5496 " ccccccccccccccc :\n" 5497 " ddddddddddddddd;", 5498 Style); 5499 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5500 " aaaaaaaaaaaaaaa :\n" 5501 " (bbbbbbbbbbbbbbb ? //\n" 5502 " ccccccccccccccc :\n" 5503 " ddddddddddddddd);", 5504 Style); 5505 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5506 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 5507 " ccccccccccccccccccccccccccc;", 5508 Style); 5509 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5510 " aaaaa :\n" 5511 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 5512 Style); 5513 } 5514 5515 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 5516 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 5517 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 5518 verifyFormat("bool a = true, b = false;"); 5519 5520 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5521 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 5522 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 5523 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 5524 verifyFormat( 5525 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 5526 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 5527 " d = e && f;"); 5528 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 5529 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 5530 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5531 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 5532 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 5533 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 5534 5535 FormatStyle Style = getGoogleStyle(); 5536 Style.PointerAlignment = FormatStyle::PAS_Left; 5537 Style.DerivePointerAlignment = false; 5538 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5539 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 5540 " *b = bbbbbbbbbbbbbbbbbbb;", 5541 Style); 5542 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5543 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 5544 Style); 5545 verifyFormat("vector<int*> a, b;", Style); 5546 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 5547 } 5548 5549 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 5550 verifyFormat("arr[foo ? bar : baz];"); 5551 verifyFormat("f()[foo ? bar : baz];"); 5552 verifyFormat("(a + b)[foo ? bar : baz];"); 5553 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 5554 } 5555 5556 TEST_F(FormatTest, AlignsStringLiterals) { 5557 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 5558 " \"short literal\");"); 5559 verifyFormat( 5560 "looooooooooooooooooooooooongFunction(\n" 5561 " \"short literal\"\n" 5562 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 5563 verifyFormat("someFunction(\"Always break between multi-line\"\n" 5564 " \" string literals\",\n" 5565 " and, other, parameters);"); 5566 EXPECT_EQ("fun + \"1243\" /* comment */\n" 5567 " \"5678\";", 5568 format("fun + \"1243\" /* comment */\n" 5569 " \"5678\";", 5570 getLLVMStyleWithColumns(28))); 5571 EXPECT_EQ( 5572 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 5573 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 5574 " \"aaaaaaaaaaaaaaaa\";", 5575 format("aaaaaa =" 5576 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 5577 "aaaaaaaaaaaaaaaaaaaaa\" " 5578 "\"aaaaaaaaaaaaaaaa\";")); 5579 verifyFormat("a = a + \"a\"\n" 5580 " \"a\"\n" 5581 " \"a\";"); 5582 verifyFormat("f(\"a\", \"b\"\n" 5583 " \"c\");"); 5584 5585 verifyFormat( 5586 "#define LL_FORMAT \"ll\"\n" 5587 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 5588 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 5589 5590 verifyFormat("#define A(X) \\\n" 5591 " \"aaaaa\" #X \"bbbbbb\" \\\n" 5592 " \"ccccc\"", 5593 getLLVMStyleWithColumns(23)); 5594 verifyFormat("#define A \"def\"\n" 5595 "f(\"abc\" A \"ghi\"\n" 5596 " \"jkl\");"); 5597 5598 verifyFormat("f(L\"a\"\n" 5599 " L\"b\");"); 5600 verifyFormat("#define A(X) \\\n" 5601 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 5602 " L\"ccccc\"", 5603 getLLVMStyleWithColumns(25)); 5604 5605 verifyFormat("f(@\"a\"\n" 5606 " @\"b\");"); 5607 verifyFormat("NSString s = @\"a\"\n" 5608 " @\"b\"\n" 5609 " @\"c\";"); 5610 verifyFormat("NSString s = @\"a\"\n" 5611 " \"b\"\n" 5612 " \"c\";"); 5613 } 5614 5615 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 5616 FormatStyle Style = getLLVMStyle(); 5617 // No declarations or definitions should be moved to own line. 5618 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 5619 verifyFormat("class A {\n" 5620 " int f() { return 1; }\n" 5621 " int g();\n" 5622 "};\n" 5623 "int f() { return 1; }\n" 5624 "int g();\n", 5625 Style); 5626 5627 // All declarations and definitions should have the return type moved to its 5628 // own 5629 // line. 5630 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 5631 verifyFormat("class E {\n" 5632 " int\n" 5633 " f() {\n" 5634 " return 1;\n" 5635 " }\n" 5636 " int\n" 5637 " g();\n" 5638 "};\n" 5639 "int\n" 5640 "f() {\n" 5641 " return 1;\n" 5642 "}\n" 5643 "int\n" 5644 "g();\n", 5645 Style); 5646 5647 // Top-level definitions, and no kinds of declarations should have the 5648 // return type moved to its own line. 5649 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 5650 verifyFormat("class B {\n" 5651 " int f() { return 1; }\n" 5652 " int g();\n" 5653 "};\n" 5654 "int\n" 5655 "f() {\n" 5656 " return 1;\n" 5657 "}\n" 5658 "int g();\n", 5659 Style); 5660 5661 // Top-level definitions and declarations should have the return type moved 5662 // to its own line. 5663 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 5664 verifyFormat("class C {\n" 5665 " int f() { return 1; }\n" 5666 " int g();\n" 5667 "};\n" 5668 "int\n" 5669 "f() {\n" 5670 " return 1;\n" 5671 "}\n" 5672 "int\n" 5673 "g();\n", 5674 Style); 5675 5676 // All definitions should have the return type moved to its own line, but no 5677 // kinds of declarations. 5678 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 5679 verifyFormat("class D {\n" 5680 " int\n" 5681 " f() {\n" 5682 " return 1;\n" 5683 " }\n" 5684 " int g();\n" 5685 "};\n" 5686 "int\n" 5687 "f() {\n" 5688 " return 1;\n" 5689 "}\n" 5690 "int g();\n", 5691 Style); 5692 verifyFormat("const char *\n" 5693 "f(void) {\n" // Break here. 5694 " return \"\";\n" 5695 "}\n" 5696 "const char *bar(void);\n", // No break here. 5697 Style); 5698 verifyFormat("template <class T>\n" 5699 "T *\n" 5700 "f(T &c) {\n" // Break here. 5701 " return NULL;\n" 5702 "}\n" 5703 "template <class T> T *f(T &c);\n", // No break here. 5704 Style); 5705 verifyFormat("class C {\n" 5706 " int\n" 5707 " operator+() {\n" 5708 " return 1;\n" 5709 " }\n" 5710 " int\n" 5711 " operator()() {\n" 5712 " return 1;\n" 5713 " }\n" 5714 "};\n", 5715 Style); 5716 verifyFormat("void\n" 5717 "A::operator()() {}\n" 5718 "void\n" 5719 "A::operator>>() {}\n" 5720 "void\n" 5721 "A::operator+() {}\n", 5722 Style); 5723 verifyFormat("void *operator new(std::size_t s);", // No break here. 5724 Style); 5725 verifyFormat("void *\n" 5726 "operator new(std::size_t s) {}", 5727 Style); 5728 verifyFormat("void *\n" 5729 "operator delete[](void *ptr) {}", 5730 Style); 5731 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 5732 verifyFormat("const char *\n" 5733 "f(void)\n" // Break here. 5734 "{\n" 5735 " return \"\";\n" 5736 "}\n" 5737 "const char *bar(void);\n", // No break here. 5738 Style); 5739 verifyFormat("template <class T>\n" 5740 "T *\n" // Problem here: no line break 5741 "f(T &c)\n" // Break here. 5742 "{\n" 5743 " return NULL;\n" 5744 "}\n" 5745 "template <class T> T *f(T &c);\n", // No break here. 5746 Style); 5747 verifyFormat("int\n" 5748 "foo(A<bool> a)\n" 5749 "{\n" 5750 " return a;\n" 5751 "}\n", 5752 Style); 5753 verifyFormat("int\n" 5754 "foo(A<8> a)\n" 5755 "{\n" 5756 " return a;\n" 5757 "}\n", 5758 Style); 5759 verifyFormat("int\n" 5760 "foo(A<B<bool>, 8> a)\n" 5761 "{\n" 5762 " return a;\n" 5763 "}\n", 5764 Style); 5765 verifyFormat("int\n" 5766 "foo(A<B<8>, bool> a)\n" 5767 "{\n" 5768 " return a;\n" 5769 "}\n", 5770 Style); 5771 verifyFormat("int\n" 5772 "foo(A<B<bool>, bool> a)\n" 5773 "{\n" 5774 " return a;\n" 5775 "}\n", 5776 Style); 5777 verifyFormat("int\n" 5778 "foo(A<B<8>, 8> a)\n" 5779 "{\n" 5780 " return a;\n" 5781 "}\n", 5782 Style); 5783 5784 Style = getGNUStyle(); 5785 5786 // Test for comments at the end of function declarations. 5787 verifyFormat("void\n" 5788 "foo (int a, /*abc*/ int b) // def\n" 5789 "{\n" 5790 "}\n", 5791 Style); 5792 5793 verifyFormat("void\n" 5794 "foo (int a, /* abc */ int b) /* def */\n" 5795 "{\n" 5796 "}\n", 5797 Style); 5798 5799 // Definitions that should not break after return type 5800 verifyFormat("void foo (int a, int b); // def\n", Style); 5801 verifyFormat("void foo (int a, int b); /* def */\n", Style); 5802 verifyFormat("void foo (int a, int b);\n", Style); 5803 } 5804 5805 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 5806 FormatStyle NoBreak = getLLVMStyle(); 5807 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 5808 FormatStyle Break = getLLVMStyle(); 5809 Break.AlwaysBreakBeforeMultilineStrings = true; 5810 verifyFormat("aaaa = \"bbbb\"\n" 5811 " \"cccc\";", 5812 NoBreak); 5813 verifyFormat("aaaa =\n" 5814 " \"bbbb\"\n" 5815 " \"cccc\";", 5816 Break); 5817 verifyFormat("aaaa(\"bbbb\"\n" 5818 " \"cccc\");", 5819 NoBreak); 5820 verifyFormat("aaaa(\n" 5821 " \"bbbb\"\n" 5822 " \"cccc\");", 5823 Break); 5824 verifyFormat("aaaa(qqq, \"bbbb\"\n" 5825 " \"cccc\");", 5826 NoBreak); 5827 verifyFormat("aaaa(qqq,\n" 5828 " \"bbbb\"\n" 5829 " \"cccc\");", 5830 Break); 5831 verifyFormat("aaaa(qqq,\n" 5832 " L\"bbbb\"\n" 5833 " L\"cccc\");", 5834 Break); 5835 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 5836 " \"bbbb\"));", 5837 Break); 5838 verifyFormat("string s = someFunction(\n" 5839 " \"abc\"\n" 5840 " \"abc\");", 5841 Break); 5842 5843 // As we break before unary operators, breaking right after them is bad. 5844 verifyFormat("string foo = abc ? \"x\"\n" 5845 " \"blah blah blah blah blah blah\"\n" 5846 " : \"y\";", 5847 Break); 5848 5849 // Don't break if there is no column gain. 5850 verifyFormat("f(\"aaaa\"\n" 5851 " \"bbbb\");", 5852 Break); 5853 5854 // Treat literals with escaped newlines like multi-line string literals. 5855 EXPECT_EQ("x = \"a\\\n" 5856 "b\\\n" 5857 "c\";", 5858 format("x = \"a\\\n" 5859 "b\\\n" 5860 "c\";", 5861 NoBreak)); 5862 EXPECT_EQ("xxxx =\n" 5863 " \"a\\\n" 5864 "b\\\n" 5865 "c\";", 5866 format("xxxx = \"a\\\n" 5867 "b\\\n" 5868 "c\";", 5869 Break)); 5870 5871 EXPECT_EQ("NSString *const kString =\n" 5872 " @\"aaaa\"\n" 5873 " @\"bbbb\";", 5874 format("NSString *const kString = @\"aaaa\"\n" 5875 "@\"bbbb\";", 5876 Break)); 5877 5878 Break.ColumnLimit = 0; 5879 verifyFormat("const char *hello = \"hello llvm\";", Break); 5880 } 5881 5882 TEST_F(FormatTest, AlignsPipes) { 5883 verifyFormat( 5884 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5885 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5886 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5887 verifyFormat( 5888 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 5889 " << aaaaaaaaaaaaaaaaaaaa;"); 5890 verifyFormat( 5891 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5892 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5893 verifyFormat( 5894 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5895 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5896 verifyFormat( 5897 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 5898 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 5899 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 5900 verifyFormat( 5901 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5902 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5903 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5904 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5905 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5906 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5907 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 5908 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 5909 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 5910 verifyFormat( 5911 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5912 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5913 verifyFormat( 5914 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 5915 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5916 5917 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 5918 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 5919 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5920 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5921 " aaaaaaaaaaaaaaaaaaaaa)\n" 5922 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5923 verifyFormat("LOG_IF(aaa == //\n" 5924 " bbb)\n" 5925 " << a << b;"); 5926 5927 // But sometimes, breaking before the first "<<" is desirable. 5928 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 5929 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 5930 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 5931 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5932 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5933 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 5934 " << BEF << IsTemplate << Description << E->getType();"); 5935 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 5936 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5937 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5938 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 5939 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5940 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5941 " << aaa;"); 5942 5943 verifyFormat( 5944 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5945 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5946 5947 // Incomplete string literal. 5948 EXPECT_EQ("llvm::errs() << \"\n" 5949 " << a;", 5950 format("llvm::errs() << \"\n<<a;")); 5951 5952 verifyFormat("void f() {\n" 5953 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 5954 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 5955 "}"); 5956 5957 // Handle 'endl'. 5958 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 5959 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 5960 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 5961 5962 // Handle '\n'. 5963 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 5964 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 5965 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 5966 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 5967 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 5968 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 5969 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 5970 } 5971 5972 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 5973 verifyFormat("return out << \"somepacket = {\\n\"\n" 5974 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 5975 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 5976 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 5977 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 5978 " << \"}\";"); 5979 5980 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 5981 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 5982 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 5983 verifyFormat( 5984 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 5985 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 5986 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 5987 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 5988 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 5989 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 5990 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 5991 verifyFormat( 5992 "void f() {\n" 5993 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 5994 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5995 "}"); 5996 5997 // Breaking before the first "<<" is generally not desirable. 5998 verifyFormat( 5999 "llvm::errs()\n" 6000 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6001 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6002 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6003 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6004 getLLVMStyleWithColumns(70)); 6005 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6006 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6007 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6008 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6009 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6010 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6011 getLLVMStyleWithColumns(70)); 6012 6013 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6014 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6015 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6016 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6017 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6018 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 6019 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 6020 " (aaaa + aaaa);", 6021 getLLVMStyleWithColumns(40)); 6022 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 6023 " (aaaaaaa + aaaaa));", 6024 getLLVMStyleWithColumns(40)); 6025 verifyFormat( 6026 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 6027 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 6028 " bbbbbbbbbbbbbbbbbbbbbbb);"); 6029 } 6030 6031 TEST_F(FormatTest, UnderstandsEquals) { 6032 verifyFormat( 6033 "aaaaaaaaaaaaaaaaa =\n" 6034 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6035 verifyFormat( 6036 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6037 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6038 verifyFormat( 6039 "if (a) {\n" 6040 " f();\n" 6041 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6042 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 6043 "}"); 6044 6045 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6046 " 100000000 + 10000000) {\n}"); 6047 } 6048 6049 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 6050 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6051 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 6052 6053 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6054 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 6055 6056 verifyFormat( 6057 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 6058 " Parameter2);"); 6059 6060 verifyFormat( 6061 "ShortObject->shortFunction(\n" 6062 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 6063 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 6064 6065 verifyFormat("loooooooooooooongFunction(\n" 6066 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 6067 6068 verifyFormat( 6069 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 6070 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 6071 6072 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6073 " .WillRepeatedly(Return(SomeValue));"); 6074 verifyFormat("void f() {\n" 6075 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6076 " .Times(2)\n" 6077 " .WillRepeatedly(Return(SomeValue));\n" 6078 "}"); 6079 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 6080 " ccccccccccccccccccccccc);"); 6081 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6082 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6083 " .aaaaa(aaaaa),\n" 6084 " aaaaaaaaaaaaaaaaaaaaa);"); 6085 verifyFormat("void f() {\n" 6086 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6087 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 6088 "}"); 6089 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6090 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6091 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6092 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6093 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6094 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6095 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6096 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6097 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 6098 "}"); 6099 6100 // Here, it is not necessary to wrap at "." or "->". 6101 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 6102 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6103 verifyFormat( 6104 "aaaaaaaaaaa->aaaaaaaaa(\n" 6105 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6106 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 6107 6108 verifyFormat( 6109 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6110 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 6111 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 6112 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6113 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 6114 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6115 6116 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6117 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6118 " .a();"); 6119 6120 FormatStyle NoBinPacking = getLLVMStyle(); 6121 NoBinPacking.BinPackParameters = false; 6122 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6123 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6124 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 6125 " aaaaaaaaaaaaaaaaaaa,\n" 6126 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6127 NoBinPacking); 6128 6129 // If there is a subsequent call, change to hanging indentation. 6130 verifyFormat( 6131 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6132 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 6133 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6134 verifyFormat( 6135 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6136 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 6137 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6138 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6139 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6140 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6141 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6142 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6143 } 6144 6145 TEST_F(FormatTest, WrapsTemplateDeclarations) { 6146 verifyFormat("template <typename T>\n" 6147 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6148 verifyFormat("template <typename T>\n" 6149 "// T should be one of {A, B}.\n" 6150 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6151 verifyFormat( 6152 "template <typename T>\n" 6153 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 6154 verifyFormat("template <typename T>\n" 6155 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 6156 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 6157 verifyFormat( 6158 "template <typename T>\n" 6159 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 6160 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 6161 verifyFormat( 6162 "template <typename T>\n" 6163 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 6164 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 6165 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6166 verifyFormat("template <typename T>\n" 6167 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6168 " int aaaaaaaaaaaaaaaaaaaaaa);"); 6169 verifyFormat( 6170 "template <typename T1, typename T2 = char, typename T3 = char,\n" 6171 " typename T4 = char>\n" 6172 "void f();"); 6173 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 6174 " template <typename> class cccccccccccccccccccccc,\n" 6175 " typename ddddddddddddd>\n" 6176 "class C {};"); 6177 verifyFormat( 6178 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 6179 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6180 6181 verifyFormat("void f() {\n" 6182 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 6183 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 6184 "}"); 6185 6186 verifyFormat("template <typename T> class C {};"); 6187 verifyFormat("template <typename T> void f();"); 6188 verifyFormat("template <typename T> void f() {}"); 6189 verifyFormat( 6190 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6191 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6192 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 6193 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6194 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6195 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 6196 " bbbbbbbbbbbbbbbbbbbbbbbb);", 6197 getLLVMStyleWithColumns(72)); 6198 EXPECT_EQ("static_cast<A< //\n" 6199 " B> *>(\n" 6200 "\n" 6201 ");", 6202 format("static_cast<A<//\n" 6203 " B>*>(\n" 6204 "\n" 6205 " );")); 6206 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6207 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 6208 6209 FormatStyle AlwaysBreak = getLLVMStyle(); 6210 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 6211 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 6212 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 6213 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 6214 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6215 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6216 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 6217 verifyFormat("template <template <typename> class Fooooooo,\n" 6218 " template <typename> class Baaaaaaar>\n" 6219 "struct C {};", 6220 AlwaysBreak); 6221 verifyFormat("template <typename T> // T can be A, B or C.\n" 6222 "struct C {};", 6223 AlwaysBreak); 6224 verifyFormat("template <enum E> class A {\n" 6225 "public:\n" 6226 " E *f();\n" 6227 "};"); 6228 6229 FormatStyle NeverBreak = getLLVMStyle(); 6230 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 6231 verifyFormat("template <typename T> class C {};", NeverBreak); 6232 verifyFormat("template <typename T> void f();", NeverBreak); 6233 verifyFormat("template <typename T> void f() {}", NeverBreak); 6234 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbb) {}", 6235 NeverBreak); 6236 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6237 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6238 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 6239 NeverBreak); 6240 verifyFormat("template <template <typename> class Fooooooo,\n" 6241 " template <typename> class Baaaaaaar>\n" 6242 "struct C {};", 6243 NeverBreak); 6244 verifyFormat("template <typename T> // T can be A, B or C.\n" 6245 "struct C {};", 6246 NeverBreak); 6247 verifyFormat("template <enum E> class A {\n" 6248 "public:\n" 6249 " E *f();\n" 6250 "};", NeverBreak); 6251 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 6252 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbb) {}", 6253 NeverBreak); 6254 } 6255 6256 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 6257 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 6258 Style.ColumnLimit = 60; 6259 EXPECT_EQ("// Baseline - no comments.\n" 6260 "template <\n" 6261 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6262 "void f() {}", 6263 format("// Baseline - no comments.\n" 6264 "template <\n" 6265 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6266 "void f() {}", 6267 Style)); 6268 6269 EXPECT_EQ("template <\n" 6270 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6271 "void f() {}", 6272 format("template <\n" 6273 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6274 "void f() {}", 6275 Style)); 6276 6277 EXPECT_EQ( 6278 "template <\n" 6279 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6280 "void f() {}", 6281 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6282 "void f() {}", 6283 Style)); 6284 6285 EXPECT_EQ( 6286 "template <\n" 6287 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6288 " // multiline\n" 6289 "void f() {}", 6290 format("template <\n" 6291 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6292 " // multiline\n" 6293 "void f() {}", 6294 Style)); 6295 6296 EXPECT_EQ( 6297 "template <typename aaaaaaaaaa<\n" 6298 " bbbbbbbbbbbb>::value> // trailing loooong\n" 6299 "void f() {}", 6300 format( 6301 "template <\n" 6302 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 6303 "void f() {}", 6304 Style)); 6305 } 6306 6307 TEST_F(FormatTest, WrapsTemplateParameters) { 6308 FormatStyle Style = getLLVMStyle(); 6309 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6310 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6311 verifyFormat( 6312 "template <typename... a> struct q {};\n" 6313 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6314 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6315 " y;", 6316 Style); 6317 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6318 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6319 verifyFormat( 6320 "template <typename... a> struct r {};\n" 6321 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6322 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6323 " y;", 6324 Style); 6325 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6326 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6327 verifyFormat( 6328 "template <typename... a> struct s {};\n" 6329 "extern s<\n" 6330 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 6331 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n" 6332 " y;", 6333 Style); 6334 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6335 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6336 verifyFormat( 6337 "template <typename... a> struct t {};\n" 6338 "extern t<\n" 6339 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 6340 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n" 6341 " y;", 6342 Style); 6343 } 6344 6345 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 6346 verifyFormat( 6347 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6348 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6349 verifyFormat( 6350 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6351 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6352 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6353 6354 // FIXME: Should we have the extra indent after the second break? 6355 verifyFormat( 6356 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6357 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6358 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6359 6360 verifyFormat( 6361 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 6362 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 6363 6364 // Breaking at nested name specifiers is generally not desirable. 6365 verifyFormat( 6366 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6367 " aaaaaaaaaaaaaaaaaaaaaaa);"); 6368 6369 verifyFormat( 6370 "aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 6371 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6372 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6373 " aaaaaaaaaaaaaaaaaaaaa);", 6374 getLLVMStyleWithColumns(74)); 6375 6376 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6377 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6378 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6379 } 6380 6381 TEST_F(FormatTest, UnderstandsTemplateParameters) { 6382 verifyFormat("A<int> a;"); 6383 verifyFormat("A<A<A<int>>> a;"); 6384 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 6385 verifyFormat("bool x = a < 1 || 2 > a;"); 6386 verifyFormat("bool x = 5 < f<int>();"); 6387 verifyFormat("bool x = f<int>() > 5;"); 6388 verifyFormat("bool x = 5 < a<int>::x;"); 6389 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 6390 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 6391 6392 verifyGoogleFormat("A<A<int>> a;"); 6393 verifyGoogleFormat("A<A<A<int>>> a;"); 6394 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 6395 verifyGoogleFormat("A<A<int> > a;"); 6396 verifyGoogleFormat("A<A<A<int> > > a;"); 6397 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 6398 verifyGoogleFormat("A<::A<int>> a;"); 6399 verifyGoogleFormat("A<::A> a;"); 6400 verifyGoogleFormat("A< ::A> a;"); 6401 verifyGoogleFormat("A< ::A<int> > a;"); 6402 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 6403 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 6404 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 6405 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 6406 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 6407 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 6408 6409 verifyFormat("A<A>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 6410 6411 verifyFormat("test >> a >> b;"); 6412 verifyFormat("test << a >> b;"); 6413 6414 verifyFormat("f<int>();"); 6415 verifyFormat("template <typename T> void f() {}"); 6416 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 6417 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 6418 "sizeof(char)>::type>;"); 6419 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 6420 verifyFormat("f(a.operator()<A>());"); 6421 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6422 " .template operator()<A>());", 6423 getLLVMStyleWithColumns(35)); 6424 6425 // Not template parameters. 6426 verifyFormat("return a < b && c > d;"); 6427 verifyFormat("void f() {\n" 6428 " while (a < b && c > d) {\n" 6429 " }\n" 6430 "}"); 6431 verifyFormat("template <typename... Types>\n" 6432 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 6433 6434 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6435 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 6436 getLLVMStyleWithColumns(60)); 6437 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 6438 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 6439 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 6440 } 6441 6442 TEST_F(FormatTest, BitshiftOperatorWidth) { 6443 EXPECT_EQ("int a = 1 << 2; /* foo\n" 6444 " bar */", 6445 format("int a=1<<2; /* foo\n" 6446 " bar */")); 6447 6448 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 6449 " bar */", 6450 format("int b =256>>1 ; /* foo\n" 6451 " bar */")); 6452 } 6453 6454 TEST_F(FormatTest, UnderstandsBinaryOperators) { 6455 verifyFormat("COMPARE(a, ==, b);"); 6456 verifyFormat("auto s = sizeof...(Ts) - 1;"); 6457 } 6458 6459 TEST_F(FormatTest, UnderstandsPointersToMembers) { 6460 verifyFormat("int A::*x;"); 6461 verifyFormat("int (S::*func)(void *);"); 6462 verifyFormat("void f() { int (S::*func)(void *); }"); 6463 verifyFormat("typedef bool *(Class::*Member)() const;"); 6464 verifyFormat("void f() {\n" 6465 " (a->*f)();\n" 6466 " a->*x;\n" 6467 " (a.*f)();\n" 6468 " ((*a).*f)();\n" 6469 " a.*x;\n" 6470 "}"); 6471 verifyFormat("void f() {\n" 6472 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 6473 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 6474 "}"); 6475 verifyFormat( 6476 "(aaaaaaaaaa->*bbbbbbb)(\n" 6477 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6478 FormatStyle Style = getLLVMStyle(); 6479 Style.PointerAlignment = FormatStyle::PAS_Left; 6480 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 6481 } 6482 6483 TEST_F(FormatTest, UnderstandsUnaryOperators) { 6484 verifyFormat("int a = -2;"); 6485 verifyFormat("f(-1, -2, -3);"); 6486 verifyFormat("a[-1] = 5;"); 6487 verifyFormat("int a = 5 + -2;"); 6488 verifyFormat("if (i == -1) {\n}"); 6489 verifyFormat("if (i != -1) {\n}"); 6490 verifyFormat("if (i > -1) {\n}"); 6491 verifyFormat("if (i < -1) {\n}"); 6492 verifyFormat("++(a->f());"); 6493 verifyFormat("--(a->f());"); 6494 verifyFormat("(a->f())++;"); 6495 verifyFormat("a[42]++;"); 6496 verifyFormat("if (!(a->f())) {\n}"); 6497 verifyFormat("if (!+i) {\n}"); 6498 verifyFormat("~&a;"); 6499 6500 verifyFormat("a-- > b;"); 6501 verifyFormat("b ? -a : c;"); 6502 verifyFormat("n * sizeof char16;"); 6503 verifyFormat("n * alignof char16;", getGoogleStyle()); 6504 verifyFormat("sizeof(char);"); 6505 verifyFormat("alignof(char);", getGoogleStyle()); 6506 6507 verifyFormat("return -1;"); 6508 verifyFormat("switch (a) {\n" 6509 "case -1:\n" 6510 " break;\n" 6511 "}"); 6512 verifyFormat("#define X -1"); 6513 verifyFormat("#define X -kConstant"); 6514 6515 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 6516 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 6517 6518 verifyFormat("int a = /* confusing comment */ -1;"); 6519 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 6520 verifyFormat("int a = i /* confusing comment */++;"); 6521 } 6522 6523 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 6524 verifyFormat("if (!aaaaaaaaaa( // break\n" 6525 " aaaaa)) {\n" 6526 "}"); 6527 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 6528 " aaaaa));"); 6529 verifyFormat("*aaa = aaaaaaa( // break\n" 6530 " bbbbbb);"); 6531 } 6532 6533 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 6534 verifyFormat("bool operator<();"); 6535 verifyFormat("bool operator>();"); 6536 verifyFormat("bool operator=();"); 6537 verifyFormat("bool operator==();"); 6538 verifyFormat("bool operator!=();"); 6539 verifyFormat("int operator+();"); 6540 verifyFormat("int operator++();"); 6541 verifyFormat("int operator++(int) volatile noexcept;"); 6542 verifyFormat("bool operator,();"); 6543 verifyFormat("bool operator();"); 6544 verifyFormat("bool operator()();"); 6545 verifyFormat("bool operator[]();"); 6546 verifyFormat("operator bool();"); 6547 verifyFormat("operator int();"); 6548 verifyFormat("operator void *();"); 6549 verifyFormat("operator SomeType<int>();"); 6550 verifyFormat("operator SomeType<int, int>();"); 6551 verifyFormat("operator SomeType<SomeType<int>>();"); 6552 verifyFormat("void *operator new(std::size_t size);"); 6553 verifyFormat("void *operator new[](std::size_t size);"); 6554 verifyFormat("void operator delete(void *ptr);"); 6555 verifyFormat("void operator delete[](void *ptr);"); 6556 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 6557 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 6558 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 6559 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 6560 6561 verifyFormat( 6562 "ostream &operator<<(ostream &OutputStream,\n" 6563 " SomeReallyLongType WithSomeReallyLongValue);"); 6564 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 6565 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 6566 " return left.group < right.group;\n" 6567 "}"); 6568 verifyFormat("SomeType &operator=(const SomeType &S);"); 6569 verifyFormat("f.template operator()<int>();"); 6570 6571 verifyGoogleFormat("operator void*();"); 6572 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 6573 verifyGoogleFormat("operator ::A();"); 6574 6575 verifyFormat("using A::operator+;"); 6576 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 6577 "int i;"); 6578 } 6579 6580 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 6581 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 6582 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 6583 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 6584 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 6585 verifyFormat("Deleted &operator=(const Deleted &) &;"); 6586 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 6587 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 6588 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 6589 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 6590 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 6591 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 6592 verifyFormat("void Fn(T const &) const &;"); 6593 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 6594 verifyFormat("template <typename T>\n" 6595 "void F(T) && = delete;", 6596 getGoogleStyle()); 6597 6598 FormatStyle AlignLeft = getLLVMStyle(); 6599 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 6600 verifyFormat("void A::b() && {}", AlignLeft); 6601 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 6602 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 6603 AlignLeft); 6604 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 6605 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 6606 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 6607 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 6608 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 6609 verifyFormat("auto Function(T) & -> void;", AlignLeft); 6610 verifyFormat("void Fn(T const&) const&;", AlignLeft); 6611 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 6612 6613 FormatStyle Spaces = getLLVMStyle(); 6614 Spaces.SpacesInCStyleCastParentheses = true; 6615 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 6616 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 6617 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 6618 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 6619 6620 Spaces.SpacesInCStyleCastParentheses = false; 6621 Spaces.SpacesInParentheses = true; 6622 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 6623 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", Spaces); 6624 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 6625 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 6626 } 6627 6628 TEST_F(FormatTest, UnderstandsNewAndDelete) { 6629 verifyFormat("void f() {\n" 6630 " A *a = new A;\n" 6631 " A *a = new (placement) A;\n" 6632 " delete a;\n" 6633 " delete (A *)a;\n" 6634 "}"); 6635 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 6636 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 6637 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6638 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 6639 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 6640 verifyFormat("delete[] h->p;"); 6641 } 6642 6643 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 6644 verifyFormat("int *f(int *a) {}"); 6645 verifyFormat("int main(int argc, char **argv) {}"); 6646 verifyFormat("Test::Test(int b) : a(b * b) {}"); 6647 verifyIndependentOfContext("f(a, *a);"); 6648 verifyFormat("void g() { f(*a); }"); 6649 verifyIndependentOfContext("int a = b * 10;"); 6650 verifyIndependentOfContext("int a = 10 * b;"); 6651 verifyIndependentOfContext("int a = b * c;"); 6652 verifyIndependentOfContext("int a += b * c;"); 6653 verifyIndependentOfContext("int a -= b * c;"); 6654 verifyIndependentOfContext("int a *= b * c;"); 6655 verifyIndependentOfContext("int a /= b * c;"); 6656 verifyIndependentOfContext("int a = *b;"); 6657 verifyIndependentOfContext("int a = *b * c;"); 6658 verifyIndependentOfContext("int a = b * *c;"); 6659 verifyIndependentOfContext("int a = b * (10);"); 6660 verifyIndependentOfContext("S << b * (10);"); 6661 verifyIndependentOfContext("return 10 * b;"); 6662 verifyIndependentOfContext("return *b * *c;"); 6663 verifyIndependentOfContext("return a & ~b;"); 6664 verifyIndependentOfContext("f(b ? *c : *d);"); 6665 verifyIndependentOfContext("int a = b ? *c : *d;"); 6666 verifyIndependentOfContext("*b = a;"); 6667 verifyIndependentOfContext("a * ~b;"); 6668 verifyIndependentOfContext("a * !b;"); 6669 verifyIndependentOfContext("a * +b;"); 6670 verifyIndependentOfContext("a * -b;"); 6671 verifyIndependentOfContext("a * ++b;"); 6672 verifyIndependentOfContext("a * --b;"); 6673 verifyIndependentOfContext("a[4] * b;"); 6674 verifyIndependentOfContext("a[a * a] = 1;"); 6675 verifyIndependentOfContext("f() * b;"); 6676 verifyIndependentOfContext("a * [self dostuff];"); 6677 verifyIndependentOfContext("int x = a * (a + b);"); 6678 verifyIndependentOfContext("(a *)(a + b);"); 6679 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 6680 verifyIndependentOfContext("int *pa = (int *)&a;"); 6681 verifyIndependentOfContext("return sizeof(int **);"); 6682 verifyIndependentOfContext("return sizeof(int ******);"); 6683 verifyIndependentOfContext("return (int **&)a;"); 6684 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 6685 verifyFormat("void f(Type (*parameter)[10]) {}"); 6686 verifyFormat("void f(Type (¶meter)[10]) {}"); 6687 verifyGoogleFormat("return sizeof(int**);"); 6688 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 6689 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 6690 verifyFormat("auto a = [](int **&, int ***) {};"); 6691 verifyFormat("auto PointerBinding = [](const char *S) {};"); 6692 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 6693 verifyFormat("[](const decltype(*a) &value) {}"); 6694 verifyFormat("decltype(a * b) F();"); 6695 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 6696 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 6697 verifyIndependentOfContext("typedef void (*f)(int *a);"); 6698 verifyIndependentOfContext("int i{a * b};"); 6699 verifyIndependentOfContext("aaa && aaa->f();"); 6700 verifyIndependentOfContext("int x = ~*p;"); 6701 verifyFormat("Constructor() : a(a), area(width * height) {}"); 6702 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 6703 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 6704 verifyFormat("void f() { f(a, c * d); }"); 6705 verifyFormat("void f() { f(new a(), c * d); }"); 6706 verifyFormat("void f(const MyOverride &override);"); 6707 verifyFormat("void f(const MyFinal &final);"); 6708 verifyIndependentOfContext("bool a = f() && override.f();"); 6709 verifyIndependentOfContext("bool a = f() && final.f();"); 6710 6711 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 6712 6713 verifyIndependentOfContext("A<int *> a;"); 6714 verifyIndependentOfContext("A<int **> a;"); 6715 verifyIndependentOfContext("A<int *, int *> a;"); 6716 verifyIndependentOfContext("A<int *[]> a;"); 6717 verifyIndependentOfContext( 6718 "const char *const p = reinterpret_cast<const char *const>(q);"); 6719 verifyIndependentOfContext("A<int **, int **> a;"); 6720 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 6721 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 6722 verifyFormat("for (; a && b;) {\n}"); 6723 verifyFormat("bool foo = true && [] { return false; }();"); 6724 6725 verifyFormat( 6726 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6727 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6728 6729 verifyGoogleFormat("int const* a = &b;"); 6730 verifyGoogleFormat("**outparam = 1;"); 6731 verifyGoogleFormat("*outparam = a * b;"); 6732 verifyGoogleFormat("int main(int argc, char** argv) {}"); 6733 verifyGoogleFormat("A<int*> a;"); 6734 verifyGoogleFormat("A<int**> a;"); 6735 verifyGoogleFormat("A<int*, int*> a;"); 6736 verifyGoogleFormat("A<int**, int**> a;"); 6737 verifyGoogleFormat("f(b ? *c : *d);"); 6738 verifyGoogleFormat("int a = b ? *c : *d;"); 6739 verifyGoogleFormat("Type* t = **x;"); 6740 verifyGoogleFormat("Type* t = *++*x;"); 6741 verifyGoogleFormat("*++*x;"); 6742 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 6743 verifyGoogleFormat("Type* t = x++ * y;"); 6744 verifyGoogleFormat( 6745 "const char* const p = reinterpret_cast<const char* const>(q);"); 6746 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 6747 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 6748 verifyGoogleFormat("template <typename T>\n" 6749 "void f(int i = 0, SomeType** temps = NULL);"); 6750 6751 FormatStyle Left = getLLVMStyle(); 6752 Left.PointerAlignment = FormatStyle::PAS_Left; 6753 verifyFormat("x = *a(x) = *a(y);", Left); 6754 verifyFormat("for (;; *a = b) {\n}", Left); 6755 verifyFormat("return *this += 1;", Left); 6756 verifyFormat("throw *x;", Left); 6757 verifyFormat("delete *x;", Left); 6758 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 6759 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 6760 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 6761 6762 verifyIndependentOfContext("a = *(x + y);"); 6763 verifyIndependentOfContext("a = &(x + y);"); 6764 verifyIndependentOfContext("*(x + y).call();"); 6765 verifyIndependentOfContext("&(x + y)->call();"); 6766 verifyFormat("void f() { &(*I).first; }"); 6767 6768 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 6769 verifyFormat( 6770 "int *MyValues = {\n" 6771 " *A, // Operator detection might be confused by the '{'\n" 6772 " *BB // Operator detection might be confused by previous comment\n" 6773 "};"); 6774 6775 verifyIndependentOfContext("if (int *a = &b)"); 6776 verifyIndependentOfContext("if (int &a = *b)"); 6777 verifyIndependentOfContext("if (a & b[i])"); 6778 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 6779 verifyIndependentOfContext("if (*b[i])"); 6780 verifyIndependentOfContext("if (int *a = (&b))"); 6781 verifyIndependentOfContext("while (int *a = &b)"); 6782 verifyIndependentOfContext("size = sizeof *a;"); 6783 verifyIndependentOfContext("if (a && (b = c))"); 6784 verifyFormat("void f() {\n" 6785 " for (const int &v : Values) {\n" 6786 " }\n" 6787 "}"); 6788 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 6789 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 6790 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 6791 6792 verifyFormat("#define A (!a * b)"); 6793 verifyFormat("#define MACRO \\\n" 6794 " int *i = a * b; \\\n" 6795 " void f(a *b);", 6796 getLLVMStyleWithColumns(19)); 6797 6798 verifyIndependentOfContext("A = new SomeType *[Length];"); 6799 verifyIndependentOfContext("A = new SomeType *[Length]();"); 6800 verifyIndependentOfContext("T **t = new T *;"); 6801 verifyIndependentOfContext("T **t = new T *();"); 6802 verifyGoogleFormat("A = new SomeType*[Length]();"); 6803 verifyGoogleFormat("A = new SomeType*[Length];"); 6804 verifyGoogleFormat("T** t = new T*;"); 6805 verifyGoogleFormat("T** t = new T*();"); 6806 6807 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 6808 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 6809 verifyFormat("template <bool a, bool b> " 6810 "typename t::if<x && y>::type f() {}"); 6811 verifyFormat("template <int *y> f() {}"); 6812 verifyFormat("vector<int *> v;"); 6813 verifyFormat("vector<int *const> v;"); 6814 verifyFormat("vector<int *const **const *> v;"); 6815 verifyFormat("vector<int *volatile> v;"); 6816 verifyFormat("vector<a * b> v;"); 6817 verifyFormat("foo<b && false>();"); 6818 verifyFormat("foo<b & 1>();"); 6819 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 6820 verifyFormat( 6821 "template <class T, class = typename std::enable_if<\n" 6822 " std::is_integral<T>::value &&\n" 6823 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 6824 "void F();", 6825 getLLVMStyleWithColumns(70)); 6826 verifyFormat( 6827 "template <class T,\n" 6828 " class = typename std::enable_if<\n" 6829 " std::is_integral<T>::value &&\n" 6830 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 6831 " class U>\n" 6832 "void F();", 6833 getLLVMStyleWithColumns(70)); 6834 verifyFormat( 6835 "template <class T,\n" 6836 " class = typename ::std::enable_if<\n" 6837 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 6838 "void F();", 6839 getGoogleStyleWithColumns(68)); 6840 6841 verifyIndependentOfContext("MACRO(int *i);"); 6842 verifyIndependentOfContext("MACRO(auto *a);"); 6843 verifyIndependentOfContext("MACRO(const A *a);"); 6844 verifyIndependentOfContext("MACRO(A *const a);"); 6845 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 6846 verifyFormat("void f() { f(float{1}, a * a); }"); 6847 // FIXME: Is there a way to make this work? 6848 // verifyIndependentOfContext("MACRO(A *a);"); 6849 6850 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 6851 verifyFormat("return options != nullptr && operator==(*options);"); 6852 6853 EXPECT_EQ("#define OP(x) \\\n" 6854 " ostream &operator<<(ostream &s, const A &a) { \\\n" 6855 " return s << a.DebugString(); \\\n" 6856 " }", 6857 format("#define OP(x) \\\n" 6858 " ostream &operator<<(ostream &s, const A &a) { \\\n" 6859 " return s << a.DebugString(); \\\n" 6860 " }", 6861 getLLVMStyleWithColumns(50))); 6862 6863 // FIXME: We cannot handle this case yet; we might be able to figure out that 6864 // foo<x> d > v; doesn't make sense. 6865 verifyFormat("foo<a<b && c> d> v;"); 6866 6867 FormatStyle PointerMiddle = getLLVMStyle(); 6868 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 6869 verifyFormat("delete *x;", PointerMiddle); 6870 verifyFormat("int * x;", PointerMiddle); 6871 verifyFormat("int *[] x;", PointerMiddle); 6872 verifyFormat("template <int * y> f() {}", PointerMiddle); 6873 verifyFormat("int * f(int * a) {}", PointerMiddle); 6874 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 6875 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 6876 verifyFormat("A<int *> a;", PointerMiddle); 6877 verifyFormat("A<int **> a;", PointerMiddle); 6878 verifyFormat("A<int *, int *> a;", PointerMiddle); 6879 verifyFormat("A<int *[]> a;", PointerMiddle); 6880 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 6881 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 6882 verifyFormat("T ** t = new T *;", PointerMiddle); 6883 6884 // Member function reference qualifiers aren't binary operators. 6885 verifyFormat("string // break\n" 6886 "operator()() & {}"); 6887 verifyFormat("string // break\n" 6888 "operator()() && {}"); 6889 verifyGoogleFormat("template <typename T>\n" 6890 "auto x() & -> int {}"); 6891 } 6892 6893 TEST_F(FormatTest, UnderstandsAttributes) { 6894 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 6895 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 6896 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 6897 FormatStyle AfterType = getLLVMStyle(); 6898 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 6899 verifyFormat("__attribute__((nodebug)) void\n" 6900 "foo() {}\n", 6901 AfterType); 6902 } 6903 6904 TEST_F(FormatTest, UnderstandsSquareAttributes) { 6905 verifyFormat("SomeType s [[unused]] (InitValue);"); 6906 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 6907 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 6908 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 6909 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 6910 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6911 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 6912 6913 // Make sure we do not mistake attributes for array subscripts. 6914 verifyFormat("int a() {}\n" 6915 "[[unused]] int b() {}\n"); 6916 verifyFormat("NSArray *arr;\n" 6917 "arr[[Foo() bar]];"); 6918 6919 // On the other hand, we still need to correctly find array subscripts. 6920 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 6921 6922 // Make sure we do not parse attributes as lambda introducers. 6923 FormatStyle MultiLineFunctions = getLLVMStyle(); 6924 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 6925 verifyFormat("[[unused]] int b() {\n" 6926 " return 42;\n" 6927 "}\n", 6928 MultiLineFunctions); 6929 } 6930 6931 TEST_F(FormatTest, UnderstandsEllipsis) { 6932 verifyFormat("int printf(const char *fmt, ...);"); 6933 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 6934 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 6935 6936 FormatStyle PointersLeft = getLLVMStyle(); 6937 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 6938 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 6939 } 6940 6941 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 6942 EXPECT_EQ("int *a;\n" 6943 "int *a;\n" 6944 "int *a;", 6945 format("int *a;\n" 6946 "int* a;\n" 6947 "int *a;", 6948 getGoogleStyle())); 6949 EXPECT_EQ("int* a;\n" 6950 "int* a;\n" 6951 "int* a;", 6952 format("int* a;\n" 6953 "int* a;\n" 6954 "int *a;", 6955 getGoogleStyle())); 6956 EXPECT_EQ("int *a;\n" 6957 "int *a;\n" 6958 "int *a;", 6959 format("int *a;\n" 6960 "int * a;\n" 6961 "int * a;", 6962 getGoogleStyle())); 6963 EXPECT_EQ("auto x = [] {\n" 6964 " int *a;\n" 6965 " int *a;\n" 6966 " int *a;\n" 6967 "};", 6968 format("auto x=[]{int *a;\n" 6969 "int * a;\n" 6970 "int * a;};", 6971 getGoogleStyle())); 6972 } 6973 6974 TEST_F(FormatTest, UnderstandsRvalueReferences) { 6975 verifyFormat("int f(int &&a) {}"); 6976 verifyFormat("int f(int a, char &&b) {}"); 6977 verifyFormat("void f() { int &&a = b; }"); 6978 verifyGoogleFormat("int f(int a, char&& b) {}"); 6979 verifyGoogleFormat("void f() { int&& a = b; }"); 6980 6981 verifyIndependentOfContext("A<int &&> a;"); 6982 verifyIndependentOfContext("A<int &&, int &&> a;"); 6983 verifyGoogleFormat("A<int&&> a;"); 6984 verifyGoogleFormat("A<int&&, int&&> a;"); 6985 6986 // Not rvalue references: 6987 verifyFormat("template <bool B, bool C> class A {\n" 6988 " static_assert(B && C, \"Something is wrong\");\n" 6989 "};"); 6990 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 6991 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 6992 verifyFormat("#define A(a, b) (a && b)"); 6993 } 6994 6995 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 6996 verifyFormat("void f() {\n" 6997 " x[aaaaaaaaa -\n" 6998 " b] = 23;\n" 6999 "}", 7000 getLLVMStyleWithColumns(15)); 7001 } 7002 7003 TEST_F(FormatTest, FormatsCasts) { 7004 verifyFormat("Type *A = static_cast<Type *>(P);"); 7005 verifyFormat("Type *A = (Type *)P;"); 7006 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7007 verifyFormat("int a = (int)(2.0f);"); 7008 verifyFormat("int a = (int)2.0f;"); 7009 verifyFormat("x[(int32)y];"); 7010 verifyFormat("x = (int32)y;"); 7011 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7012 verifyFormat("int a = (int)*b;"); 7013 verifyFormat("int a = (int)2.0f;"); 7014 verifyFormat("int a = (int)~0;"); 7015 verifyFormat("int a = (int)++a;"); 7016 verifyFormat("int a = (int)sizeof(int);"); 7017 verifyFormat("int a = (int)+2;"); 7018 verifyFormat("my_int a = (my_int)2.0f;"); 7019 verifyFormat("my_int a = (my_int)sizeof(int);"); 7020 verifyFormat("return (my_int)aaa;"); 7021 verifyFormat("#define x ((int)-1)"); 7022 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7023 verifyFormat("#define p(q) ((int *)&q)"); 7024 verifyFormat("fn(a)(b) + 1;"); 7025 7026 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7027 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7028 verifyFormat("my_int a = (my_int)~0;"); 7029 verifyFormat("my_int a = (my_int)++a;"); 7030 verifyFormat("my_int a = (my_int)-2;"); 7031 verifyFormat("my_int a = (my_int)1;"); 7032 verifyFormat("my_int a = (my_int *)1;"); 7033 verifyFormat("my_int a = (const my_int)-1;"); 7034 verifyFormat("my_int a = (const my_int *)-1;"); 7035 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7036 verifyFormat("my_int a = (ns::my_int)-2;"); 7037 verifyFormat("case (my_int)ONE:"); 7038 verifyFormat("auto x = (X)this;"); 7039 7040 // FIXME: single value wrapped with paren will be treated as cast. 7041 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7042 7043 verifyFormat("{ (void)F; }"); 7044 7045 // Don't break after a cast's 7046 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7047 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7048 " bbbbbbbbbbbbbbbbbbbbbb);"); 7049 7050 // These are not casts. 7051 verifyFormat("void f(int *) {}"); 7052 verifyFormat("f(foo)->b;"); 7053 verifyFormat("f(foo).b;"); 7054 verifyFormat("f(foo)(b);"); 7055 verifyFormat("f(foo)[b];"); 7056 verifyFormat("[](foo) { return 4; }(bar);"); 7057 verifyFormat("(*funptr)(foo)[4];"); 7058 verifyFormat("funptrs[4](foo)[4];"); 7059 verifyFormat("void f(int *);"); 7060 verifyFormat("void f(int *) = 0;"); 7061 verifyFormat("void f(SmallVector<int>) {}"); 7062 verifyFormat("void f(SmallVector<int>);"); 7063 verifyFormat("void f(SmallVector<int>) = 0;"); 7064 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7065 verifyFormat("int a = sizeof(int) * b;"); 7066 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7067 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7068 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7069 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7070 7071 // These are not casts, but at some point were confused with casts. 7072 verifyFormat("virtual void foo(int *) override;"); 7073 verifyFormat("virtual void foo(char &) const;"); 7074 verifyFormat("virtual void foo(int *a, char *) const;"); 7075 verifyFormat("int a = sizeof(int *) + b;"); 7076 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7077 verifyFormat("bool b = f(g<int>) && c;"); 7078 verifyFormat("typedef void (*f)(int i) func;"); 7079 7080 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7081 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7082 // FIXME: The indentation here is not ideal. 7083 verifyFormat( 7084 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7085 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7086 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7087 } 7088 7089 TEST_F(FormatTest, FormatsFunctionTypes) { 7090 verifyFormat("A<bool()> a;"); 7091 verifyFormat("A<SomeType()> a;"); 7092 verifyFormat("A<void (*)(int, std::string)> a;"); 7093 verifyFormat("A<void *(int)>;"); 7094 verifyFormat("void *(*a)(int *, SomeType *);"); 7095 verifyFormat("int (*func)(void *);"); 7096 verifyFormat("void f() { int (*func)(void *); }"); 7097 verifyFormat("template <class CallbackClass>\n" 7098 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7099 7100 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7101 verifyGoogleFormat("void* (*a)(int);"); 7102 verifyGoogleFormat( 7103 "template <class CallbackClass>\n" 7104 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7105 7106 // Other constructs can look somewhat like function types: 7107 verifyFormat("A<sizeof(*x)> a;"); 7108 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7109 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7110 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7111 verifyFormat("int x = f(&h)();"); 7112 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7113 verifyFormat("std::function<\n" 7114 " LooooooooooongTemplatedType<\n" 7115 " SomeType>*(\n" 7116 " LooooooooooooooooongType type)>\n" 7117 " function;", 7118 getGoogleStyleWithColumns(40)); 7119 } 7120 7121 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7122 verifyFormat("A (*foo_)[6];"); 7123 verifyFormat("vector<int> (*foo_)[6];"); 7124 } 7125 7126 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7127 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7128 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7129 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7130 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7131 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7132 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7133 7134 // Different ways of ()-initializiation. 7135 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7136 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7137 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7138 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7139 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7140 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7141 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7142 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7143 7144 // Lambdas should not confuse the variable declaration heuristic. 7145 verifyFormat("LooooooooooooooooongType\n" 7146 " variable(nullptr, [](A *a) {});", 7147 getLLVMStyleWithColumns(40)); 7148 } 7149 7150 TEST_F(FormatTest, BreaksLongDeclarations) { 7151 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7152 " AnotherNameForTheLongType;"); 7153 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7154 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7155 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7156 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7157 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7158 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7159 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7160 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7161 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7162 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7163 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7164 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7165 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7166 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7167 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7168 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7169 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7170 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7171 FormatStyle Indented = getLLVMStyle(); 7172 Indented.IndentWrappedFunctionNames = true; 7173 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7174 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7175 Indented); 7176 verifyFormat( 7177 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7178 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7179 Indented); 7180 verifyFormat( 7181 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7182 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7183 Indented); 7184 verifyFormat( 7185 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7186 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7187 Indented); 7188 7189 // FIXME: Without the comment, this breaks after "(". 7190 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7191 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7192 getGoogleStyle()); 7193 7194 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7195 " int LoooooooooooooooooooongParam2) {}"); 7196 verifyFormat( 7197 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7198 " SourceLocation L, IdentifierIn *II,\n" 7199 " Type *T) {}"); 7200 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7201 "ReallyReaaallyLongFunctionName(\n" 7202 " const std::string &SomeParameter,\n" 7203 " const SomeType<string, SomeOtherTemplateParameter>\n" 7204 " &ReallyReallyLongParameterName,\n" 7205 " const SomeType<string, SomeOtherTemplateParameter>\n" 7206 " &AnotherLongParameterName) {}"); 7207 verifyFormat("template <typename A>\n" 7208 "SomeLoooooooooooooooooooooongType<\n" 7209 " typename some_namespace::SomeOtherType<A>::Type>\n" 7210 "Function() {}"); 7211 7212 verifyGoogleFormat( 7213 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7214 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7215 verifyGoogleFormat( 7216 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7217 " SourceLocation L) {}"); 7218 verifyGoogleFormat( 7219 "some_namespace::LongReturnType\n" 7220 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7221 " int first_long_parameter, int second_parameter) {}"); 7222 7223 verifyGoogleFormat("template <typename T>\n" 7224 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7225 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7226 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7227 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7228 7229 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7230 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7231 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7232 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7233 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7234 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 7235 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7236 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 7237 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 7238 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7239 7240 verifyFormat("template <typename T> // Templates on own line.\n" 7241 "static int // Some comment.\n" 7242 "MyFunction(int a);", 7243 getLLVMStyle()); 7244 } 7245 7246 TEST_F(FormatTest, FormatsArrays) { 7247 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7248 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 7249 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 7250 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 7251 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 7252 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 7253 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7254 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7255 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7256 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 7257 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7258 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7259 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7260 verifyFormat( 7261 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 7262 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7263 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 7264 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 7265 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7266 7267 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 7268 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 7269 verifyFormat( 7270 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 7271 " .aaaaaaa[0]\n" 7272 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7273 verifyFormat("a[::b::c];"); 7274 7275 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 7276 7277 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 7278 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 7279 } 7280 7281 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 7282 verifyFormat("(a)->b();"); 7283 verifyFormat("--a;"); 7284 } 7285 7286 TEST_F(FormatTest, HandlesIncludeDirectives) { 7287 verifyFormat("#include <string>\n" 7288 "#include <a/b/c.h>\n" 7289 "#include \"a/b/string\"\n" 7290 "#include \"string.h\"\n" 7291 "#include \"string.h\"\n" 7292 "#include <a-a>\n" 7293 "#include < path with space >\n" 7294 "#include_next <test.h>" 7295 "#include \"abc.h\" // this is included for ABC\n" 7296 "#include \"some long include\" // with a comment\n" 7297 "#include \"some very long include path\"\n" 7298 "#include <some/very/long/include/path>\n", 7299 getLLVMStyleWithColumns(35)); 7300 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 7301 EXPECT_EQ("#include <a>", format("#include<a>")); 7302 7303 verifyFormat("#import <string>"); 7304 verifyFormat("#import <a/b/c.h>"); 7305 verifyFormat("#import \"a/b/string\""); 7306 verifyFormat("#import \"string.h\""); 7307 verifyFormat("#import \"string.h\""); 7308 verifyFormat("#if __has_include(<strstream>)\n" 7309 "#include <strstream>\n" 7310 "#endif"); 7311 7312 verifyFormat("#define MY_IMPORT <a/b>"); 7313 7314 verifyFormat("#if __has_include(<a/b>)"); 7315 verifyFormat("#if __has_include_next(<a/b>)"); 7316 verifyFormat("#define F __has_include(<a/b>)"); 7317 verifyFormat("#define F __has_include_next(<a/b>)"); 7318 7319 // Protocol buffer definition or missing "#". 7320 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 7321 getLLVMStyleWithColumns(30)); 7322 7323 FormatStyle Style = getLLVMStyle(); 7324 Style.AlwaysBreakBeforeMultilineStrings = true; 7325 Style.ColumnLimit = 0; 7326 verifyFormat("#import \"abc.h\"", Style); 7327 7328 // But 'import' might also be a regular C++ namespace. 7329 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7330 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7331 } 7332 7333 //===----------------------------------------------------------------------===// 7334 // Error recovery tests. 7335 //===----------------------------------------------------------------------===// 7336 7337 TEST_F(FormatTest, IncompleteParameterLists) { 7338 FormatStyle NoBinPacking = getLLVMStyle(); 7339 NoBinPacking.BinPackParameters = false; 7340 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 7341 " double *min_x,\n" 7342 " double *max_x,\n" 7343 " double *min_y,\n" 7344 " double *max_y,\n" 7345 " double *min_z,\n" 7346 " double *max_z, ) {}", 7347 NoBinPacking); 7348 } 7349 7350 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 7351 verifyFormat("void f() { return; }\n42"); 7352 verifyFormat("void f() {\n" 7353 " if (0)\n" 7354 " return;\n" 7355 "}\n" 7356 "42"); 7357 verifyFormat("void f() { return }\n42"); 7358 verifyFormat("void f() {\n" 7359 " if (0)\n" 7360 " return\n" 7361 "}\n" 7362 "42"); 7363 } 7364 7365 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 7366 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 7367 EXPECT_EQ("void f() {\n" 7368 " if (a)\n" 7369 " return\n" 7370 "}", 7371 format("void f ( ) { if ( a ) return }")); 7372 EXPECT_EQ("namespace N {\n" 7373 "void f()\n" 7374 "}", 7375 format("namespace N { void f() }")); 7376 EXPECT_EQ("namespace N {\n" 7377 "void f() {}\n" 7378 "void g()\n" 7379 "} // namespace N", 7380 format("namespace N { void f( ) { } void g( ) }")); 7381 } 7382 7383 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 7384 verifyFormat("int aaaaaaaa =\n" 7385 " // Overlylongcomment\n" 7386 " b;", 7387 getLLVMStyleWithColumns(20)); 7388 verifyFormat("function(\n" 7389 " ShortArgument,\n" 7390 " LoooooooooooongArgument);\n", 7391 getLLVMStyleWithColumns(20)); 7392 } 7393 7394 TEST_F(FormatTest, IncorrectAccessSpecifier) { 7395 verifyFormat("public:"); 7396 verifyFormat("class A {\n" 7397 "public\n" 7398 " void f() {}\n" 7399 "};"); 7400 verifyFormat("public\n" 7401 "int qwerty;"); 7402 verifyFormat("public\n" 7403 "B {}"); 7404 verifyFormat("public\n" 7405 "{}"); 7406 verifyFormat("public\n" 7407 "B { int x; }"); 7408 } 7409 7410 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 7411 verifyFormat("{"); 7412 verifyFormat("#})"); 7413 verifyNoCrash("(/**/[:!] ?[)."); 7414 } 7415 7416 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 7417 // Found by oss-fuzz: 7418 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 7419 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 7420 Style.ColumnLimit = 60; 7421 verifyNoCrash( 7422 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 7423 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 7424 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 7425 Style); 7426 } 7427 7428 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 7429 verifyFormat("do {\n}"); 7430 verifyFormat("do {\n}\n" 7431 "f();"); 7432 verifyFormat("do {\n}\n" 7433 "wheeee(fun);"); 7434 verifyFormat("do {\n" 7435 " f();\n" 7436 "}"); 7437 } 7438 7439 TEST_F(FormatTest, IncorrectCodeMissingParens) { 7440 verifyFormat("if {\n foo;\n foo();\n}"); 7441 verifyFormat("switch {\n foo;\n foo();\n}"); 7442 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 7443 verifyFormat("while {\n foo;\n foo();\n}"); 7444 verifyFormat("do {\n foo;\n foo();\n} while;"); 7445 } 7446 7447 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 7448 verifyIncompleteFormat("namespace {\n" 7449 "class Foo { Foo (\n" 7450 "};\n" 7451 "} // namespace"); 7452 } 7453 7454 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 7455 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 7456 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 7457 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 7458 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 7459 7460 EXPECT_EQ("{\n" 7461 " {\n" 7462 " breakme(\n" 7463 " qwe);\n" 7464 " }\n", 7465 format("{\n" 7466 " {\n" 7467 " breakme(qwe);\n" 7468 "}\n", 7469 getLLVMStyleWithColumns(10))); 7470 } 7471 7472 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 7473 verifyFormat("int x = {\n" 7474 " avariable,\n" 7475 " b(alongervariable)};", 7476 getLLVMStyleWithColumns(25)); 7477 } 7478 7479 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 7480 verifyFormat("return (a)(b){1, 2, 3};"); 7481 } 7482 7483 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 7484 verifyFormat("vector<int> x{1, 2, 3, 4};"); 7485 verifyFormat("vector<int> x{\n" 7486 " 1,\n" 7487 " 2,\n" 7488 " 3,\n" 7489 " 4,\n" 7490 "};"); 7491 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 7492 verifyFormat("f({1, 2});"); 7493 verifyFormat("auto v = Foo{-1};"); 7494 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 7495 verifyFormat("Class::Class : member{1, 2, 3} {}"); 7496 verifyFormat("new vector<int>{1, 2, 3};"); 7497 verifyFormat("new int[3]{1, 2, 3};"); 7498 verifyFormat("new int{1};"); 7499 verifyFormat("return {arg1, arg2};"); 7500 verifyFormat("return {arg1, SomeType{parameter}};"); 7501 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 7502 verifyFormat("new T{arg1, arg2};"); 7503 verifyFormat("f(MyMap[{composite, key}]);"); 7504 verifyFormat("class Class {\n" 7505 " T member = {arg1, arg2};\n" 7506 "};"); 7507 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 7508 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 7509 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 7510 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 7511 verifyFormat("int a = std::is_integral<int>{} + 0;"); 7512 7513 verifyFormat("int foo(int i) { return fo1{}(i); }"); 7514 verifyFormat("int foo(int i) { return fo1{}(i); }"); 7515 verifyFormat("auto i = decltype(x){};"); 7516 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 7517 verifyFormat("Node n{1, Node{1000}, //\n" 7518 " 2};"); 7519 verifyFormat("Aaaa aaaaaaa{\n" 7520 " {\n" 7521 " aaaa,\n" 7522 " },\n" 7523 "};"); 7524 verifyFormat("class C : public D {\n" 7525 " SomeClass SC{2};\n" 7526 "};"); 7527 verifyFormat("class C : public A {\n" 7528 " class D : public B {\n" 7529 " void f() { int i{2}; }\n" 7530 " };\n" 7531 "};"); 7532 verifyFormat("#define A {a, a},"); 7533 7534 // Avoid breaking between equal sign and opening brace 7535 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 7536 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 7537 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 7538 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 7539 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 7540 " {\"ccccccccccccccccccccc\", 2}};", 7541 AvoidBreakingFirstArgument); 7542 7543 // Binpacking only if there is no trailing comma 7544 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 7545 " cccccccccc, dddddddddd};", 7546 getLLVMStyleWithColumns(50)); 7547 verifyFormat("const Aaaaaa aaaaa = {\n" 7548 " aaaaaaaaaaa,\n" 7549 " bbbbbbbbbbb,\n" 7550 " ccccccccccc,\n" 7551 " ddddddddddd,\n" 7552 "};", getLLVMStyleWithColumns(50)); 7553 7554 // Cases where distinguising braced lists and blocks is hard. 7555 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 7556 verifyFormat("void f() {\n" 7557 " return; // comment\n" 7558 "}\n" 7559 "SomeType t;"); 7560 verifyFormat("void f() {\n" 7561 " if (a) {\n" 7562 " f();\n" 7563 " }\n" 7564 "}\n" 7565 "SomeType t;"); 7566 7567 // In combination with BinPackArguments = false. 7568 FormatStyle NoBinPacking = getLLVMStyle(); 7569 NoBinPacking.BinPackArguments = false; 7570 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 7571 " bbbbb,\n" 7572 " ccccc,\n" 7573 " ddddd,\n" 7574 " eeeee,\n" 7575 " ffffff,\n" 7576 " ggggg,\n" 7577 " hhhhhh,\n" 7578 " iiiiii,\n" 7579 " jjjjjj,\n" 7580 " kkkkkk};", 7581 NoBinPacking); 7582 verifyFormat("const Aaaaaa aaaaa = {\n" 7583 " aaaaa,\n" 7584 " bbbbb,\n" 7585 " ccccc,\n" 7586 " ddddd,\n" 7587 " eeeee,\n" 7588 " ffffff,\n" 7589 " ggggg,\n" 7590 " hhhhhh,\n" 7591 " iiiiii,\n" 7592 " jjjjjj,\n" 7593 " kkkkkk,\n" 7594 "};", 7595 NoBinPacking); 7596 verifyFormat( 7597 "const Aaaaaa aaaaa = {\n" 7598 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 7599 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 7600 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 7601 "};", 7602 NoBinPacking); 7603 7604 // FIXME: The alignment of these trailing comments might be bad. Then again, 7605 // this might be utterly useless in real code. 7606 verifyFormat("Constructor::Constructor()\n" 7607 " : some_value{ //\n" 7608 " aaaaaaa, //\n" 7609 " bbbbbbb} {}"); 7610 7611 // In braced lists, the first comment is always assumed to belong to the 7612 // first element. Thus, it can be moved to the next or previous line as 7613 // appropriate. 7614 EXPECT_EQ("function({// First element:\n" 7615 " 1,\n" 7616 " // Second element:\n" 7617 " 2});", 7618 format("function({\n" 7619 " // First element:\n" 7620 " 1,\n" 7621 " // Second element:\n" 7622 " 2});")); 7623 EXPECT_EQ("std::vector<int> MyNumbers{\n" 7624 " // First element:\n" 7625 " 1,\n" 7626 " // Second element:\n" 7627 " 2};", 7628 format("std::vector<int> MyNumbers{// First element:\n" 7629 " 1,\n" 7630 " // Second element:\n" 7631 " 2};", 7632 getLLVMStyleWithColumns(30))); 7633 // A trailing comma should still lead to an enforced line break and no 7634 // binpacking. 7635 EXPECT_EQ("vector<int> SomeVector = {\n" 7636 " // aaa\n" 7637 " 1,\n" 7638 " 2,\n" 7639 "};", 7640 format("vector<int> SomeVector = { // aaa\n" 7641 " 1, 2, };")); 7642 7643 FormatStyle ExtraSpaces = getLLVMStyle(); 7644 ExtraSpaces.Cpp11BracedListStyle = false; 7645 ExtraSpaces.ColumnLimit = 75; 7646 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 7647 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 7648 verifyFormat("f({ 1, 2 });", ExtraSpaces); 7649 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 7650 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 7651 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 7652 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 7653 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 7654 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 7655 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 7656 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 7657 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 7658 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 7659 verifyFormat("class Class {\n" 7660 " T member = { arg1, arg2 };\n" 7661 "};", 7662 ExtraSpaces); 7663 verifyFormat( 7664 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7665 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 7666 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 7667 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 7668 ExtraSpaces); 7669 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 7670 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 7671 ExtraSpaces); 7672 verifyFormat( 7673 "someFunction(OtherParam,\n" 7674 " BracedList{ // comment 1 (Forcing interesting break)\n" 7675 " param1, param2,\n" 7676 " // comment 2\n" 7677 " param3, param4 });", 7678 ExtraSpaces); 7679 verifyFormat( 7680 "std::this_thread::sleep_for(\n" 7681 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 7682 ExtraSpaces); 7683 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 7684 " aaaaaaa,\n" 7685 " aaaaaaaaaa,\n" 7686 " aaaaa,\n" 7687 " aaaaaaaaaaaaaaa,\n" 7688 " aaa,\n" 7689 " aaaaaaaaaa,\n" 7690 " a,\n" 7691 " aaaaaaaaaaaaaaaaaaaaa,\n" 7692 " aaaaaaaaaaaa,\n" 7693 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 7694 " aaaaaaa,\n" 7695 " a};"); 7696 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 7697 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 7698 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 7699 7700 // Avoid breaking between initializer/equal sign and opening brace 7701 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 7702 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 7703 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 7704 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 7705 " { \"ccccccccccccccccccccc\", 2 }\n" 7706 "};", 7707 ExtraSpaces); 7708 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 7709 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 7710 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 7711 " { \"ccccccccccccccccccccc\", 2 }\n" 7712 "};", 7713 ExtraSpaces); 7714 7715 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 7716 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 7717 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 7718 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 7719 } 7720 7721 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 7722 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7723 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7724 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7725 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7726 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7727 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 7728 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 7729 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7730 " 1, 22, 333, 4444, 55555, //\n" 7731 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7732 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 7733 verifyFormat( 7734 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7735 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7736 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 7737 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 7738 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 7739 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 7740 " 7777777};"); 7741 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 7742 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 7743 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 7744 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 7745 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 7746 " // Separating comment.\n" 7747 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 7748 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 7749 " // Leading comment\n" 7750 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 7751 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 7752 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 7753 " 1, 1, 1, 1};", 7754 getLLVMStyleWithColumns(39)); 7755 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 7756 " 1, 1, 1, 1};", 7757 getLLVMStyleWithColumns(38)); 7758 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 7759 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 7760 getLLVMStyleWithColumns(43)); 7761 verifyFormat( 7762 "static unsigned SomeValues[10][3] = {\n" 7763 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 7764 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 7765 verifyFormat("static auto fields = new vector<string>{\n" 7766 " \"aaaaaaaaaaaaa\",\n" 7767 " \"aaaaaaaaaaaaa\",\n" 7768 " \"aaaaaaaaaaaa\",\n" 7769 " \"aaaaaaaaaaaaaa\",\n" 7770 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 7771 " \"aaaaaaaaaaaa\",\n" 7772 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 7773 "};"); 7774 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 7775 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 7776 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 7777 " 3, cccccccccccccccccccccc};", 7778 getLLVMStyleWithColumns(60)); 7779 7780 // Trailing commas. 7781 verifyFormat("vector<int> x = {\n" 7782 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 7783 "};", 7784 getLLVMStyleWithColumns(39)); 7785 verifyFormat("vector<int> x = {\n" 7786 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 7787 "};", 7788 getLLVMStyleWithColumns(39)); 7789 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 7790 " 1, 1, 1, 1,\n" 7791 " /**/ /**/};", 7792 getLLVMStyleWithColumns(39)); 7793 7794 // Trailing comment in the first line. 7795 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 7796 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 7797 " 111111111, 222222222, 3333333333, 444444444, //\n" 7798 " 11111111, 22222222, 333333333, 44444444};"); 7799 // Trailing comment in the last line. 7800 verifyFormat("int aaaaa[] = {\n" 7801 " 1, 2, 3, // comment\n" 7802 " 4, 5, 6 // comment\n" 7803 "};"); 7804 7805 // With nested lists, we should either format one item per line or all nested 7806 // lists one on line. 7807 // FIXME: For some nested lists, we can do better. 7808 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 7809 " {aaaaaaaaaaaaaaaaaaa},\n" 7810 " {aaaaaaaaaaaaaaaaaaaaa},\n" 7811 " {aaaaaaaaaaaaaaaaa}};", 7812 getLLVMStyleWithColumns(60)); 7813 verifyFormat( 7814 "SomeStruct my_struct_array = {\n" 7815 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 7816 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 7817 " {aaa, aaa},\n" 7818 " {aaa, aaa},\n" 7819 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 7820 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 7821 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 7822 7823 // No column layout should be used here. 7824 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 7825 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 7826 7827 verifyNoCrash("a<,"); 7828 7829 // No braced initializer here. 7830 verifyFormat("void f() {\n" 7831 " struct Dummy {};\n" 7832 " f(v);\n" 7833 "}"); 7834 7835 // Long lists should be formatted in columns even if they are nested. 7836 verifyFormat( 7837 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7838 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7839 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7840 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7841 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7842 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 7843 7844 // Allow "single-column" layout even if that violates the column limit. There 7845 // isn't going to be a better way. 7846 verifyFormat("std::vector<int> a = {\n" 7847 " aaaaaaaa,\n" 7848 " aaaaaaaa,\n" 7849 " aaaaaaaa,\n" 7850 " aaaaaaaa,\n" 7851 " aaaaaaaaaa,\n" 7852 " aaaaaaaa,\n" 7853 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 7854 getLLVMStyleWithColumns(30)); 7855 verifyFormat("vector<int> aaaa = {\n" 7856 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7857 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7858 " aaaaaa.aaaaaaa,\n" 7859 " aaaaaa.aaaaaaa,\n" 7860 " aaaaaa.aaaaaaa,\n" 7861 " aaaaaa.aaaaaaa,\n" 7862 "};"); 7863 7864 // Don't create hanging lists. 7865 verifyFormat("someFunction(Param, {List1, List2,\n" 7866 " List3});", 7867 getLLVMStyleWithColumns(35)); 7868 verifyFormat("someFunction(Param, Param,\n" 7869 " {List1, List2,\n" 7870 " List3});", 7871 getLLVMStyleWithColumns(35)); 7872 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 7873 " aaaaaaaaaaaaaaaaaaaaaaa);"); 7874 } 7875 7876 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 7877 FormatStyle DoNotMerge = getLLVMStyle(); 7878 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7879 7880 verifyFormat("void f() { return 42; }"); 7881 verifyFormat("void f() {\n" 7882 " return 42;\n" 7883 "}", 7884 DoNotMerge); 7885 verifyFormat("void f() {\n" 7886 " // Comment\n" 7887 "}"); 7888 verifyFormat("{\n" 7889 "#error {\n" 7890 " int a;\n" 7891 "}"); 7892 verifyFormat("{\n" 7893 " int a;\n" 7894 "#error {\n" 7895 "}"); 7896 verifyFormat("void f() {} // comment"); 7897 verifyFormat("void f() { int a; } // comment"); 7898 verifyFormat("void f() {\n" 7899 "} // comment", 7900 DoNotMerge); 7901 verifyFormat("void f() {\n" 7902 " int a;\n" 7903 "} // comment", 7904 DoNotMerge); 7905 verifyFormat("void f() {\n" 7906 "} // comment", 7907 getLLVMStyleWithColumns(15)); 7908 7909 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 7910 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 7911 7912 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 7913 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 7914 verifyFormat("class C {\n" 7915 " C()\n" 7916 " : iiiiiiii(nullptr),\n" 7917 " kkkkkkk(nullptr),\n" 7918 " mmmmmmm(nullptr),\n" 7919 " nnnnnnn(nullptr) {}\n" 7920 "};", 7921 getGoogleStyle()); 7922 7923 FormatStyle NoColumnLimit = getLLVMStyle(); 7924 NoColumnLimit.ColumnLimit = 0; 7925 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 7926 EXPECT_EQ("class C {\n" 7927 " A() : b(0) {}\n" 7928 "};", 7929 format("class C{A():b(0){}};", NoColumnLimit)); 7930 EXPECT_EQ("A()\n" 7931 " : b(0) {\n" 7932 "}", 7933 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 7934 7935 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 7936 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 7937 FormatStyle::SFS_None; 7938 EXPECT_EQ("A()\n" 7939 " : b(0) {\n" 7940 "}", 7941 format("A():b(0){}", DoNotMergeNoColumnLimit)); 7942 EXPECT_EQ("A()\n" 7943 " : b(0) {\n" 7944 "}", 7945 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 7946 7947 verifyFormat("#define A \\\n" 7948 " void f() { \\\n" 7949 " int i; \\\n" 7950 " }", 7951 getLLVMStyleWithColumns(20)); 7952 verifyFormat("#define A \\\n" 7953 " void f() { int i; }", 7954 getLLVMStyleWithColumns(21)); 7955 verifyFormat("#define A \\\n" 7956 " void f() { \\\n" 7957 " int i; \\\n" 7958 " } \\\n" 7959 " int j;", 7960 getLLVMStyleWithColumns(22)); 7961 verifyFormat("#define A \\\n" 7962 " void f() { int i; } \\\n" 7963 " int j;", 7964 getLLVMStyleWithColumns(23)); 7965 } 7966 7967 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 7968 FormatStyle MergeEmptyOnly = getLLVMStyle(); 7969 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 7970 verifyFormat("class C {\n" 7971 " int f() {}\n" 7972 "};", 7973 MergeEmptyOnly); 7974 verifyFormat("class C {\n" 7975 " int f() {\n" 7976 " return 42;\n" 7977 " }\n" 7978 "};", 7979 MergeEmptyOnly); 7980 verifyFormat("int f() {}", MergeEmptyOnly); 7981 verifyFormat("int f() {\n" 7982 " return 42;\n" 7983 "}", 7984 MergeEmptyOnly); 7985 7986 // Also verify behavior when BraceWrapping.AfterFunction = true 7987 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 7988 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 7989 verifyFormat("int f() {}", MergeEmptyOnly); 7990 verifyFormat("class C {\n" 7991 " int f() {}\n" 7992 "};", 7993 MergeEmptyOnly); 7994 } 7995 7996 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 7997 FormatStyle MergeInlineOnly = getLLVMStyle(); 7998 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 7999 verifyFormat("class C {\n" 8000 " int f() { return 42; }\n" 8001 "};", 8002 MergeInlineOnly); 8003 verifyFormat("int f() {\n" 8004 " return 42;\n" 8005 "}", 8006 MergeInlineOnly); 8007 8008 // SFS_Inline implies SFS_Empty 8009 verifyFormat("class C {\n" 8010 " int f() {}\n" 8011 "};", 8012 MergeInlineOnly); 8013 verifyFormat("int f() {}", MergeInlineOnly); 8014 8015 // Also verify behavior when BraceWrapping.AfterFunction = true 8016 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8017 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8018 verifyFormat("class C {\n" 8019 " int f() { return 42; }\n" 8020 "};", 8021 MergeInlineOnly); 8022 verifyFormat("int f()\n" 8023 "{\n" 8024 " return 42;\n" 8025 "}", 8026 MergeInlineOnly); 8027 8028 // SFS_Inline implies SFS_Empty 8029 verifyFormat("int f() {}", MergeInlineOnly); 8030 verifyFormat("class C {\n" 8031 " int f() {}\n" 8032 "};", 8033 MergeInlineOnly); 8034 } 8035 8036 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8037 FormatStyle MergeInlineOnly = getLLVMStyle(); 8038 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8039 FormatStyle::SFS_InlineOnly; 8040 verifyFormat("class C {\n" 8041 " int f() { return 42; }\n" 8042 "};", 8043 MergeInlineOnly); 8044 verifyFormat("int f() {\n" 8045 " return 42;\n" 8046 "}", 8047 MergeInlineOnly); 8048 8049 // SFS_InlineOnly does not imply SFS_Empty 8050 verifyFormat("class C {\n" 8051 " int f() {}\n" 8052 "};", 8053 MergeInlineOnly); 8054 verifyFormat("int f() {\n" 8055 "}", 8056 MergeInlineOnly); 8057 8058 // Also verify behavior when BraceWrapping.AfterFunction = true 8059 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8060 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8061 verifyFormat("class C {\n" 8062 " int f() { return 42; }\n" 8063 "};", 8064 MergeInlineOnly); 8065 verifyFormat("int f()\n" 8066 "{\n" 8067 " return 42;\n" 8068 "}", 8069 MergeInlineOnly); 8070 8071 // SFS_InlineOnly does not imply SFS_Empty 8072 verifyFormat("int f()\n" 8073 "{\n" 8074 "}", 8075 MergeInlineOnly); 8076 verifyFormat("class C {\n" 8077 " int f() {}\n" 8078 "};", 8079 MergeInlineOnly); 8080 } 8081 8082 TEST_F(FormatTest, SplitEmptyFunction) { 8083 FormatStyle Style = getLLVMStyle(); 8084 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8085 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8086 Style.BraceWrapping.AfterFunction = true; 8087 Style.BraceWrapping.SplitEmptyFunction = false; 8088 Style.ColumnLimit = 40; 8089 8090 verifyFormat("int f()\n" 8091 "{}", 8092 Style); 8093 verifyFormat("int f()\n" 8094 "{\n" 8095 " return 42;\n" 8096 "}", 8097 Style); 8098 verifyFormat("int f()\n" 8099 "{\n" 8100 " // some comment\n" 8101 "}", 8102 Style); 8103 8104 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8105 verifyFormat("int f() {}", Style); 8106 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8107 "{}", 8108 Style); 8109 verifyFormat("int f()\n" 8110 "{\n" 8111 " return 0;\n" 8112 "}", 8113 Style); 8114 8115 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8116 verifyFormat("class Foo {\n" 8117 " int f() {}\n" 8118 "};\n", 8119 Style); 8120 verifyFormat("class Foo {\n" 8121 " int f() { return 0; }\n" 8122 "};\n", 8123 Style); 8124 verifyFormat("class Foo {\n" 8125 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8126 " {}\n" 8127 "};\n", 8128 Style); 8129 verifyFormat("class Foo {\n" 8130 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8131 " {\n" 8132 " return 0;\n" 8133 " }\n" 8134 "};\n", 8135 Style); 8136 8137 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8138 verifyFormat("int f() {}", Style); 8139 verifyFormat("int f() { return 0; }", Style); 8140 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8141 "{}", 8142 Style); 8143 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8144 "{\n" 8145 " return 0;\n" 8146 "}", 8147 Style); 8148 } 8149 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8150 FormatStyle Style = getLLVMStyle(); 8151 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8152 verifyFormat("#ifdef A\n" 8153 "int f() {}\n" 8154 "#else\n" 8155 "int g() {}\n" 8156 "#endif", 8157 Style); 8158 } 8159 8160 TEST_F(FormatTest, SplitEmptyClass) { 8161 FormatStyle Style = getLLVMStyle(); 8162 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8163 Style.BraceWrapping.AfterClass = true; 8164 Style.BraceWrapping.SplitEmptyRecord = false; 8165 8166 verifyFormat("class Foo\n" 8167 "{};", 8168 Style); 8169 verifyFormat("/* something */ class Foo\n" 8170 "{};", 8171 Style); 8172 verifyFormat("template <typename X> class Foo\n" 8173 "{};", 8174 Style); 8175 verifyFormat("class Foo\n" 8176 "{\n" 8177 " Foo();\n" 8178 "};", 8179 Style); 8180 verifyFormat("typedef class Foo\n" 8181 "{\n" 8182 "} Foo_t;", 8183 Style); 8184 } 8185 8186 TEST_F(FormatTest, SplitEmptyStruct) { 8187 FormatStyle Style = getLLVMStyle(); 8188 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8189 Style.BraceWrapping.AfterStruct = true; 8190 Style.BraceWrapping.SplitEmptyRecord = false; 8191 8192 verifyFormat("struct Foo\n" 8193 "{};", 8194 Style); 8195 verifyFormat("/* something */ struct Foo\n" 8196 "{};", 8197 Style); 8198 verifyFormat("template <typename X> struct Foo\n" 8199 "{};", 8200 Style); 8201 verifyFormat("struct Foo\n" 8202 "{\n" 8203 " Foo();\n" 8204 "};", 8205 Style); 8206 verifyFormat("typedef struct Foo\n" 8207 "{\n" 8208 "} Foo_t;", 8209 Style); 8210 //typedef struct Bar {} Bar_t; 8211 } 8212 8213 TEST_F(FormatTest, SplitEmptyUnion) { 8214 FormatStyle Style = getLLVMStyle(); 8215 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8216 Style.BraceWrapping.AfterUnion = true; 8217 Style.BraceWrapping.SplitEmptyRecord = false; 8218 8219 verifyFormat("union Foo\n" 8220 "{};", 8221 Style); 8222 verifyFormat("/* something */ union Foo\n" 8223 "{};", 8224 Style); 8225 verifyFormat("union Foo\n" 8226 "{\n" 8227 " A,\n" 8228 "};", 8229 Style); 8230 verifyFormat("typedef union Foo\n" 8231 "{\n" 8232 "} Foo_t;", 8233 Style); 8234 } 8235 8236 TEST_F(FormatTest, SplitEmptyNamespace) { 8237 FormatStyle Style = getLLVMStyle(); 8238 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8239 Style.BraceWrapping.AfterNamespace = true; 8240 Style.BraceWrapping.SplitEmptyNamespace = false; 8241 8242 verifyFormat("namespace Foo\n" 8243 "{};", 8244 Style); 8245 verifyFormat("/* something */ namespace Foo\n" 8246 "{};", 8247 Style); 8248 verifyFormat("inline namespace Foo\n" 8249 "{};", 8250 Style); 8251 verifyFormat("/* something */ inline namespace Foo\n" 8252 "{};", 8253 Style); 8254 verifyFormat("export namespace Foo\n" 8255 "{};", 8256 Style); 8257 verifyFormat("namespace Foo\n" 8258 "{\n" 8259 "void Bar();\n" 8260 "};", 8261 Style); 8262 } 8263 8264 TEST_F(FormatTest, NeverMergeShortRecords) { 8265 FormatStyle Style = getLLVMStyle(); 8266 8267 verifyFormat("class Foo {\n" 8268 " Foo();\n" 8269 "};", 8270 Style); 8271 verifyFormat("typedef class Foo {\n" 8272 " Foo();\n" 8273 "} Foo_t;", 8274 Style); 8275 verifyFormat("struct Foo {\n" 8276 " Foo();\n" 8277 "};", 8278 Style); 8279 verifyFormat("typedef struct Foo {\n" 8280 " Foo();\n" 8281 "} Foo_t;", 8282 Style); 8283 verifyFormat("union Foo {\n" 8284 " A,\n" 8285 "};", 8286 Style); 8287 verifyFormat("typedef union Foo {\n" 8288 " A,\n" 8289 "} Foo_t;", 8290 Style); 8291 verifyFormat("namespace Foo {\n" 8292 "void Bar();\n" 8293 "};", 8294 Style); 8295 8296 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8297 Style.BraceWrapping.AfterClass = true; 8298 Style.BraceWrapping.AfterStruct = true; 8299 Style.BraceWrapping.AfterUnion = true; 8300 Style.BraceWrapping.AfterNamespace = true; 8301 verifyFormat("class Foo\n" 8302 "{\n" 8303 " Foo();\n" 8304 "};", 8305 Style); 8306 verifyFormat("typedef class Foo\n" 8307 "{\n" 8308 " Foo();\n" 8309 "} Foo_t;", 8310 Style); 8311 verifyFormat("struct Foo\n" 8312 "{\n" 8313 " Foo();\n" 8314 "};", 8315 Style); 8316 verifyFormat("typedef struct Foo\n" 8317 "{\n" 8318 " Foo();\n" 8319 "} Foo_t;", 8320 Style); 8321 verifyFormat("union Foo\n" 8322 "{\n" 8323 " A,\n" 8324 "};", 8325 Style); 8326 verifyFormat("typedef union Foo\n" 8327 "{\n" 8328 " A,\n" 8329 "} Foo_t;", 8330 Style); 8331 verifyFormat("namespace Foo\n" 8332 "{\n" 8333 "void Bar();\n" 8334 "};", 8335 Style); 8336 } 8337 8338 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 8339 // Elaborate type variable declarations. 8340 verifyFormat("struct foo a = {bar};\nint n;"); 8341 verifyFormat("class foo a = {bar};\nint n;"); 8342 verifyFormat("union foo a = {bar};\nint n;"); 8343 8344 // Elaborate types inside function definitions. 8345 verifyFormat("struct foo f() {}\nint n;"); 8346 verifyFormat("class foo f() {}\nint n;"); 8347 verifyFormat("union foo f() {}\nint n;"); 8348 8349 // Templates. 8350 verifyFormat("template <class X> void f() {}\nint n;"); 8351 verifyFormat("template <struct X> void f() {}\nint n;"); 8352 verifyFormat("template <union X> void f() {}\nint n;"); 8353 8354 // Actual definitions... 8355 verifyFormat("struct {\n} n;"); 8356 verifyFormat( 8357 "template <template <class T, class Y>, class Z> class X {\n} n;"); 8358 verifyFormat("union Z {\n int n;\n} x;"); 8359 verifyFormat("class MACRO Z {\n} n;"); 8360 verifyFormat("class MACRO(X) Z {\n} n;"); 8361 verifyFormat("class __attribute__(X) Z {\n} n;"); 8362 verifyFormat("class __declspec(X) Z {\n} n;"); 8363 verifyFormat("class A##B##C {\n} n;"); 8364 verifyFormat("class alignas(16) Z {\n} n;"); 8365 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 8366 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 8367 8368 // Redefinition from nested context: 8369 verifyFormat("class A::B::C {\n} n;"); 8370 8371 // Template definitions. 8372 verifyFormat( 8373 "template <typename F>\n" 8374 "Matcher(const Matcher<F> &Other,\n" 8375 " typename enable_if_c<is_base_of<F, T>::value &&\n" 8376 " !is_same<F, T>::value>::type * = 0)\n" 8377 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 8378 8379 // FIXME: This is still incorrectly handled at the formatter side. 8380 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 8381 verifyFormat("int i = SomeFunction(a<b, a> b);"); 8382 8383 // FIXME: 8384 // This now gets parsed incorrectly as class definition. 8385 // verifyFormat("class A<int> f() {\n}\nint n;"); 8386 8387 // Elaborate types where incorrectly parsing the structural element would 8388 // break the indent. 8389 verifyFormat("if (true)\n" 8390 " class X x;\n" 8391 "else\n" 8392 " f();\n"); 8393 8394 // This is simply incomplete. Formatting is not important, but must not crash. 8395 verifyFormat("class A:"); 8396 } 8397 8398 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 8399 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 8400 format("#error Leave all white!!!!! space* alone!\n")); 8401 EXPECT_EQ( 8402 "#warning Leave all white!!!!! space* alone!\n", 8403 format("#warning Leave all white!!!!! space* alone!\n")); 8404 EXPECT_EQ("#error 1", format(" # error 1")); 8405 EXPECT_EQ("#warning 1", format(" # warning 1")); 8406 } 8407 8408 TEST_F(FormatTest, FormatHashIfExpressions) { 8409 verifyFormat("#if AAAA && BBBB"); 8410 verifyFormat("#if (AAAA && BBBB)"); 8411 verifyFormat("#elif (AAAA && BBBB)"); 8412 // FIXME: Come up with a better indentation for #elif. 8413 verifyFormat( 8414 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 8415 " defined(BBBBBBBB)\n" 8416 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 8417 " defined(BBBBBBBB)\n" 8418 "#endif", 8419 getLLVMStyleWithColumns(65)); 8420 } 8421 8422 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 8423 FormatStyle AllowsMergedIf = getGoogleStyle(); 8424 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 8425 FormatStyle::SIS_WithoutElse; 8426 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 8427 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 8428 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 8429 EXPECT_EQ("if (true) return 42;", 8430 format("if (true)\nreturn 42;", AllowsMergedIf)); 8431 FormatStyle ShortMergedIf = AllowsMergedIf; 8432 ShortMergedIf.ColumnLimit = 25; 8433 verifyFormat("#define A \\\n" 8434 " if (true) return 42;", 8435 ShortMergedIf); 8436 verifyFormat("#define A \\\n" 8437 " f(); \\\n" 8438 " if (true)\n" 8439 "#define B", 8440 ShortMergedIf); 8441 verifyFormat("#define A \\\n" 8442 " f(); \\\n" 8443 " if (true)\n" 8444 "g();", 8445 ShortMergedIf); 8446 verifyFormat("{\n" 8447 "#ifdef A\n" 8448 " // Comment\n" 8449 " if (true) continue;\n" 8450 "#endif\n" 8451 " // Comment\n" 8452 " if (true) continue;\n" 8453 "}", 8454 ShortMergedIf); 8455 ShortMergedIf.ColumnLimit = 33; 8456 verifyFormat("#define A \\\n" 8457 " if constexpr (true) return 42;", 8458 ShortMergedIf); 8459 ShortMergedIf.ColumnLimit = 29; 8460 verifyFormat("#define A \\\n" 8461 " if (aaaaaaaaaa) return 1; \\\n" 8462 " return 2;", 8463 ShortMergedIf); 8464 ShortMergedIf.ColumnLimit = 28; 8465 verifyFormat("#define A \\\n" 8466 " if (aaaaaaaaaa) \\\n" 8467 " return 1; \\\n" 8468 " return 2;", 8469 ShortMergedIf); 8470 verifyFormat("#define A \\\n" 8471 " if constexpr (aaaaaaa) \\\n" 8472 " return 1; \\\n" 8473 " return 2;", 8474 ShortMergedIf); 8475 } 8476 8477 TEST_F(FormatTest, FormatStarDependingOnContext) { 8478 verifyFormat("void f(int *a);"); 8479 verifyFormat("void f() { f(fint * b); }"); 8480 verifyFormat("class A {\n void f(int *a);\n};"); 8481 verifyFormat("class A {\n int *a;\n};"); 8482 verifyFormat("namespace a {\n" 8483 "namespace b {\n" 8484 "class A {\n" 8485 " void f() {}\n" 8486 " int *a;\n" 8487 "};\n" 8488 "} // namespace b\n" 8489 "} // namespace a"); 8490 } 8491 8492 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 8493 verifyFormat("while"); 8494 verifyFormat("operator"); 8495 } 8496 8497 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 8498 // This code would be painfully slow to format if we didn't skip it. 8499 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 8500 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8501 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8502 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8503 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8504 "A(1, 1)\n" 8505 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 8506 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8507 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8508 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8509 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8510 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8511 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8512 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8513 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8514 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 8515 // Deeply nested part is untouched, rest is formatted. 8516 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 8517 format(std::string("int i;\n") + Code + "int j;\n", 8518 getLLVMStyle(), SC_ExpectIncomplete)); 8519 } 8520 8521 //===----------------------------------------------------------------------===// 8522 // Objective-C tests. 8523 //===----------------------------------------------------------------------===// 8524 8525 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 8526 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 8527 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 8528 format("-(NSUInteger)indexOfObject:(id)anObject;")); 8529 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 8530 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 8531 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 8532 format("-(NSInteger)Method3:(id)anObject;")); 8533 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 8534 format("-(NSInteger)Method4:(id)anObject;")); 8535 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 8536 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 8537 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 8538 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 8539 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 8540 "forAllCells:(BOOL)flag;", 8541 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 8542 "forAllCells:(BOOL)flag;")); 8543 8544 // Very long objectiveC method declaration. 8545 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 8546 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 8547 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 8548 " inRange:(NSRange)range\n" 8549 " outRange:(NSRange)out_range\n" 8550 " outRange1:(NSRange)out_range1\n" 8551 " outRange2:(NSRange)out_range2\n" 8552 " outRange3:(NSRange)out_range3\n" 8553 " outRange4:(NSRange)out_range4\n" 8554 " outRange5:(NSRange)out_range5\n" 8555 " outRange6:(NSRange)out_range6\n" 8556 " outRange7:(NSRange)out_range7\n" 8557 " outRange8:(NSRange)out_range8\n" 8558 " outRange9:(NSRange)out_range9;"); 8559 8560 // When the function name has to be wrapped. 8561 FormatStyle Style = getLLVMStyle(); 8562 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 8563 // and always indents instead. 8564 Style.IndentWrappedFunctionNames = false; 8565 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 8566 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 8567 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 8568 "}", 8569 Style); 8570 Style.IndentWrappedFunctionNames = true; 8571 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 8572 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 8573 " anotherName:(NSString)dddddddddddddd {\n" 8574 "}", 8575 Style); 8576 8577 verifyFormat("- (int)sum:(vector<int>)numbers;"); 8578 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 8579 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 8580 // protocol lists (but not for template classes): 8581 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 8582 8583 verifyFormat("- (int (*)())foo:(int (*)())f;"); 8584 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 8585 8586 // If there's no return type (very rare in practice!), LLVM and Google style 8587 // agree. 8588 verifyFormat("- foo;"); 8589 verifyFormat("- foo:(int)f;"); 8590 verifyGoogleFormat("- foo:(int)foo;"); 8591 } 8592 8593 8594 TEST_F(FormatTest, BreaksStringLiterals) { 8595 EXPECT_EQ("\"some text \"\n" 8596 "\"other\";", 8597 format("\"some text other\";", getLLVMStyleWithColumns(12))); 8598 EXPECT_EQ("\"some text \"\n" 8599 "\"other\";", 8600 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 8601 EXPECT_EQ( 8602 "#define A \\\n" 8603 " \"some \" \\\n" 8604 " \"text \" \\\n" 8605 " \"other\";", 8606 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 8607 EXPECT_EQ( 8608 "#define A \\\n" 8609 " \"so \" \\\n" 8610 " \"text \" \\\n" 8611 " \"other\";", 8612 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 8613 8614 EXPECT_EQ("\"some text\"", 8615 format("\"some text\"", getLLVMStyleWithColumns(1))); 8616 EXPECT_EQ("\"some text\"", 8617 format("\"some text\"", getLLVMStyleWithColumns(11))); 8618 EXPECT_EQ("\"some \"\n" 8619 "\"text\"", 8620 format("\"some text\"", getLLVMStyleWithColumns(10))); 8621 EXPECT_EQ("\"some \"\n" 8622 "\"text\"", 8623 format("\"some text\"", getLLVMStyleWithColumns(7))); 8624 EXPECT_EQ("\"some\"\n" 8625 "\" tex\"\n" 8626 "\"t\"", 8627 format("\"some text\"", getLLVMStyleWithColumns(6))); 8628 EXPECT_EQ("\"some\"\n" 8629 "\" tex\"\n" 8630 "\" and\"", 8631 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 8632 EXPECT_EQ("\"some\"\n" 8633 "\"/tex\"\n" 8634 "\"/and\"", 8635 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 8636 8637 EXPECT_EQ("variable =\n" 8638 " \"long string \"\n" 8639 " \"literal\";", 8640 format("variable = \"long string literal\";", 8641 getLLVMStyleWithColumns(20))); 8642 8643 EXPECT_EQ("variable = f(\n" 8644 " \"long string \"\n" 8645 " \"literal\",\n" 8646 " short,\n" 8647 " loooooooooooooooooooong);", 8648 format("variable = f(\"long string literal\", short, " 8649 "loooooooooooooooooooong);", 8650 getLLVMStyleWithColumns(20))); 8651 8652 EXPECT_EQ( 8653 "f(g(\"long string \"\n" 8654 " \"literal\"),\n" 8655 " b);", 8656 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 8657 EXPECT_EQ("f(g(\"long string \"\n" 8658 " \"literal\",\n" 8659 " a),\n" 8660 " b);", 8661 format("f(g(\"long string literal\", a), b);", 8662 getLLVMStyleWithColumns(20))); 8663 EXPECT_EQ( 8664 "f(\"one two\".split(\n" 8665 " variable));", 8666 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 8667 EXPECT_EQ("f(\"one two three four five six \"\n" 8668 " \"seven\".split(\n" 8669 " really_looooong_variable));", 8670 format("f(\"one two three four five six seven\"." 8671 "split(really_looooong_variable));", 8672 getLLVMStyleWithColumns(33))); 8673 8674 EXPECT_EQ("f(\"some \"\n" 8675 " \"text\",\n" 8676 " other);", 8677 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 8678 8679 // Only break as a last resort. 8680 verifyFormat( 8681 "aaaaaaaaaaaaaaaaaaaa(\n" 8682 " aaaaaaaaaaaaaaaaaaaa,\n" 8683 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 8684 8685 EXPECT_EQ("\"splitmea\"\n" 8686 "\"trandomp\"\n" 8687 "\"oint\"", 8688 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 8689 8690 EXPECT_EQ("\"split/\"\n" 8691 "\"pathat/\"\n" 8692 "\"slashes\"", 8693 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 8694 8695 EXPECT_EQ("\"split/\"\n" 8696 "\"pathat/\"\n" 8697 "\"slashes\"", 8698 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 8699 EXPECT_EQ("\"split at \"\n" 8700 "\"spaces/at/\"\n" 8701 "\"slashes.at.any$\"\n" 8702 "\"non-alphanumeric%\"\n" 8703 "\"1111111111characte\"\n" 8704 "\"rs\"", 8705 format("\"split at " 8706 "spaces/at/" 8707 "slashes.at." 8708 "any$non-" 8709 "alphanumeric%" 8710 "1111111111characte" 8711 "rs\"", 8712 getLLVMStyleWithColumns(20))); 8713 8714 // Verify that splitting the strings understands 8715 // Style::AlwaysBreakBeforeMultilineStrings. 8716 EXPECT_EQ( 8717 "aaaaaaaaaaaa(\n" 8718 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 8719 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 8720 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 8721 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 8722 "aaaaaaaaaaaaaaaaaaaaaa\");", 8723 getGoogleStyle())); 8724 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 8725 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 8726 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 8727 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 8728 "aaaaaaaaaaaaaaaaaaaaaa\";", 8729 getGoogleStyle())); 8730 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 8731 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 8732 format("llvm::outs() << " 8733 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 8734 "aaaaaaaaaaaaaaaaaaa\";")); 8735 EXPECT_EQ("ffff(\n" 8736 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 8737 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 8738 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 8739 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 8740 getGoogleStyle())); 8741 8742 FormatStyle Style = getLLVMStyleWithColumns(12); 8743 Style.BreakStringLiterals = false; 8744 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 8745 8746 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 8747 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 8748 EXPECT_EQ("#define A \\\n" 8749 " \"some \" \\\n" 8750 " \"text \" \\\n" 8751 " \"other\";", 8752 format("#define A \"some text other\";", AlignLeft)); 8753 } 8754 8755 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 8756 EXPECT_EQ("C a = \"some more \"\n" 8757 " \"text\";", 8758 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 8759 } 8760 8761 TEST_F(FormatTest, FullyRemoveEmptyLines) { 8762 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 8763 NoEmptyLines.MaxEmptyLinesToKeep = 0; 8764 EXPECT_EQ("int i = a(b());", 8765 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 8766 } 8767 8768 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 8769 EXPECT_EQ( 8770 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 8771 "(\n" 8772 " \"x\t\");", 8773 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 8774 "aaaaaaa(" 8775 "\"x\t\");")); 8776 } 8777 8778 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 8779 EXPECT_EQ( 8780 "u8\"utf8 string \"\n" 8781 "u8\"literal\";", 8782 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 8783 EXPECT_EQ( 8784 "u\"utf16 string \"\n" 8785 "u\"literal\";", 8786 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 8787 EXPECT_EQ( 8788 "U\"utf32 string \"\n" 8789 "U\"literal\";", 8790 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 8791 EXPECT_EQ("L\"wide string \"\n" 8792 "L\"literal\";", 8793 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 8794 EXPECT_EQ("@\"NSString \"\n" 8795 "@\"literal\";", 8796 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 8797 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 8798 8799 // This input makes clang-format try to split the incomplete unicode escape 8800 // sequence, which used to lead to a crasher. 8801 verifyNoCrash( 8802 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 8803 getLLVMStyleWithColumns(60)); 8804 } 8805 8806 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 8807 FormatStyle Style = getGoogleStyleWithColumns(15); 8808 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 8809 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 8810 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 8811 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 8812 EXPECT_EQ("u8R\"x(raw literal)x\";", 8813 format("u8R\"x(raw literal)x\";", Style)); 8814 } 8815 8816 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 8817 FormatStyle Style = getLLVMStyleWithColumns(20); 8818 EXPECT_EQ( 8819 "_T(\"aaaaaaaaaaaaaa\")\n" 8820 "_T(\"aaaaaaaaaaaaaa\")\n" 8821 "_T(\"aaaaaaaaaaaa\")", 8822 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 8823 EXPECT_EQ("f(x,\n" 8824 " _T(\"aaaaaaaaaaaa\")\n" 8825 " _T(\"aaa\"),\n" 8826 " z);", 8827 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 8828 8829 // FIXME: Handle embedded spaces in one iteration. 8830 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 8831 // "_T(\"aaaaaaaaaaaaa\")\n" 8832 // "_T(\"aaaaaaaaaaaaa\")\n" 8833 // "_T(\"a\")", 8834 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 8835 // getLLVMStyleWithColumns(20))); 8836 EXPECT_EQ( 8837 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 8838 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 8839 EXPECT_EQ("f(\n" 8840 "#if !TEST\n" 8841 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 8842 "#endif\n" 8843 ");", 8844 format("f(\n" 8845 "#if !TEST\n" 8846 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 8847 "#endif\n" 8848 ");")); 8849 EXPECT_EQ("f(\n" 8850 "\n" 8851 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 8852 format("f(\n" 8853 "\n" 8854 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 8855 } 8856 8857 TEST_F(FormatTest, BreaksStringLiteralOperands) { 8858 // In a function call with two operands, the second can be broken with no line 8859 // break before it. 8860 EXPECT_EQ("func(a, \"long long \"\n" 8861 " \"long long\");", 8862 format("func(a, \"long long long long\");", 8863 getLLVMStyleWithColumns(24))); 8864 // In a function call with three operands, the second must be broken with a 8865 // line break before it. 8866 EXPECT_EQ("func(a,\n" 8867 " \"long long long \"\n" 8868 " \"long\",\n" 8869 " c);", 8870 format("func(a, \"long long long long\", c);", 8871 getLLVMStyleWithColumns(24))); 8872 // In a function call with three operands, the third must be broken with a 8873 // line break before it. 8874 EXPECT_EQ("func(a, b,\n" 8875 " \"long long long \"\n" 8876 " \"long\");", 8877 format("func(a, b, \"long long long long\");", 8878 getLLVMStyleWithColumns(24))); 8879 // In a function call with three operands, both the second and the third must 8880 // be broken with a line break before them. 8881 EXPECT_EQ("func(a,\n" 8882 " \"long long long \"\n" 8883 " \"long\",\n" 8884 " \"long long long \"\n" 8885 " \"long\");", 8886 format("func(a, \"long long long long\", \"long long long long\");", 8887 getLLVMStyleWithColumns(24))); 8888 // In a chain of << with two operands, the second can be broken with no line 8889 // break before it. 8890 EXPECT_EQ("a << \"line line \"\n" 8891 " \"line\";", 8892 format("a << \"line line line\";", 8893 getLLVMStyleWithColumns(20))); 8894 // In a chain of << with three operands, the second can be broken with no line 8895 // break before it. 8896 EXPECT_EQ("abcde << \"line \"\n" 8897 " \"line line\"\n" 8898 " << c;", 8899 format("abcde << \"line line line\" << c;", 8900 getLLVMStyleWithColumns(20))); 8901 // In a chain of << with three operands, the third must be broken with a line 8902 // break before it. 8903 EXPECT_EQ("a << b\n" 8904 " << \"line line \"\n" 8905 " \"line\";", 8906 format("a << b << \"line line line\";", 8907 getLLVMStyleWithColumns(20))); 8908 // In a chain of << with three operands, the second can be broken with no line 8909 // break before it and the third must be broken with a line break before it. 8910 EXPECT_EQ("abcd << \"line line \"\n" 8911 " \"line\"\n" 8912 " << \"line line \"\n" 8913 " \"line\";", 8914 format("abcd << \"line line line\" << \"line line line\";", 8915 getLLVMStyleWithColumns(20))); 8916 // In a chain of binary operators with two operands, the second can be broken 8917 // with no line break before it. 8918 EXPECT_EQ("abcd + \"line line \"\n" 8919 " \"line line\";", 8920 format("abcd + \"line line line line\";", 8921 getLLVMStyleWithColumns(20))); 8922 // In a chain of binary operators with three operands, the second must be 8923 // broken with a line break before it. 8924 EXPECT_EQ("abcd +\n" 8925 " \"line line \"\n" 8926 " \"line line\" +\n" 8927 " e;", 8928 format("abcd + \"line line line line\" + e;", 8929 getLLVMStyleWithColumns(20))); 8930 // In a function call with two operands, with AlignAfterOpenBracket enabled, 8931 // the first must be broken with a line break before it. 8932 FormatStyle Style = getLLVMStyleWithColumns(25); 8933 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 8934 EXPECT_EQ("someFunction(\n" 8935 " \"long long long \"\n" 8936 " \"long\",\n" 8937 " a);", 8938 format("someFunction(\"long long long long\", a);", Style)); 8939 } 8940 8941 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 8942 EXPECT_EQ( 8943 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 8944 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 8945 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 8946 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 8947 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 8948 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 8949 } 8950 8951 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 8952 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 8953 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 8954 EXPECT_EQ("fffffffffff(g(R\"x(\n" 8955 "multiline raw string literal xxxxxxxxxxxxxx\n" 8956 ")x\",\n" 8957 " a),\n" 8958 " b);", 8959 format("fffffffffff(g(R\"x(\n" 8960 "multiline raw string literal xxxxxxxxxxxxxx\n" 8961 ")x\", a), b);", 8962 getGoogleStyleWithColumns(20))); 8963 EXPECT_EQ("fffffffffff(\n" 8964 " g(R\"x(qqq\n" 8965 "multiline raw string literal xxxxxxxxxxxxxx\n" 8966 ")x\",\n" 8967 " a),\n" 8968 " b);", 8969 format("fffffffffff(g(R\"x(qqq\n" 8970 "multiline raw string literal xxxxxxxxxxxxxx\n" 8971 ")x\", a), b);", 8972 getGoogleStyleWithColumns(20))); 8973 8974 EXPECT_EQ("fffffffffff(R\"x(\n" 8975 "multiline raw string literal xxxxxxxxxxxxxx\n" 8976 ")x\");", 8977 format("fffffffffff(R\"x(\n" 8978 "multiline raw string literal xxxxxxxxxxxxxx\n" 8979 ")x\");", 8980 getGoogleStyleWithColumns(20))); 8981 EXPECT_EQ("fffffffffff(R\"x(\n" 8982 "multiline raw string literal xxxxxxxxxxxxxx\n" 8983 ")x\" + bbbbbb);", 8984 format("fffffffffff(R\"x(\n" 8985 "multiline raw string literal xxxxxxxxxxxxxx\n" 8986 ")x\" + bbbbbb);", 8987 getGoogleStyleWithColumns(20))); 8988 EXPECT_EQ("fffffffffff(\n" 8989 " R\"x(\n" 8990 "multiline raw string literal xxxxxxxxxxxxxx\n" 8991 ")x\" +\n" 8992 " bbbbbb);", 8993 format("fffffffffff(\n" 8994 " R\"x(\n" 8995 "multiline raw string literal xxxxxxxxxxxxxx\n" 8996 ")x\" + bbbbbb);", 8997 getGoogleStyleWithColumns(20))); 8998 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 8999 format("fffffffffff(\n" 9000 " R\"(single line raw string)\" + bbbbbb);")); 9001 } 9002 9003 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 9004 verifyFormat("string a = \"unterminated;"); 9005 EXPECT_EQ("function(\"unterminated,\n" 9006 " OtherParameter);", 9007 format("function( \"unterminated,\n" 9008 " OtherParameter);")); 9009 } 9010 9011 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9012 FormatStyle Style = getLLVMStyle(); 9013 Style.Standard = FormatStyle::LS_Cpp03; 9014 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9015 format("#define x(_a) printf(\"foo\"_a);", Style)); 9016 } 9017 9018 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9019 9020 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9021 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9022 " \"ddeeefff\");", 9023 format("someFunction(\"aaabbbcccdddeeefff\");", 9024 getLLVMStyleWithColumns(25))); 9025 EXPECT_EQ("someFunction1234567890(\n" 9026 " \"aaabbbcccdddeeefff\");", 9027 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9028 getLLVMStyleWithColumns(26))); 9029 EXPECT_EQ("someFunction1234567890(\n" 9030 " \"aaabbbcccdddeeeff\"\n" 9031 " \"f\");", 9032 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9033 getLLVMStyleWithColumns(25))); 9034 EXPECT_EQ("someFunction1234567890(\n" 9035 " \"aaabbbcccdddeeeff\"\n" 9036 " \"f\");", 9037 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9038 getLLVMStyleWithColumns(24))); 9039 EXPECT_EQ("someFunction(\n" 9040 " \"aaabbbcc ddde \"\n" 9041 " \"efff\");", 9042 format("someFunction(\"aaabbbcc ddde efff\");", 9043 getLLVMStyleWithColumns(25))); 9044 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9045 " \"ddeeefff\");", 9046 format("someFunction(\"aaabbbccc ddeeefff\");", 9047 getLLVMStyleWithColumns(25))); 9048 EXPECT_EQ("someFunction1234567890(\n" 9049 " \"aaabb \"\n" 9050 " \"cccdddeeefff\");", 9051 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9052 getLLVMStyleWithColumns(25))); 9053 EXPECT_EQ("#define A \\\n" 9054 " string s = \\\n" 9055 " \"123456789\" \\\n" 9056 " \"0\"; \\\n" 9057 " int i;", 9058 format("#define A string s = \"1234567890\"; int i;", 9059 getLLVMStyleWithColumns(20))); 9060 EXPECT_EQ("someFunction(\n" 9061 " \"aaabbbcc \"\n" 9062 " \"dddeeefff\");", 9063 format("someFunction(\"aaabbbcc dddeeefff\");", 9064 getLLVMStyleWithColumns(25))); 9065 } 9066 9067 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9068 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9069 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9070 EXPECT_EQ("\"test\"\n" 9071 "\"\\n\"", 9072 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9073 EXPECT_EQ("\"tes\\\\\"\n" 9074 "\"n\"", 9075 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9076 EXPECT_EQ("\"\\\\\\\\\"\n" 9077 "\"\\n\"", 9078 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9079 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9080 EXPECT_EQ("\"\\uff01\"\n" 9081 "\"test\"", 9082 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9083 EXPECT_EQ("\"\\Uff01ff02\"", 9084 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9085 EXPECT_EQ("\"\\x000000000001\"\n" 9086 "\"next\"", 9087 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9088 EXPECT_EQ("\"\\x000000000001next\"", 9089 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9090 EXPECT_EQ("\"\\x000000000001\"", 9091 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9092 EXPECT_EQ("\"test\"\n" 9093 "\"\\000000\"\n" 9094 "\"000001\"", 9095 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9096 EXPECT_EQ("\"test\\000\"\n" 9097 "\"00000000\"\n" 9098 "\"1\"", 9099 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9100 } 9101 9102 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9103 verifyFormat("void f() {\n" 9104 " return g() {}\n" 9105 " void h() {}"); 9106 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9107 "g();\n" 9108 "}"); 9109 } 9110 9111 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9112 verifyFormat( 9113 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9114 } 9115 9116 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9117 verifyFormat("class X {\n" 9118 " void f() {\n" 9119 " }\n" 9120 "};", 9121 getLLVMStyleWithColumns(12)); 9122 } 9123 9124 TEST_F(FormatTest, ConfigurableIndentWidth) { 9125 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9126 EightIndent.IndentWidth = 8; 9127 EightIndent.ContinuationIndentWidth = 8; 9128 verifyFormat("void f() {\n" 9129 " someFunction();\n" 9130 " if (true) {\n" 9131 " f();\n" 9132 " }\n" 9133 "}", 9134 EightIndent); 9135 verifyFormat("class X {\n" 9136 " void f() {\n" 9137 " }\n" 9138 "};", 9139 EightIndent); 9140 verifyFormat("int x[] = {\n" 9141 " call(),\n" 9142 " call()};", 9143 EightIndent); 9144 } 9145 9146 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9147 verifyFormat("double\n" 9148 "f();", 9149 getLLVMStyleWithColumns(8)); 9150 } 9151 9152 TEST_F(FormatTest, ConfigurableUseOfTab) { 9153 FormatStyle Tab = getLLVMStyleWithColumns(42); 9154 Tab.IndentWidth = 8; 9155 Tab.UseTab = FormatStyle::UT_Always; 9156 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9157 9158 EXPECT_EQ("if (aaaaaaaa && // q\n" 9159 " bb)\t\t// w\n" 9160 "\t;", 9161 format("if (aaaaaaaa &&// q\n" 9162 "bb)// w\n" 9163 ";", 9164 Tab)); 9165 EXPECT_EQ("if (aaa && bbb) // w\n" 9166 "\t;", 9167 format("if(aaa&&bbb)// w\n" 9168 ";", 9169 Tab)); 9170 9171 verifyFormat("class X {\n" 9172 "\tvoid f() {\n" 9173 "\t\tsomeFunction(parameter1,\n" 9174 "\t\t\t parameter2);\n" 9175 "\t}\n" 9176 "};", 9177 Tab); 9178 verifyFormat("#define A \\\n" 9179 "\tvoid f() { \\\n" 9180 "\t\tsomeFunction( \\\n" 9181 "\t\t parameter1, \\\n" 9182 "\t\t parameter2); \\\n" 9183 "\t}", 9184 Tab); 9185 verifyFormat("int a;\t // x\n" 9186 "int bbbbbbbb; // x\n", 9187 Tab); 9188 9189 Tab.TabWidth = 4; 9190 Tab.IndentWidth = 8; 9191 verifyFormat("class TabWidth4Indent8 {\n" 9192 "\t\tvoid f() {\n" 9193 "\t\t\t\tsomeFunction(parameter1,\n" 9194 "\t\t\t\t\t\t\t parameter2);\n" 9195 "\t\t}\n" 9196 "};", 9197 Tab); 9198 9199 Tab.TabWidth = 4; 9200 Tab.IndentWidth = 4; 9201 verifyFormat("class TabWidth4Indent4 {\n" 9202 "\tvoid f() {\n" 9203 "\t\tsomeFunction(parameter1,\n" 9204 "\t\t\t\t\t parameter2);\n" 9205 "\t}\n" 9206 "};", 9207 Tab); 9208 9209 Tab.TabWidth = 8; 9210 Tab.IndentWidth = 4; 9211 verifyFormat("class TabWidth8Indent4 {\n" 9212 " void f() {\n" 9213 "\tsomeFunction(parameter1,\n" 9214 "\t\t parameter2);\n" 9215 " }\n" 9216 "};", 9217 Tab); 9218 9219 Tab.TabWidth = 8; 9220 Tab.IndentWidth = 8; 9221 EXPECT_EQ("/*\n" 9222 "\t a\t\tcomment\n" 9223 "\t in multiple lines\n" 9224 " */", 9225 format(" /*\t \t \n" 9226 " \t \t a\t\tcomment\t \t\n" 9227 " \t \t in multiple lines\t\n" 9228 " \t */", 9229 Tab)); 9230 9231 Tab.UseTab = FormatStyle::UT_ForIndentation; 9232 verifyFormat("{\n" 9233 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9234 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9235 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9236 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9237 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9238 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9239 "};", 9240 Tab); 9241 verifyFormat("enum AA {\n" 9242 "\ta1, // Force multiple lines\n" 9243 "\ta2,\n" 9244 "\ta3\n" 9245 "};", 9246 Tab); 9247 EXPECT_EQ("if (aaaaaaaa && // q\n" 9248 " bb) // w\n" 9249 "\t;", 9250 format("if (aaaaaaaa &&// q\n" 9251 "bb)// w\n" 9252 ";", 9253 Tab)); 9254 verifyFormat("class X {\n" 9255 "\tvoid f() {\n" 9256 "\t\tsomeFunction(parameter1,\n" 9257 "\t\t parameter2);\n" 9258 "\t}\n" 9259 "};", 9260 Tab); 9261 verifyFormat("{\n" 9262 "\tQ(\n" 9263 "\t {\n" 9264 "\t\t int a;\n" 9265 "\t\t someFunction(aaaaaaaa,\n" 9266 "\t\t bbbbbbb);\n" 9267 "\t },\n" 9268 "\t p);\n" 9269 "}", 9270 Tab); 9271 EXPECT_EQ("{\n" 9272 "\t/* aaaa\n" 9273 "\t bbbb */\n" 9274 "}", 9275 format("{\n" 9276 "/* aaaa\n" 9277 " bbbb */\n" 9278 "}", 9279 Tab)); 9280 EXPECT_EQ("{\n" 9281 "\t/*\n" 9282 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9283 "\t bbbbbbbbbbbbb\n" 9284 "\t*/\n" 9285 "}", 9286 format("{\n" 9287 "/*\n" 9288 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9289 "*/\n" 9290 "}", 9291 Tab)); 9292 EXPECT_EQ("{\n" 9293 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9294 "\t// bbbbbbbbbbbbb\n" 9295 "}", 9296 format("{\n" 9297 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9298 "}", 9299 Tab)); 9300 EXPECT_EQ("{\n" 9301 "\t/*\n" 9302 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9303 "\t bbbbbbbbbbbbb\n" 9304 "\t*/\n" 9305 "}", 9306 format("{\n" 9307 "\t/*\n" 9308 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9309 "\t*/\n" 9310 "}", 9311 Tab)); 9312 EXPECT_EQ("{\n" 9313 "\t/*\n" 9314 "\n" 9315 "\t*/\n" 9316 "}", 9317 format("{\n" 9318 "\t/*\n" 9319 "\n" 9320 "\t*/\n" 9321 "}", 9322 Tab)); 9323 EXPECT_EQ("{\n" 9324 "\t/*\n" 9325 " asdf\n" 9326 "\t*/\n" 9327 "}", 9328 format("{\n" 9329 "\t/*\n" 9330 " asdf\n" 9331 "\t*/\n" 9332 "}", 9333 Tab)); 9334 9335 Tab.UseTab = FormatStyle::UT_Never; 9336 EXPECT_EQ("/*\n" 9337 " a\t\tcomment\n" 9338 " in multiple lines\n" 9339 " */", 9340 format(" /*\t \t \n" 9341 " \t \t a\t\tcomment\t \t\n" 9342 " \t \t in multiple lines\t\n" 9343 " \t */", 9344 Tab)); 9345 EXPECT_EQ("/* some\n" 9346 " comment */", 9347 format(" \t \t /* some\n" 9348 " \t \t comment */", 9349 Tab)); 9350 EXPECT_EQ("int a; /* some\n" 9351 " comment */", 9352 format(" \t \t int a; /* some\n" 9353 " \t \t comment */", 9354 Tab)); 9355 9356 EXPECT_EQ("int a; /* some\n" 9357 "comment */", 9358 format(" \t \t int\ta; /* some\n" 9359 " \t \t comment */", 9360 Tab)); 9361 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9362 " comment */", 9363 format(" \t \t f(\"\t\t\"); /* some\n" 9364 " \t \t comment */", 9365 Tab)); 9366 EXPECT_EQ("{\n" 9367 " /*\n" 9368 " * Comment\n" 9369 " */\n" 9370 " int i;\n" 9371 "}", 9372 format("{\n" 9373 "\t/*\n" 9374 "\t * Comment\n" 9375 "\t */\n" 9376 "\t int i;\n" 9377 "}")); 9378 9379 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 9380 Tab.TabWidth = 8; 9381 Tab.IndentWidth = 8; 9382 EXPECT_EQ("if (aaaaaaaa && // q\n" 9383 " bb) // w\n" 9384 "\t;", 9385 format("if (aaaaaaaa &&// q\n" 9386 "bb)// w\n" 9387 ";", 9388 Tab)); 9389 EXPECT_EQ("if (aaa && bbb) // w\n" 9390 "\t;", 9391 format("if(aaa&&bbb)// w\n" 9392 ";", 9393 Tab)); 9394 verifyFormat("class X {\n" 9395 "\tvoid f() {\n" 9396 "\t\tsomeFunction(parameter1,\n" 9397 "\t\t\t parameter2);\n" 9398 "\t}\n" 9399 "};", 9400 Tab); 9401 verifyFormat("#define A \\\n" 9402 "\tvoid f() { \\\n" 9403 "\t\tsomeFunction( \\\n" 9404 "\t\t parameter1, \\\n" 9405 "\t\t parameter2); \\\n" 9406 "\t}", 9407 Tab); 9408 Tab.TabWidth = 4; 9409 Tab.IndentWidth = 8; 9410 verifyFormat("class TabWidth4Indent8 {\n" 9411 "\t\tvoid f() {\n" 9412 "\t\t\t\tsomeFunction(parameter1,\n" 9413 "\t\t\t\t\t\t\t parameter2);\n" 9414 "\t\t}\n" 9415 "};", 9416 Tab); 9417 Tab.TabWidth = 4; 9418 Tab.IndentWidth = 4; 9419 verifyFormat("class TabWidth4Indent4 {\n" 9420 "\tvoid f() {\n" 9421 "\t\tsomeFunction(parameter1,\n" 9422 "\t\t\t\t\t parameter2);\n" 9423 "\t}\n" 9424 "};", 9425 Tab); 9426 Tab.TabWidth = 8; 9427 Tab.IndentWidth = 4; 9428 verifyFormat("class TabWidth8Indent4 {\n" 9429 " void f() {\n" 9430 "\tsomeFunction(parameter1,\n" 9431 "\t\t parameter2);\n" 9432 " }\n" 9433 "};", 9434 Tab); 9435 Tab.TabWidth = 8; 9436 Tab.IndentWidth = 8; 9437 EXPECT_EQ("/*\n" 9438 "\t a\t\tcomment\n" 9439 "\t in multiple lines\n" 9440 " */", 9441 format(" /*\t \t \n" 9442 " \t \t a\t\tcomment\t \t\n" 9443 " \t \t in multiple lines\t\n" 9444 " \t */", 9445 Tab)); 9446 verifyFormat("{\n" 9447 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9448 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9449 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9450 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9451 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9452 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9453 "};", 9454 Tab); 9455 verifyFormat("enum AA {\n" 9456 "\ta1, // Force multiple lines\n" 9457 "\ta2,\n" 9458 "\ta3\n" 9459 "};", 9460 Tab); 9461 EXPECT_EQ("if (aaaaaaaa && // q\n" 9462 " bb) // w\n" 9463 "\t;", 9464 format("if (aaaaaaaa &&// q\n" 9465 "bb)// w\n" 9466 ";", 9467 Tab)); 9468 verifyFormat("class X {\n" 9469 "\tvoid f() {\n" 9470 "\t\tsomeFunction(parameter1,\n" 9471 "\t\t\t parameter2);\n" 9472 "\t}\n" 9473 "};", 9474 Tab); 9475 verifyFormat("{\n" 9476 "\tQ(\n" 9477 "\t {\n" 9478 "\t\t int a;\n" 9479 "\t\t someFunction(aaaaaaaa,\n" 9480 "\t\t\t\t bbbbbbb);\n" 9481 "\t },\n" 9482 "\t p);\n" 9483 "}", 9484 Tab); 9485 EXPECT_EQ("{\n" 9486 "\t/* aaaa\n" 9487 "\t bbbb */\n" 9488 "}", 9489 format("{\n" 9490 "/* aaaa\n" 9491 " bbbb */\n" 9492 "}", 9493 Tab)); 9494 EXPECT_EQ("{\n" 9495 "\t/*\n" 9496 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9497 "\t bbbbbbbbbbbbb\n" 9498 "\t*/\n" 9499 "}", 9500 format("{\n" 9501 "/*\n" 9502 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9503 "*/\n" 9504 "}", 9505 Tab)); 9506 EXPECT_EQ("{\n" 9507 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9508 "\t// bbbbbbbbbbbbb\n" 9509 "}", 9510 format("{\n" 9511 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9512 "}", 9513 Tab)); 9514 EXPECT_EQ("{\n" 9515 "\t/*\n" 9516 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9517 "\t bbbbbbbbbbbbb\n" 9518 "\t*/\n" 9519 "}", 9520 format("{\n" 9521 "\t/*\n" 9522 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9523 "\t*/\n" 9524 "}", 9525 Tab)); 9526 EXPECT_EQ("{\n" 9527 "\t/*\n" 9528 "\n" 9529 "\t*/\n" 9530 "}", 9531 format("{\n" 9532 "\t/*\n" 9533 "\n" 9534 "\t*/\n" 9535 "}", 9536 Tab)); 9537 EXPECT_EQ("{\n" 9538 "\t/*\n" 9539 " asdf\n" 9540 "\t*/\n" 9541 "}", 9542 format("{\n" 9543 "\t/*\n" 9544 " asdf\n" 9545 "\t*/\n" 9546 "}", 9547 Tab)); 9548 EXPECT_EQ("/*\n" 9549 "\t a\t\tcomment\n" 9550 "\t in multiple lines\n" 9551 " */", 9552 format(" /*\t \t \n" 9553 " \t \t a\t\tcomment\t \t\n" 9554 " \t \t in multiple lines\t\n" 9555 " \t */", 9556 Tab)); 9557 EXPECT_EQ("/* some\n" 9558 " comment */", 9559 format(" \t \t /* some\n" 9560 " \t \t comment */", 9561 Tab)); 9562 EXPECT_EQ("int a; /* some\n" 9563 " comment */", 9564 format(" \t \t int a; /* some\n" 9565 " \t \t comment */", 9566 Tab)); 9567 EXPECT_EQ("int a; /* some\n" 9568 "comment */", 9569 format(" \t \t int\ta; /* some\n" 9570 " \t \t comment */", 9571 Tab)); 9572 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9573 " comment */", 9574 format(" \t \t f(\"\t\t\"); /* some\n" 9575 " \t \t comment */", 9576 Tab)); 9577 EXPECT_EQ("{\n" 9578 " /*\n" 9579 " * Comment\n" 9580 " */\n" 9581 " int i;\n" 9582 "}", 9583 format("{\n" 9584 "\t/*\n" 9585 "\t * Comment\n" 9586 "\t */\n" 9587 "\t int i;\n" 9588 "}")); 9589 Tab.AlignConsecutiveAssignments = true; 9590 Tab.AlignConsecutiveDeclarations = true; 9591 Tab.TabWidth = 4; 9592 Tab.IndentWidth = 4; 9593 verifyFormat("class Assign {\n" 9594 "\tvoid f() {\n" 9595 "\t\tint x = 123;\n" 9596 "\t\tint random = 4;\n" 9597 "\t\tstd::string alphabet =\n" 9598 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 9599 "\t}\n" 9600 "};", 9601 Tab); 9602 } 9603 9604 TEST_F(FormatTest, CalculatesOriginalColumn) { 9605 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9606 "q\"; /* some\n" 9607 " comment */", 9608 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9609 "q\"; /* some\n" 9610 " comment */", 9611 getLLVMStyle())); 9612 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 9613 "/* some\n" 9614 " comment */", 9615 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 9616 " /* some\n" 9617 " comment */", 9618 getLLVMStyle())); 9619 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9620 "qqq\n" 9621 "/* some\n" 9622 " comment */", 9623 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9624 "qqq\n" 9625 " /* some\n" 9626 " comment */", 9627 getLLVMStyle())); 9628 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9629 "wwww; /* some\n" 9630 " comment */", 9631 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9632 "wwww; /* some\n" 9633 " comment */", 9634 getLLVMStyle())); 9635 } 9636 9637 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 9638 FormatStyle NoSpace = getLLVMStyle(); 9639 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 9640 9641 verifyFormat("while(true)\n" 9642 " continue;", 9643 NoSpace); 9644 verifyFormat("for(;;)\n" 9645 " continue;", 9646 NoSpace); 9647 verifyFormat("if(true)\n" 9648 " f();\n" 9649 "else if(true)\n" 9650 " f();", 9651 NoSpace); 9652 verifyFormat("do {\n" 9653 " do_something();\n" 9654 "} while(something());", 9655 NoSpace); 9656 verifyFormat("switch(x) {\n" 9657 "default:\n" 9658 " break;\n" 9659 "}", 9660 NoSpace); 9661 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 9662 verifyFormat("size_t x = sizeof(x);", NoSpace); 9663 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 9664 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 9665 verifyFormat("alignas(128) char a[128];", NoSpace); 9666 verifyFormat("size_t x = alignof(MyType);", NoSpace); 9667 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 9668 verifyFormat("int f() throw(Deprecated);", NoSpace); 9669 verifyFormat("typedef void (*cb)(int);", NoSpace); 9670 verifyFormat("T A::operator()();", NoSpace); 9671 verifyFormat("X A::operator++(T);", NoSpace); 9672 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 9673 9674 FormatStyle Space = getLLVMStyle(); 9675 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 9676 9677 verifyFormat("int f ();", Space); 9678 verifyFormat("void f (int a, T b) {\n" 9679 " while (true)\n" 9680 " continue;\n" 9681 "}", 9682 Space); 9683 verifyFormat("if (true)\n" 9684 " f ();\n" 9685 "else if (true)\n" 9686 " f ();", 9687 Space); 9688 verifyFormat("do {\n" 9689 " do_something ();\n" 9690 "} while (something ());", 9691 Space); 9692 verifyFormat("switch (x) {\n" 9693 "default:\n" 9694 " break;\n" 9695 "}", 9696 Space); 9697 verifyFormat("A::A () : a (1) {}", Space); 9698 verifyFormat("void f () __attribute__ ((asdf));", Space); 9699 verifyFormat("*(&a + 1);\n" 9700 "&((&a)[1]);\n" 9701 "a[(b + c) * d];\n" 9702 "(((a + 1) * 2) + 3) * 4;", 9703 Space); 9704 verifyFormat("#define A(x) x", Space); 9705 verifyFormat("#define A (x) x", Space); 9706 verifyFormat("#if defined(x)\n" 9707 "#endif", 9708 Space); 9709 verifyFormat("auto i = std::make_unique<int> (5);", Space); 9710 verifyFormat("size_t x = sizeof (x);", Space); 9711 verifyFormat("auto f (int x) -> decltype (x);", Space); 9712 verifyFormat("int f (T x) noexcept (x.create ());", Space); 9713 verifyFormat("alignas (128) char a[128];", Space); 9714 verifyFormat("size_t x = alignof (MyType);", Space); 9715 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 9716 verifyFormat("int f () throw (Deprecated);", Space); 9717 verifyFormat("typedef void (*cb) (int);", Space); 9718 verifyFormat("T A::operator() ();", Space); 9719 verifyFormat("X A::operator++ (T);", Space); 9720 verifyFormat("auto lambda = [] () { return 0; };", Space); 9721 verifyFormat("int x = int (y);", Space); 9722 9723 FormatStyle SomeSpace = getLLVMStyle(); 9724 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 9725 9726 verifyFormat("[]() -> float {}", SomeSpace); 9727 verifyFormat("[] (auto foo) {}", SomeSpace); 9728 verifyFormat("[foo]() -> int {}", SomeSpace); 9729 verifyFormat("int f();", SomeSpace); 9730 verifyFormat("void f (int a, T b) {\n" 9731 " while (true)\n" 9732 " continue;\n" 9733 "}", 9734 SomeSpace); 9735 verifyFormat("if (true)\n" 9736 " f();\n" 9737 "else if (true)\n" 9738 " f();", 9739 SomeSpace); 9740 verifyFormat("do {\n" 9741 " do_something();\n" 9742 "} while (something());", 9743 SomeSpace); 9744 verifyFormat("switch (x) {\n" 9745 "default:\n" 9746 " break;\n" 9747 "}", 9748 SomeSpace); 9749 verifyFormat("A::A() : a (1) {}", SomeSpace); 9750 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 9751 verifyFormat("*(&a + 1);\n" 9752 "&((&a)[1]);\n" 9753 "a[(b + c) * d];\n" 9754 "(((a + 1) * 2) + 3) * 4;", 9755 SomeSpace); 9756 verifyFormat("#define A(x) x", SomeSpace); 9757 verifyFormat("#define A (x) x", SomeSpace); 9758 verifyFormat("#if defined(x)\n" 9759 "#endif", 9760 SomeSpace); 9761 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 9762 verifyFormat("size_t x = sizeof (x);", SomeSpace); 9763 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 9764 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 9765 verifyFormat("alignas (128) char a[128];", SomeSpace); 9766 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 9767 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 9768 SomeSpace); 9769 verifyFormat("int f() throw (Deprecated);", SomeSpace); 9770 verifyFormat("typedef void (*cb) (int);", SomeSpace); 9771 verifyFormat("T A::operator()();", SomeSpace); 9772 verifyFormat("X A::operator++ (T);", SomeSpace); 9773 verifyFormat("int x = int (y);", SomeSpace); 9774 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 9775 } 9776 9777 TEST_F(FormatTest, SpaceAfterLogicalNot) { 9778 FormatStyle Spaces = getLLVMStyle(); 9779 Spaces.SpaceAfterLogicalNot = true; 9780 9781 verifyFormat("bool x = ! y", Spaces); 9782 verifyFormat("if (! isFailure())", Spaces); 9783 verifyFormat("if (! (a && b))", Spaces); 9784 verifyFormat("\"Error!\"", Spaces); 9785 verifyFormat("! ! x", Spaces); 9786 } 9787 9788 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 9789 FormatStyle Spaces = getLLVMStyle(); 9790 9791 Spaces.SpacesInParentheses = true; 9792 verifyFormat("do_something( ::globalVar );", Spaces); 9793 verifyFormat("call( x, y, z );", Spaces); 9794 verifyFormat("call();", Spaces); 9795 verifyFormat("std::function<void( int, int )> callback;", Spaces); 9796 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 9797 Spaces); 9798 verifyFormat("while ( (bool)1 )\n" 9799 " continue;", 9800 Spaces); 9801 verifyFormat("for ( ;; )\n" 9802 " continue;", 9803 Spaces); 9804 verifyFormat("if ( true )\n" 9805 " f();\n" 9806 "else if ( true )\n" 9807 " f();", 9808 Spaces); 9809 verifyFormat("do {\n" 9810 " do_something( (int)i );\n" 9811 "} while ( something() );", 9812 Spaces); 9813 verifyFormat("switch ( x ) {\n" 9814 "default:\n" 9815 " break;\n" 9816 "}", 9817 Spaces); 9818 9819 Spaces.SpacesInParentheses = false; 9820 Spaces.SpacesInCStyleCastParentheses = true; 9821 verifyFormat("Type *A = ( Type * )P;", Spaces); 9822 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 9823 verifyFormat("x = ( int32 )y;", Spaces); 9824 verifyFormat("int a = ( int )(2.0f);", Spaces); 9825 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 9826 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 9827 verifyFormat("#define x (( int )-1)", Spaces); 9828 9829 // Run the first set of tests again with: 9830 Spaces.SpacesInParentheses = false; 9831 Spaces.SpaceInEmptyParentheses = true; 9832 Spaces.SpacesInCStyleCastParentheses = true; 9833 verifyFormat("call(x, y, z);", Spaces); 9834 verifyFormat("call( );", Spaces); 9835 verifyFormat("std::function<void(int, int)> callback;", Spaces); 9836 verifyFormat("while (( bool )1)\n" 9837 " continue;", 9838 Spaces); 9839 verifyFormat("for (;;)\n" 9840 " continue;", 9841 Spaces); 9842 verifyFormat("if (true)\n" 9843 " f( );\n" 9844 "else if (true)\n" 9845 " f( );", 9846 Spaces); 9847 verifyFormat("do {\n" 9848 " do_something(( int )i);\n" 9849 "} while (something( ));", 9850 Spaces); 9851 verifyFormat("switch (x) {\n" 9852 "default:\n" 9853 " break;\n" 9854 "}", 9855 Spaces); 9856 9857 // Run the first set of tests again with: 9858 Spaces.SpaceAfterCStyleCast = true; 9859 verifyFormat("call(x, y, z);", Spaces); 9860 verifyFormat("call( );", Spaces); 9861 verifyFormat("std::function<void(int, int)> callback;", Spaces); 9862 verifyFormat("while (( bool ) 1)\n" 9863 " continue;", 9864 Spaces); 9865 verifyFormat("for (;;)\n" 9866 " continue;", 9867 Spaces); 9868 verifyFormat("if (true)\n" 9869 " f( );\n" 9870 "else if (true)\n" 9871 " f( );", 9872 Spaces); 9873 verifyFormat("do {\n" 9874 " do_something(( int ) i);\n" 9875 "} while (something( ));", 9876 Spaces); 9877 verifyFormat("switch (x) {\n" 9878 "default:\n" 9879 " break;\n" 9880 "}", 9881 Spaces); 9882 9883 // Run subset of tests again with: 9884 Spaces.SpacesInCStyleCastParentheses = false; 9885 Spaces.SpaceAfterCStyleCast = true; 9886 verifyFormat("while ((bool) 1)\n" 9887 " continue;", 9888 Spaces); 9889 verifyFormat("do {\n" 9890 " do_something((int) i);\n" 9891 "} while (something( ));", 9892 Spaces); 9893 } 9894 9895 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 9896 verifyFormat("int a[5];"); 9897 verifyFormat("a[3] += 42;"); 9898 9899 FormatStyle Spaces = getLLVMStyle(); 9900 Spaces.SpacesInSquareBrackets = true; 9901 // Lambdas unchanged. 9902 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 9903 verifyFormat("return [i, args...] {};", Spaces); 9904 9905 // Not lambdas. 9906 verifyFormat("int a[ 5 ];", Spaces); 9907 verifyFormat("a[ 3 ] += 42;", Spaces); 9908 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 9909 verifyFormat("double &operator[](int i) { return 0; }\n" 9910 "int i;", 9911 Spaces); 9912 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 9913 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 9914 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 9915 } 9916 9917 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 9918 verifyFormat("int a = 5;"); 9919 verifyFormat("a += 42;"); 9920 verifyFormat("a or_eq 8;"); 9921 9922 FormatStyle Spaces = getLLVMStyle(); 9923 Spaces.SpaceBeforeAssignmentOperators = false; 9924 verifyFormat("int a= 5;", Spaces); 9925 verifyFormat("a+= 42;", Spaces); 9926 verifyFormat("a or_eq 8;", Spaces); 9927 } 9928 9929 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 9930 verifyFormat("class Foo : public Bar {};"); 9931 verifyFormat("Foo::Foo() : foo(1) {}"); 9932 verifyFormat("for (auto a : b) {\n}"); 9933 verifyFormat("int x = a ? b : c;"); 9934 verifyFormat("{\n" 9935 "label0:\n" 9936 " int x = 0;\n" 9937 "}"); 9938 verifyFormat("switch (x) {\n" 9939 "case 1:\n" 9940 "default:\n" 9941 "}"); 9942 9943 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 9944 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 9945 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 9946 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 9947 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 9948 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 9949 verifyFormat("{\n" 9950 "label1:\n" 9951 " int x = 0;\n" 9952 "}", 9953 CtorInitializerStyle); 9954 verifyFormat("switch (x) {\n" 9955 "case 1:\n" 9956 "default:\n" 9957 "}", 9958 CtorInitializerStyle); 9959 CtorInitializerStyle.BreakConstructorInitializers = 9960 FormatStyle::BCIS_AfterColon; 9961 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 9962 " aaaaaaaaaaaaaaaa(1),\n" 9963 " bbbbbbbbbbbbbbbb(2) {}", 9964 CtorInitializerStyle); 9965 CtorInitializerStyle.BreakConstructorInitializers = 9966 FormatStyle::BCIS_BeforeComma; 9967 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 9968 " : aaaaaaaaaaaaaaaa(1)\n" 9969 " , bbbbbbbbbbbbbbbb(2) {}", 9970 CtorInitializerStyle); 9971 CtorInitializerStyle.BreakConstructorInitializers = 9972 FormatStyle::BCIS_BeforeColon; 9973 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 9974 " : aaaaaaaaaaaaaaaa(1),\n" 9975 " bbbbbbbbbbbbbbbb(2) {}", 9976 CtorInitializerStyle); 9977 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 9978 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 9979 ": aaaaaaaaaaaaaaaa(1),\n" 9980 " bbbbbbbbbbbbbbbb(2) {}", 9981 CtorInitializerStyle); 9982 9983 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 9984 InheritanceStyle.SpaceBeforeInheritanceColon = false; 9985 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 9986 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 9987 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 9988 verifyFormat("int x = a ? b : c;", InheritanceStyle); 9989 verifyFormat("{\n" 9990 "label2:\n" 9991 " int x = 0;\n" 9992 "}", 9993 InheritanceStyle); 9994 verifyFormat("switch (x) {\n" 9995 "case 1:\n" 9996 "default:\n" 9997 "}", 9998 InheritanceStyle); 9999 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 10000 verifyFormat("class Foooooooooooooooooooooo:\n" 10001 " public aaaaaaaaaaaaaaaaaa,\n" 10002 " public bbbbbbbbbbbbbbbbbb {\n" 10003 "}", 10004 InheritanceStyle); 10005 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 10006 verifyFormat("class Foooooooooooooooooooooo\n" 10007 " : public aaaaaaaaaaaaaaaaaa\n" 10008 " , public bbbbbbbbbbbbbbbbbb {\n" 10009 "}", 10010 InheritanceStyle); 10011 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 10012 verifyFormat("class Foooooooooooooooooooooo\n" 10013 " : public aaaaaaaaaaaaaaaaaa,\n" 10014 " public bbbbbbbbbbbbbbbbbb {\n" 10015 "}", 10016 InheritanceStyle); 10017 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 10018 verifyFormat("class Foooooooooooooooooooooo\n" 10019 ": public aaaaaaaaaaaaaaaaaa,\n" 10020 " public bbbbbbbbbbbbbbbbbb {}", 10021 InheritanceStyle); 10022 10023 FormatStyle ForLoopStyle = getLLVMStyle(); 10024 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 10025 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 10026 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 10027 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 10028 verifyFormat("int x = a ? b : c;", ForLoopStyle); 10029 verifyFormat("{\n" 10030 "label2:\n" 10031 " int x = 0;\n" 10032 "}", 10033 ForLoopStyle); 10034 verifyFormat("switch (x) {\n" 10035 "case 1:\n" 10036 "default:\n" 10037 "}", 10038 ForLoopStyle); 10039 10040 FormatStyle NoSpaceStyle = getLLVMStyle(); 10041 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 10042 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 10043 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 10044 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 10045 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 10046 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 10047 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 10048 verifyFormat("{\n" 10049 "label3:\n" 10050 " int x = 0;\n" 10051 "}", 10052 NoSpaceStyle); 10053 verifyFormat("switch (x) {\n" 10054 "case 1:\n" 10055 "default:\n" 10056 "}", 10057 NoSpaceStyle); 10058 } 10059 10060 TEST_F(FormatTest, AlignConsecutiveAssignments) { 10061 FormatStyle Alignment = getLLVMStyle(); 10062 Alignment.AlignConsecutiveAssignments = false; 10063 verifyFormat("int a = 5;\n" 10064 "int oneTwoThree = 123;", 10065 Alignment); 10066 verifyFormat("int a = 5;\n" 10067 "int oneTwoThree = 123;", 10068 Alignment); 10069 10070 Alignment.AlignConsecutiveAssignments = true; 10071 verifyFormat("int a = 5;\n" 10072 "int oneTwoThree = 123;", 10073 Alignment); 10074 verifyFormat("int a = method();\n" 10075 "int oneTwoThree = 133;", 10076 Alignment); 10077 verifyFormat("a &= 5;\n" 10078 "bcd *= 5;\n" 10079 "ghtyf += 5;\n" 10080 "dvfvdb -= 5;\n" 10081 "a /= 5;\n" 10082 "vdsvsv %= 5;\n" 10083 "sfdbddfbdfbb ^= 5;\n" 10084 "dvsdsv |= 5;\n" 10085 "int dsvvdvsdvvv = 123;", 10086 Alignment); 10087 verifyFormat("int i = 1, j = 10;\n" 10088 "something = 2000;", 10089 Alignment); 10090 verifyFormat("something = 2000;\n" 10091 "int i = 1, j = 10;\n", 10092 Alignment); 10093 verifyFormat("something = 2000;\n" 10094 "another = 911;\n" 10095 "int i = 1, j = 10;\n" 10096 "oneMore = 1;\n" 10097 "i = 2;", 10098 Alignment); 10099 verifyFormat("int a = 5;\n" 10100 "int one = 1;\n" 10101 "method();\n" 10102 "int oneTwoThree = 123;\n" 10103 "int oneTwo = 12;", 10104 Alignment); 10105 verifyFormat("int oneTwoThree = 123;\n" 10106 "int oneTwo = 12;\n" 10107 "method();\n", 10108 Alignment); 10109 verifyFormat("int oneTwoThree = 123; // comment\n" 10110 "int oneTwo = 12; // comment", 10111 Alignment); 10112 EXPECT_EQ("int a = 5;\n" 10113 "\n" 10114 "int oneTwoThree = 123;", 10115 format("int a = 5;\n" 10116 "\n" 10117 "int oneTwoThree= 123;", 10118 Alignment)); 10119 EXPECT_EQ("int a = 5;\n" 10120 "int one = 1;\n" 10121 "\n" 10122 "int oneTwoThree = 123;", 10123 format("int a = 5;\n" 10124 "int one = 1;\n" 10125 "\n" 10126 "int oneTwoThree = 123;", 10127 Alignment)); 10128 EXPECT_EQ("int a = 5;\n" 10129 "int one = 1;\n" 10130 "\n" 10131 "int oneTwoThree = 123;\n" 10132 "int oneTwo = 12;", 10133 format("int a = 5;\n" 10134 "int one = 1;\n" 10135 "\n" 10136 "int oneTwoThree = 123;\n" 10137 "int oneTwo = 12;", 10138 Alignment)); 10139 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10140 verifyFormat("#define A \\\n" 10141 " int aaaa = 12; \\\n" 10142 " int b = 23; \\\n" 10143 " int ccc = 234; \\\n" 10144 " int dddddddddd = 2345;", 10145 Alignment); 10146 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10147 verifyFormat("#define A \\\n" 10148 " int aaaa = 12; \\\n" 10149 " int b = 23; \\\n" 10150 " int ccc = 234; \\\n" 10151 " int dddddddddd = 2345;", 10152 Alignment); 10153 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10154 verifyFormat("#define A " 10155 " \\\n" 10156 " int aaaa = 12; " 10157 " \\\n" 10158 " int b = 23; " 10159 " \\\n" 10160 " int ccc = 234; " 10161 " \\\n" 10162 " int dddddddddd = 2345;", 10163 Alignment); 10164 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10165 "k = 4, int l = 5,\n" 10166 " int m = 6) {\n" 10167 " int j = 10;\n" 10168 " otherThing = 1;\n" 10169 "}", 10170 Alignment); 10171 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10172 " int i = 1;\n" 10173 " int j = 2;\n" 10174 " int big = 10000;\n" 10175 "}", 10176 Alignment); 10177 verifyFormat("class C {\n" 10178 "public:\n" 10179 " int i = 1;\n" 10180 " virtual void f() = 0;\n" 10181 "};", 10182 Alignment); 10183 verifyFormat("int i = 1;\n" 10184 "if (SomeType t = getSomething()) {\n" 10185 "}\n" 10186 "int j = 2;\n" 10187 "int big = 10000;", 10188 Alignment); 10189 verifyFormat("int j = 7;\n" 10190 "for (int k = 0; k < N; ++k) {\n" 10191 "}\n" 10192 "int j = 2;\n" 10193 "int big = 10000;\n" 10194 "}", 10195 Alignment); 10196 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10197 verifyFormat("int i = 1;\n" 10198 "LooooooooooongType loooooooooooooooooooooongVariable\n" 10199 " = someLooooooooooooooooongFunction();\n" 10200 "int j = 2;", 10201 Alignment); 10202 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 10203 verifyFormat("int i = 1;\n" 10204 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 10205 " someLooooooooooooooooongFunction();\n" 10206 "int j = 2;", 10207 Alignment); 10208 10209 verifyFormat("auto lambda = []() {\n" 10210 " auto i = 0;\n" 10211 " return 0;\n" 10212 "};\n" 10213 "int i = 0;\n" 10214 "auto v = type{\n" 10215 " i = 1, //\n" 10216 " (i = 2), //\n" 10217 " i = 3 //\n" 10218 "};", 10219 Alignment); 10220 10221 verifyFormat( 10222 "int i = 1;\n" 10223 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 10224 " loooooooooooooooooooooongParameterB);\n" 10225 "int j = 2;", 10226 Alignment); 10227 10228 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 10229 " typename B = very_long_type_name_1,\n" 10230 " typename T_2 = very_long_type_name_2>\n" 10231 "auto foo() {}\n", 10232 Alignment); 10233 verifyFormat("int a, b = 1;\n" 10234 "int c = 2;\n" 10235 "int dd = 3;\n", 10236 Alignment); 10237 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10238 "float b[1][] = {{3.f}};\n", 10239 Alignment); 10240 verifyFormat("for (int i = 0; i < 1; i++)\n" 10241 " int x = 1;\n", 10242 Alignment); 10243 verifyFormat("for (i = 0; i < 1; i++)\n" 10244 " x = 1;\n" 10245 "y = 1;\n", 10246 Alignment); 10247 } 10248 10249 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 10250 FormatStyle Alignment = getLLVMStyle(); 10251 Alignment.AlignConsecutiveDeclarations = false; 10252 verifyFormat("float const a = 5;\n" 10253 "int oneTwoThree = 123;", 10254 Alignment); 10255 verifyFormat("int a = 5;\n" 10256 "float const oneTwoThree = 123;", 10257 Alignment); 10258 10259 Alignment.AlignConsecutiveDeclarations = true; 10260 verifyFormat("float const a = 5;\n" 10261 "int oneTwoThree = 123;", 10262 Alignment); 10263 verifyFormat("int a = method();\n" 10264 "float const oneTwoThree = 133;", 10265 Alignment); 10266 verifyFormat("int i = 1, j = 10;\n" 10267 "something = 2000;", 10268 Alignment); 10269 verifyFormat("something = 2000;\n" 10270 "int i = 1, j = 10;\n", 10271 Alignment); 10272 verifyFormat("float something = 2000;\n" 10273 "double another = 911;\n" 10274 "int i = 1, j = 10;\n" 10275 "const int *oneMore = 1;\n" 10276 "unsigned i = 2;", 10277 Alignment); 10278 verifyFormat("float a = 5;\n" 10279 "int one = 1;\n" 10280 "method();\n" 10281 "const double oneTwoThree = 123;\n" 10282 "const unsigned int oneTwo = 12;", 10283 Alignment); 10284 verifyFormat("int oneTwoThree{0}; // comment\n" 10285 "unsigned oneTwo; // comment", 10286 Alignment); 10287 EXPECT_EQ("float const a = 5;\n" 10288 "\n" 10289 "int oneTwoThree = 123;", 10290 format("float const a = 5;\n" 10291 "\n" 10292 "int oneTwoThree= 123;", 10293 Alignment)); 10294 EXPECT_EQ("float a = 5;\n" 10295 "int one = 1;\n" 10296 "\n" 10297 "unsigned oneTwoThree = 123;", 10298 format("float a = 5;\n" 10299 "int one = 1;\n" 10300 "\n" 10301 "unsigned oneTwoThree = 123;", 10302 Alignment)); 10303 EXPECT_EQ("float a = 5;\n" 10304 "int one = 1;\n" 10305 "\n" 10306 "unsigned oneTwoThree = 123;\n" 10307 "int oneTwo = 12;", 10308 format("float a = 5;\n" 10309 "int one = 1;\n" 10310 "\n" 10311 "unsigned oneTwoThree = 123;\n" 10312 "int oneTwo = 12;", 10313 Alignment)); 10314 // Function prototype alignment 10315 verifyFormat("int a();\n" 10316 "double b();", 10317 Alignment); 10318 verifyFormat("int a(int x);\n" 10319 "double b();", 10320 Alignment); 10321 unsigned OldColumnLimit = Alignment.ColumnLimit; 10322 // We need to set ColumnLimit to zero, in order to stress nested alignments, 10323 // otherwise the function parameters will be re-flowed onto a single line. 10324 Alignment.ColumnLimit = 0; 10325 EXPECT_EQ("int a(int x,\n" 10326 " float y);\n" 10327 "double b(int x,\n" 10328 " double y);", 10329 format("int a(int x,\n" 10330 " float y);\n" 10331 "double b(int x,\n" 10332 " double y);", 10333 Alignment)); 10334 // This ensures that function parameters of function declarations are 10335 // correctly indented when their owning functions are indented. 10336 // The failure case here is for 'double y' to not be indented enough. 10337 EXPECT_EQ("double a(int x);\n" 10338 "int b(int y,\n" 10339 " double z);", 10340 format("double a(int x);\n" 10341 "int b(int y,\n" 10342 " double z);", 10343 Alignment)); 10344 // Set ColumnLimit low so that we induce wrapping immediately after 10345 // the function name and opening paren. 10346 Alignment.ColumnLimit = 13; 10347 verifyFormat("int function(\n" 10348 " int x,\n" 10349 " bool y);", 10350 Alignment); 10351 Alignment.ColumnLimit = OldColumnLimit; 10352 // Ensure function pointers don't screw up recursive alignment 10353 verifyFormat("int a(int x, void (*fp)(int y));\n" 10354 "double b();", 10355 Alignment); 10356 Alignment.AlignConsecutiveAssignments = true; 10357 // Ensure recursive alignment is broken by function braces, so that the 10358 // "a = 1" does not align with subsequent assignments inside the function 10359 // body. 10360 verifyFormat("int func(int a = 1) {\n" 10361 " int b = 2;\n" 10362 " int cc = 3;\n" 10363 "}", 10364 Alignment); 10365 verifyFormat("float something = 2000;\n" 10366 "double another = 911;\n" 10367 "int i = 1, j = 10;\n" 10368 "const int *oneMore = 1;\n" 10369 "unsigned i = 2;", 10370 Alignment); 10371 verifyFormat("int oneTwoThree = {0}; // comment\n" 10372 "unsigned oneTwo = 0; // comment", 10373 Alignment); 10374 // Make sure that scope is correctly tracked, in the absence of braces 10375 verifyFormat("for (int i = 0; i < n; i++)\n" 10376 " j = i;\n" 10377 "double x = 1;\n", 10378 Alignment); 10379 verifyFormat("if (int i = 0)\n" 10380 " j = i;\n" 10381 "double x = 1;\n", 10382 Alignment); 10383 // Ensure operator[] and operator() are comprehended 10384 verifyFormat("struct test {\n" 10385 " long long int foo();\n" 10386 " int operator[](int a);\n" 10387 " double bar();\n" 10388 "};\n", 10389 Alignment); 10390 verifyFormat("struct test {\n" 10391 " long long int foo();\n" 10392 " int operator()(int a);\n" 10393 " double bar();\n" 10394 "};\n", 10395 Alignment); 10396 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 10397 " int const i = 1;\n" 10398 " int * j = 2;\n" 10399 " int big = 10000;\n" 10400 "\n" 10401 " unsigned oneTwoThree = 123;\n" 10402 " int oneTwo = 12;\n" 10403 " method();\n" 10404 " float k = 2;\n" 10405 " int ll = 10000;\n" 10406 "}", 10407 format("void SomeFunction(int parameter= 0) {\n" 10408 " int const i= 1;\n" 10409 " int *j=2;\n" 10410 " int big = 10000;\n" 10411 "\n" 10412 "unsigned oneTwoThree =123;\n" 10413 "int oneTwo = 12;\n" 10414 " method();\n" 10415 "float k= 2;\n" 10416 "int ll=10000;\n" 10417 "}", 10418 Alignment)); 10419 Alignment.AlignConsecutiveAssignments = false; 10420 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10421 verifyFormat("#define A \\\n" 10422 " int aaaa = 12; \\\n" 10423 " float b = 23; \\\n" 10424 " const int ccc = 234; \\\n" 10425 " unsigned dddddddddd = 2345;", 10426 Alignment); 10427 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10428 verifyFormat("#define A \\\n" 10429 " int aaaa = 12; \\\n" 10430 " float b = 23; \\\n" 10431 " const int ccc = 234; \\\n" 10432 " unsigned dddddddddd = 2345;", 10433 Alignment); 10434 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10435 Alignment.ColumnLimit = 30; 10436 verifyFormat("#define A \\\n" 10437 " int aaaa = 12; \\\n" 10438 " float b = 23; \\\n" 10439 " const int ccc = 234; \\\n" 10440 " int dddddddddd = 2345;", 10441 Alignment); 10442 Alignment.ColumnLimit = 80; 10443 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10444 "k = 4, int l = 5,\n" 10445 " int m = 6) {\n" 10446 " const int j = 10;\n" 10447 " otherThing = 1;\n" 10448 "}", 10449 Alignment); 10450 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10451 " int const i = 1;\n" 10452 " int * j = 2;\n" 10453 " int big = 10000;\n" 10454 "}", 10455 Alignment); 10456 verifyFormat("class C {\n" 10457 "public:\n" 10458 " int i = 1;\n" 10459 " virtual void f() = 0;\n" 10460 "};", 10461 Alignment); 10462 verifyFormat("float i = 1;\n" 10463 "if (SomeType t = getSomething()) {\n" 10464 "}\n" 10465 "const unsigned j = 2;\n" 10466 "int big = 10000;", 10467 Alignment); 10468 verifyFormat("float j = 7;\n" 10469 "for (int k = 0; k < N; ++k) {\n" 10470 "}\n" 10471 "unsigned j = 2;\n" 10472 "int big = 10000;\n" 10473 "}", 10474 Alignment); 10475 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10476 verifyFormat("float i = 1;\n" 10477 "LooooooooooongType loooooooooooooooooooooongVariable\n" 10478 " = someLooooooooooooooooongFunction();\n" 10479 "int j = 2;", 10480 Alignment); 10481 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 10482 verifyFormat("int i = 1;\n" 10483 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 10484 " someLooooooooooooooooongFunction();\n" 10485 "int j = 2;", 10486 Alignment); 10487 10488 Alignment.AlignConsecutiveAssignments = true; 10489 verifyFormat("auto lambda = []() {\n" 10490 " auto ii = 0;\n" 10491 " float j = 0;\n" 10492 " return 0;\n" 10493 "};\n" 10494 "int i = 0;\n" 10495 "float i2 = 0;\n" 10496 "auto v = type{\n" 10497 " i = 1, //\n" 10498 " (i = 2), //\n" 10499 " i = 3 //\n" 10500 "};", 10501 Alignment); 10502 Alignment.AlignConsecutiveAssignments = false; 10503 10504 verifyFormat( 10505 "int i = 1;\n" 10506 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 10507 " loooooooooooooooooooooongParameterB);\n" 10508 "int j = 2;", 10509 Alignment); 10510 10511 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 10512 // We expect declarations and assignments to align, as long as it doesn't 10513 // exceed the column limit, starting a new alignment sequence whenever it 10514 // happens. 10515 Alignment.AlignConsecutiveAssignments = true; 10516 Alignment.ColumnLimit = 30; 10517 verifyFormat("float ii = 1;\n" 10518 "unsigned j = 2;\n" 10519 "int someVerylongVariable = 1;\n" 10520 "AnotherLongType ll = 123456;\n" 10521 "VeryVeryLongType k = 2;\n" 10522 "int myvar = 1;", 10523 Alignment); 10524 Alignment.ColumnLimit = 80; 10525 Alignment.AlignConsecutiveAssignments = false; 10526 10527 verifyFormat( 10528 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 10529 " typename LongType, typename B>\n" 10530 "auto foo() {}\n", 10531 Alignment); 10532 verifyFormat("float a, b = 1;\n" 10533 "int c = 2;\n" 10534 "int dd = 3;\n", 10535 Alignment); 10536 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10537 "float b[1][] = {{3.f}};\n", 10538 Alignment); 10539 Alignment.AlignConsecutiveAssignments = true; 10540 verifyFormat("float a, b = 1;\n" 10541 "int c = 2;\n" 10542 "int dd = 3;\n", 10543 Alignment); 10544 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10545 "float b[1][] = {{3.f}};\n", 10546 Alignment); 10547 Alignment.AlignConsecutiveAssignments = false; 10548 10549 Alignment.ColumnLimit = 30; 10550 Alignment.BinPackParameters = false; 10551 verifyFormat("void foo(float a,\n" 10552 " float b,\n" 10553 " int c,\n" 10554 " uint32_t *d) {\n" 10555 " int * e = 0;\n" 10556 " float f = 0;\n" 10557 " double g = 0;\n" 10558 "}\n" 10559 "void bar(ino_t a,\n" 10560 " int b,\n" 10561 " uint32_t *c,\n" 10562 " bool d) {}\n", 10563 Alignment); 10564 Alignment.BinPackParameters = true; 10565 Alignment.ColumnLimit = 80; 10566 10567 // Bug 33507 10568 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 10569 verifyFormat( 10570 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 10571 " static const Version verVs2017;\n" 10572 " return true;\n" 10573 "});\n", 10574 Alignment); 10575 Alignment.PointerAlignment = FormatStyle::PAS_Right; 10576 10577 // See llvm.org/PR35641 10578 Alignment.AlignConsecutiveDeclarations = true; 10579 verifyFormat("int func() { //\n" 10580 " int b;\n" 10581 " unsigned c;\n" 10582 "}", 10583 Alignment); 10584 10585 // See PR37175 10586 FormatStyle Style = getMozillaStyle(); 10587 Style.AlignConsecutiveDeclarations = true; 10588 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 10589 "foo(int a);", 10590 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 10591 } 10592 10593 TEST_F(FormatTest, LinuxBraceBreaking) { 10594 FormatStyle LinuxBraceStyle = getLLVMStyle(); 10595 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 10596 verifyFormat("namespace a\n" 10597 "{\n" 10598 "class A\n" 10599 "{\n" 10600 " void f()\n" 10601 " {\n" 10602 " if (true) {\n" 10603 " a();\n" 10604 " b();\n" 10605 " } else {\n" 10606 " a();\n" 10607 " }\n" 10608 " }\n" 10609 " void g() { return; }\n" 10610 "};\n" 10611 "struct B {\n" 10612 " int x;\n" 10613 "};\n" 10614 "} // namespace a\n", 10615 LinuxBraceStyle); 10616 verifyFormat("enum X {\n" 10617 " Y = 0,\n" 10618 "}\n", 10619 LinuxBraceStyle); 10620 verifyFormat("struct S {\n" 10621 " int Type;\n" 10622 " union {\n" 10623 " int x;\n" 10624 " double y;\n" 10625 " } Value;\n" 10626 " class C\n" 10627 " {\n" 10628 " MyFavoriteType Value;\n" 10629 " } Class;\n" 10630 "}\n", 10631 LinuxBraceStyle); 10632 } 10633 10634 TEST_F(FormatTest, MozillaBraceBreaking) { 10635 FormatStyle MozillaBraceStyle = getLLVMStyle(); 10636 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 10637 MozillaBraceStyle.FixNamespaceComments = false; 10638 verifyFormat("namespace a {\n" 10639 "class A\n" 10640 "{\n" 10641 " void f()\n" 10642 " {\n" 10643 " if (true) {\n" 10644 " a();\n" 10645 " b();\n" 10646 " }\n" 10647 " }\n" 10648 " void g() { return; }\n" 10649 "};\n" 10650 "enum E\n" 10651 "{\n" 10652 " A,\n" 10653 " // foo\n" 10654 " B,\n" 10655 " C\n" 10656 "};\n" 10657 "struct B\n" 10658 "{\n" 10659 " int x;\n" 10660 "};\n" 10661 "}\n", 10662 MozillaBraceStyle); 10663 verifyFormat("struct S\n" 10664 "{\n" 10665 " int Type;\n" 10666 " union\n" 10667 " {\n" 10668 " int x;\n" 10669 " double y;\n" 10670 " } Value;\n" 10671 " class C\n" 10672 " {\n" 10673 " MyFavoriteType Value;\n" 10674 " } Class;\n" 10675 "}\n", 10676 MozillaBraceStyle); 10677 } 10678 10679 TEST_F(FormatTest, StroustrupBraceBreaking) { 10680 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 10681 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 10682 verifyFormat("namespace a {\n" 10683 "class A {\n" 10684 " void f()\n" 10685 " {\n" 10686 " if (true) {\n" 10687 " a();\n" 10688 " b();\n" 10689 " }\n" 10690 " }\n" 10691 " void g() { return; }\n" 10692 "};\n" 10693 "struct B {\n" 10694 " int x;\n" 10695 "};\n" 10696 "} // namespace a\n", 10697 StroustrupBraceStyle); 10698 10699 verifyFormat("void foo()\n" 10700 "{\n" 10701 " if (a) {\n" 10702 " a();\n" 10703 " }\n" 10704 " else {\n" 10705 " b();\n" 10706 " }\n" 10707 "}\n", 10708 StroustrupBraceStyle); 10709 10710 verifyFormat("#ifdef _DEBUG\n" 10711 "int foo(int i = 0)\n" 10712 "#else\n" 10713 "int foo(int i = 5)\n" 10714 "#endif\n" 10715 "{\n" 10716 " return i;\n" 10717 "}", 10718 StroustrupBraceStyle); 10719 10720 verifyFormat("void foo() {}\n" 10721 "void bar()\n" 10722 "#ifdef _DEBUG\n" 10723 "{\n" 10724 " foo();\n" 10725 "}\n" 10726 "#else\n" 10727 "{\n" 10728 "}\n" 10729 "#endif", 10730 StroustrupBraceStyle); 10731 10732 verifyFormat("void foobar() { int i = 5; }\n" 10733 "#ifdef _DEBUG\n" 10734 "void bar() {}\n" 10735 "#else\n" 10736 "void bar() { foobar(); }\n" 10737 "#endif", 10738 StroustrupBraceStyle); 10739 } 10740 10741 TEST_F(FormatTest, AllmanBraceBreaking) { 10742 FormatStyle AllmanBraceStyle = getLLVMStyle(); 10743 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 10744 10745 EXPECT_EQ("namespace a\n" 10746 "{\n" 10747 "void f();\n" 10748 "void g();\n" 10749 "} // namespace a\n", 10750 format("namespace a\n" 10751 "{\n" 10752 "void f();\n" 10753 "void g();\n" 10754 "}\n", 10755 AllmanBraceStyle)); 10756 10757 verifyFormat("namespace a\n" 10758 "{\n" 10759 "class A\n" 10760 "{\n" 10761 " void f()\n" 10762 " {\n" 10763 " if (true)\n" 10764 " {\n" 10765 " a();\n" 10766 " b();\n" 10767 " }\n" 10768 " }\n" 10769 " void g() { return; }\n" 10770 "};\n" 10771 "struct B\n" 10772 "{\n" 10773 " int x;\n" 10774 "};\n" 10775 "} // namespace a", 10776 AllmanBraceStyle); 10777 10778 verifyFormat("void f()\n" 10779 "{\n" 10780 " if (true)\n" 10781 " {\n" 10782 " a();\n" 10783 " }\n" 10784 " else if (false)\n" 10785 " {\n" 10786 " b();\n" 10787 " }\n" 10788 " else\n" 10789 " {\n" 10790 " c();\n" 10791 " }\n" 10792 "}\n", 10793 AllmanBraceStyle); 10794 10795 verifyFormat("void f()\n" 10796 "{\n" 10797 " for (int i = 0; i < 10; ++i)\n" 10798 " {\n" 10799 " a();\n" 10800 " }\n" 10801 " while (false)\n" 10802 " {\n" 10803 " b();\n" 10804 " }\n" 10805 " do\n" 10806 " {\n" 10807 " c();\n" 10808 " } while (false)\n" 10809 "}\n", 10810 AllmanBraceStyle); 10811 10812 verifyFormat("void f(int a)\n" 10813 "{\n" 10814 " switch (a)\n" 10815 " {\n" 10816 " case 0:\n" 10817 " break;\n" 10818 " case 1:\n" 10819 " {\n" 10820 " break;\n" 10821 " }\n" 10822 " case 2:\n" 10823 " {\n" 10824 " }\n" 10825 " break;\n" 10826 " default:\n" 10827 " break;\n" 10828 " }\n" 10829 "}\n", 10830 AllmanBraceStyle); 10831 10832 verifyFormat("enum X\n" 10833 "{\n" 10834 " Y = 0,\n" 10835 "}\n", 10836 AllmanBraceStyle); 10837 verifyFormat("enum X\n" 10838 "{\n" 10839 " Y = 0\n" 10840 "}\n", 10841 AllmanBraceStyle); 10842 10843 verifyFormat("@interface BSApplicationController ()\n" 10844 "{\n" 10845 "@private\n" 10846 " id _extraIvar;\n" 10847 "}\n" 10848 "@end\n", 10849 AllmanBraceStyle); 10850 10851 verifyFormat("#ifdef _DEBUG\n" 10852 "int foo(int i = 0)\n" 10853 "#else\n" 10854 "int foo(int i = 5)\n" 10855 "#endif\n" 10856 "{\n" 10857 " return i;\n" 10858 "}", 10859 AllmanBraceStyle); 10860 10861 verifyFormat("void foo() {}\n" 10862 "void bar()\n" 10863 "#ifdef _DEBUG\n" 10864 "{\n" 10865 " foo();\n" 10866 "}\n" 10867 "#else\n" 10868 "{\n" 10869 "}\n" 10870 "#endif", 10871 AllmanBraceStyle); 10872 10873 verifyFormat("void foobar() { int i = 5; }\n" 10874 "#ifdef _DEBUG\n" 10875 "void bar() {}\n" 10876 "#else\n" 10877 "void bar() { foobar(); }\n" 10878 "#endif", 10879 AllmanBraceStyle); 10880 10881 // This shouldn't affect ObjC blocks.. 10882 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 10883 " // ...\n" 10884 " int i;\n" 10885 "}];", 10886 AllmanBraceStyle); 10887 verifyFormat("void (^block)(void) = ^{\n" 10888 " // ...\n" 10889 " int i;\n" 10890 "};", 10891 AllmanBraceStyle); 10892 // .. or dict literals. 10893 verifyFormat("void f()\n" 10894 "{\n" 10895 " // ...\n" 10896 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 10897 "}", 10898 AllmanBraceStyle); 10899 verifyFormat("void f()\n" 10900 "{\n" 10901 " // ...\n" 10902 " [object someMethod:@{a : @\"b\"}];\n" 10903 "}", 10904 AllmanBraceStyle); 10905 verifyFormat("int f()\n" 10906 "{ // comment\n" 10907 " return 42;\n" 10908 "}", 10909 AllmanBraceStyle); 10910 10911 AllmanBraceStyle.ColumnLimit = 19; 10912 verifyFormat("void f() { int i; }", AllmanBraceStyle); 10913 AllmanBraceStyle.ColumnLimit = 18; 10914 verifyFormat("void f()\n" 10915 "{\n" 10916 " int i;\n" 10917 "}", 10918 AllmanBraceStyle); 10919 AllmanBraceStyle.ColumnLimit = 80; 10920 10921 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 10922 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 10923 FormatStyle::SIS_WithoutElse; 10924 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 10925 verifyFormat("void f(bool b)\n" 10926 "{\n" 10927 " if (b)\n" 10928 " {\n" 10929 " return;\n" 10930 " }\n" 10931 "}\n", 10932 BreakBeforeBraceShortIfs); 10933 verifyFormat("void f(bool b)\n" 10934 "{\n" 10935 " if constexpr (b)\n" 10936 " {\n" 10937 " return;\n" 10938 " }\n" 10939 "}\n", 10940 BreakBeforeBraceShortIfs); 10941 verifyFormat("void f(bool b)\n" 10942 "{\n" 10943 " if (b) return;\n" 10944 "}\n", 10945 BreakBeforeBraceShortIfs); 10946 verifyFormat("void f(bool b)\n" 10947 "{\n" 10948 " if constexpr (b) return;\n" 10949 "}\n", 10950 BreakBeforeBraceShortIfs); 10951 verifyFormat("void f(bool b)\n" 10952 "{\n" 10953 " while (b)\n" 10954 " {\n" 10955 " return;\n" 10956 " }\n" 10957 "}\n", 10958 BreakBeforeBraceShortIfs); 10959 } 10960 10961 TEST_F(FormatTest, GNUBraceBreaking) { 10962 FormatStyle GNUBraceStyle = getLLVMStyle(); 10963 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 10964 verifyFormat("namespace a\n" 10965 "{\n" 10966 "class A\n" 10967 "{\n" 10968 " void f()\n" 10969 " {\n" 10970 " int a;\n" 10971 " {\n" 10972 " int b;\n" 10973 " }\n" 10974 " if (true)\n" 10975 " {\n" 10976 " a();\n" 10977 " b();\n" 10978 " }\n" 10979 " }\n" 10980 " void g() { return; }\n" 10981 "}\n" 10982 "} // namespace a", 10983 GNUBraceStyle); 10984 10985 verifyFormat("void f()\n" 10986 "{\n" 10987 " if (true)\n" 10988 " {\n" 10989 " a();\n" 10990 " }\n" 10991 " else if (false)\n" 10992 " {\n" 10993 " b();\n" 10994 " }\n" 10995 " else\n" 10996 " {\n" 10997 " c();\n" 10998 " }\n" 10999 "}\n", 11000 GNUBraceStyle); 11001 11002 verifyFormat("void f()\n" 11003 "{\n" 11004 " for (int i = 0; i < 10; ++i)\n" 11005 " {\n" 11006 " a();\n" 11007 " }\n" 11008 " while (false)\n" 11009 " {\n" 11010 " b();\n" 11011 " }\n" 11012 " do\n" 11013 " {\n" 11014 " c();\n" 11015 " }\n" 11016 " while (false);\n" 11017 "}\n", 11018 GNUBraceStyle); 11019 11020 verifyFormat("void f(int a)\n" 11021 "{\n" 11022 " switch (a)\n" 11023 " {\n" 11024 " case 0:\n" 11025 " break;\n" 11026 " case 1:\n" 11027 " {\n" 11028 " break;\n" 11029 " }\n" 11030 " case 2:\n" 11031 " {\n" 11032 " }\n" 11033 " break;\n" 11034 " default:\n" 11035 " break;\n" 11036 " }\n" 11037 "}\n", 11038 GNUBraceStyle); 11039 11040 verifyFormat("enum X\n" 11041 "{\n" 11042 " Y = 0,\n" 11043 "}\n", 11044 GNUBraceStyle); 11045 11046 verifyFormat("@interface BSApplicationController ()\n" 11047 "{\n" 11048 "@private\n" 11049 " id _extraIvar;\n" 11050 "}\n" 11051 "@end\n", 11052 GNUBraceStyle); 11053 11054 verifyFormat("#ifdef _DEBUG\n" 11055 "int foo(int i = 0)\n" 11056 "#else\n" 11057 "int foo(int i = 5)\n" 11058 "#endif\n" 11059 "{\n" 11060 " return i;\n" 11061 "}", 11062 GNUBraceStyle); 11063 11064 verifyFormat("void foo() {}\n" 11065 "void bar()\n" 11066 "#ifdef _DEBUG\n" 11067 "{\n" 11068 " foo();\n" 11069 "}\n" 11070 "#else\n" 11071 "{\n" 11072 "}\n" 11073 "#endif", 11074 GNUBraceStyle); 11075 11076 verifyFormat("void foobar() { int i = 5; }\n" 11077 "#ifdef _DEBUG\n" 11078 "void bar() {}\n" 11079 "#else\n" 11080 "void bar() { foobar(); }\n" 11081 "#endif", 11082 GNUBraceStyle); 11083 } 11084 11085 TEST_F(FormatTest, WebKitBraceBreaking) { 11086 FormatStyle WebKitBraceStyle = getLLVMStyle(); 11087 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 11088 WebKitBraceStyle.FixNamespaceComments = false; 11089 verifyFormat("namespace a {\n" 11090 "class A {\n" 11091 " void f()\n" 11092 " {\n" 11093 " if (true) {\n" 11094 " a();\n" 11095 " b();\n" 11096 " }\n" 11097 " }\n" 11098 " void g() { return; }\n" 11099 "};\n" 11100 "enum E {\n" 11101 " A,\n" 11102 " // foo\n" 11103 " B,\n" 11104 " C\n" 11105 "};\n" 11106 "struct B {\n" 11107 " int x;\n" 11108 "};\n" 11109 "}\n", 11110 WebKitBraceStyle); 11111 verifyFormat("struct S {\n" 11112 " int Type;\n" 11113 " union {\n" 11114 " int x;\n" 11115 " double y;\n" 11116 " } Value;\n" 11117 " class C {\n" 11118 " MyFavoriteType Value;\n" 11119 " } Class;\n" 11120 "};\n", 11121 WebKitBraceStyle); 11122 } 11123 11124 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 11125 verifyFormat("void f() {\n" 11126 " try {\n" 11127 " } catch (const Exception &e) {\n" 11128 " }\n" 11129 "}\n", 11130 getLLVMStyle()); 11131 } 11132 11133 TEST_F(FormatTest, UnderstandsPragmas) { 11134 verifyFormat("#pragma omp reduction(| : var)"); 11135 verifyFormat("#pragma omp reduction(+ : var)"); 11136 11137 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 11138 "(including parentheses).", 11139 format("#pragma mark Any non-hyphenated or hyphenated string " 11140 "(including parentheses).")); 11141 } 11142 11143 TEST_F(FormatTest, UnderstandPragmaOption) { 11144 verifyFormat("#pragma option -C -A"); 11145 11146 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 11147 } 11148 11149 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 11150 FormatStyle Style = getLLVMStyle(); 11151 Style.ColumnLimit = 20; 11152 11153 // See PR41213 11154 EXPECT_EQ("/*\n" 11155 " *\t9012345\n" 11156 " * /8901\n" 11157 " */", 11158 format("/*\n" 11159 " *\t9012345 /8901\n" 11160 " */", 11161 Style)); 11162 EXPECT_EQ("/*\n" 11163 " *345678\n" 11164 " *\t/8901\n" 11165 " */", 11166 format("/*\n" 11167 " *345678\t/8901\n" 11168 " */", 11169 Style)); 11170 11171 verifyFormat("int a; // the\n" 11172 " // comment", Style); 11173 EXPECT_EQ("int a; /* first line\n" 11174 " * second\n" 11175 " * line third\n" 11176 " * line\n" 11177 " */", 11178 format("int a; /* first line\n" 11179 " * second\n" 11180 " * line third\n" 11181 " * line\n" 11182 " */", 11183 Style)); 11184 EXPECT_EQ("int a; // first line\n" 11185 " // second\n" 11186 " // line third\n" 11187 " // line", 11188 format("int a; // first line\n" 11189 " // second line\n" 11190 " // third line", 11191 Style)); 11192 11193 Style.PenaltyExcessCharacter = 90; 11194 verifyFormat("int a; // the comment", Style); 11195 EXPECT_EQ("int a; // the comment\n" 11196 " // aaa", 11197 format("int a; // the comment aaa", Style)); 11198 EXPECT_EQ("int a; /* first line\n" 11199 " * second line\n" 11200 " * third line\n" 11201 " */", 11202 format("int a; /* first line\n" 11203 " * second line\n" 11204 " * third line\n" 11205 " */", 11206 Style)); 11207 EXPECT_EQ("int a; // first line\n" 11208 " // second line\n" 11209 " // third line", 11210 format("int a; // first line\n" 11211 " // second line\n" 11212 " // third line", 11213 Style)); 11214 // FIXME: Investigate why this is not getting the same layout as the test 11215 // above. 11216 EXPECT_EQ("int a; /* first line\n" 11217 " * second line\n" 11218 " * third line\n" 11219 " */", 11220 format("int a; /* first line second line third line" 11221 "\n*/", 11222 Style)); 11223 11224 EXPECT_EQ("// foo bar baz bazfoo\n" 11225 "// foo bar foo bar\n", 11226 format("// foo bar baz bazfoo\n" 11227 "// foo bar foo bar\n", 11228 Style)); 11229 EXPECT_EQ("// foo bar baz bazfoo\n" 11230 "// foo bar foo bar\n", 11231 format("// foo bar baz bazfoo\n" 11232 "// foo bar foo bar\n", 11233 Style)); 11234 11235 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 11236 // next one. 11237 EXPECT_EQ("// foo bar baz bazfoo\n" 11238 "// bar foo bar\n", 11239 format("// foo bar baz bazfoo bar\n" 11240 "// foo bar\n", 11241 Style)); 11242 11243 EXPECT_EQ("// foo bar baz bazfoo\n" 11244 "// foo bar baz bazfoo\n" 11245 "// bar foo bar\n", 11246 format("// foo bar baz bazfoo\n" 11247 "// foo bar baz bazfoo bar\n" 11248 "// foo bar\n", 11249 Style)); 11250 11251 EXPECT_EQ("// foo bar baz bazfoo\n" 11252 "// foo bar baz bazfoo\n" 11253 "// bar foo bar\n", 11254 format("// foo bar baz bazfoo\n" 11255 "// foo bar baz bazfoo bar\n" 11256 "// foo bar\n", 11257 Style)); 11258 11259 // Make sure we do not keep protruding characters if strict mode reflow is 11260 // cheaper than keeping protruding characters. 11261 Style.ColumnLimit = 21; 11262 EXPECT_EQ("// foo foo foo foo\n" 11263 "// foo foo foo foo\n" 11264 "// foo foo foo foo\n", 11265 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", 11266 Style)); 11267 11268 EXPECT_EQ("int a = /* long block\n" 11269 " comment */\n" 11270 " 42;", 11271 format("int a = /* long block comment */ 42;", Style)); 11272 } 11273 11274 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 11275 for (size_t i = 1; i < Styles.size(); ++i) \ 11276 EXPECT_EQ(Styles[0], Styles[i]) << "Style #" << i << " of " << Styles.size() \ 11277 << " differs from Style #0" 11278 11279 TEST_F(FormatTest, GetsPredefinedStyleByName) { 11280 SmallVector<FormatStyle, 3> Styles; 11281 Styles.resize(3); 11282 11283 Styles[0] = getLLVMStyle(); 11284 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 11285 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 11286 EXPECT_ALL_STYLES_EQUAL(Styles); 11287 11288 Styles[0] = getGoogleStyle(); 11289 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 11290 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 11291 EXPECT_ALL_STYLES_EQUAL(Styles); 11292 11293 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 11294 EXPECT_TRUE( 11295 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 11296 EXPECT_TRUE( 11297 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 11298 EXPECT_ALL_STYLES_EQUAL(Styles); 11299 11300 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 11301 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 11302 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 11303 EXPECT_ALL_STYLES_EQUAL(Styles); 11304 11305 Styles[0] = getMozillaStyle(); 11306 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 11307 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 11308 EXPECT_ALL_STYLES_EQUAL(Styles); 11309 11310 Styles[0] = getWebKitStyle(); 11311 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 11312 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 11313 EXPECT_ALL_STYLES_EQUAL(Styles); 11314 11315 Styles[0] = getGNUStyle(); 11316 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 11317 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 11318 EXPECT_ALL_STYLES_EQUAL(Styles); 11319 11320 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 11321 } 11322 11323 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 11324 SmallVector<FormatStyle, 8> Styles; 11325 Styles.resize(2); 11326 11327 Styles[0] = getGoogleStyle(); 11328 Styles[1] = getLLVMStyle(); 11329 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 11330 EXPECT_ALL_STYLES_EQUAL(Styles); 11331 11332 Styles.resize(5); 11333 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 11334 Styles[1] = getLLVMStyle(); 11335 Styles[1].Language = FormatStyle::LK_JavaScript; 11336 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 11337 11338 Styles[2] = getLLVMStyle(); 11339 Styles[2].Language = FormatStyle::LK_JavaScript; 11340 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 11341 "BasedOnStyle: Google", 11342 &Styles[2]) 11343 .value()); 11344 11345 Styles[3] = getLLVMStyle(); 11346 Styles[3].Language = FormatStyle::LK_JavaScript; 11347 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 11348 "Language: JavaScript", 11349 &Styles[3]) 11350 .value()); 11351 11352 Styles[4] = getLLVMStyle(); 11353 Styles[4].Language = FormatStyle::LK_JavaScript; 11354 EXPECT_EQ(0, parseConfiguration("---\n" 11355 "BasedOnStyle: LLVM\n" 11356 "IndentWidth: 123\n" 11357 "---\n" 11358 "BasedOnStyle: Google\n" 11359 "Language: JavaScript", 11360 &Styles[4]) 11361 .value()); 11362 EXPECT_ALL_STYLES_EQUAL(Styles); 11363 } 11364 11365 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 11366 Style.FIELD = false; \ 11367 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 11368 EXPECT_TRUE(Style.FIELD); \ 11369 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 11370 EXPECT_FALSE(Style.FIELD); 11371 11372 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 11373 11374 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 11375 Style.STRUCT.FIELD = false; \ 11376 EXPECT_EQ(0, \ 11377 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 11378 .value()); \ 11379 EXPECT_TRUE(Style.STRUCT.FIELD); \ 11380 EXPECT_EQ(0, \ 11381 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 11382 .value()); \ 11383 EXPECT_FALSE(Style.STRUCT.FIELD); 11384 11385 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 11386 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 11387 11388 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 11389 EXPECT_NE(VALUE, Style.FIELD); \ 11390 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 11391 EXPECT_EQ(VALUE, Style.FIELD) 11392 11393 TEST_F(FormatTest, ParsesConfigurationBools) { 11394 FormatStyle Style = {}; 11395 Style.Language = FormatStyle::LK_Cpp; 11396 CHECK_PARSE_BOOL(AlignOperands); 11397 CHECK_PARSE_BOOL(AlignTrailingComments); 11398 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 11399 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 11400 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 11401 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 11402 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 11403 CHECK_PARSE_BOOL(AllowShortBlocksOnASingleLine); 11404 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 11405 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 11406 CHECK_PARSE_BOOL(BinPackArguments); 11407 CHECK_PARSE_BOOL(BinPackParameters); 11408 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 11409 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 11410 CHECK_PARSE_BOOL(BreakStringLiterals); 11411 CHECK_PARSE_BOOL(CompactNamespaces); 11412 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 11413 CHECK_PARSE_BOOL(DerivePointerAlignment); 11414 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 11415 CHECK_PARSE_BOOL(DisableFormat); 11416 CHECK_PARSE_BOOL(IndentCaseLabels); 11417 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 11418 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 11419 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 11420 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 11421 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 11422 CHECK_PARSE_BOOL(ReflowComments); 11423 CHECK_PARSE_BOOL(SortIncludes); 11424 CHECK_PARSE_BOOL(SortUsingDeclarations); 11425 CHECK_PARSE_BOOL(SpacesInParentheses); 11426 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 11427 CHECK_PARSE_BOOL(SpacesInAngles); 11428 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 11429 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 11430 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 11431 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 11432 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 11433 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 11434 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 11435 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 11436 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 11437 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 11438 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 11439 11440 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 11441 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 11442 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterControlStatement); 11443 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 11444 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 11445 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 11446 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 11447 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 11448 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 11449 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 11450 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 11451 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 11452 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 11453 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 11454 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 11455 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 11456 } 11457 11458 #undef CHECK_PARSE_BOOL 11459 11460 TEST_F(FormatTest, ParsesConfiguration) { 11461 FormatStyle Style = {}; 11462 Style.Language = FormatStyle::LK_Cpp; 11463 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 11464 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 11465 ConstructorInitializerIndentWidth, 1234u); 11466 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 11467 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 11468 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 11469 CHECK_PARSE("PenaltyBreakAssignment: 1234", 11470 PenaltyBreakAssignment, 1234u); 11471 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 11472 PenaltyBreakBeforeFirstCallParameter, 1234u); 11473 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 11474 PenaltyBreakTemplateDeclaration, 1234u); 11475 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 11476 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 11477 PenaltyReturnTypeOnItsOwnLine, 1234u); 11478 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 11479 SpacesBeforeTrailingComments, 1234u); 11480 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 11481 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 11482 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 11483 11484 Style.PointerAlignment = FormatStyle::PAS_Middle; 11485 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 11486 FormatStyle::PAS_Left); 11487 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 11488 FormatStyle::PAS_Right); 11489 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 11490 FormatStyle::PAS_Middle); 11491 // For backward compatibility: 11492 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 11493 FormatStyle::PAS_Left); 11494 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 11495 FormatStyle::PAS_Right); 11496 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 11497 FormatStyle::PAS_Middle); 11498 11499 Style.Standard = FormatStyle::LS_Auto; 11500 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 11501 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11); 11502 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 11503 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 11504 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 11505 11506 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11507 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 11508 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 11509 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 11510 FormatStyle::BOS_None); 11511 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 11512 FormatStyle::BOS_All); 11513 // For backward compatibility: 11514 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 11515 FormatStyle::BOS_None); 11516 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 11517 FormatStyle::BOS_All); 11518 11519 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 11520 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 11521 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 11522 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 11523 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 11524 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 11525 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 11526 // For backward compatibility: 11527 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 11528 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 11529 11530 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 11531 CHECK_PARSE("BreakInheritanceList: BeforeComma", 11532 BreakInheritanceList, FormatStyle::BILS_BeforeComma); 11533 CHECK_PARSE("BreakInheritanceList: AfterColon", 11534 BreakInheritanceList, FormatStyle::BILS_AfterColon); 11535 CHECK_PARSE("BreakInheritanceList: BeforeColon", 11536 BreakInheritanceList, FormatStyle::BILS_BeforeColon); 11537 // For backward compatibility: 11538 CHECK_PARSE("BreakBeforeInheritanceComma: true", 11539 BreakInheritanceList, FormatStyle::BILS_BeforeComma); 11540 11541 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 11542 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 11543 FormatStyle::BAS_Align); 11544 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 11545 FormatStyle::BAS_DontAlign); 11546 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 11547 FormatStyle::BAS_AlwaysBreak); 11548 // For backward compatibility: 11549 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 11550 FormatStyle::BAS_DontAlign); 11551 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 11552 FormatStyle::BAS_Align); 11553 11554 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11555 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 11556 FormatStyle::ENAS_DontAlign); 11557 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 11558 FormatStyle::ENAS_Left); 11559 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 11560 FormatStyle::ENAS_Right); 11561 // For backward compatibility: 11562 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 11563 FormatStyle::ENAS_Left); 11564 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 11565 FormatStyle::ENAS_Right); 11566 11567 Style.UseTab = FormatStyle::UT_ForIndentation; 11568 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 11569 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 11570 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 11571 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 11572 FormatStyle::UT_ForContinuationAndIndentation); 11573 // For backward compatibility: 11574 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 11575 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 11576 11577 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 11578 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 11579 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 11580 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 11581 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 11582 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 11583 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 11584 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 11585 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 11586 // For backward compatibility: 11587 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 11588 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 11589 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 11590 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 11591 11592 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 11593 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 11594 FormatStyle::SBPO_Never); 11595 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 11596 FormatStyle::SBPO_Always); 11597 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 11598 FormatStyle::SBPO_ControlStatements); 11599 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 11600 FormatStyle::SBPO_NonEmptyParentheses); 11601 // For backward compatibility: 11602 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 11603 FormatStyle::SBPO_Never); 11604 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 11605 FormatStyle::SBPO_ControlStatements); 11606 11607 Style.ColumnLimit = 123; 11608 FormatStyle BaseStyle = getLLVMStyle(); 11609 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 11610 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 11611 11612 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11613 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 11614 FormatStyle::BS_Attach); 11615 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 11616 FormatStyle::BS_Linux); 11617 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 11618 FormatStyle::BS_Mozilla); 11619 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 11620 FormatStyle::BS_Stroustrup); 11621 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 11622 FormatStyle::BS_Allman); 11623 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 11624 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 11625 FormatStyle::BS_WebKit); 11626 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 11627 FormatStyle::BS_Custom); 11628 11629 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 11630 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 11631 FormatStyle::RTBS_None); 11632 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 11633 FormatStyle::RTBS_All); 11634 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 11635 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 11636 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 11637 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 11638 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 11639 AlwaysBreakAfterReturnType, 11640 FormatStyle::RTBS_TopLevelDefinitions); 11641 11642 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 11643 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", AlwaysBreakTemplateDeclarations, 11644 FormatStyle::BTDS_No); 11645 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", AlwaysBreakTemplateDeclarations, 11646 FormatStyle::BTDS_MultiLine); 11647 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", AlwaysBreakTemplateDeclarations, 11648 FormatStyle::BTDS_Yes); 11649 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", AlwaysBreakTemplateDeclarations, 11650 FormatStyle::BTDS_MultiLine); 11651 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", AlwaysBreakTemplateDeclarations, 11652 FormatStyle::BTDS_Yes); 11653 11654 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 11655 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 11656 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 11657 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 11658 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 11659 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 11660 AlwaysBreakAfterDefinitionReturnType, 11661 FormatStyle::DRTBS_TopLevel); 11662 11663 Style.NamespaceIndentation = FormatStyle::NI_All; 11664 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 11665 FormatStyle::NI_None); 11666 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 11667 FormatStyle::NI_Inner); 11668 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 11669 FormatStyle::NI_All); 11670 11671 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 11672 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 11673 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 11674 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 11675 AllowShortIfStatementsOnASingleLine, 11676 FormatStyle::SIS_WithoutElse); 11677 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 11678 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 11679 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 11680 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 11681 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 11682 AllowShortIfStatementsOnASingleLine, 11683 FormatStyle::SIS_WithoutElse); 11684 11685 // FIXME: This is required because parsing a configuration simply overwrites 11686 // the first N elements of the list instead of resetting it. 11687 Style.ForEachMacros.clear(); 11688 std::vector<std::string> BoostForeach; 11689 BoostForeach.push_back("BOOST_FOREACH"); 11690 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 11691 std::vector<std::string> BoostAndQForeach; 11692 BoostAndQForeach.push_back("BOOST_FOREACH"); 11693 BoostAndQForeach.push_back("Q_FOREACH"); 11694 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 11695 BoostAndQForeach); 11696 11697 Style.StatementMacros.clear(); 11698 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 11699 std::vector<std::string>{"QUNUSED"}); 11700 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 11701 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 11702 11703 Style.IncludeStyle.IncludeCategories.clear(); 11704 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 11705 {"abc/.*", 2}, {".*", 1}}; 11706 CHECK_PARSE("IncludeCategories:\n" 11707 " - Regex: abc/.*\n" 11708 " Priority: 2\n" 11709 " - Regex: .*\n" 11710 " Priority: 1", 11711 IncludeStyle.IncludeCategories, ExpectedCategories); 11712 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 11713 "abc$"); 11714 11715 Style.RawStringFormats.clear(); 11716 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 11717 { 11718 FormatStyle::LK_TextProto, 11719 {"pb", "proto"}, 11720 {"PARSE_TEXT_PROTO"}, 11721 /*CanonicalDelimiter=*/"", 11722 "llvm", 11723 }, 11724 { 11725 FormatStyle::LK_Cpp, 11726 {"cc", "cpp"}, 11727 {"C_CODEBLOCK", "CPPEVAL"}, 11728 /*CanonicalDelimiter=*/"cc", 11729 /*BasedOnStyle=*/"", 11730 }, 11731 }; 11732 11733 CHECK_PARSE("RawStringFormats:\n" 11734 " - Language: TextProto\n" 11735 " Delimiters:\n" 11736 " - 'pb'\n" 11737 " - 'proto'\n" 11738 " EnclosingFunctions:\n" 11739 " - 'PARSE_TEXT_PROTO'\n" 11740 " BasedOnStyle: llvm\n" 11741 " - Language: Cpp\n" 11742 " Delimiters:\n" 11743 " - 'cc'\n" 11744 " - 'cpp'\n" 11745 " EnclosingFunctions:\n" 11746 " - 'C_CODEBLOCK'\n" 11747 " - 'CPPEVAL'\n" 11748 " CanonicalDelimiter: 'cc'", 11749 RawStringFormats, ExpectedRawStringFormats); 11750 } 11751 11752 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 11753 FormatStyle Style = {}; 11754 Style.Language = FormatStyle::LK_Cpp; 11755 CHECK_PARSE("Language: Cpp\n" 11756 "IndentWidth: 12", 11757 IndentWidth, 12u); 11758 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 11759 "IndentWidth: 34", 11760 &Style), 11761 ParseError::Unsuitable); 11762 EXPECT_EQ(12u, Style.IndentWidth); 11763 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 11764 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 11765 11766 Style.Language = FormatStyle::LK_JavaScript; 11767 CHECK_PARSE("Language: JavaScript\n" 11768 "IndentWidth: 12", 11769 IndentWidth, 12u); 11770 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 11771 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 11772 "IndentWidth: 34", 11773 &Style), 11774 ParseError::Unsuitable); 11775 EXPECT_EQ(23u, Style.IndentWidth); 11776 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 11777 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 11778 11779 CHECK_PARSE("BasedOnStyle: LLVM\n" 11780 "IndentWidth: 67", 11781 IndentWidth, 67u); 11782 11783 CHECK_PARSE("---\n" 11784 "Language: JavaScript\n" 11785 "IndentWidth: 12\n" 11786 "---\n" 11787 "Language: Cpp\n" 11788 "IndentWidth: 34\n" 11789 "...\n", 11790 IndentWidth, 12u); 11791 11792 Style.Language = FormatStyle::LK_Cpp; 11793 CHECK_PARSE("---\n" 11794 "Language: JavaScript\n" 11795 "IndentWidth: 12\n" 11796 "---\n" 11797 "Language: Cpp\n" 11798 "IndentWidth: 34\n" 11799 "...\n", 11800 IndentWidth, 34u); 11801 CHECK_PARSE("---\n" 11802 "IndentWidth: 78\n" 11803 "---\n" 11804 "Language: JavaScript\n" 11805 "IndentWidth: 56\n" 11806 "...\n", 11807 IndentWidth, 78u); 11808 11809 Style.ColumnLimit = 123; 11810 Style.IndentWidth = 234; 11811 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 11812 Style.TabWidth = 345; 11813 EXPECT_FALSE(parseConfiguration("---\n" 11814 "IndentWidth: 456\n" 11815 "BreakBeforeBraces: Allman\n" 11816 "---\n" 11817 "Language: JavaScript\n" 11818 "IndentWidth: 111\n" 11819 "TabWidth: 111\n" 11820 "---\n" 11821 "Language: Cpp\n" 11822 "BreakBeforeBraces: Stroustrup\n" 11823 "TabWidth: 789\n" 11824 "...\n", 11825 &Style)); 11826 EXPECT_EQ(123u, Style.ColumnLimit); 11827 EXPECT_EQ(456u, Style.IndentWidth); 11828 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 11829 EXPECT_EQ(789u, Style.TabWidth); 11830 11831 EXPECT_EQ(parseConfiguration("---\n" 11832 "Language: JavaScript\n" 11833 "IndentWidth: 56\n" 11834 "---\n" 11835 "IndentWidth: 78\n" 11836 "...\n", 11837 &Style), 11838 ParseError::Error); 11839 EXPECT_EQ(parseConfiguration("---\n" 11840 "Language: JavaScript\n" 11841 "IndentWidth: 56\n" 11842 "---\n" 11843 "Language: JavaScript\n" 11844 "IndentWidth: 78\n" 11845 "...\n", 11846 &Style), 11847 ParseError::Error); 11848 11849 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 11850 } 11851 11852 #undef CHECK_PARSE 11853 11854 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 11855 FormatStyle Style = {}; 11856 Style.Language = FormatStyle::LK_JavaScript; 11857 Style.BreakBeforeTernaryOperators = true; 11858 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 11859 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 11860 11861 Style.BreakBeforeTernaryOperators = true; 11862 EXPECT_EQ(0, parseConfiguration("---\n" 11863 "BasedOnStyle: Google\n" 11864 "---\n" 11865 "Language: JavaScript\n" 11866 "IndentWidth: 76\n" 11867 "...\n", 11868 &Style) 11869 .value()); 11870 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 11871 EXPECT_EQ(76u, Style.IndentWidth); 11872 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 11873 } 11874 11875 TEST_F(FormatTest, ConfigurationRoundTripTest) { 11876 FormatStyle Style = getLLVMStyle(); 11877 std::string YAML = configurationAsText(Style); 11878 FormatStyle ParsedStyle = {}; 11879 ParsedStyle.Language = FormatStyle::LK_Cpp; 11880 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 11881 EXPECT_EQ(Style, ParsedStyle); 11882 } 11883 11884 TEST_F(FormatTest, WorksFor8bitEncodings) { 11885 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 11886 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 11887 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 11888 "\"\xef\xee\xf0\xf3...\"", 11889 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 11890 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 11891 "\xef\xee\xf0\xf3...\"", 11892 getLLVMStyleWithColumns(12))); 11893 } 11894 11895 TEST_F(FormatTest, HandlesUTF8BOM) { 11896 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 11897 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 11898 format("\xef\xbb\xbf#include <iostream>")); 11899 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 11900 format("\xef\xbb\xbf\n#include <iostream>")); 11901 } 11902 11903 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 11904 #if !defined(_MSC_VER) 11905 11906 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 11907 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 11908 getLLVMStyleWithColumns(35)); 11909 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 11910 getLLVMStyleWithColumns(31)); 11911 verifyFormat("// Однажды в студёную зимнюю пору...", 11912 getLLVMStyleWithColumns(36)); 11913 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 11914 verifyFormat("/* Однажды в студёную зимнюю пору... */", 11915 getLLVMStyleWithColumns(39)); 11916 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 11917 getLLVMStyleWithColumns(35)); 11918 } 11919 11920 TEST_F(FormatTest, SplitsUTF8Strings) { 11921 // Non-printable characters' width is currently considered to be the length in 11922 // bytes in UTF8. The characters can be displayed in very different manner 11923 // (zero-width, single width with a substitution glyph, expanded to their code 11924 // (e.g. "<8d>"), so there's no single correct way to handle them. 11925 EXPECT_EQ("\"aaaaÄ\"\n" 11926 "\"\xc2\x8d\";", 11927 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 11928 EXPECT_EQ("\"aaaaaaaÄ\"\n" 11929 "\"\xc2\x8d\";", 11930 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 11931 EXPECT_EQ("\"Однажды, в \"\n" 11932 "\"студёную \"\n" 11933 "\"зимнюю \"\n" 11934 "\"пору,\"", 11935 format("\"Однажды, в студёную зимнюю пору,\"", 11936 getLLVMStyleWithColumns(13))); 11937 EXPECT_EQ( 11938 "\"一 二 三 \"\n" 11939 "\"四 五六 \"\n" 11940 "\"七 八 九 \"\n" 11941 "\"十\"", 11942 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 11943 EXPECT_EQ("\"一\t\"\n" 11944 "\"二 \t\"\n" 11945 "\"三 四 \"\n" 11946 "\"五\t\"\n" 11947 "\"六 \t\"\n" 11948 "\"七 \"\n" 11949 "\"八九十\tqq\"", 11950 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 11951 getLLVMStyleWithColumns(11))); 11952 11953 // UTF8 character in an escape sequence. 11954 EXPECT_EQ("\"aaaaaa\"\n" 11955 "\"\\\xC2\x8D\"", 11956 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 11957 } 11958 11959 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 11960 EXPECT_EQ("const char *sssss =\n" 11961 " \"一二三四五六七八\\\n" 11962 " 九 十\";", 11963 format("const char *sssss = \"一二三四五六七八\\\n" 11964 " 九 十\";", 11965 getLLVMStyleWithColumns(30))); 11966 } 11967 11968 TEST_F(FormatTest, SplitsUTF8LineComments) { 11969 EXPECT_EQ("// aaaaÄ\xc2\x8d", 11970 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 11971 EXPECT_EQ("// Я из лесу\n" 11972 "// вышел; был\n" 11973 "// сильный\n" 11974 "// мороз.", 11975 format("// Я из лесу вышел; был сильный мороз.", 11976 getLLVMStyleWithColumns(13))); 11977 EXPECT_EQ("// 一二三\n" 11978 "// 四五六七\n" 11979 "// 八 九\n" 11980 "// 十", 11981 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 11982 } 11983 11984 TEST_F(FormatTest, SplitsUTF8BlockComments) { 11985 EXPECT_EQ("/* Гляжу,\n" 11986 " * поднимается\n" 11987 " * медленно в\n" 11988 " * гору\n" 11989 " * Лошадка,\n" 11990 " * везущая\n" 11991 " * хворосту\n" 11992 " * воз. */", 11993 format("/* Гляжу, поднимается медленно в гору\n" 11994 " * Лошадка, везущая хворосту воз. */", 11995 getLLVMStyleWithColumns(13))); 11996 EXPECT_EQ( 11997 "/* 一二三\n" 11998 " * 四五六七\n" 11999 " * 八 九\n" 12000 " * 十 */", 12001 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 12002 EXPECT_EQ("/* �������� ��������\n" 12003 " * ��������\n" 12004 " * ������-�� */", 12005 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 12006 } 12007 12008 #endif // _MSC_VER 12009 12010 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 12011 FormatStyle Style = getLLVMStyle(); 12012 12013 Style.ConstructorInitializerIndentWidth = 4; 12014 verifyFormat( 12015 "SomeClass::Constructor()\n" 12016 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12017 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12018 Style); 12019 12020 Style.ConstructorInitializerIndentWidth = 2; 12021 verifyFormat( 12022 "SomeClass::Constructor()\n" 12023 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12024 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12025 Style); 12026 12027 Style.ConstructorInitializerIndentWidth = 0; 12028 verifyFormat( 12029 "SomeClass::Constructor()\n" 12030 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12031 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12032 Style); 12033 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 12034 verifyFormat( 12035 "SomeLongTemplateVariableName<\n" 12036 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 12037 Style); 12038 verifyFormat( 12039 "bool smaller = 1 < bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 12040 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 12041 Style); 12042 12043 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 12044 verifyFormat( 12045 "SomeClass::Constructor() :\n" 12046 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 12047 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 12048 Style); 12049 } 12050 12051 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 12052 FormatStyle Style = getLLVMStyle(); 12053 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 12054 Style.ConstructorInitializerIndentWidth = 4; 12055 verifyFormat("SomeClass::Constructor()\n" 12056 " : a(a)\n" 12057 " , b(b)\n" 12058 " , c(c) {}", 12059 Style); 12060 verifyFormat("SomeClass::Constructor()\n" 12061 " : a(a) {}", 12062 Style); 12063 12064 Style.ColumnLimit = 0; 12065 verifyFormat("SomeClass::Constructor()\n" 12066 " : a(a) {}", 12067 Style); 12068 verifyFormat("SomeClass::Constructor() noexcept\n" 12069 " : a(a) {}", 12070 Style); 12071 verifyFormat("SomeClass::Constructor()\n" 12072 " : a(a)\n" 12073 " , b(b)\n" 12074 " , c(c) {}", 12075 Style); 12076 verifyFormat("SomeClass::Constructor()\n" 12077 " : a(a) {\n" 12078 " foo();\n" 12079 " bar();\n" 12080 "}", 12081 Style); 12082 12083 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 12084 verifyFormat("SomeClass::Constructor()\n" 12085 " : a(a)\n" 12086 " , b(b)\n" 12087 " , c(c) {\n}", 12088 Style); 12089 verifyFormat("SomeClass::Constructor()\n" 12090 " : a(a) {\n}", 12091 Style); 12092 12093 Style.ColumnLimit = 80; 12094 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 12095 Style.ConstructorInitializerIndentWidth = 2; 12096 verifyFormat("SomeClass::Constructor()\n" 12097 " : a(a)\n" 12098 " , b(b)\n" 12099 " , c(c) {}", 12100 Style); 12101 12102 Style.ConstructorInitializerIndentWidth = 0; 12103 verifyFormat("SomeClass::Constructor()\n" 12104 ": a(a)\n" 12105 ", b(b)\n" 12106 ", c(c) {}", 12107 Style); 12108 12109 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 12110 Style.ConstructorInitializerIndentWidth = 4; 12111 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 12112 verifyFormat( 12113 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 12114 Style); 12115 verifyFormat( 12116 "SomeClass::Constructor()\n" 12117 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 12118 Style); 12119 Style.ConstructorInitializerIndentWidth = 4; 12120 Style.ColumnLimit = 60; 12121 verifyFormat("SomeClass::Constructor()\n" 12122 " : aaaaaaaa(aaaaaaaa)\n" 12123 " , aaaaaaaa(aaaaaaaa)\n" 12124 " , aaaaaaaa(aaaaaaaa) {}", 12125 Style); 12126 } 12127 12128 TEST_F(FormatTest, Destructors) { 12129 verifyFormat("void F(int &i) { i.~int(); }"); 12130 verifyFormat("void F(int &i) { i->~int(); }"); 12131 } 12132 12133 TEST_F(FormatTest, FormatsWithWebKitStyle) { 12134 FormatStyle Style = getWebKitStyle(); 12135 12136 // Don't indent in outer namespaces. 12137 verifyFormat("namespace outer {\n" 12138 "int i;\n" 12139 "namespace inner {\n" 12140 " int i;\n" 12141 "} // namespace inner\n" 12142 "} // namespace outer\n" 12143 "namespace other_outer {\n" 12144 "int i;\n" 12145 "}", 12146 Style); 12147 12148 // Don't indent case labels. 12149 verifyFormat("switch (variable) {\n" 12150 "case 1:\n" 12151 "case 2:\n" 12152 " doSomething();\n" 12153 " break;\n" 12154 "default:\n" 12155 " ++variable;\n" 12156 "}", 12157 Style); 12158 12159 // Wrap before binary operators. 12160 EXPECT_EQ("void f()\n" 12161 "{\n" 12162 " if (aaaaaaaaaaaaaaaa\n" 12163 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 12164 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 12165 " return;\n" 12166 "}", 12167 format("void f() {\n" 12168 "if (aaaaaaaaaaaaaaaa\n" 12169 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 12170 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 12171 "return;\n" 12172 "}", 12173 Style)); 12174 12175 // Allow functions on a single line. 12176 verifyFormat("void f() { return; }", Style); 12177 12178 // Constructor initializers are formatted one per line with the "," on the 12179 // new line. 12180 verifyFormat("Constructor()\n" 12181 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 12182 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 12183 " aaaaaaaaaaaaaa)\n" 12184 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 12185 "{\n" 12186 "}", 12187 Style); 12188 verifyFormat("SomeClass::Constructor()\n" 12189 " : a(a)\n" 12190 "{\n" 12191 "}", 12192 Style); 12193 EXPECT_EQ("SomeClass::Constructor()\n" 12194 " : a(a)\n" 12195 "{\n" 12196 "}", 12197 format("SomeClass::Constructor():a(a){}", Style)); 12198 verifyFormat("SomeClass::Constructor()\n" 12199 " : a(a)\n" 12200 " , b(b)\n" 12201 " , c(c)\n" 12202 "{\n" 12203 "}", 12204 Style); 12205 verifyFormat("SomeClass::Constructor()\n" 12206 " : a(a)\n" 12207 "{\n" 12208 " foo();\n" 12209 " bar();\n" 12210 "}", 12211 Style); 12212 12213 // Access specifiers should be aligned left. 12214 verifyFormat("class C {\n" 12215 "public:\n" 12216 " int i;\n" 12217 "};", 12218 Style); 12219 12220 // Do not align comments. 12221 verifyFormat("int a; // Do not\n" 12222 "double b; // align comments.", 12223 Style); 12224 12225 // Do not align operands. 12226 EXPECT_EQ("ASSERT(aaaa\n" 12227 " || bbbb);", 12228 format("ASSERT ( aaaa\n||bbbb);", Style)); 12229 12230 // Accept input's line breaks. 12231 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 12232 " || bbbbbbbbbbbbbbb) {\n" 12233 " i++;\n" 12234 "}", 12235 format("if (aaaaaaaaaaaaaaa\n" 12236 "|| bbbbbbbbbbbbbbb) { i++; }", 12237 Style)); 12238 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 12239 " i++;\n" 12240 "}", 12241 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 12242 12243 // Don't automatically break all macro definitions (llvm.org/PR17842). 12244 verifyFormat("#define aNumber 10", Style); 12245 // However, generally keep the line breaks that the user authored. 12246 EXPECT_EQ("#define aNumber \\\n" 12247 " 10", 12248 format("#define aNumber \\\n" 12249 " 10", 12250 Style)); 12251 12252 // Keep empty and one-element array literals on a single line. 12253 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 12254 " copyItems:YES];", 12255 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 12256 "copyItems:YES];", 12257 Style)); 12258 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 12259 " copyItems:YES];", 12260 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 12261 " copyItems:YES];", 12262 Style)); 12263 // FIXME: This does not seem right, there should be more indentation before 12264 // the array literal's entries. Nested blocks have the same problem. 12265 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 12266 " @\"a\",\n" 12267 " @\"a\"\n" 12268 "]\n" 12269 " copyItems:YES];", 12270 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 12271 " @\"a\",\n" 12272 " @\"a\"\n" 12273 " ]\n" 12274 " copyItems:YES];", 12275 Style)); 12276 EXPECT_EQ( 12277 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 12278 " copyItems:YES];", 12279 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 12280 " copyItems:YES];", 12281 Style)); 12282 12283 verifyFormat("[self.a b:c c:d];", Style); 12284 EXPECT_EQ("[self.a b:c\n" 12285 " c:d];", 12286 format("[self.a b:c\n" 12287 "c:d];", 12288 Style)); 12289 } 12290 12291 TEST_F(FormatTest, FormatsLambdas) { 12292 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 12293 verifyFormat( 12294 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 12295 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 12296 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 12297 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 12298 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 12299 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 12300 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 12301 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 12302 verifyFormat("int x = f(*+[] {});"); 12303 verifyFormat("void f() {\n" 12304 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 12305 "}\n"); 12306 verifyFormat("void f() {\n" 12307 " other(x.begin(), //\n" 12308 " x.end(), //\n" 12309 " [&](int, int) { return 1; });\n" 12310 "}\n"); 12311 verifyFormat("void f() {\n" 12312 " other.other.other.other.other(\n" 12313 " x.begin(), x.end(),\n" 12314 " [something, rather](int, int, int, int, int, int, int) { return 1; });\n" 12315 "}\n"); 12316 verifyFormat("void f() {\n" 12317 " other.other.other.other.other(\n" 12318 " x.begin(), x.end(),\n" 12319 " [something, rather](int, int, int, int, int, int, int) {\n" 12320 " //\n" 12321 " });\n" 12322 "}\n"); 12323 verifyFormat("SomeFunction([]() { // A cool function...\n" 12324 " return 43;\n" 12325 "});"); 12326 EXPECT_EQ("SomeFunction([]() {\n" 12327 "#define A a\n" 12328 " return 43;\n" 12329 "});", 12330 format("SomeFunction([](){\n" 12331 "#define A a\n" 12332 "return 43;\n" 12333 "});")); 12334 verifyFormat("void f() {\n" 12335 " SomeFunction([](decltype(x), A *a) {});\n" 12336 "}"); 12337 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 12338 " [](const aaaaaaaaaa &a) { return a; });"); 12339 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 12340 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 12341 "});"); 12342 verifyFormat("Constructor()\n" 12343 " : Field([] { // comment\n" 12344 " int i;\n" 12345 " }) {}"); 12346 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 12347 " return some_parameter.size();\n" 12348 "};"); 12349 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 12350 " [](const string &s) { return s; };"); 12351 verifyFormat("int i = aaaaaa ? 1 //\n" 12352 " : [] {\n" 12353 " return 2; //\n" 12354 " }();"); 12355 verifyFormat("llvm::errs() << \"number of twos is \"\n" 12356 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 12357 " return x == 2; // force break\n" 12358 " });"); 12359 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 12360 " [=](int iiiiiiiiiiii) {\n" 12361 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 12362 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 12363 " });", 12364 getLLVMStyleWithColumns(60)); 12365 verifyFormat("SomeFunction({[&] {\n" 12366 " // comment\n" 12367 " },\n" 12368 " [&] {\n" 12369 " // comment\n" 12370 " }});"); 12371 verifyFormat("SomeFunction({[&] {\n" 12372 " // comment\n" 12373 "}});"); 12374 verifyFormat("virtual aaaaaaaaaaaaaaaa(\n" 12375 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 12376 " aaaaa aaaaaaaaa);"); 12377 12378 // Lambdas with return types. 12379 verifyFormat("int c = []() -> int { return 2; }();\n"); 12380 verifyFormat("int c = []() -> int * { return 2; }();\n"); 12381 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 12382 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 12383 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 12384 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 12385 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 12386 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 12387 verifyFormat("[a, a]() -> a<1> {};"); 12388 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 12389 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 12390 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 12391 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 12392 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 12393 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 12394 verifyFormat("[]() -> foo<!5> { return {}; };"); 12395 verifyFormat("[]() -> foo<~5> { return {}; };"); 12396 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 12397 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 12398 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 12399 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 12400 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 12401 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 12402 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 12403 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 12404 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 12405 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 12406 verifyFormat("namespace bar {\n" 12407 "// broken:\n" 12408 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 12409 "} // namespace bar"); 12410 verifyFormat("namespace bar {\n" 12411 "// broken:\n" 12412 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 12413 "} // namespace bar"); 12414 verifyFormat("namespace bar {\n" 12415 "// broken:\n" 12416 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 12417 "} // namespace bar"); 12418 verifyFormat("namespace bar {\n" 12419 "// broken:\n" 12420 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 12421 "} // namespace bar"); 12422 verifyFormat("namespace bar {\n" 12423 "// broken:\n" 12424 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 12425 "} // namespace bar"); 12426 verifyFormat("namespace bar {\n" 12427 "// broken:\n" 12428 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 12429 "} // namespace bar"); 12430 verifyFormat("namespace bar {\n" 12431 "// broken:\n" 12432 "auto foo{[]() -> foo<!5> { return {}; }};\n" 12433 "} // namespace bar"); 12434 verifyFormat("namespace bar {\n" 12435 "// broken:\n" 12436 "auto foo{[]() -> foo<~5> { return {}; }};\n" 12437 "} // namespace bar"); 12438 verifyFormat("namespace bar {\n" 12439 "// broken:\n" 12440 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 12441 "} // namespace bar"); 12442 verifyFormat("namespace bar {\n" 12443 "// broken:\n" 12444 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 12445 "} // namespace bar"); 12446 verifyFormat("namespace bar {\n" 12447 "// broken:\n" 12448 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 12449 "} // namespace bar"); 12450 verifyFormat("namespace bar {\n" 12451 "// broken:\n" 12452 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 12453 "} // namespace bar"); 12454 verifyFormat("namespace bar {\n" 12455 "// broken:\n" 12456 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 12457 "} // namespace bar"); 12458 verifyFormat("namespace bar {\n" 12459 "// broken:\n" 12460 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 12461 "} // namespace bar"); 12462 verifyFormat("namespace bar {\n" 12463 "// broken:\n" 12464 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 12465 "} // namespace bar"); 12466 verifyFormat("namespace bar {\n" 12467 "// broken:\n" 12468 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 12469 "} // namespace bar"); 12470 verifyFormat("namespace bar {\n" 12471 "// broken:\n" 12472 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 12473 "} // namespace bar"); 12474 verifyFormat("namespace bar {\n" 12475 "// broken:\n" 12476 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 12477 "} // namespace bar"); 12478 verifyFormat("[]() -> a<1> {};"); 12479 verifyFormat("[]() -> a<1> { ; };"); 12480 verifyFormat("[]() -> a<1> { ; }();"); 12481 verifyFormat("[a, a]() -> a<true> {};"); 12482 verifyFormat("[]() -> a<true> {};"); 12483 verifyFormat("[]() -> a<true> { ; };"); 12484 verifyFormat("[]() -> a<true> { ; }();"); 12485 verifyFormat("[a, a]() -> a<false> {};"); 12486 verifyFormat("[]() -> a<false> {};"); 12487 verifyFormat("[]() -> a<false> { ; };"); 12488 verifyFormat("[]() -> a<false> { ; }();"); 12489 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 12490 verifyFormat("namespace bar {\n" 12491 "auto foo{[]() -> foo<false> { ; }};\n" 12492 "} // namespace bar"); 12493 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 12494 " int j) -> int {\n" 12495 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 12496 "};"); 12497 verifyFormat( 12498 "aaaaaaaaaaaaaaaaaaaaaa(\n" 12499 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 12500 " return aaaaaaaaaaaaaaaaa;\n" 12501 " });", 12502 getLLVMStyleWithColumns(70)); 12503 verifyFormat("[]() //\n" 12504 " -> int {\n" 12505 " return 1; //\n" 12506 "};"); 12507 12508 // Multiple lambdas in the same parentheses change indentation rules. These 12509 // lambdas are forced to start on new lines. 12510 verifyFormat("SomeFunction(\n" 12511 " []() {\n" 12512 " //\n" 12513 " },\n" 12514 " []() {\n" 12515 " //\n" 12516 " });"); 12517 12518 // A lambda passed as arg0 is always pushed to the next line. 12519 verifyFormat("SomeFunction(\n" 12520 " [this] {\n" 12521 " //\n" 12522 " },\n" 12523 " 1);\n"); 12524 12525 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like the arg0 12526 // case above. 12527 auto Style = getGoogleStyle(); 12528 Style.BinPackArguments = false; 12529 verifyFormat("SomeFunction(\n" 12530 " a,\n" 12531 " [this] {\n" 12532 " //\n" 12533 " },\n" 12534 " b);\n", 12535 Style); 12536 verifyFormat("SomeFunction(\n" 12537 " a,\n" 12538 " [this] {\n" 12539 " //\n" 12540 " },\n" 12541 " b);\n"); 12542 12543 // A lambda with a very long line forces arg0 to be pushed out irrespective of 12544 // the BinPackArguments value (as long as the code is wide enough). 12545 verifyFormat("something->SomeFunction(\n" 12546 " a,\n" 12547 " [this] {\n" 12548 " D0000000000000000000000000000000000000000000000000000000000001();\n" 12549 " },\n" 12550 " b);\n"); 12551 12552 // A multi-line lambda is pulled up as long as the introducer fits on the previous 12553 // line and there are no further args. 12554 verifyFormat("function(1, [this, that] {\n" 12555 " //\n" 12556 "});\n"); 12557 verifyFormat("function([this, that] {\n" 12558 " //\n" 12559 "});\n"); 12560 // FIXME: this format is not ideal and we should consider forcing the first arg 12561 // onto its own line. 12562 verifyFormat("function(a, b, c, //\n" 12563 " d, [this, that] {\n" 12564 " //\n" 12565 " });\n"); 12566 12567 // Multiple lambdas are treated correctly even when there is a short arg0. 12568 verifyFormat("SomeFunction(\n" 12569 " 1,\n" 12570 " [this] {\n" 12571 " //\n" 12572 " },\n" 12573 " [this] {\n" 12574 " //\n" 12575 " },\n" 12576 " 1);\n"); 12577 12578 // More complex introducers. 12579 verifyFormat("return [i, args...] {};"); 12580 12581 // Not lambdas. 12582 verifyFormat("constexpr char hello[]{\"hello\"};"); 12583 verifyFormat("double &operator[](int i) { return 0; }\n" 12584 "int i;"); 12585 verifyFormat("std::unique_ptr<int[]> foo() {}"); 12586 verifyFormat("int i = a[a][a]->f();"); 12587 verifyFormat("int i = (*b)[a]->f();"); 12588 12589 // Other corner cases. 12590 verifyFormat("void f() {\n" 12591 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 12592 " );\n" 12593 "}"); 12594 12595 // Lambdas created through weird macros. 12596 verifyFormat("void f() {\n" 12597 " MACRO((const AA &a) { return 1; });\n" 12598 " MACRO((AA &a) { return 1; });\n" 12599 "}"); 12600 12601 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 12602 " doo_dah();\n" 12603 " doo_dah();\n" 12604 " })) {\n" 12605 "}"); 12606 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 12607 " doo_dah();\n" 12608 " doo_dah();\n" 12609 " })) {\n" 12610 "}"); 12611 verifyFormat("auto lambda = []() {\n" 12612 " int a = 2\n" 12613 "#if A\n" 12614 " + 2\n" 12615 "#endif\n" 12616 " ;\n" 12617 "};"); 12618 12619 // Lambdas with complex multiline introducers. 12620 verifyFormat( 12621 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 12622 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 12623 " -> ::std::unordered_set<\n" 12624 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 12625 " //\n" 12626 " });"); 12627 12628 FormatStyle DoNotMerge = getLLVMStyle(); 12629 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 12630 verifyFormat("auto c = []() {\n" 12631 " return b;\n" 12632 "};", 12633 "auto c = []() { return b; };", DoNotMerge); 12634 verifyFormat("auto c = []() {\n" 12635 "};", 12636 " auto c = []() {};", DoNotMerge); 12637 12638 FormatStyle MergeEmptyOnly = getLLVMStyle(); 12639 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 12640 verifyFormat("auto c = []() {\n" 12641 " return b;\n" 12642 "};", 12643 "auto c = []() {\n" 12644 " return b;\n" 12645 " };", 12646 MergeEmptyOnly); 12647 verifyFormat("auto c = []() {};", 12648 "auto c = []() {\n" 12649 "};", 12650 MergeEmptyOnly); 12651 12652 FormatStyle MergeInline = getLLVMStyle(); 12653 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 12654 verifyFormat("auto c = []() {\n" 12655 " return b;\n" 12656 "};", 12657 "auto c = []() { return b; };", MergeInline); 12658 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 12659 MergeInline); 12660 verifyFormat("function([]() { return b; }, a)", 12661 "function([]() { return b; }, a)", MergeInline); 12662 verifyFormat("function(a, []() { return b; })", 12663 "function(a, []() { return b; })", MergeInline); 12664 } 12665 12666 TEST_F(FormatTest, EmptyLinesInLambdas) { 12667 verifyFormat("auto lambda = []() {\n" 12668 " x(); //\n" 12669 "};", 12670 "auto lambda = []() {\n" 12671 "\n" 12672 " x(); //\n" 12673 "\n" 12674 "};"); 12675 } 12676 12677 TEST_F(FormatTest, FormatsBlocks) { 12678 FormatStyle ShortBlocks = getLLVMStyle(); 12679 ShortBlocks.AllowShortBlocksOnASingleLine = true; 12680 verifyFormat("int (^Block)(int, int);", ShortBlocks); 12681 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 12682 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 12683 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 12684 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 12685 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 12686 12687 verifyFormat("foo(^{ bar(); });", ShortBlocks); 12688 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 12689 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 12690 12691 verifyFormat("[operation setCompletionBlock:^{\n" 12692 " [self onOperationDone];\n" 12693 "}];"); 12694 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 12695 " [self onOperationDone];\n" 12696 "}]};"); 12697 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 12698 " f();\n" 12699 "}];"); 12700 verifyFormat("int a = [operation block:^int(int *i) {\n" 12701 " return 1;\n" 12702 "}];"); 12703 verifyFormat("[myObject doSomethingWith:arg1\n" 12704 " aaa:^int(int *a) {\n" 12705 " return 1;\n" 12706 " }\n" 12707 " bbb:f(a * bbbbbbbb)];"); 12708 12709 verifyFormat("[operation setCompletionBlock:^{\n" 12710 " [self.delegate newDataAvailable];\n" 12711 "}];", 12712 getLLVMStyleWithColumns(60)); 12713 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 12714 " NSString *path = [self sessionFilePath];\n" 12715 " if (path) {\n" 12716 " // ...\n" 12717 " }\n" 12718 "});"); 12719 verifyFormat("[[SessionService sharedService]\n" 12720 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 12721 " if (window) {\n" 12722 " [self windowDidLoad:window];\n" 12723 " } else {\n" 12724 " [self errorLoadingWindow];\n" 12725 " }\n" 12726 " }];"); 12727 verifyFormat("void (^largeBlock)(void) = ^{\n" 12728 " // ...\n" 12729 "};\n", 12730 getLLVMStyleWithColumns(40)); 12731 verifyFormat("[[SessionService sharedService]\n" 12732 " loadWindowWithCompletionBlock: //\n" 12733 " ^(SessionWindow *window) {\n" 12734 " if (window) {\n" 12735 " [self windowDidLoad:window];\n" 12736 " } else {\n" 12737 " [self errorLoadingWindow];\n" 12738 " }\n" 12739 " }];", 12740 getLLVMStyleWithColumns(60)); 12741 verifyFormat("[myObject doSomethingWith:arg1\n" 12742 " firstBlock:^(Foo *a) {\n" 12743 " // ...\n" 12744 " int i;\n" 12745 " }\n" 12746 " secondBlock:^(Bar *b) {\n" 12747 " // ...\n" 12748 " int i;\n" 12749 " }\n" 12750 " thirdBlock:^Foo(Bar *b) {\n" 12751 " // ...\n" 12752 " int i;\n" 12753 " }];"); 12754 verifyFormat("[myObject doSomethingWith:arg1\n" 12755 " firstBlock:-1\n" 12756 " secondBlock:^(Bar *b) {\n" 12757 " // ...\n" 12758 " int i;\n" 12759 " }];"); 12760 12761 verifyFormat("f(^{\n" 12762 " @autoreleasepool {\n" 12763 " if (a) {\n" 12764 " g();\n" 12765 " }\n" 12766 " }\n" 12767 "});"); 12768 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 12769 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 12770 "};"); 12771 12772 FormatStyle FourIndent = getLLVMStyle(); 12773 FourIndent.ObjCBlockIndentWidth = 4; 12774 verifyFormat("[operation setCompletionBlock:^{\n" 12775 " [self onOperationDone];\n" 12776 "}];", 12777 FourIndent); 12778 } 12779 12780 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 12781 FormatStyle ZeroColumn = getLLVMStyle(); 12782 ZeroColumn.ColumnLimit = 0; 12783 12784 verifyFormat("[[SessionService sharedService] " 12785 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 12786 " if (window) {\n" 12787 " [self windowDidLoad:window];\n" 12788 " } else {\n" 12789 " [self errorLoadingWindow];\n" 12790 " }\n" 12791 "}];", 12792 ZeroColumn); 12793 EXPECT_EQ("[[SessionService sharedService]\n" 12794 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 12795 " if (window) {\n" 12796 " [self windowDidLoad:window];\n" 12797 " } else {\n" 12798 " [self errorLoadingWindow];\n" 12799 " }\n" 12800 " }];", 12801 format("[[SessionService sharedService]\n" 12802 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 12803 " if (window) {\n" 12804 " [self windowDidLoad:window];\n" 12805 " } else {\n" 12806 " [self errorLoadingWindow];\n" 12807 " }\n" 12808 "}];", 12809 ZeroColumn)); 12810 verifyFormat("[myObject doSomethingWith:arg1\n" 12811 " firstBlock:^(Foo *a) {\n" 12812 " // ...\n" 12813 " int i;\n" 12814 " }\n" 12815 " secondBlock:^(Bar *b) {\n" 12816 " // ...\n" 12817 " int i;\n" 12818 " }\n" 12819 " thirdBlock:^Foo(Bar *b) {\n" 12820 " // ...\n" 12821 " int i;\n" 12822 " }];", 12823 ZeroColumn); 12824 verifyFormat("f(^{\n" 12825 " @autoreleasepool {\n" 12826 " if (a) {\n" 12827 " g();\n" 12828 " }\n" 12829 " }\n" 12830 "});", 12831 ZeroColumn); 12832 verifyFormat("void (^largeBlock)(void) = ^{\n" 12833 " // ...\n" 12834 "};", 12835 ZeroColumn); 12836 12837 ZeroColumn.AllowShortBlocksOnASingleLine = true; 12838 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 12839 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 12840 ZeroColumn.AllowShortBlocksOnASingleLine = false; 12841 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 12842 " int i;\n" 12843 "};", 12844 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 12845 } 12846 12847 TEST_F(FormatTest, SupportsCRLF) { 12848 EXPECT_EQ("int a;\r\n" 12849 "int b;\r\n" 12850 "int c;\r\n", 12851 format("int a;\r\n" 12852 " int b;\r\n" 12853 " int c;\r\n", 12854 getLLVMStyle())); 12855 EXPECT_EQ("int a;\r\n" 12856 "int b;\r\n" 12857 "int c;\r\n", 12858 format("int a;\r\n" 12859 " int b;\n" 12860 " int c;\r\n", 12861 getLLVMStyle())); 12862 EXPECT_EQ("int a;\n" 12863 "int b;\n" 12864 "int c;\n", 12865 format("int a;\r\n" 12866 " int b;\n" 12867 " int c;\n", 12868 getLLVMStyle())); 12869 EXPECT_EQ("\"aaaaaaa \"\r\n" 12870 "\"bbbbbbb\";\r\n", 12871 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 12872 EXPECT_EQ("#define A \\\r\n" 12873 " b; \\\r\n" 12874 " c; \\\r\n" 12875 " d;\r\n", 12876 format("#define A \\\r\n" 12877 " b; \\\r\n" 12878 " c; d; \r\n", 12879 getGoogleStyle())); 12880 12881 EXPECT_EQ("/*\r\n" 12882 "multi line block comments\r\n" 12883 "should not introduce\r\n" 12884 "an extra carriage return\r\n" 12885 "*/\r\n", 12886 format("/*\r\n" 12887 "multi line block comments\r\n" 12888 "should not introduce\r\n" 12889 "an extra carriage return\r\n" 12890 "*/\r\n")); 12891 EXPECT_EQ("/*\r\n" 12892 "\r\n" 12893 "*/", 12894 format("/*\r\n" 12895 " \r\r\r\n" 12896 "*/")); 12897 } 12898 12899 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 12900 verifyFormat("MY_CLASS(C) {\n" 12901 " int i;\n" 12902 " int j;\n" 12903 "};"); 12904 } 12905 12906 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 12907 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 12908 TwoIndent.ContinuationIndentWidth = 2; 12909 12910 EXPECT_EQ("int i =\n" 12911 " longFunction(\n" 12912 " arg);", 12913 format("int i = longFunction(arg);", TwoIndent)); 12914 12915 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 12916 SixIndent.ContinuationIndentWidth = 6; 12917 12918 EXPECT_EQ("int i =\n" 12919 " longFunction(\n" 12920 " arg);", 12921 format("int i = longFunction(arg);", SixIndent)); 12922 } 12923 12924 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 12925 FormatStyle Style = getLLVMStyle(); 12926 verifyFormat("int Foo::getter(\n" 12927 " //\n" 12928 ") const {\n" 12929 " return foo;\n" 12930 "}", 12931 Style); 12932 verifyFormat("void Foo::setter(\n" 12933 " //\n" 12934 ") {\n" 12935 " foo = 1;\n" 12936 "}", 12937 Style); 12938 } 12939 12940 TEST_F(FormatTest, SpacesInAngles) { 12941 FormatStyle Spaces = getLLVMStyle(); 12942 Spaces.SpacesInAngles = true; 12943 12944 verifyFormat("static_cast< int >(arg);", Spaces); 12945 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 12946 verifyFormat("f< int, float >();", Spaces); 12947 verifyFormat("template <> g() {}", Spaces); 12948 verifyFormat("template < std::vector< int > > f() {}", Spaces); 12949 verifyFormat("std::function< void(int, int) > fct;", Spaces); 12950 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 12951 Spaces); 12952 12953 Spaces.Standard = FormatStyle::LS_Cpp03; 12954 Spaces.SpacesInAngles = true; 12955 verifyFormat("A< A< int > >();", Spaces); 12956 12957 Spaces.SpacesInAngles = false; 12958 verifyFormat("A<A<int> >();", Spaces); 12959 12960 Spaces.Standard = FormatStyle::LS_Cpp11; 12961 Spaces.SpacesInAngles = true; 12962 verifyFormat("A< A< int > >();", Spaces); 12963 12964 Spaces.SpacesInAngles = false; 12965 verifyFormat("A<A<int>>();", Spaces); 12966 } 12967 12968 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 12969 FormatStyle Style = getLLVMStyle(); 12970 Style.SpaceAfterTemplateKeyword = false; 12971 verifyFormat("template<int> void foo();", Style); 12972 } 12973 12974 TEST_F(FormatTest, TripleAngleBrackets) { 12975 verifyFormat("f<<<1, 1>>>();"); 12976 verifyFormat("f<<<1, 1, 1, s>>>();"); 12977 verifyFormat("f<<<a, b, c, d>>>();"); 12978 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 12979 verifyFormat("f<param><<<1, 1>>>();"); 12980 verifyFormat("f<1><<<1, 1>>>();"); 12981 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 12982 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 12983 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 12984 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 12985 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 12986 } 12987 12988 TEST_F(FormatTest, MergeLessLessAtEnd) { 12989 verifyFormat("<<"); 12990 EXPECT_EQ("< < <", format("\\\n<<<")); 12991 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 12992 "aaallvm::outs() <<"); 12993 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 12994 "aaaallvm::outs()\n <<"); 12995 } 12996 12997 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 12998 std::string code = "#if A\n" 12999 "#if B\n" 13000 "a.\n" 13001 "#endif\n" 13002 " a = 1;\n" 13003 "#else\n" 13004 "#endif\n" 13005 "#if C\n" 13006 "#else\n" 13007 "#endif\n"; 13008 EXPECT_EQ(code, format(code)); 13009 } 13010 13011 TEST_F(FormatTest, HandleConflictMarkers) { 13012 // Git/SVN conflict markers. 13013 EXPECT_EQ("int a;\n" 13014 "void f() {\n" 13015 " callme(some(parameter1,\n" 13016 "<<<<<<< text by the vcs\n" 13017 " parameter2),\n" 13018 "||||||| text by the vcs\n" 13019 " parameter2),\n" 13020 " parameter3,\n" 13021 "======= text by the vcs\n" 13022 " parameter2, parameter3),\n" 13023 ">>>>>>> text by the vcs\n" 13024 " otherparameter);\n", 13025 format("int a;\n" 13026 "void f() {\n" 13027 " callme(some(parameter1,\n" 13028 "<<<<<<< text by the vcs\n" 13029 " parameter2),\n" 13030 "||||||| text by the vcs\n" 13031 " parameter2),\n" 13032 " parameter3,\n" 13033 "======= text by the vcs\n" 13034 " parameter2,\n" 13035 " parameter3),\n" 13036 ">>>>>>> text by the vcs\n" 13037 " otherparameter);\n")); 13038 13039 // Perforce markers. 13040 EXPECT_EQ("void f() {\n" 13041 " function(\n" 13042 ">>>> text by the vcs\n" 13043 " parameter,\n" 13044 "==== text by the vcs\n" 13045 " parameter,\n" 13046 "==== text by the vcs\n" 13047 " parameter,\n" 13048 "<<<< text by the vcs\n" 13049 " parameter);\n", 13050 format("void f() {\n" 13051 " function(\n" 13052 ">>>> text by the vcs\n" 13053 " parameter,\n" 13054 "==== text by the vcs\n" 13055 " parameter,\n" 13056 "==== text by the vcs\n" 13057 " parameter,\n" 13058 "<<<< text by the vcs\n" 13059 " parameter);\n")); 13060 13061 EXPECT_EQ("<<<<<<<\n" 13062 "|||||||\n" 13063 "=======\n" 13064 ">>>>>>>", 13065 format("<<<<<<<\n" 13066 "|||||||\n" 13067 "=======\n" 13068 ">>>>>>>")); 13069 13070 EXPECT_EQ("<<<<<<<\n" 13071 "|||||||\n" 13072 "int i;\n" 13073 "=======\n" 13074 ">>>>>>>", 13075 format("<<<<<<<\n" 13076 "|||||||\n" 13077 "int i;\n" 13078 "=======\n" 13079 ">>>>>>>")); 13080 13081 // FIXME: Handle parsing of macros around conflict markers correctly: 13082 EXPECT_EQ("#define Macro \\\n" 13083 "<<<<<<<\n" 13084 "Something \\\n" 13085 "|||||||\n" 13086 "Else \\\n" 13087 "=======\n" 13088 "Other \\\n" 13089 ">>>>>>>\n" 13090 " End int i;\n", 13091 format("#define Macro \\\n" 13092 "<<<<<<<\n" 13093 " Something \\\n" 13094 "|||||||\n" 13095 " Else \\\n" 13096 "=======\n" 13097 " Other \\\n" 13098 ">>>>>>>\n" 13099 " End\n" 13100 "int i;\n")); 13101 } 13102 13103 TEST_F(FormatTest, DisableRegions) { 13104 EXPECT_EQ("int i;\n" 13105 "// clang-format off\n" 13106 " int j;\n" 13107 "// clang-format on\n" 13108 "int k;", 13109 format(" int i;\n" 13110 " // clang-format off\n" 13111 " int j;\n" 13112 " // clang-format on\n" 13113 " int k;")); 13114 EXPECT_EQ("int i;\n" 13115 "/* clang-format off */\n" 13116 " int j;\n" 13117 "/* clang-format on */\n" 13118 "int k;", 13119 format(" int i;\n" 13120 " /* clang-format off */\n" 13121 " int j;\n" 13122 " /* clang-format on */\n" 13123 " int k;")); 13124 13125 // Don't reflow comments within disabled regions. 13126 EXPECT_EQ( 13127 "// clang-format off\n" 13128 "// long long long long long long line\n" 13129 "/* clang-format on */\n" 13130 "/* long long long\n" 13131 " * long long long\n" 13132 " * line */\n" 13133 "int i;\n" 13134 "/* clang-format off */\n" 13135 "/* long long long long long long line */\n", 13136 format("// clang-format off\n" 13137 "// long long long long long long line\n" 13138 "/* clang-format on */\n" 13139 "/* long long long long long long line */\n" 13140 "int i;\n" 13141 "/* clang-format off */\n" 13142 "/* long long long long long long line */\n", 13143 getLLVMStyleWithColumns(20))); 13144 } 13145 13146 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 13147 format("? ) ="); 13148 verifyNoCrash("#define a\\\n /**/}"); 13149 } 13150 13151 TEST_F(FormatTest, FormatsTableGenCode) { 13152 FormatStyle Style = getLLVMStyle(); 13153 Style.Language = FormatStyle::LK_TableGen; 13154 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 13155 } 13156 13157 TEST_F(FormatTest, ArrayOfTemplates) { 13158 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 13159 format("auto a = new unique_ptr<int > [ 10];")); 13160 13161 FormatStyle Spaces = getLLVMStyle(); 13162 Spaces.SpacesInSquareBrackets = true; 13163 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 13164 format("auto a = new unique_ptr<int > [10];", Spaces)); 13165 } 13166 13167 TEST_F(FormatTest, ArrayAsTemplateType) { 13168 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 13169 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 13170 13171 FormatStyle Spaces = getLLVMStyle(); 13172 Spaces.SpacesInSquareBrackets = true; 13173 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 13174 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 13175 } 13176 13177 TEST_F(FormatTest, NoSpaceAfterSuper) { 13178 verifyFormat("__super::FooBar();"); 13179 } 13180 13181 TEST(FormatStyle, GetStyleWithEmptyFileName) { 13182 llvm::vfs::InMemoryFileSystem FS; 13183 auto Style1 = getStyle("file", "", "Google", "", &FS); 13184 ASSERT_TRUE((bool)Style1); 13185 ASSERT_EQ(*Style1, getGoogleStyle()); 13186 } 13187 13188 TEST(FormatStyle, GetStyleOfFile) { 13189 llvm::vfs::InMemoryFileSystem FS; 13190 // Test 1: format file in the same directory. 13191 ASSERT_TRUE( 13192 FS.addFile("/a/.clang-format", 0, 13193 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 13194 ASSERT_TRUE( 13195 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13196 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 13197 ASSERT_TRUE((bool)Style1); 13198 ASSERT_EQ(*Style1, getLLVMStyle()); 13199 13200 // Test 2.1: fallback to default. 13201 ASSERT_TRUE( 13202 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13203 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 13204 ASSERT_TRUE((bool)Style2); 13205 ASSERT_EQ(*Style2, getMozillaStyle()); 13206 13207 // Test 2.2: no format on 'none' fallback style. 13208 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 13209 ASSERT_TRUE((bool)Style2); 13210 ASSERT_EQ(*Style2, getNoStyle()); 13211 13212 // Test 2.3: format if config is found with no based style while fallback is 13213 // 'none'. 13214 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 13215 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 13216 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 13217 ASSERT_TRUE((bool)Style2); 13218 ASSERT_EQ(*Style2, getLLVMStyle()); 13219 13220 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 13221 Style2 = getStyle("{}", "a.h", "none", "", &FS); 13222 ASSERT_TRUE((bool)Style2); 13223 ASSERT_EQ(*Style2, getLLVMStyle()); 13224 13225 // Test 3: format file in parent directory. 13226 ASSERT_TRUE( 13227 FS.addFile("/c/.clang-format", 0, 13228 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 13229 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 13230 llvm::MemoryBuffer::getMemBuffer("int i;"))); 13231 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 13232 ASSERT_TRUE((bool)Style3); 13233 ASSERT_EQ(*Style3, getGoogleStyle()); 13234 13235 // Test 4: error on invalid fallback style 13236 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 13237 ASSERT_FALSE((bool)Style4); 13238 llvm::consumeError(Style4.takeError()); 13239 13240 // Test 5: error on invalid yaml on command line 13241 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 13242 ASSERT_FALSE((bool)Style5); 13243 llvm::consumeError(Style5.takeError()); 13244 13245 // Test 6: error on invalid style 13246 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 13247 ASSERT_FALSE((bool)Style6); 13248 llvm::consumeError(Style6.takeError()); 13249 13250 // Test 7: found config file, error on parsing it 13251 ASSERT_TRUE( 13252 FS.addFile("/d/.clang-format", 0, 13253 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 13254 "InvalidKey: InvalidValue"))); 13255 ASSERT_TRUE( 13256 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13257 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 13258 ASSERT_FALSE((bool)Style7); 13259 llvm::consumeError(Style7.takeError()); 13260 13261 // Test 8: inferred per-language defaults apply. 13262 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 13263 ASSERT_TRUE((bool)StyleTd); 13264 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 13265 } 13266 13267 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 13268 // Column limit is 20. 13269 std::string Code = "Type *a =\n" 13270 " new Type();\n" 13271 "g(iiiii, 0, jjjjj,\n" 13272 " 0, kkkkk, 0, mm);\n" 13273 "int bad = format ;"; 13274 std::string Expected = "auto a = new Type();\n" 13275 "g(iiiii, nullptr,\n" 13276 " jjjjj, nullptr,\n" 13277 " kkkkk, nullptr,\n" 13278 " mm);\n" 13279 "int bad = format ;"; 13280 FileID ID = Context.createInMemoryFile("format.cpp", Code); 13281 tooling::Replacements Replaces = toReplacements( 13282 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 13283 "auto "), 13284 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 13285 "nullptr"), 13286 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 13287 "nullptr"), 13288 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 13289 "nullptr")}); 13290 13291 format::FormatStyle Style = format::getLLVMStyle(); 13292 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 13293 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 13294 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 13295 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 13296 auto Result = applyAllReplacements(Code, *FormattedReplaces); 13297 EXPECT_TRUE(static_cast<bool>(Result)); 13298 EXPECT_EQ(Expected, *Result); 13299 } 13300 13301 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 13302 std::string Code = "#include \"a.h\"\n" 13303 "#include \"c.h\"\n" 13304 "\n" 13305 "int main() {\n" 13306 " return 0;\n" 13307 "}"; 13308 std::string Expected = "#include \"a.h\"\n" 13309 "#include \"b.h\"\n" 13310 "#include \"c.h\"\n" 13311 "\n" 13312 "int main() {\n" 13313 " return 0;\n" 13314 "}"; 13315 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 13316 tooling::Replacements Replaces = toReplacements( 13317 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 13318 "#include \"b.h\"\n")}); 13319 13320 format::FormatStyle Style = format::getLLVMStyle(); 13321 Style.SortIncludes = true; 13322 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 13323 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 13324 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 13325 auto Result = applyAllReplacements(Code, *FormattedReplaces); 13326 EXPECT_TRUE(static_cast<bool>(Result)); 13327 EXPECT_EQ(Expected, *Result); 13328 } 13329 13330 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 13331 EXPECT_EQ("using std::cin;\n" 13332 "using std::cout;", 13333 format("using std::cout;\n" 13334 "using std::cin;", getGoogleStyle())); 13335 } 13336 13337 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 13338 format::FormatStyle Style = format::getLLVMStyle(); 13339 Style.Standard = FormatStyle::LS_Cpp03; 13340 // cpp03 recognize this string as identifier u8 and literal character 'a' 13341 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 13342 } 13343 13344 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 13345 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 13346 // all modes, including C++11, C++14 and C++17 13347 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 13348 } 13349 13350 TEST_F(FormatTest, DoNotFormatLikelyXml) { 13351 EXPECT_EQ("<!-- ;> -->", 13352 format("<!-- ;> -->", getGoogleStyle())); 13353 EXPECT_EQ(" <!-- >; -->", 13354 format(" <!-- >; -->", getGoogleStyle())); 13355 } 13356 13357 TEST_F(FormatTest, StructuredBindings) { 13358 // Structured bindings is a C++17 feature. 13359 // all modes, including C++11, C++14 and C++17 13360 verifyFormat("auto [a, b] = f();"); 13361 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 13362 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 13363 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 13364 EXPECT_EQ("auto const volatile [a, b] = f();", 13365 format("auto const volatile[a, b] = f();")); 13366 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 13367 EXPECT_EQ("auto &[a, b, c] = f();", 13368 format("auto &[ a , b,c ] = f();")); 13369 EXPECT_EQ("auto &&[a, b, c] = f();", 13370 format("auto &&[ a , b,c ] = f();")); 13371 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 13372 EXPECT_EQ("auto const volatile &&[a, b] = f();", 13373 format("auto const volatile &&[a, b] = f();")); 13374 EXPECT_EQ("auto const &&[a, b] = f();", format("auto const && [a, b] = f();")); 13375 EXPECT_EQ("const auto &[a, b] = f();", format("const auto & [a, b] = f();")); 13376 EXPECT_EQ("const auto volatile &&[a, b] = f();", 13377 format("const auto volatile &&[a, b] = f();")); 13378 EXPECT_EQ("volatile const auto &&[a, b] = f();", 13379 format("volatile const auto &&[a, b] = f();")); 13380 EXPECT_EQ("const auto &&[a, b] = f();", format("const auto && [a, b] = f();")); 13381 13382 // Make sure we don't mistake structured bindings for lambdas. 13383 FormatStyle PointerMiddle = getLLVMStyle(); 13384 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 13385 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 13386 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 13387 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 13388 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 13389 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 13390 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 13391 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 13392 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 13393 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 13394 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 13395 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 13396 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 13397 13398 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 13399 format("for (const auto && [a, b] : some_range) {\n}")); 13400 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 13401 format("for (const auto & [a, b] : some_range) {\n}")); 13402 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 13403 format("for (const auto[a, b] : some_range) {\n}")); 13404 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 13405 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 13406 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 13407 EXPECT_EQ("auto const &[x, y](expr);", format("auto const & [x,y] (expr);")); 13408 EXPECT_EQ("auto const &&[x, y](expr);", format("auto const && [x,y] (expr);")); 13409 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 13410 EXPECT_EQ("auto const &[x, y]{expr};", format("auto const & [x,y] {expr};")); 13411 EXPECT_EQ("auto const &&[x, y]{expr};", format("auto const && [x,y] {expr};")); 13412 13413 format::FormatStyle Spaces = format::getLLVMStyle(); 13414 Spaces.SpacesInSquareBrackets = true; 13415 verifyFormat("auto [ a, b ] = f();", Spaces); 13416 verifyFormat("auto &&[ a, b ] = f();", Spaces); 13417 verifyFormat("auto &[ a, b ] = f();", Spaces); 13418 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 13419 verifyFormat("auto const &[ a, b ] = f();", Spaces); 13420 } 13421 13422 TEST_F(FormatTest, FileAndCode) { 13423 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 13424 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 13425 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 13426 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 13427 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@interface Foo\n@end\n")); 13428 EXPECT_EQ( 13429 FormatStyle::LK_ObjC, 13430 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 13431 EXPECT_EQ(FormatStyle::LK_ObjC, 13432 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 13433 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 13434 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 13435 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo", "@interface Foo\n@end\n")); 13436 EXPECT_EQ(FormatStyle::LK_ObjC, 13437 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 13438 EXPECT_EQ( 13439 FormatStyle::LK_ObjC, 13440 guessLanguage("foo.h", 13441 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 13442 EXPECT_EQ( 13443 FormatStyle::LK_Cpp, 13444 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 13445 } 13446 13447 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 13448 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 13449 EXPECT_EQ(FormatStyle::LK_ObjC, 13450 guessLanguage("foo.h", "array[[calculator getIndex]];")); 13451 EXPECT_EQ(FormatStyle::LK_Cpp, 13452 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 13453 EXPECT_EQ( 13454 FormatStyle::LK_Cpp, 13455 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 13456 EXPECT_EQ(FormatStyle::LK_ObjC, 13457 guessLanguage("foo.h", "[[noreturn foo] bar];")); 13458 EXPECT_EQ(FormatStyle::LK_Cpp, 13459 guessLanguage("foo.h", "[[clang::fallthrough]];")); 13460 EXPECT_EQ(FormatStyle::LK_ObjC, 13461 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 13462 EXPECT_EQ(FormatStyle::LK_Cpp, 13463 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 13464 EXPECT_EQ(FormatStyle::LK_Cpp, 13465 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 13466 EXPECT_EQ(FormatStyle::LK_ObjC, 13467 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 13468 EXPECT_EQ(FormatStyle::LK_Cpp, 13469 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 13470 EXPECT_EQ( 13471 FormatStyle::LK_Cpp, 13472 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 13473 EXPECT_EQ( 13474 FormatStyle::LK_Cpp, 13475 guessLanguage("foo.h", 13476 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 13477 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 13478 } 13479 13480 TEST_F(FormatTest, GuessLanguageWithCaret) { 13481 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 13482 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 13483 EXPECT_EQ(FormatStyle::LK_ObjC, 13484 guessLanguage("foo.h", "int(^)(char, float);")); 13485 EXPECT_EQ(FormatStyle::LK_ObjC, 13486 guessLanguage("foo.h", "int(^foo)(char, float);")); 13487 EXPECT_EQ(FormatStyle::LK_ObjC, 13488 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 13489 EXPECT_EQ(FormatStyle::LK_ObjC, 13490 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 13491 EXPECT_EQ( 13492 FormatStyle::LK_ObjC, 13493 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 13494 } 13495 13496 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 13497 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13498 "void f() {\n" 13499 " asm (\"mov %[e], %[d]\"\n" 13500 " : [d] \"=rm\" (d)\n" 13501 " [e] \"rm\" (*e));\n" 13502 "}")); 13503 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13504 "void f() {\n" 13505 " _asm (\"mov %[e], %[d]\"\n" 13506 " : [d] \"=rm\" (d)\n" 13507 " [e] \"rm\" (*e));\n" 13508 "}")); 13509 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13510 "void f() {\n" 13511 " __asm (\"mov %[e], %[d]\"\n" 13512 " : [d] \"=rm\" (d)\n" 13513 " [e] \"rm\" (*e));\n" 13514 "}")); 13515 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13516 "void f() {\n" 13517 " __asm__ (\"mov %[e], %[d]\"\n" 13518 " : [d] \"=rm\" (d)\n" 13519 " [e] \"rm\" (*e));\n" 13520 "}")); 13521 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13522 "void f() {\n" 13523 " asm (\"mov %[e], %[d]\"\n" 13524 " : [d] \"=rm\" (d),\n" 13525 " [e] \"rm\" (*e));\n" 13526 "}")); 13527 EXPECT_EQ(FormatStyle::LK_Cpp, 13528 guessLanguage("foo.h", "void f() {\n" 13529 " asm volatile (\"mov %[e], %[d]\"\n" 13530 " : [d] \"=rm\" (d)\n" 13531 " [e] \"rm\" (*e));\n" 13532 "}")); 13533 } 13534 13535 TEST_F(FormatTest, GuessLanguageWithChildLines) { 13536 EXPECT_EQ(FormatStyle::LK_Cpp, 13537 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 13538 EXPECT_EQ(FormatStyle::LK_ObjC, 13539 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 13540 EXPECT_EQ( 13541 FormatStyle::LK_Cpp, 13542 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 13543 EXPECT_EQ( 13544 FormatStyle::LK_ObjC, 13545 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 13546 } 13547 13548 } // end namespace 13549 } // end namespace format 13550 } // end namespace clang 13551