1 //===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "clang/Format/Format.h" 10 11 #include "../Tooling/ReplacementTest.h" 12 #include "FormatTestUtils.h" 13 14 #include "clang/Frontend/TextDiagnosticPrinter.h" 15 #include "llvm/Support/Debug.h" 16 #include "llvm/Support/MemoryBuffer.h" 17 #include "gtest/gtest.h" 18 19 #define DEBUG_TYPE "format-test" 20 21 using clang::tooling::ReplacementTest; 22 using clang::tooling::toReplacements; 23 24 namespace clang { 25 namespace format { 26 namespace { 27 28 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); } 29 30 class FormatTest : public ::testing::Test { 31 protected: 32 enum StatusCheck { 33 SC_ExpectComplete, 34 SC_ExpectIncomplete, 35 SC_DoNotCheck 36 }; 37 38 std::string format(llvm::StringRef Code, 39 const FormatStyle &Style = getLLVMStyle(), 40 StatusCheck CheckComplete = SC_ExpectComplete) { 41 LLVM_DEBUG(llvm::errs() << "---\n"); 42 LLVM_DEBUG(llvm::errs() << Code << "\n\n"); 43 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size())); 44 FormattingAttemptStatus Status; 45 tooling::Replacements Replaces = 46 reformat(Style, Code, Ranges, "<stdin>", &Status); 47 if (CheckComplete != SC_DoNotCheck) { 48 bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete; 49 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete) 50 << Code << "\n\n"; 51 } 52 ReplacementCount = Replaces.size(); 53 auto Result = applyAllReplacements(Code, Replaces); 54 EXPECT_TRUE(static_cast<bool>(Result)); 55 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); 56 return *Result; 57 } 58 59 FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) { 60 Style.ColumnLimit = ColumnLimit; 61 return Style; 62 } 63 64 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 65 return getStyleWithColumns(getLLVMStyle(), ColumnLimit); 66 } 67 68 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) { 69 return getStyleWithColumns(getGoogleStyle(), ColumnLimit); 70 } 71 72 void verifyFormat(llvm::StringRef Expected, llvm::StringRef Code, 73 const FormatStyle &Style = getLLVMStyle()) { 74 EXPECT_EQ(Expected.str(), format(Expected, Style)) 75 << "Expected code is not stable"; 76 EXPECT_EQ(Expected.str(), format(Code, Style)); 77 if (Style.Language == FormatStyle::LK_Cpp) { 78 // Objective-C++ is a superset of C++, so everything checked for C++ 79 // needs to be checked for Objective-C++ as well. 80 FormatStyle ObjCStyle = Style; 81 ObjCStyle.Language = FormatStyle::LK_ObjC; 82 EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle)); 83 } 84 } 85 86 void verifyFormat(llvm::StringRef Code, 87 const FormatStyle &Style = getLLVMStyle()) { 88 verifyFormat(Code, test::messUp(Code), Style); 89 } 90 91 void verifyIncompleteFormat(llvm::StringRef Code, 92 const FormatStyle &Style = getLLVMStyle()) { 93 EXPECT_EQ(Code.str(), 94 format(test::messUp(Code), Style, SC_ExpectIncomplete)); 95 } 96 97 void verifyGoogleFormat(llvm::StringRef Code) { 98 verifyFormat(Code, getGoogleStyle()); 99 } 100 101 void verifyIndependentOfContext(llvm::StringRef text) { 102 verifyFormat(text); 103 verifyFormat(llvm::Twine("void f() { " + text + " }").str()); 104 } 105 106 /// \brief Verify that clang-format does not crash on the given input. 107 void verifyNoCrash(llvm::StringRef Code, 108 const FormatStyle &Style = getLLVMStyle()) { 109 format(Code, Style, SC_DoNotCheck); 110 } 111 112 int ReplacementCount; 113 }; 114 115 TEST_F(FormatTest, MessUp) { 116 EXPECT_EQ("1 2 3", test::messUp("1 2 3")); 117 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n")); 118 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc")); 119 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc")); 120 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne")); 121 } 122 123 TEST_F(FormatTest, DefaultLLVMStyleIsCpp) { 124 EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language); 125 } 126 127 TEST_F(FormatTest, LLVMStyleOverride) { 128 EXPECT_EQ(FormatStyle::LK_Proto, 129 getLLVMStyle(FormatStyle::LK_Proto).Language); 130 } 131 132 //===----------------------------------------------------------------------===// 133 // Basic function tests. 134 //===----------------------------------------------------------------------===// 135 136 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { 137 EXPECT_EQ(";", format(";")); 138 } 139 140 TEST_F(FormatTest, FormatsGlobalStatementsAt0) { 141 EXPECT_EQ("int i;", format(" int i;")); 142 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;")); 143 EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); 144 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); 145 } 146 147 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { 148 EXPECT_EQ("int i;", format("int\ni;")); 149 } 150 151 TEST_F(FormatTest, FormatsNestedBlockStatements) { 152 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}")); 153 } 154 155 TEST_F(FormatTest, FormatsNestedCall) { 156 verifyFormat("Method(f1, f2(f3));"); 157 verifyFormat("Method(f1(f2, f3()));"); 158 verifyFormat("Method(f1(f2, (f3())));"); 159 } 160 161 TEST_F(FormatTest, NestedNameSpecifiers) { 162 verifyFormat("vector<::Type> v;"); 163 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())"); 164 verifyFormat("static constexpr bool Bar = decltype(bar())::value;"); 165 verifyFormat("bool a = 2 < ::SomeFunction();"); 166 verifyFormat("ALWAYS_INLINE ::std::string getName();"); 167 verifyFormat("some::string getName();"); 168 } 169 170 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { 171 EXPECT_EQ("if (a) {\n" 172 " f();\n" 173 "}", 174 format("if(a){f();}")); 175 EXPECT_EQ(4, ReplacementCount); 176 EXPECT_EQ("if (a) {\n" 177 " f();\n" 178 "}", 179 format("if (a) {\n" 180 " f();\n" 181 "}")); 182 EXPECT_EQ(0, ReplacementCount); 183 EXPECT_EQ("/*\r\n" 184 "\r\n" 185 "*/\r\n", 186 format("/*\r\n" 187 "\r\n" 188 "*/\r\n")); 189 EXPECT_EQ(0, ReplacementCount); 190 } 191 192 TEST_F(FormatTest, RemovesEmptyLines) { 193 EXPECT_EQ("class C {\n" 194 " int i;\n" 195 "};", 196 format("class C {\n" 197 " int i;\n" 198 "\n" 199 "};")); 200 201 // Don't remove empty lines at the start of namespaces or extern "C" blocks. 202 EXPECT_EQ("namespace N {\n" 203 "\n" 204 "int i;\n" 205 "}", 206 format("namespace N {\n" 207 "\n" 208 "int i;\n" 209 "}", 210 getGoogleStyle())); 211 EXPECT_EQ("/* something */ namespace N {\n" 212 "\n" 213 "int i;\n" 214 "}", 215 format("/* something */ namespace N {\n" 216 "\n" 217 "int i;\n" 218 "}", 219 getGoogleStyle())); 220 EXPECT_EQ("inline namespace N {\n" 221 "\n" 222 "int i;\n" 223 "}", 224 format("inline namespace N {\n" 225 "\n" 226 "int i;\n" 227 "}", 228 getGoogleStyle())); 229 EXPECT_EQ("/* something */ inline namespace N {\n" 230 "\n" 231 "int i;\n" 232 "}", 233 format("/* something */ inline namespace N {\n" 234 "\n" 235 "int i;\n" 236 "}", 237 getGoogleStyle())); 238 EXPECT_EQ("export namespace N {\n" 239 "\n" 240 "int i;\n" 241 "}", 242 format("export namespace N {\n" 243 "\n" 244 "int i;\n" 245 "}", 246 getGoogleStyle())); 247 EXPECT_EQ("extern /**/ \"C\" /**/ {\n" 248 "\n" 249 "int i;\n" 250 "}", 251 format("extern /**/ \"C\" /**/ {\n" 252 "\n" 253 "int i;\n" 254 "}", 255 getGoogleStyle())); 256 257 // ...but do keep inlining and removing empty lines for non-block extern "C" 258 // functions. 259 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle()); 260 EXPECT_EQ("extern \"C\" int f() {\n" 261 " int i = 42;\n" 262 " return i;\n" 263 "}", 264 format("extern \"C\" int f() {\n" 265 "\n" 266 " int i = 42;\n" 267 " return i;\n" 268 "}", 269 getGoogleStyle())); 270 271 // Remove empty lines at the beginning and end of blocks. 272 EXPECT_EQ("void f() {\n" 273 "\n" 274 " if (a) {\n" 275 "\n" 276 " f();\n" 277 " }\n" 278 "}", 279 format("void f() {\n" 280 "\n" 281 " if (a) {\n" 282 "\n" 283 " f();\n" 284 "\n" 285 " }\n" 286 "\n" 287 "}", 288 getLLVMStyle())); 289 EXPECT_EQ("void f() {\n" 290 " if (a) {\n" 291 " f();\n" 292 " }\n" 293 "}", 294 format("void f() {\n" 295 "\n" 296 " if (a) {\n" 297 "\n" 298 " f();\n" 299 "\n" 300 " }\n" 301 "\n" 302 "}", 303 getGoogleStyle())); 304 305 // Don't remove empty lines in more complex control statements. 306 EXPECT_EQ("void f() {\n" 307 " if (a) {\n" 308 " f();\n" 309 "\n" 310 " } else if (b) {\n" 311 " f();\n" 312 " }\n" 313 "}", 314 format("void f() {\n" 315 " if (a) {\n" 316 " f();\n" 317 "\n" 318 " } else if (b) {\n" 319 " f();\n" 320 "\n" 321 " }\n" 322 "\n" 323 "}")); 324 325 // Don't remove empty lines before namespace endings. 326 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 327 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 328 EXPECT_EQ("namespace {\n" 329 "int i;\n" 330 "\n" 331 "}", 332 format("namespace {\n" 333 "int i;\n" 334 "\n" 335 "}", LLVMWithNoNamespaceFix)); 336 EXPECT_EQ("namespace {\n" 337 "int i;\n" 338 "}", 339 format("namespace {\n" 340 "int i;\n" 341 "}", LLVMWithNoNamespaceFix)); 342 EXPECT_EQ("namespace {\n" 343 "int i;\n" 344 "\n" 345 "};", 346 format("namespace {\n" 347 "int i;\n" 348 "\n" 349 "};", LLVMWithNoNamespaceFix)); 350 EXPECT_EQ("namespace {\n" 351 "int i;\n" 352 "};", 353 format("namespace {\n" 354 "int i;\n" 355 "};", LLVMWithNoNamespaceFix)); 356 EXPECT_EQ("namespace {\n" 357 "int i;\n" 358 "\n" 359 "}", 360 format("namespace {\n" 361 "int i;\n" 362 "\n" 363 "}")); 364 EXPECT_EQ("namespace {\n" 365 "int i;\n" 366 "\n" 367 "} // namespace", 368 format("namespace {\n" 369 "int i;\n" 370 "\n" 371 "} // namespace")); 372 373 FormatStyle Style = getLLVMStyle(); 374 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 375 Style.MaxEmptyLinesToKeep = 2; 376 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 377 Style.BraceWrapping.AfterClass = true; 378 Style.BraceWrapping.AfterFunction = true; 379 Style.KeepEmptyLinesAtTheStartOfBlocks = false; 380 381 EXPECT_EQ("class Foo\n" 382 "{\n" 383 " Foo() {}\n" 384 "\n" 385 " void funk() {}\n" 386 "};", 387 format("class Foo\n" 388 "{\n" 389 " Foo()\n" 390 " {\n" 391 " }\n" 392 "\n" 393 " void funk() {}\n" 394 "};", 395 Style)); 396 } 397 398 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) { 399 verifyFormat("x = (a) and (b);"); 400 verifyFormat("x = (a) or (b);"); 401 verifyFormat("x = (a) bitand (b);"); 402 verifyFormat("x = (a) bitor (b);"); 403 verifyFormat("x = (a) not_eq (b);"); 404 verifyFormat("x = (a) and_eq (b);"); 405 verifyFormat("x = (a) or_eq (b);"); 406 verifyFormat("x = (a) xor (b);"); 407 } 408 409 TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) { 410 verifyFormat("x = compl(a);"); 411 verifyFormat("x = not(a);"); 412 verifyFormat("x = bitand(a);"); 413 // Unary operator must not be merged with the next identifier 414 verifyFormat("x = compl a;"); 415 verifyFormat("x = not a;"); 416 verifyFormat("x = bitand a;"); 417 } 418 419 //===----------------------------------------------------------------------===// 420 // Tests for control statements. 421 //===----------------------------------------------------------------------===// 422 423 TEST_F(FormatTest, FormatIfWithoutCompoundStatement) { 424 verifyFormat("if (true)\n f();\ng();"); 425 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();"); 426 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();"); 427 verifyFormat("if constexpr (true)\n" 428 " f();\ng();"); 429 verifyFormat("if constexpr (a)\n" 430 " if constexpr (b)\n" 431 " if constexpr (c)\n" 432 " g();\n" 433 "h();"); 434 verifyFormat("if constexpr (a)\n" 435 " if constexpr (b) {\n" 436 " f();\n" 437 " }\n" 438 "g();"); 439 440 FormatStyle AllowsMergedIf = getLLVMStyle(); 441 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 442 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 443 FormatStyle::SIS_WithoutElse; 444 verifyFormat("if (a)\n" 445 " // comment\n" 446 " f();", 447 AllowsMergedIf); 448 verifyFormat("{\n" 449 " if (a)\n" 450 " label:\n" 451 " f();\n" 452 "}", 453 AllowsMergedIf); 454 verifyFormat("#define A \\\n" 455 " if (a) \\\n" 456 " label: \\\n" 457 " f()", 458 AllowsMergedIf); 459 verifyFormat("if (a)\n" 460 " ;", 461 AllowsMergedIf); 462 verifyFormat("if (a)\n" 463 " if (b) return;", 464 AllowsMergedIf); 465 466 verifyFormat("if (a) // Can't merge this\n" 467 " f();\n", 468 AllowsMergedIf); 469 verifyFormat("if (a) /* still don't merge */\n" 470 " f();", 471 AllowsMergedIf); 472 verifyFormat("if (a) { // Never merge this\n" 473 " f();\n" 474 "}", 475 AllowsMergedIf); 476 verifyFormat("if (a) { /* Never merge this */\n" 477 " f();\n" 478 "}", 479 AllowsMergedIf); 480 481 AllowsMergedIf.ColumnLimit = 14; 482 verifyFormat("if (a) return;", AllowsMergedIf); 483 verifyFormat("if (aaaaaaaaa)\n" 484 " return;", 485 AllowsMergedIf); 486 487 AllowsMergedIf.ColumnLimit = 13; 488 verifyFormat("if (a)\n return;", AllowsMergedIf); 489 } 490 491 TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) { 492 FormatStyle AllowsMergedIf = getLLVMStyle(); 493 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 494 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 495 FormatStyle::SIS_WithoutElse; 496 verifyFormat("if (a)\n" 497 " f();\n" 498 "else {\n" 499 " g();\n" 500 "}", 501 AllowsMergedIf); 502 verifyFormat("if (a)\n" 503 " f();\n" 504 "else\n" 505 " g();\n", 506 AllowsMergedIf); 507 508 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 509 510 verifyFormat("if (a) f();\n" 511 "else {\n" 512 " g();\n" 513 "}", 514 AllowsMergedIf); 515 verifyFormat("if (a) f();\n" 516 "else {\n" 517 " if (a) f();\n" 518 " else {\n" 519 " g();\n" 520 " }\n" 521 " g();\n" 522 "}", 523 AllowsMergedIf); 524 } 525 526 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) { 527 FormatStyle AllowsMergedLoops = getLLVMStyle(); 528 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true; 529 verifyFormat("while (true) continue;", AllowsMergedLoops); 530 verifyFormat("for (;;) continue;", AllowsMergedLoops); 531 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops); 532 verifyFormat("while (true)\n" 533 " ;", 534 AllowsMergedLoops); 535 verifyFormat("for (;;)\n" 536 " ;", 537 AllowsMergedLoops); 538 verifyFormat("for (;;)\n" 539 " for (;;) continue;", 540 AllowsMergedLoops); 541 verifyFormat("for (;;) // Can't merge this\n" 542 " continue;", 543 AllowsMergedLoops); 544 verifyFormat("for (;;) /* still don't merge */\n" 545 " continue;", 546 AllowsMergedLoops); 547 } 548 549 TEST_F(FormatTest, FormatShortBracedStatements) { 550 FormatStyle AllowSimpleBracedStatements = getLLVMStyle(); 551 AllowSimpleBracedStatements.ColumnLimit = 40; 552 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = true; 553 554 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 555 FormatStyle::SIS_WithoutElse; 556 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 557 558 AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom; 559 AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true; 560 AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false; 561 562 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 563 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 564 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 565 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 566 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 567 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 568 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 569 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 570 verifyFormat("if (true) {\n" 571 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 572 "}", 573 AllowSimpleBracedStatements); 574 verifyFormat("if (true) { //\n" 575 " f();\n" 576 "}", 577 AllowSimpleBracedStatements); 578 verifyFormat("if (true) {\n" 579 " f();\n" 580 " f();\n" 581 "}", 582 AllowSimpleBracedStatements); 583 verifyFormat("if (true) {\n" 584 " f();\n" 585 "} else {\n" 586 " f();\n" 587 "}", 588 AllowSimpleBracedStatements); 589 590 verifyFormat("struct A2 {\n" 591 " int X;\n" 592 "};", 593 AllowSimpleBracedStatements); 594 verifyFormat("typedef struct A2 {\n" 595 " int X;\n" 596 "} A2_t;", 597 AllowSimpleBracedStatements); 598 verifyFormat("template <int> struct A2 {\n" 599 " struct B {};\n" 600 "};", 601 AllowSimpleBracedStatements); 602 603 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 604 FormatStyle::SIS_Never; 605 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 606 verifyFormat("if (true) {\n" 607 " f();\n" 608 "}", 609 AllowSimpleBracedStatements); 610 verifyFormat("if (true) {\n" 611 " f();\n" 612 "} else {\n" 613 " f();\n" 614 "}", 615 AllowSimpleBracedStatements); 616 617 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 618 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 619 verifyFormat("while (true) {\n" 620 " f();\n" 621 "}", 622 AllowSimpleBracedStatements); 623 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 624 verifyFormat("for (;;) {\n" 625 " f();\n" 626 "}", 627 AllowSimpleBracedStatements); 628 629 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 630 FormatStyle::SIS_WithoutElse; 631 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 632 AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement = true; 633 634 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 635 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 636 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 637 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 638 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 639 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 640 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 641 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 642 verifyFormat("if (true)\n" 643 "{\n" 644 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 645 "}", 646 AllowSimpleBracedStatements); 647 verifyFormat("if (true)\n" 648 "{ //\n" 649 " f();\n" 650 "}", 651 AllowSimpleBracedStatements); 652 verifyFormat("if (true)\n" 653 "{\n" 654 " f();\n" 655 " f();\n" 656 "}", 657 AllowSimpleBracedStatements); 658 verifyFormat("if (true)\n" 659 "{\n" 660 " f();\n" 661 "} else\n" 662 "{\n" 663 " f();\n" 664 "}", 665 AllowSimpleBracedStatements); 666 667 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 668 FormatStyle::SIS_Never; 669 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 670 verifyFormat("if (true)\n" 671 "{\n" 672 " f();\n" 673 "}", 674 AllowSimpleBracedStatements); 675 verifyFormat("if (true)\n" 676 "{\n" 677 " f();\n" 678 "} else\n" 679 "{\n" 680 " f();\n" 681 "}", 682 AllowSimpleBracedStatements); 683 684 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 685 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 686 verifyFormat("while (true)\n" 687 "{\n" 688 " f();\n" 689 "}", 690 AllowSimpleBracedStatements); 691 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 692 verifyFormat("for (;;)\n" 693 "{\n" 694 " f();\n" 695 "}", 696 AllowSimpleBracedStatements); 697 } 698 699 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) { 700 FormatStyle Style = getLLVMStyleWithColumns(60); 701 Style.AllowShortBlocksOnASingleLine = true; 702 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 703 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 704 EXPECT_EQ("#define A \\\n" 705 " if (HANDLEwernufrnuLwrmviferuvnierv) \\\n" 706 " { RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; }\n" 707 "X;", 708 format("#define A \\\n" 709 " if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n" 710 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n" 711 " }\n" 712 "X;", 713 Style)); 714 } 715 716 TEST_F(FormatTest, ParseIfElse) { 717 verifyFormat("if (true)\n" 718 " if (true)\n" 719 " if (true)\n" 720 " f();\n" 721 " else\n" 722 " g();\n" 723 " else\n" 724 " h();\n" 725 "else\n" 726 " i();"); 727 verifyFormat("if (true)\n" 728 " if (true)\n" 729 " if (true) {\n" 730 " if (true)\n" 731 " f();\n" 732 " } else {\n" 733 " g();\n" 734 " }\n" 735 " else\n" 736 " h();\n" 737 "else {\n" 738 " i();\n" 739 "}"); 740 verifyFormat("if (true)\n" 741 " if constexpr (true)\n" 742 " if (true) {\n" 743 " if constexpr (true)\n" 744 " f();\n" 745 " } else {\n" 746 " g();\n" 747 " }\n" 748 " else\n" 749 " h();\n" 750 "else {\n" 751 " i();\n" 752 "}"); 753 verifyFormat("void f() {\n" 754 " if (a) {\n" 755 " } else {\n" 756 " }\n" 757 "}"); 758 } 759 760 TEST_F(FormatTest, ElseIf) { 761 verifyFormat("if (a) {\n} else if (b) {\n}"); 762 verifyFormat("if (a)\n" 763 " f();\n" 764 "else if (b)\n" 765 " g();\n" 766 "else\n" 767 " h();"); 768 verifyFormat("if constexpr (a)\n" 769 " f();\n" 770 "else if constexpr (b)\n" 771 " g();\n" 772 "else\n" 773 " h();"); 774 verifyFormat("if (a) {\n" 775 " f();\n" 776 "}\n" 777 "// or else ..\n" 778 "else {\n" 779 " g()\n" 780 "}"); 781 782 verifyFormat("if (a) {\n" 783 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 784 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 785 "}"); 786 verifyFormat("if (a) {\n" 787 "} else if (\n" 788 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 789 "}", 790 getLLVMStyleWithColumns(62)); 791 verifyFormat("if (a) {\n" 792 "} else if constexpr (\n" 793 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 794 "}", 795 getLLVMStyleWithColumns(62)); 796 } 797 798 TEST_F(FormatTest, FormatsForLoop) { 799 verifyFormat( 800 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 801 " ++VeryVeryLongLoopVariable)\n" 802 " ;"); 803 verifyFormat("for (;;)\n" 804 " f();"); 805 verifyFormat("for (;;) {\n}"); 806 verifyFormat("for (;;) {\n" 807 " f();\n" 808 "}"); 809 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 810 811 verifyFormat( 812 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 813 " E = UnwrappedLines.end();\n" 814 " I != E; ++I) {\n}"); 815 816 verifyFormat( 817 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 818 " ++IIIII) {\n}"); 819 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 820 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 821 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 822 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 823 " I = FD->getDeclsInPrototypeScope().begin(),\n" 824 " E = FD->getDeclsInPrototypeScope().end();\n" 825 " I != E; ++I) {\n}"); 826 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n" 827 " I = Container.begin(),\n" 828 " E = Container.end();\n" 829 " I != E; ++I) {\n}", 830 getLLVMStyleWithColumns(76)); 831 832 verifyFormat( 833 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 834 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 835 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 836 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 837 " ++aaaaaaaaaaa) {\n}"); 838 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 839 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n" 840 " ++i) {\n}"); 841 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 842 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 843 "}"); 844 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 845 " aaaaaaaaaa);\n" 846 " iter; ++iter) {\n" 847 "}"); 848 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 849 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 850 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n" 851 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {"); 852 853 // These should not be formatted as Objective-C for-in loops. 854 verifyFormat("for (Foo *x = 0; x != in; x++) {\n}"); 855 verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}"); 856 verifyFormat("Foo *x;\nfor (x in y) {\n}"); 857 verifyFormat("for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}"); 858 859 FormatStyle NoBinPacking = getLLVMStyle(); 860 NoBinPacking.BinPackParameters = false; 861 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 862 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 863 " aaaaaaaaaaaaaaaa,\n" 864 " aaaaaaaaaaaaaaaa,\n" 865 " aaaaaaaaaaaaaaaa);\n" 866 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 867 "}", 868 NoBinPacking); 869 verifyFormat( 870 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 871 " E = UnwrappedLines.end();\n" 872 " I != E;\n" 873 " ++I) {\n}", 874 NoBinPacking); 875 876 FormatStyle AlignLeft = getLLVMStyle(); 877 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 878 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft); 879 } 880 881 TEST_F(FormatTest, RangeBasedForLoops) { 882 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 883 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 884 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 885 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 886 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 887 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 888 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n" 889 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}"); 890 } 891 892 TEST_F(FormatTest, ForEachLoops) { 893 verifyFormat("void f() {\n" 894 " foreach (Item *item, itemlist) {}\n" 895 " Q_FOREACH (Item *item, itemlist) {}\n" 896 " BOOST_FOREACH (Item *item, itemlist) {}\n" 897 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 898 "}"); 899 900 // As function-like macros. 901 verifyFormat("#define foreach(x, y)\n" 902 "#define Q_FOREACH(x, y)\n" 903 "#define BOOST_FOREACH(x, y)\n" 904 "#define UNKNOWN_FOREACH(x, y)\n"); 905 906 // Not as function-like macros. 907 verifyFormat("#define foreach (x, y)\n" 908 "#define Q_FOREACH (x, y)\n" 909 "#define BOOST_FOREACH (x, y)\n" 910 "#define UNKNOWN_FOREACH (x, y)\n"); 911 } 912 913 TEST_F(FormatTest, FormatsWhileLoop) { 914 verifyFormat("while (true) {\n}"); 915 verifyFormat("while (true)\n" 916 " f();"); 917 verifyFormat("while () {\n}"); 918 verifyFormat("while () {\n" 919 " f();\n" 920 "}"); 921 } 922 923 TEST_F(FormatTest, FormatsDoWhile) { 924 verifyFormat("do {\n" 925 " do_something();\n" 926 "} while (something());"); 927 verifyFormat("do\n" 928 " do_something();\n" 929 "while (something());"); 930 } 931 932 TEST_F(FormatTest, FormatsSwitchStatement) { 933 verifyFormat("switch (x) {\n" 934 "case 1:\n" 935 " f();\n" 936 " break;\n" 937 "case kFoo:\n" 938 "case ns::kBar:\n" 939 "case kBaz:\n" 940 " break;\n" 941 "default:\n" 942 " g();\n" 943 " break;\n" 944 "}"); 945 verifyFormat("switch (x) {\n" 946 "case 1: {\n" 947 " f();\n" 948 " break;\n" 949 "}\n" 950 "case 2: {\n" 951 " break;\n" 952 "}\n" 953 "}"); 954 verifyFormat("switch (x) {\n" 955 "case 1: {\n" 956 " f();\n" 957 " {\n" 958 " g();\n" 959 " h();\n" 960 " }\n" 961 " break;\n" 962 "}\n" 963 "}"); 964 verifyFormat("switch (x) {\n" 965 "case 1: {\n" 966 " f();\n" 967 " if (foo) {\n" 968 " g();\n" 969 " h();\n" 970 " }\n" 971 " break;\n" 972 "}\n" 973 "}"); 974 verifyFormat("switch (x) {\n" 975 "case 1: {\n" 976 " f();\n" 977 " g();\n" 978 "} break;\n" 979 "}"); 980 verifyFormat("switch (test)\n" 981 " ;"); 982 verifyFormat("switch (x) {\n" 983 "default: {\n" 984 " // Do nothing.\n" 985 "}\n" 986 "}"); 987 verifyFormat("switch (x) {\n" 988 "// comment\n" 989 "// if 1, do f()\n" 990 "case 1:\n" 991 " f();\n" 992 "}"); 993 verifyFormat("switch (x) {\n" 994 "case 1:\n" 995 " // Do amazing stuff\n" 996 " {\n" 997 " f();\n" 998 " g();\n" 999 " }\n" 1000 " break;\n" 1001 "}"); 1002 verifyFormat("#define A \\\n" 1003 " switch (x) { \\\n" 1004 " case a: \\\n" 1005 " foo = b; \\\n" 1006 " }", 1007 getLLVMStyleWithColumns(20)); 1008 verifyFormat("#define OPERATION_CASE(name) \\\n" 1009 " case OP_name: \\\n" 1010 " return operations::Operation##name\n", 1011 getLLVMStyleWithColumns(40)); 1012 verifyFormat("switch (x) {\n" 1013 "case 1:;\n" 1014 "default:;\n" 1015 " int i;\n" 1016 "}"); 1017 1018 verifyGoogleFormat("switch (x) {\n" 1019 " case 1:\n" 1020 " f();\n" 1021 " break;\n" 1022 " case kFoo:\n" 1023 " case ns::kBar:\n" 1024 " case kBaz:\n" 1025 " break;\n" 1026 " default:\n" 1027 " g();\n" 1028 " break;\n" 1029 "}"); 1030 verifyGoogleFormat("switch (x) {\n" 1031 " case 1: {\n" 1032 " f();\n" 1033 " break;\n" 1034 " }\n" 1035 "}"); 1036 verifyGoogleFormat("switch (test)\n" 1037 " ;"); 1038 1039 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 1040 " case OP_name: \\\n" 1041 " return operations::Operation##name\n"); 1042 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 1043 " // Get the correction operation class.\n" 1044 " switch (OpCode) {\n" 1045 " CASE(Add);\n" 1046 " CASE(Subtract);\n" 1047 " default:\n" 1048 " return operations::Unknown;\n" 1049 " }\n" 1050 "#undef OPERATION_CASE\n" 1051 "}"); 1052 verifyFormat("DEBUG({\n" 1053 " switch (x) {\n" 1054 " case A:\n" 1055 " f();\n" 1056 " break;\n" 1057 " // fallthrough\n" 1058 " case B:\n" 1059 " g();\n" 1060 " break;\n" 1061 " }\n" 1062 "});"); 1063 EXPECT_EQ("DEBUG({\n" 1064 " switch (x) {\n" 1065 " case A:\n" 1066 " f();\n" 1067 " break;\n" 1068 " // On B:\n" 1069 " case B:\n" 1070 " g();\n" 1071 " break;\n" 1072 " }\n" 1073 "});", 1074 format("DEBUG({\n" 1075 " switch (x) {\n" 1076 " case A:\n" 1077 " f();\n" 1078 " break;\n" 1079 " // On B:\n" 1080 " case B:\n" 1081 " g();\n" 1082 " break;\n" 1083 " }\n" 1084 "});", 1085 getLLVMStyle())); 1086 EXPECT_EQ("switch (n) {\n" 1087 "case 0: {\n" 1088 " return false;\n" 1089 "}\n" 1090 "default: {\n" 1091 " return true;\n" 1092 "}\n" 1093 "}", 1094 format("switch (n)\n" 1095 "{\n" 1096 "case 0: {\n" 1097 " return false;\n" 1098 "}\n" 1099 "default: {\n" 1100 " return true;\n" 1101 "}\n" 1102 "}", 1103 getLLVMStyle())); 1104 verifyFormat("switch (a) {\n" 1105 "case (b):\n" 1106 " return;\n" 1107 "}"); 1108 1109 verifyFormat("switch (a) {\n" 1110 "case some_namespace::\n" 1111 " some_constant:\n" 1112 " return;\n" 1113 "}", 1114 getLLVMStyleWithColumns(34)); 1115 1116 FormatStyle Style = getLLVMStyle(); 1117 Style.IndentCaseLabels = true; 1118 Style.AllowShortBlocksOnASingleLine = false; 1119 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1120 Style.BraceWrapping.AfterCaseLabel = true; 1121 Style.BraceWrapping.AfterControlStatement = true; 1122 EXPECT_EQ("switch (n)\n" 1123 "{\n" 1124 " case 0:\n" 1125 " {\n" 1126 " return false;\n" 1127 " }\n" 1128 " default:\n" 1129 " {\n" 1130 " return true;\n" 1131 " }\n" 1132 "}", 1133 format("switch (n) {\n" 1134 " case 0: {\n" 1135 " return false;\n" 1136 " }\n" 1137 " default: {\n" 1138 " return true;\n" 1139 " }\n" 1140 "}", 1141 Style)); 1142 Style.BraceWrapping.AfterCaseLabel = false; 1143 EXPECT_EQ("switch (n)\n" 1144 "{\n" 1145 " case 0: {\n" 1146 " return false;\n" 1147 " }\n" 1148 " default: {\n" 1149 " return true;\n" 1150 " }\n" 1151 "}", 1152 format("switch (n) {\n" 1153 " case 0:\n" 1154 " {\n" 1155 " return false;\n" 1156 " }\n" 1157 " default:\n" 1158 " {\n" 1159 " return true;\n" 1160 " }\n" 1161 "}", 1162 Style)); 1163 } 1164 1165 TEST_F(FormatTest, CaseRanges) { 1166 verifyFormat("switch (x) {\n" 1167 "case 'A' ... 'Z':\n" 1168 "case 1 ... 5:\n" 1169 "case a ... b:\n" 1170 " break;\n" 1171 "}"); 1172 } 1173 1174 TEST_F(FormatTest, ShortCaseLabels) { 1175 FormatStyle Style = getLLVMStyle(); 1176 Style.AllowShortCaseLabelsOnASingleLine = true; 1177 verifyFormat("switch (a) {\n" 1178 "case 1: x = 1; break;\n" 1179 "case 2: return;\n" 1180 "case 3:\n" 1181 "case 4:\n" 1182 "case 5: return;\n" 1183 "case 6: // comment\n" 1184 " return;\n" 1185 "case 7:\n" 1186 " // comment\n" 1187 " return;\n" 1188 "case 8:\n" 1189 " x = 8; // comment\n" 1190 " break;\n" 1191 "default: y = 1; break;\n" 1192 "}", 1193 Style); 1194 verifyFormat("switch (a) {\n" 1195 "case 0: return; // comment\n" 1196 "case 1: break; // comment\n" 1197 "case 2: return;\n" 1198 "// comment\n" 1199 "case 3: return;\n" 1200 "// comment 1\n" 1201 "// comment 2\n" 1202 "// comment 3\n" 1203 "case 4: break; /* comment */\n" 1204 "case 5:\n" 1205 " // comment\n" 1206 " break;\n" 1207 "case 6: /* comment */ x = 1; break;\n" 1208 "case 7: x = /* comment */ 1; break;\n" 1209 "case 8:\n" 1210 " x = 1; /* comment */\n" 1211 " break;\n" 1212 "case 9:\n" 1213 " break; // comment line 1\n" 1214 " // comment line 2\n" 1215 "}", 1216 Style); 1217 EXPECT_EQ("switch (a) {\n" 1218 "case 1:\n" 1219 " x = 8;\n" 1220 " // fall through\n" 1221 "case 2: x = 8;\n" 1222 "// comment\n" 1223 "case 3:\n" 1224 " return; /* comment line 1\n" 1225 " * comment line 2 */\n" 1226 "case 4: i = 8;\n" 1227 "// something else\n" 1228 "#if FOO\n" 1229 "case 5: break;\n" 1230 "#endif\n" 1231 "}", 1232 format("switch (a) {\n" 1233 "case 1: x = 8;\n" 1234 " // fall through\n" 1235 "case 2:\n" 1236 " x = 8;\n" 1237 "// comment\n" 1238 "case 3:\n" 1239 " return; /* comment line 1\n" 1240 " * comment line 2 */\n" 1241 "case 4:\n" 1242 " i = 8;\n" 1243 "// something else\n" 1244 "#if FOO\n" 1245 "case 5: break;\n" 1246 "#endif\n" 1247 "}", 1248 Style)); 1249 EXPECT_EQ("switch (a) {\n" "case 0:\n" 1250 " return; // long long long long long long long long long long long long comment\n" 1251 " // line\n" "}", 1252 format("switch (a) {\n" 1253 "case 0: return; // long long long long long long long long long long long long comment line\n" 1254 "}", 1255 Style)); 1256 EXPECT_EQ("switch (a) {\n" 1257 "case 0:\n" 1258 " return; /* long long long long long long long long long long long long comment\n" 1259 " line */\n" 1260 "}", 1261 format("switch (a) {\n" 1262 "case 0: return; /* long long long long long long long long long long long long comment line */\n" 1263 "}", 1264 Style)); 1265 verifyFormat("switch (a) {\n" 1266 "#if FOO\n" 1267 "case 0: return 0;\n" 1268 "#endif\n" 1269 "}", 1270 Style); 1271 verifyFormat("switch (a) {\n" 1272 "case 1: {\n" 1273 "}\n" 1274 "case 2: {\n" 1275 " return;\n" 1276 "}\n" 1277 "case 3: {\n" 1278 " x = 1;\n" 1279 " return;\n" 1280 "}\n" 1281 "case 4:\n" 1282 " if (x)\n" 1283 " return;\n" 1284 "}", 1285 Style); 1286 Style.ColumnLimit = 21; 1287 verifyFormat("switch (a) {\n" 1288 "case 1: x = 1; break;\n" 1289 "case 2: return;\n" 1290 "case 3:\n" 1291 "case 4:\n" 1292 "case 5: return;\n" 1293 "default:\n" 1294 " y = 1;\n" 1295 " break;\n" 1296 "}", 1297 Style); 1298 Style.ColumnLimit = 80; 1299 Style.AllowShortCaseLabelsOnASingleLine = false; 1300 Style.IndentCaseLabels = true; 1301 EXPECT_EQ("switch (n) {\n" 1302 " default /*comments*/:\n" 1303 " return true;\n" 1304 " case 0:\n" 1305 " return false;\n" 1306 "}", 1307 format("switch (n) {\n" 1308 "default/*comments*/:\n" 1309 " return true;\n" 1310 "case 0:\n" 1311 " return false;\n" 1312 "}", 1313 Style)); 1314 Style.AllowShortCaseLabelsOnASingleLine = true; 1315 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1316 Style.BraceWrapping.AfterCaseLabel = true; 1317 Style.BraceWrapping.AfterControlStatement = true; 1318 EXPECT_EQ("switch (n)\n" 1319 "{\n" 1320 " case 0:\n" 1321 " {\n" 1322 " return false;\n" 1323 " }\n" 1324 " default:\n" 1325 " {\n" 1326 " return true;\n" 1327 " }\n" 1328 "}", 1329 format("switch (n) {\n" 1330 " case 0: {\n" 1331 " return false;\n" 1332 " }\n" 1333 " default:\n" 1334 " {\n" 1335 " return true;\n" 1336 " }\n" 1337 "}", 1338 Style)); 1339 } 1340 1341 TEST_F(FormatTest, FormatsLabels) { 1342 verifyFormat("void f() {\n" 1343 " some_code();\n" 1344 "test_label:\n" 1345 " some_other_code();\n" 1346 " {\n" 1347 " some_more_code();\n" 1348 " another_label:\n" 1349 " some_more_code();\n" 1350 " }\n" 1351 "}"); 1352 verifyFormat("{\n" 1353 " some_code();\n" 1354 "test_label:\n" 1355 " some_other_code();\n" 1356 "}"); 1357 verifyFormat("{\n" 1358 " some_code();\n" 1359 "test_label:;\n" 1360 " int i = 0;\n" 1361 "}"); 1362 } 1363 1364 //===----------------------------------------------------------------------===// 1365 // Tests for classes, namespaces, etc. 1366 //===----------------------------------------------------------------------===// 1367 1368 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1369 verifyFormat("class A {};"); 1370 } 1371 1372 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1373 verifyFormat("class A {\n" 1374 "public:\n" 1375 "public: // comment\n" 1376 "protected:\n" 1377 "private:\n" 1378 " void f() {}\n" 1379 "};"); 1380 verifyFormat("export class A {\n" 1381 "public:\n" 1382 "public: // comment\n" 1383 "protected:\n" 1384 "private:\n" 1385 " void f() {}\n" 1386 "};"); 1387 verifyGoogleFormat("class A {\n" 1388 " public:\n" 1389 " protected:\n" 1390 " private:\n" 1391 " void f() {}\n" 1392 "};"); 1393 verifyGoogleFormat("export class A {\n" 1394 " public:\n" 1395 " protected:\n" 1396 " private:\n" 1397 " void f() {}\n" 1398 "};"); 1399 verifyFormat("class A {\n" 1400 "public slots:\n" 1401 " void f1() {}\n" 1402 "public Q_SLOTS:\n" 1403 " void f2() {}\n" 1404 "protected slots:\n" 1405 " void f3() {}\n" 1406 "protected Q_SLOTS:\n" 1407 " void f4() {}\n" 1408 "private slots:\n" 1409 " void f5() {}\n" 1410 "private Q_SLOTS:\n" 1411 " void f6() {}\n" 1412 "signals:\n" 1413 " void g1();\n" 1414 "Q_SIGNALS:\n" 1415 " void g2();\n" 1416 "};"); 1417 1418 // Don't interpret 'signals' the wrong way. 1419 verifyFormat("signals.set();"); 1420 verifyFormat("for (Signals signals : f()) {\n}"); 1421 verifyFormat("{\n" 1422 " signals.set(); // This needs indentation.\n" 1423 "}"); 1424 verifyFormat("void f() {\n" 1425 "label:\n" 1426 " signals.baz();\n" 1427 "}"); 1428 } 1429 1430 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1431 EXPECT_EQ("class A {\n" 1432 "public:\n" 1433 " void f();\n" 1434 "\n" 1435 "private:\n" 1436 " void g() {}\n" 1437 " // test\n" 1438 "protected:\n" 1439 " int h;\n" 1440 "};", 1441 format("class A {\n" 1442 "public:\n" 1443 "void f();\n" 1444 "private:\n" 1445 "void g() {}\n" 1446 "// test\n" 1447 "protected:\n" 1448 "int h;\n" 1449 "};")); 1450 EXPECT_EQ("class A {\n" 1451 "protected:\n" 1452 "public:\n" 1453 " void f();\n" 1454 "};", 1455 format("class A {\n" 1456 "protected:\n" 1457 "\n" 1458 "public:\n" 1459 "\n" 1460 " void f();\n" 1461 "};")); 1462 1463 // Even ensure proper spacing inside macros. 1464 EXPECT_EQ("#define B \\\n" 1465 " class A { \\\n" 1466 " protected: \\\n" 1467 " public: \\\n" 1468 " void f(); \\\n" 1469 " };", 1470 format("#define B \\\n" 1471 " class A { \\\n" 1472 " protected: \\\n" 1473 " \\\n" 1474 " public: \\\n" 1475 " \\\n" 1476 " void f(); \\\n" 1477 " };", 1478 getGoogleStyle())); 1479 // But don't remove empty lines after macros ending in access specifiers. 1480 EXPECT_EQ("#define A private:\n" 1481 "\n" 1482 "int i;", 1483 format("#define A private:\n" 1484 "\n" 1485 "int i;")); 1486 } 1487 1488 TEST_F(FormatTest, FormatsClasses) { 1489 verifyFormat("class A : public B {};"); 1490 verifyFormat("class A : public ::B {};"); 1491 1492 verifyFormat( 1493 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1494 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1495 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1496 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1497 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1498 verifyFormat( 1499 "class A : public B, public C, public D, public E, public F {};"); 1500 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1501 " public C,\n" 1502 " public D,\n" 1503 " public E,\n" 1504 " public F,\n" 1505 " public G {};"); 1506 1507 verifyFormat("class\n" 1508 " ReallyReallyLongClassName {\n" 1509 " int i;\n" 1510 "};", 1511 getLLVMStyleWithColumns(32)); 1512 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1513 " aaaaaaaaaaaaaaaa> {};"); 1514 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1515 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1516 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1517 verifyFormat("template <class R, class C>\n" 1518 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1519 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1520 verifyFormat("class ::A::B {};"); 1521 } 1522 1523 TEST_F(FormatTest, BreakInheritanceStyle) { 1524 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1525 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1526 FormatStyle::BILS_BeforeComma; 1527 verifyFormat("class MyClass : public X {};", 1528 StyleWithInheritanceBreakBeforeComma); 1529 verifyFormat("class MyClass\n" 1530 " : public X\n" 1531 " , public Y {};", 1532 StyleWithInheritanceBreakBeforeComma); 1533 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1534 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1535 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1536 StyleWithInheritanceBreakBeforeComma); 1537 verifyFormat("struct aaaaaaaaaaaaa\n" 1538 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1539 " aaaaaaaaaaaaaaaa> {};", 1540 StyleWithInheritanceBreakBeforeComma); 1541 1542 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1543 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1544 FormatStyle::BILS_AfterColon; 1545 verifyFormat("class MyClass : public X {};", 1546 StyleWithInheritanceBreakAfterColon); 1547 verifyFormat("class MyClass : public X, public Y {};", 1548 StyleWithInheritanceBreakAfterColon); 1549 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1550 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1551 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1552 StyleWithInheritanceBreakAfterColon); 1553 verifyFormat("struct aaaaaaaaaaaaa :\n" 1554 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1555 " aaaaaaaaaaaaaaaa> {};", 1556 StyleWithInheritanceBreakAfterColon); 1557 } 1558 1559 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1560 verifyFormat("class A {\n} a, b;"); 1561 verifyFormat("struct A {\n} a, b;"); 1562 verifyFormat("union A {\n} a;"); 1563 } 1564 1565 TEST_F(FormatTest, FormatsEnum) { 1566 verifyFormat("enum {\n" 1567 " Zero,\n" 1568 " One = 1,\n" 1569 " Two = One + 1,\n" 1570 " Three = (One + Two),\n" 1571 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1572 " Five = (One, Two, Three, Four, 5)\n" 1573 "};"); 1574 verifyGoogleFormat("enum {\n" 1575 " Zero,\n" 1576 " One = 1,\n" 1577 " Two = One + 1,\n" 1578 " Three = (One + Two),\n" 1579 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1580 " Five = (One, Two, Three, Four, 5)\n" 1581 "};"); 1582 verifyFormat("enum Enum {};"); 1583 verifyFormat("enum {};"); 1584 verifyFormat("enum X E {} d;"); 1585 verifyFormat("enum __attribute__((...)) E {} d;"); 1586 verifyFormat("enum __declspec__((...)) E {} d;"); 1587 verifyFormat("enum {\n" 1588 " Bar = Foo<int, int>::value\n" 1589 "};", 1590 getLLVMStyleWithColumns(30)); 1591 1592 verifyFormat("enum ShortEnum { A, B, C };"); 1593 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1594 1595 EXPECT_EQ("enum KeepEmptyLines {\n" 1596 " ONE,\n" 1597 "\n" 1598 " TWO,\n" 1599 "\n" 1600 " THREE\n" 1601 "}", 1602 format("enum KeepEmptyLines {\n" 1603 " ONE,\n" 1604 "\n" 1605 " TWO,\n" 1606 "\n" 1607 "\n" 1608 " THREE\n" 1609 "}")); 1610 verifyFormat("enum E { // comment\n" 1611 " ONE,\n" 1612 " TWO\n" 1613 "};\n" 1614 "int i;"); 1615 // Not enums. 1616 verifyFormat("enum X f() {\n" 1617 " a();\n" 1618 " return 42;\n" 1619 "}"); 1620 verifyFormat("enum X Type::f() {\n" 1621 " a();\n" 1622 " return 42;\n" 1623 "}"); 1624 verifyFormat("enum ::X f() {\n" 1625 " a();\n" 1626 " return 42;\n" 1627 "}"); 1628 verifyFormat("enum ns::X f() {\n" 1629 " a();\n" 1630 " return 42;\n" 1631 "}"); 1632 } 1633 1634 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1635 verifyFormat("enum Type {\n" 1636 " One = 0; // These semicolons should be commas.\n" 1637 " Two = 1;\n" 1638 "};"); 1639 verifyFormat("namespace n {\n" 1640 "enum Type {\n" 1641 " One,\n" 1642 " Two, // missing };\n" 1643 " int i;\n" 1644 "}\n" 1645 "void g() {}"); 1646 } 1647 1648 TEST_F(FormatTest, FormatsEnumStruct) { 1649 verifyFormat("enum struct {\n" 1650 " Zero,\n" 1651 " One = 1,\n" 1652 " Two = One + 1,\n" 1653 " Three = (One + Two),\n" 1654 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1655 " Five = (One, Two, Three, Four, 5)\n" 1656 "};"); 1657 verifyFormat("enum struct Enum {};"); 1658 verifyFormat("enum struct {};"); 1659 verifyFormat("enum struct X E {} d;"); 1660 verifyFormat("enum struct __attribute__((...)) E {} d;"); 1661 verifyFormat("enum struct __declspec__((...)) E {} d;"); 1662 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1663 } 1664 1665 TEST_F(FormatTest, FormatsEnumClass) { 1666 verifyFormat("enum class {\n" 1667 " Zero,\n" 1668 " One = 1,\n" 1669 " Two = One + 1,\n" 1670 " Three = (One + Two),\n" 1671 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1672 " Five = (One, Two, Three, Four, 5)\n" 1673 "};"); 1674 verifyFormat("enum class Enum {};"); 1675 verifyFormat("enum class {};"); 1676 verifyFormat("enum class X E {} d;"); 1677 verifyFormat("enum class __attribute__((...)) E {} d;"); 1678 verifyFormat("enum class __declspec__((...)) E {} d;"); 1679 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 1680 } 1681 1682 TEST_F(FormatTest, FormatsEnumTypes) { 1683 verifyFormat("enum X : int {\n" 1684 " A, // Force multiple lines.\n" 1685 " B\n" 1686 "};"); 1687 verifyFormat("enum X : int { A, B };"); 1688 verifyFormat("enum X : std::uint32_t { A, B };"); 1689 } 1690 1691 TEST_F(FormatTest, FormatsTypedefEnum) { 1692 FormatStyle Style = getLLVMStyle(); 1693 Style.ColumnLimit = 40; 1694 verifyFormat("typedef enum {} EmptyEnum;"); 1695 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1696 verifyFormat("typedef enum {\n" 1697 " ZERO = 0,\n" 1698 " ONE = 1,\n" 1699 " TWO = 2,\n" 1700 " THREE = 3\n" 1701 "} LongEnum;", 1702 Style); 1703 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1704 Style.BraceWrapping.AfterEnum = true; 1705 verifyFormat("typedef enum {} EmptyEnum;"); 1706 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1707 verifyFormat("typedef enum\n" 1708 "{\n" 1709 " ZERO = 0,\n" 1710 " ONE = 1,\n" 1711 " TWO = 2,\n" 1712 " THREE = 3\n" 1713 "} LongEnum;", 1714 Style); 1715 } 1716 1717 TEST_F(FormatTest, FormatsNSEnums) { 1718 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1719 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 1720 " // Information about someDecentlyLongValue.\n" 1721 " someDecentlyLongValue,\n" 1722 " // Information about anotherDecentlyLongValue.\n" 1723 " anotherDecentlyLongValue,\n" 1724 " // Information about aThirdDecentlyLongValue.\n" 1725 " aThirdDecentlyLongValue\n" 1726 "};"); 1727 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 1728 " a = 1,\n" 1729 " b = 2,\n" 1730 " c = 3,\n" 1731 "};"); 1732 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 1733 " a = 1,\n" 1734 " b = 2,\n" 1735 " c = 3,\n" 1736 "};"); 1737 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 1738 " a = 1,\n" 1739 " b = 2,\n" 1740 " c = 3,\n" 1741 "};"); 1742 } 1743 1744 TEST_F(FormatTest, FormatsBitfields) { 1745 verifyFormat("struct Bitfields {\n" 1746 " unsigned sClass : 8;\n" 1747 " unsigned ValueKind : 2;\n" 1748 "};"); 1749 verifyFormat("struct A {\n" 1750 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 1751 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 1752 "};"); 1753 verifyFormat("struct MyStruct {\n" 1754 " uchar data;\n" 1755 " uchar : 8;\n" 1756 " uchar : 8;\n" 1757 " uchar other;\n" 1758 "};"); 1759 } 1760 1761 TEST_F(FormatTest, FormatsNamespaces) { 1762 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 1763 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 1764 1765 verifyFormat("namespace some_namespace {\n" 1766 "class A {};\n" 1767 "void f() { f(); }\n" 1768 "}", 1769 LLVMWithNoNamespaceFix); 1770 verifyFormat("/* something */ namespace some_namespace {\n" 1771 "class A {};\n" 1772 "void f() { f(); }\n" 1773 "}", 1774 LLVMWithNoNamespaceFix); 1775 verifyFormat("namespace {\n" 1776 "class A {};\n" 1777 "void f() { f(); }\n" 1778 "}", 1779 LLVMWithNoNamespaceFix); 1780 verifyFormat("/* something */ namespace {\n" 1781 "class A {};\n" 1782 "void f() { f(); }\n" 1783 "}", 1784 LLVMWithNoNamespaceFix); 1785 verifyFormat("inline namespace X {\n" 1786 "class A {};\n" 1787 "void f() { f(); }\n" 1788 "}", 1789 LLVMWithNoNamespaceFix); 1790 verifyFormat("/* something */ inline namespace X {\n" 1791 "class A {};\n" 1792 "void f() { f(); }\n" 1793 "}", 1794 LLVMWithNoNamespaceFix); 1795 verifyFormat("export namespace X {\n" 1796 "class A {};\n" 1797 "void f() { f(); }\n" 1798 "}", 1799 LLVMWithNoNamespaceFix); 1800 verifyFormat("using namespace some_namespace;\n" 1801 "class A {};\n" 1802 "void f() { f(); }", 1803 LLVMWithNoNamespaceFix); 1804 1805 // This code is more common than we thought; if we 1806 // layout this correctly the semicolon will go into 1807 // its own line, which is undesirable. 1808 verifyFormat("namespace {};", 1809 LLVMWithNoNamespaceFix); 1810 verifyFormat("namespace {\n" 1811 "class A {};\n" 1812 "};", 1813 LLVMWithNoNamespaceFix); 1814 1815 verifyFormat("namespace {\n" 1816 "int SomeVariable = 0; // comment\n" 1817 "} // namespace", 1818 LLVMWithNoNamespaceFix); 1819 EXPECT_EQ("#ifndef HEADER_GUARD\n" 1820 "#define HEADER_GUARD\n" 1821 "namespace my_namespace {\n" 1822 "int i;\n" 1823 "} // my_namespace\n" 1824 "#endif // HEADER_GUARD", 1825 format("#ifndef HEADER_GUARD\n" 1826 " #define HEADER_GUARD\n" 1827 " namespace my_namespace {\n" 1828 "int i;\n" 1829 "} // my_namespace\n" 1830 "#endif // HEADER_GUARD", 1831 LLVMWithNoNamespaceFix)); 1832 1833 EXPECT_EQ("namespace A::B {\n" 1834 "class C {};\n" 1835 "}", 1836 format("namespace A::B {\n" 1837 "class C {};\n" 1838 "}", 1839 LLVMWithNoNamespaceFix)); 1840 1841 FormatStyle Style = getLLVMStyle(); 1842 Style.NamespaceIndentation = FormatStyle::NI_All; 1843 EXPECT_EQ("namespace out {\n" 1844 " int i;\n" 1845 " namespace in {\n" 1846 " int i;\n" 1847 " } // namespace in\n" 1848 "} // namespace out", 1849 format("namespace out {\n" 1850 "int i;\n" 1851 "namespace in {\n" 1852 "int i;\n" 1853 "} // namespace in\n" 1854 "} // namespace out", 1855 Style)); 1856 1857 Style.NamespaceIndentation = FormatStyle::NI_Inner; 1858 EXPECT_EQ("namespace out {\n" 1859 "int i;\n" 1860 "namespace in {\n" 1861 " int i;\n" 1862 "} // namespace in\n" 1863 "} // namespace out", 1864 format("namespace out {\n" 1865 "int i;\n" 1866 "namespace in {\n" 1867 "int i;\n" 1868 "} // namespace in\n" 1869 "} // namespace out", 1870 Style)); 1871 } 1872 1873 TEST_F(FormatTest, FormatsCompactNamespaces) { 1874 FormatStyle Style = getLLVMStyle(); 1875 Style.CompactNamespaces = true; 1876 1877 verifyFormat("namespace A { namespace B {\n" 1878 "}} // namespace A::B", 1879 Style); 1880 1881 EXPECT_EQ("namespace out { namespace in {\n" 1882 "}} // namespace out::in", 1883 format("namespace out {\n" 1884 "namespace in {\n" 1885 "} // namespace in\n" 1886 "} // namespace out", 1887 Style)); 1888 1889 // Only namespaces which have both consecutive opening and end get compacted 1890 EXPECT_EQ("namespace out {\n" 1891 "namespace in1 {\n" 1892 "} // namespace in1\n" 1893 "namespace in2 {\n" 1894 "} // namespace in2\n" 1895 "} // namespace out", 1896 format("namespace out {\n" 1897 "namespace in1 {\n" 1898 "} // namespace in1\n" 1899 "namespace in2 {\n" 1900 "} // namespace in2\n" 1901 "} // namespace out", 1902 Style)); 1903 1904 EXPECT_EQ("namespace out {\n" 1905 "int i;\n" 1906 "namespace in {\n" 1907 "int j;\n" 1908 "} // namespace in\n" 1909 "int k;\n" 1910 "} // namespace out", 1911 format("namespace out { int i;\n" 1912 "namespace in { int j; } // namespace in\n" 1913 "int k; } // namespace out", 1914 Style)); 1915 1916 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 1917 "}}} // namespace A::B::C\n", 1918 format("namespace A { namespace B {\n" 1919 "namespace C {\n" 1920 "}} // namespace B::C\n" 1921 "} // namespace A\n", 1922 Style)); 1923 1924 Style.ColumnLimit = 40; 1925 EXPECT_EQ("namespace aaaaaaaaaa {\n" 1926 "namespace bbbbbbbbbb {\n" 1927 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 1928 format("namespace aaaaaaaaaa {\n" 1929 "namespace bbbbbbbbbb {\n" 1930 "} // namespace bbbbbbbbbb\n" 1931 "} // namespace aaaaaaaaaa", 1932 Style)); 1933 1934 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 1935 "namespace cccccc {\n" 1936 "}}} // namespace aaaaaa::bbbbbb::cccccc", 1937 format("namespace aaaaaa {\n" 1938 "namespace bbbbbb {\n" 1939 "namespace cccccc {\n" 1940 "} // namespace cccccc\n" 1941 "} // namespace bbbbbb\n" 1942 "} // namespace aaaaaa", 1943 Style)); 1944 Style.ColumnLimit = 80; 1945 1946 // Extra semicolon after 'inner' closing brace prevents merging 1947 EXPECT_EQ("namespace out { namespace in {\n" 1948 "}; } // namespace out::in", 1949 format("namespace out {\n" 1950 "namespace in {\n" 1951 "}; // namespace in\n" 1952 "} // namespace out", 1953 Style)); 1954 1955 // Extra semicolon after 'outer' closing brace is conserved 1956 EXPECT_EQ("namespace out { namespace in {\n" 1957 "}}; // namespace out::in", 1958 format("namespace out {\n" 1959 "namespace in {\n" 1960 "} // namespace in\n" 1961 "}; // namespace out", 1962 Style)); 1963 1964 Style.NamespaceIndentation = FormatStyle::NI_All; 1965 EXPECT_EQ("namespace out { namespace in {\n" 1966 " int i;\n" 1967 "}} // namespace out::in", 1968 format("namespace out {\n" 1969 "namespace in {\n" 1970 "int i;\n" 1971 "} // namespace in\n" 1972 "} // namespace out", 1973 Style)); 1974 EXPECT_EQ("namespace out { namespace mid {\n" 1975 " namespace in {\n" 1976 " int j;\n" 1977 " } // namespace in\n" 1978 " int k;\n" 1979 "}} // namespace out::mid", 1980 format("namespace out { namespace mid {\n" 1981 "namespace in { int j; } // namespace in\n" 1982 "int k; }} // namespace out::mid", 1983 Style)); 1984 1985 Style.NamespaceIndentation = FormatStyle::NI_Inner; 1986 EXPECT_EQ("namespace out { namespace in {\n" 1987 " int i;\n" 1988 "}} // namespace out::in", 1989 format("namespace out {\n" 1990 "namespace in {\n" 1991 "int i;\n" 1992 "} // namespace in\n" 1993 "} // namespace out", 1994 Style)); 1995 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 1996 " int i;\n" 1997 "}}} // namespace out::mid::in", 1998 format("namespace out {\n" 1999 "namespace mid {\n" 2000 "namespace in {\n" 2001 "int i;\n" 2002 "} // namespace in\n" 2003 "} // namespace mid\n" 2004 "} // namespace out", 2005 Style)); 2006 } 2007 2008 TEST_F(FormatTest, FormatsExternC) { 2009 verifyFormat("extern \"C\" {\nint a;"); 2010 verifyFormat("extern \"C\" {}"); 2011 verifyFormat("extern \"C\" {\n" 2012 "int foo();\n" 2013 "}"); 2014 verifyFormat("extern \"C\" int foo() {}"); 2015 verifyFormat("extern \"C\" int foo();"); 2016 verifyFormat("extern \"C\" int foo() {\n" 2017 " int i = 42;\n" 2018 " return i;\n" 2019 "}"); 2020 2021 FormatStyle Style = getLLVMStyle(); 2022 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2023 Style.BraceWrapping.AfterFunction = true; 2024 verifyFormat("extern \"C\" int foo() {}", Style); 2025 verifyFormat("extern \"C\" int foo();", Style); 2026 verifyFormat("extern \"C\" int foo()\n" 2027 "{\n" 2028 " int i = 42;\n" 2029 " return i;\n" 2030 "}", 2031 Style); 2032 2033 Style.BraceWrapping.AfterExternBlock = true; 2034 Style.BraceWrapping.SplitEmptyRecord = false; 2035 verifyFormat("extern \"C\"\n" 2036 "{}", 2037 Style); 2038 verifyFormat("extern \"C\"\n" 2039 "{\n" 2040 " int foo();\n" 2041 "}", 2042 Style); 2043 } 2044 2045 TEST_F(FormatTest, FormatsInlineASM) { 2046 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2047 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2048 verifyFormat( 2049 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2050 " \"cpuid\\n\\t\"\n" 2051 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2052 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2053 " : \"a\"(value));"); 2054 EXPECT_EQ( 2055 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2056 " __asm {\n" 2057 " mov edx,[that] // vtable in edx\n" 2058 " mov eax,methodIndex\n" 2059 " call [edx][eax*4] // stdcall\n" 2060 " }\n" 2061 "}", 2062 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2063 " __asm {\n" 2064 " mov edx,[that] // vtable in edx\n" 2065 " mov eax,methodIndex\n" 2066 " call [edx][eax*4] // stdcall\n" 2067 " }\n" 2068 "}")); 2069 EXPECT_EQ("_asm {\n" 2070 " xor eax, eax;\n" 2071 " cpuid;\n" 2072 "}", 2073 format("_asm {\n" 2074 " xor eax, eax;\n" 2075 " cpuid;\n" 2076 "}")); 2077 verifyFormat("void function() {\n" 2078 " // comment\n" 2079 " asm(\"\");\n" 2080 "}"); 2081 EXPECT_EQ("__asm {\n" 2082 "}\n" 2083 "int i;", 2084 format("__asm {\n" 2085 "}\n" 2086 "int i;")); 2087 } 2088 2089 TEST_F(FormatTest, FormatTryCatch) { 2090 verifyFormat("try {\n" 2091 " throw a * b;\n" 2092 "} catch (int a) {\n" 2093 " // Do nothing.\n" 2094 "} catch (...) {\n" 2095 " exit(42);\n" 2096 "}"); 2097 2098 // Function-level try statements. 2099 verifyFormat("int f() try { return 4; } catch (...) {\n" 2100 " return 5;\n" 2101 "}"); 2102 verifyFormat("class A {\n" 2103 " int a;\n" 2104 " A() try : a(0) {\n" 2105 " } catch (...) {\n" 2106 " throw;\n" 2107 " }\n" 2108 "};\n"); 2109 2110 // Incomplete try-catch blocks. 2111 verifyIncompleteFormat("try {} catch ("); 2112 } 2113 2114 TEST_F(FormatTest, FormatSEHTryCatch) { 2115 verifyFormat("__try {\n" 2116 " int a = b * c;\n" 2117 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2118 " // Do nothing.\n" 2119 "}"); 2120 2121 verifyFormat("__try {\n" 2122 " int a = b * c;\n" 2123 "} __finally {\n" 2124 " // Do nothing.\n" 2125 "}"); 2126 2127 verifyFormat("DEBUG({\n" 2128 " __try {\n" 2129 " } __finally {\n" 2130 " }\n" 2131 "});\n"); 2132 } 2133 2134 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2135 verifyFormat("try {\n" 2136 " f();\n" 2137 "} catch {\n" 2138 " g();\n" 2139 "}"); 2140 verifyFormat("try {\n" 2141 " f();\n" 2142 "} catch (A a) MACRO(x) {\n" 2143 " g();\n" 2144 "} catch (B b) MACRO(x) {\n" 2145 " g();\n" 2146 "}"); 2147 } 2148 2149 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2150 FormatStyle Style = getLLVMStyle(); 2151 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2152 FormatStyle::BS_WebKit}) { 2153 Style.BreakBeforeBraces = BraceStyle; 2154 verifyFormat("try {\n" 2155 " // something\n" 2156 "} catch (...) {\n" 2157 " // something\n" 2158 "}", 2159 Style); 2160 } 2161 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2162 verifyFormat("try {\n" 2163 " // something\n" 2164 "}\n" 2165 "catch (...) {\n" 2166 " // something\n" 2167 "}", 2168 Style); 2169 verifyFormat("__try {\n" 2170 " // something\n" 2171 "}\n" 2172 "__finally {\n" 2173 " // something\n" 2174 "}", 2175 Style); 2176 verifyFormat("@try {\n" 2177 " // something\n" 2178 "}\n" 2179 "@finally {\n" 2180 " // something\n" 2181 "}", 2182 Style); 2183 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2184 verifyFormat("try\n" 2185 "{\n" 2186 " // something\n" 2187 "}\n" 2188 "catch (...)\n" 2189 "{\n" 2190 " // something\n" 2191 "}", 2192 Style); 2193 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2194 verifyFormat("try\n" 2195 " {\n" 2196 " // something\n" 2197 " }\n" 2198 "catch (...)\n" 2199 " {\n" 2200 " // something\n" 2201 " }", 2202 Style); 2203 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2204 Style.BraceWrapping.BeforeCatch = true; 2205 verifyFormat("try {\n" 2206 " // something\n" 2207 "}\n" 2208 "catch (...) {\n" 2209 " // something\n" 2210 "}", 2211 Style); 2212 } 2213 2214 TEST_F(FormatTest, StaticInitializers) { 2215 verifyFormat("static SomeClass SC = {1, 'a'};"); 2216 2217 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2218 " 100000000, " 2219 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2220 2221 // Here, everything other than the "}" would fit on a line. 2222 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2223 " 10000000000000000000000000};"); 2224 EXPECT_EQ("S s = {a,\n" 2225 "\n" 2226 " b};", 2227 format("S s = {\n" 2228 " a,\n" 2229 "\n" 2230 " b\n" 2231 "};")); 2232 2233 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2234 // line. However, the formatting looks a bit off and this probably doesn't 2235 // happen often in practice. 2236 verifyFormat("static int Variable[1] = {\n" 2237 " {1000000000000000000000000000000000000}};", 2238 getLLVMStyleWithColumns(40)); 2239 } 2240 2241 TEST_F(FormatTest, DesignatedInitializers) { 2242 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2243 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2244 " .bbbbbbbbbb = 2,\n" 2245 " .cccccccccc = 3,\n" 2246 " .dddddddddd = 4,\n" 2247 " .eeeeeeeeee = 5};"); 2248 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2249 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2250 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2251 " .ccccccccccccccccccccccccccc = 3,\n" 2252 " .ddddddddddddddddddddddddddd = 4,\n" 2253 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2254 2255 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2256 2257 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2258 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2259 " [2] = bbbbbbbbbb,\n" 2260 " [3] = cccccccccc,\n" 2261 " [4] = dddddddddd,\n" 2262 " [5] = eeeeeeeeee};"); 2263 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2264 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2265 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2266 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2267 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2268 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2269 } 2270 2271 TEST_F(FormatTest, NestedStaticInitializers) { 2272 verifyFormat("static A x = {{{}}};\n"); 2273 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2274 " {init1, init2, init3, init4}}};", 2275 getLLVMStyleWithColumns(50)); 2276 2277 verifyFormat("somes Status::global_reps[3] = {\n" 2278 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2279 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2280 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2281 getLLVMStyleWithColumns(60)); 2282 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2283 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2284 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2285 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2286 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2287 " {rect.fRight - rect.fLeft, rect.fBottom - " 2288 "rect.fTop}};"); 2289 2290 verifyFormat( 2291 "SomeArrayOfSomeType a = {\n" 2292 " {{1, 2, 3},\n" 2293 " {1, 2, 3},\n" 2294 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2295 " 333333333333333333333333333333},\n" 2296 " {1, 2, 3},\n" 2297 " {1, 2, 3}}};"); 2298 verifyFormat( 2299 "SomeArrayOfSomeType a = {\n" 2300 " {{1, 2, 3}},\n" 2301 " {{1, 2, 3}},\n" 2302 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2303 " 333333333333333333333333333333}},\n" 2304 " {{1, 2, 3}},\n" 2305 " {{1, 2, 3}}};"); 2306 2307 verifyFormat("struct {\n" 2308 " unsigned bit;\n" 2309 " const char *const name;\n" 2310 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2311 " {kOsWin, \"Windows\"},\n" 2312 " {kOsLinux, \"Linux\"},\n" 2313 " {kOsCrOS, \"Chrome OS\"}};"); 2314 verifyFormat("struct {\n" 2315 " unsigned bit;\n" 2316 " const char *const name;\n" 2317 "} kBitsToOs[] = {\n" 2318 " {kOsMac, \"Mac\"},\n" 2319 " {kOsWin, \"Windows\"},\n" 2320 " {kOsLinux, \"Linux\"},\n" 2321 " {kOsCrOS, \"Chrome OS\"},\n" 2322 "};"); 2323 } 2324 2325 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2326 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2327 " \\\n" 2328 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2329 } 2330 2331 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2332 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2333 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2334 2335 // Do break defaulted and deleted functions. 2336 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2337 " default;", 2338 getLLVMStyleWithColumns(40)); 2339 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2340 " delete;", 2341 getLLVMStyleWithColumns(40)); 2342 } 2343 2344 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2345 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2346 getLLVMStyleWithColumns(40)); 2347 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2348 getLLVMStyleWithColumns(40)); 2349 EXPECT_EQ("#define Q \\\n" 2350 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2351 " \"aaaaaaaa.cpp\"", 2352 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2353 getLLVMStyleWithColumns(40))); 2354 } 2355 2356 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2357 EXPECT_EQ("# 123 \"A string literal\"", 2358 format(" # 123 \"A string literal\"")); 2359 } 2360 2361 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2362 EXPECT_EQ("#;", format("#;")); 2363 verifyFormat("#\n;\n;\n;"); 2364 } 2365 2366 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2367 EXPECT_EQ("#line 42 \"test\"\n", 2368 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2369 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2370 getLLVMStyleWithColumns(12))); 2371 } 2372 2373 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2374 EXPECT_EQ("#line 42 \"test\"", 2375 format("# \\\n line \\\n 42 \\\n \"test\"")); 2376 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2377 } 2378 2379 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2380 verifyFormat("#define A \\x20"); 2381 verifyFormat("#define A \\ x20"); 2382 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2383 verifyFormat("#define A ''"); 2384 verifyFormat("#define A ''qqq"); 2385 verifyFormat("#define A `qqq"); 2386 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2387 EXPECT_EQ("const char *c = STRINGIFY(\n" 2388 "\\na : b);", 2389 format("const char * c = STRINGIFY(\n" 2390 "\\na : b);")); 2391 2392 verifyFormat("a\r\\"); 2393 verifyFormat("a\v\\"); 2394 verifyFormat("a\f\\"); 2395 } 2396 2397 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2398 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2399 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2400 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2401 // FIXME: We never break before the macro name. 2402 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2403 2404 verifyFormat("#define A A\n#define A A"); 2405 verifyFormat("#define A(X) A\n#define A A"); 2406 2407 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2408 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2409 } 2410 2411 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2412 EXPECT_EQ("// somecomment\n" 2413 "#include \"a.h\"\n" 2414 "#define A( \\\n" 2415 " A, B)\n" 2416 "#include \"b.h\"\n" 2417 "// somecomment\n", 2418 format(" // somecomment\n" 2419 " #include \"a.h\"\n" 2420 "#define A(A,\\\n" 2421 " B)\n" 2422 " #include \"b.h\"\n" 2423 " // somecomment\n", 2424 getLLVMStyleWithColumns(13))); 2425 } 2426 2427 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2428 2429 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2430 EXPECT_EQ("#define A \\\n" 2431 " c; \\\n" 2432 " e;\n" 2433 "f;", 2434 format("#define A c; e;\n" 2435 "f;", 2436 getLLVMStyleWithColumns(14))); 2437 } 2438 2439 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2440 2441 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2442 EXPECT_EQ("int x,\n" 2443 "#define A\n" 2444 " y;", 2445 format("int x,\n#define A\ny;")); 2446 } 2447 2448 TEST_F(FormatTest, HashInMacroDefinition) { 2449 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2450 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2451 verifyFormat("#define A \\\n" 2452 " { \\\n" 2453 " f(#c); \\\n" 2454 " }", 2455 getLLVMStyleWithColumns(11)); 2456 2457 verifyFormat("#define A(X) \\\n" 2458 " void function##X()", 2459 getLLVMStyleWithColumns(22)); 2460 2461 verifyFormat("#define A(a, b, c) \\\n" 2462 " void a##b##c()", 2463 getLLVMStyleWithColumns(22)); 2464 2465 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2466 } 2467 2468 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2469 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2470 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2471 2472 FormatStyle Style = getLLVMStyle(); 2473 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 2474 verifyFormat("#define true ((foo)1)", Style); 2475 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 2476 verifyFormat("#define false((foo)0)", Style); 2477 } 2478 2479 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2480 EXPECT_EQ("#define A b;", format("#define A \\\n" 2481 " \\\n" 2482 " b;", 2483 getLLVMStyleWithColumns(25))); 2484 EXPECT_EQ("#define A \\\n" 2485 " \\\n" 2486 " a; \\\n" 2487 " b;", 2488 format("#define A \\\n" 2489 " \\\n" 2490 " a; \\\n" 2491 " b;", 2492 getLLVMStyleWithColumns(11))); 2493 EXPECT_EQ("#define A \\\n" 2494 " a; \\\n" 2495 " \\\n" 2496 " b;", 2497 format("#define A \\\n" 2498 " a; \\\n" 2499 " \\\n" 2500 " b;", 2501 getLLVMStyleWithColumns(11))); 2502 } 2503 2504 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 2505 verifyIncompleteFormat("#define A :"); 2506 verifyFormat("#define SOMECASES \\\n" 2507 " case 1: \\\n" 2508 " case 2\n", 2509 getLLVMStyleWithColumns(20)); 2510 verifyFormat("#define MACRO(a) \\\n" 2511 " if (a) \\\n" 2512 " f(); \\\n" 2513 " else \\\n" 2514 " g()", 2515 getLLVMStyleWithColumns(18)); 2516 verifyFormat("#define A template <typename T>"); 2517 verifyIncompleteFormat("#define STR(x) #x\n" 2518 "f(STR(this_is_a_string_literal{));"); 2519 verifyFormat("#pragma omp threadprivate( \\\n" 2520 " y)), // expected-warning", 2521 getLLVMStyleWithColumns(28)); 2522 verifyFormat("#d, = };"); 2523 verifyFormat("#if \"a"); 2524 verifyIncompleteFormat("({\n" 2525 "#define b \\\n" 2526 " } \\\n" 2527 " a\n" 2528 "a", 2529 getLLVMStyleWithColumns(15)); 2530 verifyFormat("#define A \\\n" 2531 " { \\\n" 2532 " {\n" 2533 "#define B \\\n" 2534 " } \\\n" 2535 " }", 2536 getLLVMStyleWithColumns(15)); 2537 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 2538 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 2539 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 2540 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 2541 } 2542 2543 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 2544 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 2545 EXPECT_EQ("class A : public QObject {\n" 2546 " Q_OBJECT\n" 2547 "\n" 2548 " A() {}\n" 2549 "};", 2550 format("class A : public QObject {\n" 2551 " Q_OBJECT\n" 2552 "\n" 2553 " A() {\n}\n" 2554 "} ;")); 2555 EXPECT_EQ("MACRO\n" 2556 "/*static*/ int i;", 2557 format("MACRO\n" 2558 " /*static*/ int i;")); 2559 EXPECT_EQ("SOME_MACRO\n" 2560 "namespace {\n" 2561 "void f();\n" 2562 "} // namespace", 2563 format("SOME_MACRO\n" 2564 " namespace {\n" 2565 "void f( );\n" 2566 "} // namespace")); 2567 // Only if the identifier contains at least 5 characters. 2568 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 2569 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 2570 // Only if everything is upper case. 2571 EXPECT_EQ("class A : public QObject {\n" 2572 " Q_Object A() {}\n" 2573 "};", 2574 format("class A : public QObject {\n" 2575 " Q_Object\n" 2576 " A() {\n}\n" 2577 "} ;")); 2578 2579 // Only if the next line can actually start an unwrapped line. 2580 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 2581 format("SOME_WEIRD_LOG_MACRO\n" 2582 "<< SomeThing;")); 2583 2584 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 2585 "(n, buffers))\n", 2586 getChromiumStyle(FormatStyle::LK_Cpp)); 2587 } 2588 2589 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 2590 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2591 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2592 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2593 "class X {};\n" 2594 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2595 "int *createScopDetectionPass() { return 0; }", 2596 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2597 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2598 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2599 " class X {};\n" 2600 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2601 " int *createScopDetectionPass() { return 0; }")); 2602 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 2603 // braces, so that inner block is indented one level more. 2604 EXPECT_EQ("int q() {\n" 2605 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2606 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2607 " IPC_END_MESSAGE_MAP()\n" 2608 "}", 2609 format("int q() {\n" 2610 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2611 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2612 " IPC_END_MESSAGE_MAP()\n" 2613 "}")); 2614 2615 // Same inside macros. 2616 EXPECT_EQ("#define LIST(L) \\\n" 2617 " L(A) \\\n" 2618 " L(B) \\\n" 2619 " L(C)", 2620 format("#define LIST(L) \\\n" 2621 " L(A) \\\n" 2622 " L(B) \\\n" 2623 " L(C)", 2624 getGoogleStyle())); 2625 2626 // These must not be recognized as macros. 2627 EXPECT_EQ("int q() {\n" 2628 " f(x);\n" 2629 " f(x) {}\n" 2630 " f(x)->g();\n" 2631 " f(x)->*g();\n" 2632 " f(x).g();\n" 2633 " f(x) = x;\n" 2634 " f(x) += x;\n" 2635 " f(x) -= x;\n" 2636 " f(x) *= x;\n" 2637 " f(x) /= x;\n" 2638 " f(x) %= x;\n" 2639 " f(x) &= x;\n" 2640 " f(x) |= x;\n" 2641 " f(x) ^= x;\n" 2642 " f(x) >>= x;\n" 2643 " f(x) <<= x;\n" 2644 " f(x)[y].z();\n" 2645 " LOG(INFO) << x;\n" 2646 " ifstream(x) >> x;\n" 2647 "}\n", 2648 format("int q() {\n" 2649 " f(x)\n;\n" 2650 " f(x)\n {}\n" 2651 " f(x)\n->g();\n" 2652 " f(x)\n->*g();\n" 2653 " f(x)\n.g();\n" 2654 " f(x)\n = x;\n" 2655 " f(x)\n += x;\n" 2656 " f(x)\n -= x;\n" 2657 " f(x)\n *= x;\n" 2658 " f(x)\n /= x;\n" 2659 " f(x)\n %= x;\n" 2660 " f(x)\n &= x;\n" 2661 " f(x)\n |= x;\n" 2662 " f(x)\n ^= x;\n" 2663 " f(x)\n >>= x;\n" 2664 " f(x)\n <<= x;\n" 2665 " f(x)\n[y].z();\n" 2666 " LOG(INFO)\n << x;\n" 2667 " ifstream(x)\n >> x;\n" 2668 "}\n")); 2669 EXPECT_EQ("int q() {\n" 2670 " F(x)\n" 2671 " if (1) {\n" 2672 " }\n" 2673 " F(x)\n" 2674 " while (1) {\n" 2675 " }\n" 2676 " F(x)\n" 2677 " G(x);\n" 2678 " F(x)\n" 2679 " try {\n" 2680 " Q();\n" 2681 " } catch (...) {\n" 2682 " }\n" 2683 "}\n", 2684 format("int q() {\n" 2685 "F(x)\n" 2686 "if (1) {}\n" 2687 "F(x)\n" 2688 "while (1) {}\n" 2689 "F(x)\n" 2690 "G(x);\n" 2691 "F(x)\n" 2692 "try { Q(); } catch (...) {}\n" 2693 "}\n")); 2694 EXPECT_EQ("class A {\n" 2695 " A() : t(0) {}\n" 2696 " A(int i) noexcept() : {}\n" 2697 " A(X x)\n" // FIXME: function-level try blocks are broken. 2698 " try : t(0) {\n" 2699 " } catch (...) {\n" 2700 " }\n" 2701 "};", 2702 format("class A {\n" 2703 " A()\n : t(0) {}\n" 2704 " A(int i)\n noexcept() : {}\n" 2705 " A(X x)\n" 2706 " try : t(0) {} catch (...) {}\n" 2707 "};")); 2708 FormatStyle Style = getLLVMStyle(); 2709 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2710 Style.BraceWrapping.AfterControlStatement = true; 2711 Style.BraceWrapping.AfterFunction = true; 2712 EXPECT_EQ("void f()\n" 2713 "try\n" 2714 "{\n" 2715 "}", 2716 format("void f() try {\n" 2717 "}", Style)); 2718 EXPECT_EQ("class SomeClass {\n" 2719 "public:\n" 2720 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2721 "};", 2722 format("class SomeClass {\n" 2723 "public:\n" 2724 " SomeClass()\n" 2725 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2726 "};")); 2727 EXPECT_EQ("class SomeClass {\n" 2728 "public:\n" 2729 " SomeClass()\n" 2730 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2731 "};", 2732 format("class SomeClass {\n" 2733 "public:\n" 2734 " SomeClass()\n" 2735 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2736 "};", 2737 getLLVMStyleWithColumns(40))); 2738 2739 verifyFormat("MACRO(>)"); 2740 2741 // Some macros contain an implicit semicolon. 2742 Style = getLLVMStyle(); 2743 Style.StatementMacros.push_back("FOO"); 2744 verifyFormat("FOO(a) int b = 0;"); 2745 verifyFormat("FOO(a)\n" 2746 "int b = 0;", 2747 Style); 2748 verifyFormat("FOO(a);\n" 2749 "int b = 0;", 2750 Style); 2751 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 2752 "int b = 0;", 2753 Style); 2754 verifyFormat("FOO()\n" 2755 "int b = 0;", 2756 Style); 2757 verifyFormat("FOO\n" 2758 "int b = 0;", 2759 Style); 2760 verifyFormat("void f() {\n" 2761 " FOO(a)\n" 2762 " return a;\n" 2763 "}", 2764 Style); 2765 verifyFormat("FOO(a)\n" 2766 "FOO(b)", 2767 Style); 2768 verifyFormat("int a = 0;\n" 2769 "FOO(b)\n" 2770 "int c = 0;", 2771 Style); 2772 verifyFormat("int a = 0;\n" 2773 "int x = FOO(a)\n" 2774 "int b = 0;", 2775 Style); 2776 verifyFormat("void foo(int a) { FOO(a) }\n" 2777 "uint32_t bar() {}", 2778 Style); 2779 } 2780 2781 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 2782 verifyFormat("#define A \\\n" 2783 " f({ \\\n" 2784 " g(); \\\n" 2785 " });", 2786 getLLVMStyleWithColumns(11)); 2787 } 2788 2789 TEST_F(FormatTest, IndentPreprocessorDirectives) { 2790 FormatStyle Style = getLLVMStyle(); 2791 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 2792 Style.ColumnLimit = 40; 2793 verifyFormat("#ifdef _WIN32\n" 2794 "#define A 0\n" 2795 "#ifdef VAR2\n" 2796 "#define B 1\n" 2797 "#include <someheader.h>\n" 2798 "#define MACRO \\\n" 2799 " some_very_long_func_aaaaaaaaaa();\n" 2800 "#endif\n" 2801 "#else\n" 2802 "#define A 1\n" 2803 "#endif", 2804 Style); 2805 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 2806 verifyFormat("#ifdef _WIN32\n" 2807 "# define A 0\n" 2808 "# ifdef VAR2\n" 2809 "# define B 1\n" 2810 "# include <someheader.h>\n" 2811 "# define MACRO \\\n" 2812 " some_very_long_func_aaaaaaaaaa();\n" 2813 "# endif\n" 2814 "#else\n" 2815 "# define A 1\n" 2816 "#endif", 2817 Style); 2818 verifyFormat("#if A\n" 2819 "# define MACRO \\\n" 2820 " void a(int x) { \\\n" 2821 " b(); \\\n" 2822 " c(); \\\n" 2823 " d(); \\\n" 2824 " e(); \\\n" 2825 " f(); \\\n" 2826 " }\n" 2827 "#endif", 2828 Style); 2829 // Comments before include guard. 2830 verifyFormat("// file comment\n" 2831 "// file comment\n" 2832 "#ifndef HEADER_H\n" 2833 "#define HEADER_H\n" 2834 "code();\n" 2835 "#endif", 2836 Style); 2837 // Test with include guards. 2838 verifyFormat("#ifndef HEADER_H\n" 2839 "#define HEADER_H\n" 2840 "code();\n" 2841 "#endif", 2842 Style); 2843 // Include guards must have a #define with the same variable immediately 2844 // after #ifndef. 2845 verifyFormat("#ifndef NOT_GUARD\n" 2846 "# define FOO\n" 2847 "code();\n" 2848 "#endif", 2849 Style); 2850 2851 // Include guards must cover the entire file. 2852 verifyFormat("code();\n" 2853 "code();\n" 2854 "#ifndef NOT_GUARD\n" 2855 "# define NOT_GUARD\n" 2856 "code();\n" 2857 "#endif", 2858 Style); 2859 verifyFormat("#ifndef NOT_GUARD\n" 2860 "# define NOT_GUARD\n" 2861 "code();\n" 2862 "#endif\n" 2863 "code();", 2864 Style); 2865 // Test with trailing blank lines. 2866 verifyFormat("#ifndef HEADER_H\n" 2867 "#define HEADER_H\n" 2868 "code();\n" 2869 "#endif\n", 2870 Style); 2871 // Include guards don't have #else. 2872 verifyFormat("#ifndef NOT_GUARD\n" 2873 "# define NOT_GUARD\n" 2874 "code();\n" 2875 "#else\n" 2876 "#endif", 2877 Style); 2878 verifyFormat("#ifndef NOT_GUARD\n" 2879 "# define NOT_GUARD\n" 2880 "code();\n" 2881 "#elif FOO\n" 2882 "#endif", 2883 Style); 2884 // Non-identifier #define after potential include guard. 2885 verifyFormat("#ifndef FOO\n" 2886 "# define 1\n" 2887 "#endif\n", 2888 Style); 2889 // #if closes past last non-preprocessor line. 2890 verifyFormat("#ifndef FOO\n" 2891 "#define FOO\n" 2892 "#if 1\n" 2893 "int i;\n" 2894 "# define A 0\n" 2895 "#endif\n" 2896 "#endif\n", 2897 Style); 2898 // FIXME: This doesn't handle the case where there's code between the 2899 // #ifndef and #define but all other conditions hold. This is because when 2900 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 2901 // previous code line yet, so we can't detect it. 2902 EXPECT_EQ("#ifndef NOT_GUARD\n" 2903 "code();\n" 2904 "#define NOT_GUARD\n" 2905 "code();\n" 2906 "#endif", 2907 format("#ifndef NOT_GUARD\n" 2908 "code();\n" 2909 "# define NOT_GUARD\n" 2910 "code();\n" 2911 "#endif", 2912 Style)); 2913 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 2914 // be outside an include guard. Examples are #pragma once and 2915 // #pragma GCC diagnostic, or anything else that does not change the meaning 2916 // of the file if it's included multiple times. 2917 EXPECT_EQ("#ifdef WIN32\n" 2918 "# pragma once\n" 2919 "#endif\n" 2920 "#ifndef HEADER_H\n" 2921 "# define HEADER_H\n" 2922 "code();\n" 2923 "#endif", 2924 format("#ifdef WIN32\n" 2925 "# pragma once\n" 2926 "#endif\n" 2927 "#ifndef HEADER_H\n" 2928 "#define HEADER_H\n" 2929 "code();\n" 2930 "#endif", 2931 Style)); 2932 // FIXME: This does not detect when there is a single non-preprocessor line 2933 // in front of an include-guard-like structure where other conditions hold 2934 // because ScopedLineState hides the line. 2935 EXPECT_EQ("code();\n" 2936 "#ifndef HEADER_H\n" 2937 "#define HEADER_H\n" 2938 "code();\n" 2939 "#endif", 2940 format("code();\n" 2941 "#ifndef HEADER_H\n" 2942 "# define HEADER_H\n" 2943 "code();\n" 2944 "#endif", 2945 Style)); 2946 // Keep comments aligned with #, otherwise indent comments normally. These 2947 // tests cannot use verifyFormat because messUp manipulates leading 2948 // whitespace. 2949 { 2950 const char *Expected = "" 2951 "void f() {\n" 2952 "#if 1\n" 2953 "// Preprocessor aligned.\n" 2954 "# define A 0\n" 2955 " // Code. Separated by blank line.\n" 2956 "\n" 2957 "# define B 0\n" 2958 " // Code. Not aligned with #\n" 2959 "# define C 0\n" 2960 "#endif"; 2961 const char *ToFormat = "" 2962 "void f() {\n" 2963 "#if 1\n" 2964 "// Preprocessor aligned.\n" 2965 "# define A 0\n" 2966 "// Code. Separated by blank line.\n" 2967 "\n" 2968 "# define B 0\n" 2969 " // Code. Not aligned with #\n" 2970 "# define C 0\n" 2971 "#endif"; 2972 EXPECT_EQ(Expected, format(ToFormat, Style)); 2973 EXPECT_EQ(Expected, format(Expected, Style)); 2974 } 2975 // Keep block quotes aligned. 2976 { 2977 const char *Expected = "" 2978 "void f() {\n" 2979 "#if 1\n" 2980 "/* Preprocessor aligned. */\n" 2981 "# define A 0\n" 2982 " /* Code. Separated by blank line. */\n" 2983 "\n" 2984 "# define B 0\n" 2985 " /* Code. Not aligned with # */\n" 2986 "# define C 0\n" 2987 "#endif"; 2988 const char *ToFormat = "" 2989 "void f() {\n" 2990 "#if 1\n" 2991 "/* Preprocessor aligned. */\n" 2992 "# define A 0\n" 2993 "/* Code. Separated by blank line. */\n" 2994 "\n" 2995 "# define B 0\n" 2996 " /* Code. Not aligned with # */\n" 2997 "# define C 0\n" 2998 "#endif"; 2999 EXPECT_EQ(Expected, format(ToFormat, Style)); 3000 EXPECT_EQ(Expected, format(Expected, Style)); 3001 } 3002 // Keep comments aligned with un-indented directives. 3003 { 3004 const char *Expected = "" 3005 "void f() {\n" 3006 "// Preprocessor aligned.\n" 3007 "#define A 0\n" 3008 " // Code. Separated by blank line.\n" 3009 "\n" 3010 "#define B 0\n" 3011 " // Code. Not aligned with #\n" 3012 "#define C 0\n"; 3013 const char *ToFormat = "" 3014 "void f() {\n" 3015 "// Preprocessor aligned.\n" 3016 "#define A 0\n" 3017 "// Code. Separated by blank line.\n" 3018 "\n" 3019 "#define B 0\n" 3020 " // Code. Not aligned with #\n" 3021 "#define C 0\n"; 3022 EXPECT_EQ(Expected, format(ToFormat, Style)); 3023 EXPECT_EQ(Expected, format(Expected, Style)); 3024 } 3025 // Test AfterHash with tabs. 3026 { 3027 FormatStyle Tabbed = Style; 3028 Tabbed.UseTab = FormatStyle::UT_Always; 3029 Tabbed.IndentWidth = 8; 3030 Tabbed.TabWidth = 8; 3031 verifyFormat("#ifdef _WIN32\n" 3032 "#\tdefine A 0\n" 3033 "#\tifdef VAR2\n" 3034 "#\t\tdefine B 1\n" 3035 "#\t\tinclude <someheader.h>\n" 3036 "#\t\tdefine MACRO \\\n" 3037 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3038 "#\tendif\n" 3039 "#else\n" 3040 "#\tdefine A 1\n" 3041 "#endif", 3042 Tabbed); 3043 } 3044 3045 // Regression test: Multiline-macro inside include guards. 3046 verifyFormat("#ifndef HEADER_H\n" 3047 "#define HEADER_H\n" 3048 "#define A() \\\n" 3049 " int i; \\\n" 3050 " int j;\n" 3051 "#endif // HEADER_H", 3052 getLLVMStyleWithColumns(20)); 3053 3054 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3055 // Basic before hash indent tests 3056 verifyFormat("#ifdef _WIN32\n" 3057 " #define A 0\n" 3058 " #ifdef VAR2\n" 3059 " #define B 1\n" 3060 " #include <someheader.h>\n" 3061 " #define MACRO \\\n" 3062 " some_very_long_func_aaaaaaaaaa();\n" 3063 " #endif\n" 3064 "#else\n" 3065 " #define A 1\n" 3066 "#endif", 3067 Style); 3068 verifyFormat("#if A\n" 3069 " #define MACRO \\\n" 3070 " void a(int x) { \\\n" 3071 " b(); \\\n" 3072 " c(); \\\n" 3073 " d(); \\\n" 3074 " e(); \\\n" 3075 " f(); \\\n" 3076 " }\n" 3077 "#endif", 3078 Style); 3079 // Keep comments aligned with indented directives. These 3080 // tests cannot use verifyFormat because messUp manipulates leading 3081 // whitespace. 3082 { 3083 const char *Expected = "void f() {\n" 3084 "// Aligned to preprocessor.\n" 3085 "#if 1\n" 3086 " // Aligned to code.\n" 3087 " int a;\n" 3088 " #if 1\n" 3089 " // Aligned to preprocessor.\n" 3090 " #define A 0\n" 3091 " // Aligned to code.\n" 3092 " int b;\n" 3093 " #endif\n" 3094 "#endif\n" 3095 "}"; 3096 const char *ToFormat = "void f() {\n" 3097 "// Aligned to preprocessor.\n" 3098 "#if 1\n" 3099 "// Aligned to code.\n" 3100 "int a;\n" 3101 "#if 1\n" 3102 "// Aligned to preprocessor.\n" 3103 "#define A 0\n" 3104 "// Aligned to code.\n" 3105 "int b;\n" 3106 "#endif\n" 3107 "#endif\n" 3108 "}"; 3109 EXPECT_EQ(Expected, format(ToFormat, Style)); 3110 EXPECT_EQ(Expected, format(Expected, Style)); 3111 } 3112 { 3113 const char *Expected = "void f() {\n" 3114 "/* Aligned to preprocessor. */\n" 3115 "#if 1\n" 3116 " /* Aligned to code. */\n" 3117 " int a;\n" 3118 " #if 1\n" 3119 " /* Aligned to preprocessor. */\n" 3120 " #define A 0\n" 3121 " /* Aligned to code. */\n" 3122 " int b;\n" 3123 " #endif\n" 3124 "#endif\n" 3125 "}"; 3126 const char *ToFormat = "void f() {\n" 3127 "/* Aligned to preprocessor. */\n" 3128 "#if 1\n" 3129 "/* Aligned to code. */\n" 3130 "int a;\n" 3131 "#if 1\n" 3132 "/* Aligned to preprocessor. */\n" 3133 "#define A 0\n" 3134 "/* Aligned to code. */\n" 3135 "int b;\n" 3136 "#endif\n" 3137 "#endif\n" 3138 "}"; 3139 EXPECT_EQ(Expected, format(ToFormat, Style)); 3140 EXPECT_EQ(Expected, format(Expected, Style)); 3141 } 3142 3143 // Test single comment before preprocessor 3144 verifyFormat("// Comment\n" 3145 "\n" 3146 "#if 1\n" 3147 "#endif", 3148 Style); 3149 } 3150 3151 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3152 verifyFormat("{\n { a #c; }\n}"); 3153 } 3154 3155 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3156 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3157 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3158 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3159 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3160 } 3161 3162 TEST_F(FormatTest, EscapedNewlines) { 3163 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3164 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3165 format("#define A \\\nint i;\\\n int j;", Narrow)); 3166 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3167 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3168 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3169 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3170 3171 FormatStyle AlignLeft = getLLVMStyle(); 3172 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3173 EXPECT_EQ("#define MACRO(x) \\\n" 3174 "private: \\\n" 3175 " int x(int a);\n", 3176 format("#define MACRO(x) \\\n" 3177 "private: \\\n" 3178 " int x(int a);\n", 3179 AlignLeft)); 3180 3181 // CRLF line endings 3182 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3183 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3184 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3185 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3186 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3187 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3188 EXPECT_EQ("#define MACRO(x) \\\r\n" 3189 "private: \\\r\n" 3190 " int x(int a);\r\n", 3191 format("#define MACRO(x) \\\r\n" 3192 "private: \\\r\n" 3193 " int x(int a);\r\n", 3194 AlignLeft)); 3195 3196 FormatStyle DontAlign = getLLVMStyle(); 3197 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3198 DontAlign.MaxEmptyLinesToKeep = 3; 3199 // FIXME: can't use verifyFormat here because the newline before 3200 // "public:" is not inserted the first time it's reformatted 3201 EXPECT_EQ("#define A \\\n" 3202 " class Foo { \\\n" 3203 " void bar(); \\\n" 3204 "\\\n" 3205 "\\\n" 3206 "\\\n" 3207 " public: \\\n" 3208 " void baz(); \\\n" 3209 " };", 3210 format("#define A \\\n" 3211 " class Foo { \\\n" 3212 " void bar(); \\\n" 3213 "\\\n" 3214 "\\\n" 3215 "\\\n" 3216 " public: \\\n" 3217 " void baz(); \\\n" 3218 " };", 3219 DontAlign)); 3220 } 3221 3222 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3223 verifyFormat("#define A \\\n" 3224 " int v( \\\n" 3225 " a); \\\n" 3226 " int i;", 3227 getLLVMStyleWithColumns(11)); 3228 } 3229 3230 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3231 EXPECT_EQ( 3232 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3233 " \\\n" 3234 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3235 "\n" 3236 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3237 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3238 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3239 "\\\n" 3240 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3241 " \n" 3242 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3243 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3244 } 3245 3246 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3247 EXPECT_EQ("int\n" 3248 "#define A\n" 3249 " a;", 3250 format("int\n#define A\na;")); 3251 verifyFormat("functionCallTo(\n" 3252 " someOtherFunction(\n" 3253 " withSomeParameters, whichInSequence,\n" 3254 " areLongerThanALine(andAnotherCall,\n" 3255 "#define A B\n" 3256 " withMoreParamters,\n" 3257 " whichStronglyInfluenceTheLayout),\n" 3258 " andMoreParameters),\n" 3259 " trailing);", 3260 getLLVMStyleWithColumns(69)); 3261 verifyFormat("Foo::Foo()\n" 3262 "#ifdef BAR\n" 3263 " : baz(0)\n" 3264 "#endif\n" 3265 "{\n" 3266 "}"); 3267 verifyFormat("void f() {\n" 3268 " if (true)\n" 3269 "#ifdef A\n" 3270 " f(42);\n" 3271 " x();\n" 3272 "#else\n" 3273 " g();\n" 3274 " x();\n" 3275 "#endif\n" 3276 "}"); 3277 verifyFormat("void f(param1, param2,\n" 3278 " param3,\n" 3279 "#ifdef A\n" 3280 " param4(param5,\n" 3281 "#ifdef A1\n" 3282 " param6,\n" 3283 "#ifdef A2\n" 3284 " param7),\n" 3285 "#else\n" 3286 " param8),\n" 3287 " param9,\n" 3288 "#endif\n" 3289 " param10,\n" 3290 "#endif\n" 3291 " param11)\n" 3292 "#else\n" 3293 " param12)\n" 3294 "#endif\n" 3295 "{\n" 3296 " x();\n" 3297 "}", 3298 getLLVMStyleWithColumns(28)); 3299 verifyFormat("#if 1\n" 3300 "int i;"); 3301 verifyFormat("#if 1\n" 3302 "#endif\n" 3303 "#if 1\n" 3304 "#else\n" 3305 "#endif\n"); 3306 verifyFormat("DEBUG({\n" 3307 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3308 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3309 "});\n" 3310 "#if a\n" 3311 "#else\n" 3312 "#endif"); 3313 3314 verifyIncompleteFormat("void f(\n" 3315 "#if A\n" 3316 ");\n" 3317 "#else\n" 3318 "#endif"); 3319 } 3320 3321 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3322 verifyFormat("#endif\n" 3323 "#if B"); 3324 } 3325 3326 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3327 FormatStyle SingleLine = getLLVMStyle(); 3328 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3329 verifyFormat("#if 0\n" 3330 "#elif 1\n" 3331 "#endif\n" 3332 "void foo() {\n" 3333 " if (test) foo2();\n" 3334 "}", 3335 SingleLine); 3336 } 3337 3338 TEST_F(FormatTest, LayoutBlockInsideParens) { 3339 verifyFormat("functionCall({ int i; });"); 3340 verifyFormat("functionCall({\n" 3341 " int i;\n" 3342 " int j;\n" 3343 "});"); 3344 verifyFormat("functionCall(\n" 3345 " {\n" 3346 " int i;\n" 3347 " int j;\n" 3348 " },\n" 3349 " aaaa, bbbb, cccc);"); 3350 verifyFormat("functionA(functionB({\n" 3351 " int i;\n" 3352 " int j;\n" 3353 " }),\n" 3354 " aaaa, bbbb, cccc);"); 3355 verifyFormat("functionCall(\n" 3356 " {\n" 3357 " int i;\n" 3358 " int j;\n" 3359 " },\n" 3360 " aaaa, bbbb, // comment\n" 3361 " cccc);"); 3362 verifyFormat("functionA(functionB({\n" 3363 " int i;\n" 3364 " int j;\n" 3365 " }),\n" 3366 " aaaa, bbbb, // comment\n" 3367 " cccc);"); 3368 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3369 verifyFormat("functionCall(aaaa, bbbb, {\n" 3370 " int i;\n" 3371 " int j;\n" 3372 "});"); 3373 verifyFormat( 3374 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3375 " {\n" 3376 " int i; // break\n" 3377 " },\n" 3378 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3379 " ccccccccccccccccc));"); 3380 verifyFormat("DEBUG({\n" 3381 " if (a)\n" 3382 " f();\n" 3383 "});"); 3384 } 3385 3386 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3387 EXPECT_EQ("SOME_MACRO { int i; }\n" 3388 "int i;", 3389 format(" SOME_MACRO {int i;} int i;")); 3390 } 3391 3392 TEST_F(FormatTest, LayoutNestedBlocks) { 3393 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3394 " struct s {\n" 3395 " int i;\n" 3396 " };\n" 3397 " s kBitsToOs[] = {{10}};\n" 3398 " for (int i = 0; i < 10; ++i)\n" 3399 " return;\n" 3400 "}"); 3401 verifyFormat("call(parameter, {\n" 3402 " something();\n" 3403 " // Comment using all columns.\n" 3404 " somethingelse();\n" 3405 "});", 3406 getLLVMStyleWithColumns(40)); 3407 verifyFormat("DEBUG( //\n" 3408 " { f(); }, a);"); 3409 verifyFormat("DEBUG( //\n" 3410 " {\n" 3411 " f(); //\n" 3412 " },\n" 3413 " a);"); 3414 3415 EXPECT_EQ("call(parameter, {\n" 3416 " something();\n" 3417 " // Comment too\n" 3418 " // looooooooooong.\n" 3419 " somethingElse();\n" 3420 "});", 3421 format("call(parameter, {\n" 3422 " something();\n" 3423 " // Comment too looooooooooong.\n" 3424 " somethingElse();\n" 3425 "});", 3426 getLLVMStyleWithColumns(29))); 3427 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3428 EXPECT_EQ("DEBUG({ // comment\n" 3429 " int i;\n" 3430 "});", 3431 format("DEBUG({ // comment\n" 3432 "int i;\n" 3433 "});")); 3434 EXPECT_EQ("DEBUG({\n" 3435 " int i;\n" 3436 "\n" 3437 " // comment\n" 3438 " int j;\n" 3439 "});", 3440 format("DEBUG({\n" 3441 " int i;\n" 3442 "\n" 3443 " // comment\n" 3444 " int j;\n" 3445 "});")); 3446 3447 verifyFormat("DEBUG({\n" 3448 " if (a)\n" 3449 " return;\n" 3450 "});"); 3451 verifyGoogleFormat("DEBUG({\n" 3452 " if (a) return;\n" 3453 "});"); 3454 FormatStyle Style = getGoogleStyle(); 3455 Style.ColumnLimit = 45; 3456 verifyFormat("Debug(\n" 3457 " aaaaa,\n" 3458 " {\n" 3459 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 3460 " },\n" 3461 " a);", 3462 Style); 3463 3464 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 3465 3466 verifyNoCrash("^{v^{a}}"); 3467 } 3468 3469 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 3470 EXPECT_EQ("#define MACRO() \\\n" 3471 " Debug(aaa, /* force line break */ \\\n" 3472 " { \\\n" 3473 " int i; \\\n" 3474 " int j; \\\n" 3475 " })", 3476 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 3477 " { int i; int j; })", 3478 getGoogleStyle())); 3479 3480 EXPECT_EQ("#define A \\\n" 3481 " [] { \\\n" 3482 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3483 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 3484 " }", 3485 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3486 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 3487 getGoogleStyle())); 3488 } 3489 3490 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 3491 EXPECT_EQ("{}", format("{}")); 3492 verifyFormat("enum E {};"); 3493 verifyFormat("enum E {}"); 3494 } 3495 3496 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 3497 FormatStyle Style = getLLVMStyle(); 3498 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 3499 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 3500 verifyFormat("FOO_BEGIN\n" 3501 " FOO_ENTRY\n" 3502 "FOO_END", Style); 3503 verifyFormat("FOO_BEGIN\n" 3504 " NESTED_FOO_BEGIN\n" 3505 " NESTED_FOO_ENTRY\n" 3506 " NESTED_FOO_END\n" 3507 "FOO_END", Style); 3508 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 3509 " int x;\n" 3510 " x = 1;\n" 3511 "FOO_END(Baz)", Style); 3512 } 3513 3514 //===----------------------------------------------------------------------===// 3515 // Line break tests. 3516 //===----------------------------------------------------------------------===// 3517 3518 TEST_F(FormatTest, PreventConfusingIndents) { 3519 verifyFormat( 3520 "void f() {\n" 3521 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 3522 " parameter, parameter, parameter)),\n" 3523 " SecondLongCall(parameter));\n" 3524 "}"); 3525 verifyFormat( 3526 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3527 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3528 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3529 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 3530 verifyFormat( 3531 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3532 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 3533 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 3534 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 3535 verifyFormat( 3536 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 3537 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 3538 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 3539 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 3540 verifyFormat("int a = bbbb && ccc &&\n" 3541 " fffff(\n" 3542 "#define A Just forcing a new line\n" 3543 " ddd);"); 3544 } 3545 3546 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 3547 verifyFormat( 3548 "bool aaaaaaa =\n" 3549 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 3550 " bbbbbbbb();"); 3551 verifyFormat( 3552 "bool aaaaaaa =\n" 3553 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 3554 " bbbbbbbb();"); 3555 3556 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3557 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 3558 " ccccccccc == ddddddddddd;"); 3559 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3560 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 3561 " ccccccccc == ddddddddddd;"); 3562 verifyFormat( 3563 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 3564 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 3565 " ccccccccc == ddddddddddd;"); 3566 3567 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3568 " aaaaaa) &&\n" 3569 " bbbbbb && cccccc;"); 3570 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3571 " aaaaaa) >>\n" 3572 " bbbbbb;"); 3573 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 3574 " SourceMgr.getSpellingColumnNumber(\n" 3575 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 3576 " 1);"); 3577 3578 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3579 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 3580 " cccccc) {\n}"); 3581 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3582 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3583 " cccccc) {\n}"); 3584 verifyFormat("b = a &&\n" 3585 " // Comment\n" 3586 " b.c && d;"); 3587 3588 // If the LHS of a comparison is not a binary expression itself, the 3589 // additional linebreak confuses many people. 3590 verifyFormat( 3591 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3592 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 3593 "}"); 3594 verifyFormat( 3595 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3596 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3597 "}"); 3598 verifyFormat( 3599 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 3600 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3601 "}"); 3602 verifyFormat( 3603 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3604 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 3605 "}"); 3606 // Even explicit parentheses stress the precedence enough to make the 3607 // additional break unnecessary. 3608 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3609 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3610 "}"); 3611 // This cases is borderline, but with the indentation it is still readable. 3612 verifyFormat( 3613 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3614 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3615 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 3616 "}", 3617 getLLVMStyleWithColumns(75)); 3618 3619 // If the LHS is a binary expression, we should still use the additional break 3620 // as otherwise the formatting hides the operator precedence. 3621 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3622 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3623 " 5) {\n" 3624 "}"); 3625 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3626 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 3627 " 5) {\n" 3628 "}"); 3629 3630 FormatStyle OnePerLine = getLLVMStyle(); 3631 OnePerLine.BinPackParameters = false; 3632 verifyFormat( 3633 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3634 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3635 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 3636 OnePerLine); 3637 3638 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 3639 " .aaa(aaaaaaaaaaaaa) *\n" 3640 " aaaaaaa +\n" 3641 " aaaaaaa;", 3642 getLLVMStyleWithColumns(40)); 3643 } 3644 3645 TEST_F(FormatTest, ExpressionIndentation) { 3646 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3647 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3648 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3649 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3650 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 3651 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 3652 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3653 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 3654 " ccccccccccccccccccccccccccccccccccccccccc;"); 3655 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3656 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3657 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3658 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3659 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3660 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3661 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3662 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3663 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3664 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3665 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3666 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3667 verifyFormat("if () {\n" 3668 "} else if (aaaaa && bbbbb > // break\n" 3669 " ccccc) {\n" 3670 "}"); 3671 verifyFormat("if () {\n" 3672 "} else if (aaaaa &&\n" 3673 " bbbbb > // break\n" 3674 " ccccc &&\n" 3675 " ddddd) {\n" 3676 "}"); 3677 3678 // Presence of a trailing comment used to change indentation of b. 3679 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 3680 " b;\n" 3681 "return aaaaaaaaaaaaaaaaaaa +\n" 3682 " b; //", 3683 getLLVMStyleWithColumns(30)); 3684 } 3685 3686 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 3687 // Not sure what the best system is here. Like this, the LHS can be found 3688 // immediately above an operator (everything with the same or a higher 3689 // indent). The RHS is aligned right of the operator and so compasses 3690 // everything until something with the same indent as the operator is found. 3691 // FIXME: Is this a good system? 3692 FormatStyle Style = getLLVMStyle(); 3693 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 3694 verifyFormat( 3695 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3696 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3697 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3698 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3699 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3700 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3701 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3702 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3703 " > ccccccccccccccccccccccccccccccccccccccccc;", 3704 Style); 3705 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3706 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3707 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3708 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3709 Style); 3710 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3711 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3712 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3713 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3714 Style); 3715 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3716 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3717 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3718 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3719 Style); 3720 verifyFormat("if () {\n" 3721 "} else if (aaaaa\n" 3722 " && bbbbb // break\n" 3723 " > ccccc) {\n" 3724 "}", 3725 Style); 3726 verifyFormat("return (a)\n" 3727 " // comment\n" 3728 " + b;", 3729 Style); 3730 verifyFormat( 3731 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3732 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3733 " + cc;", 3734 Style); 3735 3736 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3737 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 3738 Style); 3739 3740 // Forced by comments. 3741 verifyFormat( 3742 "unsigned ContentSize =\n" 3743 " sizeof(int16_t) // DWARF ARange version number\n" 3744 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 3745 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 3746 " + sizeof(int8_t); // Segment Size (in bytes)"); 3747 3748 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 3749 " == boost::fusion::at_c<1>(iiii).second;", 3750 Style); 3751 3752 Style.ColumnLimit = 60; 3753 verifyFormat("zzzzzzzzzz\n" 3754 " = bbbbbbbbbbbbbbbbb\n" 3755 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 3756 Style); 3757 3758 Style.ColumnLimit = 80; 3759 Style.IndentWidth = 4; 3760 Style.TabWidth = 4; 3761 Style.UseTab = FormatStyle::UT_Always; 3762 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 3763 Style.AlignOperands = false; 3764 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 3765 "\t&& (someOtherLongishConditionPart1\n" 3766 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 3767 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && (someOtherLongishConditionPart1 || someOtherEvenLongerNestedConditionPart2);", 3768 Style)); 3769 } 3770 3771 TEST_F(FormatTest, EnforcedOperatorWraps) { 3772 // Here we'd like to wrap after the || operators, but a comment is forcing an 3773 // earlier wrap. 3774 verifyFormat("bool x = aaaaa //\n" 3775 " || bbbbb\n" 3776 " //\n" 3777 " || cccc;"); 3778 } 3779 3780 TEST_F(FormatTest, NoOperandAlignment) { 3781 FormatStyle Style = getLLVMStyle(); 3782 Style.AlignOperands = false; 3783 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 3784 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3785 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 3786 Style); 3787 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 3788 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3789 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3790 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3791 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3792 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3793 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3794 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3795 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3796 " > ccccccccccccccccccccccccccccccccccccccccc;", 3797 Style); 3798 3799 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3800 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3801 " + cc;", 3802 Style); 3803 verifyFormat("int a = aa\n" 3804 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3805 " * cccccccccccccccccccccccccccccccccccc;\n", 3806 Style); 3807 3808 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 3809 verifyFormat("return (a > b\n" 3810 " // comment1\n" 3811 " // comment2\n" 3812 " || c);", 3813 Style); 3814 } 3815 3816 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 3817 FormatStyle Style = getLLVMStyle(); 3818 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 3819 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 3820 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3821 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 3822 Style); 3823 } 3824 3825 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 3826 FormatStyle Style = getLLVMStyle(); 3827 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 3828 Style.BinPackArguments = false; 3829 Style.ColumnLimit = 40; 3830 verifyFormat("void test() {\n" 3831 " someFunction(\n" 3832 " this + argument + is + quite\n" 3833 " + long + so + it + gets + wrapped\n" 3834 " + but + remains + bin - packed);\n" 3835 "}", 3836 Style); 3837 verifyFormat("void test() {\n" 3838 " someFunction(arg1,\n" 3839 " this + argument + is\n" 3840 " + quite + long + so\n" 3841 " + it + gets + wrapped\n" 3842 " + but + remains + bin\n" 3843 " - packed,\n" 3844 " arg3);\n" 3845 "}", 3846 Style); 3847 verifyFormat("void test() {\n" 3848 " someFunction(\n" 3849 " arg1,\n" 3850 " this + argument + has\n" 3851 " + anotherFunc(nested,\n" 3852 " calls + whose\n" 3853 " + arguments\n" 3854 " + are + also\n" 3855 " + wrapped,\n" 3856 " in + addition)\n" 3857 " + to + being + bin - packed,\n" 3858 " arg3);\n" 3859 "}", 3860 Style); 3861 3862 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 3863 verifyFormat("void test() {\n" 3864 " someFunction(\n" 3865 " arg1,\n" 3866 " this + argument + has +\n" 3867 " anotherFunc(nested,\n" 3868 " calls + whose +\n" 3869 " arguments +\n" 3870 " are + also +\n" 3871 " wrapped,\n" 3872 " in + addition) +\n" 3873 " to + being + bin - packed,\n" 3874 " arg3);\n" 3875 "}", 3876 Style); 3877 } 3878 3879 TEST_F(FormatTest, ConstructorInitializers) { 3880 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 3881 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 3882 getLLVMStyleWithColumns(45)); 3883 verifyFormat("Constructor()\n" 3884 " : Inttializer(FitsOnTheLine) {}", 3885 getLLVMStyleWithColumns(44)); 3886 verifyFormat("Constructor()\n" 3887 " : Inttializer(FitsOnTheLine) {}", 3888 getLLVMStyleWithColumns(43)); 3889 3890 verifyFormat("template <typename T>\n" 3891 "Constructor() : Initializer(FitsOnTheLine) {}", 3892 getLLVMStyleWithColumns(45)); 3893 3894 verifyFormat( 3895 "SomeClass::Constructor()\n" 3896 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 3897 3898 verifyFormat( 3899 "SomeClass::Constructor()\n" 3900 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 3901 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 3902 verifyFormat( 3903 "SomeClass::Constructor()\n" 3904 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3905 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 3906 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3907 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3908 " : aaaaaaaaaa(aaaaaa) {}"); 3909 3910 verifyFormat("Constructor()\n" 3911 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3912 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3913 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3914 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 3915 3916 verifyFormat("Constructor()\n" 3917 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3918 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 3919 3920 verifyFormat("Constructor(int Parameter = 0)\n" 3921 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 3922 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 3923 verifyFormat("Constructor()\n" 3924 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 3925 "}", 3926 getLLVMStyleWithColumns(60)); 3927 verifyFormat("Constructor()\n" 3928 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3929 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 3930 3931 // Here a line could be saved by splitting the second initializer onto two 3932 // lines, but that is not desirable. 3933 verifyFormat("Constructor()\n" 3934 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 3935 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 3936 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 3937 3938 FormatStyle OnePerLine = getLLVMStyle(); 3939 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 3940 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 3941 verifyFormat("SomeClass::Constructor()\n" 3942 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 3943 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 3944 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 3945 OnePerLine); 3946 verifyFormat("SomeClass::Constructor()\n" 3947 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 3948 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 3949 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 3950 OnePerLine); 3951 verifyFormat("MyClass::MyClass(int var)\n" 3952 " : some_var_(var), // 4 space indent\n" 3953 " some_other_var_(var + 1) { // lined up\n" 3954 "}", 3955 OnePerLine); 3956 verifyFormat("Constructor()\n" 3957 " : aaaaa(aaaaaa),\n" 3958 " aaaaa(aaaaaa),\n" 3959 " aaaaa(aaaaaa),\n" 3960 " aaaaa(aaaaaa),\n" 3961 " aaaaa(aaaaaa) {}", 3962 OnePerLine); 3963 verifyFormat("Constructor()\n" 3964 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 3965 " aaaaaaaaaaaaaaaaaaaaaa) {}", 3966 OnePerLine); 3967 OnePerLine.BinPackParameters = false; 3968 verifyFormat( 3969 "Constructor()\n" 3970 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3971 " aaaaaaaaaaa().aaa(),\n" 3972 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 3973 OnePerLine); 3974 OnePerLine.ColumnLimit = 60; 3975 verifyFormat("Constructor()\n" 3976 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 3977 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 3978 OnePerLine); 3979 3980 EXPECT_EQ("Constructor()\n" 3981 " : // Comment forcing unwanted break.\n" 3982 " aaaa(aaaa) {}", 3983 format("Constructor() :\n" 3984 " // Comment forcing unwanted break.\n" 3985 " aaaa(aaaa) {}")); 3986 } 3987 3988 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 3989 FormatStyle Style = getLLVMStyle(); 3990 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 3991 Style.ColumnLimit = 60; 3992 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 3993 Style.AllowAllConstructorInitializersOnNextLine = true; 3994 Style.BinPackParameters = false; 3995 3996 for (int i = 0; i < 4; ++i) { 3997 // Test all combinations of parameters that should not have an effect. 3998 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 3999 Style.AllowAllArgumentsOnNextLine = i & 2; 4000 4001 Style.AllowAllConstructorInitializersOnNextLine = true; 4002 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4003 verifyFormat("Constructor()\n" 4004 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4005 Style); 4006 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4007 4008 Style.AllowAllConstructorInitializersOnNextLine = false; 4009 verifyFormat("Constructor()\n" 4010 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4011 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4012 Style); 4013 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4014 4015 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4016 Style.AllowAllConstructorInitializersOnNextLine = true; 4017 verifyFormat("Constructor()\n" 4018 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4019 Style); 4020 4021 Style.AllowAllConstructorInitializersOnNextLine = false; 4022 verifyFormat("Constructor()\n" 4023 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4024 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4025 Style); 4026 4027 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4028 Style.AllowAllConstructorInitializersOnNextLine = true; 4029 verifyFormat("Constructor() :\n" 4030 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4031 Style); 4032 4033 Style.AllowAllConstructorInitializersOnNextLine = false; 4034 verifyFormat("Constructor() :\n" 4035 " aaaaaaaaaaaaaaaaaa(a),\n" 4036 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4037 Style); 4038 } 4039 4040 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4041 // AllowAllConstructorInitializersOnNextLine in all 4042 // BreakConstructorInitializers modes 4043 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4044 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4045 Style.AllowAllConstructorInitializersOnNextLine = false; 4046 verifyFormat("SomeClassWithALongName::Constructor(\n" 4047 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4048 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4049 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4050 Style); 4051 4052 Style.AllowAllConstructorInitializersOnNextLine = true; 4053 verifyFormat("SomeClassWithALongName::Constructor(\n" 4054 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4055 " int bbbbbbbbbbbbb,\n" 4056 " int cccccccccccccccc)\n" 4057 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4058 Style); 4059 4060 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4061 Style.AllowAllConstructorInitializersOnNextLine = false; 4062 verifyFormat("SomeClassWithALongName::Constructor(\n" 4063 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4064 " int bbbbbbbbbbbbb)\n" 4065 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4066 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4067 Style); 4068 4069 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4070 4071 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4072 verifyFormat("SomeClassWithALongName::Constructor(\n" 4073 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4074 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4075 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4076 Style); 4077 4078 Style.AllowAllConstructorInitializersOnNextLine = true; 4079 verifyFormat("SomeClassWithALongName::Constructor(\n" 4080 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4081 " int bbbbbbbbbbbbb,\n" 4082 " int cccccccccccccccc)\n" 4083 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4084 Style); 4085 4086 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4087 Style.AllowAllConstructorInitializersOnNextLine = false; 4088 verifyFormat("SomeClassWithALongName::Constructor(\n" 4089 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4090 " int bbbbbbbbbbbbb)\n" 4091 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4092 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4093 Style); 4094 4095 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4096 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4097 verifyFormat("SomeClassWithALongName::Constructor(\n" 4098 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4099 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4100 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4101 Style); 4102 4103 Style.AllowAllConstructorInitializersOnNextLine = true; 4104 verifyFormat("SomeClassWithALongName::Constructor(\n" 4105 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4106 " int bbbbbbbbbbbbb,\n" 4107 " int cccccccccccccccc) :\n" 4108 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4109 Style); 4110 4111 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4112 Style.AllowAllConstructorInitializersOnNextLine = false; 4113 verifyFormat("SomeClassWithALongName::Constructor(\n" 4114 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4115 " int bbbbbbbbbbbbb) :\n" 4116 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4117 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4118 Style); 4119 } 4120 4121 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4122 FormatStyle Style = getLLVMStyle(); 4123 Style.ColumnLimit = 60; 4124 Style.BinPackArguments = false; 4125 for (int i = 0; i < 4; ++i) { 4126 // Test all combinations of parameters that should not have an effect. 4127 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4128 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4129 4130 Style.AllowAllArgumentsOnNextLine = true; 4131 verifyFormat("void foo() {\n" 4132 " FunctionCallWithReallyLongName(\n" 4133 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4134 "}", 4135 Style); 4136 Style.AllowAllArgumentsOnNextLine = false; 4137 verifyFormat("void foo() {\n" 4138 " FunctionCallWithReallyLongName(\n" 4139 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4140 " bbbbbbbbbbbb);\n" 4141 "}", 4142 Style); 4143 4144 Style.AllowAllArgumentsOnNextLine = true; 4145 verifyFormat("void foo() {\n" 4146 " auto VariableWithReallyLongName = {\n" 4147 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4148 "}", 4149 Style); 4150 Style.AllowAllArgumentsOnNextLine = false; 4151 verifyFormat("void foo() {\n" 4152 " auto VariableWithReallyLongName = {\n" 4153 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4154 " bbbbbbbbbbbb};\n" 4155 "}", 4156 Style); 4157 } 4158 4159 // This parameter should not affect declarations. 4160 Style.BinPackParameters = false; 4161 Style.AllowAllArgumentsOnNextLine = false; 4162 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4163 verifyFormat("void FunctionCallWithReallyLongName(\n" 4164 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4165 Style); 4166 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4167 verifyFormat("void FunctionCallWithReallyLongName(\n" 4168 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4169 " int bbbbbbbbbbbb);", 4170 Style); 4171 } 4172 4173 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4174 FormatStyle Style = getLLVMStyle(); 4175 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4176 4177 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4178 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4179 getStyleWithColumns(Style, 45)); 4180 verifyFormat("Constructor() :\n" 4181 " Initializer(FitsOnTheLine) {}", 4182 getStyleWithColumns(Style, 44)); 4183 verifyFormat("Constructor() :\n" 4184 " Initializer(FitsOnTheLine) {}", 4185 getStyleWithColumns(Style, 43)); 4186 4187 verifyFormat("template <typename T>\n" 4188 "Constructor() : Initializer(FitsOnTheLine) {}", 4189 getStyleWithColumns(Style, 50)); 4190 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4191 verifyFormat( 4192 "SomeClass::Constructor() :\n" 4193 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4194 Style); 4195 4196 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4197 verifyFormat( 4198 "SomeClass::Constructor() :\n" 4199 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4200 Style); 4201 4202 verifyFormat( 4203 "SomeClass::Constructor() :\n" 4204 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4205 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4206 Style); 4207 verifyFormat( 4208 "SomeClass::Constructor() :\n" 4209 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4210 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4211 Style); 4212 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4213 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4214 " aaaaaaaaaa(aaaaaa) {}", 4215 Style); 4216 4217 verifyFormat("Constructor() :\n" 4218 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4219 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4220 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4221 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4222 Style); 4223 4224 verifyFormat("Constructor() :\n" 4225 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4226 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4227 Style); 4228 4229 verifyFormat("Constructor(int Parameter = 0) :\n" 4230 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4231 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4232 Style); 4233 verifyFormat("Constructor() :\n" 4234 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4235 "}", 4236 getStyleWithColumns(Style, 60)); 4237 verifyFormat("Constructor() :\n" 4238 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4239 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4240 Style); 4241 4242 // Here a line could be saved by splitting the second initializer onto two 4243 // lines, but that is not desirable. 4244 verifyFormat("Constructor() :\n" 4245 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4246 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4247 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4248 Style); 4249 4250 FormatStyle OnePerLine = Style; 4251 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4252 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4253 verifyFormat("SomeClass::Constructor() :\n" 4254 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4255 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4256 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4257 OnePerLine); 4258 verifyFormat("SomeClass::Constructor() :\n" 4259 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4260 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4261 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4262 OnePerLine); 4263 verifyFormat("MyClass::MyClass(int var) :\n" 4264 " some_var_(var), // 4 space indent\n" 4265 " some_other_var_(var + 1) { // lined up\n" 4266 "}", 4267 OnePerLine); 4268 verifyFormat("Constructor() :\n" 4269 " aaaaa(aaaaaa),\n" 4270 " aaaaa(aaaaaa),\n" 4271 " aaaaa(aaaaaa),\n" 4272 " aaaaa(aaaaaa),\n" 4273 " aaaaa(aaaaaa) {}", 4274 OnePerLine); 4275 verifyFormat("Constructor() :\n" 4276 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4277 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4278 OnePerLine); 4279 OnePerLine.BinPackParameters = false; 4280 verifyFormat( 4281 "Constructor() :\n" 4282 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4283 " aaaaaaaaaaa().aaa(),\n" 4284 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4285 OnePerLine); 4286 OnePerLine.ColumnLimit = 60; 4287 verifyFormat("Constructor() :\n" 4288 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4289 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4290 OnePerLine); 4291 4292 EXPECT_EQ("Constructor() :\n" 4293 " // Comment forcing unwanted break.\n" 4294 " aaaa(aaaa) {}", 4295 format("Constructor() :\n" 4296 " // Comment forcing unwanted break.\n" 4297 " aaaa(aaaa) {}", 4298 Style)); 4299 4300 Style.ColumnLimit = 0; 4301 verifyFormat("SomeClass::Constructor() :\n" 4302 " a(a) {}", 4303 Style); 4304 verifyFormat("SomeClass::Constructor() noexcept :\n" 4305 " a(a) {}", 4306 Style); 4307 verifyFormat("SomeClass::Constructor() :\n" 4308 " a(a), b(b), c(c) {}", 4309 Style); 4310 verifyFormat("SomeClass::Constructor() :\n" 4311 " a(a) {\n" 4312 " foo();\n" 4313 " bar();\n" 4314 "}", 4315 Style); 4316 4317 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4318 verifyFormat("SomeClass::Constructor() :\n" 4319 " a(a), b(b), c(c) {\n" 4320 "}", 4321 Style); 4322 verifyFormat("SomeClass::Constructor() :\n" 4323 " a(a) {\n" 4324 "}", 4325 Style); 4326 4327 Style.ColumnLimit = 80; 4328 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4329 Style.ConstructorInitializerIndentWidth = 2; 4330 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", 4331 Style); 4332 verifyFormat("SomeClass::Constructor() :\n" 4333 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4334 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 4335 Style); 4336 4337 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as well 4338 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 4339 verifyFormat("class SomeClass\n" 4340 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4341 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4342 Style); 4343 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 4344 verifyFormat("class SomeClass\n" 4345 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4346 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4347 Style); 4348 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 4349 verifyFormat("class SomeClass :\n" 4350 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4351 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4352 Style); 4353 } 4354 4355 #ifndef EXPENSIVE_CHECKS 4356 // Expensive checks enables libstdc++ checking which includes validating the 4357 // state of ranges used in std::priority_queue - this blows out the 4358 // runtime/scalability of the function and makes this test unacceptably slow. 4359 TEST_F(FormatTest, MemoizationTests) { 4360 // This breaks if the memoization lookup does not take \c Indent and 4361 // \c LastSpace into account. 4362 verifyFormat( 4363 "extern CFRunLoopTimerRef\n" 4364 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 4365 " CFTimeInterval interval, CFOptionFlags flags,\n" 4366 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 4367 " CFRunLoopTimerContext *context) {}"); 4368 4369 // Deep nesting somewhat works around our memoization. 4370 verifyFormat( 4371 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4372 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4373 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4374 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4375 " aaaaa())))))))))))))))))))))))))))))))))))))));", 4376 getLLVMStyleWithColumns(65)); 4377 verifyFormat( 4378 "aaaaa(\n" 4379 " aaaaa,\n" 4380 " aaaaa(\n" 4381 " aaaaa,\n" 4382 " aaaaa(\n" 4383 " aaaaa,\n" 4384 " aaaaa(\n" 4385 " aaaaa,\n" 4386 " aaaaa(\n" 4387 " aaaaa,\n" 4388 " aaaaa(\n" 4389 " aaaaa,\n" 4390 " aaaaa(\n" 4391 " aaaaa,\n" 4392 " aaaaa(\n" 4393 " aaaaa,\n" 4394 " aaaaa(\n" 4395 " aaaaa,\n" 4396 " aaaaa(\n" 4397 " aaaaa,\n" 4398 " aaaaa(\n" 4399 " aaaaa,\n" 4400 " aaaaa(\n" 4401 " aaaaa,\n" 4402 " aaaaa))))))))))));", 4403 getLLVMStyleWithColumns(65)); 4404 verifyFormat( 4405 "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" 4406 " a),\n" 4407 " a),\n" 4408 " a),\n" 4409 " a),\n" 4410 " a),\n" 4411 " a),\n" 4412 " a),\n" 4413 " a),\n" 4414 " a),\n" 4415 " a),\n" 4416 " a),\n" 4417 " a),\n" 4418 " a),\n" 4419 " a),\n" 4420 " a),\n" 4421 " a),\n" 4422 " a)", 4423 getLLVMStyleWithColumns(65)); 4424 4425 // This test takes VERY long when memoization is broken. 4426 FormatStyle OnePerLine = getLLVMStyle(); 4427 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4428 OnePerLine.BinPackParameters = false; 4429 std::string input = "Constructor()\n" 4430 " : aaaa(a,\n"; 4431 for (unsigned i = 0, e = 80; i != e; ++i) { 4432 input += " a,\n"; 4433 } 4434 input += " a) {}"; 4435 verifyFormat(input, OnePerLine); 4436 } 4437 #endif 4438 4439 TEST_F(FormatTest, BreaksAsHighAsPossible) { 4440 verifyFormat( 4441 "void f() {\n" 4442 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 4443 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 4444 " f();\n" 4445 "}"); 4446 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 4447 " Intervals[i - 1].getRange().getLast()) {\n}"); 4448 } 4449 4450 TEST_F(FormatTest, BreaksFunctionDeclarations) { 4451 // Principially, we break function declarations in a certain order: 4452 // 1) break amongst arguments. 4453 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 4454 " Cccccccccccccc cccccccccccccc);"); 4455 verifyFormat("template <class TemplateIt>\n" 4456 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 4457 " TemplateIt *stop) {}"); 4458 4459 // 2) break after return type. 4460 verifyFormat( 4461 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4462 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 4463 getGoogleStyle()); 4464 4465 // 3) break after (. 4466 verifyFormat( 4467 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 4468 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 4469 getGoogleStyle()); 4470 4471 // 4) break before after nested name specifiers. 4472 verifyFormat( 4473 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4474 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 4475 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 4476 getGoogleStyle()); 4477 4478 // However, there are exceptions, if a sufficient amount of lines can be 4479 // saved. 4480 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 4481 // more adjusting. 4482 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4483 " Cccccccccccccc cccccccccc,\n" 4484 " Cccccccccccccc cccccccccc,\n" 4485 " Cccccccccccccc cccccccccc,\n" 4486 " Cccccccccccccc cccccccccc);"); 4487 verifyFormat( 4488 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4489 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4490 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4491 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 4492 getGoogleStyle()); 4493 verifyFormat( 4494 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4495 " Cccccccccccccc cccccccccc,\n" 4496 " Cccccccccccccc cccccccccc,\n" 4497 " Cccccccccccccc cccccccccc,\n" 4498 " Cccccccccccccc cccccccccc,\n" 4499 " Cccccccccccccc cccccccccc,\n" 4500 " Cccccccccccccc cccccccccc);"); 4501 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4502 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4503 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4504 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4505 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 4506 4507 // Break after multi-line parameters. 4508 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4509 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4510 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4511 " bbbb bbbb);"); 4512 verifyFormat("void SomeLoooooooooooongFunction(\n" 4513 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 4514 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4515 " int bbbbbbbbbbbbb);"); 4516 4517 // Treat overloaded operators like other functions. 4518 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4519 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 4520 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4521 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 4522 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4523 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 4524 verifyGoogleFormat( 4525 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 4526 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4527 verifyGoogleFormat( 4528 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 4529 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4530 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4531 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4532 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 4533 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4534 verifyGoogleFormat( 4535 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 4536 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4537 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 4538 verifyGoogleFormat( 4539 "template <typename T>\n" 4540 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4541 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 4542 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 4543 4544 FormatStyle Style = getLLVMStyle(); 4545 Style.PointerAlignment = FormatStyle::PAS_Left; 4546 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4547 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 4548 Style); 4549 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 4550 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4551 Style); 4552 } 4553 4554 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 4555 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 4556 // Prefer keeping `::` followed by `operator` together. 4557 EXPECT_EQ("const aaaa::bbbbbbb &\n" 4558 "ccccccccc::operator++() {\n" 4559 " stuff();\n" 4560 "}", 4561 format("const aaaa::bbbbbbb\n" 4562 "&ccccccccc::operator++() { stuff(); }", 4563 getLLVMStyleWithColumns(40))); 4564 } 4565 4566 TEST_F(FormatTest, TrailingReturnType) { 4567 verifyFormat("auto foo() -> int;\n"); 4568 verifyFormat("struct S {\n" 4569 " auto bar() const -> int;\n" 4570 "};"); 4571 verifyFormat("template <size_t Order, typename T>\n" 4572 "auto load_img(const std::string &filename)\n" 4573 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 4574 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 4575 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 4576 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 4577 verifyFormat("template <typename T>\n" 4578 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 4579 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 4580 4581 // Not trailing return types. 4582 verifyFormat("void f() { auto a = b->c(); }"); 4583 } 4584 4585 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 4586 // Avoid breaking before trailing 'const' or other trailing annotations, if 4587 // they are not function-like. 4588 FormatStyle Style = getGoogleStyle(); 4589 Style.ColumnLimit = 47; 4590 verifyFormat("void someLongFunction(\n" 4591 " int someLoooooooooooooongParameter) const {\n}", 4592 getLLVMStyleWithColumns(47)); 4593 verifyFormat("LoooooongReturnType\n" 4594 "someLoooooooongFunction() const {}", 4595 getLLVMStyleWithColumns(47)); 4596 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 4597 " const {}", 4598 Style); 4599 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4600 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 4601 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4602 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 4603 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4604 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 4605 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 4606 " aaaaaaaaaaa aaaaa) const override;"); 4607 verifyGoogleFormat( 4608 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4609 " const override;"); 4610 4611 // Even if the first parameter has to be wrapped. 4612 verifyFormat("void someLongFunction(\n" 4613 " int someLongParameter) const {}", 4614 getLLVMStyleWithColumns(46)); 4615 verifyFormat("void someLongFunction(\n" 4616 " int someLongParameter) const {}", 4617 Style); 4618 verifyFormat("void someLongFunction(\n" 4619 " int someLongParameter) override {}", 4620 Style); 4621 verifyFormat("void someLongFunction(\n" 4622 " int someLongParameter) OVERRIDE {}", 4623 Style); 4624 verifyFormat("void someLongFunction(\n" 4625 " int someLongParameter) final {}", 4626 Style); 4627 verifyFormat("void someLongFunction(\n" 4628 " int someLongParameter) FINAL {}", 4629 Style); 4630 verifyFormat("void someLongFunction(\n" 4631 " int parameter) const override {}", 4632 Style); 4633 4634 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 4635 verifyFormat("void someLongFunction(\n" 4636 " int someLongParameter) const\n" 4637 "{\n" 4638 "}", 4639 Style); 4640 4641 // Unless these are unknown annotations. 4642 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 4643 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4644 " LONG_AND_UGLY_ANNOTATION;"); 4645 4646 // Breaking before function-like trailing annotations is fine to keep them 4647 // close to their arguments. 4648 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4649 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 4650 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 4651 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 4652 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 4653 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 4654 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 4655 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 4656 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 4657 4658 verifyFormat( 4659 "void aaaaaaaaaaaaaaaaaa()\n" 4660 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 4661 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 4662 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4663 " __attribute__((unused));"); 4664 verifyGoogleFormat( 4665 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4666 " GUARDED_BY(aaaaaaaaaaaa);"); 4667 verifyGoogleFormat( 4668 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4669 " GUARDED_BY(aaaaaaaaaaaa);"); 4670 verifyGoogleFormat( 4671 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 4672 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4673 verifyGoogleFormat( 4674 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 4675 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 4676 } 4677 4678 TEST_F(FormatTest, FunctionAnnotations) { 4679 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4680 "int OldFunction(const string ¶meter) {}"); 4681 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4682 "string OldFunction(const string ¶meter) {}"); 4683 verifyFormat("template <typename T>\n" 4684 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4685 "string OldFunction(const string ¶meter) {}"); 4686 4687 // Not function annotations. 4688 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4689 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 4690 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 4691 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 4692 verifyFormat("MACRO(abc).function() // wrap\n" 4693 " << abc;"); 4694 verifyFormat("MACRO(abc)->function() // wrap\n" 4695 " << abc;"); 4696 verifyFormat("MACRO(abc)::function() // wrap\n" 4697 " << abc;"); 4698 } 4699 4700 TEST_F(FormatTest, BreaksDesireably) { 4701 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 4702 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 4703 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 4704 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4705 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 4706 "}"); 4707 4708 verifyFormat( 4709 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4710 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4711 4712 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4713 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4714 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4715 4716 verifyFormat( 4717 "aaaaaaaa(aaaaaaaaaaaaa,\n" 4718 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4719 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 4720 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4721 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 4722 4723 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4724 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4725 4726 verifyFormat( 4727 "void f() {\n" 4728 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 4729 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 4730 "}"); 4731 verifyFormat( 4732 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4733 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4734 verifyFormat( 4735 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4736 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4737 verifyFormat( 4738 "aaaaaa(aaa,\n" 4739 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4740 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4741 " aaaa);"); 4742 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4743 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4744 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4745 4746 // Indent consistently independent of call expression and unary operator. 4747 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4748 " dddddddddddddddddddddddddddddd));"); 4749 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4750 " dddddddddddddddddddddddddddddd));"); 4751 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 4752 " dddddddddddddddddddddddddddddd));"); 4753 4754 // This test case breaks on an incorrect memoization, i.e. an optimization not 4755 // taking into account the StopAt value. 4756 verifyFormat( 4757 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 4758 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 4759 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 4760 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4761 4762 verifyFormat("{\n {\n {\n" 4763 " Annotation.SpaceRequiredBefore =\n" 4764 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 4765 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 4766 " }\n }\n}"); 4767 4768 // Break on an outer level if there was a break on an inner level. 4769 EXPECT_EQ("f(g(h(a, // comment\n" 4770 " b, c),\n" 4771 " d, e),\n" 4772 " x, y);", 4773 format("f(g(h(a, // comment\n" 4774 " b, c), d, e), x, y);")); 4775 4776 // Prefer breaking similar line breaks. 4777 verifyFormat( 4778 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 4779 " NSTrackingMouseEnteredAndExited |\n" 4780 " NSTrackingActiveAlways;"); 4781 } 4782 4783 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 4784 FormatStyle NoBinPacking = getGoogleStyle(); 4785 NoBinPacking.BinPackParameters = false; 4786 NoBinPacking.BinPackArguments = true; 4787 verifyFormat("void f() {\n" 4788 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 4789 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 4790 "}", 4791 NoBinPacking); 4792 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 4793 " int aaaaaaaaaaaaaaaaaaaa,\n" 4794 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4795 NoBinPacking); 4796 4797 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 4798 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4799 " vector<int> bbbbbbbbbbbbbbb);", 4800 NoBinPacking); 4801 // FIXME: This behavior difference is probably not wanted. However, currently 4802 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 4803 // template arguments from BreakBeforeParameter being set because of the 4804 // one-per-line formatting. 4805 verifyFormat( 4806 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 4807 " aaaaaaaaaa> aaaaaaaaaa);", 4808 NoBinPacking); 4809 verifyFormat( 4810 "void fffffffffff(\n" 4811 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 4812 " aaaaaaaaaa);"); 4813 } 4814 4815 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 4816 FormatStyle NoBinPacking = getGoogleStyle(); 4817 NoBinPacking.BinPackParameters = false; 4818 NoBinPacking.BinPackArguments = false; 4819 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 4820 " aaaaaaaaaaaaaaaaaaaa,\n" 4821 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 4822 NoBinPacking); 4823 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 4824 " aaaaaaaaaaaaa,\n" 4825 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 4826 NoBinPacking); 4827 verifyFormat( 4828 "aaaaaaaa(aaaaaaaaaaaaa,\n" 4829 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4830 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 4831 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4832 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 4833 NoBinPacking); 4834 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 4835 " .aaaaaaaaaaaaaaaaaa();", 4836 NoBinPacking); 4837 verifyFormat("void f() {\n" 4838 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4839 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 4840 "}", 4841 NoBinPacking); 4842 4843 verifyFormat( 4844 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4845 " aaaaaaaaaaaa,\n" 4846 " aaaaaaaaaaaa);", 4847 NoBinPacking); 4848 verifyFormat( 4849 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 4850 " ddddddddddddddddddddddddddddd),\n" 4851 " test);", 4852 NoBinPacking); 4853 4854 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 4855 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 4856 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 4857 " aaaaaaaaaaaaaaaaaa;", 4858 NoBinPacking); 4859 verifyFormat("a(\"a\"\n" 4860 " \"a\",\n" 4861 " a);"); 4862 4863 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 4864 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 4865 " aaaaaaaaa,\n" 4866 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4867 NoBinPacking); 4868 verifyFormat( 4869 "void f() {\n" 4870 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 4871 " .aaaaaaa();\n" 4872 "}", 4873 NoBinPacking); 4874 verifyFormat( 4875 "template <class SomeType, class SomeOtherType>\n" 4876 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 4877 NoBinPacking); 4878 } 4879 4880 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 4881 FormatStyle Style = getLLVMStyleWithColumns(15); 4882 Style.ExperimentalAutoDetectBinPacking = true; 4883 EXPECT_EQ("aaa(aaaa,\n" 4884 " aaaa,\n" 4885 " aaaa);\n" 4886 "aaa(aaaa,\n" 4887 " aaaa,\n" 4888 " aaaa);", 4889 format("aaa(aaaa,\n" // one-per-line 4890 " aaaa,\n" 4891 " aaaa );\n" 4892 "aaa(aaaa, aaaa, aaaa);", // inconclusive 4893 Style)); 4894 EXPECT_EQ("aaa(aaaa, aaaa,\n" 4895 " aaaa);\n" 4896 "aaa(aaaa, aaaa,\n" 4897 " aaaa);", 4898 format("aaa(aaaa, aaaa,\n" // bin-packed 4899 " aaaa );\n" 4900 "aaa(aaaa, aaaa, aaaa);", // inconclusive 4901 Style)); 4902 } 4903 4904 TEST_F(FormatTest, FormatsBuilderPattern) { 4905 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 4906 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 4907 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 4908 " .StartsWith(\".init\", ORDER_INIT)\n" 4909 " .StartsWith(\".fini\", ORDER_FINI)\n" 4910 " .StartsWith(\".hash\", ORDER_HASH)\n" 4911 " .Default(ORDER_TEXT);\n"); 4912 4913 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 4914 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 4915 verifyFormat( 4916 "aaaaaaa->aaaaaaa\n" 4917 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4918 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4919 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 4920 verifyFormat( 4921 "aaaaaaa->aaaaaaa\n" 4922 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4923 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 4924 verifyFormat( 4925 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 4926 " aaaaaaaaaaaaaa);"); 4927 verifyFormat( 4928 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 4929 " aaaaaa->aaaaaaaaaaaa()\n" 4930 " ->aaaaaaaaaaaaaaaa(\n" 4931 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4932 " ->aaaaaaaaaaaaaaaaa();"); 4933 verifyGoogleFormat( 4934 "void f() {\n" 4935 " someo->Add((new util::filetools::Handler(dir))\n" 4936 " ->OnEvent1(NewPermanentCallback(\n" 4937 " this, &HandlerHolderClass::EventHandlerCBA))\n" 4938 " ->OnEvent2(NewPermanentCallback(\n" 4939 " this, &HandlerHolderClass::EventHandlerCBB))\n" 4940 " ->OnEvent3(NewPermanentCallback(\n" 4941 " this, &HandlerHolderClass::EventHandlerCBC))\n" 4942 " ->OnEvent5(NewPermanentCallback(\n" 4943 " this, &HandlerHolderClass::EventHandlerCBD))\n" 4944 " ->OnEvent6(NewPermanentCallback(\n" 4945 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 4946 "}"); 4947 4948 verifyFormat( 4949 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 4950 verifyFormat("aaaaaaaaaaaaaaa()\n" 4951 " .aaaaaaaaaaaaaaa()\n" 4952 " .aaaaaaaaaaaaaaa()\n" 4953 " .aaaaaaaaaaaaaaa()\n" 4954 " .aaaaaaaaaaaaaaa();"); 4955 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 4956 " .aaaaaaaaaaaaaaa()\n" 4957 " .aaaaaaaaaaaaaaa()\n" 4958 " .aaaaaaaaaaaaaaa();"); 4959 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 4960 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 4961 " .aaaaaaaaaaaaaaa();"); 4962 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 4963 " ->aaaaaaaaaaaaaae(0)\n" 4964 " ->aaaaaaaaaaaaaaa();"); 4965 4966 // Don't linewrap after very short segments. 4967 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4968 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4969 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 4970 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4971 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4972 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 4973 verifyFormat("aaa()\n" 4974 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4975 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4976 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 4977 4978 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 4979 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4980 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 4981 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 4982 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 4983 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 4984 4985 // Prefer not to break after empty parentheses. 4986 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 4987 " First->LastNewlineOffset);"); 4988 4989 // Prefer not to create "hanging" indents. 4990 verifyFormat( 4991 "return !soooooooooooooome_map\n" 4992 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4993 " .second;"); 4994 verifyFormat( 4995 "return aaaaaaaaaaaaaaaa\n" 4996 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 4997 " .aaaa(aaaaaaaaaaaaaa);"); 4998 // No hanging indent here. 4999 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5000 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5001 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5002 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5003 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5004 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5005 getLLVMStyleWithColumns(60)); 5006 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5007 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5008 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5009 getLLVMStyleWithColumns(59)); 5010 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5011 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5012 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5013 5014 // Dont break if only closing statements before member call 5015 verifyFormat("test() {\n" 5016 " ([]() -> {\n" 5017 " int b = 32;\n" 5018 " return 3;\n" 5019 " }).foo();\n" 5020 "}"); 5021 verifyFormat("test() {\n" 5022 " (\n" 5023 " []() -> {\n" 5024 " int b = 32;\n" 5025 " return 3;\n" 5026 " },\n" 5027 " foo, bar)\n" 5028 " .foo();\n" 5029 "}"); 5030 verifyFormat("test() {\n" 5031 " ([]() -> {\n" 5032 " int b = 32;\n" 5033 " return 3;\n" 5034 " })\n" 5035 " .foo()\n" 5036 " .bar();\n" 5037 "}"); 5038 verifyFormat("test() {\n" 5039 " ([]() -> {\n" 5040 " int b = 32;\n" 5041 " return 3;\n" 5042 " })\n" 5043 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5044 " \"bbbb\");\n" 5045 "}", 5046 getLLVMStyleWithColumns(30)); 5047 } 5048 5049 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5050 verifyFormat( 5051 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5052 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5053 verifyFormat( 5054 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5055 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5056 5057 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5058 " ccccccccccccccccccccccccc) {\n}"); 5059 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5060 " ccccccccccccccccccccccccc) {\n}"); 5061 5062 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5063 " ccccccccccccccccccccccccc) {\n}"); 5064 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5065 " ccccccccccccccccccccccccc) {\n}"); 5066 5067 verifyFormat( 5068 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5069 " ccccccccccccccccccccccccc) {\n}"); 5070 verifyFormat( 5071 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5072 " ccccccccccccccccccccccccc) {\n}"); 5073 5074 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5075 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5076 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5077 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5078 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5079 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5080 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5081 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5082 5083 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5084 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5085 " aaaaaaaaaaaaaaa != aa) {\n}"); 5086 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5087 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5088 " aaaaaaaaaaaaaaa != aa) {\n}"); 5089 } 5090 5091 TEST_F(FormatTest, BreaksAfterAssignments) { 5092 verifyFormat( 5093 "unsigned Cost =\n" 5094 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5095 " SI->getPointerAddressSpaceee());\n"); 5096 verifyFormat( 5097 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5098 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5099 5100 verifyFormat( 5101 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5102 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5103 verifyFormat("unsigned OriginalStartColumn =\n" 5104 " SourceMgr.getSpellingColumnNumber(\n" 5105 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5106 " 1;"); 5107 } 5108 5109 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5110 FormatStyle Style = getLLVMStyle(); 5111 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5112 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5113 Style); 5114 5115 Style.PenaltyBreakAssignment = 20; 5116 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5117 " cccccccccccccccccccccccccc;", 5118 Style); 5119 } 5120 5121 TEST_F(FormatTest, AlignsAfterAssignments) { 5122 verifyFormat( 5123 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5124 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5125 verifyFormat( 5126 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5127 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5128 verifyFormat( 5129 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5130 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5131 verifyFormat( 5132 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5133 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5134 verifyFormat( 5135 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5136 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5137 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5138 } 5139 5140 TEST_F(FormatTest, AlignsAfterReturn) { 5141 verifyFormat( 5142 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5143 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5144 verifyFormat( 5145 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5146 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5147 verifyFormat( 5148 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5149 " aaaaaaaaaaaaaaaaaaaaaa();"); 5150 verifyFormat( 5151 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5152 " aaaaaaaaaaaaaaaaaaaaaa());"); 5153 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5154 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5155 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5156 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5157 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5158 verifyFormat("return\n" 5159 " // true if code is one of a or b.\n" 5160 " code == a || code == b;"); 5161 } 5162 5163 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5164 verifyFormat( 5165 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5166 " aaaaaaaaa aaaaaaa) {}"); 5167 verifyFormat( 5168 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5169 " aaaaaaaaaaa aaaaaaaaa);"); 5170 verifyFormat( 5171 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5172 " aaaaaaaaaaaaaaaaaaaaa));"); 5173 FormatStyle Style = getLLVMStyle(); 5174 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5175 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5176 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5177 Style); 5178 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5179 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5180 Style); 5181 verifyFormat("SomeLongVariableName->someFunction(\n" 5182 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5183 Style); 5184 verifyFormat( 5185 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5186 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5187 Style); 5188 verifyFormat( 5189 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5190 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5191 Style); 5192 verifyFormat( 5193 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5194 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5195 Style); 5196 5197 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5198 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5199 " b));", 5200 Style); 5201 5202 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5203 Style.BinPackArguments = false; 5204 Style.BinPackParameters = false; 5205 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5206 " aaaaaaaaaaa aaaaaaaa,\n" 5207 " aaaaaaaaa aaaaaaa,\n" 5208 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5209 Style); 5210 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5211 " aaaaaaaaaaa aaaaaaaaa,\n" 5212 " aaaaaaaaaaa aaaaaaaaa,\n" 5213 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5214 Style); 5215 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5216 " aaaaaaaaaaaaaaa,\n" 5217 " aaaaaaaaaaaaaaaaaaaaa,\n" 5218 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5219 Style); 5220 verifyFormat( 5221 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5222 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5223 Style); 5224 verifyFormat( 5225 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5226 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5227 Style); 5228 verifyFormat( 5229 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5230 " aaaaaaaaaaaaaaaaaaaaa(\n" 5231 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5232 " aaaaaaaaaaaaaaaa);", 5233 Style); 5234 verifyFormat( 5235 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5236 " aaaaaaaaaaaaaaaaaaaaa(\n" 5237 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5238 " aaaaaaaaaaaaaaaa);", 5239 Style); 5240 } 5241 5242 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5243 FormatStyle Style = getLLVMStyleWithColumns(40); 5244 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5245 " bbbbbbbbbbbbbbbbbbbbbb);", 5246 Style); 5247 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5248 Style.AlignOperands = false; 5249 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5250 " bbbbbbbbbbbbbbbbbbbbbb);", 5251 Style); 5252 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5253 Style.AlignOperands = true; 5254 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5255 " bbbbbbbbbbbbbbbbbbbbbb);", 5256 Style); 5257 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5258 Style.AlignOperands = false; 5259 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5260 " bbbbbbbbbbbbbbbbbbbbbb);", 5261 Style); 5262 } 5263 5264 TEST_F(FormatTest, BreaksConditionalExpressions) { 5265 verifyFormat( 5266 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5267 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5268 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5269 verifyFormat( 5270 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5271 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5272 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5273 verifyFormat( 5274 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5275 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5276 verifyFormat( 5277 "aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5278 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5279 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5280 verifyFormat( 5281 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5282 " : aaaaaaaaaaaaa);"); 5283 verifyFormat( 5284 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5285 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5286 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5287 " aaaaaaaaaaaaa);"); 5288 verifyFormat( 5289 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5290 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5291 " aaaaaaaaaaaaa);"); 5292 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5293 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5294 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5295 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5296 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5297 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5298 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5299 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5300 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5301 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5302 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5303 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5304 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5305 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5306 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5307 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5308 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5309 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5310 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5311 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5312 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5313 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5314 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5315 " : aaaaaaaaaaaaaaaa;"); 5316 verifyFormat( 5317 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5318 " ? aaaaaaaaaaaaaaa\n" 5319 " : aaaaaaaaaaaaaaa;"); 5320 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5321 " aaaaaaaaa\n" 5322 " ? b\n" 5323 " : c);"); 5324 verifyFormat("return aaaa == bbbb\n" 5325 " // comment\n" 5326 " ? aaaa\n" 5327 " : bbbb;"); 5328 verifyFormat("unsigned Indent =\n" 5329 " format(TheLine.First,\n" 5330 " IndentForLevel[TheLine.Level] >= 0\n" 5331 " ? IndentForLevel[TheLine.Level]\n" 5332 " : TheLine * 2,\n" 5333 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5334 getLLVMStyleWithColumns(60)); 5335 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5336 " ? aaaaaaaaaaaaaaa\n" 5337 " : bbbbbbbbbbbbbbb //\n" 5338 " ? ccccccccccccccc\n" 5339 " : ddddddddddddddd;"); 5340 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5341 " ? aaaaaaaaaaaaaaa\n" 5342 " : (bbbbbbbbbbbbbbb //\n" 5343 " ? ccccccccccccccc\n" 5344 " : ddddddddddddddd);"); 5345 verifyFormat( 5346 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5347 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5348 " aaaaaaaaaaaaaaaaaaaaa +\n" 5349 " aaaaaaaaaaaaaaaaaaaaa\n" 5350 " : aaaaaaaaaa;"); 5351 verifyFormat( 5352 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5353 " : aaaaaaaaaaaaaaaaaaaaaa\n" 5354 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5355 5356 FormatStyle NoBinPacking = getLLVMStyle(); 5357 NoBinPacking.BinPackArguments = false; 5358 verifyFormat( 5359 "void f() {\n" 5360 " g(aaa,\n" 5361 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5362 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5363 " ? aaaaaaaaaaaaaaa\n" 5364 " : aaaaaaaaaaaaaaa);\n" 5365 "}", 5366 NoBinPacking); 5367 verifyFormat( 5368 "void f() {\n" 5369 " g(aaa,\n" 5370 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5371 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5372 " ?: aaaaaaaaaaaaaaa);\n" 5373 "}", 5374 NoBinPacking); 5375 5376 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 5377 " // comment.\n" 5378 " ccccccccccccccccccccccccccccccccccccccc\n" 5379 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5380 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 5381 5382 // Assignments in conditional expressions. Apparently not uncommon :-(. 5383 verifyFormat("return a != b\n" 5384 " // comment\n" 5385 " ? a = b\n" 5386 " : a = b;"); 5387 verifyFormat("return a != b\n" 5388 " // comment\n" 5389 " ? a = a != b\n" 5390 " // comment\n" 5391 " ? a = b\n" 5392 " : a\n" 5393 " : a;\n"); 5394 verifyFormat("return a != b\n" 5395 " // comment\n" 5396 " ? a\n" 5397 " : a = a != b\n" 5398 " // comment\n" 5399 " ? a = b\n" 5400 " : a;"); 5401 } 5402 5403 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 5404 FormatStyle Style = getLLVMStyle(); 5405 Style.BreakBeforeTernaryOperators = false; 5406 Style.ColumnLimit = 70; 5407 verifyFormat( 5408 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5409 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5410 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5411 Style); 5412 verifyFormat( 5413 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5414 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5415 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5416 Style); 5417 verifyFormat( 5418 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5419 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5420 Style); 5421 verifyFormat( 5422 "aaaa(aaaaaaaa, aaaaaaaaaa,\n" 5423 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5424 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5425 Style); 5426 verifyFormat( 5427 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 5428 " aaaaaaaaaaaaa);", 5429 Style); 5430 verifyFormat( 5431 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5432 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5433 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5434 " aaaaaaaaaaaaa);", 5435 Style); 5436 verifyFormat( 5437 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5438 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5439 " aaaaaaaaaaaaa);", 5440 Style); 5441 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5442 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5443 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5444 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5445 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5446 Style); 5447 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5448 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5449 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5450 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5451 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5452 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5453 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5454 Style); 5455 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5456 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 5457 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5458 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5459 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5460 Style); 5461 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5462 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5463 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5464 Style); 5465 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5466 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5467 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5468 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5469 Style); 5470 verifyFormat( 5471 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5472 " aaaaaaaaaaaaaaa :\n" 5473 " aaaaaaaaaaaaaaa;", 5474 Style); 5475 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5476 " aaaaaaaaa ?\n" 5477 " b :\n" 5478 " c);", 5479 Style); 5480 verifyFormat("unsigned Indent =\n" 5481 " format(TheLine.First,\n" 5482 " IndentForLevel[TheLine.Level] >= 0 ?\n" 5483 " IndentForLevel[TheLine.Level] :\n" 5484 " TheLine * 2,\n" 5485 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5486 Style); 5487 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5488 " aaaaaaaaaaaaaaa :\n" 5489 " bbbbbbbbbbbbbbb ? //\n" 5490 " ccccccccccccccc :\n" 5491 " ddddddddddddddd;", 5492 Style); 5493 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5494 " aaaaaaaaaaaaaaa :\n" 5495 " (bbbbbbbbbbbbbbb ? //\n" 5496 " ccccccccccccccc :\n" 5497 " ddddddddddddddd);", 5498 Style); 5499 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5500 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 5501 " ccccccccccccccccccccccccccc;", 5502 Style); 5503 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5504 " aaaaa :\n" 5505 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 5506 Style); 5507 } 5508 5509 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 5510 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 5511 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 5512 verifyFormat("bool a = true, b = false;"); 5513 5514 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5515 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 5516 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 5517 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 5518 verifyFormat( 5519 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 5520 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 5521 " d = e && f;"); 5522 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 5523 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 5524 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5525 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 5526 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 5527 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 5528 5529 FormatStyle Style = getGoogleStyle(); 5530 Style.PointerAlignment = FormatStyle::PAS_Left; 5531 Style.DerivePointerAlignment = false; 5532 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5533 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 5534 " *b = bbbbbbbbbbbbbbbbbbb;", 5535 Style); 5536 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5537 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 5538 Style); 5539 verifyFormat("vector<int*> a, b;", Style); 5540 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 5541 } 5542 5543 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 5544 verifyFormat("arr[foo ? bar : baz];"); 5545 verifyFormat("f()[foo ? bar : baz];"); 5546 verifyFormat("(a + b)[foo ? bar : baz];"); 5547 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 5548 } 5549 5550 TEST_F(FormatTest, AlignsStringLiterals) { 5551 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 5552 " \"short literal\");"); 5553 verifyFormat( 5554 "looooooooooooooooooooooooongFunction(\n" 5555 " \"short literal\"\n" 5556 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 5557 verifyFormat("someFunction(\"Always break between multi-line\"\n" 5558 " \" string literals\",\n" 5559 " and, other, parameters);"); 5560 EXPECT_EQ("fun + \"1243\" /* comment */\n" 5561 " \"5678\";", 5562 format("fun + \"1243\" /* comment */\n" 5563 " \"5678\";", 5564 getLLVMStyleWithColumns(28))); 5565 EXPECT_EQ( 5566 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 5567 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 5568 " \"aaaaaaaaaaaaaaaa\";", 5569 format("aaaaaa =" 5570 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 5571 "aaaaaaaaaaaaaaaaaaaaa\" " 5572 "\"aaaaaaaaaaaaaaaa\";")); 5573 verifyFormat("a = a + \"a\"\n" 5574 " \"a\"\n" 5575 " \"a\";"); 5576 verifyFormat("f(\"a\", \"b\"\n" 5577 " \"c\");"); 5578 5579 verifyFormat( 5580 "#define LL_FORMAT \"ll\"\n" 5581 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 5582 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 5583 5584 verifyFormat("#define A(X) \\\n" 5585 " \"aaaaa\" #X \"bbbbbb\" \\\n" 5586 " \"ccccc\"", 5587 getLLVMStyleWithColumns(23)); 5588 verifyFormat("#define A \"def\"\n" 5589 "f(\"abc\" A \"ghi\"\n" 5590 " \"jkl\");"); 5591 5592 verifyFormat("f(L\"a\"\n" 5593 " L\"b\");"); 5594 verifyFormat("#define A(X) \\\n" 5595 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 5596 " L\"ccccc\"", 5597 getLLVMStyleWithColumns(25)); 5598 5599 verifyFormat("f(@\"a\"\n" 5600 " @\"b\");"); 5601 verifyFormat("NSString s = @\"a\"\n" 5602 " @\"b\"\n" 5603 " @\"c\";"); 5604 verifyFormat("NSString s = @\"a\"\n" 5605 " \"b\"\n" 5606 " \"c\";"); 5607 } 5608 5609 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 5610 FormatStyle Style = getLLVMStyle(); 5611 // No declarations or definitions should be moved to own line. 5612 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 5613 verifyFormat("class A {\n" 5614 " int f() { return 1; }\n" 5615 " int g();\n" 5616 "};\n" 5617 "int f() { return 1; }\n" 5618 "int g();\n", 5619 Style); 5620 5621 // All declarations and definitions should have the return type moved to its 5622 // own 5623 // line. 5624 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 5625 verifyFormat("class E {\n" 5626 " int\n" 5627 " f() {\n" 5628 " return 1;\n" 5629 " }\n" 5630 " int\n" 5631 " g();\n" 5632 "};\n" 5633 "int\n" 5634 "f() {\n" 5635 " return 1;\n" 5636 "}\n" 5637 "int\n" 5638 "g();\n", 5639 Style); 5640 5641 // Top-level definitions, and no kinds of declarations should have the 5642 // return type moved to its own line. 5643 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 5644 verifyFormat("class B {\n" 5645 " int f() { return 1; }\n" 5646 " int g();\n" 5647 "};\n" 5648 "int\n" 5649 "f() {\n" 5650 " return 1;\n" 5651 "}\n" 5652 "int g();\n", 5653 Style); 5654 5655 // Top-level definitions and declarations should have the return type moved 5656 // to its own line. 5657 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 5658 verifyFormat("class C {\n" 5659 " int f() { return 1; }\n" 5660 " int g();\n" 5661 "};\n" 5662 "int\n" 5663 "f() {\n" 5664 " return 1;\n" 5665 "}\n" 5666 "int\n" 5667 "g();\n", 5668 Style); 5669 5670 // All definitions should have the return type moved to its own line, but no 5671 // kinds of declarations. 5672 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 5673 verifyFormat("class D {\n" 5674 " int\n" 5675 " f() {\n" 5676 " return 1;\n" 5677 " }\n" 5678 " int g();\n" 5679 "};\n" 5680 "int\n" 5681 "f() {\n" 5682 " return 1;\n" 5683 "}\n" 5684 "int g();\n", 5685 Style); 5686 verifyFormat("const char *\n" 5687 "f(void) {\n" // Break here. 5688 " return \"\";\n" 5689 "}\n" 5690 "const char *bar(void);\n", // No break here. 5691 Style); 5692 verifyFormat("template <class T>\n" 5693 "T *\n" 5694 "f(T &c) {\n" // Break here. 5695 " return NULL;\n" 5696 "}\n" 5697 "template <class T> T *f(T &c);\n", // No break here. 5698 Style); 5699 verifyFormat("class C {\n" 5700 " int\n" 5701 " operator+() {\n" 5702 " return 1;\n" 5703 " }\n" 5704 " int\n" 5705 " operator()() {\n" 5706 " return 1;\n" 5707 " }\n" 5708 "};\n", 5709 Style); 5710 verifyFormat("void\n" 5711 "A::operator()() {}\n" 5712 "void\n" 5713 "A::operator>>() {}\n" 5714 "void\n" 5715 "A::operator+() {}\n", 5716 Style); 5717 verifyFormat("void *operator new(std::size_t s);", // No break here. 5718 Style); 5719 verifyFormat("void *\n" 5720 "operator new(std::size_t s) {}", 5721 Style); 5722 verifyFormat("void *\n" 5723 "operator delete[](void *ptr) {}", 5724 Style); 5725 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 5726 verifyFormat("const char *\n" 5727 "f(void)\n" // Break here. 5728 "{\n" 5729 " return \"\";\n" 5730 "}\n" 5731 "const char *bar(void);\n", // No break here. 5732 Style); 5733 verifyFormat("template <class T>\n" 5734 "T *\n" // Problem here: no line break 5735 "f(T &c)\n" // Break here. 5736 "{\n" 5737 " return NULL;\n" 5738 "}\n" 5739 "template <class T> T *f(T &c);\n", // No break here. 5740 Style); 5741 verifyFormat("int\n" 5742 "foo(A<bool> a)\n" 5743 "{\n" 5744 " return a;\n" 5745 "}\n", 5746 Style); 5747 verifyFormat("int\n" 5748 "foo(A<8> a)\n" 5749 "{\n" 5750 " return a;\n" 5751 "}\n", 5752 Style); 5753 verifyFormat("int\n" 5754 "foo(A<B<bool>, 8> a)\n" 5755 "{\n" 5756 " return a;\n" 5757 "}\n", 5758 Style); 5759 verifyFormat("int\n" 5760 "foo(A<B<8>, bool> a)\n" 5761 "{\n" 5762 " return a;\n" 5763 "}\n", 5764 Style); 5765 verifyFormat("int\n" 5766 "foo(A<B<bool>, bool> a)\n" 5767 "{\n" 5768 " return a;\n" 5769 "}\n", 5770 Style); 5771 verifyFormat("int\n" 5772 "foo(A<B<8>, 8> a)\n" 5773 "{\n" 5774 " return a;\n" 5775 "}\n", 5776 Style); 5777 5778 Style = getGNUStyle(); 5779 5780 // Test for comments at the end of function declarations. 5781 verifyFormat("void\n" 5782 "foo (int a, /*abc*/ int b) // def\n" 5783 "{\n" 5784 "}\n", 5785 Style); 5786 5787 verifyFormat("void\n" 5788 "foo (int a, /* abc */ int b) /* def */\n" 5789 "{\n" 5790 "}\n", 5791 Style); 5792 5793 // Definitions that should not break after return type 5794 verifyFormat("void foo (int a, int b); // def\n", Style); 5795 verifyFormat("void foo (int a, int b); /* def */\n", Style); 5796 verifyFormat("void foo (int a, int b);\n", Style); 5797 } 5798 5799 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 5800 FormatStyle NoBreak = getLLVMStyle(); 5801 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 5802 FormatStyle Break = getLLVMStyle(); 5803 Break.AlwaysBreakBeforeMultilineStrings = true; 5804 verifyFormat("aaaa = \"bbbb\"\n" 5805 " \"cccc\";", 5806 NoBreak); 5807 verifyFormat("aaaa =\n" 5808 " \"bbbb\"\n" 5809 " \"cccc\";", 5810 Break); 5811 verifyFormat("aaaa(\"bbbb\"\n" 5812 " \"cccc\");", 5813 NoBreak); 5814 verifyFormat("aaaa(\n" 5815 " \"bbbb\"\n" 5816 " \"cccc\");", 5817 Break); 5818 verifyFormat("aaaa(qqq, \"bbbb\"\n" 5819 " \"cccc\");", 5820 NoBreak); 5821 verifyFormat("aaaa(qqq,\n" 5822 " \"bbbb\"\n" 5823 " \"cccc\");", 5824 Break); 5825 verifyFormat("aaaa(qqq,\n" 5826 " L\"bbbb\"\n" 5827 " L\"cccc\");", 5828 Break); 5829 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 5830 " \"bbbb\"));", 5831 Break); 5832 verifyFormat("string s = someFunction(\n" 5833 " \"abc\"\n" 5834 " \"abc\");", 5835 Break); 5836 5837 // As we break before unary operators, breaking right after them is bad. 5838 verifyFormat("string foo = abc ? \"x\"\n" 5839 " \"blah blah blah blah blah blah\"\n" 5840 " : \"y\";", 5841 Break); 5842 5843 // Don't break if there is no column gain. 5844 verifyFormat("f(\"aaaa\"\n" 5845 " \"bbbb\");", 5846 Break); 5847 5848 // Treat literals with escaped newlines like multi-line string literals. 5849 EXPECT_EQ("x = \"a\\\n" 5850 "b\\\n" 5851 "c\";", 5852 format("x = \"a\\\n" 5853 "b\\\n" 5854 "c\";", 5855 NoBreak)); 5856 EXPECT_EQ("xxxx =\n" 5857 " \"a\\\n" 5858 "b\\\n" 5859 "c\";", 5860 format("xxxx = \"a\\\n" 5861 "b\\\n" 5862 "c\";", 5863 Break)); 5864 5865 EXPECT_EQ("NSString *const kString =\n" 5866 " @\"aaaa\"\n" 5867 " @\"bbbb\";", 5868 format("NSString *const kString = @\"aaaa\"\n" 5869 "@\"bbbb\";", 5870 Break)); 5871 5872 Break.ColumnLimit = 0; 5873 verifyFormat("const char *hello = \"hello llvm\";", Break); 5874 } 5875 5876 TEST_F(FormatTest, AlignsPipes) { 5877 verifyFormat( 5878 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5879 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5880 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5881 verifyFormat( 5882 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 5883 " << aaaaaaaaaaaaaaaaaaaa;"); 5884 verifyFormat( 5885 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5886 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5887 verifyFormat( 5888 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5889 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5890 verifyFormat( 5891 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 5892 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 5893 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 5894 verifyFormat( 5895 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5896 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5897 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5898 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5899 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5900 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5901 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 5902 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 5903 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 5904 verifyFormat( 5905 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5906 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5907 verifyFormat( 5908 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 5909 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5910 5911 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 5912 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 5913 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5914 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5915 " aaaaaaaaaaaaaaaaaaaaa)\n" 5916 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5917 verifyFormat("LOG_IF(aaa == //\n" 5918 " bbb)\n" 5919 " << a << b;"); 5920 5921 // But sometimes, breaking before the first "<<" is desirable. 5922 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 5923 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 5924 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 5925 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5926 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5927 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 5928 " << BEF << IsTemplate << Description << E->getType();"); 5929 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 5930 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5931 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5932 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 5933 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5934 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5935 " << aaa;"); 5936 5937 verifyFormat( 5938 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5939 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5940 5941 // Incomplete string literal. 5942 EXPECT_EQ("llvm::errs() << \"\n" 5943 " << a;", 5944 format("llvm::errs() << \"\n<<a;")); 5945 5946 verifyFormat("void f() {\n" 5947 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 5948 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 5949 "}"); 5950 5951 // Handle 'endl'. 5952 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 5953 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 5954 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 5955 5956 // Handle '\n'. 5957 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 5958 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 5959 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 5960 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 5961 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 5962 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 5963 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 5964 } 5965 5966 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 5967 verifyFormat("return out << \"somepacket = {\\n\"\n" 5968 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 5969 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 5970 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 5971 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 5972 " << \"}\";"); 5973 5974 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 5975 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 5976 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 5977 verifyFormat( 5978 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 5979 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 5980 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 5981 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 5982 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 5983 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 5984 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 5985 verifyFormat( 5986 "void f() {\n" 5987 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 5988 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5989 "}"); 5990 5991 // Breaking before the first "<<" is generally not desirable. 5992 verifyFormat( 5993 "llvm::errs()\n" 5994 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5995 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5996 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5997 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5998 getLLVMStyleWithColumns(70)); 5999 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6000 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6001 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6002 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6003 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6004 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6005 getLLVMStyleWithColumns(70)); 6006 6007 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6008 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6009 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6010 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6011 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6012 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 6013 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 6014 " (aaaa + aaaa);", 6015 getLLVMStyleWithColumns(40)); 6016 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 6017 " (aaaaaaa + aaaaa));", 6018 getLLVMStyleWithColumns(40)); 6019 verifyFormat( 6020 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 6021 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 6022 " bbbbbbbbbbbbbbbbbbbbbbb);"); 6023 } 6024 6025 TEST_F(FormatTest, UnderstandsEquals) { 6026 verifyFormat( 6027 "aaaaaaaaaaaaaaaaa =\n" 6028 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6029 verifyFormat( 6030 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6031 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6032 verifyFormat( 6033 "if (a) {\n" 6034 " f();\n" 6035 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6036 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 6037 "}"); 6038 6039 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6040 " 100000000 + 10000000) {\n}"); 6041 } 6042 6043 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 6044 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6045 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 6046 6047 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6048 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 6049 6050 verifyFormat( 6051 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 6052 " Parameter2);"); 6053 6054 verifyFormat( 6055 "ShortObject->shortFunction(\n" 6056 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 6057 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 6058 6059 verifyFormat("loooooooooooooongFunction(\n" 6060 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 6061 6062 verifyFormat( 6063 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 6064 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 6065 6066 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6067 " .WillRepeatedly(Return(SomeValue));"); 6068 verifyFormat("void f() {\n" 6069 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6070 " .Times(2)\n" 6071 " .WillRepeatedly(Return(SomeValue));\n" 6072 "}"); 6073 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 6074 " ccccccccccccccccccccccc);"); 6075 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6076 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6077 " .aaaaa(aaaaa),\n" 6078 " aaaaaaaaaaaaaaaaaaaaa);"); 6079 verifyFormat("void f() {\n" 6080 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6081 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 6082 "}"); 6083 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6084 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6085 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6086 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6087 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6088 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6089 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6090 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6091 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 6092 "}"); 6093 6094 // Here, it is not necessary to wrap at "." or "->". 6095 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 6096 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6097 verifyFormat( 6098 "aaaaaaaaaaa->aaaaaaaaa(\n" 6099 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6100 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 6101 6102 verifyFormat( 6103 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6104 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 6105 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 6106 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6107 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 6108 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6109 6110 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6111 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6112 " .a();"); 6113 6114 FormatStyle NoBinPacking = getLLVMStyle(); 6115 NoBinPacking.BinPackParameters = false; 6116 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6117 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6118 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 6119 " aaaaaaaaaaaaaaaaaaa,\n" 6120 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6121 NoBinPacking); 6122 6123 // If there is a subsequent call, change to hanging indentation. 6124 verifyFormat( 6125 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6126 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 6127 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6128 verifyFormat( 6129 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6130 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 6131 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6132 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6133 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6134 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6135 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6136 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6137 } 6138 6139 TEST_F(FormatTest, WrapsTemplateDeclarations) { 6140 verifyFormat("template <typename T>\n" 6141 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6142 verifyFormat("template <typename T>\n" 6143 "// T should be one of {A, B}.\n" 6144 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6145 verifyFormat( 6146 "template <typename T>\n" 6147 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 6148 verifyFormat("template <typename T>\n" 6149 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 6150 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 6151 verifyFormat( 6152 "template <typename T>\n" 6153 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 6154 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 6155 verifyFormat( 6156 "template <typename T>\n" 6157 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 6158 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 6159 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6160 verifyFormat("template <typename T>\n" 6161 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6162 " int aaaaaaaaaaaaaaaaaaaaaa);"); 6163 verifyFormat( 6164 "template <typename T1, typename T2 = char, typename T3 = char,\n" 6165 " typename T4 = char>\n" 6166 "void f();"); 6167 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 6168 " template <typename> class cccccccccccccccccccccc,\n" 6169 " typename ddddddddddddd>\n" 6170 "class C {};"); 6171 verifyFormat( 6172 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 6173 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6174 6175 verifyFormat("void f() {\n" 6176 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 6177 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 6178 "}"); 6179 6180 verifyFormat("template <typename T> class C {};"); 6181 verifyFormat("template <typename T> void f();"); 6182 verifyFormat("template <typename T> void f() {}"); 6183 verifyFormat( 6184 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6185 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6186 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 6187 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6188 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6189 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 6190 " bbbbbbbbbbbbbbbbbbbbbbbb);", 6191 getLLVMStyleWithColumns(72)); 6192 EXPECT_EQ("static_cast<A< //\n" 6193 " B> *>(\n" 6194 "\n" 6195 ");", 6196 format("static_cast<A<//\n" 6197 " B>*>(\n" 6198 "\n" 6199 " );")); 6200 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6201 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 6202 6203 FormatStyle AlwaysBreak = getLLVMStyle(); 6204 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 6205 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 6206 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 6207 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 6208 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6209 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6210 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 6211 verifyFormat("template <template <typename> class Fooooooo,\n" 6212 " template <typename> class Baaaaaaar>\n" 6213 "struct C {};", 6214 AlwaysBreak); 6215 verifyFormat("template <typename T> // T can be A, B or C.\n" 6216 "struct C {};", 6217 AlwaysBreak); 6218 verifyFormat("template <enum E> class A {\n" 6219 "public:\n" 6220 " E *f();\n" 6221 "};"); 6222 6223 FormatStyle NeverBreak = getLLVMStyle(); 6224 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 6225 verifyFormat("template <typename T> class C {};", NeverBreak); 6226 verifyFormat("template <typename T> void f();", NeverBreak); 6227 verifyFormat("template <typename T> void f() {}", NeverBreak); 6228 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbb) {}", 6229 NeverBreak); 6230 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6231 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6232 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 6233 NeverBreak); 6234 verifyFormat("template <template <typename> class Fooooooo,\n" 6235 " template <typename> class Baaaaaaar>\n" 6236 "struct C {};", 6237 NeverBreak); 6238 verifyFormat("template <typename T> // T can be A, B or C.\n" 6239 "struct C {};", 6240 NeverBreak); 6241 verifyFormat("template <enum E> class A {\n" 6242 "public:\n" 6243 " E *f();\n" 6244 "};", NeverBreak); 6245 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 6246 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbb) {}", 6247 NeverBreak); 6248 } 6249 6250 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 6251 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 6252 Style.ColumnLimit = 60; 6253 EXPECT_EQ("// Baseline - no comments.\n" 6254 "template <\n" 6255 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6256 "void f() {}", 6257 format("// Baseline - no comments.\n" 6258 "template <\n" 6259 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6260 "void f() {}", 6261 Style)); 6262 6263 EXPECT_EQ("template <\n" 6264 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6265 "void f() {}", 6266 format("template <\n" 6267 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6268 "void f() {}", 6269 Style)); 6270 6271 EXPECT_EQ( 6272 "template <\n" 6273 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6274 "void f() {}", 6275 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6276 "void f() {}", 6277 Style)); 6278 6279 EXPECT_EQ( 6280 "template <\n" 6281 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6282 " // multiline\n" 6283 "void f() {}", 6284 format("template <\n" 6285 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6286 " // multiline\n" 6287 "void f() {}", 6288 Style)); 6289 6290 EXPECT_EQ( 6291 "template <typename aaaaaaaaaa<\n" 6292 " bbbbbbbbbbbb>::value> // trailing loooong\n" 6293 "void f() {}", 6294 format( 6295 "template <\n" 6296 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 6297 "void f() {}", 6298 Style)); 6299 } 6300 6301 TEST_F(FormatTest, WrapsTemplateParameters) { 6302 FormatStyle Style = getLLVMStyle(); 6303 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6304 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6305 verifyFormat( 6306 "template <typename... a> struct q {};\n" 6307 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6308 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6309 " y;", 6310 Style); 6311 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6312 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6313 verifyFormat( 6314 "template <typename... a> struct r {};\n" 6315 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6316 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6317 " y;", 6318 Style); 6319 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6320 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6321 verifyFormat( 6322 "template <typename... a> struct s {};\n" 6323 "extern s<\n" 6324 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 6325 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n" 6326 " y;", 6327 Style); 6328 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6329 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6330 verifyFormat( 6331 "template <typename... a> struct t {};\n" 6332 "extern t<\n" 6333 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 6334 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n" 6335 " y;", 6336 Style); 6337 } 6338 6339 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 6340 verifyFormat( 6341 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6342 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6343 verifyFormat( 6344 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6345 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6346 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6347 6348 // FIXME: Should we have the extra indent after the second break? 6349 verifyFormat( 6350 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6351 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6352 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6353 6354 verifyFormat( 6355 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 6356 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 6357 6358 // Breaking at nested name specifiers is generally not desirable. 6359 verifyFormat( 6360 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6361 " aaaaaaaaaaaaaaaaaaaaaaa);"); 6362 6363 verifyFormat( 6364 "aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 6365 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6366 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6367 " aaaaaaaaaaaaaaaaaaaaa);", 6368 getLLVMStyleWithColumns(74)); 6369 6370 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6371 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6372 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6373 } 6374 6375 TEST_F(FormatTest, UnderstandsTemplateParameters) { 6376 verifyFormat("A<int> a;"); 6377 verifyFormat("A<A<A<int>>> a;"); 6378 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 6379 verifyFormat("bool x = a < 1 || 2 > a;"); 6380 verifyFormat("bool x = 5 < f<int>();"); 6381 verifyFormat("bool x = f<int>() > 5;"); 6382 verifyFormat("bool x = 5 < a<int>::x;"); 6383 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 6384 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 6385 6386 verifyGoogleFormat("A<A<int>> a;"); 6387 verifyGoogleFormat("A<A<A<int>>> a;"); 6388 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 6389 verifyGoogleFormat("A<A<int> > a;"); 6390 verifyGoogleFormat("A<A<A<int> > > a;"); 6391 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 6392 verifyGoogleFormat("A<::A<int>> a;"); 6393 verifyGoogleFormat("A<::A> a;"); 6394 verifyGoogleFormat("A< ::A> a;"); 6395 verifyGoogleFormat("A< ::A<int> > a;"); 6396 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 6397 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 6398 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 6399 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 6400 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 6401 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 6402 6403 verifyFormat("A<A>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 6404 6405 verifyFormat("test >> a >> b;"); 6406 verifyFormat("test << a >> b;"); 6407 6408 verifyFormat("f<int>();"); 6409 verifyFormat("template <typename T> void f() {}"); 6410 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 6411 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 6412 "sizeof(char)>::type>;"); 6413 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 6414 verifyFormat("f(a.operator()<A>());"); 6415 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6416 " .template operator()<A>());", 6417 getLLVMStyleWithColumns(35)); 6418 6419 // Not template parameters. 6420 verifyFormat("return a < b && c > d;"); 6421 verifyFormat("void f() {\n" 6422 " while (a < b && c > d) {\n" 6423 " }\n" 6424 "}"); 6425 verifyFormat("template <typename... Types>\n" 6426 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 6427 6428 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6429 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 6430 getLLVMStyleWithColumns(60)); 6431 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 6432 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 6433 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 6434 } 6435 6436 TEST_F(FormatTest, BitshiftOperatorWidth) { 6437 EXPECT_EQ("int a = 1 << 2; /* foo\n" 6438 " bar */", 6439 format("int a=1<<2; /* foo\n" 6440 " bar */")); 6441 6442 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 6443 " bar */", 6444 format("int b =256>>1 ; /* foo\n" 6445 " bar */")); 6446 } 6447 6448 TEST_F(FormatTest, UnderstandsBinaryOperators) { 6449 verifyFormat("COMPARE(a, ==, b);"); 6450 verifyFormat("auto s = sizeof...(Ts) - 1;"); 6451 } 6452 6453 TEST_F(FormatTest, UnderstandsPointersToMembers) { 6454 verifyFormat("int A::*x;"); 6455 verifyFormat("int (S::*func)(void *);"); 6456 verifyFormat("void f() { int (S::*func)(void *); }"); 6457 verifyFormat("typedef bool *(Class::*Member)() const;"); 6458 verifyFormat("void f() {\n" 6459 " (a->*f)();\n" 6460 " a->*x;\n" 6461 " (a.*f)();\n" 6462 " ((*a).*f)();\n" 6463 " a.*x;\n" 6464 "}"); 6465 verifyFormat("void f() {\n" 6466 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 6467 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 6468 "}"); 6469 verifyFormat( 6470 "(aaaaaaaaaa->*bbbbbbb)(\n" 6471 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6472 FormatStyle Style = getLLVMStyle(); 6473 Style.PointerAlignment = FormatStyle::PAS_Left; 6474 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 6475 } 6476 6477 TEST_F(FormatTest, UnderstandsUnaryOperators) { 6478 verifyFormat("int a = -2;"); 6479 verifyFormat("f(-1, -2, -3);"); 6480 verifyFormat("a[-1] = 5;"); 6481 verifyFormat("int a = 5 + -2;"); 6482 verifyFormat("if (i == -1) {\n}"); 6483 verifyFormat("if (i != -1) {\n}"); 6484 verifyFormat("if (i > -1) {\n}"); 6485 verifyFormat("if (i < -1) {\n}"); 6486 verifyFormat("++(a->f());"); 6487 verifyFormat("--(a->f());"); 6488 verifyFormat("(a->f())++;"); 6489 verifyFormat("a[42]++;"); 6490 verifyFormat("if (!(a->f())) {\n}"); 6491 verifyFormat("if (!+i) {\n}"); 6492 verifyFormat("~&a;"); 6493 6494 verifyFormat("a-- > b;"); 6495 verifyFormat("b ? -a : c;"); 6496 verifyFormat("n * sizeof char16;"); 6497 verifyFormat("n * alignof char16;", getGoogleStyle()); 6498 verifyFormat("sizeof(char);"); 6499 verifyFormat("alignof(char);", getGoogleStyle()); 6500 6501 verifyFormat("return -1;"); 6502 verifyFormat("switch (a) {\n" 6503 "case -1:\n" 6504 " break;\n" 6505 "}"); 6506 verifyFormat("#define X -1"); 6507 verifyFormat("#define X -kConstant"); 6508 6509 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 6510 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 6511 6512 verifyFormat("int a = /* confusing comment */ -1;"); 6513 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 6514 verifyFormat("int a = i /* confusing comment */++;"); 6515 } 6516 6517 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 6518 verifyFormat("if (!aaaaaaaaaa( // break\n" 6519 " aaaaa)) {\n" 6520 "}"); 6521 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 6522 " aaaaa));"); 6523 verifyFormat("*aaa = aaaaaaa( // break\n" 6524 " bbbbbb);"); 6525 } 6526 6527 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 6528 verifyFormat("bool operator<();"); 6529 verifyFormat("bool operator>();"); 6530 verifyFormat("bool operator=();"); 6531 verifyFormat("bool operator==();"); 6532 verifyFormat("bool operator!=();"); 6533 verifyFormat("int operator+();"); 6534 verifyFormat("int operator++();"); 6535 verifyFormat("int operator++(int) volatile noexcept;"); 6536 verifyFormat("bool operator,();"); 6537 verifyFormat("bool operator();"); 6538 verifyFormat("bool operator()();"); 6539 verifyFormat("bool operator[]();"); 6540 verifyFormat("operator bool();"); 6541 verifyFormat("operator int();"); 6542 verifyFormat("operator void *();"); 6543 verifyFormat("operator SomeType<int>();"); 6544 verifyFormat("operator SomeType<int, int>();"); 6545 verifyFormat("operator SomeType<SomeType<int>>();"); 6546 verifyFormat("void *operator new(std::size_t size);"); 6547 verifyFormat("void *operator new[](std::size_t size);"); 6548 verifyFormat("void operator delete(void *ptr);"); 6549 verifyFormat("void operator delete[](void *ptr);"); 6550 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 6551 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 6552 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 6553 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 6554 6555 verifyFormat( 6556 "ostream &operator<<(ostream &OutputStream,\n" 6557 " SomeReallyLongType WithSomeReallyLongValue);"); 6558 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 6559 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 6560 " return left.group < right.group;\n" 6561 "}"); 6562 verifyFormat("SomeType &operator=(const SomeType &S);"); 6563 verifyFormat("f.template operator()<int>();"); 6564 6565 verifyGoogleFormat("operator void*();"); 6566 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 6567 verifyGoogleFormat("operator ::A();"); 6568 6569 verifyFormat("using A::operator+;"); 6570 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 6571 "int i;"); 6572 } 6573 6574 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 6575 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 6576 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 6577 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 6578 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 6579 verifyFormat("Deleted &operator=(const Deleted &) &;"); 6580 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 6581 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 6582 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 6583 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 6584 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 6585 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 6586 verifyFormat("void Fn(T const &) const &;"); 6587 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 6588 verifyFormat("template <typename T>\n" 6589 "void F(T) && = delete;", 6590 getGoogleStyle()); 6591 6592 FormatStyle AlignLeft = getLLVMStyle(); 6593 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 6594 verifyFormat("void A::b() && {}", AlignLeft); 6595 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 6596 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 6597 AlignLeft); 6598 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 6599 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 6600 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 6601 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 6602 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 6603 verifyFormat("auto Function(T) & -> void;", AlignLeft); 6604 verifyFormat("void Fn(T const&) const&;", AlignLeft); 6605 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 6606 6607 FormatStyle Spaces = getLLVMStyle(); 6608 Spaces.SpacesInCStyleCastParentheses = true; 6609 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 6610 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 6611 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 6612 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 6613 6614 Spaces.SpacesInCStyleCastParentheses = false; 6615 Spaces.SpacesInParentheses = true; 6616 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 6617 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", Spaces); 6618 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 6619 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 6620 } 6621 6622 TEST_F(FormatTest, UnderstandsNewAndDelete) { 6623 verifyFormat("void f() {\n" 6624 " A *a = new A;\n" 6625 " A *a = new (placement) A;\n" 6626 " delete a;\n" 6627 " delete (A *)a;\n" 6628 "}"); 6629 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 6630 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 6631 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6632 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 6633 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 6634 verifyFormat("delete[] h->p;"); 6635 } 6636 6637 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 6638 verifyFormat("int *f(int *a) {}"); 6639 verifyFormat("int main(int argc, char **argv) {}"); 6640 verifyFormat("Test::Test(int b) : a(b * b) {}"); 6641 verifyIndependentOfContext("f(a, *a);"); 6642 verifyFormat("void g() { f(*a); }"); 6643 verifyIndependentOfContext("int a = b * 10;"); 6644 verifyIndependentOfContext("int a = 10 * b;"); 6645 verifyIndependentOfContext("int a = b * c;"); 6646 verifyIndependentOfContext("int a += b * c;"); 6647 verifyIndependentOfContext("int a -= b * c;"); 6648 verifyIndependentOfContext("int a *= b * c;"); 6649 verifyIndependentOfContext("int a /= b * c;"); 6650 verifyIndependentOfContext("int a = *b;"); 6651 verifyIndependentOfContext("int a = *b * c;"); 6652 verifyIndependentOfContext("int a = b * *c;"); 6653 verifyIndependentOfContext("int a = b * (10);"); 6654 verifyIndependentOfContext("S << b * (10);"); 6655 verifyIndependentOfContext("return 10 * b;"); 6656 verifyIndependentOfContext("return *b * *c;"); 6657 verifyIndependentOfContext("return a & ~b;"); 6658 verifyIndependentOfContext("f(b ? *c : *d);"); 6659 verifyIndependentOfContext("int a = b ? *c : *d;"); 6660 verifyIndependentOfContext("*b = a;"); 6661 verifyIndependentOfContext("a * ~b;"); 6662 verifyIndependentOfContext("a * !b;"); 6663 verifyIndependentOfContext("a * +b;"); 6664 verifyIndependentOfContext("a * -b;"); 6665 verifyIndependentOfContext("a * ++b;"); 6666 verifyIndependentOfContext("a * --b;"); 6667 verifyIndependentOfContext("a[4] * b;"); 6668 verifyIndependentOfContext("a[a * a] = 1;"); 6669 verifyIndependentOfContext("f() * b;"); 6670 verifyIndependentOfContext("a * [self dostuff];"); 6671 verifyIndependentOfContext("int x = a * (a + b);"); 6672 verifyIndependentOfContext("(a *)(a + b);"); 6673 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 6674 verifyIndependentOfContext("int *pa = (int *)&a;"); 6675 verifyIndependentOfContext("return sizeof(int **);"); 6676 verifyIndependentOfContext("return sizeof(int ******);"); 6677 verifyIndependentOfContext("return (int **&)a;"); 6678 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 6679 verifyFormat("void f(Type (*parameter)[10]) {}"); 6680 verifyFormat("void f(Type (¶meter)[10]) {}"); 6681 verifyGoogleFormat("return sizeof(int**);"); 6682 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 6683 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 6684 verifyFormat("auto a = [](int **&, int ***) {};"); 6685 verifyFormat("auto PointerBinding = [](const char *S) {};"); 6686 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 6687 verifyFormat("[](const decltype(*a) &value) {}"); 6688 verifyFormat("decltype(a * b) F();"); 6689 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 6690 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 6691 verifyIndependentOfContext("typedef void (*f)(int *a);"); 6692 verifyIndependentOfContext("int i{a * b};"); 6693 verifyIndependentOfContext("aaa && aaa->f();"); 6694 verifyIndependentOfContext("int x = ~*p;"); 6695 verifyFormat("Constructor() : a(a), area(width * height) {}"); 6696 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 6697 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 6698 verifyFormat("void f() { f(a, c * d); }"); 6699 verifyFormat("void f() { f(new a(), c * d); }"); 6700 verifyFormat("void f(const MyOverride &override);"); 6701 verifyFormat("void f(const MyFinal &final);"); 6702 verifyIndependentOfContext("bool a = f() && override.f();"); 6703 verifyIndependentOfContext("bool a = f() && final.f();"); 6704 6705 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 6706 6707 verifyIndependentOfContext("A<int *> a;"); 6708 verifyIndependentOfContext("A<int **> a;"); 6709 verifyIndependentOfContext("A<int *, int *> a;"); 6710 verifyIndependentOfContext("A<int *[]> a;"); 6711 verifyIndependentOfContext( 6712 "const char *const p = reinterpret_cast<const char *const>(q);"); 6713 verifyIndependentOfContext("A<int **, int **> a;"); 6714 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 6715 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 6716 verifyFormat("for (; a && b;) {\n}"); 6717 verifyFormat("bool foo = true && [] { return false; }();"); 6718 6719 verifyFormat( 6720 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6721 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6722 6723 verifyGoogleFormat("int const* a = &b;"); 6724 verifyGoogleFormat("**outparam = 1;"); 6725 verifyGoogleFormat("*outparam = a * b;"); 6726 verifyGoogleFormat("int main(int argc, char** argv) {}"); 6727 verifyGoogleFormat("A<int*> a;"); 6728 verifyGoogleFormat("A<int**> a;"); 6729 verifyGoogleFormat("A<int*, int*> a;"); 6730 verifyGoogleFormat("A<int**, int**> a;"); 6731 verifyGoogleFormat("f(b ? *c : *d);"); 6732 verifyGoogleFormat("int a = b ? *c : *d;"); 6733 verifyGoogleFormat("Type* t = **x;"); 6734 verifyGoogleFormat("Type* t = *++*x;"); 6735 verifyGoogleFormat("*++*x;"); 6736 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 6737 verifyGoogleFormat("Type* t = x++ * y;"); 6738 verifyGoogleFormat( 6739 "const char* const p = reinterpret_cast<const char* const>(q);"); 6740 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 6741 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 6742 verifyGoogleFormat("template <typename T>\n" 6743 "void f(int i = 0, SomeType** temps = NULL);"); 6744 6745 FormatStyle Left = getLLVMStyle(); 6746 Left.PointerAlignment = FormatStyle::PAS_Left; 6747 verifyFormat("x = *a(x) = *a(y);", Left); 6748 verifyFormat("for (;; *a = b) {\n}", Left); 6749 verifyFormat("return *this += 1;", Left); 6750 verifyFormat("throw *x;", Left); 6751 verifyFormat("delete *x;", Left); 6752 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 6753 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 6754 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 6755 6756 verifyIndependentOfContext("a = *(x + y);"); 6757 verifyIndependentOfContext("a = &(x + y);"); 6758 verifyIndependentOfContext("*(x + y).call();"); 6759 verifyIndependentOfContext("&(x + y)->call();"); 6760 verifyFormat("void f() { &(*I).first; }"); 6761 6762 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 6763 verifyFormat( 6764 "int *MyValues = {\n" 6765 " *A, // Operator detection might be confused by the '{'\n" 6766 " *BB // Operator detection might be confused by previous comment\n" 6767 "};"); 6768 6769 verifyIndependentOfContext("if (int *a = &b)"); 6770 verifyIndependentOfContext("if (int &a = *b)"); 6771 verifyIndependentOfContext("if (a & b[i])"); 6772 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 6773 verifyIndependentOfContext("if (*b[i])"); 6774 verifyIndependentOfContext("if (int *a = (&b))"); 6775 verifyIndependentOfContext("while (int *a = &b)"); 6776 verifyIndependentOfContext("size = sizeof *a;"); 6777 verifyIndependentOfContext("if (a && (b = c))"); 6778 verifyFormat("void f() {\n" 6779 " for (const int &v : Values) {\n" 6780 " }\n" 6781 "}"); 6782 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 6783 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 6784 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 6785 6786 verifyFormat("#define A (!a * b)"); 6787 verifyFormat("#define MACRO \\\n" 6788 " int *i = a * b; \\\n" 6789 " void f(a *b);", 6790 getLLVMStyleWithColumns(19)); 6791 6792 verifyIndependentOfContext("A = new SomeType *[Length];"); 6793 verifyIndependentOfContext("A = new SomeType *[Length]();"); 6794 verifyIndependentOfContext("T **t = new T *;"); 6795 verifyIndependentOfContext("T **t = new T *();"); 6796 verifyGoogleFormat("A = new SomeType*[Length]();"); 6797 verifyGoogleFormat("A = new SomeType*[Length];"); 6798 verifyGoogleFormat("T** t = new T*;"); 6799 verifyGoogleFormat("T** t = new T*();"); 6800 6801 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 6802 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 6803 verifyFormat("template <bool a, bool b> " 6804 "typename t::if<x && y>::type f() {}"); 6805 verifyFormat("template <int *y> f() {}"); 6806 verifyFormat("vector<int *> v;"); 6807 verifyFormat("vector<int *const> v;"); 6808 verifyFormat("vector<int *const **const *> v;"); 6809 verifyFormat("vector<int *volatile> v;"); 6810 verifyFormat("vector<a * b> v;"); 6811 verifyFormat("foo<b && false>();"); 6812 verifyFormat("foo<b & 1>();"); 6813 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 6814 verifyFormat( 6815 "template <class T, class = typename std::enable_if<\n" 6816 " std::is_integral<T>::value &&\n" 6817 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 6818 "void F();", 6819 getLLVMStyleWithColumns(70)); 6820 verifyFormat( 6821 "template <class T,\n" 6822 " class = typename std::enable_if<\n" 6823 " std::is_integral<T>::value &&\n" 6824 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 6825 " class U>\n" 6826 "void F();", 6827 getLLVMStyleWithColumns(70)); 6828 verifyFormat( 6829 "template <class T,\n" 6830 " class = typename ::std::enable_if<\n" 6831 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 6832 "void F();", 6833 getGoogleStyleWithColumns(68)); 6834 6835 verifyIndependentOfContext("MACRO(int *i);"); 6836 verifyIndependentOfContext("MACRO(auto *a);"); 6837 verifyIndependentOfContext("MACRO(const A *a);"); 6838 verifyIndependentOfContext("MACRO(A *const a);"); 6839 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 6840 verifyFormat("void f() { f(float{1}, a * a); }"); 6841 // FIXME: Is there a way to make this work? 6842 // verifyIndependentOfContext("MACRO(A *a);"); 6843 6844 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 6845 verifyFormat("return options != nullptr && operator==(*options);"); 6846 6847 EXPECT_EQ("#define OP(x) \\\n" 6848 " ostream &operator<<(ostream &s, const A &a) { \\\n" 6849 " return s << a.DebugString(); \\\n" 6850 " }", 6851 format("#define OP(x) \\\n" 6852 " ostream &operator<<(ostream &s, const A &a) { \\\n" 6853 " return s << a.DebugString(); \\\n" 6854 " }", 6855 getLLVMStyleWithColumns(50))); 6856 6857 // FIXME: We cannot handle this case yet; we might be able to figure out that 6858 // foo<x> d > v; doesn't make sense. 6859 verifyFormat("foo<a<b && c> d> v;"); 6860 6861 FormatStyle PointerMiddle = getLLVMStyle(); 6862 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 6863 verifyFormat("delete *x;", PointerMiddle); 6864 verifyFormat("int * x;", PointerMiddle); 6865 verifyFormat("int *[] x;", PointerMiddle); 6866 verifyFormat("template <int * y> f() {}", PointerMiddle); 6867 verifyFormat("int * f(int * a) {}", PointerMiddle); 6868 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 6869 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 6870 verifyFormat("A<int *> a;", PointerMiddle); 6871 verifyFormat("A<int **> a;", PointerMiddle); 6872 verifyFormat("A<int *, int *> a;", PointerMiddle); 6873 verifyFormat("A<int *[]> a;", PointerMiddle); 6874 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 6875 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 6876 verifyFormat("T ** t = new T *;", PointerMiddle); 6877 6878 // Member function reference qualifiers aren't binary operators. 6879 verifyFormat("string // break\n" 6880 "operator()() & {}"); 6881 verifyFormat("string // break\n" 6882 "operator()() && {}"); 6883 verifyGoogleFormat("template <typename T>\n" 6884 "auto x() & -> int {}"); 6885 } 6886 6887 TEST_F(FormatTest, UnderstandsAttributes) { 6888 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 6889 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 6890 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 6891 FormatStyle AfterType = getLLVMStyle(); 6892 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 6893 verifyFormat("__attribute__((nodebug)) void\n" 6894 "foo() {}\n", 6895 AfterType); 6896 } 6897 6898 TEST_F(FormatTest, UnderstandsSquareAttributes) { 6899 verifyFormat("SomeType s [[unused]] (InitValue);"); 6900 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 6901 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 6902 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 6903 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 6904 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6905 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 6906 6907 // Make sure we do not mistake attributes for array subscripts. 6908 verifyFormat("int a() {}\n" 6909 "[[unused]] int b() {}\n"); 6910 verifyFormat("NSArray *arr;\n" 6911 "arr[[Foo() bar]];"); 6912 6913 // On the other hand, we still need to correctly find array subscripts. 6914 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 6915 6916 // Make sure we do not parse attributes as lambda introducers. 6917 FormatStyle MultiLineFunctions = getLLVMStyle(); 6918 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 6919 verifyFormat("[[unused]] int b() {\n" 6920 " return 42;\n" 6921 "}\n", 6922 MultiLineFunctions); 6923 } 6924 6925 TEST_F(FormatTest, UnderstandsEllipsis) { 6926 verifyFormat("int printf(const char *fmt, ...);"); 6927 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 6928 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 6929 6930 FormatStyle PointersLeft = getLLVMStyle(); 6931 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 6932 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 6933 } 6934 6935 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 6936 EXPECT_EQ("int *a;\n" 6937 "int *a;\n" 6938 "int *a;", 6939 format("int *a;\n" 6940 "int* a;\n" 6941 "int *a;", 6942 getGoogleStyle())); 6943 EXPECT_EQ("int* a;\n" 6944 "int* a;\n" 6945 "int* a;", 6946 format("int* a;\n" 6947 "int* a;\n" 6948 "int *a;", 6949 getGoogleStyle())); 6950 EXPECT_EQ("int *a;\n" 6951 "int *a;\n" 6952 "int *a;", 6953 format("int *a;\n" 6954 "int * a;\n" 6955 "int * a;", 6956 getGoogleStyle())); 6957 EXPECT_EQ("auto x = [] {\n" 6958 " int *a;\n" 6959 " int *a;\n" 6960 " int *a;\n" 6961 "};", 6962 format("auto x=[]{int *a;\n" 6963 "int * a;\n" 6964 "int * a;};", 6965 getGoogleStyle())); 6966 } 6967 6968 TEST_F(FormatTest, UnderstandsRvalueReferences) { 6969 verifyFormat("int f(int &&a) {}"); 6970 verifyFormat("int f(int a, char &&b) {}"); 6971 verifyFormat("void f() { int &&a = b; }"); 6972 verifyGoogleFormat("int f(int a, char&& b) {}"); 6973 verifyGoogleFormat("void f() { int&& a = b; }"); 6974 6975 verifyIndependentOfContext("A<int &&> a;"); 6976 verifyIndependentOfContext("A<int &&, int &&> a;"); 6977 verifyGoogleFormat("A<int&&> a;"); 6978 verifyGoogleFormat("A<int&&, int&&> a;"); 6979 6980 // Not rvalue references: 6981 verifyFormat("template <bool B, bool C> class A {\n" 6982 " static_assert(B && C, \"Something is wrong\");\n" 6983 "};"); 6984 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 6985 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 6986 verifyFormat("#define A(a, b) (a && b)"); 6987 } 6988 6989 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 6990 verifyFormat("void f() {\n" 6991 " x[aaaaaaaaa -\n" 6992 " b] = 23;\n" 6993 "}", 6994 getLLVMStyleWithColumns(15)); 6995 } 6996 6997 TEST_F(FormatTest, FormatsCasts) { 6998 verifyFormat("Type *A = static_cast<Type *>(P);"); 6999 verifyFormat("Type *A = (Type *)P;"); 7000 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7001 verifyFormat("int a = (int)(2.0f);"); 7002 verifyFormat("int a = (int)2.0f;"); 7003 verifyFormat("x[(int32)y];"); 7004 verifyFormat("x = (int32)y;"); 7005 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7006 verifyFormat("int a = (int)*b;"); 7007 verifyFormat("int a = (int)2.0f;"); 7008 verifyFormat("int a = (int)~0;"); 7009 verifyFormat("int a = (int)++a;"); 7010 verifyFormat("int a = (int)sizeof(int);"); 7011 verifyFormat("int a = (int)+2;"); 7012 verifyFormat("my_int a = (my_int)2.0f;"); 7013 verifyFormat("my_int a = (my_int)sizeof(int);"); 7014 verifyFormat("return (my_int)aaa;"); 7015 verifyFormat("#define x ((int)-1)"); 7016 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7017 verifyFormat("#define p(q) ((int *)&q)"); 7018 verifyFormat("fn(a)(b) + 1;"); 7019 7020 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7021 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7022 verifyFormat("my_int a = (my_int)~0;"); 7023 verifyFormat("my_int a = (my_int)++a;"); 7024 verifyFormat("my_int a = (my_int)-2;"); 7025 verifyFormat("my_int a = (my_int)1;"); 7026 verifyFormat("my_int a = (my_int *)1;"); 7027 verifyFormat("my_int a = (const my_int)-1;"); 7028 verifyFormat("my_int a = (const my_int *)-1;"); 7029 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7030 verifyFormat("my_int a = (ns::my_int)-2;"); 7031 verifyFormat("case (my_int)ONE:"); 7032 verifyFormat("auto x = (X)this;"); 7033 7034 // FIXME: single value wrapped with paren will be treated as cast. 7035 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7036 7037 verifyFormat("{ (void)F; }"); 7038 7039 // Don't break after a cast's 7040 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7041 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7042 " bbbbbbbbbbbbbbbbbbbbbb);"); 7043 7044 // These are not casts. 7045 verifyFormat("void f(int *) {}"); 7046 verifyFormat("f(foo)->b;"); 7047 verifyFormat("f(foo).b;"); 7048 verifyFormat("f(foo)(b);"); 7049 verifyFormat("f(foo)[b];"); 7050 verifyFormat("[](foo) { return 4; }(bar);"); 7051 verifyFormat("(*funptr)(foo)[4];"); 7052 verifyFormat("funptrs[4](foo)[4];"); 7053 verifyFormat("void f(int *);"); 7054 verifyFormat("void f(int *) = 0;"); 7055 verifyFormat("void f(SmallVector<int>) {}"); 7056 verifyFormat("void f(SmallVector<int>);"); 7057 verifyFormat("void f(SmallVector<int>) = 0;"); 7058 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7059 verifyFormat("int a = sizeof(int) * b;"); 7060 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7061 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7062 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7063 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7064 7065 // These are not casts, but at some point were confused with casts. 7066 verifyFormat("virtual void foo(int *) override;"); 7067 verifyFormat("virtual void foo(char &) const;"); 7068 verifyFormat("virtual void foo(int *a, char *) const;"); 7069 verifyFormat("int a = sizeof(int *) + b;"); 7070 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7071 verifyFormat("bool b = f(g<int>) && c;"); 7072 verifyFormat("typedef void (*f)(int i) func;"); 7073 7074 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7075 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7076 // FIXME: The indentation here is not ideal. 7077 verifyFormat( 7078 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7079 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7080 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7081 } 7082 7083 TEST_F(FormatTest, FormatsFunctionTypes) { 7084 verifyFormat("A<bool()> a;"); 7085 verifyFormat("A<SomeType()> a;"); 7086 verifyFormat("A<void (*)(int, std::string)> a;"); 7087 verifyFormat("A<void *(int)>;"); 7088 verifyFormat("void *(*a)(int *, SomeType *);"); 7089 verifyFormat("int (*func)(void *);"); 7090 verifyFormat("void f() { int (*func)(void *); }"); 7091 verifyFormat("template <class CallbackClass>\n" 7092 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7093 7094 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7095 verifyGoogleFormat("void* (*a)(int);"); 7096 verifyGoogleFormat( 7097 "template <class CallbackClass>\n" 7098 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7099 7100 // Other constructs can look somewhat like function types: 7101 verifyFormat("A<sizeof(*x)> a;"); 7102 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7103 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7104 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7105 verifyFormat("int x = f(&h)();"); 7106 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7107 verifyFormat("std::function<\n" 7108 " LooooooooooongTemplatedType<\n" 7109 " SomeType>*(\n" 7110 " LooooooooooooooooongType type)>\n" 7111 " function;", 7112 getGoogleStyleWithColumns(40)); 7113 } 7114 7115 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7116 verifyFormat("A (*foo_)[6];"); 7117 verifyFormat("vector<int> (*foo_)[6];"); 7118 } 7119 7120 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7121 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7122 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7123 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7124 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7125 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7126 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7127 7128 // Different ways of ()-initializiation. 7129 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7130 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7131 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7132 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7133 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7134 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7135 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7136 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7137 7138 // Lambdas should not confuse the variable declaration heuristic. 7139 verifyFormat("LooooooooooooooooongType\n" 7140 " variable(nullptr, [](A *a) {});", 7141 getLLVMStyleWithColumns(40)); 7142 } 7143 7144 TEST_F(FormatTest, BreaksLongDeclarations) { 7145 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7146 " AnotherNameForTheLongType;"); 7147 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7148 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7149 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7150 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7151 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7152 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7153 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7154 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7155 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7156 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7157 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7158 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7159 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7160 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7161 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7162 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7163 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7164 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7165 FormatStyle Indented = getLLVMStyle(); 7166 Indented.IndentWrappedFunctionNames = true; 7167 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7168 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7169 Indented); 7170 verifyFormat( 7171 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7172 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7173 Indented); 7174 verifyFormat( 7175 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7176 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7177 Indented); 7178 verifyFormat( 7179 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7180 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7181 Indented); 7182 7183 // FIXME: Without the comment, this breaks after "(". 7184 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7185 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7186 getGoogleStyle()); 7187 7188 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7189 " int LoooooooooooooooooooongParam2) {}"); 7190 verifyFormat( 7191 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7192 " SourceLocation L, IdentifierIn *II,\n" 7193 " Type *T) {}"); 7194 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7195 "ReallyReaaallyLongFunctionName(\n" 7196 " const std::string &SomeParameter,\n" 7197 " const SomeType<string, SomeOtherTemplateParameter>\n" 7198 " &ReallyReallyLongParameterName,\n" 7199 " const SomeType<string, SomeOtherTemplateParameter>\n" 7200 " &AnotherLongParameterName) {}"); 7201 verifyFormat("template <typename A>\n" 7202 "SomeLoooooooooooooooooooooongType<\n" 7203 " typename some_namespace::SomeOtherType<A>::Type>\n" 7204 "Function() {}"); 7205 7206 verifyGoogleFormat( 7207 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7208 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7209 verifyGoogleFormat( 7210 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7211 " SourceLocation L) {}"); 7212 verifyGoogleFormat( 7213 "some_namespace::LongReturnType\n" 7214 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7215 " int first_long_parameter, int second_parameter) {}"); 7216 7217 verifyGoogleFormat("template <typename T>\n" 7218 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7219 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7220 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7221 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7222 7223 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7224 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7225 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7226 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7227 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7228 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 7229 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7230 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 7231 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 7232 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7233 7234 verifyFormat("template <typename T> // Templates on own line.\n" 7235 "static int // Some comment.\n" 7236 "MyFunction(int a);", 7237 getLLVMStyle()); 7238 } 7239 7240 TEST_F(FormatTest, FormatsArrays) { 7241 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7242 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 7243 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 7244 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 7245 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 7246 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 7247 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7248 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7249 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7250 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 7251 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7252 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7253 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7254 verifyFormat( 7255 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 7256 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7257 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 7258 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 7259 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7260 7261 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 7262 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 7263 verifyFormat( 7264 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 7265 " .aaaaaaa[0]\n" 7266 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7267 verifyFormat("a[::b::c];"); 7268 7269 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 7270 7271 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 7272 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 7273 } 7274 7275 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 7276 verifyFormat("(a)->b();"); 7277 verifyFormat("--a;"); 7278 } 7279 7280 TEST_F(FormatTest, HandlesIncludeDirectives) { 7281 verifyFormat("#include <string>\n" 7282 "#include <a/b/c.h>\n" 7283 "#include \"a/b/string\"\n" 7284 "#include \"string.h\"\n" 7285 "#include \"string.h\"\n" 7286 "#include <a-a>\n" 7287 "#include < path with space >\n" 7288 "#include_next <test.h>" 7289 "#include \"abc.h\" // this is included for ABC\n" 7290 "#include \"some long include\" // with a comment\n" 7291 "#include \"some very long include path\"\n" 7292 "#include <some/very/long/include/path>\n", 7293 getLLVMStyleWithColumns(35)); 7294 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 7295 EXPECT_EQ("#include <a>", format("#include<a>")); 7296 7297 verifyFormat("#import <string>"); 7298 verifyFormat("#import <a/b/c.h>"); 7299 verifyFormat("#import \"a/b/string\""); 7300 verifyFormat("#import \"string.h\""); 7301 verifyFormat("#import \"string.h\""); 7302 verifyFormat("#if __has_include(<strstream>)\n" 7303 "#include <strstream>\n" 7304 "#endif"); 7305 7306 verifyFormat("#define MY_IMPORT <a/b>"); 7307 7308 verifyFormat("#if __has_include(<a/b>)"); 7309 verifyFormat("#if __has_include_next(<a/b>)"); 7310 verifyFormat("#define F __has_include(<a/b>)"); 7311 verifyFormat("#define F __has_include_next(<a/b>)"); 7312 7313 // Protocol buffer definition or missing "#". 7314 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 7315 getLLVMStyleWithColumns(30)); 7316 7317 FormatStyle Style = getLLVMStyle(); 7318 Style.AlwaysBreakBeforeMultilineStrings = true; 7319 Style.ColumnLimit = 0; 7320 verifyFormat("#import \"abc.h\"", Style); 7321 7322 // But 'import' might also be a regular C++ namespace. 7323 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7324 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7325 } 7326 7327 //===----------------------------------------------------------------------===// 7328 // Error recovery tests. 7329 //===----------------------------------------------------------------------===// 7330 7331 TEST_F(FormatTest, IncompleteParameterLists) { 7332 FormatStyle NoBinPacking = getLLVMStyle(); 7333 NoBinPacking.BinPackParameters = false; 7334 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 7335 " double *min_x,\n" 7336 " double *max_x,\n" 7337 " double *min_y,\n" 7338 " double *max_y,\n" 7339 " double *min_z,\n" 7340 " double *max_z, ) {}", 7341 NoBinPacking); 7342 } 7343 7344 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 7345 verifyFormat("void f() { return; }\n42"); 7346 verifyFormat("void f() {\n" 7347 " if (0)\n" 7348 " return;\n" 7349 "}\n" 7350 "42"); 7351 verifyFormat("void f() { return }\n42"); 7352 verifyFormat("void f() {\n" 7353 " if (0)\n" 7354 " return\n" 7355 "}\n" 7356 "42"); 7357 } 7358 7359 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 7360 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 7361 EXPECT_EQ("void f() {\n" 7362 " if (a)\n" 7363 " return\n" 7364 "}", 7365 format("void f ( ) { if ( a ) return }")); 7366 EXPECT_EQ("namespace N {\n" 7367 "void f()\n" 7368 "}", 7369 format("namespace N { void f() }")); 7370 EXPECT_EQ("namespace N {\n" 7371 "void f() {}\n" 7372 "void g()\n" 7373 "} // namespace N", 7374 format("namespace N { void f( ) { } void g( ) }")); 7375 } 7376 7377 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 7378 verifyFormat("int aaaaaaaa =\n" 7379 " // Overlylongcomment\n" 7380 " b;", 7381 getLLVMStyleWithColumns(20)); 7382 verifyFormat("function(\n" 7383 " ShortArgument,\n" 7384 " LoooooooooooongArgument);\n", 7385 getLLVMStyleWithColumns(20)); 7386 } 7387 7388 TEST_F(FormatTest, IncorrectAccessSpecifier) { 7389 verifyFormat("public:"); 7390 verifyFormat("class A {\n" 7391 "public\n" 7392 " void f() {}\n" 7393 "};"); 7394 verifyFormat("public\n" 7395 "int qwerty;"); 7396 verifyFormat("public\n" 7397 "B {}"); 7398 verifyFormat("public\n" 7399 "{}"); 7400 verifyFormat("public\n" 7401 "B { int x; }"); 7402 } 7403 7404 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 7405 verifyFormat("{"); 7406 verifyFormat("#})"); 7407 verifyNoCrash("(/**/[:!] ?[)."); 7408 } 7409 7410 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 7411 // Found by oss-fuzz: 7412 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 7413 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 7414 Style.ColumnLimit = 60; 7415 verifyNoCrash( 7416 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 7417 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 7418 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 7419 Style); 7420 } 7421 7422 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 7423 verifyFormat("do {\n}"); 7424 verifyFormat("do {\n}\n" 7425 "f();"); 7426 verifyFormat("do {\n}\n" 7427 "wheeee(fun);"); 7428 verifyFormat("do {\n" 7429 " f();\n" 7430 "}"); 7431 } 7432 7433 TEST_F(FormatTest, IncorrectCodeMissingParens) { 7434 verifyFormat("if {\n foo;\n foo();\n}"); 7435 verifyFormat("switch {\n foo;\n foo();\n}"); 7436 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 7437 verifyFormat("while {\n foo;\n foo();\n}"); 7438 verifyFormat("do {\n foo;\n foo();\n} while;"); 7439 } 7440 7441 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 7442 verifyIncompleteFormat("namespace {\n" 7443 "class Foo { Foo (\n" 7444 "};\n" 7445 "} // namespace"); 7446 } 7447 7448 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 7449 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 7450 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 7451 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 7452 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 7453 7454 EXPECT_EQ("{\n" 7455 " {\n" 7456 " breakme(\n" 7457 " qwe);\n" 7458 " }\n", 7459 format("{\n" 7460 " {\n" 7461 " breakme(qwe);\n" 7462 "}\n", 7463 getLLVMStyleWithColumns(10))); 7464 } 7465 7466 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 7467 verifyFormat("int x = {\n" 7468 " avariable,\n" 7469 " b(alongervariable)};", 7470 getLLVMStyleWithColumns(25)); 7471 } 7472 7473 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 7474 verifyFormat("return (a)(b){1, 2, 3};"); 7475 } 7476 7477 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 7478 verifyFormat("vector<int> x{1, 2, 3, 4};"); 7479 verifyFormat("vector<int> x{\n" 7480 " 1,\n" 7481 " 2,\n" 7482 " 3,\n" 7483 " 4,\n" 7484 "};"); 7485 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 7486 verifyFormat("f({1, 2});"); 7487 verifyFormat("auto v = Foo{-1};"); 7488 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 7489 verifyFormat("Class::Class : member{1, 2, 3} {}"); 7490 verifyFormat("new vector<int>{1, 2, 3};"); 7491 verifyFormat("new int[3]{1, 2, 3};"); 7492 verifyFormat("new int{1};"); 7493 verifyFormat("return {arg1, arg2};"); 7494 verifyFormat("return {arg1, SomeType{parameter}};"); 7495 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 7496 verifyFormat("new T{arg1, arg2};"); 7497 verifyFormat("f(MyMap[{composite, key}]);"); 7498 verifyFormat("class Class {\n" 7499 " T member = {arg1, arg2};\n" 7500 "};"); 7501 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 7502 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 7503 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 7504 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 7505 verifyFormat("int a = std::is_integral<int>{} + 0;"); 7506 7507 verifyFormat("int foo(int i) { return fo1{}(i); }"); 7508 verifyFormat("int foo(int i) { return fo1{}(i); }"); 7509 verifyFormat("auto i = decltype(x){};"); 7510 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 7511 verifyFormat("Node n{1, Node{1000}, //\n" 7512 " 2};"); 7513 verifyFormat("Aaaa aaaaaaa{\n" 7514 " {\n" 7515 " aaaa,\n" 7516 " },\n" 7517 "};"); 7518 verifyFormat("class C : public D {\n" 7519 " SomeClass SC{2};\n" 7520 "};"); 7521 verifyFormat("class C : public A {\n" 7522 " class D : public B {\n" 7523 " void f() { int i{2}; }\n" 7524 " };\n" 7525 "};"); 7526 verifyFormat("#define A {a, a},"); 7527 7528 // Avoid breaking between equal sign and opening brace 7529 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 7530 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 7531 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 7532 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 7533 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 7534 " {\"ccccccccccccccccccccc\", 2}};", 7535 AvoidBreakingFirstArgument); 7536 7537 // Binpacking only if there is no trailing comma 7538 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 7539 " cccccccccc, dddddddddd};", 7540 getLLVMStyleWithColumns(50)); 7541 verifyFormat("const Aaaaaa aaaaa = {\n" 7542 " aaaaaaaaaaa,\n" 7543 " bbbbbbbbbbb,\n" 7544 " ccccccccccc,\n" 7545 " ddddddddddd,\n" 7546 "};", getLLVMStyleWithColumns(50)); 7547 7548 // Cases where distinguising braced lists and blocks is hard. 7549 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 7550 verifyFormat("void f() {\n" 7551 " return; // comment\n" 7552 "}\n" 7553 "SomeType t;"); 7554 verifyFormat("void f() {\n" 7555 " if (a) {\n" 7556 " f();\n" 7557 " }\n" 7558 "}\n" 7559 "SomeType t;"); 7560 7561 // In combination with BinPackArguments = false. 7562 FormatStyle NoBinPacking = getLLVMStyle(); 7563 NoBinPacking.BinPackArguments = false; 7564 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 7565 " bbbbb,\n" 7566 " ccccc,\n" 7567 " ddddd,\n" 7568 " eeeee,\n" 7569 " ffffff,\n" 7570 " ggggg,\n" 7571 " hhhhhh,\n" 7572 " iiiiii,\n" 7573 " jjjjjj,\n" 7574 " kkkkkk};", 7575 NoBinPacking); 7576 verifyFormat("const Aaaaaa aaaaa = {\n" 7577 " aaaaa,\n" 7578 " bbbbb,\n" 7579 " ccccc,\n" 7580 " ddddd,\n" 7581 " eeeee,\n" 7582 " ffffff,\n" 7583 " ggggg,\n" 7584 " hhhhhh,\n" 7585 " iiiiii,\n" 7586 " jjjjjj,\n" 7587 " kkkkkk,\n" 7588 "};", 7589 NoBinPacking); 7590 verifyFormat( 7591 "const Aaaaaa aaaaa = {\n" 7592 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 7593 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 7594 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 7595 "};", 7596 NoBinPacking); 7597 7598 // FIXME: The alignment of these trailing comments might be bad. Then again, 7599 // this might be utterly useless in real code. 7600 verifyFormat("Constructor::Constructor()\n" 7601 " : some_value{ //\n" 7602 " aaaaaaa, //\n" 7603 " bbbbbbb} {}"); 7604 7605 // In braced lists, the first comment is always assumed to belong to the 7606 // first element. Thus, it can be moved to the next or previous line as 7607 // appropriate. 7608 EXPECT_EQ("function({// First element:\n" 7609 " 1,\n" 7610 " // Second element:\n" 7611 " 2});", 7612 format("function({\n" 7613 " // First element:\n" 7614 " 1,\n" 7615 " // Second element:\n" 7616 " 2});")); 7617 EXPECT_EQ("std::vector<int> MyNumbers{\n" 7618 " // First element:\n" 7619 " 1,\n" 7620 " // Second element:\n" 7621 " 2};", 7622 format("std::vector<int> MyNumbers{// First element:\n" 7623 " 1,\n" 7624 " // Second element:\n" 7625 " 2};", 7626 getLLVMStyleWithColumns(30))); 7627 // A trailing comma should still lead to an enforced line break and no 7628 // binpacking. 7629 EXPECT_EQ("vector<int> SomeVector = {\n" 7630 " // aaa\n" 7631 " 1,\n" 7632 " 2,\n" 7633 "};", 7634 format("vector<int> SomeVector = { // aaa\n" 7635 " 1, 2, };")); 7636 7637 FormatStyle ExtraSpaces = getLLVMStyle(); 7638 ExtraSpaces.Cpp11BracedListStyle = false; 7639 ExtraSpaces.ColumnLimit = 75; 7640 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 7641 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 7642 verifyFormat("f({ 1, 2 });", ExtraSpaces); 7643 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 7644 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 7645 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 7646 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 7647 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 7648 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 7649 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 7650 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 7651 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 7652 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 7653 verifyFormat("class Class {\n" 7654 " T member = { arg1, arg2 };\n" 7655 "};", 7656 ExtraSpaces); 7657 verifyFormat( 7658 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7659 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 7660 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 7661 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 7662 ExtraSpaces); 7663 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 7664 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 7665 ExtraSpaces); 7666 verifyFormat( 7667 "someFunction(OtherParam,\n" 7668 " BracedList{ // comment 1 (Forcing interesting break)\n" 7669 " param1, param2,\n" 7670 " // comment 2\n" 7671 " param3, param4 });", 7672 ExtraSpaces); 7673 verifyFormat( 7674 "std::this_thread::sleep_for(\n" 7675 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 7676 ExtraSpaces); 7677 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 7678 " aaaaaaa,\n" 7679 " aaaaaaaaaa,\n" 7680 " aaaaa,\n" 7681 " aaaaaaaaaaaaaaa,\n" 7682 " aaa,\n" 7683 " aaaaaaaaaa,\n" 7684 " a,\n" 7685 " aaaaaaaaaaaaaaaaaaaaa,\n" 7686 " aaaaaaaaaaaa,\n" 7687 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 7688 " aaaaaaa,\n" 7689 " a};"); 7690 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 7691 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 7692 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 7693 7694 // Avoid breaking between initializer/equal sign and opening brace 7695 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 7696 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 7697 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 7698 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 7699 " { \"ccccccccccccccccccccc\", 2 }\n" 7700 "};", 7701 ExtraSpaces); 7702 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 7703 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 7704 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 7705 " { \"ccccccccccccccccccccc\", 2 }\n" 7706 "};", 7707 ExtraSpaces); 7708 7709 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 7710 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 7711 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 7712 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 7713 } 7714 7715 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 7716 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7717 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7718 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7719 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7720 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7721 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 7722 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 7723 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7724 " 1, 22, 333, 4444, 55555, //\n" 7725 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7726 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 7727 verifyFormat( 7728 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7729 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7730 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 7731 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 7732 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 7733 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 7734 " 7777777};"); 7735 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 7736 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 7737 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 7738 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 7739 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 7740 " // Separating comment.\n" 7741 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 7742 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 7743 " // Leading comment\n" 7744 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 7745 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 7746 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 7747 " 1, 1, 1, 1};", 7748 getLLVMStyleWithColumns(39)); 7749 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 7750 " 1, 1, 1, 1};", 7751 getLLVMStyleWithColumns(38)); 7752 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 7753 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 7754 getLLVMStyleWithColumns(43)); 7755 verifyFormat( 7756 "static unsigned SomeValues[10][3] = {\n" 7757 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 7758 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 7759 verifyFormat("static auto fields = new vector<string>{\n" 7760 " \"aaaaaaaaaaaaa\",\n" 7761 " \"aaaaaaaaaaaaa\",\n" 7762 " \"aaaaaaaaaaaa\",\n" 7763 " \"aaaaaaaaaaaaaa\",\n" 7764 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 7765 " \"aaaaaaaaaaaa\",\n" 7766 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 7767 "};"); 7768 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 7769 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 7770 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 7771 " 3, cccccccccccccccccccccc};", 7772 getLLVMStyleWithColumns(60)); 7773 7774 // Trailing commas. 7775 verifyFormat("vector<int> x = {\n" 7776 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 7777 "};", 7778 getLLVMStyleWithColumns(39)); 7779 verifyFormat("vector<int> x = {\n" 7780 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 7781 "};", 7782 getLLVMStyleWithColumns(39)); 7783 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 7784 " 1, 1, 1, 1,\n" 7785 " /**/ /**/};", 7786 getLLVMStyleWithColumns(39)); 7787 7788 // Trailing comment in the first line. 7789 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 7790 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 7791 " 111111111, 222222222, 3333333333, 444444444, //\n" 7792 " 11111111, 22222222, 333333333, 44444444};"); 7793 // Trailing comment in the last line. 7794 verifyFormat("int aaaaa[] = {\n" 7795 " 1, 2, 3, // comment\n" 7796 " 4, 5, 6 // comment\n" 7797 "};"); 7798 7799 // With nested lists, we should either format one item per line or all nested 7800 // lists one on line. 7801 // FIXME: For some nested lists, we can do better. 7802 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 7803 " {aaaaaaaaaaaaaaaaaaa},\n" 7804 " {aaaaaaaaaaaaaaaaaaaaa},\n" 7805 " {aaaaaaaaaaaaaaaaa}};", 7806 getLLVMStyleWithColumns(60)); 7807 verifyFormat( 7808 "SomeStruct my_struct_array = {\n" 7809 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 7810 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 7811 " {aaa, aaa},\n" 7812 " {aaa, aaa},\n" 7813 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 7814 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 7815 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 7816 7817 // No column layout should be used here. 7818 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 7819 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 7820 7821 verifyNoCrash("a<,"); 7822 7823 // No braced initializer here. 7824 verifyFormat("void f() {\n" 7825 " struct Dummy {};\n" 7826 " f(v);\n" 7827 "}"); 7828 7829 // Long lists should be formatted in columns even if they are nested. 7830 verifyFormat( 7831 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7832 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7833 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7834 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7835 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7836 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 7837 7838 // Allow "single-column" layout even if that violates the column limit. There 7839 // isn't going to be a better way. 7840 verifyFormat("std::vector<int> a = {\n" 7841 " aaaaaaaa,\n" 7842 " aaaaaaaa,\n" 7843 " aaaaaaaa,\n" 7844 " aaaaaaaa,\n" 7845 " aaaaaaaaaa,\n" 7846 " aaaaaaaa,\n" 7847 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 7848 getLLVMStyleWithColumns(30)); 7849 verifyFormat("vector<int> aaaa = {\n" 7850 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7851 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7852 " aaaaaa.aaaaaaa,\n" 7853 " aaaaaa.aaaaaaa,\n" 7854 " aaaaaa.aaaaaaa,\n" 7855 " aaaaaa.aaaaaaa,\n" 7856 "};"); 7857 7858 // Don't create hanging lists. 7859 verifyFormat("someFunction(Param, {List1, List2,\n" 7860 " List3});", 7861 getLLVMStyleWithColumns(35)); 7862 verifyFormat("someFunction(Param, Param,\n" 7863 " {List1, List2,\n" 7864 " List3});", 7865 getLLVMStyleWithColumns(35)); 7866 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 7867 " aaaaaaaaaaaaaaaaaaaaaaa);"); 7868 } 7869 7870 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 7871 FormatStyle DoNotMerge = getLLVMStyle(); 7872 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7873 7874 verifyFormat("void f() { return 42; }"); 7875 verifyFormat("void f() {\n" 7876 " return 42;\n" 7877 "}", 7878 DoNotMerge); 7879 verifyFormat("void f() {\n" 7880 " // Comment\n" 7881 "}"); 7882 verifyFormat("{\n" 7883 "#error {\n" 7884 " int a;\n" 7885 "}"); 7886 verifyFormat("{\n" 7887 " int a;\n" 7888 "#error {\n" 7889 "}"); 7890 verifyFormat("void f() {} // comment"); 7891 verifyFormat("void f() { int a; } // comment"); 7892 verifyFormat("void f() {\n" 7893 "} // comment", 7894 DoNotMerge); 7895 verifyFormat("void f() {\n" 7896 " int a;\n" 7897 "} // comment", 7898 DoNotMerge); 7899 verifyFormat("void f() {\n" 7900 "} // comment", 7901 getLLVMStyleWithColumns(15)); 7902 7903 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 7904 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 7905 7906 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 7907 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 7908 verifyFormat("class C {\n" 7909 " C()\n" 7910 " : iiiiiiii(nullptr),\n" 7911 " kkkkkkk(nullptr),\n" 7912 " mmmmmmm(nullptr),\n" 7913 " nnnnnnn(nullptr) {}\n" 7914 "};", 7915 getGoogleStyle()); 7916 7917 FormatStyle NoColumnLimit = getLLVMStyle(); 7918 NoColumnLimit.ColumnLimit = 0; 7919 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 7920 EXPECT_EQ("class C {\n" 7921 " A() : b(0) {}\n" 7922 "};", 7923 format("class C{A():b(0){}};", NoColumnLimit)); 7924 EXPECT_EQ("A()\n" 7925 " : b(0) {\n" 7926 "}", 7927 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 7928 7929 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 7930 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 7931 FormatStyle::SFS_None; 7932 EXPECT_EQ("A()\n" 7933 " : b(0) {\n" 7934 "}", 7935 format("A():b(0){}", DoNotMergeNoColumnLimit)); 7936 EXPECT_EQ("A()\n" 7937 " : b(0) {\n" 7938 "}", 7939 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 7940 7941 verifyFormat("#define A \\\n" 7942 " void f() { \\\n" 7943 " int i; \\\n" 7944 " }", 7945 getLLVMStyleWithColumns(20)); 7946 verifyFormat("#define A \\\n" 7947 " void f() { int i; }", 7948 getLLVMStyleWithColumns(21)); 7949 verifyFormat("#define A \\\n" 7950 " void f() { \\\n" 7951 " int i; \\\n" 7952 " } \\\n" 7953 " int j;", 7954 getLLVMStyleWithColumns(22)); 7955 verifyFormat("#define A \\\n" 7956 " void f() { int i; } \\\n" 7957 " int j;", 7958 getLLVMStyleWithColumns(23)); 7959 } 7960 7961 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 7962 FormatStyle MergeEmptyOnly = getLLVMStyle(); 7963 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 7964 verifyFormat("class C {\n" 7965 " int f() {}\n" 7966 "};", 7967 MergeEmptyOnly); 7968 verifyFormat("class C {\n" 7969 " int f() {\n" 7970 " return 42;\n" 7971 " }\n" 7972 "};", 7973 MergeEmptyOnly); 7974 verifyFormat("int f() {}", MergeEmptyOnly); 7975 verifyFormat("int f() {\n" 7976 " return 42;\n" 7977 "}", 7978 MergeEmptyOnly); 7979 7980 // Also verify behavior when BraceWrapping.AfterFunction = true 7981 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 7982 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 7983 verifyFormat("int f() {}", MergeEmptyOnly); 7984 verifyFormat("class C {\n" 7985 " int f() {}\n" 7986 "};", 7987 MergeEmptyOnly); 7988 } 7989 7990 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 7991 FormatStyle MergeInlineOnly = getLLVMStyle(); 7992 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 7993 verifyFormat("class C {\n" 7994 " int f() { return 42; }\n" 7995 "};", 7996 MergeInlineOnly); 7997 verifyFormat("int f() {\n" 7998 " return 42;\n" 7999 "}", 8000 MergeInlineOnly); 8001 8002 // SFS_Inline implies SFS_Empty 8003 verifyFormat("class C {\n" 8004 " int f() {}\n" 8005 "};", 8006 MergeInlineOnly); 8007 verifyFormat("int f() {}", MergeInlineOnly); 8008 8009 // Also verify behavior when BraceWrapping.AfterFunction = true 8010 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8011 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8012 verifyFormat("class C {\n" 8013 " int f() { return 42; }\n" 8014 "};", 8015 MergeInlineOnly); 8016 verifyFormat("int f()\n" 8017 "{\n" 8018 " return 42;\n" 8019 "}", 8020 MergeInlineOnly); 8021 8022 // SFS_Inline implies SFS_Empty 8023 verifyFormat("int f() {}", MergeInlineOnly); 8024 verifyFormat("class C {\n" 8025 " int f() {}\n" 8026 "};", 8027 MergeInlineOnly); 8028 } 8029 8030 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8031 FormatStyle MergeInlineOnly = getLLVMStyle(); 8032 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8033 FormatStyle::SFS_InlineOnly; 8034 verifyFormat("class C {\n" 8035 " int f() { return 42; }\n" 8036 "};", 8037 MergeInlineOnly); 8038 verifyFormat("int f() {\n" 8039 " return 42;\n" 8040 "}", 8041 MergeInlineOnly); 8042 8043 // SFS_InlineOnly does not imply SFS_Empty 8044 verifyFormat("class C {\n" 8045 " int f() {}\n" 8046 "};", 8047 MergeInlineOnly); 8048 verifyFormat("int f() {\n" 8049 "}", 8050 MergeInlineOnly); 8051 8052 // Also verify behavior when BraceWrapping.AfterFunction = true 8053 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8054 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8055 verifyFormat("class C {\n" 8056 " int f() { return 42; }\n" 8057 "};", 8058 MergeInlineOnly); 8059 verifyFormat("int f()\n" 8060 "{\n" 8061 " return 42;\n" 8062 "}", 8063 MergeInlineOnly); 8064 8065 // SFS_InlineOnly does not imply SFS_Empty 8066 verifyFormat("int f()\n" 8067 "{\n" 8068 "}", 8069 MergeInlineOnly); 8070 verifyFormat("class C {\n" 8071 " int f() {}\n" 8072 "};", 8073 MergeInlineOnly); 8074 } 8075 8076 TEST_F(FormatTest, SplitEmptyFunction) { 8077 FormatStyle Style = getLLVMStyle(); 8078 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8079 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8080 Style.BraceWrapping.AfterFunction = true; 8081 Style.BraceWrapping.SplitEmptyFunction = false; 8082 Style.ColumnLimit = 40; 8083 8084 verifyFormat("int f()\n" 8085 "{}", 8086 Style); 8087 verifyFormat("int f()\n" 8088 "{\n" 8089 " return 42;\n" 8090 "}", 8091 Style); 8092 verifyFormat("int f()\n" 8093 "{\n" 8094 " // some comment\n" 8095 "}", 8096 Style); 8097 8098 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8099 verifyFormat("int f() {}", Style); 8100 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8101 "{}", 8102 Style); 8103 verifyFormat("int f()\n" 8104 "{\n" 8105 " return 0;\n" 8106 "}", 8107 Style); 8108 8109 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8110 verifyFormat("class Foo {\n" 8111 " int f() {}\n" 8112 "};\n", 8113 Style); 8114 verifyFormat("class Foo {\n" 8115 " int f() { return 0; }\n" 8116 "};\n", 8117 Style); 8118 verifyFormat("class Foo {\n" 8119 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8120 " {}\n" 8121 "};\n", 8122 Style); 8123 verifyFormat("class Foo {\n" 8124 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8125 " {\n" 8126 " return 0;\n" 8127 " }\n" 8128 "};\n", 8129 Style); 8130 8131 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8132 verifyFormat("int f() {}", Style); 8133 verifyFormat("int f() { return 0; }", Style); 8134 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8135 "{}", 8136 Style); 8137 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8138 "{\n" 8139 " return 0;\n" 8140 "}", 8141 Style); 8142 } 8143 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8144 FormatStyle Style = getLLVMStyle(); 8145 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8146 verifyFormat("#ifdef A\n" 8147 "int f() {}\n" 8148 "#else\n" 8149 "int g() {}\n" 8150 "#endif", 8151 Style); 8152 } 8153 8154 TEST_F(FormatTest, SplitEmptyClass) { 8155 FormatStyle Style = getLLVMStyle(); 8156 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8157 Style.BraceWrapping.AfterClass = true; 8158 Style.BraceWrapping.SplitEmptyRecord = false; 8159 8160 verifyFormat("class Foo\n" 8161 "{};", 8162 Style); 8163 verifyFormat("/* something */ class Foo\n" 8164 "{};", 8165 Style); 8166 verifyFormat("template <typename X> class Foo\n" 8167 "{};", 8168 Style); 8169 verifyFormat("class Foo\n" 8170 "{\n" 8171 " Foo();\n" 8172 "};", 8173 Style); 8174 verifyFormat("typedef class Foo\n" 8175 "{\n" 8176 "} Foo_t;", 8177 Style); 8178 } 8179 8180 TEST_F(FormatTest, SplitEmptyStruct) { 8181 FormatStyle Style = getLLVMStyle(); 8182 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8183 Style.BraceWrapping.AfterStruct = true; 8184 Style.BraceWrapping.SplitEmptyRecord = false; 8185 8186 verifyFormat("struct Foo\n" 8187 "{};", 8188 Style); 8189 verifyFormat("/* something */ struct Foo\n" 8190 "{};", 8191 Style); 8192 verifyFormat("template <typename X> struct Foo\n" 8193 "{};", 8194 Style); 8195 verifyFormat("struct Foo\n" 8196 "{\n" 8197 " Foo();\n" 8198 "};", 8199 Style); 8200 verifyFormat("typedef struct Foo\n" 8201 "{\n" 8202 "} Foo_t;", 8203 Style); 8204 //typedef struct Bar {} Bar_t; 8205 } 8206 8207 TEST_F(FormatTest, SplitEmptyUnion) { 8208 FormatStyle Style = getLLVMStyle(); 8209 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8210 Style.BraceWrapping.AfterUnion = true; 8211 Style.BraceWrapping.SplitEmptyRecord = false; 8212 8213 verifyFormat("union Foo\n" 8214 "{};", 8215 Style); 8216 verifyFormat("/* something */ union Foo\n" 8217 "{};", 8218 Style); 8219 verifyFormat("union Foo\n" 8220 "{\n" 8221 " A,\n" 8222 "};", 8223 Style); 8224 verifyFormat("typedef union Foo\n" 8225 "{\n" 8226 "} Foo_t;", 8227 Style); 8228 } 8229 8230 TEST_F(FormatTest, SplitEmptyNamespace) { 8231 FormatStyle Style = getLLVMStyle(); 8232 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8233 Style.BraceWrapping.AfterNamespace = true; 8234 Style.BraceWrapping.SplitEmptyNamespace = false; 8235 8236 verifyFormat("namespace Foo\n" 8237 "{};", 8238 Style); 8239 verifyFormat("/* something */ namespace Foo\n" 8240 "{};", 8241 Style); 8242 verifyFormat("inline namespace Foo\n" 8243 "{};", 8244 Style); 8245 verifyFormat("/* something */ inline namespace Foo\n" 8246 "{};", 8247 Style); 8248 verifyFormat("export namespace Foo\n" 8249 "{};", 8250 Style); 8251 verifyFormat("namespace Foo\n" 8252 "{\n" 8253 "void Bar();\n" 8254 "};", 8255 Style); 8256 } 8257 8258 TEST_F(FormatTest, NeverMergeShortRecords) { 8259 FormatStyle Style = getLLVMStyle(); 8260 8261 verifyFormat("class Foo {\n" 8262 " Foo();\n" 8263 "};", 8264 Style); 8265 verifyFormat("typedef class Foo {\n" 8266 " Foo();\n" 8267 "} Foo_t;", 8268 Style); 8269 verifyFormat("struct Foo {\n" 8270 " Foo();\n" 8271 "};", 8272 Style); 8273 verifyFormat("typedef struct Foo {\n" 8274 " Foo();\n" 8275 "} Foo_t;", 8276 Style); 8277 verifyFormat("union Foo {\n" 8278 " A,\n" 8279 "};", 8280 Style); 8281 verifyFormat("typedef union Foo {\n" 8282 " A,\n" 8283 "} Foo_t;", 8284 Style); 8285 verifyFormat("namespace Foo {\n" 8286 "void Bar();\n" 8287 "};", 8288 Style); 8289 8290 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8291 Style.BraceWrapping.AfterClass = true; 8292 Style.BraceWrapping.AfterStruct = true; 8293 Style.BraceWrapping.AfterUnion = true; 8294 Style.BraceWrapping.AfterNamespace = true; 8295 verifyFormat("class Foo\n" 8296 "{\n" 8297 " Foo();\n" 8298 "};", 8299 Style); 8300 verifyFormat("typedef class Foo\n" 8301 "{\n" 8302 " Foo();\n" 8303 "} Foo_t;", 8304 Style); 8305 verifyFormat("struct Foo\n" 8306 "{\n" 8307 " Foo();\n" 8308 "};", 8309 Style); 8310 verifyFormat("typedef struct Foo\n" 8311 "{\n" 8312 " Foo();\n" 8313 "} Foo_t;", 8314 Style); 8315 verifyFormat("union Foo\n" 8316 "{\n" 8317 " A,\n" 8318 "};", 8319 Style); 8320 verifyFormat("typedef union Foo\n" 8321 "{\n" 8322 " A,\n" 8323 "} Foo_t;", 8324 Style); 8325 verifyFormat("namespace Foo\n" 8326 "{\n" 8327 "void Bar();\n" 8328 "};", 8329 Style); 8330 } 8331 8332 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 8333 // Elaborate type variable declarations. 8334 verifyFormat("struct foo a = {bar};\nint n;"); 8335 verifyFormat("class foo a = {bar};\nint n;"); 8336 verifyFormat("union foo a = {bar};\nint n;"); 8337 8338 // Elaborate types inside function definitions. 8339 verifyFormat("struct foo f() {}\nint n;"); 8340 verifyFormat("class foo f() {}\nint n;"); 8341 verifyFormat("union foo f() {}\nint n;"); 8342 8343 // Templates. 8344 verifyFormat("template <class X> void f() {}\nint n;"); 8345 verifyFormat("template <struct X> void f() {}\nint n;"); 8346 verifyFormat("template <union X> void f() {}\nint n;"); 8347 8348 // Actual definitions... 8349 verifyFormat("struct {\n} n;"); 8350 verifyFormat( 8351 "template <template <class T, class Y>, class Z> class X {\n} n;"); 8352 verifyFormat("union Z {\n int n;\n} x;"); 8353 verifyFormat("class MACRO Z {\n} n;"); 8354 verifyFormat("class MACRO(X) Z {\n} n;"); 8355 verifyFormat("class __attribute__(X) Z {\n} n;"); 8356 verifyFormat("class __declspec(X) Z {\n} n;"); 8357 verifyFormat("class A##B##C {\n} n;"); 8358 verifyFormat("class alignas(16) Z {\n} n;"); 8359 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 8360 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 8361 8362 // Redefinition from nested context: 8363 verifyFormat("class A::B::C {\n} n;"); 8364 8365 // Template definitions. 8366 verifyFormat( 8367 "template <typename F>\n" 8368 "Matcher(const Matcher<F> &Other,\n" 8369 " typename enable_if_c<is_base_of<F, T>::value &&\n" 8370 " !is_same<F, T>::value>::type * = 0)\n" 8371 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 8372 8373 // FIXME: This is still incorrectly handled at the formatter side. 8374 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 8375 verifyFormat("int i = SomeFunction(a<b, a> b);"); 8376 8377 // FIXME: 8378 // This now gets parsed incorrectly as class definition. 8379 // verifyFormat("class A<int> f() {\n}\nint n;"); 8380 8381 // Elaborate types where incorrectly parsing the structural element would 8382 // break the indent. 8383 verifyFormat("if (true)\n" 8384 " class X x;\n" 8385 "else\n" 8386 " f();\n"); 8387 8388 // This is simply incomplete. Formatting is not important, but must not crash. 8389 verifyFormat("class A:"); 8390 } 8391 8392 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 8393 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 8394 format("#error Leave all white!!!!! space* alone!\n")); 8395 EXPECT_EQ( 8396 "#warning Leave all white!!!!! space* alone!\n", 8397 format("#warning Leave all white!!!!! space* alone!\n")); 8398 EXPECT_EQ("#error 1", format(" # error 1")); 8399 EXPECT_EQ("#warning 1", format(" # warning 1")); 8400 } 8401 8402 TEST_F(FormatTest, FormatHashIfExpressions) { 8403 verifyFormat("#if AAAA && BBBB"); 8404 verifyFormat("#if (AAAA && BBBB)"); 8405 verifyFormat("#elif (AAAA && BBBB)"); 8406 // FIXME: Come up with a better indentation for #elif. 8407 verifyFormat( 8408 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 8409 " defined(BBBBBBBB)\n" 8410 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 8411 " defined(BBBBBBBB)\n" 8412 "#endif", 8413 getLLVMStyleWithColumns(65)); 8414 } 8415 8416 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 8417 FormatStyle AllowsMergedIf = getGoogleStyle(); 8418 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 8419 FormatStyle::SIS_WithoutElse; 8420 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 8421 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 8422 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 8423 EXPECT_EQ("if (true) return 42;", 8424 format("if (true)\nreturn 42;", AllowsMergedIf)); 8425 FormatStyle ShortMergedIf = AllowsMergedIf; 8426 ShortMergedIf.ColumnLimit = 25; 8427 verifyFormat("#define A \\\n" 8428 " if (true) return 42;", 8429 ShortMergedIf); 8430 verifyFormat("#define A \\\n" 8431 " f(); \\\n" 8432 " if (true)\n" 8433 "#define B", 8434 ShortMergedIf); 8435 verifyFormat("#define A \\\n" 8436 " f(); \\\n" 8437 " if (true)\n" 8438 "g();", 8439 ShortMergedIf); 8440 verifyFormat("{\n" 8441 "#ifdef A\n" 8442 " // Comment\n" 8443 " if (true) continue;\n" 8444 "#endif\n" 8445 " // Comment\n" 8446 " if (true) continue;\n" 8447 "}", 8448 ShortMergedIf); 8449 ShortMergedIf.ColumnLimit = 33; 8450 verifyFormat("#define A \\\n" 8451 " if constexpr (true) return 42;", 8452 ShortMergedIf); 8453 ShortMergedIf.ColumnLimit = 29; 8454 verifyFormat("#define A \\\n" 8455 " if (aaaaaaaaaa) return 1; \\\n" 8456 " return 2;", 8457 ShortMergedIf); 8458 ShortMergedIf.ColumnLimit = 28; 8459 verifyFormat("#define A \\\n" 8460 " if (aaaaaaaaaa) \\\n" 8461 " return 1; \\\n" 8462 " return 2;", 8463 ShortMergedIf); 8464 verifyFormat("#define A \\\n" 8465 " if constexpr (aaaaaaa) \\\n" 8466 " return 1; \\\n" 8467 " return 2;", 8468 ShortMergedIf); 8469 } 8470 8471 TEST_F(FormatTest, FormatStarDependingOnContext) { 8472 verifyFormat("void f(int *a);"); 8473 verifyFormat("void f() { f(fint * b); }"); 8474 verifyFormat("class A {\n void f(int *a);\n};"); 8475 verifyFormat("class A {\n int *a;\n};"); 8476 verifyFormat("namespace a {\n" 8477 "namespace b {\n" 8478 "class A {\n" 8479 " void f() {}\n" 8480 " int *a;\n" 8481 "};\n" 8482 "} // namespace b\n" 8483 "} // namespace a"); 8484 } 8485 8486 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 8487 verifyFormat("while"); 8488 verifyFormat("operator"); 8489 } 8490 8491 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 8492 // This code would be painfully slow to format if we didn't skip it. 8493 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 8494 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8495 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8496 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8497 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8498 "A(1, 1)\n" 8499 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 8500 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8501 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8502 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8503 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8504 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8505 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8506 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8507 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8508 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 8509 // Deeply nested part is untouched, rest is formatted. 8510 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 8511 format(std::string("int i;\n") + Code + "int j;\n", 8512 getLLVMStyle(), SC_ExpectIncomplete)); 8513 } 8514 8515 //===----------------------------------------------------------------------===// 8516 // Objective-C tests. 8517 //===----------------------------------------------------------------------===// 8518 8519 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 8520 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 8521 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 8522 format("-(NSUInteger)indexOfObject:(id)anObject;")); 8523 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 8524 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 8525 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 8526 format("-(NSInteger)Method3:(id)anObject;")); 8527 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 8528 format("-(NSInteger)Method4:(id)anObject;")); 8529 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 8530 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 8531 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 8532 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 8533 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 8534 "forAllCells:(BOOL)flag;", 8535 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 8536 "forAllCells:(BOOL)flag;")); 8537 8538 // Very long objectiveC method declaration. 8539 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 8540 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 8541 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 8542 " inRange:(NSRange)range\n" 8543 " outRange:(NSRange)out_range\n" 8544 " outRange1:(NSRange)out_range1\n" 8545 " outRange2:(NSRange)out_range2\n" 8546 " outRange3:(NSRange)out_range3\n" 8547 " outRange4:(NSRange)out_range4\n" 8548 " outRange5:(NSRange)out_range5\n" 8549 " outRange6:(NSRange)out_range6\n" 8550 " outRange7:(NSRange)out_range7\n" 8551 " outRange8:(NSRange)out_range8\n" 8552 " outRange9:(NSRange)out_range9;"); 8553 8554 // When the function name has to be wrapped. 8555 FormatStyle Style = getLLVMStyle(); 8556 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 8557 // and always indents instead. 8558 Style.IndentWrappedFunctionNames = false; 8559 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 8560 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 8561 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 8562 "}", 8563 Style); 8564 Style.IndentWrappedFunctionNames = true; 8565 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 8566 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 8567 " anotherName:(NSString)dddddddddddddd {\n" 8568 "}", 8569 Style); 8570 8571 verifyFormat("- (int)sum:(vector<int>)numbers;"); 8572 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 8573 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 8574 // protocol lists (but not for template classes): 8575 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 8576 8577 verifyFormat("- (int (*)())foo:(int (*)())f;"); 8578 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 8579 8580 // If there's no return type (very rare in practice!), LLVM and Google style 8581 // agree. 8582 verifyFormat("- foo;"); 8583 verifyFormat("- foo:(int)f;"); 8584 verifyGoogleFormat("- foo:(int)foo;"); 8585 } 8586 8587 8588 TEST_F(FormatTest, BreaksStringLiterals) { 8589 EXPECT_EQ("\"some text \"\n" 8590 "\"other\";", 8591 format("\"some text other\";", getLLVMStyleWithColumns(12))); 8592 EXPECT_EQ("\"some text \"\n" 8593 "\"other\";", 8594 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 8595 EXPECT_EQ( 8596 "#define A \\\n" 8597 " \"some \" \\\n" 8598 " \"text \" \\\n" 8599 " \"other\";", 8600 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 8601 EXPECT_EQ( 8602 "#define A \\\n" 8603 " \"so \" \\\n" 8604 " \"text \" \\\n" 8605 " \"other\";", 8606 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 8607 8608 EXPECT_EQ("\"some text\"", 8609 format("\"some text\"", getLLVMStyleWithColumns(1))); 8610 EXPECT_EQ("\"some text\"", 8611 format("\"some text\"", getLLVMStyleWithColumns(11))); 8612 EXPECT_EQ("\"some \"\n" 8613 "\"text\"", 8614 format("\"some text\"", getLLVMStyleWithColumns(10))); 8615 EXPECT_EQ("\"some \"\n" 8616 "\"text\"", 8617 format("\"some text\"", getLLVMStyleWithColumns(7))); 8618 EXPECT_EQ("\"some\"\n" 8619 "\" tex\"\n" 8620 "\"t\"", 8621 format("\"some text\"", getLLVMStyleWithColumns(6))); 8622 EXPECT_EQ("\"some\"\n" 8623 "\" tex\"\n" 8624 "\" and\"", 8625 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 8626 EXPECT_EQ("\"some\"\n" 8627 "\"/tex\"\n" 8628 "\"/and\"", 8629 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 8630 8631 EXPECT_EQ("variable =\n" 8632 " \"long string \"\n" 8633 " \"literal\";", 8634 format("variable = \"long string literal\";", 8635 getLLVMStyleWithColumns(20))); 8636 8637 EXPECT_EQ("variable = f(\n" 8638 " \"long string \"\n" 8639 " \"literal\",\n" 8640 " short,\n" 8641 " loooooooooooooooooooong);", 8642 format("variable = f(\"long string literal\", short, " 8643 "loooooooooooooooooooong);", 8644 getLLVMStyleWithColumns(20))); 8645 8646 EXPECT_EQ( 8647 "f(g(\"long string \"\n" 8648 " \"literal\"),\n" 8649 " b);", 8650 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 8651 EXPECT_EQ("f(g(\"long string \"\n" 8652 " \"literal\",\n" 8653 " a),\n" 8654 " b);", 8655 format("f(g(\"long string literal\", a), b);", 8656 getLLVMStyleWithColumns(20))); 8657 EXPECT_EQ( 8658 "f(\"one two\".split(\n" 8659 " variable));", 8660 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 8661 EXPECT_EQ("f(\"one two three four five six \"\n" 8662 " \"seven\".split(\n" 8663 " really_looooong_variable));", 8664 format("f(\"one two three four five six seven\"." 8665 "split(really_looooong_variable));", 8666 getLLVMStyleWithColumns(33))); 8667 8668 EXPECT_EQ("f(\"some \"\n" 8669 " \"text\",\n" 8670 " other);", 8671 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 8672 8673 // Only break as a last resort. 8674 verifyFormat( 8675 "aaaaaaaaaaaaaaaaaaaa(\n" 8676 " aaaaaaaaaaaaaaaaaaaa,\n" 8677 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 8678 8679 EXPECT_EQ("\"splitmea\"\n" 8680 "\"trandomp\"\n" 8681 "\"oint\"", 8682 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 8683 8684 EXPECT_EQ("\"split/\"\n" 8685 "\"pathat/\"\n" 8686 "\"slashes\"", 8687 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 8688 8689 EXPECT_EQ("\"split/\"\n" 8690 "\"pathat/\"\n" 8691 "\"slashes\"", 8692 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 8693 EXPECT_EQ("\"split at \"\n" 8694 "\"spaces/at/\"\n" 8695 "\"slashes.at.any$\"\n" 8696 "\"non-alphanumeric%\"\n" 8697 "\"1111111111characte\"\n" 8698 "\"rs\"", 8699 format("\"split at " 8700 "spaces/at/" 8701 "slashes.at." 8702 "any$non-" 8703 "alphanumeric%" 8704 "1111111111characte" 8705 "rs\"", 8706 getLLVMStyleWithColumns(20))); 8707 8708 // Verify that splitting the strings understands 8709 // Style::AlwaysBreakBeforeMultilineStrings. 8710 EXPECT_EQ( 8711 "aaaaaaaaaaaa(\n" 8712 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 8713 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 8714 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 8715 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 8716 "aaaaaaaaaaaaaaaaaaaaaa\");", 8717 getGoogleStyle())); 8718 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 8719 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 8720 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 8721 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 8722 "aaaaaaaaaaaaaaaaaaaaaa\";", 8723 getGoogleStyle())); 8724 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 8725 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 8726 format("llvm::outs() << " 8727 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 8728 "aaaaaaaaaaaaaaaaaaa\";")); 8729 EXPECT_EQ("ffff(\n" 8730 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 8731 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 8732 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 8733 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 8734 getGoogleStyle())); 8735 8736 FormatStyle Style = getLLVMStyleWithColumns(12); 8737 Style.BreakStringLiterals = false; 8738 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 8739 8740 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 8741 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 8742 EXPECT_EQ("#define A \\\n" 8743 " \"some \" \\\n" 8744 " \"text \" \\\n" 8745 " \"other\";", 8746 format("#define A \"some text other\";", AlignLeft)); 8747 } 8748 8749 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 8750 EXPECT_EQ("C a = \"some more \"\n" 8751 " \"text\";", 8752 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 8753 } 8754 8755 TEST_F(FormatTest, FullyRemoveEmptyLines) { 8756 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 8757 NoEmptyLines.MaxEmptyLinesToKeep = 0; 8758 EXPECT_EQ("int i = a(b());", 8759 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 8760 } 8761 8762 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 8763 EXPECT_EQ( 8764 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 8765 "(\n" 8766 " \"x\t\");", 8767 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 8768 "aaaaaaa(" 8769 "\"x\t\");")); 8770 } 8771 8772 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 8773 EXPECT_EQ( 8774 "u8\"utf8 string \"\n" 8775 "u8\"literal\";", 8776 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 8777 EXPECT_EQ( 8778 "u\"utf16 string \"\n" 8779 "u\"literal\";", 8780 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 8781 EXPECT_EQ( 8782 "U\"utf32 string \"\n" 8783 "U\"literal\";", 8784 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 8785 EXPECT_EQ("L\"wide string \"\n" 8786 "L\"literal\";", 8787 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 8788 EXPECT_EQ("@\"NSString \"\n" 8789 "@\"literal\";", 8790 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 8791 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 8792 8793 // This input makes clang-format try to split the incomplete unicode escape 8794 // sequence, which used to lead to a crasher. 8795 verifyNoCrash( 8796 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 8797 getLLVMStyleWithColumns(60)); 8798 } 8799 8800 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 8801 FormatStyle Style = getGoogleStyleWithColumns(15); 8802 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 8803 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 8804 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 8805 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 8806 EXPECT_EQ("u8R\"x(raw literal)x\";", 8807 format("u8R\"x(raw literal)x\";", Style)); 8808 } 8809 8810 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 8811 FormatStyle Style = getLLVMStyleWithColumns(20); 8812 EXPECT_EQ( 8813 "_T(\"aaaaaaaaaaaaaa\")\n" 8814 "_T(\"aaaaaaaaaaaaaa\")\n" 8815 "_T(\"aaaaaaaaaaaa\")", 8816 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 8817 EXPECT_EQ("f(x,\n" 8818 " _T(\"aaaaaaaaaaaa\")\n" 8819 " _T(\"aaa\"),\n" 8820 " z);", 8821 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 8822 8823 // FIXME: Handle embedded spaces in one iteration. 8824 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 8825 // "_T(\"aaaaaaaaaaaaa\")\n" 8826 // "_T(\"aaaaaaaaaaaaa\")\n" 8827 // "_T(\"a\")", 8828 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 8829 // getLLVMStyleWithColumns(20))); 8830 EXPECT_EQ( 8831 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 8832 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 8833 EXPECT_EQ("f(\n" 8834 "#if !TEST\n" 8835 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 8836 "#endif\n" 8837 ");", 8838 format("f(\n" 8839 "#if !TEST\n" 8840 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 8841 "#endif\n" 8842 ");")); 8843 EXPECT_EQ("f(\n" 8844 "\n" 8845 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 8846 format("f(\n" 8847 "\n" 8848 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 8849 } 8850 8851 TEST_F(FormatTest, BreaksStringLiteralOperands) { 8852 // In a function call with two operands, the second can be broken with no line 8853 // break before it. 8854 EXPECT_EQ("func(a, \"long long \"\n" 8855 " \"long long\");", 8856 format("func(a, \"long long long long\");", 8857 getLLVMStyleWithColumns(24))); 8858 // In a function call with three operands, the second must be broken with a 8859 // line break before it. 8860 EXPECT_EQ("func(a,\n" 8861 " \"long long long \"\n" 8862 " \"long\",\n" 8863 " c);", 8864 format("func(a, \"long long long long\", c);", 8865 getLLVMStyleWithColumns(24))); 8866 // In a function call with three operands, the third must be broken with a 8867 // line break before it. 8868 EXPECT_EQ("func(a, b,\n" 8869 " \"long long long \"\n" 8870 " \"long\");", 8871 format("func(a, b, \"long long long long\");", 8872 getLLVMStyleWithColumns(24))); 8873 // In a function call with three operands, both the second and the third must 8874 // be broken with a line break before them. 8875 EXPECT_EQ("func(a,\n" 8876 " \"long long long \"\n" 8877 " \"long\",\n" 8878 " \"long long long \"\n" 8879 " \"long\");", 8880 format("func(a, \"long long long long\", \"long long long long\");", 8881 getLLVMStyleWithColumns(24))); 8882 // In a chain of << with two operands, the second can be broken with no line 8883 // break before it. 8884 EXPECT_EQ("a << \"line line \"\n" 8885 " \"line\";", 8886 format("a << \"line line line\";", 8887 getLLVMStyleWithColumns(20))); 8888 // In a chain of << with three operands, the second can be broken with no line 8889 // break before it. 8890 EXPECT_EQ("abcde << \"line \"\n" 8891 " \"line line\"\n" 8892 " << c;", 8893 format("abcde << \"line line line\" << c;", 8894 getLLVMStyleWithColumns(20))); 8895 // In a chain of << with three operands, the third must be broken with a line 8896 // break before it. 8897 EXPECT_EQ("a << b\n" 8898 " << \"line line \"\n" 8899 " \"line\";", 8900 format("a << b << \"line line line\";", 8901 getLLVMStyleWithColumns(20))); 8902 // In a chain of << with three operands, the second can be broken with no line 8903 // break before it and the third must be broken with a line break before it. 8904 EXPECT_EQ("abcd << \"line line \"\n" 8905 " \"line\"\n" 8906 " << \"line line \"\n" 8907 " \"line\";", 8908 format("abcd << \"line line line\" << \"line line line\";", 8909 getLLVMStyleWithColumns(20))); 8910 // In a chain of binary operators with two operands, the second can be broken 8911 // with no line break before it. 8912 EXPECT_EQ("abcd + \"line line \"\n" 8913 " \"line line\";", 8914 format("abcd + \"line line line line\";", 8915 getLLVMStyleWithColumns(20))); 8916 // In a chain of binary operators with three operands, the second must be 8917 // broken with a line break before it. 8918 EXPECT_EQ("abcd +\n" 8919 " \"line line \"\n" 8920 " \"line line\" +\n" 8921 " e;", 8922 format("abcd + \"line line line line\" + e;", 8923 getLLVMStyleWithColumns(20))); 8924 // In a function call with two operands, with AlignAfterOpenBracket enabled, 8925 // the first must be broken with a line break before it. 8926 FormatStyle Style = getLLVMStyleWithColumns(25); 8927 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 8928 EXPECT_EQ("someFunction(\n" 8929 " \"long long long \"\n" 8930 " \"long\",\n" 8931 " a);", 8932 format("someFunction(\"long long long long\", a);", Style)); 8933 } 8934 8935 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 8936 EXPECT_EQ( 8937 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 8938 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 8939 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 8940 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 8941 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 8942 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 8943 } 8944 8945 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 8946 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 8947 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 8948 EXPECT_EQ("fffffffffff(g(R\"x(\n" 8949 "multiline raw string literal xxxxxxxxxxxxxx\n" 8950 ")x\",\n" 8951 " a),\n" 8952 " b);", 8953 format("fffffffffff(g(R\"x(\n" 8954 "multiline raw string literal xxxxxxxxxxxxxx\n" 8955 ")x\", a), b);", 8956 getGoogleStyleWithColumns(20))); 8957 EXPECT_EQ("fffffffffff(\n" 8958 " g(R\"x(qqq\n" 8959 "multiline raw string literal xxxxxxxxxxxxxx\n" 8960 ")x\",\n" 8961 " a),\n" 8962 " b);", 8963 format("fffffffffff(g(R\"x(qqq\n" 8964 "multiline raw string literal xxxxxxxxxxxxxx\n" 8965 ")x\", a), b);", 8966 getGoogleStyleWithColumns(20))); 8967 8968 EXPECT_EQ("fffffffffff(R\"x(\n" 8969 "multiline raw string literal xxxxxxxxxxxxxx\n" 8970 ")x\");", 8971 format("fffffffffff(R\"x(\n" 8972 "multiline raw string literal xxxxxxxxxxxxxx\n" 8973 ")x\");", 8974 getGoogleStyleWithColumns(20))); 8975 EXPECT_EQ("fffffffffff(R\"x(\n" 8976 "multiline raw string literal xxxxxxxxxxxxxx\n" 8977 ")x\" + bbbbbb);", 8978 format("fffffffffff(R\"x(\n" 8979 "multiline raw string literal xxxxxxxxxxxxxx\n" 8980 ")x\" + bbbbbb);", 8981 getGoogleStyleWithColumns(20))); 8982 EXPECT_EQ("fffffffffff(\n" 8983 " R\"x(\n" 8984 "multiline raw string literal xxxxxxxxxxxxxx\n" 8985 ")x\" +\n" 8986 " bbbbbb);", 8987 format("fffffffffff(\n" 8988 " R\"x(\n" 8989 "multiline raw string literal xxxxxxxxxxxxxx\n" 8990 ")x\" + bbbbbb);", 8991 getGoogleStyleWithColumns(20))); 8992 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 8993 format("fffffffffff(\n" 8994 " R\"(single line raw string)\" + bbbbbb);")); 8995 } 8996 8997 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 8998 verifyFormat("string a = \"unterminated;"); 8999 EXPECT_EQ("function(\"unterminated,\n" 9000 " OtherParameter);", 9001 format("function( \"unterminated,\n" 9002 " OtherParameter);")); 9003 } 9004 9005 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9006 FormatStyle Style = getLLVMStyle(); 9007 Style.Standard = FormatStyle::LS_Cpp03; 9008 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9009 format("#define x(_a) printf(\"foo\"_a);", Style)); 9010 } 9011 9012 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9013 9014 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9015 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9016 " \"ddeeefff\");", 9017 format("someFunction(\"aaabbbcccdddeeefff\");", 9018 getLLVMStyleWithColumns(25))); 9019 EXPECT_EQ("someFunction1234567890(\n" 9020 " \"aaabbbcccdddeeefff\");", 9021 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9022 getLLVMStyleWithColumns(26))); 9023 EXPECT_EQ("someFunction1234567890(\n" 9024 " \"aaabbbcccdddeeeff\"\n" 9025 " \"f\");", 9026 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9027 getLLVMStyleWithColumns(25))); 9028 EXPECT_EQ("someFunction1234567890(\n" 9029 " \"aaabbbcccdddeeeff\"\n" 9030 " \"f\");", 9031 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9032 getLLVMStyleWithColumns(24))); 9033 EXPECT_EQ("someFunction(\n" 9034 " \"aaabbbcc ddde \"\n" 9035 " \"efff\");", 9036 format("someFunction(\"aaabbbcc ddde efff\");", 9037 getLLVMStyleWithColumns(25))); 9038 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9039 " \"ddeeefff\");", 9040 format("someFunction(\"aaabbbccc ddeeefff\");", 9041 getLLVMStyleWithColumns(25))); 9042 EXPECT_EQ("someFunction1234567890(\n" 9043 " \"aaabb \"\n" 9044 " \"cccdddeeefff\");", 9045 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9046 getLLVMStyleWithColumns(25))); 9047 EXPECT_EQ("#define A \\\n" 9048 " string s = \\\n" 9049 " \"123456789\" \\\n" 9050 " \"0\"; \\\n" 9051 " int i;", 9052 format("#define A string s = \"1234567890\"; int i;", 9053 getLLVMStyleWithColumns(20))); 9054 EXPECT_EQ("someFunction(\n" 9055 " \"aaabbbcc \"\n" 9056 " \"dddeeefff\");", 9057 format("someFunction(\"aaabbbcc dddeeefff\");", 9058 getLLVMStyleWithColumns(25))); 9059 } 9060 9061 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9062 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9063 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9064 EXPECT_EQ("\"test\"\n" 9065 "\"\\n\"", 9066 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9067 EXPECT_EQ("\"tes\\\\\"\n" 9068 "\"n\"", 9069 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9070 EXPECT_EQ("\"\\\\\\\\\"\n" 9071 "\"\\n\"", 9072 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9073 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9074 EXPECT_EQ("\"\\uff01\"\n" 9075 "\"test\"", 9076 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9077 EXPECT_EQ("\"\\Uff01ff02\"", 9078 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9079 EXPECT_EQ("\"\\x000000000001\"\n" 9080 "\"next\"", 9081 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9082 EXPECT_EQ("\"\\x000000000001next\"", 9083 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9084 EXPECT_EQ("\"\\x000000000001\"", 9085 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9086 EXPECT_EQ("\"test\"\n" 9087 "\"\\000000\"\n" 9088 "\"000001\"", 9089 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9090 EXPECT_EQ("\"test\\000\"\n" 9091 "\"00000000\"\n" 9092 "\"1\"", 9093 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9094 } 9095 9096 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9097 verifyFormat("void f() {\n" 9098 " return g() {}\n" 9099 " void h() {}"); 9100 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9101 "g();\n" 9102 "}"); 9103 } 9104 9105 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9106 verifyFormat( 9107 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9108 } 9109 9110 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9111 verifyFormat("class X {\n" 9112 " void f() {\n" 9113 " }\n" 9114 "};", 9115 getLLVMStyleWithColumns(12)); 9116 } 9117 9118 TEST_F(FormatTest, ConfigurableIndentWidth) { 9119 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9120 EightIndent.IndentWidth = 8; 9121 EightIndent.ContinuationIndentWidth = 8; 9122 verifyFormat("void f() {\n" 9123 " someFunction();\n" 9124 " if (true) {\n" 9125 " f();\n" 9126 " }\n" 9127 "}", 9128 EightIndent); 9129 verifyFormat("class X {\n" 9130 " void f() {\n" 9131 " }\n" 9132 "};", 9133 EightIndent); 9134 verifyFormat("int x[] = {\n" 9135 " call(),\n" 9136 " call()};", 9137 EightIndent); 9138 } 9139 9140 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9141 verifyFormat("double\n" 9142 "f();", 9143 getLLVMStyleWithColumns(8)); 9144 } 9145 9146 TEST_F(FormatTest, ConfigurableUseOfTab) { 9147 FormatStyle Tab = getLLVMStyleWithColumns(42); 9148 Tab.IndentWidth = 8; 9149 Tab.UseTab = FormatStyle::UT_Always; 9150 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9151 9152 EXPECT_EQ("if (aaaaaaaa && // q\n" 9153 " bb)\t\t// w\n" 9154 "\t;", 9155 format("if (aaaaaaaa &&// q\n" 9156 "bb)// w\n" 9157 ";", 9158 Tab)); 9159 EXPECT_EQ("if (aaa && bbb) // w\n" 9160 "\t;", 9161 format("if(aaa&&bbb)// w\n" 9162 ";", 9163 Tab)); 9164 9165 verifyFormat("class X {\n" 9166 "\tvoid f() {\n" 9167 "\t\tsomeFunction(parameter1,\n" 9168 "\t\t\t parameter2);\n" 9169 "\t}\n" 9170 "};", 9171 Tab); 9172 verifyFormat("#define A \\\n" 9173 "\tvoid f() { \\\n" 9174 "\t\tsomeFunction( \\\n" 9175 "\t\t parameter1, \\\n" 9176 "\t\t parameter2); \\\n" 9177 "\t}", 9178 Tab); 9179 verifyFormat("int a;\t // x\n" 9180 "int bbbbbbbb; // x\n", 9181 Tab); 9182 9183 Tab.TabWidth = 4; 9184 Tab.IndentWidth = 8; 9185 verifyFormat("class TabWidth4Indent8 {\n" 9186 "\t\tvoid f() {\n" 9187 "\t\t\t\tsomeFunction(parameter1,\n" 9188 "\t\t\t\t\t\t\t parameter2);\n" 9189 "\t\t}\n" 9190 "};", 9191 Tab); 9192 9193 Tab.TabWidth = 4; 9194 Tab.IndentWidth = 4; 9195 verifyFormat("class TabWidth4Indent4 {\n" 9196 "\tvoid f() {\n" 9197 "\t\tsomeFunction(parameter1,\n" 9198 "\t\t\t\t\t parameter2);\n" 9199 "\t}\n" 9200 "};", 9201 Tab); 9202 9203 Tab.TabWidth = 8; 9204 Tab.IndentWidth = 4; 9205 verifyFormat("class TabWidth8Indent4 {\n" 9206 " void f() {\n" 9207 "\tsomeFunction(parameter1,\n" 9208 "\t\t parameter2);\n" 9209 " }\n" 9210 "};", 9211 Tab); 9212 9213 Tab.TabWidth = 8; 9214 Tab.IndentWidth = 8; 9215 EXPECT_EQ("/*\n" 9216 "\t a\t\tcomment\n" 9217 "\t in multiple lines\n" 9218 " */", 9219 format(" /*\t \t \n" 9220 " \t \t a\t\tcomment\t \t\n" 9221 " \t \t in multiple lines\t\n" 9222 " \t */", 9223 Tab)); 9224 9225 Tab.UseTab = FormatStyle::UT_ForIndentation; 9226 verifyFormat("{\n" 9227 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9228 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9229 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9230 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9231 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9232 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9233 "};", 9234 Tab); 9235 verifyFormat("enum AA {\n" 9236 "\ta1, // Force multiple lines\n" 9237 "\ta2,\n" 9238 "\ta3\n" 9239 "};", 9240 Tab); 9241 EXPECT_EQ("if (aaaaaaaa && // q\n" 9242 " bb) // w\n" 9243 "\t;", 9244 format("if (aaaaaaaa &&// q\n" 9245 "bb)// w\n" 9246 ";", 9247 Tab)); 9248 verifyFormat("class X {\n" 9249 "\tvoid f() {\n" 9250 "\t\tsomeFunction(parameter1,\n" 9251 "\t\t parameter2);\n" 9252 "\t}\n" 9253 "};", 9254 Tab); 9255 verifyFormat("{\n" 9256 "\tQ(\n" 9257 "\t {\n" 9258 "\t\t int a;\n" 9259 "\t\t someFunction(aaaaaaaa,\n" 9260 "\t\t bbbbbbb);\n" 9261 "\t },\n" 9262 "\t p);\n" 9263 "}", 9264 Tab); 9265 EXPECT_EQ("{\n" 9266 "\t/* aaaa\n" 9267 "\t bbbb */\n" 9268 "}", 9269 format("{\n" 9270 "/* aaaa\n" 9271 " bbbb */\n" 9272 "}", 9273 Tab)); 9274 EXPECT_EQ("{\n" 9275 "\t/*\n" 9276 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9277 "\t bbbbbbbbbbbbb\n" 9278 "\t*/\n" 9279 "}", 9280 format("{\n" 9281 "/*\n" 9282 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9283 "*/\n" 9284 "}", 9285 Tab)); 9286 EXPECT_EQ("{\n" 9287 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9288 "\t// bbbbbbbbbbbbb\n" 9289 "}", 9290 format("{\n" 9291 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9292 "}", 9293 Tab)); 9294 EXPECT_EQ("{\n" 9295 "\t/*\n" 9296 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9297 "\t bbbbbbbbbbbbb\n" 9298 "\t*/\n" 9299 "}", 9300 format("{\n" 9301 "\t/*\n" 9302 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9303 "\t*/\n" 9304 "}", 9305 Tab)); 9306 EXPECT_EQ("{\n" 9307 "\t/*\n" 9308 "\n" 9309 "\t*/\n" 9310 "}", 9311 format("{\n" 9312 "\t/*\n" 9313 "\n" 9314 "\t*/\n" 9315 "}", 9316 Tab)); 9317 EXPECT_EQ("{\n" 9318 "\t/*\n" 9319 " asdf\n" 9320 "\t*/\n" 9321 "}", 9322 format("{\n" 9323 "\t/*\n" 9324 " asdf\n" 9325 "\t*/\n" 9326 "}", 9327 Tab)); 9328 9329 Tab.UseTab = FormatStyle::UT_Never; 9330 EXPECT_EQ("/*\n" 9331 " a\t\tcomment\n" 9332 " in multiple lines\n" 9333 " */", 9334 format(" /*\t \t \n" 9335 " \t \t a\t\tcomment\t \t\n" 9336 " \t \t in multiple lines\t\n" 9337 " \t */", 9338 Tab)); 9339 EXPECT_EQ("/* some\n" 9340 " comment */", 9341 format(" \t \t /* some\n" 9342 " \t \t comment */", 9343 Tab)); 9344 EXPECT_EQ("int a; /* some\n" 9345 " comment */", 9346 format(" \t \t int a; /* some\n" 9347 " \t \t comment */", 9348 Tab)); 9349 9350 EXPECT_EQ("int a; /* some\n" 9351 "comment */", 9352 format(" \t \t int\ta; /* some\n" 9353 " \t \t comment */", 9354 Tab)); 9355 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9356 " comment */", 9357 format(" \t \t f(\"\t\t\"); /* some\n" 9358 " \t \t comment */", 9359 Tab)); 9360 EXPECT_EQ("{\n" 9361 " /*\n" 9362 " * Comment\n" 9363 " */\n" 9364 " int i;\n" 9365 "}", 9366 format("{\n" 9367 "\t/*\n" 9368 "\t * Comment\n" 9369 "\t */\n" 9370 "\t int i;\n" 9371 "}")); 9372 9373 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 9374 Tab.TabWidth = 8; 9375 Tab.IndentWidth = 8; 9376 EXPECT_EQ("if (aaaaaaaa && // q\n" 9377 " bb) // w\n" 9378 "\t;", 9379 format("if (aaaaaaaa &&// q\n" 9380 "bb)// w\n" 9381 ";", 9382 Tab)); 9383 EXPECT_EQ("if (aaa && bbb) // w\n" 9384 "\t;", 9385 format("if(aaa&&bbb)// w\n" 9386 ";", 9387 Tab)); 9388 verifyFormat("class X {\n" 9389 "\tvoid f() {\n" 9390 "\t\tsomeFunction(parameter1,\n" 9391 "\t\t\t parameter2);\n" 9392 "\t}\n" 9393 "};", 9394 Tab); 9395 verifyFormat("#define A \\\n" 9396 "\tvoid f() { \\\n" 9397 "\t\tsomeFunction( \\\n" 9398 "\t\t parameter1, \\\n" 9399 "\t\t parameter2); \\\n" 9400 "\t}", 9401 Tab); 9402 Tab.TabWidth = 4; 9403 Tab.IndentWidth = 8; 9404 verifyFormat("class TabWidth4Indent8 {\n" 9405 "\t\tvoid f() {\n" 9406 "\t\t\t\tsomeFunction(parameter1,\n" 9407 "\t\t\t\t\t\t\t parameter2);\n" 9408 "\t\t}\n" 9409 "};", 9410 Tab); 9411 Tab.TabWidth = 4; 9412 Tab.IndentWidth = 4; 9413 verifyFormat("class TabWidth4Indent4 {\n" 9414 "\tvoid f() {\n" 9415 "\t\tsomeFunction(parameter1,\n" 9416 "\t\t\t\t\t parameter2);\n" 9417 "\t}\n" 9418 "};", 9419 Tab); 9420 Tab.TabWidth = 8; 9421 Tab.IndentWidth = 4; 9422 verifyFormat("class TabWidth8Indent4 {\n" 9423 " void f() {\n" 9424 "\tsomeFunction(parameter1,\n" 9425 "\t\t parameter2);\n" 9426 " }\n" 9427 "};", 9428 Tab); 9429 Tab.TabWidth = 8; 9430 Tab.IndentWidth = 8; 9431 EXPECT_EQ("/*\n" 9432 "\t a\t\tcomment\n" 9433 "\t in multiple lines\n" 9434 " */", 9435 format(" /*\t \t \n" 9436 " \t \t a\t\tcomment\t \t\n" 9437 " \t \t in multiple lines\t\n" 9438 " \t */", 9439 Tab)); 9440 verifyFormat("{\n" 9441 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9442 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9443 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9444 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9445 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9446 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9447 "};", 9448 Tab); 9449 verifyFormat("enum AA {\n" 9450 "\ta1, // Force multiple lines\n" 9451 "\ta2,\n" 9452 "\ta3\n" 9453 "};", 9454 Tab); 9455 EXPECT_EQ("if (aaaaaaaa && // q\n" 9456 " bb) // w\n" 9457 "\t;", 9458 format("if (aaaaaaaa &&// q\n" 9459 "bb)// w\n" 9460 ";", 9461 Tab)); 9462 verifyFormat("class X {\n" 9463 "\tvoid f() {\n" 9464 "\t\tsomeFunction(parameter1,\n" 9465 "\t\t\t parameter2);\n" 9466 "\t}\n" 9467 "};", 9468 Tab); 9469 verifyFormat("{\n" 9470 "\tQ(\n" 9471 "\t {\n" 9472 "\t\t int a;\n" 9473 "\t\t someFunction(aaaaaaaa,\n" 9474 "\t\t\t\t bbbbbbb);\n" 9475 "\t },\n" 9476 "\t p);\n" 9477 "}", 9478 Tab); 9479 EXPECT_EQ("{\n" 9480 "\t/* aaaa\n" 9481 "\t bbbb */\n" 9482 "}", 9483 format("{\n" 9484 "/* aaaa\n" 9485 " bbbb */\n" 9486 "}", 9487 Tab)); 9488 EXPECT_EQ("{\n" 9489 "\t/*\n" 9490 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9491 "\t bbbbbbbbbbbbb\n" 9492 "\t*/\n" 9493 "}", 9494 format("{\n" 9495 "/*\n" 9496 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9497 "*/\n" 9498 "}", 9499 Tab)); 9500 EXPECT_EQ("{\n" 9501 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9502 "\t// bbbbbbbbbbbbb\n" 9503 "}", 9504 format("{\n" 9505 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9506 "}", 9507 Tab)); 9508 EXPECT_EQ("{\n" 9509 "\t/*\n" 9510 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9511 "\t bbbbbbbbbbbbb\n" 9512 "\t*/\n" 9513 "}", 9514 format("{\n" 9515 "\t/*\n" 9516 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9517 "\t*/\n" 9518 "}", 9519 Tab)); 9520 EXPECT_EQ("{\n" 9521 "\t/*\n" 9522 "\n" 9523 "\t*/\n" 9524 "}", 9525 format("{\n" 9526 "\t/*\n" 9527 "\n" 9528 "\t*/\n" 9529 "}", 9530 Tab)); 9531 EXPECT_EQ("{\n" 9532 "\t/*\n" 9533 " asdf\n" 9534 "\t*/\n" 9535 "}", 9536 format("{\n" 9537 "\t/*\n" 9538 " asdf\n" 9539 "\t*/\n" 9540 "}", 9541 Tab)); 9542 EXPECT_EQ("/*\n" 9543 "\t a\t\tcomment\n" 9544 "\t in multiple lines\n" 9545 " */", 9546 format(" /*\t \t \n" 9547 " \t \t a\t\tcomment\t \t\n" 9548 " \t \t in multiple lines\t\n" 9549 " \t */", 9550 Tab)); 9551 EXPECT_EQ("/* some\n" 9552 " comment */", 9553 format(" \t \t /* some\n" 9554 " \t \t comment */", 9555 Tab)); 9556 EXPECT_EQ("int a; /* some\n" 9557 " comment */", 9558 format(" \t \t int a; /* some\n" 9559 " \t \t comment */", 9560 Tab)); 9561 EXPECT_EQ("int a; /* some\n" 9562 "comment */", 9563 format(" \t \t int\ta; /* some\n" 9564 " \t \t comment */", 9565 Tab)); 9566 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9567 " comment */", 9568 format(" \t \t f(\"\t\t\"); /* some\n" 9569 " \t \t comment */", 9570 Tab)); 9571 EXPECT_EQ("{\n" 9572 " /*\n" 9573 " * Comment\n" 9574 " */\n" 9575 " int i;\n" 9576 "}", 9577 format("{\n" 9578 "\t/*\n" 9579 "\t * Comment\n" 9580 "\t */\n" 9581 "\t int i;\n" 9582 "}")); 9583 Tab.AlignConsecutiveAssignments = true; 9584 Tab.AlignConsecutiveDeclarations = true; 9585 Tab.TabWidth = 4; 9586 Tab.IndentWidth = 4; 9587 verifyFormat("class Assign {\n" 9588 "\tvoid f() {\n" 9589 "\t\tint x = 123;\n" 9590 "\t\tint random = 4;\n" 9591 "\t\tstd::string alphabet =\n" 9592 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 9593 "\t}\n" 9594 "};", 9595 Tab); 9596 } 9597 9598 TEST_F(FormatTest, CalculatesOriginalColumn) { 9599 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9600 "q\"; /* some\n" 9601 " comment */", 9602 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9603 "q\"; /* some\n" 9604 " comment */", 9605 getLLVMStyle())); 9606 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 9607 "/* some\n" 9608 " comment */", 9609 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 9610 " /* some\n" 9611 " comment */", 9612 getLLVMStyle())); 9613 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9614 "qqq\n" 9615 "/* some\n" 9616 " comment */", 9617 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9618 "qqq\n" 9619 " /* some\n" 9620 " comment */", 9621 getLLVMStyle())); 9622 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9623 "wwww; /* some\n" 9624 " comment */", 9625 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9626 "wwww; /* some\n" 9627 " comment */", 9628 getLLVMStyle())); 9629 } 9630 9631 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 9632 FormatStyle NoSpace = getLLVMStyle(); 9633 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 9634 9635 verifyFormat("while(true)\n" 9636 " continue;", 9637 NoSpace); 9638 verifyFormat("for(;;)\n" 9639 " continue;", 9640 NoSpace); 9641 verifyFormat("if(true)\n" 9642 " f();\n" 9643 "else if(true)\n" 9644 " f();", 9645 NoSpace); 9646 verifyFormat("do {\n" 9647 " do_something();\n" 9648 "} while(something());", 9649 NoSpace); 9650 verifyFormat("switch(x) {\n" 9651 "default:\n" 9652 " break;\n" 9653 "}", 9654 NoSpace); 9655 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 9656 verifyFormat("size_t x = sizeof(x);", NoSpace); 9657 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 9658 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 9659 verifyFormat("alignas(128) char a[128];", NoSpace); 9660 verifyFormat("size_t x = alignof(MyType);", NoSpace); 9661 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 9662 verifyFormat("int f() throw(Deprecated);", NoSpace); 9663 verifyFormat("typedef void (*cb)(int);", NoSpace); 9664 verifyFormat("T A::operator()();", NoSpace); 9665 verifyFormat("X A::operator++(T);", NoSpace); 9666 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 9667 9668 FormatStyle Space = getLLVMStyle(); 9669 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 9670 9671 verifyFormat("int f ();", Space); 9672 verifyFormat("void f (int a, T b) {\n" 9673 " while (true)\n" 9674 " continue;\n" 9675 "}", 9676 Space); 9677 verifyFormat("if (true)\n" 9678 " f ();\n" 9679 "else if (true)\n" 9680 " f ();", 9681 Space); 9682 verifyFormat("do {\n" 9683 " do_something ();\n" 9684 "} while (something ());", 9685 Space); 9686 verifyFormat("switch (x) {\n" 9687 "default:\n" 9688 " break;\n" 9689 "}", 9690 Space); 9691 verifyFormat("A::A () : a (1) {}", Space); 9692 verifyFormat("void f () __attribute__ ((asdf));", Space); 9693 verifyFormat("*(&a + 1);\n" 9694 "&((&a)[1]);\n" 9695 "a[(b + c) * d];\n" 9696 "(((a + 1) * 2) + 3) * 4;", 9697 Space); 9698 verifyFormat("#define A(x) x", Space); 9699 verifyFormat("#define A (x) x", Space); 9700 verifyFormat("#if defined(x)\n" 9701 "#endif", 9702 Space); 9703 verifyFormat("auto i = std::make_unique<int> (5);", Space); 9704 verifyFormat("size_t x = sizeof (x);", Space); 9705 verifyFormat("auto f (int x) -> decltype (x);", Space); 9706 verifyFormat("int f (T x) noexcept (x.create ());", Space); 9707 verifyFormat("alignas (128) char a[128];", Space); 9708 verifyFormat("size_t x = alignof (MyType);", Space); 9709 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 9710 verifyFormat("int f () throw (Deprecated);", Space); 9711 verifyFormat("typedef void (*cb) (int);", Space); 9712 verifyFormat("T A::operator() ();", Space); 9713 verifyFormat("X A::operator++ (T);", Space); 9714 verifyFormat("auto lambda = [] () { return 0; };", Space); 9715 verifyFormat("int x = int (y);", Space); 9716 9717 FormatStyle SomeSpace = getLLVMStyle(); 9718 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 9719 9720 verifyFormat("[]() -> float {}", SomeSpace); 9721 verifyFormat("[] (auto foo) {}", SomeSpace); 9722 verifyFormat("[foo]() -> int {}", SomeSpace); 9723 verifyFormat("int f();", SomeSpace); 9724 verifyFormat("void f (int a, T b) {\n" 9725 " while (true)\n" 9726 " continue;\n" 9727 "}", 9728 SomeSpace); 9729 verifyFormat("if (true)\n" 9730 " f();\n" 9731 "else if (true)\n" 9732 " f();", 9733 SomeSpace); 9734 verifyFormat("do {\n" 9735 " do_something();\n" 9736 "} while (something());", 9737 SomeSpace); 9738 verifyFormat("switch (x) {\n" 9739 "default:\n" 9740 " break;\n" 9741 "}", 9742 SomeSpace); 9743 verifyFormat("A::A() : a (1) {}", SomeSpace); 9744 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 9745 verifyFormat("*(&a + 1);\n" 9746 "&((&a)[1]);\n" 9747 "a[(b + c) * d];\n" 9748 "(((a + 1) * 2) + 3) * 4;", 9749 SomeSpace); 9750 verifyFormat("#define A(x) x", SomeSpace); 9751 verifyFormat("#define A (x) x", SomeSpace); 9752 verifyFormat("#if defined(x)\n" 9753 "#endif", 9754 SomeSpace); 9755 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 9756 verifyFormat("size_t x = sizeof (x);", SomeSpace); 9757 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 9758 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 9759 verifyFormat("alignas (128) char a[128];", SomeSpace); 9760 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 9761 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 9762 SomeSpace); 9763 verifyFormat("int f() throw (Deprecated);", SomeSpace); 9764 verifyFormat("typedef void (*cb) (int);", SomeSpace); 9765 verifyFormat("T A::operator()();", SomeSpace); 9766 verifyFormat("X A::operator++ (T);", SomeSpace); 9767 verifyFormat("int x = int (y);", SomeSpace); 9768 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 9769 } 9770 9771 TEST_F(FormatTest, SpaceAfterLogicalNot) { 9772 FormatStyle Spaces = getLLVMStyle(); 9773 Spaces.SpaceAfterLogicalNot = true; 9774 9775 verifyFormat("bool x = ! y", Spaces); 9776 verifyFormat("if (! isFailure())", Spaces); 9777 verifyFormat("if (! (a && b))", Spaces); 9778 verifyFormat("\"Error!\"", Spaces); 9779 verifyFormat("! ! x", Spaces); 9780 } 9781 9782 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 9783 FormatStyle Spaces = getLLVMStyle(); 9784 9785 Spaces.SpacesInParentheses = true; 9786 verifyFormat("do_something( ::globalVar );", Spaces); 9787 verifyFormat("call( x, y, z );", Spaces); 9788 verifyFormat("call();", Spaces); 9789 verifyFormat("std::function<void( int, int )> callback;", Spaces); 9790 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 9791 Spaces); 9792 verifyFormat("while ( (bool)1 )\n" 9793 " continue;", 9794 Spaces); 9795 verifyFormat("for ( ;; )\n" 9796 " continue;", 9797 Spaces); 9798 verifyFormat("if ( true )\n" 9799 " f();\n" 9800 "else if ( true )\n" 9801 " f();", 9802 Spaces); 9803 verifyFormat("do {\n" 9804 " do_something( (int)i );\n" 9805 "} while ( something() );", 9806 Spaces); 9807 verifyFormat("switch ( x ) {\n" 9808 "default:\n" 9809 " break;\n" 9810 "}", 9811 Spaces); 9812 9813 Spaces.SpacesInParentheses = false; 9814 Spaces.SpacesInCStyleCastParentheses = true; 9815 verifyFormat("Type *A = ( Type * )P;", Spaces); 9816 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 9817 verifyFormat("x = ( int32 )y;", Spaces); 9818 verifyFormat("int a = ( int )(2.0f);", Spaces); 9819 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 9820 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 9821 verifyFormat("#define x (( int )-1)", Spaces); 9822 9823 // Run the first set of tests again with: 9824 Spaces.SpacesInParentheses = false; 9825 Spaces.SpaceInEmptyParentheses = true; 9826 Spaces.SpacesInCStyleCastParentheses = true; 9827 verifyFormat("call(x, y, z);", Spaces); 9828 verifyFormat("call( );", Spaces); 9829 verifyFormat("std::function<void(int, int)> callback;", Spaces); 9830 verifyFormat("while (( bool )1)\n" 9831 " continue;", 9832 Spaces); 9833 verifyFormat("for (;;)\n" 9834 " continue;", 9835 Spaces); 9836 verifyFormat("if (true)\n" 9837 " f( );\n" 9838 "else if (true)\n" 9839 " f( );", 9840 Spaces); 9841 verifyFormat("do {\n" 9842 " do_something(( int )i);\n" 9843 "} while (something( ));", 9844 Spaces); 9845 verifyFormat("switch (x) {\n" 9846 "default:\n" 9847 " break;\n" 9848 "}", 9849 Spaces); 9850 9851 // Run the first set of tests again with: 9852 Spaces.SpaceAfterCStyleCast = true; 9853 verifyFormat("call(x, y, z);", Spaces); 9854 verifyFormat("call( );", Spaces); 9855 verifyFormat("std::function<void(int, int)> callback;", Spaces); 9856 verifyFormat("while (( bool ) 1)\n" 9857 " continue;", 9858 Spaces); 9859 verifyFormat("for (;;)\n" 9860 " continue;", 9861 Spaces); 9862 verifyFormat("if (true)\n" 9863 " f( );\n" 9864 "else if (true)\n" 9865 " f( );", 9866 Spaces); 9867 verifyFormat("do {\n" 9868 " do_something(( int ) i);\n" 9869 "} while (something( ));", 9870 Spaces); 9871 verifyFormat("switch (x) {\n" 9872 "default:\n" 9873 " break;\n" 9874 "}", 9875 Spaces); 9876 9877 // Run subset of tests again with: 9878 Spaces.SpacesInCStyleCastParentheses = false; 9879 Spaces.SpaceAfterCStyleCast = true; 9880 verifyFormat("while ((bool) 1)\n" 9881 " continue;", 9882 Spaces); 9883 verifyFormat("do {\n" 9884 " do_something((int) i);\n" 9885 "} while (something( ));", 9886 Spaces); 9887 } 9888 9889 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 9890 verifyFormat("int a[5];"); 9891 verifyFormat("a[3] += 42;"); 9892 9893 FormatStyle Spaces = getLLVMStyle(); 9894 Spaces.SpacesInSquareBrackets = true; 9895 // Lambdas unchanged. 9896 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 9897 verifyFormat("return [i, args...] {};", Spaces); 9898 9899 // Not lambdas. 9900 verifyFormat("int a[ 5 ];", Spaces); 9901 verifyFormat("a[ 3 ] += 42;", Spaces); 9902 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 9903 verifyFormat("double &operator[](int i) { return 0; }\n" 9904 "int i;", 9905 Spaces); 9906 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 9907 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 9908 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 9909 } 9910 9911 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 9912 verifyFormat("int a = 5;"); 9913 verifyFormat("a += 42;"); 9914 verifyFormat("a or_eq 8;"); 9915 9916 FormatStyle Spaces = getLLVMStyle(); 9917 Spaces.SpaceBeforeAssignmentOperators = false; 9918 verifyFormat("int a= 5;", Spaces); 9919 verifyFormat("a+= 42;", Spaces); 9920 verifyFormat("a or_eq 8;", Spaces); 9921 } 9922 9923 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 9924 verifyFormat("class Foo : public Bar {};"); 9925 verifyFormat("Foo::Foo() : foo(1) {}"); 9926 verifyFormat("for (auto a : b) {\n}"); 9927 verifyFormat("int x = a ? b : c;"); 9928 verifyFormat("{\n" 9929 "label0:\n" 9930 " int x = 0;\n" 9931 "}"); 9932 verifyFormat("switch (x) {\n" 9933 "case 1:\n" 9934 "default:\n" 9935 "}"); 9936 9937 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 9938 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 9939 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 9940 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 9941 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 9942 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 9943 verifyFormat("{\n" 9944 "label1:\n" 9945 " int x = 0;\n" 9946 "}", 9947 CtorInitializerStyle); 9948 verifyFormat("switch (x) {\n" 9949 "case 1:\n" 9950 "default:\n" 9951 "}", 9952 CtorInitializerStyle); 9953 CtorInitializerStyle.BreakConstructorInitializers = 9954 FormatStyle::BCIS_AfterColon; 9955 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 9956 " aaaaaaaaaaaaaaaa(1),\n" 9957 " bbbbbbbbbbbbbbbb(2) {}", 9958 CtorInitializerStyle); 9959 CtorInitializerStyle.BreakConstructorInitializers = 9960 FormatStyle::BCIS_BeforeComma; 9961 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 9962 " : aaaaaaaaaaaaaaaa(1)\n" 9963 " , bbbbbbbbbbbbbbbb(2) {}", 9964 CtorInitializerStyle); 9965 CtorInitializerStyle.BreakConstructorInitializers = 9966 FormatStyle::BCIS_BeforeColon; 9967 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 9968 " : aaaaaaaaaaaaaaaa(1),\n" 9969 " bbbbbbbbbbbbbbbb(2) {}", 9970 CtorInitializerStyle); 9971 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 9972 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 9973 ": aaaaaaaaaaaaaaaa(1),\n" 9974 " bbbbbbbbbbbbbbbb(2) {}", 9975 CtorInitializerStyle); 9976 9977 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 9978 InheritanceStyle.SpaceBeforeInheritanceColon = false; 9979 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 9980 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 9981 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 9982 verifyFormat("int x = a ? b : c;", InheritanceStyle); 9983 verifyFormat("{\n" 9984 "label2:\n" 9985 " int x = 0;\n" 9986 "}", 9987 InheritanceStyle); 9988 verifyFormat("switch (x) {\n" 9989 "case 1:\n" 9990 "default:\n" 9991 "}", 9992 InheritanceStyle); 9993 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 9994 verifyFormat("class Foooooooooooooooooooooo:\n" 9995 " public aaaaaaaaaaaaaaaaaa,\n" 9996 " public bbbbbbbbbbbbbbbbbb {\n" 9997 "}", 9998 InheritanceStyle); 9999 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 10000 verifyFormat("class Foooooooooooooooooooooo\n" 10001 " : public aaaaaaaaaaaaaaaaaa\n" 10002 " , public bbbbbbbbbbbbbbbbbb {\n" 10003 "}", 10004 InheritanceStyle); 10005 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 10006 verifyFormat("class Foooooooooooooooooooooo\n" 10007 " : public aaaaaaaaaaaaaaaaaa,\n" 10008 " public bbbbbbbbbbbbbbbbbb {\n" 10009 "}", 10010 InheritanceStyle); 10011 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 10012 verifyFormat("class Foooooooooooooooooooooo\n" 10013 ": public aaaaaaaaaaaaaaaaaa,\n" 10014 " public bbbbbbbbbbbbbbbbbb {}", 10015 InheritanceStyle); 10016 10017 FormatStyle ForLoopStyle = getLLVMStyle(); 10018 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 10019 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 10020 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 10021 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 10022 verifyFormat("int x = a ? b : c;", ForLoopStyle); 10023 verifyFormat("{\n" 10024 "label2:\n" 10025 " int x = 0;\n" 10026 "}", 10027 ForLoopStyle); 10028 verifyFormat("switch (x) {\n" 10029 "case 1:\n" 10030 "default:\n" 10031 "}", 10032 ForLoopStyle); 10033 10034 FormatStyle NoSpaceStyle = getLLVMStyle(); 10035 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 10036 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 10037 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 10038 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 10039 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 10040 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 10041 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 10042 verifyFormat("{\n" 10043 "label3:\n" 10044 " int x = 0;\n" 10045 "}", 10046 NoSpaceStyle); 10047 verifyFormat("switch (x) {\n" 10048 "case 1:\n" 10049 "default:\n" 10050 "}", 10051 NoSpaceStyle); 10052 } 10053 10054 TEST_F(FormatTest, AlignConsecutiveAssignments) { 10055 FormatStyle Alignment = getLLVMStyle(); 10056 Alignment.AlignConsecutiveAssignments = false; 10057 verifyFormat("int a = 5;\n" 10058 "int oneTwoThree = 123;", 10059 Alignment); 10060 verifyFormat("int a = 5;\n" 10061 "int oneTwoThree = 123;", 10062 Alignment); 10063 10064 Alignment.AlignConsecutiveAssignments = true; 10065 verifyFormat("int a = 5;\n" 10066 "int oneTwoThree = 123;", 10067 Alignment); 10068 verifyFormat("int a = method();\n" 10069 "int oneTwoThree = 133;", 10070 Alignment); 10071 verifyFormat("a &= 5;\n" 10072 "bcd *= 5;\n" 10073 "ghtyf += 5;\n" 10074 "dvfvdb -= 5;\n" 10075 "a /= 5;\n" 10076 "vdsvsv %= 5;\n" 10077 "sfdbddfbdfbb ^= 5;\n" 10078 "dvsdsv |= 5;\n" 10079 "int dsvvdvsdvvv = 123;", 10080 Alignment); 10081 verifyFormat("int i = 1, j = 10;\n" 10082 "something = 2000;", 10083 Alignment); 10084 verifyFormat("something = 2000;\n" 10085 "int i = 1, j = 10;\n", 10086 Alignment); 10087 verifyFormat("something = 2000;\n" 10088 "another = 911;\n" 10089 "int i = 1, j = 10;\n" 10090 "oneMore = 1;\n" 10091 "i = 2;", 10092 Alignment); 10093 verifyFormat("int a = 5;\n" 10094 "int one = 1;\n" 10095 "method();\n" 10096 "int oneTwoThree = 123;\n" 10097 "int oneTwo = 12;", 10098 Alignment); 10099 verifyFormat("int oneTwoThree = 123;\n" 10100 "int oneTwo = 12;\n" 10101 "method();\n", 10102 Alignment); 10103 verifyFormat("int oneTwoThree = 123; // comment\n" 10104 "int oneTwo = 12; // comment", 10105 Alignment); 10106 EXPECT_EQ("int a = 5;\n" 10107 "\n" 10108 "int oneTwoThree = 123;", 10109 format("int a = 5;\n" 10110 "\n" 10111 "int oneTwoThree= 123;", 10112 Alignment)); 10113 EXPECT_EQ("int a = 5;\n" 10114 "int one = 1;\n" 10115 "\n" 10116 "int oneTwoThree = 123;", 10117 format("int a = 5;\n" 10118 "int one = 1;\n" 10119 "\n" 10120 "int oneTwoThree = 123;", 10121 Alignment)); 10122 EXPECT_EQ("int a = 5;\n" 10123 "int one = 1;\n" 10124 "\n" 10125 "int oneTwoThree = 123;\n" 10126 "int oneTwo = 12;", 10127 format("int a = 5;\n" 10128 "int one = 1;\n" 10129 "\n" 10130 "int oneTwoThree = 123;\n" 10131 "int oneTwo = 12;", 10132 Alignment)); 10133 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10134 verifyFormat("#define A \\\n" 10135 " int aaaa = 12; \\\n" 10136 " int b = 23; \\\n" 10137 " int ccc = 234; \\\n" 10138 " int dddddddddd = 2345;", 10139 Alignment); 10140 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10141 verifyFormat("#define A \\\n" 10142 " int aaaa = 12; \\\n" 10143 " int b = 23; \\\n" 10144 " int ccc = 234; \\\n" 10145 " int dddddddddd = 2345;", 10146 Alignment); 10147 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10148 verifyFormat("#define A " 10149 " \\\n" 10150 " int aaaa = 12; " 10151 " \\\n" 10152 " int b = 23; " 10153 " \\\n" 10154 " int ccc = 234; " 10155 " \\\n" 10156 " int dddddddddd = 2345;", 10157 Alignment); 10158 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10159 "k = 4, int l = 5,\n" 10160 " int m = 6) {\n" 10161 " int j = 10;\n" 10162 " otherThing = 1;\n" 10163 "}", 10164 Alignment); 10165 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10166 " int i = 1;\n" 10167 " int j = 2;\n" 10168 " int big = 10000;\n" 10169 "}", 10170 Alignment); 10171 verifyFormat("class C {\n" 10172 "public:\n" 10173 " int i = 1;\n" 10174 " virtual void f() = 0;\n" 10175 "};", 10176 Alignment); 10177 verifyFormat("int i = 1;\n" 10178 "if (SomeType t = getSomething()) {\n" 10179 "}\n" 10180 "int j = 2;\n" 10181 "int big = 10000;", 10182 Alignment); 10183 verifyFormat("int j = 7;\n" 10184 "for (int k = 0; k < N; ++k) {\n" 10185 "}\n" 10186 "int j = 2;\n" 10187 "int big = 10000;\n" 10188 "}", 10189 Alignment); 10190 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10191 verifyFormat("int i = 1;\n" 10192 "LooooooooooongType loooooooooooooooooooooongVariable\n" 10193 " = someLooooooooooooooooongFunction();\n" 10194 "int j = 2;", 10195 Alignment); 10196 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 10197 verifyFormat("int i = 1;\n" 10198 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 10199 " someLooooooooooooooooongFunction();\n" 10200 "int j = 2;", 10201 Alignment); 10202 10203 verifyFormat("auto lambda = []() {\n" 10204 " auto i = 0;\n" 10205 " return 0;\n" 10206 "};\n" 10207 "int i = 0;\n" 10208 "auto v = type{\n" 10209 " i = 1, //\n" 10210 " (i = 2), //\n" 10211 " i = 3 //\n" 10212 "};", 10213 Alignment); 10214 10215 verifyFormat( 10216 "int i = 1;\n" 10217 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 10218 " loooooooooooooooooooooongParameterB);\n" 10219 "int j = 2;", 10220 Alignment); 10221 10222 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 10223 " typename B = very_long_type_name_1,\n" 10224 " typename T_2 = very_long_type_name_2>\n" 10225 "auto foo() {}\n", 10226 Alignment); 10227 verifyFormat("int a, b = 1;\n" 10228 "int c = 2;\n" 10229 "int dd = 3;\n", 10230 Alignment); 10231 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10232 "float b[1][] = {{3.f}};\n", 10233 Alignment); 10234 verifyFormat("for (int i = 0; i < 1; i++)\n" 10235 " int x = 1;\n", 10236 Alignment); 10237 verifyFormat("for (i = 0; i < 1; i++)\n" 10238 " x = 1;\n" 10239 "y = 1;\n", 10240 Alignment); 10241 } 10242 10243 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 10244 FormatStyle Alignment = getLLVMStyle(); 10245 Alignment.AlignConsecutiveDeclarations = false; 10246 verifyFormat("float const a = 5;\n" 10247 "int oneTwoThree = 123;", 10248 Alignment); 10249 verifyFormat("int a = 5;\n" 10250 "float const oneTwoThree = 123;", 10251 Alignment); 10252 10253 Alignment.AlignConsecutiveDeclarations = true; 10254 verifyFormat("float const a = 5;\n" 10255 "int oneTwoThree = 123;", 10256 Alignment); 10257 verifyFormat("int a = method();\n" 10258 "float const oneTwoThree = 133;", 10259 Alignment); 10260 verifyFormat("int i = 1, j = 10;\n" 10261 "something = 2000;", 10262 Alignment); 10263 verifyFormat("something = 2000;\n" 10264 "int i = 1, j = 10;\n", 10265 Alignment); 10266 verifyFormat("float something = 2000;\n" 10267 "double another = 911;\n" 10268 "int i = 1, j = 10;\n" 10269 "const int *oneMore = 1;\n" 10270 "unsigned i = 2;", 10271 Alignment); 10272 verifyFormat("float a = 5;\n" 10273 "int one = 1;\n" 10274 "method();\n" 10275 "const double oneTwoThree = 123;\n" 10276 "const unsigned int oneTwo = 12;", 10277 Alignment); 10278 verifyFormat("int oneTwoThree{0}; // comment\n" 10279 "unsigned oneTwo; // comment", 10280 Alignment); 10281 EXPECT_EQ("float const a = 5;\n" 10282 "\n" 10283 "int oneTwoThree = 123;", 10284 format("float const a = 5;\n" 10285 "\n" 10286 "int oneTwoThree= 123;", 10287 Alignment)); 10288 EXPECT_EQ("float a = 5;\n" 10289 "int one = 1;\n" 10290 "\n" 10291 "unsigned oneTwoThree = 123;", 10292 format("float a = 5;\n" 10293 "int one = 1;\n" 10294 "\n" 10295 "unsigned oneTwoThree = 123;", 10296 Alignment)); 10297 EXPECT_EQ("float a = 5;\n" 10298 "int one = 1;\n" 10299 "\n" 10300 "unsigned oneTwoThree = 123;\n" 10301 "int oneTwo = 12;", 10302 format("float a = 5;\n" 10303 "int one = 1;\n" 10304 "\n" 10305 "unsigned oneTwoThree = 123;\n" 10306 "int oneTwo = 12;", 10307 Alignment)); 10308 // Function prototype alignment 10309 verifyFormat("int a();\n" 10310 "double b();", 10311 Alignment); 10312 verifyFormat("int a(int x);\n" 10313 "double b();", 10314 Alignment); 10315 unsigned OldColumnLimit = Alignment.ColumnLimit; 10316 // We need to set ColumnLimit to zero, in order to stress nested alignments, 10317 // otherwise the function parameters will be re-flowed onto a single line. 10318 Alignment.ColumnLimit = 0; 10319 EXPECT_EQ("int a(int x,\n" 10320 " float y);\n" 10321 "double b(int x,\n" 10322 " double y);", 10323 format("int a(int x,\n" 10324 " float y);\n" 10325 "double b(int x,\n" 10326 " double y);", 10327 Alignment)); 10328 // This ensures that function parameters of function declarations are 10329 // correctly indented when their owning functions are indented. 10330 // The failure case here is for 'double y' to not be indented enough. 10331 EXPECT_EQ("double a(int x);\n" 10332 "int b(int y,\n" 10333 " double z);", 10334 format("double a(int x);\n" 10335 "int b(int y,\n" 10336 " double z);", 10337 Alignment)); 10338 // Set ColumnLimit low so that we induce wrapping immediately after 10339 // the function name and opening paren. 10340 Alignment.ColumnLimit = 13; 10341 verifyFormat("int function(\n" 10342 " int x,\n" 10343 " bool y);", 10344 Alignment); 10345 Alignment.ColumnLimit = OldColumnLimit; 10346 // Ensure function pointers don't screw up recursive alignment 10347 verifyFormat("int a(int x, void (*fp)(int y));\n" 10348 "double b();", 10349 Alignment); 10350 Alignment.AlignConsecutiveAssignments = true; 10351 // Ensure recursive alignment is broken by function braces, so that the 10352 // "a = 1" does not align with subsequent assignments inside the function 10353 // body. 10354 verifyFormat("int func(int a = 1) {\n" 10355 " int b = 2;\n" 10356 " int cc = 3;\n" 10357 "}", 10358 Alignment); 10359 verifyFormat("float something = 2000;\n" 10360 "double another = 911;\n" 10361 "int i = 1, j = 10;\n" 10362 "const int *oneMore = 1;\n" 10363 "unsigned i = 2;", 10364 Alignment); 10365 verifyFormat("int oneTwoThree = {0}; // comment\n" 10366 "unsigned oneTwo = 0; // comment", 10367 Alignment); 10368 // Make sure that scope is correctly tracked, in the absence of braces 10369 verifyFormat("for (int i = 0; i < n; i++)\n" 10370 " j = i;\n" 10371 "double x = 1;\n", 10372 Alignment); 10373 verifyFormat("if (int i = 0)\n" 10374 " j = i;\n" 10375 "double x = 1;\n", 10376 Alignment); 10377 // Ensure operator[] and operator() are comprehended 10378 verifyFormat("struct test {\n" 10379 " long long int foo();\n" 10380 " int operator[](int a);\n" 10381 " double bar();\n" 10382 "};\n", 10383 Alignment); 10384 verifyFormat("struct test {\n" 10385 " long long int foo();\n" 10386 " int operator()(int a);\n" 10387 " double bar();\n" 10388 "};\n", 10389 Alignment); 10390 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 10391 " int const i = 1;\n" 10392 " int * j = 2;\n" 10393 " int big = 10000;\n" 10394 "\n" 10395 " unsigned oneTwoThree = 123;\n" 10396 " int oneTwo = 12;\n" 10397 " method();\n" 10398 " float k = 2;\n" 10399 " int ll = 10000;\n" 10400 "}", 10401 format("void SomeFunction(int parameter= 0) {\n" 10402 " int const i= 1;\n" 10403 " int *j=2;\n" 10404 " int big = 10000;\n" 10405 "\n" 10406 "unsigned oneTwoThree =123;\n" 10407 "int oneTwo = 12;\n" 10408 " method();\n" 10409 "float k= 2;\n" 10410 "int ll=10000;\n" 10411 "}", 10412 Alignment)); 10413 Alignment.AlignConsecutiveAssignments = false; 10414 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10415 verifyFormat("#define A \\\n" 10416 " int aaaa = 12; \\\n" 10417 " float b = 23; \\\n" 10418 " const int ccc = 234; \\\n" 10419 " unsigned dddddddddd = 2345;", 10420 Alignment); 10421 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10422 verifyFormat("#define A \\\n" 10423 " int aaaa = 12; \\\n" 10424 " float b = 23; \\\n" 10425 " const int ccc = 234; \\\n" 10426 " unsigned dddddddddd = 2345;", 10427 Alignment); 10428 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10429 Alignment.ColumnLimit = 30; 10430 verifyFormat("#define A \\\n" 10431 " int aaaa = 12; \\\n" 10432 " float b = 23; \\\n" 10433 " const int ccc = 234; \\\n" 10434 " int dddddddddd = 2345;", 10435 Alignment); 10436 Alignment.ColumnLimit = 80; 10437 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10438 "k = 4, int l = 5,\n" 10439 " int m = 6) {\n" 10440 " const int j = 10;\n" 10441 " otherThing = 1;\n" 10442 "}", 10443 Alignment); 10444 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10445 " int const i = 1;\n" 10446 " int * j = 2;\n" 10447 " int big = 10000;\n" 10448 "}", 10449 Alignment); 10450 verifyFormat("class C {\n" 10451 "public:\n" 10452 " int i = 1;\n" 10453 " virtual void f() = 0;\n" 10454 "};", 10455 Alignment); 10456 verifyFormat("float i = 1;\n" 10457 "if (SomeType t = getSomething()) {\n" 10458 "}\n" 10459 "const unsigned j = 2;\n" 10460 "int big = 10000;", 10461 Alignment); 10462 verifyFormat("float j = 7;\n" 10463 "for (int k = 0; k < N; ++k) {\n" 10464 "}\n" 10465 "unsigned j = 2;\n" 10466 "int big = 10000;\n" 10467 "}", 10468 Alignment); 10469 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10470 verifyFormat("float i = 1;\n" 10471 "LooooooooooongType loooooooooooooooooooooongVariable\n" 10472 " = someLooooooooooooooooongFunction();\n" 10473 "int j = 2;", 10474 Alignment); 10475 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 10476 verifyFormat("int i = 1;\n" 10477 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 10478 " someLooooooooooooooooongFunction();\n" 10479 "int j = 2;", 10480 Alignment); 10481 10482 Alignment.AlignConsecutiveAssignments = true; 10483 verifyFormat("auto lambda = []() {\n" 10484 " auto ii = 0;\n" 10485 " float j = 0;\n" 10486 " return 0;\n" 10487 "};\n" 10488 "int i = 0;\n" 10489 "float i2 = 0;\n" 10490 "auto v = type{\n" 10491 " i = 1, //\n" 10492 " (i = 2), //\n" 10493 " i = 3 //\n" 10494 "};", 10495 Alignment); 10496 Alignment.AlignConsecutiveAssignments = false; 10497 10498 verifyFormat( 10499 "int i = 1;\n" 10500 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 10501 " loooooooooooooooooooooongParameterB);\n" 10502 "int j = 2;", 10503 Alignment); 10504 10505 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 10506 // We expect declarations and assignments to align, as long as it doesn't 10507 // exceed the column limit, starting a new alignment sequence whenever it 10508 // happens. 10509 Alignment.AlignConsecutiveAssignments = true; 10510 Alignment.ColumnLimit = 30; 10511 verifyFormat("float ii = 1;\n" 10512 "unsigned j = 2;\n" 10513 "int someVerylongVariable = 1;\n" 10514 "AnotherLongType ll = 123456;\n" 10515 "VeryVeryLongType k = 2;\n" 10516 "int myvar = 1;", 10517 Alignment); 10518 Alignment.ColumnLimit = 80; 10519 Alignment.AlignConsecutiveAssignments = false; 10520 10521 verifyFormat( 10522 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 10523 " typename LongType, typename B>\n" 10524 "auto foo() {}\n", 10525 Alignment); 10526 verifyFormat("float a, b = 1;\n" 10527 "int c = 2;\n" 10528 "int dd = 3;\n", 10529 Alignment); 10530 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10531 "float b[1][] = {{3.f}};\n", 10532 Alignment); 10533 Alignment.AlignConsecutiveAssignments = true; 10534 verifyFormat("float a, b = 1;\n" 10535 "int c = 2;\n" 10536 "int dd = 3;\n", 10537 Alignment); 10538 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10539 "float b[1][] = {{3.f}};\n", 10540 Alignment); 10541 Alignment.AlignConsecutiveAssignments = false; 10542 10543 Alignment.ColumnLimit = 30; 10544 Alignment.BinPackParameters = false; 10545 verifyFormat("void foo(float a,\n" 10546 " float b,\n" 10547 " int c,\n" 10548 " uint32_t *d) {\n" 10549 " int * e = 0;\n" 10550 " float f = 0;\n" 10551 " double g = 0;\n" 10552 "}\n" 10553 "void bar(ino_t a,\n" 10554 " int b,\n" 10555 " uint32_t *c,\n" 10556 " bool d) {}\n", 10557 Alignment); 10558 Alignment.BinPackParameters = true; 10559 Alignment.ColumnLimit = 80; 10560 10561 // Bug 33507 10562 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 10563 verifyFormat( 10564 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 10565 " static const Version verVs2017;\n" 10566 " return true;\n" 10567 "});\n", 10568 Alignment); 10569 Alignment.PointerAlignment = FormatStyle::PAS_Right; 10570 10571 // See llvm.org/PR35641 10572 Alignment.AlignConsecutiveDeclarations = true; 10573 verifyFormat("int func() { //\n" 10574 " int b;\n" 10575 " unsigned c;\n" 10576 "}", 10577 Alignment); 10578 } 10579 10580 TEST_F(FormatTest, LinuxBraceBreaking) { 10581 FormatStyle LinuxBraceStyle = getLLVMStyle(); 10582 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 10583 verifyFormat("namespace a\n" 10584 "{\n" 10585 "class A\n" 10586 "{\n" 10587 " void f()\n" 10588 " {\n" 10589 " if (true) {\n" 10590 " a();\n" 10591 " b();\n" 10592 " } else {\n" 10593 " a();\n" 10594 " }\n" 10595 " }\n" 10596 " void g() { return; }\n" 10597 "};\n" 10598 "struct B {\n" 10599 " int x;\n" 10600 "};\n" 10601 "} // namespace a\n", 10602 LinuxBraceStyle); 10603 verifyFormat("enum X {\n" 10604 " Y = 0,\n" 10605 "}\n", 10606 LinuxBraceStyle); 10607 verifyFormat("struct S {\n" 10608 " int Type;\n" 10609 " union {\n" 10610 " int x;\n" 10611 " double y;\n" 10612 " } Value;\n" 10613 " class C\n" 10614 " {\n" 10615 " MyFavoriteType Value;\n" 10616 " } Class;\n" 10617 "}\n", 10618 LinuxBraceStyle); 10619 } 10620 10621 TEST_F(FormatTest, MozillaBraceBreaking) { 10622 FormatStyle MozillaBraceStyle = getLLVMStyle(); 10623 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 10624 MozillaBraceStyle.FixNamespaceComments = false; 10625 verifyFormat("namespace a {\n" 10626 "class A\n" 10627 "{\n" 10628 " void f()\n" 10629 " {\n" 10630 " if (true) {\n" 10631 " a();\n" 10632 " b();\n" 10633 " }\n" 10634 " }\n" 10635 " void g() { return; }\n" 10636 "};\n" 10637 "enum E\n" 10638 "{\n" 10639 " A,\n" 10640 " // foo\n" 10641 " B,\n" 10642 " C\n" 10643 "};\n" 10644 "struct B\n" 10645 "{\n" 10646 " int x;\n" 10647 "};\n" 10648 "}\n", 10649 MozillaBraceStyle); 10650 verifyFormat("struct S\n" 10651 "{\n" 10652 " int Type;\n" 10653 " union\n" 10654 " {\n" 10655 " int x;\n" 10656 " double y;\n" 10657 " } Value;\n" 10658 " class C\n" 10659 " {\n" 10660 " MyFavoriteType Value;\n" 10661 " } Class;\n" 10662 "}\n", 10663 MozillaBraceStyle); 10664 } 10665 10666 TEST_F(FormatTest, StroustrupBraceBreaking) { 10667 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 10668 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 10669 verifyFormat("namespace a {\n" 10670 "class A {\n" 10671 " void f()\n" 10672 " {\n" 10673 " if (true) {\n" 10674 " a();\n" 10675 " b();\n" 10676 " }\n" 10677 " }\n" 10678 " void g() { return; }\n" 10679 "};\n" 10680 "struct B {\n" 10681 " int x;\n" 10682 "};\n" 10683 "} // namespace a\n", 10684 StroustrupBraceStyle); 10685 10686 verifyFormat("void foo()\n" 10687 "{\n" 10688 " if (a) {\n" 10689 " a();\n" 10690 " }\n" 10691 " else {\n" 10692 " b();\n" 10693 " }\n" 10694 "}\n", 10695 StroustrupBraceStyle); 10696 10697 verifyFormat("#ifdef _DEBUG\n" 10698 "int foo(int i = 0)\n" 10699 "#else\n" 10700 "int foo(int i = 5)\n" 10701 "#endif\n" 10702 "{\n" 10703 " return i;\n" 10704 "}", 10705 StroustrupBraceStyle); 10706 10707 verifyFormat("void foo() {}\n" 10708 "void bar()\n" 10709 "#ifdef _DEBUG\n" 10710 "{\n" 10711 " foo();\n" 10712 "}\n" 10713 "#else\n" 10714 "{\n" 10715 "}\n" 10716 "#endif", 10717 StroustrupBraceStyle); 10718 10719 verifyFormat("void foobar() { int i = 5; }\n" 10720 "#ifdef _DEBUG\n" 10721 "void bar() {}\n" 10722 "#else\n" 10723 "void bar() { foobar(); }\n" 10724 "#endif", 10725 StroustrupBraceStyle); 10726 } 10727 10728 TEST_F(FormatTest, AllmanBraceBreaking) { 10729 FormatStyle AllmanBraceStyle = getLLVMStyle(); 10730 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 10731 10732 EXPECT_EQ("namespace a\n" 10733 "{\n" 10734 "void f();\n" 10735 "void g();\n" 10736 "} // namespace a\n", 10737 format("namespace a\n" 10738 "{\n" 10739 "void f();\n" 10740 "void g();\n" 10741 "}\n", 10742 AllmanBraceStyle)); 10743 10744 verifyFormat("namespace a\n" 10745 "{\n" 10746 "class A\n" 10747 "{\n" 10748 " void f()\n" 10749 " {\n" 10750 " if (true)\n" 10751 " {\n" 10752 " a();\n" 10753 " b();\n" 10754 " }\n" 10755 " }\n" 10756 " void g() { return; }\n" 10757 "};\n" 10758 "struct B\n" 10759 "{\n" 10760 " int x;\n" 10761 "};\n" 10762 "} // namespace a", 10763 AllmanBraceStyle); 10764 10765 verifyFormat("void f()\n" 10766 "{\n" 10767 " if (true)\n" 10768 " {\n" 10769 " a();\n" 10770 " }\n" 10771 " else if (false)\n" 10772 " {\n" 10773 " b();\n" 10774 " }\n" 10775 " else\n" 10776 " {\n" 10777 " c();\n" 10778 " }\n" 10779 "}\n", 10780 AllmanBraceStyle); 10781 10782 verifyFormat("void f()\n" 10783 "{\n" 10784 " for (int i = 0; i < 10; ++i)\n" 10785 " {\n" 10786 " a();\n" 10787 " }\n" 10788 " while (false)\n" 10789 " {\n" 10790 " b();\n" 10791 " }\n" 10792 " do\n" 10793 " {\n" 10794 " c();\n" 10795 " } while (false)\n" 10796 "}\n", 10797 AllmanBraceStyle); 10798 10799 verifyFormat("void f(int a)\n" 10800 "{\n" 10801 " switch (a)\n" 10802 " {\n" 10803 " case 0:\n" 10804 " break;\n" 10805 " case 1:\n" 10806 " {\n" 10807 " break;\n" 10808 " }\n" 10809 " case 2:\n" 10810 " {\n" 10811 " }\n" 10812 " break;\n" 10813 " default:\n" 10814 " break;\n" 10815 " }\n" 10816 "}\n", 10817 AllmanBraceStyle); 10818 10819 verifyFormat("enum X\n" 10820 "{\n" 10821 " Y = 0,\n" 10822 "}\n", 10823 AllmanBraceStyle); 10824 verifyFormat("enum X\n" 10825 "{\n" 10826 " Y = 0\n" 10827 "}\n", 10828 AllmanBraceStyle); 10829 10830 verifyFormat("@interface BSApplicationController ()\n" 10831 "{\n" 10832 "@private\n" 10833 " id _extraIvar;\n" 10834 "}\n" 10835 "@end\n", 10836 AllmanBraceStyle); 10837 10838 verifyFormat("#ifdef _DEBUG\n" 10839 "int foo(int i = 0)\n" 10840 "#else\n" 10841 "int foo(int i = 5)\n" 10842 "#endif\n" 10843 "{\n" 10844 " return i;\n" 10845 "}", 10846 AllmanBraceStyle); 10847 10848 verifyFormat("void foo() {}\n" 10849 "void bar()\n" 10850 "#ifdef _DEBUG\n" 10851 "{\n" 10852 " foo();\n" 10853 "}\n" 10854 "#else\n" 10855 "{\n" 10856 "}\n" 10857 "#endif", 10858 AllmanBraceStyle); 10859 10860 verifyFormat("void foobar() { int i = 5; }\n" 10861 "#ifdef _DEBUG\n" 10862 "void bar() {}\n" 10863 "#else\n" 10864 "void bar() { foobar(); }\n" 10865 "#endif", 10866 AllmanBraceStyle); 10867 10868 // This shouldn't affect ObjC blocks.. 10869 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 10870 " // ...\n" 10871 " int i;\n" 10872 "}];", 10873 AllmanBraceStyle); 10874 verifyFormat("void (^block)(void) = ^{\n" 10875 " // ...\n" 10876 " int i;\n" 10877 "};", 10878 AllmanBraceStyle); 10879 // .. or dict literals. 10880 verifyFormat("void f()\n" 10881 "{\n" 10882 " // ...\n" 10883 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 10884 "}", 10885 AllmanBraceStyle); 10886 verifyFormat("void f()\n" 10887 "{\n" 10888 " // ...\n" 10889 " [object someMethod:@{a : @\"b\"}];\n" 10890 "}", 10891 AllmanBraceStyle); 10892 verifyFormat("int f()\n" 10893 "{ // comment\n" 10894 " return 42;\n" 10895 "}", 10896 AllmanBraceStyle); 10897 10898 AllmanBraceStyle.ColumnLimit = 19; 10899 verifyFormat("void f() { int i; }", AllmanBraceStyle); 10900 AllmanBraceStyle.ColumnLimit = 18; 10901 verifyFormat("void f()\n" 10902 "{\n" 10903 " int i;\n" 10904 "}", 10905 AllmanBraceStyle); 10906 AllmanBraceStyle.ColumnLimit = 80; 10907 10908 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 10909 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 10910 FormatStyle::SIS_WithoutElse; 10911 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 10912 verifyFormat("void f(bool b)\n" 10913 "{\n" 10914 " if (b)\n" 10915 " {\n" 10916 " return;\n" 10917 " }\n" 10918 "}\n", 10919 BreakBeforeBraceShortIfs); 10920 verifyFormat("void f(bool b)\n" 10921 "{\n" 10922 " if constexpr (b)\n" 10923 " {\n" 10924 " return;\n" 10925 " }\n" 10926 "}\n", 10927 BreakBeforeBraceShortIfs); 10928 verifyFormat("void f(bool b)\n" 10929 "{\n" 10930 " if (b) return;\n" 10931 "}\n", 10932 BreakBeforeBraceShortIfs); 10933 verifyFormat("void f(bool b)\n" 10934 "{\n" 10935 " if constexpr (b) return;\n" 10936 "}\n", 10937 BreakBeforeBraceShortIfs); 10938 verifyFormat("void f(bool b)\n" 10939 "{\n" 10940 " while (b)\n" 10941 " {\n" 10942 " return;\n" 10943 " }\n" 10944 "}\n", 10945 BreakBeforeBraceShortIfs); 10946 } 10947 10948 TEST_F(FormatTest, GNUBraceBreaking) { 10949 FormatStyle GNUBraceStyle = getLLVMStyle(); 10950 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 10951 verifyFormat("namespace a\n" 10952 "{\n" 10953 "class A\n" 10954 "{\n" 10955 " void f()\n" 10956 " {\n" 10957 " int a;\n" 10958 " {\n" 10959 " int b;\n" 10960 " }\n" 10961 " if (true)\n" 10962 " {\n" 10963 " a();\n" 10964 " b();\n" 10965 " }\n" 10966 " }\n" 10967 " void g() { return; }\n" 10968 "}\n" 10969 "} // namespace a", 10970 GNUBraceStyle); 10971 10972 verifyFormat("void f()\n" 10973 "{\n" 10974 " if (true)\n" 10975 " {\n" 10976 " a();\n" 10977 " }\n" 10978 " else if (false)\n" 10979 " {\n" 10980 " b();\n" 10981 " }\n" 10982 " else\n" 10983 " {\n" 10984 " c();\n" 10985 " }\n" 10986 "}\n", 10987 GNUBraceStyle); 10988 10989 verifyFormat("void f()\n" 10990 "{\n" 10991 " for (int i = 0; i < 10; ++i)\n" 10992 " {\n" 10993 " a();\n" 10994 " }\n" 10995 " while (false)\n" 10996 " {\n" 10997 " b();\n" 10998 " }\n" 10999 " do\n" 11000 " {\n" 11001 " c();\n" 11002 " }\n" 11003 " while (false);\n" 11004 "}\n", 11005 GNUBraceStyle); 11006 11007 verifyFormat("void f(int a)\n" 11008 "{\n" 11009 " switch (a)\n" 11010 " {\n" 11011 " case 0:\n" 11012 " break;\n" 11013 " case 1:\n" 11014 " {\n" 11015 " break;\n" 11016 " }\n" 11017 " case 2:\n" 11018 " {\n" 11019 " }\n" 11020 " break;\n" 11021 " default:\n" 11022 " break;\n" 11023 " }\n" 11024 "}\n", 11025 GNUBraceStyle); 11026 11027 verifyFormat("enum X\n" 11028 "{\n" 11029 " Y = 0,\n" 11030 "}\n", 11031 GNUBraceStyle); 11032 11033 verifyFormat("@interface BSApplicationController ()\n" 11034 "{\n" 11035 "@private\n" 11036 " id _extraIvar;\n" 11037 "}\n" 11038 "@end\n", 11039 GNUBraceStyle); 11040 11041 verifyFormat("#ifdef _DEBUG\n" 11042 "int foo(int i = 0)\n" 11043 "#else\n" 11044 "int foo(int i = 5)\n" 11045 "#endif\n" 11046 "{\n" 11047 " return i;\n" 11048 "}", 11049 GNUBraceStyle); 11050 11051 verifyFormat("void foo() {}\n" 11052 "void bar()\n" 11053 "#ifdef _DEBUG\n" 11054 "{\n" 11055 " foo();\n" 11056 "}\n" 11057 "#else\n" 11058 "{\n" 11059 "}\n" 11060 "#endif", 11061 GNUBraceStyle); 11062 11063 verifyFormat("void foobar() { int i = 5; }\n" 11064 "#ifdef _DEBUG\n" 11065 "void bar() {}\n" 11066 "#else\n" 11067 "void bar() { foobar(); }\n" 11068 "#endif", 11069 GNUBraceStyle); 11070 } 11071 11072 TEST_F(FormatTest, WebKitBraceBreaking) { 11073 FormatStyle WebKitBraceStyle = getLLVMStyle(); 11074 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 11075 WebKitBraceStyle.FixNamespaceComments = false; 11076 verifyFormat("namespace a {\n" 11077 "class A {\n" 11078 " void f()\n" 11079 " {\n" 11080 " if (true) {\n" 11081 " a();\n" 11082 " b();\n" 11083 " }\n" 11084 " }\n" 11085 " void g() { return; }\n" 11086 "};\n" 11087 "enum E {\n" 11088 " A,\n" 11089 " // foo\n" 11090 " B,\n" 11091 " C\n" 11092 "};\n" 11093 "struct B {\n" 11094 " int x;\n" 11095 "};\n" 11096 "}\n", 11097 WebKitBraceStyle); 11098 verifyFormat("struct S {\n" 11099 " int Type;\n" 11100 " union {\n" 11101 " int x;\n" 11102 " double y;\n" 11103 " } Value;\n" 11104 " class C {\n" 11105 " MyFavoriteType Value;\n" 11106 " } Class;\n" 11107 "};\n", 11108 WebKitBraceStyle); 11109 } 11110 11111 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 11112 verifyFormat("void f() {\n" 11113 " try {\n" 11114 " } catch (const Exception &e) {\n" 11115 " }\n" 11116 "}\n", 11117 getLLVMStyle()); 11118 } 11119 11120 TEST_F(FormatTest, UnderstandsPragmas) { 11121 verifyFormat("#pragma omp reduction(| : var)"); 11122 verifyFormat("#pragma omp reduction(+ : var)"); 11123 11124 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 11125 "(including parentheses).", 11126 format("#pragma mark Any non-hyphenated or hyphenated string " 11127 "(including parentheses).")); 11128 } 11129 11130 TEST_F(FormatTest, UnderstandPragmaOption) { 11131 verifyFormat("#pragma option -C -A"); 11132 11133 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 11134 } 11135 11136 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 11137 FormatStyle Style = getLLVMStyle(); 11138 Style.ColumnLimit = 20; 11139 11140 verifyFormat("int a; // the\n" 11141 " // comment", Style); 11142 EXPECT_EQ("int a; /* first line\n" 11143 " * second\n" 11144 " * line third\n" 11145 " * line\n" 11146 " */", 11147 format("int a; /* first line\n" 11148 " * second\n" 11149 " * line third\n" 11150 " * line\n" 11151 " */", 11152 Style)); 11153 EXPECT_EQ("int a; // first line\n" 11154 " // second\n" 11155 " // line third\n" 11156 " // line", 11157 format("int a; // first line\n" 11158 " // second line\n" 11159 " // third line", 11160 Style)); 11161 11162 Style.PenaltyExcessCharacter = 90; 11163 verifyFormat("int a; // the comment", Style); 11164 EXPECT_EQ("int a; // the comment\n" 11165 " // aaa", 11166 format("int a; // the comment aaa", Style)); 11167 EXPECT_EQ("int a; /* first line\n" 11168 " * second line\n" 11169 " * third line\n" 11170 " */", 11171 format("int a; /* first line\n" 11172 " * second line\n" 11173 " * third line\n" 11174 " */", 11175 Style)); 11176 EXPECT_EQ("int a; // first line\n" 11177 " // second line\n" 11178 " // third line", 11179 format("int a; // first line\n" 11180 " // second line\n" 11181 " // third line", 11182 Style)); 11183 // FIXME: Investigate why this is not getting the same layout as the test 11184 // above. 11185 EXPECT_EQ("int a; /* first line\n" 11186 " * second line\n" 11187 " * third line\n" 11188 " */", 11189 format("int a; /* first line second line third line" 11190 "\n*/", 11191 Style)); 11192 11193 EXPECT_EQ("// foo bar baz bazfoo\n" 11194 "// foo bar foo bar\n", 11195 format("// foo bar baz bazfoo\n" 11196 "// foo bar foo bar\n", 11197 Style)); 11198 EXPECT_EQ("// foo bar baz bazfoo\n" 11199 "// foo bar foo bar\n", 11200 format("// foo bar baz bazfoo\n" 11201 "// foo bar foo bar\n", 11202 Style)); 11203 11204 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 11205 // next one. 11206 EXPECT_EQ("// foo bar baz bazfoo\n" 11207 "// bar foo bar\n", 11208 format("// foo bar baz bazfoo bar\n" 11209 "// foo bar\n", 11210 Style)); 11211 11212 EXPECT_EQ("// foo bar baz bazfoo\n" 11213 "// foo bar baz bazfoo\n" 11214 "// bar foo bar\n", 11215 format("// foo bar baz bazfoo\n" 11216 "// foo bar baz bazfoo bar\n" 11217 "// foo bar\n", 11218 Style)); 11219 11220 EXPECT_EQ("// foo bar baz bazfoo\n" 11221 "// foo bar baz bazfoo\n" 11222 "// bar foo bar\n", 11223 format("// foo bar baz bazfoo\n" 11224 "// foo bar baz bazfoo bar\n" 11225 "// foo bar\n", 11226 Style)); 11227 11228 // Make sure we do not keep protruding characters if strict mode reflow is 11229 // cheaper than keeping protruding characters. 11230 Style.ColumnLimit = 21; 11231 EXPECT_EQ("// foo foo foo foo\n" 11232 "// foo foo foo foo\n" 11233 "// foo foo foo foo\n", 11234 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", 11235 Style)); 11236 11237 EXPECT_EQ("int a = /* long block\n" 11238 " comment */\n" 11239 " 42;", 11240 format("int a = /* long block comment */ 42;", Style)); 11241 } 11242 11243 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 11244 for (size_t i = 1; i < Styles.size(); ++i) \ 11245 EXPECT_EQ(Styles[0], Styles[i]) << "Style #" << i << " of " << Styles.size() \ 11246 << " differs from Style #0" 11247 11248 TEST_F(FormatTest, GetsPredefinedStyleByName) { 11249 SmallVector<FormatStyle, 3> Styles; 11250 Styles.resize(3); 11251 11252 Styles[0] = getLLVMStyle(); 11253 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 11254 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 11255 EXPECT_ALL_STYLES_EQUAL(Styles); 11256 11257 Styles[0] = getGoogleStyle(); 11258 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 11259 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 11260 EXPECT_ALL_STYLES_EQUAL(Styles); 11261 11262 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 11263 EXPECT_TRUE( 11264 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 11265 EXPECT_TRUE( 11266 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 11267 EXPECT_ALL_STYLES_EQUAL(Styles); 11268 11269 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 11270 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 11271 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 11272 EXPECT_ALL_STYLES_EQUAL(Styles); 11273 11274 Styles[0] = getMozillaStyle(); 11275 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 11276 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 11277 EXPECT_ALL_STYLES_EQUAL(Styles); 11278 11279 Styles[0] = getWebKitStyle(); 11280 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 11281 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 11282 EXPECT_ALL_STYLES_EQUAL(Styles); 11283 11284 Styles[0] = getGNUStyle(); 11285 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 11286 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 11287 EXPECT_ALL_STYLES_EQUAL(Styles); 11288 11289 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 11290 } 11291 11292 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 11293 SmallVector<FormatStyle, 8> Styles; 11294 Styles.resize(2); 11295 11296 Styles[0] = getGoogleStyle(); 11297 Styles[1] = getLLVMStyle(); 11298 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 11299 EXPECT_ALL_STYLES_EQUAL(Styles); 11300 11301 Styles.resize(5); 11302 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 11303 Styles[1] = getLLVMStyle(); 11304 Styles[1].Language = FormatStyle::LK_JavaScript; 11305 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 11306 11307 Styles[2] = getLLVMStyle(); 11308 Styles[2].Language = FormatStyle::LK_JavaScript; 11309 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 11310 "BasedOnStyle: Google", 11311 &Styles[2]) 11312 .value()); 11313 11314 Styles[3] = getLLVMStyle(); 11315 Styles[3].Language = FormatStyle::LK_JavaScript; 11316 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 11317 "Language: JavaScript", 11318 &Styles[3]) 11319 .value()); 11320 11321 Styles[4] = getLLVMStyle(); 11322 Styles[4].Language = FormatStyle::LK_JavaScript; 11323 EXPECT_EQ(0, parseConfiguration("---\n" 11324 "BasedOnStyle: LLVM\n" 11325 "IndentWidth: 123\n" 11326 "---\n" 11327 "BasedOnStyle: Google\n" 11328 "Language: JavaScript", 11329 &Styles[4]) 11330 .value()); 11331 EXPECT_ALL_STYLES_EQUAL(Styles); 11332 } 11333 11334 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 11335 Style.FIELD = false; \ 11336 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 11337 EXPECT_TRUE(Style.FIELD); \ 11338 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 11339 EXPECT_FALSE(Style.FIELD); 11340 11341 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 11342 11343 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 11344 Style.STRUCT.FIELD = false; \ 11345 EXPECT_EQ(0, \ 11346 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 11347 .value()); \ 11348 EXPECT_TRUE(Style.STRUCT.FIELD); \ 11349 EXPECT_EQ(0, \ 11350 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 11351 .value()); \ 11352 EXPECT_FALSE(Style.STRUCT.FIELD); 11353 11354 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 11355 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 11356 11357 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 11358 EXPECT_NE(VALUE, Style.FIELD); \ 11359 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 11360 EXPECT_EQ(VALUE, Style.FIELD) 11361 11362 TEST_F(FormatTest, ParsesConfigurationBools) { 11363 FormatStyle Style = {}; 11364 Style.Language = FormatStyle::LK_Cpp; 11365 CHECK_PARSE_BOOL(AlignOperands); 11366 CHECK_PARSE_BOOL(AlignTrailingComments); 11367 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 11368 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 11369 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 11370 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 11371 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 11372 CHECK_PARSE_BOOL(AllowShortBlocksOnASingleLine); 11373 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 11374 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 11375 CHECK_PARSE_BOOL(BinPackArguments); 11376 CHECK_PARSE_BOOL(BinPackParameters); 11377 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 11378 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 11379 CHECK_PARSE_BOOL(BreakStringLiterals); 11380 CHECK_PARSE_BOOL(CompactNamespaces); 11381 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 11382 CHECK_PARSE_BOOL(DerivePointerAlignment); 11383 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 11384 CHECK_PARSE_BOOL(DisableFormat); 11385 CHECK_PARSE_BOOL(IndentCaseLabels); 11386 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 11387 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 11388 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 11389 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 11390 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 11391 CHECK_PARSE_BOOL(ReflowComments); 11392 CHECK_PARSE_BOOL(SortIncludes); 11393 CHECK_PARSE_BOOL(SortUsingDeclarations); 11394 CHECK_PARSE_BOOL(SpacesInParentheses); 11395 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 11396 CHECK_PARSE_BOOL(SpacesInAngles); 11397 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 11398 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 11399 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 11400 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 11401 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 11402 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 11403 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 11404 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 11405 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 11406 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 11407 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 11408 11409 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 11410 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 11411 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterControlStatement); 11412 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 11413 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 11414 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 11415 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 11416 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 11417 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 11418 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 11419 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 11420 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 11421 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 11422 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 11423 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 11424 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 11425 } 11426 11427 #undef CHECK_PARSE_BOOL 11428 11429 TEST_F(FormatTest, ParsesConfiguration) { 11430 FormatStyle Style = {}; 11431 Style.Language = FormatStyle::LK_Cpp; 11432 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 11433 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 11434 ConstructorInitializerIndentWidth, 1234u); 11435 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 11436 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 11437 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 11438 CHECK_PARSE("PenaltyBreakAssignment: 1234", 11439 PenaltyBreakAssignment, 1234u); 11440 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 11441 PenaltyBreakBeforeFirstCallParameter, 1234u); 11442 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 11443 PenaltyBreakTemplateDeclaration, 1234u); 11444 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 11445 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 11446 PenaltyReturnTypeOnItsOwnLine, 1234u); 11447 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 11448 SpacesBeforeTrailingComments, 1234u); 11449 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 11450 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 11451 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 11452 11453 Style.PointerAlignment = FormatStyle::PAS_Middle; 11454 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 11455 FormatStyle::PAS_Left); 11456 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 11457 FormatStyle::PAS_Right); 11458 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 11459 FormatStyle::PAS_Middle); 11460 // For backward compatibility: 11461 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 11462 FormatStyle::PAS_Left); 11463 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 11464 FormatStyle::PAS_Right); 11465 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 11466 FormatStyle::PAS_Middle); 11467 11468 Style.Standard = FormatStyle::LS_Auto; 11469 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 11470 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11); 11471 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 11472 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 11473 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 11474 11475 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11476 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 11477 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 11478 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 11479 FormatStyle::BOS_None); 11480 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 11481 FormatStyle::BOS_All); 11482 // For backward compatibility: 11483 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 11484 FormatStyle::BOS_None); 11485 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 11486 FormatStyle::BOS_All); 11487 11488 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 11489 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 11490 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 11491 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 11492 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 11493 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 11494 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 11495 // For backward compatibility: 11496 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 11497 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 11498 11499 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 11500 CHECK_PARSE("BreakInheritanceList: BeforeComma", 11501 BreakInheritanceList, FormatStyle::BILS_BeforeComma); 11502 CHECK_PARSE("BreakInheritanceList: AfterColon", 11503 BreakInheritanceList, FormatStyle::BILS_AfterColon); 11504 CHECK_PARSE("BreakInheritanceList: BeforeColon", 11505 BreakInheritanceList, FormatStyle::BILS_BeforeColon); 11506 // For backward compatibility: 11507 CHECK_PARSE("BreakBeforeInheritanceComma: true", 11508 BreakInheritanceList, FormatStyle::BILS_BeforeComma); 11509 11510 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 11511 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 11512 FormatStyle::BAS_Align); 11513 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 11514 FormatStyle::BAS_DontAlign); 11515 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 11516 FormatStyle::BAS_AlwaysBreak); 11517 // For backward compatibility: 11518 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 11519 FormatStyle::BAS_DontAlign); 11520 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 11521 FormatStyle::BAS_Align); 11522 11523 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11524 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 11525 FormatStyle::ENAS_DontAlign); 11526 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 11527 FormatStyle::ENAS_Left); 11528 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 11529 FormatStyle::ENAS_Right); 11530 // For backward compatibility: 11531 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 11532 FormatStyle::ENAS_Left); 11533 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 11534 FormatStyle::ENAS_Right); 11535 11536 Style.UseTab = FormatStyle::UT_ForIndentation; 11537 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 11538 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 11539 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 11540 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 11541 FormatStyle::UT_ForContinuationAndIndentation); 11542 // For backward compatibility: 11543 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 11544 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 11545 11546 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 11547 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 11548 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 11549 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 11550 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 11551 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 11552 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 11553 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 11554 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 11555 // For backward compatibility: 11556 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 11557 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 11558 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 11559 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 11560 11561 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 11562 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 11563 FormatStyle::SBPO_Never); 11564 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 11565 FormatStyle::SBPO_Always); 11566 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 11567 FormatStyle::SBPO_ControlStatements); 11568 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 11569 FormatStyle::SBPO_NonEmptyParentheses); 11570 // For backward compatibility: 11571 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 11572 FormatStyle::SBPO_Never); 11573 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 11574 FormatStyle::SBPO_ControlStatements); 11575 11576 Style.ColumnLimit = 123; 11577 FormatStyle BaseStyle = getLLVMStyle(); 11578 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 11579 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 11580 11581 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11582 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 11583 FormatStyle::BS_Attach); 11584 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 11585 FormatStyle::BS_Linux); 11586 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 11587 FormatStyle::BS_Mozilla); 11588 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 11589 FormatStyle::BS_Stroustrup); 11590 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 11591 FormatStyle::BS_Allman); 11592 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 11593 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 11594 FormatStyle::BS_WebKit); 11595 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 11596 FormatStyle::BS_Custom); 11597 11598 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 11599 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 11600 FormatStyle::RTBS_None); 11601 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 11602 FormatStyle::RTBS_All); 11603 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 11604 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 11605 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 11606 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 11607 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 11608 AlwaysBreakAfterReturnType, 11609 FormatStyle::RTBS_TopLevelDefinitions); 11610 11611 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 11612 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", AlwaysBreakTemplateDeclarations, 11613 FormatStyle::BTDS_No); 11614 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", AlwaysBreakTemplateDeclarations, 11615 FormatStyle::BTDS_MultiLine); 11616 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", AlwaysBreakTemplateDeclarations, 11617 FormatStyle::BTDS_Yes); 11618 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", AlwaysBreakTemplateDeclarations, 11619 FormatStyle::BTDS_MultiLine); 11620 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", AlwaysBreakTemplateDeclarations, 11621 FormatStyle::BTDS_Yes); 11622 11623 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 11624 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 11625 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 11626 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 11627 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 11628 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 11629 AlwaysBreakAfterDefinitionReturnType, 11630 FormatStyle::DRTBS_TopLevel); 11631 11632 Style.NamespaceIndentation = FormatStyle::NI_All; 11633 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 11634 FormatStyle::NI_None); 11635 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 11636 FormatStyle::NI_Inner); 11637 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 11638 FormatStyle::NI_All); 11639 11640 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 11641 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 11642 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 11643 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 11644 AllowShortIfStatementsOnASingleLine, 11645 FormatStyle::SIS_WithoutElse); 11646 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 11647 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 11648 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 11649 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 11650 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 11651 AllowShortIfStatementsOnASingleLine, 11652 FormatStyle::SIS_WithoutElse); 11653 11654 // FIXME: This is required because parsing a configuration simply overwrites 11655 // the first N elements of the list instead of resetting it. 11656 Style.ForEachMacros.clear(); 11657 std::vector<std::string> BoostForeach; 11658 BoostForeach.push_back("BOOST_FOREACH"); 11659 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 11660 std::vector<std::string> BoostAndQForeach; 11661 BoostAndQForeach.push_back("BOOST_FOREACH"); 11662 BoostAndQForeach.push_back("Q_FOREACH"); 11663 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 11664 BoostAndQForeach); 11665 11666 Style.StatementMacros.clear(); 11667 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 11668 std::vector<std::string>{"QUNUSED"}); 11669 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 11670 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 11671 11672 Style.IncludeStyle.IncludeCategories.clear(); 11673 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 11674 {"abc/.*", 2}, {".*", 1}}; 11675 CHECK_PARSE("IncludeCategories:\n" 11676 " - Regex: abc/.*\n" 11677 " Priority: 2\n" 11678 " - Regex: .*\n" 11679 " Priority: 1", 11680 IncludeStyle.IncludeCategories, ExpectedCategories); 11681 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 11682 "abc$"); 11683 11684 Style.RawStringFormats.clear(); 11685 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 11686 { 11687 FormatStyle::LK_TextProto, 11688 {"pb", "proto"}, 11689 {"PARSE_TEXT_PROTO"}, 11690 /*CanonicalDelimiter=*/"", 11691 "llvm", 11692 }, 11693 { 11694 FormatStyle::LK_Cpp, 11695 {"cc", "cpp"}, 11696 {"C_CODEBLOCK", "CPPEVAL"}, 11697 /*CanonicalDelimiter=*/"cc", 11698 /*BasedOnStyle=*/"", 11699 }, 11700 }; 11701 11702 CHECK_PARSE("RawStringFormats:\n" 11703 " - Language: TextProto\n" 11704 " Delimiters:\n" 11705 " - 'pb'\n" 11706 " - 'proto'\n" 11707 " EnclosingFunctions:\n" 11708 " - 'PARSE_TEXT_PROTO'\n" 11709 " BasedOnStyle: llvm\n" 11710 " - Language: Cpp\n" 11711 " Delimiters:\n" 11712 " - 'cc'\n" 11713 " - 'cpp'\n" 11714 " EnclosingFunctions:\n" 11715 " - 'C_CODEBLOCK'\n" 11716 " - 'CPPEVAL'\n" 11717 " CanonicalDelimiter: 'cc'", 11718 RawStringFormats, ExpectedRawStringFormats); 11719 } 11720 11721 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 11722 FormatStyle Style = {}; 11723 Style.Language = FormatStyle::LK_Cpp; 11724 CHECK_PARSE("Language: Cpp\n" 11725 "IndentWidth: 12", 11726 IndentWidth, 12u); 11727 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 11728 "IndentWidth: 34", 11729 &Style), 11730 ParseError::Unsuitable); 11731 EXPECT_EQ(12u, Style.IndentWidth); 11732 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 11733 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 11734 11735 Style.Language = FormatStyle::LK_JavaScript; 11736 CHECK_PARSE("Language: JavaScript\n" 11737 "IndentWidth: 12", 11738 IndentWidth, 12u); 11739 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 11740 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 11741 "IndentWidth: 34", 11742 &Style), 11743 ParseError::Unsuitable); 11744 EXPECT_EQ(23u, Style.IndentWidth); 11745 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 11746 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 11747 11748 CHECK_PARSE("BasedOnStyle: LLVM\n" 11749 "IndentWidth: 67", 11750 IndentWidth, 67u); 11751 11752 CHECK_PARSE("---\n" 11753 "Language: JavaScript\n" 11754 "IndentWidth: 12\n" 11755 "---\n" 11756 "Language: Cpp\n" 11757 "IndentWidth: 34\n" 11758 "...\n", 11759 IndentWidth, 12u); 11760 11761 Style.Language = FormatStyle::LK_Cpp; 11762 CHECK_PARSE("---\n" 11763 "Language: JavaScript\n" 11764 "IndentWidth: 12\n" 11765 "---\n" 11766 "Language: Cpp\n" 11767 "IndentWidth: 34\n" 11768 "...\n", 11769 IndentWidth, 34u); 11770 CHECK_PARSE("---\n" 11771 "IndentWidth: 78\n" 11772 "---\n" 11773 "Language: JavaScript\n" 11774 "IndentWidth: 56\n" 11775 "...\n", 11776 IndentWidth, 78u); 11777 11778 Style.ColumnLimit = 123; 11779 Style.IndentWidth = 234; 11780 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 11781 Style.TabWidth = 345; 11782 EXPECT_FALSE(parseConfiguration("---\n" 11783 "IndentWidth: 456\n" 11784 "BreakBeforeBraces: Allman\n" 11785 "---\n" 11786 "Language: JavaScript\n" 11787 "IndentWidth: 111\n" 11788 "TabWidth: 111\n" 11789 "---\n" 11790 "Language: Cpp\n" 11791 "BreakBeforeBraces: Stroustrup\n" 11792 "TabWidth: 789\n" 11793 "...\n", 11794 &Style)); 11795 EXPECT_EQ(123u, Style.ColumnLimit); 11796 EXPECT_EQ(456u, Style.IndentWidth); 11797 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 11798 EXPECT_EQ(789u, Style.TabWidth); 11799 11800 EXPECT_EQ(parseConfiguration("---\n" 11801 "Language: JavaScript\n" 11802 "IndentWidth: 56\n" 11803 "---\n" 11804 "IndentWidth: 78\n" 11805 "...\n", 11806 &Style), 11807 ParseError::Error); 11808 EXPECT_EQ(parseConfiguration("---\n" 11809 "Language: JavaScript\n" 11810 "IndentWidth: 56\n" 11811 "---\n" 11812 "Language: JavaScript\n" 11813 "IndentWidth: 78\n" 11814 "...\n", 11815 &Style), 11816 ParseError::Error); 11817 11818 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 11819 } 11820 11821 #undef CHECK_PARSE 11822 11823 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 11824 FormatStyle Style = {}; 11825 Style.Language = FormatStyle::LK_JavaScript; 11826 Style.BreakBeforeTernaryOperators = true; 11827 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 11828 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 11829 11830 Style.BreakBeforeTernaryOperators = true; 11831 EXPECT_EQ(0, parseConfiguration("---\n" 11832 "BasedOnStyle: Google\n" 11833 "---\n" 11834 "Language: JavaScript\n" 11835 "IndentWidth: 76\n" 11836 "...\n", 11837 &Style) 11838 .value()); 11839 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 11840 EXPECT_EQ(76u, Style.IndentWidth); 11841 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 11842 } 11843 11844 TEST_F(FormatTest, ConfigurationRoundTripTest) { 11845 FormatStyle Style = getLLVMStyle(); 11846 std::string YAML = configurationAsText(Style); 11847 FormatStyle ParsedStyle = {}; 11848 ParsedStyle.Language = FormatStyle::LK_Cpp; 11849 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 11850 EXPECT_EQ(Style, ParsedStyle); 11851 } 11852 11853 TEST_F(FormatTest, WorksFor8bitEncodings) { 11854 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 11855 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 11856 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 11857 "\"\xef\xee\xf0\xf3...\"", 11858 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 11859 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 11860 "\xef\xee\xf0\xf3...\"", 11861 getLLVMStyleWithColumns(12))); 11862 } 11863 11864 TEST_F(FormatTest, HandlesUTF8BOM) { 11865 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 11866 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 11867 format("\xef\xbb\xbf#include <iostream>")); 11868 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 11869 format("\xef\xbb\xbf\n#include <iostream>")); 11870 } 11871 11872 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 11873 #if !defined(_MSC_VER) 11874 11875 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 11876 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 11877 getLLVMStyleWithColumns(35)); 11878 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 11879 getLLVMStyleWithColumns(31)); 11880 verifyFormat("// Однажды в студёную зимнюю пору...", 11881 getLLVMStyleWithColumns(36)); 11882 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 11883 verifyFormat("/* Однажды в студёную зимнюю пору... */", 11884 getLLVMStyleWithColumns(39)); 11885 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 11886 getLLVMStyleWithColumns(35)); 11887 } 11888 11889 TEST_F(FormatTest, SplitsUTF8Strings) { 11890 // Non-printable characters' width is currently considered to be the length in 11891 // bytes in UTF8. The characters can be displayed in very different manner 11892 // (zero-width, single width with a substitution glyph, expanded to their code 11893 // (e.g. "<8d>"), so there's no single correct way to handle them. 11894 EXPECT_EQ("\"aaaaÄ\"\n" 11895 "\"\xc2\x8d\";", 11896 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 11897 EXPECT_EQ("\"aaaaaaaÄ\"\n" 11898 "\"\xc2\x8d\";", 11899 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 11900 EXPECT_EQ("\"Однажды, в \"\n" 11901 "\"студёную \"\n" 11902 "\"зимнюю \"\n" 11903 "\"пору,\"", 11904 format("\"Однажды, в студёную зимнюю пору,\"", 11905 getLLVMStyleWithColumns(13))); 11906 EXPECT_EQ( 11907 "\"一 二 三 \"\n" 11908 "\"四 五六 \"\n" 11909 "\"七 八 九 \"\n" 11910 "\"十\"", 11911 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 11912 EXPECT_EQ("\"一\t\"\n" 11913 "\"二 \t\"\n" 11914 "\"三 四 \"\n" 11915 "\"五\t\"\n" 11916 "\"六 \t\"\n" 11917 "\"七 \"\n" 11918 "\"八九十\tqq\"", 11919 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 11920 getLLVMStyleWithColumns(11))); 11921 11922 // UTF8 character in an escape sequence. 11923 EXPECT_EQ("\"aaaaaa\"\n" 11924 "\"\\\xC2\x8D\"", 11925 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 11926 } 11927 11928 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 11929 EXPECT_EQ("const char *sssss =\n" 11930 " \"一二三四五六七八\\\n" 11931 " 九 十\";", 11932 format("const char *sssss = \"一二三四五六七八\\\n" 11933 " 九 十\";", 11934 getLLVMStyleWithColumns(30))); 11935 } 11936 11937 TEST_F(FormatTest, SplitsUTF8LineComments) { 11938 EXPECT_EQ("// aaaaÄ\xc2\x8d", 11939 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 11940 EXPECT_EQ("// Я из лесу\n" 11941 "// вышел; был\n" 11942 "// сильный\n" 11943 "// мороз.", 11944 format("// Я из лесу вышел; был сильный мороз.", 11945 getLLVMStyleWithColumns(13))); 11946 EXPECT_EQ("// 一二三\n" 11947 "// 四五六七\n" 11948 "// 八 九\n" 11949 "// 十", 11950 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 11951 } 11952 11953 TEST_F(FormatTest, SplitsUTF8BlockComments) { 11954 EXPECT_EQ("/* Гляжу,\n" 11955 " * поднимается\n" 11956 " * медленно в\n" 11957 " * гору\n" 11958 " * Лошадка,\n" 11959 " * везущая\n" 11960 " * хворосту\n" 11961 " * воз. */", 11962 format("/* Гляжу, поднимается медленно в гору\n" 11963 " * Лошадка, везущая хворосту воз. */", 11964 getLLVMStyleWithColumns(13))); 11965 EXPECT_EQ( 11966 "/* 一二三\n" 11967 " * 四五六七\n" 11968 " * 八 九\n" 11969 " * 十 */", 11970 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 11971 EXPECT_EQ("/* �������� ��������\n" 11972 " * ��������\n" 11973 " * ������-�� */", 11974 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 11975 } 11976 11977 #endif // _MSC_VER 11978 11979 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 11980 FormatStyle Style = getLLVMStyle(); 11981 11982 Style.ConstructorInitializerIndentWidth = 4; 11983 verifyFormat( 11984 "SomeClass::Constructor()\n" 11985 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 11986 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 11987 Style); 11988 11989 Style.ConstructorInitializerIndentWidth = 2; 11990 verifyFormat( 11991 "SomeClass::Constructor()\n" 11992 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 11993 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 11994 Style); 11995 11996 Style.ConstructorInitializerIndentWidth = 0; 11997 verifyFormat( 11998 "SomeClass::Constructor()\n" 11999 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12000 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12001 Style); 12002 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 12003 verifyFormat( 12004 "SomeLongTemplateVariableName<\n" 12005 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 12006 Style); 12007 verifyFormat( 12008 "bool smaller = 1 < bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 12009 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 12010 Style); 12011 12012 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 12013 verifyFormat( 12014 "SomeClass::Constructor() :\n" 12015 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 12016 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 12017 Style); 12018 } 12019 12020 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 12021 FormatStyle Style = getLLVMStyle(); 12022 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 12023 Style.ConstructorInitializerIndentWidth = 4; 12024 verifyFormat("SomeClass::Constructor()\n" 12025 " : a(a)\n" 12026 " , b(b)\n" 12027 " , c(c) {}", 12028 Style); 12029 verifyFormat("SomeClass::Constructor()\n" 12030 " : a(a) {}", 12031 Style); 12032 12033 Style.ColumnLimit = 0; 12034 verifyFormat("SomeClass::Constructor()\n" 12035 " : a(a) {}", 12036 Style); 12037 verifyFormat("SomeClass::Constructor() noexcept\n" 12038 " : a(a) {}", 12039 Style); 12040 verifyFormat("SomeClass::Constructor()\n" 12041 " : a(a)\n" 12042 " , b(b)\n" 12043 " , c(c) {}", 12044 Style); 12045 verifyFormat("SomeClass::Constructor()\n" 12046 " : a(a) {\n" 12047 " foo();\n" 12048 " bar();\n" 12049 "}", 12050 Style); 12051 12052 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 12053 verifyFormat("SomeClass::Constructor()\n" 12054 " : a(a)\n" 12055 " , b(b)\n" 12056 " , c(c) {\n}", 12057 Style); 12058 verifyFormat("SomeClass::Constructor()\n" 12059 " : a(a) {\n}", 12060 Style); 12061 12062 Style.ColumnLimit = 80; 12063 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 12064 Style.ConstructorInitializerIndentWidth = 2; 12065 verifyFormat("SomeClass::Constructor()\n" 12066 " : a(a)\n" 12067 " , b(b)\n" 12068 " , c(c) {}", 12069 Style); 12070 12071 Style.ConstructorInitializerIndentWidth = 0; 12072 verifyFormat("SomeClass::Constructor()\n" 12073 ": a(a)\n" 12074 ", b(b)\n" 12075 ", c(c) {}", 12076 Style); 12077 12078 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 12079 Style.ConstructorInitializerIndentWidth = 4; 12080 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 12081 verifyFormat( 12082 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 12083 Style); 12084 verifyFormat( 12085 "SomeClass::Constructor()\n" 12086 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 12087 Style); 12088 Style.ConstructorInitializerIndentWidth = 4; 12089 Style.ColumnLimit = 60; 12090 verifyFormat("SomeClass::Constructor()\n" 12091 " : aaaaaaaa(aaaaaaaa)\n" 12092 " , aaaaaaaa(aaaaaaaa)\n" 12093 " , aaaaaaaa(aaaaaaaa) {}", 12094 Style); 12095 } 12096 12097 TEST_F(FormatTest, Destructors) { 12098 verifyFormat("void F(int &i) { i.~int(); }"); 12099 verifyFormat("void F(int &i) { i->~int(); }"); 12100 } 12101 12102 TEST_F(FormatTest, FormatsWithWebKitStyle) { 12103 FormatStyle Style = getWebKitStyle(); 12104 12105 // Don't indent in outer namespaces. 12106 verifyFormat("namespace outer {\n" 12107 "int i;\n" 12108 "namespace inner {\n" 12109 " int i;\n" 12110 "} // namespace inner\n" 12111 "} // namespace outer\n" 12112 "namespace other_outer {\n" 12113 "int i;\n" 12114 "}", 12115 Style); 12116 12117 // Don't indent case labels. 12118 verifyFormat("switch (variable) {\n" 12119 "case 1:\n" 12120 "case 2:\n" 12121 " doSomething();\n" 12122 " break;\n" 12123 "default:\n" 12124 " ++variable;\n" 12125 "}", 12126 Style); 12127 12128 // Wrap before binary operators. 12129 EXPECT_EQ("void f()\n" 12130 "{\n" 12131 " if (aaaaaaaaaaaaaaaa\n" 12132 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 12133 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 12134 " return;\n" 12135 "}", 12136 format("void f() {\n" 12137 "if (aaaaaaaaaaaaaaaa\n" 12138 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 12139 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 12140 "return;\n" 12141 "}", 12142 Style)); 12143 12144 // Allow functions on a single line. 12145 verifyFormat("void f() { return; }", Style); 12146 12147 // Constructor initializers are formatted one per line with the "," on the 12148 // new line. 12149 verifyFormat("Constructor()\n" 12150 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 12151 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 12152 " aaaaaaaaaaaaaa)\n" 12153 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 12154 "{\n" 12155 "}", 12156 Style); 12157 verifyFormat("SomeClass::Constructor()\n" 12158 " : a(a)\n" 12159 "{\n" 12160 "}", 12161 Style); 12162 EXPECT_EQ("SomeClass::Constructor()\n" 12163 " : a(a)\n" 12164 "{\n" 12165 "}", 12166 format("SomeClass::Constructor():a(a){}", Style)); 12167 verifyFormat("SomeClass::Constructor()\n" 12168 " : a(a)\n" 12169 " , b(b)\n" 12170 " , c(c)\n" 12171 "{\n" 12172 "}", 12173 Style); 12174 verifyFormat("SomeClass::Constructor()\n" 12175 " : a(a)\n" 12176 "{\n" 12177 " foo();\n" 12178 " bar();\n" 12179 "}", 12180 Style); 12181 12182 // Access specifiers should be aligned left. 12183 verifyFormat("class C {\n" 12184 "public:\n" 12185 " int i;\n" 12186 "};", 12187 Style); 12188 12189 // Do not align comments. 12190 verifyFormat("int a; // Do not\n" 12191 "double b; // align comments.", 12192 Style); 12193 12194 // Do not align operands. 12195 EXPECT_EQ("ASSERT(aaaa\n" 12196 " || bbbb);", 12197 format("ASSERT ( aaaa\n||bbbb);", Style)); 12198 12199 // Accept input's line breaks. 12200 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 12201 " || bbbbbbbbbbbbbbb) {\n" 12202 " i++;\n" 12203 "}", 12204 format("if (aaaaaaaaaaaaaaa\n" 12205 "|| bbbbbbbbbbbbbbb) { i++; }", 12206 Style)); 12207 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 12208 " i++;\n" 12209 "}", 12210 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 12211 12212 // Don't automatically break all macro definitions (llvm.org/PR17842). 12213 verifyFormat("#define aNumber 10", Style); 12214 // However, generally keep the line breaks that the user authored. 12215 EXPECT_EQ("#define aNumber \\\n" 12216 " 10", 12217 format("#define aNumber \\\n" 12218 " 10", 12219 Style)); 12220 12221 // Keep empty and one-element array literals on a single line. 12222 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 12223 " copyItems:YES];", 12224 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 12225 "copyItems:YES];", 12226 Style)); 12227 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 12228 " copyItems:YES];", 12229 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 12230 " copyItems:YES];", 12231 Style)); 12232 // FIXME: This does not seem right, there should be more indentation before 12233 // the array literal's entries. Nested blocks have the same problem. 12234 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 12235 " @\"a\",\n" 12236 " @\"a\"\n" 12237 "]\n" 12238 " copyItems:YES];", 12239 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 12240 " @\"a\",\n" 12241 " @\"a\"\n" 12242 " ]\n" 12243 " copyItems:YES];", 12244 Style)); 12245 EXPECT_EQ( 12246 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 12247 " copyItems:YES];", 12248 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 12249 " copyItems:YES];", 12250 Style)); 12251 12252 verifyFormat("[self.a b:c c:d];", Style); 12253 EXPECT_EQ("[self.a b:c\n" 12254 " c:d];", 12255 format("[self.a b:c\n" 12256 "c:d];", 12257 Style)); 12258 } 12259 12260 TEST_F(FormatTest, FormatsLambdas) { 12261 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 12262 verifyFormat( 12263 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 12264 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 12265 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 12266 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 12267 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 12268 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 12269 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 12270 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 12271 verifyFormat("int x = f(*+[] {});"); 12272 verifyFormat("void f() {\n" 12273 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 12274 "}\n"); 12275 verifyFormat("void f() {\n" 12276 " other(x.begin(), //\n" 12277 " x.end(), //\n" 12278 " [&](int, int) { return 1; });\n" 12279 "}\n"); 12280 verifyFormat("void f() {\n" 12281 " other.other.other.other.other(\n" 12282 " x.begin(), x.end(),\n" 12283 " [something, rather](int, int, int, int, int, int, int) { return 1; });\n" 12284 "}\n"); 12285 verifyFormat("void f() {\n" 12286 " other.other.other.other.other(\n" 12287 " x.begin(), x.end(),\n" 12288 " [something, rather](int, int, int, int, int, int, int) {\n" 12289 " //\n" 12290 " });\n" 12291 "}\n"); 12292 verifyFormat("SomeFunction([]() { // A cool function...\n" 12293 " return 43;\n" 12294 "});"); 12295 EXPECT_EQ("SomeFunction([]() {\n" 12296 "#define A a\n" 12297 " return 43;\n" 12298 "});", 12299 format("SomeFunction([](){\n" 12300 "#define A a\n" 12301 "return 43;\n" 12302 "});")); 12303 verifyFormat("void f() {\n" 12304 " SomeFunction([](decltype(x), A *a) {});\n" 12305 "}"); 12306 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 12307 " [](const aaaaaaaaaa &a) { return a; });"); 12308 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 12309 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 12310 "});"); 12311 verifyFormat("Constructor()\n" 12312 " : Field([] { // comment\n" 12313 " int i;\n" 12314 " }) {}"); 12315 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 12316 " return some_parameter.size();\n" 12317 "};"); 12318 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 12319 " [](const string &s) { return s; };"); 12320 verifyFormat("int i = aaaaaa ? 1 //\n" 12321 " : [] {\n" 12322 " return 2; //\n" 12323 " }();"); 12324 verifyFormat("llvm::errs() << \"number of twos is \"\n" 12325 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 12326 " return x == 2; // force break\n" 12327 " });"); 12328 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 12329 " [=](int iiiiiiiiiiii) {\n" 12330 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 12331 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 12332 " });", 12333 getLLVMStyleWithColumns(60)); 12334 verifyFormat("SomeFunction({[&] {\n" 12335 " // comment\n" 12336 " },\n" 12337 " [&] {\n" 12338 " // comment\n" 12339 " }});"); 12340 verifyFormat("SomeFunction({[&] {\n" 12341 " // comment\n" 12342 "}});"); 12343 verifyFormat("virtual aaaaaaaaaaaaaaaa(\n" 12344 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 12345 " aaaaa aaaaaaaaa);"); 12346 12347 // Lambdas with return types. 12348 verifyFormat("int c = []() -> int { return 2; }();\n"); 12349 verifyFormat("int c = []() -> int * { return 2; }();\n"); 12350 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 12351 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 12352 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 12353 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 12354 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 12355 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 12356 verifyFormat("[a, a]() -> a<1> {};"); 12357 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 12358 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 12359 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 12360 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 12361 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 12362 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 12363 verifyFormat("[]() -> foo<!5> { return {}; };"); 12364 verifyFormat("[]() -> foo<~5> { return {}; };"); 12365 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 12366 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 12367 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 12368 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 12369 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 12370 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 12371 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 12372 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 12373 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 12374 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 12375 verifyFormat("namespace bar {\n" 12376 "// broken:\n" 12377 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 12378 "} // namespace bar"); 12379 verifyFormat("namespace bar {\n" 12380 "// broken:\n" 12381 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 12382 "} // namespace bar"); 12383 verifyFormat("namespace bar {\n" 12384 "// broken:\n" 12385 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 12386 "} // namespace bar"); 12387 verifyFormat("namespace bar {\n" 12388 "// broken:\n" 12389 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 12390 "} // namespace bar"); 12391 verifyFormat("namespace bar {\n" 12392 "// broken:\n" 12393 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 12394 "} // namespace bar"); 12395 verifyFormat("namespace bar {\n" 12396 "// broken:\n" 12397 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 12398 "} // namespace bar"); 12399 verifyFormat("namespace bar {\n" 12400 "// broken:\n" 12401 "auto foo{[]() -> foo<!5> { return {}; }};\n" 12402 "} // namespace bar"); 12403 verifyFormat("namespace bar {\n" 12404 "// broken:\n" 12405 "auto foo{[]() -> foo<~5> { return {}; }};\n" 12406 "} // namespace bar"); 12407 verifyFormat("namespace bar {\n" 12408 "// broken:\n" 12409 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 12410 "} // namespace bar"); 12411 verifyFormat("namespace bar {\n" 12412 "// broken:\n" 12413 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 12414 "} // namespace bar"); 12415 verifyFormat("namespace bar {\n" 12416 "// broken:\n" 12417 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 12418 "} // namespace bar"); 12419 verifyFormat("namespace bar {\n" 12420 "// broken:\n" 12421 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 12422 "} // namespace bar"); 12423 verifyFormat("namespace bar {\n" 12424 "// broken:\n" 12425 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 12426 "} // namespace bar"); 12427 verifyFormat("namespace bar {\n" 12428 "// broken:\n" 12429 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 12430 "} // namespace bar"); 12431 verifyFormat("namespace bar {\n" 12432 "// broken:\n" 12433 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 12434 "} // namespace bar"); 12435 verifyFormat("namespace bar {\n" 12436 "// broken:\n" 12437 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 12438 "} // namespace bar"); 12439 verifyFormat("namespace bar {\n" 12440 "// broken:\n" 12441 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 12442 "} // namespace bar"); 12443 verifyFormat("namespace bar {\n" 12444 "// broken:\n" 12445 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 12446 "} // namespace bar"); 12447 verifyFormat("[]() -> a<1> {};"); 12448 verifyFormat("[]() -> a<1> { ; };"); 12449 verifyFormat("[]() -> a<1> { ; }();"); 12450 verifyFormat("[a, a]() -> a<true> {};"); 12451 verifyFormat("[]() -> a<true> {};"); 12452 verifyFormat("[]() -> a<true> { ; };"); 12453 verifyFormat("[]() -> a<true> { ; }();"); 12454 verifyFormat("[a, a]() -> a<false> {};"); 12455 verifyFormat("[]() -> a<false> {};"); 12456 verifyFormat("[]() -> a<false> { ; };"); 12457 verifyFormat("[]() -> a<false> { ; }();"); 12458 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 12459 verifyFormat("namespace bar {\n" 12460 "auto foo{[]() -> foo<false> { ; }};\n" 12461 "} // namespace bar"); 12462 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 12463 " int j) -> int {\n" 12464 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 12465 "};"); 12466 verifyFormat( 12467 "aaaaaaaaaaaaaaaaaaaaaa(\n" 12468 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 12469 " return aaaaaaaaaaaaaaaaa;\n" 12470 " });", 12471 getLLVMStyleWithColumns(70)); 12472 verifyFormat("[]() //\n" 12473 " -> int {\n" 12474 " return 1; //\n" 12475 "};"); 12476 12477 // Multiple lambdas in the same parentheses change indentation rules. These 12478 // lambdas are forced to start on new lines. 12479 verifyFormat("SomeFunction(\n" 12480 " []() {\n" 12481 " //\n" 12482 " },\n" 12483 " []() {\n" 12484 " //\n" 12485 " });"); 12486 12487 // A lambda passed as arg0 is always pushed to the next line. 12488 verifyFormat("SomeFunction(\n" 12489 " [this] {\n" 12490 " //\n" 12491 " },\n" 12492 " 1);\n"); 12493 12494 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like the arg0 12495 // case above. 12496 auto Style = getGoogleStyle(); 12497 Style.BinPackArguments = false; 12498 verifyFormat("SomeFunction(\n" 12499 " a,\n" 12500 " [this] {\n" 12501 " //\n" 12502 " },\n" 12503 " b);\n", 12504 Style); 12505 verifyFormat("SomeFunction(\n" 12506 " a,\n" 12507 " [this] {\n" 12508 " //\n" 12509 " },\n" 12510 " b);\n"); 12511 12512 // A lambda with a very long line forces arg0 to be pushed out irrespective of 12513 // the BinPackArguments value (as long as the code is wide enough). 12514 verifyFormat("something->SomeFunction(\n" 12515 " a,\n" 12516 " [this] {\n" 12517 " D0000000000000000000000000000000000000000000000000000000000001();\n" 12518 " },\n" 12519 " b);\n"); 12520 12521 // A multi-line lambda is pulled up as long as the introducer fits on the previous 12522 // line and there are no further args. 12523 verifyFormat("function(1, [this, that] {\n" 12524 " //\n" 12525 "});\n"); 12526 verifyFormat("function([this, that] {\n" 12527 " //\n" 12528 "});\n"); 12529 // FIXME: this format is not ideal and we should consider forcing the first arg 12530 // onto its own line. 12531 verifyFormat("function(a, b, c, //\n" 12532 " d, [this, that] {\n" 12533 " //\n" 12534 " });\n"); 12535 12536 // Multiple lambdas are treated correctly even when there is a short arg0. 12537 verifyFormat("SomeFunction(\n" 12538 " 1,\n" 12539 " [this] {\n" 12540 " //\n" 12541 " },\n" 12542 " [this] {\n" 12543 " //\n" 12544 " },\n" 12545 " 1);\n"); 12546 12547 // More complex introducers. 12548 verifyFormat("return [i, args...] {};"); 12549 12550 // Not lambdas. 12551 verifyFormat("constexpr char hello[]{\"hello\"};"); 12552 verifyFormat("double &operator[](int i) { return 0; }\n" 12553 "int i;"); 12554 verifyFormat("std::unique_ptr<int[]> foo() {}"); 12555 verifyFormat("int i = a[a][a]->f();"); 12556 verifyFormat("int i = (*b)[a]->f();"); 12557 12558 // Other corner cases. 12559 verifyFormat("void f() {\n" 12560 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 12561 " );\n" 12562 "}"); 12563 12564 // Lambdas created through weird macros. 12565 verifyFormat("void f() {\n" 12566 " MACRO((const AA &a) { return 1; });\n" 12567 " MACRO((AA &a) { return 1; });\n" 12568 "}"); 12569 12570 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 12571 " doo_dah();\n" 12572 " doo_dah();\n" 12573 " })) {\n" 12574 "}"); 12575 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 12576 " doo_dah();\n" 12577 " doo_dah();\n" 12578 " })) {\n" 12579 "}"); 12580 verifyFormat("auto lambda = []() {\n" 12581 " int a = 2\n" 12582 "#if A\n" 12583 " + 2\n" 12584 "#endif\n" 12585 " ;\n" 12586 "};"); 12587 12588 // Lambdas with complex multiline introducers. 12589 verifyFormat( 12590 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 12591 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 12592 " -> ::std::unordered_set<\n" 12593 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 12594 " //\n" 12595 " });"); 12596 12597 FormatStyle DoNotMerge = getLLVMStyle(); 12598 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 12599 verifyFormat("auto c = []() {\n" 12600 " return b;\n" 12601 "};", 12602 "auto c = []() { return b; };", DoNotMerge); 12603 verifyFormat("auto c = []() {\n" 12604 "};", 12605 " auto c = []() {};", DoNotMerge); 12606 12607 FormatStyle MergeEmptyOnly = getLLVMStyle(); 12608 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 12609 verifyFormat("auto c = []() {\n" 12610 " return b;\n" 12611 "};", 12612 "auto c = []() {\n" 12613 " return b;\n" 12614 " };", 12615 MergeEmptyOnly); 12616 verifyFormat("auto c = []() {};", 12617 "auto c = []() {\n" 12618 "};", 12619 MergeEmptyOnly); 12620 12621 FormatStyle MergeInline = getLLVMStyle(); 12622 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 12623 verifyFormat("auto c = []() {\n" 12624 " return b;\n" 12625 "};", 12626 "auto c = []() { return b; };", MergeInline); 12627 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 12628 MergeInline); 12629 verifyFormat("function([]() { return b; }, a)", 12630 "function([]() { return b; }, a)", MergeInline); 12631 verifyFormat("function(a, []() { return b; })", 12632 "function(a, []() { return b; })", MergeInline); 12633 } 12634 12635 TEST_F(FormatTest, EmptyLinesInLambdas) { 12636 verifyFormat("auto lambda = []() {\n" 12637 " x(); //\n" 12638 "};", 12639 "auto lambda = []() {\n" 12640 "\n" 12641 " x(); //\n" 12642 "\n" 12643 "};"); 12644 } 12645 12646 TEST_F(FormatTest, FormatsBlocks) { 12647 FormatStyle ShortBlocks = getLLVMStyle(); 12648 ShortBlocks.AllowShortBlocksOnASingleLine = true; 12649 verifyFormat("int (^Block)(int, int);", ShortBlocks); 12650 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 12651 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 12652 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 12653 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 12654 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 12655 12656 verifyFormat("foo(^{ bar(); });", ShortBlocks); 12657 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 12658 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 12659 12660 verifyFormat("[operation setCompletionBlock:^{\n" 12661 " [self onOperationDone];\n" 12662 "}];"); 12663 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 12664 " [self onOperationDone];\n" 12665 "}]};"); 12666 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 12667 " f();\n" 12668 "}];"); 12669 verifyFormat("int a = [operation block:^int(int *i) {\n" 12670 " return 1;\n" 12671 "}];"); 12672 verifyFormat("[myObject doSomethingWith:arg1\n" 12673 " aaa:^int(int *a) {\n" 12674 " return 1;\n" 12675 " }\n" 12676 " bbb:f(a * bbbbbbbb)];"); 12677 12678 verifyFormat("[operation setCompletionBlock:^{\n" 12679 " [self.delegate newDataAvailable];\n" 12680 "}];", 12681 getLLVMStyleWithColumns(60)); 12682 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 12683 " NSString *path = [self sessionFilePath];\n" 12684 " if (path) {\n" 12685 " // ...\n" 12686 " }\n" 12687 "});"); 12688 verifyFormat("[[SessionService sharedService]\n" 12689 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 12690 " if (window) {\n" 12691 " [self windowDidLoad:window];\n" 12692 " } else {\n" 12693 " [self errorLoadingWindow];\n" 12694 " }\n" 12695 " }];"); 12696 verifyFormat("void (^largeBlock)(void) = ^{\n" 12697 " // ...\n" 12698 "};\n", 12699 getLLVMStyleWithColumns(40)); 12700 verifyFormat("[[SessionService sharedService]\n" 12701 " loadWindowWithCompletionBlock: //\n" 12702 " ^(SessionWindow *window) {\n" 12703 " if (window) {\n" 12704 " [self windowDidLoad:window];\n" 12705 " } else {\n" 12706 " [self errorLoadingWindow];\n" 12707 " }\n" 12708 " }];", 12709 getLLVMStyleWithColumns(60)); 12710 verifyFormat("[myObject doSomethingWith:arg1\n" 12711 " firstBlock:^(Foo *a) {\n" 12712 " // ...\n" 12713 " int i;\n" 12714 " }\n" 12715 " secondBlock:^(Bar *b) {\n" 12716 " // ...\n" 12717 " int i;\n" 12718 " }\n" 12719 " thirdBlock:^Foo(Bar *b) {\n" 12720 " // ...\n" 12721 " int i;\n" 12722 " }];"); 12723 verifyFormat("[myObject doSomethingWith:arg1\n" 12724 " firstBlock:-1\n" 12725 " secondBlock:^(Bar *b) {\n" 12726 " // ...\n" 12727 " int i;\n" 12728 " }];"); 12729 12730 verifyFormat("f(^{\n" 12731 " @autoreleasepool {\n" 12732 " if (a) {\n" 12733 " g();\n" 12734 " }\n" 12735 " }\n" 12736 "});"); 12737 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 12738 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 12739 "};"); 12740 12741 FormatStyle FourIndent = getLLVMStyle(); 12742 FourIndent.ObjCBlockIndentWidth = 4; 12743 verifyFormat("[operation setCompletionBlock:^{\n" 12744 " [self onOperationDone];\n" 12745 "}];", 12746 FourIndent); 12747 } 12748 12749 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 12750 FormatStyle ZeroColumn = getLLVMStyle(); 12751 ZeroColumn.ColumnLimit = 0; 12752 12753 verifyFormat("[[SessionService sharedService] " 12754 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 12755 " if (window) {\n" 12756 " [self windowDidLoad:window];\n" 12757 " } else {\n" 12758 " [self errorLoadingWindow];\n" 12759 " }\n" 12760 "}];", 12761 ZeroColumn); 12762 EXPECT_EQ("[[SessionService sharedService]\n" 12763 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 12764 " if (window) {\n" 12765 " [self windowDidLoad:window];\n" 12766 " } else {\n" 12767 " [self errorLoadingWindow];\n" 12768 " }\n" 12769 " }];", 12770 format("[[SessionService sharedService]\n" 12771 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 12772 " if (window) {\n" 12773 " [self windowDidLoad:window];\n" 12774 " } else {\n" 12775 " [self errorLoadingWindow];\n" 12776 " }\n" 12777 "}];", 12778 ZeroColumn)); 12779 verifyFormat("[myObject doSomethingWith:arg1\n" 12780 " firstBlock:^(Foo *a) {\n" 12781 " // ...\n" 12782 " int i;\n" 12783 " }\n" 12784 " secondBlock:^(Bar *b) {\n" 12785 " // ...\n" 12786 " int i;\n" 12787 " }\n" 12788 " thirdBlock:^Foo(Bar *b) {\n" 12789 " // ...\n" 12790 " int i;\n" 12791 " }];", 12792 ZeroColumn); 12793 verifyFormat("f(^{\n" 12794 " @autoreleasepool {\n" 12795 " if (a) {\n" 12796 " g();\n" 12797 " }\n" 12798 " }\n" 12799 "});", 12800 ZeroColumn); 12801 verifyFormat("void (^largeBlock)(void) = ^{\n" 12802 " // ...\n" 12803 "};", 12804 ZeroColumn); 12805 12806 ZeroColumn.AllowShortBlocksOnASingleLine = true; 12807 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 12808 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 12809 ZeroColumn.AllowShortBlocksOnASingleLine = false; 12810 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 12811 " int i;\n" 12812 "};", 12813 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 12814 } 12815 12816 TEST_F(FormatTest, SupportsCRLF) { 12817 EXPECT_EQ("int a;\r\n" 12818 "int b;\r\n" 12819 "int c;\r\n", 12820 format("int a;\r\n" 12821 " int b;\r\n" 12822 " int c;\r\n", 12823 getLLVMStyle())); 12824 EXPECT_EQ("int a;\r\n" 12825 "int b;\r\n" 12826 "int c;\r\n", 12827 format("int a;\r\n" 12828 " int b;\n" 12829 " int c;\r\n", 12830 getLLVMStyle())); 12831 EXPECT_EQ("int a;\n" 12832 "int b;\n" 12833 "int c;\n", 12834 format("int a;\r\n" 12835 " int b;\n" 12836 " int c;\n", 12837 getLLVMStyle())); 12838 EXPECT_EQ("\"aaaaaaa \"\r\n" 12839 "\"bbbbbbb\";\r\n", 12840 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 12841 EXPECT_EQ("#define A \\\r\n" 12842 " b; \\\r\n" 12843 " c; \\\r\n" 12844 " d;\r\n", 12845 format("#define A \\\r\n" 12846 " b; \\\r\n" 12847 " c; d; \r\n", 12848 getGoogleStyle())); 12849 12850 EXPECT_EQ("/*\r\n" 12851 "multi line block comments\r\n" 12852 "should not introduce\r\n" 12853 "an extra carriage return\r\n" 12854 "*/\r\n", 12855 format("/*\r\n" 12856 "multi line block comments\r\n" 12857 "should not introduce\r\n" 12858 "an extra carriage return\r\n" 12859 "*/\r\n")); 12860 EXPECT_EQ("/*\r\n" 12861 "\r\n" 12862 "*/", 12863 format("/*\r\n" 12864 " \r\r\r\n" 12865 "*/")); 12866 } 12867 12868 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 12869 verifyFormat("MY_CLASS(C) {\n" 12870 " int i;\n" 12871 " int j;\n" 12872 "};"); 12873 } 12874 12875 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 12876 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 12877 TwoIndent.ContinuationIndentWidth = 2; 12878 12879 EXPECT_EQ("int i =\n" 12880 " longFunction(\n" 12881 " arg);", 12882 format("int i = longFunction(arg);", TwoIndent)); 12883 12884 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 12885 SixIndent.ContinuationIndentWidth = 6; 12886 12887 EXPECT_EQ("int i =\n" 12888 " longFunction(\n" 12889 " arg);", 12890 format("int i = longFunction(arg);", SixIndent)); 12891 } 12892 12893 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 12894 FormatStyle Style = getLLVMStyle(); 12895 verifyFormat("int Foo::getter(\n" 12896 " //\n" 12897 ") const {\n" 12898 " return foo;\n" 12899 "}", 12900 Style); 12901 verifyFormat("void Foo::setter(\n" 12902 " //\n" 12903 ") {\n" 12904 " foo = 1;\n" 12905 "}", 12906 Style); 12907 } 12908 12909 TEST_F(FormatTest, SpacesInAngles) { 12910 FormatStyle Spaces = getLLVMStyle(); 12911 Spaces.SpacesInAngles = true; 12912 12913 verifyFormat("static_cast< int >(arg);", Spaces); 12914 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 12915 verifyFormat("f< int, float >();", Spaces); 12916 verifyFormat("template <> g() {}", Spaces); 12917 verifyFormat("template < std::vector< int > > f() {}", Spaces); 12918 verifyFormat("std::function< void(int, int) > fct;", Spaces); 12919 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 12920 Spaces); 12921 12922 Spaces.Standard = FormatStyle::LS_Cpp03; 12923 Spaces.SpacesInAngles = true; 12924 verifyFormat("A< A< int > >();", Spaces); 12925 12926 Spaces.SpacesInAngles = false; 12927 verifyFormat("A<A<int> >();", Spaces); 12928 12929 Spaces.Standard = FormatStyle::LS_Cpp11; 12930 Spaces.SpacesInAngles = true; 12931 verifyFormat("A< A< int > >();", Spaces); 12932 12933 Spaces.SpacesInAngles = false; 12934 verifyFormat("A<A<int>>();", Spaces); 12935 } 12936 12937 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 12938 FormatStyle Style = getLLVMStyle(); 12939 Style.SpaceAfterTemplateKeyword = false; 12940 verifyFormat("template<int> void foo();", Style); 12941 } 12942 12943 TEST_F(FormatTest, TripleAngleBrackets) { 12944 verifyFormat("f<<<1, 1>>>();"); 12945 verifyFormat("f<<<1, 1, 1, s>>>();"); 12946 verifyFormat("f<<<a, b, c, d>>>();"); 12947 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 12948 verifyFormat("f<param><<<1, 1>>>();"); 12949 verifyFormat("f<1><<<1, 1>>>();"); 12950 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 12951 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 12952 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 12953 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 12954 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 12955 } 12956 12957 TEST_F(FormatTest, MergeLessLessAtEnd) { 12958 verifyFormat("<<"); 12959 EXPECT_EQ("< < <", format("\\\n<<<")); 12960 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 12961 "aaallvm::outs() <<"); 12962 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 12963 "aaaallvm::outs()\n <<"); 12964 } 12965 12966 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 12967 std::string code = "#if A\n" 12968 "#if B\n" 12969 "a.\n" 12970 "#endif\n" 12971 " a = 1;\n" 12972 "#else\n" 12973 "#endif\n" 12974 "#if C\n" 12975 "#else\n" 12976 "#endif\n"; 12977 EXPECT_EQ(code, format(code)); 12978 } 12979 12980 TEST_F(FormatTest, HandleConflictMarkers) { 12981 // Git/SVN conflict markers. 12982 EXPECT_EQ("int a;\n" 12983 "void f() {\n" 12984 " callme(some(parameter1,\n" 12985 "<<<<<<< text by the vcs\n" 12986 " parameter2),\n" 12987 "||||||| text by the vcs\n" 12988 " parameter2),\n" 12989 " parameter3,\n" 12990 "======= text by the vcs\n" 12991 " parameter2, parameter3),\n" 12992 ">>>>>>> text by the vcs\n" 12993 " otherparameter);\n", 12994 format("int a;\n" 12995 "void f() {\n" 12996 " callme(some(parameter1,\n" 12997 "<<<<<<< text by the vcs\n" 12998 " parameter2),\n" 12999 "||||||| text by the vcs\n" 13000 " parameter2),\n" 13001 " parameter3,\n" 13002 "======= text by the vcs\n" 13003 " parameter2,\n" 13004 " parameter3),\n" 13005 ">>>>>>> text by the vcs\n" 13006 " otherparameter);\n")); 13007 13008 // Perforce markers. 13009 EXPECT_EQ("void f() {\n" 13010 " function(\n" 13011 ">>>> text by the vcs\n" 13012 " parameter,\n" 13013 "==== text by the vcs\n" 13014 " parameter,\n" 13015 "==== text by the vcs\n" 13016 " parameter,\n" 13017 "<<<< text by the vcs\n" 13018 " parameter);\n", 13019 format("void f() {\n" 13020 " function(\n" 13021 ">>>> text by the vcs\n" 13022 " parameter,\n" 13023 "==== text by the vcs\n" 13024 " parameter,\n" 13025 "==== text by the vcs\n" 13026 " parameter,\n" 13027 "<<<< text by the vcs\n" 13028 " parameter);\n")); 13029 13030 EXPECT_EQ("<<<<<<<\n" 13031 "|||||||\n" 13032 "=======\n" 13033 ">>>>>>>", 13034 format("<<<<<<<\n" 13035 "|||||||\n" 13036 "=======\n" 13037 ">>>>>>>")); 13038 13039 EXPECT_EQ("<<<<<<<\n" 13040 "|||||||\n" 13041 "int i;\n" 13042 "=======\n" 13043 ">>>>>>>", 13044 format("<<<<<<<\n" 13045 "|||||||\n" 13046 "int i;\n" 13047 "=======\n" 13048 ">>>>>>>")); 13049 13050 // FIXME: Handle parsing of macros around conflict markers correctly: 13051 EXPECT_EQ("#define Macro \\\n" 13052 "<<<<<<<\n" 13053 "Something \\\n" 13054 "|||||||\n" 13055 "Else \\\n" 13056 "=======\n" 13057 "Other \\\n" 13058 ">>>>>>>\n" 13059 " End int i;\n", 13060 format("#define Macro \\\n" 13061 "<<<<<<<\n" 13062 " Something \\\n" 13063 "|||||||\n" 13064 " Else \\\n" 13065 "=======\n" 13066 " Other \\\n" 13067 ">>>>>>>\n" 13068 " End\n" 13069 "int i;\n")); 13070 } 13071 13072 TEST_F(FormatTest, DisableRegions) { 13073 EXPECT_EQ("int i;\n" 13074 "// clang-format off\n" 13075 " int j;\n" 13076 "// clang-format on\n" 13077 "int k;", 13078 format(" int i;\n" 13079 " // clang-format off\n" 13080 " int j;\n" 13081 " // clang-format on\n" 13082 " int k;")); 13083 EXPECT_EQ("int i;\n" 13084 "/* clang-format off */\n" 13085 " int j;\n" 13086 "/* clang-format on */\n" 13087 "int k;", 13088 format(" int i;\n" 13089 " /* clang-format off */\n" 13090 " int j;\n" 13091 " /* clang-format on */\n" 13092 " int k;")); 13093 13094 // Don't reflow comments within disabled regions. 13095 EXPECT_EQ( 13096 "// clang-format off\n" 13097 "// long long long long long long line\n" 13098 "/* clang-format on */\n" 13099 "/* long long long\n" 13100 " * long long long\n" 13101 " * line */\n" 13102 "int i;\n" 13103 "/* clang-format off */\n" 13104 "/* long long long long long long line */\n", 13105 format("// clang-format off\n" 13106 "// long long long long long long line\n" 13107 "/* clang-format on */\n" 13108 "/* long long long long long long line */\n" 13109 "int i;\n" 13110 "/* clang-format off */\n" 13111 "/* long long long long long long line */\n", 13112 getLLVMStyleWithColumns(20))); 13113 } 13114 13115 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 13116 format("? ) ="); 13117 verifyNoCrash("#define a\\\n /**/}"); 13118 } 13119 13120 TEST_F(FormatTest, FormatsTableGenCode) { 13121 FormatStyle Style = getLLVMStyle(); 13122 Style.Language = FormatStyle::LK_TableGen; 13123 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 13124 } 13125 13126 TEST_F(FormatTest, ArrayOfTemplates) { 13127 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 13128 format("auto a = new unique_ptr<int > [ 10];")); 13129 13130 FormatStyle Spaces = getLLVMStyle(); 13131 Spaces.SpacesInSquareBrackets = true; 13132 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 13133 format("auto a = new unique_ptr<int > [10];", Spaces)); 13134 } 13135 13136 TEST_F(FormatTest, ArrayAsTemplateType) { 13137 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 13138 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 13139 13140 FormatStyle Spaces = getLLVMStyle(); 13141 Spaces.SpacesInSquareBrackets = true; 13142 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 13143 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 13144 } 13145 13146 TEST_F(FormatTest, NoSpaceAfterSuper) { 13147 verifyFormat("__super::FooBar();"); 13148 } 13149 13150 TEST(FormatStyle, GetStyleWithEmptyFileName) { 13151 llvm::vfs::InMemoryFileSystem FS; 13152 auto Style1 = getStyle("file", "", "Google", "", &FS); 13153 ASSERT_TRUE((bool)Style1); 13154 ASSERT_EQ(*Style1, getGoogleStyle()); 13155 } 13156 13157 TEST(FormatStyle, GetStyleOfFile) { 13158 llvm::vfs::InMemoryFileSystem FS; 13159 // Test 1: format file in the same directory. 13160 ASSERT_TRUE( 13161 FS.addFile("/a/.clang-format", 0, 13162 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 13163 ASSERT_TRUE( 13164 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13165 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 13166 ASSERT_TRUE((bool)Style1); 13167 ASSERT_EQ(*Style1, getLLVMStyle()); 13168 13169 // Test 2.1: fallback to default. 13170 ASSERT_TRUE( 13171 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13172 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 13173 ASSERT_TRUE((bool)Style2); 13174 ASSERT_EQ(*Style2, getMozillaStyle()); 13175 13176 // Test 2.2: no format on 'none' fallback style. 13177 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 13178 ASSERT_TRUE((bool)Style2); 13179 ASSERT_EQ(*Style2, getNoStyle()); 13180 13181 // Test 2.3: format if config is found with no based style while fallback is 13182 // 'none'. 13183 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 13184 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 13185 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 13186 ASSERT_TRUE((bool)Style2); 13187 ASSERT_EQ(*Style2, getLLVMStyle()); 13188 13189 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 13190 Style2 = getStyle("{}", "a.h", "none", "", &FS); 13191 ASSERT_TRUE((bool)Style2); 13192 ASSERT_EQ(*Style2, getLLVMStyle()); 13193 13194 // Test 3: format file in parent directory. 13195 ASSERT_TRUE( 13196 FS.addFile("/c/.clang-format", 0, 13197 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 13198 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 13199 llvm::MemoryBuffer::getMemBuffer("int i;"))); 13200 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 13201 ASSERT_TRUE((bool)Style3); 13202 ASSERT_EQ(*Style3, getGoogleStyle()); 13203 13204 // Test 4: error on invalid fallback style 13205 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 13206 ASSERT_FALSE((bool)Style4); 13207 llvm::consumeError(Style4.takeError()); 13208 13209 // Test 5: error on invalid yaml on command line 13210 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 13211 ASSERT_FALSE((bool)Style5); 13212 llvm::consumeError(Style5.takeError()); 13213 13214 // Test 6: error on invalid style 13215 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 13216 ASSERT_FALSE((bool)Style6); 13217 llvm::consumeError(Style6.takeError()); 13218 13219 // Test 7: found config file, error on parsing it 13220 ASSERT_TRUE( 13221 FS.addFile("/d/.clang-format", 0, 13222 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 13223 "InvalidKey: InvalidValue"))); 13224 ASSERT_TRUE( 13225 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13226 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 13227 ASSERT_FALSE((bool)Style7); 13228 llvm::consumeError(Style7.takeError()); 13229 13230 // Test 8: inferred per-language defaults apply. 13231 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 13232 ASSERT_TRUE((bool)StyleTd); 13233 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 13234 } 13235 13236 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 13237 // Column limit is 20. 13238 std::string Code = "Type *a =\n" 13239 " new Type();\n" 13240 "g(iiiii, 0, jjjjj,\n" 13241 " 0, kkkkk, 0, mm);\n" 13242 "int bad = format ;"; 13243 std::string Expected = "auto a = new Type();\n" 13244 "g(iiiii, nullptr,\n" 13245 " jjjjj, nullptr,\n" 13246 " kkkkk, nullptr,\n" 13247 " mm);\n" 13248 "int bad = format ;"; 13249 FileID ID = Context.createInMemoryFile("format.cpp", Code); 13250 tooling::Replacements Replaces = toReplacements( 13251 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 13252 "auto "), 13253 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 13254 "nullptr"), 13255 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 13256 "nullptr"), 13257 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 13258 "nullptr")}); 13259 13260 format::FormatStyle Style = format::getLLVMStyle(); 13261 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 13262 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 13263 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 13264 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 13265 auto Result = applyAllReplacements(Code, *FormattedReplaces); 13266 EXPECT_TRUE(static_cast<bool>(Result)); 13267 EXPECT_EQ(Expected, *Result); 13268 } 13269 13270 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 13271 std::string Code = "#include \"a.h\"\n" 13272 "#include \"c.h\"\n" 13273 "\n" 13274 "int main() {\n" 13275 " return 0;\n" 13276 "}"; 13277 std::string Expected = "#include \"a.h\"\n" 13278 "#include \"b.h\"\n" 13279 "#include \"c.h\"\n" 13280 "\n" 13281 "int main() {\n" 13282 " return 0;\n" 13283 "}"; 13284 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 13285 tooling::Replacements Replaces = toReplacements( 13286 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 13287 "#include \"b.h\"\n")}); 13288 13289 format::FormatStyle Style = format::getLLVMStyle(); 13290 Style.SortIncludes = true; 13291 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 13292 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 13293 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 13294 auto Result = applyAllReplacements(Code, *FormattedReplaces); 13295 EXPECT_TRUE(static_cast<bool>(Result)); 13296 EXPECT_EQ(Expected, *Result); 13297 } 13298 13299 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 13300 EXPECT_EQ("using std::cin;\n" 13301 "using std::cout;", 13302 format("using std::cout;\n" 13303 "using std::cin;", getGoogleStyle())); 13304 } 13305 13306 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 13307 format::FormatStyle Style = format::getLLVMStyle(); 13308 Style.Standard = FormatStyle::LS_Cpp03; 13309 // cpp03 recognize this string as identifier u8 and literal character 'a' 13310 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 13311 } 13312 13313 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 13314 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 13315 // all modes, including C++11, C++14 and C++17 13316 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 13317 } 13318 13319 TEST_F(FormatTest, DoNotFormatLikelyXml) { 13320 EXPECT_EQ("<!-- ;> -->", 13321 format("<!-- ;> -->", getGoogleStyle())); 13322 EXPECT_EQ(" <!-- >; -->", 13323 format(" <!-- >; -->", getGoogleStyle())); 13324 } 13325 13326 TEST_F(FormatTest, StructuredBindings) { 13327 // Structured bindings is a C++17 feature. 13328 // all modes, including C++11, C++14 and C++17 13329 verifyFormat("auto [a, b] = f();"); 13330 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 13331 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 13332 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 13333 EXPECT_EQ("auto const volatile [a, b] = f();", 13334 format("auto const volatile[a, b] = f();")); 13335 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 13336 EXPECT_EQ("auto &[a, b, c] = f();", 13337 format("auto &[ a , b,c ] = f();")); 13338 EXPECT_EQ("auto &&[a, b, c] = f();", 13339 format("auto &&[ a , b,c ] = f();")); 13340 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 13341 EXPECT_EQ("auto const volatile &&[a, b] = f();", 13342 format("auto const volatile &&[a, b] = f();")); 13343 EXPECT_EQ("auto const &&[a, b] = f();", format("auto const && [a, b] = f();")); 13344 EXPECT_EQ("const auto &[a, b] = f();", format("const auto & [a, b] = f();")); 13345 EXPECT_EQ("const auto volatile &&[a, b] = f();", 13346 format("const auto volatile &&[a, b] = f();")); 13347 EXPECT_EQ("volatile const auto &&[a, b] = f();", 13348 format("volatile const auto &&[a, b] = f();")); 13349 EXPECT_EQ("const auto &&[a, b] = f();", format("const auto && [a, b] = f();")); 13350 13351 // Make sure we don't mistake structured bindings for lambdas. 13352 FormatStyle PointerMiddle = getLLVMStyle(); 13353 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 13354 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 13355 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 13356 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 13357 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 13358 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 13359 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 13360 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 13361 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 13362 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 13363 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 13364 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 13365 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 13366 13367 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 13368 format("for (const auto && [a, b] : some_range) {\n}")); 13369 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 13370 format("for (const auto & [a, b] : some_range) {\n}")); 13371 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 13372 format("for (const auto[a, b] : some_range) {\n}")); 13373 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 13374 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 13375 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 13376 EXPECT_EQ("auto const &[x, y](expr);", format("auto const & [x,y] (expr);")); 13377 EXPECT_EQ("auto const &&[x, y](expr);", format("auto const && [x,y] (expr);")); 13378 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 13379 EXPECT_EQ("auto const &[x, y]{expr};", format("auto const & [x,y] {expr};")); 13380 EXPECT_EQ("auto const &&[x, y]{expr};", format("auto const && [x,y] {expr};")); 13381 13382 format::FormatStyle Spaces = format::getLLVMStyle(); 13383 Spaces.SpacesInSquareBrackets = true; 13384 verifyFormat("auto [ a, b ] = f();", Spaces); 13385 verifyFormat("auto &&[ a, b ] = f();", Spaces); 13386 verifyFormat("auto &[ a, b ] = f();", Spaces); 13387 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 13388 verifyFormat("auto const &[ a, b ] = f();", Spaces); 13389 } 13390 13391 TEST_F(FormatTest, FileAndCode) { 13392 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 13393 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 13394 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 13395 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 13396 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@interface Foo\n@end\n")); 13397 EXPECT_EQ( 13398 FormatStyle::LK_ObjC, 13399 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 13400 EXPECT_EQ(FormatStyle::LK_ObjC, 13401 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 13402 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 13403 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 13404 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo", "@interface Foo\n@end\n")); 13405 EXPECT_EQ(FormatStyle::LK_ObjC, 13406 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 13407 EXPECT_EQ( 13408 FormatStyle::LK_ObjC, 13409 guessLanguage("foo.h", 13410 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 13411 EXPECT_EQ( 13412 FormatStyle::LK_Cpp, 13413 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 13414 } 13415 13416 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 13417 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 13418 EXPECT_EQ(FormatStyle::LK_ObjC, 13419 guessLanguage("foo.h", "array[[calculator getIndex]];")); 13420 EXPECT_EQ(FormatStyle::LK_Cpp, 13421 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 13422 EXPECT_EQ( 13423 FormatStyle::LK_Cpp, 13424 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 13425 EXPECT_EQ(FormatStyle::LK_ObjC, 13426 guessLanguage("foo.h", "[[noreturn foo] bar];")); 13427 EXPECT_EQ(FormatStyle::LK_Cpp, 13428 guessLanguage("foo.h", "[[clang::fallthrough]];")); 13429 EXPECT_EQ(FormatStyle::LK_ObjC, 13430 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 13431 EXPECT_EQ(FormatStyle::LK_Cpp, 13432 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 13433 EXPECT_EQ(FormatStyle::LK_Cpp, 13434 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 13435 EXPECT_EQ(FormatStyle::LK_ObjC, 13436 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 13437 EXPECT_EQ(FormatStyle::LK_Cpp, 13438 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 13439 EXPECT_EQ( 13440 FormatStyle::LK_Cpp, 13441 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 13442 EXPECT_EQ( 13443 FormatStyle::LK_Cpp, 13444 guessLanguage("foo.h", 13445 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 13446 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 13447 } 13448 13449 TEST_F(FormatTest, GuessLanguageWithCaret) { 13450 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 13451 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 13452 EXPECT_EQ(FormatStyle::LK_ObjC, 13453 guessLanguage("foo.h", "int(^)(char, float);")); 13454 EXPECT_EQ(FormatStyle::LK_ObjC, 13455 guessLanguage("foo.h", "int(^foo)(char, float);")); 13456 EXPECT_EQ(FormatStyle::LK_ObjC, 13457 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 13458 EXPECT_EQ(FormatStyle::LK_ObjC, 13459 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 13460 EXPECT_EQ( 13461 FormatStyle::LK_ObjC, 13462 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 13463 } 13464 13465 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 13466 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13467 "void f() {\n" 13468 " asm (\"mov %[e], %[d]\"\n" 13469 " : [d] \"=rm\" (d)\n" 13470 " [e] \"rm\" (*e));\n" 13471 "}")); 13472 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13473 "void f() {\n" 13474 " _asm (\"mov %[e], %[d]\"\n" 13475 " : [d] \"=rm\" (d)\n" 13476 " [e] \"rm\" (*e));\n" 13477 "}")); 13478 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13479 "void f() {\n" 13480 " __asm (\"mov %[e], %[d]\"\n" 13481 " : [d] \"=rm\" (d)\n" 13482 " [e] \"rm\" (*e));\n" 13483 "}")); 13484 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13485 "void f() {\n" 13486 " __asm__ (\"mov %[e], %[d]\"\n" 13487 " : [d] \"=rm\" (d)\n" 13488 " [e] \"rm\" (*e));\n" 13489 "}")); 13490 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13491 "void f() {\n" 13492 " asm (\"mov %[e], %[d]\"\n" 13493 " : [d] \"=rm\" (d),\n" 13494 " [e] \"rm\" (*e));\n" 13495 "}")); 13496 EXPECT_EQ(FormatStyle::LK_Cpp, 13497 guessLanguage("foo.h", "void f() {\n" 13498 " asm volatile (\"mov %[e], %[d]\"\n" 13499 " : [d] \"=rm\" (d)\n" 13500 " [e] \"rm\" (*e));\n" 13501 "}")); 13502 } 13503 13504 TEST_F(FormatTest, GuessLanguageWithChildLines) { 13505 EXPECT_EQ(FormatStyle::LK_Cpp, 13506 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 13507 EXPECT_EQ(FormatStyle::LK_ObjC, 13508 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 13509 EXPECT_EQ( 13510 FormatStyle::LK_Cpp, 13511 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 13512 EXPECT_EQ( 13513 FormatStyle::LK_ObjC, 13514 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 13515 } 13516 13517 } // end namespace 13518 } // end namespace format 13519 } // end namespace clang 13520