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 (true)\n" 430 " f();\ng();"); 431 verifyFormat("if constexpr (a)\n" 432 " if constexpr (b)\n" 433 " if constexpr (c)\n" 434 " g();\n" 435 "h();"); 436 verifyFormat("if CONSTEXPR (a)\n" 437 " if CONSTEXPR (b)\n" 438 " if CONSTEXPR (c)\n" 439 " g();\n" 440 "h();"); 441 verifyFormat("if constexpr (a)\n" 442 " if constexpr (b) {\n" 443 " f();\n" 444 " }\n" 445 "g();"); 446 verifyFormat("if CONSTEXPR (a)\n" 447 " if CONSTEXPR (b) {\n" 448 " f();\n" 449 " }\n" 450 "g();"); 451 452 FormatStyle AllowsMergedIf = getLLVMStyle(); 453 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 454 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 455 FormatStyle::SIS_WithoutElse; 456 verifyFormat("if (a)\n" 457 " // comment\n" 458 " f();", 459 AllowsMergedIf); 460 verifyFormat("{\n" 461 " if (a)\n" 462 " label:\n" 463 " f();\n" 464 "}", 465 AllowsMergedIf); 466 verifyFormat("#define A \\\n" 467 " if (a) \\\n" 468 " label: \\\n" 469 " f()", 470 AllowsMergedIf); 471 verifyFormat("if (a)\n" 472 " ;", 473 AllowsMergedIf); 474 verifyFormat("if (a)\n" 475 " if (b) return;", 476 AllowsMergedIf); 477 478 verifyFormat("if (a) // Can't merge this\n" 479 " f();\n", 480 AllowsMergedIf); 481 verifyFormat("if (a) /* still don't merge */\n" 482 " f();", 483 AllowsMergedIf); 484 verifyFormat("if (a) { // Never merge this\n" 485 " f();\n" 486 "}", 487 AllowsMergedIf); 488 verifyFormat("if (a) { /* Never merge this */\n" 489 " f();\n" 490 "}", 491 AllowsMergedIf); 492 493 AllowsMergedIf.ColumnLimit = 14; 494 verifyFormat("if (a) return;", AllowsMergedIf); 495 verifyFormat("if (aaaaaaaaa)\n" 496 " return;", 497 AllowsMergedIf); 498 499 AllowsMergedIf.ColumnLimit = 13; 500 verifyFormat("if (a)\n return;", AllowsMergedIf); 501 } 502 503 TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) { 504 FormatStyle AllowsMergedIf = getLLVMStyle(); 505 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 506 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 507 FormatStyle::SIS_WithoutElse; 508 verifyFormat("if (a)\n" 509 " f();\n" 510 "else {\n" 511 " g();\n" 512 "}", 513 AllowsMergedIf); 514 verifyFormat("if (a)\n" 515 " f();\n" 516 "else\n" 517 " g();\n", 518 AllowsMergedIf); 519 520 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 521 522 verifyFormat("if (a) f();\n" 523 "else {\n" 524 " g();\n" 525 "}", 526 AllowsMergedIf); 527 verifyFormat("if (a) f();\n" 528 "else {\n" 529 " if (a) f();\n" 530 " else {\n" 531 " g();\n" 532 " }\n" 533 " g();\n" 534 "}", 535 AllowsMergedIf); 536 } 537 538 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) { 539 FormatStyle AllowsMergedLoops = getLLVMStyle(); 540 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true; 541 verifyFormat("while (true) continue;", AllowsMergedLoops); 542 verifyFormat("for (;;) continue;", AllowsMergedLoops); 543 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops); 544 verifyFormat("while (true)\n" 545 " ;", 546 AllowsMergedLoops); 547 verifyFormat("for (;;)\n" 548 " ;", 549 AllowsMergedLoops); 550 verifyFormat("for (;;)\n" 551 " for (;;) continue;", 552 AllowsMergedLoops); 553 verifyFormat("for (;;) // Can't merge this\n" 554 " continue;", 555 AllowsMergedLoops); 556 verifyFormat("for (;;) /* still don't merge */\n" 557 " continue;", 558 AllowsMergedLoops); 559 } 560 561 TEST_F(FormatTest, FormatShortBracedStatements) { 562 FormatStyle AllowSimpleBracedStatements = getLLVMStyle(); 563 AllowSimpleBracedStatements.ColumnLimit = 40; 564 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = 565 FormatStyle::SBS_Always; 566 567 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 568 FormatStyle::SIS_WithoutElse; 569 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 570 571 AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom; 572 AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true; 573 AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false; 574 575 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 576 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 577 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 578 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 579 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 580 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 581 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 582 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 583 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 584 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 585 verifyFormat("if (true) {\n" 586 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 587 "}", 588 AllowSimpleBracedStatements); 589 verifyFormat("if (true) { //\n" 590 " f();\n" 591 "}", 592 AllowSimpleBracedStatements); 593 verifyFormat("if (true) {\n" 594 " f();\n" 595 " f();\n" 596 "}", 597 AllowSimpleBracedStatements); 598 verifyFormat("if (true) {\n" 599 " f();\n" 600 "} else {\n" 601 " f();\n" 602 "}", 603 AllowSimpleBracedStatements); 604 605 verifyFormat("struct A2 {\n" 606 " int X;\n" 607 "};", 608 AllowSimpleBracedStatements); 609 verifyFormat("typedef struct A2 {\n" 610 " int X;\n" 611 "} A2_t;", 612 AllowSimpleBracedStatements); 613 verifyFormat("template <int> struct A2 {\n" 614 " struct B {};\n" 615 "};", 616 AllowSimpleBracedStatements); 617 618 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 619 FormatStyle::SIS_Never; 620 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 621 verifyFormat("if (true) {\n" 622 " f();\n" 623 "}", 624 AllowSimpleBracedStatements); 625 verifyFormat("if (true) {\n" 626 " f();\n" 627 "} else {\n" 628 " f();\n" 629 "}", 630 AllowSimpleBracedStatements); 631 632 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 633 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 634 verifyFormat("while (true) {\n" 635 " f();\n" 636 "}", 637 AllowSimpleBracedStatements); 638 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 639 verifyFormat("for (;;) {\n" 640 " f();\n" 641 "}", 642 AllowSimpleBracedStatements); 643 644 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 645 FormatStyle::SIS_WithoutElse; 646 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 647 AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement = true; 648 649 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 650 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 651 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 652 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 653 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 654 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 655 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 656 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 657 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 658 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 659 verifyFormat("if (true)\n" 660 "{\n" 661 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 662 "}", 663 AllowSimpleBracedStatements); 664 verifyFormat("if (true)\n" 665 "{ //\n" 666 " f();\n" 667 "}", 668 AllowSimpleBracedStatements); 669 verifyFormat("if (true)\n" 670 "{\n" 671 " f();\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.AllowShortIfStatementsOnASingleLine = 685 FormatStyle::SIS_Never; 686 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 687 verifyFormat("if (true)\n" 688 "{\n" 689 " f();\n" 690 "}", 691 AllowSimpleBracedStatements); 692 verifyFormat("if (true)\n" 693 "{\n" 694 " f();\n" 695 "} else\n" 696 "{\n" 697 " f();\n" 698 "}", 699 AllowSimpleBracedStatements); 700 701 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 702 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 703 verifyFormat("while (true)\n" 704 "{\n" 705 " f();\n" 706 "}", 707 AllowSimpleBracedStatements); 708 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 709 verifyFormat("for (;;)\n" 710 "{\n" 711 " f();\n" 712 "}", 713 AllowSimpleBracedStatements); 714 } 715 716 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) { 717 FormatStyle Style = getLLVMStyleWithColumns(60); 718 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 719 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 720 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 721 EXPECT_EQ("#define A \\\n" 722 " if (HANDLEwernufrnuLwrmviferuvnierv) \\\n" 723 " { RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; }\n" 724 "X;", 725 format("#define A \\\n" 726 " if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n" 727 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n" 728 " }\n" 729 "X;", 730 Style)); 731 } 732 733 TEST_F(FormatTest, ParseIfElse) { 734 verifyFormat("if (true)\n" 735 " if (true)\n" 736 " if (true)\n" 737 " f();\n" 738 " else\n" 739 " g();\n" 740 " else\n" 741 " h();\n" 742 "else\n" 743 " i();"); 744 verifyFormat("if (true)\n" 745 " if (true)\n" 746 " if (true) {\n" 747 " if (true)\n" 748 " f();\n" 749 " } else {\n" 750 " g();\n" 751 " }\n" 752 " else\n" 753 " h();\n" 754 "else {\n" 755 " i();\n" 756 "}"); 757 verifyFormat("if (true)\n" 758 " if constexpr (true)\n" 759 " if (true) {\n" 760 " if constexpr (true)\n" 761 " f();\n" 762 " } else {\n" 763 " g();\n" 764 " }\n" 765 " else\n" 766 " h();\n" 767 "else {\n" 768 " i();\n" 769 "}"); 770 verifyFormat("if (true)\n" 771 " if CONSTEXPR (true)\n" 772 " if (true) {\n" 773 " if CONSTEXPR (true)\n" 774 " f();\n" 775 " } else {\n" 776 " g();\n" 777 " }\n" 778 " else\n" 779 " h();\n" 780 "else {\n" 781 " i();\n" 782 "}"); 783 verifyFormat("void f() {\n" 784 " if (a) {\n" 785 " } else {\n" 786 " }\n" 787 "}"); 788 } 789 790 TEST_F(FormatTest, ElseIf) { 791 verifyFormat("if (a) {\n} else if (b) {\n}"); 792 verifyFormat("if (a)\n" 793 " f();\n" 794 "else if (b)\n" 795 " g();\n" 796 "else\n" 797 " h();"); 798 verifyFormat("if constexpr (a)\n" 799 " f();\n" 800 "else if constexpr (b)\n" 801 " g();\n" 802 "else\n" 803 " h();"); 804 verifyFormat("if CONSTEXPR (a)\n" 805 " f();\n" 806 "else if CONSTEXPR (b)\n" 807 " g();\n" 808 "else\n" 809 " h();"); 810 verifyFormat("if (a) {\n" 811 " f();\n" 812 "}\n" 813 "// or else ..\n" 814 "else {\n" 815 " g()\n" 816 "}"); 817 818 verifyFormat("if (a) {\n" 819 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 820 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 821 "}"); 822 verifyFormat("if (a) {\n" 823 "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 824 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 825 "}"); 826 verifyFormat("if (a) {\n" 827 "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 828 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 829 "}"); 830 verifyFormat("if (a) {\n" 831 "} else if (\n" 832 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 833 "}", 834 getLLVMStyleWithColumns(62)); 835 verifyFormat("if (a) {\n" 836 "} else if constexpr (\n" 837 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 838 "}", 839 getLLVMStyleWithColumns(62)); 840 verifyFormat("if (a) {\n" 841 "} else if CONSTEXPR (\n" 842 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 843 "}", 844 getLLVMStyleWithColumns(62)); 845 } 846 847 TEST_F(FormatTest, FormatsForLoop) { 848 verifyFormat( 849 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 850 " ++VeryVeryLongLoopVariable)\n" 851 " ;"); 852 verifyFormat("for (;;)\n" 853 " f();"); 854 verifyFormat("for (;;) {\n}"); 855 verifyFormat("for (;;) {\n" 856 " f();\n" 857 "}"); 858 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 859 860 verifyFormat( 861 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 862 " E = UnwrappedLines.end();\n" 863 " I != E; ++I) {\n}"); 864 865 verifyFormat( 866 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 867 " ++IIIII) {\n}"); 868 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 869 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 870 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 871 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 872 " I = FD->getDeclsInPrototypeScope().begin(),\n" 873 " E = FD->getDeclsInPrototypeScope().end();\n" 874 " I != E; ++I) {\n}"); 875 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n" 876 " I = Container.begin(),\n" 877 " E = Container.end();\n" 878 " I != E; ++I) {\n}", 879 getLLVMStyleWithColumns(76)); 880 881 verifyFormat( 882 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 883 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 884 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 885 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 886 " ++aaaaaaaaaaa) {\n}"); 887 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 888 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n" 889 " ++i) {\n}"); 890 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 891 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 892 "}"); 893 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 894 " aaaaaaaaaa);\n" 895 " iter; ++iter) {\n" 896 "}"); 897 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 898 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 899 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n" 900 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {"); 901 902 // These should not be formatted as Objective-C for-in loops. 903 verifyFormat("for (Foo *x = 0; x != in; x++) {\n}"); 904 verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}"); 905 verifyFormat("Foo *x;\nfor (x in y) {\n}"); 906 verifyFormat("for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}"); 907 908 FormatStyle NoBinPacking = getLLVMStyle(); 909 NoBinPacking.BinPackParameters = false; 910 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 911 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 912 " aaaaaaaaaaaaaaaa,\n" 913 " aaaaaaaaaaaaaaaa,\n" 914 " aaaaaaaaaaaaaaaa);\n" 915 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 916 "}", 917 NoBinPacking); 918 verifyFormat( 919 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 920 " E = UnwrappedLines.end();\n" 921 " I != E;\n" 922 " ++I) {\n}", 923 NoBinPacking); 924 925 FormatStyle AlignLeft = getLLVMStyle(); 926 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 927 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft); 928 } 929 930 TEST_F(FormatTest, RangeBasedForLoops) { 931 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 932 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 933 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 934 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 935 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 936 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 937 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n" 938 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}"); 939 } 940 941 TEST_F(FormatTest, ForEachLoops) { 942 verifyFormat("void f() {\n" 943 " foreach (Item *item, itemlist) {}\n" 944 " Q_FOREACH (Item *item, itemlist) {}\n" 945 " BOOST_FOREACH (Item *item, itemlist) {}\n" 946 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 947 "}"); 948 949 // As function-like macros. 950 verifyFormat("#define foreach(x, y)\n" 951 "#define Q_FOREACH(x, y)\n" 952 "#define BOOST_FOREACH(x, y)\n" 953 "#define UNKNOWN_FOREACH(x, y)\n"); 954 955 // Not as function-like macros. 956 verifyFormat("#define foreach (x, y)\n" 957 "#define Q_FOREACH (x, y)\n" 958 "#define BOOST_FOREACH (x, y)\n" 959 "#define UNKNOWN_FOREACH (x, y)\n"); 960 } 961 962 TEST_F(FormatTest, FormatsWhileLoop) { 963 verifyFormat("while (true) {\n}"); 964 verifyFormat("while (true)\n" 965 " f();"); 966 verifyFormat("while () {\n}"); 967 verifyFormat("while () {\n" 968 " f();\n" 969 "}"); 970 } 971 972 TEST_F(FormatTest, FormatsDoWhile) { 973 verifyFormat("do {\n" 974 " do_something();\n" 975 "} while (something());"); 976 verifyFormat("do\n" 977 " do_something();\n" 978 "while (something());"); 979 } 980 981 TEST_F(FormatTest, FormatsSwitchStatement) { 982 verifyFormat("switch (x) {\n" 983 "case 1:\n" 984 " f();\n" 985 " break;\n" 986 "case kFoo:\n" 987 "case ns::kBar:\n" 988 "case kBaz:\n" 989 " break;\n" 990 "default:\n" 991 " g();\n" 992 " break;\n" 993 "}"); 994 verifyFormat("switch (x) {\n" 995 "case 1: {\n" 996 " f();\n" 997 " break;\n" 998 "}\n" 999 "case 2: {\n" 1000 " break;\n" 1001 "}\n" 1002 "}"); 1003 verifyFormat("switch (x) {\n" 1004 "case 1: {\n" 1005 " f();\n" 1006 " {\n" 1007 " g();\n" 1008 " h();\n" 1009 " }\n" 1010 " break;\n" 1011 "}\n" 1012 "}"); 1013 verifyFormat("switch (x) {\n" 1014 "case 1: {\n" 1015 " f();\n" 1016 " if (foo) {\n" 1017 " g();\n" 1018 " h();\n" 1019 " }\n" 1020 " break;\n" 1021 "}\n" 1022 "}"); 1023 verifyFormat("switch (x) {\n" 1024 "case 1: {\n" 1025 " f();\n" 1026 " g();\n" 1027 "} break;\n" 1028 "}"); 1029 verifyFormat("switch (test)\n" 1030 " ;"); 1031 verifyFormat("switch (x) {\n" 1032 "default: {\n" 1033 " // Do nothing.\n" 1034 "}\n" 1035 "}"); 1036 verifyFormat("switch (x) {\n" 1037 "// comment\n" 1038 "// if 1, do f()\n" 1039 "case 1:\n" 1040 " f();\n" 1041 "}"); 1042 verifyFormat("switch (x) {\n" 1043 "case 1:\n" 1044 " // Do amazing stuff\n" 1045 " {\n" 1046 " f();\n" 1047 " g();\n" 1048 " }\n" 1049 " break;\n" 1050 "}"); 1051 verifyFormat("#define A \\\n" 1052 " switch (x) { \\\n" 1053 " case a: \\\n" 1054 " foo = b; \\\n" 1055 " }", 1056 getLLVMStyleWithColumns(20)); 1057 verifyFormat("#define OPERATION_CASE(name) \\\n" 1058 " case OP_name: \\\n" 1059 " return operations::Operation##name\n", 1060 getLLVMStyleWithColumns(40)); 1061 verifyFormat("switch (x) {\n" 1062 "case 1:;\n" 1063 "default:;\n" 1064 " int i;\n" 1065 "}"); 1066 1067 verifyGoogleFormat("switch (x) {\n" 1068 " case 1:\n" 1069 " f();\n" 1070 " break;\n" 1071 " case kFoo:\n" 1072 " case ns::kBar:\n" 1073 " case kBaz:\n" 1074 " break;\n" 1075 " default:\n" 1076 " g();\n" 1077 " break;\n" 1078 "}"); 1079 verifyGoogleFormat("switch (x) {\n" 1080 " case 1: {\n" 1081 " f();\n" 1082 " break;\n" 1083 " }\n" 1084 "}"); 1085 verifyGoogleFormat("switch (test)\n" 1086 " ;"); 1087 1088 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 1089 " case OP_name: \\\n" 1090 " return operations::Operation##name\n"); 1091 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 1092 " // Get the correction operation class.\n" 1093 " switch (OpCode) {\n" 1094 " CASE(Add);\n" 1095 " CASE(Subtract);\n" 1096 " default:\n" 1097 " return operations::Unknown;\n" 1098 " }\n" 1099 "#undef OPERATION_CASE\n" 1100 "}"); 1101 verifyFormat("DEBUG({\n" 1102 " switch (x) {\n" 1103 " case A:\n" 1104 " f();\n" 1105 " break;\n" 1106 " // fallthrough\n" 1107 " case B:\n" 1108 " g();\n" 1109 " break;\n" 1110 " }\n" 1111 "});"); 1112 EXPECT_EQ("DEBUG({\n" 1113 " switch (x) {\n" 1114 " case A:\n" 1115 " f();\n" 1116 " break;\n" 1117 " // On B:\n" 1118 " case B:\n" 1119 " g();\n" 1120 " break;\n" 1121 " }\n" 1122 "});", 1123 format("DEBUG({\n" 1124 " switch (x) {\n" 1125 " case A:\n" 1126 " f();\n" 1127 " break;\n" 1128 " // On B:\n" 1129 " case B:\n" 1130 " g();\n" 1131 " break;\n" 1132 " }\n" 1133 "});", 1134 getLLVMStyle())); 1135 EXPECT_EQ("switch (n) {\n" 1136 "case 0: {\n" 1137 " return false;\n" 1138 "}\n" 1139 "default: {\n" 1140 " return true;\n" 1141 "}\n" 1142 "}", 1143 format("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 getLLVMStyle())); 1153 verifyFormat("switch (a) {\n" 1154 "case (b):\n" 1155 " return;\n" 1156 "}"); 1157 1158 verifyFormat("switch (a) {\n" 1159 "case some_namespace::\n" 1160 " some_constant:\n" 1161 " return;\n" 1162 "}", 1163 getLLVMStyleWithColumns(34)); 1164 1165 FormatStyle Style = getLLVMStyle(); 1166 Style.IndentCaseLabels = true; 1167 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 1168 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1169 Style.BraceWrapping.AfterCaseLabel = true; 1170 Style.BraceWrapping.AfterControlStatement = true; 1171 EXPECT_EQ("switch (n)\n" 1172 "{\n" 1173 " case 0:\n" 1174 " {\n" 1175 " return false;\n" 1176 " }\n" 1177 " default:\n" 1178 " {\n" 1179 " return true;\n" 1180 " }\n" 1181 "}", 1182 format("switch (n) {\n" 1183 " case 0: {\n" 1184 " return false;\n" 1185 " }\n" 1186 " default: {\n" 1187 " return true;\n" 1188 " }\n" 1189 "}", 1190 Style)); 1191 Style.BraceWrapping.AfterCaseLabel = false; 1192 EXPECT_EQ("switch (n)\n" 1193 "{\n" 1194 " case 0: {\n" 1195 " return false;\n" 1196 " }\n" 1197 " default: {\n" 1198 " return true;\n" 1199 " }\n" 1200 "}", 1201 format("switch (n) {\n" 1202 " case 0:\n" 1203 " {\n" 1204 " return false;\n" 1205 " }\n" 1206 " default:\n" 1207 " {\n" 1208 " return true;\n" 1209 " }\n" 1210 "}", 1211 Style)); 1212 } 1213 1214 TEST_F(FormatTest, CaseRanges) { 1215 verifyFormat("switch (x) {\n" 1216 "case 'A' ... 'Z':\n" 1217 "case 1 ... 5:\n" 1218 "case a ... b:\n" 1219 " break;\n" 1220 "}"); 1221 } 1222 1223 TEST_F(FormatTest, ShortCaseLabels) { 1224 FormatStyle Style = getLLVMStyle(); 1225 Style.AllowShortCaseLabelsOnASingleLine = true; 1226 verifyFormat("switch (a) {\n" 1227 "case 1: x = 1; break;\n" 1228 "case 2: return;\n" 1229 "case 3:\n" 1230 "case 4:\n" 1231 "case 5: return;\n" 1232 "case 6: // comment\n" 1233 " return;\n" 1234 "case 7:\n" 1235 " // comment\n" 1236 " return;\n" 1237 "case 8:\n" 1238 " x = 8; // comment\n" 1239 " break;\n" 1240 "default: y = 1; break;\n" 1241 "}", 1242 Style); 1243 verifyFormat("switch (a) {\n" 1244 "case 0: return; // comment\n" 1245 "case 1: break; // comment\n" 1246 "case 2: return;\n" 1247 "// comment\n" 1248 "case 3: return;\n" 1249 "// comment 1\n" 1250 "// comment 2\n" 1251 "// comment 3\n" 1252 "case 4: break; /* comment */\n" 1253 "case 5:\n" 1254 " // comment\n" 1255 " break;\n" 1256 "case 6: /* comment */ x = 1; break;\n" 1257 "case 7: x = /* comment */ 1; break;\n" 1258 "case 8:\n" 1259 " x = 1; /* comment */\n" 1260 " break;\n" 1261 "case 9:\n" 1262 " break; // comment line 1\n" 1263 " // comment line 2\n" 1264 "}", 1265 Style); 1266 EXPECT_EQ("switch (a) {\n" 1267 "case 1:\n" 1268 " x = 8;\n" 1269 " // fall through\n" 1270 "case 2: x = 8;\n" 1271 "// comment\n" 1272 "case 3:\n" 1273 " return; /* comment line 1\n" 1274 " * comment line 2 */\n" 1275 "case 4: i = 8;\n" 1276 "// something else\n" 1277 "#if FOO\n" 1278 "case 5: break;\n" 1279 "#endif\n" 1280 "}", 1281 format("switch (a) {\n" 1282 "case 1: x = 8;\n" 1283 " // fall through\n" 1284 "case 2:\n" 1285 " x = 8;\n" 1286 "// comment\n" 1287 "case 3:\n" 1288 " return; /* comment line 1\n" 1289 " * comment line 2 */\n" 1290 "case 4:\n" 1291 " i = 8;\n" 1292 "// something else\n" 1293 "#if FOO\n" 1294 "case 5: break;\n" 1295 "#endif\n" 1296 "}", 1297 Style)); 1298 EXPECT_EQ("switch (a) {\n" "case 0:\n" 1299 " return; // long long long long long long long long long long long long comment\n" 1300 " // line\n" "}", 1301 format("switch (a) {\n" 1302 "case 0: return; // long long long long long long long long long long long long comment line\n" 1303 "}", 1304 Style)); 1305 EXPECT_EQ("switch (a) {\n" 1306 "case 0:\n" 1307 " return; /* long long long long long long long long long long long long comment\n" 1308 " line */\n" 1309 "}", 1310 format("switch (a) {\n" 1311 "case 0: return; /* long long long long long long long long long long long long comment line */\n" 1312 "}", 1313 Style)); 1314 verifyFormat("switch (a) {\n" 1315 "#if FOO\n" 1316 "case 0: return 0;\n" 1317 "#endif\n" 1318 "}", 1319 Style); 1320 verifyFormat("switch (a) {\n" 1321 "case 1: {\n" 1322 "}\n" 1323 "case 2: {\n" 1324 " return;\n" 1325 "}\n" 1326 "case 3: {\n" 1327 " x = 1;\n" 1328 " return;\n" 1329 "}\n" 1330 "case 4:\n" 1331 " if (x)\n" 1332 " return;\n" 1333 "}", 1334 Style); 1335 Style.ColumnLimit = 21; 1336 verifyFormat("switch (a) {\n" 1337 "case 1: x = 1; break;\n" 1338 "case 2: return;\n" 1339 "case 3:\n" 1340 "case 4:\n" 1341 "case 5: return;\n" 1342 "default:\n" 1343 " y = 1;\n" 1344 " break;\n" 1345 "}", 1346 Style); 1347 Style.ColumnLimit = 80; 1348 Style.AllowShortCaseLabelsOnASingleLine = false; 1349 Style.IndentCaseLabels = true; 1350 EXPECT_EQ("switch (n) {\n" 1351 " default /*comments*/:\n" 1352 " return true;\n" 1353 " case 0:\n" 1354 " return false;\n" 1355 "}", 1356 format("switch (n) {\n" 1357 "default/*comments*/:\n" 1358 " return true;\n" 1359 "case 0:\n" 1360 " return false;\n" 1361 "}", 1362 Style)); 1363 Style.AllowShortCaseLabelsOnASingleLine = true; 1364 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1365 Style.BraceWrapping.AfterCaseLabel = true; 1366 Style.BraceWrapping.AfterControlStatement = true; 1367 EXPECT_EQ("switch (n)\n" 1368 "{\n" 1369 " case 0:\n" 1370 " {\n" 1371 " return false;\n" 1372 " }\n" 1373 " default:\n" 1374 " {\n" 1375 " return true;\n" 1376 " }\n" 1377 "}", 1378 format("switch (n) {\n" 1379 " case 0: {\n" 1380 " return false;\n" 1381 " }\n" 1382 " default:\n" 1383 " {\n" 1384 " return true;\n" 1385 " }\n" 1386 "}", 1387 Style)); 1388 } 1389 1390 TEST_F(FormatTest, FormatsLabels) { 1391 verifyFormat("void f() {\n" 1392 " some_code();\n" 1393 "test_label:\n" 1394 " some_other_code();\n" 1395 " {\n" 1396 " some_more_code();\n" 1397 " another_label:\n" 1398 " some_more_code();\n" 1399 " }\n" 1400 "}"); 1401 verifyFormat("{\n" 1402 " some_code();\n" 1403 "test_label:\n" 1404 " some_other_code();\n" 1405 "}"); 1406 verifyFormat("{\n" 1407 " some_code();\n" 1408 "test_label:;\n" 1409 " int i = 0;\n" 1410 "}"); 1411 FormatStyle Style = getLLVMStyle(); 1412 Style.IndentGotoLabels = false; 1413 verifyFormat("void f() {\n" 1414 " some_code();\n" 1415 "test_label:\n" 1416 " some_other_code();\n" 1417 " {\n" 1418 " some_more_code();\n" 1419 "another_label:\n" 1420 " some_more_code();\n" 1421 " }\n" 1422 "}", 1423 Style); 1424 verifyFormat("{\n" 1425 " some_code();\n" 1426 "test_label:\n" 1427 " some_other_code();\n" 1428 "}", 1429 Style); 1430 verifyFormat("{\n" 1431 " some_code();\n" 1432 "test_label:;\n" 1433 " int i = 0;\n" 1434 "}"); 1435 } 1436 1437 //===----------------------------------------------------------------------===// 1438 // Tests for classes, namespaces, etc. 1439 //===----------------------------------------------------------------------===// 1440 1441 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1442 verifyFormat("class A {};"); 1443 } 1444 1445 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1446 verifyFormat("class A {\n" 1447 "public:\n" 1448 "public: // comment\n" 1449 "protected:\n" 1450 "private:\n" 1451 " void f() {}\n" 1452 "};"); 1453 verifyFormat("export class A {\n" 1454 "public:\n" 1455 "public: // comment\n" 1456 "protected:\n" 1457 "private:\n" 1458 " void f() {}\n" 1459 "};"); 1460 verifyGoogleFormat("class A {\n" 1461 " public:\n" 1462 " protected:\n" 1463 " private:\n" 1464 " void f() {}\n" 1465 "};"); 1466 verifyGoogleFormat("export class A {\n" 1467 " public:\n" 1468 " protected:\n" 1469 " private:\n" 1470 " void f() {}\n" 1471 "};"); 1472 verifyFormat("class A {\n" 1473 "public slots:\n" 1474 " void f1() {}\n" 1475 "public Q_SLOTS:\n" 1476 " void f2() {}\n" 1477 "protected slots:\n" 1478 " void f3() {}\n" 1479 "protected Q_SLOTS:\n" 1480 " void f4() {}\n" 1481 "private slots:\n" 1482 " void f5() {}\n" 1483 "private Q_SLOTS:\n" 1484 " void f6() {}\n" 1485 "signals:\n" 1486 " void g1();\n" 1487 "Q_SIGNALS:\n" 1488 " void g2();\n" 1489 "};"); 1490 1491 // Don't interpret 'signals' the wrong way. 1492 verifyFormat("signals.set();"); 1493 verifyFormat("for (Signals signals : f()) {\n}"); 1494 verifyFormat("{\n" 1495 " signals.set(); // This needs indentation.\n" 1496 "}"); 1497 verifyFormat("void f() {\n" 1498 "label:\n" 1499 " signals.baz();\n" 1500 "}"); 1501 } 1502 1503 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1504 EXPECT_EQ("class A {\n" 1505 "public:\n" 1506 " void f();\n" 1507 "\n" 1508 "private:\n" 1509 " void g() {}\n" 1510 " // test\n" 1511 "protected:\n" 1512 " int h;\n" 1513 "};", 1514 format("class A {\n" 1515 "public:\n" 1516 "void f();\n" 1517 "private:\n" 1518 "void g() {}\n" 1519 "// test\n" 1520 "protected:\n" 1521 "int h;\n" 1522 "};")); 1523 EXPECT_EQ("class A {\n" 1524 "protected:\n" 1525 "public:\n" 1526 " void f();\n" 1527 "};", 1528 format("class A {\n" 1529 "protected:\n" 1530 "\n" 1531 "public:\n" 1532 "\n" 1533 " void f();\n" 1534 "};")); 1535 1536 // Even ensure proper spacing inside macros. 1537 EXPECT_EQ("#define B \\\n" 1538 " class A { \\\n" 1539 " protected: \\\n" 1540 " public: \\\n" 1541 " void f(); \\\n" 1542 " };", 1543 format("#define B \\\n" 1544 " class A { \\\n" 1545 " protected: \\\n" 1546 " \\\n" 1547 " public: \\\n" 1548 " \\\n" 1549 " void f(); \\\n" 1550 " };", 1551 getGoogleStyle())); 1552 // But don't remove empty lines after macros ending in access specifiers. 1553 EXPECT_EQ("#define A private:\n" 1554 "\n" 1555 "int i;", 1556 format("#define A private:\n" 1557 "\n" 1558 "int i;")); 1559 } 1560 1561 TEST_F(FormatTest, FormatsClasses) { 1562 verifyFormat("class A : public B {};"); 1563 verifyFormat("class A : public ::B {};"); 1564 1565 verifyFormat( 1566 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1567 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1568 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1569 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1570 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1571 verifyFormat( 1572 "class A : public B, public C, public D, public E, public F {};"); 1573 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1574 " public C,\n" 1575 " public D,\n" 1576 " public E,\n" 1577 " public F,\n" 1578 " public G {};"); 1579 1580 verifyFormat("class\n" 1581 " ReallyReallyLongClassName {\n" 1582 " int i;\n" 1583 "};", 1584 getLLVMStyleWithColumns(32)); 1585 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1586 " aaaaaaaaaaaaaaaa> {};"); 1587 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1588 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1589 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1590 verifyFormat("template <class R, class C>\n" 1591 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1592 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1593 verifyFormat("class ::A::B {};"); 1594 } 1595 1596 TEST_F(FormatTest, BreakInheritanceStyle) { 1597 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1598 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1599 FormatStyle::BILS_BeforeComma; 1600 verifyFormat("class MyClass : public X {};", 1601 StyleWithInheritanceBreakBeforeComma); 1602 verifyFormat("class MyClass\n" 1603 " : public X\n" 1604 " , public Y {};", 1605 StyleWithInheritanceBreakBeforeComma); 1606 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1607 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1608 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1609 StyleWithInheritanceBreakBeforeComma); 1610 verifyFormat("struct aaaaaaaaaaaaa\n" 1611 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1612 " aaaaaaaaaaaaaaaa> {};", 1613 StyleWithInheritanceBreakBeforeComma); 1614 1615 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1616 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1617 FormatStyle::BILS_AfterColon; 1618 verifyFormat("class MyClass : public X {};", 1619 StyleWithInheritanceBreakAfterColon); 1620 verifyFormat("class MyClass : public X, public Y {};", 1621 StyleWithInheritanceBreakAfterColon); 1622 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1623 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1624 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1625 StyleWithInheritanceBreakAfterColon); 1626 verifyFormat("struct aaaaaaaaaaaaa :\n" 1627 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1628 " aaaaaaaaaaaaaaaa> {};", 1629 StyleWithInheritanceBreakAfterColon); 1630 } 1631 1632 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1633 verifyFormat("class A {\n} a, b;"); 1634 verifyFormat("struct A {\n} a, b;"); 1635 verifyFormat("union A {\n} a;"); 1636 } 1637 1638 TEST_F(FormatTest, FormatsEnum) { 1639 verifyFormat("enum {\n" 1640 " Zero,\n" 1641 " One = 1,\n" 1642 " Two = One + 1,\n" 1643 " Three = (One + Two),\n" 1644 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1645 " Five = (One, Two, Three, Four, 5)\n" 1646 "};"); 1647 verifyGoogleFormat("enum {\n" 1648 " Zero,\n" 1649 " One = 1,\n" 1650 " Two = One + 1,\n" 1651 " Three = (One + Two),\n" 1652 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1653 " Five = (One, Two, Three, Four, 5)\n" 1654 "};"); 1655 verifyFormat("enum Enum {};"); 1656 verifyFormat("enum {};"); 1657 verifyFormat("enum X E {} d;"); 1658 verifyFormat("enum __attribute__((...)) E {} d;"); 1659 verifyFormat("enum __declspec__((...)) E {} d;"); 1660 verifyFormat("enum {\n" 1661 " Bar = Foo<int, int>::value\n" 1662 "};", 1663 getLLVMStyleWithColumns(30)); 1664 1665 verifyFormat("enum ShortEnum { A, B, C };"); 1666 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1667 1668 EXPECT_EQ("enum KeepEmptyLines {\n" 1669 " ONE,\n" 1670 "\n" 1671 " TWO,\n" 1672 "\n" 1673 " THREE\n" 1674 "}", 1675 format("enum KeepEmptyLines {\n" 1676 " ONE,\n" 1677 "\n" 1678 " TWO,\n" 1679 "\n" 1680 "\n" 1681 " THREE\n" 1682 "}")); 1683 verifyFormat("enum E { // comment\n" 1684 " ONE,\n" 1685 " TWO\n" 1686 "};\n" 1687 "int i;"); 1688 // Not enums. 1689 verifyFormat("enum X f() {\n" 1690 " a();\n" 1691 " return 42;\n" 1692 "}"); 1693 verifyFormat("enum X Type::f() {\n" 1694 " a();\n" 1695 " return 42;\n" 1696 "}"); 1697 verifyFormat("enum ::X f() {\n" 1698 " a();\n" 1699 " return 42;\n" 1700 "}"); 1701 verifyFormat("enum ns::X f() {\n" 1702 " a();\n" 1703 " return 42;\n" 1704 "}"); 1705 } 1706 1707 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1708 verifyFormat("enum Type {\n" 1709 " One = 0; // These semicolons should be commas.\n" 1710 " Two = 1;\n" 1711 "};"); 1712 verifyFormat("namespace n {\n" 1713 "enum Type {\n" 1714 " One,\n" 1715 " Two, // missing };\n" 1716 " int i;\n" 1717 "}\n" 1718 "void g() {}"); 1719 } 1720 1721 TEST_F(FormatTest, FormatsEnumStruct) { 1722 verifyFormat("enum struct {\n" 1723 " Zero,\n" 1724 " One = 1,\n" 1725 " Two = One + 1,\n" 1726 " Three = (One + Two),\n" 1727 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1728 " Five = (One, Two, Three, Four, 5)\n" 1729 "};"); 1730 verifyFormat("enum struct Enum {};"); 1731 verifyFormat("enum struct {};"); 1732 verifyFormat("enum struct X E {} d;"); 1733 verifyFormat("enum struct __attribute__((...)) E {} d;"); 1734 verifyFormat("enum struct __declspec__((...)) E {} d;"); 1735 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1736 } 1737 1738 TEST_F(FormatTest, FormatsEnumClass) { 1739 verifyFormat("enum class {\n" 1740 " Zero,\n" 1741 " One = 1,\n" 1742 " Two = One + 1,\n" 1743 " Three = (One + Two),\n" 1744 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1745 " Five = (One, Two, Three, Four, 5)\n" 1746 "};"); 1747 verifyFormat("enum class Enum {};"); 1748 verifyFormat("enum class {};"); 1749 verifyFormat("enum class X E {} d;"); 1750 verifyFormat("enum class __attribute__((...)) E {} d;"); 1751 verifyFormat("enum class __declspec__((...)) E {} d;"); 1752 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 1753 } 1754 1755 TEST_F(FormatTest, FormatsEnumTypes) { 1756 verifyFormat("enum X : int {\n" 1757 " A, // Force multiple lines.\n" 1758 " B\n" 1759 "};"); 1760 verifyFormat("enum X : int { A, B };"); 1761 verifyFormat("enum X : std::uint32_t { A, B };"); 1762 } 1763 1764 TEST_F(FormatTest, FormatsTypedefEnum) { 1765 FormatStyle Style = getLLVMStyle(); 1766 Style.ColumnLimit = 40; 1767 verifyFormat("typedef enum {} EmptyEnum;"); 1768 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1769 verifyFormat("typedef enum {\n" 1770 " ZERO = 0,\n" 1771 " ONE = 1,\n" 1772 " TWO = 2,\n" 1773 " THREE = 3\n" 1774 "} LongEnum;", 1775 Style); 1776 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1777 Style.BraceWrapping.AfterEnum = true; 1778 verifyFormat("typedef enum {} EmptyEnum;"); 1779 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1780 verifyFormat("typedef enum\n" 1781 "{\n" 1782 " ZERO = 0,\n" 1783 " ONE = 1,\n" 1784 " TWO = 2,\n" 1785 " THREE = 3\n" 1786 "} LongEnum;", 1787 Style); 1788 } 1789 1790 TEST_F(FormatTest, FormatsNSEnums) { 1791 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1792 verifyGoogleFormat( 1793 "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1794 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 1795 " // Information about someDecentlyLongValue.\n" 1796 " someDecentlyLongValue,\n" 1797 " // Information about anotherDecentlyLongValue.\n" 1798 " anotherDecentlyLongValue,\n" 1799 " // Information about aThirdDecentlyLongValue.\n" 1800 " aThirdDecentlyLongValue\n" 1801 "};"); 1802 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n" 1803 " // Information about someDecentlyLongValue.\n" 1804 " someDecentlyLongValue,\n" 1805 " // Information about anotherDecentlyLongValue.\n" 1806 " anotherDecentlyLongValue,\n" 1807 " // Information about aThirdDecentlyLongValue.\n" 1808 " aThirdDecentlyLongValue\n" 1809 "};"); 1810 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 1811 " a = 1,\n" 1812 " b = 2,\n" 1813 " c = 3,\n" 1814 "};"); 1815 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 1816 " a = 1,\n" 1817 " b = 2,\n" 1818 " c = 3,\n" 1819 "};"); 1820 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n" 1821 " a = 1,\n" 1822 " b = 2,\n" 1823 " c = 3,\n" 1824 "};"); 1825 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 1826 " a = 1,\n" 1827 " b = 2,\n" 1828 " c = 3,\n" 1829 "};"); 1830 } 1831 1832 TEST_F(FormatTest, FormatsBitfields) { 1833 verifyFormat("struct Bitfields {\n" 1834 " unsigned sClass : 8;\n" 1835 " unsigned ValueKind : 2;\n" 1836 "};"); 1837 verifyFormat("struct A {\n" 1838 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 1839 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 1840 "};"); 1841 verifyFormat("struct MyStruct {\n" 1842 " uchar data;\n" 1843 " uchar : 8;\n" 1844 " uchar : 8;\n" 1845 " uchar other;\n" 1846 "};"); 1847 } 1848 1849 TEST_F(FormatTest, FormatsNamespaces) { 1850 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 1851 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 1852 1853 verifyFormat("namespace some_namespace {\n" 1854 "class A {};\n" 1855 "void f() { f(); }\n" 1856 "}", 1857 LLVMWithNoNamespaceFix); 1858 verifyFormat("namespace N::inline D {\n" 1859 "class A {};\n" 1860 "void f() { f(); }\n" 1861 "}", 1862 LLVMWithNoNamespaceFix); 1863 verifyFormat("namespace N::inline D::E {\n" 1864 "class A {};\n" 1865 "void f() { f(); }\n" 1866 "}", 1867 LLVMWithNoNamespaceFix); 1868 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n" 1869 "class A {};\n" 1870 "void f() { f(); }\n" 1871 "}", 1872 LLVMWithNoNamespaceFix); 1873 verifyFormat("/* something */ namespace some_namespace {\n" 1874 "class A {};\n" 1875 "void f() { f(); }\n" 1876 "}", 1877 LLVMWithNoNamespaceFix); 1878 verifyFormat("namespace {\n" 1879 "class A {};\n" 1880 "void f() { f(); }\n" 1881 "}", 1882 LLVMWithNoNamespaceFix); 1883 verifyFormat("/* something */ namespace {\n" 1884 "class A {};\n" 1885 "void f() { f(); }\n" 1886 "}", 1887 LLVMWithNoNamespaceFix); 1888 verifyFormat("inline namespace X {\n" 1889 "class A {};\n" 1890 "void f() { f(); }\n" 1891 "}", 1892 LLVMWithNoNamespaceFix); 1893 verifyFormat("/* something */ inline namespace X {\n" 1894 "class A {};\n" 1895 "void f() { f(); }\n" 1896 "}", 1897 LLVMWithNoNamespaceFix); 1898 verifyFormat("export namespace X {\n" 1899 "class A {};\n" 1900 "void f() { f(); }\n" 1901 "}", 1902 LLVMWithNoNamespaceFix); 1903 verifyFormat("using namespace some_namespace;\n" 1904 "class A {};\n" 1905 "void f() { f(); }", 1906 LLVMWithNoNamespaceFix); 1907 1908 // This code is more common than we thought; if we 1909 // layout this correctly the semicolon will go into 1910 // its own line, which is undesirable. 1911 verifyFormat("namespace {};", 1912 LLVMWithNoNamespaceFix); 1913 verifyFormat("namespace {\n" 1914 "class A {};\n" 1915 "};", 1916 LLVMWithNoNamespaceFix); 1917 1918 verifyFormat("namespace {\n" 1919 "int SomeVariable = 0; // comment\n" 1920 "} // namespace", 1921 LLVMWithNoNamespaceFix); 1922 EXPECT_EQ("#ifndef HEADER_GUARD\n" 1923 "#define HEADER_GUARD\n" 1924 "namespace my_namespace {\n" 1925 "int i;\n" 1926 "} // my_namespace\n" 1927 "#endif // HEADER_GUARD", 1928 format("#ifndef HEADER_GUARD\n" 1929 " #define HEADER_GUARD\n" 1930 " namespace my_namespace {\n" 1931 "int i;\n" 1932 "} // my_namespace\n" 1933 "#endif // HEADER_GUARD", 1934 LLVMWithNoNamespaceFix)); 1935 1936 EXPECT_EQ("namespace A::B {\n" 1937 "class C {};\n" 1938 "}", 1939 format("namespace A::B {\n" 1940 "class C {};\n" 1941 "}", 1942 LLVMWithNoNamespaceFix)); 1943 1944 FormatStyle Style = getLLVMStyle(); 1945 Style.NamespaceIndentation = FormatStyle::NI_All; 1946 EXPECT_EQ("namespace out {\n" 1947 " int i;\n" 1948 " namespace in {\n" 1949 " int i;\n" 1950 " } // namespace in\n" 1951 "} // namespace out", 1952 format("namespace out {\n" 1953 "int i;\n" 1954 "namespace in {\n" 1955 "int i;\n" 1956 "} // namespace in\n" 1957 "} // namespace out", 1958 Style)); 1959 1960 Style.NamespaceIndentation = FormatStyle::NI_Inner; 1961 EXPECT_EQ("namespace out {\n" 1962 "int i;\n" 1963 "namespace in {\n" 1964 " int i;\n" 1965 "} // namespace in\n" 1966 "} // namespace out", 1967 format("namespace out {\n" 1968 "int i;\n" 1969 "namespace in {\n" 1970 "int i;\n" 1971 "} // namespace in\n" 1972 "} // namespace out", 1973 Style)); 1974 } 1975 1976 TEST_F(FormatTest, NamespaceMacros) { 1977 FormatStyle Style = getLLVMStyle(); 1978 Style.NamespaceMacros.push_back("TESTSUITE"); 1979 1980 verifyFormat("TESTSUITE(A) {\n" 1981 "int foo();\n" 1982 "} // TESTSUITE(A)", 1983 Style); 1984 1985 verifyFormat("TESTSUITE(A, B) {\n" 1986 "int foo();\n" 1987 "} // TESTSUITE(A)", 1988 Style); 1989 1990 // Properly indent according to NamespaceIndentation style 1991 Style.NamespaceIndentation = FormatStyle::NI_All; 1992 verifyFormat("TESTSUITE(A) {\n" 1993 " int foo();\n" 1994 "} // TESTSUITE(A)", 1995 Style); 1996 verifyFormat("TESTSUITE(A) {\n" 1997 " namespace B {\n" 1998 " int foo();\n" 1999 " } // namespace B\n" 2000 "} // TESTSUITE(A)", 2001 Style); 2002 verifyFormat("namespace A {\n" 2003 " TESTSUITE(B) {\n" 2004 " int foo();\n" 2005 " } // TESTSUITE(B)\n" 2006 "} // namespace A", 2007 Style); 2008 2009 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2010 verifyFormat("TESTSUITE(A) {\n" 2011 "TESTSUITE(B) {\n" 2012 " int foo();\n" 2013 "} // TESTSUITE(B)\n" 2014 "} // TESTSUITE(A)", 2015 Style); 2016 verifyFormat("TESTSUITE(A) {\n" 2017 "namespace B {\n" 2018 " int foo();\n" 2019 "} // namespace B\n" 2020 "} // TESTSUITE(A)", 2021 Style); 2022 verifyFormat("namespace A {\n" 2023 "TESTSUITE(B) {\n" 2024 " int foo();\n" 2025 "} // TESTSUITE(B)\n" 2026 "} // namespace A", 2027 Style); 2028 2029 // Properly merge namespace-macros blocks in CompactNamespaces mode 2030 Style.NamespaceIndentation = FormatStyle::NI_None; 2031 Style.CompactNamespaces = true; 2032 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n" 2033 "}} // TESTSUITE(A::B)", 2034 Style); 2035 2036 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2037 "}} // TESTSUITE(out::in)", 2038 format("TESTSUITE(out) {\n" 2039 "TESTSUITE(in) {\n" 2040 "} // TESTSUITE(in)\n" 2041 "} // TESTSUITE(out)", 2042 Style)); 2043 2044 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2045 "}} // TESTSUITE(out::in)", 2046 format("TESTSUITE(out) {\n" 2047 "TESTSUITE(in) {\n" 2048 "} // TESTSUITE(in)\n" 2049 "} // TESTSUITE(out)", 2050 Style)); 2051 2052 // Do not merge different namespaces/macros 2053 EXPECT_EQ("namespace out {\n" 2054 "TESTSUITE(in) {\n" 2055 "} // TESTSUITE(in)\n" 2056 "} // namespace out", 2057 format("namespace out {\n" 2058 "TESTSUITE(in) {\n" 2059 "} // TESTSUITE(in)\n" 2060 "} // namespace out", 2061 Style)); 2062 EXPECT_EQ("TESTSUITE(out) {\n" 2063 "namespace in {\n" 2064 "} // namespace in\n" 2065 "} // TESTSUITE(out)", 2066 format("TESTSUITE(out) {\n" 2067 "namespace in {\n" 2068 "} // namespace in\n" 2069 "} // TESTSUITE(out)", 2070 Style)); 2071 Style.NamespaceMacros.push_back("FOOBAR"); 2072 EXPECT_EQ("TESTSUITE(out) {\n" 2073 "FOOBAR(in) {\n" 2074 "} // FOOBAR(in)\n" 2075 "} // TESTSUITE(out)", 2076 format("TESTSUITE(out) {\n" 2077 "FOOBAR(in) {\n" 2078 "} // FOOBAR(in)\n" 2079 "} // TESTSUITE(out)", 2080 Style)); 2081 } 2082 2083 TEST_F(FormatTest, FormatsCompactNamespaces) { 2084 FormatStyle Style = getLLVMStyle(); 2085 Style.CompactNamespaces = true; 2086 Style.NamespaceMacros.push_back("TESTSUITE"); 2087 2088 verifyFormat("namespace A { namespace B {\n" 2089 "}} // namespace A::B", 2090 Style); 2091 2092 EXPECT_EQ("namespace out { namespace in {\n" 2093 "}} // namespace out::in", 2094 format("namespace out {\n" 2095 "namespace in {\n" 2096 "} // namespace in\n" 2097 "} // namespace out", 2098 Style)); 2099 2100 // Only namespaces which have both consecutive opening and end get compacted 2101 EXPECT_EQ("namespace out {\n" 2102 "namespace in1 {\n" 2103 "} // namespace in1\n" 2104 "namespace in2 {\n" 2105 "} // namespace in2\n" 2106 "} // namespace out", 2107 format("namespace out {\n" 2108 "namespace in1 {\n" 2109 "} // namespace in1\n" 2110 "namespace in2 {\n" 2111 "} // namespace in2\n" 2112 "} // namespace out", 2113 Style)); 2114 2115 EXPECT_EQ("namespace out {\n" 2116 "int i;\n" 2117 "namespace in {\n" 2118 "int j;\n" 2119 "} // namespace in\n" 2120 "int k;\n" 2121 "} // namespace out", 2122 format("namespace out { int i;\n" 2123 "namespace in { int j; } // namespace in\n" 2124 "int k; } // namespace out", 2125 Style)); 2126 2127 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 2128 "}}} // namespace A::B::C\n", 2129 format("namespace A { namespace B {\n" 2130 "namespace C {\n" 2131 "}} // namespace B::C\n" 2132 "} // namespace A\n", 2133 Style)); 2134 2135 Style.ColumnLimit = 40; 2136 EXPECT_EQ("namespace aaaaaaaaaa {\n" 2137 "namespace bbbbbbbbbb {\n" 2138 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 2139 format("namespace aaaaaaaaaa {\n" 2140 "namespace bbbbbbbbbb {\n" 2141 "} // namespace bbbbbbbbbb\n" 2142 "} // namespace aaaaaaaaaa", 2143 Style)); 2144 2145 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 2146 "namespace cccccc {\n" 2147 "}}} // namespace aaaaaa::bbbbbb::cccccc", 2148 format("namespace aaaaaa {\n" 2149 "namespace bbbbbb {\n" 2150 "namespace cccccc {\n" 2151 "} // namespace cccccc\n" 2152 "} // namespace bbbbbb\n" 2153 "} // namespace aaaaaa", 2154 Style)); 2155 Style.ColumnLimit = 80; 2156 2157 // Extra semicolon after 'inner' closing brace prevents merging 2158 EXPECT_EQ("namespace out { namespace in {\n" 2159 "}; } // namespace out::in", 2160 format("namespace out {\n" 2161 "namespace in {\n" 2162 "}; // namespace in\n" 2163 "} // namespace out", 2164 Style)); 2165 2166 // Extra semicolon after 'outer' closing brace is conserved 2167 EXPECT_EQ("namespace out { namespace in {\n" 2168 "}}; // namespace out::in", 2169 format("namespace out {\n" 2170 "namespace in {\n" 2171 "} // namespace in\n" 2172 "}; // namespace out", 2173 Style)); 2174 2175 Style.NamespaceIndentation = FormatStyle::NI_All; 2176 EXPECT_EQ("namespace out { namespace in {\n" 2177 " int i;\n" 2178 "}} // namespace out::in", 2179 format("namespace out {\n" 2180 "namespace in {\n" 2181 "int i;\n" 2182 "} // namespace in\n" 2183 "} // namespace out", 2184 Style)); 2185 EXPECT_EQ("namespace out { namespace mid {\n" 2186 " namespace in {\n" 2187 " int j;\n" 2188 " } // namespace in\n" 2189 " int k;\n" 2190 "}} // namespace out::mid", 2191 format("namespace out { namespace mid {\n" 2192 "namespace in { int j; } // namespace in\n" 2193 "int k; }} // namespace out::mid", 2194 Style)); 2195 2196 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2197 EXPECT_EQ("namespace out { namespace in {\n" 2198 " int i;\n" 2199 "}} // namespace out::in", 2200 format("namespace out {\n" 2201 "namespace in {\n" 2202 "int i;\n" 2203 "} // namespace in\n" 2204 "} // namespace out", 2205 Style)); 2206 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 2207 " int i;\n" 2208 "}}} // namespace out::mid::in", 2209 format("namespace out {\n" 2210 "namespace mid {\n" 2211 "namespace in {\n" 2212 "int i;\n" 2213 "} // namespace in\n" 2214 "} // namespace mid\n" 2215 "} // namespace out", 2216 Style)); 2217 } 2218 2219 TEST_F(FormatTest, FormatsExternC) { 2220 verifyFormat("extern \"C\" {\nint a;"); 2221 verifyFormat("extern \"C\" {}"); 2222 verifyFormat("extern \"C\" {\n" 2223 "int foo();\n" 2224 "}"); 2225 verifyFormat("extern \"C\" int foo() {}"); 2226 verifyFormat("extern \"C\" int foo();"); 2227 verifyFormat("extern \"C\" int foo() {\n" 2228 " int i = 42;\n" 2229 " return i;\n" 2230 "}"); 2231 2232 FormatStyle Style = getLLVMStyle(); 2233 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2234 Style.BraceWrapping.AfterFunction = true; 2235 verifyFormat("extern \"C\" int foo() {}", Style); 2236 verifyFormat("extern \"C\" int foo();", Style); 2237 verifyFormat("extern \"C\" int foo()\n" 2238 "{\n" 2239 " int i = 42;\n" 2240 " return i;\n" 2241 "}", 2242 Style); 2243 2244 Style.BraceWrapping.AfterExternBlock = true; 2245 Style.BraceWrapping.SplitEmptyRecord = false; 2246 verifyFormat("extern \"C\"\n" 2247 "{}", 2248 Style); 2249 verifyFormat("extern \"C\"\n" 2250 "{\n" 2251 " int foo();\n" 2252 "}", 2253 Style); 2254 } 2255 2256 TEST_F(FormatTest, FormatsInlineASM) { 2257 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2258 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2259 verifyFormat( 2260 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2261 " \"cpuid\\n\\t\"\n" 2262 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2263 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2264 " : \"a\"(value));"); 2265 EXPECT_EQ( 2266 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2267 " __asm {\n" 2268 " mov edx,[that] // vtable in edx\n" 2269 " mov eax,methodIndex\n" 2270 " call [edx][eax*4] // stdcall\n" 2271 " }\n" 2272 "}", 2273 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2274 " __asm {\n" 2275 " mov edx,[that] // vtable in edx\n" 2276 " mov eax,methodIndex\n" 2277 " call [edx][eax*4] // stdcall\n" 2278 " }\n" 2279 "}")); 2280 EXPECT_EQ("_asm {\n" 2281 " xor eax, eax;\n" 2282 " cpuid;\n" 2283 "}", 2284 format("_asm {\n" 2285 " xor eax, eax;\n" 2286 " cpuid;\n" 2287 "}")); 2288 verifyFormat("void function() {\n" 2289 " // comment\n" 2290 " asm(\"\");\n" 2291 "}"); 2292 EXPECT_EQ("__asm {\n" 2293 "}\n" 2294 "int i;", 2295 format("__asm {\n" 2296 "}\n" 2297 "int i;")); 2298 } 2299 2300 TEST_F(FormatTest, FormatTryCatch) { 2301 verifyFormat("try {\n" 2302 " throw a * b;\n" 2303 "} catch (int a) {\n" 2304 " // Do nothing.\n" 2305 "} catch (...) {\n" 2306 " exit(42);\n" 2307 "}"); 2308 2309 // Function-level try statements. 2310 verifyFormat("int f() try { return 4; } catch (...) {\n" 2311 " return 5;\n" 2312 "}"); 2313 verifyFormat("class A {\n" 2314 " int a;\n" 2315 " A() try : a(0) {\n" 2316 " } catch (...) {\n" 2317 " throw;\n" 2318 " }\n" 2319 "};\n"); 2320 2321 // Incomplete try-catch blocks. 2322 verifyIncompleteFormat("try {} catch ("); 2323 } 2324 2325 TEST_F(FormatTest, FormatSEHTryCatch) { 2326 verifyFormat("__try {\n" 2327 " int a = b * c;\n" 2328 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2329 " // Do nothing.\n" 2330 "}"); 2331 2332 verifyFormat("__try {\n" 2333 " int a = b * c;\n" 2334 "} __finally {\n" 2335 " // Do nothing.\n" 2336 "}"); 2337 2338 verifyFormat("DEBUG({\n" 2339 " __try {\n" 2340 " } __finally {\n" 2341 " }\n" 2342 "});\n"); 2343 } 2344 2345 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2346 verifyFormat("try {\n" 2347 " f();\n" 2348 "} catch {\n" 2349 " g();\n" 2350 "}"); 2351 verifyFormat("try {\n" 2352 " f();\n" 2353 "} catch (A a) MACRO(x) {\n" 2354 " g();\n" 2355 "} catch (B b) MACRO(x) {\n" 2356 " g();\n" 2357 "}"); 2358 } 2359 2360 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2361 FormatStyle Style = getLLVMStyle(); 2362 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2363 FormatStyle::BS_WebKit}) { 2364 Style.BreakBeforeBraces = BraceStyle; 2365 verifyFormat("try {\n" 2366 " // something\n" 2367 "} catch (...) {\n" 2368 " // something\n" 2369 "}", 2370 Style); 2371 } 2372 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2373 verifyFormat("try {\n" 2374 " // something\n" 2375 "}\n" 2376 "catch (...) {\n" 2377 " // something\n" 2378 "}", 2379 Style); 2380 verifyFormat("__try {\n" 2381 " // something\n" 2382 "}\n" 2383 "__finally {\n" 2384 " // something\n" 2385 "}", 2386 Style); 2387 verifyFormat("@try {\n" 2388 " // something\n" 2389 "}\n" 2390 "@finally {\n" 2391 " // something\n" 2392 "}", 2393 Style); 2394 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2395 verifyFormat("try\n" 2396 "{\n" 2397 " // something\n" 2398 "}\n" 2399 "catch (...)\n" 2400 "{\n" 2401 " // something\n" 2402 "}", 2403 Style); 2404 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2405 verifyFormat("try\n" 2406 " {\n" 2407 " // something\n" 2408 " }\n" 2409 "catch (...)\n" 2410 " {\n" 2411 " // something\n" 2412 " }", 2413 Style); 2414 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2415 Style.BraceWrapping.BeforeCatch = true; 2416 verifyFormat("try {\n" 2417 " // something\n" 2418 "}\n" 2419 "catch (...) {\n" 2420 " // something\n" 2421 "}", 2422 Style); 2423 } 2424 2425 TEST_F(FormatTest, StaticInitializers) { 2426 verifyFormat("static SomeClass SC = {1, 'a'};"); 2427 2428 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2429 " 100000000, " 2430 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2431 2432 // Here, everything other than the "}" would fit on a line. 2433 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2434 " 10000000000000000000000000};"); 2435 EXPECT_EQ("S s = {a,\n" 2436 "\n" 2437 " b};", 2438 format("S s = {\n" 2439 " a,\n" 2440 "\n" 2441 " b\n" 2442 "};")); 2443 2444 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2445 // line. However, the formatting looks a bit off and this probably doesn't 2446 // happen often in practice. 2447 verifyFormat("static int Variable[1] = {\n" 2448 " {1000000000000000000000000000000000000}};", 2449 getLLVMStyleWithColumns(40)); 2450 } 2451 2452 TEST_F(FormatTest, DesignatedInitializers) { 2453 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2454 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2455 " .bbbbbbbbbb = 2,\n" 2456 " .cccccccccc = 3,\n" 2457 " .dddddddddd = 4,\n" 2458 " .eeeeeeeeee = 5};"); 2459 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2460 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2461 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2462 " .ccccccccccccccccccccccccccc = 3,\n" 2463 " .ddddddddddddddddddddddddddd = 4,\n" 2464 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2465 2466 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2467 2468 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2469 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2470 " [2] = bbbbbbbbbb,\n" 2471 " [3] = cccccccccc,\n" 2472 " [4] = dddddddddd,\n" 2473 " [5] = eeeeeeeeee};"); 2474 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2475 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2476 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2477 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2478 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2479 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2480 } 2481 2482 TEST_F(FormatTest, NestedStaticInitializers) { 2483 verifyFormat("static A x = {{{}}};\n"); 2484 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2485 " {init1, init2, init3, init4}}};", 2486 getLLVMStyleWithColumns(50)); 2487 2488 verifyFormat("somes Status::global_reps[3] = {\n" 2489 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2490 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2491 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2492 getLLVMStyleWithColumns(60)); 2493 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2494 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2495 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2496 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2497 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2498 " {rect.fRight - rect.fLeft, rect.fBottom - " 2499 "rect.fTop}};"); 2500 2501 verifyFormat( 2502 "SomeArrayOfSomeType a = {\n" 2503 " {{1, 2, 3},\n" 2504 " {1, 2, 3},\n" 2505 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2506 " 333333333333333333333333333333},\n" 2507 " {1, 2, 3},\n" 2508 " {1, 2, 3}}};"); 2509 verifyFormat( 2510 "SomeArrayOfSomeType a = {\n" 2511 " {{1, 2, 3}},\n" 2512 " {{1, 2, 3}},\n" 2513 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2514 " 333333333333333333333333333333}},\n" 2515 " {{1, 2, 3}},\n" 2516 " {{1, 2, 3}}};"); 2517 2518 verifyFormat("struct {\n" 2519 " unsigned bit;\n" 2520 " const char *const name;\n" 2521 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2522 " {kOsWin, \"Windows\"},\n" 2523 " {kOsLinux, \"Linux\"},\n" 2524 " {kOsCrOS, \"Chrome OS\"}};"); 2525 verifyFormat("struct {\n" 2526 " unsigned bit;\n" 2527 " const char *const name;\n" 2528 "} kBitsToOs[] = {\n" 2529 " {kOsMac, \"Mac\"},\n" 2530 " {kOsWin, \"Windows\"},\n" 2531 " {kOsLinux, \"Linux\"},\n" 2532 " {kOsCrOS, \"Chrome OS\"},\n" 2533 "};"); 2534 } 2535 2536 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2537 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2538 " \\\n" 2539 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2540 } 2541 2542 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2543 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2544 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2545 2546 // Do break defaulted and deleted functions. 2547 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2548 " default;", 2549 getLLVMStyleWithColumns(40)); 2550 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2551 " delete;", 2552 getLLVMStyleWithColumns(40)); 2553 } 2554 2555 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2556 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2557 getLLVMStyleWithColumns(40)); 2558 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2559 getLLVMStyleWithColumns(40)); 2560 EXPECT_EQ("#define Q \\\n" 2561 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2562 " \"aaaaaaaa.cpp\"", 2563 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2564 getLLVMStyleWithColumns(40))); 2565 } 2566 2567 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2568 EXPECT_EQ("# 123 \"A string literal\"", 2569 format(" # 123 \"A string literal\"")); 2570 } 2571 2572 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2573 EXPECT_EQ("#;", format("#;")); 2574 verifyFormat("#\n;\n;\n;"); 2575 } 2576 2577 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2578 EXPECT_EQ("#line 42 \"test\"\n", 2579 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2580 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2581 getLLVMStyleWithColumns(12))); 2582 } 2583 2584 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2585 EXPECT_EQ("#line 42 \"test\"", 2586 format("# \\\n line \\\n 42 \\\n \"test\"")); 2587 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2588 } 2589 2590 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2591 verifyFormat("#define A \\x20"); 2592 verifyFormat("#define A \\ x20"); 2593 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2594 verifyFormat("#define A ''"); 2595 verifyFormat("#define A ''qqq"); 2596 verifyFormat("#define A `qqq"); 2597 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2598 EXPECT_EQ("const char *c = STRINGIFY(\n" 2599 "\\na : b);", 2600 format("const char * c = STRINGIFY(\n" 2601 "\\na : b);")); 2602 2603 verifyFormat("a\r\\"); 2604 verifyFormat("a\v\\"); 2605 verifyFormat("a\f\\"); 2606 } 2607 2608 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2609 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2610 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2611 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2612 // FIXME: We never break before the macro name. 2613 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2614 2615 verifyFormat("#define A A\n#define A A"); 2616 verifyFormat("#define A(X) A\n#define A A"); 2617 2618 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2619 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2620 } 2621 2622 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2623 EXPECT_EQ("// somecomment\n" 2624 "#include \"a.h\"\n" 2625 "#define A( \\\n" 2626 " A, B)\n" 2627 "#include \"b.h\"\n" 2628 "// somecomment\n", 2629 format(" // somecomment\n" 2630 " #include \"a.h\"\n" 2631 "#define A(A,\\\n" 2632 " B)\n" 2633 " #include \"b.h\"\n" 2634 " // somecomment\n", 2635 getLLVMStyleWithColumns(13))); 2636 } 2637 2638 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2639 2640 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2641 EXPECT_EQ("#define A \\\n" 2642 " c; \\\n" 2643 " e;\n" 2644 "f;", 2645 format("#define A c; e;\n" 2646 "f;", 2647 getLLVMStyleWithColumns(14))); 2648 } 2649 2650 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2651 2652 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2653 EXPECT_EQ("int x,\n" 2654 "#define A\n" 2655 " y;", 2656 format("int x,\n#define A\ny;")); 2657 } 2658 2659 TEST_F(FormatTest, HashInMacroDefinition) { 2660 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2661 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2662 verifyFormat("#define A \\\n" 2663 " { \\\n" 2664 " f(#c); \\\n" 2665 " }", 2666 getLLVMStyleWithColumns(11)); 2667 2668 verifyFormat("#define A(X) \\\n" 2669 " void function##X()", 2670 getLLVMStyleWithColumns(22)); 2671 2672 verifyFormat("#define A(a, b, c) \\\n" 2673 " void a##b##c()", 2674 getLLVMStyleWithColumns(22)); 2675 2676 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2677 } 2678 2679 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2680 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2681 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2682 2683 FormatStyle Style = getLLVMStyle(); 2684 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 2685 verifyFormat("#define true ((foo)1)", Style); 2686 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 2687 verifyFormat("#define false((foo)0)", Style); 2688 } 2689 2690 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2691 EXPECT_EQ("#define A b;", format("#define A \\\n" 2692 " \\\n" 2693 " b;", 2694 getLLVMStyleWithColumns(25))); 2695 EXPECT_EQ("#define A \\\n" 2696 " \\\n" 2697 " a; \\\n" 2698 " b;", 2699 format("#define A \\\n" 2700 " \\\n" 2701 " a; \\\n" 2702 " b;", 2703 getLLVMStyleWithColumns(11))); 2704 EXPECT_EQ("#define A \\\n" 2705 " a; \\\n" 2706 " \\\n" 2707 " b;", 2708 format("#define A \\\n" 2709 " a; \\\n" 2710 " \\\n" 2711 " b;", 2712 getLLVMStyleWithColumns(11))); 2713 } 2714 2715 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 2716 verifyIncompleteFormat("#define A :"); 2717 verifyFormat("#define SOMECASES \\\n" 2718 " case 1: \\\n" 2719 " case 2\n", 2720 getLLVMStyleWithColumns(20)); 2721 verifyFormat("#define MACRO(a) \\\n" 2722 " if (a) \\\n" 2723 " f(); \\\n" 2724 " else \\\n" 2725 " g()", 2726 getLLVMStyleWithColumns(18)); 2727 verifyFormat("#define A template <typename T>"); 2728 verifyIncompleteFormat("#define STR(x) #x\n" 2729 "f(STR(this_is_a_string_literal{));"); 2730 verifyFormat("#pragma omp threadprivate( \\\n" 2731 " y)), // expected-warning", 2732 getLLVMStyleWithColumns(28)); 2733 verifyFormat("#d, = };"); 2734 verifyFormat("#if \"a"); 2735 verifyIncompleteFormat("({\n" 2736 "#define b \\\n" 2737 " } \\\n" 2738 " a\n" 2739 "a", 2740 getLLVMStyleWithColumns(15)); 2741 verifyFormat("#define A \\\n" 2742 " { \\\n" 2743 " {\n" 2744 "#define B \\\n" 2745 " } \\\n" 2746 " }", 2747 getLLVMStyleWithColumns(15)); 2748 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 2749 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 2750 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 2751 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 2752 } 2753 2754 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 2755 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 2756 EXPECT_EQ("class A : public QObject {\n" 2757 " Q_OBJECT\n" 2758 "\n" 2759 " A() {}\n" 2760 "};", 2761 format("class A : public QObject {\n" 2762 " Q_OBJECT\n" 2763 "\n" 2764 " A() {\n}\n" 2765 "} ;")); 2766 EXPECT_EQ("MACRO\n" 2767 "/*static*/ int i;", 2768 format("MACRO\n" 2769 " /*static*/ int i;")); 2770 EXPECT_EQ("SOME_MACRO\n" 2771 "namespace {\n" 2772 "void f();\n" 2773 "} // namespace", 2774 format("SOME_MACRO\n" 2775 " namespace {\n" 2776 "void f( );\n" 2777 "} // namespace")); 2778 // Only if the identifier contains at least 5 characters. 2779 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 2780 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 2781 // Only if everything is upper case. 2782 EXPECT_EQ("class A : public QObject {\n" 2783 " Q_Object A() {}\n" 2784 "};", 2785 format("class A : public QObject {\n" 2786 " Q_Object\n" 2787 " A() {\n}\n" 2788 "} ;")); 2789 2790 // Only if the next line can actually start an unwrapped line. 2791 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 2792 format("SOME_WEIRD_LOG_MACRO\n" 2793 "<< SomeThing;")); 2794 2795 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 2796 "(n, buffers))\n", 2797 getChromiumStyle(FormatStyle::LK_Cpp)); 2798 2799 // See PR41483 2800 EXPECT_EQ("/**/ FOO(a)\n" 2801 "FOO(b)", 2802 format("/**/ FOO(a)\n" 2803 "FOO(b)")); 2804 } 2805 2806 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 2807 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2808 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2809 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2810 "class X {};\n" 2811 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2812 "int *createScopDetectionPass() { return 0; }", 2813 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2814 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2815 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2816 " class X {};\n" 2817 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2818 " int *createScopDetectionPass() { return 0; }")); 2819 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 2820 // braces, so that inner block is indented one level more. 2821 EXPECT_EQ("int q() {\n" 2822 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2823 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2824 " IPC_END_MESSAGE_MAP()\n" 2825 "}", 2826 format("int q() {\n" 2827 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2828 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2829 " IPC_END_MESSAGE_MAP()\n" 2830 "}")); 2831 2832 // Same inside macros. 2833 EXPECT_EQ("#define LIST(L) \\\n" 2834 " L(A) \\\n" 2835 " L(B) \\\n" 2836 " L(C)", 2837 format("#define LIST(L) \\\n" 2838 " L(A) \\\n" 2839 " L(B) \\\n" 2840 " L(C)", 2841 getGoogleStyle())); 2842 2843 // These must not be recognized as macros. 2844 EXPECT_EQ("int q() {\n" 2845 " f(x);\n" 2846 " f(x) {}\n" 2847 " f(x)->g();\n" 2848 " f(x)->*g();\n" 2849 " f(x).g();\n" 2850 " f(x) = x;\n" 2851 " f(x) += x;\n" 2852 " f(x) -= x;\n" 2853 " f(x) *= x;\n" 2854 " f(x) /= x;\n" 2855 " f(x) %= x;\n" 2856 " f(x) &= x;\n" 2857 " f(x) |= x;\n" 2858 " f(x) ^= x;\n" 2859 " f(x) >>= x;\n" 2860 " f(x) <<= x;\n" 2861 " f(x)[y].z();\n" 2862 " LOG(INFO) << x;\n" 2863 " ifstream(x) >> x;\n" 2864 "}\n", 2865 format("int q() {\n" 2866 " f(x)\n;\n" 2867 " f(x)\n {}\n" 2868 " f(x)\n->g();\n" 2869 " f(x)\n->*g();\n" 2870 " f(x)\n.g();\n" 2871 " f(x)\n = x;\n" 2872 " f(x)\n += x;\n" 2873 " f(x)\n -= x;\n" 2874 " f(x)\n *= x;\n" 2875 " f(x)\n /= x;\n" 2876 " f(x)\n %= x;\n" 2877 " f(x)\n &= x;\n" 2878 " f(x)\n |= x;\n" 2879 " f(x)\n ^= x;\n" 2880 " f(x)\n >>= x;\n" 2881 " f(x)\n <<= x;\n" 2882 " f(x)\n[y].z();\n" 2883 " LOG(INFO)\n << x;\n" 2884 " ifstream(x)\n >> x;\n" 2885 "}\n")); 2886 EXPECT_EQ("int q() {\n" 2887 " F(x)\n" 2888 " if (1) {\n" 2889 " }\n" 2890 " F(x)\n" 2891 " while (1) {\n" 2892 " }\n" 2893 " F(x)\n" 2894 " G(x);\n" 2895 " F(x)\n" 2896 " try {\n" 2897 " Q();\n" 2898 " } catch (...) {\n" 2899 " }\n" 2900 "}\n", 2901 format("int q() {\n" 2902 "F(x)\n" 2903 "if (1) {}\n" 2904 "F(x)\n" 2905 "while (1) {}\n" 2906 "F(x)\n" 2907 "G(x);\n" 2908 "F(x)\n" 2909 "try { Q(); } catch (...) {}\n" 2910 "}\n")); 2911 EXPECT_EQ("class A {\n" 2912 " A() : t(0) {}\n" 2913 " A(int i) noexcept() : {}\n" 2914 " A(X x)\n" // FIXME: function-level try blocks are broken. 2915 " try : t(0) {\n" 2916 " } catch (...) {\n" 2917 " }\n" 2918 "};", 2919 format("class A {\n" 2920 " A()\n : t(0) {}\n" 2921 " A(int i)\n noexcept() : {}\n" 2922 " A(X x)\n" 2923 " try : t(0) {} catch (...) {}\n" 2924 "};")); 2925 FormatStyle Style = getLLVMStyle(); 2926 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2927 Style.BraceWrapping.AfterControlStatement = true; 2928 Style.BraceWrapping.AfterFunction = true; 2929 EXPECT_EQ("void f()\n" 2930 "try\n" 2931 "{\n" 2932 "}", 2933 format("void f() try {\n" 2934 "}", Style)); 2935 EXPECT_EQ("class SomeClass {\n" 2936 "public:\n" 2937 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2938 "};", 2939 format("class SomeClass {\n" 2940 "public:\n" 2941 " SomeClass()\n" 2942 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2943 "};")); 2944 EXPECT_EQ("class SomeClass {\n" 2945 "public:\n" 2946 " SomeClass()\n" 2947 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2948 "};", 2949 format("class SomeClass {\n" 2950 "public:\n" 2951 " SomeClass()\n" 2952 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2953 "};", 2954 getLLVMStyleWithColumns(40))); 2955 2956 verifyFormat("MACRO(>)"); 2957 2958 // Some macros contain an implicit semicolon. 2959 Style = getLLVMStyle(); 2960 Style.StatementMacros.push_back("FOO"); 2961 verifyFormat("FOO(a) int b = 0;"); 2962 verifyFormat("FOO(a)\n" 2963 "int b = 0;", 2964 Style); 2965 verifyFormat("FOO(a);\n" 2966 "int b = 0;", 2967 Style); 2968 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 2969 "int b = 0;", 2970 Style); 2971 verifyFormat("FOO()\n" 2972 "int b = 0;", 2973 Style); 2974 verifyFormat("FOO\n" 2975 "int b = 0;", 2976 Style); 2977 verifyFormat("void f() {\n" 2978 " FOO(a)\n" 2979 " return a;\n" 2980 "}", 2981 Style); 2982 verifyFormat("FOO(a)\n" 2983 "FOO(b)", 2984 Style); 2985 verifyFormat("int a = 0;\n" 2986 "FOO(b)\n" 2987 "int c = 0;", 2988 Style); 2989 verifyFormat("int a = 0;\n" 2990 "int x = FOO(a)\n" 2991 "int b = 0;", 2992 Style); 2993 verifyFormat("void foo(int a) { FOO(a) }\n" 2994 "uint32_t bar() {}", 2995 Style); 2996 } 2997 2998 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 2999 verifyFormat("#define A \\\n" 3000 " f({ \\\n" 3001 " g(); \\\n" 3002 " });", 3003 getLLVMStyleWithColumns(11)); 3004 } 3005 3006 TEST_F(FormatTest, IndentPreprocessorDirectives) { 3007 FormatStyle Style = getLLVMStyle(); 3008 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 3009 Style.ColumnLimit = 40; 3010 verifyFormat("#ifdef _WIN32\n" 3011 "#define A 0\n" 3012 "#ifdef VAR2\n" 3013 "#define B 1\n" 3014 "#include <someheader.h>\n" 3015 "#define MACRO \\\n" 3016 " some_very_long_func_aaaaaaaaaa();\n" 3017 "#endif\n" 3018 "#else\n" 3019 "#define A 1\n" 3020 "#endif", 3021 Style); 3022 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 3023 verifyFormat("#ifdef _WIN32\n" 3024 "# define A 0\n" 3025 "# ifdef VAR2\n" 3026 "# define B 1\n" 3027 "# include <someheader.h>\n" 3028 "# define MACRO \\\n" 3029 " some_very_long_func_aaaaaaaaaa();\n" 3030 "# endif\n" 3031 "#else\n" 3032 "# define A 1\n" 3033 "#endif", 3034 Style); 3035 verifyFormat("#if A\n" 3036 "# define MACRO \\\n" 3037 " void a(int x) { \\\n" 3038 " b(); \\\n" 3039 " c(); \\\n" 3040 " d(); \\\n" 3041 " e(); \\\n" 3042 " f(); \\\n" 3043 " }\n" 3044 "#endif", 3045 Style); 3046 // Comments before include guard. 3047 verifyFormat("// file comment\n" 3048 "// file comment\n" 3049 "#ifndef HEADER_H\n" 3050 "#define HEADER_H\n" 3051 "code();\n" 3052 "#endif", 3053 Style); 3054 // Test with include guards. 3055 verifyFormat("#ifndef HEADER_H\n" 3056 "#define HEADER_H\n" 3057 "code();\n" 3058 "#endif", 3059 Style); 3060 // Include guards must have a #define with the same variable immediately 3061 // after #ifndef. 3062 verifyFormat("#ifndef NOT_GUARD\n" 3063 "# define FOO\n" 3064 "code();\n" 3065 "#endif", 3066 Style); 3067 3068 // Include guards must cover the entire file. 3069 verifyFormat("code();\n" 3070 "code();\n" 3071 "#ifndef NOT_GUARD\n" 3072 "# define NOT_GUARD\n" 3073 "code();\n" 3074 "#endif", 3075 Style); 3076 verifyFormat("#ifndef NOT_GUARD\n" 3077 "# define NOT_GUARD\n" 3078 "code();\n" 3079 "#endif\n" 3080 "code();", 3081 Style); 3082 // Test with trailing blank lines. 3083 verifyFormat("#ifndef HEADER_H\n" 3084 "#define HEADER_H\n" 3085 "code();\n" 3086 "#endif\n", 3087 Style); 3088 // Include guards don't have #else. 3089 verifyFormat("#ifndef NOT_GUARD\n" 3090 "# define NOT_GUARD\n" 3091 "code();\n" 3092 "#else\n" 3093 "#endif", 3094 Style); 3095 verifyFormat("#ifndef NOT_GUARD\n" 3096 "# define NOT_GUARD\n" 3097 "code();\n" 3098 "#elif FOO\n" 3099 "#endif", 3100 Style); 3101 // Non-identifier #define after potential include guard. 3102 verifyFormat("#ifndef FOO\n" 3103 "# define 1\n" 3104 "#endif\n", 3105 Style); 3106 // #if closes past last non-preprocessor line. 3107 verifyFormat("#ifndef FOO\n" 3108 "#define FOO\n" 3109 "#if 1\n" 3110 "int i;\n" 3111 "# define A 0\n" 3112 "#endif\n" 3113 "#endif\n", 3114 Style); 3115 // Don't crash if there is an #elif directive without a condition. 3116 verifyFormat("#if 1\n" 3117 "int x;\n" 3118 "#elif\n" 3119 "int y;\n" 3120 "#else\n" 3121 "int z;\n" 3122 "#endif", 3123 Style); 3124 // FIXME: This doesn't handle the case where there's code between the 3125 // #ifndef and #define but all other conditions hold. This is because when 3126 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 3127 // previous code line yet, so we can't detect it. 3128 EXPECT_EQ("#ifndef NOT_GUARD\n" 3129 "code();\n" 3130 "#define NOT_GUARD\n" 3131 "code();\n" 3132 "#endif", 3133 format("#ifndef NOT_GUARD\n" 3134 "code();\n" 3135 "# define NOT_GUARD\n" 3136 "code();\n" 3137 "#endif", 3138 Style)); 3139 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 3140 // be outside an include guard. Examples are #pragma once and 3141 // #pragma GCC diagnostic, or anything else that does not change the meaning 3142 // of the file if it's included multiple times. 3143 EXPECT_EQ("#ifdef WIN32\n" 3144 "# pragma once\n" 3145 "#endif\n" 3146 "#ifndef HEADER_H\n" 3147 "# define HEADER_H\n" 3148 "code();\n" 3149 "#endif", 3150 format("#ifdef WIN32\n" 3151 "# pragma once\n" 3152 "#endif\n" 3153 "#ifndef HEADER_H\n" 3154 "#define HEADER_H\n" 3155 "code();\n" 3156 "#endif", 3157 Style)); 3158 // FIXME: This does not detect when there is a single non-preprocessor line 3159 // in front of an include-guard-like structure where other conditions hold 3160 // because ScopedLineState hides the line. 3161 EXPECT_EQ("code();\n" 3162 "#ifndef HEADER_H\n" 3163 "#define HEADER_H\n" 3164 "code();\n" 3165 "#endif", 3166 format("code();\n" 3167 "#ifndef HEADER_H\n" 3168 "# define HEADER_H\n" 3169 "code();\n" 3170 "#endif", 3171 Style)); 3172 // Keep comments aligned with #, otherwise indent comments normally. These 3173 // tests cannot use verifyFormat because messUp manipulates leading 3174 // whitespace. 3175 { 3176 const char *Expected = "" 3177 "void f() {\n" 3178 "#if 1\n" 3179 "// Preprocessor aligned.\n" 3180 "# define A 0\n" 3181 " // Code. Separated by blank line.\n" 3182 "\n" 3183 "# define B 0\n" 3184 " // Code. Not aligned with #\n" 3185 "# define C 0\n" 3186 "#endif"; 3187 const char *ToFormat = "" 3188 "void f() {\n" 3189 "#if 1\n" 3190 "// Preprocessor aligned.\n" 3191 "# define A 0\n" 3192 "// Code. Separated by blank line.\n" 3193 "\n" 3194 "# define B 0\n" 3195 " // Code. Not aligned with #\n" 3196 "# define C 0\n" 3197 "#endif"; 3198 EXPECT_EQ(Expected, format(ToFormat, Style)); 3199 EXPECT_EQ(Expected, format(Expected, Style)); 3200 } 3201 // Keep block quotes aligned. 3202 { 3203 const char *Expected = "" 3204 "void f() {\n" 3205 "#if 1\n" 3206 "/* Preprocessor aligned. */\n" 3207 "# define A 0\n" 3208 " /* Code. Separated by blank line. */\n" 3209 "\n" 3210 "# define B 0\n" 3211 " /* Code. Not aligned with # */\n" 3212 "# define C 0\n" 3213 "#endif"; 3214 const char *ToFormat = "" 3215 "void f() {\n" 3216 "#if 1\n" 3217 "/* Preprocessor aligned. */\n" 3218 "# define A 0\n" 3219 "/* Code. Separated by blank line. */\n" 3220 "\n" 3221 "# define B 0\n" 3222 " /* Code. Not aligned with # */\n" 3223 "# define C 0\n" 3224 "#endif"; 3225 EXPECT_EQ(Expected, format(ToFormat, Style)); 3226 EXPECT_EQ(Expected, format(Expected, Style)); 3227 } 3228 // Keep comments aligned with un-indented directives. 3229 { 3230 const char *Expected = "" 3231 "void f() {\n" 3232 "// Preprocessor aligned.\n" 3233 "#define A 0\n" 3234 " // Code. Separated by blank line.\n" 3235 "\n" 3236 "#define B 0\n" 3237 " // Code. Not aligned with #\n" 3238 "#define C 0\n"; 3239 const char *ToFormat = "" 3240 "void f() {\n" 3241 "// Preprocessor aligned.\n" 3242 "#define A 0\n" 3243 "// Code. Separated by blank line.\n" 3244 "\n" 3245 "#define B 0\n" 3246 " // Code. Not aligned with #\n" 3247 "#define C 0\n"; 3248 EXPECT_EQ(Expected, format(ToFormat, Style)); 3249 EXPECT_EQ(Expected, format(Expected, Style)); 3250 } 3251 // Test AfterHash with tabs. 3252 { 3253 FormatStyle Tabbed = Style; 3254 Tabbed.UseTab = FormatStyle::UT_Always; 3255 Tabbed.IndentWidth = 8; 3256 Tabbed.TabWidth = 8; 3257 verifyFormat("#ifdef _WIN32\n" 3258 "#\tdefine A 0\n" 3259 "#\tifdef VAR2\n" 3260 "#\t\tdefine B 1\n" 3261 "#\t\tinclude <someheader.h>\n" 3262 "#\t\tdefine MACRO \\\n" 3263 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3264 "#\tendif\n" 3265 "#else\n" 3266 "#\tdefine A 1\n" 3267 "#endif", 3268 Tabbed); 3269 } 3270 3271 // Regression test: Multiline-macro inside include guards. 3272 verifyFormat("#ifndef HEADER_H\n" 3273 "#define HEADER_H\n" 3274 "#define A() \\\n" 3275 " int i; \\\n" 3276 " int j;\n" 3277 "#endif // HEADER_H", 3278 getLLVMStyleWithColumns(20)); 3279 3280 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3281 // Basic before hash indent tests 3282 verifyFormat("#ifdef _WIN32\n" 3283 " #define A 0\n" 3284 " #ifdef VAR2\n" 3285 " #define B 1\n" 3286 " #include <someheader.h>\n" 3287 " #define MACRO \\\n" 3288 " some_very_long_func_aaaaaaaaaa();\n" 3289 " #endif\n" 3290 "#else\n" 3291 " #define A 1\n" 3292 "#endif", 3293 Style); 3294 verifyFormat("#if A\n" 3295 " #define MACRO \\\n" 3296 " void a(int x) { \\\n" 3297 " b(); \\\n" 3298 " c(); \\\n" 3299 " d(); \\\n" 3300 " e(); \\\n" 3301 " f(); \\\n" 3302 " }\n" 3303 "#endif", 3304 Style); 3305 // Keep comments aligned with indented directives. These 3306 // tests cannot use verifyFormat because messUp manipulates leading 3307 // whitespace. 3308 { 3309 const char *Expected = "void f() {\n" 3310 "// Aligned to preprocessor.\n" 3311 "#if 1\n" 3312 " // Aligned to code.\n" 3313 " int a;\n" 3314 " #if 1\n" 3315 " // Aligned to preprocessor.\n" 3316 " #define A 0\n" 3317 " // Aligned to code.\n" 3318 " int b;\n" 3319 " #endif\n" 3320 "#endif\n" 3321 "}"; 3322 const char *ToFormat = "void f() {\n" 3323 "// Aligned to preprocessor.\n" 3324 "#if 1\n" 3325 "// Aligned to code.\n" 3326 "int a;\n" 3327 "#if 1\n" 3328 "// Aligned to preprocessor.\n" 3329 "#define A 0\n" 3330 "// Aligned to code.\n" 3331 "int b;\n" 3332 "#endif\n" 3333 "#endif\n" 3334 "}"; 3335 EXPECT_EQ(Expected, format(ToFormat, Style)); 3336 EXPECT_EQ(Expected, format(Expected, Style)); 3337 } 3338 { 3339 const char *Expected = "void f() {\n" 3340 "/* Aligned to preprocessor. */\n" 3341 "#if 1\n" 3342 " /* Aligned to code. */\n" 3343 " int a;\n" 3344 " #if 1\n" 3345 " /* Aligned to preprocessor. */\n" 3346 " #define A 0\n" 3347 " /* Aligned to code. */\n" 3348 " int b;\n" 3349 " #endif\n" 3350 "#endif\n" 3351 "}"; 3352 const char *ToFormat = "void f() {\n" 3353 "/* Aligned to preprocessor. */\n" 3354 "#if 1\n" 3355 "/* Aligned to code. */\n" 3356 "int a;\n" 3357 "#if 1\n" 3358 "/* Aligned to preprocessor. */\n" 3359 "#define A 0\n" 3360 "/* Aligned to code. */\n" 3361 "int b;\n" 3362 "#endif\n" 3363 "#endif\n" 3364 "}"; 3365 EXPECT_EQ(Expected, format(ToFormat, Style)); 3366 EXPECT_EQ(Expected, format(Expected, Style)); 3367 } 3368 3369 // Test single comment before preprocessor 3370 verifyFormat("// Comment\n" 3371 "\n" 3372 "#if 1\n" 3373 "#endif", 3374 Style); 3375 } 3376 3377 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3378 verifyFormat("{\n { a #c; }\n}"); 3379 } 3380 3381 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3382 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3383 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3384 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3385 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3386 } 3387 3388 TEST_F(FormatTest, EscapedNewlines) { 3389 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3390 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3391 format("#define A \\\nint i;\\\n int j;", Narrow)); 3392 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3393 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3394 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3395 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3396 3397 FormatStyle AlignLeft = getLLVMStyle(); 3398 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3399 EXPECT_EQ("#define MACRO(x) \\\n" 3400 "private: \\\n" 3401 " int x(int a);\n", 3402 format("#define MACRO(x) \\\n" 3403 "private: \\\n" 3404 " int x(int a);\n", 3405 AlignLeft)); 3406 3407 // CRLF line endings 3408 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3409 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3410 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3411 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3412 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3413 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3414 EXPECT_EQ("#define MACRO(x) \\\r\n" 3415 "private: \\\r\n" 3416 " int x(int a);\r\n", 3417 format("#define MACRO(x) \\\r\n" 3418 "private: \\\r\n" 3419 " int x(int a);\r\n", 3420 AlignLeft)); 3421 3422 FormatStyle DontAlign = getLLVMStyle(); 3423 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3424 DontAlign.MaxEmptyLinesToKeep = 3; 3425 // FIXME: can't use verifyFormat here because the newline before 3426 // "public:" is not inserted the first time it's reformatted 3427 EXPECT_EQ("#define A \\\n" 3428 " class Foo { \\\n" 3429 " void bar(); \\\n" 3430 "\\\n" 3431 "\\\n" 3432 "\\\n" 3433 " public: \\\n" 3434 " void baz(); \\\n" 3435 " };", 3436 format("#define A \\\n" 3437 " class Foo { \\\n" 3438 " void bar(); \\\n" 3439 "\\\n" 3440 "\\\n" 3441 "\\\n" 3442 " public: \\\n" 3443 " void baz(); \\\n" 3444 " };", 3445 DontAlign)); 3446 } 3447 3448 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3449 verifyFormat("#define A \\\n" 3450 " int v( \\\n" 3451 " a); \\\n" 3452 " int i;", 3453 getLLVMStyleWithColumns(11)); 3454 } 3455 3456 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3457 EXPECT_EQ( 3458 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3459 " \\\n" 3460 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3461 "\n" 3462 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3463 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3464 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3465 "\\\n" 3466 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3467 " \n" 3468 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3469 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3470 } 3471 3472 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3473 EXPECT_EQ("int\n" 3474 "#define A\n" 3475 " a;", 3476 format("int\n#define A\na;")); 3477 verifyFormat("functionCallTo(\n" 3478 " someOtherFunction(\n" 3479 " withSomeParameters, whichInSequence,\n" 3480 " areLongerThanALine(andAnotherCall,\n" 3481 "#define A B\n" 3482 " withMoreParamters,\n" 3483 " whichStronglyInfluenceTheLayout),\n" 3484 " andMoreParameters),\n" 3485 " trailing);", 3486 getLLVMStyleWithColumns(69)); 3487 verifyFormat("Foo::Foo()\n" 3488 "#ifdef BAR\n" 3489 " : baz(0)\n" 3490 "#endif\n" 3491 "{\n" 3492 "}"); 3493 verifyFormat("void f() {\n" 3494 " if (true)\n" 3495 "#ifdef A\n" 3496 " f(42);\n" 3497 " x();\n" 3498 "#else\n" 3499 " g();\n" 3500 " x();\n" 3501 "#endif\n" 3502 "}"); 3503 verifyFormat("void f(param1, param2,\n" 3504 " param3,\n" 3505 "#ifdef A\n" 3506 " param4(param5,\n" 3507 "#ifdef A1\n" 3508 " param6,\n" 3509 "#ifdef A2\n" 3510 " param7),\n" 3511 "#else\n" 3512 " param8),\n" 3513 " param9,\n" 3514 "#endif\n" 3515 " param10,\n" 3516 "#endif\n" 3517 " param11)\n" 3518 "#else\n" 3519 " param12)\n" 3520 "#endif\n" 3521 "{\n" 3522 " x();\n" 3523 "}", 3524 getLLVMStyleWithColumns(28)); 3525 verifyFormat("#if 1\n" 3526 "int i;"); 3527 verifyFormat("#if 1\n" 3528 "#endif\n" 3529 "#if 1\n" 3530 "#else\n" 3531 "#endif\n"); 3532 verifyFormat("DEBUG({\n" 3533 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3534 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3535 "});\n" 3536 "#if a\n" 3537 "#else\n" 3538 "#endif"); 3539 3540 verifyIncompleteFormat("void f(\n" 3541 "#if A\n" 3542 ");\n" 3543 "#else\n" 3544 "#endif"); 3545 } 3546 3547 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3548 verifyFormat("#endif\n" 3549 "#if B"); 3550 } 3551 3552 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3553 FormatStyle SingleLine = getLLVMStyle(); 3554 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3555 verifyFormat("#if 0\n" 3556 "#elif 1\n" 3557 "#endif\n" 3558 "void foo() {\n" 3559 " if (test) foo2();\n" 3560 "}", 3561 SingleLine); 3562 } 3563 3564 TEST_F(FormatTest, LayoutBlockInsideParens) { 3565 verifyFormat("functionCall({ int i; });"); 3566 verifyFormat("functionCall({\n" 3567 " int i;\n" 3568 " int j;\n" 3569 "});"); 3570 verifyFormat("functionCall(\n" 3571 " {\n" 3572 " int i;\n" 3573 " int j;\n" 3574 " },\n" 3575 " aaaa, bbbb, cccc);"); 3576 verifyFormat("functionA(functionB({\n" 3577 " int i;\n" 3578 " int j;\n" 3579 " }),\n" 3580 " aaaa, bbbb, cccc);"); 3581 verifyFormat("functionCall(\n" 3582 " {\n" 3583 " int i;\n" 3584 " int j;\n" 3585 " },\n" 3586 " aaaa, bbbb, // comment\n" 3587 " cccc);"); 3588 verifyFormat("functionA(functionB({\n" 3589 " int i;\n" 3590 " int j;\n" 3591 " }),\n" 3592 " aaaa, bbbb, // comment\n" 3593 " cccc);"); 3594 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3595 verifyFormat("functionCall(aaaa, bbbb, {\n" 3596 " int i;\n" 3597 " int j;\n" 3598 "});"); 3599 verifyFormat( 3600 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3601 " {\n" 3602 " int i; // break\n" 3603 " },\n" 3604 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3605 " ccccccccccccccccc));"); 3606 verifyFormat("DEBUG({\n" 3607 " if (a)\n" 3608 " f();\n" 3609 "});"); 3610 } 3611 3612 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3613 EXPECT_EQ("SOME_MACRO { int i; }\n" 3614 "int i;", 3615 format(" SOME_MACRO {int i;} int i;")); 3616 } 3617 3618 TEST_F(FormatTest, LayoutNestedBlocks) { 3619 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3620 " struct s {\n" 3621 " int i;\n" 3622 " };\n" 3623 " s kBitsToOs[] = {{10}};\n" 3624 " for (int i = 0; i < 10; ++i)\n" 3625 " return;\n" 3626 "}"); 3627 verifyFormat("call(parameter, {\n" 3628 " something();\n" 3629 " // Comment using all columns.\n" 3630 " somethingelse();\n" 3631 "});", 3632 getLLVMStyleWithColumns(40)); 3633 verifyFormat("DEBUG( //\n" 3634 " { f(); }, a);"); 3635 verifyFormat("DEBUG( //\n" 3636 " {\n" 3637 " f(); //\n" 3638 " },\n" 3639 " a);"); 3640 3641 EXPECT_EQ("call(parameter, {\n" 3642 " something();\n" 3643 " // Comment too\n" 3644 " // looooooooooong.\n" 3645 " somethingElse();\n" 3646 "});", 3647 format("call(parameter, {\n" 3648 " something();\n" 3649 " // Comment too looooooooooong.\n" 3650 " somethingElse();\n" 3651 "});", 3652 getLLVMStyleWithColumns(29))); 3653 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3654 EXPECT_EQ("DEBUG({ // comment\n" 3655 " int i;\n" 3656 "});", 3657 format("DEBUG({ // comment\n" 3658 "int i;\n" 3659 "});")); 3660 EXPECT_EQ("DEBUG({\n" 3661 " int i;\n" 3662 "\n" 3663 " // comment\n" 3664 " int j;\n" 3665 "});", 3666 format("DEBUG({\n" 3667 " int i;\n" 3668 "\n" 3669 " // comment\n" 3670 " int j;\n" 3671 "});")); 3672 3673 verifyFormat("DEBUG({\n" 3674 " if (a)\n" 3675 " return;\n" 3676 "});"); 3677 verifyGoogleFormat("DEBUG({\n" 3678 " if (a) return;\n" 3679 "});"); 3680 FormatStyle Style = getGoogleStyle(); 3681 Style.ColumnLimit = 45; 3682 verifyFormat("Debug(\n" 3683 " aaaaa,\n" 3684 " {\n" 3685 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 3686 " },\n" 3687 " a);", 3688 Style); 3689 3690 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 3691 3692 verifyNoCrash("^{v^{a}}"); 3693 } 3694 3695 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 3696 EXPECT_EQ("#define MACRO() \\\n" 3697 " Debug(aaa, /* force line break */ \\\n" 3698 " { \\\n" 3699 " int i; \\\n" 3700 " int j; \\\n" 3701 " })", 3702 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 3703 " { int i; int j; })", 3704 getGoogleStyle())); 3705 3706 EXPECT_EQ("#define A \\\n" 3707 " [] { \\\n" 3708 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3709 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 3710 " }", 3711 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3712 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 3713 getGoogleStyle())); 3714 } 3715 3716 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 3717 EXPECT_EQ("{}", format("{}")); 3718 verifyFormat("enum E {};"); 3719 verifyFormat("enum E {}"); 3720 FormatStyle Style = getLLVMStyle(); 3721 Style.SpaceInEmptyBlock = true; 3722 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 3723 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 3724 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 3725 } 3726 3727 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 3728 FormatStyle Style = getLLVMStyle(); 3729 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 3730 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 3731 verifyFormat("FOO_BEGIN\n" 3732 " FOO_ENTRY\n" 3733 "FOO_END", Style); 3734 verifyFormat("FOO_BEGIN\n" 3735 " NESTED_FOO_BEGIN\n" 3736 " NESTED_FOO_ENTRY\n" 3737 " NESTED_FOO_END\n" 3738 "FOO_END", Style); 3739 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 3740 " int x;\n" 3741 " x = 1;\n" 3742 "FOO_END(Baz)", Style); 3743 } 3744 3745 //===----------------------------------------------------------------------===// 3746 // Line break tests. 3747 //===----------------------------------------------------------------------===// 3748 3749 TEST_F(FormatTest, PreventConfusingIndents) { 3750 verifyFormat( 3751 "void f() {\n" 3752 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 3753 " parameter, parameter, parameter)),\n" 3754 " SecondLongCall(parameter));\n" 3755 "}"); 3756 verifyFormat( 3757 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3758 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3759 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3760 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 3761 verifyFormat( 3762 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3763 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 3764 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 3765 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 3766 verifyFormat( 3767 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 3768 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 3769 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 3770 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 3771 verifyFormat("int a = bbbb && ccc &&\n" 3772 " fffff(\n" 3773 "#define A Just forcing a new line\n" 3774 " ddd);"); 3775 } 3776 3777 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 3778 verifyFormat( 3779 "bool aaaaaaa =\n" 3780 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 3781 " bbbbbbbb();"); 3782 verifyFormat( 3783 "bool aaaaaaa =\n" 3784 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 3785 " bbbbbbbb();"); 3786 3787 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3788 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 3789 " ccccccccc == ddddddddddd;"); 3790 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3791 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 3792 " ccccccccc == ddddddddddd;"); 3793 verifyFormat( 3794 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 3795 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 3796 " ccccccccc == ddddddddddd;"); 3797 3798 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3799 " aaaaaa) &&\n" 3800 " bbbbbb && cccccc;"); 3801 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3802 " aaaaaa) >>\n" 3803 " bbbbbb;"); 3804 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 3805 " SourceMgr.getSpellingColumnNumber(\n" 3806 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 3807 " 1);"); 3808 3809 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3810 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 3811 " cccccc) {\n}"); 3812 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3813 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3814 " cccccc) {\n}"); 3815 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3816 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3817 " cccccc) {\n}"); 3818 verifyFormat("b = a &&\n" 3819 " // Comment\n" 3820 " b.c && d;"); 3821 3822 // If the LHS of a comparison is not a binary expression itself, the 3823 // additional linebreak confuses many people. 3824 verifyFormat( 3825 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3826 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 3827 "}"); 3828 verifyFormat( 3829 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3830 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3831 "}"); 3832 verifyFormat( 3833 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 3834 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3835 "}"); 3836 verifyFormat( 3837 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3838 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 3839 "}"); 3840 // Even explicit parentheses stress the precedence enough to make the 3841 // additional break unnecessary. 3842 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3843 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3844 "}"); 3845 // This cases is borderline, but with the indentation it is still readable. 3846 verifyFormat( 3847 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3848 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3849 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 3850 "}", 3851 getLLVMStyleWithColumns(75)); 3852 3853 // If the LHS is a binary expression, we should still use the additional break 3854 // as otherwise the formatting hides the operator precedence. 3855 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3856 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3857 " 5) {\n" 3858 "}"); 3859 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3860 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 3861 " 5) {\n" 3862 "}"); 3863 3864 FormatStyle OnePerLine = getLLVMStyle(); 3865 OnePerLine.BinPackParameters = false; 3866 verifyFormat( 3867 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3868 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3869 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 3870 OnePerLine); 3871 3872 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 3873 " .aaa(aaaaaaaaaaaaa) *\n" 3874 " aaaaaaa +\n" 3875 " aaaaaaa;", 3876 getLLVMStyleWithColumns(40)); 3877 } 3878 3879 TEST_F(FormatTest, ExpressionIndentation) { 3880 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3881 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3882 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3883 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3884 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 3885 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 3886 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3887 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 3888 " ccccccccccccccccccccccccccccccccccccccccc;"); 3889 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3890 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3891 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3892 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3893 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3894 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3895 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3896 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3897 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3898 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3899 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3900 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3901 verifyFormat("if () {\n" 3902 "} else if (aaaaa && bbbbb > // break\n" 3903 " ccccc) {\n" 3904 "}"); 3905 verifyFormat("if () {\n" 3906 "} else if constexpr (aaaaa && bbbbb > // break\n" 3907 " ccccc) {\n" 3908 "}"); 3909 verifyFormat("if () {\n" 3910 "} else if CONSTEXPR (aaaaa && bbbbb > // break\n" 3911 " ccccc) {\n" 3912 "}"); 3913 verifyFormat("if () {\n" 3914 "} else if (aaaaa &&\n" 3915 " bbbbb > // break\n" 3916 " ccccc &&\n" 3917 " ddddd) {\n" 3918 "}"); 3919 3920 // Presence of a trailing comment used to change indentation of b. 3921 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 3922 " b;\n" 3923 "return aaaaaaaaaaaaaaaaaaa +\n" 3924 " b; //", 3925 getLLVMStyleWithColumns(30)); 3926 } 3927 3928 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 3929 // Not sure what the best system is here. Like this, the LHS can be found 3930 // immediately above an operator (everything with the same or a higher 3931 // indent). The RHS is aligned right of the operator and so compasses 3932 // everything until something with the same indent as the operator is found. 3933 // FIXME: Is this a good system? 3934 FormatStyle Style = getLLVMStyle(); 3935 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 3936 verifyFormat( 3937 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3938 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3939 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3940 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3941 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3942 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3943 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3944 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3945 " > ccccccccccccccccccccccccccccccccccccccccc;", 3946 Style); 3947 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3948 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3949 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3950 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3951 Style); 3952 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3953 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3954 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3955 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3956 Style); 3957 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3958 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3959 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3960 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3961 Style); 3962 verifyFormat("if () {\n" 3963 "} else if (aaaaa\n" 3964 " && bbbbb // break\n" 3965 " > ccccc) {\n" 3966 "}", 3967 Style); 3968 verifyFormat("return (a)\n" 3969 " // comment\n" 3970 " + b;", 3971 Style); 3972 verifyFormat( 3973 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3974 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3975 " + cc;", 3976 Style); 3977 3978 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3979 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 3980 Style); 3981 3982 // Forced by comments. 3983 verifyFormat( 3984 "unsigned ContentSize =\n" 3985 " sizeof(int16_t) // DWARF ARange version number\n" 3986 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 3987 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 3988 " + sizeof(int8_t); // Segment Size (in bytes)"); 3989 3990 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 3991 " == boost::fusion::at_c<1>(iiii).second;", 3992 Style); 3993 3994 Style.ColumnLimit = 60; 3995 verifyFormat("zzzzzzzzzz\n" 3996 " = bbbbbbbbbbbbbbbbb\n" 3997 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 3998 Style); 3999 4000 Style.ColumnLimit = 80; 4001 Style.IndentWidth = 4; 4002 Style.TabWidth = 4; 4003 Style.UseTab = FormatStyle::UT_Always; 4004 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4005 Style.AlignOperands = false; 4006 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 4007 "\t&& (someOtherLongishConditionPart1\n" 4008 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 4009 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && (someOtherLongishConditionPart1 || someOtherEvenLongerNestedConditionPart2);", 4010 Style)); 4011 } 4012 4013 TEST_F(FormatTest, EnforcedOperatorWraps) { 4014 // Here we'd like to wrap after the || operators, but a comment is forcing an 4015 // earlier wrap. 4016 verifyFormat("bool x = aaaaa //\n" 4017 " || bbbbb\n" 4018 " //\n" 4019 " || cccc;"); 4020 } 4021 4022 TEST_F(FormatTest, NoOperandAlignment) { 4023 FormatStyle Style = getLLVMStyle(); 4024 Style.AlignOperands = false; 4025 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 4026 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4027 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4028 Style); 4029 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4030 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4031 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4032 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4033 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4034 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4035 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4036 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4037 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4038 " > ccccccccccccccccccccccccccccccccccccccccc;", 4039 Style); 4040 4041 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4042 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4043 " + cc;", 4044 Style); 4045 verifyFormat("int a = aa\n" 4046 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4047 " * cccccccccccccccccccccccccccccccccccc;\n", 4048 Style); 4049 4050 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4051 verifyFormat("return (a > b\n" 4052 " // comment1\n" 4053 " // comment2\n" 4054 " || c);", 4055 Style); 4056 } 4057 4058 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 4059 FormatStyle Style = getLLVMStyle(); 4060 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4061 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4062 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4063 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4064 Style); 4065 } 4066 4067 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 4068 FormatStyle Style = getLLVMStyle(); 4069 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4070 Style.BinPackArguments = false; 4071 Style.ColumnLimit = 40; 4072 verifyFormat("void test() {\n" 4073 " someFunction(\n" 4074 " this + argument + is + quite\n" 4075 " + long + so + it + gets + wrapped\n" 4076 " + but + remains + bin - packed);\n" 4077 "}", 4078 Style); 4079 verifyFormat("void test() {\n" 4080 " someFunction(arg1,\n" 4081 " this + argument + is\n" 4082 " + quite + long + so\n" 4083 " + it + gets + wrapped\n" 4084 " + but + remains + bin\n" 4085 " - packed,\n" 4086 " arg3);\n" 4087 "}", 4088 Style); 4089 verifyFormat("void test() {\n" 4090 " someFunction(\n" 4091 " arg1,\n" 4092 " this + argument + has\n" 4093 " + anotherFunc(nested,\n" 4094 " calls + whose\n" 4095 " + arguments\n" 4096 " + are + also\n" 4097 " + wrapped,\n" 4098 " in + addition)\n" 4099 " + to + being + bin - packed,\n" 4100 " arg3);\n" 4101 "}", 4102 Style); 4103 4104 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4105 verifyFormat("void test() {\n" 4106 " someFunction(\n" 4107 " arg1,\n" 4108 " this + argument + has +\n" 4109 " anotherFunc(nested,\n" 4110 " calls + whose +\n" 4111 " arguments +\n" 4112 " are + also +\n" 4113 " wrapped,\n" 4114 " in + addition) +\n" 4115 " to + being + bin - packed,\n" 4116 " arg3);\n" 4117 "}", 4118 Style); 4119 } 4120 4121 TEST_F(FormatTest, ConstructorInitializers) { 4122 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4123 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 4124 getLLVMStyleWithColumns(45)); 4125 verifyFormat("Constructor()\n" 4126 " : Inttializer(FitsOnTheLine) {}", 4127 getLLVMStyleWithColumns(44)); 4128 verifyFormat("Constructor()\n" 4129 " : Inttializer(FitsOnTheLine) {}", 4130 getLLVMStyleWithColumns(43)); 4131 4132 verifyFormat("template <typename T>\n" 4133 "Constructor() : Initializer(FitsOnTheLine) {}", 4134 getLLVMStyleWithColumns(45)); 4135 4136 verifyFormat( 4137 "SomeClass::Constructor()\n" 4138 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4139 4140 verifyFormat( 4141 "SomeClass::Constructor()\n" 4142 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4143 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 4144 verifyFormat( 4145 "SomeClass::Constructor()\n" 4146 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4147 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4148 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4149 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4150 " : aaaaaaaaaa(aaaaaa) {}"); 4151 4152 verifyFormat("Constructor()\n" 4153 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4154 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4155 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4156 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 4157 4158 verifyFormat("Constructor()\n" 4159 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4160 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4161 4162 verifyFormat("Constructor(int Parameter = 0)\n" 4163 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4164 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 4165 verifyFormat("Constructor()\n" 4166 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4167 "}", 4168 getLLVMStyleWithColumns(60)); 4169 verifyFormat("Constructor()\n" 4170 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4171 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 4172 4173 // Here a line could be saved by splitting the second initializer onto two 4174 // lines, but that is not desirable. 4175 verifyFormat("Constructor()\n" 4176 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4177 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4178 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4179 4180 FormatStyle OnePerLine = getLLVMStyle(); 4181 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4182 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 4183 verifyFormat("SomeClass::Constructor()\n" 4184 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4185 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4186 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4187 OnePerLine); 4188 verifyFormat("SomeClass::Constructor()\n" 4189 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4190 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4191 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4192 OnePerLine); 4193 verifyFormat("MyClass::MyClass(int var)\n" 4194 " : some_var_(var), // 4 space indent\n" 4195 " some_other_var_(var + 1) { // lined up\n" 4196 "}", 4197 OnePerLine); 4198 verifyFormat("Constructor()\n" 4199 " : aaaaa(aaaaaa),\n" 4200 " aaaaa(aaaaaa),\n" 4201 " aaaaa(aaaaaa),\n" 4202 " aaaaa(aaaaaa),\n" 4203 " aaaaa(aaaaaa) {}", 4204 OnePerLine); 4205 verifyFormat("Constructor()\n" 4206 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4207 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4208 OnePerLine); 4209 OnePerLine.BinPackParameters = false; 4210 verifyFormat( 4211 "Constructor()\n" 4212 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4213 " aaaaaaaaaaa().aaa(),\n" 4214 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4215 OnePerLine); 4216 OnePerLine.ColumnLimit = 60; 4217 verifyFormat("Constructor()\n" 4218 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4219 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4220 OnePerLine); 4221 4222 EXPECT_EQ("Constructor()\n" 4223 " : // Comment forcing unwanted break.\n" 4224 " aaaa(aaaa) {}", 4225 format("Constructor() :\n" 4226 " // Comment forcing unwanted break.\n" 4227 " aaaa(aaaa) {}")); 4228 } 4229 4230 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 4231 FormatStyle Style = getLLVMStyle(); 4232 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4233 Style.ColumnLimit = 60; 4234 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4235 Style.AllowAllConstructorInitializersOnNextLine = true; 4236 Style.BinPackParameters = false; 4237 4238 for (int i = 0; i < 4; ++i) { 4239 // Test all combinations of parameters that should not have an effect. 4240 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4241 Style.AllowAllArgumentsOnNextLine = i & 2; 4242 4243 Style.AllowAllConstructorInitializersOnNextLine = true; 4244 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4245 verifyFormat("Constructor()\n" 4246 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4247 Style); 4248 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4249 4250 Style.AllowAllConstructorInitializersOnNextLine = false; 4251 verifyFormat("Constructor()\n" 4252 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4253 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4254 Style); 4255 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4256 4257 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4258 Style.AllowAllConstructorInitializersOnNextLine = true; 4259 verifyFormat("Constructor()\n" 4260 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4261 Style); 4262 4263 Style.AllowAllConstructorInitializersOnNextLine = false; 4264 verifyFormat("Constructor()\n" 4265 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4266 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4267 Style); 4268 4269 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4270 Style.AllowAllConstructorInitializersOnNextLine = true; 4271 verifyFormat("Constructor() :\n" 4272 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4273 Style); 4274 4275 Style.AllowAllConstructorInitializersOnNextLine = false; 4276 verifyFormat("Constructor() :\n" 4277 " aaaaaaaaaaaaaaaaaa(a),\n" 4278 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4279 Style); 4280 } 4281 4282 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4283 // AllowAllConstructorInitializersOnNextLine in all 4284 // BreakConstructorInitializers modes 4285 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4286 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4287 Style.AllowAllConstructorInitializersOnNextLine = false; 4288 verifyFormat("SomeClassWithALongName::Constructor(\n" 4289 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4290 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4291 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4292 Style); 4293 4294 Style.AllowAllConstructorInitializersOnNextLine = true; 4295 verifyFormat("SomeClassWithALongName::Constructor(\n" 4296 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4297 " int bbbbbbbbbbbbb,\n" 4298 " int cccccccccccccccc)\n" 4299 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4300 Style); 4301 4302 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4303 Style.AllowAllConstructorInitializersOnNextLine = false; 4304 verifyFormat("SomeClassWithALongName::Constructor(\n" 4305 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4306 " int bbbbbbbbbbbbb)\n" 4307 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4308 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4309 Style); 4310 4311 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4312 4313 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4314 verifyFormat("SomeClassWithALongName::Constructor(\n" 4315 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4316 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4317 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4318 Style); 4319 4320 Style.AllowAllConstructorInitializersOnNextLine = true; 4321 verifyFormat("SomeClassWithALongName::Constructor(\n" 4322 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4323 " int bbbbbbbbbbbbb,\n" 4324 " int cccccccccccccccc)\n" 4325 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4326 Style); 4327 4328 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4329 Style.AllowAllConstructorInitializersOnNextLine = false; 4330 verifyFormat("SomeClassWithALongName::Constructor(\n" 4331 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4332 " int bbbbbbbbbbbbb)\n" 4333 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4334 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4335 Style); 4336 4337 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4338 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4339 verifyFormat("SomeClassWithALongName::Constructor(\n" 4340 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4341 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4342 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4343 Style); 4344 4345 Style.AllowAllConstructorInitializersOnNextLine = true; 4346 verifyFormat("SomeClassWithALongName::Constructor(\n" 4347 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4348 " int bbbbbbbbbbbbb,\n" 4349 " int cccccccccccccccc) :\n" 4350 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4351 Style); 4352 4353 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4354 Style.AllowAllConstructorInitializersOnNextLine = false; 4355 verifyFormat("SomeClassWithALongName::Constructor(\n" 4356 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4357 " int bbbbbbbbbbbbb) :\n" 4358 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4359 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4360 Style); 4361 } 4362 4363 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4364 FormatStyle Style = getLLVMStyle(); 4365 Style.ColumnLimit = 60; 4366 Style.BinPackArguments = false; 4367 for (int i = 0; i < 4; ++i) { 4368 // Test all combinations of parameters that should not have an effect. 4369 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4370 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4371 4372 Style.AllowAllArgumentsOnNextLine = true; 4373 verifyFormat("void foo() {\n" 4374 " FunctionCallWithReallyLongName(\n" 4375 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4376 "}", 4377 Style); 4378 Style.AllowAllArgumentsOnNextLine = false; 4379 verifyFormat("void foo() {\n" 4380 " FunctionCallWithReallyLongName(\n" 4381 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4382 " bbbbbbbbbbbb);\n" 4383 "}", 4384 Style); 4385 4386 Style.AllowAllArgumentsOnNextLine = true; 4387 verifyFormat("void foo() {\n" 4388 " auto VariableWithReallyLongName = {\n" 4389 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4390 "}", 4391 Style); 4392 Style.AllowAllArgumentsOnNextLine = false; 4393 verifyFormat("void foo() {\n" 4394 " auto VariableWithReallyLongName = {\n" 4395 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4396 " bbbbbbbbbbbb};\n" 4397 "}", 4398 Style); 4399 } 4400 4401 // This parameter should not affect declarations. 4402 Style.BinPackParameters = false; 4403 Style.AllowAllArgumentsOnNextLine = false; 4404 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4405 verifyFormat("void FunctionCallWithReallyLongName(\n" 4406 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4407 Style); 4408 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4409 verifyFormat("void FunctionCallWithReallyLongName(\n" 4410 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4411 " int bbbbbbbbbbbb);", 4412 Style); 4413 } 4414 4415 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4416 FormatStyle Style = getLLVMStyle(); 4417 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4418 4419 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4420 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4421 getStyleWithColumns(Style, 45)); 4422 verifyFormat("Constructor() :\n" 4423 " Initializer(FitsOnTheLine) {}", 4424 getStyleWithColumns(Style, 44)); 4425 verifyFormat("Constructor() :\n" 4426 " Initializer(FitsOnTheLine) {}", 4427 getStyleWithColumns(Style, 43)); 4428 4429 verifyFormat("template <typename T>\n" 4430 "Constructor() : Initializer(FitsOnTheLine) {}", 4431 getStyleWithColumns(Style, 50)); 4432 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4433 verifyFormat( 4434 "SomeClass::Constructor() :\n" 4435 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4436 Style); 4437 4438 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4439 verifyFormat( 4440 "SomeClass::Constructor() :\n" 4441 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4442 Style); 4443 4444 verifyFormat( 4445 "SomeClass::Constructor() :\n" 4446 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4447 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4448 Style); 4449 verifyFormat( 4450 "SomeClass::Constructor() :\n" 4451 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4452 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4453 Style); 4454 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4455 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4456 " aaaaaaaaaa(aaaaaa) {}", 4457 Style); 4458 4459 verifyFormat("Constructor() :\n" 4460 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4461 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4462 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4463 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4464 Style); 4465 4466 verifyFormat("Constructor() :\n" 4467 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4468 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4469 Style); 4470 4471 verifyFormat("Constructor(int Parameter = 0) :\n" 4472 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4473 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4474 Style); 4475 verifyFormat("Constructor() :\n" 4476 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4477 "}", 4478 getStyleWithColumns(Style, 60)); 4479 verifyFormat("Constructor() :\n" 4480 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4481 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4482 Style); 4483 4484 // Here a line could be saved by splitting the second initializer onto two 4485 // lines, but that is not desirable. 4486 verifyFormat("Constructor() :\n" 4487 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4488 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4489 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4490 Style); 4491 4492 FormatStyle OnePerLine = Style; 4493 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4494 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4495 verifyFormat("SomeClass::Constructor() :\n" 4496 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4497 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4498 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4499 OnePerLine); 4500 verifyFormat("SomeClass::Constructor() :\n" 4501 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4502 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4503 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4504 OnePerLine); 4505 verifyFormat("MyClass::MyClass(int var) :\n" 4506 " some_var_(var), // 4 space indent\n" 4507 " some_other_var_(var + 1) { // lined up\n" 4508 "}", 4509 OnePerLine); 4510 verifyFormat("Constructor() :\n" 4511 " aaaaa(aaaaaa),\n" 4512 " aaaaa(aaaaaa),\n" 4513 " aaaaa(aaaaaa),\n" 4514 " aaaaa(aaaaaa),\n" 4515 " aaaaa(aaaaaa) {}", 4516 OnePerLine); 4517 verifyFormat("Constructor() :\n" 4518 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4519 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4520 OnePerLine); 4521 OnePerLine.BinPackParameters = false; 4522 verifyFormat( 4523 "Constructor() :\n" 4524 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4525 " aaaaaaaaaaa().aaa(),\n" 4526 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4527 OnePerLine); 4528 OnePerLine.ColumnLimit = 60; 4529 verifyFormat("Constructor() :\n" 4530 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4531 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4532 OnePerLine); 4533 4534 EXPECT_EQ("Constructor() :\n" 4535 " // Comment forcing unwanted break.\n" 4536 " aaaa(aaaa) {}", 4537 format("Constructor() :\n" 4538 " // Comment forcing unwanted break.\n" 4539 " aaaa(aaaa) {}", 4540 Style)); 4541 4542 Style.ColumnLimit = 0; 4543 verifyFormat("SomeClass::Constructor() :\n" 4544 " a(a) {}", 4545 Style); 4546 verifyFormat("SomeClass::Constructor() noexcept :\n" 4547 " a(a) {}", 4548 Style); 4549 verifyFormat("SomeClass::Constructor() :\n" 4550 " a(a), b(b), c(c) {}", 4551 Style); 4552 verifyFormat("SomeClass::Constructor() :\n" 4553 " a(a) {\n" 4554 " foo();\n" 4555 " bar();\n" 4556 "}", 4557 Style); 4558 4559 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4560 verifyFormat("SomeClass::Constructor() :\n" 4561 " a(a), b(b), c(c) {\n" 4562 "}", 4563 Style); 4564 verifyFormat("SomeClass::Constructor() :\n" 4565 " a(a) {\n" 4566 "}", 4567 Style); 4568 4569 Style.ColumnLimit = 80; 4570 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4571 Style.ConstructorInitializerIndentWidth = 2; 4572 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", 4573 Style); 4574 verifyFormat("SomeClass::Constructor() :\n" 4575 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4576 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 4577 Style); 4578 4579 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as well 4580 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 4581 verifyFormat("class SomeClass\n" 4582 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4583 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4584 Style); 4585 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 4586 verifyFormat("class SomeClass\n" 4587 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4588 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4589 Style); 4590 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 4591 verifyFormat("class SomeClass :\n" 4592 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4593 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4594 Style); 4595 } 4596 4597 #ifndef EXPENSIVE_CHECKS 4598 // Expensive checks enables libstdc++ checking which includes validating the 4599 // state of ranges used in std::priority_queue - this blows out the 4600 // runtime/scalability of the function and makes this test unacceptably slow. 4601 TEST_F(FormatTest, MemoizationTests) { 4602 // This breaks if the memoization lookup does not take \c Indent and 4603 // \c LastSpace into account. 4604 verifyFormat( 4605 "extern CFRunLoopTimerRef\n" 4606 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 4607 " CFTimeInterval interval, CFOptionFlags flags,\n" 4608 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 4609 " CFRunLoopTimerContext *context) {}"); 4610 4611 // Deep nesting somewhat works around our memoization. 4612 verifyFormat( 4613 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4614 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4615 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4616 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4617 " aaaaa())))))))))))))))))))))))))))))))))))))));", 4618 getLLVMStyleWithColumns(65)); 4619 verifyFormat( 4620 "aaaaa(\n" 4621 " aaaaa,\n" 4622 " aaaaa(\n" 4623 " aaaaa,\n" 4624 " aaaaa(\n" 4625 " aaaaa,\n" 4626 " aaaaa(\n" 4627 " aaaaa,\n" 4628 " aaaaa(\n" 4629 " aaaaa,\n" 4630 " aaaaa(\n" 4631 " aaaaa,\n" 4632 " aaaaa(\n" 4633 " aaaaa,\n" 4634 " aaaaa(\n" 4635 " aaaaa,\n" 4636 " aaaaa(\n" 4637 " aaaaa,\n" 4638 " aaaaa(\n" 4639 " aaaaa,\n" 4640 " aaaaa(\n" 4641 " aaaaa,\n" 4642 " aaaaa(\n" 4643 " aaaaa,\n" 4644 " aaaaa))))))))))));", 4645 getLLVMStyleWithColumns(65)); 4646 verifyFormat( 4647 "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" 4648 " a),\n" 4649 " a),\n" 4650 " a),\n" 4651 " a),\n" 4652 " a),\n" 4653 " a),\n" 4654 " a),\n" 4655 " a),\n" 4656 " a),\n" 4657 " a),\n" 4658 " a),\n" 4659 " a),\n" 4660 " a),\n" 4661 " a),\n" 4662 " a),\n" 4663 " a),\n" 4664 " a)", 4665 getLLVMStyleWithColumns(65)); 4666 4667 // This test takes VERY long when memoization is broken. 4668 FormatStyle OnePerLine = getLLVMStyle(); 4669 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4670 OnePerLine.BinPackParameters = false; 4671 std::string input = "Constructor()\n" 4672 " : aaaa(a,\n"; 4673 for (unsigned i = 0, e = 80; i != e; ++i) { 4674 input += " a,\n"; 4675 } 4676 input += " a) {}"; 4677 verifyFormat(input, OnePerLine); 4678 } 4679 #endif 4680 4681 TEST_F(FormatTest, BreaksAsHighAsPossible) { 4682 verifyFormat( 4683 "void f() {\n" 4684 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 4685 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 4686 " f();\n" 4687 "}"); 4688 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 4689 " Intervals[i - 1].getRange().getLast()) {\n}"); 4690 } 4691 4692 TEST_F(FormatTest, BreaksFunctionDeclarations) { 4693 // Principially, we break function declarations in a certain order: 4694 // 1) break amongst arguments. 4695 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 4696 " Cccccccccccccc cccccccccccccc);"); 4697 verifyFormat("template <class TemplateIt>\n" 4698 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 4699 " TemplateIt *stop) {}"); 4700 4701 // 2) break after return type. 4702 verifyFormat( 4703 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4704 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 4705 getGoogleStyle()); 4706 4707 // 3) break after (. 4708 verifyFormat( 4709 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 4710 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 4711 getGoogleStyle()); 4712 4713 // 4) break before after nested name specifiers. 4714 verifyFormat( 4715 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4716 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 4717 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 4718 getGoogleStyle()); 4719 4720 // However, there are exceptions, if a sufficient amount of lines can be 4721 // saved. 4722 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 4723 // more adjusting. 4724 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4725 " Cccccccccccccc cccccccccc,\n" 4726 " Cccccccccccccc cccccccccc,\n" 4727 " Cccccccccccccc cccccccccc,\n" 4728 " Cccccccccccccc cccccccccc);"); 4729 verifyFormat( 4730 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4731 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4732 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4733 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 4734 getGoogleStyle()); 4735 verifyFormat( 4736 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4737 " Cccccccccccccc cccccccccc,\n" 4738 " Cccccccccccccc cccccccccc,\n" 4739 " Cccccccccccccc cccccccccc,\n" 4740 " Cccccccccccccc cccccccccc,\n" 4741 " Cccccccccccccc cccccccccc,\n" 4742 " Cccccccccccccc cccccccccc);"); 4743 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4744 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4745 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4746 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4747 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 4748 4749 // Break after multi-line parameters. 4750 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4751 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4752 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4753 " bbbb bbbb);"); 4754 verifyFormat("void SomeLoooooooooooongFunction(\n" 4755 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 4756 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4757 " int bbbbbbbbbbbbb);"); 4758 4759 // Treat overloaded operators like other functions. 4760 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4761 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 4762 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4763 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 4764 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4765 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 4766 verifyGoogleFormat( 4767 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 4768 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4769 verifyGoogleFormat( 4770 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 4771 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4772 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4773 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4774 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 4775 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4776 verifyGoogleFormat( 4777 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 4778 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4779 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 4780 verifyGoogleFormat( 4781 "template <typename T>\n" 4782 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4783 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 4784 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 4785 4786 FormatStyle Style = getLLVMStyle(); 4787 Style.PointerAlignment = FormatStyle::PAS_Left; 4788 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4789 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 4790 Style); 4791 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 4792 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4793 Style); 4794 } 4795 4796 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 4797 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 4798 // Prefer keeping `::` followed by `operator` together. 4799 EXPECT_EQ("const aaaa::bbbbbbb &\n" 4800 "ccccccccc::operator++() {\n" 4801 " stuff();\n" 4802 "}", 4803 format("const aaaa::bbbbbbb\n" 4804 "&ccccccccc::operator++() { stuff(); }", 4805 getLLVMStyleWithColumns(40))); 4806 } 4807 4808 TEST_F(FormatTest, TrailingReturnType) { 4809 verifyFormat("auto foo() -> int;\n"); 4810 verifyFormat("struct S {\n" 4811 " auto bar() const -> int;\n" 4812 "};"); 4813 verifyFormat("template <size_t Order, typename T>\n" 4814 "auto load_img(const std::string &filename)\n" 4815 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 4816 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 4817 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 4818 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 4819 verifyFormat("template <typename T>\n" 4820 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 4821 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 4822 4823 // Not trailing return types. 4824 verifyFormat("void f() { auto a = b->c(); }"); 4825 } 4826 4827 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 4828 // Avoid breaking before trailing 'const' or other trailing annotations, if 4829 // they are not function-like. 4830 FormatStyle Style = getGoogleStyle(); 4831 Style.ColumnLimit = 47; 4832 verifyFormat("void someLongFunction(\n" 4833 " int someLoooooooooooooongParameter) const {\n}", 4834 getLLVMStyleWithColumns(47)); 4835 verifyFormat("LoooooongReturnType\n" 4836 "someLoooooooongFunction() const {}", 4837 getLLVMStyleWithColumns(47)); 4838 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 4839 " const {}", 4840 Style); 4841 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4842 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 4843 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4844 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 4845 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4846 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 4847 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 4848 " aaaaaaaaaaa aaaaa) const override;"); 4849 verifyGoogleFormat( 4850 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4851 " const override;"); 4852 4853 // Even if the first parameter has to be wrapped. 4854 verifyFormat("void someLongFunction(\n" 4855 " int someLongParameter) const {}", 4856 getLLVMStyleWithColumns(46)); 4857 verifyFormat("void someLongFunction(\n" 4858 " int someLongParameter) const {}", 4859 Style); 4860 verifyFormat("void someLongFunction(\n" 4861 " int someLongParameter) override {}", 4862 Style); 4863 verifyFormat("void someLongFunction(\n" 4864 " int someLongParameter) OVERRIDE {}", 4865 Style); 4866 verifyFormat("void someLongFunction(\n" 4867 " int someLongParameter) final {}", 4868 Style); 4869 verifyFormat("void someLongFunction(\n" 4870 " int someLongParameter) FINAL {}", 4871 Style); 4872 verifyFormat("void someLongFunction(\n" 4873 " int parameter) const override {}", 4874 Style); 4875 4876 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 4877 verifyFormat("void someLongFunction(\n" 4878 " int someLongParameter) const\n" 4879 "{\n" 4880 "}", 4881 Style); 4882 4883 // Unless these are unknown annotations. 4884 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 4885 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4886 " LONG_AND_UGLY_ANNOTATION;"); 4887 4888 // Breaking before function-like trailing annotations is fine to keep them 4889 // close to their arguments. 4890 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4891 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 4892 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 4893 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 4894 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 4895 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 4896 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 4897 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 4898 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 4899 4900 verifyFormat( 4901 "void aaaaaaaaaaaaaaaaaa()\n" 4902 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 4903 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 4904 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4905 " __attribute__((unused));"); 4906 verifyGoogleFormat( 4907 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4908 " GUARDED_BY(aaaaaaaaaaaa);"); 4909 verifyGoogleFormat( 4910 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4911 " GUARDED_BY(aaaaaaaaaaaa);"); 4912 verifyGoogleFormat( 4913 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 4914 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4915 verifyGoogleFormat( 4916 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 4917 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 4918 } 4919 4920 TEST_F(FormatTest, FunctionAnnotations) { 4921 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4922 "int OldFunction(const string ¶meter) {}"); 4923 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4924 "string OldFunction(const string ¶meter) {}"); 4925 verifyFormat("template <typename T>\n" 4926 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4927 "string OldFunction(const string ¶meter) {}"); 4928 4929 // Not function annotations. 4930 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4931 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 4932 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 4933 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 4934 verifyFormat("MACRO(abc).function() // wrap\n" 4935 " << abc;"); 4936 verifyFormat("MACRO(abc)->function() // wrap\n" 4937 " << abc;"); 4938 verifyFormat("MACRO(abc)::function() // wrap\n" 4939 " << abc;"); 4940 } 4941 4942 TEST_F(FormatTest, BreaksDesireably) { 4943 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 4944 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 4945 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 4946 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4947 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 4948 "}"); 4949 4950 verifyFormat( 4951 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4952 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4953 4954 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4955 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4956 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4957 4958 verifyFormat( 4959 "aaaaaaaa(aaaaaaaaaaaaa,\n" 4960 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4961 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 4962 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4963 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 4964 4965 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4966 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4967 4968 verifyFormat( 4969 "void f() {\n" 4970 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 4971 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 4972 "}"); 4973 verifyFormat( 4974 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4975 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4976 verifyFormat( 4977 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4978 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4979 verifyFormat( 4980 "aaaaaa(aaa,\n" 4981 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4982 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4983 " aaaa);"); 4984 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4985 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4986 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4987 4988 // Indent consistently independent of call expression and unary operator. 4989 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4990 " dddddddddddddddddddddddddddddd));"); 4991 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4992 " dddddddddddddddddddddddddddddd));"); 4993 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 4994 " dddddddddddddddddddddddddddddd));"); 4995 4996 // This test case breaks on an incorrect memoization, i.e. an optimization not 4997 // taking into account the StopAt value. 4998 verifyFormat( 4999 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5000 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5001 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5002 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5003 5004 verifyFormat("{\n {\n {\n" 5005 " Annotation.SpaceRequiredBefore =\n" 5006 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 5007 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 5008 " }\n }\n}"); 5009 5010 // Break on an outer level if there was a break on an inner level. 5011 EXPECT_EQ("f(g(h(a, // comment\n" 5012 " b, c),\n" 5013 " d, e),\n" 5014 " x, y);", 5015 format("f(g(h(a, // comment\n" 5016 " b, c), d, e), x, y);")); 5017 5018 // Prefer breaking similar line breaks. 5019 verifyFormat( 5020 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 5021 " NSTrackingMouseEnteredAndExited |\n" 5022 " NSTrackingActiveAlways;"); 5023 } 5024 5025 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 5026 FormatStyle NoBinPacking = getGoogleStyle(); 5027 NoBinPacking.BinPackParameters = false; 5028 NoBinPacking.BinPackArguments = true; 5029 verifyFormat("void f() {\n" 5030 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 5031 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5032 "}", 5033 NoBinPacking); 5034 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 5035 " int aaaaaaaaaaaaaaaaaaaa,\n" 5036 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5037 NoBinPacking); 5038 5039 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5040 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5041 " vector<int> bbbbbbbbbbbbbbb);", 5042 NoBinPacking); 5043 // FIXME: This behavior difference is probably not wanted. However, currently 5044 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 5045 // template arguments from BreakBeforeParameter being set because of the 5046 // one-per-line formatting. 5047 verifyFormat( 5048 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5049 " aaaaaaaaaa> aaaaaaaaaa);", 5050 NoBinPacking); 5051 verifyFormat( 5052 "void fffffffffff(\n" 5053 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 5054 " aaaaaaaaaa);"); 5055 } 5056 5057 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 5058 FormatStyle NoBinPacking = getGoogleStyle(); 5059 NoBinPacking.BinPackParameters = false; 5060 NoBinPacking.BinPackArguments = false; 5061 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 5062 " aaaaaaaaaaaaaaaaaaaa,\n" 5063 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 5064 NoBinPacking); 5065 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 5066 " aaaaaaaaaaaaa,\n" 5067 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 5068 NoBinPacking); 5069 verifyFormat( 5070 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5071 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5072 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5073 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5074 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 5075 NoBinPacking); 5076 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5077 " .aaaaaaaaaaaaaaaaaa();", 5078 NoBinPacking); 5079 verifyFormat("void f() {\n" 5080 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5081 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 5082 "}", 5083 NoBinPacking); 5084 5085 verifyFormat( 5086 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5087 " aaaaaaaaaaaa,\n" 5088 " aaaaaaaaaaaa);", 5089 NoBinPacking); 5090 verifyFormat( 5091 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 5092 " ddddddddddddddddddddddddddddd),\n" 5093 " test);", 5094 NoBinPacking); 5095 5096 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5097 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 5098 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 5099 " aaaaaaaaaaaaaaaaaa;", 5100 NoBinPacking); 5101 verifyFormat("a(\"a\"\n" 5102 " \"a\",\n" 5103 " a);"); 5104 5105 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5106 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 5107 " aaaaaaaaa,\n" 5108 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5109 NoBinPacking); 5110 verifyFormat( 5111 "void f() {\n" 5112 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5113 " .aaaaaaa();\n" 5114 "}", 5115 NoBinPacking); 5116 verifyFormat( 5117 "template <class SomeType, class SomeOtherType>\n" 5118 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 5119 NoBinPacking); 5120 } 5121 5122 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 5123 FormatStyle Style = getLLVMStyleWithColumns(15); 5124 Style.ExperimentalAutoDetectBinPacking = true; 5125 EXPECT_EQ("aaa(aaaa,\n" 5126 " aaaa,\n" 5127 " aaaa);\n" 5128 "aaa(aaaa,\n" 5129 " aaaa,\n" 5130 " aaaa);", 5131 format("aaa(aaaa,\n" // one-per-line 5132 " aaaa,\n" 5133 " aaaa );\n" 5134 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5135 Style)); 5136 EXPECT_EQ("aaa(aaaa, aaaa,\n" 5137 " aaaa);\n" 5138 "aaa(aaaa, aaaa,\n" 5139 " aaaa);", 5140 format("aaa(aaaa, aaaa,\n" // bin-packed 5141 " aaaa );\n" 5142 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5143 Style)); 5144 } 5145 5146 TEST_F(FormatTest, FormatsBuilderPattern) { 5147 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 5148 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 5149 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 5150 " .StartsWith(\".init\", ORDER_INIT)\n" 5151 " .StartsWith(\".fini\", ORDER_FINI)\n" 5152 " .StartsWith(\".hash\", ORDER_HASH)\n" 5153 " .Default(ORDER_TEXT);\n"); 5154 5155 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 5156 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 5157 verifyFormat( 5158 "aaaaaaa->aaaaaaa\n" 5159 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5160 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5161 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5162 verifyFormat( 5163 "aaaaaaa->aaaaaaa\n" 5164 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5165 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5166 verifyFormat( 5167 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 5168 " aaaaaaaaaaaaaa);"); 5169 verifyFormat( 5170 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 5171 " aaaaaa->aaaaaaaaaaaa()\n" 5172 " ->aaaaaaaaaaaaaaaa(\n" 5173 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5174 " ->aaaaaaaaaaaaaaaaa();"); 5175 verifyGoogleFormat( 5176 "void f() {\n" 5177 " someo->Add((new util::filetools::Handler(dir))\n" 5178 " ->OnEvent1(NewPermanentCallback(\n" 5179 " this, &HandlerHolderClass::EventHandlerCBA))\n" 5180 " ->OnEvent2(NewPermanentCallback(\n" 5181 " this, &HandlerHolderClass::EventHandlerCBB))\n" 5182 " ->OnEvent3(NewPermanentCallback(\n" 5183 " this, &HandlerHolderClass::EventHandlerCBC))\n" 5184 " ->OnEvent5(NewPermanentCallback(\n" 5185 " this, &HandlerHolderClass::EventHandlerCBD))\n" 5186 " ->OnEvent6(NewPermanentCallback(\n" 5187 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 5188 "}"); 5189 5190 verifyFormat( 5191 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 5192 verifyFormat("aaaaaaaaaaaaaaa()\n" 5193 " .aaaaaaaaaaaaaaa()\n" 5194 " .aaaaaaaaaaaaaaa()\n" 5195 " .aaaaaaaaaaaaaaa()\n" 5196 " .aaaaaaaaaaaaaaa();"); 5197 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5198 " .aaaaaaaaaaaaaaa()\n" 5199 " .aaaaaaaaaaaaaaa()\n" 5200 " .aaaaaaaaaaaaaaa();"); 5201 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5202 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5203 " .aaaaaaaaaaaaaaa();"); 5204 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 5205 " ->aaaaaaaaaaaaaae(0)\n" 5206 " ->aaaaaaaaaaaaaaa();"); 5207 5208 // Don't linewrap after very short segments. 5209 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5210 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5211 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5212 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5213 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5214 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5215 verifyFormat("aaa()\n" 5216 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5217 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5218 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5219 5220 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5221 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5222 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 5223 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5224 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 5225 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 5226 5227 // Prefer not to break after empty parentheses. 5228 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 5229 " First->LastNewlineOffset);"); 5230 5231 // Prefer not to create "hanging" indents. 5232 verifyFormat( 5233 "return !soooooooooooooome_map\n" 5234 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5235 " .second;"); 5236 verifyFormat( 5237 "return aaaaaaaaaaaaaaaa\n" 5238 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 5239 " .aaaa(aaaaaaaaaaaaaa);"); 5240 // No hanging indent here. 5241 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5242 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5243 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5244 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5245 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5246 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5247 getLLVMStyleWithColumns(60)); 5248 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5249 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5250 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5251 getLLVMStyleWithColumns(59)); 5252 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5253 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5254 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5255 5256 // Dont break if only closing statements before member call 5257 verifyFormat("test() {\n" 5258 " ([]() -> {\n" 5259 " int b = 32;\n" 5260 " return 3;\n" 5261 " }).foo();\n" 5262 "}"); 5263 verifyFormat("test() {\n" 5264 " (\n" 5265 " []() -> {\n" 5266 " int b = 32;\n" 5267 " return 3;\n" 5268 " },\n" 5269 " foo, bar)\n" 5270 " .foo();\n" 5271 "}"); 5272 verifyFormat("test() {\n" 5273 " ([]() -> {\n" 5274 " int b = 32;\n" 5275 " return 3;\n" 5276 " })\n" 5277 " .foo()\n" 5278 " .bar();\n" 5279 "}"); 5280 verifyFormat("test() {\n" 5281 " ([]() -> {\n" 5282 " int b = 32;\n" 5283 " return 3;\n" 5284 " })\n" 5285 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5286 " \"bbbb\");\n" 5287 "}", 5288 getLLVMStyleWithColumns(30)); 5289 } 5290 5291 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5292 verifyFormat( 5293 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5294 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5295 verifyFormat( 5296 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5297 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5298 5299 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5300 " ccccccccccccccccccccccccc) {\n}"); 5301 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5302 " ccccccccccccccccccccccccc) {\n}"); 5303 5304 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5305 " ccccccccccccccccccccccccc) {\n}"); 5306 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5307 " ccccccccccccccccccccccccc) {\n}"); 5308 5309 verifyFormat( 5310 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5311 " ccccccccccccccccccccccccc) {\n}"); 5312 verifyFormat( 5313 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5314 " ccccccccccccccccccccccccc) {\n}"); 5315 5316 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5317 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5318 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5319 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5320 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5321 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5322 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5323 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5324 5325 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5326 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5327 " aaaaaaaaaaaaaaa != aa) {\n}"); 5328 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5329 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5330 " aaaaaaaaaaaaaaa != aa) {\n}"); 5331 } 5332 5333 TEST_F(FormatTest, BreaksAfterAssignments) { 5334 verifyFormat( 5335 "unsigned Cost =\n" 5336 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5337 " SI->getPointerAddressSpaceee());\n"); 5338 verifyFormat( 5339 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5340 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5341 5342 verifyFormat( 5343 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5344 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5345 verifyFormat("unsigned OriginalStartColumn =\n" 5346 " SourceMgr.getSpellingColumnNumber(\n" 5347 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5348 " 1;"); 5349 } 5350 5351 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5352 FormatStyle Style = getLLVMStyle(); 5353 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5354 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5355 Style); 5356 5357 Style.PenaltyBreakAssignment = 20; 5358 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5359 " cccccccccccccccccccccccccc;", 5360 Style); 5361 } 5362 5363 TEST_F(FormatTest, AlignsAfterAssignments) { 5364 verifyFormat( 5365 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5366 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5367 verifyFormat( 5368 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5369 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5370 verifyFormat( 5371 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5372 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5373 verifyFormat( 5374 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5375 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5376 verifyFormat( 5377 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5378 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5379 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5380 } 5381 5382 TEST_F(FormatTest, AlignsAfterReturn) { 5383 verifyFormat( 5384 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5385 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5386 verifyFormat( 5387 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5388 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5389 verifyFormat( 5390 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5391 " aaaaaaaaaaaaaaaaaaaaaa();"); 5392 verifyFormat( 5393 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5394 " aaaaaaaaaaaaaaaaaaaaaa());"); 5395 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5396 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5397 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5398 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5399 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5400 verifyFormat("return\n" 5401 " // true if code is one of a or b.\n" 5402 " code == a || code == b;"); 5403 } 5404 5405 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5406 verifyFormat( 5407 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5408 " aaaaaaaaa aaaaaaa) {}"); 5409 verifyFormat( 5410 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5411 " aaaaaaaaaaa aaaaaaaaa);"); 5412 verifyFormat( 5413 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5414 " aaaaaaaaaaaaaaaaaaaaa));"); 5415 FormatStyle Style = getLLVMStyle(); 5416 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5417 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5418 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5419 Style); 5420 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5421 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5422 Style); 5423 verifyFormat("SomeLongVariableName->someFunction(\n" 5424 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5425 Style); 5426 verifyFormat( 5427 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5428 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5429 Style); 5430 verifyFormat( 5431 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5432 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5433 Style); 5434 verifyFormat( 5435 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5436 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5437 Style); 5438 5439 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5440 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5441 " b));", 5442 Style); 5443 5444 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5445 Style.BinPackArguments = false; 5446 Style.BinPackParameters = false; 5447 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5448 " aaaaaaaaaaa aaaaaaaa,\n" 5449 " aaaaaaaaa aaaaaaa,\n" 5450 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5451 Style); 5452 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5453 " aaaaaaaaaaa aaaaaaaaa,\n" 5454 " aaaaaaaaaaa aaaaaaaaa,\n" 5455 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5456 Style); 5457 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5458 " aaaaaaaaaaaaaaa,\n" 5459 " aaaaaaaaaaaaaaaaaaaaa,\n" 5460 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5461 Style); 5462 verifyFormat( 5463 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5464 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5465 Style); 5466 verifyFormat( 5467 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5468 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5469 Style); 5470 verifyFormat( 5471 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5472 " aaaaaaaaaaaaaaaaaaaaa(\n" 5473 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5474 " aaaaaaaaaaaaaaaa);", 5475 Style); 5476 verifyFormat( 5477 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5478 " aaaaaaaaaaaaaaaaaaaaa(\n" 5479 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5480 " aaaaaaaaaaaaaaaa);", 5481 Style); 5482 } 5483 5484 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5485 FormatStyle Style = getLLVMStyleWithColumns(40); 5486 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5487 " bbbbbbbbbbbbbbbbbbbbbb);", 5488 Style); 5489 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5490 Style.AlignOperands = false; 5491 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5492 " bbbbbbbbbbbbbbbbbbbbbb);", 5493 Style); 5494 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5495 Style.AlignOperands = true; 5496 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5497 " bbbbbbbbbbbbbbbbbbbbbb);", 5498 Style); 5499 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5500 Style.AlignOperands = false; 5501 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5502 " bbbbbbbbbbbbbbbbbbbbbb);", 5503 Style); 5504 } 5505 5506 TEST_F(FormatTest, BreaksConditionalExpressions) { 5507 verifyFormat( 5508 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5509 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5510 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5511 verifyFormat( 5512 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5513 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5514 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5515 verifyFormat( 5516 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5517 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5518 verifyFormat( 5519 "aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5520 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5521 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5522 verifyFormat( 5523 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5524 " : aaaaaaaaaaaaa);"); 5525 verifyFormat( 5526 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5527 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5528 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5529 " aaaaaaaaaaaaa);"); 5530 verifyFormat( 5531 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5532 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5533 " aaaaaaaaaaaaa);"); 5534 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5535 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5536 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5537 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5538 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5539 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5540 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5541 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5542 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5543 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5544 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5545 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5546 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5547 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5548 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5549 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5550 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5551 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5552 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5553 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5554 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5555 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5556 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5557 " : aaaaaaaaaaaaaaaa;"); 5558 verifyFormat( 5559 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5560 " ? aaaaaaaaaaaaaaa\n" 5561 " : aaaaaaaaaaaaaaa;"); 5562 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5563 " aaaaaaaaa\n" 5564 " ? b\n" 5565 " : c);"); 5566 verifyFormat("return aaaa == bbbb\n" 5567 " // comment\n" 5568 " ? aaaa\n" 5569 " : bbbb;"); 5570 verifyFormat("unsigned Indent =\n" 5571 " format(TheLine.First,\n" 5572 " IndentForLevel[TheLine.Level] >= 0\n" 5573 " ? IndentForLevel[TheLine.Level]\n" 5574 " : TheLine * 2,\n" 5575 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5576 getLLVMStyleWithColumns(60)); 5577 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5578 " ? aaaaaaaaaaaaaaa\n" 5579 " : bbbbbbbbbbbbbbb //\n" 5580 " ? ccccccccccccccc\n" 5581 " : ddddddddddddddd;"); 5582 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5583 " ? aaaaaaaaaaaaaaa\n" 5584 " : (bbbbbbbbbbbbbbb //\n" 5585 " ? ccccccccccccccc\n" 5586 " : ddddddddddddddd);"); 5587 verifyFormat( 5588 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5589 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5590 " aaaaaaaaaaaaaaaaaaaaa +\n" 5591 " aaaaaaaaaaaaaaaaaaaaa\n" 5592 " : aaaaaaaaaa;"); 5593 verifyFormat( 5594 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5595 " : aaaaaaaaaaaaaaaaaaaaaa\n" 5596 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5597 5598 FormatStyle NoBinPacking = getLLVMStyle(); 5599 NoBinPacking.BinPackArguments = false; 5600 verifyFormat( 5601 "void f() {\n" 5602 " g(aaa,\n" 5603 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5604 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5605 " ? aaaaaaaaaaaaaaa\n" 5606 " : aaaaaaaaaaaaaaa);\n" 5607 "}", 5608 NoBinPacking); 5609 verifyFormat( 5610 "void f() {\n" 5611 " g(aaa,\n" 5612 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5613 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5614 " ?: aaaaaaaaaaaaaaa);\n" 5615 "}", 5616 NoBinPacking); 5617 5618 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 5619 " // comment.\n" 5620 " ccccccccccccccccccccccccccccccccccccccc\n" 5621 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5622 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 5623 5624 // Assignments in conditional expressions. Apparently not uncommon :-(. 5625 verifyFormat("return a != b\n" 5626 " // comment\n" 5627 " ? a = b\n" 5628 " : a = b;"); 5629 verifyFormat("return a != b\n" 5630 " // comment\n" 5631 " ? a = a != b\n" 5632 " // comment\n" 5633 " ? a = b\n" 5634 " : a\n" 5635 " : a;\n"); 5636 verifyFormat("return a != b\n" 5637 " // comment\n" 5638 " ? a\n" 5639 " : a = a != b\n" 5640 " // comment\n" 5641 " ? a = b\n" 5642 " : a;"); 5643 } 5644 5645 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 5646 FormatStyle Style = getLLVMStyle(); 5647 Style.BreakBeforeTernaryOperators = false; 5648 Style.ColumnLimit = 70; 5649 verifyFormat( 5650 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5651 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5652 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5653 Style); 5654 verifyFormat( 5655 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5656 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5657 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5658 Style); 5659 verifyFormat( 5660 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5661 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5662 Style); 5663 verifyFormat( 5664 "aaaa(aaaaaaaa, aaaaaaaaaa,\n" 5665 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5666 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5667 Style); 5668 verifyFormat( 5669 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 5670 " aaaaaaaaaaaaa);", 5671 Style); 5672 verifyFormat( 5673 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5674 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5675 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5676 " aaaaaaaaaaaaa);", 5677 Style); 5678 verifyFormat( 5679 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5680 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5681 " aaaaaaaaaaaaa);", 5682 Style); 5683 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5684 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5685 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5686 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5687 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5688 Style); 5689 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5690 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5691 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5692 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5693 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5694 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5695 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5696 Style); 5697 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5698 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 5699 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5700 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5701 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5702 Style); 5703 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5704 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5705 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5706 Style); 5707 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5708 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5709 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5710 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5711 Style); 5712 verifyFormat( 5713 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5714 " aaaaaaaaaaaaaaa :\n" 5715 " aaaaaaaaaaaaaaa;", 5716 Style); 5717 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5718 " aaaaaaaaa ?\n" 5719 " b :\n" 5720 " c);", 5721 Style); 5722 verifyFormat("unsigned Indent =\n" 5723 " format(TheLine.First,\n" 5724 " IndentForLevel[TheLine.Level] >= 0 ?\n" 5725 " IndentForLevel[TheLine.Level] :\n" 5726 " TheLine * 2,\n" 5727 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5728 Style); 5729 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5730 " aaaaaaaaaaaaaaa :\n" 5731 " bbbbbbbbbbbbbbb ? //\n" 5732 " ccccccccccccccc :\n" 5733 " ddddddddddddddd;", 5734 Style); 5735 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5736 " aaaaaaaaaaaaaaa :\n" 5737 " (bbbbbbbbbbbbbbb ? //\n" 5738 " ccccccccccccccc :\n" 5739 " ddddddddddddddd);", 5740 Style); 5741 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5742 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 5743 " ccccccccccccccccccccccccccc;", 5744 Style); 5745 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5746 " aaaaa :\n" 5747 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 5748 Style); 5749 } 5750 5751 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 5752 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 5753 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 5754 verifyFormat("bool a = true, b = false;"); 5755 5756 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5757 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 5758 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 5759 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 5760 verifyFormat( 5761 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 5762 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 5763 " d = e && f;"); 5764 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 5765 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 5766 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5767 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 5768 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 5769 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 5770 5771 FormatStyle Style = getGoogleStyle(); 5772 Style.PointerAlignment = FormatStyle::PAS_Left; 5773 Style.DerivePointerAlignment = false; 5774 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5775 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 5776 " *b = bbbbbbbbbbbbbbbbbbb;", 5777 Style); 5778 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5779 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 5780 Style); 5781 verifyFormat("vector<int*> a, b;", Style); 5782 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 5783 } 5784 5785 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 5786 verifyFormat("arr[foo ? bar : baz];"); 5787 verifyFormat("f()[foo ? bar : baz];"); 5788 verifyFormat("(a + b)[foo ? bar : baz];"); 5789 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 5790 } 5791 5792 TEST_F(FormatTest, AlignsStringLiterals) { 5793 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 5794 " \"short literal\");"); 5795 verifyFormat( 5796 "looooooooooooooooooooooooongFunction(\n" 5797 " \"short literal\"\n" 5798 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 5799 verifyFormat("someFunction(\"Always break between multi-line\"\n" 5800 " \" string literals\",\n" 5801 " and, other, parameters);"); 5802 EXPECT_EQ("fun + \"1243\" /* comment */\n" 5803 " \"5678\";", 5804 format("fun + \"1243\" /* comment */\n" 5805 " \"5678\";", 5806 getLLVMStyleWithColumns(28))); 5807 EXPECT_EQ( 5808 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 5809 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 5810 " \"aaaaaaaaaaaaaaaa\";", 5811 format("aaaaaa =" 5812 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 5813 "aaaaaaaaaaaaaaaaaaaaa\" " 5814 "\"aaaaaaaaaaaaaaaa\";")); 5815 verifyFormat("a = a + \"a\"\n" 5816 " \"a\"\n" 5817 " \"a\";"); 5818 verifyFormat("f(\"a\", \"b\"\n" 5819 " \"c\");"); 5820 5821 verifyFormat( 5822 "#define LL_FORMAT \"ll\"\n" 5823 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 5824 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 5825 5826 verifyFormat("#define A(X) \\\n" 5827 " \"aaaaa\" #X \"bbbbbb\" \\\n" 5828 " \"ccccc\"", 5829 getLLVMStyleWithColumns(23)); 5830 verifyFormat("#define A \"def\"\n" 5831 "f(\"abc\" A \"ghi\"\n" 5832 " \"jkl\");"); 5833 5834 verifyFormat("f(L\"a\"\n" 5835 " L\"b\");"); 5836 verifyFormat("#define A(X) \\\n" 5837 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 5838 " L\"ccccc\"", 5839 getLLVMStyleWithColumns(25)); 5840 5841 verifyFormat("f(@\"a\"\n" 5842 " @\"b\");"); 5843 verifyFormat("NSString s = @\"a\"\n" 5844 " @\"b\"\n" 5845 " @\"c\";"); 5846 verifyFormat("NSString s = @\"a\"\n" 5847 " \"b\"\n" 5848 " \"c\";"); 5849 } 5850 5851 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 5852 FormatStyle Style = getLLVMStyle(); 5853 // No declarations or definitions should be moved to own line. 5854 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 5855 verifyFormat("class A {\n" 5856 " int f() { return 1; }\n" 5857 " int g();\n" 5858 "};\n" 5859 "int f() { return 1; }\n" 5860 "int g();\n", 5861 Style); 5862 5863 // All declarations and definitions should have the return type moved to its 5864 // own 5865 // line. 5866 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 5867 verifyFormat("class E {\n" 5868 " int\n" 5869 " f() {\n" 5870 " return 1;\n" 5871 " }\n" 5872 " int\n" 5873 " g();\n" 5874 "};\n" 5875 "int\n" 5876 "f() {\n" 5877 " return 1;\n" 5878 "}\n" 5879 "int\n" 5880 "g();\n", 5881 Style); 5882 5883 // Top-level definitions, and no kinds of declarations should have the 5884 // return type moved to its own line. 5885 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 5886 verifyFormat("class B {\n" 5887 " int f() { return 1; }\n" 5888 " int g();\n" 5889 "};\n" 5890 "int\n" 5891 "f() {\n" 5892 " return 1;\n" 5893 "}\n" 5894 "int g();\n", 5895 Style); 5896 5897 // Top-level definitions and declarations should have the return type moved 5898 // to its own line. 5899 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 5900 verifyFormat("class C {\n" 5901 " int f() { return 1; }\n" 5902 " int g();\n" 5903 "};\n" 5904 "int\n" 5905 "f() {\n" 5906 " return 1;\n" 5907 "}\n" 5908 "int\n" 5909 "g();\n", 5910 Style); 5911 5912 // All definitions should have the return type moved to its own line, but no 5913 // kinds of declarations. 5914 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 5915 verifyFormat("class D {\n" 5916 " int\n" 5917 " f() {\n" 5918 " return 1;\n" 5919 " }\n" 5920 " int g();\n" 5921 "};\n" 5922 "int\n" 5923 "f() {\n" 5924 " return 1;\n" 5925 "}\n" 5926 "int g();\n", 5927 Style); 5928 verifyFormat("const char *\n" 5929 "f(void) {\n" // Break here. 5930 " return \"\";\n" 5931 "}\n" 5932 "const char *bar(void);\n", // No break here. 5933 Style); 5934 verifyFormat("template <class T>\n" 5935 "T *\n" 5936 "f(T &c) {\n" // Break here. 5937 " return NULL;\n" 5938 "}\n" 5939 "template <class T> T *f(T &c);\n", // No break here. 5940 Style); 5941 verifyFormat("class C {\n" 5942 " int\n" 5943 " operator+() {\n" 5944 " return 1;\n" 5945 " }\n" 5946 " int\n" 5947 " operator()() {\n" 5948 " return 1;\n" 5949 " }\n" 5950 "};\n", 5951 Style); 5952 verifyFormat("void\n" 5953 "A::operator()() {}\n" 5954 "void\n" 5955 "A::operator>>() {}\n" 5956 "void\n" 5957 "A::operator+() {}\n", 5958 Style); 5959 verifyFormat("void *operator new(std::size_t s);", // No break here. 5960 Style); 5961 verifyFormat("void *\n" 5962 "operator new(std::size_t s) {}", 5963 Style); 5964 verifyFormat("void *\n" 5965 "operator delete[](void *ptr) {}", 5966 Style); 5967 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 5968 verifyFormat("const char *\n" 5969 "f(void)\n" // Break here. 5970 "{\n" 5971 " return \"\";\n" 5972 "}\n" 5973 "const char *bar(void);\n", // No break here. 5974 Style); 5975 verifyFormat("template <class T>\n" 5976 "T *\n" // Problem here: no line break 5977 "f(T &c)\n" // Break here. 5978 "{\n" 5979 " return NULL;\n" 5980 "}\n" 5981 "template <class T> T *f(T &c);\n", // No break here. 5982 Style); 5983 verifyFormat("int\n" 5984 "foo(A<bool> a)\n" 5985 "{\n" 5986 " return a;\n" 5987 "}\n", 5988 Style); 5989 verifyFormat("int\n" 5990 "foo(A<8> a)\n" 5991 "{\n" 5992 " return a;\n" 5993 "}\n", 5994 Style); 5995 verifyFormat("int\n" 5996 "foo(A<B<bool>, 8> a)\n" 5997 "{\n" 5998 " return a;\n" 5999 "}\n", 6000 Style); 6001 verifyFormat("int\n" 6002 "foo(A<B<8>, bool> a)\n" 6003 "{\n" 6004 " return a;\n" 6005 "}\n", 6006 Style); 6007 verifyFormat("int\n" 6008 "foo(A<B<bool>, bool> a)\n" 6009 "{\n" 6010 " return a;\n" 6011 "}\n", 6012 Style); 6013 verifyFormat("int\n" 6014 "foo(A<B<8>, 8> a)\n" 6015 "{\n" 6016 " return a;\n" 6017 "}\n", 6018 Style); 6019 6020 Style = getGNUStyle(); 6021 6022 // Test for comments at the end of function declarations. 6023 verifyFormat("void\n" 6024 "foo (int a, /*abc*/ int b) // def\n" 6025 "{\n" 6026 "}\n", 6027 Style); 6028 6029 verifyFormat("void\n" 6030 "foo (int a, /* abc */ int b) /* def */\n" 6031 "{\n" 6032 "}\n", 6033 Style); 6034 6035 // Definitions that should not break after return type 6036 verifyFormat("void foo (int a, int b); // def\n", Style); 6037 verifyFormat("void foo (int a, int b); /* def */\n", Style); 6038 verifyFormat("void foo (int a, int b);\n", Style); 6039 } 6040 6041 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 6042 FormatStyle NoBreak = getLLVMStyle(); 6043 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 6044 FormatStyle Break = getLLVMStyle(); 6045 Break.AlwaysBreakBeforeMultilineStrings = true; 6046 verifyFormat("aaaa = \"bbbb\"\n" 6047 " \"cccc\";", 6048 NoBreak); 6049 verifyFormat("aaaa =\n" 6050 " \"bbbb\"\n" 6051 " \"cccc\";", 6052 Break); 6053 verifyFormat("aaaa(\"bbbb\"\n" 6054 " \"cccc\");", 6055 NoBreak); 6056 verifyFormat("aaaa(\n" 6057 " \"bbbb\"\n" 6058 " \"cccc\");", 6059 Break); 6060 verifyFormat("aaaa(qqq, \"bbbb\"\n" 6061 " \"cccc\");", 6062 NoBreak); 6063 verifyFormat("aaaa(qqq,\n" 6064 " \"bbbb\"\n" 6065 " \"cccc\");", 6066 Break); 6067 verifyFormat("aaaa(qqq,\n" 6068 " L\"bbbb\"\n" 6069 " L\"cccc\");", 6070 Break); 6071 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 6072 " \"bbbb\"));", 6073 Break); 6074 verifyFormat("string s = someFunction(\n" 6075 " \"abc\"\n" 6076 " \"abc\");", 6077 Break); 6078 6079 // As we break before unary operators, breaking right after them is bad. 6080 verifyFormat("string foo = abc ? \"x\"\n" 6081 " \"blah blah blah blah blah blah\"\n" 6082 " : \"y\";", 6083 Break); 6084 6085 // Don't break if there is no column gain. 6086 verifyFormat("f(\"aaaa\"\n" 6087 " \"bbbb\");", 6088 Break); 6089 6090 // Treat literals with escaped newlines like multi-line string literals. 6091 EXPECT_EQ("x = \"a\\\n" 6092 "b\\\n" 6093 "c\";", 6094 format("x = \"a\\\n" 6095 "b\\\n" 6096 "c\";", 6097 NoBreak)); 6098 EXPECT_EQ("xxxx =\n" 6099 " \"a\\\n" 6100 "b\\\n" 6101 "c\";", 6102 format("xxxx = \"a\\\n" 6103 "b\\\n" 6104 "c\";", 6105 Break)); 6106 6107 EXPECT_EQ("NSString *const kString =\n" 6108 " @\"aaaa\"\n" 6109 " @\"bbbb\";", 6110 format("NSString *const kString = @\"aaaa\"\n" 6111 "@\"bbbb\";", 6112 Break)); 6113 6114 Break.ColumnLimit = 0; 6115 verifyFormat("const char *hello = \"hello llvm\";", Break); 6116 } 6117 6118 TEST_F(FormatTest, AlignsPipes) { 6119 verifyFormat( 6120 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6121 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6122 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6123 verifyFormat( 6124 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 6125 " << aaaaaaaaaaaaaaaaaaaa;"); 6126 verifyFormat( 6127 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6128 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6129 verifyFormat( 6130 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 6131 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6132 verifyFormat( 6133 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 6134 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 6135 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 6136 verifyFormat( 6137 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6138 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6139 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6140 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6141 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6142 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6143 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6144 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 6145 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 6146 verifyFormat( 6147 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6148 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6149 verifyFormat( 6150 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 6151 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6152 6153 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 6154 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 6155 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6156 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6157 " aaaaaaaaaaaaaaaaaaaaa)\n" 6158 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6159 verifyFormat("LOG_IF(aaa == //\n" 6160 " bbb)\n" 6161 " << a << b;"); 6162 6163 // But sometimes, breaking before the first "<<" is desirable. 6164 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6165 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 6166 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 6167 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6168 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6169 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 6170 " << BEF << IsTemplate << Description << E->getType();"); 6171 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6172 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6173 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6174 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6175 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6176 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6177 " << aaa;"); 6178 6179 verifyFormat( 6180 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6181 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6182 6183 // Incomplete string literal. 6184 EXPECT_EQ("llvm::errs() << \"\n" 6185 " << a;", 6186 format("llvm::errs() << \"\n<<a;")); 6187 6188 verifyFormat("void f() {\n" 6189 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 6190 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 6191 "}"); 6192 6193 // Handle 'endl'. 6194 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 6195 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6196 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6197 6198 // Handle '\n'. 6199 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 6200 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6201 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 6202 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 6203 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 6204 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 6205 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6206 } 6207 6208 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 6209 verifyFormat("return out << \"somepacket = {\\n\"\n" 6210 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 6211 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 6212 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 6213 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 6214 " << \"}\";"); 6215 6216 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6217 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6218 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 6219 verifyFormat( 6220 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 6221 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 6222 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 6223 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 6224 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 6225 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 6226 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6227 verifyFormat( 6228 "void f() {\n" 6229 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 6230 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 6231 "}"); 6232 6233 // Breaking before the first "<<" is generally not desirable. 6234 verifyFormat( 6235 "llvm::errs()\n" 6236 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6237 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6238 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6239 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6240 getLLVMStyleWithColumns(70)); 6241 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6242 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6243 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6244 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6245 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6246 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6247 getLLVMStyleWithColumns(70)); 6248 6249 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6250 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6251 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6252 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6253 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6254 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 6255 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 6256 " (aaaa + aaaa);", 6257 getLLVMStyleWithColumns(40)); 6258 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 6259 " (aaaaaaa + aaaaa));", 6260 getLLVMStyleWithColumns(40)); 6261 verifyFormat( 6262 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 6263 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 6264 " bbbbbbbbbbbbbbbbbbbbbbb);"); 6265 } 6266 6267 TEST_F(FormatTest, UnderstandsEquals) { 6268 verifyFormat( 6269 "aaaaaaaaaaaaaaaaa =\n" 6270 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6271 verifyFormat( 6272 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6273 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6274 verifyFormat( 6275 "if (a) {\n" 6276 " f();\n" 6277 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6278 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 6279 "}"); 6280 6281 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6282 " 100000000 + 10000000) {\n}"); 6283 } 6284 6285 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 6286 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6287 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 6288 6289 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6290 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 6291 6292 verifyFormat( 6293 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 6294 " Parameter2);"); 6295 6296 verifyFormat( 6297 "ShortObject->shortFunction(\n" 6298 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 6299 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 6300 6301 verifyFormat("loooooooooooooongFunction(\n" 6302 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 6303 6304 verifyFormat( 6305 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 6306 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 6307 6308 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6309 " .WillRepeatedly(Return(SomeValue));"); 6310 verifyFormat("void f() {\n" 6311 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6312 " .Times(2)\n" 6313 " .WillRepeatedly(Return(SomeValue));\n" 6314 "}"); 6315 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 6316 " ccccccccccccccccccccccc);"); 6317 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6318 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6319 " .aaaaa(aaaaa),\n" 6320 " aaaaaaaaaaaaaaaaaaaaa);"); 6321 verifyFormat("void f() {\n" 6322 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6323 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 6324 "}"); 6325 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6326 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6327 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6328 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6329 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6330 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6331 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6332 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6333 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 6334 "}"); 6335 6336 // Here, it is not necessary to wrap at "." or "->". 6337 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 6338 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6339 verifyFormat( 6340 "aaaaaaaaaaa->aaaaaaaaa(\n" 6341 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6342 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 6343 6344 verifyFormat( 6345 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6346 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 6347 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 6348 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6349 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 6350 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6351 6352 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6353 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6354 " .a();"); 6355 6356 FormatStyle NoBinPacking = getLLVMStyle(); 6357 NoBinPacking.BinPackParameters = false; 6358 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6359 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6360 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 6361 " aaaaaaaaaaaaaaaaaaa,\n" 6362 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6363 NoBinPacking); 6364 6365 // If there is a subsequent call, change to hanging indentation. 6366 verifyFormat( 6367 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6368 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 6369 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6370 verifyFormat( 6371 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6372 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 6373 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6374 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6375 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6376 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6377 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6378 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6379 } 6380 6381 TEST_F(FormatTest, WrapsTemplateDeclarations) { 6382 verifyFormat("template <typename T>\n" 6383 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6384 verifyFormat("template <typename T>\n" 6385 "// T should be one of {A, B}.\n" 6386 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6387 verifyFormat( 6388 "template <typename T>\n" 6389 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 6390 verifyFormat("template <typename T>\n" 6391 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 6392 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 6393 verifyFormat( 6394 "template <typename T>\n" 6395 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 6396 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 6397 verifyFormat( 6398 "template <typename T>\n" 6399 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 6400 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 6401 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6402 verifyFormat("template <typename T>\n" 6403 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6404 " int aaaaaaaaaaaaaaaaaaaaaa);"); 6405 verifyFormat( 6406 "template <typename T1, typename T2 = char, typename T3 = char,\n" 6407 " typename T4 = char>\n" 6408 "void f();"); 6409 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 6410 " template <typename> class cccccccccccccccccccccc,\n" 6411 " typename ddddddddddddd>\n" 6412 "class C {};"); 6413 verifyFormat( 6414 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 6415 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6416 6417 verifyFormat("void f() {\n" 6418 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 6419 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 6420 "}"); 6421 6422 verifyFormat("template <typename T> class C {};"); 6423 verifyFormat("template <typename T> void f();"); 6424 verifyFormat("template <typename T> void f() {}"); 6425 verifyFormat( 6426 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6427 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6428 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 6429 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6430 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6431 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 6432 " bbbbbbbbbbbbbbbbbbbbbbbb);", 6433 getLLVMStyleWithColumns(72)); 6434 EXPECT_EQ("static_cast<A< //\n" 6435 " B> *>(\n" 6436 "\n" 6437 ");", 6438 format("static_cast<A<//\n" 6439 " B>*>(\n" 6440 "\n" 6441 " );")); 6442 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6443 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 6444 6445 FormatStyle AlwaysBreak = getLLVMStyle(); 6446 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 6447 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 6448 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 6449 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 6450 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6451 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6452 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 6453 verifyFormat("template <template <typename> class Fooooooo,\n" 6454 " template <typename> class Baaaaaaar>\n" 6455 "struct C {};", 6456 AlwaysBreak); 6457 verifyFormat("template <typename T> // T can be A, B or C.\n" 6458 "struct C {};", 6459 AlwaysBreak); 6460 verifyFormat("template <enum E> class A {\n" 6461 "public:\n" 6462 " E *f();\n" 6463 "};"); 6464 6465 FormatStyle NeverBreak = getLLVMStyle(); 6466 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 6467 verifyFormat("template <typename T> class C {};", NeverBreak); 6468 verifyFormat("template <typename T> void f();", NeverBreak); 6469 verifyFormat("template <typename T> void f() {}", NeverBreak); 6470 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbb) {}", 6471 NeverBreak); 6472 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6473 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6474 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 6475 NeverBreak); 6476 verifyFormat("template <template <typename> class Fooooooo,\n" 6477 " template <typename> class Baaaaaaar>\n" 6478 "struct C {};", 6479 NeverBreak); 6480 verifyFormat("template <typename T> // T can be A, B or C.\n" 6481 "struct C {};", 6482 NeverBreak); 6483 verifyFormat("template <enum E> class A {\n" 6484 "public:\n" 6485 " E *f();\n" 6486 "};", NeverBreak); 6487 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 6488 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbb) {}", 6489 NeverBreak); 6490 } 6491 6492 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 6493 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 6494 Style.ColumnLimit = 60; 6495 EXPECT_EQ("// Baseline - no comments.\n" 6496 "template <\n" 6497 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6498 "void f() {}", 6499 format("// Baseline - no comments.\n" 6500 "template <\n" 6501 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6502 "void f() {}", 6503 Style)); 6504 6505 EXPECT_EQ("template <\n" 6506 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6507 "void f() {}", 6508 format("template <\n" 6509 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6510 "void f() {}", 6511 Style)); 6512 6513 EXPECT_EQ( 6514 "template <\n" 6515 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6516 "void f() {}", 6517 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6518 "void f() {}", 6519 Style)); 6520 6521 EXPECT_EQ( 6522 "template <\n" 6523 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6524 " // multiline\n" 6525 "void f() {}", 6526 format("template <\n" 6527 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6528 " // multiline\n" 6529 "void f() {}", 6530 Style)); 6531 6532 EXPECT_EQ( 6533 "template <typename aaaaaaaaaa<\n" 6534 " bbbbbbbbbbbb>::value> // trailing loooong\n" 6535 "void f() {}", 6536 format( 6537 "template <\n" 6538 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 6539 "void f() {}", 6540 Style)); 6541 } 6542 6543 TEST_F(FormatTest, WrapsTemplateParameters) { 6544 FormatStyle Style = getLLVMStyle(); 6545 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6546 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6547 verifyFormat( 6548 "template <typename... a> struct q {};\n" 6549 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6550 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6551 " y;", 6552 Style); 6553 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6554 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6555 verifyFormat( 6556 "template <typename... a> struct r {};\n" 6557 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6558 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6559 " y;", 6560 Style); 6561 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6562 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6563 verifyFormat( 6564 "template <typename... a> struct s {};\n" 6565 "extern s<\n" 6566 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 6567 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n" 6568 " y;", 6569 Style); 6570 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6571 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6572 verifyFormat( 6573 "template <typename... a> struct t {};\n" 6574 "extern t<\n" 6575 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 6576 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n" 6577 " y;", 6578 Style); 6579 } 6580 6581 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 6582 verifyFormat( 6583 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6584 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6585 verifyFormat( 6586 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6587 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6588 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6589 6590 // FIXME: Should we have the extra indent after the second break? 6591 verifyFormat( 6592 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6593 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6594 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6595 6596 verifyFormat( 6597 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 6598 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 6599 6600 // Breaking at nested name specifiers is generally not desirable. 6601 verifyFormat( 6602 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6603 " aaaaaaaaaaaaaaaaaaaaaaa);"); 6604 6605 verifyFormat( 6606 "aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 6607 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6608 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6609 " aaaaaaaaaaaaaaaaaaaaa);", 6610 getLLVMStyleWithColumns(74)); 6611 6612 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6613 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6614 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6615 } 6616 6617 TEST_F(FormatTest, UnderstandsTemplateParameters) { 6618 verifyFormat("A<int> a;"); 6619 verifyFormat("A<A<A<int>>> a;"); 6620 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 6621 verifyFormat("bool x = a < 1 || 2 > a;"); 6622 verifyFormat("bool x = 5 < f<int>();"); 6623 verifyFormat("bool x = f<int>() > 5;"); 6624 verifyFormat("bool x = 5 < a<int>::x;"); 6625 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 6626 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 6627 6628 verifyGoogleFormat("A<A<int>> a;"); 6629 verifyGoogleFormat("A<A<A<int>>> a;"); 6630 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 6631 verifyGoogleFormat("A<A<int> > a;"); 6632 verifyGoogleFormat("A<A<A<int> > > a;"); 6633 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 6634 verifyGoogleFormat("A<::A<int>> a;"); 6635 verifyGoogleFormat("A<::A> a;"); 6636 verifyGoogleFormat("A< ::A> a;"); 6637 verifyGoogleFormat("A< ::A<int> > a;"); 6638 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 6639 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 6640 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 6641 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 6642 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 6643 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 6644 6645 verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 6646 6647 // template closer followed by a token that starts with > or = 6648 verifyFormat("bool b = a<1> > 1;"); 6649 verifyFormat("bool b = a<1> >= 1;"); 6650 verifyFormat("int i = a<1> >> 1;"); 6651 FormatStyle Style = getLLVMStyle(); 6652 Style.SpaceBeforeAssignmentOperators = false; 6653 verifyFormat("bool b= a<1> == 1;", Style); 6654 verifyFormat("a<int> = 1;", Style); 6655 verifyFormat("a<int> >>= 1;", Style); 6656 6657 verifyFormat("test >> a >> b;"); 6658 verifyFormat("test << a >> b;"); 6659 6660 verifyFormat("f<int>();"); 6661 verifyFormat("template <typename T> void f() {}"); 6662 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 6663 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 6664 "sizeof(char)>::type>;"); 6665 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 6666 verifyFormat("f(a.operator()<A>());"); 6667 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6668 " .template operator()<A>());", 6669 getLLVMStyleWithColumns(35)); 6670 6671 // Not template parameters. 6672 verifyFormat("return a < b && c > d;"); 6673 verifyFormat("void f() {\n" 6674 " while (a < b && c > d) {\n" 6675 " }\n" 6676 "}"); 6677 verifyFormat("template <typename... Types>\n" 6678 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 6679 6680 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6681 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 6682 getLLVMStyleWithColumns(60)); 6683 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 6684 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 6685 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 6686 } 6687 6688 TEST_F(FormatTest, BitshiftOperatorWidth) { 6689 EXPECT_EQ("int a = 1 << 2; /* foo\n" 6690 " bar */", 6691 format("int a=1<<2; /* foo\n" 6692 " bar */")); 6693 6694 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 6695 " bar */", 6696 format("int b =256>>1 ; /* foo\n" 6697 " bar */")); 6698 } 6699 6700 TEST_F(FormatTest, UnderstandsBinaryOperators) { 6701 verifyFormat("COMPARE(a, ==, b);"); 6702 verifyFormat("auto s = sizeof...(Ts) - 1;"); 6703 } 6704 6705 TEST_F(FormatTest, UnderstandsPointersToMembers) { 6706 verifyFormat("int A::*x;"); 6707 verifyFormat("int (S::*func)(void *);"); 6708 verifyFormat("void f() { int (S::*func)(void *); }"); 6709 verifyFormat("typedef bool *(Class::*Member)() const;"); 6710 verifyFormat("void f() {\n" 6711 " (a->*f)();\n" 6712 " a->*x;\n" 6713 " (a.*f)();\n" 6714 " ((*a).*f)();\n" 6715 " a.*x;\n" 6716 "}"); 6717 verifyFormat("void f() {\n" 6718 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 6719 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 6720 "}"); 6721 verifyFormat( 6722 "(aaaaaaaaaa->*bbbbbbb)(\n" 6723 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6724 FormatStyle Style = getLLVMStyle(); 6725 Style.PointerAlignment = FormatStyle::PAS_Left; 6726 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 6727 } 6728 6729 TEST_F(FormatTest, UnderstandsUnaryOperators) { 6730 verifyFormat("int a = -2;"); 6731 verifyFormat("f(-1, -2, -3);"); 6732 verifyFormat("a[-1] = 5;"); 6733 verifyFormat("int a = 5 + -2;"); 6734 verifyFormat("if (i == -1) {\n}"); 6735 verifyFormat("if (i != -1) {\n}"); 6736 verifyFormat("if (i > -1) {\n}"); 6737 verifyFormat("if (i < -1) {\n}"); 6738 verifyFormat("++(a->f());"); 6739 verifyFormat("--(a->f());"); 6740 verifyFormat("(a->f())++;"); 6741 verifyFormat("a[42]++;"); 6742 verifyFormat("if (!(a->f())) {\n}"); 6743 verifyFormat("if (!+i) {\n}"); 6744 verifyFormat("~&a;"); 6745 6746 verifyFormat("a-- > b;"); 6747 verifyFormat("b ? -a : c;"); 6748 verifyFormat("n * sizeof char16;"); 6749 verifyFormat("n * alignof char16;", getGoogleStyle()); 6750 verifyFormat("sizeof(char);"); 6751 verifyFormat("alignof(char);", getGoogleStyle()); 6752 6753 verifyFormat("return -1;"); 6754 verifyFormat("switch (a) {\n" 6755 "case -1:\n" 6756 " break;\n" 6757 "}"); 6758 verifyFormat("#define X -1"); 6759 verifyFormat("#define X -kConstant"); 6760 6761 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 6762 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 6763 6764 verifyFormat("int a = /* confusing comment */ -1;"); 6765 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 6766 verifyFormat("int a = i /* confusing comment */++;"); 6767 } 6768 6769 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 6770 verifyFormat("if (!aaaaaaaaaa( // break\n" 6771 " aaaaa)) {\n" 6772 "}"); 6773 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 6774 " aaaaa));"); 6775 verifyFormat("*aaa = aaaaaaa( // break\n" 6776 " bbbbbb);"); 6777 } 6778 6779 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 6780 verifyFormat("bool operator<();"); 6781 verifyFormat("bool operator>();"); 6782 verifyFormat("bool operator=();"); 6783 verifyFormat("bool operator==();"); 6784 verifyFormat("bool operator!=();"); 6785 verifyFormat("int operator+();"); 6786 verifyFormat("int operator++();"); 6787 verifyFormat("int operator++(int) volatile noexcept;"); 6788 verifyFormat("bool operator,();"); 6789 verifyFormat("bool operator();"); 6790 verifyFormat("bool operator()();"); 6791 verifyFormat("bool operator[]();"); 6792 verifyFormat("operator bool();"); 6793 verifyFormat("operator int();"); 6794 verifyFormat("operator void *();"); 6795 verifyFormat("operator SomeType<int>();"); 6796 verifyFormat("operator SomeType<int, int>();"); 6797 verifyFormat("operator SomeType<SomeType<int>>();"); 6798 verifyFormat("void *operator new(std::size_t size);"); 6799 verifyFormat("void *operator new[](std::size_t size);"); 6800 verifyFormat("void operator delete(void *ptr);"); 6801 verifyFormat("void operator delete[](void *ptr);"); 6802 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 6803 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 6804 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 6805 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 6806 6807 verifyFormat( 6808 "ostream &operator<<(ostream &OutputStream,\n" 6809 " SomeReallyLongType WithSomeReallyLongValue);"); 6810 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 6811 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 6812 " return left.group < right.group;\n" 6813 "}"); 6814 verifyFormat("SomeType &operator=(const SomeType &S);"); 6815 verifyFormat("f.template operator()<int>();"); 6816 6817 verifyGoogleFormat("operator void*();"); 6818 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 6819 verifyGoogleFormat("operator ::A();"); 6820 6821 verifyFormat("using A::operator+;"); 6822 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 6823 "int i;"); 6824 } 6825 6826 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 6827 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 6828 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 6829 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 6830 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 6831 verifyFormat("Deleted &operator=(const Deleted &) &;"); 6832 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 6833 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 6834 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 6835 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 6836 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 6837 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 6838 verifyFormat("void Fn(T const &) const &;"); 6839 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 6840 verifyFormat("template <typename T>\n" 6841 "void F(T) && = delete;", 6842 getGoogleStyle()); 6843 6844 FormatStyle AlignLeft = getLLVMStyle(); 6845 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 6846 verifyFormat("void A::b() && {}", AlignLeft); 6847 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 6848 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 6849 AlignLeft); 6850 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 6851 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 6852 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 6853 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 6854 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 6855 verifyFormat("auto Function(T) & -> void;", AlignLeft); 6856 verifyFormat("void Fn(T const&) const&;", AlignLeft); 6857 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 6858 6859 FormatStyle Spaces = getLLVMStyle(); 6860 Spaces.SpacesInCStyleCastParentheses = true; 6861 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 6862 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 6863 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 6864 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 6865 6866 Spaces.SpacesInCStyleCastParentheses = false; 6867 Spaces.SpacesInParentheses = true; 6868 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 6869 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", Spaces); 6870 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 6871 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 6872 } 6873 6874 TEST_F(FormatTest, UnderstandsNewAndDelete) { 6875 verifyFormat("void f() {\n" 6876 " A *a = new A;\n" 6877 " A *a = new (placement) A;\n" 6878 " delete a;\n" 6879 " delete (A *)a;\n" 6880 "}"); 6881 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 6882 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 6883 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6884 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 6885 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 6886 verifyFormat("delete[] h->p;"); 6887 } 6888 6889 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 6890 verifyFormat("int *f(int *a) {}"); 6891 verifyFormat("int main(int argc, char **argv) {}"); 6892 verifyFormat("Test::Test(int b) : a(b * b) {}"); 6893 verifyIndependentOfContext("f(a, *a);"); 6894 verifyFormat("void g() { f(*a); }"); 6895 verifyIndependentOfContext("int a = b * 10;"); 6896 verifyIndependentOfContext("int a = 10 * b;"); 6897 verifyIndependentOfContext("int a = b * c;"); 6898 verifyIndependentOfContext("int a += b * c;"); 6899 verifyIndependentOfContext("int a -= b * c;"); 6900 verifyIndependentOfContext("int a *= b * c;"); 6901 verifyIndependentOfContext("int a /= b * c;"); 6902 verifyIndependentOfContext("int a = *b;"); 6903 verifyIndependentOfContext("int a = *b * c;"); 6904 verifyIndependentOfContext("int a = b * *c;"); 6905 verifyIndependentOfContext("int a = b * (10);"); 6906 verifyIndependentOfContext("S << b * (10);"); 6907 verifyIndependentOfContext("return 10 * b;"); 6908 verifyIndependentOfContext("return *b * *c;"); 6909 verifyIndependentOfContext("return a & ~b;"); 6910 verifyIndependentOfContext("f(b ? *c : *d);"); 6911 verifyIndependentOfContext("int a = b ? *c : *d;"); 6912 verifyIndependentOfContext("*b = a;"); 6913 verifyIndependentOfContext("a * ~b;"); 6914 verifyIndependentOfContext("a * !b;"); 6915 verifyIndependentOfContext("a * +b;"); 6916 verifyIndependentOfContext("a * -b;"); 6917 verifyIndependentOfContext("a * ++b;"); 6918 verifyIndependentOfContext("a * --b;"); 6919 verifyIndependentOfContext("a[4] * b;"); 6920 verifyIndependentOfContext("a[a * a] = 1;"); 6921 verifyIndependentOfContext("f() * b;"); 6922 verifyIndependentOfContext("a * [self dostuff];"); 6923 verifyIndependentOfContext("int x = a * (a + b);"); 6924 verifyIndependentOfContext("(a *)(a + b);"); 6925 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 6926 verifyIndependentOfContext("int *pa = (int *)&a;"); 6927 verifyIndependentOfContext("return sizeof(int **);"); 6928 verifyIndependentOfContext("return sizeof(int ******);"); 6929 verifyIndependentOfContext("return (int **&)a;"); 6930 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 6931 verifyFormat("void f(Type (*parameter)[10]) {}"); 6932 verifyFormat("void f(Type (¶meter)[10]) {}"); 6933 verifyGoogleFormat("return sizeof(int**);"); 6934 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 6935 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 6936 verifyFormat("auto a = [](int **&, int ***) {};"); 6937 verifyFormat("auto PointerBinding = [](const char *S) {};"); 6938 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 6939 verifyFormat("[](const decltype(*a) &value) {}"); 6940 verifyFormat("decltype(a * b) F();"); 6941 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 6942 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 6943 verifyIndependentOfContext("typedef void (*f)(int *a);"); 6944 verifyIndependentOfContext("int i{a * b};"); 6945 verifyIndependentOfContext("aaa && aaa->f();"); 6946 verifyIndependentOfContext("int x = ~*p;"); 6947 verifyFormat("Constructor() : a(a), area(width * height) {}"); 6948 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 6949 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 6950 verifyFormat("void f() { f(a, c * d); }"); 6951 verifyFormat("void f() { f(new a(), c * d); }"); 6952 verifyFormat("void f(const MyOverride &override);"); 6953 verifyFormat("void f(const MyFinal &final);"); 6954 verifyIndependentOfContext("bool a = f() && override.f();"); 6955 verifyIndependentOfContext("bool a = f() && final.f();"); 6956 6957 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 6958 6959 verifyIndependentOfContext("A<int *> a;"); 6960 verifyIndependentOfContext("A<int **> a;"); 6961 verifyIndependentOfContext("A<int *, int *> a;"); 6962 verifyIndependentOfContext("A<int *[]> a;"); 6963 verifyIndependentOfContext( 6964 "const char *const p = reinterpret_cast<const char *const>(q);"); 6965 verifyIndependentOfContext("A<int **, int **> a;"); 6966 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 6967 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 6968 verifyFormat("for (; a && b;) {\n}"); 6969 verifyFormat("bool foo = true && [] { return false; }();"); 6970 6971 verifyFormat( 6972 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6973 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6974 6975 verifyGoogleFormat("int const* a = &b;"); 6976 verifyGoogleFormat("**outparam = 1;"); 6977 verifyGoogleFormat("*outparam = a * b;"); 6978 verifyGoogleFormat("int main(int argc, char** argv) {}"); 6979 verifyGoogleFormat("A<int*> a;"); 6980 verifyGoogleFormat("A<int**> a;"); 6981 verifyGoogleFormat("A<int*, int*> a;"); 6982 verifyGoogleFormat("A<int**, int**> a;"); 6983 verifyGoogleFormat("f(b ? *c : *d);"); 6984 verifyGoogleFormat("int a = b ? *c : *d;"); 6985 verifyGoogleFormat("Type* t = **x;"); 6986 verifyGoogleFormat("Type* t = *++*x;"); 6987 verifyGoogleFormat("*++*x;"); 6988 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 6989 verifyGoogleFormat("Type* t = x++ * y;"); 6990 verifyGoogleFormat( 6991 "const char* const p = reinterpret_cast<const char* const>(q);"); 6992 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 6993 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 6994 verifyGoogleFormat("template <typename T>\n" 6995 "void f(int i = 0, SomeType** temps = NULL);"); 6996 6997 FormatStyle Left = getLLVMStyle(); 6998 Left.PointerAlignment = FormatStyle::PAS_Left; 6999 verifyFormat("x = *a(x) = *a(y);", Left); 7000 verifyFormat("for (;; *a = b) {\n}", Left); 7001 verifyFormat("return *this += 1;", Left); 7002 verifyFormat("throw *x;", Left); 7003 verifyFormat("delete *x;", Left); 7004 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 7005 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 7006 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 7007 7008 verifyIndependentOfContext("a = *(x + y);"); 7009 verifyIndependentOfContext("a = &(x + y);"); 7010 verifyIndependentOfContext("*(x + y).call();"); 7011 verifyIndependentOfContext("&(x + y)->call();"); 7012 verifyFormat("void f() { &(*I).first; }"); 7013 7014 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 7015 verifyFormat( 7016 "int *MyValues = {\n" 7017 " *A, // Operator detection might be confused by the '{'\n" 7018 " *BB // Operator detection might be confused by previous comment\n" 7019 "};"); 7020 7021 verifyIndependentOfContext("if (int *a = &b)"); 7022 verifyIndependentOfContext("if (int &a = *b)"); 7023 verifyIndependentOfContext("if (a & b[i])"); 7024 verifyIndependentOfContext("if constexpr (a & b[i])"); 7025 verifyIndependentOfContext("if CONSTEXPR (a & b[i])"); 7026 verifyIndependentOfContext("if (a * (b * c))"); 7027 verifyIndependentOfContext("if constexpr (a * (b * c))"); 7028 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))"); 7029 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 7030 verifyIndependentOfContext("if (*b[i])"); 7031 verifyIndependentOfContext("if (int *a = (&b))"); 7032 verifyIndependentOfContext("while (int *a = &b)"); 7033 verifyIndependentOfContext("while (a * (b * c))"); 7034 verifyIndependentOfContext("size = sizeof *a;"); 7035 verifyIndependentOfContext("if (a && (b = c))"); 7036 verifyFormat("void f() {\n" 7037 " for (const int &v : Values) {\n" 7038 " }\n" 7039 "}"); 7040 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 7041 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 7042 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 7043 7044 verifyFormat("#define A (!a * b)"); 7045 verifyFormat("#define MACRO \\\n" 7046 " int *i = a * b; \\\n" 7047 " void f(a *b);", 7048 getLLVMStyleWithColumns(19)); 7049 7050 verifyIndependentOfContext("A = new SomeType *[Length];"); 7051 verifyIndependentOfContext("A = new SomeType *[Length]();"); 7052 verifyIndependentOfContext("T **t = new T *;"); 7053 verifyIndependentOfContext("T **t = new T *();"); 7054 verifyGoogleFormat("A = new SomeType*[Length]();"); 7055 verifyGoogleFormat("A = new SomeType*[Length];"); 7056 verifyGoogleFormat("T** t = new T*;"); 7057 verifyGoogleFormat("T** t = new T*();"); 7058 7059 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 7060 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 7061 verifyFormat("template <bool a, bool b> " 7062 "typename t::if<x && y>::type f() {}"); 7063 verifyFormat("template <int *y> f() {}"); 7064 verifyFormat("vector<int *> v;"); 7065 verifyFormat("vector<int *const> v;"); 7066 verifyFormat("vector<int *const **const *> v;"); 7067 verifyFormat("vector<int *volatile> v;"); 7068 verifyFormat("vector<a * b> v;"); 7069 verifyFormat("foo<b && false>();"); 7070 verifyFormat("foo<b & 1>();"); 7071 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 7072 verifyFormat( 7073 "template <class T, class = typename std::enable_if<\n" 7074 " std::is_integral<T>::value &&\n" 7075 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 7076 "void F();", 7077 getLLVMStyleWithColumns(70)); 7078 verifyFormat( 7079 "template <class T,\n" 7080 " class = typename std::enable_if<\n" 7081 " std::is_integral<T>::value &&\n" 7082 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 7083 " class U>\n" 7084 "void F();", 7085 getLLVMStyleWithColumns(70)); 7086 verifyFormat( 7087 "template <class T,\n" 7088 " class = typename ::std::enable_if<\n" 7089 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 7090 "void F();", 7091 getGoogleStyleWithColumns(68)); 7092 7093 verifyIndependentOfContext("MACRO(int *i);"); 7094 verifyIndependentOfContext("MACRO(auto *a);"); 7095 verifyIndependentOfContext("MACRO(const A *a);"); 7096 verifyIndependentOfContext("MACRO(A *const a);"); 7097 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 7098 verifyFormat("void f() { f(float{1}, a * a); }"); 7099 // FIXME: Is there a way to make this work? 7100 // verifyIndependentOfContext("MACRO(A *a);"); 7101 7102 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 7103 verifyFormat("return options != nullptr && operator==(*options);"); 7104 7105 EXPECT_EQ("#define OP(x) \\\n" 7106 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7107 " return s << a.DebugString(); \\\n" 7108 " }", 7109 format("#define OP(x) \\\n" 7110 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7111 " return s << a.DebugString(); \\\n" 7112 " }", 7113 getLLVMStyleWithColumns(50))); 7114 7115 // FIXME: We cannot handle this case yet; we might be able to figure out that 7116 // foo<x> d > v; doesn't make sense. 7117 verifyFormat("foo<a<b && c> d> v;"); 7118 7119 FormatStyle PointerMiddle = getLLVMStyle(); 7120 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7121 verifyFormat("delete *x;", PointerMiddle); 7122 verifyFormat("int * x;", PointerMiddle); 7123 verifyFormat("int *[] x;", PointerMiddle); 7124 verifyFormat("template <int * y> f() {}", PointerMiddle); 7125 verifyFormat("int * f(int * a) {}", PointerMiddle); 7126 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7127 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7128 verifyFormat("A<int *> a;", PointerMiddle); 7129 verifyFormat("A<int **> a;", PointerMiddle); 7130 verifyFormat("A<int *, int *> a;", PointerMiddle); 7131 verifyFormat("A<int *[]> a;", PointerMiddle); 7132 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7133 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7134 verifyFormat("T ** t = new T *;", PointerMiddle); 7135 7136 // Member function reference qualifiers aren't binary operators. 7137 verifyFormat("string // break\n" 7138 "operator()() & {}"); 7139 verifyFormat("string // break\n" 7140 "operator()() && {}"); 7141 verifyGoogleFormat("template <typename T>\n" 7142 "auto x() & -> int {}"); 7143 } 7144 7145 TEST_F(FormatTest, UnderstandsAttributes) { 7146 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7147 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7148 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7149 FormatStyle AfterType = getLLVMStyle(); 7150 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7151 verifyFormat("__attribute__((nodebug)) void\n" 7152 "foo() {}\n", 7153 AfterType); 7154 } 7155 7156 TEST_F(FormatTest, UnderstandsSquareAttributes) { 7157 verifyFormat("SomeType s [[unused]] (InitValue);"); 7158 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 7159 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 7160 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 7161 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 7162 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7163 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7164 7165 // Make sure we do not mistake attributes for array subscripts. 7166 verifyFormat("int a() {}\n" 7167 "[[unused]] int b() {}\n"); 7168 verifyFormat("NSArray *arr;\n" 7169 "arr[[Foo() bar]];"); 7170 7171 // On the other hand, we still need to correctly find array subscripts. 7172 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 7173 7174 // Make sure that we do not mistake Objective-C method inside array literals 7175 // as attributes, even if those method names are also keywords. 7176 verifyFormat("@[ [foo bar] ];"); 7177 verifyFormat("@[ [NSArray class] ];"); 7178 verifyFormat("@[ [foo enum] ];"); 7179 7180 // Make sure we do not parse attributes as lambda introducers. 7181 FormatStyle MultiLineFunctions = getLLVMStyle(); 7182 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7183 verifyFormat("[[unused]] int b() {\n" 7184 " return 42;\n" 7185 "}\n", 7186 MultiLineFunctions); 7187 } 7188 7189 TEST_F(FormatTest, UnderstandsEllipsis) { 7190 verifyFormat("int printf(const char *fmt, ...);"); 7191 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 7192 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 7193 7194 FormatStyle PointersLeft = getLLVMStyle(); 7195 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 7196 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 7197 } 7198 7199 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 7200 EXPECT_EQ("int *a;\n" 7201 "int *a;\n" 7202 "int *a;", 7203 format("int *a;\n" 7204 "int* a;\n" 7205 "int *a;", 7206 getGoogleStyle())); 7207 EXPECT_EQ("int* a;\n" 7208 "int* a;\n" 7209 "int* a;", 7210 format("int* a;\n" 7211 "int* a;\n" 7212 "int *a;", 7213 getGoogleStyle())); 7214 EXPECT_EQ("int *a;\n" 7215 "int *a;\n" 7216 "int *a;", 7217 format("int *a;\n" 7218 "int * a;\n" 7219 "int * a;", 7220 getGoogleStyle())); 7221 EXPECT_EQ("auto x = [] {\n" 7222 " int *a;\n" 7223 " int *a;\n" 7224 " int *a;\n" 7225 "};", 7226 format("auto x=[]{int *a;\n" 7227 "int * a;\n" 7228 "int * a;};", 7229 getGoogleStyle())); 7230 } 7231 7232 TEST_F(FormatTest, UnderstandsRvalueReferences) { 7233 verifyFormat("int f(int &&a) {}"); 7234 verifyFormat("int f(int a, char &&b) {}"); 7235 verifyFormat("void f() { int &&a = b; }"); 7236 verifyGoogleFormat("int f(int a, char&& b) {}"); 7237 verifyGoogleFormat("void f() { int&& a = b; }"); 7238 7239 verifyIndependentOfContext("A<int &&> a;"); 7240 verifyIndependentOfContext("A<int &&, int &&> a;"); 7241 verifyGoogleFormat("A<int&&> a;"); 7242 verifyGoogleFormat("A<int&&, int&&> a;"); 7243 7244 // Not rvalue references: 7245 verifyFormat("template <bool B, bool C> class A {\n" 7246 " static_assert(B && C, \"Something is wrong\");\n" 7247 "};"); 7248 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 7249 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 7250 verifyFormat("#define A(a, b) (a && b)"); 7251 } 7252 7253 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 7254 verifyFormat("void f() {\n" 7255 " x[aaaaaaaaa -\n" 7256 " b] = 23;\n" 7257 "}", 7258 getLLVMStyleWithColumns(15)); 7259 } 7260 7261 TEST_F(FormatTest, FormatsCasts) { 7262 verifyFormat("Type *A = static_cast<Type *>(P);"); 7263 verifyFormat("Type *A = (Type *)P;"); 7264 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7265 verifyFormat("int a = (int)(2.0f);"); 7266 verifyFormat("int a = (int)2.0f;"); 7267 verifyFormat("x[(int32)y];"); 7268 verifyFormat("x = (int32)y;"); 7269 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7270 verifyFormat("int a = (int)*b;"); 7271 verifyFormat("int a = (int)2.0f;"); 7272 verifyFormat("int a = (int)~0;"); 7273 verifyFormat("int a = (int)++a;"); 7274 verifyFormat("int a = (int)sizeof(int);"); 7275 verifyFormat("int a = (int)+2;"); 7276 verifyFormat("my_int a = (my_int)2.0f;"); 7277 verifyFormat("my_int a = (my_int)sizeof(int);"); 7278 verifyFormat("return (my_int)aaa;"); 7279 verifyFormat("#define x ((int)-1)"); 7280 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7281 verifyFormat("#define p(q) ((int *)&q)"); 7282 verifyFormat("fn(a)(b) + 1;"); 7283 7284 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7285 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7286 verifyFormat("my_int a = (my_int)~0;"); 7287 verifyFormat("my_int a = (my_int)++a;"); 7288 verifyFormat("my_int a = (my_int)-2;"); 7289 verifyFormat("my_int a = (my_int)1;"); 7290 verifyFormat("my_int a = (my_int *)1;"); 7291 verifyFormat("my_int a = (const my_int)-1;"); 7292 verifyFormat("my_int a = (const my_int *)-1;"); 7293 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7294 verifyFormat("my_int a = (ns::my_int)-2;"); 7295 verifyFormat("case (my_int)ONE:"); 7296 verifyFormat("auto x = (X)this;"); 7297 7298 // FIXME: single value wrapped with paren will be treated as cast. 7299 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7300 7301 verifyFormat("{ (void)F; }"); 7302 7303 // Don't break after a cast's 7304 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7305 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7306 " bbbbbbbbbbbbbbbbbbbbbb);"); 7307 7308 // These are not casts. 7309 verifyFormat("void f(int *) {}"); 7310 verifyFormat("f(foo)->b;"); 7311 verifyFormat("f(foo).b;"); 7312 verifyFormat("f(foo)(b);"); 7313 verifyFormat("f(foo)[b];"); 7314 verifyFormat("[](foo) { return 4; }(bar);"); 7315 verifyFormat("(*funptr)(foo)[4];"); 7316 verifyFormat("funptrs[4](foo)[4];"); 7317 verifyFormat("void f(int *);"); 7318 verifyFormat("void f(int *) = 0;"); 7319 verifyFormat("void f(SmallVector<int>) {}"); 7320 verifyFormat("void f(SmallVector<int>);"); 7321 verifyFormat("void f(SmallVector<int>) = 0;"); 7322 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7323 verifyFormat("int a = sizeof(int) * b;"); 7324 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7325 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7326 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7327 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7328 7329 // These are not casts, but at some point were confused with casts. 7330 verifyFormat("virtual void foo(int *) override;"); 7331 verifyFormat("virtual void foo(char &) const;"); 7332 verifyFormat("virtual void foo(int *a, char *) const;"); 7333 verifyFormat("int a = sizeof(int *) + b;"); 7334 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7335 verifyFormat("bool b = f(g<int>) && c;"); 7336 verifyFormat("typedef void (*f)(int i) func;"); 7337 7338 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7339 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7340 // FIXME: The indentation here is not ideal. 7341 verifyFormat( 7342 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7343 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7344 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7345 } 7346 7347 TEST_F(FormatTest, FormatsFunctionTypes) { 7348 verifyFormat("A<bool()> a;"); 7349 verifyFormat("A<SomeType()> a;"); 7350 verifyFormat("A<void (*)(int, std::string)> a;"); 7351 verifyFormat("A<void *(int)>;"); 7352 verifyFormat("void *(*a)(int *, SomeType *);"); 7353 verifyFormat("int (*func)(void *);"); 7354 verifyFormat("void f() { int (*func)(void *); }"); 7355 verifyFormat("template <class CallbackClass>\n" 7356 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7357 7358 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7359 verifyGoogleFormat("void* (*a)(int);"); 7360 verifyGoogleFormat( 7361 "template <class CallbackClass>\n" 7362 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7363 7364 // Other constructs can look somewhat like function types: 7365 verifyFormat("A<sizeof(*x)> a;"); 7366 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7367 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7368 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7369 verifyFormat("int x = f(&h)();"); 7370 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7371 verifyFormat("std::function<\n" 7372 " LooooooooooongTemplatedType<\n" 7373 " SomeType>*(\n" 7374 " LooooooooooooooooongType type)>\n" 7375 " function;", 7376 getGoogleStyleWithColumns(40)); 7377 } 7378 7379 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7380 verifyFormat("A (*foo_)[6];"); 7381 verifyFormat("vector<int> (*foo_)[6];"); 7382 } 7383 7384 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7385 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7386 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7387 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7388 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7389 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7390 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7391 7392 // Different ways of ()-initializiation. 7393 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7394 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7395 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7396 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7397 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7398 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7399 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7400 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7401 7402 // Lambdas should not confuse the variable declaration heuristic. 7403 verifyFormat("LooooooooooooooooongType\n" 7404 " variable(nullptr, [](A *a) {});", 7405 getLLVMStyleWithColumns(40)); 7406 } 7407 7408 TEST_F(FormatTest, BreaksLongDeclarations) { 7409 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7410 " AnotherNameForTheLongType;"); 7411 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7412 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7413 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7414 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7415 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7416 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7417 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7418 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7419 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7420 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7421 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7422 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7423 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7424 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7425 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7426 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7427 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7428 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7429 FormatStyle Indented = getLLVMStyle(); 7430 Indented.IndentWrappedFunctionNames = true; 7431 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7432 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7433 Indented); 7434 verifyFormat( 7435 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7436 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7437 Indented); 7438 verifyFormat( 7439 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7440 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7441 Indented); 7442 verifyFormat( 7443 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7444 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7445 Indented); 7446 7447 // FIXME: Without the comment, this breaks after "(". 7448 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7449 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7450 getGoogleStyle()); 7451 7452 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7453 " int LoooooooooooooooooooongParam2) {}"); 7454 verifyFormat( 7455 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7456 " SourceLocation L, IdentifierIn *II,\n" 7457 " Type *T) {}"); 7458 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7459 "ReallyReaaallyLongFunctionName(\n" 7460 " const std::string &SomeParameter,\n" 7461 " const SomeType<string, SomeOtherTemplateParameter>\n" 7462 " &ReallyReallyLongParameterName,\n" 7463 " const SomeType<string, SomeOtherTemplateParameter>\n" 7464 " &AnotherLongParameterName) {}"); 7465 verifyFormat("template <typename A>\n" 7466 "SomeLoooooooooooooooooooooongType<\n" 7467 " typename some_namespace::SomeOtherType<A>::Type>\n" 7468 "Function() {}"); 7469 7470 verifyGoogleFormat( 7471 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7472 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7473 verifyGoogleFormat( 7474 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7475 " SourceLocation L) {}"); 7476 verifyGoogleFormat( 7477 "some_namespace::LongReturnType\n" 7478 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7479 " int first_long_parameter, int second_parameter) {}"); 7480 7481 verifyGoogleFormat("template <typename T>\n" 7482 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7483 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7484 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7485 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7486 7487 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7488 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7489 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7490 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7491 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7492 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 7493 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7494 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 7495 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 7496 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7497 7498 verifyFormat("template <typename T> // Templates on own line.\n" 7499 "static int // Some comment.\n" 7500 "MyFunction(int a);", 7501 getLLVMStyle()); 7502 } 7503 7504 TEST_F(FormatTest, FormatsArrays) { 7505 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7506 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 7507 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 7508 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 7509 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 7510 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 7511 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7512 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7513 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7514 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 7515 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7516 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7517 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7518 verifyFormat( 7519 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 7520 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7521 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 7522 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 7523 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7524 7525 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 7526 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 7527 verifyFormat( 7528 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 7529 " .aaaaaaa[0]\n" 7530 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7531 verifyFormat("a[::b::c];"); 7532 7533 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 7534 7535 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 7536 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 7537 } 7538 7539 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 7540 verifyFormat("(a)->b();"); 7541 verifyFormat("--a;"); 7542 } 7543 7544 TEST_F(FormatTest, HandlesIncludeDirectives) { 7545 verifyFormat("#include <string>\n" 7546 "#include <a/b/c.h>\n" 7547 "#include \"a/b/string\"\n" 7548 "#include \"string.h\"\n" 7549 "#include \"string.h\"\n" 7550 "#include <a-a>\n" 7551 "#include < path with space >\n" 7552 "#include_next <test.h>" 7553 "#include \"abc.h\" // this is included for ABC\n" 7554 "#include \"some long include\" // with a comment\n" 7555 "#include \"some very long include path\"\n" 7556 "#include <some/very/long/include/path>\n", 7557 getLLVMStyleWithColumns(35)); 7558 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 7559 EXPECT_EQ("#include <a>", format("#include<a>")); 7560 7561 verifyFormat("#import <string>"); 7562 verifyFormat("#import <a/b/c.h>"); 7563 verifyFormat("#import \"a/b/string\""); 7564 verifyFormat("#import \"string.h\""); 7565 verifyFormat("#import \"string.h\""); 7566 verifyFormat("#if __has_include(<strstream>)\n" 7567 "#include <strstream>\n" 7568 "#endif"); 7569 7570 verifyFormat("#define MY_IMPORT <a/b>"); 7571 7572 verifyFormat("#if __has_include(<a/b>)"); 7573 verifyFormat("#if __has_include_next(<a/b>)"); 7574 verifyFormat("#define F __has_include(<a/b>)"); 7575 verifyFormat("#define F __has_include_next(<a/b>)"); 7576 7577 // Protocol buffer definition or missing "#". 7578 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 7579 getLLVMStyleWithColumns(30)); 7580 7581 FormatStyle Style = getLLVMStyle(); 7582 Style.AlwaysBreakBeforeMultilineStrings = true; 7583 Style.ColumnLimit = 0; 7584 verifyFormat("#import \"abc.h\"", Style); 7585 7586 // But 'import' might also be a regular C++ namespace. 7587 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7588 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7589 } 7590 7591 //===----------------------------------------------------------------------===// 7592 // Error recovery tests. 7593 //===----------------------------------------------------------------------===// 7594 7595 TEST_F(FormatTest, IncompleteParameterLists) { 7596 FormatStyle NoBinPacking = getLLVMStyle(); 7597 NoBinPacking.BinPackParameters = false; 7598 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 7599 " double *min_x,\n" 7600 " double *max_x,\n" 7601 " double *min_y,\n" 7602 " double *max_y,\n" 7603 " double *min_z,\n" 7604 " double *max_z, ) {}", 7605 NoBinPacking); 7606 } 7607 7608 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 7609 verifyFormat("void f() { return; }\n42"); 7610 verifyFormat("void f() {\n" 7611 " if (0)\n" 7612 " return;\n" 7613 "}\n" 7614 "42"); 7615 verifyFormat("void f() { return }\n42"); 7616 verifyFormat("void f() {\n" 7617 " if (0)\n" 7618 " return\n" 7619 "}\n" 7620 "42"); 7621 } 7622 7623 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 7624 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 7625 EXPECT_EQ("void f() {\n" 7626 " if (a)\n" 7627 " return\n" 7628 "}", 7629 format("void f ( ) { if ( a ) return }")); 7630 EXPECT_EQ("namespace N {\n" 7631 "void f()\n" 7632 "}", 7633 format("namespace N { void f() }")); 7634 EXPECT_EQ("namespace N {\n" 7635 "void f() {}\n" 7636 "void g()\n" 7637 "} // namespace N", 7638 format("namespace N { void f( ) { } void g( ) }")); 7639 } 7640 7641 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 7642 verifyFormat("int aaaaaaaa =\n" 7643 " // Overlylongcomment\n" 7644 " b;", 7645 getLLVMStyleWithColumns(20)); 7646 verifyFormat("function(\n" 7647 " ShortArgument,\n" 7648 " LoooooooooooongArgument);\n", 7649 getLLVMStyleWithColumns(20)); 7650 } 7651 7652 TEST_F(FormatTest, IncorrectAccessSpecifier) { 7653 verifyFormat("public:"); 7654 verifyFormat("class A {\n" 7655 "public\n" 7656 " void f() {}\n" 7657 "};"); 7658 verifyFormat("public\n" 7659 "int qwerty;"); 7660 verifyFormat("public\n" 7661 "B {}"); 7662 verifyFormat("public\n" 7663 "{}"); 7664 verifyFormat("public\n" 7665 "B { int x; }"); 7666 } 7667 7668 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 7669 verifyFormat("{"); 7670 verifyFormat("#})"); 7671 verifyNoCrash("(/**/[:!] ?[)."); 7672 } 7673 7674 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 7675 // Found by oss-fuzz: 7676 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 7677 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 7678 Style.ColumnLimit = 60; 7679 verifyNoCrash( 7680 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 7681 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 7682 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 7683 Style); 7684 } 7685 7686 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 7687 verifyFormat("do {\n}"); 7688 verifyFormat("do {\n}\n" 7689 "f();"); 7690 verifyFormat("do {\n}\n" 7691 "wheeee(fun);"); 7692 verifyFormat("do {\n" 7693 " f();\n" 7694 "}"); 7695 } 7696 7697 TEST_F(FormatTest, IncorrectCodeMissingParens) { 7698 verifyFormat("if {\n foo;\n foo();\n}"); 7699 verifyFormat("switch {\n foo;\n foo();\n}"); 7700 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 7701 verifyFormat("while {\n foo;\n foo();\n}"); 7702 verifyFormat("do {\n foo;\n foo();\n} while;"); 7703 } 7704 7705 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 7706 verifyIncompleteFormat("namespace {\n" 7707 "class Foo { Foo (\n" 7708 "};\n" 7709 "} // namespace"); 7710 } 7711 7712 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 7713 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 7714 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 7715 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 7716 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 7717 7718 EXPECT_EQ("{\n" 7719 " {\n" 7720 " breakme(\n" 7721 " qwe);\n" 7722 " }\n", 7723 format("{\n" 7724 " {\n" 7725 " breakme(qwe);\n" 7726 "}\n", 7727 getLLVMStyleWithColumns(10))); 7728 } 7729 7730 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 7731 verifyFormat("int x = {\n" 7732 " avariable,\n" 7733 " b(alongervariable)};", 7734 getLLVMStyleWithColumns(25)); 7735 } 7736 7737 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 7738 verifyFormat("return (a)(b){1, 2, 3};"); 7739 } 7740 7741 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 7742 verifyFormat("vector<int> x{1, 2, 3, 4};"); 7743 verifyFormat("vector<int> x{\n" 7744 " 1,\n" 7745 " 2,\n" 7746 " 3,\n" 7747 " 4,\n" 7748 "};"); 7749 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 7750 verifyFormat("f({1, 2});"); 7751 verifyFormat("auto v = Foo{-1};"); 7752 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 7753 verifyFormat("Class::Class : member{1, 2, 3} {}"); 7754 verifyFormat("new vector<int>{1, 2, 3};"); 7755 verifyFormat("new int[3]{1, 2, 3};"); 7756 verifyFormat("new int{1};"); 7757 verifyFormat("return {arg1, arg2};"); 7758 verifyFormat("return {arg1, SomeType{parameter}};"); 7759 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 7760 verifyFormat("new T{arg1, arg2};"); 7761 verifyFormat("f(MyMap[{composite, key}]);"); 7762 verifyFormat("class Class {\n" 7763 " T member = {arg1, arg2};\n" 7764 "};"); 7765 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 7766 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 7767 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 7768 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 7769 verifyFormat("int a = std::is_integral<int>{} + 0;"); 7770 7771 verifyFormat("int foo(int i) { return fo1{}(i); }"); 7772 verifyFormat("int foo(int i) { return fo1{}(i); }"); 7773 verifyFormat("auto i = decltype(x){};"); 7774 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 7775 verifyFormat("Node n{1, Node{1000}, //\n" 7776 " 2};"); 7777 verifyFormat("Aaaa aaaaaaa{\n" 7778 " {\n" 7779 " aaaa,\n" 7780 " },\n" 7781 "};"); 7782 verifyFormat("class C : public D {\n" 7783 " SomeClass SC{2};\n" 7784 "};"); 7785 verifyFormat("class C : public A {\n" 7786 " class D : public B {\n" 7787 " void f() { int i{2}; }\n" 7788 " };\n" 7789 "};"); 7790 verifyFormat("#define A {a, a},"); 7791 7792 // Avoid breaking between equal sign and opening brace 7793 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 7794 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 7795 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 7796 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 7797 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 7798 " {\"ccccccccccccccccccccc\", 2}};", 7799 AvoidBreakingFirstArgument); 7800 7801 // Binpacking only if there is no trailing comma 7802 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 7803 " cccccccccc, dddddddddd};", 7804 getLLVMStyleWithColumns(50)); 7805 verifyFormat("const Aaaaaa aaaaa = {\n" 7806 " aaaaaaaaaaa,\n" 7807 " bbbbbbbbbbb,\n" 7808 " ccccccccccc,\n" 7809 " ddddddddddd,\n" 7810 "};", getLLVMStyleWithColumns(50)); 7811 7812 // Cases where distinguising braced lists and blocks is hard. 7813 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 7814 verifyFormat("void f() {\n" 7815 " return; // comment\n" 7816 "}\n" 7817 "SomeType t;"); 7818 verifyFormat("void f() {\n" 7819 " if (a) {\n" 7820 " f();\n" 7821 " }\n" 7822 "}\n" 7823 "SomeType t;"); 7824 7825 // In combination with BinPackArguments = false. 7826 FormatStyle NoBinPacking = getLLVMStyle(); 7827 NoBinPacking.BinPackArguments = false; 7828 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 7829 " bbbbb,\n" 7830 " ccccc,\n" 7831 " ddddd,\n" 7832 " eeeee,\n" 7833 " ffffff,\n" 7834 " ggggg,\n" 7835 " hhhhhh,\n" 7836 " iiiiii,\n" 7837 " jjjjjj,\n" 7838 " kkkkkk};", 7839 NoBinPacking); 7840 verifyFormat("const Aaaaaa aaaaa = {\n" 7841 " aaaaa,\n" 7842 " bbbbb,\n" 7843 " ccccc,\n" 7844 " ddddd,\n" 7845 " eeeee,\n" 7846 " ffffff,\n" 7847 " ggggg,\n" 7848 " hhhhhh,\n" 7849 " iiiiii,\n" 7850 " jjjjjj,\n" 7851 " kkkkkk,\n" 7852 "};", 7853 NoBinPacking); 7854 verifyFormat( 7855 "const Aaaaaa aaaaa = {\n" 7856 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 7857 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 7858 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 7859 "};", 7860 NoBinPacking); 7861 7862 NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 7863 EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n" 7864 " CDDDP83848_BMCR_REGISTER,\n" 7865 " CDDDP83848_BMSR_REGISTER,\n" 7866 " CDDDP83848_RBR_REGISTER};", 7867 format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n" 7868 " CDDDP83848_BMSR_REGISTER,\n" 7869 " CDDDP83848_RBR_REGISTER};", 7870 NoBinPacking)); 7871 7872 // FIXME: The alignment of these trailing comments might be bad. Then again, 7873 // this might be utterly useless in real code. 7874 verifyFormat("Constructor::Constructor()\n" 7875 " : some_value{ //\n" 7876 " aaaaaaa, //\n" 7877 " bbbbbbb} {}"); 7878 7879 // In braced lists, the first comment is always assumed to belong to the 7880 // first element. Thus, it can be moved to the next or previous line as 7881 // appropriate. 7882 EXPECT_EQ("function({// First element:\n" 7883 " 1,\n" 7884 " // Second element:\n" 7885 " 2});", 7886 format("function({\n" 7887 " // First element:\n" 7888 " 1,\n" 7889 " // Second element:\n" 7890 " 2});")); 7891 EXPECT_EQ("std::vector<int> MyNumbers{\n" 7892 " // First element:\n" 7893 " 1,\n" 7894 " // Second element:\n" 7895 " 2};", 7896 format("std::vector<int> MyNumbers{// First element:\n" 7897 " 1,\n" 7898 " // Second element:\n" 7899 " 2};", 7900 getLLVMStyleWithColumns(30))); 7901 // A trailing comma should still lead to an enforced line break and no 7902 // binpacking. 7903 EXPECT_EQ("vector<int> SomeVector = {\n" 7904 " // aaa\n" 7905 " 1,\n" 7906 " 2,\n" 7907 "};", 7908 format("vector<int> SomeVector = { // aaa\n" 7909 " 1, 2, };")); 7910 7911 FormatStyle ExtraSpaces = getLLVMStyle(); 7912 ExtraSpaces.Cpp11BracedListStyle = false; 7913 ExtraSpaces.ColumnLimit = 75; 7914 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 7915 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 7916 verifyFormat("f({ 1, 2 });", ExtraSpaces); 7917 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 7918 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 7919 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 7920 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 7921 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 7922 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 7923 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 7924 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 7925 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 7926 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 7927 verifyFormat("class Class {\n" 7928 " T member = { arg1, arg2 };\n" 7929 "};", 7930 ExtraSpaces); 7931 verifyFormat( 7932 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7933 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 7934 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 7935 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 7936 ExtraSpaces); 7937 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 7938 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 7939 ExtraSpaces); 7940 verifyFormat( 7941 "someFunction(OtherParam,\n" 7942 " BracedList{ // comment 1 (Forcing interesting break)\n" 7943 " param1, param2,\n" 7944 " // comment 2\n" 7945 " param3, param4 });", 7946 ExtraSpaces); 7947 verifyFormat( 7948 "std::this_thread::sleep_for(\n" 7949 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 7950 ExtraSpaces); 7951 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 7952 " aaaaaaa,\n" 7953 " aaaaaaaaaa,\n" 7954 " aaaaa,\n" 7955 " aaaaaaaaaaaaaaa,\n" 7956 " aaa,\n" 7957 " aaaaaaaaaa,\n" 7958 " a,\n" 7959 " aaaaaaaaaaaaaaaaaaaaa,\n" 7960 " aaaaaaaaaaaa,\n" 7961 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 7962 " aaaaaaa,\n" 7963 " a};"); 7964 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 7965 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 7966 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 7967 7968 // Avoid breaking between initializer/equal sign and opening brace 7969 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 7970 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 7971 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 7972 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 7973 " { \"ccccccccccccccccccccc\", 2 }\n" 7974 "};", 7975 ExtraSpaces); 7976 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 7977 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 7978 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 7979 " { \"ccccccccccccccccccccc\", 2 }\n" 7980 "};", 7981 ExtraSpaces); 7982 7983 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 7984 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 7985 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 7986 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 7987 } 7988 7989 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 7990 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7991 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7992 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7993 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7994 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7995 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 7996 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 7997 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7998 " 1, 22, 333, 4444, 55555, //\n" 7999 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8000 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8001 verifyFormat( 8002 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8003 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8004 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 8005 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8006 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8007 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8008 " 7777777};"); 8009 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8010 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8011 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8012 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8013 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8014 " // Separating comment.\n" 8015 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8016 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8017 " // Leading comment\n" 8018 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8019 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8020 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8021 " 1, 1, 1, 1};", 8022 getLLVMStyleWithColumns(39)); 8023 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8024 " 1, 1, 1, 1};", 8025 getLLVMStyleWithColumns(38)); 8026 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 8027 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 8028 getLLVMStyleWithColumns(43)); 8029 verifyFormat( 8030 "static unsigned SomeValues[10][3] = {\n" 8031 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 8032 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 8033 verifyFormat("static auto fields = new vector<string>{\n" 8034 " \"aaaaaaaaaaaaa\",\n" 8035 " \"aaaaaaaaaaaaa\",\n" 8036 " \"aaaaaaaaaaaa\",\n" 8037 " \"aaaaaaaaaaaaaa\",\n" 8038 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8039 " \"aaaaaaaaaaaa\",\n" 8040 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8041 "};"); 8042 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 8043 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 8044 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 8045 " 3, cccccccccccccccccccccc};", 8046 getLLVMStyleWithColumns(60)); 8047 8048 // Trailing commas. 8049 verifyFormat("vector<int> x = {\n" 8050 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 8051 "};", 8052 getLLVMStyleWithColumns(39)); 8053 verifyFormat("vector<int> x = {\n" 8054 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 8055 "};", 8056 getLLVMStyleWithColumns(39)); 8057 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8058 " 1, 1, 1, 1,\n" 8059 " /**/ /**/};", 8060 getLLVMStyleWithColumns(39)); 8061 8062 // Trailing comment in the first line. 8063 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 8064 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 8065 " 111111111, 222222222, 3333333333, 444444444, //\n" 8066 " 11111111, 22222222, 333333333, 44444444};"); 8067 // Trailing comment in the last line. 8068 verifyFormat("int aaaaa[] = {\n" 8069 " 1, 2, 3, // comment\n" 8070 " 4, 5, 6 // comment\n" 8071 "};"); 8072 8073 // With nested lists, we should either format one item per line or all nested 8074 // lists one on line. 8075 // FIXME: For some nested lists, we can do better. 8076 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 8077 " {aaaaaaaaaaaaaaaaaaa},\n" 8078 " {aaaaaaaaaaaaaaaaaaaaa},\n" 8079 " {aaaaaaaaaaaaaaaaa}};", 8080 getLLVMStyleWithColumns(60)); 8081 verifyFormat( 8082 "SomeStruct my_struct_array = {\n" 8083 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 8084 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 8085 " {aaa, aaa},\n" 8086 " {aaa, aaa},\n" 8087 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 8088 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 8089 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 8090 8091 // No column layout should be used here. 8092 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 8093 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 8094 8095 verifyNoCrash("a<,"); 8096 8097 // No braced initializer here. 8098 verifyFormat("void f() {\n" 8099 " struct Dummy {};\n" 8100 " f(v);\n" 8101 "}"); 8102 8103 // Long lists should be formatted in columns even if they are nested. 8104 verifyFormat( 8105 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8106 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8107 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8108 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8109 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8110 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 8111 8112 // Allow "single-column" layout even if that violates the column limit. There 8113 // isn't going to be a better way. 8114 verifyFormat("std::vector<int> a = {\n" 8115 " aaaaaaaa,\n" 8116 " aaaaaaaa,\n" 8117 " aaaaaaaa,\n" 8118 " aaaaaaaa,\n" 8119 " aaaaaaaaaa,\n" 8120 " aaaaaaaa,\n" 8121 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 8122 getLLVMStyleWithColumns(30)); 8123 verifyFormat("vector<int> aaaa = {\n" 8124 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8125 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8126 " aaaaaa.aaaaaaa,\n" 8127 " aaaaaa.aaaaaaa,\n" 8128 " aaaaaa.aaaaaaa,\n" 8129 " aaaaaa.aaaaaaa,\n" 8130 "};"); 8131 8132 // Don't create hanging lists. 8133 verifyFormat("someFunction(Param, {List1, List2,\n" 8134 " List3});", 8135 getLLVMStyleWithColumns(35)); 8136 verifyFormat("someFunction(Param, Param,\n" 8137 " {List1, List2,\n" 8138 " List3});", 8139 getLLVMStyleWithColumns(35)); 8140 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 8141 " aaaaaaaaaaaaaaaaaaaaaaa);"); 8142 } 8143 8144 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 8145 FormatStyle DoNotMerge = getLLVMStyle(); 8146 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8147 8148 verifyFormat("void f() { return 42; }"); 8149 verifyFormat("void f() {\n" 8150 " return 42;\n" 8151 "}", 8152 DoNotMerge); 8153 verifyFormat("void f() {\n" 8154 " // Comment\n" 8155 "}"); 8156 verifyFormat("{\n" 8157 "#error {\n" 8158 " int a;\n" 8159 "}"); 8160 verifyFormat("{\n" 8161 " int a;\n" 8162 "#error {\n" 8163 "}"); 8164 verifyFormat("void f() {} // comment"); 8165 verifyFormat("void f() { int a; } // comment"); 8166 verifyFormat("void f() {\n" 8167 "} // comment", 8168 DoNotMerge); 8169 verifyFormat("void f() {\n" 8170 " int a;\n" 8171 "} // comment", 8172 DoNotMerge); 8173 verifyFormat("void f() {\n" 8174 "} // comment", 8175 getLLVMStyleWithColumns(15)); 8176 8177 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 8178 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 8179 8180 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 8181 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 8182 verifyFormat("class C {\n" 8183 " C()\n" 8184 " : iiiiiiii(nullptr),\n" 8185 " kkkkkkk(nullptr),\n" 8186 " mmmmmmm(nullptr),\n" 8187 " nnnnnnn(nullptr) {}\n" 8188 "};", 8189 getGoogleStyle()); 8190 8191 FormatStyle NoColumnLimit = getLLVMStyle(); 8192 NoColumnLimit.ColumnLimit = 0; 8193 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 8194 EXPECT_EQ("class C {\n" 8195 " A() : b(0) {}\n" 8196 "};", 8197 format("class C{A():b(0){}};", NoColumnLimit)); 8198 EXPECT_EQ("A()\n" 8199 " : b(0) {\n" 8200 "}", 8201 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 8202 8203 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 8204 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 8205 FormatStyle::SFS_None; 8206 EXPECT_EQ("A()\n" 8207 " : b(0) {\n" 8208 "}", 8209 format("A():b(0){}", DoNotMergeNoColumnLimit)); 8210 EXPECT_EQ("A()\n" 8211 " : b(0) {\n" 8212 "}", 8213 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 8214 8215 verifyFormat("#define A \\\n" 8216 " void f() { \\\n" 8217 " int i; \\\n" 8218 " }", 8219 getLLVMStyleWithColumns(20)); 8220 verifyFormat("#define A \\\n" 8221 " void f() { int i; }", 8222 getLLVMStyleWithColumns(21)); 8223 verifyFormat("#define A \\\n" 8224 " void f() { \\\n" 8225 " int i; \\\n" 8226 " } \\\n" 8227 " int j;", 8228 getLLVMStyleWithColumns(22)); 8229 verifyFormat("#define A \\\n" 8230 " void f() { int i; } \\\n" 8231 " int j;", 8232 getLLVMStyleWithColumns(23)); 8233 } 8234 8235 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 8236 FormatStyle MergeEmptyOnly = getLLVMStyle(); 8237 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8238 verifyFormat("class C {\n" 8239 " int f() {}\n" 8240 "};", 8241 MergeEmptyOnly); 8242 verifyFormat("class C {\n" 8243 " int f() {\n" 8244 " return 42;\n" 8245 " }\n" 8246 "};", 8247 MergeEmptyOnly); 8248 verifyFormat("int f() {}", MergeEmptyOnly); 8249 verifyFormat("int f() {\n" 8250 " return 42;\n" 8251 "}", 8252 MergeEmptyOnly); 8253 8254 // Also verify behavior when BraceWrapping.AfterFunction = true 8255 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8256 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 8257 verifyFormat("int f() {}", MergeEmptyOnly); 8258 verifyFormat("class C {\n" 8259 " int f() {}\n" 8260 "};", 8261 MergeEmptyOnly); 8262 } 8263 8264 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 8265 FormatStyle MergeInlineOnly = getLLVMStyle(); 8266 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8267 verifyFormat("class C {\n" 8268 " int f() { return 42; }\n" 8269 "};", 8270 MergeInlineOnly); 8271 verifyFormat("int f() {\n" 8272 " return 42;\n" 8273 "}", 8274 MergeInlineOnly); 8275 8276 // SFS_Inline implies SFS_Empty 8277 verifyFormat("class C {\n" 8278 " int f() {}\n" 8279 "};", 8280 MergeInlineOnly); 8281 verifyFormat("int f() {}", MergeInlineOnly); 8282 8283 // Also verify behavior when BraceWrapping.AfterFunction = true 8284 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8285 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8286 verifyFormat("class C {\n" 8287 " int f() { return 42; }\n" 8288 "};", 8289 MergeInlineOnly); 8290 verifyFormat("int f()\n" 8291 "{\n" 8292 " return 42;\n" 8293 "}", 8294 MergeInlineOnly); 8295 8296 // SFS_Inline implies SFS_Empty 8297 verifyFormat("int f() {}", MergeInlineOnly); 8298 verifyFormat("class C {\n" 8299 " int f() {}\n" 8300 "};", 8301 MergeInlineOnly); 8302 } 8303 8304 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8305 FormatStyle MergeInlineOnly = getLLVMStyle(); 8306 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8307 FormatStyle::SFS_InlineOnly; 8308 verifyFormat("class C {\n" 8309 " int f() { return 42; }\n" 8310 "};", 8311 MergeInlineOnly); 8312 verifyFormat("int f() {\n" 8313 " return 42;\n" 8314 "}", 8315 MergeInlineOnly); 8316 8317 // SFS_InlineOnly does not imply SFS_Empty 8318 verifyFormat("class C {\n" 8319 " int f() {}\n" 8320 "};", 8321 MergeInlineOnly); 8322 verifyFormat("int f() {\n" 8323 "}", 8324 MergeInlineOnly); 8325 8326 // Also verify behavior when BraceWrapping.AfterFunction = true 8327 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8328 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8329 verifyFormat("class C {\n" 8330 " int f() { return 42; }\n" 8331 "};", 8332 MergeInlineOnly); 8333 verifyFormat("int f()\n" 8334 "{\n" 8335 " return 42;\n" 8336 "}", 8337 MergeInlineOnly); 8338 8339 // SFS_InlineOnly does not imply SFS_Empty 8340 verifyFormat("int f()\n" 8341 "{\n" 8342 "}", 8343 MergeInlineOnly); 8344 verifyFormat("class C {\n" 8345 " int f() {}\n" 8346 "};", 8347 MergeInlineOnly); 8348 } 8349 8350 TEST_F(FormatTest, SplitEmptyFunction) { 8351 FormatStyle Style = getLLVMStyle(); 8352 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8353 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8354 Style.BraceWrapping.AfterFunction = true; 8355 Style.BraceWrapping.SplitEmptyFunction = false; 8356 Style.ColumnLimit = 40; 8357 8358 verifyFormat("int f()\n" 8359 "{}", 8360 Style); 8361 verifyFormat("int f()\n" 8362 "{\n" 8363 " return 42;\n" 8364 "}", 8365 Style); 8366 verifyFormat("int f()\n" 8367 "{\n" 8368 " // some comment\n" 8369 "}", 8370 Style); 8371 8372 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8373 verifyFormat("int f() {}", Style); 8374 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8375 "{}", 8376 Style); 8377 verifyFormat("int f()\n" 8378 "{\n" 8379 " return 0;\n" 8380 "}", 8381 Style); 8382 8383 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8384 verifyFormat("class Foo {\n" 8385 " int f() {}\n" 8386 "};\n", 8387 Style); 8388 verifyFormat("class Foo {\n" 8389 " int f() { return 0; }\n" 8390 "};\n", 8391 Style); 8392 verifyFormat("class Foo {\n" 8393 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8394 " {}\n" 8395 "};\n", 8396 Style); 8397 verifyFormat("class Foo {\n" 8398 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8399 " {\n" 8400 " return 0;\n" 8401 " }\n" 8402 "};\n", 8403 Style); 8404 8405 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8406 verifyFormat("int f() {}", Style); 8407 verifyFormat("int f() { return 0; }", Style); 8408 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8409 "{}", 8410 Style); 8411 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8412 "{\n" 8413 " return 0;\n" 8414 "}", 8415 Style); 8416 } 8417 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8418 FormatStyle Style = getLLVMStyle(); 8419 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8420 verifyFormat("#ifdef A\n" 8421 "int f() {}\n" 8422 "#else\n" 8423 "int g() {}\n" 8424 "#endif", 8425 Style); 8426 } 8427 8428 TEST_F(FormatTest, SplitEmptyClass) { 8429 FormatStyle Style = getLLVMStyle(); 8430 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8431 Style.BraceWrapping.AfterClass = true; 8432 Style.BraceWrapping.SplitEmptyRecord = false; 8433 8434 verifyFormat("class Foo\n" 8435 "{};", 8436 Style); 8437 verifyFormat("/* something */ class Foo\n" 8438 "{};", 8439 Style); 8440 verifyFormat("template <typename X> class Foo\n" 8441 "{};", 8442 Style); 8443 verifyFormat("class Foo\n" 8444 "{\n" 8445 " Foo();\n" 8446 "};", 8447 Style); 8448 verifyFormat("typedef class Foo\n" 8449 "{\n" 8450 "} Foo_t;", 8451 Style); 8452 } 8453 8454 TEST_F(FormatTest, SplitEmptyStruct) { 8455 FormatStyle Style = getLLVMStyle(); 8456 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8457 Style.BraceWrapping.AfterStruct = true; 8458 Style.BraceWrapping.SplitEmptyRecord = false; 8459 8460 verifyFormat("struct Foo\n" 8461 "{};", 8462 Style); 8463 verifyFormat("/* something */ struct Foo\n" 8464 "{};", 8465 Style); 8466 verifyFormat("template <typename X> struct Foo\n" 8467 "{};", 8468 Style); 8469 verifyFormat("struct Foo\n" 8470 "{\n" 8471 " Foo();\n" 8472 "};", 8473 Style); 8474 verifyFormat("typedef struct Foo\n" 8475 "{\n" 8476 "} Foo_t;", 8477 Style); 8478 //typedef struct Bar {} Bar_t; 8479 } 8480 8481 TEST_F(FormatTest, SplitEmptyUnion) { 8482 FormatStyle Style = getLLVMStyle(); 8483 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8484 Style.BraceWrapping.AfterUnion = true; 8485 Style.BraceWrapping.SplitEmptyRecord = false; 8486 8487 verifyFormat("union Foo\n" 8488 "{};", 8489 Style); 8490 verifyFormat("/* something */ union Foo\n" 8491 "{};", 8492 Style); 8493 verifyFormat("union Foo\n" 8494 "{\n" 8495 " A,\n" 8496 "};", 8497 Style); 8498 verifyFormat("typedef union Foo\n" 8499 "{\n" 8500 "} Foo_t;", 8501 Style); 8502 } 8503 8504 TEST_F(FormatTest, SplitEmptyNamespace) { 8505 FormatStyle Style = getLLVMStyle(); 8506 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8507 Style.BraceWrapping.AfterNamespace = true; 8508 Style.BraceWrapping.SplitEmptyNamespace = false; 8509 8510 verifyFormat("namespace Foo\n" 8511 "{};", 8512 Style); 8513 verifyFormat("/* something */ namespace Foo\n" 8514 "{};", 8515 Style); 8516 verifyFormat("inline namespace Foo\n" 8517 "{};", 8518 Style); 8519 verifyFormat("/* something */ inline namespace Foo\n" 8520 "{};", 8521 Style); 8522 verifyFormat("export namespace Foo\n" 8523 "{};", 8524 Style); 8525 verifyFormat("namespace Foo\n" 8526 "{\n" 8527 "void Bar();\n" 8528 "};", 8529 Style); 8530 } 8531 8532 TEST_F(FormatTest, NeverMergeShortRecords) { 8533 FormatStyle Style = getLLVMStyle(); 8534 8535 verifyFormat("class Foo {\n" 8536 " Foo();\n" 8537 "};", 8538 Style); 8539 verifyFormat("typedef class Foo {\n" 8540 " Foo();\n" 8541 "} Foo_t;", 8542 Style); 8543 verifyFormat("struct Foo {\n" 8544 " Foo();\n" 8545 "};", 8546 Style); 8547 verifyFormat("typedef struct Foo {\n" 8548 " Foo();\n" 8549 "} Foo_t;", 8550 Style); 8551 verifyFormat("union Foo {\n" 8552 " A,\n" 8553 "};", 8554 Style); 8555 verifyFormat("typedef union Foo {\n" 8556 " A,\n" 8557 "} Foo_t;", 8558 Style); 8559 verifyFormat("namespace Foo {\n" 8560 "void Bar();\n" 8561 "};", 8562 Style); 8563 8564 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8565 Style.BraceWrapping.AfterClass = true; 8566 Style.BraceWrapping.AfterStruct = true; 8567 Style.BraceWrapping.AfterUnion = true; 8568 Style.BraceWrapping.AfterNamespace = true; 8569 verifyFormat("class Foo\n" 8570 "{\n" 8571 " Foo();\n" 8572 "};", 8573 Style); 8574 verifyFormat("typedef class Foo\n" 8575 "{\n" 8576 " Foo();\n" 8577 "} Foo_t;", 8578 Style); 8579 verifyFormat("struct Foo\n" 8580 "{\n" 8581 " Foo();\n" 8582 "};", 8583 Style); 8584 verifyFormat("typedef struct Foo\n" 8585 "{\n" 8586 " Foo();\n" 8587 "} Foo_t;", 8588 Style); 8589 verifyFormat("union Foo\n" 8590 "{\n" 8591 " A,\n" 8592 "};", 8593 Style); 8594 verifyFormat("typedef union Foo\n" 8595 "{\n" 8596 " A,\n" 8597 "} Foo_t;", 8598 Style); 8599 verifyFormat("namespace Foo\n" 8600 "{\n" 8601 "void Bar();\n" 8602 "};", 8603 Style); 8604 } 8605 8606 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 8607 // Elaborate type variable declarations. 8608 verifyFormat("struct foo a = {bar};\nint n;"); 8609 verifyFormat("class foo a = {bar};\nint n;"); 8610 verifyFormat("union foo a = {bar};\nint n;"); 8611 8612 // Elaborate types inside function definitions. 8613 verifyFormat("struct foo f() {}\nint n;"); 8614 verifyFormat("class foo f() {}\nint n;"); 8615 verifyFormat("union foo f() {}\nint n;"); 8616 8617 // Templates. 8618 verifyFormat("template <class X> void f() {}\nint n;"); 8619 verifyFormat("template <struct X> void f() {}\nint n;"); 8620 verifyFormat("template <union X> void f() {}\nint n;"); 8621 8622 // Actual definitions... 8623 verifyFormat("struct {\n} n;"); 8624 verifyFormat( 8625 "template <template <class T, class Y>, class Z> class X {\n} n;"); 8626 verifyFormat("union Z {\n int n;\n} x;"); 8627 verifyFormat("class MACRO Z {\n} n;"); 8628 verifyFormat("class MACRO(X) Z {\n} n;"); 8629 verifyFormat("class __attribute__(X) Z {\n} n;"); 8630 verifyFormat("class __declspec(X) Z {\n} n;"); 8631 verifyFormat("class A##B##C {\n} n;"); 8632 verifyFormat("class alignas(16) Z {\n} n;"); 8633 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 8634 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 8635 8636 // Redefinition from nested context: 8637 verifyFormat("class A::B::C {\n} n;"); 8638 8639 // Template definitions. 8640 verifyFormat( 8641 "template <typename F>\n" 8642 "Matcher(const Matcher<F> &Other,\n" 8643 " typename enable_if_c<is_base_of<F, T>::value &&\n" 8644 " !is_same<F, T>::value>::type * = 0)\n" 8645 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 8646 8647 // FIXME: This is still incorrectly handled at the formatter side. 8648 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 8649 verifyFormat("int i = SomeFunction(a<b, a> b);"); 8650 8651 // FIXME: 8652 // This now gets parsed incorrectly as class definition. 8653 // verifyFormat("class A<int> f() {\n}\nint n;"); 8654 8655 // Elaborate types where incorrectly parsing the structural element would 8656 // break the indent. 8657 verifyFormat("if (true)\n" 8658 " class X x;\n" 8659 "else\n" 8660 " f();\n"); 8661 8662 // This is simply incomplete. Formatting is not important, but must not crash. 8663 verifyFormat("class A:"); 8664 } 8665 8666 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 8667 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 8668 format("#error Leave all white!!!!! space* alone!\n")); 8669 EXPECT_EQ( 8670 "#warning Leave all white!!!!! space* alone!\n", 8671 format("#warning Leave all white!!!!! space* alone!\n")); 8672 EXPECT_EQ("#error 1", format(" # error 1")); 8673 EXPECT_EQ("#warning 1", format(" # warning 1")); 8674 } 8675 8676 TEST_F(FormatTest, FormatHashIfExpressions) { 8677 verifyFormat("#if AAAA && BBBB"); 8678 verifyFormat("#if (AAAA && BBBB)"); 8679 verifyFormat("#elif (AAAA && BBBB)"); 8680 // FIXME: Come up with a better indentation for #elif. 8681 verifyFormat( 8682 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 8683 " defined(BBBBBBBB)\n" 8684 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 8685 " defined(BBBBBBBB)\n" 8686 "#endif", 8687 getLLVMStyleWithColumns(65)); 8688 } 8689 8690 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 8691 FormatStyle AllowsMergedIf = getGoogleStyle(); 8692 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 8693 FormatStyle::SIS_WithoutElse; 8694 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 8695 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 8696 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 8697 EXPECT_EQ("if (true) return 42;", 8698 format("if (true)\nreturn 42;", AllowsMergedIf)); 8699 FormatStyle ShortMergedIf = AllowsMergedIf; 8700 ShortMergedIf.ColumnLimit = 25; 8701 verifyFormat("#define A \\\n" 8702 " if (true) return 42;", 8703 ShortMergedIf); 8704 verifyFormat("#define A \\\n" 8705 " f(); \\\n" 8706 " if (true)\n" 8707 "#define B", 8708 ShortMergedIf); 8709 verifyFormat("#define A \\\n" 8710 " f(); \\\n" 8711 " if (true)\n" 8712 "g();", 8713 ShortMergedIf); 8714 verifyFormat("{\n" 8715 "#ifdef A\n" 8716 " // Comment\n" 8717 " if (true) continue;\n" 8718 "#endif\n" 8719 " // Comment\n" 8720 " if (true) continue;\n" 8721 "}", 8722 ShortMergedIf); 8723 ShortMergedIf.ColumnLimit = 33; 8724 verifyFormat("#define A \\\n" 8725 " if constexpr (true) return 42;", 8726 ShortMergedIf); 8727 verifyFormat("#define A \\\n" 8728 " if CONSTEXPR (true) return 42;", 8729 ShortMergedIf); 8730 ShortMergedIf.ColumnLimit = 29; 8731 verifyFormat("#define A \\\n" 8732 " if (aaaaaaaaaa) return 1; \\\n" 8733 " return 2;", 8734 ShortMergedIf); 8735 ShortMergedIf.ColumnLimit = 28; 8736 verifyFormat("#define A \\\n" 8737 " if (aaaaaaaaaa) \\\n" 8738 " return 1; \\\n" 8739 " return 2;", 8740 ShortMergedIf); 8741 verifyFormat("#define A \\\n" 8742 " if constexpr (aaaaaaa) \\\n" 8743 " return 1; \\\n" 8744 " return 2;", 8745 ShortMergedIf); 8746 verifyFormat("#define A \\\n" 8747 " if CONSTEXPR (aaaaaaa) \\\n" 8748 " return 1; \\\n" 8749 " return 2;", 8750 ShortMergedIf); 8751 } 8752 8753 TEST_F(FormatTest, FormatStarDependingOnContext) { 8754 verifyFormat("void f(int *a);"); 8755 verifyFormat("void f() { f(fint * b); }"); 8756 verifyFormat("class A {\n void f(int *a);\n};"); 8757 verifyFormat("class A {\n int *a;\n};"); 8758 verifyFormat("namespace a {\n" 8759 "namespace b {\n" 8760 "class A {\n" 8761 " void f() {}\n" 8762 " int *a;\n" 8763 "};\n" 8764 "} // namespace b\n" 8765 "} // namespace a"); 8766 } 8767 8768 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 8769 verifyFormat("while"); 8770 verifyFormat("operator"); 8771 } 8772 8773 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 8774 // This code would be painfully slow to format if we didn't skip it. 8775 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 8776 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8777 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8778 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8779 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8780 "A(1, 1)\n" 8781 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 8782 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8783 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8784 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8785 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8786 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8787 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8788 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8789 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8790 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 8791 // Deeply nested part is untouched, rest is formatted. 8792 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 8793 format(std::string("int i;\n") + Code + "int j;\n", 8794 getLLVMStyle(), SC_ExpectIncomplete)); 8795 } 8796 8797 //===----------------------------------------------------------------------===// 8798 // Objective-C tests. 8799 //===----------------------------------------------------------------------===// 8800 8801 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 8802 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 8803 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 8804 format("-(NSUInteger)indexOfObject:(id)anObject;")); 8805 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 8806 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 8807 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 8808 format("-(NSInteger)Method3:(id)anObject;")); 8809 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 8810 format("-(NSInteger)Method4:(id)anObject;")); 8811 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 8812 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 8813 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 8814 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 8815 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 8816 "forAllCells:(BOOL)flag;", 8817 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 8818 "forAllCells:(BOOL)flag;")); 8819 8820 // Very long objectiveC method declaration. 8821 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 8822 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 8823 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 8824 " inRange:(NSRange)range\n" 8825 " outRange:(NSRange)out_range\n" 8826 " outRange1:(NSRange)out_range1\n" 8827 " outRange2:(NSRange)out_range2\n" 8828 " outRange3:(NSRange)out_range3\n" 8829 " outRange4:(NSRange)out_range4\n" 8830 " outRange5:(NSRange)out_range5\n" 8831 " outRange6:(NSRange)out_range6\n" 8832 " outRange7:(NSRange)out_range7\n" 8833 " outRange8:(NSRange)out_range8\n" 8834 " outRange9:(NSRange)out_range9;"); 8835 8836 // When the function name has to be wrapped. 8837 FormatStyle Style = getLLVMStyle(); 8838 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 8839 // and always indents instead. 8840 Style.IndentWrappedFunctionNames = false; 8841 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 8842 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 8843 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 8844 "}", 8845 Style); 8846 Style.IndentWrappedFunctionNames = true; 8847 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 8848 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 8849 " anotherName:(NSString)dddddddddddddd {\n" 8850 "}", 8851 Style); 8852 8853 verifyFormat("- (int)sum:(vector<int>)numbers;"); 8854 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 8855 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 8856 // protocol lists (but not for template classes): 8857 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 8858 8859 verifyFormat("- (int (*)())foo:(int (*)())f;"); 8860 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 8861 8862 // If there's no return type (very rare in practice!), LLVM and Google style 8863 // agree. 8864 verifyFormat("- foo;"); 8865 verifyFormat("- foo:(int)f;"); 8866 verifyGoogleFormat("- foo:(int)foo;"); 8867 } 8868 8869 8870 TEST_F(FormatTest, BreaksStringLiterals) { 8871 EXPECT_EQ("\"some text \"\n" 8872 "\"other\";", 8873 format("\"some text other\";", getLLVMStyleWithColumns(12))); 8874 EXPECT_EQ("\"some text \"\n" 8875 "\"other\";", 8876 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 8877 EXPECT_EQ( 8878 "#define A \\\n" 8879 " \"some \" \\\n" 8880 " \"text \" \\\n" 8881 " \"other\";", 8882 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 8883 EXPECT_EQ( 8884 "#define A \\\n" 8885 " \"so \" \\\n" 8886 " \"text \" \\\n" 8887 " \"other\";", 8888 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 8889 8890 EXPECT_EQ("\"some text\"", 8891 format("\"some text\"", getLLVMStyleWithColumns(1))); 8892 EXPECT_EQ("\"some text\"", 8893 format("\"some text\"", getLLVMStyleWithColumns(11))); 8894 EXPECT_EQ("\"some \"\n" 8895 "\"text\"", 8896 format("\"some text\"", getLLVMStyleWithColumns(10))); 8897 EXPECT_EQ("\"some \"\n" 8898 "\"text\"", 8899 format("\"some text\"", getLLVMStyleWithColumns(7))); 8900 EXPECT_EQ("\"some\"\n" 8901 "\" tex\"\n" 8902 "\"t\"", 8903 format("\"some text\"", getLLVMStyleWithColumns(6))); 8904 EXPECT_EQ("\"some\"\n" 8905 "\" tex\"\n" 8906 "\" and\"", 8907 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 8908 EXPECT_EQ("\"some\"\n" 8909 "\"/tex\"\n" 8910 "\"/and\"", 8911 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 8912 8913 EXPECT_EQ("variable =\n" 8914 " \"long string \"\n" 8915 " \"literal\";", 8916 format("variable = \"long string literal\";", 8917 getLLVMStyleWithColumns(20))); 8918 8919 EXPECT_EQ("variable = f(\n" 8920 " \"long string \"\n" 8921 " \"literal\",\n" 8922 " short,\n" 8923 " loooooooooooooooooooong);", 8924 format("variable = f(\"long string literal\", short, " 8925 "loooooooooooooooooooong);", 8926 getLLVMStyleWithColumns(20))); 8927 8928 EXPECT_EQ( 8929 "f(g(\"long string \"\n" 8930 " \"literal\"),\n" 8931 " b);", 8932 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 8933 EXPECT_EQ("f(g(\"long string \"\n" 8934 " \"literal\",\n" 8935 " a),\n" 8936 " b);", 8937 format("f(g(\"long string literal\", a), b);", 8938 getLLVMStyleWithColumns(20))); 8939 EXPECT_EQ( 8940 "f(\"one two\".split(\n" 8941 " variable));", 8942 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 8943 EXPECT_EQ("f(\"one two three four five six \"\n" 8944 " \"seven\".split(\n" 8945 " really_looooong_variable));", 8946 format("f(\"one two three four five six seven\"." 8947 "split(really_looooong_variable));", 8948 getLLVMStyleWithColumns(33))); 8949 8950 EXPECT_EQ("f(\"some \"\n" 8951 " \"text\",\n" 8952 " other);", 8953 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 8954 8955 // Only break as a last resort. 8956 verifyFormat( 8957 "aaaaaaaaaaaaaaaaaaaa(\n" 8958 " aaaaaaaaaaaaaaaaaaaa,\n" 8959 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 8960 8961 EXPECT_EQ("\"splitmea\"\n" 8962 "\"trandomp\"\n" 8963 "\"oint\"", 8964 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 8965 8966 EXPECT_EQ("\"split/\"\n" 8967 "\"pathat/\"\n" 8968 "\"slashes\"", 8969 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 8970 8971 EXPECT_EQ("\"split/\"\n" 8972 "\"pathat/\"\n" 8973 "\"slashes\"", 8974 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 8975 EXPECT_EQ("\"split at \"\n" 8976 "\"spaces/at/\"\n" 8977 "\"slashes.at.any$\"\n" 8978 "\"non-alphanumeric%\"\n" 8979 "\"1111111111characte\"\n" 8980 "\"rs\"", 8981 format("\"split at " 8982 "spaces/at/" 8983 "slashes.at." 8984 "any$non-" 8985 "alphanumeric%" 8986 "1111111111characte" 8987 "rs\"", 8988 getLLVMStyleWithColumns(20))); 8989 8990 // Verify that splitting the strings understands 8991 // Style::AlwaysBreakBeforeMultilineStrings. 8992 EXPECT_EQ( 8993 "aaaaaaaaaaaa(\n" 8994 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 8995 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 8996 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 8997 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 8998 "aaaaaaaaaaaaaaaaaaaaaa\");", 8999 getGoogleStyle())); 9000 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9001 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 9002 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 9003 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9004 "aaaaaaaaaaaaaaaaaaaaaa\";", 9005 getGoogleStyle())); 9006 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9007 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9008 format("llvm::outs() << " 9009 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 9010 "aaaaaaaaaaaaaaaaaaa\";")); 9011 EXPECT_EQ("ffff(\n" 9012 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9013 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9014 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 9015 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9016 getGoogleStyle())); 9017 9018 FormatStyle Style = getLLVMStyleWithColumns(12); 9019 Style.BreakStringLiterals = false; 9020 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 9021 9022 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 9023 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9024 EXPECT_EQ("#define A \\\n" 9025 " \"some \" \\\n" 9026 " \"text \" \\\n" 9027 " \"other\";", 9028 format("#define A \"some text other\";", AlignLeft)); 9029 } 9030 9031 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 9032 EXPECT_EQ("C a = \"some more \"\n" 9033 " \"text\";", 9034 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 9035 } 9036 9037 TEST_F(FormatTest, FullyRemoveEmptyLines) { 9038 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 9039 NoEmptyLines.MaxEmptyLinesToKeep = 0; 9040 EXPECT_EQ("int i = a(b());", 9041 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 9042 } 9043 9044 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 9045 EXPECT_EQ( 9046 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9047 "(\n" 9048 " \"x\t\");", 9049 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9050 "aaaaaaa(" 9051 "\"x\t\");")); 9052 } 9053 9054 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 9055 EXPECT_EQ( 9056 "u8\"utf8 string \"\n" 9057 "u8\"literal\";", 9058 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 9059 EXPECT_EQ( 9060 "u\"utf16 string \"\n" 9061 "u\"literal\";", 9062 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 9063 EXPECT_EQ( 9064 "U\"utf32 string \"\n" 9065 "U\"literal\";", 9066 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 9067 EXPECT_EQ("L\"wide string \"\n" 9068 "L\"literal\";", 9069 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 9070 EXPECT_EQ("@\"NSString \"\n" 9071 "@\"literal\";", 9072 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 9073 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 9074 9075 // This input makes clang-format try to split the incomplete unicode escape 9076 // sequence, which used to lead to a crasher. 9077 verifyNoCrash( 9078 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 9079 getLLVMStyleWithColumns(60)); 9080 } 9081 9082 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 9083 FormatStyle Style = getGoogleStyleWithColumns(15); 9084 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 9085 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 9086 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 9087 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 9088 EXPECT_EQ("u8R\"x(raw literal)x\";", 9089 format("u8R\"x(raw literal)x\";", Style)); 9090 } 9091 9092 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 9093 FormatStyle Style = getLLVMStyleWithColumns(20); 9094 EXPECT_EQ( 9095 "_T(\"aaaaaaaaaaaaaa\")\n" 9096 "_T(\"aaaaaaaaaaaaaa\")\n" 9097 "_T(\"aaaaaaaaaaaa\")", 9098 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 9099 EXPECT_EQ("f(x,\n" 9100 " _T(\"aaaaaaaaaaaa\")\n" 9101 " _T(\"aaa\"),\n" 9102 " z);", 9103 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 9104 9105 // FIXME: Handle embedded spaces in one iteration. 9106 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 9107 // "_T(\"aaaaaaaaaaaaa\")\n" 9108 // "_T(\"aaaaaaaaaaaaa\")\n" 9109 // "_T(\"a\")", 9110 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9111 // getLLVMStyleWithColumns(20))); 9112 EXPECT_EQ( 9113 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9114 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 9115 EXPECT_EQ("f(\n" 9116 "#if !TEST\n" 9117 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9118 "#endif\n" 9119 ");", 9120 format("f(\n" 9121 "#if !TEST\n" 9122 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9123 "#endif\n" 9124 ");")); 9125 EXPECT_EQ("f(\n" 9126 "\n" 9127 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 9128 format("f(\n" 9129 "\n" 9130 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 9131 } 9132 9133 TEST_F(FormatTest, BreaksStringLiteralOperands) { 9134 // In a function call with two operands, the second can be broken with no line 9135 // break before it. 9136 EXPECT_EQ("func(a, \"long long \"\n" 9137 " \"long long\");", 9138 format("func(a, \"long long long long\");", 9139 getLLVMStyleWithColumns(24))); 9140 // In a function call with three operands, the second must be broken with a 9141 // line break before it. 9142 EXPECT_EQ("func(a,\n" 9143 " \"long long long \"\n" 9144 " \"long\",\n" 9145 " c);", 9146 format("func(a, \"long long long long\", c);", 9147 getLLVMStyleWithColumns(24))); 9148 // In a function call with three operands, the third must be broken with a 9149 // line break before it. 9150 EXPECT_EQ("func(a, b,\n" 9151 " \"long long long \"\n" 9152 " \"long\");", 9153 format("func(a, b, \"long long long long\");", 9154 getLLVMStyleWithColumns(24))); 9155 // In a function call with three operands, both the second and the third must 9156 // be broken with a line break before them. 9157 EXPECT_EQ("func(a,\n" 9158 " \"long long long \"\n" 9159 " \"long\",\n" 9160 " \"long long long \"\n" 9161 " \"long\");", 9162 format("func(a, \"long long long long\", \"long long long long\");", 9163 getLLVMStyleWithColumns(24))); 9164 // In a chain of << with two operands, the second can be broken with no line 9165 // break before it. 9166 EXPECT_EQ("a << \"line line \"\n" 9167 " \"line\";", 9168 format("a << \"line line line\";", 9169 getLLVMStyleWithColumns(20))); 9170 // In a chain of << with three operands, the second can be broken with no line 9171 // break before it. 9172 EXPECT_EQ("abcde << \"line \"\n" 9173 " \"line line\"\n" 9174 " << c;", 9175 format("abcde << \"line line line\" << c;", 9176 getLLVMStyleWithColumns(20))); 9177 // In a chain of << with three operands, the third must be broken with a line 9178 // break before it. 9179 EXPECT_EQ("a << b\n" 9180 " << \"line line \"\n" 9181 " \"line\";", 9182 format("a << b << \"line line line\";", 9183 getLLVMStyleWithColumns(20))); 9184 // In a chain of << with three operands, the second can be broken with no line 9185 // break before it and the third must be broken with a line break before it. 9186 EXPECT_EQ("abcd << \"line line \"\n" 9187 " \"line\"\n" 9188 " << \"line line \"\n" 9189 " \"line\";", 9190 format("abcd << \"line line line\" << \"line line line\";", 9191 getLLVMStyleWithColumns(20))); 9192 // In a chain of binary operators with two operands, the second can be broken 9193 // with no line break before it. 9194 EXPECT_EQ("abcd + \"line line \"\n" 9195 " \"line line\";", 9196 format("abcd + \"line line line line\";", 9197 getLLVMStyleWithColumns(20))); 9198 // In a chain of binary operators with three operands, the second must be 9199 // broken with a line break before it. 9200 EXPECT_EQ("abcd +\n" 9201 " \"line line \"\n" 9202 " \"line line\" +\n" 9203 " e;", 9204 format("abcd + \"line line line line\" + e;", 9205 getLLVMStyleWithColumns(20))); 9206 // In a function call with two operands, with AlignAfterOpenBracket enabled, 9207 // the first must be broken with a line break before it. 9208 FormatStyle Style = getLLVMStyleWithColumns(25); 9209 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 9210 EXPECT_EQ("someFunction(\n" 9211 " \"long long long \"\n" 9212 " \"long\",\n" 9213 " a);", 9214 format("someFunction(\"long long long long\", a);", Style)); 9215 } 9216 9217 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 9218 EXPECT_EQ( 9219 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9220 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9221 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9222 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9223 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9224 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 9225 } 9226 9227 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 9228 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 9229 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 9230 EXPECT_EQ("fffffffffff(g(R\"x(\n" 9231 "multiline raw string literal xxxxxxxxxxxxxx\n" 9232 ")x\",\n" 9233 " a),\n" 9234 " b);", 9235 format("fffffffffff(g(R\"x(\n" 9236 "multiline raw string literal xxxxxxxxxxxxxx\n" 9237 ")x\", a), b);", 9238 getGoogleStyleWithColumns(20))); 9239 EXPECT_EQ("fffffffffff(\n" 9240 " g(R\"x(qqq\n" 9241 "multiline raw string literal xxxxxxxxxxxxxx\n" 9242 ")x\",\n" 9243 " a),\n" 9244 " b);", 9245 format("fffffffffff(g(R\"x(qqq\n" 9246 "multiline raw string literal xxxxxxxxxxxxxx\n" 9247 ")x\", a), b);", 9248 getGoogleStyleWithColumns(20))); 9249 9250 EXPECT_EQ("fffffffffff(R\"x(\n" 9251 "multiline raw string literal xxxxxxxxxxxxxx\n" 9252 ")x\");", 9253 format("fffffffffff(R\"x(\n" 9254 "multiline raw string literal xxxxxxxxxxxxxx\n" 9255 ")x\");", 9256 getGoogleStyleWithColumns(20))); 9257 EXPECT_EQ("fffffffffff(R\"x(\n" 9258 "multiline raw string literal xxxxxxxxxxxxxx\n" 9259 ")x\" + bbbbbb);", 9260 format("fffffffffff(R\"x(\n" 9261 "multiline raw string literal xxxxxxxxxxxxxx\n" 9262 ")x\" + bbbbbb);", 9263 getGoogleStyleWithColumns(20))); 9264 EXPECT_EQ("fffffffffff(\n" 9265 " R\"x(\n" 9266 "multiline raw string literal xxxxxxxxxxxxxx\n" 9267 ")x\" +\n" 9268 " bbbbbb);", 9269 format("fffffffffff(\n" 9270 " R\"x(\n" 9271 "multiline raw string literal xxxxxxxxxxxxxx\n" 9272 ")x\" + bbbbbb);", 9273 getGoogleStyleWithColumns(20))); 9274 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 9275 format("fffffffffff(\n" 9276 " R\"(single line raw string)\" + bbbbbb);")); 9277 } 9278 9279 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 9280 verifyFormat("string a = \"unterminated;"); 9281 EXPECT_EQ("function(\"unterminated,\n" 9282 " OtherParameter);", 9283 format("function( \"unterminated,\n" 9284 " OtherParameter);")); 9285 } 9286 9287 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9288 FormatStyle Style = getLLVMStyle(); 9289 Style.Standard = FormatStyle::LS_Cpp03; 9290 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9291 format("#define x(_a) printf(\"foo\"_a);", Style)); 9292 } 9293 9294 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9295 9296 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9297 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9298 " \"ddeeefff\");", 9299 format("someFunction(\"aaabbbcccdddeeefff\");", 9300 getLLVMStyleWithColumns(25))); 9301 EXPECT_EQ("someFunction1234567890(\n" 9302 " \"aaabbbcccdddeeefff\");", 9303 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9304 getLLVMStyleWithColumns(26))); 9305 EXPECT_EQ("someFunction1234567890(\n" 9306 " \"aaabbbcccdddeeeff\"\n" 9307 " \"f\");", 9308 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9309 getLLVMStyleWithColumns(25))); 9310 EXPECT_EQ("someFunction1234567890(\n" 9311 " \"aaabbbcccdddeeeff\"\n" 9312 " \"f\");", 9313 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9314 getLLVMStyleWithColumns(24))); 9315 EXPECT_EQ("someFunction(\n" 9316 " \"aaabbbcc ddde \"\n" 9317 " \"efff\");", 9318 format("someFunction(\"aaabbbcc ddde efff\");", 9319 getLLVMStyleWithColumns(25))); 9320 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9321 " \"ddeeefff\");", 9322 format("someFunction(\"aaabbbccc ddeeefff\");", 9323 getLLVMStyleWithColumns(25))); 9324 EXPECT_EQ("someFunction1234567890(\n" 9325 " \"aaabb \"\n" 9326 " \"cccdddeeefff\");", 9327 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9328 getLLVMStyleWithColumns(25))); 9329 EXPECT_EQ("#define A \\\n" 9330 " string s = \\\n" 9331 " \"123456789\" \\\n" 9332 " \"0\"; \\\n" 9333 " int i;", 9334 format("#define A string s = \"1234567890\"; int i;", 9335 getLLVMStyleWithColumns(20))); 9336 EXPECT_EQ("someFunction(\n" 9337 " \"aaabbbcc \"\n" 9338 " \"dddeeefff\");", 9339 format("someFunction(\"aaabbbcc dddeeefff\");", 9340 getLLVMStyleWithColumns(25))); 9341 } 9342 9343 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9344 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9345 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9346 EXPECT_EQ("\"test\"\n" 9347 "\"\\n\"", 9348 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9349 EXPECT_EQ("\"tes\\\\\"\n" 9350 "\"n\"", 9351 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9352 EXPECT_EQ("\"\\\\\\\\\"\n" 9353 "\"\\n\"", 9354 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9355 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9356 EXPECT_EQ("\"\\uff01\"\n" 9357 "\"test\"", 9358 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9359 EXPECT_EQ("\"\\Uff01ff02\"", 9360 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9361 EXPECT_EQ("\"\\x000000000001\"\n" 9362 "\"next\"", 9363 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9364 EXPECT_EQ("\"\\x000000000001next\"", 9365 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9366 EXPECT_EQ("\"\\x000000000001\"", 9367 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9368 EXPECT_EQ("\"test\"\n" 9369 "\"\\000000\"\n" 9370 "\"000001\"", 9371 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9372 EXPECT_EQ("\"test\\000\"\n" 9373 "\"00000000\"\n" 9374 "\"1\"", 9375 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9376 } 9377 9378 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9379 verifyFormat("void f() {\n" 9380 " return g() {}\n" 9381 " void h() {}"); 9382 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9383 "g();\n" 9384 "}"); 9385 } 9386 9387 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9388 verifyFormat( 9389 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9390 } 9391 9392 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9393 verifyFormat("class X {\n" 9394 " void f() {\n" 9395 " }\n" 9396 "};", 9397 getLLVMStyleWithColumns(12)); 9398 } 9399 9400 TEST_F(FormatTest, ConfigurableIndentWidth) { 9401 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9402 EightIndent.IndentWidth = 8; 9403 EightIndent.ContinuationIndentWidth = 8; 9404 verifyFormat("void f() {\n" 9405 " someFunction();\n" 9406 " if (true) {\n" 9407 " f();\n" 9408 " }\n" 9409 "}", 9410 EightIndent); 9411 verifyFormat("class X {\n" 9412 " void f() {\n" 9413 " }\n" 9414 "};", 9415 EightIndent); 9416 verifyFormat("int x[] = {\n" 9417 " call(),\n" 9418 " call()};", 9419 EightIndent); 9420 } 9421 9422 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9423 verifyFormat("double\n" 9424 "f();", 9425 getLLVMStyleWithColumns(8)); 9426 } 9427 9428 TEST_F(FormatTest, ConfigurableUseOfTab) { 9429 FormatStyle Tab = getLLVMStyleWithColumns(42); 9430 Tab.IndentWidth = 8; 9431 Tab.UseTab = FormatStyle::UT_Always; 9432 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9433 9434 EXPECT_EQ("if (aaaaaaaa && // q\n" 9435 " bb)\t\t// w\n" 9436 "\t;", 9437 format("if (aaaaaaaa &&// q\n" 9438 "bb)// w\n" 9439 ";", 9440 Tab)); 9441 EXPECT_EQ("if (aaa && bbb) // w\n" 9442 "\t;", 9443 format("if(aaa&&bbb)// w\n" 9444 ";", 9445 Tab)); 9446 9447 verifyFormat("class X {\n" 9448 "\tvoid f() {\n" 9449 "\t\tsomeFunction(parameter1,\n" 9450 "\t\t\t parameter2);\n" 9451 "\t}\n" 9452 "};", 9453 Tab); 9454 verifyFormat("#define A \\\n" 9455 "\tvoid f() { \\\n" 9456 "\t\tsomeFunction( \\\n" 9457 "\t\t parameter1, \\\n" 9458 "\t\t parameter2); \\\n" 9459 "\t}", 9460 Tab); 9461 verifyFormat("int a;\t // x\n" 9462 "int bbbbbbbb; // x\n", 9463 Tab); 9464 9465 Tab.TabWidth = 4; 9466 Tab.IndentWidth = 8; 9467 verifyFormat("class TabWidth4Indent8 {\n" 9468 "\t\tvoid f() {\n" 9469 "\t\t\t\tsomeFunction(parameter1,\n" 9470 "\t\t\t\t\t\t\t parameter2);\n" 9471 "\t\t}\n" 9472 "};", 9473 Tab); 9474 9475 Tab.TabWidth = 4; 9476 Tab.IndentWidth = 4; 9477 verifyFormat("class TabWidth4Indent4 {\n" 9478 "\tvoid f() {\n" 9479 "\t\tsomeFunction(parameter1,\n" 9480 "\t\t\t\t\t parameter2);\n" 9481 "\t}\n" 9482 "};", 9483 Tab); 9484 9485 Tab.TabWidth = 8; 9486 Tab.IndentWidth = 4; 9487 verifyFormat("class TabWidth8Indent4 {\n" 9488 " void f() {\n" 9489 "\tsomeFunction(parameter1,\n" 9490 "\t\t parameter2);\n" 9491 " }\n" 9492 "};", 9493 Tab); 9494 9495 Tab.TabWidth = 8; 9496 Tab.IndentWidth = 8; 9497 EXPECT_EQ("/*\n" 9498 "\t a\t\tcomment\n" 9499 "\t in multiple lines\n" 9500 " */", 9501 format(" /*\t \t \n" 9502 " \t \t a\t\tcomment\t \t\n" 9503 " \t \t in multiple lines\t\n" 9504 " \t */", 9505 Tab)); 9506 9507 Tab.UseTab = FormatStyle::UT_ForIndentation; 9508 verifyFormat("{\n" 9509 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9510 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9511 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9512 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9513 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9514 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9515 "};", 9516 Tab); 9517 verifyFormat("enum AA {\n" 9518 "\ta1, // Force multiple lines\n" 9519 "\ta2,\n" 9520 "\ta3\n" 9521 "};", 9522 Tab); 9523 EXPECT_EQ("if (aaaaaaaa && // q\n" 9524 " bb) // w\n" 9525 "\t;", 9526 format("if (aaaaaaaa &&// q\n" 9527 "bb)// w\n" 9528 ";", 9529 Tab)); 9530 verifyFormat("class X {\n" 9531 "\tvoid f() {\n" 9532 "\t\tsomeFunction(parameter1,\n" 9533 "\t\t parameter2);\n" 9534 "\t}\n" 9535 "};", 9536 Tab); 9537 verifyFormat("{\n" 9538 "\tQ(\n" 9539 "\t {\n" 9540 "\t\t int a;\n" 9541 "\t\t someFunction(aaaaaaaa,\n" 9542 "\t\t bbbbbbb);\n" 9543 "\t },\n" 9544 "\t p);\n" 9545 "}", 9546 Tab); 9547 EXPECT_EQ("{\n" 9548 "\t/* aaaa\n" 9549 "\t bbbb */\n" 9550 "}", 9551 format("{\n" 9552 "/* aaaa\n" 9553 " bbbb */\n" 9554 "}", 9555 Tab)); 9556 EXPECT_EQ("{\n" 9557 "\t/*\n" 9558 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9559 "\t bbbbbbbbbbbbb\n" 9560 "\t*/\n" 9561 "}", 9562 format("{\n" 9563 "/*\n" 9564 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9565 "*/\n" 9566 "}", 9567 Tab)); 9568 EXPECT_EQ("{\n" 9569 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9570 "\t// bbbbbbbbbbbbb\n" 9571 "}", 9572 format("{\n" 9573 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9574 "}", 9575 Tab)); 9576 EXPECT_EQ("{\n" 9577 "\t/*\n" 9578 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9579 "\t bbbbbbbbbbbbb\n" 9580 "\t*/\n" 9581 "}", 9582 format("{\n" 9583 "\t/*\n" 9584 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9585 "\t*/\n" 9586 "}", 9587 Tab)); 9588 EXPECT_EQ("{\n" 9589 "\t/*\n" 9590 "\n" 9591 "\t*/\n" 9592 "}", 9593 format("{\n" 9594 "\t/*\n" 9595 "\n" 9596 "\t*/\n" 9597 "}", 9598 Tab)); 9599 EXPECT_EQ("{\n" 9600 "\t/*\n" 9601 " asdf\n" 9602 "\t*/\n" 9603 "}", 9604 format("{\n" 9605 "\t/*\n" 9606 " asdf\n" 9607 "\t*/\n" 9608 "}", 9609 Tab)); 9610 9611 Tab.UseTab = FormatStyle::UT_Never; 9612 EXPECT_EQ("/*\n" 9613 " a\t\tcomment\n" 9614 " in multiple lines\n" 9615 " */", 9616 format(" /*\t \t \n" 9617 " \t \t a\t\tcomment\t \t\n" 9618 " \t \t in multiple lines\t\n" 9619 " \t */", 9620 Tab)); 9621 EXPECT_EQ("/* some\n" 9622 " comment */", 9623 format(" \t \t /* some\n" 9624 " \t \t comment */", 9625 Tab)); 9626 EXPECT_EQ("int a; /* some\n" 9627 " comment */", 9628 format(" \t \t int a; /* some\n" 9629 " \t \t comment */", 9630 Tab)); 9631 9632 EXPECT_EQ("int a; /* some\n" 9633 "comment */", 9634 format(" \t \t int\ta; /* some\n" 9635 " \t \t comment */", 9636 Tab)); 9637 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9638 " comment */", 9639 format(" \t \t f(\"\t\t\"); /* some\n" 9640 " \t \t comment */", 9641 Tab)); 9642 EXPECT_EQ("{\n" 9643 " /*\n" 9644 " * Comment\n" 9645 " */\n" 9646 " int i;\n" 9647 "}", 9648 format("{\n" 9649 "\t/*\n" 9650 "\t * Comment\n" 9651 "\t */\n" 9652 "\t int i;\n" 9653 "}")); 9654 9655 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 9656 Tab.TabWidth = 8; 9657 Tab.IndentWidth = 8; 9658 EXPECT_EQ("if (aaaaaaaa && // q\n" 9659 " bb) // w\n" 9660 "\t;", 9661 format("if (aaaaaaaa &&// q\n" 9662 "bb)// w\n" 9663 ";", 9664 Tab)); 9665 EXPECT_EQ("if (aaa && bbb) // w\n" 9666 "\t;", 9667 format("if(aaa&&bbb)// w\n" 9668 ";", 9669 Tab)); 9670 verifyFormat("class X {\n" 9671 "\tvoid f() {\n" 9672 "\t\tsomeFunction(parameter1,\n" 9673 "\t\t\t parameter2);\n" 9674 "\t}\n" 9675 "};", 9676 Tab); 9677 verifyFormat("#define A \\\n" 9678 "\tvoid f() { \\\n" 9679 "\t\tsomeFunction( \\\n" 9680 "\t\t parameter1, \\\n" 9681 "\t\t parameter2); \\\n" 9682 "\t}", 9683 Tab); 9684 Tab.TabWidth = 4; 9685 Tab.IndentWidth = 8; 9686 verifyFormat("class TabWidth4Indent8 {\n" 9687 "\t\tvoid f() {\n" 9688 "\t\t\t\tsomeFunction(parameter1,\n" 9689 "\t\t\t\t\t\t\t parameter2);\n" 9690 "\t\t}\n" 9691 "};", 9692 Tab); 9693 Tab.TabWidth = 4; 9694 Tab.IndentWidth = 4; 9695 verifyFormat("class TabWidth4Indent4 {\n" 9696 "\tvoid f() {\n" 9697 "\t\tsomeFunction(parameter1,\n" 9698 "\t\t\t\t\t parameter2);\n" 9699 "\t}\n" 9700 "};", 9701 Tab); 9702 Tab.TabWidth = 8; 9703 Tab.IndentWidth = 4; 9704 verifyFormat("class TabWidth8Indent4 {\n" 9705 " void f() {\n" 9706 "\tsomeFunction(parameter1,\n" 9707 "\t\t parameter2);\n" 9708 " }\n" 9709 "};", 9710 Tab); 9711 Tab.TabWidth = 8; 9712 Tab.IndentWidth = 8; 9713 EXPECT_EQ("/*\n" 9714 "\t a\t\tcomment\n" 9715 "\t in multiple lines\n" 9716 " */", 9717 format(" /*\t \t \n" 9718 " \t \t a\t\tcomment\t \t\n" 9719 " \t \t in multiple lines\t\n" 9720 " \t */", 9721 Tab)); 9722 verifyFormat("{\n" 9723 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9724 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9725 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9726 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9727 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9728 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9729 "};", 9730 Tab); 9731 verifyFormat("enum AA {\n" 9732 "\ta1, // Force multiple lines\n" 9733 "\ta2,\n" 9734 "\ta3\n" 9735 "};", 9736 Tab); 9737 EXPECT_EQ("if (aaaaaaaa && // q\n" 9738 " bb) // w\n" 9739 "\t;", 9740 format("if (aaaaaaaa &&// q\n" 9741 "bb)// w\n" 9742 ";", 9743 Tab)); 9744 verifyFormat("class X {\n" 9745 "\tvoid f() {\n" 9746 "\t\tsomeFunction(parameter1,\n" 9747 "\t\t\t parameter2);\n" 9748 "\t}\n" 9749 "};", 9750 Tab); 9751 verifyFormat("{\n" 9752 "\tQ(\n" 9753 "\t {\n" 9754 "\t\t int a;\n" 9755 "\t\t someFunction(aaaaaaaa,\n" 9756 "\t\t\t\t bbbbbbb);\n" 9757 "\t },\n" 9758 "\t p);\n" 9759 "}", 9760 Tab); 9761 EXPECT_EQ("{\n" 9762 "\t/* aaaa\n" 9763 "\t bbbb */\n" 9764 "}", 9765 format("{\n" 9766 "/* aaaa\n" 9767 " bbbb */\n" 9768 "}", 9769 Tab)); 9770 EXPECT_EQ("{\n" 9771 "\t/*\n" 9772 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9773 "\t bbbbbbbbbbbbb\n" 9774 "\t*/\n" 9775 "}", 9776 format("{\n" 9777 "/*\n" 9778 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9779 "*/\n" 9780 "}", 9781 Tab)); 9782 EXPECT_EQ("{\n" 9783 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9784 "\t// bbbbbbbbbbbbb\n" 9785 "}", 9786 format("{\n" 9787 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9788 "}", 9789 Tab)); 9790 EXPECT_EQ("{\n" 9791 "\t/*\n" 9792 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9793 "\t bbbbbbbbbbbbb\n" 9794 "\t*/\n" 9795 "}", 9796 format("{\n" 9797 "\t/*\n" 9798 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9799 "\t*/\n" 9800 "}", 9801 Tab)); 9802 EXPECT_EQ("{\n" 9803 "\t/*\n" 9804 "\n" 9805 "\t*/\n" 9806 "}", 9807 format("{\n" 9808 "\t/*\n" 9809 "\n" 9810 "\t*/\n" 9811 "}", 9812 Tab)); 9813 EXPECT_EQ("{\n" 9814 "\t/*\n" 9815 " asdf\n" 9816 "\t*/\n" 9817 "}", 9818 format("{\n" 9819 "\t/*\n" 9820 " asdf\n" 9821 "\t*/\n" 9822 "}", 9823 Tab)); 9824 EXPECT_EQ("/*\n" 9825 "\t a\t\tcomment\n" 9826 "\t in multiple lines\n" 9827 " */", 9828 format(" /*\t \t \n" 9829 " \t \t a\t\tcomment\t \t\n" 9830 " \t \t in multiple lines\t\n" 9831 " \t */", 9832 Tab)); 9833 EXPECT_EQ("/* some\n" 9834 " comment */", 9835 format(" \t \t /* some\n" 9836 " \t \t comment */", 9837 Tab)); 9838 EXPECT_EQ("int a; /* some\n" 9839 " comment */", 9840 format(" \t \t int a; /* some\n" 9841 " \t \t comment */", 9842 Tab)); 9843 EXPECT_EQ("int a; /* some\n" 9844 "comment */", 9845 format(" \t \t int\ta; /* some\n" 9846 " \t \t comment */", 9847 Tab)); 9848 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9849 " comment */", 9850 format(" \t \t f(\"\t\t\"); /* some\n" 9851 " \t \t comment */", 9852 Tab)); 9853 EXPECT_EQ("{\n" 9854 " /*\n" 9855 " * Comment\n" 9856 " */\n" 9857 " int i;\n" 9858 "}", 9859 format("{\n" 9860 "\t/*\n" 9861 "\t * Comment\n" 9862 "\t */\n" 9863 "\t int i;\n" 9864 "}")); 9865 Tab.AlignConsecutiveAssignments = true; 9866 Tab.AlignConsecutiveDeclarations = true; 9867 Tab.TabWidth = 4; 9868 Tab.IndentWidth = 4; 9869 verifyFormat("class Assign {\n" 9870 "\tvoid f() {\n" 9871 "\t\tint x = 123;\n" 9872 "\t\tint random = 4;\n" 9873 "\t\tstd::string alphabet =\n" 9874 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 9875 "\t}\n" 9876 "};", 9877 Tab); 9878 } 9879 9880 TEST_F(FormatTest, ZeroTabWidth) { 9881 FormatStyle Tab = getLLVMStyleWithColumns(42); 9882 Tab.IndentWidth = 8; 9883 Tab.UseTab = FormatStyle::UT_Never; 9884 Tab.TabWidth = 0; 9885 EXPECT_EQ("void a(){\n" 9886 " // line starts with '\t'\n" 9887 "};", 9888 format("void a(){\n" 9889 "\t// line starts with '\t'\n" 9890 "};", 9891 Tab)); 9892 9893 EXPECT_EQ("void a(){\n" 9894 " // line starts with '\t'\n" 9895 "};", 9896 format("void a(){\n" 9897 "\t\t// line starts with '\t'\n" 9898 "};", 9899 Tab)); 9900 9901 Tab.UseTab = FormatStyle::UT_ForIndentation; 9902 EXPECT_EQ("void a(){\n" 9903 " // line starts with '\t'\n" 9904 "};", 9905 format("void a(){\n" 9906 "\t// line starts with '\t'\n" 9907 "};", 9908 Tab)); 9909 9910 EXPECT_EQ("void a(){\n" 9911 " // line starts with '\t'\n" 9912 "};", 9913 format("void a(){\n" 9914 "\t\t// line starts with '\t'\n" 9915 "};", 9916 Tab)); 9917 9918 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 9919 EXPECT_EQ("void a(){\n" 9920 " // line starts with '\t'\n" 9921 "};", 9922 format("void a(){\n" 9923 "\t// line starts with '\t'\n" 9924 "};", 9925 Tab)); 9926 9927 EXPECT_EQ("void a(){\n" 9928 " // line starts with '\t'\n" 9929 "};", 9930 format("void a(){\n" 9931 "\t\t// line starts with '\t'\n" 9932 "};", 9933 Tab)); 9934 9935 Tab.UseTab = FormatStyle::UT_Always; 9936 EXPECT_EQ("void a(){\n" 9937 "// line starts with '\t'\n" 9938 "};", 9939 format("void a(){\n" 9940 "\t// line starts with '\t'\n" 9941 "};", 9942 Tab)); 9943 9944 EXPECT_EQ("void a(){\n" 9945 "// line starts with '\t'\n" 9946 "};", 9947 format("void a(){\n" 9948 "\t\t// line starts with '\t'\n" 9949 "};", 9950 Tab)); 9951 } 9952 9953 TEST_F(FormatTest, CalculatesOriginalColumn) { 9954 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9955 "q\"; /* some\n" 9956 " comment */", 9957 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9958 "q\"; /* some\n" 9959 " comment */", 9960 getLLVMStyle())); 9961 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 9962 "/* some\n" 9963 " comment */", 9964 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 9965 " /* some\n" 9966 " comment */", 9967 getLLVMStyle())); 9968 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9969 "qqq\n" 9970 "/* some\n" 9971 " comment */", 9972 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9973 "qqq\n" 9974 " /* some\n" 9975 " comment */", 9976 getLLVMStyle())); 9977 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9978 "wwww; /* some\n" 9979 " comment */", 9980 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9981 "wwww; /* some\n" 9982 " comment */", 9983 getLLVMStyle())); 9984 } 9985 9986 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 9987 FormatStyle NoSpace = getLLVMStyle(); 9988 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 9989 9990 verifyFormat("while(true)\n" 9991 " continue;", 9992 NoSpace); 9993 verifyFormat("for(;;)\n" 9994 " continue;", 9995 NoSpace); 9996 verifyFormat("if(true)\n" 9997 " f();\n" 9998 "else if(true)\n" 9999 " f();", 10000 NoSpace); 10001 verifyFormat("do {\n" 10002 " do_something();\n" 10003 "} while(something());", 10004 NoSpace); 10005 verifyFormat("switch(x) {\n" 10006 "default:\n" 10007 " break;\n" 10008 "}", 10009 NoSpace); 10010 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 10011 verifyFormat("size_t x = sizeof(x);", NoSpace); 10012 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 10013 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 10014 verifyFormat("alignas(128) char a[128];", NoSpace); 10015 verifyFormat("size_t x = alignof(MyType);", NoSpace); 10016 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 10017 verifyFormat("int f() throw(Deprecated);", NoSpace); 10018 verifyFormat("typedef void (*cb)(int);", NoSpace); 10019 verifyFormat("T A::operator()();", NoSpace); 10020 verifyFormat("X A::operator++(T);", NoSpace); 10021 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 10022 10023 FormatStyle Space = getLLVMStyle(); 10024 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 10025 10026 verifyFormat("int f ();", Space); 10027 verifyFormat("void f (int a, T b) {\n" 10028 " while (true)\n" 10029 " continue;\n" 10030 "}", 10031 Space); 10032 verifyFormat("if (true)\n" 10033 " f ();\n" 10034 "else if (true)\n" 10035 " f ();", 10036 Space); 10037 verifyFormat("do {\n" 10038 " do_something ();\n" 10039 "} while (something ());", 10040 Space); 10041 verifyFormat("switch (x) {\n" 10042 "default:\n" 10043 " break;\n" 10044 "}", 10045 Space); 10046 verifyFormat("A::A () : a (1) {}", Space); 10047 verifyFormat("void f () __attribute__ ((asdf));", Space); 10048 verifyFormat("*(&a + 1);\n" 10049 "&((&a)[1]);\n" 10050 "a[(b + c) * d];\n" 10051 "(((a + 1) * 2) + 3) * 4;", 10052 Space); 10053 verifyFormat("#define A(x) x", Space); 10054 verifyFormat("#define A (x) x", Space); 10055 verifyFormat("#if defined(x)\n" 10056 "#endif", 10057 Space); 10058 verifyFormat("auto i = std::make_unique<int> (5);", Space); 10059 verifyFormat("size_t x = sizeof (x);", Space); 10060 verifyFormat("auto f (int x) -> decltype (x);", Space); 10061 verifyFormat("int f (T x) noexcept (x.create ());", Space); 10062 verifyFormat("alignas (128) char a[128];", Space); 10063 verifyFormat("size_t x = alignof (MyType);", Space); 10064 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 10065 verifyFormat("int f () throw (Deprecated);", Space); 10066 verifyFormat("typedef void (*cb) (int);", Space); 10067 verifyFormat("T A::operator() ();", Space); 10068 verifyFormat("X A::operator++ (T);", Space); 10069 verifyFormat("auto lambda = [] () { return 0; };", Space); 10070 verifyFormat("int x = int (y);", Space); 10071 10072 FormatStyle SomeSpace = getLLVMStyle(); 10073 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 10074 10075 verifyFormat("[]() -> float {}", SomeSpace); 10076 verifyFormat("[] (auto foo) {}", SomeSpace); 10077 verifyFormat("[foo]() -> int {}", SomeSpace); 10078 verifyFormat("int f();", SomeSpace); 10079 verifyFormat("void f (int a, T b) {\n" 10080 " while (true)\n" 10081 " continue;\n" 10082 "}", 10083 SomeSpace); 10084 verifyFormat("if (true)\n" 10085 " f();\n" 10086 "else if (true)\n" 10087 " f();", 10088 SomeSpace); 10089 verifyFormat("do {\n" 10090 " do_something();\n" 10091 "} while (something());", 10092 SomeSpace); 10093 verifyFormat("switch (x) {\n" 10094 "default:\n" 10095 " break;\n" 10096 "}", 10097 SomeSpace); 10098 verifyFormat("A::A() : a (1) {}", SomeSpace); 10099 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 10100 verifyFormat("*(&a + 1);\n" 10101 "&((&a)[1]);\n" 10102 "a[(b + c) * d];\n" 10103 "(((a + 1) * 2) + 3) * 4;", 10104 SomeSpace); 10105 verifyFormat("#define A(x) x", SomeSpace); 10106 verifyFormat("#define A (x) x", SomeSpace); 10107 verifyFormat("#if defined(x)\n" 10108 "#endif", 10109 SomeSpace); 10110 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 10111 verifyFormat("size_t x = sizeof (x);", SomeSpace); 10112 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 10113 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 10114 verifyFormat("alignas (128) char a[128];", SomeSpace); 10115 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 10116 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 10117 SomeSpace); 10118 verifyFormat("int f() throw (Deprecated);", SomeSpace); 10119 verifyFormat("typedef void (*cb) (int);", SomeSpace); 10120 verifyFormat("T A::operator()();", SomeSpace); 10121 verifyFormat("X A::operator++ (T);", SomeSpace); 10122 verifyFormat("int x = int (y);", SomeSpace); 10123 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 10124 } 10125 10126 TEST_F(FormatTest, SpaceAfterLogicalNot) { 10127 FormatStyle Spaces = getLLVMStyle(); 10128 Spaces.SpaceAfterLogicalNot = true; 10129 10130 verifyFormat("bool x = ! y", Spaces); 10131 verifyFormat("if (! isFailure())", Spaces); 10132 verifyFormat("if (! (a && b))", Spaces); 10133 verifyFormat("\"Error!\"", Spaces); 10134 verifyFormat("! ! x", Spaces); 10135 } 10136 10137 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 10138 FormatStyle Spaces = getLLVMStyle(); 10139 10140 Spaces.SpacesInParentheses = true; 10141 verifyFormat("do_something( ::globalVar );", Spaces); 10142 verifyFormat("call( x, y, z );", Spaces); 10143 verifyFormat("call();", Spaces); 10144 verifyFormat("std::function<void( int, int )> callback;", Spaces); 10145 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 10146 Spaces); 10147 verifyFormat("while ( (bool)1 )\n" 10148 " continue;", 10149 Spaces); 10150 verifyFormat("for ( ;; )\n" 10151 " continue;", 10152 Spaces); 10153 verifyFormat("if ( true )\n" 10154 " f();\n" 10155 "else if ( true )\n" 10156 " f();", 10157 Spaces); 10158 verifyFormat("do {\n" 10159 " do_something( (int)i );\n" 10160 "} while ( something() );", 10161 Spaces); 10162 verifyFormat("switch ( x ) {\n" 10163 "default:\n" 10164 " break;\n" 10165 "}", 10166 Spaces); 10167 10168 Spaces.SpacesInParentheses = false; 10169 Spaces.SpacesInCStyleCastParentheses = true; 10170 verifyFormat("Type *A = ( Type * )P;", Spaces); 10171 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 10172 verifyFormat("x = ( int32 )y;", Spaces); 10173 verifyFormat("int a = ( int )(2.0f);", Spaces); 10174 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 10175 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 10176 verifyFormat("#define x (( int )-1)", Spaces); 10177 10178 // Run the first set of tests again with: 10179 Spaces.SpacesInParentheses = false; 10180 Spaces.SpaceInEmptyParentheses = true; 10181 Spaces.SpacesInCStyleCastParentheses = true; 10182 verifyFormat("call(x, y, z);", Spaces); 10183 verifyFormat("call( );", Spaces); 10184 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10185 verifyFormat("while (( bool )1)\n" 10186 " continue;", 10187 Spaces); 10188 verifyFormat("for (;;)\n" 10189 " continue;", 10190 Spaces); 10191 verifyFormat("if (true)\n" 10192 " f( );\n" 10193 "else if (true)\n" 10194 " f( );", 10195 Spaces); 10196 verifyFormat("do {\n" 10197 " do_something(( int )i);\n" 10198 "} while (something( ));", 10199 Spaces); 10200 verifyFormat("switch (x) {\n" 10201 "default:\n" 10202 " break;\n" 10203 "}", 10204 Spaces); 10205 10206 // Run the first set of tests again with: 10207 Spaces.SpaceAfterCStyleCast = true; 10208 verifyFormat("call(x, y, z);", Spaces); 10209 verifyFormat("call( );", Spaces); 10210 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10211 verifyFormat("while (( bool ) 1)\n" 10212 " continue;", 10213 Spaces); 10214 verifyFormat("for (;;)\n" 10215 " continue;", 10216 Spaces); 10217 verifyFormat("if (true)\n" 10218 " f( );\n" 10219 "else if (true)\n" 10220 " f( );", 10221 Spaces); 10222 verifyFormat("do {\n" 10223 " do_something(( int ) i);\n" 10224 "} while (something( ));", 10225 Spaces); 10226 verifyFormat("switch (x) {\n" 10227 "default:\n" 10228 " break;\n" 10229 "}", 10230 Spaces); 10231 10232 // Run subset of tests again with: 10233 Spaces.SpacesInCStyleCastParentheses = false; 10234 Spaces.SpaceAfterCStyleCast = true; 10235 verifyFormat("while ((bool) 1)\n" 10236 " continue;", 10237 Spaces); 10238 verifyFormat("do {\n" 10239 " do_something((int) i);\n" 10240 "} while (something( ));", 10241 Spaces); 10242 } 10243 10244 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 10245 verifyFormat("int a[5];"); 10246 verifyFormat("a[3] += 42;"); 10247 10248 FormatStyle Spaces = getLLVMStyle(); 10249 Spaces.SpacesInSquareBrackets = true; 10250 // Lambdas unchanged. 10251 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 10252 verifyFormat("return [i, args...] {};", Spaces); 10253 10254 // Not lambdas. 10255 verifyFormat("int a[ 5 ];", Spaces); 10256 verifyFormat("a[ 3 ] += 42;", Spaces); 10257 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 10258 verifyFormat("double &operator[](int i) { return 0; }\n" 10259 "int i;", 10260 Spaces); 10261 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 10262 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 10263 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 10264 } 10265 10266 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 10267 verifyFormat("int a = 5;"); 10268 verifyFormat("a += 42;"); 10269 verifyFormat("a or_eq 8;"); 10270 10271 FormatStyle Spaces = getLLVMStyle(); 10272 Spaces.SpaceBeforeAssignmentOperators = false; 10273 verifyFormat("int a= 5;", Spaces); 10274 verifyFormat("a+= 42;", Spaces); 10275 verifyFormat("a or_eq 8;", Spaces); 10276 } 10277 10278 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 10279 verifyFormat("class Foo : public Bar {};"); 10280 verifyFormat("Foo::Foo() : foo(1) {}"); 10281 verifyFormat("for (auto a : b) {\n}"); 10282 verifyFormat("int x = a ? b : c;"); 10283 verifyFormat("{\n" 10284 "label0:\n" 10285 " int x = 0;\n" 10286 "}"); 10287 verifyFormat("switch (x) {\n" 10288 "case 1:\n" 10289 "default:\n" 10290 "}"); 10291 10292 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 10293 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 10294 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 10295 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 10296 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 10297 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 10298 verifyFormat("{\n" 10299 "label1:\n" 10300 " int x = 0;\n" 10301 "}", 10302 CtorInitializerStyle); 10303 verifyFormat("switch (x) {\n" 10304 "case 1:\n" 10305 "default:\n" 10306 "}", 10307 CtorInitializerStyle); 10308 CtorInitializerStyle.BreakConstructorInitializers = 10309 FormatStyle::BCIS_AfterColon; 10310 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 10311 " aaaaaaaaaaaaaaaa(1),\n" 10312 " bbbbbbbbbbbbbbbb(2) {}", 10313 CtorInitializerStyle); 10314 CtorInitializerStyle.BreakConstructorInitializers = 10315 FormatStyle::BCIS_BeforeComma; 10316 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10317 " : aaaaaaaaaaaaaaaa(1)\n" 10318 " , bbbbbbbbbbbbbbbb(2) {}", 10319 CtorInitializerStyle); 10320 CtorInitializerStyle.BreakConstructorInitializers = 10321 FormatStyle::BCIS_BeforeColon; 10322 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10323 " : aaaaaaaaaaaaaaaa(1),\n" 10324 " bbbbbbbbbbbbbbbb(2) {}", 10325 CtorInitializerStyle); 10326 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 10327 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10328 ": aaaaaaaaaaaaaaaa(1),\n" 10329 " bbbbbbbbbbbbbbbb(2) {}", 10330 CtorInitializerStyle); 10331 10332 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 10333 InheritanceStyle.SpaceBeforeInheritanceColon = false; 10334 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 10335 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 10336 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 10337 verifyFormat("int x = a ? b : c;", InheritanceStyle); 10338 verifyFormat("{\n" 10339 "label2:\n" 10340 " int x = 0;\n" 10341 "}", 10342 InheritanceStyle); 10343 verifyFormat("switch (x) {\n" 10344 "case 1:\n" 10345 "default:\n" 10346 "}", 10347 InheritanceStyle); 10348 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 10349 verifyFormat("class Foooooooooooooooooooooo:\n" 10350 " public aaaaaaaaaaaaaaaaaa,\n" 10351 " public bbbbbbbbbbbbbbbbbb {\n" 10352 "}", 10353 InheritanceStyle); 10354 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 10355 verifyFormat("class Foooooooooooooooooooooo\n" 10356 " : public aaaaaaaaaaaaaaaaaa\n" 10357 " , public bbbbbbbbbbbbbbbbbb {\n" 10358 "}", 10359 InheritanceStyle); 10360 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 10361 verifyFormat("class Foooooooooooooooooooooo\n" 10362 " : public aaaaaaaaaaaaaaaaaa,\n" 10363 " public bbbbbbbbbbbbbbbbbb {\n" 10364 "}", 10365 InheritanceStyle); 10366 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 10367 verifyFormat("class Foooooooooooooooooooooo\n" 10368 ": public aaaaaaaaaaaaaaaaaa,\n" 10369 " public bbbbbbbbbbbbbbbbbb {}", 10370 InheritanceStyle); 10371 10372 FormatStyle ForLoopStyle = getLLVMStyle(); 10373 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 10374 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 10375 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 10376 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 10377 verifyFormat("int x = a ? b : c;", ForLoopStyle); 10378 verifyFormat("{\n" 10379 "label2:\n" 10380 " int x = 0;\n" 10381 "}", 10382 ForLoopStyle); 10383 verifyFormat("switch (x) {\n" 10384 "case 1:\n" 10385 "default:\n" 10386 "}", 10387 ForLoopStyle); 10388 10389 FormatStyle NoSpaceStyle = getLLVMStyle(); 10390 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 10391 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 10392 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 10393 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 10394 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 10395 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 10396 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 10397 verifyFormat("{\n" 10398 "label3:\n" 10399 " int x = 0;\n" 10400 "}", 10401 NoSpaceStyle); 10402 verifyFormat("switch (x) {\n" 10403 "case 1:\n" 10404 "default:\n" 10405 "}", 10406 NoSpaceStyle); 10407 } 10408 10409 TEST_F(FormatTest, AlignConsecutiveMacros) { 10410 FormatStyle Style = getLLVMStyle(); 10411 Style.AlignConsecutiveAssignments = true; 10412 Style.AlignConsecutiveDeclarations = true; 10413 Style.AlignConsecutiveMacros = false; 10414 10415 verifyFormat("#define a 3\n" 10416 "#define bbbb 4\n" 10417 "#define ccc (5)", 10418 Style); 10419 10420 verifyFormat("#define f(x) (x * x)\n" 10421 "#define fff(x, y, z) (x * y + z)\n" 10422 "#define ffff(x, y) (x - y)", 10423 Style); 10424 10425 verifyFormat("#define foo(x, y) (x + y)\n" 10426 "#define bar (5, 6)(2 + 2)", 10427 Style); 10428 10429 verifyFormat("#define a 3\n" 10430 "#define bbbb 4\n" 10431 "#define ccc (5)\n" 10432 "#define f(x) (x * x)\n" 10433 "#define fff(x, y, z) (x * y + z)\n" 10434 "#define ffff(x, y) (x - y)", 10435 Style); 10436 10437 Style.AlignConsecutiveMacros = true; 10438 verifyFormat("#define a 3\n" 10439 "#define bbbb 4\n" 10440 "#define ccc (5)", 10441 Style); 10442 10443 verifyFormat("#define f(x) (x * x)\n" 10444 "#define fff(x, y, z) (x * y + z)\n" 10445 "#define ffff(x, y) (x - y)", 10446 Style); 10447 10448 verifyFormat("#define foo(x, y) (x + y)\n" 10449 "#define bar (5, 6)(2 + 2)", 10450 Style); 10451 10452 verifyFormat("#define a 3\n" 10453 "#define bbbb 4\n" 10454 "#define ccc (5)\n" 10455 "#define f(x) (x * x)\n" 10456 "#define fff(x, y, z) (x * y + z)\n" 10457 "#define ffff(x, y) (x - y)", 10458 Style); 10459 10460 verifyFormat("#define a 5\n" 10461 "#define foo(x, y) (x + y)\n" 10462 "#define CCC (6)\n" 10463 "auto lambda = []() {\n" 10464 " auto ii = 0;\n" 10465 " float j = 0;\n" 10466 " return 0;\n" 10467 "};\n" 10468 "int i = 0;\n" 10469 "float i2 = 0;\n" 10470 "auto v = type{\n" 10471 " i = 1, //\n" 10472 " (i = 2), //\n" 10473 " i = 3 //\n" 10474 "};", 10475 Style); 10476 10477 Style.AlignConsecutiveMacros = false; 10478 Style.ColumnLimit = 20; 10479 10480 verifyFormat("#define a \\\n" 10481 " \"aabbbbbbbbbbbb\"\n" 10482 "#define D \\\n" 10483 " \"aabbbbbbbbbbbb\" \\\n" 10484 " \"ccddeeeeeeeee\"\n" 10485 "#define B \\\n" 10486 " \"QQQQQQQQQQQQQ\" \\\n" 10487 " \"FFFFFFFFFFFFF\" \\\n" 10488 " \"LLLLLLLL\"\n", 10489 Style); 10490 10491 Style.AlignConsecutiveMacros = true; 10492 verifyFormat("#define a \\\n" 10493 " \"aabbbbbbbbbbbb\"\n" 10494 "#define D \\\n" 10495 " \"aabbbbbbbbbbbb\" \\\n" 10496 " \"ccddeeeeeeeee\"\n" 10497 "#define B \\\n" 10498 " \"QQQQQQQQQQQQQ\" \\\n" 10499 " \"FFFFFFFFFFFFF\" \\\n" 10500 " \"LLLLLLLL\"\n", 10501 Style); 10502 } 10503 10504 TEST_F(FormatTest, AlignConsecutiveAssignments) { 10505 FormatStyle Alignment = getLLVMStyle(); 10506 Alignment.AlignConsecutiveMacros = true; 10507 Alignment.AlignConsecutiveAssignments = false; 10508 verifyFormat("int a = 5;\n" 10509 "int oneTwoThree = 123;", 10510 Alignment); 10511 verifyFormat("int a = 5;\n" 10512 "int oneTwoThree = 123;", 10513 Alignment); 10514 10515 Alignment.AlignConsecutiveAssignments = true; 10516 verifyFormat("int a = 5;\n" 10517 "int oneTwoThree = 123;", 10518 Alignment); 10519 verifyFormat("int a = method();\n" 10520 "int oneTwoThree = 133;", 10521 Alignment); 10522 verifyFormat("a &= 5;\n" 10523 "bcd *= 5;\n" 10524 "ghtyf += 5;\n" 10525 "dvfvdb -= 5;\n" 10526 "a /= 5;\n" 10527 "vdsvsv %= 5;\n" 10528 "sfdbddfbdfbb ^= 5;\n" 10529 "dvsdsv |= 5;\n" 10530 "int dsvvdvsdvvv = 123;", 10531 Alignment); 10532 verifyFormat("int i = 1, j = 10;\n" 10533 "something = 2000;", 10534 Alignment); 10535 verifyFormat("something = 2000;\n" 10536 "int i = 1, j = 10;\n", 10537 Alignment); 10538 verifyFormat("something = 2000;\n" 10539 "another = 911;\n" 10540 "int i = 1, j = 10;\n" 10541 "oneMore = 1;\n" 10542 "i = 2;", 10543 Alignment); 10544 verifyFormat("int a = 5;\n" 10545 "int one = 1;\n" 10546 "method();\n" 10547 "int oneTwoThree = 123;\n" 10548 "int oneTwo = 12;", 10549 Alignment); 10550 verifyFormat("int oneTwoThree = 123;\n" 10551 "int oneTwo = 12;\n" 10552 "method();\n", 10553 Alignment); 10554 verifyFormat("int oneTwoThree = 123; // comment\n" 10555 "int oneTwo = 12; // comment", 10556 Alignment); 10557 EXPECT_EQ("int a = 5;\n" 10558 "\n" 10559 "int oneTwoThree = 123;", 10560 format("int a = 5;\n" 10561 "\n" 10562 "int oneTwoThree= 123;", 10563 Alignment)); 10564 EXPECT_EQ("int a = 5;\n" 10565 "int one = 1;\n" 10566 "\n" 10567 "int oneTwoThree = 123;", 10568 format("int a = 5;\n" 10569 "int one = 1;\n" 10570 "\n" 10571 "int oneTwoThree = 123;", 10572 Alignment)); 10573 EXPECT_EQ("int a = 5;\n" 10574 "int one = 1;\n" 10575 "\n" 10576 "int oneTwoThree = 123;\n" 10577 "int oneTwo = 12;", 10578 format("int a = 5;\n" 10579 "int one = 1;\n" 10580 "\n" 10581 "int oneTwoThree = 123;\n" 10582 "int oneTwo = 12;", 10583 Alignment)); 10584 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10585 verifyFormat("#define A \\\n" 10586 " int aaaa = 12; \\\n" 10587 " int b = 23; \\\n" 10588 " int ccc = 234; \\\n" 10589 " int dddddddddd = 2345;", 10590 Alignment); 10591 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10592 verifyFormat("#define A \\\n" 10593 " int aaaa = 12; \\\n" 10594 " int b = 23; \\\n" 10595 " int ccc = 234; \\\n" 10596 " int dddddddddd = 2345;", 10597 Alignment); 10598 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10599 verifyFormat("#define A " 10600 " \\\n" 10601 " int aaaa = 12; " 10602 " \\\n" 10603 " int b = 23; " 10604 " \\\n" 10605 " int ccc = 234; " 10606 " \\\n" 10607 " int dddddddddd = 2345;", 10608 Alignment); 10609 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10610 "k = 4, int l = 5,\n" 10611 " int m = 6) {\n" 10612 " int j = 10;\n" 10613 " otherThing = 1;\n" 10614 "}", 10615 Alignment); 10616 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10617 " int i = 1;\n" 10618 " int j = 2;\n" 10619 " int big = 10000;\n" 10620 "}", 10621 Alignment); 10622 verifyFormat("class C {\n" 10623 "public:\n" 10624 " int i = 1;\n" 10625 " virtual void f() = 0;\n" 10626 "};", 10627 Alignment); 10628 verifyFormat("int i = 1;\n" 10629 "if (SomeType t = getSomething()) {\n" 10630 "}\n" 10631 "int j = 2;\n" 10632 "int big = 10000;", 10633 Alignment); 10634 verifyFormat("int j = 7;\n" 10635 "for (int k = 0; k < N; ++k) {\n" 10636 "}\n" 10637 "int j = 2;\n" 10638 "int big = 10000;\n" 10639 "}", 10640 Alignment); 10641 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10642 verifyFormat("int i = 1;\n" 10643 "LooooooooooongType loooooooooooooooooooooongVariable\n" 10644 " = someLooooooooooooooooongFunction();\n" 10645 "int j = 2;", 10646 Alignment); 10647 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 10648 verifyFormat("int i = 1;\n" 10649 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 10650 " someLooooooooooooooooongFunction();\n" 10651 "int j = 2;", 10652 Alignment); 10653 10654 verifyFormat("auto lambda = []() {\n" 10655 " auto i = 0;\n" 10656 " return 0;\n" 10657 "};\n" 10658 "int i = 0;\n" 10659 "auto v = type{\n" 10660 " i = 1, //\n" 10661 " (i = 2), //\n" 10662 " i = 3 //\n" 10663 "};", 10664 Alignment); 10665 10666 verifyFormat( 10667 "int i = 1;\n" 10668 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 10669 " loooooooooooooooooooooongParameterB);\n" 10670 "int j = 2;", 10671 Alignment); 10672 10673 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 10674 " typename B = very_long_type_name_1,\n" 10675 " typename T_2 = very_long_type_name_2>\n" 10676 "auto foo() {}\n", 10677 Alignment); 10678 verifyFormat("int a, b = 1;\n" 10679 "int c = 2;\n" 10680 "int dd = 3;\n", 10681 Alignment); 10682 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10683 "float b[1][] = {{3.f}};\n", 10684 Alignment); 10685 verifyFormat("for (int i = 0; i < 1; i++)\n" 10686 " int x = 1;\n", 10687 Alignment); 10688 verifyFormat("for (i = 0; i < 1; i++)\n" 10689 " x = 1;\n" 10690 "y = 1;\n", 10691 Alignment); 10692 } 10693 10694 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 10695 FormatStyle Alignment = getLLVMStyle(); 10696 Alignment.AlignConsecutiveMacros = true; 10697 Alignment.AlignConsecutiveDeclarations = false; 10698 verifyFormat("float const a = 5;\n" 10699 "int oneTwoThree = 123;", 10700 Alignment); 10701 verifyFormat("int a = 5;\n" 10702 "float const oneTwoThree = 123;", 10703 Alignment); 10704 10705 Alignment.AlignConsecutiveDeclarations = true; 10706 verifyFormat("float const a = 5;\n" 10707 "int oneTwoThree = 123;", 10708 Alignment); 10709 verifyFormat("int a = method();\n" 10710 "float const oneTwoThree = 133;", 10711 Alignment); 10712 verifyFormat("int i = 1, j = 10;\n" 10713 "something = 2000;", 10714 Alignment); 10715 verifyFormat("something = 2000;\n" 10716 "int i = 1, j = 10;\n", 10717 Alignment); 10718 verifyFormat("float something = 2000;\n" 10719 "double another = 911;\n" 10720 "int i = 1, j = 10;\n" 10721 "const int *oneMore = 1;\n" 10722 "unsigned i = 2;", 10723 Alignment); 10724 verifyFormat("float a = 5;\n" 10725 "int one = 1;\n" 10726 "method();\n" 10727 "const double oneTwoThree = 123;\n" 10728 "const unsigned int oneTwo = 12;", 10729 Alignment); 10730 verifyFormat("int oneTwoThree{0}; // comment\n" 10731 "unsigned oneTwo; // comment", 10732 Alignment); 10733 EXPECT_EQ("float const a = 5;\n" 10734 "\n" 10735 "int oneTwoThree = 123;", 10736 format("float const a = 5;\n" 10737 "\n" 10738 "int oneTwoThree= 123;", 10739 Alignment)); 10740 EXPECT_EQ("float a = 5;\n" 10741 "int one = 1;\n" 10742 "\n" 10743 "unsigned oneTwoThree = 123;", 10744 format("float a = 5;\n" 10745 "int one = 1;\n" 10746 "\n" 10747 "unsigned oneTwoThree = 123;", 10748 Alignment)); 10749 EXPECT_EQ("float a = 5;\n" 10750 "int one = 1;\n" 10751 "\n" 10752 "unsigned oneTwoThree = 123;\n" 10753 "int oneTwo = 12;", 10754 format("float a = 5;\n" 10755 "int one = 1;\n" 10756 "\n" 10757 "unsigned oneTwoThree = 123;\n" 10758 "int oneTwo = 12;", 10759 Alignment)); 10760 // Function prototype alignment 10761 verifyFormat("int a();\n" 10762 "double b();", 10763 Alignment); 10764 verifyFormat("int a(int x);\n" 10765 "double b();", 10766 Alignment); 10767 unsigned OldColumnLimit = Alignment.ColumnLimit; 10768 // We need to set ColumnLimit to zero, in order to stress nested alignments, 10769 // otherwise the function parameters will be re-flowed onto a single line. 10770 Alignment.ColumnLimit = 0; 10771 EXPECT_EQ("int a(int x,\n" 10772 " float y);\n" 10773 "double b(int x,\n" 10774 " double y);", 10775 format("int a(int x,\n" 10776 " float y);\n" 10777 "double b(int x,\n" 10778 " double y);", 10779 Alignment)); 10780 // This ensures that function parameters of function declarations are 10781 // correctly indented when their owning functions are indented. 10782 // The failure case here is for 'double y' to not be indented enough. 10783 EXPECT_EQ("double a(int x);\n" 10784 "int b(int y,\n" 10785 " double z);", 10786 format("double a(int x);\n" 10787 "int b(int y,\n" 10788 " double z);", 10789 Alignment)); 10790 // Set ColumnLimit low so that we induce wrapping immediately after 10791 // the function name and opening paren. 10792 Alignment.ColumnLimit = 13; 10793 verifyFormat("int function(\n" 10794 " int x,\n" 10795 " bool y);", 10796 Alignment); 10797 Alignment.ColumnLimit = OldColumnLimit; 10798 // Ensure function pointers don't screw up recursive alignment 10799 verifyFormat("int a(int x, void (*fp)(int y));\n" 10800 "double b();", 10801 Alignment); 10802 Alignment.AlignConsecutiveAssignments = true; 10803 // Ensure recursive alignment is broken by function braces, so that the 10804 // "a = 1" does not align with subsequent assignments inside the function 10805 // body. 10806 verifyFormat("int func(int a = 1) {\n" 10807 " int b = 2;\n" 10808 " int cc = 3;\n" 10809 "}", 10810 Alignment); 10811 verifyFormat("float something = 2000;\n" 10812 "double another = 911;\n" 10813 "int i = 1, j = 10;\n" 10814 "const int *oneMore = 1;\n" 10815 "unsigned i = 2;", 10816 Alignment); 10817 verifyFormat("int oneTwoThree = {0}; // comment\n" 10818 "unsigned oneTwo = 0; // comment", 10819 Alignment); 10820 // Make sure that scope is correctly tracked, in the absence of braces 10821 verifyFormat("for (int i = 0; i < n; i++)\n" 10822 " j = i;\n" 10823 "double x = 1;\n", 10824 Alignment); 10825 verifyFormat("if (int i = 0)\n" 10826 " j = i;\n" 10827 "double x = 1;\n", 10828 Alignment); 10829 // Ensure operator[] and operator() are comprehended 10830 verifyFormat("struct test {\n" 10831 " long long int foo();\n" 10832 " int operator[](int a);\n" 10833 " double bar();\n" 10834 "};\n", 10835 Alignment); 10836 verifyFormat("struct test {\n" 10837 " long long int foo();\n" 10838 " int operator()(int a);\n" 10839 " double bar();\n" 10840 "};\n", 10841 Alignment); 10842 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 10843 " int const i = 1;\n" 10844 " int * j = 2;\n" 10845 " int big = 10000;\n" 10846 "\n" 10847 " unsigned oneTwoThree = 123;\n" 10848 " int oneTwo = 12;\n" 10849 " method();\n" 10850 " float k = 2;\n" 10851 " int ll = 10000;\n" 10852 "}", 10853 format("void SomeFunction(int parameter= 0) {\n" 10854 " int const i= 1;\n" 10855 " int *j=2;\n" 10856 " int big = 10000;\n" 10857 "\n" 10858 "unsigned oneTwoThree =123;\n" 10859 "int oneTwo = 12;\n" 10860 " method();\n" 10861 "float k= 2;\n" 10862 "int ll=10000;\n" 10863 "}", 10864 Alignment)); 10865 Alignment.AlignConsecutiveAssignments = false; 10866 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10867 verifyFormat("#define A \\\n" 10868 " int aaaa = 12; \\\n" 10869 " float b = 23; \\\n" 10870 " const int ccc = 234; \\\n" 10871 " unsigned dddddddddd = 2345;", 10872 Alignment); 10873 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10874 verifyFormat("#define A \\\n" 10875 " int aaaa = 12; \\\n" 10876 " float b = 23; \\\n" 10877 " const int ccc = 234; \\\n" 10878 " unsigned dddddddddd = 2345;", 10879 Alignment); 10880 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10881 Alignment.ColumnLimit = 30; 10882 verifyFormat("#define A \\\n" 10883 " int aaaa = 12; \\\n" 10884 " float b = 23; \\\n" 10885 " const int ccc = 234; \\\n" 10886 " int dddddddddd = 2345;", 10887 Alignment); 10888 Alignment.ColumnLimit = 80; 10889 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10890 "k = 4, int l = 5,\n" 10891 " int m = 6) {\n" 10892 " const int j = 10;\n" 10893 " otherThing = 1;\n" 10894 "}", 10895 Alignment); 10896 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10897 " int const i = 1;\n" 10898 " int * j = 2;\n" 10899 " int big = 10000;\n" 10900 "}", 10901 Alignment); 10902 verifyFormat("class C {\n" 10903 "public:\n" 10904 " int i = 1;\n" 10905 " virtual void f() = 0;\n" 10906 "};", 10907 Alignment); 10908 verifyFormat("float i = 1;\n" 10909 "if (SomeType t = getSomething()) {\n" 10910 "}\n" 10911 "const unsigned j = 2;\n" 10912 "int big = 10000;", 10913 Alignment); 10914 verifyFormat("float j = 7;\n" 10915 "for (int k = 0; k < N; ++k) {\n" 10916 "}\n" 10917 "unsigned j = 2;\n" 10918 "int big = 10000;\n" 10919 "}", 10920 Alignment); 10921 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10922 verifyFormat("float i = 1;\n" 10923 "LooooooooooongType loooooooooooooooooooooongVariable\n" 10924 " = someLooooooooooooooooongFunction();\n" 10925 "int j = 2;", 10926 Alignment); 10927 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 10928 verifyFormat("int i = 1;\n" 10929 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 10930 " someLooooooooooooooooongFunction();\n" 10931 "int j = 2;", 10932 Alignment); 10933 10934 Alignment.AlignConsecutiveAssignments = true; 10935 verifyFormat("auto lambda = []() {\n" 10936 " auto ii = 0;\n" 10937 " float j = 0;\n" 10938 " return 0;\n" 10939 "};\n" 10940 "int i = 0;\n" 10941 "float i2 = 0;\n" 10942 "auto v = type{\n" 10943 " i = 1, //\n" 10944 " (i = 2), //\n" 10945 " i = 3 //\n" 10946 "};", 10947 Alignment); 10948 Alignment.AlignConsecutiveAssignments = false; 10949 10950 verifyFormat( 10951 "int i = 1;\n" 10952 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 10953 " loooooooooooooooooooooongParameterB);\n" 10954 "int j = 2;", 10955 Alignment); 10956 10957 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 10958 // We expect declarations and assignments to align, as long as it doesn't 10959 // exceed the column limit, starting a new alignment sequence whenever it 10960 // happens. 10961 Alignment.AlignConsecutiveAssignments = true; 10962 Alignment.ColumnLimit = 30; 10963 verifyFormat("float ii = 1;\n" 10964 "unsigned j = 2;\n" 10965 "int someVerylongVariable = 1;\n" 10966 "AnotherLongType ll = 123456;\n" 10967 "VeryVeryLongType k = 2;\n" 10968 "int myvar = 1;", 10969 Alignment); 10970 Alignment.ColumnLimit = 80; 10971 Alignment.AlignConsecutiveAssignments = false; 10972 10973 verifyFormat( 10974 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 10975 " typename LongType, typename B>\n" 10976 "auto foo() {}\n", 10977 Alignment); 10978 verifyFormat("float a, b = 1;\n" 10979 "int c = 2;\n" 10980 "int dd = 3;\n", 10981 Alignment); 10982 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10983 "float b[1][] = {{3.f}};\n", 10984 Alignment); 10985 Alignment.AlignConsecutiveAssignments = true; 10986 verifyFormat("float a, b = 1;\n" 10987 "int c = 2;\n" 10988 "int dd = 3;\n", 10989 Alignment); 10990 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10991 "float b[1][] = {{3.f}};\n", 10992 Alignment); 10993 Alignment.AlignConsecutiveAssignments = false; 10994 10995 Alignment.ColumnLimit = 30; 10996 Alignment.BinPackParameters = false; 10997 verifyFormat("void foo(float a,\n" 10998 " float b,\n" 10999 " int c,\n" 11000 " uint32_t *d) {\n" 11001 " int * e = 0;\n" 11002 " float f = 0;\n" 11003 " double g = 0;\n" 11004 "}\n" 11005 "void bar(ino_t a,\n" 11006 " int b,\n" 11007 " uint32_t *c,\n" 11008 " bool d) {}\n", 11009 Alignment); 11010 Alignment.BinPackParameters = true; 11011 Alignment.ColumnLimit = 80; 11012 11013 // Bug 33507 11014 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 11015 verifyFormat( 11016 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 11017 " static const Version verVs2017;\n" 11018 " return true;\n" 11019 "});\n", 11020 Alignment); 11021 Alignment.PointerAlignment = FormatStyle::PAS_Right; 11022 11023 // See llvm.org/PR35641 11024 Alignment.AlignConsecutiveDeclarations = true; 11025 verifyFormat("int func() { //\n" 11026 " int b;\n" 11027 " unsigned c;\n" 11028 "}", 11029 Alignment); 11030 11031 // See PR37175 11032 FormatStyle Style = getMozillaStyle(); 11033 Style.AlignConsecutiveDeclarations = true; 11034 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 11035 "foo(int a);", 11036 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 11037 } 11038 11039 TEST_F(FormatTest, LinuxBraceBreaking) { 11040 FormatStyle LinuxBraceStyle = getLLVMStyle(); 11041 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 11042 verifyFormat("namespace a\n" 11043 "{\n" 11044 "class A\n" 11045 "{\n" 11046 " void f()\n" 11047 " {\n" 11048 " if (true) {\n" 11049 " a();\n" 11050 " b();\n" 11051 " } else {\n" 11052 " a();\n" 11053 " }\n" 11054 " }\n" 11055 " void g() { return; }\n" 11056 "};\n" 11057 "struct B {\n" 11058 " int x;\n" 11059 "};\n" 11060 "} // namespace a\n", 11061 LinuxBraceStyle); 11062 verifyFormat("enum X {\n" 11063 " Y = 0,\n" 11064 "}\n", 11065 LinuxBraceStyle); 11066 verifyFormat("struct S {\n" 11067 " int Type;\n" 11068 " union {\n" 11069 " int x;\n" 11070 " double y;\n" 11071 " } Value;\n" 11072 " class C\n" 11073 " {\n" 11074 " MyFavoriteType Value;\n" 11075 " } Class;\n" 11076 "}\n", 11077 LinuxBraceStyle); 11078 } 11079 11080 TEST_F(FormatTest, MozillaBraceBreaking) { 11081 FormatStyle MozillaBraceStyle = getLLVMStyle(); 11082 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 11083 MozillaBraceStyle.FixNamespaceComments = false; 11084 verifyFormat("namespace a {\n" 11085 "class A\n" 11086 "{\n" 11087 " void f()\n" 11088 " {\n" 11089 " if (true) {\n" 11090 " a();\n" 11091 " b();\n" 11092 " }\n" 11093 " }\n" 11094 " void g() { return; }\n" 11095 "};\n" 11096 "enum E\n" 11097 "{\n" 11098 " A,\n" 11099 " // foo\n" 11100 " B,\n" 11101 " C\n" 11102 "};\n" 11103 "struct B\n" 11104 "{\n" 11105 " int x;\n" 11106 "};\n" 11107 "}\n", 11108 MozillaBraceStyle); 11109 verifyFormat("struct S\n" 11110 "{\n" 11111 " int Type;\n" 11112 " union\n" 11113 " {\n" 11114 " int x;\n" 11115 " double y;\n" 11116 " } Value;\n" 11117 " class C\n" 11118 " {\n" 11119 " MyFavoriteType Value;\n" 11120 " } Class;\n" 11121 "}\n", 11122 MozillaBraceStyle); 11123 } 11124 11125 TEST_F(FormatTest, StroustrupBraceBreaking) { 11126 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 11127 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11128 verifyFormat("namespace a {\n" 11129 "class A {\n" 11130 " void f()\n" 11131 " {\n" 11132 " if (true) {\n" 11133 " a();\n" 11134 " b();\n" 11135 " }\n" 11136 " }\n" 11137 " void g() { return; }\n" 11138 "};\n" 11139 "struct B {\n" 11140 " int x;\n" 11141 "};\n" 11142 "} // namespace a\n", 11143 StroustrupBraceStyle); 11144 11145 verifyFormat("void foo()\n" 11146 "{\n" 11147 " if (a) {\n" 11148 " a();\n" 11149 " }\n" 11150 " else {\n" 11151 " b();\n" 11152 " }\n" 11153 "}\n", 11154 StroustrupBraceStyle); 11155 11156 verifyFormat("#ifdef _DEBUG\n" 11157 "int foo(int i = 0)\n" 11158 "#else\n" 11159 "int foo(int i = 5)\n" 11160 "#endif\n" 11161 "{\n" 11162 " return i;\n" 11163 "}", 11164 StroustrupBraceStyle); 11165 11166 verifyFormat("void foo() {}\n" 11167 "void bar()\n" 11168 "#ifdef _DEBUG\n" 11169 "{\n" 11170 " foo();\n" 11171 "}\n" 11172 "#else\n" 11173 "{\n" 11174 "}\n" 11175 "#endif", 11176 StroustrupBraceStyle); 11177 11178 verifyFormat("void foobar() { int i = 5; }\n" 11179 "#ifdef _DEBUG\n" 11180 "void bar() {}\n" 11181 "#else\n" 11182 "void bar() { foobar(); }\n" 11183 "#endif", 11184 StroustrupBraceStyle); 11185 } 11186 11187 TEST_F(FormatTest, AllmanBraceBreaking) { 11188 FormatStyle AllmanBraceStyle = getLLVMStyle(); 11189 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 11190 11191 EXPECT_EQ("namespace a\n" 11192 "{\n" 11193 "void f();\n" 11194 "void g();\n" 11195 "} // namespace a\n", 11196 format("namespace a\n" 11197 "{\n" 11198 "void f();\n" 11199 "void g();\n" 11200 "}\n", 11201 AllmanBraceStyle)); 11202 11203 verifyFormat("namespace a\n" 11204 "{\n" 11205 "class A\n" 11206 "{\n" 11207 " void f()\n" 11208 " {\n" 11209 " if (true)\n" 11210 " {\n" 11211 " a();\n" 11212 " b();\n" 11213 " }\n" 11214 " }\n" 11215 " void g() { return; }\n" 11216 "};\n" 11217 "struct B\n" 11218 "{\n" 11219 " int x;\n" 11220 "};\n" 11221 "union C\n" 11222 "{\n" 11223 "};\n" 11224 "} // namespace a", 11225 AllmanBraceStyle); 11226 11227 verifyFormat("void f()\n" 11228 "{\n" 11229 " if (true)\n" 11230 " {\n" 11231 " a();\n" 11232 " }\n" 11233 " else if (false)\n" 11234 " {\n" 11235 " b();\n" 11236 " }\n" 11237 " else\n" 11238 " {\n" 11239 " c();\n" 11240 " }\n" 11241 "}\n", 11242 AllmanBraceStyle); 11243 11244 verifyFormat("void f()\n" 11245 "{\n" 11246 " for (int i = 0; i < 10; ++i)\n" 11247 " {\n" 11248 " a();\n" 11249 " }\n" 11250 " while (false)\n" 11251 " {\n" 11252 " b();\n" 11253 " }\n" 11254 " do\n" 11255 " {\n" 11256 " c();\n" 11257 " } while (false)\n" 11258 "}\n", 11259 AllmanBraceStyle); 11260 11261 verifyFormat("void f(int a)\n" 11262 "{\n" 11263 " switch (a)\n" 11264 " {\n" 11265 " case 0:\n" 11266 " break;\n" 11267 " case 1:\n" 11268 " {\n" 11269 " break;\n" 11270 " }\n" 11271 " case 2:\n" 11272 " {\n" 11273 " }\n" 11274 " break;\n" 11275 " default:\n" 11276 " break;\n" 11277 " }\n" 11278 "}\n", 11279 AllmanBraceStyle); 11280 11281 verifyFormat("enum X\n" 11282 "{\n" 11283 " Y = 0,\n" 11284 "}\n", 11285 AllmanBraceStyle); 11286 verifyFormat("enum X\n" 11287 "{\n" 11288 " Y = 0\n" 11289 "}\n", 11290 AllmanBraceStyle); 11291 11292 verifyFormat("@interface BSApplicationController ()\n" 11293 "{\n" 11294 "@private\n" 11295 " id _extraIvar;\n" 11296 "}\n" 11297 "@end\n", 11298 AllmanBraceStyle); 11299 11300 verifyFormat("#ifdef _DEBUG\n" 11301 "int foo(int i = 0)\n" 11302 "#else\n" 11303 "int foo(int i = 5)\n" 11304 "#endif\n" 11305 "{\n" 11306 " return i;\n" 11307 "}", 11308 AllmanBraceStyle); 11309 11310 verifyFormat("void foo() {}\n" 11311 "void bar()\n" 11312 "#ifdef _DEBUG\n" 11313 "{\n" 11314 " foo();\n" 11315 "}\n" 11316 "#else\n" 11317 "{\n" 11318 "}\n" 11319 "#endif", 11320 AllmanBraceStyle); 11321 11322 verifyFormat("void foobar() { int i = 5; }\n" 11323 "#ifdef _DEBUG\n" 11324 "void bar() {}\n" 11325 "#else\n" 11326 "void bar() { foobar(); }\n" 11327 "#endif", 11328 AllmanBraceStyle); 11329 11330 // This shouldn't affect ObjC blocks.. 11331 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 11332 " // ...\n" 11333 " int i;\n" 11334 "}];", 11335 AllmanBraceStyle); 11336 verifyFormat("void (^block)(void) = ^{\n" 11337 " // ...\n" 11338 " int i;\n" 11339 "};", 11340 AllmanBraceStyle); 11341 // .. or dict literals. 11342 verifyFormat("void f()\n" 11343 "{\n" 11344 " // ...\n" 11345 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 11346 "}", 11347 AllmanBraceStyle); 11348 verifyFormat("void f()\n" 11349 "{\n" 11350 " // ...\n" 11351 " [object someMethod:@{a : @\"b\"}];\n" 11352 "}", 11353 AllmanBraceStyle); 11354 verifyFormat("int f()\n" 11355 "{ // comment\n" 11356 " return 42;\n" 11357 "}", 11358 AllmanBraceStyle); 11359 11360 AllmanBraceStyle.ColumnLimit = 19; 11361 verifyFormat("void f() { int i; }", AllmanBraceStyle); 11362 AllmanBraceStyle.ColumnLimit = 18; 11363 verifyFormat("void f()\n" 11364 "{\n" 11365 " int i;\n" 11366 "}", 11367 AllmanBraceStyle); 11368 AllmanBraceStyle.ColumnLimit = 80; 11369 11370 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 11371 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 11372 FormatStyle::SIS_WithoutElse; 11373 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 11374 verifyFormat("void f(bool b)\n" 11375 "{\n" 11376 " if (b)\n" 11377 " {\n" 11378 " return;\n" 11379 " }\n" 11380 "}\n", 11381 BreakBeforeBraceShortIfs); 11382 verifyFormat("void f(bool b)\n" 11383 "{\n" 11384 " if constexpr (b)\n" 11385 " {\n" 11386 " return;\n" 11387 " }\n" 11388 "}\n", 11389 BreakBeforeBraceShortIfs); 11390 verifyFormat("void f(bool b)\n" 11391 "{\n" 11392 " if CONSTEXPR (b)\n" 11393 " {\n" 11394 " return;\n" 11395 " }\n" 11396 "}\n", 11397 BreakBeforeBraceShortIfs); 11398 verifyFormat("void f(bool b)\n" 11399 "{\n" 11400 " if (b) return;\n" 11401 "}\n", 11402 BreakBeforeBraceShortIfs); 11403 verifyFormat("void f(bool b)\n" 11404 "{\n" 11405 " if constexpr (b) return;\n" 11406 "}\n", 11407 BreakBeforeBraceShortIfs); 11408 verifyFormat("void f(bool b)\n" 11409 "{\n" 11410 " if CONSTEXPR (b) return;\n" 11411 "}\n", 11412 BreakBeforeBraceShortIfs); 11413 verifyFormat("void f(bool b)\n" 11414 "{\n" 11415 " while (b)\n" 11416 " {\n" 11417 " return;\n" 11418 " }\n" 11419 "}\n", 11420 BreakBeforeBraceShortIfs); 11421 } 11422 11423 TEST_F(FormatTest, GNUBraceBreaking) { 11424 FormatStyle GNUBraceStyle = getLLVMStyle(); 11425 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 11426 verifyFormat("namespace a\n" 11427 "{\n" 11428 "class A\n" 11429 "{\n" 11430 " void f()\n" 11431 " {\n" 11432 " int a;\n" 11433 " {\n" 11434 " int b;\n" 11435 " }\n" 11436 " if (true)\n" 11437 " {\n" 11438 " a();\n" 11439 " b();\n" 11440 " }\n" 11441 " }\n" 11442 " void g() { return; }\n" 11443 "}\n" 11444 "} // namespace a", 11445 GNUBraceStyle); 11446 11447 verifyFormat("void f()\n" 11448 "{\n" 11449 " if (true)\n" 11450 " {\n" 11451 " a();\n" 11452 " }\n" 11453 " else if (false)\n" 11454 " {\n" 11455 " b();\n" 11456 " }\n" 11457 " else\n" 11458 " {\n" 11459 " c();\n" 11460 " }\n" 11461 "}\n", 11462 GNUBraceStyle); 11463 11464 verifyFormat("void f()\n" 11465 "{\n" 11466 " for (int i = 0; i < 10; ++i)\n" 11467 " {\n" 11468 " a();\n" 11469 " }\n" 11470 " while (false)\n" 11471 " {\n" 11472 " b();\n" 11473 " }\n" 11474 " do\n" 11475 " {\n" 11476 " c();\n" 11477 " }\n" 11478 " while (false);\n" 11479 "}\n", 11480 GNUBraceStyle); 11481 11482 verifyFormat("void f(int a)\n" 11483 "{\n" 11484 " switch (a)\n" 11485 " {\n" 11486 " case 0:\n" 11487 " break;\n" 11488 " case 1:\n" 11489 " {\n" 11490 " break;\n" 11491 " }\n" 11492 " case 2:\n" 11493 " {\n" 11494 " }\n" 11495 " break;\n" 11496 " default:\n" 11497 " break;\n" 11498 " }\n" 11499 "}\n", 11500 GNUBraceStyle); 11501 11502 verifyFormat("enum X\n" 11503 "{\n" 11504 " Y = 0,\n" 11505 "}\n", 11506 GNUBraceStyle); 11507 11508 verifyFormat("@interface BSApplicationController ()\n" 11509 "{\n" 11510 "@private\n" 11511 " id _extraIvar;\n" 11512 "}\n" 11513 "@end\n", 11514 GNUBraceStyle); 11515 11516 verifyFormat("#ifdef _DEBUG\n" 11517 "int foo(int i = 0)\n" 11518 "#else\n" 11519 "int foo(int i = 5)\n" 11520 "#endif\n" 11521 "{\n" 11522 " return i;\n" 11523 "}", 11524 GNUBraceStyle); 11525 11526 verifyFormat("void foo() {}\n" 11527 "void bar()\n" 11528 "#ifdef _DEBUG\n" 11529 "{\n" 11530 " foo();\n" 11531 "}\n" 11532 "#else\n" 11533 "{\n" 11534 "}\n" 11535 "#endif", 11536 GNUBraceStyle); 11537 11538 verifyFormat("void foobar() { int i = 5; }\n" 11539 "#ifdef _DEBUG\n" 11540 "void bar() {}\n" 11541 "#else\n" 11542 "void bar() { foobar(); }\n" 11543 "#endif", 11544 GNUBraceStyle); 11545 } 11546 11547 TEST_F(FormatTest, WebKitBraceBreaking) { 11548 FormatStyle WebKitBraceStyle = getLLVMStyle(); 11549 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 11550 WebKitBraceStyle.FixNamespaceComments = false; 11551 verifyFormat("namespace a {\n" 11552 "class A {\n" 11553 " void f()\n" 11554 " {\n" 11555 " if (true) {\n" 11556 " a();\n" 11557 " b();\n" 11558 " }\n" 11559 " }\n" 11560 " void g() { return; }\n" 11561 "};\n" 11562 "enum E {\n" 11563 " A,\n" 11564 " // foo\n" 11565 " B,\n" 11566 " C\n" 11567 "};\n" 11568 "struct B {\n" 11569 " int x;\n" 11570 "};\n" 11571 "}\n", 11572 WebKitBraceStyle); 11573 verifyFormat("struct S {\n" 11574 " int Type;\n" 11575 " union {\n" 11576 " int x;\n" 11577 " double y;\n" 11578 " } Value;\n" 11579 " class C {\n" 11580 " MyFavoriteType Value;\n" 11581 " } Class;\n" 11582 "};\n", 11583 WebKitBraceStyle); 11584 } 11585 11586 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 11587 verifyFormat("void f() {\n" 11588 " try {\n" 11589 " } catch (const Exception &e) {\n" 11590 " }\n" 11591 "}\n", 11592 getLLVMStyle()); 11593 } 11594 11595 TEST_F(FormatTest, UnderstandsPragmas) { 11596 verifyFormat("#pragma omp reduction(| : var)"); 11597 verifyFormat("#pragma omp reduction(+ : var)"); 11598 11599 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 11600 "(including parentheses).", 11601 format("#pragma mark Any non-hyphenated or hyphenated string " 11602 "(including parentheses).")); 11603 } 11604 11605 TEST_F(FormatTest, UnderstandPragmaOption) { 11606 verifyFormat("#pragma option -C -A"); 11607 11608 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 11609 } 11610 11611 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 11612 FormatStyle Style = getLLVMStyle(); 11613 Style.ColumnLimit = 20; 11614 11615 // See PR41213 11616 EXPECT_EQ("/*\n" 11617 " *\t9012345\n" 11618 " * /8901\n" 11619 " */", 11620 format("/*\n" 11621 " *\t9012345 /8901\n" 11622 " */", 11623 Style)); 11624 EXPECT_EQ("/*\n" 11625 " *345678\n" 11626 " *\t/8901\n" 11627 " */", 11628 format("/*\n" 11629 " *345678\t/8901\n" 11630 " */", 11631 Style)); 11632 11633 verifyFormat("int a; // the\n" 11634 " // comment", Style); 11635 EXPECT_EQ("int a; /* first line\n" 11636 " * second\n" 11637 " * line third\n" 11638 " * line\n" 11639 " */", 11640 format("int a; /* first line\n" 11641 " * second\n" 11642 " * line third\n" 11643 " * line\n" 11644 " */", 11645 Style)); 11646 EXPECT_EQ("int a; // first line\n" 11647 " // second\n" 11648 " // line third\n" 11649 " // line", 11650 format("int a; // first line\n" 11651 " // second line\n" 11652 " // third line", 11653 Style)); 11654 11655 Style.PenaltyExcessCharacter = 90; 11656 verifyFormat("int a; // the comment", Style); 11657 EXPECT_EQ("int a; // the comment\n" 11658 " // aaa", 11659 format("int a; // the comment aaa", Style)); 11660 EXPECT_EQ("int a; /* first line\n" 11661 " * second line\n" 11662 " * third line\n" 11663 " */", 11664 format("int a; /* first line\n" 11665 " * second line\n" 11666 " * third line\n" 11667 " */", 11668 Style)); 11669 EXPECT_EQ("int a; // first line\n" 11670 " // second line\n" 11671 " // third line", 11672 format("int a; // first line\n" 11673 " // second line\n" 11674 " // third line", 11675 Style)); 11676 // FIXME: Investigate why this is not getting the same layout as the test 11677 // above. 11678 EXPECT_EQ("int a; /* first line\n" 11679 " * second line\n" 11680 " * third line\n" 11681 " */", 11682 format("int a; /* first line second line third line" 11683 "\n*/", 11684 Style)); 11685 11686 EXPECT_EQ("// foo bar baz bazfoo\n" 11687 "// foo bar foo bar\n", 11688 format("// foo bar baz bazfoo\n" 11689 "// foo bar foo bar\n", 11690 Style)); 11691 EXPECT_EQ("// foo bar baz bazfoo\n" 11692 "// foo bar foo bar\n", 11693 format("// foo bar baz bazfoo\n" 11694 "// foo bar foo bar\n", 11695 Style)); 11696 11697 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 11698 // next one. 11699 EXPECT_EQ("// foo bar baz bazfoo\n" 11700 "// bar foo bar\n", 11701 format("// foo bar baz bazfoo bar\n" 11702 "// foo bar\n", 11703 Style)); 11704 11705 EXPECT_EQ("// foo bar baz bazfoo\n" 11706 "// foo bar baz bazfoo\n" 11707 "// bar foo bar\n", 11708 format("// foo bar baz bazfoo\n" 11709 "// foo bar baz bazfoo bar\n" 11710 "// foo bar\n", 11711 Style)); 11712 11713 EXPECT_EQ("// foo bar baz bazfoo\n" 11714 "// foo bar baz bazfoo\n" 11715 "// bar foo bar\n", 11716 format("// foo bar baz bazfoo\n" 11717 "// foo bar baz bazfoo bar\n" 11718 "// foo bar\n", 11719 Style)); 11720 11721 // Make sure we do not keep protruding characters if strict mode reflow is 11722 // cheaper than keeping protruding characters. 11723 Style.ColumnLimit = 21; 11724 EXPECT_EQ("// foo foo foo foo\n" 11725 "// foo foo foo foo\n" 11726 "// foo foo foo foo\n", 11727 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", 11728 Style)); 11729 11730 EXPECT_EQ("int a = /* long block\n" 11731 " comment */\n" 11732 " 42;", 11733 format("int a = /* long block comment */ 42;", Style)); 11734 } 11735 11736 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 11737 for (size_t i = 1; i < Styles.size(); ++i) \ 11738 EXPECT_EQ(Styles[0], Styles[i]) << "Style #" << i << " of " << Styles.size() \ 11739 << " differs from Style #0" 11740 11741 TEST_F(FormatTest, GetsPredefinedStyleByName) { 11742 SmallVector<FormatStyle, 3> Styles; 11743 Styles.resize(3); 11744 11745 Styles[0] = getLLVMStyle(); 11746 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 11747 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 11748 EXPECT_ALL_STYLES_EQUAL(Styles); 11749 11750 Styles[0] = getGoogleStyle(); 11751 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 11752 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 11753 EXPECT_ALL_STYLES_EQUAL(Styles); 11754 11755 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 11756 EXPECT_TRUE( 11757 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 11758 EXPECT_TRUE( 11759 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 11760 EXPECT_ALL_STYLES_EQUAL(Styles); 11761 11762 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 11763 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 11764 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 11765 EXPECT_ALL_STYLES_EQUAL(Styles); 11766 11767 Styles[0] = getMozillaStyle(); 11768 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 11769 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 11770 EXPECT_ALL_STYLES_EQUAL(Styles); 11771 11772 Styles[0] = getWebKitStyle(); 11773 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 11774 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 11775 EXPECT_ALL_STYLES_EQUAL(Styles); 11776 11777 Styles[0] = getGNUStyle(); 11778 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 11779 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 11780 EXPECT_ALL_STYLES_EQUAL(Styles); 11781 11782 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 11783 } 11784 11785 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 11786 SmallVector<FormatStyle, 8> Styles; 11787 Styles.resize(2); 11788 11789 Styles[0] = getGoogleStyle(); 11790 Styles[1] = getLLVMStyle(); 11791 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 11792 EXPECT_ALL_STYLES_EQUAL(Styles); 11793 11794 Styles.resize(5); 11795 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 11796 Styles[1] = getLLVMStyle(); 11797 Styles[1].Language = FormatStyle::LK_JavaScript; 11798 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 11799 11800 Styles[2] = getLLVMStyle(); 11801 Styles[2].Language = FormatStyle::LK_JavaScript; 11802 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 11803 "BasedOnStyle: Google", 11804 &Styles[2]) 11805 .value()); 11806 11807 Styles[3] = getLLVMStyle(); 11808 Styles[3].Language = FormatStyle::LK_JavaScript; 11809 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 11810 "Language: JavaScript", 11811 &Styles[3]) 11812 .value()); 11813 11814 Styles[4] = getLLVMStyle(); 11815 Styles[4].Language = FormatStyle::LK_JavaScript; 11816 EXPECT_EQ(0, parseConfiguration("---\n" 11817 "BasedOnStyle: LLVM\n" 11818 "IndentWidth: 123\n" 11819 "---\n" 11820 "BasedOnStyle: Google\n" 11821 "Language: JavaScript", 11822 &Styles[4]) 11823 .value()); 11824 EXPECT_ALL_STYLES_EQUAL(Styles); 11825 } 11826 11827 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 11828 Style.FIELD = false; \ 11829 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 11830 EXPECT_TRUE(Style.FIELD); \ 11831 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 11832 EXPECT_FALSE(Style.FIELD); 11833 11834 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 11835 11836 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 11837 Style.STRUCT.FIELD = false; \ 11838 EXPECT_EQ(0, \ 11839 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 11840 .value()); \ 11841 EXPECT_TRUE(Style.STRUCT.FIELD); \ 11842 EXPECT_EQ(0, \ 11843 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 11844 .value()); \ 11845 EXPECT_FALSE(Style.STRUCT.FIELD); 11846 11847 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 11848 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 11849 11850 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 11851 EXPECT_NE(VALUE, Style.FIELD); \ 11852 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 11853 EXPECT_EQ(VALUE, Style.FIELD) 11854 11855 TEST_F(FormatTest, ParsesConfigurationBools) { 11856 FormatStyle Style = {}; 11857 Style.Language = FormatStyle::LK_Cpp; 11858 CHECK_PARSE_BOOL(AlignOperands); 11859 CHECK_PARSE_BOOL(AlignTrailingComments); 11860 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 11861 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 11862 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 11863 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 11864 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 11865 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 11866 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 11867 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 11868 CHECK_PARSE_BOOL(BinPackArguments); 11869 CHECK_PARSE_BOOL(BinPackParameters); 11870 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 11871 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 11872 CHECK_PARSE_BOOL(BreakStringLiterals); 11873 CHECK_PARSE_BOOL(CompactNamespaces); 11874 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 11875 CHECK_PARSE_BOOL(DerivePointerAlignment); 11876 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 11877 CHECK_PARSE_BOOL(DisableFormat); 11878 CHECK_PARSE_BOOL(IndentCaseLabels); 11879 CHECK_PARSE_BOOL(IndentGotoLabels); 11880 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 11881 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 11882 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 11883 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 11884 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 11885 CHECK_PARSE_BOOL(ReflowComments); 11886 CHECK_PARSE_BOOL(SortIncludes); 11887 CHECK_PARSE_BOOL(SortUsingDeclarations); 11888 CHECK_PARSE_BOOL(SpacesInParentheses); 11889 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 11890 CHECK_PARSE_BOOL(SpacesInAngles); 11891 CHECK_PARSE_BOOL(SpaceInEmptyBlock); 11892 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 11893 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 11894 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 11895 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 11896 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 11897 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 11898 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 11899 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 11900 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 11901 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 11902 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 11903 11904 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 11905 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 11906 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterControlStatement); 11907 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 11908 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 11909 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 11910 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 11911 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 11912 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 11913 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 11914 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 11915 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 11916 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 11917 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 11918 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 11919 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 11920 } 11921 11922 #undef CHECK_PARSE_BOOL 11923 11924 TEST_F(FormatTest, ParsesConfiguration) { 11925 FormatStyle Style = {}; 11926 Style.Language = FormatStyle::LK_Cpp; 11927 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 11928 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 11929 ConstructorInitializerIndentWidth, 1234u); 11930 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 11931 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 11932 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 11933 CHECK_PARSE("PenaltyBreakAssignment: 1234", 11934 PenaltyBreakAssignment, 1234u); 11935 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 11936 PenaltyBreakBeforeFirstCallParameter, 1234u); 11937 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 11938 PenaltyBreakTemplateDeclaration, 1234u); 11939 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 11940 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 11941 PenaltyReturnTypeOnItsOwnLine, 1234u); 11942 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 11943 SpacesBeforeTrailingComments, 1234u); 11944 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 11945 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 11946 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 11947 11948 Style.PointerAlignment = FormatStyle::PAS_Middle; 11949 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 11950 FormatStyle::PAS_Left); 11951 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 11952 FormatStyle::PAS_Right); 11953 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 11954 FormatStyle::PAS_Middle); 11955 // For backward compatibility: 11956 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 11957 FormatStyle::PAS_Left); 11958 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 11959 FormatStyle::PAS_Right); 11960 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 11961 FormatStyle::PAS_Middle); 11962 11963 Style.Standard = FormatStyle::LS_Auto; 11964 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 11965 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11); 11966 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 11967 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 11968 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 11969 11970 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11971 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 11972 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 11973 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 11974 FormatStyle::BOS_None); 11975 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 11976 FormatStyle::BOS_All); 11977 // For backward compatibility: 11978 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 11979 FormatStyle::BOS_None); 11980 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 11981 FormatStyle::BOS_All); 11982 11983 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 11984 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 11985 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 11986 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 11987 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 11988 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 11989 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 11990 // For backward compatibility: 11991 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 11992 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 11993 11994 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 11995 CHECK_PARSE("BreakInheritanceList: BeforeComma", 11996 BreakInheritanceList, FormatStyle::BILS_BeforeComma); 11997 CHECK_PARSE("BreakInheritanceList: AfterColon", 11998 BreakInheritanceList, FormatStyle::BILS_AfterColon); 11999 CHECK_PARSE("BreakInheritanceList: BeforeColon", 12000 BreakInheritanceList, FormatStyle::BILS_BeforeColon); 12001 // For backward compatibility: 12002 CHECK_PARSE("BreakBeforeInheritanceComma: true", 12003 BreakInheritanceList, FormatStyle::BILS_BeforeComma); 12004 12005 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 12006 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 12007 FormatStyle::BAS_Align); 12008 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 12009 FormatStyle::BAS_DontAlign); 12010 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 12011 FormatStyle::BAS_AlwaysBreak); 12012 // For backward compatibility: 12013 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 12014 FormatStyle::BAS_DontAlign); 12015 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 12016 FormatStyle::BAS_Align); 12017 12018 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 12019 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 12020 FormatStyle::ENAS_DontAlign); 12021 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 12022 FormatStyle::ENAS_Left); 12023 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 12024 FormatStyle::ENAS_Right); 12025 // For backward compatibility: 12026 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 12027 FormatStyle::ENAS_Left); 12028 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 12029 FormatStyle::ENAS_Right); 12030 12031 Style.UseTab = FormatStyle::UT_ForIndentation; 12032 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 12033 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 12034 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 12035 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 12036 FormatStyle::UT_ForContinuationAndIndentation); 12037 // For backward compatibility: 12038 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 12039 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 12040 12041 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 12042 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never", 12043 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12044 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty", 12045 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty); 12046 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always", 12047 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12048 // For backward compatibility: 12049 CHECK_PARSE("AllowShortBlocksOnASingleLine: false", 12050 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12051 CHECK_PARSE("AllowShortBlocksOnASingleLine: true", 12052 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12053 12054 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 12055 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 12056 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12057 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 12058 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 12059 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 12060 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 12061 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 12062 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12063 // For backward compatibility: 12064 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 12065 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12066 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 12067 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12068 12069 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 12070 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 12071 FormatStyle::SBPO_Never); 12072 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 12073 FormatStyle::SBPO_Always); 12074 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 12075 FormatStyle::SBPO_ControlStatements); 12076 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 12077 FormatStyle::SBPO_NonEmptyParentheses); 12078 // For backward compatibility: 12079 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 12080 FormatStyle::SBPO_Never); 12081 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 12082 FormatStyle::SBPO_ControlStatements); 12083 12084 Style.ColumnLimit = 123; 12085 FormatStyle BaseStyle = getLLVMStyle(); 12086 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 12087 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 12088 12089 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 12090 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 12091 FormatStyle::BS_Attach); 12092 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 12093 FormatStyle::BS_Linux); 12094 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 12095 FormatStyle::BS_Mozilla); 12096 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 12097 FormatStyle::BS_Stroustrup); 12098 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 12099 FormatStyle::BS_Allman); 12100 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 12101 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 12102 FormatStyle::BS_WebKit); 12103 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 12104 FormatStyle::BS_Custom); 12105 12106 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 12107 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 12108 FormatStyle::RTBS_None); 12109 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 12110 FormatStyle::RTBS_All); 12111 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 12112 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 12113 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 12114 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 12115 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 12116 AlwaysBreakAfterReturnType, 12117 FormatStyle::RTBS_TopLevelDefinitions); 12118 12119 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 12120 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", AlwaysBreakTemplateDeclarations, 12121 FormatStyle::BTDS_No); 12122 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", AlwaysBreakTemplateDeclarations, 12123 FormatStyle::BTDS_MultiLine); 12124 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", AlwaysBreakTemplateDeclarations, 12125 FormatStyle::BTDS_Yes); 12126 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", AlwaysBreakTemplateDeclarations, 12127 FormatStyle::BTDS_MultiLine); 12128 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", AlwaysBreakTemplateDeclarations, 12129 FormatStyle::BTDS_Yes); 12130 12131 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 12132 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 12133 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 12134 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 12135 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 12136 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 12137 AlwaysBreakAfterDefinitionReturnType, 12138 FormatStyle::DRTBS_TopLevel); 12139 12140 Style.NamespaceIndentation = FormatStyle::NI_All; 12141 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 12142 FormatStyle::NI_None); 12143 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 12144 FormatStyle::NI_Inner); 12145 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 12146 FormatStyle::NI_All); 12147 12148 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 12149 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 12150 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12151 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 12152 AllowShortIfStatementsOnASingleLine, 12153 FormatStyle::SIS_WithoutElse); 12154 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 12155 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 12156 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 12157 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12158 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 12159 AllowShortIfStatementsOnASingleLine, 12160 FormatStyle::SIS_WithoutElse); 12161 12162 // FIXME: This is required because parsing a configuration simply overwrites 12163 // the first N elements of the list instead of resetting it. 12164 Style.ForEachMacros.clear(); 12165 std::vector<std::string> BoostForeach; 12166 BoostForeach.push_back("BOOST_FOREACH"); 12167 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 12168 std::vector<std::string> BoostAndQForeach; 12169 BoostAndQForeach.push_back("BOOST_FOREACH"); 12170 BoostAndQForeach.push_back("Q_FOREACH"); 12171 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 12172 BoostAndQForeach); 12173 12174 Style.StatementMacros.clear(); 12175 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 12176 std::vector<std::string>{"QUNUSED"}); 12177 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 12178 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 12179 12180 Style.NamespaceMacros.clear(); 12181 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 12182 std::vector<std::string>{"TESTSUITE"}); 12183 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 12184 std::vector<std::string>({"TESTSUITE", "SUITE"})); 12185 12186 Style.IncludeStyle.IncludeCategories.clear(); 12187 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 12188 {"abc/.*", 2}, {".*", 1}}; 12189 CHECK_PARSE("IncludeCategories:\n" 12190 " - Regex: abc/.*\n" 12191 " Priority: 2\n" 12192 " - Regex: .*\n" 12193 " Priority: 1", 12194 IncludeStyle.IncludeCategories, ExpectedCategories); 12195 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 12196 "abc$"); 12197 12198 Style.RawStringFormats.clear(); 12199 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 12200 { 12201 FormatStyle::LK_TextProto, 12202 {"pb", "proto"}, 12203 {"PARSE_TEXT_PROTO"}, 12204 /*CanonicalDelimiter=*/"", 12205 "llvm", 12206 }, 12207 { 12208 FormatStyle::LK_Cpp, 12209 {"cc", "cpp"}, 12210 {"C_CODEBLOCK", "CPPEVAL"}, 12211 /*CanonicalDelimiter=*/"cc", 12212 /*BasedOnStyle=*/"", 12213 }, 12214 }; 12215 12216 CHECK_PARSE("RawStringFormats:\n" 12217 " - Language: TextProto\n" 12218 " Delimiters:\n" 12219 " - 'pb'\n" 12220 " - 'proto'\n" 12221 " EnclosingFunctions:\n" 12222 " - 'PARSE_TEXT_PROTO'\n" 12223 " BasedOnStyle: llvm\n" 12224 " - Language: Cpp\n" 12225 " Delimiters:\n" 12226 " - 'cc'\n" 12227 " - 'cpp'\n" 12228 " EnclosingFunctions:\n" 12229 " - 'C_CODEBLOCK'\n" 12230 " - 'CPPEVAL'\n" 12231 " CanonicalDelimiter: 'cc'", 12232 RawStringFormats, ExpectedRawStringFormats); 12233 } 12234 12235 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 12236 FormatStyle Style = {}; 12237 Style.Language = FormatStyle::LK_Cpp; 12238 CHECK_PARSE("Language: Cpp\n" 12239 "IndentWidth: 12", 12240 IndentWidth, 12u); 12241 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 12242 "IndentWidth: 34", 12243 &Style), 12244 ParseError::Unsuitable); 12245 EXPECT_EQ(12u, Style.IndentWidth); 12246 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12247 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12248 12249 Style.Language = FormatStyle::LK_JavaScript; 12250 CHECK_PARSE("Language: JavaScript\n" 12251 "IndentWidth: 12", 12252 IndentWidth, 12u); 12253 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 12254 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 12255 "IndentWidth: 34", 12256 &Style), 12257 ParseError::Unsuitable); 12258 EXPECT_EQ(23u, Style.IndentWidth); 12259 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12260 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12261 12262 CHECK_PARSE("BasedOnStyle: LLVM\n" 12263 "IndentWidth: 67", 12264 IndentWidth, 67u); 12265 12266 CHECK_PARSE("---\n" 12267 "Language: JavaScript\n" 12268 "IndentWidth: 12\n" 12269 "---\n" 12270 "Language: Cpp\n" 12271 "IndentWidth: 34\n" 12272 "...\n", 12273 IndentWidth, 12u); 12274 12275 Style.Language = FormatStyle::LK_Cpp; 12276 CHECK_PARSE("---\n" 12277 "Language: JavaScript\n" 12278 "IndentWidth: 12\n" 12279 "---\n" 12280 "Language: Cpp\n" 12281 "IndentWidth: 34\n" 12282 "...\n", 12283 IndentWidth, 34u); 12284 CHECK_PARSE("---\n" 12285 "IndentWidth: 78\n" 12286 "---\n" 12287 "Language: JavaScript\n" 12288 "IndentWidth: 56\n" 12289 "...\n", 12290 IndentWidth, 78u); 12291 12292 Style.ColumnLimit = 123; 12293 Style.IndentWidth = 234; 12294 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 12295 Style.TabWidth = 345; 12296 EXPECT_FALSE(parseConfiguration("---\n" 12297 "IndentWidth: 456\n" 12298 "BreakBeforeBraces: Allman\n" 12299 "---\n" 12300 "Language: JavaScript\n" 12301 "IndentWidth: 111\n" 12302 "TabWidth: 111\n" 12303 "---\n" 12304 "Language: Cpp\n" 12305 "BreakBeforeBraces: Stroustrup\n" 12306 "TabWidth: 789\n" 12307 "...\n", 12308 &Style)); 12309 EXPECT_EQ(123u, Style.ColumnLimit); 12310 EXPECT_EQ(456u, Style.IndentWidth); 12311 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 12312 EXPECT_EQ(789u, Style.TabWidth); 12313 12314 EXPECT_EQ(parseConfiguration("---\n" 12315 "Language: JavaScript\n" 12316 "IndentWidth: 56\n" 12317 "---\n" 12318 "IndentWidth: 78\n" 12319 "...\n", 12320 &Style), 12321 ParseError::Error); 12322 EXPECT_EQ(parseConfiguration("---\n" 12323 "Language: JavaScript\n" 12324 "IndentWidth: 56\n" 12325 "---\n" 12326 "Language: JavaScript\n" 12327 "IndentWidth: 78\n" 12328 "...\n", 12329 &Style), 12330 ParseError::Error); 12331 12332 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12333 } 12334 12335 #undef CHECK_PARSE 12336 12337 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 12338 FormatStyle Style = {}; 12339 Style.Language = FormatStyle::LK_JavaScript; 12340 Style.BreakBeforeTernaryOperators = true; 12341 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 12342 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 12343 12344 Style.BreakBeforeTernaryOperators = true; 12345 EXPECT_EQ(0, parseConfiguration("---\n" 12346 "BasedOnStyle: Google\n" 12347 "---\n" 12348 "Language: JavaScript\n" 12349 "IndentWidth: 76\n" 12350 "...\n", 12351 &Style) 12352 .value()); 12353 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 12354 EXPECT_EQ(76u, Style.IndentWidth); 12355 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12356 } 12357 12358 TEST_F(FormatTest, ConfigurationRoundTripTest) { 12359 FormatStyle Style = getLLVMStyle(); 12360 std::string YAML = configurationAsText(Style); 12361 FormatStyle ParsedStyle = {}; 12362 ParsedStyle.Language = FormatStyle::LK_Cpp; 12363 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 12364 EXPECT_EQ(Style, ParsedStyle); 12365 } 12366 12367 TEST_F(FormatTest, WorksFor8bitEncodings) { 12368 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 12369 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 12370 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 12371 "\"\xef\xee\xf0\xf3...\"", 12372 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 12373 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 12374 "\xef\xee\xf0\xf3...\"", 12375 getLLVMStyleWithColumns(12))); 12376 } 12377 12378 TEST_F(FormatTest, HandlesUTF8BOM) { 12379 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 12380 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 12381 format("\xef\xbb\xbf#include <iostream>")); 12382 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 12383 format("\xef\xbb\xbf\n#include <iostream>")); 12384 } 12385 12386 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 12387 #if !defined(_MSC_VER) 12388 12389 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 12390 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 12391 getLLVMStyleWithColumns(35)); 12392 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 12393 getLLVMStyleWithColumns(31)); 12394 verifyFormat("// Однажды в студёную зимнюю пору...", 12395 getLLVMStyleWithColumns(36)); 12396 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 12397 verifyFormat("/* Однажды в студёную зимнюю пору... */", 12398 getLLVMStyleWithColumns(39)); 12399 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 12400 getLLVMStyleWithColumns(35)); 12401 } 12402 12403 TEST_F(FormatTest, SplitsUTF8Strings) { 12404 // Non-printable characters' width is currently considered to be the length in 12405 // bytes in UTF8. The characters can be displayed in very different manner 12406 // (zero-width, single width with a substitution glyph, expanded to their code 12407 // (e.g. "<8d>"), so there's no single correct way to handle them. 12408 EXPECT_EQ("\"aaaaÄ\"\n" 12409 "\"\xc2\x8d\";", 12410 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 12411 EXPECT_EQ("\"aaaaaaaÄ\"\n" 12412 "\"\xc2\x8d\";", 12413 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 12414 EXPECT_EQ("\"Однажды, в \"\n" 12415 "\"студёную \"\n" 12416 "\"зимнюю \"\n" 12417 "\"пору,\"", 12418 format("\"Однажды, в студёную зимнюю пору,\"", 12419 getLLVMStyleWithColumns(13))); 12420 EXPECT_EQ( 12421 "\"一 二 三 \"\n" 12422 "\"四 五六 \"\n" 12423 "\"七 八 九 \"\n" 12424 "\"十\"", 12425 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 12426 EXPECT_EQ("\"一\t\"\n" 12427 "\"二 \t\"\n" 12428 "\"三 四 \"\n" 12429 "\"五\t\"\n" 12430 "\"六 \t\"\n" 12431 "\"七 \"\n" 12432 "\"八九十\tqq\"", 12433 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 12434 getLLVMStyleWithColumns(11))); 12435 12436 // UTF8 character in an escape sequence. 12437 EXPECT_EQ("\"aaaaaa\"\n" 12438 "\"\\\xC2\x8D\"", 12439 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 12440 } 12441 12442 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 12443 EXPECT_EQ("const char *sssss =\n" 12444 " \"一二三四五六七八\\\n" 12445 " 九 十\";", 12446 format("const char *sssss = \"一二三四五六七八\\\n" 12447 " 九 十\";", 12448 getLLVMStyleWithColumns(30))); 12449 } 12450 12451 TEST_F(FormatTest, SplitsUTF8LineComments) { 12452 EXPECT_EQ("// aaaaÄ\xc2\x8d", 12453 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 12454 EXPECT_EQ("// Я из лесу\n" 12455 "// вышел; был\n" 12456 "// сильный\n" 12457 "// мороз.", 12458 format("// Я из лесу вышел; был сильный мороз.", 12459 getLLVMStyleWithColumns(13))); 12460 EXPECT_EQ("// 一二三\n" 12461 "// 四五六七\n" 12462 "// 八 九\n" 12463 "// 十", 12464 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 12465 } 12466 12467 TEST_F(FormatTest, SplitsUTF8BlockComments) { 12468 EXPECT_EQ("/* Гляжу,\n" 12469 " * поднимается\n" 12470 " * медленно в\n" 12471 " * гору\n" 12472 " * Лошадка,\n" 12473 " * везущая\n" 12474 " * хворосту\n" 12475 " * воз. */", 12476 format("/* Гляжу, поднимается медленно в гору\n" 12477 " * Лошадка, везущая хворосту воз. */", 12478 getLLVMStyleWithColumns(13))); 12479 EXPECT_EQ( 12480 "/* 一二三\n" 12481 " * 四五六七\n" 12482 " * 八 九\n" 12483 " * 十 */", 12484 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 12485 EXPECT_EQ("/* �������� ��������\n" 12486 " * ��������\n" 12487 " * ������-�� */", 12488 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 12489 } 12490 12491 #endif // _MSC_VER 12492 12493 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 12494 FormatStyle Style = getLLVMStyle(); 12495 12496 Style.ConstructorInitializerIndentWidth = 4; 12497 verifyFormat( 12498 "SomeClass::Constructor()\n" 12499 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12500 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12501 Style); 12502 12503 Style.ConstructorInitializerIndentWidth = 2; 12504 verifyFormat( 12505 "SomeClass::Constructor()\n" 12506 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12507 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12508 Style); 12509 12510 Style.ConstructorInitializerIndentWidth = 0; 12511 verifyFormat( 12512 "SomeClass::Constructor()\n" 12513 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12514 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12515 Style); 12516 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 12517 verifyFormat( 12518 "SomeLongTemplateVariableName<\n" 12519 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 12520 Style); 12521 verifyFormat( 12522 "bool smaller = 1 < bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 12523 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 12524 Style); 12525 12526 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 12527 verifyFormat( 12528 "SomeClass::Constructor() :\n" 12529 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 12530 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 12531 Style); 12532 } 12533 12534 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 12535 FormatStyle Style = getLLVMStyle(); 12536 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 12537 Style.ConstructorInitializerIndentWidth = 4; 12538 verifyFormat("SomeClass::Constructor()\n" 12539 " : a(a)\n" 12540 " , b(b)\n" 12541 " , c(c) {}", 12542 Style); 12543 verifyFormat("SomeClass::Constructor()\n" 12544 " : a(a) {}", 12545 Style); 12546 12547 Style.ColumnLimit = 0; 12548 verifyFormat("SomeClass::Constructor()\n" 12549 " : a(a) {}", 12550 Style); 12551 verifyFormat("SomeClass::Constructor() noexcept\n" 12552 " : a(a) {}", 12553 Style); 12554 verifyFormat("SomeClass::Constructor()\n" 12555 " : a(a)\n" 12556 " , b(b)\n" 12557 " , c(c) {}", 12558 Style); 12559 verifyFormat("SomeClass::Constructor()\n" 12560 " : a(a) {\n" 12561 " foo();\n" 12562 " bar();\n" 12563 "}", 12564 Style); 12565 12566 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 12567 verifyFormat("SomeClass::Constructor()\n" 12568 " : a(a)\n" 12569 " , b(b)\n" 12570 " , c(c) {\n}", 12571 Style); 12572 verifyFormat("SomeClass::Constructor()\n" 12573 " : a(a) {\n}", 12574 Style); 12575 12576 Style.ColumnLimit = 80; 12577 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 12578 Style.ConstructorInitializerIndentWidth = 2; 12579 verifyFormat("SomeClass::Constructor()\n" 12580 " : a(a)\n" 12581 " , b(b)\n" 12582 " , c(c) {}", 12583 Style); 12584 12585 Style.ConstructorInitializerIndentWidth = 0; 12586 verifyFormat("SomeClass::Constructor()\n" 12587 ": a(a)\n" 12588 ", b(b)\n" 12589 ", c(c) {}", 12590 Style); 12591 12592 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 12593 Style.ConstructorInitializerIndentWidth = 4; 12594 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 12595 verifyFormat( 12596 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 12597 Style); 12598 verifyFormat( 12599 "SomeClass::Constructor()\n" 12600 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 12601 Style); 12602 Style.ConstructorInitializerIndentWidth = 4; 12603 Style.ColumnLimit = 60; 12604 verifyFormat("SomeClass::Constructor()\n" 12605 " : aaaaaaaa(aaaaaaaa)\n" 12606 " , aaaaaaaa(aaaaaaaa)\n" 12607 " , aaaaaaaa(aaaaaaaa) {}", 12608 Style); 12609 } 12610 12611 TEST_F(FormatTest, Destructors) { 12612 verifyFormat("void F(int &i) { i.~int(); }"); 12613 verifyFormat("void F(int &i) { i->~int(); }"); 12614 } 12615 12616 TEST_F(FormatTest, FormatsWithWebKitStyle) { 12617 FormatStyle Style = getWebKitStyle(); 12618 12619 // Don't indent in outer namespaces. 12620 verifyFormat("namespace outer {\n" 12621 "int i;\n" 12622 "namespace inner {\n" 12623 " int i;\n" 12624 "} // namespace inner\n" 12625 "} // namespace outer\n" 12626 "namespace other_outer {\n" 12627 "int i;\n" 12628 "}", 12629 Style); 12630 12631 // Don't indent case labels. 12632 verifyFormat("switch (variable) {\n" 12633 "case 1:\n" 12634 "case 2:\n" 12635 " doSomething();\n" 12636 " break;\n" 12637 "default:\n" 12638 " ++variable;\n" 12639 "}", 12640 Style); 12641 12642 // Wrap before binary operators. 12643 EXPECT_EQ("void f()\n" 12644 "{\n" 12645 " if (aaaaaaaaaaaaaaaa\n" 12646 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 12647 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 12648 " return;\n" 12649 "}", 12650 format("void f() {\n" 12651 "if (aaaaaaaaaaaaaaaa\n" 12652 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 12653 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 12654 "return;\n" 12655 "}", 12656 Style)); 12657 12658 // Allow functions on a single line. 12659 verifyFormat("void f() { return; }", Style); 12660 12661 // Allow empty blocks on a single line and insert a space in empty blocks. 12662 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 12663 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 12664 // However, don't merge non-empty short loops. 12665 EXPECT_EQ("while (true) {\n" 12666 " continue;\n" 12667 "}", format("while (true) { continue; }", Style)); 12668 12669 // Constructor initializers are formatted one per line with the "," on the 12670 // new line. 12671 verifyFormat("Constructor()\n" 12672 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 12673 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 12674 " aaaaaaaaaaaaaa)\n" 12675 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 12676 "{\n" 12677 "}", 12678 Style); 12679 verifyFormat("SomeClass::Constructor()\n" 12680 " : a(a)\n" 12681 "{\n" 12682 "}", 12683 Style); 12684 EXPECT_EQ("SomeClass::Constructor()\n" 12685 " : a(a)\n" 12686 "{\n" 12687 "}", 12688 format("SomeClass::Constructor():a(a){}", Style)); 12689 verifyFormat("SomeClass::Constructor()\n" 12690 " : a(a)\n" 12691 " , b(b)\n" 12692 " , c(c)\n" 12693 "{\n" 12694 "}", 12695 Style); 12696 verifyFormat("SomeClass::Constructor()\n" 12697 " : a(a)\n" 12698 "{\n" 12699 " foo();\n" 12700 " bar();\n" 12701 "}", 12702 Style); 12703 12704 // Access specifiers should be aligned left. 12705 verifyFormat("class C {\n" 12706 "public:\n" 12707 " int i;\n" 12708 "};", 12709 Style); 12710 12711 // Do not align comments. 12712 verifyFormat("int a; // Do not\n" 12713 "double b; // align comments.", 12714 Style); 12715 12716 // Do not align operands. 12717 EXPECT_EQ("ASSERT(aaaa\n" 12718 " || bbbb);", 12719 format("ASSERT ( aaaa\n||bbbb);", Style)); 12720 12721 // Accept input's line breaks. 12722 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 12723 " || bbbbbbbbbbbbbbb) {\n" 12724 " i++;\n" 12725 "}", 12726 format("if (aaaaaaaaaaaaaaa\n" 12727 "|| bbbbbbbbbbbbbbb) { i++; }", 12728 Style)); 12729 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 12730 " i++;\n" 12731 "}", 12732 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 12733 12734 // Don't automatically break all macro definitions (llvm.org/PR17842). 12735 verifyFormat("#define aNumber 10", Style); 12736 // However, generally keep the line breaks that the user authored. 12737 EXPECT_EQ("#define aNumber \\\n" 12738 " 10", 12739 format("#define aNumber \\\n" 12740 " 10", 12741 Style)); 12742 12743 // Keep empty and one-element array literals on a single line. 12744 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 12745 " copyItems:YES];", 12746 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 12747 "copyItems:YES];", 12748 Style)); 12749 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 12750 " copyItems:YES];", 12751 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 12752 " copyItems:YES];", 12753 Style)); 12754 // FIXME: This does not seem right, there should be more indentation before 12755 // the array literal's entries. Nested blocks have the same problem. 12756 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 12757 " @\"a\",\n" 12758 " @\"a\"\n" 12759 "]\n" 12760 " copyItems:YES];", 12761 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 12762 " @\"a\",\n" 12763 " @\"a\"\n" 12764 " ]\n" 12765 " copyItems:YES];", 12766 Style)); 12767 EXPECT_EQ( 12768 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 12769 " copyItems:YES];", 12770 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 12771 " copyItems:YES];", 12772 Style)); 12773 12774 verifyFormat("[self.a b:c c:d];", Style); 12775 EXPECT_EQ("[self.a b:c\n" 12776 " c:d];", 12777 format("[self.a b:c\n" 12778 "c:d];", 12779 Style)); 12780 } 12781 12782 TEST_F(FormatTest, FormatsLambdas) { 12783 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 12784 verifyFormat( 12785 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 12786 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 12787 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 12788 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 12789 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 12790 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 12791 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 12792 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 12793 verifyFormat("int x = f(*+[] {});"); 12794 verifyFormat("void f() {\n" 12795 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 12796 "}\n"); 12797 verifyFormat("void f() {\n" 12798 " other(x.begin(), //\n" 12799 " x.end(), //\n" 12800 " [&](int, int) { return 1; });\n" 12801 "}\n"); 12802 verifyFormat("void f() {\n" 12803 " other.other.other.other.other(\n" 12804 " x.begin(), x.end(),\n" 12805 " [something, rather](int, int, int, int, int, int, int) { return 1; });\n" 12806 "}\n"); 12807 verifyFormat("void f() {\n" 12808 " other.other.other.other.other(\n" 12809 " x.begin(), x.end(),\n" 12810 " [something, rather](int, int, int, int, int, int, int) {\n" 12811 " //\n" 12812 " });\n" 12813 "}\n"); 12814 verifyFormat("SomeFunction([]() { // A cool function...\n" 12815 " return 43;\n" 12816 "});"); 12817 EXPECT_EQ("SomeFunction([]() {\n" 12818 "#define A a\n" 12819 " return 43;\n" 12820 "});", 12821 format("SomeFunction([](){\n" 12822 "#define A a\n" 12823 "return 43;\n" 12824 "});")); 12825 verifyFormat("void f() {\n" 12826 " SomeFunction([](decltype(x), A *a) {});\n" 12827 "}"); 12828 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 12829 " [](const aaaaaaaaaa &a) { return a; });"); 12830 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 12831 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 12832 "});"); 12833 verifyFormat("Constructor()\n" 12834 " : Field([] { // comment\n" 12835 " int i;\n" 12836 " }) {}"); 12837 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 12838 " return some_parameter.size();\n" 12839 "};"); 12840 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 12841 " [](const string &s) { return s; };"); 12842 verifyFormat("int i = aaaaaa ? 1 //\n" 12843 " : [] {\n" 12844 " return 2; //\n" 12845 " }();"); 12846 verifyFormat("llvm::errs() << \"number of twos is \"\n" 12847 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 12848 " return x == 2; // force break\n" 12849 " });"); 12850 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 12851 " [=](int iiiiiiiiiiii) {\n" 12852 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 12853 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 12854 " });", 12855 getLLVMStyleWithColumns(60)); 12856 verifyFormat("SomeFunction({[&] {\n" 12857 " // comment\n" 12858 " },\n" 12859 " [&] {\n" 12860 " // comment\n" 12861 " }});"); 12862 verifyFormat("SomeFunction({[&] {\n" 12863 " // comment\n" 12864 "}});"); 12865 verifyFormat("virtual aaaaaaaaaaaaaaaa(\n" 12866 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 12867 " aaaaa aaaaaaaaa);"); 12868 12869 // Lambdas with return types. 12870 verifyFormat("int c = []() -> int { return 2; }();\n"); 12871 verifyFormat("int c = []() -> int * { return 2; }();\n"); 12872 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 12873 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 12874 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 12875 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 12876 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 12877 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 12878 verifyFormat("[a, a]() -> a<1> {};"); 12879 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 12880 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 12881 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 12882 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 12883 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 12884 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 12885 verifyFormat("[]() -> foo<!5> { return {}; };"); 12886 verifyFormat("[]() -> foo<~5> { return {}; };"); 12887 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 12888 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 12889 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 12890 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 12891 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 12892 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 12893 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 12894 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 12895 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 12896 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 12897 verifyFormat("namespace bar {\n" 12898 "// broken:\n" 12899 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 12900 "} // namespace bar"); 12901 verifyFormat("namespace bar {\n" 12902 "// broken:\n" 12903 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 12904 "} // namespace bar"); 12905 verifyFormat("namespace bar {\n" 12906 "// broken:\n" 12907 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 12908 "} // namespace bar"); 12909 verifyFormat("namespace bar {\n" 12910 "// broken:\n" 12911 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 12912 "} // namespace bar"); 12913 verifyFormat("namespace bar {\n" 12914 "// broken:\n" 12915 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 12916 "} // namespace bar"); 12917 verifyFormat("namespace bar {\n" 12918 "// broken:\n" 12919 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 12920 "} // namespace bar"); 12921 verifyFormat("namespace bar {\n" 12922 "// broken:\n" 12923 "auto foo{[]() -> foo<!5> { return {}; }};\n" 12924 "} // namespace bar"); 12925 verifyFormat("namespace bar {\n" 12926 "// broken:\n" 12927 "auto foo{[]() -> foo<~5> { return {}; }};\n" 12928 "} // namespace bar"); 12929 verifyFormat("namespace bar {\n" 12930 "// broken:\n" 12931 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 12932 "} // namespace bar"); 12933 verifyFormat("namespace bar {\n" 12934 "// broken:\n" 12935 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 12936 "} // namespace bar"); 12937 verifyFormat("namespace bar {\n" 12938 "// broken:\n" 12939 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 12940 "} // namespace bar"); 12941 verifyFormat("namespace bar {\n" 12942 "// broken:\n" 12943 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 12944 "} // namespace bar"); 12945 verifyFormat("namespace bar {\n" 12946 "// broken:\n" 12947 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 12948 "} // namespace bar"); 12949 verifyFormat("namespace bar {\n" 12950 "// broken:\n" 12951 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 12952 "} // namespace bar"); 12953 verifyFormat("namespace bar {\n" 12954 "// broken:\n" 12955 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 12956 "} // namespace bar"); 12957 verifyFormat("namespace bar {\n" 12958 "// broken:\n" 12959 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 12960 "} // namespace bar"); 12961 verifyFormat("namespace bar {\n" 12962 "// broken:\n" 12963 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 12964 "} // namespace bar"); 12965 verifyFormat("namespace bar {\n" 12966 "// broken:\n" 12967 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 12968 "} // namespace bar"); 12969 verifyFormat("[]() -> a<1> {};"); 12970 verifyFormat("[]() -> a<1> { ; };"); 12971 verifyFormat("[]() -> a<1> { ; }();"); 12972 verifyFormat("[a, a]() -> a<true> {};"); 12973 verifyFormat("[]() -> a<true> {};"); 12974 verifyFormat("[]() -> a<true> { ; };"); 12975 verifyFormat("[]() -> a<true> { ; }();"); 12976 verifyFormat("[a, a]() -> a<false> {};"); 12977 verifyFormat("[]() -> a<false> {};"); 12978 verifyFormat("[]() -> a<false> { ; };"); 12979 verifyFormat("[]() -> a<false> { ; }();"); 12980 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 12981 verifyFormat("namespace bar {\n" 12982 "auto foo{[]() -> foo<false> { ; }};\n" 12983 "} // namespace bar"); 12984 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 12985 " int j) -> int {\n" 12986 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 12987 "};"); 12988 verifyFormat( 12989 "aaaaaaaaaaaaaaaaaaaaaa(\n" 12990 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 12991 " return aaaaaaaaaaaaaaaaa;\n" 12992 " });", 12993 getLLVMStyleWithColumns(70)); 12994 verifyFormat("[]() //\n" 12995 " -> int {\n" 12996 " return 1; //\n" 12997 "};"); 12998 12999 // Lambdas with explicit template argument lists. 13000 verifyFormat( 13001 "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n"); 13002 13003 // Multiple lambdas in the same parentheses change indentation rules. These 13004 // lambdas are forced to start on new lines. 13005 verifyFormat("SomeFunction(\n" 13006 " []() {\n" 13007 " //\n" 13008 " },\n" 13009 " []() {\n" 13010 " //\n" 13011 " });"); 13012 13013 // A lambda passed as arg0 is always pushed to the next line. 13014 verifyFormat("SomeFunction(\n" 13015 " [this] {\n" 13016 " //\n" 13017 " },\n" 13018 " 1);\n"); 13019 13020 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like 13021 // the arg0 case above. 13022 auto Style = getGoogleStyle(); 13023 Style.BinPackArguments = false; 13024 verifyFormat("SomeFunction(\n" 13025 " a,\n" 13026 " [this] {\n" 13027 " //\n" 13028 " },\n" 13029 " b);\n", 13030 Style); 13031 verifyFormat("SomeFunction(\n" 13032 " a,\n" 13033 " [this] {\n" 13034 " //\n" 13035 " },\n" 13036 " b);\n"); 13037 13038 // A lambda with a very long line forces arg0 to be pushed out irrespective of 13039 // the BinPackArguments value (as long as the code is wide enough). 13040 verifyFormat("something->SomeFunction(\n" 13041 " a,\n" 13042 " [this] {\n" 13043 " D0000000000000000000000000000000000000000000000000000000000001();\n" 13044 " },\n" 13045 " b);\n"); 13046 13047 // A multi-line lambda is pulled up as long as the introducer fits on the previous 13048 // line and there are no further args. 13049 verifyFormat("function(1, [this, that] {\n" 13050 " //\n" 13051 "});\n"); 13052 verifyFormat("function([this, that] {\n" 13053 " //\n" 13054 "});\n"); 13055 // FIXME: this format is not ideal and we should consider forcing the first arg 13056 // onto its own line. 13057 verifyFormat("function(a, b, c, //\n" 13058 " d, [this, that] {\n" 13059 " //\n" 13060 " });\n"); 13061 13062 // Multiple lambdas are treated correctly even when there is a short arg0. 13063 verifyFormat("SomeFunction(\n" 13064 " 1,\n" 13065 " [this] {\n" 13066 " //\n" 13067 " },\n" 13068 " [this] {\n" 13069 " //\n" 13070 " },\n" 13071 " 1);\n"); 13072 13073 // More complex introducers. 13074 verifyFormat("return [i, args...] {};"); 13075 13076 // Not lambdas. 13077 verifyFormat("constexpr char hello[]{\"hello\"};"); 13078 verifyFormat("double &operator[](int i) { return 0; }\n" 13079 "int i;"); 13080 verifyFormat("std::unique_ptr<int[]> foo() {}"); 13081 verifyFormat("int i = a[a][a]->f();"); 13082 verifyFormat("int i = (*b)[a]->f();"); 13083 13084 // Other corner cases. 13085 verifyFormat("void f() {\n" 13086 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 13087 " );\n" 13088 "}"); 13089 13090 // Lambdas created through weird macros. 13091 verifyFormat("void f() {\n" 13092 " MACRO((const AA &a) { return 1; });\n" 13093 " MACRO((AA &a) { return 1; });\n" 13094 "}"); 13095 13096 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 13097 " doo_dah();\n" 13098 " doo_dah();\n" 13099 " })) {\n" 13100 "}"); 13101 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 13102 " doo_dah();\n" 13103 " doo_dah();\n" 13104 " })) {\n" 13105 "}"); 13106 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n" 13107 " doo_dah();\n" 13108 " doo_dah();\n" 13109 " })) {\n" 13110 "}"); 13111 verifyFormat("auto lambda = []() {\n" 13112 " int a = 2\n" 13113 "#if A\n" 13114 " + 2\n" 13115 "#endif\n" 13116 " ;\n" 13117 "};"); 13118 13119 // Lambdas with complex multiline introducers. 13120 verifyFormat( 13121 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13122 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 13123 " -> ::std::unordered_set<\n" 13124 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 13125 " //\n" 13126 " });"); 13127 13128 FormatStyle DoNotMerge = getLLVMStyle(); 13129 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 13130 verifyFormat("auto c = []() {\n" 13131 " return b;\n" 13132 "};", 13133 "auto c = []() { return b; };", DoNotMerge); 13134 verifyFormat("auto c = []() {\n" 13135 "};", 13136 " auto c = []() {};", DoNotMerge); 13137 13138 FormatStyle MergeEmptyOnly = getLLVMStyle(); 13139 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 13140 verifyFormat("auto c = []() {\n" 13141 " return b;\n" 13142 "};", 13143 "auto c = []() {\n" 13144 " return b;\n" 13145 " };", 13146 MergeEmptyOnly); 13147 verifyFormat("auto c = []() {};", 13148 "auto c = []() {\n" 13149 "};", 13150 MergeEmptyOnly); 13151 13152 FormatStyle MergeInline = getLLVMStyle(); 13153 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 13154 verifyFormat("auto c = []() {\n" 13155 " return b;\n" 13156 "};", 13157 "auto c = []() { return b; };", MergeInline); 13158 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 13159 MergeInline); 13160 verifyFormat("function([]() { return b; }, a)", 13161 "function([]() { return b; }, a)", MergeInline); 13162 verifyFormat("function(a, []() { return b; })", 13163 "function(a, []() { return b; })", MergeInline); 13164 } 13165 13166 TEST_F(FormatTest, EmptyLinesInLambdas) { 13167 verifyFormat("auto lambda = []() {\n" 13168 " x(); //\n" 13169 "};", 13170 "auto lambda = []() {\n" 13171 "\n" 13172 " x(); //\n" 13173 "\n" 13174 "};"); 13175 } 13176 13177 TEST_F(FormatTest, FormatsBlocks) { 13178 FormatStyle ShortBlocks = getLLVMStyle(); 13179 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13180 verifyFormat("int (^Block)(int, int);", ShortBlocks); 13181 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 13182 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 13183 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 13184 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 13185 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 13186 13187 verifyFormat("foo(^{ bar(); });", ShortBlocks); 13188 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 13189 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 13190 13191 verifyFormat("[operation setCompletionBlock:^{\n" 13192 " [self onOperationDone];\n" 13193 "}];"); 13194 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 13195 " [self onOperationDone];\n" 13196 "}]};"); 13197 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 13198 " f();\n" 13199 "}];"); 13200 verifyFormat("int a = [operation block:^int(int *i) {\n" 13201 " return 1;\n" 13202 "}];"); 13203 verifyFormat("[myObject doSomethingWith:arg1\n" 13204 " aaa:^int(int *a) {\n" 13205 " return 1;\n" 13206 " }\n" 13207 " bbb:f(a * bbbbbbbb)];"); 13208 13209 verifyFormat("[operation setCompletionBlock:^{\n" 13210 " [self.delegate newDataAvailable];\n" 13211 "}];", 13212 getLLVMStyleWithColumns(60)); 13213 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 13214 " NSString *path = [self sessionFilePath];\n" 13215 " if (path) {\n" 13216 " // ...\n" 13217 " }\n" 13218 "});"); 13219 verifyFormat("[[SessionService sharedService]\n" 13220 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13221 " if (window) {\n" 13222 " [self windowDidLoad:window];\n" 13223 " } else {\n" 13224 " [self errorLoadingWindow];\n" 13225 " }\n" 13226 " }];"); 13227 verifyFormat("void (^largeBlock)(void) = ^{\n" 13228 " // ...\n" 13229 "};\n", 13230 getLLVMStyleWithColumns(40)); 13231 verifyFormat("[[SessionService sharedService]\n" 13232 " loadWindowWithCompletionBlock: //\n" 13233 " ^(SessionWindow *window) {\n" 13234 " if (window) {\n" 13235 " [self windowDidLoad:window];\n" 13236 " } else {\n" 13237 " [self errorLoadingWindow];\n" 13238 " }\n" 13239 " }];", 13240 getLLVMStyleWithColumns(60)); 13241 verifyFormat("[myObject doSomethingWith:arg1\n" 13242 " firstBlock:^(Foo *a) {\n" 13243 " // ...\n" 13244 " int i;\n" 13245 " }\n" 13246 " secondBlock:^(Bar *b) {\n" 13247 " // ...\n" 13248 " int i;\n" 13249 " }\n" 13250 " thirdBlock:^Foo(Bar *b) {\n" 13251 " // ...\n" 13252 " int i;\n" 13253 " }];"); 13254 verifyFormat("[myObject doSomethingWith:arg1\n" 13255 " firstBlock:-1\n" 13256 " secondBlock:^(Bar *b) {\n" 13257 " // ...\n" 13258 " int i;\n" 13259 " }];"); 13260 13261 verifyFormat("f(^{\n" 13262 " @autoreleasepool {\n" 13263 " if (a) {\n" 13264 " g();\n" 13265 " }\n" 13266 " }\n" 13267 "});"); 13268 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 13269 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 13270 "};"); 13271 13272 FormatStyle FourIndent = getLLVMStyle(); 13273 FourIndent.ObjCBlockIndentWidth = 4; 13274 verifyFormat("[operation setCompletionBlock:^{\n" 13275 " [self onOperationDone];\n" 13276 "}];", 13277 FourIndent); 13278 } 13279 13280 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 13281 FormatStyle ZeroColumn = getLLVMStyle(); 13282 ZeroColumn.ColumnLimit = 0; 13283 13284 verifyFormat("[[SessionService sharedService] " 13285 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13286 " if (window) {\n" 13287 " [self windowDidLoad:window];\n" 13288 " } else {\n" 13289 " [self errorLoadingWindow];\n" 13290 " }\n" 13291 "}];", 13292 ZeroColumn); 13293 EXPECT_EQ("[[SessionService sharedService]\n" 13294 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13295 " if (window) {\n" 13296 " [self windowDidLoad:window];\n" 13297 " } else {\n" 13298 " [self errorLoadingWindow];\n" 13299 " }\n" 13300 " }];", 13301 format("[[SessionService sharedService]\n" 13302 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13303 " if (window) {\n" 13304 " [self windowDidLoad:window];\n" 13305 " } else {\n" 13306 " [self errorLoadingWindow];\n" 13307 " }\n" 13308 "}];", 13309 ZeroColumn)); 13310 verifyFormat("[myObject doSomethingWith:arg1\n" 13311 " firstBlock:^(Foo *a) {\n" 13312 " // ...\n" 13313 " int i;\n" 13314 " }\n" 13315 " secondBlock:^(Bar *b) {\n" 13316 " // ...\n" 13317 " int i;\n" 13318 " }\n" 13319 " thirdBlock:^Foo(Bar *b) {\n" 13320 " // ...\n" 13321 " int i;\n" 13322 " }];", 13323 ZeroColumn); 13324 verifyFormat("f(^{\n" 13325 " @autoreleasepool {\n" 13326 " if (a) {\n" 13327 " g();\n" 13328 " }\n" 13329 " }\n" 13330 "});", 13331 ZeroColumn); 13332 verifyFormat("void (^largeBlock)(void) = ^{\n" 13333 " // ...\n" 13334 "};", 13335 ZeroColumn); 13336 13337 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13338 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 13339 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 13340 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 13341 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 13342 " int i;\n" 13343 "};", 13344 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 13345 } 13346 13347 TEST_F(FormatTest, SupportsCRLF) { 13348 EXPECT_EQ("int a;\r\n" 13349 "int b;\r\n" 13350 "int c;\r\n", 13351 format("int a;\r\n" 13352 " int b;\r\n" 13353 " int c;\r\n", 13354 getLLVMStyle())); 13355 EXPECT_EQ("int a;\r\n" 13356 "int b;\r\n" 13357 "int c;\r\n", 13358 format("int a;\r\n" 13359 " int b;\n" 13360 " int c;\r\n", 13361 getLLVMStyle())); 13362 EXPECT_EQ("int a;\n" 13363 "int b;\n" 13364 "int c;\n", 13365 format("int a;\r\n" 13366 " int b;\n" 13367 " int c;\n", 13368 getLLVMStyle())); 13369 EXPECT_EQ("\"aaaaaaa \"\r\n" 13370 "\"bbbbbbb\";\r\n", 13371 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 13372 EXPECT_EQ("#define A \\\r\n" 13373 " b; \\\r\n" 13374 " c; \\\r\n" 13375 " d;\r\n", 13376 format("#define A \\\r\n" 13377 " b; \\\r\n" 13378 " c; d; \r\n", 13379 getGoogleStyle())); 13380 13381 EXPECT_EQ("/*\r\n" 13382 "multi line block comments\r\n" 13383 "should not introduce\r\n" 13384 "an extra carriage return\r\n" 13385 "*/\r\n", 13386 format("/*\r\n" 13387 "multi line block comments\r\n" 13388 "should not introduce\r\n" 13389 "an extra carriage return\r\n" 13390 "*/\r\n")); 13391 EXPECT_EQ("/*\r\n" 13392 "\r\n" 13393 "*/", 13394 format("/*\r\n" 13395 " \r\r\r\n" 13396 "*/")); 13397 } 13398 13399 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 13400 verifyFormat("MY_CLASS(C) {\n" 13401 " int i;\n" 13402 " int j;\n" 13403 "};"); 13404 } 13405 13406 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 13407 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 13408 TwoIndent.ContinuationIndentWidth = 2; 13409 13410 EXPECT_EQ("int i =\n" 13411 " longFunction(\n" 13412 " arg);", 13413 format("int i = longFunction(arg);", TwoIndent)); 13414 13415 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 13416 SixIndent.ContinuationIndentWidth = 6; 13417 13418 EXPECT_EQ("int i =\n" 13419 " longFunction(\n" 13420 " arg);", 13421 format("int i = longFunction(arg);", SixIndent)); 13422 } 13423 13424 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 13425 FormatStyle Style = getLLVMStyle(); 13426 verifyFormat("int Foo::getter(\n" 13427 " //\n" 13428 ") const {\n" 13429 " return foo;\n" 13430 "}", 13431 Style); 13432 verifyFormat("void Foo::setter(\n" 13433 " //\n" 13434 ") {\n" 13435 " foo = 1;\n" 13436 "}", 13437 Style); 13438 } 13439 13440 TEST_F(FormatTest, SpacesInAngles) { 13441 FormatStyle Spaces = getLLVMStyle(); 13442 Spaces.SpacesInAngles = true; 13443 13444 verifyFormat("static_cast< int >(arg);", Spaces); 13445 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 13446 verifyFormat("f< int, float >();", Spaces); 13447 verifyFormat("template <> g() {}", Spaces); 13448 verifyFormat("template < std::vector< int > > f() {}", Spaces); 13449 verifyFormat("std::function< void(int, int) > fct;", Spaces); 13450 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 13451 Spaces); 13452 13453 Spaces.Standard = FormatStyle::LS_Cpp03; 13454 Spaces.SpacesInAngles = true; 13455 verifyFormat("A< A< int > >();", Spaces); 13456 13457 Spaces.SpacesInAngles = false; 13458 verifyFormat("A<A<int> >();", Spaces); 13459 13460 Spaces.Standard = FormatStyle::LS_Cpp11; 13461 Spaces.SpacesInAngles = true; 13462 verifyFormat("A< A< int > >();", Spaces); 13463 13464 Spaces.SpacesInAngles = false; 13465 verifyFormat("A<A<int>>();", Spaces); 13466 } 13467 13468 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 13469 FormatStyle Style = getLLVMStyle(); 13470 Style.SpaceAfterTemplateKeyword = false; 13471 verifyFormat("template<int> void foo();", Style); 13472 } 13473 13474 TEST_F(FormatTest, TripleAngleBrackets) { 13475 verifyFormat("f<<<1, 1>>>();"); 13476 verifyFormat("f<<<1, 1, 1, s>>>();"); 13477 verifyFormat("f<<<a, b, c, d>>>();"); 13478 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 13479 verifyFormat("f<param><<<1, 1>>>();"); 13480 verifyFormat("f<1><<<1, 1>>>();"); 13481 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 13482 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 13483 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 13484 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 13485 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 13486 } 13487 13488 TEST_F(FormatTest, MergeLessLessAtEnd) { 13489 verifyFormat("<<"); 13490 EXPECT_EQ("< < <", format("\\\n<<<")); 13491 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 13492 "aaallvm::outs() <<"); 13493 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 13494 "aaaallvm::outs()\n <<"); 13495 } 13496 13497 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 13498 std::string code = "#if A\n" 13499 "#if B\n" 13500 "a.\n" 13501 "#endif\n" 13502 " a = 1;\n" 13503 "#else\n" 13504 "#endif\n" 13505 "#if C\n" 13506 "#else\n" 13507 "#endif\n"; 13508 EXPECT_EQ(code, format(code)); 13509 } 13510 13511 TEST_F(FormatTest, HandleConflictMarkers) { 13512 // Git/SVN conflict markers. 13513 EXPECT_EQ("int a;\n" 13514 "void f() {\n" 13515 " callme(some(parameter1,\n" 13516 "<<<<<<< text by the vcs\n" 13517 " parameter2),\n" 13518 "||||||| text by the vcs\n" 13519 " parameter2),\n" 13520 " parameter3,\n" 13521 "======= text by the vcs\n" 13522 " parameter2, parameter3),\n" 13523 ">>>>>>> text by the vcs\n" 13524 " otherparameter);\n", 13525 format("int a;\n" 13526 "void f() {\n" 13527 " callme(some(parameter1,\n" 13528 "<<<<<<< text by the vcs\n" 13529 " parameter2),\n" 13530 "||||||| text by the vcs\n" 13531 " parameter2),\n" 13532 " parameter3,\n" 13533 "======= text by the vcs\n" 13534 " parameter2,\n" 13535 " parameter3),\n" 13536 ">>>>>>> text by the vcs\n" 13537 " otherparameter);\n")); 13538 13539 // Perforce markers. 13540 EXPECT_EQ("void f() {\n" 13541 " function(\n" 13542 ">>>> text by the vcs\n" 13543 " parameter,\n" 13544 "==== text by the vcs\n" 13545 " parameter,\n" 13546 "==== text by the vcs\n" 13547 " parameter,\n" 13548 "<<<< text by the vcs\n" 13549 " parameter);\n", 13550 format("void f() {\n" 13551 " function(\n" 13552 ">>>> text by the vcs\n" 13553 " parameter,\n" 13554 "==== text by the vcs\n" 13555 " parameter,\n" 13556 "==== text by the vcs\n" 13557 " parameter,\n" 13558 "<<<< text by the vcs\n" 13559 " parameter);\n")); 13560 13561 EXPECT_EQ("<<<<<<<\n" 13562 "|||||||\n" 13563 "=======\n" 13564 ">>>>>>>", 13565 format("<<<<<<<\n" 13566 "|||||||\n" 13567 "=======\n" 13568 ">>>>>>>")); 13569 13570 EXPECT_EQ("<<<<<<<\n" 13571 "|||||||\n" 13572 "int i;\n" 13573 "=======\n" 13574 ">>>>>>>", 13575 format("<<<<<<<\n" 13576 "|||||||\n" 13577 "int i;\n" 13578 "=======\n" 13579 ">>>>>>>")); 13580 13581 // FIXME: Handle parsing of macros around conflict markers correctly: 13582 EXPECT_EQ("#define Macro \\\n" 13583 "<<<<<<<\n" 13584 "Something \\\n" 13585 "|||||||\n" 13586 "Else \\\n" 13587 "=======\n" 13588 "Other \\\n" 13589 ">>>>>>>\n" 13590 " End int i;\n", 13591 format("#define Macro \\\n" 13592 "<<<<<<<\n" 13593 " Something \\\n" 13594 "|||||||\n" 13595 " Else \\\n" 13596 "=======\n" 13597 " Other \\\n" 13598 ">>>>>>>\n" 13599 " End\n" 13600 "int i;\n")); 13601 } 13602 13603 TEST_F(FormatTest, DisableRegions) { 13604 EXPECT_EQ("int i;\n" 13605 "// clang-format off\n" 13606 " int j;\n" 13607 "// clang-format on\n" 13608 "int k;", 13609 format(" int i;\n" 13610 " // clang-format off\n" 13611 " int j;\n" 13612 " // clang-format on\n" 13613 " int k;")); 13614 EXPECT_EQ("int i;\n" 13615 "/* clang-format off */\n" 13616 " int j;\n" 13617 "/* clang-format on */\n" 13618 "int k;", 13619 format(" int i;\n" 13620 " /* clang-format off */\n" 13621 " int j;\n" 13622 " /* clang-format on */\n" 13623 " int k;")); 13624 13625 // Don't reflow comments within disabled regions. 13626 EXPECT_EQ( 13627 "// clang-format off\n" 13628 "// long long long long long long line\n" 13629 "/* clang-format on */\n" 13630 "/* long long long\n" 13631 " * long long long\n" 13632 " * line */\n" 13633 "int i;\n" 13634 "/* clang-format off */\n" 13635 "/* long long long long long long line */\n", 13636 format("// clang-format off\n" 13637 "// long long long long long long line\n" 13638 "/* clang-format on */\n" 13639 "/* long long long long long long line */\n" 13640 "int i;\n" 13641 "/* clang-format off */\n" 13642 "/* long long long long long long line */\n", 13643 getLLVMStyleWithColumns(20))); 13644 } 13645 13646 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 13647 format("? ) ="); 13648 verifyNoCrash("#define a\\\n /**/}"); 13649 } 13650 13651 TEST_F(FormatTest, FormatsTableGenCode) { 13652 FormatStyle Style = getLLVMStyle(); 13653 Style.Language = FormatStyle::LK_TableGen; 13654 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 13655 } 13656 13657 TEST_F(FormatTest, ArrayOfTemplates) { 13658 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 13659 format("auto a = new unique_ptr<int > [ 10];")); 13660 13661 FormatStyle Spaces = getLLVMStyle(); 13662 Spaces.SpacesInSquareBrackets = true; 13663 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 13664 format("auto a = new unique_ptr<int > [10];", Spaces)); 13665 } 13666 13667 TEST_F(FormatTest, ArrayAsTemplateType) { 13668 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 13669 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 13670 13671 FormatStyle Spaces = getLLVMStyle(); 13672 Spaces.SpacesInSquareBrackets = true; 13673 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 13674 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 13675 } 13676 13677 TEST_F(FormatTest, NoSpaceAfterSuper) { 13678 verifyFormat("__super::FooBar();"); 13679 } 13680 13681 TEST(FormatStyle, GetStyleWithEmptyFileName) { 13682 llvm::vfs::InMemoryFileSystem FS; 13683 auto Style1 = getStyle("file", "", "Google", "", &FS); 13684 ASSERT_TRUE((bool)Style1); 13685 ASSERT_EQ(*Style1, getGoogleStyle()); 13686 } 13687 13688 TEST(FormatStyle, GetStyleOfFile) { 13689 llvm::vfs::InMemoryFileSystem FS; 13690 // Test 1: format file in the same directory. 13691 ASSERT_TRUE( 13692 FS.addFile("/a/.clang-format", 0, 13693 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 13694 ASSERT_TRUE( 13695 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13696 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 13697 ASSERT_TRUE((bool)Style1); 13698 ASSERT_EQ(*Style1, getLLVMStyle()); 13699 13700 // Test 2.1: fallback to default. 13701 ASSERT_TRUE( 13702 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13703 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 13704 ASSERT_TRUE((bool)Style2); 13705 ASSERT_EQ(*Style2, getMozillaStyle()); 13706 13707 // Test 2.2: no format on 'none' fallback style. 13708 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 13709 ASSERT_TRUE((bool)Style2); 13710 ASSERT_EQ(*Style2, getNoStyle()); 13711 13712 // Test 2.3: format if config is found with no based style while fallback is 13713 // 'none'. 13714 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 13715 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 13716 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 13717 ASSERT_TRUE((bool)Style2); 13718 ASSERT_EQ(*Style2, getLLVMStyle()); 13719 13720 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 13721 Style2 = getStyle("{}", "a.h", "none", "", &FS); 13722 ASSERT_TRUE((bool)Style2); 13723 ASSERT_EQ(*Style2, getLLVMStyle()); 13724 13725 // Test 3: format file in parent directory. 13726 ASSERT_TRUE( 13727 FS.addFile("/c/.clang-format", 0, 13728 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 13729 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 13730 llvm::MemoryBuffer::getMemBuffer("int i;"))); 13731 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 13732 ASSERT_TRUE((bool)Style3); 13733 ASSERT_EQ(*Style3, getGoogleStyle()); 13734 13735 // Test 4: error on invalid fallback style 13736 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 13737 ASSERT_FALSE((bool)Style4); 13738 llvm::consumeError(Style4.takeError()); 13739 13740 // Test 5: error on invalid yaml on command line 13741 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 13742 ASSERT_FALSE((bool)Style5); 13743 llvm::consumeError(Style5.takeError()); 13744 13745 // Test 6: error on invalid style 13746 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 13747 ASSERT_FALSE((bool)Style6); 13748 llvm::consumeError(Style6.takeError()); 13749 13750 // Test 7: found config file, error on parsing it 13751 ASSERT_TRUE( 13752 FS.addFile("/d/.clang-format", 0, 13753 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 13754 "InvalidKey: InvalidValue"))); 13755 ASSERT_TRUE( 13756 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13757 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 13758 ASSERT_FALSE((bool)Style7); 13759 llvm::consumeError(Style7.takeError()); 13760 13761 // Test 8: inferred per-language defaults apply. 13762 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 13763 ASSERT_TRUE((bool)StyleTd); 13764 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 13765 } 13766 13767 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 13768 // Column limit is 20. 13769 std::string Code = "Type *a =\n" 13770 " new Type();\n" 13771 "g(iiiii, 0, jjjjj,\n" 13772 " 0, kkkkk, 0, mm);\n" 13773 "int bad = format ;"; 13774 std::string Expected = "auto a = new Type();\n" 13775 "g(iiiii, nullptr,\n" 13776 " jjjjj, nullptr,\n" 13777 " kkkkk, nullptr,\n" 13778 " mm);\n" 13779 "int bad = format ;"; 13780 FileID ID = Context.createInMemoryFile("format.cpp", Code); 13781 tooling::Replacements Replaces = toReplacements( 13782 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 13783 "auto "), 13784 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 13785 "nullptr"), 13786 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 13787 "nullptr"), 13788 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 13789 "nullptr")}); 13790 13791 format::FormatStyle Style = format::getLLVMStyle(); 13792 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 13793 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 13794 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 13795 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 13796 auto Result = applyAllReplacements(Code, *FormattedReplaces); 13797 EXPECT_TRUE(static_cast<bool>(Result)); 13798 EXPECT_EQ(Expected, *Result); 13799 } 13800 13801 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 13802 std::string Code = "#include \"a.h\"\n" 13803 "#include \"c.h\"\n" 13804 "\n" 13805 "int main() {\n" 13806 " return 0;\n" 13807 "}"; 13808 std::string Expected = "#include \"a.h\"\n" 13809 "#include \"b.h\"\n" 13810 "#include \"c.h\"\n" 13811 "\n" 13812 "int main() {\n" 13813 " return 0;\n" 13814 "}"; 13815 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 13816 tooling::Replacements Replaces = toReplacements( 13817 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 13818 "#include \"b.h\"\n")}); 13819 13820 format::FormatStyle Style = format::getLLVMStyle(); 13821 Style.SortIncludes = true; 13822 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 13823 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 13824 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 13825 auto Result = applyAllReplacements(Code, *FormattedReplaces); 13826 EXPECT_TRUE(static_cast<bool>(Result)); 13827 EXPECT_EQ(Expected, *Result); 13828 } 13829 13830 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 13831 EXPECT_EQ("using std::cin;\n" 13832 "using std::cout;", 13833 format("using std::cout;\n" 13834 "using std::cin;", getGoogleStyle())); 13835 } 13836 13837 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 13838 format::FormatStyle Style = format::getLLVMStyle(); 13839 Style.Standard = FormatStyle::LS_Cpp03; 13840 // cpp03 recognize this string as identifier u8 and literal character 'a' 13841 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 13842 } 13843 13844 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 13845 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 13846 // all modes, including C++11, C++14 and C++17 13847 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 13848 } 13849 13850 TEST_F(FormatTest, DoNotFormatLikelyXml) { 13851 EXPECT_EQ("<!-- ;> -->", 13852 format("<!-- ;> -->", getGoogleStyle())); 13853 EXPECT_EQ(" <!-- >; -->", 13854 format(" <!-- >; -->", getGoogleStyle())); 13855 } 13856 13857 TEST_F(FormatTest, StructuredBindings) { 13858 // Structured bindings is a C++17 feature. 13859 // all modes, including C++11, C++14 and C++17 13860 verifyFormat("auto [a, b] = f();"); 13861 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 13862 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 13863 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 13864 EXPECT_EQ("auto const volatile [a, b] = f();", 13865 format("auto const volatile[a, b] = f();")); 13866 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 13867 EXPECT_EQ("auto &[a, b, c] = f();", 13868 format("auto &[ a , b,c ] = f();")); 13869 EXPECT_EQ("auto &&[a, b, c] = f();", 13870 format("auto &&[ a , b,c ] = f();")); 13871 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 13872 EXPECT_EQ("auto const volatile &&[a, b] = f();", 13873 format("auto const volatile &&[a, b] = f();")); 13874 EXPECT_EQ("auto const &&[a, b] = f();", format("auto const && [a, b] = f();")); 13875 EXPECT_EQ("const auto &[a, b] = f();", format("const auto & [a, b] = f();")); 13876 EXPECT_EQ("const auto volatile &&[a, b] = f();", 13877 format("const auto volatile &&[a, b] = f();")); 13878 EXPECT_EQ("volatile const auto &&[a, b] = f();", 13879 format("volatile const auto &&[a, b] = f();")); 13880 EXPECT_EQ("const auto &&[a, b] = f();", format("const auto && [a, b] = f();")); 13881 13882 // Make sure we don't mistake structured bindings for lambdas. 13883 FormatStyle PointerMiddle = getLLVMStyle(); 13884 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 13885 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 13886 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 13887 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 13888 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 13889 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 13890 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 13891 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 13892 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 13893 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 13894 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 13895 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 13896 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 13897 13898 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 13899 format("for (const auto && [a, b] : some_range) {\n}")); 13900 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 13901 format("for (const auto & [a, b] : some_range) {\n}")); 13902 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 13903 format("for (const auto[a, b] : some_range) {\n}")); 13904 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 13905 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 13906 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 13907 EXPECT_EQ("auto const &[x, y](expr);", format("auto const & [x,y] (expr);")); 13908 EXPECT_EQ("auto const &&[x, y](expr);", format("auto const && [x,y] (expr);")); 13909 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 13910 EXPECT_EQ("auto const &[x, y]{expr};", format("auto const & [x,y] {expr};")); 13911 EXPECT_EQ("auto const &&[x, y]{expr};", format("auto const && [x,y] {expr};")); 13912 13913 format::FormatStyle Spaces = format::getLLVMStyle(); 13914 Spaces.SpacesInSquareBrackets = true; 13915 verifyFormat("auto [ a, b ] = f();", Spaces); 13916 verifyFormat("auto &&[ a, b ] = f();", Spaces); 13917 verifyFormat("auto &[ a, b ] = f();", Spaces); 13918 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 13919 verifyFormat("auto const &[ a, b ] = f();", Spaces); 13920 } 13921 13922 TEST_F(FormatTest, FileAndCode) { 13923 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 13924 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 13925 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 13926 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 13927 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@interface Foo\n@end\n")); 13928 EXPECT_EQ( 13929 FormatStyle::LK_ObjC, 13930 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 13931 EXPECT_EQ(FormatStyle::LK_ObjC, 13932 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 13933 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 13934 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 13935 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo", "@interface Foo\n@end\n")); 13936 EXPECT_EQ(FormatStyle::LK_ObjC, 13937 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 13938 EXPECT_EQ( 13939 FormatStyle::LK_ObjC, 13940 guessLanguage("foo.h", 13941 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 13942 EXPECT_EQ( 13943 FormatStyle::LK_Cpp, 13944 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 13945 } 13946 13947 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 13948 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 13949 EXPECT_EQ(FormatStyle::LK_ObjC, 13950 guessLanguage("foo.h", "array[[calculator getIndex]];")); 13951 EXPECT_EQ(FormatStyle::LK_Cpp, 13952 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 13953 EXPECT_EQ( 13954 FormatStyle::LK_Cpp, 13955 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 13956 EXPECT_EQ(FormatStyle::LK_ObjC, 13957 guessLanguage("foo.h", "[[noreturn foo] bar];")); 13958 EXPECT_EQ(FormatStyle::LK_Cpp, 13959 guessLanguage("foo.h", "[[clang::fallthrough]];")); 13960 EXPECT_EQ(FormatStyle::LK_ObjC, 13961 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 13962 EXPECT_EQ(FormatStyle::LK_Cpp, 13963 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 13964 EXPECT_EQ(FormatStyle::LK_Cpp, 13965 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 13966 EXPECT_EQ(FormatStyle::LK_ObjC, 13967 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 13968 EXPECT_EQ(FormatStyle::LK_Cpp, 13969 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 13970 EXPECT_EQ( 13971 FormatStyle::LK_Cpp, 13972 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 13973 EXPECT_EQ( 13974 FormatStyle::LK_Cpp, 13975 guessLanguage("foo.h", 13976 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 13977 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 13978 } 13979 13980 TEST_F(FormatTest, GuessLanguageWithCaret) { 13981 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 13982 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 13983 EXPECT_EQ(FormatStyle::LK_ObjC, 13984 guessLanguage("foo.h", "int(^)(char, float);")); 13985 EXPECT_EQ(FormatStyle::LK_ObjC, 13986 guessLanguage("foo.h", "int(^foo)(char, float);")); 13987 EXPECT_EQ(FormatStyle::LK_ObjC, 13988 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 13989 EXPECT_EQ(FormatStyle::LK_ObjC, 13990 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 13991 EXPECT_EQ( 13992 FormatStyle::LK_ObjC, 13993 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 13994 } 13995 13996 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 13997 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13998 "void f() {\n" 13999 " asm (\"mov %[e], %[d]\"\n" 14000 " : [d] \"=rm\" (d)\n" 14001 " [e] \"rm\" (*e));\n" 14002 "}")); 14003 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 14004 "void f() {\n" 14005 " _asm (\"mov %[e], %[d]\"\n" 14006 " : [d] \"=rm\" (d)\n" 14007 " [e] \"rm\" (*e));\n" 14008 "}")); 14009 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 14010 "void f() {\n" 14011 " __asm (\"mov %[e], %[d]\"\n" 14012 " : [d] \"=rm\" (d)\n" 14013 " [e] \"rm\" (*e));\n" 14014 "}")); 14015 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 14016 "void f() {\n" 14017 " __asm__ (\"mov %[e], %[d]\"\n" 14018 " : [d] \"=rm\" (d)\n" 14019 " [e] \"rm\" (*e));\n" 14020 "}")); 14021 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 14022 "void f() {\n" 14023 " asm (\"mov %[e], %[d]\"\n" 14024 " : [d] \"=rm\" (d),\n" 14025 " [e] \"rm\" (*e));\n" 14026 "}")); 14027 EXPECT_EQ(FormatStyle::LK_Cpp, 14028 guessLanguage("foo.h", "void f() {\n" 14029 " asm volatile (\"mov %[e], %[d]\"\n" 14030 " : [d] \"=rm\" (d)\n" 14031 " [e] \"rm\" (*e));\n" 14032 "}")); 14033 } 14034 14035 TEST_F(FormatTest, GuessLanguageWithChildLines) { 14036 EXPECT_EQ(FormatStyle::LK_Cpp, 14037 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 14038 EXPECT_EQ(FormatStyle::LK_ObjC, 14039 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 14040 EXPECT_EQ( 14041 FormatStyle::LK_Cpp, 14042 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 14043 EXPECT_EQ( 14044 FormatStyle::LK_ObjC, 14045 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 14046 } 14047 14048 TEST_F(FormatTest, TypenameMacros) { 14049 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 14050 14051 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 14052 FormatStyle Google = getGoogleStyleWithColumns(0); 14053 Google.TypenameMacros = TypenameMacros; 14054 verifyFormat("struct foo {\n" 14055 " int bar;\n" 14056 " TAILQ_ENTRY(a) bleh;\n" 14057 "};", Google); 14058 14059 FormatStyle Macros = getLLVMStyle(); 14060 Macros.TypenameMacros = TypenameMacros; 14061 14062 verifyFormat("STACK_OF(int) a;", Macros); 14063 verifyFormat("STACK_OF(int) *a;", Macros); 14064 verifyFormat("STACK_OF(int const *) *a;", Macros); 14065 verifyFormat("STACK_OF(int *const) *a;", Macros); 14066 verifyFormat("STACK_OF(int, string) a;", Macros); 14067 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 14068 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 14069 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 14070 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 14071 14072 Macros.PointerAlignment = FormatStyle::PAS_Left; 14073 verifyFormat("STACK_OF(int)* a;", Macros); 14074 verifyFormat("STACK_OF(int*)* a;", Macros); 14075 } 14076 14077 TEST_F(FormatTest, AmbersandInLamda) { 14078 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899 14079 FormatStyle AlignStyle = getLLVMStyle(); 14080 AlignStyle.PointerAlignment = FormatStyle::PAS_Left; 14081 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 14082 AlignStyle.PointerAlignment = FormatStyle::PAS_Right; 14083 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 14084 } 14085 14086 } // end namespace 14087 } // end namespace format 14088 } // end namespace clang 14089