1 //===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "clang/Format/Format.h" 10 11 #include "../Tooling/ReplacementTest.h" 12 #include "FormatTestUtils.h" 13 14 #include "clang/Frontend/TextDiagnosticPrinter.h" 15 #include "llvm/Support/Debug.h" 16 #include "llvm/Support/MemoryBuffer.h" 17 #include "gtest/gtest.h" 18 19 #define DEBUG_TYPE "format-test" 20 21 using clang::tooling::ReplacementTest; 22 using clang::tooling::toReplacements; 23 24 namespace clang { 25 namespace format { 26 namespace { 27 28 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); } 29 30 class FormatTest : public ::testing::Test { 31 protected: 32 enum StatusCheck { 33 SC_ExpectComplete, 34 SC_ExpectIncomplete, 35 SC_DoNotCheck 36 }; 37 38 std::string format(llvm::StringRef Code, 39 const FormatStyle &Style = getLLVMStyle(), 40 StatusCheck CheckComplete = SC_ExpectComplete) { 41 LLVM_DEBUG(llvm::errs() << "---\n"); 42 LLVM_DEBUG(llvm::errs() << Code << "\n\n"); 43 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size())); 44 FormattingAttemptStatus Status; 45 tooling::Replacements Replaces = 46 reformat(Style, Code, Ranges, "<stdin>", &Status); 47 if (CheckComplete != SC_DoNotCheck) { 48 bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete; 49 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete) 50 << Code << "\n\n"; 51 } 52 ReplacementCount = Replaces.size(); 53 auto Result = applyAllReplacements(Code, Replaces); 54 EXPECT_TRUE(static_cast<bool>(Result)); 55 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); 56 return *Result; 57 } 58 59 FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) { 60 Style.ColumnLimit = ColumnLimit; 61 return Style; 62 } 63 64 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 65 return getStyleWithColumns(getLLVMStyle(), ColumnLimit); 66 } 67 68 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) { 69 return getStyleWithColumns(getGoogleStyle(), ColumnLimit); 70 } 71 72 void verifyFormat(llvm::StringRef Expected, llvm::StringRef Code, 73 const FormatStyle &Style = getLLVMStyle()) { 74 EXPECT_EQ(Expected.str(), format(Expected, Style)) 75 << "Expected code is not stable"; 76 EXPECT_EQ(Expected.str(), format(Code, Style)); 77 if (Style.Language == FormatStyle::LK_Cpp) { 78 // Objective-C++ is a superset of C++, so everything checked for C++ 79 // needs to be checked for Objective-C++ as well. 80 FormatStyle ObjCStyle = Style; 81 ObjCStyle.Language = FormatStyle::LK_ObjC; 82 EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle)); 83 } 84 } 85 86 void verifyFormat(llvm::StringRef Code, 87 const FormatStyle &Style = getLLVMStyle()) { 88 verifyFormat(Code, test::messUp(Code), Style); 89 } 90 91 void verifyIncompleteFormat(llvm::StringRef Code, 92 const FormatStyle &Style = getLLVMStyle()) { 93 EXPECT_EQ(Code.str(), 94 format(test::messUp(Code), Style, SC_ExpectIncomplete)); 95 } 96 97 void verifyGoogleFormat(llvm::StringRef Code) { 98 verifyFormat(Code, getGoogleStyle()); 99 } 100 101 void verifyIndependentOfContext(llvm::StringRef text) { 102 verifyFormat(text); 103 verifyFormat(llvm::Twine("void f() { " + text + " }").str()); 104 } 105 106 /// \brief Verify that clang-format does not crash on the given input. 107 void verifyNoCrash(llvm::StringRef Code, 108 const FormatStyle &Style = getLLVMStyle()) { 109 format(Code, Style, SC_DoNotCheck); 110 } 111 112 int ReplacementCount; 113 }; 114 115 TEST_F(FormatTest, MessUp) { 116 EXPECT_EQ("1 2 3", test::messUp("1 2 3")); 117 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n")); 118 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc")); 119 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc")); 120 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne")); 121 } 122 123 TEST_F(FormatTest, DefaultLLVMStyleIsCpp) { 124 EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language); 125 } 126 127 TEST_F(FormatTest, LLVMStyleOverride) { 128 EXPECT_EQ(FormatStyle::LK_Proto, 129 getLLVMStyle(FormatStyle::LK_Proto).Language); 130 } 131 132 //===----------------------------------------------------------------------===// 133 // Basic function tests. 134 //===----------------------------------------------------------------------===// 135 136 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { 137 EXPECT_EQ(";", format(";")); 138 } 139 140 TEST_F(FormatTest, FormatsGlobalStatementsAt0) { 141 EXPECT_EQ("int i;", format(" int i;")); 142 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;")); 143 EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); 144 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); 145 } 146 147 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { 148 EXPECT_EQ("int i;", format("int\ni;")); 149 } 150 151 TEST_F(FormatTest, FormatsNestedBlockStatements) { 152 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}")); 153 } 154 155 TEST_F(FormatTest, FormatsNestedCall) { 156 verifyFormat("Method(f1, f2(f3));"); 157 verifyFormat("Method(f1(f2, f3()));"); 158 verifyFormat("Method(f1(f2, (f3())));"); 159 } 160 161 TEST_F(FormatTest, NestedNameSpecifiers) { 162 verifyFormat("vector<::Type> v;"); 163 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())"); 164 verifyFormat("static constexpr bool Bar = decltype(bar())::value;"); 165 verifyFormat("bool a = 2 < ::SomeFunction();"); 166 verifyFormat("ALWAYS_INLINE ::std::string getName();"); 167 verifyFormat("some::string getName();"); 168 } 169 170 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { 171 EXPECT_EQ("if (a) {\n" 172 " f();\n" 173 "}", 174 format("if(a){f();}")); 175 EXPECT_EQ(4, ReplacementCount); 176 EXPECT_EQ("if (a) {\n" 177 " f();\n" 178 "}", 179 format("if (a) {\n" 180 " f();\n" 181 "}")); 182 EXPECT_EQ(0, ReplacementCount); 183 EXPECT_EQ("/*\r\n" 184 "\r\n" 185 "*/\r\n", 186 format("/*\r\n" 187 "\r\n" 188 "*/\r\n")); 189 EXPECT_EQ(0, ReplacementCount); 190 } 191 192 TEST_F(FormatTest, RemovesEmptyLines) { 193 EXPECT_EQ("class C {\n" 194 " int i;\n" 195 "};", 196 format("class C {\n" 197 " int i;\n" 198 "\n" 199 "};")); 200 201 // Don't remove empty lines at the start of namespaces or extern "C" blocks. 202 EXPECT_EQ("namespace N {\n" 203 "\n" 204 "int i;\n" 205 "}", 206 format("namespace N {\n" 207 "\n" 208 "int i;\n" 209 "}", 210 getGoogleStyle())); 211 EXPECT_EQ("/* something */ namespace N {\n" 212 "\n" 213 "int i;\n" 214 "}", 215 format("/* something */ namespace N {\n" 216 "\n" 217 "int i;\n" 218 "}", 219 getGoogleStyle())); 220 EXPECT_EQ("inline namespace N {\n" 221 "\n" 222 "int i;\n" 223 "}", 224 format("inline namespace N {\n" 225 "\n" 226 "int i;\n" 227 "}", 228 getGoogleStyle())); 229 EXPECT_EQ("/* something */ inline namespace N {\n" 230 "\n" 231 "int i;\n" 232 "}", 233 format("/* something */ inline namespace N {\n" 234 "\n" 235 "int i;\n" 236 "}", 237 getGoogleStyle())); 238 EXPECT_EQ("export namespace N {\n" 239 "\n" 240 "int i;\n" 241 "}", 242 format("export namespace N {\n" 243 "\n" 244 "int i;\n" 245 "}", 246 getGoogleStyle())); 247 EXPECT_EQ("extern /**/ \"C\" /**/ {\n" 248 "\n" 249 "int i;\n" 250 "}", 251 format("extern /**/ \"C\" /**/ {\n" 252 "\n" 253 "int i;\n" 254 "}", 255 getGoogleStyle())); 256 257 // ...but do keep inlining and removing empty lines for non-block extern "C" 258 // functions. 259 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle()); 260 EXPECT_EQ("extern \"C\" int f() {\n" 261 " int i = 42;\n" 262 " return i;\n" 263 "}", 264 format("extern \"C\" int f() {\n" 265 "\n" 266 " int i = 42;\n" 267 " return i;\n" 268 "}", 269 getGoogleStyle())); 270 271 // Remove empty lines at the beginning and end of blocks. 272 EXPECT_EQ("void f() {\n" 273 "\n" 274 " if (a) {\n" 275 "\n" 276 " f();\n" 277 " }\n" 278 "}", 279 format("void f() {\n" 280 "\n" 281 " if (a) {\n" 282 "\n" 283 " f();\n" 284 "\n" 285 " }\n" 286 "\n" 287 "}", 288 getLLVMStyle())); 289 EXPECT_EQ("void f() {\n" 290 " if (a) {\n" 291 " f();\n" 292 " }\n" 293 "}", 294 format("void f() {\n" 295 "\n" 296 " if (a) {\n" 297 "\n" 298 " f();\n" 299 "\n" 300 " }\n" 301 "\n" 302 "}", 303 getGoogleStyle())); 304 305 // Don't remove empty lines in more complex control statements. 306 EXPECT_EQ("void f() {\n" 307 " if (a) {\n" 308 " f();\n" 309 "\n" 310 " } else if (b) {\n" 311 " f();\n" 312 " }\n" 313 "}", 314 format("void f() {\n" 315 " if (a) {\n" 316 " f();\n" 317 "\n" 318 " } else if (b) {\n" 319 " f();\n" 320 "\n" 321 " }\n" 322 "\n" 323 "}")); 324 325 // Don't remove empty lines before namespace endings. 326 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 327 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 328 EXPECT_EQ("namespace {\n" 329 "int i;\n" 330 "\n" 331 "}", 332 format("namespace {\n" 333 "int i;\n" 334 "\n" 335 "}", LLVMWithNoNamespaceFix)); 336 EXPECT_EQ("namespace {\n" 337 "int i;\n" 338 "}", 339 format("namespace {\n" 340 "int i;\n" 341 "}", LLVMWithNoNamespaceFix)); 342 EXPECT_EQ("namespace {\n" 343 "int i;\n" 344 "\n" 345 "};", 346 format("namespace {\n" 347 "int i;\n" 348 "\n" 349 "};", LLVMWithNoNamespaceFix)); 350 EXPECT_EQ("namespace {\n" 351 "int i;\n" 352 "};", 353 format("namespace {\n" 354 "int i;\n" 355 "};", LLVMWithNoNamespaceFix)); 356 EXPECT_EQ("namespace {\n" 357 "int i;\n" 358 "\n" 359 "}", 360 format("namespace {\n" 361 "int i;\n" 362 "\n" 363 "}")); 364 EXPECT_EQ("namespace {\n" 365 "int i;\n" 366 "\n" 367 "} // namespace", 368 format("namespace {\n" 369 "int i;\n" 370 "\n" 371 "} // namespace")); 372 373 FormatStyle Style = getLLVMStyle(); 374 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 375 Style.MaxEmptyLinesToKeep = 2; 376 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 377 Style.BraceWrapping.AfterClass = true; 378 Style.BraceWrapping.AfterFunction = true; 379 Style.KeepEmptyLinesAtTheStartOfBlocks = false; 380 381 EXPECT_EQ("class Foo\n" 382 "{\n" 383 " Foo() {}\n" 384 "\n" 385 " void funk() {}\n" 386 "};", 387 format("class Foo\n" 388 "{\n" 389 " Foo()\n" 390 " {\n" 391 " }\n" 392 "\n" 393 " void funk() {}\n" 394 "};", 395 Style)); 396 } 397 398 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) { 399 verifyFormat("x = (a) and (b);"); 400 verifyFormat("x = (a) or (b);"); 401 verifyFormat("x = (a) bitand (b);"); 402 verifyFormat("x = (a) bitor (b);"); 403 verifyFormat("x = (a) not_eq (b);"); 404 verifyFormat("x = (a) and_eq (b);"); 405 verifyFormat("x = (a) or_eq (b);"); 406 verifyFormat("x = (a) xor (b);"); 407 } 408 409 TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) { 410 verifyFormat("x = compl(a);"); 411 verifyFormat("x = not(a);"); 412 verifyFormat("x = bitand(a);"); 413 // Unary operator must not be merged with the next identifier 414 verifyFormat("x = compl a;"); 415 verifyFormat("x = not a;"); 416 verifyFormat("x = bitand a;"); 417 } 418 419 //===----------------------------------------------------------------------===// 420 // Tests for control statements. 421 //===----------------------------------------------------------------------===// 422 423 TEST_F(FormatTest, FormatIfWithoutCompoundStatement) { 424 verifyFormat("if (true)\n f();\ng();"); 425 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();"); 426 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();"); 427 verifyFormat("if constexpr (true)\n" 428 " f();\ng();"); 429 verifyFormat("if CONSTEXPR (true)\n" 430 " f();\ng();"); 431 verifyFormat("if constexpr (a)\n" 432 " if constexpr (b)\n" 433 " if constexpr (c)\n" 434 " g();\n" 435 "h();"); 436 verifyFormat("if CONSTEXPR (a)\n" 437 " if CONSTEXPR (b)\n" 438 " if CONSTEXPR (c)\n" 439 " g();\n" 440 "h();"); 441 verifyFormat("if constexpr (a)\n" 442 " if constexpr (b) {\n" 443 " f();\n" 444 " }\n" 445 "g();"); 446 verifyFormat("if CONSTEXPR (a)\n" 447 " if CONSTEXPR (b) {\n" 448 " f();\n" 449 " }\n" 450 "g();"); 451 452 FormatStyle AllowsMergedIf = getLLVMStyle(); 453 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 454 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 455 FormatStyle::SIS_WithoutElse; 456 verifyFormat("if (a)\n" 457 " // comment\n" 458 " f();", 459 AllowsMergedIf); 460 verifyFormat("{\n" 461 " if (a)\n" 462 " label:\n" 463 " f();\n" 464 "}", 465 AllowsMergedIf); 466 verifyFormat("#define A \\\n" 467 " if (a) \\\n" 468 " label: \\\n" 469 " f()", 470 AllowsMergedIf); 471 verifyFormat("if (a)\n" 472 " ;", 473 AllowsMergedIf); 474 verifyFormat("if (a)\n" 475 " if (b) return;", 476 AllowsMergedIf); 477 478 verifyFormat("if (a) // Can't merge this\n" 479 " f();\n", 480 AllowsMergedIf); 481 verifyFormat("if (a) /* still don't merge */\n" 482 " f();", 483 AllowsMergedIf); 484 verifyFormat("if (a) { // Never merge this\n" 485 " f();\n" 486 "}", 487 AllowsMergedIf); 488 verifyFormat("if (a) { /* Never merge this */\n" 489 " f();\n" 490 "}", 491 AllowsMergedIf); 492 493 AllowsMergedIf.ColumnLimit = 14; 494 verifyFormat("if (a) return;", AllowsMergedIf); 495 verifyFormat("if (aaaaaaaaa)\n" 496 " return;", 497 AllowsMergedIf); 498 499 AllowsMergedIf.ColumnLimit = 13; 500 verifyFormat("if (a)\n return;", AllowsMergedIf); 501 } 502 503 TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) { 504 FormatStyle AllowsMergedIf = getLLVMStyle(); 505 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 506 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 507 FormatStyle::SIS_WithoutElse; 508 verifyFormat("if (a)\n" 509 " f();\n" 510 "else {\n" 511 " g();\n" 512 "}", 513 AllowsMergedIf); 514 verifyFormat("if (a)\n" 515 " f();\n" 516 "else\n" 517 " g();\n", 518 AllowsMergedIf); 519 520 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 521 522 verifyFormat("if (a) f();\n" 523 "else {\n" 524 " g();\n" 525 "}", 526 AllowsMergedIf); 527 verifyFormat("if (a) f();\n" 528 "else {\n" 529 " if (a) f();\n" 530 " else {\n" 531 " g();\n" 532 " }\n" 533 " g();\n" 534 "}", 535 AllowsMergedIf); 536 } 537 538 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) { 539 FormatStyle AllowsMergedLoops = getLLVMStyle(); 540 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true; 541 verifyFormat("while (true) continue;", AllowsMergedLoops); 542 verifyFormat("for (;;) continue;", AllowsMergedLoops); 543 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops); 544 verifyFormat("while (true)\n" 545 " ;", 546 AllowsMergedLoops); 547 verifyFormat("for (;;)\n" 548 " ;", 549 AllowsMergedLoops); 550 verifyFormat("for (;;)\n" 551 " for (;;) continue;", 552 AllowsMergedLoops); 553 verifyFormat("for (;;) // Can't merge this\n" 554 " continue;", 555 AllowsMergedLoops); 556 verifyFormat("for (;;) /* still don't merge */\n" 557 " continue;", 558 AllowsMergedLoops); 559 } 560 561 TEST_F(FormatTest, FormatShortBracedStatements) { 562 FormatStyle AllowSimpleBracedStatements = getLLVMStyle(); 563 AllowSimpleBracedStatements.ColumnLimit = 40; 564 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = 565 FormatStyle::SBS_Always; 566 567 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 568 FormatStyle::SIS_WithoutElse; 569 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 570 571 AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom; 572 AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true; 573 AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false; 574 575 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 576 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 577 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 578 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 579 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 580 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 581 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 582 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 583 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 584 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 585 verifyFormat("if (true) {\n" 586 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 587 "}", 588 AllowSimpleBracedStatements); 589 verifyFormat("if (true) { //\n" 590 " f();\n" 591 "}", 592 AllowSimpleBracedStatements); 593 verifyFormat("if (true) {\n" 594 " f();\n" 595 " f();\n" 596 "}", 597 AllowSimpleBracedStatements); 598 verifyFormat("if (true) {\n" 599 " f();\n" 600 "} else {\n" 601 " f();\n" 602 "}", 603 AllowSimpleBracedStatements); 604 605 verifyFormat("struct A2 {\n" 606 " int X;\n" 607 "};", 608 AllowSimpleBracedStatements); 609 verifyFormat("typedef struct A2 {\n" 610 " int X;\n" 611 "} A2_t;", 612 AllowSimpleBracedStatements); 613 verifyFormat("template <int> struct A2 {\n" 614 " struct B {};\n" 615 "};", 616 AllowSimpleBracedStatements); 617 618 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 619 FormatStyle::SIS_Never; 620 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 621 verifyFormat("if (true) {\n" 622 " f();\n" 623 "}", 624 AllowSimpleBracedStatements); 625 verifyFormat("if (true) {\n" 626 " f();\n" 627 "} else {\n" 628 " f();\n" 629 "}", 630 AllowSimpleBracedStatements); 631 632 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 633 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 634 verifyFormat("while (true) {\n" 635 " f();\n" 636 "}", 637 AllowSimpleBracedStatements); 638 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 639 verifyFormat("for (;;) {\n" 640 " f();\n" 641 "}", 642 AllowSimpleBracedStatements); 643 644 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 645 FormatStyle::SIS_WithoutElse; 646 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 647 AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement = true; 648 649 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 650 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 651 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 652 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 653 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 654 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 655 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 656 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 657 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 658 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 659 verifyFormat("if (true)\n" 660 "{\n" 661 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 662 "}", 663 AllowSimpleBracedStatements); 664 verifyFormat("if (true)\n" 665 "{ //\n" 666 " f();\n" 667 "}", 668 AllowSimpleBracedStatements); 669 verifyFormat("if (true)\n" 670 "{\n" 671 " f();\n" 672 " f();\n" 673 "}", 674 AllowSimpleBracedStatements); 675 verifyFormat("if (true)\n" 676 "{\n" 677 " f();\n" 678 "} else\n" 679 "{\n" 680 " f();\n" 681 "}", 682 AllowSimpleBracedStatements); 683 684 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 685 FormatStyle::SIS_Never; 686 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 687 verifyFormat("if (true)\n" 688 "{\n" 689 " f();\n" 690 "}", 691 AllowSimpleBracedStatements); 692 verifyFormat("if (true)\n" 693 "{\n" 694 " f();\n" 695 "} else\n" 696 "{\n" 697 " f();\n" 698 "}", 699 AllowSimpleBracedStatements); 700 701 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 702 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 703 verifyFormat("while (true)\n" 704 "{\n" 705 " f();\n" 706 "}", 707 AllowSimpleBracedStatements); 708 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 709 verifyFormat("for (;;)\n" 710 "{\n" 711 " f();\n" 712 "}", 713 AllowSimpleBracedStatements); 714 } 715 716 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) { 717 FormatStyle Style = getLLVMStyleWithColumns(60); 718 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 719 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 720 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 721 EXPECT_EQ("#define A \\\n" 722 " if (HANDLEwernufrnuLwrmviferuvnierv) \\\n" 723 " { RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; }\n" 724 "X;", 725 format("#define A \\\n" 726 " if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n" 727 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n" 728 " }\n" 729 "X;", 730 Style)); 731 } 732 733 TEST_F(FormatTest, ParseIfElse) { 734 verifyFormat("if (true)\n" 735 " if (true)\n" 736 " if (true)\n" 737 " f();\n" 738 " else\n" 739 " g();\n" 740 " else\n" 741 " h();\n" 742 "else\n" 743 " i();"); 744 verifyFormat("if (true)\n" 745 " if (true)\n" 746 " if (true) {\n" 747 " if (true)\n" 748 " f();\n" 749 " } else {\n" 750 " g();\n" 751 " }\n" 752 " else\n" 753 " h();\n" 754 "else {\n" 755 " i();\n" 756 "}"); 757 verifyFormat("if (true)\n" 758 " if constexpr (true)\n" 759 " if (true) {\n" 760 " if constexpr (true)\n" 761 " f();\n" 762 " } else {\n" 763 " g();\n" 764 " }\n" 765 " else\n" 766 " h();\n" 767 "else {\n" 768 " i();\n" 769 "}"); 770 verifyFormat("if (true)\n" 771 " if CONSTEXPR (true)\n" 772 " if (true) {\n" 773 " if CONSTEXPR (true)\n" 774 " f();\n" 775 " } else {\n" 776 " g();\n" 777 " }\n" 778 " else\n" 779 " h();\n" 780 "else {\n" 781 " i();\n" 782 "}"); 783 verifyFormat("void f() {\n" 784 " if (a) {\n" 785 " } else {\n" 786 " }\n" 787 "}"); 788 } 789 790 TEST_F(FormatTest, ElseIf) { 791 verifyFormat("if (a) {\n} else if (b) {\n}"); 792 verifyFormat("if (a)\n" 793 " f();\n" 794 "else if (b)\n" 795 " g();\n" 796 "else\n" 797 " h();"); 798 verifyFormat("if constexpr (a)\n" 799 " f();\n" 800 "else if constexpr (b)\n" 801 " g();\n" 802 "else\n" 803 " h();"); 804 verifyFormat("if CONSTEXPR (a)\n" 805 " f();\n" 806 "else if CONSTEXPR (b)\n" 807 " g();\n" 808 "else\n" 809 " h();"); 810 verifyFormat("if (a) {\n" 811 " f();\n" 812 "}\n" 813 "// or else ..\n" 814 "else {\n" 815 " g()\n" 816 "}"); 817 818 verifyFormat("if (a) {\n" 819 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 820 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 821 "}"); 822 verifyFormat("if (a) {\n" 823 "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 824 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 825 "}"); 826 verifyFormat("if (a) {\n" 827 "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 828 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 829 "}"); 830 verifyFormat("if (a) {\n" 831 "} else if (\n" 832 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 833 "}", 834 getLLVMStyleWithColumns(62)); 835 verifyFormat("if (a) {\n" 836 "} else if constexpr (\n" 837 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 838 "}", 839 getLLVMStyleWithColumns(62)); 840 verifyFormat("if (a) {\n" 841 "} else if CONSTEXPR (\n" 842 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 843 "}", 844 getLLVMStyleWithColumns(62)); 845 } 846 847 TEST_F(FormatTest, FormatsForLoop) { 848 verifyFormat( 849 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 850 " ++VeryVeryLongLoopVariable)\n" 851 " ;"); 852 verifyFormat("for (;;)\n" 853 " f();"); 854 verifyFormat("for (;;) {\n}"); 855 verifyFormat("for (;;) {\n" 856 " f();\n" 857 "}"); 858 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 859 860 verifyFormat( 861 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 862 " E = UnwrappedLines.end();\n" 863 " I != E; ++I) {\n}"); 864 865 verifyFormat( 866 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 867 " ++IIIII) {\n}"); 868 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 869 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 870 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 871 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 872 " I = FD->getDeclsInPrototypeScope().begin(),\n" 873 " E = FD->getDeclsInPrototypeScope().end();\n" 874 " I != E; ++I) {\n}"); 875 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n" 876 " I = Container.begin(),\n" 877 " E = Container.end();\n" 878 " I != E; ++I) {\n}", 879 getLLVMStyleWithColumns(76)); 880 881 verifyFormat( 882 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 883 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 884 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 885 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 886 " ++aaaaaaaaaaa) {\n}"); 887 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 888 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n" 889 " ++i) {\n}"); 890 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 891 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 892 "}"); 893 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 894 " aaaaaaaaaa);\n" 895 " iter; ++iter) {\n" 896 "}"); 897 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 898 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 899 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n" 900 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {"); 901 902 // These should not be formatted as Objective-C for-in loops. 903 verifyFormat("for (Foo *x = 0; x != in; x++) {\n}"); 904 verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}"); 905 verifyFormat("Foo *x;\nfor (x in y) {\n}"); 906 verifyFormat("for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}"); 907 908 FormatStyle NoBinPacking = getLLVMStyle(); 909 NoBinPacking.BinPackParameters = false; 910 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 911 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 912 " aaaaaaaaaaaaaaaa,\n" 913 " aaaaaaaaaaaaaaaa,\n" 914 " aaaaaaaaaaaaaaaa);\n" 915 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 916 "}", 917 NoBinPacking); 918 verifyFormat( 919 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 920 " E = UnwrappedLines.end();\n" 921 " I != E;\n" 922 " ++I) {\n}", 923 NoBinPacking); 924 925 FormatStyle AlignLeft = getLLVMStyle(); 926 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 927 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft); 928 } 929 930 TEST_F(FormatTest, RangeBasedForLoops) { 931 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 932 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 933 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 934 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 935 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 936 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 937 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n" 938 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}"); 939 } 940 941 TEST_F(FormatTest, ForEachLoops) { 942 verifyFormat("void f() {\n" 943 " foreach (Item *item, itemlist) {}\n" 944 " Q_FOREACH (Item *item, itemlist) {}\n" 945 " BOOST_FOREACH (Item *item, itemlist) {}\n" 946 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 947 "}"); 948 949 // As function-like macros. 950 verifyFormat("#define foreach(x, y)\n" 951 "#define Q_FOREACH(x, y)\n" 952 "#define BOOST_FOREACH(x, y)\n" 953 "#define UNKNOWN_FOREACH(x, y)\n"); 954 955 // Not as function-like macros. 956 verifyFormat("#define foreach (x, y)\n" 957 "#define Q_FOREACH (x, y)\n" 958 "#define BOOST_FOREACH (x, y)\n" 959 "#define UNKNOWN_FOREACH (x, y)\n"); 960 } 961 962 TEST_F(FormatTest, FormatsWhileLoop) { 963 verifyFormat("while (true) {\n}"); 964 verifyFormat("while (true)\n" 965 " f();"); 966 verifyFormat("while () {\n}"); 967 verifyFormat("while () {\n" 968 " f();\n" 969 "}"); 970 } 971 972 TEST_F(FormatTest, FormatsDoWhile) { 973 verifyFormat("do {\n" 974 " do_something();\n" 975 "} while (something());"); 976 verifyFormat("do\n" 977 " do_something();\n" 978 "while (something());"); 979 } 980 981 TEST_F(FormatTest, FormatsSwitchStatement) { 982 verifyFormat("switch (x) {\n" 983 "case 1:\n" 984 " f();\n" 985 " break;\n" 986 "case kFoo:\n" 987 "case ns::kBar:\n" 988 "case kBaz:\n" 989 " break;\n" 990 "default:\n" 991 " g();\n" 992 " break;\n" 993 "}"); 994 verifyFormat("switch (x) {\n" 995 "case 1: {\n" 996 " f();\n" 997 " break;\n" 998 "}\n" 999 "case 2: {\n" 1000 " break;\n" 1001 "}\n" 1002 "}"); 1003 verifyFormat("switch (x) {\n" 1004 "case 1: {\n" 1005 " f();\n" 1006 " {\n" 1007 " g();\n" 1008 " h();\n" 1009 " }\n" 1010 " break;\n" 1011 "}\n" 1012 "}"); 1013 verifyFormat("switch (x) {\n" 1014 "case 1: {\n" 1015 " f();\n" 1016 " if (foo) {\n" 1017 " g();\n" 1018 " h();\n" 1019 " }\n" 1020 " break;\n" 1021 "}\n" 1022 "}"); 1023 verifyFormat("switch (x) {\n" 1024 "case 1: {\n" 1025 " f();\n" 1026 " g();\n" 1027 "} break;\n" 1028 "}"); 1029 verifyFormat("switch (test)\n" 1030 " ;"); 1031 verifyFormat("switch (x) {\n" 1032 "default: {\n" 1033 " // Do nothing.\n" 1034 "}\n" 1035 "}"); 1036 verifyFormat("switch (x) {\n" 1037 "// comment\n" 1038 "// if 1, do f()\n" 1039 "case 1:\n" 1040 " f();\n" 1041 "}"); 1042 verifyFormat("switch (x) {\n" 1043 "case 1:\n" 1044 " // Do amazing stuff\n" 1045 " {\n" 1046 " f();\n" 1047 " g();\n" 1048 " }\n" 1049 " break;\n" 1050 "}"); 1051 verifyFormat("#define A \\\n" 1052 " switch (x) { \\\n" 1053 " case a: \\\n" 1054 " foo = b; \\\n" 1055 " }", 1056 getLLVMStyleWithColumns(20)); 1057 verifyFormat("#define OPERATION_CASE(name) \\\n" 1058 " case OP_name: \\\n" 1059 " return operations::Operation##name\n", 1060 getLLVMStyleWithColumns(40)); 1061 verifyFormat("switch (x) {\n" 1062 "case 1:;\n" 1063 "default:;\n" 1064 " int i;\n" 1065 "}"); 1066 1067 verifyGoogleFormat("switch (x) {\n" 1068 " case 1:\n" 1069 " f();\n" 1070 " break;\n" 1071 " case kFoo:\n" 1072 " case ns::kBar:\n" 1073 " case kBaz:\n" 1074 " break;\n" 1075 " default:\n" 1076 " g();\n" 1077 " break;\n" 1078 "}"); 1079 verifyGoogleFormat("switch (x) {\n" 1080 " case 1: {\n" 1081 " f();\n" 1082 " break;\n" 1083 " }\n" 1084 "}"); 1085 verifyGoogleFormat("switch (test)\n" 1086 " ;"); 1087 1088 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 1089 " case OP_name: \\\n" 1090 " return operations::Operation##name\n"); 1091 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 1092 " // Get the correction operation class.\n" 1093 " switch (OpCode) {\n" 1094 " CASE(Add);\n" 1095 " CASE(Subtract);\n" 1096 " default:\n" 1097 " return operations::Unknown;\n" 1098 " }\n" 1099 "#undef OPERATION_CASE\n" 1100 "}"); 1101 verifyFormat("DEBUG({\n" 1102 " switch (x) {\n" 1103 " case A:\n" 1104 " f();\n" 1105 " break;\n" 1106 " // fallthrough\n" 1107 " case B:\n" 1108 " g();\n" 1109 " break;\n" 1110 " }\n" 1111 "});"); 1112 EXPECT_EQ("DEBUG({\n" 1113 " switch (x) {\n" 1114 " case A:\n" 1115 " f();\n" 1116 " break;\n" 1117 " // On B:\n" 1118 " case B:\n" 1119 " g();\n" 1120 " break;\n" 1121 " }\n" 1122 "});", 1123 format("DEBUG({\n" 1124 " switch (x) {\n" 1125 " case A:\n" 1126 " f();\n" 1127 " break;\n" 1128 " // On B:\n" 1129 " case B:\n" 1130 " g();\n" 1131 " break;\n" 1132 " }\n" 1133 "});", 1134 getLLVMStyle())); 1135 EXPECT_EQ("switch (n) {\n" 1136 "case 0: {\n" 1137 " return false;\n" 1138 "}\n" 1139 "default: {\n" 1140 " return true;\n" 1141 "}\n" 1142 "}", 1143 format("switch (n)\n" 1144 "{\n" 1145 "case 0: {\n" 1146 " return false;\n" 1147 "}\n" 1148 "default: {\n" 1149 " return true;\n" 1150 "}\n" 1151 "}", 1152 getLLVMStyle())); 1153 verifyFormat("switch (a) {\n" 1154 "case (b):\n" 1155 " return;\n" 1156 "}"); 1157 1158 verifyFormat("switch (a) {\n" 1159 "case some_namespace::\n" 1160 " some_constant:\n" 1161 " return;\n" 1162 "}", 1163 getLLVMStyleWithColumns(34)); 1164 1165 FormatStyle Style = getLLVMStyle(); 1166 Style.IndentCaseLabels = true; 1167 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 1168 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1169 Style.BraceWrapping.AfterCaseLabel = true; 1170 Style.BraceWrapping.AfterControlStatement = true; 1171 EXPECT_EQ("switch (n)\n" 1172 "{\n" 1173 " case 0:\n" 1174 " {\n" 1175 " return false;\n" 1176 " }\n" 1177 " default:\n" 1178 " {\n" 1179 " return true;\n" 1180 " }\n" 1181 "}", 1182 format("switch (n) {\n" 1183 " case 0: {\n" 1184 " return false;\n" 1185 " }\n" 1186 " default: {\n" 1187 " return true;\n" 1188 " }\n" 1189 "}", 1190 Style)); 1191 Style.BraceWrapping.AfterCaseLabel = false; 1192 EXPECT_EQ("switch (n)\n" 1193 "{\n" 1194 " case 0: {\n" 1195 " return false;\n" 1196 " }\n" 1197 " default: {\n" 1198 " return true;\n" 1199 " }\n" 1200 "}", 1201 format("switch (n) {\n" 1202 " case 0:\n" 1203 " {\n" 1204 " return false;\n" 1205 " }\n" 1206 " default:\n" 1207 " {\n" 1208 " return true;\n" 1209 " }\n" 1210 "}", 1211 Style)); 1212 } 1213 1214 TEST_F(FormatTest, CaseRanges) { 1215 verifyFormat("switch (x) {\n" 1216 "case 'A' ... 'Z':\n" 1217 "case 1 ... 5:\n" 1218 "case a ... b:\n" 1219 " break;\n" 1220 "}"); 1221 } 1222 1223 TEST_F(FormatTest, ShortCaseLabels) { 1224 FormatStyle Style = getLLVMStyle(); 1225 Style.AllowShortCaseLabelsOnASingleLine = true; 1226 verifyFormat("switch (a) {\n" 1227 "case 1: x = 1; break;\n" 1228 "case 2: return;\n" 1229 "case 3:\n" 1230 "case 4:\n" 1231 "case 5: return;\n" 1232 "case 6: // comment\n" 1233 " return;\n" 1234 "case 7:\n" 1235 " // comment\n" 1236 " return;\n" 1237 "case 8:\n" 1238 " x = 8; // comment\n" 1239 " break;\n" 1240 "default: y = 1; break;\n" 1241 "}", 1242 Style); 1243 verifyFormat("switch (a) {\n" 1244 "case 0: return; // comment\n" 1245 "case 1: break; // comment\n" 1246 "case 2: return;\n" 1247 "// comment\n" 1248 "case 3: return;\n" 1249 "// comment 1\n" 1250 "// comment 2\n" 1251 "// comment 3\n" 1252 "case 4: break; /* comment */\n" 1253 "case 5:\n" 1254 " // comment\n" 1255 " break;\n" 1256 "case 6: /* comment */ x = 1; break;\n" 1257 "case 7: x = /* comment */ 1; break;\n" 1258 "case 8:\n" 1259 " x = 1; /* comment */\n" 1260 " break;\n" 1261 "case 9:\n" 1262 " break; // comment line 1\n" 1263 " // comment line 2\n" 1264 "}", 1265 Style); 1266 EXPECT_EQ("switch (a) {\n" 1267 "case 1:\n" 1268 " x = 8;\n" 1269 " // fall through\n" 1270 "case 2: x = 8;\n" 1271 "// comment\n" 1272 "case 3:\n" 1273 " return; /* comment line 1\n" 1274 " * comment line 2 */\n" 1275 "case 4: i = 8;\n" 1276 "// something else\n" 1277 "#if FOO\n" 1278 "case 5: break;\n" 1279 "#endif\n" 1280 "}", 1281 format("switch (a) {\n" 1282 "case 1: x = 8;\n" 1283 " // fall through\n" 1284 "case 2:\n" 1285 " x = 8;\n" 1286 "// comment\n" 1287 "case 3:\n" 1288 " return; /* comment line 1\n" 1289 " * comment line 2 */\n" 1290 "case 4:\n" 1291 " i = 8;\n" 1292 "// something else\n" 1293 "#if FOO\n" 1294 "case 5: break;\n" 1295 "#endif\n" 1296 "}", 1297 Style)); 1298 EXPECT_EQ("switch (a) {\n" "case 0:\n" 1299 " return; // long long long long long long long long long long long long comment\n" 1300 " // line\n" "}", 1301 format("switch (a) {\n" 1302 "case 0: return; // long long long long long long long long long long long long comment line\n" 1303 "}", 1304 Style)); 1305 EXPECT_EQ("switch (a) {\n" 1306 "case 0:\n" 1307 " return; /* long long long long long long long long long long long long comment\n" 1308 " line */\n" 1309 "}", 1310 format("switch (a) {\n" 1311 "case 0: return; /* long long long long long long long long long long long long comment line */\n" 1312 "}", 1313 Style)); 1314 verifyFormat("switch (a) {\n" 1315 "#if FOO\n" 1316 "case 0: return 0;\n" 1317 "#endif\n" 1318 "}", 1319 Style); 1320 verifyFormat("switch (a) {\n" 1321 "case 1: {\n" 1322 "}\n" 1323 "case 2: {\n" 1324 " return;\n" 1325 "}\n" 1326 "case 3: {\n" 1327 " x = 1;\n" 1328 " return;\n" 1329 "}\n" 1330 "case 4:\n" 1331 " if (x)\n" 1332 " return;\n" 1333 "}", 1334 Style); 1335 Style.ColumnLimit = 21; 1336 verifyFormat("switch (a) {\n" 1337 "case 1: x = 1; break;\n" 1338 "case 2: return;\n" 1339 "case 3:\n" 1340 "case 4:\n" 1341 "case 5: return;\n" 1342 "default:\n" 1343 " y = 1;\n" 1344 " break;\n" 1345 "}", 1346 Style); 1347 Style.ColumnLimit = 80; 1348 Style.AllowShortCaseLabelsOnASingleLine = false; 1349 Style.IndentCaseLabels = true; 1350 EXPECT_EQ("switch (n) {\n" 1351 " default /*comments*/:\n" 1352 " return true;\n" 1353 " case 0:\n" 1354 " return false;\n" 1355 "}", 1356 format("switch (n) {\n" 1357 "default/*comments*/:\n" 1358 " return true;\n" 1359 "case 0:\n" 1360 " return false;\n" 1361 "}", 1362 Style)); 1363 Style.AllowShortCaseLabelsOnASingleLine = true; 1364 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1365 Style.BraceWrapping.AfterCaseLabel = true; 1366 Style.BraceWrapping.AfterControlStatement = true; 1367 EXPECT_EQ("switch (n)\n" 1368 "{\n" 1369 " case 0:\n" 1370 " {\n" 1371 " return false;\n" 1372 " }\n" 1373 " default:\n" 1374 " {\n" 1375 " return true;\n" 1376 " }\n" 1377 "}", 1378 format("switch (n) {\n" 1379 " case 0: {\n" 1380 " return false;\n" 1381 " }\n" 1382 " default:\n" 1383 " {\n" 1384 " return true;\n" 1385 " }\n" 1386 "}", 1387 Style)); 1388 } 1389 1390 TEST_F(FormatTest, FormatsLabels) { 1391 verifyFormat("void f() {\n" 1392 " some_code();\n" 1393 "test_label:\n" 1394 " some_other_code();\n" 1395 " {\n" 1396 " some_more_code();\n" 1397 " another_label:\n" 1398 " some_more_code();\n" 1399 " }\n" 1400 "}"); 1401 verifyFormat("{\n" 1402 " some_code();\n" 1403 "test_label:\n" 1404 " some_other_code();\n" 1405 "}"); 1406 verifyFormat("{\n" 1407 " some_code();\n" 1408 "test_label:;\n" 1409 " int i = 0;\n" 1410 "}"); 1411 } 1412 1413 //===----------------------------------------------------------------------===// 1414 // Tests for classes, namespaces, etc. 1415 //===----------------------------------------------------------------------===// 1416 1417 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1418 verifyFormat("class A {};"); 1419 } 1420 1421 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1422 verifyFormat("class A {\n" 1423 "public:\n" 1424 "public: // comment\n" 1425 "protected:\n" 1426 "private:\n" 1427 " void f() {}\n" 1428 "};"); 1429 verifyFormat("export class A {\n" 1430 "public:\n" 1431 "public: // comment\n" 1432 "protected:\n" 1433 "private:\n" 1434 " void f() {}\n" 1435 "};"); 1436 verifyGoogleFormat("class A {\n" 1437 " public:\n" 1438 " protected:\n" 1439 " private:\n" 1440 " void f() {}\n" 1441 "};"); 1442 verifyGoogleFormat("export class A {\n" 1443 " public:\n" 1444 " protected:\n" 1445 " private:\n" 1446 " void f() {}\n" 1447 "};"); 1448 verifyFormat("class A {\n" 1449 "public slots:\n" 1450 " void f1() {}\n" 1451 "public Q_SLOTS:\n" 1452 " void f2() {}\n" 1453 "protected slots:\n" 1454 " void f3() {}\n" 1455 "protected Q_SLOTS:\n" 1456 " void f4() {}\n" 1457 "private slots:\n" 1458 " void f5() {}\n" 1459 "private Q_SLOTS:\n" 1460 " void f6() {}\n" 1461 "signals:\n" 1462 " void g1();\n" 1463 "Q_SIGNALS:\n" 1464 " void g2();\n" 1465 "};"); 1466 1467 // Don't interpret 'signals' the wrong way. 1468 verifyFormat("signals.set();"); 1469 verifyFormat("for (Signals signals : f()) {\n}"); 1470 verifyFormat("{\n" 1471 " signals.set(); // This needs indentation.\n" 1472 "}"); 1473 verifyFormat("void f() {\n" 1474 "label:\n" 1475 " signals.baz();\n" 1476 "}"); 1477 } 1478 1479 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1480 EXPECT_EQ("class A {\n" 1481 "public:\n" 1482 " void f();\n" 1483 "\n" 1484 "private:\n" 1485 " void g() {}\n" 1486 " // test\n" 1487 "protected:\n" 1488 " int h;\n" 1489 "};", 1490 format("class A {\n" 1491 "public:\n" 1492 "void f();\n" 1493 "private:\n" 1494 "void g() {}\n" 1495 "// test\n" 1496 "protected:\n" 1497 "int h;\n" 1498 "};")); 1499 EXPECT_EQ("class A {\n" 1500 "protected:\n" 1501 "public:\n" 1502 " void f();\n" 1503 "};", 1504 format("class A {\n" 1505 "protected:\n" 1506 "\n" 1507 "public:\n" 1508 "\n" 1509 " void f();\n" 1510 "};")); 1511 1512 // Even ensure proper spacing inside macros. 1513 EXPECT_EQ("#define B \\\n" 1514 " class A { \\\n" 1515 " protected: \\\n" 1516 " public: \\\n" 1517 " void f(); \\\n" 1518 " };", 1519 format("#define B \\\n" 1520 " class A { \\\n" 1521 " protected: \\\n" 1522 " \\\n" 1523 " public: \\\n" 1524 " \\\n" 1525 " void f(); \\\n" 1526 " };", 1527 getGoogleStyle())); 1528 // But don't remove empty lines after macros ending in access specifiers. 1529 EXPECT_EQ("#define A private:\n" 1530 "\n" 1531 "int i;", 1532 format("#define A private:\n" 1533 "\n" 1534 "int i;")); 1535 } 1536 1537 TEST_F(FormatTest, FormatsClasses) { 1538 verifyFormat("class A : public B {};"); 1539 verifyFormat("class A : public ::B {};"); 1540 1541 verifyFormat( 1542 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1543 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1544 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1545 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1546 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1547 verifyFormat( 1548 "class A : public B, public C, public D, public E, public F {};"); 1549 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1550 " public C,\n" 1551 " public D,\n" 1552 " public E,\n" 1553 " public F,\n" 1554 " public G {};"); 1555 1556 verifyFormat("class\n" 1557 " ReallyReallyLongClassName {\n" 1558 " int i;\n" 1559 "};", 1560 getLLVMStyleWithColumns(32)); 1561 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1562 " aaaaaaaaaaaaaaaa> {};"); 1563 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1564 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1565 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1566 verifyFormat("template <class R, class C>\n" 1567 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1568 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1569 verifyFormat("class ::A::B {};"); 1570 } 1571 1572 TEST_F(FormatTest, BreakInheritanceStyle) { 1573 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1574 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1575 FormatStyle::BILS_BeforeComma; 1576 verifyFormat("class MyClass : public X {};", 1577 StyleWithInheritanceBreakBeforeComma); 1578 verifyFormat("class MyClass\n" 1579 " : public X\n" 1580 " , public Y {};", 1581 StyleWithInheritanceBreakBeforeComma); 1582 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1583 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1584 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1585 StyleWithInheritanceBreakBeforeComma); 1586 verifyFormat("struct aaaaaaaaaaaaa\n" 1587 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1588 " aaaaaaaaaaaaaaaa> {};", 1589 StyleWithInheritanceBreakBeforeComma); 1590 1591 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1592 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1593 FormatStyle::BILS_AfterColon; 1594 verifyFormat("class MyClass : public X {};", 1595 StyleWithInheritanceBreakAfterColon); 1596 verifyFormat("class MyClass : public X, public Y {};", 1597 StyleWithInheritanceBreakAfterColon); 1598 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1599 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1600 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1601 StyleWithInheritanceBreakAfterColon); 1602 verifyFormat("struct aaaaaaaaaaaaa :\n" 1603 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1604 " aaaaaaaaaaaaaaaa> {};", 1605 StyleWithInheritanceBreakAfterColon); 1606 } 1607 1608 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1609 verifyFormat("class A {\n} a, b;"); 1610 verifyFormat("struct A {\n} a, b;"); 1611 verifyFormat("union A {\n} a;"); 1612 } 1613 1614 TEST_F(FormatTest, FormatsEnum) { 1615 verifyFormat("enum {\n" 1616 " Zero,\n" 1617 " One = 1,\n" 1618 " Two = One + 1,\n" 1619 " Three = (One + Two),\n" 1620 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1621 " Five = (One, Two, Three, Four, 5)\n" 1622 "};"); 1623 verifyGoogleFormat("enum {\n" 1624 " Zero,\n" 1625 " One = 1,\n" 1626 " Two = One + 1,\n" 1627 " Three = (One + Two),\n" 1628 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1629 " Five = (One, Two, Three, Four, 5)\n" 1630 "};"); 1631 verifyFormat("enum Enum {};"); 1632 verifyFormat("enum {};"); 1633 verifyFormat("enum X E {} d;"); 1634 verifyFormat("enum __attribute__((...)) E {} d;"); 1635 verifyFormat("enum __declspec__((...)) E {} d;"); 1636 verifyFormat("enum {\n" 1637 " Bar = Foo<int, int>::value\n" 1638 "};", 1639 getLLVMStyleWithColumns(30)); 1640 1641 verifyFormat("enum ShortEnum { A, B, C };"); 1642 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1643 1644 EXPECT_EQ("enum KeepEmptyLines {\n" 1645 " ONE,\n" 1646 "\n" 1647 " TWO,\n" 1648 "\n" 1649 " THREE\n" 1650 "}", 1651 format("enum KeepEmptyLines {\n" 1652 " ONE,\n" 1653 "\n" 1654 " TWO,\n" 1655 "\n" 1656 "\n" 1657 " THREE\n" 1658 "}")); 1659 verifyFormat("enum E { // comment\n" 1660 " ONE,\n" 1661 " TWO\n" 1662 "};\n" 1663 "int i;"); 1664 // Not enums. 1665 verifyFormat("enum X f() {\n" 1666 " a();\n" 1667 " return 42;\n" 1668 "}"); 1669 verifyFormat("enum X Type::f() {\n" 1670 " a();\n" 1671 " return 42;\n" 1672 "}"); 1673 verifyFormat("enum ::X f() {\n" 1674 " a();\n" 1675 " return 42;\n" 1676 "}"); 1677 verifyFormat("enum ns::X f() {\n" 1678 " a();\n" 1679 " return 42;\n" 1680 "}"); 1681 } 1682 1683 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1684 verifyFormat("enum Type {\n" 1685 " One = 0; // These semicolons should be commas.\n" 1686 " Two = 1;\n" 1687 "};"); 1688 verifyFormat("namespace n {\n" 1689 "enum Type {\n" 1690 " One,\n" 1691 " Two, // missing };\n" 1692 " int i;\n" 1693 "}\n" 1694 "void g() {}"); 1695 } 1696 1697 TEST_F(FormatTest, FormatsEnumStruct) { 1698 verifyFormat("enum struct {\n" 1699 " Zero,\n" 1700 " One = 1,\n" 1701 " Two = One + 1,\n" 1702 " Three = (One + Two),\n" 1703 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1704 " Five = (One, Two, Three, Four, 5)\n" 1705 "};"); 1706 verifyFormat("enum struct Enum {};"); 1707 verifyFormat("enum struct {};"); 1708 verifyFormat("enum struct X E {} d;"); 1709 verifyFormat("enum struct __attribute__((...)) E {} d;"); 1710 verifyFormat("enum struct __declspec__((...)) E {} d;"); 1711 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1712 } 1713 1714 TEST_F(FormatTest, FormatsEnumClass) { 1715 verifyFormat("enum class {\n" 1716 " Zero,\n" 1717 " One = 1,\n" 1718 " Two = One + 1,\n" 1719 " Three = (One + Two),\n" 1720 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1721 " Five = (One, Two, Three, Four, 5)\n" 1722 "};"); 1723 verifyFormat("enum class Enum {};"); 1724 verifyFormat("enum class {};"); 1725 verifyFormat("enum class X E {} d;"); 1726 verifyFormat("enum class __attribute__((...)) E {} d;"); 1727 verifyFormat("enum class __declspec__((...)) E {} d;"); 1728 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 1729 } 1730 1731 TEST_F(FormatTest, FormatsEnumTypes) { 1732 verifyFormat("enum X : int {\n" 1733 " A, // Force multiple lines.\n" 1734 " B\n" 1735 "};"); 1736 verifyFormat("enum X : int { A, B };"); 1737 verifyFormat("enum X : std::uint32_t { A, B };"); 1738 } 1739 1740 TEST_F(FormatTest, FormatsTypedefEnum) { 1741 FormatStyle Style = getLLVMStyle(); 1742 Style.ColumnLimit = 40; 1743 verifyFormat("typedef enum {} EmptyEnum;"); 1744 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1745 verifyFormat("typedef enum {\n" 1746 " ZERO = 0,\n" 1747 " ONE = 1,\n" 1748 " TWO = 2,\n" 1749 " THREE = 3\n" 1750 "} LongEnum;", 1751 Style); 1752 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1753 Style.BraceWrapping.AfterEnum = true; 1754 verifyFormat("typedef enum {} EmptyEnum;"); 1755 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1756 verifyFormat("typedef enum\n" 1757 "{\n" 1758 " ZERO = 0,\n" 1759 " ONE = 1,\n" 1760 " TWO = 2,\n" 1761 " THREE = 3\n" 1762 "} LongEnum;", 1763 Style); 1764 } 1765 1766 TEST_F(FormatTest, FormatsNSEnums) { 1767 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1768 verifyGoogleFormat( 1769 "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1770 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 1771 " // Information about someDecentlyLongValue.\n" 1772 " someDecentlyLongValue,\n" 1773 " // Information about anotherDecentlyLongValue.\n" 1774 " anotherDecentlyLongValue,\n" 1775 " // Information about aThirdDecentlyLongValue.\n" 1776 " aThirdDecentlyLongValue\n" 1777 "};"); 1778 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n" 1779 " // Information about someDecentlyLongValue.\n" 1780 " someDecentlyLongValue,\n" 1781 " // Information about anotherDecentlyLongValue.\n" 1782 " anotherDecentlyLongValue,\n" 1783 " // Information about aThirdDecentlyLongValue.\n" 1784 " aThirdDecentlyLongValue\n" 1785 "};"); 1786 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 1787 " a = 1,\n" 1788 " b = 2,\n" 1789 " c = 3,\n" 1790 "};"); 1791 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 1792 " a = 1,\n" 1793 " b = 2,\n" 1794 " c = 3,\n" 1795 "};"); 1796 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n" 1797 " a = 1,\n" 1798 " b = 2,\n" 1799 " c = 3,\n" 1800 "};"); 1801 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 1802 " a = 1,\n" 1803 " b = 2,\n" 1804 " c = 3,\n" 1805 "};"); 1806 } 1807 1808 TEST_F(FormatTest, FormatsBitfields) { 1809 verifyFormat("struct Bitfields {\n" 1810 " unsigned sClass : 8;\n" 1811 " unsigned ValueKind : 2;\n" 1812 "};"); 1813 verifyFormat("struct A {\n" 1814 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 1815 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 1816 "};"); 1817 verifyFormat("struct MyStruct {\n" 1818 " uchar data;\n" 1819 " uchar : 8;\n" 1820 " uchar : 8;\n" 1821 " uchar other;\n" 1822 "};"); 1823 } 1824 1825 TEST_F(FormatTest, FormatsNamespaces) { 1826 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 1827 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 1828 1829 verifyFormat("namespace some_namespace {\n" 1830 "class A {};\n" 1831 "void f() { f(); }\n" 1832 "}", 1833 LLVMWithNoNamespaceFix); 1834 verifyFormat("namespace N::inline D {\n" 1835 "class A {};\n" 1836 "void f() { f(); }\n" 1837 "}", 1838 LLVMWithNoNamespaceFix); 1839 verifyFormat("namespace N::inline D::E {\n" 1840 "class A {};\n" 1841 "void f() { f(); }\n" 1842 "}", 1843 LLVMWithNoNamespaceFix); 1844 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n" 1845 "class A {};\n" 1846 "void f() { f(); }\n" 1847 "}", 1848 LLVMWithNoNamespaceFix); 1849 verifyFormat("/* something */ namespace some_namespace {\n" 1850 "class A {};\n" 1851 "void f() { f(); }\n" 1852 "}", 1853 LLVMWithNoNamespaceFix); 1854 verifyFormat("namespace {\n" 1855 "class A {};\n" 1856 "void f() { f(); }\n" 1857 "}", 1858 LLVMWithNoNamespaceFix); 1859 verifyFormat("/* something */ namespace {\n" 1860 "class A {};\n" 1861 "void f() { f(); }\n" 1862 "}", 1863 LLVMWithNoNamespaceFix); 1864 verifyFormat("inline namespace X {\n" 1865 "class A {};\n" 1866 "void f() { f(); }\n" 1867 "}", 1868 LLVMWithNoNamespaceFix); 1869 verifyFormat("/* something */ inline namespace X {\n" 1870 "class A {};\n" 1871 "void f() { f(); }\n" 1872 "}", 1873 LLVMWithNoNamespaceFix); 1874 verifyFormat("export namespace X {\n" 1875 "class A {};\n" 1876 "void f() { f(); }\n" 1877 "}", 1878 LLVMWithNoNamespaceFix); 1879 verifyFormat("using namespace some_namespace;\n" 1880 "class A {};\n" 1881 "void f() { f(); }", 1882 LLVMWithNoNamespaceFix); 1883 1884 // This code is more common than we thought; if we 1885 // layout this correctly the semicolon will go into 1886 // its own line, which is undesirable. 1887 verifyFormat("namespace {};", 1888 LLVMWithNoNamespaceFix); 1889 verifyFormat("namespace {\n" 1890 "class A {};\n" 1891 "};", 1892 LLVMWithNoNamespaceFix); 1893 1894 verifyFormat("namespace {\n" 1895 "int SomeVariable = 0; // comment\n" 1896 "} // namespace", 1897 LLVMWithNoNamespaceFix); 1898 EXPECT_EQ("#ifndef HEADER_GUARD\n" 1899 "#define HEADER_GUARD\n" 1900 "namespace my_namespace {\n" 1901 "int i;\n" 1902 "} // my_namespace\n" 1903 "#endif // HEADER_GUARD", 1904 format("#ifndef HEADER_GUARD\n" 1905 " #define HEADER_GUARD\n" 1906 " namespace my_namespace {\n" 1907 "int i;\n" 1908 "} // my_namespace\n" 1909 "#endif // HEADER_GUARD", 1910 LLVMWithNoNamespaceFix)); 1911 1912 EXPECT_EQ("namespace A::B {\n" 1913 "class C {};\n" 1914 "}", 1915 format("namespace A::B {\n" 1916 "class C {};\n" 1917 "}", 1918 LLVMWithNoNamespaceFix)); 1919 1920 FormatStyle Style = getLLVMStyle(); 1921 Style.NamespaceIndentation = FormatStyle::NI_All; 1922 EXPECT_EQ("namespace out {\n" 1923 " int i;\n" 1924 " namespace in {\n" 1925 " int i;\n" 1926 " } // namespace in\n" 1927 "} // namespace out", 1928 format("namespace out {\n" 1929 "int i;\n" 1930 "namespace in {\n" 1931 "int i;\n" 1932 "} // namespace in\n" 1933 "} // namespace out", 1934 Style)); 1935 1936 Style.NamespaceIndentation = FormatStyle::NI_Inner; 1937 EXPECT_EQ("namespace out {\n" 1938 "int i;\n" 1939 "namespace in {\n" 1940 " int i;\n" 1941 "} // namespace in\n" 1942 "} // namespace out", 1943 format("namespace out {\n" 1944 "int i;\n" 1945 "namespace in {\n" 1946 "int i;\n" 1947 "} // namespace in\n" 1948 "} // namespace out", 1949 Style)); 1950 } 1951 1952 TEST_F(FormatTest, NamespaceMacros) { 1953 FormatStyle Style = getLLVMStyle(); 1954 Style.NamespaceMacros.push_back("TESTSUITE"); 1955 1956 verifyFormat("TESTSUITE(A) {\n" 1957 "int foo();\n" 1958 "} // TESTSUITE(A)", 1959 Style); 1960 1961 verifyFormat("TESTSUITE(A, B) {\n" 1962 "int foo();\n" 1963 "} // TESTSUITE(A)", 1964 Style); 1965 1966 // Properly indent according to NamespaceIndentation style 1967 Style.NamespaceIndentation = FormatStyle::NI_All; 1968 verifyFormat("TESTSUITE(A) {\n" 1969 " int foo();\n" 1970 "} // TESTSUITE(A)", 1971 Style); 1972 verifyFormat("TESTSUITE(A) {\n" 1973 " namespace B {\n" 1974 " int foo();\n" 1975 " } // namespace B\n" 1976 "} // TESTSUITE(A)", 1977 Style); 1978 verifyFormat("namespace A {\n" 1979 " TESTSUITE(B) {\n" 1980 " int foo();\n" 1981 " } // TESTSUITE(B)\n" 1982 "} // namespace A", 1983 Style); 1984 1985 Style.NamespaceIndentation = FormatStyle::NI_Inner; 1986 verifyFormat("TESTSUITE(A) {\n" 1987 "TESTSUITE(B) {\n" 1988 " int foo();\n" 1989 "} // TESTSUITE(B)\n" 1990 "} // TESTSUITE(A)", 1991 Style); 1992 verifyFormat("TESTSUITE(A) {\n" 1993 "namespace B {\n" 1994 " int foo();\n" 1995 "} // namespace B\n" 1996 "} // TESTSUITE(A)", 1997 Style); 1998 verifyFormat("namespace A {\n" 1999 "TESTSUITE(B) {\n" 2000 " int foo();\n" 2001 "} // TESTSUITE(B)\n" 2002 "} // namespace A", 2003 Style); 2004 2005 // Properly merge namespace-macros blocks in CompactNamespaces mode 2006 Style.NamespaceIndentation = FormatStyle::NI_None; 2007 Style.CompactNamespaces = true; 2008 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n" 2009 "}} // TESTSUITE(A::B)", 2010 Style); 2011 2012 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2013 "}} // TESTSUITE(out::in)", 2014 format("TESTSUITE(out) {\n" 2015 "TESTSUITE(in) {\n" 2016 "} // TESTSUITE(in)\n" 2017 "} // TESTSUITE(out)", 2018 Style)); 2019 2020 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2021 "}} // TESTSUITE(out::in)", 2022 format("TESTSUITE(out) {\n" 2023 "TESTSUITE(in) {\n" 2024 "} // TESTSUITE(in)\n" 2025 "} // TESTSUITE(out)", 2026 Style)); 2027 2028 // Do not merge different namespaces/macros 2029 EXPECT_EQ("namespace out {\n" 2030 "TESTSUITE(in) {\n" 2031 "} // TESTSUITE(in)\n" 2032 "} // namespace out", 2033 format("namespace out {\n" 2034 "TESTSUITE(in) {\n" 2035 "} // TESTSUITE(in)\n" 2036 "} // namespace out", 2037 Style)); 2038 EXPECT_EQ("TESTSUITE(out) {\n" 2039 "namespace in {\n" 2040 "} // namespace in\n" 2041 "} // TESTSUITE(out)", 2042 format("TESTSUITE(out) {\n" 2043 "namespace in {\n" 2044 "} // namespace in\n" 2045 "} // TESTSUITE(out)", 2046 Style)); 2047 Style.NamespaceMacros.push_back("FOOBAR"); 2048 EXPECT_EQ("TESTSUITE(out) {\n" 2049 "FOOBAR(in) {\n" 2050 "} // FOOBAR(in)\n" 2051 "} // TESTSUITE(out)", 2052 format("TESTSUITE(out) {\n" 2053 "FOOBAR(in) {\n" 2054 "} // FOOBAR(in)\n" 2055 "} // TESTSUITE(out)", 2056 Style)); 2057 } 2058 2059 TEST_F(FormatTest, FormatsCompactNamespaces) { 2060 FormatStyle Style = getLLVMStyle(); 2061 Style.CompactNamespaces = true; 2062 Style.NamespaceMacros.push_back("TESTSUITE"); 2063 2064 verifyFormat("namespace A { namespace B {\n" 2065 "}} // namespace A::B", 2066 Style); 2067 2068 EXPECT_EQ("namespace out { namespace in {\n" 2069 "}} // namespace out::in", 2070 format("namespace out {\n" 2071 "namespace in {\n" 2072 "} // namespace in\n" 2073 "} // namespace out", 2074 Style)); 2075 2076 // Only namespaces which have both consecutive opening and end get compacted 2077 EXPECT_EQ("namespace out {\n" 2078 "namespace in1 {\n" 2079 "} // namespace in1\n" 2080 "namespace in2 {\n" 2081 "} // namespace in2\n" 2082 "} // namespace out", 2083 format("namespace out {\n" 2084 "namespace in1 {\n" 2085 "} // namespace in1\n" 2086 "namespace in2 {\n" 2087 "} // namespace in2\n" 2088 "} // namespace out", 2089 Style)); 2090 2091 EXPECT_EQ("namespace out {\n" 2092 "int i;\n" 2093 "namespace in {\n" 2094 "int j;\n" 2095 "} // namespace in\n" 2096 "int k;\n" 2097 "} // namespace out", 2098 format("namespace out { int i;\n" 2099 "namespace in { int j; } // namespace in\n" 2100 "int k; } // namespace out", 2101 Style)); 2102 2103 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 2104 "}}} // namespace A::B::C\n", 2105 format("namespace A { namespace B {\n" 2106 "namespace C {\n" 2107 "}} // namespace B::C\n" 2108 "} // namespace A\n", 2109 Style)); 2110 2111 Style.ColumnLimit = 40; 2112 EXPECT_EQ("namespace aaaaaaaaaa {\n" 2113 "namespace bbbbbbbbbb {\n" 2114 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 2115 format("namespace aaaaaaaaaa {\n" 2116 "namespace bbbbbbbbbb {\n" 2117 "} // namespace bbbbbbbbbb\n" 2118 "} // namespace aaaaaaaaaa", 2119 Style)); 2120 2121 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 2122 "namespace cccccc {\n" 2123 "}}} // namespace aaaaaa::bbbbbb::cccccc", 2124 format("namespace aaaaaa {\n" 2125 "namespace bbbbbb {\n" 2126 "namespace cccccc {\n" 2127 "} // namespace cccccc\n" 2128 "} // namespace bbbbbb\n" 2129 "} // namespace aaaaaa", 2130 Style)); 2131 Style.ColumnLimit = 80; 2132 2133 // Extra semicolon after 'inner' closing brace prevents merging 2134 EXPECT_EQ("namespace out { namespace in {\n" 2135 "}; } // namespace out::in", 2136 format("namespace out {\n" 2137 "namespace in {\n" 2138 "}; // namespace in\n" 2139 "} // namespace out", 2140 Style)); 2141 2142 // Extra semicolon after 'outer' closing brace is conserved 2143 EXPECT_EQ("namespace out { namespace in {\n" 2144 "}}; // namespace out::in", 2145 format("namespace out {\n" 2146 "namespace in {\n" 2147 "} // namespace in\n" 2148 "}; // namespace out", 2149 Style)); 2150 2151 Style.NamespaceIndentation = FormatStyle::NI_All; 2152 EXPECT_EQ("namespace out { namespace in {\n" 2153 " int i;\n" 2154 "}} // namespace out::in", 2155 format("namespace out {\n" 2156 "namespace in {\n" 2157 "int i;\n" 2158 "} // namespace in\n" 2159 "} // namespace out", 2160 Style)); 2161 EXPECT_EQ("namespace out { namespace mid {\n" 2162 " namespace in {\n" 2163 " int j;\n" 2164 " } // namespace in\n" 2165 " int k;\n" 2166 "}} // namespace out::mid", 2167 format("namespace out { namespace mid {\n" 2168 "namespace in { int j; } // namespace in\n" 2169 "int k; }} // namespace out::mid", 2170 Style)); 2171 2172 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2173 EXPECT_EQ("namespace out { namespace in {\n" 2174 " int i;\n" 2175 "}} // namespace out::in", 2176 format("namespace out {\n" 2177 "namespace in {\n" 2178 "int i;\n" 2179 "} // namespace in\n" 2180 "} // namespace out", 2181 Style)); 2182 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 2183 " int i;\n" 2184 "}}} // namespace out::mid::in", 2185 format("namespace out {\n" 2186 "namespace mid {\n" 2187 "namespace in {\n" 2188 "int i;\n" 2189 "} // namespace in\n" 2190 "} // namespace mid\n" 2191 "} // namespace out", 2192 Style)); 2193 } 2194 2195 TEST_F(FormatTest, FormatsExternC) { 2196 verifyFormat("extern \"C\" {\nint a;"); 2197 verifyFormat("extern \"C\" {}"); 2198 verifyFormat("extern \"C\" {\n" 2199 "int foo();\n" 2200 "}"); 2201 verifyFormat("extern \"C\" int foo() {}"); 2202 verifyFormat("extern \"C\" int foo();"); 2203 verifyFormat("extern \"C\" int foo() {\n" 2204 " int i = 42;\n" 2205 " return i;\n" 2206 "}"); 2207 2208 FormatStyle Style = getLLVMStyle(); 2209 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2210 Style.BraceWrapping.AfterFunction = true; 2211 verifyFormat("extern \"C\" int foo() {}", Style); 2212 verifyFormat("extern \"C\" int foo();", Style); 2213 verifyFormat("extern \"C\" int foo()\n" 2214 "{\n" 2215 " int i = 42;\n" 2216 " return i;\n" 2217 "}", 2218 Style); 2219 2220 Style.BraceWrapping.AfterExternBlock = true; 2221 Style.BraceWrapping.SplitEmptyRecord = false; 2222 verifyFormat("extern \"C\"\n" 2223 "{}", 2224 Style); 2225 verifyFormat("extern \"C\"\n" 2226 "{\n" 2227 " int foo();\n" 2228 "}", 2229 Style); 2230 } 2231 2232 TEST_F(FormatTest, FormatsInlineASM) { 2233 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2234 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2235 verifyFormat( 2236 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2237 " \"cpuid\\n\\t\"\n" 2238 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2239 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2240 " : \"a\"(value));"); 2241 EXPECT_EQ( 2242 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2243 " __asm {\n" 2244 " mov edx,[that] // vtable in edx\n" 2245 " mov eax,methodIndex\n" 2246 " call [edx][eax*4] // stdcall\n" 2247 " }\n" 2248 "}", 2249 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2250 " __asm {\n" 2251 " mov edx,[that] // vtable in edx\n" 2252 " mov eax,methodIndex\n" 2253 " call [edx][eax*4] // stdcall\n" 2254 " }\n" 2255 "}")); 2256 EXPECT_EQ("_asm {\n" 2257 " xor eax, eax;\n" 2258 " cpuid;\n" 2259 "}", 2260 format("_asm {\n" 2261 " xor eax, eax;\n" 2262 " cpuid;\n" 2263 "}")); 2264 verifyFormat("void function() {\n" 2265 " // comment\n" 2266 " asm(\"\");\n" 2267 "}"); 2268 EXPECT_EQ("__asm {\n" 2269 "}\n" 2270 "int i;", 2271 format("__asm {\n" 2272 "}\n" 2273 "int i;")); 2274 } 2275 2276 TEST_F(FormatTest, FormatTryCatch) { 2277 verifyFormat("try {\n" 2278 " throw a * b;\n" 2279 "} catch (int a) {\n" 2280 " // Do nothing.\n" 2281 "} catch (...) {\n" 2282 " exit(42);\n" 2283 "}"); 2284 2285 // Function-level try statements. 2286 verifyFormat("int f() try { return 4; } catch (...) {\n" 2287 " return 5;\n" 2288 "}"); 2289 verifyFormat("class A {\n" 2290 " int a;\n" 2291 " A() try : a(0) {\n" 2292 " } catch (...) {\n" 2293 " throw;\n" 2294 " }\n" 2295 "};\n"); 2296 2297 // Incomplete try-catch blocks. 2298 verifyIncompleteFormat("try {} catch ("); 2299 } 2300 2301 TEST_F(FormatTest, FormatSEHTryCatch) { 2302 verifyFormat("__try {\n" 2303 " int a = b * c;\n" 2304 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2305 " // Do nothing.\n" 2306 "}"); 2307 2308 verifyFormat("__try {\n" 2309 " int a = b * c;\n" 2310 "} __finally {\n" 2311 " // Do nothing.\n" 2312 "}"); 2313 2314 verifyFormat("DEBUG({\n" 2315 " __try {\n" 2316 " } __finally {\n" 2317 " }\n" 2318 "});\n"); 2319 } 2320 2321 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2322 verifyFormat("try {\n" 2323 " f();\n" 2324 "} catch {\n" 2325 " g();\n" 2326 "}"); 2327 verifyFormat("try {\n" 2328 " f();\n" 2329 "} catch (A a) MACRO(x) {\n" 2330 " g();\n" 2331 "} catch (B b) MACRO(x) {\n" 2332 " g();\n" 2333 "}"); 2334 } 2335 2336 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2337 FormatStyle Style = getLLVMStyle(); 2338 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2339 FormatStyle::BS_WebKit}) { 2340 Style.BreakBeforeBraces = BraceStyle; 2341 verifyFormat("try {\n" 2342 " // something\n" 2343 "} catch (...) {\n" 2344 " // something\n" 2345 "}", 2346 Style); 2347 } 2348 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2349 verifyFormat("try {\n" 2350 " // something\n" 2351 "}\n" 2352 "catch (...) {\n" 2353 " // something\n" 2354 "}", 2355 Style); 2356 verifyFormat("__try {\n" 2357 " // something\n" 2358 "}\n" 2359 "__finally {\n" 2360 " // something\n" 2361 "}", 2362 Style); 2363 verifyFormat("@try {\n" 2364 " // something\n" 2365 "}\n" 2366 "@finally {\n" 2367 " // something\n" 2368 "}", 2369 Style); 2370 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2371 verifyFormat("try\n" 2372 "{\n" 2373 " // something\n" 2374 "}\n" 2375 "catch (...)\n" 2376 "{\n" 2377 " // something\n" 2378 "}", 2379 Style); 2380 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2381 verifyFormat("try\n" 2382 " {\n" 2383 " // something\n" 2384 " }\n" 2385 "catch (...)\n" 2386 " {\n" 2387 " // something\n" 2388 " }", 2389 Style); 2390 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2391 Style.BraceWrapping.BeforeCatch = true; 2392 verifyFormat("try {\n" 2393 " // something\n" 2394 "}\n" 2395 "catch (...) {\n" 2396 " // something\n" 2397 "}", 2398 Style); 2399 } 2400 2401 TEST_F(FormatTest, StaticInitializers) { 2402 verifyFormat("static SomeClass SC = {1, 'a'};"); 2403 2404 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2405 " 100000000, " 2406 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2407 2408 // Here, everything other than the "}" would fit on a line. 2409 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2410 " 10000000000000000000000000};"); 2411 EXPECT_EQ("S s = {a,\n" 2412 "\n" 2413 " b};", 2414 format("S s = {\n" 2415 " a,\n" 2416 "\n" 2417 " b\n" 2418 "};")); 2419 2420 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2421 // line. However, the formatting looks a bit off and this probably doesn't 2422 // happen often in practice. 2423 verifyFormat("static int Variable[1] = {\n" 2424 " {1000000000000000000000000000000000000}};", 2425 getLLVMStyleWithColumns(40)); 2426 } 2427 2428 TEST_F(FormatTest, DesignatedInitializers) { 2429 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2430 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2431 " .bbbbbbbbbb = 2,\n" 2432 " .cccccccccc = 3,\n" 2433 " .dddddddddd = 4,\n" 2434 " .eeeeeeeeee = 5};"); 2435 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2436 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2437 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2438 " .ccccccccccccccccccccccccccc = 3,\n" 2439 " .ddddddddddddddddddddddddddd = 4,\n" 2440 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2441 2442 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2443 2444 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2445 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2446 " [2] = bbbbbbbbbb,\n" 2447 " [3] = cccccccccc,\n" 2448 " [4] = dddddddddd,\n" 2449 " [5] = eeeeeeeeee};"); 2450 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2451 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2452 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2453 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2454 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2455 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2456 } 2457 2458 TEST_F(FormatTest, NestedStaticInitializers) { 2459 verifyFormat("static A x = {{{}}};\n"); 2460 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2461 " {init1, init2, init3, init4}}};", 2462 getLLVMStyleWithColumns(50)); 2463 2464 verifyFormat("somes Status::global_reps[3] = {\n" 2465 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2466 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2467 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2468 getLLVMStyleWithColumns(60)); 2469 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2470 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2471 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2472 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2473 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2474 " {rect.fRight - rect.fLeft, rect.fBottom - " 2475 "rect.fTop}};"); 2476 2477 verifyFormat( 2478 "SomeArrayOfSomeType a = {\n" 2479 " {{1, 2, 3},\n" 2480 " {1, 2, 3},\n" 2481 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2482 " 333333333333333333333333333333},\n" 2483 " {1, 2, 3},\n" 2484 " {1, 2, 3}}};"); 2485 verifyFormat( 2486 "SomeArrayOfSomeType a = {\n" 2487 " {{1, 2, 3}},\n" 2488 " {{1, 2, 3}},\n" 2489 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2490 " 333333333333333333333333333333}},\n" 2491 " {{1, 2, 3}},\n" 2492 " {{1, 2, 3}}};"); 2493 2494 verifyFormat("struct {\n" 2495 " unsigned bit;\n" 2496 " const char *const name;\n" 2497 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2498 " {kOsWin, \"Windows\"},\n" 2499 " {kOsLinux, \"Linux\"},\n" 2500 " {kOsCrOS, \"Chrome OS\"}};"); 2501 verifyFormat("struct {\n" 2502 " unsigned bit;\n" 2503 " const char *const name;\n" 2504 "} kBitsToOs[] = {\n" 2505 " {kOsMac, \"Mac\"},\n" 2506 " {kOsWin, \"Windows\"},\n" 2507 " {kOsLinux, \"Linux\"},\n" 2508 " {kOsCrOS, \"Chrome OS\"},\n" 2509 "};"); 2510 } 2511 2512 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2513 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2514 " \\\n" 2515 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2516 } 2517 2518 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2519 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2520 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2521 2522 // Do break defaulted and deleted functions. 2523 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2524 " default;", 2525 getLLVMStyleWithColumns(40)); 2526 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2527 " delete;", 2528 getLLVMStyleWithColumns(40)); 2529 } 2530 2531 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2532 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2533 getLLVMStyleWithColumns(40)); 2534 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2535 getLLVMStyleWithColumns(40)); 2536 EXPECT_EQ("#define Q \\\n" 2537 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2538 " \"aaaaaaaa.cpp\"", 2539 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2540 getLLVMStyleWithColumns(40))); 2541 } 2542 2543 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2544 EXPECT_EQ("# 123 \"A string literal\"", 2545 format(" # 123 \"A string literal\"")); 2546 } 2547 2548 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2549 EXPECT_EQ("#;", format("#;")); 2550 verifyFormat("#\n;\n;\n;"); 2551 } 2552 2553 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2554 EXPECT_EQ("#line 42 \"test\"\n", 2555 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2556 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2557 getLLVMStyleWithColumns(12))); 2558 } 2559 2560 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2561 EXPECT_EQ("#line 42 \"test\"", 2562 format("# \\\n line \\\n 42 \\\n \"test\"")); 2563 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2564 } 2565 2566 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2567 verifyFormat("#define A \\x20"); 2568 verifyFormat("#define A \\ x20"); 2569 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2570 verifyFormat("#define A ''"); 2571 verifyFormat("#define A ''qqq"); 2572 verifyFormat("#define A `qqq"); 2573 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2574 EXPECT_EQ("const char *c = STRINGIFY(\n" 2575 "\\na : b);", 2576 format("const char * c = STRINGIFY(\n" 2577 "\\na : b);")); 2578 2579 verifyFormat("a\r\\"); 2580 verifyFormat("a\v\\"); 2581 verifyFormat("a\f\\"); 2582 } 2583 2584 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2585 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2586 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2587 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2588 // FIXME: We never break before the macro name. 2589 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2590 2591 verifyFormat("#define A A\n#define A A"); 2592 verifyFormat("#define A(X) A\n#define A A"); 2593 2594 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2595 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2596 } 2597 2598 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2599 EXPECT_EQ("// somecomment\n" 2600 "#include \"a.h\"\n" 2601 "#define A( \\\n" 2602 " A, B)\n" 2603 "#include \"b.h\"\n" 2604 "// somecomment\n", 2605 format(" // somecomment\n" 2606 " #include \"a.h\"\n" 2607 "#define A(A,\\\n" 2608 " B)\n" 2609 " #include \"b.h\"\n" 2610 " // somecomment\n", 2611 getLLVMStyleWithColumns(13))); 2612 } 2613 2614 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2615 2616 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2617 EXPECT_EQ("#define A \\\n" 2618 " c; \\\n" 2619 " e;\n" 2620 "f;", 2621 format("#define A c; e;\n" 2622 "f;", 2623 getLLVMStyleWithColumns(14))); 2624 } 2625 2626 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2627 2628 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2629 EXPECT_EQ("int x,\n" 2630 "#define A\n" 2631 " y;", 2632 format("int x,\n#define A\ny;")); 2633 } 2634 2635 TEST_F(FormatTest, HashInMacroDefinition) { 2636 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2637 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2638 verifyFormat("#define A \\\n" 2639 " { \\\n" 2640 " f(#c); \\\n" 2641 " }", 2642 getLLVMStyleWithColumns(11)); 2643 2644 verifyFormat("#define A(X) \\\n" 2645 " void function##X()", 2646 getLLVMStyleWithColumns(22)); 2647 2648 verifyFormat("#define A(a, b, c) \\\n" 2649 " void a##b##c()", 2650 getLLVMStyleWithColumns(22)); 2651 2652 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2653 } 2654 2655 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2656 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2657 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2658 2659 FormatStyle Style = getLLVMStyle(); 2660 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 2661 verifyFormat("#define true ((foo)1)", Style); 2662 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 2663 verifyFormat("#define false((foo)0)", Style); 2664 } 2665 2666 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2667 EXPECT_EQ("#define A b;", format("#define A \\\n" 2668 " \\\n" 2669 " b;", 2670 getLLVMStyleWithColumns(25))); 2671 EXPECT_EQ("#define A \\\n" 2672 " \\\n" 2673 " a; \\\n" 2674 " b;", 2675 format("#define A \\\n" 2676 " \\\n" 2677 " a; \\\n" 2678 " b;", 2679 getLLVMStyleWithColumns(11))); 2680 EXPECT_EQ("#define A \\\n" 2681 " a; \\\n" 2682 " \\\n" 2683 " b;", 2684 format("#define A \\\n" 2685 " a; \\\n" 2686 " \\\n" 2687 " b;", 2688 getLLVMStyleWithColumns(11))); 2689 } 2690 2691 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 2692 verifyIncompleteFormat("#define A :"); 2693 verifyFormat("#define SOMECASES \\\n" 2694 " case 1: \\\n" 2695 " case 2\n", 2696 getLLVMStyleWithColumns(20)); 2697 verifyFormat("#define MACRO(a) \\\n" 2698 " if (a) \\\n" 2699 " f(); \\\n" 2700 " else \\\n" 2701 " g()", 2702 getLLVMStyleWithColumns(18)); 2703 verifyFormat("#define A template <typename T>"); 2704 verifyIncompleteFormat("#define STR(x) #x\n" 2705 "f(STR(this_is_a_string_literal{));"); 2706 verifyFormat("#pragma omp threadprivate( \\\n" 2707 " y)), // expected-warning", 2708 getLLVMStyleWithColumns(28)); 2709 verifyFormat("#d, = };"); 2710 verifyFormat("#if \"a"); 2711 verifyIncompleteFormat("({\n" 2712 "#define b \\\n" 2713 " } \\\n" 2714 " a\n" 2715 "a", 2716 getLLVMStyleWithColumns(15)); 2717 verifyFormat("#define A \\\n" 2718 " { \\\n" 2719 " {\n" 2720 "#define B \\\n" 2721 " } \\\n" 2722 " }", 2723 getLLVMStyleWithColumns(15)); 2724 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 2725 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 2726 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 2727 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 2728 } 2729 2730 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 2731 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 2732 EXPECT_EQ("class A : public QObject {\n" 2733 " Q_OBJECT\n" 2734 "\n" 2735 " A() {}\n" 2736 "};", 2737 format("class A : public QObject {\n" 2738 " Q_OBJECT\n" 2739 "\n" 2740 " A() {\n}\n" 2741 "} ;")); 2742 EXPECT_EQ("MACRO\n" 2743 "/*static*/ int i;", 2744 format("MACRO\n" 2745 " /*static*/ int i;")); 2746 EXPECT_EQ("SOME_MACRO\n" 2747 "namespace {\n" 2748 "void f();\n" 2749 "} // namespace", 2750 format("SOME_MACRO\n" 2751 " namespace {\n" 2752 "void f( );\n" 2753 "} // namespace")); 2754 // Only if the identifier contains at least 5 characters. 2755 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 2756 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 2757 // Only if everything is upper case. 2758 EXPECT_EQ("class A : public QObject {\n" 2759 " Q_Object A() {}\n" 2760 "};", 2761 format("class A : public QObject {\n" 2762 " Q_Object\n" 2763 " A() {\n}\n" 2764 "} ;")); 2765 2766 // Only if the next line can actually start an unwrapped line. 2767 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 2768 format("SOME_WEIRD_LOG_MACRO\n" 2769 "<< SomeThing;")); 2770 2771 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 2772 "(n, buffers))\n", 2773 getChromiumStyle(FormatStyle::LK_Cpp)); 2774 2775 // See PR41483 2776 EXPECT_EQ("/**/ FOO(a)\n" 2777 "FOO(b)", 2778 format("/**/ FOO(a)\n" 2779 "FOO(b)")); 2780 } 2781 2782 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 2783 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2784 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2785 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2786 "class X {};\n" 2787 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2788 "int *createScopDetectionPass() { return 0; }", 2789 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2790 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2791 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2792 " class X {};\n" 2793 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2794 " int *createScopDetectionPass() { return 0; }")); 2795 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 2796 // braces, so that inner block is indented one level more. 2797 EXPECT_EQ("int q() {\n" 2798 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2799 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2800 " IPC_END_MESSAGE_MAP()\n" 2801 "}", 2802 format("int q() {\n" 2803 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2804 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2805 " IPC_END_MESSAGE_MAP()\n" 2806 "}")); 2807 2808 // Same inside macros. 2809 EXPECT_EQ("#define LIST(L) \\\n" 2810 " L(A) \\\n" 2811 " L(B) \\\n" 2812 " L(C)", 2813 format("#define LIST(L) \\\n" 2814 " L(A) \\\n" 2815 " L(B) \\\n" 2816 " L(C)", 2817 getGoogleStyle())); 2818 2819 // These must not be recognized as macros. 2820 EXPECT_EQ("int q() {\n" 2821 " f(x);\n" 2822 " f(x) {}\n" 2823 " f(x)->g();\n" 2824 " f(x)->*g();\n" 2825 " f(x).g();\n" 2826 " f(x) = x;\n" 2827 " f(x) += x;\n" 2828 " f(x) -= x;\n" 2829 " f(x) *= x;\n" 2830 " f(x) /= x;\n" 2831 " f(x) %= x;\n" 2832 " f(x) &= x;\n" 2833 " f(x) |= x;\n" 2834 " f(x) ^= x;\n" 2835 " f(x) >>= x;\n" 2836 " f(x) <<= x;\n" 2837 " f(x)[y].z();\n" 2838 " LOG(INFO) << x;\n" 2839 " ifstream(x) >> x;\n" 2840 "}\n", 2841 format("int q() {\n" 2842 " f(x)\n;\n" 2843 " f(x)\n {}\n" 2844 " f(x)\n->g();\n" 2845 " f(x)\n->*g();\n" 2846 " f(x)\n.g();\n" 2847 " f(x)\n = x;\n" 2848 " f(x)\n += x;\n" 2849 " f(x)\n -= x;\n" 2850 " f(x)\n *= x;\n" 2851 " f(x)\n /= x;\n" 2852 " f(x)\n %= x;\n" 2853 " f(x)\n &= x;\n" 2854 " f(x)\n |= x;\n" 2855 " f(x)\n ^= x;\n" 2856 " f(x)\n >>= x;\n" 2857 " f(x)\n <<= x;\n" 2858 " f(x)\n[y].z();\n" 2859 " LOG(INFO)\n << x;\n" 2860 " ifstream(x)\n >> x;\n" 2861 "}\n")); 2862 EXPECT_EQ("int q() {\n" 2863 " F(x)\n" 2864 " if (1) {\n" 2865 " }\n" 2866 " F(x)\n" 2867 " while (1) {\n" 2868 " }\n" 2869 " F(x)\n" 2870 " G(x);\n" 2871 " F(x)\n" 2872 " try {\n" 2873 " Q();\n" 2874 " } catch (...) {\n" 2875 " }\n" 2876 "}\n", 2877 format("int q() {\n" 2878 "F(x)\n" 2879 "if (1) {}\n" 2880 "F(x)\n" 2881 "while (1) {}\n" 2882 "F(x)\n" 2883 "G(x);\n" 2884 "F(x)\n" 2885 "try { Q(); } catch (...) {}\n" 2886 "}\n")); 2887 EXPECT_EQ("class A {\n" 2888 " A() : t(0) {}\n" 2889 " A(int i) noexcept() : {}\n" 2890 " A(X x)\n" // FIXME: function-level try blocks are broken. 2891 " try : t(0) {\n" 2892 " } catch (...) {\n" 2893 " }\n" 2894 "};", 2895 format("class A {\n" 2896 " A()\n : t(0) {}\n" 2897 " A(int i)\n noexcept() : {}\n" 2898 " A(X x)\n" 2899 " try : t(0) {} catch (...) {}\n" 2900 "};")); 2901 FormatStyle Style = getLLVMStyle(); 2902 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2903 Style.BraceWrapping.AfterControlStatement = true; 2904 Style.BraceWrapping.AfterFunction = true; 2905 EXPECT_EQ("void f()\n" 2906 "try\n" 2907 "{\n" 2908 "}", 2909 format("void f() try {\n" 2910 "}", Style)); 2911 EXPECT_EQ("class SomeClass {\n" 2912 "public:\n" 2913 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2914 "};", 2915 format("class SomeClass {\n" 2916 "public:\n" 2917 " SomeClass()\n" 2918 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2919 "};")); 2920 EXPECT_EQ("class SomeClass {\n" 2921 "public:\n" 2922 " SomeClass()\n" 2923 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2924 "};", 2925 format("class SomeClass {\n" 2926 "public:\n" 2927 " SomeClass()\n" 2928 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2929 "};", 2930 getLLVMStyleWithColumns(40))); 2931 2932 verifyFormat("MACRO(>)"); 2933 2934 // Some macros contain an implicit semicolon. 2935 Style = getLLVMStyle(); 2936 Style.StatementMacros.push_back("FOO"); 2937 verifyFormat("FOO(a) int b = 0;"); 2938 verifyFormat("FOO(a)\n" 2939 "int b = 0;", 2940 Style); 2941 verifyFormat("FOO(a);\n" 2942 "int b = 0;", 2943 Style); 2944 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 2945 "int b = 0;", 2946 Style); 2947 verifyFormat("FOO()\n" 2948 "int b = 0;", 2949 Style); 2950 verifyFormat("FOO\n" 2951 "int b = 0;", 2952 Style); 2953 verifyFormat("void f() {\n" 2954 " FOO(a)\n" 2955 " return a;\n" 2956 "}", 2957 Style); 2958 verifyFormat("FOO(a)\n" 2959 "FOO(b)", 2960 Style); 2961 verifyFormat("int a = 0;\n" 2962 "FOO(b)\n" 2963 "int c = 0;", 2964 Style); 2965 verifyFormat("int a = 0;\n" 2966 "int x = FOO(a)\n" 2967 "int b = 0;", 2968 Style); 2969 verifyFormat("void foo(int a) { FOO(a) }\n" 2970 "uint32_t bar() {}", 2971 Style); 2972 } 2973 2974 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 2975 verifyFormat("#define A \\\n" 2976 " f({ \\\n" 2977 " g(); \\\n" 2978 " });", 2979 getLLVMStyleWithColumns(11)); 2980 } 2981 2982 TEST_F(FormatTest, IndentPreprocessorDirectives) { 2983 FormatStyle Style = getLLVMStyle(); 2984 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 2985 Style.ColumnLimit = 40; 2986 verifyFormat("#ifdef _WIN32\n" 2987 "#define A 0\n" 2988 "#ifdef VAR2\n" 2989 "#define B 1\n" 2990 "#include <someheader.h>\n" 2991 "#define MACRO \\\n" 2992 " some_very_long_func_aaaaaaaaaa();\n" 2993 "#endif\n" 2994 "#else\n" 2995 "#define A 1\n" 2996 "#endif", 2997 Style); 2998 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 2999 verifyFormat("#ifdef _WIN32\n" 3000 "# define A 0\n" 3001 "# ifdef VAR2\n" 3002 "# define B 1\n" 3003 "# include <someheader.h>\n" 3004 "# define MACRO \\\n" 3005 " some_very_long_func_aaaaaaaaaa();\n" 3006 "# endif\n" 3007 "#else\n" 3008 "# define A 1\n" 3009 "#endif", 3010 Style); 3011 verifyFormat("#if A\n" 3012 "# define MACRO \\\n" 3013 " void a(int x) { \\\n" 3014 " b(); \\\n" 3015 " c(); \\\n" 3016 " d(); \\\n" 3017 " e(); \\\n" 3018 " f(); \\\n" 3019 " }\n" 3020 "#endif", 3021 Style); 3022 // Comments before include guard. 3023 verifyFormat("// file comment\n" 3024 "// file comment\n" 3025 "#ifndef HEADER_H\n" 3026 "#define HEADER_H\n" 3027 "code();\n" 3028 "#endif", 3029 Style); 3030 // Test with include guards. 3031 verifyFormat("#ifndef HEADER_H\n" 3032 "#define HEADER_H\n" 3033 "code();\n" 3034 "#endif", 3035 Style); 3036 // Include guards must have a #define with the same variable immediately 3037 // after #ifndef. 3038 verifyFormat("#ifndef NOT_GUARD\n" 3039 "# define FOO\n" 3040 "code();\n" 3041 "#endif", 3042 Style); 3043 3044 // Include guards must cover the entire file. 3045 verifyFormat("code();\n" 3046 "code();\n" 3047 "#ifndef NOT_GUARD\n" 3048 "# define NOT_GUARD\n" 3049 "code();\n" 3050 "#endif", 3051 Style); 3052 verifyFormat("#ifndef NOT_GUARD\n" 3053 "# define NOT_GUARD\n" 3054 "code();\n" 3055 "#endif\n" 3056 "code();", 3057 Style); 3058 // Test with trailing blank lines. 3059 verifyFormat("#ifndef HEADER_H\n" 3060 "#define HEADER_H\n" 3061 "code();\n" 3062 "#endif\n", 3063 Style); 3064 // Include guards don't have #else. 3065 verifyFormat("#ifndef NOT_GUARD\n" 3066 "# define NOT_GUARD\n" 3067 "code();\n" 3068 "#else\n" 3069 "#endif", 3070 Style); 3071 verifyFormat("#ifndef NOT_GUARD\n" 3072 "# define NOT_GUARD\n" 3073 "code();\n" 3074 "#elif FOO\n" 3075 "#endif", 3076 Style); 3077 // Non-identifier #define after potential include guard. 3078 verifyFormat("#ifndef FOO\n" 3079 "# define 1\n" 3080 "#endif\n", 3081 Style); 3082 // #if closes past last non-preprocessor line. 3083 verifyFormat("#ifndef FOO\n" 3084 "#define FOO\n" 3085 "#if 1\n" 3086 "int i;\n" 3087 "# define A 0\n" 3088 "#endif\n" 3089 "#endif\n", 3090 Style); 3091 // Don't crash if there is an #elif directive without a condition. 3092 verifyFormat("#if 1\n" 3093 "int x;\n" 3094 "#elif\n" 3095 "int y;\n" 3096 "#else\n" 3097 "int z;\n" 3098 "#endif", 3099 Style); 3100 // FIXME: This doesn't handle the case where there's code between the 3101 // #ifndef and #define but all other conditions hold. This is because when 3102 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 3103 // previous code line yet, so we can't detect it. 3104 EXPECT_EQ("#ifndef NOT_GUARD\n" 3105 "code();\n" 3106 "#define NOT_GUARD\n" 3107 "code();\n" 3108 "#endif", 3109 format("#ifndef NOT_GUARD\n" 3110 "code();\n" 3111 "# define NOT_GUARD\n" 3112 "code();\n" 3113 "#endif", 3114 Style)); 3115 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 3116 // be outside an include guard. Examples are #pragma once and 3117 // #pragma GCC diagnostic, or anything else that does not change the meaning 3118 // of the file if it's included multiple times. 3119 EXPECT_EQ("#ifdef WIN32\n" 3120 "# pragma once\n" 3121 "#endif\n" 3122 "#ifndef HEADER_H\n" 3123 "# define HEADER_H\n" 3124 "code();\n" 3125 "#endif", 3126 format("#ifdef WIN32\n" 3127 "# pragma once\n" 3128 "#endif\n" 3129 "#ifndef HEADER_H\n" 3130 "#define HEADER_H\n" 3131 "code();\n" 3132 "#endif", 3133 Style)); 3134 // FIXME: This does not detect when there is a single non-preprocessor line 3135 // in front of an include-guard-like structure where other conditions hold 3136 // because ScopedLineState hides the line. 3137 EXPECT_EQ("code();\n" 3138 "#ifndef HEADER_H\n" 3139 "#define HEADER_H\n" 3140 "code();\n" 3141 "#endif", 3142 format("code();\n" 3143 "#ifndef HEADER_H\n" 3144 "# define HEADER_H\n" 3145 "code();\n" 3146 "#endif", 3147 Style)); 3148 // Keep comments aligned with #, otherwise indent comments normally. These 3149 // tests cannot use verifyFormat because messUp manipulates leading 3150 // whitespace. 3151 { 3152 const char *Expected = "" 3153 "void f() {\n" 3154 "#if 1\n" 3155 "// Preprocessor aligned.\n" 3156 "# define A 0\n" 3157 " // Code. Separated by blank line.\n" 3158 "\n" 3159 "# define B 0\n" 3160 " // Code. Not aligned with #\n" 3161 "# define C 0\n" 3162 "#endif"; 3163 const char *ToFormat = "" 3164 "void f() {\n" 3165 "#if 1\n" 3166 "// Preprocessor aligned.\n" 3167 "# define A 0\n" 3168 "// Code. Separated by blank line.\n" 3169 "\n" 3170 "# define B 0\n" 3171 " // Code. Not aligned with #\n" 3172 "# define C 0\n" 3173 "#endif"; 3174 EXPECT_EQ(Expected, format(ToFormat, Style)); 3175 EXPECT_EQ(Expected, format(Expected, Style)); 3176 } 3177 // Keep block quotes aligned. 3178 { 3179 const char *Expected = "" 3180 "void f() {\n" 3181 "#if 1\n" 3182 "/* Preprocessor aligned. */\n" 3183 "# define A 0\n" 3184 " /* Code. Separated by blank line. */\n" 3185 "\n" 3186 "# define B 0\n" 3187 " /* Code. Not aligned with # */\n" 3188 "# define C 0\n" 3189 "#endif"; 3190 const char *ToFormat = "" 3191 "void f() {\n" 3192 "#if 1\n" 3193 "/* Preprocessor aligned. */\n" 3194 "# define A 0\n" 3195 "/* Code. Separated by blank line. */\n" 3196 "\n" 3197 "# define B 0\n" 3198 " /* Code. Not aligned with # */\n" 3199 "# define C 0\n" 3200 "#endif"; 3201 EXPECT_EQ(Expected, format(ToFormat, Style)); 3202 EXPECT_EQ(Expected, format(Expected, Style)); 3203 } 3204 // Keep comments aligned with un-indented directives. 3205 { 3206 const char *Expected = "" 3207 "void f() {\n" 3208 "// Preprocessor aligned.\n" 3209 "#define A 0\n" 3210 " // Code. Separated by blank line.\n" 3211 "\n" 3212 "#define B 0\n" 3213 " // Code. Not aligned with #\n" 3214 "#define C 0\n"; 3215 const char *ToFormat = "" 3216 "void f() {\n" 3217 "// Preprocessor aligned.\n" 3218 "#define A 0\n" 3219 "// Code. Separated by blank line.\n" 3220 "\n" 3221 "#define B 0\n" 3222 " // Code. Not aligned with #\n" 3223 "#define C 0\n"; 3224 EXPECT_EQ(Expected, format(ToFormat, Style)); 3225 EXPECT_EQ(Expected, format(Expected, Style)); 3226 } 3227 // Test AfterHash with tabs. 3228 { 3229 FormatStyle Tabbed = Style; 3230 Tabbed.UseTab = FormatStyle::UT_Always; 3231 Tabbed.IndentWidth = 8; 3232 Tabbed.TabWidth = 8; 3233 verifyFormat("#ifdef _WIN32\n" 3234 "#\tdefine A 0\n" 3235 "#\tifdef VAR2\n" 3236 "#\t\tdefine B 1\n" 3237 "#\t\tinclude <someheader.h>\n" 3238 "#\t\tdefine MACRO \\\n" 3239 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3240 "#\tendif\n" 3241 "#else\n" 3242 "#\tdefine A 1\n" 3243 "#endif", 3244 Tabbed); 3245 } 3246 3247 // Regression test: Multiline-macro inside include guards. 3248 verifyFormat("#ifndef HEADER_H\n" 3249 "#define HEADER_H\n" 3250 "#define A() \\\n" 3251 " int i; \\\n" 3252 " int j;\n" 3253 "#endif // HEADER_H", 3254 getLLVMStyleWithColumns(20)); 3255 3256 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3257 // Basic before hash indent tests 3258 verifyFormat("#ifdef _WIN32\n" 3259 " #define A 0\n" 3260 " #ifdef VAR2\n" 3261 " #define B 1\n" 3262 " #include <someheader.h>\n" 3263 " #define MACRO \\\n" 3264 " some_very_long_func_aaaaaaaaaa();\n" 3265 " #endif\n" 3266 "#else\n" 3267 " #define A 1\n" 3268 "#endif", 3269 Style); 3270 verifyFormat("#if A\n" 3271 " #define MACRO \\\n" 3272 " void a(int x) { \\\n" 3273 " b(); \\\n" 3274 " c(); \\\n" 3275 " d(); \\\n" 3276 " e(); \\\n" 3277 " f(); \\\n" 3278 " }\n" 3279 "#endif", 3280 Style); 3281 // Keep comments aligned with indented directives. These 3282 // tests cannot use verifyFormat because messUp manipulates leading 3283 // whitespace. 3284 { 3285 const char *Expected = "void f() {\n" 3286 "// Aligned to preprocessor.\n" 3287 "#if 1\n" 3288 " // Aligned to code.\n" 3289 " int a;\n" 3290 " #if 1\n" 3291 " // Aligned to preprocessor.\n" 3292 " #define A 0\n" 3293 " // Aligned to code.\n" 3294 " int b;\n" 3295 " #endif\n" 3296 "#endif\n" 3297 "}"; 3298 const char *ToFormat = "void f() {\n" 3299 "// Aligned to preprocessor.\n" 3300 "#if 1\n" 3301 "// Aligned to code.\n" 3302 "int a;\n" 3303 "#if 1\n" 3304 "// Aligned to preprocessor.\n" 3305 "#define A 0\n" 3306 "// Aligned to code.\n" 3307 "int b;\n" 3308 "#endif\n" 3309 "#endif\n" 3310 "}"; 3311 EXPECT_EQ(Expected, format(ToFormat, Style)); 3312 EXPECT_EQ(Expected, format(Expected, Style)); 3313 } 3314 { 3315 const char *Expected = "void f() {\n" 3316 "/* Aligned to preprocessor. */\n" 3317 "#if 1\n" 3318 " /* Aligned to code. */\n" 3319 " int a;\n" 3320 " #if 1\n" 3321 " /* Aligned to preprocessor. */\n" 3322 " #define A 0\n" 3323 " /* Aligned to code. */\n" 3324 " int b;\n" 3325 " #endif\n" 3326 "#endif\n" 3327 "}"; 3328 const char *ToFormat = "void f() {\n" 3329 "/* Aligned to preprocessor. */\n" 3330 "#if 1\n" 3331 "/* Aligned to code. */\n" 3332 "int a;\n" 3333 "#if 1\n" 3334 "/* Aligned to preprocessor. */\n" 3335 "#define A 0\n" 3336 "/* Aligned to code. */\n" 3337 "int b;\n" 3338 "#endif\n" 3339 "#endif\n" 3340 "}"; 3341 EXPECT_EQ(Expected, format(ToFormat, Style)); 3342 EXPECT_EQ(Expected, format(Expected, Style)); 3343 } 3344 3345 // Test single comment before preprocessor 3346 verifyFormat("// Comment\n" 3347 "\n" 3348 "#if 1\n" 3349 "#endif", 3350 Style); 3351 } 3352 3353 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3354 verifyFormat("{\n { a #c; }\n}"); 3355 } 3356 3357 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3358 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3359 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3360 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3361 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3362 } 3363 3364 TEST_F(FormatTest, EscapedNewlines) { 3365 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3366 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3367 format("#define A \\\nint i;\\\n int j;", Narrow)); 3368 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3369 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3370 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3371 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3372 3373 FormatStyle AlignLeft = getLLVMStyle(); 3374 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3375 EXPECT_EQ("#define MACRO(x) \\\n" 3376 "private: \\\n" 3377 " int x(int a);\n", 3378 format("#define MACRO(x) \\\n" 3379 "private: \\\n" 3380 " int x(int a);\n", 3381 AlignLeft)); 3382 3383 // CRLF line endings 3384 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3385 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3386 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3387 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3388 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3389 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3390 EXPECT_EQ("#define MACRO(x) \\\r\n" 3391 "private: \\\r\n" 3392 " int x(int a);\r\n", 3393 format("#define MACRO(x) \\\r\n" 3394 "private: \\\r\n" 3395 " int x(int a);\r\n", 3396 AlignLeft)); 3397 3398 FormatStyle DontAlign = getLLVMStyle(); 3399 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3400 DontAlign.MaxEmptyLinesToKeep = 3; 3401 // FIXME: can't use verifyFormat here because the newline before 3402 // "public:" is not inserted the first time it's reformatted 3403 EXPECT_EQ("#define A \\\n" 3404 " class Foo { \\\n" 3405 " void bar(); \\\n" 3406 "\\\n" 3407 "\\\n" 3408 "\\\n" 3409 " public: \\\n" 3410 " void baz(); \\\n" 3411 " };", 3412 format("#define A \\\n" 3413 " class Foo { \\\n" 3414 " void bar(); \\\n" 3415 "\\\n" 3416 "\\\n" 3417 "\\\n" 3418 " public: \\\n" 3419 " void baz(); \\\n" 3420 " };", 3421 DontAlign)); 3422 } 3423 3424 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3425 verifyFormat("#define A \\\n" 3426 " int v( \\\n" 3427 " a); \\\n" 3428 " int i;", 3429 getLLVMStyleWithColumns(11)); 3430 } 3431 3432 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3433 EXPECT_EQ( 3434 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3435 " \\\n" 3436 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3437 "\n" 3438 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3439 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3440 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3441 "\\\n" 3442 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3443 " \n" 3444 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3445 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3446 } 3447 3448 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3449 EXPECT_EQ("int\n" 3450 "#define A\n" 3451 " a;", 3452 format("int\n#define A\na;")); 3453 verifyFormat("functionCallTo(\n" 3454 " someOtherFunction(\n" 3455 " withSomeParameters, whichInSequence,\n" 3456 " areLongerThanALine(andAnotherCall,\n" 3457 "#define A B\n" 3458 " withMoreParamters,\n" 3459 " whichStronglyInfluenceTheLayout),\n" 3460 " andMoreParameters),\n" 3461 " trailing);", 3462 getLLVMStyleWithColumns(69)); 3463 verifyFormat("Foo::Foo()\n" 3464 "#ifdef BAR\n" 3465 " : baz(0)\n" 3466 "#endif\n" 3467 "{\n" 3468 "}"); 3469 verifyFormat("void f() {\n" 3470 " if (true)\n" 3471 "#ifdef A\n" 3472 " f(42);\n" 3473 " x();\n" 3474 "#else\n" 3475 " g();\n" 3476 " x();\n" 3477 "#endif\n" 3478 "}"); 3479 verifyFormat("void f(param1, param2,\n" 3480 " param3,\n" 3481 "#ifdef A\n" 3482 " param4(param5,\n" 3483 "#ifdef A1\n" 3484 " param6,\n" 3485 "#ifdef A2\n" 3486 " param7),\n" 3487 "#else\n" 3488 " param8),\n" 3489 " param9,\n" 3490 "#endif\n" 3491 " param10,\n" 3492 "#endif\n" 3493 " param11)\n" 3494 "#else\n" 3495 " param12)\n" 3496 "#endif\n" 3497 "{\n" 3498 " x();\n" 3499 "}", 3500 getLLVMStyleWithColumns(28)); 3501 verifyFormat("#if 1\n" 3502 "int i;"); 3503 verifyFormat("#if 1\n" 3504 "#endif\n" 3505 "#if 1\n" 3506 "#else\n" 3507 "#endif\n"); 3508 verifyFormat("DEBUG({\n" 3509 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3510 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3511 "});\n" 3512 "#if a\n" 3513 "#else\n" 3514 "#endif"); 3515 3516 verifyIncompleteFormat("void f(\n" 3517 "#if A\n" 3518 ");\n" 3519 "#else\n" 3520 "#endif"); 3521 } 3522 3523 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3524 verifyFormat("#endif\n" 3525 "#if B"); 3526 } 3527 3528 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3529 FormatStyle SingleLine = getLLVMStyle(); 3530 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3531 verifyFormat("#if 0\n" 3532 "#elif 1\n" 3533 "#endif\n" 3534 "void foo() {\n" 3535 " if (test) foo2();\n" 3536 "}", 3537 SingleLine); 3538 } 3539 3540 TEST_F(FormatTest, LayoutBlockInsideParens) { 3541 verifyFormat("functionCall({ int i; });"); 3542 verifyFormat("functionCall({\n" 3543 " int i;\n" 3544 " int j;\n" 3545 "});"); 3546 verifyFormat("functionCall(\n" 3547 " {\n" 3548 " int i;\n" 3549 " int j;\n" 3550 " },\n" 3551 " aaaa, bbbb, cccc);"); 3552 verifyFormat("functionA(functionB({\n" 3553 " int i;\n" 3554 " int j;\n" 3555 " }),\n" 3556 " aaaa, bbbb, cccc);"); 3557 verifyFormat("functionCall(\n" 3558 " {\n" 3559 " int i;\n" 3560 " int j;\n" 3561 " },\n" 3562 " aaaa, bbbb, // comment\n" 3563 " cccc);"); 3564 verifyFormat("functionA(functionB({\n" 3565 " int i;\n" 3566 " int j;\n" 3567 " }),\n" 3568 " aaaa, bbbb, // comment\n" 3569 " cccc);"); 3570 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3571 verifyFormat("functionCall(aaaa, bbbb, {\n" 3572 " int i;\n" 3573 " int j;\n" 3574 "});"); 3575 verifyFormat( 3576 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3577 " {\n" 3578 " int i; // break\n" 3579 " },\n" 3580 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3581 " ccccccccccccccccc));"); 3582 verifyFormat("DEBUG({\n" 3583 " if (a)\n" 3584 " f();\n" 3585 "});"); 3586 } 3587 3588 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3589 EXPECT_EQ("SOME_MACRO { int i; }\n" 3590 "int i;", 3591 format(" SOME_MACRO {int i;} int i;")); 3592 } 3593 3594 TEST_F(FormatTest, LayoutNestedBlocks) { 3595 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3596 " struct s {\n" 3597 " int i;\n" 3598 " };\n" 3599 " s kBitsToOs[] = {{10}};\n" 3600 " for (int i = 0; i < 10; ++i)\n" 3601 " return;\n" 3602 "}"); 3603 verifyFormat("call(parameter, {\n" 3604 " something();\n" 3605 " // Comment using all columns.\n" 3606 " somethingelse();\n" 3607 "});", 3608 getLLVMStyleWithColumns(40)); 3609 verifyFormat("DEBUG( //\n" 3610 " { f(); }, a);"); 3611 verifyFormat("DEBUG( //\n" 3612 " {\n" 3613 " f(); //\n" 3614 " },\n" 3615 " a);"); 3616 3617 EXPECT_EQ("call(parameter, {\n" 3618 " something();\n" 3619 " // Comment too\n" 3620 " // looooooooooong.\n" 3621 " somethingElse();\n" 3622 "});", 3623 format("call(parameter, {\n" 3624 " something();\n" 3625 " // Comment too looooooooooong.\n" 3626 " somethingElse();\n" 3627 "});", 3628 getLLVMStyleWithColumns(29))); 3629 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3630 EXPECT_EQ("DEBUG({ // comment\n" 3631 " int i;\n" 3632 "});", 3633 format("DEBUG({ // comment\n" 3634 "int i;\n" 3635 "});")); 3636 EXPECT_EQ("DEBUG({\n" 3637 " int i;\n" 3638 "\n" 3639 " // comment\n" 3640 " int j;\n" 3641 "});", 3642 format("DEBUG({\n" 3643 " int i;\n" 3644 "\n" 3645 " // comment\n" 3646 " int j;\n" 3647 "});")); 3648 3649 verifyFormat("DEBUG({\n" 3650 " if (a)\n" 3651 " return;\n" 3652 "});"); 3653 verifyGoogleFormat("DEBUG({\n" 3654 " if (a) return;\n" 3655 "});"); 3656 FormatStyle Style = getGoogleStyle(); 3657 Style.ColumnLimit = 45; 3658 verifyFormat("Debug(\n" 3659 " aaaaa,\n" 3660 " {\n" 3661 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 3662 " },\n" 3663 " a);", 3664 Style); 3665 3666 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 3667 3668 verifyNoCrash("^{v^{a}}"); 3669 } 3670 3671 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 3672 EXPECT_EQ("#define MACRO() \\\n" 3673 " Debug(aaa, /* force line break */ \\\n" 3674 " { \\\n" 3675 " int i; \\\n" 3676 " int j; \\\n" 3677 " })", 3678 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 3679 " { int i; int j; })", 3680 getGoogleStyle())); 3681 3682 EXPECT_EQ("#define A \\\n" 3683 " [] { \\\n" 3684 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3685 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 3686 " }", 3687 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3688 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 3689 getGoogleStyle())); 3690 } 3691 3692 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 3693 EXPECT_EQ("{}", format("{}")); 3694 verifyFormat("enum E {};"); 3695 verifyFormat("enum E {}"); 3696 FormatStyle Style = getLLVMStyle(); 3697 Style.SpaceInEmptyBlock = true; 3698 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 3699 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 3700 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 3701 } 3702 3703 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 3704 FormatStyle Style = getLLVMStyle(); 3705 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 3706 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 3707 verifyFormat("FOO_BEGIN\n" 3708 " FOO_ENTRY\n" 3709 "FOO_END", Style); 3710 verifyFormat("FOO_BEGIN\n" 3711 " NESTED_FOO_BEGIN\n" 3712 " NESTED_FOO_ENTRY\n" 3713 " NESTED_FOO_END\n" 3714 "FOO_END", Style); 3715 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 3716 " int x;\n" 3717 " x = 1;\n" 3718 "FOO_END(Baz)", Style); 3719 } 3720 3721 //===----------------------------------------------------------------------===// 3722 // Line break tests. 3723 //===----------------------------------------------------------------------===// 3724 3725 TEST_F(FormatTest, PreventConfusingIndents) { 3726 verifyFormat( 3727 "void f() {\n" 3728 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 3729 " parameter, parameter, parameter)),\n" 3730 " SecondLongCall(parameter));\n" 3731 "}"); 3732 verifyFormat( 3733 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3734 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3735 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3736 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 3737 verifyFormat( 3738 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3739 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 3740 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 3741 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 3742 verifyFormat( 3743 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 3744 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 3745 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 3746 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 3747 verifyFormat("int a = bbbb && ccc &&\n" 3748 " fffff(\n" 3749 "#define A Just forcing a new line\n" 3750 " ddd);"); 3751 } 3752 3753 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 3754 verifyFormat( 3755 "bool aaaaaaa =\n" 3756 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 3757 " bbbbbbbb();"); 3758 verifyFormat( 3759 "bool aaaaaaa =\n" 3760 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 3761 " bbbbbbbb();"); 3762 3763 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3764 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 3765 " ccccccccc == ddddddddddd;"); 3766 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3767 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 3768 " ccccccccc == ddddddddddd;"); 3769 verifyFormat( 3770 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 3771 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 3772 " ccccccccc == ddddddddddd;"); 3773 3774 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3775 " aaaaaa) &&\n" 3776 " bbbbbb && cccccc;"); 3777 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3778 " aaaaaa) >>\n" 3779 " bbbbbb;"); 3780 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 3781 " SourceMgr.getSpellingColumnNumber(\n" 3782 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 3783 " 1);"); 3784 3785 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3786 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 3787 " cccccc) {\n}"); 3788 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3789 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3790 " cccccc) {\n}"); 3791 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3792 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3793 " cccccc) {\n}"); 3794 verifyFormat("b = a &&\n" 3795 " // Comment\n" 3796 " b.c && d;"); 3797 3798 // If the LHS of a comparison is not a binary expression itself, the 3799 // additional linebreak confuses many people. 3800 verifyFormat( 3801 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3802 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 3803 "}"); 3804 verifyFormat( 3805 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3806 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3807 "}"); 3808 verifyFormat( 3809 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 3810 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3811 "}"); 3812 verifyFormat( 3813 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3814 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 3815 "}"); 3816 // Even explicit parentheses stress the precedence enough to make the 3817 // additional break unnecessary. 3818 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3819 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3820 "}"); 3821 // This cases is borderline, but with the indentation it is still readable. 3822 verifyFormat( 3823 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3824 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3825 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 3826 "}", 3827 getLLVMStyleWithColumns(75)); 3828 3829 // If the LHS is a binary expression, we should still use the additional break 3830 // as otherwise the formatting hides the operator precedence. 3831 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3832 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3833 " 5) {\n" 3834 "}"); 3835 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3836 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 3837 " 5) {\n" 3838 "}"); 3839 3840 FormatStyle OnePerLine = getLLVMStyle(); 3841 OnePerLine.BinPackParameters = false; 3842 verifyFormat( 3843 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3844 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3845 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 3846 OnePerLine); 3847 3848 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 3849 " .aaa(aaaaaaaaaaaaa) *\n" 3850 " aaaaaaa +\n" 3851 " aaaaaaa;", 3852 getLLVMStyleWithColumns(40)); 3853 } 3854 3855 TEST_F(FormatTest, ExpressionIndentation) { 3856 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3857 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3858 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3859 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3860 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 3861 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 3862 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3863 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 3864 " ccccccccccccccccccccccccccccccccccccccccc;"); 3865 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3866 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3867 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3868 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3869 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3870 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3871 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3872 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3873 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3874 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3875 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3876 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3877 verifyFormat("if () {\n" 3878 "} else if (aaaaa && bbbbb > // break\n" 3879 " ccccc) {\n" 3880 "}"); 3881 verifyFormat("if () {\n" 3882 "} else if constexpr (aaaaa && bbbbb > // break\n" 3883 " ccccc) {\n" 3884 "}"); 3885 verifyFormat("if () {\n" 3886 "} else if CONSTEXPR (aaaaa && bbbbb > // break\n" 3887 " ccccc) {\n" 3888 "}"); 3889 verifyFormat("if () {\n" 3890 "} else if (aaaaa &&\n" 3891 " bbbbb > // break\n" 3892 " ccccc &&\n" 3893 " ddddd) {\n" 3894 "}"); 3895 3896 // Presence of a trailing comment used to change indentation of b. 3897 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 3898 " b;\n" 3899 "return aaaaaaaaaaaaaaaaaaa +\n" 3900 " b; //", 3901 getLLVMStyleWithColumns(30)); 3902 } 3903 3904 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 3905 // Not sure what the best system is here. Like this, the LHS can be found 3906 // immediately above an operator (everything with the same or a higher 3907 // indent). The RHS is aligned right of the operator and so compasses 3908 // everything until something with the same indent as the operator is found. 3909 // FIXME: Is this a good system? 3910 FormatStyle Style = getLLVMStyle(); 3911 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 3912 verifyFormat( 3913 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3914 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3915 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3916 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3917 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3918 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3919 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3920 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3921 " > ccccccccccccccccccccccccccccccccccccccccc;", 3922 Style); 3923 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3924 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3925 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3926 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3927 Style); 3928 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3929 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3930 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3931 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3932 Style); 3933 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3934 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3935 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3936 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3937 Style); 3938 verifyFormat("if () {\n" 3939 "} else if (aaaaa\n" 3940 " && bbbbb // break\n" 3941 " > ccccc) {\n" 3942 "}", 3943 Style); 3944 verifyFormat("return (a)\n" 3945 " // comment\n" 3946 " + b;", 3947 Style); 3948 verifyFormat( 3949 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3950 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3951 " + cc;", 3952 Style); 3953 3954 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3955 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 3956 Style); 3957 3958 // Forced by comments. 3959 verifyFormat( 3960 "unsigned ContentSize =\n" 3961 " sizeof(int16_t) // DWARF ARange version number\n" 3962 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 3963 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 3964 " + sizeof(int8_t); // Segment Size (in bytes)"); 3965 3966 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 3967 " == boost::fusion::at_c<1>(iiii).second;", 3968 Style); 3969 3970 Style.ColumnLimit = 60; 3971 verifyFormat("zzzzzzzzzz\n" 3972 " = bbbbbbbbbbbbbbbbb\n" 3973 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 3974 Style); 3975 3976 Style.ColumnLimit = 80; 3977 Style.IndentWidth = 4; 3978 Style.TabWidth = 4; 3979 Style.UseTab = FormatStyle::UT_Always; 3980 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 3981 Style.AlignOperands = false; 3982 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 3983 "\t&& (someOtherLongishConditionPart1\n" 3984 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 3985 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && (someOtherLongishConditionPart1 || someOtherEvenLongerNestedConditionPart2);", 3986 Style)); 3987 } 3988 3989 TEST_F(FormatTest, EnforcedOperatorWraps) { 3990 // Here we'd like to wrap after the || operators, but a comment is forcing an 3991 // earlier wrap. 3992 verifyFormat("bool x = aaaaa //\n" 3993 " || bbbbb\n" 3994 " //\n" 3995 " || cccc;"); 3996 } 3997 3998 TEST_F(FormatTest, NoOperandAlignment) { 3999 FormatStyle Style = getLLVMStyle(); 4000 Style.AlignOperands = false; 4001 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 4002 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4003 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4004 Style); 4005 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4006 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4007 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4008 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4009 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4010 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4011 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4012 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4013 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4014 " > ccccccccccccccccccccccccccccccccccccccccc;", 4015 Style); 4016 4017 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4018 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4019 " + cc;", 4020 Style); 4021 verifyFormat("int a = aa\n" 4022 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4023 " * cccccccccccccccccccccccccccccccccccc;\n", 4024 Style); 4025 4026 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4027 verifyFormat("return (a > b\n" 4028 " // comment1\n" 4029 " // comment2\n" 4030 " || c);", 4031 Style); 4032 } 4033 4034 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 4035 FormatStyle Style = getLLVMStyle(); 4036 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4037 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4038 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4039 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4040 Style); 4041 } 4042 4043 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 4044 FormatStyle Style = getLLVMStyle(); 4045 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4046 Style.BinPackArguments = false; 4047 Style.ColumnLimit = 40; 4048 verifyFormat("void test() {\n" 4049 " someFunction(\n" 4050 " this + argument + is + quite\n" 4051 " + long + so + it + gets + wrapped\n" 4052 " + but + remains + bin - packed);\n" 4053 "}", 4054 Style); 4055 verifyFormat("void test() {\n" 4056 " someFunction(arg1,\n" 4057 " this + argument + is\n" 4058 " + quite + long + so\n" 4059 " + it + gets + wrapped\n" 4060 " + but + remains + bin\n" 4061 " - packed,\n" 4062 " arg3);\n" 4063 "}", 4064 Style); 4065 verifyFormat("void test() {\n" 4066 " someFunction(\n" 4067 " arg1,\n" 4068 " this + argument + has\n" 4069 " + anotherFunc(nested,\n" 4070 " calls + whose\n" 4071 " + arguments\n" 4072 " + are + also\n" 4073 " + wrapped,\n" 4074 " in + addition)\n" 4075 " + to + being + bin - packed,\n" 4076 " arg3);\n" 4077 "}", 4078 Style); 4079 4080 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4081 verifyFormat("void test() {\n" 4082 " someFunction(\n" 4083 " arg1,\n" 4084 " this + argument + has +\n" 4085 " anotherFunc(nested,\n" 4086 " calls + whose +\n" 4087 " arguments +\n" 4088 " are + also +\n" 4089 " wrapped,\n" 4090 " in + addition) +\n" 4091 " to + being + bin - packed,\n" 4092 " arg3);\n" 4093 "}", 4094 Style); 4095 } 4096 4097 TEST_F(FormatTest, ConstructorInitializers) { 4098 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4099 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 4100 getLLVMStyleWithColumns(45)); 4101 verifyFormat("Constructor()\n" 4102 " : Inttializer(FitsOnTheLine) {}", 4103 getLLVMStyleWithColumns(44)); 4104 verifyFormat("Constructor()\n" 4105 " : Inttializer(FitsOnTheLine) {}", 4106 getLLVMStyleWithColumns(43)); 4107 4108 verifyFormat("template <typename T>\n" 4109 "Constructor() : Initializer(FitsOnTheLine) {}", 4110 getLLVMStyleWithColumns(45)); 4111 4112 verifyFormat( 4113 "SomeClass::Constructor()\n" 4114 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4115 4116 verifyFormat( 4117 "SomeClass::Constructor()\n" 4118 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4119 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 4120 verifyFormat( 4121 "SomeClass::Constructor()\n" 4122 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4123 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4124 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4125 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4126 " : aaaaaaaaaa(aaaaaa) {}"); 4127 4128 verifyFormat("Constructor()\n" 4129 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4130 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4131 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4132 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 4133 4134 verifyFormat("Constructor()\n" 4135 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4136 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4137 4138 verifyFormat("Constructor(int Parameter = 0)\n" 4139 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4140 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 4141 verifyFormat("Constructor()\n" 4142 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4143 "}", 4144 getLLVMStyleWithColumns(60)); 4145 verifyFormat("Constructor()\n" 4146 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4147 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 4148 4149 // Here a line could be saved by splitting the second initializer onto two 4150 // lines, but that is not desirable. 4151 verifyFormat("Constructor()\n" 4152 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4153 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4154 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4155 4156 FormatStyle OnePerLine = getLLVMStyle(); 4157 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4158 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 4159 verifyFormat("SomeClass::Constructor()\n" 4160 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4161 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4162 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4163 OnePerLine); 4164 verifyFormat("SomeClass::Constructor()\n" 4165 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4166 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4167 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4168 OnePerLine); 4169 verifyFormat("MyClass::MyClass(int var)\n" 4170 " : some_var_(var), // 4 space indent\n" 4171 " some_other_var_(var + 1) { // lined up\n" 4172 "}", 4173 OnePerLine); 4174 verifyFormat("Constructor()\n" 4175 " : aaaaa(aaaaaa),\n" 4176 " aaaaa(aaaaaa),\n" 4177 " aaaaa(aaaaaa),\n" 4178 " aaaaa(aaaaaa),\n" 4179 " aaaaa(aaaaaa) {}", 4180 OnePerLine); 4181 verifyFormat("Constructor()\n" 4182 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4183 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4184 OnePerLine); 4185 OnePerLine.BinPackParameters = false; 4186 verifyFormat( 4187 "Constructor()\n" 4188 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4189 " aaaaaaaaaaa().aaa(),\n" 4190 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4191 OnePerLine); 4192 OnePerLine.ColumnLimit = 60; 4193 verifyFormat("Constructor()\n" 4194 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4195 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4196 OnePerLine); 4197 4198 EXPECT_EQ("Constructor()\n" 4199 " : // Comment forcing unwanted break.\n" 4200 " aaaa(aaaa) {}", 4201 format("Constructor() :\n" 4202 " // Comment forcing unwanted break.\n" 4203 " aaaa(aaaa) {}")); 4204 } 4205 4206 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 4207 FormatStyle Style = getLLVMStyle(); 4208 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4209 Style.ColumnLimit = 60; 4210 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4211 Style.AllowAllConstructorInitializersOnNextLine = true; 4212 Style.BinPackParameters = false; 4213 4214 for (int i = 0; i < 4; ++i) { 4215 // Test all combinations of parameters that should not have an effect. 4216 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4217 Style.AllowAllArgumentsOnNextLine = i & 2; 4218 4219 Style.AllowAllConstructorInitializersOnNextLine = true; 4220 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4221 verifyFormat("Constructor()\n" 4222 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4223 Style); 4224 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4225 4226 Style.AllowAllConstructorInitializersOnNextLine = false; 4227 verifyFormat("Constructor()\n" 4228 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4229 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4230 Style); 4231 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4232 4233 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4234 Style.AllowAllConstructorInitializersOnNextLine = true; 4235 verifyFormat("Constructor()\n" 4236 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4237 Style); 4238 4239 Style.AllowAllConstructorInitializersOnNextLine = false; 4240 verifyFormat("Constructor()\n" 4241 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4242 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4243 Style); 4244 4245 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4246 Style.AllowAllConstructorInitializersOnNextLine = true; 4247 verifyFormat("Constructor() :\n" 4248 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4249 Style); 4250 4251 Style.AllowAllConstructorInitializersOnNextLine = false; 4252 verifyFormat("Constructor() :\n" 4253 " aaaaaaaaaaaaaaaaaa(a),\n" 4254 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4255 Style); 4256 } 4257 4258 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4259 // AllowAllConstructorInitializersOnNextLine in all 4260 // BreakConstructorInitializers modes 4261 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4262 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4263 Style.AllowAllConstructorInitializersOnNextLine = false; 4264 verifyFormat("SomeClassWithALongName::Constructor(\n" 4265 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4266 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4267 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4268 Style); 4269 4270 Style.AllowAllConstructorInitializersOnNextLine = true; 4271 verifyFormat("SomeClassWithALongName::Constructor(\n" 4272 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4273 " int bbbbbbbbbbbbb,\n" 4274 " int cccccccccccccccc)\n" 4275 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4276 Style); 4277 4278 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4279 Style.AllowAllConstructorInitializersOnNextLine = false; 4280 verifyFormat("SomeClassWithALongName::Constructor(\n" 4281 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4282 " int bbbbbbbbbbbbb)\n" 4283 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4284 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4285 Style); 4286 4287 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4288 4289 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4290 verifyFormat("SomeClassWithALongName::Constructor(\n" 4291 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4292 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4293 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4294 Style); 4295 4296 Style.AllowAllConstructorInitializersOnNextLine = true; 4297 verifyFormat("SomeClassWithALongName::Constructor(\n" 4298 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4299 " int bbbbbbbbbbbbb,\n" 4300 " int cccccccccccccccc)\n" 4301 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4302 Style); 4303 4304 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4305 Style.AllowAllConstructorInitializersOnNextLine = false; 4306 verifyFormat("SomeClassWithALongName::Constructor(\n" 4307 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4308 " int bbbbbbbbbbbbb)\n" 4309 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4310 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4311 Style); 4312 4313 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4314 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4315 verifyFormat("SomeClassWithALongName::Constructor(\n" 4316 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4317 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4318 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4319 Style); 4320 4321 Style.AllowAllConstructorInitializersOnNextLine = true; 4322 verifyFormat("SomeClassWithALongName::Constructor(\n" 4323 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4324 " int bbbbbbbbbbbbb,\n" 4325 " int cccccccccccccccc) :\n" 4326 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4327 Style); 4328 4329 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4330 Style.AllowAllConstructorInitializersOnNextLine = false; 4331 verifyFormat("SomeClassWithALongName::Constructor(\n" 4332 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4333 " int bbbbbbbbbbbbb) :\n" 4334 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4335 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4336 Style); 4337 } 4338 4339 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4340 FormatStyle Style = getLLVMStyle(); 4341 Style.ColumnLimit = 60; 4342 Style.BinPackArguments = false; 4343 for (int i = 0; i < 4; ++i) { 4344 // Test all combinations of parameters that should not have an effect. 4345 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4346 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4347 4348 Style.AllowAllArgumentsOnNextLine = true; 4349 verifyFormat("void foo() {\n" 4350 " FunctionCallWithReallyLongName(\n" 4351 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4352 "}", 4353 Style); 4354 Style.AllowAllArgumentsOnNextLine = false; 4355 verifyFormat("void foo() {\n" 4356 " FunctionCallWithReallyLongName(\n" 4357 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4358 " bbbbbbbbbbbb);\n" 4359 "}", 4360 Style); 4361 4362 Style.AllowAllArgumentsOnNextLine = true; 4363 verifyFormat("void foo() {\n" 4364 " auto VariableWithReallyLongName = {\n" 4365 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4366 "}", 4367 Style); 4368 Style.AllowAllArgumentsOnNextLine = false; 4369 verifyFormat("void foo() {\n" 4370 " auto VariableWithReallyLongName = {\n" 4371 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4372 " bbbbbbbbbbbb};\n" 4373 "}", 4374 Style); 4375 } 4376 4377 // This parameter should not affect declarations. 4378 Style.BinPackParameters = false; 4379 Style.AllowAllArgumentsOnNextLine = false; 4380 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4381 verifyFormat("void FunctionCallWithReallyLongName(\n" 4382 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4383 Style); 4384 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4385 verifyFormat("void FunctionCallWithReallyLongName(\n" 4386 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4387 " int bbbbbbbbbbbb);", 4388 Style); 4389 } 4390 4391 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4392 FormatStyle Style = getLLVMStyle(); 4393 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4394 4395 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4396 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4397 getStyleWithColumns(Style, 45)); 4398 verifyFormat("Constructor() :\n" 4399 " Initializer(FitsOnTheLine) {}", 4400 getStyleWithColumns(Style, 44)); 4401 verifyFormat("Constructor() :\n" 4402 " Initializer(FitsOnTheLine) {}", 4403 getStyleWithColumns(Style, 43)); 4404 4405 verifyFormat("template <typename T>\n" 4406 "Constructor() : Initializer(FitsOnTheLine) {}", 4407 getStyleWithColumns(Style, 50)); 4408 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4409 verifyFormat( 4410 "SomeClass::Constructor() :\n" 4411 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4412 Style); 4413 4414 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4415 verifyFormat( 4416 "SomeClass::Constructor() :\n" 4417 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4418 Style); 4419 4420 verifyFormat( 4421 "SomeClass::Constructor() :\n" 4422 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4423 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4424 Style); 4425 verifyFormat( 4426 "SomeClass::Constructor() :\n" 4427 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4428 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4429 Style); 4430 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4431 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4432 " aaaaaaaaaa(aaaaaa) {}", 4433 Style); 4434 4435 verifyFormat("Constructor() :\n" 4436 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4437 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4438 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4439 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4440 Style); 4441 4442 verifyFormat("Constructor() :\n" 4443 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4444 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4445 Style); 4446 4447 verifyFormat("Constructor(int Parameter = 0) :\n" 4448 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4449 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4450 Style); 4451 verifyFormat("Constructor() :\n" 4452 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4453 "}", 4454 getStyleWithColumns(Style, 60)); 4455 verifyFormat("Constructor() :\n" 4456 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4457 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4458 Style); 4459 4460 // Here a line could be saved by splitting the second initializer onto two 4461 // lines, but that is not desirable. 4462 verifyFormat("Constructor() :\n" 4463 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4464 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4465 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4466 Style); 4467 4468 FormatStyle OnePerLine = Style; 4469 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4470 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4471 verifyFormat("SomeClass::Constructor() :\n" 4472 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4473 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4474 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4475 OnePerLine); 4476 verifyFormat("SomeClass::Constructor() :\n" 4477 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4478 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4479 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4480 OnePerLine); 4481 verifyFormat("MyClass::MyClass(int var) :\n" 4482 " some_var_(var), // 4 space indent\n" 4483 " some_other_var_(var + 1) { // lined up\n" 4484 "}", 4485 OnePerLine); 4486 verifyFormat("Constructor() :\n" 4487 " aaaaa(aaaaaa),\n" 4488 " aaaaa(aaaaaa),\n" 4489 " aaaaa(aaaaaa),\n" 4490 " aaaaa(aaaaaa),\n" 4491 " aaaaa(aaaaaa) {}", 4492 OnePerLine); 4493 verifyFormat("Constructor() :\n" 4494 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4495 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4496 OnePerLine); 4497 OnePerLine.BinPackParameters = false; 4498 verifyFormat( 4499 "Constructor() :\n" 4500 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4501 " aaaaaaaaaaa().aaa(),\n" 4502 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4503 OnePerLine); 4504 OnePerLine.ColumnLimit = 60; 4505 verifyFormat("Constructor() :\n" 4506 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4507 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4508 OnePerLine); 4509 4510 EXPECT_EQ("Constructor() :\n" 4511 " // Comment forcing unwanted break.\n" 4512 " aaaa(aaaa) {}", 4513 format("Constructor() :\n" 4514 " // Comment forcing unwanted break.\n" 4515 " aaaa(aaaa) {}", 4516 Style)); 4517 4518 Style.ColumnLimit = 0; 4519 verifyFormat("SomeClass::Constructor() :\n" 4520 " a(a) {}", 4521 Style); 4522 verifyFormat("SomeClass::Constructor() noexcept :\n" 4523 " a(a) {}", 4524 Style); 4525 verifyFormat("SomeClass::Constructor() :\n" 4526 " a(a), b(b), c(c) {}", 4527 Style); 4528 verifyFormat("SomeClass::Constructor() :\n" 4529 " a(a) {\n" 4530 " foo();\n" 4531 " bar();\n" 4532 "}", 4533 Style); 4534 4535 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4536 verifyFormat("SomeClass::Constructor() :\n" 4537 " a(a), b(b), c(c) {\n" 4538 "}", 4539 Style); 4540 verifyFormat("SomeClass::Constructor() :\n" 4541 " a(a) {\n" 4542 "}", 4543 Style); 4544 4545 Style.ColumnLimit = 80; 4546 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4547 Style.ConstructorInitializerIndentWidth = 2; 4548 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", 4549 Style); 4550 verifyFormat("SomeClass::Constructor() :\n" 4551 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4552 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 4553 Style); 4554 4555 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as well 4556 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 4557 verifyFormat("class SomeClass\n" 4558 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4559 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4560 Style); 4561 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 4562 verifyFormat("class SomeClass\n" 4563 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4564 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4565 Style); 4566 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 4567 verifyFormat("class SomeClass :\n" 4568 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4569 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4570 Style); 4571 } 4572 4573 #ifndef EXPENSIVE_CHECKS 4574 // Expensive checks enables libstdc++ checking which includes validating the 4575 // state of ranges used in std::priority_queue - this blows out the 4576 // runtime/scalability of the function and makes this test unacceptably slow. 4577 TEST_F(FormatTest, MemoizationTests) { 4578 // This breaks if the memoization lookup does not take \c Indent and 4579 // \c LastSpace into account. 4580 verifyFormat( 4581 "extern CFRunLoopTimerRef\n" 4582 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 4583 " CFTimeInterval interval, CFOptionFlags flags,\n" 4584 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 4585 " CFRunLoopTimerContext *context) {}"); 4586 4587 // Deep nesting somewhat works around our memoization. 4588 verifyFormat( 4589 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4590 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4591 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4592 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4593 " aaaaa())))))))))))))))))))))))))))))))))))))));", 4594 getLLVMStyleWithColumns(65)); 4595 verifyFormat( 4596 "aaaaa(\n" 4597 " aaaaa,\n" 4598 " aaaaa(\n" 4599 " aaaaa,\n" 4600 " aaaaa(\n" 4601 " aaaaa,\n" 4602 " aaaaa(\n" 4603 " aaaaa,\n" 4604 " aaaaa(\n" 4605 " aaaaa,\n" 4606 " aaaaa(\n" 4607 " aaaaa,\n" 4608 " aaaaa(\n" 4609 " aaaaa,\n" 4610 " aaaaa(\n" 4611 " aaaaa,\n" 4612 " aaaaa(\n" 4613 " aaaaa,\n" 4614 " aaaaa(\n" 4615 " aaaaa,\n" 4616 " aaaaa(\n" 4617 " aaaaa,\n" 4618 " aaaaa(\n" 4619 " aaaaa,\n" 4620 " aaaaa))))))))))));", 4621 getLLVMStyleWithColumns(65)); 4622 verifyFormat( 4623 "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" 4624 " a),\n" 4625 " a),\n" 4626 " a),\n" 4627 " a),\n" 4628 " a),\n" 4629 " a),\n" 4630 " a),\n" 4631 " a),\n" 4632 " a),\n" 4633 " a),\n" 4634 " a),\n" 4635 " a),\n" 4636 " a),\n" 4637 " a),\n" 4638 " a),\n" 4639 " a),\n" 4640 " a)", 4641 getLLVMStyleWithColumns(65)); 4642 4643 // This test takes VERY long when memoization is broken. 4644 FormatStyle OnePerLine = getLLVMStyle(); 4645 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4646 OnePerLine.BinPackParameters = false; 4647 std::string input = "Constructor()\n" 4648 " : aaaa(a,\n"; 4649 for (unsigned i = 0, e = 80; i != e; ++i) { 4650 input += " a,\n"; 4651 } 4652 input += " a) {}"; 4653 verifyFormat(input, OnePerLine); 4654 } 4655 #endif 4656 4657 TEST_F(FormatTest, BreaksAsHighAsPossible) { 4658 verifyFormat( 4659 "void f() {\n" 4660 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 4661 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 4662 " f();\n" 4663 "}"); 4664 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 4665 " Intervals[i - 1].getRange().getLast()) {\n}"); 4666 } 4667 4668 TEST_F(FormatTest, BreaksFunctionDeclarations) { 4669 // Principially, we break function declarations in a certain order: 4670 // 1) break amongst arguments. 4671 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 4672 " Cccccccccccccc cccccccccccccc);"); 4673 verifyFormat("template <class TemplateIt>\n" 4674 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 4675 " TemplateIt *stop) {}"); 4676 4677 // 2) break after return type. 4678 verifyFormat( 4679 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4680 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 4681 getGoogleStyle()); 4682 4683 // 3) break after (. 4684 verifyFormat( 4685 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 4686 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 4687 getGoogleStyle()); 4688 4689 // 4) break before after nested name specifiers. 4690 verifyFormat( 4691 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4692 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 4693 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 4694 getGoogleStyle()); 4695 4696 // However, there are exceptions, if a sufficient amount of lines can be 4697 // saved. 4698 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 4699 // more adjusting. 4700 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4701 " Cccccccccccccc cccccccccc,\n" 4702 " Cccccccccccccc cccccccccc,\n" 4703 " Cccccccccccccc cccccccccc,\n" 4704 " Cccccccccccccc cccccccccc);"); 4705 verifyFormat( 4706 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4707 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4708 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4709 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 4710 getGoogleStyle()); 4711 verifyFormat( 4712 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4713 " Cccccccccccccc cccccccccc,\n" 4714 " Cccccccccccccc cccccccccc,\n" 4715 " Cccccccccccccc cccccccccc,\n" 4716 " Cccccccccccccc cccccccccc,\n" 4717 " Cccccccccccccc cccccccccc,\n" 4718 " Cccccccccccccc cccccccccc);"); 4719 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4720 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4721 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4722 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4723 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 4724 4725 // Break after multi-line parameters. 4726 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4727 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4728 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4729 " bbbb bbbb);"); 4730 verifyFormat("void SomeLoooooooooooongFunction(\n" 4731 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 4732 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4733 " int bbbbbbbbbbbbb);"); 4734 4735 // Treat overloaded operators like other functions. 4736 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4737 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 4738 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4739 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 4740 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4741 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 4742 verifyGoogleFormat( 4743 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 4744 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4745 verifyGoogleFormat( 4746 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 4747 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4748 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4749 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4750 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 4751 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4752 verifyGoogleFormat( 4753 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 4754 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4755 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 4756 verifyGoogleFormat( 4757 "template <typename T>\n" 4758 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4759 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 4760 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 4761 4762 FormatStyle Style = getLLVMStyle(); 4763 Style.PointerAlignment = FormatStyle::PAS_Left; 4764 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4765 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 4766 Style); 4767 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 4768 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4769 Style); 4770 } 4771 4772 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 4773 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 4774 // Prefer keeping `::` followed by `operator` together. 4775 EXPECT_EQ("const aaaa::bbbbbbb &\n" 4776 "ccccccccc::operator++() {\n" 4777 " stuff();\n" 4778 "}", 4779 format("const aaaa::bbbbbbb\n" 4780 "&ccccccccc::operator++() { stuff(); }", 4781 getLLVMStyleWithColumns(40))); 4782 } 4783 4784 TEST_F(FormatTest, TrailingReturnType) { 4785 verifyFormat("auto foo() -> int;\n"); 4786 verifyFormat("struct S {\n" 4787 " auto bar() const -> int;\n" 4788 "};"); 4789 verifyFormat("template <size_t Order, typename T>\n" 4790 "auto load_img(const std::string &filename)\n" 4791 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 4792 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 4793 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 4794 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 4795 verifyFormat("template <typename T>\n" 4796 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 4797 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 4798 4799 // Not trailing return types. 4800 verifyFormat("void f() { auto a = b->c(); }"); 4801 } 4802 4803 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 4804 // Avoid breaking before trailing 'const' or other trailing annotations, if 4805 // they are not function-like. 4806 FormatStyle Style = getGoogleStyle(); 4807 Style.ColumnLimit = 47; 4808 verifyFormat("void someLongFunction(\n" 4809 " int someLoooooooooooooongParameter) const {\n}", 4810 getLLVMStyleWithColumns(47)); 4811 verifyFormat("LoooooongReturnType\n" 4812 "someLoooooooongFunction() const {}", 4813 getLLVMStyleWithColumns(47)); 4814 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 4815 " const {}", 4816 Style); 4817 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4818 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 4819 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4820 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 4821 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4822 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 4823 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 4824 " aaaaaaaaaaa aaaaa) const override;"); 4825 verifyGoogleFormat( 4826 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4827 " const override;"); 4828 4829 // Even if the first parameter has to be wrapped. 4830 verifyFormat("void someLongFunction(\n" 4831 " int someLongParameter) const {}", 4832 getLLVMStyleWithColumns(46)); 4833 verifyFormat("void someLongFunction(\n" 4834 " int someLongParameter) const {}", 4835 Style); 4836 verifyFormat("void someLongFunction(\n" 4837 " int someLongParameter) override {}", 4838 Style); 4839 verifyFormat("void someLongFunction(\n" 4840 " int someLongParameter) OVERRIDE {}", 4841 Style); 4842 verifyFormat("void someLongFunction(\n" 4843 " int someLongParameter) final {}", 4844 Style); 4845 verifyFormat("void someLongFunction(\n" 4846 " int someLongParameter) FINAL {}", 4847 Style); 4848 verifyFormat("void someLongFunction(\n" 4849 " int parameter) const override {}", 4850 Style); 4851 4852 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 4853 verifyFormat("void someLongFunction(\n" 4854 " int someLongParameter) const\n" 4855 "{\n" 4856 "}", 4857 Style); 4858 4859 // Unless these are unknown annotations. 4860 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 4861 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4862 " LONG_AND_UGLY_ANNOTATION;"); 4863 4864 // Breaking before function-like trailing annotations is fine to keep them 4865 // close to their arguments. 4866 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4867 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 4868 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 4869 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 4870 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 4871 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 4872 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 4873 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 4874 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 4875 4876 verifyFormat( 4877 "void aaaaaaaaaaaaaaaaaa()\n" 4878 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 4879 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 4880 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4881 " __attribute__((unused));"); 4882 verifyGoogleFormat( 4883 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4884 " GUARDED_BY(aaaaaaaaaaaa);"); 4885 verifyGoogleFormat( 4886 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4887 " GUARDED_BY(aaaaaaaaaaaa);"); 4888 verifyGoogleFormat( 4889 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 4890 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4891 verifyGoogleFormat( 4892 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 4893 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 4894 } 4895 4896 TEST_F(FormatTest, FunctionAnnotations) { 4897 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4898 "int OldFunction(const string ¶meter) {}"); 4899 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4900 "string OldFunction(const string ¶meter) {}"); 4901 verifyFormat("template <typename T>\n" 4902 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4903 "string OldFunction(const string ¶meter) {}"); 4904 4905 // Not function annotations. 4906 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4907 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 4908 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 4909 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 4910 verifyFormat("MACRO(abc).function() // wrap\n" 4911 " << abc;"); 4912 verifyFormat("MACRO(abc)->function() // wrap\n" 4913 " << abc;"); 4914 verifyFormat("MACRO(abc)::function() // wrap\n" 4915 " << abc;"); 4916 } 4917 4918 TEST_F(FormatTest, BreaksDesireably) { 4919 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 4920 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 4921 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 4922 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4923 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 4924 "}"); 4925 4926 verifyFormat( 4927 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4928 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4929 4930 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4931 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4932 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4933 4934 verifyFormat( 4935 "aaaaaaaa(aaaaaaaaaaaaa,\n" 4936 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4937 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 4938 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4939 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 4940 4941 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4942 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4943 4944 verifyFormat( 4945 "void f() {\n" 4946 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 4947 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 4948 "}"); 4949 verifyFormat( 4950 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4951 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4952 verifyFormat( 4953 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4954 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4955 verifyFormat( 4956 "aaaaaa(aaa,\n" 4957 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4958 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4959 " aaaa);"); 4960 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4961 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4962 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4963 4964 // Indent consistently independent of call expression and unary operator. 4965 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4966 " dddddddddddddddddddddddddddddd));"); 4967 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4968 " dddddddddddddddddddddddddddddd));"); 4969 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 4970 " dddddddddddddddddddddddddddddd));"); 4971 4972 // This test case breaks on an incorrect memoization, i.e. an optimization not 4973 // taking into account the StopAt value. 4974 verifyFormat( 4975 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 4976 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 4977 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 4978 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4979 4980 verifyFormat("{\n {\n {\n" 4981 " Annotation.SpaceRequiredBefore =\n" 4982 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 4983 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 4984 " }\n }\n}"); 4985 4986 // Break on an outer level if there was a break on an inner level. 4987 EXPECT_EQ("f(g(h(a, // comment\n" 4988 " b, c),\n" 4989 " d, e),\n" 4990 " x, y);", 4991 format("f(g(h(a, // comment\n" 4992 " b, c), d, e), x, y);")); 4993 4994 // Prefer breaking similar line breaks. 4995 verifyFormat( 4996 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 4997 " NSTrackingMouseEnteredAndExited |\n" 4998 " NSTrackingActiveAlways;"); 4999 } 5000 5001 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 5002 FormatStyle NoBinPacking = getGoogleStyle(); 5003 NoBinPacking.BinPackParameters = false; 5004 NoBinPacking.BinPackArguments = true; 5005 verifyFormat("void f() {\n" 5006 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 5007 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5008 "}", 5009 NoBinPacking); 5010 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 5011 " int aaaaaaaaaaaaaaaaaaaa,\n" 5012 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5013 NoBinPacking); 5014 5015 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5016 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5017 " vector<int> bbbbbbbbbbbbbbb);", 5018 NoBinPacking); 5019 // FIXME: This behavior difference is probably not wanted. However, currently 5020 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 5021 // template arguments from BreakBeforeParameter being set because of the 5022 // one-per-line formatting. 5023 verifyFormat( 5024 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5025 " aaaaaaaaaa> aaaaaaaaaa);", 5026 NoBinPacking); 5027 verifyFormat( 5028 "void fffffffffff(\n" 5029 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 5030 " aaaaaaaaaa);"); 5031 } 5032 5033 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 5034 FormatStyle NoBinPacking = getGoogleStyle(); 5035 NoBinPacking.BinPackParameters = false; 5036 NoBinPacking.BinPackArguments = false; 5037 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 5038 " aaaaaaaaaaaaaaaaaaaa,\n" 5039 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 5040 NoBinPacking); 5041 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 5042 " aaaaaaaaaaaaa,\n" 5043 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 5044 NoBinPacking); 5045 verifyFormat( 5046 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5047 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5048 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5049 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5050 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 5051 NoBinPacking); 5052 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5053 " .aaaaaaaaaaaaaaaaaa();", 5054 NoBinPacking); 5055 verifyFormat("void f() {\n" 5056 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5057 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 5058 "}", 5059 NoBinPacking); 5060 5061 verifyFormat( 5062 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5063 " aaaaaaaaaaaa,\n" 5064 " aaaaaaaaaaaa);", 5065 NoBinPacking); 5066 verifyFormat( 5067 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 5068 " ddddddddddddddddddddddddddddd),\n" 5069 " test);", 5070 NoBinPacking); 5071 5072 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5073 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 5074 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 5075 " aaaaaaaaaaaaaaaaaa;", 5076 NoBinPacking); 5077 verifyFormat("a(\"a\"\n" 5078 " \"a\",\n" 5079 " a);"); 5080 5081 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5082 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 5083 " aaaaaaaaa,\n" 5084 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5085 NoBinPacking); 5086 verifyFormat( 5087 "void f() {\n" 5088 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5089 " .aaaaaaa();\n" 5090 "}", 5091 NoBinPacking); 5092 verifyFormat( 5093 "template <class SomeType, class SomeOtherType>\n" 5094 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 5095 NoBinPacking); 5096 } 5097 5098 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 5099 FormatStyle Style = getLLVMStyleWithColumns(15); 5100 Style.ExperimentalAutoDetectBinPacking = true; 5101 EXPECT_EQ("aaa(aaaa,\n" 5102 " aaaa,\n" 5103 " aaaa);\n" 5104 "aaa(aaaa,\n" 5105 " aaaa,\n" 5106 " aaaa);", 5107 format("aaa(aaaa,\n" // one-per-line 5108 " aaaa,\n" 5109 " aaaa );\n" 5110 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5111 Style)); 5112 EXPECT_EQ("aaa(aaaa, aaaa,\n" 5113 " aaaa);\n" 5114 "aaa(aaaa, aaaa,\n" 5115 " aaaa);", 5116 format("aaa(aaaa, aaaa,\n" // bin-packed 5117 " aaaa );\n" 5118 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5119 Style)); 5120 } 5121 5122 TEST_F(FormatTest, FormatsBuilderPattern) { 5123 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 5124 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 5125 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 5126 " .StartsWith(\".init\", ORDER_INIT)\n" 5127 " .StartsWith(\".fini\", ORDER_FINI)\n" 5128 " .StartsWith(\".hash\", ORDER_HASH)\n" 5129 " .Default(ORDER_TEXT);\n"); 5130 5131 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 5132 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 5133 verifyFormat( 5134 "aaaaaaa->aaaaaaa\n" 5135 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5136 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5137 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5138 verifyFormat( 5139 "aaaaaaa->aaaaaaa\n" 5140 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5141 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5142 verifyFormat( 5143 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 5144 " aaaaaaaaaaaaaa);"); 5145 verifyFormat( 5146 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 5147 " aaaaaa->aaaaaaaaaaaa()\n" 5148 " ->aaaaaaaaaaaaaaaa(\n" 5149 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5150 " ->aaaaaaaaaaaaaaaaa();"); 5151 verifyGoogleFormat( 5152 "void f() {\n" 5153 " someo->Add((new util::filetools::Handler(dir))\n" 5154 " ->OnEvent1(NewPermanentCallback(\n" 5155 " this, &HandlerHolderClass::EventHandlerCBA))\n" 5156 " ->OnEvent2(NewPermanentCallback(\n" 5157 " this, &HandlerHolderClass::EventHandlerCBB))\n" 5158 " ->OnEvent3(NewPermanentCallback(\n" 5159 " this, &HandlerHolderClass::EventHandlerCBC))\n" 5160 " ->OnEvent5(NewPermanentCallback(\n" 5161 " this, &HandlerHolderClass::EventHandlerCBD))\n" 5162 " ->OnEvent6(NewPermanentCallback(\n" 5163 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 5164 "}"); 5165 5166 verifyFormat( 5167 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 5168 verifyFormat("aaaaaaaaaaaaaaa()\n" 5169 " .aaaaaaaaaaaaaaa()\n" 5170 " .aaaaaaaaaaaaaaa()\n" 5171 " .aaaaaaaaaaaaaaa()\n" 5172 " .aaaaaaaaaaaaaaa();"); 5173 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5174 " .aaaaaaaaaaaaaaa()\n" 5175 " .aaaaaaaaaaaaaaa()\n" 5176 " .aaaaaaaaaaaaaaa();"); 5177 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5178 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5179 " .aaaaaaaaaaaaaaa();"); 5180 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 5181 " ->aaaaaaaaaaaaaae(0)\n" 5182 " ->aaaaaaaaaaaaaaa();"); 5183 5184 // Don't linewrap after very short segments. 5185 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5186 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5187 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5188 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5189 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5190 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5191 verifyFormat("aaa()\n" 5192 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5193 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5194 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5195 5196 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5197 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5198 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 5199 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5200 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 5201 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 5202 5203 // Prefer not to break after empty parentheses. 5204 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 5205 " First->LastNewlineOffset);"); 5206 5207 // Prefer not to create "hanging" indents. 5208 verifyFormat( 5209 "return !soooooooooooooome_map\n" 5210 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5211 " .second;"); 5212 verifyFormat( 5213 "return aaaaaaaaaaaaaaaa\n" 5214 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 5215 " .aaaa(aaaaaaaaaaaaaa);"); 5216 // No hanging indent here. 5217 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5218 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5219 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5220 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5221 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5222 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5223 getLLVMStyleWithColumns(60)); 5224 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5225 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5226 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5227 getLLVMStyleWithColumns(59)); 5228 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5229 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5230 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5231 5232 // Dont break if only closing statements before member call 5233 verifyFormat("test() {\n" 5234 " ([]() -> {\n" 5235 " int b = 32;\n" 5236 " return 3;\n" 5237 " }).foo();\n" 5238 "}"); 5239 verifyFormat("test() {\n" 5240 " (\n" 5241 " []() -> {\n" 5242 " int b = 32;\n" 5243 " return 3;\n" 5244 " },\n" 5245 " foo, bar)\n" 5246 " .foo();\n" 5247 "}"); 5248 verifyFormat("test() {\n" 5249 " ([]() -> {\n" 5250 " int b = 32;\n" 5251 " return 3;\n" 5252 " })\n" 5253 " .foo()\n" 5254 " .bar();\n" 5255 "}"); 5256 verifyFormat("test() {\n" 5257 " ([]() -> {\n" 5258 " int b = 32;\n" 5259 " return 3;\n" 5260 " })\n" 5261 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5262 " \"bbbb\");\n" 5263 "}", 5264 getLLVMStyleWithColumns(30)); 5265 } 5266 5267 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5268 verifyFormat( 5269 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5270 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5271 verifyFormat( 5272 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5273 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5274 5275 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5276 " ccccccccccccccccccccccccc) {\n}"); 5277 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5278 " ccccccccccccccccccccccccc) {\n}"); 5279 5280 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5281 " ccccccccccccccccccccccccc) {\n}"); 5282 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5283 " ccccccccccccccccccccccccc) {\n}"); 5284 5285 verifyFormat( 5286 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5287 " ccccccccccccccccccccccccc) {\n}"); 5288 verifyFormat( 5289 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5290 " ccccccccccccccccccccccccc) {\n}"); 5291 5292 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5293 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5294 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5295 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5296 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5297 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5298 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5299 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5300 5301 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5302 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5303 " aaaaaaaaaaaaaaa != aa) {\n}"); 5304 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5305 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5306 " aaaaaaaaaaaaaaa != aa) {\n}"); 5307 } 5308 5309 TEST_F(FormatTest, BreaksAfterAssignments) { 5310 verifyFormat( 5311 "unsigned Cost =\n" 5312 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5313 " SI->getPointerAddressSpaceee());\n"); 5314 verifyFormat( 5315 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5316 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5317 5318 verifyFormat( 5319 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5320 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5321 verifyFormat("unsigned OriginalStartColumn =\n" 5322 " SourceMgr.getSpellingColumnNumber(\n" 5323 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5324 " 1;"); 5325 } 5326 5327 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5328 FormatStyle Style = getLLVMStyle(); 5329 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5330 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5331 Style); 5332 5333 Style.PenaltyBreakAssignment = 20; 5334 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5335 " cccccccccccccccccccccccccc;", 5336 Style); 5337 } 5338 5339 TEST_F(FormatTest, AlignsAfterAssignments) { 5340 verifyFormat( 5341 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5342 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5343 verifyFormat( 5344 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5345 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5346 verifyFormat( 5347 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5348 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5349 verifyFormat( 5350 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5351 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5352 verifyFormat( 5353 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5354 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5355 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5356 } 5357 5358 TEST_F(FormatTest, AlignsAfterReturn) { 5359 verifyFormat( 5360 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5361 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5362 verifyFormat( 5363 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5364 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5365 verifyFormat( 5366 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5367 " aaaaaaaaaaaaaaaaaaaaaa();"); 5368 verifyFormat( 5369 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5370 " aaaaaaaaaaaaaaaaaaaaaa());"); 5371 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5372 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5373 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5374 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5375 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5376 verifyFormat("return\n" 5377 " // true if code is one of a or b.\n" 5378 " code == a || code == b;"); 5379 } 5380 5381 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5382 verifyFormat( 5383 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5384 " aaaaaaaaa aaaaaaa) {}"); 5385 verifyFormat( 5386 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5387 " aaaaaaaaaaa aaaaaaaaa);"); 5388 verifyFormat( 5389 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5390 " aaaaaaaaaaaaaaaaaaaaa));"); 5391 FormatStyle Style = getLLVMStyle(); 5392 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5393 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5394 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5395 Style); 5396 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5397 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5398 Style); 5399 verifyFormat("SomeLongVariableName->someFunction(\n" 5400 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5401 Style); 5402 verifyFormat( 5403 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5404 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5405 Style); 5406 verifyFormat( 5407 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5408 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5409 Style); 5410 verifyFormat( 5411 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5412 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5413 Style); 5414 5415 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5416 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5417 " b));", 5418 Style); 5419 5420 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5421 Style.BinPackArguments = false; 5422 Style.BinPackParameters = false; 5423 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5424 " aaaaaaaaaaa aaaaaaaa,\n" 5425 " aaaaaaaaa aaaaaaa,\n" 5426 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5427 Style); 5428 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5429 " aaaaaaaaaaa aaaaaaaaa,\n" 5430 " aaaaaaaaaaa aaaaaaaaa,\n" 5431 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5432 Style); 5433 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5434 " aaaaaaaaaaaaaaa,\n" 5435 " aaaaaaaaaaaaaaaaaaaaa,\n" 5436 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5437 Style); 5438 verifyFormat( 5439 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5440 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5441 Style); 5442 verifyFormat( 5443 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5444 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5445 Style); 5446 verifyFormat( 5447 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5448 " aaaaaaaaaaaaaaaaaaaaa(\n" 5449 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5450 " aaaaaaaaaaaaaaaa);", 5451 Style); 5452 verifyFormat( 5453 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5454 " aaaaaaaaaaaaaaaaaaaaa(\n" 5455 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5456 " aaaaaaaaaaaaaaaa);", 5457 Style); 5458 } 5459 5460 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5461 FormatStyle Style = getLLVMStyleWithColumns(40); 5462 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5463 " bbbbbbbbbbbbbbbbbbbbbb);", 5464 Style); 5465 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5466 Style.AlignOperands = false; 5467 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5468 " bbbbbbbbbbbbbbbbbbbbbb);", 5469 Style); 5470 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5471 Style.AlignOperands = true; 5472 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5473 " bbbbbbbbbbbbbbbbbbbbbb);", 5474 Style); 5475 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5476 Style.AlignOperands = false; 5477 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5478 " bbbbbbbbbbbbbbbbbbbbbb);", 5479 Style); 5480 } 5481 5482 TEST_F(FormatTest, BreaksConditionalExpressions) { 5483 verifyFormat( 5484 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5485 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5486 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5487 verifyFormat( 5488 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5489 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5490 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5491 verifyFormat( 5492 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5493 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5494 verifyFormat( 5495 "aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5496 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5497 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5498 verifyFormat( 5499 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5500 " : aaaaaaaaaaaaa);"); 5501 verifyFormat( 5502 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5503 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5504 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5505 " aaaaaaaaaaaaa);"); 5506 verifyFormat( 5507 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5508 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5509 " aaaaaaaaaaaaa);"); 5510 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5511 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5512 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5513 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5514 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5515 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5516 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5517 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5518 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5519 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5520 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5521 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5522 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5523 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5524 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5525 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5526 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5527 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5528 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5529 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5530 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5531 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5532 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5533 " : aaaaaaaaaaaaaaaa;"); 5534 verifyFormat( 5535 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5536 " ? aaaaaaaaaaaaaaa\n" 5537 " : aaaaaaaaaaaaaaa;"); 5538 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5539 " aaaaaaaaa\n" 5540 " ? b\n" 5541 " : c);"); 5542 verifyFormat("return aaaa == bbbb\n" 5543 " // comment\n" 5544 " ? aaaa\n" 5545 " : bbbb;"); 5546 verifyFormat("unsigned Indent =\n" 5547 " format(TheLine.First,\n" 5548 " IndentForLevel[TheLine.Level] >= 0\n" 5549 " ? IndentForLevel[TheLine.Level]\n" 5550 " : TheLine * 2,\n" 5551 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5552 getLLVMStyleWithColumns(60)); 5553 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5554 " ? aaaaaaaaaaaaaaa\n" 5555 " : bbbbbbbbbbbbbbb //\n" 5556 " ? ccccccccccccccc\n" 5557 " : ddddddddddddddd;"); 5558 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5559 " ? aaaaaaaaaaaaaaa\n" 5560 " : (bbbbbbbbbbbbbbb //\n" 5561 " ? ccccccccccccccc\n" 5562 " : ddddddddddddddd);"); 5563 verifyFormat( 5564 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5565 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5566 " aaaaaaaaaaaaaaaaaaaaa +\n" 5567 " aaaaaaaaaaaaaaaaaaaaa\n" 5568 " : aaaaaaaaaa;"); 5569 verifyFormat( 5570 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5571 " : aaaaaaaaaaaaaaaaaaaaaa\n" 5572 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5573 5574 FormatStyle NoBinPacking = getLLVMStyle(); 5575 NoBinPacking.BinPackArguments = false; 5576 verifyFormat( 5577 "void f() {\n" 5578 " g(aaa,\n" 5579 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5580 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5581 " ? aaaaaaaaaaaaaaa\n" 5582 " : aaaaaaaaaaaaaaa);\n" 5583 "}", 5584 NoBinPacking); 5585 verifyFormat( 5586 "void f() {\n" 5587 " g(aaa,\n" 5588 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5589 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5590 " ?: aaaaaaaaaaaaaaa);\n" 5591 "}", 5592 NoBinPacking); 5593 5594 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 5595 " // comment.\n" 5596 " ccccccccccccccccccccccccccccccccccccccc\n" 5597 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5598 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 5599 5600 // Assignments in conditional expressions. Apparently not uncommon :-(. 5601 verifyFormat("return a != b\n" 5602 " // comment\n" 5603 " ? a = b\n" 5604 " : a = b;"); 5605 verifyFormat("return a != b\n" 5606 " // comment\n" 5607 " ? a = a != b\n" 5608 " // comment\n" 5609 " ? a = b\n" 5610 " : a\n" 5611 " : a;\n"); 5612 verifyFormat("return a != b\n" 5613 " // comment\n" 5614 " ? a\n" 5615 " : a = a != b\n" 5616 " // comment\n" 5617 " ? a = b\n" 5618 " : a;"); 5619 } 5620 5621 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 5622 FormatStyle Style = getLLVMStyle(); 5623 Style.BreakBeforeTernaryOperators = false; 5624 Style.ColumnLimit = 70; 5625 verifyFormat( 5626 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5627 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5628 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5629 Style); 5630 verifyFormat( 5631 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5632 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5633 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5634 Style); 5635 verifyFormat( 5636 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5637 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5638 Style); 5639 verifyFormat( 5640 "aaaa(aaaaaaaa, aaaaaaaaaa,\n" 5641 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5642 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5643 Style); 5644 verifyFormat( 5645 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 5646 " aaaaaaaaaaaaa);", 5647 Style); 5648 verifyFormat( 5649 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5650 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5651 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5652 " aaaaaaaaaaaaa);", 5653 Style); 5654 verifyFormat( 5655 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5656 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5657 " aaaaaaaaaaaaa);", 5658 Style); 5659 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5660 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5661 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5662 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5663 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5664 Style); 5665 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5666 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5667 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5668 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5669 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5670 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5671 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5672 Style); 5673 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5674 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 5675 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5676 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5677 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5678 Style); 5679 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5680 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5681 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5682 Style); 5683 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5684 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5685 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5686 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5687 Style); 5688 verifyFormat( 5689 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5690 " aaaaaaaaaaaaaaa :\n" 5691 " aaaaaaaaaaaaaaa;", 5692 Style); 5693 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5694 " aaaaaaaaa ?\n" 5695 " b :\n" 5696 " c);", 5697 Style); 5698 verifyFormat("unsigned Indent =\n" 5699 " format(TheLine.First,\n" 5700 " IndentForLevel[TheLine.Level] >= 0 ?\n" 5701 " IndentForLevel[TheLine.Level] :\n" 5702 " TheLine * 2,\n" 5703 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5704 Style); 5705 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5706 " aaaaaaaaaaaaaaa :\n" 5707 " bbbbbbbbbbbbbbb ? //\n" 5708 " ccccccccccccccc :\n" 5709 " ddddddddddddddd;", 5710 Style); 5711 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5712 " aaaaaaaaaaaaaaa :\n" 5713 " (bbbbbbbbbbbbbbb ? //\n" 5714 " ccccccccccccccc :\n" 5715 " ddddddddddddddd);", 5716 Style); 5717 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5718 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 5719 " ccccccccccccccccccccccccccc;", 5720 Style); 5721 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5722 " aaaaa :\n" 5723 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 5724 Style); 5725 } 5726 5727 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 5728 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 5729 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 5730 verifyFormat("bool a = true, b = false;"); 5731 5732 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5733 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 5734 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 5735 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 5736 verifyFormat( 5737 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 5738 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 5739 " d = e && f;"); 5740 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 5741 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 5742 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5743 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 5744 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 5745 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 5746 5747 FormatStyle Style = getGoogleStyle(); 5748 Style.PointerAlignment = FormatStyle::PAS_Left; 5749 Style.DerivePointerAlignment = false; 5750 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5751 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 5752 " *b = bbbbbbbbbbbbbbbbbbb;", 5753 Style); 5754 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5755 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 5756 Style); 5757 verifyFormat("vector<int*> a, b;", Style); 5758 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 5759 } 5760 5761 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 5762 verifyFormat("arr[foo ? bar : baz];"); 5763 verifyFormat("f()[foo ? bar : baz];"); 5764 verifyFormat("(a + b)[foo ? bar : baz];"); 5765 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 5766 } 5767 5768 TEST_F(FormatTest, AlignsStringLiterals) { 5769 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 5770 " \"short literal\");"); 5771 verifyFormat( 5772 "looooooooooooooooooooooooongFunction(\n" 5773 " \"short literal\"\n" 5774 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 5775 verifyFormat("someFunction(\"Always break between multi-line\"\n" 5776 " \" string literals\",\n" 5777 " and, other, parameters);"); 5778 EXPECT_EQ("fun + \"1243\" /* comment */\n" 5779 " \"5678\";", 5780 format("fun + \"1243\" /* comment */\n" 5781 " \"5678\";", 5782 getLLVMStyleWithColumns(28))); 5783 EXPECT_EQ( 5784 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 5785 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 5786 " \"aaaaaaaaaaaaaaaa\";", 5787 format("aaaaaa =" 5788 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 5789 "aaaaaaaaaaaaaaaaaaaaa\" " 5790 "\"aaaaaaaaaaaaaaaa\";")); 5791 verifyFormat("a = a + \"a\"\n" 5792 " \"a\"\n" 5793 " \"a\";"); 5794 verifyFormat("f(\"a\", \"b\"\n" 5795 " \"c\");"); 5796 5797 verifyFormat( 5798 "#define LL_FORMAT \"ll\"\n" 5799 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 5800 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 5801 5802 verifyFormat("#define A(X) \\\n" 5803 " \"aaaaa\" #X \"bbbbbb\" \\\n" 5804 " \"ccccc\"", 5805 getLLVMStyleWithColumns(23)); 5806 verifyFormat("#define A \"def\"\n" 5807 "f(\"abc\" A \"ghi\"\n" 5808 " \"jkl\");"); 5809 5810 verifyFormat("f(L\"a\"\n" 5811 " L\"b\");"); 5812 verifyFormat("#define A(X) \\\n" 5813 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 5814 " L\"ccccc\"", 5815 getLLVMStyleWithColumns(25)); 5816 5817 verifyFormat("f(@\"a\"\n" 5818 " @\"b\");"); 5819 verifyFormat("NSString s = @\"a\"\n" 5820 " @\"b\"\n" 5821 " @\"c\";"); 5822 verifyFormat("NSString s = @\"a\"\n" 5823 " \"b\"\n" 5824 " \"c\";"); 5825 } 5826 5827 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 5828 FormatStyle Style = getLLVMStyle(); 5829 // No declarations or definitions should be moved to own line. 5830 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 5831 verifyFormat("class A {\n" 5832 " int f() { return 1; }\n" 5833 " int g();\n" 5834 "};\n" 5835 "int f() { return 1; }\n" 5836 "int g();\n", 5837 Style); 5838 5839 // All declarations and definitions should have the return type moved to its 5840 // own 5841 // line. 5842 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 5843 verifyFormat("class E {\n" 5844 " int\n" 5845 " f() {\n" 5846 " return 1;\n" 5847 " }\n" 5848 " int\n" 5849 " g();\n" 5850 "};\n" 5851 "int\n" 5852 "f() {\n" 5853 " return 1;\n" 5854 "}\n" 5855 "int\n" 5856 "g();\n", 5857 Style); 5858 5859 // Top-level definitions, and no kinds of declarations should have the 5860 // return type moved to its own line. 5861 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 5862 verifyFormat("class B {\n" 5863 " int f() { return 1; }\n" 5864 " int g();\n" 5865 "};\n" 5866 "int\n" 5867 "f() {\n" 5868 " return 1;\n" 5869 "}\n" 5870 "int g();\n", 5871 Style); 5872 5873 // Top-level definitions and declarations should have the return type moved 5874 // to its own line. 5875 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 5876 verifyFormat("class C {\n" 5877 " int f() { return 1; }\n" 5878 " int g();\n" 5879 "};\n" 5880 "int\n" 5881 "f() {\n" 5882 " return 1;\n" 5883 "}\n" 5884 "int\n" 5885 "g();\n", 5886 Style); 5887 5888 // All definitions should have the return type moved to its own line, but no 5889 // kinds of declarations. 5890 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 5891 verifyFormat("class D {\n" 5892 " int\n" 5893 " f() {\n" 5894 " return 1;\n" 5895 " }\n" 5896 " int g();\n" 5897 "};\n" 5898 "int\n" 5899 "f() {\n" 5900 " return 1;\n" 5901 "}\n" 5902 "int g();\n", 5903 Style); 5904 verifyFormat("const char *\n" 5905 "f(void) {\n" // Break here. 5906 " return \"\";\n" 5907 "}\n" 5908 "const char *bar(void);\n", // No break here. 5909 Style); 5910 verifyFormat("template <class T>\n" 5911 "T *\n" 5912 "f(T &c) {\n" // Break here. 5913 " return NULL;\n" 5914 "}\n" 5915 "template <class T> T *f(T &c);\n", // No break here. 5916 Style); 5917 verifyFormat("class C {\n" 5918 " int\n" 5919 " operator+() {\n" 5920 " return 1;\n" 5921 " }\n" 5922 " int\n" 5923 " operator()() {\n" 5924 " return 1;\n" 5925 " }\n" 5926 "};\n", 5927 Style); 5928 verifyFormat("void\n" 5929 "A::operator()() {}\n" 5930 "void\n" 5931 "A::operator>>() {}\n" 5932 "void\n" 5933 "A::operator+() {}\n", 5934 Style); 5935 verifyFormat("void *operator new(std::size_t s);", // No break here. 5936 Style); 5937 verifyFormat("void *\n" 5938 "operator new(std::size_t s) {}", 5939 Style); 5940 verifyFormat("void *\n" 5941 "operator delete[](void *ptr) {}", 5942 Style); 5943 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 5944 verifyFormat("const char *\n" 5945 "f(void)\n" // Break here. 5946 "{\n" 5947 " return \"\";\n" 5948 "}\n" 5949 "const char *bar(void);\n", // No break here. 5950 Style); 5951 verifyFormat("template <class T>\n" 5952 "T *\n" // Problem here: no line break 5953 "f(T &c)\n" // Break here. 5954 "{\n" 5955 " return NULL;\n" 5956 "}\n" 5957 "template <class T> T *f(T &c);\n", // No break here. 5958 Style); 5959 verifyFormat("int\n" 5960 "foo(A<bool> a)\n" 5961 "{\n" 5962 " return a;\n" 5963 "}\n", 5964 Style); 5965 verifyFormat("int\n" 5966 "foo(A<8> a)\n" 5967 "{\n" 5968 " return a;\n" 5969 "}\n", 5970 Style); 5971 verifyFormat("int\n" 5972 "foo(A<B<bool>, 8> a)\n" 5973 "{\n" 5974 " return a;\n" 5975 "}\n", 5976 Style); 5977 verifyFormat("int\n" 5978 "foo(A<B<8>, bool> a)\n" 5979 "{\n" 5980 " return a;\n" 5981 "}\n", 5982 Style); 5983 verifyFormat("int\n" 5984 "foo(A<B<bool>, bool> a)\n" 5985 "{\n" 5986 " return a;\n" 5987 "}\n", 5988 Style); 5989 verifyFormat("int\n" 5990 "foo(A<B<8>, 8> a)\n" 5991 "{\n" 5992 " return a;\n" 5993 "}\n", 5994 Style); 5995 5996 Style = getGNUStyle(); 5997 5998 // Test for comments at the end of function declarations. 5999 verifyFormat("void\n" 6000 "foo (int a, /*abc*/ int b) // def\n" 6001 "{\n" 6002 "}\n", 6003 Style); 6004 6005 verifyFormat("void\n" 6006 "foo (int a, /* abc */ int b) /* def */\n" 6007 "{\n" 6008 "}\n", 6009 Style); 6010 6011 // Definitions that should not break after return type 6012 verifyFormat("void foo (int a, int b); // def\n", Style); 6013 verifyFormat("void foo (int a, int b); /* def */\n", Style); 6014 verifyFormat("void foo (int a, int b);\n", Style); 6015 } 6016 6017 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 6018 FormatStyle NoBreak = getLLVMStyle(); 6019 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 6020 FormatStyle Break = getLLVMStyle(); 6021 Break.AlwaysBreakBeforeMultilineStrings = true; 6022 verifyFormat("aaaa = \"bbbb\"\n" 6023 " \"cccc\";", 6024 NoBreak); 6025 verifyFormat("aaaa =\n" 6026 " \"bbbb\"\n" 6027 " \"cccc\";", 6028 Break); 6029 verifyFormat("aaaa(\"bbbb\"\n" 6030 " \"cccc\");", 6031 NoBreak); 6032 verifyFormat("aaaa(\n" 6033 " \"bbbb\"\n" 6034 " \"cccc\");", 6035 Break); 6036 verifyFormat("aaaa(qqq, \"bbbb\"\n" 6037 " \"cccc\");", 6038 NoBreak); 6039 verifyFormat("aaaa(qqq,\n" 6040 " \"bbbb\"\n" 6041 " \"cccc\");", 6042 Break); 6043 verifyFormat("aaaa(qqq,\n" 6044 " L\"bbbb\"\n" 6045 " L\"cccc\");", 6046 Break); 6047 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 6048 " \"bbbb\"));", 6049 Break); 6050 verifyFormat("string s = someFunction(\n" 6051 " \"abc\"\n" 6052 " \"abc\");", 6053 Break); 6054 6055 // As we break before unary operators, breaking right after them is bad. 6056 verifyFormat("string foo = abc ? \"x\"\n" 6057 " \"blah blah blah blah blah blah\"\n" 6058 " : \"y\";", 6059 Break); 6060 6061 // Don't break if there is no column gain. 6062 verifyFormat("f(\"aaaa\"\n" 6063 " \"bbbb\");", 6064 Break); 6065 6066 // Treat literals with escaped newlines like multi-line string literals. 6067 EXPECT_EQ("x = \"a\\\n" 6068 "b\\\n" 6069 "c\";", 6070 format("x = \"a\\\n" 6071 "b\\\n" 6072 "c\";", 6073 NoBreak)); 6074 EXPECT_EQ("xxxx =\n" 6075 " \"a\\\n" 6076 "b\\\n" 6077 "c\";", 6078 format("xxxx = \"a\\\n" 6079 "b\\\n" 6080 "c\";", 6081 Break)); 6082 6083 EXPECT_EQ("NSString *const kString =\n" 6084 " @\"aaaa\"\n" 6085 " @\"bbbb\";", 6086 format("NSString *const kString = @\"aaaa\"\n" 6087 "@\"bbbb\";", 6088 Break)); 6089 6090 Break.ColumnLimit = 0; 6091 verifyFormat("const char *hello = \"hello llvm\";", Break); 6092 } 6093 6094 TEST_F(FormatTest, AlignsPipes) { 6095 verifyFormat( 6096 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6097 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6098 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6099 verifyFormat( 6100 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 6101 " << aaaaaaaaaaaaaaaaaaaa;"); 6102 verifyFormat( 6103 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6104 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6105 verifyFormat( 6106 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 6107 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6108 verifyFormat( 6109 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 6110 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 6111 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 6112 verifyFormat( 6113 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6114 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6115 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6116 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6117 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6118 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6119 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6120 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 6121 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 6122 verifyFormat( 6123 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6124 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6125 verifyFormat( 6126 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 6127 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6128 6129 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 6130 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 6131 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6132 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6133 " aaaaaaaaaaaaaaaaaaaaa)\n" 6134 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6135 verifyFormat("LOG_IF(aaa == //\n" 6136 " bbb)\n" 6137 " << a << b;"); 6138 6139 // But sometimes, breaking before the first "<<" is desirable. 6140 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6141 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 6142 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 6143 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6144 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6145 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 6146 " << BEF << IsTemplate << Description << E->getType();"); 6147 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6148 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6149 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6150 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6151 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6152 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6153 " << aaa;"); 6154 6155 verifyFormat( 6156 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6157 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6158 6159 // Incomplete string literal. 6160 EXPECT_EQ("llvm::errs() << \"\n" 6161 " << a;", 6162 format("llvm::errs() << \"\n<<a;")); 6163 6164 verifyFormat("void f() {\n" 6165 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 6166 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 6167 "}"); 6168 6169 // Handle 'endl'. 6170 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 6171 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6172 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6173 6174 // Handle '\n'. 6175 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 6176 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6177 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 6178 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 6179 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 6180 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 6181 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6182 } 6183 6184 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 6185 verifyFormat("return out << \"somepacket = {\\n\"\n" 6186 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 6187 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 6188 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 6189 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 6190 " << \"}\";"); 6191 6192 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6193 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6194 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 6195 verifyFormat( 6196 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 6197 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 6198 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 6199 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 6200 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 6201 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 6202 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6203 verifyFormat( 6204 "void f() {\n" 6205 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 6206 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 6207 "}"); 6208 6209 // Breaking before the first "<<" is generally not desirable. 6210 verifyFormat( 6211 "llvm::errs()\n" 6212 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6213 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6214 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6215 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6216 getLLVMStyleWithColumns(70)); 6217 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6218 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6219 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6220 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6221 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6222 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6223 getLLVMStyleWithColumns(70)); 6224 6225 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6226 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6227 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6228 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6229 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6230 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 6231 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 6232 " (aaaa + aaaa);", 6233 getLLVMStyleWithColumns(40)); 6234 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 6235 " (aaaaaaa + aaaaa));", 6236 getLLVMStyleWithColumns(40)); 6237 verifyFormat( 6238 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 6239 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 6240 " bbbbbbbbbbbbbbbbbbbbbbb);"); 6241 } 6242 6243 TEST_F(FormatTest, UnderstandsEquals) { 6244 verifyFormat( 6245 "aaaaaaaaaaaaaaaaa =\n" 6246 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6247 verifyFormat( 6248 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6249 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6250 verifyFormat( 6251 "if (a) {\n" 6252 " f();\n" 6253 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6254 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 6255 "}"); 6256 6257 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6258 " 100000000 + 10000000) {\n}"); 6259 } 6260 6261 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 6262 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6263 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 6264 6265 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6266 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 6267 6268 verifyFormat( 6269 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 6270 " Parameter2);"); 6271 6272 verifyFormat( 6273 "ShortObject->shortFunction(\n" 6274 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 6275 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 6276 6277 verifyFormat("loooooooooooooongFunction(\n" 6278 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 6279 6280 verifyFormat( 6281 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 6282 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 6283 6284 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6285 " .WillRepeatedly(Return(SomeValue));"); 6286 verifyFormat("void f() {\n" 6287 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6288 " .Times(2)\n" 6289 " .WillRepeatedly(Return(SomeValue));\n" 6290 "}"); 6291 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 6292 " ccccccccccccccccccccccc);"); 6293 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6294 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6295 " .aaaaa(aaaaa),\n" 6296 " aaaaaaaaaaaaaaaaaaaaa);"); 6297 verifyFormat("void f() {\n" 6298 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6299 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 6300 "}"); 6301 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6302 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6303 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6304 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6305 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6306 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6307 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6308 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6309 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 6310 "}"); 6311 6312 // Here, it is not necessary to wrap at "." or "->". 6313 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 6314 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6315 verifyFormat( 6316 "aaaaaaaaaaa->aaaaaaaaa(\n" 6317 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6318 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 6319 6320 verifyFormat( 6321 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6322 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 6323 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 6324 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6325 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 6326 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6327 6328 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6329 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6330 " .a();"); 6331 6332 FormatStyle NoBinPacking = getLLVMStyle(); 6333 NoBinPacking.BinPackParameters = false; 6334 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6335 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6336 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 6337 " aaaaaaaaaaaaaaaaaaa,\n" 6338 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6339 NoBinPacking); 6340 6341 // If there is a subsequent call, change to hanging indentation. 6342 verifyFormat( 6343 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6344 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 6345 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6346 verifyFormat( 6347 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6348 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 6349 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6350 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6351 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6352 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6353 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6354 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6355 } 6356 6357 TEST_F(FormatTest, WrapsTemplateDeclarations) { 6358 verifyFormat("template <typename T>\n" 6359 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6360 verifyFormat("template <typename T>\n" 6361 "// T should be one of {A, B}.\n" 6362 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6363 verifyFormat( 6364 "template <typename T>\n" 6365 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 6366 verifyFormat("template <typename T>\n" 6367 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 6368 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 6369 verifyFormat( 6370 "template <typename T>\n" 6371 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 6372 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 6373 verifyFormat( 6374 "template <typename T>\n" 6375 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 6376 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 6377 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6378 verifyFormat("template <typename T>\n" 6379 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6380 " int aaaaaaaaaaaaaaaaaaaaaa);"); 6381 verifyFormat( 6382 "template <typename T1, typename T2 = char, typename T3 = char,\n" 6383 " typename T4 = char>\n" 6384 "void f();"); 6385 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 6386 " template <typename> class cccccccccccccccccccccc,\n" 6387 " typename ddddddddddddd>\n" 6388 "class C {};"); 6389 verifyFormat( 6390 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 6391 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6392 6393 verifyFormat("void f() {\n" 6394 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 6395 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 6396 "}"); 6397 6398 verifyFormat("template <typename T> class C {};"); 6399 verifyFormat("template <typename T> void f();"); 6400 verifyFormat("template <typename T> void f() {}"); 6401 verifyFormat( 6402 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6403 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6404 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 6405 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6406 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6407 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 6408 " bbbbbbbbbbbbbbbbbbbbbbbb);", 6409 getLLVMStyleWithColumns(72)); 6410 EXPECT_EQ("static_cast<A< //\n" 6411 " B> *>(\n" 6412 "\n" 6413 ");", 6414 format("static_cast<A<//\n" 6415 " B>*>(\n" 6416 "\n" 6417 " );")); 6418 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6419 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 6420 6421 FormatStyle AlwaysBreak = getLLVMStyle(); 6422 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 6423 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 6424 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 6425 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 6426 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6427 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6428 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 6429 verifyFormat("template <template <typename> class Fooooooo,\n" 6430 " template <typename> class Baaaaaaar>\n" 6431 "struct C {};", 6432 AlwaysBreak); 6433 verifyFormat("template <typename T> // T can be A, B or C.\n" 6434 "struct C {};", 6435 AlwaysBreak); 6436 verifyFormat("template <enum E> class A {\n" 6437 "public:\n" 6438 " E *f();\n" 6439 "};"); 6440 6441 FormatStyle NeverBreak = getLLVMStyle(); 6442 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 6443 verifyFormat("template <typename T> class C {};", NeverBreak); 6444 verifyFormat("template <typename T> void f();", NeverBreak); 6445 verifyFormat("template <typename T> void f() {}", NeverBreak); 6446 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbb) {}", 6447 NeverBreak); 6448 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6449 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6450 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 6451 NeverBreak); 6452 verifyFormat("template <template <typename> class Fooooooo,\n" 6453 " template <typename> class Baaaaaaar>\n" 6454 "struct C {};", 6455 NeverBreak); 6456 verifyFormat("template <typename T> // T can be A, B or C.\n" 6457 "struct C {};", 6458 NeverBreak); 6459 verifyFormat("template <enum E> class A {\n" 6460 "public:\n" 6461 " E *f();\n" 6462 "};", NeverBreak); 6463 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 6464 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbb) {}", 6465 NeverBreak); 6466 } 6467 6468 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 6469 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 6470 Style.ColumnLimit = 60; 6471 EXPECT_EQ("// Baseline - no comments.\n" 6472 "template <\n" 6473 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6474 "void f() {}", 6475 format("// Baseline - no comments.\n" 6476 "template <\n" 6477 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6478 "void f() {}", 6479 Style)); 6480 6481 EXPECT_EQ("template <\n" 6482 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6483 "void f() {}", 6484 format("template <\n" 6485 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6486 "void f() {}", 6487 Style)); 6488 6489 EXPECT_EQ( 6490 "template <\n" 6491 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6492 "void f() {}", 6493 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6494 "void f() {}", 6495 Style)); 6496 6497 EXPECT_EQ( 6498 "template <\n" 6499 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6500 " // multiline\n" 6501 "void f() {}", 6502 format("template <\n" 6503 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6504 " // multiline\n" 6505 "void f() {}", 6506 Style)); 6507 6508 EXPECT_EQ( 6509 "template <typename aaaaaaaaaa<\n" 6510 " bbbbbbbbbbbb>::value> // trailing loooong\n" 6511 "void f() {}", 6512 format( 6513 "template <\n" 6514 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 6515 "void f() {}", 6516 Style)); 6517 } 6518 6519 TEST_F(FormatTest, WrapsTemplateParameters) { 6520 FormatStyle Style = getLLVMStyle(); 6521 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6522 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6523 verifyFormat( 6524 "template <typename... a> struct q {};\n" 6525 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6526 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6527 " y;", 6528 Style); 6529 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6530 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6531 verifyFormat( 6532 "template <typename... a> struct r {};\n" 6533 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6534 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6535 " y;", 6536 Style); 6537 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6538 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6539 verifyFormat( 6540 "template <typename... a> struct s {};\n" 6541 "extern s<\n" 6542 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 6543 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n" 6544 " y;", 6545 Style); 6546 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6547 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6548 verifyFormat( 6549 "template <typename... a> struct t {};\n" 6550 "extern t<\n" 6551 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 6552 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n" 6553 " y;", 6554 Style); 6555 } 6556 6557 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 6558 verifyFormat( 6559 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6560 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6561 verifyFormat( 6562 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6563 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6564 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6565 6566 // FIXME: Should we have the extra indent after the second break? 6567 verifyFormat( 6568 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6569 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6570 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6571 6572 verifyFormat( 6573 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 6574 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 6575 6576 // Breaking at nested name specifiers is generally not desirable. 6577 verifyFormat( 6578 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6579 " aaaaaaaaaaaaaaaaaaaaaaa);"); 6580 6581 verifyFormat( 6582 "aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 6583 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6584 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6585 " aaaaaaaaaaaaaaaaaaaaa);", 6586 getLLVMStyleWithColumns(74)); 6587 6588 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6589 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6590 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6591 } 6592 6593 TEST_F(FormatTest, UnderstandsTemplateParameters) { 6594 verifyFormat("A<int> a;"); 6595 verifyFormat("A<A<A<int>>> a;"); 6596 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 6597 verifyFormat("bool x = a < 1 || 2 > a;"); 6598 verifyFormat("bool x = 5 < f<int>();"); 6599 verifyFormat("bool x = f<int>() > 5;"); 6600 verifyFormat("bool x = 5 < a<int>::x;"); 6601 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 6602 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 6603 6604 verifyGoogleFormat("A<A<int>> a;"); 6605 verifyGoogleFormat("A<A<A<int>>> a;"); 6606 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 6607 verifyGoogleFormat("A<A<int> > a;"); 6608 verifyGoogleFormat("A<A<A<int> > > a;"); 6609 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 6610 verifyGoogleFormat("A<::A<int>> a;"); 6611 verifyGoogleFormat("A<::A> a;"); 6612 verifyGoogleFormat("A< ::A> a;"); 6613 verifyGoogleFormat("A< ::A<int> > a;"); 6614 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 6615 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 6616 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 6617 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 6618 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 6619 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 6620 6621 verifyFormat("A<A>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 6622 6623 verifyFormat("test >> a >> b;"); 6624 verifyFormat("test << a >> b;"); 6625 6626 verifyFormat("f<int>();"); 6627 verifyFormat("template <typename T> void f() {}"); 6628 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 6629 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 6630 "sizeof(char)>::type>;"); 6631 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 6632 verifyFormat("f(a.operator()<A>());"); 6633 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6634 " .template operator()<A>());", 6635 getLLVMStyleWithColumns(35)); 6636 6637 // Not template parameters. 6638 verifyFormat("return a < b && c > d;"); 6639 verifyFormat("void f() {\n" 6640 " while (a < b && c > d) {\n" 6641 " }\n" 6642 "}"); 6643 verifyFormat("template <typename... Types>\n" 6644 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 6645 6646 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6647 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 6648 getLLVMStyleWithColumns(60)); 6649 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 6650 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 6651 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 6652 } 6653 6654 TEST_F(FormatTest, BitshiftOperatorWidth) { 6655 EXPECT_EQ("int a = 1 << 2; /* foo\n" 6656 " bar */", 6657 format("int a=1<<2; /* foo\n" 6658 " bar */")); 6659 6660 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 6661 " bar */", 6662 format("int b =256>>1 ; /* foo\n" 6663 " bar */")); 6664 } 6665 6666 TEST_F(FormatTest, UnderstandsBinaryOperators) { 6667 verifyFormat("COMPARE(a, ==, b);"); 6668 verifyFormat("auto s = sizeof...(Ts) - 1;"); 6669 } 6670 6671 TEST_F(FormatTest, UnderstandsPointersToMembers) { 6672 verifyFormat("int A::*x;"); 6673 verifyFormat("int (S::*func)(void *);"); 6674 verifyFormat("void f() { int (S::*func)(void *); }"); 6675 verifyFormat("typedef bool *(Class::*Member)() const;"); 6676 verifyFormat("void f() {\n" 6677 " (a->*f)();\n" 6678 " a->*x;\n" 6679 " (a.*f)();\n" 6680 " ((*a).*f)();\n" 6681 " a.*x;\n" 6682 "}"); 6683 verifyFormat("void f() {\n" 6684 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 6685 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 6686 "}"); 6687 verifyFormat( 6688 "(aaaaaaaaaa->*bbbbbbb)(\n" 6689 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6690 FormatStyle Style = getLLVMStyle(); 6691 Style.PointerAlignment = FormatStyle::PAS_Left; 6692 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 6693 } 6694 6695 TEST_F(FormatTest, UnderstandsUnaryOperators) { 6696 verifyFormat("int a = -2;"); 6697 verifyFormat("f(-1, -2, -3);"); 6698 verifyFormat("a[-1] = 5;"); 6699 verifyFormat("int a = 5 + -2;"); 6700 verifyFormat("if (i == -1) {\n}"); 6701 verifyFormat("if (i != -1) {\n}"); 6702 verifyFormat("if (i > -1) {\n}"); 6703 verifyFormat("if (i < -1) {\n}"); 6704 verifyFormat("++(a->f());"); 6705 verifyFormat("--(a->f());"); 6706 verifyFormat("(a->f())++;"); 6707 verifyFormat("a[42]++;"); 6708 verifyFormat("if (!(a->f())) {\n}"); 6709 verifyFormat("if (!+i) {\n}"); 6710 verifyFormat("~&a;"); 6711 6712 verifyFormat("a-- > b;"); 6713 verifyFormat("b ? -a : c;"); 6714 verifyFormat("n * sizeof char16;"); 6715 verifyFormat("n * alignof char16;", getGoogleStyle()); 6716 verifyFormat("sizeof(char);"); 6717 verifyFormat("alignof(char);", getGoogleStyle()); 6718 6719 verifyFormat("return -1;"); 6720 verifyFormat("switch (a) {\n" 6721 "case -1:\n" 6722 " break;\n" 6723 "}"); 6724 verifyFormat("#define X -1"); 6725 verifyFormat("#define X -kConstant"); 6726 6727 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 6728 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 6729 6730 verifyFormat("int a = /* confusing comment */ -1;"); 6731 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 6732 verifyFormat("int a = i /* confusing comment */++;"); 6733 } 6734 6735 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 6736 verifyFormat("if (!aaaaaaaaaa( // break\n" 6737 " aaaaa)) {\n" 6738 "}"); 6739 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 6740 " aaaaa));"); 6741 verifyFormat("*aaa = aaaaaaa( // break\n" 6742 " bbbbbb);"); 6743 } 6744 6745 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 6746 verifyFormat("bool operator<();"); 6747 verifyFormat("bool operator>();"); 6748 verifyFormat("bool operator=();"); 6749 verifyFormat("bool operator==();"); 6750 verifyFormat("bool operator!=();"); 6751 verifyFormat("int operator+();"); 6752 verifyFormat("int operator++();"); 6753 verifyFormat("int operator++(int) volatile noexcept;"); 6754 verifyFormat("bool operator,();"); 6755 verifyFormat("bool operator();"); 6756 verifyFormat("bool operator()();"); 6757 verifyFormat("bool operator[]();"); 6758 verifyFormat("operator bool();"); 6759 verifyFormat("operator int();"); 6760 verifyFormat("operator void *();"); 6761 verifyFormat("operator SomeType<int>();"); 6762 verifyFormat("operator SomeType<int, int>();"); 6763 verifyFormat("operator SomeType<SomeType<int>>();"); 6764 verifyFormat("void *operator new(std::size_t size);"); 6765 verifyFormat("void *operator new[](std::size_t size);"); 6766 verifyFormat("void operator delete(void *ptr);"); 6767 verifyFormat("void operator delete[](void *ptr);"); 6768 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 6769 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 6770 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 6771 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 6772 6773 verifyFormat( 6774 "ostream &operator<<(ostream &OutputStream,\n" 6775 " SomeReallyLongType WithSomeReallyLongValue);"); 6776 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 6777 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 6778 " return left.group < right.group;\n" 6779 "}"); 6780 verifyFormat("SomeType &operator=(const SomeType &S);"); 6781 verifyFormat("f.template operator()<int>();"); 6782 6783 verifyGoogleFormat("operator void*();"); 6784 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 6785 verifyGoogleFormat("operator ::A();"); 6786 6787 verifyFormat("using A::operator+;"); 6788 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 6789 "int i;"); 6790 } 6791 6792 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 6793 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 6794 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 6795 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 6796 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 6797 verifyFormat("Deleted &operator=(const Deleted &) &;"); 6798 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 6799 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 6800 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 6801 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 6802 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 6803 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 6804 verifyFormat("void Fn(T const &) const &;"); 6805 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 6806 verifyFormat("template <typename T>\n" 6807 "void F(T) && = delete;", 6808 getGoogleStyle()); 6809 6810 FormatStyle AlignLeft = getLLVMStyle(); 6811 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 6812 verifyFormat("void A::b() && {}", AlignLeft); 6813 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 6814 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 6815 AlignLeft); 6816 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 6817 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 6818 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 6819 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 6820 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 6821 verifyFormat("auto Function(T) & -> void;", AlignLeft); 6822 verifyFormat("void Fn(T const&) const&;", AlignLeft); 6823 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 6824 6825 FormatStyle Spaces = getLLVMStyle(); 6826 Spaces.SpacesInCStyleCastParentheses = true; 6827 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 6828 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 6829 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 6830 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 6831 6832 Spaces.SpacesInCStyleCastParentheses = false; 6833 Spaces.SpacesInParentheses = true; 6834 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 6835 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", Spaces); 6836 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 6837 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 6838 } 6839 6840 TEST_F(FormatTest, UnderstandsNewAndDelete) { 6841 verifyFormat("void f() {\n" 6842 " A *a = new A;\n" 6843 " A *a = new (placement) A;\n" 6844 " delete a;\n" 6845 " delete (A *)a;\n" 6846 "}"); 6847 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 6848 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 6849 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6850 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 6851 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 6852 verifyFormat("delete[] h->p;"); 6853 } 6854 6855 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 6856 verifyFormat("int *f(int *a) {}"); 6857 verifyFormat("int main(int argc, char **argv) {}"); 6858 verifyFormat("Test::Test(int b) : a(b * b) {}"); 6859 verifyIndependentOfContext("f(a, *a);"); 6860 verifyFormat("void g() { f(*a); }"); 6861 verifyIndependentOfContext("int a = b * 10;"); 6862 verifyIndependentOfContext("int a = 10 * b;"); 6863 verifyIndependentOfContext("int a = b * c;"); 6864 verifyIndependentOfContext("int a += b * c;"); 6865 verifyIndependentOfContext("int a -= b * c;"); 6866 verifyIndependentOfContext("int a *= b * c;"); 6867 verifyIndependentOfContext("int a /= b * c;"); 6868 verifyIndependentOfContext("int a = *b;"); 6869 verifyIndependentOfContext("int a = *b * c;"); 6870 verifyIndependentOfContext("int a = b * *c;"); 6871 verifyIndependentOfContext("int a = b * (10);"); 6872 verifyIndependentOfContext("S << b * (10);"); 6873 verifyIndependentOfContext("return 10 * b;"); 6874 verifyIndependentOfContext("return *b * *c;"); 6875 verifyIndependentOfContext("return a & ~b;"); 6876 verifyIndependentOfContext("f(b ? *c : *d);"); 6877 verifyIndependentOfContext("int a = b ? *c : *d;"); 6878 verifyIndependentOfContext("*b = a;"); 6879 verifyIndependentOfContext("a * ~b;"); 6880 verifyIndependentOfContext("a * !b;"); 6881 verifyIndependentOfContext("a * +b;"); 6882 verifyIndependentOfContext("a * -b;"); 6883 verifyIndependentOfContext("a * ++b;"); 6884 verifyIndependentOfContext("a * --b;"); 6885 verifyIndependentOfContext("a[4] * b;"); 6886 verifyIndependentOfContext("a[a * a] = 1;"); 6887 verifyIndependentOfContext("f() * b;"); 6888 verifyIndependentOfContext("a * [self dostuff];"); 6889 verifyIndependentOfContext("int x = a * (a + b);"); 6890 verifyIndependentOfContext("(a *)(a + b);"); 6891 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 6892 verifyIndependentOfContext("int *pa = (int *)&a;"); 6893 verifyIndependentOfContext("return sizeof(int **);"); 6894 verifyIndependentOfContext("return sizeof(int ******);"); 6895 verifyIndependentOfContext("return (int **&)a;"); 6896 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 6897 verifyFormat("void f(Type (*parameter)[10]) {}"); 6898 verifyFormat("void f(Type (¶meter)[10]) {}"); 6899 verifyGoogleFormat("return sizeof(int**);"); 6900 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 6901 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 6902 verifyFormat("auto a = [](int **&, int ***) {};"); 6903 verifyFormat("auto PointerBinding = [](const char *S) {};"); 6904 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 6905 verifyFormat("[](const decltype(*a) &value) {}"); 6906 verifyFormat("decltype(a * b) F();"); 6907 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 6908 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 6909 verifyIndependentOfContext("typedef void (*f)(int *a);"); 6910 verifyIndependentOfContext("int i{a * b};"); 6911 verifyIndependentOfContext("aaa && aaa->f();"); 6912 verifyIndependentOfContext("int x = ~*p;"); 6913 verifyFormat("Constructor() : a(a), area(width * height) {}"); 6914 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 6915 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 6916 verifyFormat("void f() { f(a, c * d); }"); 6917 verifyFormat("void f() { f(new a(), c * d); }"); 6918 verifyFormat("void f(const MyOverride &override);"); 6919 verifyFormat("void f(const MyFinal &final);"); 6920 verifyIndependentOfContext("bool a = f() && override.f();"); 6921 verifyIndependentOfContext("bool a = f() && final.f();"); 6922 6923 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 6924 6925 verifyIndependentOfContext("A<int *> a;"); 6926 verifyIndependentOfContext("A<int **> a;"); 6927 verifyIndependentOfContext("A<int *, int *> a;"); 6928 verifyIndependentOfContext("A<int *[]> a;"); 6929 verifyIndependentOfContext( 6930 "const char *const p = reinterpret_cast<const char *const>(q);"); 6931 verifyIndependentOfContext("A<int **, int **> a;"); 6932 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 6933 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 6934 verifyFormat("for (; a && b;) {\n}"); 6935 verifyFormat("bool foo = true && [] { return false; }();"); 6936 6937 verifyFormat( 6938 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6939 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6940 6941 verifyGoogleFormat("int const* a = &b;"); 6942 verifyGoogleFormat("**outparam = 1;"); 6943 verifyGoogleFormat("*outparam = a * b;"); 6944 verifyGoogleFormat("int main(int argc, char** argv) {}"); 6945 verifyGoogleFormat("A<int*> a;"); 6946 verifyGoogleFormat("A<int**> a;"); 6947 verifyGoogleFormat("A<int*, int*> a;"); 6948 verifyGoogleFormat("A<int**, int**> a;"); 6949 verifyGoogleFormat("f(b ? *c : *d);"); 6950 verifyGoogleFormat("int a = b ? *c : *d;"); 6951 verifyGoogleFormat("Type* t = **x;"); 6952 verifyGoogleFormat("Type* t = *++*x;"); 6953 verifyGoogleFormat("*++*x;"); 6954 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 6955 verifyGoogleFormat("Type* t = x++ * y;"); 6956 verifyGoogleFormat( 6957 "const char* const p = reinterpret_cast<const char* const>(q);"); 6958 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 6959 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 6960 verifyGoogleFormat("template <typename T>\n" 6961 "void f(int i = 0, SomeType** temps = NULL);"); 6962 6963 FormatStyle Left = getLLVMStyle(); 6964 Left.PointerAlignment = FormatStyle::PAS_Left; 6965 verifyFormat("x = *a(x) = *a(y);", Left); 6966 verifyFormat("for (;; *a = b) {\n}", Left); 6967 verifyFormat("return *this += 1;", Left); 6968 verifyFormat("throw *x;", Left); 6969 verifyFormat("delete *x;", Left); 6970 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 6971 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 6972 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 6973 6974 verifyIndependentOfContext("a = *(x + y);"); 6975 verifyIndependentOfContext("a = &(x + y);"); 6976 verifyIndependentOfContext("*(x + y).call();"); 6977 verifyIndependentOfContext("&(x + y)->call();"); 6978 verifyFormat("void f() { &(*I).first; }"); 6979 6980 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 6981 verifyFormat( 6982 "int *MyValues = {\n" 6983 " *A, // Operator detection might be confused by the '{'\n" 6984 " *BB // Operator detection might be confused by previous comment\n" 6985 "};"); 6986 6987 verifyIndependentOfContext("if (int *a = &b)"); 6988 verifyIndependentOfContext("if (int &a = *b)"); 6989 verifyIndependentOfContext("if (a & b[i])"); 6990 verifyIndependentOfContext("if constexpr (a & b[i])"); 6991 verifyIndependentOfContext("if CONSTEXPR (a & b[i])"); 6992 verifyIndependentOfContext("if (a * (b * c))"); 6993 verifyIndependentOfContext("if constexpr (a * (b * c))"); 6994 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))"); 6995 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 6996 verifyIndependentOfContext("if (*b[i])"); 6997 verifyIndependentOfContext("if (int *a = (&b))"); 6998 verifyIndependentOfContext("while (int *a = &b)"); 6999 verifyIndependentOfContext("while (a * (b * c))"); 7000 verifyIndependentOfContext("size = sizeof *a;"); 7001 verifyIndependentOfContext("if (a && (b = c))"); 7002 verifyFormat("void f() {\n" 7003 " for (const int &v : Values) {\n" 7004 " }\n" 7005 "}"); 7006 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 7007 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 7008 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 7009 7010 verifyFormat("#define A (!a * b)"); 7011 verifyFormat("#define MACRO \\\n" 7012 " int *i = a * b; \\\n" 7013 " void f(a *b);", 7014 getLLVMStyleWithColumns(19)); 7015 7016 verifyIndependentOfContext("A = new SomeType *[Length];"); 7017 verifyIndependentOfContext("A = new SomeType *[Length]();"); 7018 verifyIndependentOfContext("T **t = new T *;"); 7019 verifyIndependentOfContext("T **t = new T *();"); 7020 verifyGoogleFormat("A = new SomeType*[Length]();"); 7021 verifyGoogleFormat("A = new SomeType*[Length];"); 7022 verifyGoogleFormat("T** t = new T*;"); 7023 verifyGoogleFormat("T** t = new T*();"); 7024 7025 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 7026 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 7027 verifyFormat("template <bool a, bool b> " 7028 "typename t::if<x && y>::type f() {}"); 7029 verifyFormat("template <int *y> f() {}"); 7030 verifyFormat("vector<int *> v;"); 7031 verifyFormat("vector<int *const> v;"); 7032 verifyFormat("vector<int *const **const *> v;"); 7033 verifyFormat("vector<int *volatile> v;"); 7034 verifyFormat("vector<a * b> v;"); 7035 verifyFormat("foo<b && false>();"); 7036 verifyFormat("foo<b & 1>();"); 7037 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 7038 verifyFormat( 7039 "template <class T, class = typename std::enable_if<\n" 7040 " std::is_integral<T>::value &&\n" 7041 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 7042 "void F();", 7043 getLLVMStyleWithColumns(70)); 7044 verifyFormat( 7045 "template <class T,\n" 7046 " class = typename std::enable_if<\n" 7047 " std::is_integral<T>::value &&\n" 7048 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 7049 " class U>\n" 7050 "void F();", 7051 getLLVMStyleWithColumns(70)); 7052 verifyFormat( 7053 "template <class T,\n" 7054 " class = typename ::std::enable_if<\n" 7055 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 7056 "void F();", 7057 getGoogleStyleWithColumns(68)); 7058 7059 verifyIndependentOfContext("MACRO(int *i);"); 7060 verifyIndependentOfContext("MACRO(auto *a);"); 7061 verifyIndependentOfContext("MACRO(const A *a);"); 7062 verifyIndependentOfContext("MACRO(A *const a);"); 7063 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 7064 verifyFormat("void f() { f(float{1}, a * a); }"); 7065 // FIXME: Is there a way to make this work? 7066 // verifyIndependentOfContext("MACRO(A *a);"); 7067 7068 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 7069 verifyFormat("return options != nullptr && operator==(*options);"); 7070 7071 EXPECT_EQ("#define OP(x) \\\n" 7072 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7073 " return s << a.DebugString(); \\\n" 7074 " }", 7075 format("#define OP(x) \\\n" 7076 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7077 " return s << a.DebugString(); \\\n" 7078 " }", 7079 getLLVMStyleWithColumns(50))); 7080 7081 // FIXME: We cannot handle this case yet; we might be able to figure out that 7082 // foo<x> d > v; doesn't make sense. 7083 verifyFormat("foo<a<b && c> d> v;"); 7084 7085 FormatStyle PointerMiddle = getLLVMStyle(); 7086 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7087 verifyFormat("delete *x;", PointerMiddle); 7088 verifyFormat("int * x;", PointerMiddle); 7089 verifyFormat("int *[] x;", PointerMiddle); 7090 verifyFormat("template <int * y> f() {}", PointerMiddle); 7091 verifyFormat("int * f(int * a) {}", PointerMiddle); 7092 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7093 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7094 verifyFormat("A<int *> a;", PointerMiddle); 7095 verifyFormat("A<int **> a;", PointerMiddle); 7096 verifyFormat("A<int *, int *> a;", PointerMiddle); 7097 verifyFormat("A<int *[]> a;", PointerMiddle); 7098 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7099 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7100 verifyFormat("T ** t = new T *;", PointerMiddle); 7101 7102 // Member function reference qualifiers aren't binary operators. 7103 verifyFormat("string // break\n" 7104 "operator()() & {}"); 7105 verifyFormat("string // break\n" 7106 "operator()() && {}"); 7107 verifyGoogleFormat("template <typename T>\n" 7108 "auto x() & -> int {}"); 7109 } 7110 7111 TEST_F(FormatTest, UnderstandsAttributes) { 7112 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7113 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7114 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7115 FormatStyle AfterType = getLLVMStyle(); 7116 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7117 verifyFormat("__attribute__((nodebug)) void\n" 7118 "foo() {}\n", 7119 AfterType); 7120 } 7121 7122 TEST_F(FormatTest, UnderstandsSquareAttributes) { 7123 verifyFormat("SomeType s [[unused]] (InitValue);"); 7124 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 7125 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 7126 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 7127 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 7128 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7129 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7130 7131 // Make sure we do not mistake attributes for array subscripts. 7132 verifyFormat("int a() {}\n" 7133 "[[unused]] int b() {}\n"); 7134 verifyFormat("NSArray *arr;\n" 7135 "arr[[Foo() bar]];"); 7136 7137 // On the other hand, we still need to correctly find array subscripts. 7138 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 7139 7140 // Make sure that we do not mistake Objective-C method inside array literals 7141 // as attributes, even if those method names are also keywords. 7142 verifyFormat("@[ [foo bar] ];"); 7143 verifyFormat("@[ [NSArray class] ];"); 7144 verifyFormat("@[ [foo enum] ];"); 7145 7146 // Make sure we do not parse attributes as lambda introducers. 7147 FormatStyle MultiLineFunctions = getLLVMStyle(); 7148 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7149 verifyFormat("[[unused]] int b() {\n" 7150 " return 42;\n" 7151 "}\n", 7152 MultiLineFunctions); 7153 } 7154 7155 TEST_F(FormatTest, UnderstandsEllipsis) { 7156 verifyFormat("int printf(const char *fmt, ...);"); 7157 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 7158 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 7159 7160 FormatStyle PointersLeft = getLLVMStyle(); 7161 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 7162 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 7163 } 7164 7165 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 7166 EXPECT_EQ("int *a;\n" 7167 "int *a;\n" 7168 "int *a;", 7169 format("int *a;\n" 7170 "int* a;\n" 7171 "int *a;", 7172 getGoogleStyle())); 7173 EXPECT_EQ("int* a;\n" 7174 "int* a;\n" 7175 "int* a;", 7176 format("int* a;\n" 7177 "int* a;\n" 7178 "int *a;", 7179 getGoogleStyle())); 7180 EXPECT_EQ("int *a;\n" 7181 "int *a;\n" 7182 "int *a;", 7183 format("int *a;\n" 7184 "int * a;\n" 7185 "int * a;", 7186 getGoogleStyle())); 7187 EXPECT_EQ("auto x = [] {\n" 7188 " int *a;\n" 7189 " int *a;\n" 7190 " int *a;\n" 7191 "};", 7192 format("auto x=[]{int *a;\n" 7193 "int * a;\n" 7194 "int * a;};", 7195 getGoogleStyle())); 7196 } 7197 7198 TEST_F(FormatTest, UnderstandsRvalueReferences) { 7199 verifyFormat("int f(int &&a) {}"); 7200 verifyFormat("int f(int a, char &&b) {}"); 7201 verifyFormat("void f() { int &&a = b; }"); 7202 verifyGoogleFormat("int f(int a, char&& b) {}"); 7203 verifyGoogleFormat("void f() { int&& a = b; }"); 7204 7205 verifyIndependentOfContext("A<int &&> a;"); 7206 verifyIndependentOfContext("A<int &&, int &&> a;"); 7207 verifyGoogleFormat("A<int&&> a;"); 7208 verifyGoogleFormat("A<int&&, int&&> a;"); 7209 7210 // Not rvalue references: 7211 verifyFormat("template <bool B, bool C> class A {\n" 7212 " static_assert(B && C, \"Something is wrong\");\n" 7213 "};"); 7214 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 7215 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 7216 verifyFormat("#define A(a, b) (a && b)"); 7217 } 7218 7219 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 7220 verifyFormat("void f() {\n" 7221 " x[aaaaaaaaa -\n" 7222 " b] = 23;\n" 7223 "}", 7224 getLLVMStyleWithColumns(15)); 7225 } 7226 7227 TEST_F(FormatTest, FormatsCasts) { 7228 verifyFormat("Type *A = static_cast<Type *>(P);"); 7229 verifyFormat("Type *A = (Type *)P;"); 7230 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7231 verifyFormat("int a = (int)(2.0f);"); 7232 verifyFormat("int a = (int)2.0f;"); 7233 verifyFormat("x[(int32)y];"); 7234 verifyFormat("x = (int32)y;"); 7235 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7236 verifyFormat("int a = (int)*b;"); 7237 verifyFormat("int a = (int)2.0f;"); 7238 verifyFormat("int a = (int)~0;"); 7239 verifyFormat("int a = (int)++a;"); 7240 verifyFormat("int a = (int)sizeof(int);"); 7241 verifyFormat("int a = (int)+2;"); 7242 verifyFormat("my_int a = (my_int)2.0f;"); 7243 verifyFormat("my_int a = (my_int)sizeof(int);"); 7244 verifyFormat("return (my_int)aaa;"); 7245 verifyFormat("#define x ((int)-1)"); 7246 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7247 verifyFormat("#define p(q) ((int *)&q)"); 7248 verifyFormat("fn(a)(b) + 1;"); 7249 7250 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7251 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7252 verifyFormat("my_int a = (my_int)~0;"); 7253 verifyFormat("my_int a = (my_int)++a;"); 7254 verifyFormat("my_int a = (my_int)-2;"); 7255 verifyFormat("my_int a = (my_int)1;"); 7256 verifyFormat("my_int a = (my_int *)1;"); 7257 verifyFormat("my_int a = (const my_int)-1;"); 7258 verifyFormat("my_int a = (const my_int *)-1;"); 7259 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7260 verifyFormat("my_int a = (ns::my_int)-2;"); 7261 verifyFormat("case (my_int)ONE:"); 7262 verifyFormat("auto x = (X)this;"); 7263 7264 // FIXME: single value wrapped with paren will be treated as cast. 7265 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7266 7267 verifyFormat("{ (void)F; }"); 7268 7269 // Don't break after a cast's 7270 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7271 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7272 " bbbbbbbbbbbbbbbbbbbbbb);"); 7273 7274 // These are not casts. 7275 verifyFormat("void f(int *) {}"); 7276 verifyFormat("f(foo)->b;"); 7277 verifyFormat("f(foo).b;"); 7278 verifyFormat("f(foo)(b);"); 7279 verifyFormat("f(foo)[b];"); 7280 verifyFormat("[](foo) { return 4; }(bar);"); 7281 verifyFormat("(*funptr)(foo)[4];"); 7282 verifyFormat("funptrs[4](foo)[4];"); 7283 verifyFormat("void f(int *);"); 7284 verifyFormat("void f(int *) = 0;"); 7285 verifyFormat("void f(SmallVector<int>) {}"); 7286 verifyFormat("void f(SmallVector<int>);"); 7287 verifyFormat("void f(SmallVector<int>) = 0;"); 7288 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7289 verifyFormat("int a = sizeof(int) * b;"); 7290 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7291 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7292 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7293 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7294 7295 // These are not casts, but at some point were confused with casts. 7296 verifyFormat("virtual void foo(int *) override;"); 7297 verifyFormat("virtual void foo(char &) const;"); 7298 verifyFormat("virtual void foo(int *a, char *) const;"); 7299 verifyFormat("int a = sizeof(int *) + b;"); 7300 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7301 verifyFormat("bool b = f(g<int>) && c;"); 7302 verifyFormat("typedef void (*f)(int i) func;"); 7303 7304 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7305 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7306 // FIXME: The indentation here is not ideal. 7307 verifyFormat( 7308 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7309 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7310 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7311 } 7312 7313 TEST_F(FormatTest, FormatsFunctionTypes) { 7314 verifyFormat("A<bool()> a;"); 7315 verifyFormat("A<SomeType()> a;"); 7316 verifyFormat("A<void (*)(int, std::string)> a;"); 7317 verifyFormat("A<void *(int)>;"); 7318 verifyFormat("void *(*a)(int *, SomeType *);"); 7319 verifyFormat("int (*func)(void *);"); 7320 verifyFormat("void f() { int (*func)(void *); }"); 7321 verifyFormat("template <class CallbackClass>\n" 7322 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7323 7324 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7325 verifyGoogleFormat("void* (*a)(int);"); 7326 verifyGoogleFormat( 7327 "template <class CallbackClass>\n" 7328 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7329 7330 // Other constructs can look somewhat like function types: 7331 verifyFormat("A<sizeof(*x)> a;"); 7332 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7333 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7334 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7335 verifyFormat("int x = f(&h)();"); 7336 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7337 verifyFormat("std::function<\n" 7338 " LooooooooooongTemplatedType<\n" 7339 " SomeType>*(\n" 7340 " LooooooooooooooooongType type)>\n" 7341 " function;", 7342 getGoogleStyleWithColumns(40)); 7343 } 7344 7345 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7346 verifyFormat("A (*foo_)[6];"); 7347 verifyFormat("vector<int> (*foo_)[6];"); 7348 } 7349 7350 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7351 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7352 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7353 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7354 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7355 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7356 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7357 7358 // Different ways of ()-initializiation. 7359 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7360 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7361 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7362 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7363 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7364 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7365 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7366 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7367 7368 // Lambdas should not confuse the variable declaration heuristic. 7369 verifyFormat("LooooooooooooooooongType\n" 7370 " variable(nullptr, [](A *a) {});", 7371 getLLVMStyleWithColumns(40)); 7372 } 7373 7374 TEST_F(FormatTest, BreaksLongDeclarations) { 7375 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7376 " AnotherNameForTheLongType;"); 7377 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7378 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7379 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7380 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7381 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7382 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7383 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7384 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7385 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7386 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7387 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7388 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7389 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7390 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7391 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7392 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7393 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7394 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7395 FormatStyle Indented = getLLVMStyle(); 7396 Indented.IndentWrappedFunctionNames = true; 7397 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7398 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7399 Indented); 7400 verifyFormat( 7401 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7402 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7403 Indented); 7404 verifyFormat( 7405 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7406 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7407 Indented); 7408 verifyFormat( 7409 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7410 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7411 Indented); 7412 7413 // FIXME: Without the comment, this breaks after "(". 7414 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7415 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7416 getGoogleStyle()); 7417 7418 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7419 " int LoooooooooooooooooooongParam2) {}"); 7420 verifyFormat( 7421 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7422 " SourceLocation L, IdentifierIn *II,\n" 7423 " Type *T) {}"); 7424 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7425 "ReallyReaaallyLongFunctionName(\n" 7426 " const std::string &SomeParameter,\n" 7427 " const SomeType<string, SomeOtherTemplateParameter>\n" 7428 " &ReallyReallyLongParameterName,\n" 7429 " const SomeType<string, SomeOtherTemplateParameter>\n" 7430 " &AnotherLongParameterName) {}"); 7431 verifyFormat("template <typename A>\n" 7432 "SomeLoooooooooooooooooooooongType<\n" 7433 " typename some_namespace::SomeOtherType<A>::Type>\n" 7434 "Function() {}"); 7435 7436 verifyGoogleFormat( 7437 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7438 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7439 verifyGoogleFormat( 7440 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7441 " SourceLocation L) {}"); 7442 verifyGoogleFormat( 7443 "some_namespace::LongReturnType\n" 7444 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7445 " int first_long_parameter, int second_parameter) {}"); 7446 7447 verifyGoogleFormat("template <typename T>\n" 7448 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7449 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7450 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7451 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7452 7453 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7454 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7455 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7456 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7457 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7458 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 7459 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7460 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 7461 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 7462 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7463 7464 verifyFormat("template <typename T> // Templates on own line.\n" 7465 "static int // Some comment.\n" 7466 "MyFunction(int a);", 7467 getLLVMStyle()); 7468 } 7469 7470 TEST_F(FormatTest, FormatsArrays) { 7471 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7472 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 7473 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 7474 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 7475 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 7476 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 7477 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7478 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7479 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7480 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 7481 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7482 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7483 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7484 verifyFormat( 7485 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 7486 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7487 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 7488 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 7489 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7490 7491 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 7492 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 7493 verifyFormat( 7494 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 7495 " .aaaaaaa[0]\n" 7496 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7497 verifyFormat("a[::b::c];"); 7498 7499 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 7500 7501 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 7502 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 7503 } 7504 7505 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 7506 verifyFormat("(a)->b();"); 7507 verifyFormat("--a;"); 7508 } 7509 7510 TEST_F(FormatTest, HandlesIncludeDirectives) { 7511 verifyFormat("#include <string>\n" 7512 "#include <a/b/c.h>\n" 7513 "#include \"a/b/string\"\n" 7514 "#include \"string.h\"\n" 7515 "#include \"string.h\"\n" 7516 "#include <a-a>\n" 7517 "#include < path with space >\n" 7518 "#include_next <test.h>" 7519 "#include \"abc.h\" // this is included for ABC\n" 7520 "#include \"some long include\" // with a comment\n" 7521 "#include \"some very long include path\"\n" 7522 "#include <some/very/long/include/path>\n", 7523 getLLVMStyleWithColumns(35)); 7524 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 7525 EXPECT_EQ("#include <a>", format("#include<a>")); 7526 7527 verifyFormat("#import <string>"); 7528 verifyFormat("#import <a/b/c.h>"); 7529 verifyFormat("#import \"a/b/string\""); 7530 verifyFormat("#import \"string.h\""); 7531 verifyFormat("#import \"string.h\""); 7532 verifyFormat("#if __has_include(<strstream>)\n" 7533 "#include <strstream>\n" 7534 "#endif"); 7535 7536 verifyFormat("#define MY_IMPORT <a/b>"); 7537 7538 verifyFormat("#if __has_include(<a/b>)"); 7539 verifyFormat("#if __has_include_next(<a/b>)"); 7540 verifyFormat("#define F __has_include(<a/b>)"); 7541 verifyFormat("#define F __has_include_next(<a/b>)"); 7542 7543 // Protocol buffer definition or missing "#". 7544 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 7545 getLLVMStyleWithColumns(30)); 7546 7547 FormatStyle Style = getLLVMStyle(); 7548 Style.AlwaysBreakBeforeMultilineStrings = true; 7549 Style.ColumnLimit = 0; 7550 verifyFormat("#import \"abc.h\"", Style); 7551 7552 // But 'import' might also be a regular C++ namespace. 7553 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7554 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7555 } 7556 7557 //===----------------------------------------------------------------------===// 7558 // Error recovery tests. 7559 //===----------------------------------------------------------------------===// 7560 7561 TEST_F(FormatTest, IncompleteParameterLists) { 7562 FormatStyle NoBinPacking = getLLVMStyle(); 7563 NoBinPacking.BinPackParameters = false; 7564 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 7565 " double *min_x,\n" 7566 " double *max_x,\n" 7567 " double *min_y,\n" 7568 " double *max_y,\n" 7569 " double *min_z,\n" 7570 " double *max_z, ) {}", 7571 NoBinPacking); 7572 } 7573 7574 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 7575 verifyFormat("void f() { return; }\n42"); 7576 verifyFormat("void f() {\n" 7577 " if (0)\n" 7578 " return;\n" 7579 "}\n" 7580 "42"); 7581 verifyFormat("void f() { return }\n42"); 7582 verifyFormat("void f() {\n" 7583 " if (0)\n" 7584 " return\n" 7585 "}\n" 7586 "42"); 7587 } 7588 7589 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 7590 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 7591 EXPECT_EQ("void f() {\n" 7592 " if (a)\n" 7593 " return\n" 7594 "}", 7595 format("void f ( ) { if ( a ) return }")); 7596 EXPECT_EQ("namespace N {\n" 7597 "void f()\n" 7598 "}", 7599 format("namespace N { void f() }")); 7600 EXPECT_EQ("namespace N {\n" 7601 "void f() {}\n" 7602 "void g()\n" 7603 "} // namespace N", 7604 format("namespace N { void f( ) { } void g( ) }")); 7605 } 7606 7607 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 7608 verifyFormat("int aaaaaaaa =\n" 7609 " // Overlylongcomment\n" 7610 " b;", 7611 getLLVMStyleWithColumns(20)); 7612 verifyFormat("function(\n" 7613 " ShortArgument,\n" 7614 " LoooooooooooongArgument);\n", 7615 getLLVMStyleWithColumns(20)); 7616 } 7617 7618 TEST_F(FormatTest, IncorrectAccessSpecifier) { 7619 verifyFormat("public:"); 7620 verifyFormat("class A {\n" 7621 "public\n" 7622 " void f() {}\n" 7623 "};"); 7624 verifyFormat("public\n" 7625 "int qwerty;"); 7626 verifyFormat("public\n" 7627 "B {}"); 7628 verifyFormat("public\n" 7629 "{}"); 7630 verifyFormat("public\n" 7631 "B { int x; }"); 7632 } 7633 7634 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 7635 verifyFormat("{"); 7636 verifyFormat("#})"); 7637 verifyNoCrash("(/**/[:!] ?[)."); 7638 } 7639 7640 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 7641 // Found by oss-fuzz: 7642 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 7643 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 7644 Style.ColumnLimit = 60; 7645 verifyNoCrash( 7646 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 7647 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 7648 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 7649 Style); 7650 } 7651 7652 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 7653 verifyFormat("do {\n}"); 7654 verifyFormat("do {\n}\n" 7655 "f();"); 7656 verifyFormat("do {\n}\n" 7657 "wheeee(fun);"); 7658 verifyFormat("do {\n" 7659 " f();\n" 7660 "}"); 7661 } 7662 7663 TEST_F(FormatTest, IncorrectCodeMissingParens) { 7664 verifyFormat("if {\n foo;\n foo();\n}"); 7665 verifyFormat("switch {\n foo;\n foo();\n}"); 7666 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 7667 verifyFormat("while {\n foo;\n foo();\n}"); 7668 verifyFormat("do {\n foo;\n foo();\n} while;"); 7669 } 7670 7671 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 7672 verifyIncompleteFormat("namespace {\n" 7673 "class Foo { Foo (\n" 7674 "};\n" 7675 "} // namespace"); 7676 } 7677 7678 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 7679 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 7680 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 7681 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 7682 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 7683 7684 EXPECT_EQ("{\n" 7685 " {\n" 7686 " breakme(\n" 7687 " qwe);\n" 7688 " }\n", 7689 format("{\n" 7690 " {\n" 7691 " breakme(qwe);\n" 7692 "}\n", 7693 getLLVMStyleWithColumns(10))); 7694 } 7695 7696 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 7697 verifyFormat("int x = {\n" 7698 " avariable,\n" 7699 " b(alongervariable)};", 7700 getLLVMStyleWithColumns(25)); 7701 } 7702 7703 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 7704 verifyFormat("return (a)(b){1, 2, 3};"); 7705 } 7706 7707 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 7708 verifyFormat("vector<int> x{1, 2, 3, 4};"); 7709 verifyFormat("vector<int> x{\n" 7710 " 1,\n" 7711 " 2,\n" 7712 " 3,\n" 7713 " 4,\n" 7714 "};"); 7715 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 7716 verifyFormat("f({1, 2});"); 7717 verifyFormat("auto v = Foo{-1};"); 7718 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 7719 verifyFormat("Class::Class : member{1, 2, 3} {}"); 7720 verifyFormat("new vector<int>{1, 2, 3};"); 7721 verifyFormat("new int[3]{1, 2, 3};"); 7722 verifyFormat("new int{1};"); 7723 verifyFormat("return {arg1, arg2};"); 7724 verifyFormat("return {arg1, SomeType{parameter}};"); 7725 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 7726 verifyFormat("new T{arg1, arg2};"); 7727 verifyFormat("f(MyMap[{composite, key}]);"); 7728 verifyFormat("class Class {\n" 7729 " T member = {arg1, arg2};\n" 7730 "};"); 7731 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 7732 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 7733 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 7734 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 7735 verifyFormat("int a = std::is_integral<int>{} + 0;"); 7736 7737 verifyFormat("int foo(int i) { return fo1{}(i); }"); 7738 verifyFormat("int foo(int i) { return fo1{}(i); }"); 7739 verifyFormat("auto i = decltype(x){};"); 7740 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 7741 verifyFormat("Node n{1, Node{1000}, //\n" 7742 " 2};"); 7743 verifyFormat("Aaaa aaaaaaa{\n" 7744 " {\n" 7745 " aaaa,\n" 7746 " },\n" 7747 "};"); 7748 verifyFormat("class C : public D {\n" 7749 " SomeClass SC{2};\n" 7750 "};"); 7751 verifyFormat("class C : public A {\n" 7752 " class D : public B {\n" 7753 " void f() { int i{2}; }\n" 7754 " };\n" 7755 "};"); 7756 verifyFormat("#define A {a, a},"); 7757 7758 // Avoid breaking between equal sign and opening brace 7759 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 7760 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 7761 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 7762 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 7763 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 7764 " {\"ccccccccccccccccccccc\", 2}};", 7765 AvoidBreakingFirstArgument); 7766 7767 // Binpacking only if there is no trailing comma 7768 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 7769 " cccccccccc, dddddddddd};", 7770 getLLVMStyleWithColumns(50)); 7771 verifyFormat("const Aaaaaa aaaaa = {\n" 7772 " aaaaaaaaaaa,\n" 7773 " bbbbbbbbbbb,\n" 7774 " ccccccccccc,\n" 7775 " ddddddddddd,\n" 7776 "};", getLLVMStyleWithColumns(50)); 7777 7778 // Cases where distinguising braced lists and blocks is hard. 7779 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 7780 verifyFormat("void f() {\n" 7781 " return; // comment\n" 7782 "}\n" 7783 "SomeType t;"); 7784 verifyFormat("void f() {\n" 7785 " if (a) {\n" 7786 " f();\n" 7787 " }\n" 7788 "}\n" 7789 "SomeType t;"); 7790 7791 // In combination with BinPackArguments = false. 7792 FormatStyle NoBinPacking = getLLVMStyle(); 7793 NoBinPacking.BinPackArguments = false; 7794 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 7795 " bbbbb,\n" 7796 " ccccc,\n" 7797 " ddddd,\n" 7798 " eeeee,\n" 7799 " ffffff,\n" 7800 " ggggg,\n" 7801 " hhhhhh,\n" 7802 " iiiiii,\n" 7803 " jjjjjj,\n" 7804 " kkkkkk};", 7805 NoBinPacking); 7806 verifyFormat("const Aaaaaa aaaaa = {\n" 7807 " aaaaa,\n" 7808 " bbbbb,\n" 7809 " ccccc,\n" 7810 " ddddd,\n" 7811 " eeeee,\n" 7812 " ffffff,\n" 7813 " ggggg,\n" 7814 " hhhhhh,\n" 7815 " iiiiii,\n" 7816 " jjjjjj,\n" 7817 " kkkkkk,\n" 7818 "};", 7819 NoBinPacking); 7820 verifyFormat( 7821 "const Aaaaaa aaaaa = {\n" 7822 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 7823 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 7824 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 7825 "};", 7826 NoBinPacking); 7827 7828 // FIXME: The alignment of these trailing comments might be bad. Then again, 7829 // this might be utterly useless in real code. 7830 verifyFormat("Constructor::Constructor()\n" 7831 " : some_value{ //\n" 7832 " aaaaaaa, //\n" 7833 " bbbbbbb} {}"); 7834 7835 // In braced lists, the first comment is always assumed to belong to the 7836 // first element. Thus, it can be moved to the next or previous line as 7837 // appropriate. 7838 EXPECT_EQ("function({// First element:\n" 7839 " 1,\n" 7840 " // Second element:\n" 7841 " 2});", 7842 format("function({\n" 7843 " // First element:\n" 7844 " 1,\n" 7845 " // Second element:\n" 7846 " 2});")); 7847 EXPECT_EQ("std::vector<int> MyNumbers{\n" 7848 " // First element:\n" 7849 " 1,\n" 7850 " // Second element:\n" 7851 " 2};", 7852 format("std::vector<int> MyNumbers{// First element:\n" 7853 " 1,\n" 7854 " // Second element:\n" 7855 " 2};", 7856 getLLVMStyleWithColumns(30))); 7857 // A trailing comma should still lead to an enforced line break and no 7858 // binpacking. 7859 EXPECT_EQ("vector<int> SomeVector = {\n" 7860 " // aaa\n" 7861 " 1,\n" 7862 " 2,\n" 7863 "};", 7864 format("vector<int> SomeVector = { // aaa\n" 7865 " 1, 2, };")); 7866 7867 FormatStyle ExtraSpaces = getLLVMStyle(); 7868 ExtraSpaces.Cpp11BracedListStyle = false; 7869 ExtraSpaces.ColumnLimit = 75; 7870 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 7871 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 7872 verifyFormat("f({ 1, 2 });", ExtraSpaces); 7873 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 7874 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 7875 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 7876 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 7877 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 7878 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 7879 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 7880 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 7881 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 7882 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 7883 verifyFormat("class Class {\n" 7884 " T member = { arg1, arg2 };\n" 7885 "};", 7886 ExtraSpaces); 7887 verifyFormat( 7888 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7889 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 7890 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 7891 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 7892 ExtraSpaces); 7893 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 7894 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 7895 ExtraSpaces); 7896 verifyFormat( 7897 "someFunction(OtherParam,\n" 7898 " BracedList{ // comment 1 (Forcing interesting break)\n" 7899 " param1, param2,\n" 7900 " // comment 2\n" 7901 " param3, param4 });", 7902 ExtraSpaces); 7903 verifyFormat( 7904 "std::this_thread::sleep_for(\n" 7905 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 7906 ExtraSpaces); 7907 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 7908 " aaaaaaa,\n" 7909 " aaaaaaaaaa,\n" 7910 " aaaaa,\n" 7911 " aaaaaaaaaaaaaaa,\n" 7912 " aaa,\n" 7913 " aaaaaaaaaa,\n" 7914 " a,\n" 7915 " aaaaaaaaaaaaaaaaaaaaa,\n" 7916 " aaaaaaaaaaaa,\n" 7917 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 7918 " aaaaaaa,\n" 7919 " a};"); 7920 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 7921 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 7922 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 7923 7924 // Avoid breaking between initializer/equal sign and opening brace 7925 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 7926 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 7927 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 7928 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 7929 " { \"ccccccccccccccccccccc\", 2 }\n" 7930 "};", 7931 ExtraSpaces); 7932 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 7933 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 7934 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 7935 " { \"ccccccccccccccccccccc\", 2 }\n" 7936 "};", 7937 ExtraSpaces); 7938 7939 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 7940 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 7941 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 7942 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 7943 } 7944 7945 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 7946 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7947 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7948 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7949 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7950 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7951 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 7952 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 7953 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7954 " 1, 22, 333, 4444, 55555, //\n" 7955 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7956 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 7957 verifyFormat( 7958 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7959 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7960 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 7961 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 7962 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 7963 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 7964 " 7777777};"); 7965 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 7966 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 7967 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 7968 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 7969 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 7970 " // Separating comment.\n" 7971 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 7972 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 7973 " // Leading comment\n" 7974 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 7975 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 7976 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 7977 " 1, 1, 1, 1};", 7978 getLLVMStyleWithColumns(39)); 7979 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 7980 " 1, 1, 1, 1};", 7981 getLLVMStyleWithColumns(38)); 7982 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 7983 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 7984 getLLVMStyleWithColumns(43)); 7985 verifyFormat( 7986 "static unsigned SomeValues[10][3] = {\n" 7987 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 7988 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 7989 verifyFormat("static auto fields = new vector<string>{\n" 7990 " \"aaaaaaaaaaaaa\",\n" 7991 " \"aaaaaaaaaaaaa\",\n" 7992 " \"aaaaaaaaaaaa\",\n" 7993 " \"aaaaaaaaaaaaaa\",\n" 7994 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 7995 " \"aaaaaaaaaaaa\",\n" 7996 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 7997 "};"); 7998 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 7999 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 8000 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 8001 " 3, cccccccccccccccccccccc};", 8002 getLLVMStyleWithColumns(60)); 8003 8004 // Trailing commas. 8005 verifyFormat("vector<int> x = {\n" 8006 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 8007 "};", 8008 getLLVMStyleWithColumns(39)); 8009 verifyFormat("vector<int> x = {\n" 8010 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 8011 "};", 8012 getLLVMStyleWithColumns(39)); 8013 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8014 " 1, 1, 1, 1,\n" 8015 " /**/ /**/};", 8016 getLLVMStyleWithColumns(39)); 8017 8018 // Trailing comment in the first line. 8019 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 8020 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 8021 " 111111111, 222222222, 3333333333, 444444444, //\n" 8022 " 11111111, 22222222, 333333333, 44444444};"); 8023 // Trailing comment in the last line. 8024 verifyFormat("int aaaaa[] = {\n" 8025 " 1, 2, 3, // comment\n" 8026 " 4, 5, 6 // comment\n" 8027 "};"); 8028 8029 // With nested lists, we should either format one item per line or all nested 8030 // lists one on line. 8031 // FIXME: For some nested lists, we can do better. 8032 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 8033 " {aaaaaaaaaaaaaaaaaaa},\n" 8034 " {aaaaaaaaaaaaaaaaaaaaa},\n" 8035 " {aaaaaaaaaaaaaaaaa}};", 8036 getLLVMStyleWithColumns(60)); 8037 verifyFormat( 8038 "SomeStruct my_struct_array = {\n" 8039 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 8040 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 8041 " {aaa, aaa},\n" 8042 " {aaa, aaa},\n" 8043 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 8044 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 8045 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 8046 8047 // No column layout should be used here. 8048 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 8049 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 8050 8051 verifyNoCrash("a<,"); 8052 8053 // No braced initializer here. 8054 verifyFormat("void f() {\n" 8055 " struct Dummy {};\n" 8056 " f(v);\n" 8057 "}"); 8058 8059 // Long lists should be formatted in columns even if they are nested. 8060 verifyFormat( 8061 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8062 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8063 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8064 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8065 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8066 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 8067 8068 // Allow "single-column" layout even if that violates the column limit. There 8069 // isn't going to be a better way. 8070 verifyFormat("std::vector<int> a = {\n" 8071 " aaaaaaaa,\n" 8072 " aaaaaaaa,\n" 8073 " aaaaaaaa,\n" 8074 " aaaaaaaa,\n" 8075 " aaaaaaaaaa,\n" 8076 " aaaaaaaa,\n" 8077 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 8078 getLLVMStyleWithColumns(30)); 8079 verifyFormat("vector<int> aaaa = {\n" 8080 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8081 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8082 " aaaaaa.aaaaaaa,\n" 8083 " aaaaaa.aaaaaaa,\n" 8084 " aaaaaa.aaaaaaa,\n" 8085 " aaaaaa.aaaaaaa,\n" 8086 "};"); 8087 8088 // Don't create hanging lists. 8089 verifyFormat("someFunction(Param, {List1, List2,\n" 8090 " List3});", 8091 getLLVMStyleWithColumns(35)); 8092 verifyFormat("someFunction(Param, Param,\n" 8093 " {List1, List2,\n" 8094 " List3});", 8095 getLLVMStyleWithColumns(35)); 8096 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 8097 " aaaaaaaaaaaaaaaaaaaaaaa);"); 8098 } 8099 8100 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 8101 FormatStyle DoNotMerge = getLLVMStyle(); 8102 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8103 8104 verifyFormat("void f() { return 42; }"); 8105 verifyFormat("void f() {\n" 8106 " return 42;\n" 8107 "}", 8108 DoNotMerge); 8109 verifyFormat("void f() {\n" 8110 " // Comment\n" 8111 "}"); 8112 verifyFormat("{\n" 8113 "#error {\n" 8114 " int a;\n" 8115 "}"); 8116 verifyFormat("{\n" 8117 " int a;\n" 8118 "#error {\n" 8119 "}"); 8120 verifyFormat("void f() {} // comment"); 8121 verifyFormat("void f() { int a; } // comment"); 8122 verifyFormat("void f() {\n" 8123 "} // comment", 8124 DoNotMerge); 8125 verifyFormat("void f() {\n" 8126 " int a;\n" 8127 "} // comment", 8128 DoNotMerge); 8129 verifyFormat("void f() {\n" 8130 "} // comment", 8131 getLLVMStyleWithColumns(15)); 8132 8133 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 8134 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 8135 8136 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 8137 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 8138 verifyFormat("class C {\n" 8139 " C()\n" 8140 " : iiiiiiii(nullptr),\n" 8141 " kkkkkkk(nullptr),\n" 8142 " mmmmmmm(nullptr),\n" 8143 " nnnnnnn(nullptr) {}\n" 8144 "};", 8145 getGoogleStyle()); 8146 8147 FormatStyle NoColumnLimit = getLLVMStyle(); 8148 NoColumnLimit.ColumnLimit = 0; 8149 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 8150 EXPECT_EQ("class C {\n" 8151 " A() : b(0) {}\n" 8152 "};", 8153 format("class C{A():b(0){}};", NoColumnLimit)); 8154 EXPECT_EQ("A()\n" 8155 " : b(0) {\n" 8156 "}", 8157 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 8158 8159 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 8160 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 8161 FormatStyle::SFS_None; 8162 EXPECT_EQ("A()\n" 8163 " : b(0) {\n" 8164 "}", 8165 format("A():b(0){}", DoNotMergeNoColumnLimit)); 8166 EXPECT_EQ("A()\n" 8167 " : b(0) {\n" 8168 "}", 8169 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 8170 8171 verifyFormat("#define A \\\n" 8172 " void f() { \\\n" 8173 " int i; \\\n" 8174 " }", 8175 getLLVMStyleWithColumns(20)); 8176 verifyFormat("#define A \\\n" 8177 " void f() { int i; }", 8178 getLLVMStyleWithColumns(21)); 8179 verifyFormat("#define A \\\n" 8180 " void f() { \\\n" 8181 " int i; \\\n" 8182 " } \\\n" 8183 " int j;", 8184 getLLVMStyleWithColumns(22)); 8185 verifyFormat("#define A \\\n" 8186 " void f() { int i; } \\\n" 8187 " int j;", 8188 getLLVMStyleWithColumns(23)); 8189 } 8190 8191 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 8192 FormatStyle MergeEmptyOnly = getLLVMStyle(); 8193 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8194 verifyFormat("class C {\n" 8195 " int f() {}\n" 8196 "};", 8197 MergeEmptyOnly); 8198 verifyFormat("class C {\n" 8199 " int f() {\n" 8200 " return 42;\n" 8201 " }\n" 8202 "};", 8203 MergeEmptyOnly); 8204 verifyFormat("int f() {}", MergeEmptyOnly); 8205 verifyFormat("int f() {\n" 8206 " return 42;\n" 8207 "}", 8208 MergeEmptyOnly); 8209 8210 // Also verify behavior when BraceWrapping.AfterFunction = true 8211 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8212 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 8213 verifyFormat("int f() {}", MergeEmptyOnly); 8214 verifyFormat("class C {\n" 8215 " int f() {}\n" 8216 "};", 8217 MergeEmptyOnly); 8218 } 8219 8220 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 8221 FormatStyle MergeInlineOnly = getLLVMStyle(); 8222 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8223 verifyFormat("class C {\n" 8224 " int f() { return 42; }\n" 8225 "};", 8226 MergeInlineOnly); 8227 verifyFormat("int f() {\n" 8228 " return 42;\n" 8229 "}", 8230 MergeInlineOnly); 8231 8232 // SFS_Inline implies SFS_Empty 8233 verifyFormat("class C {\n" 8234 " int f() {}\n" 8235 "};", 8236 MergeInlineOnly); 8237 verifyFormat("int f() {}", MergeInlineOnly); 8238 8239 // Also verify behavior when BraceWrapping.AfterFunction = true 8240 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8241 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8242 verifyFormat("class C {\n" 8243 " int f() { return 42; }\n" 8244 "};", 8245 MergeInlineOnly); 8246 verifyFormat("int f()\n" 8247 "{\n" 8248 " return 42;\n" 8249 "}", 8250 MergeInlineOnly); 8251 8252 // SFS_Inline implies SFS_Empty 8253 verifyFormat("int f() {}", MergeInlineOnly); 8254 verifyFormat("class C {\n" 8255 " int f() {}\n" 8256 "};", 8257 MergeInlineOnly); 8258 } 8259 8260 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8261 FormatStyle MergeInlineOnly = getLLVMStyle(); 8262 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8263 FormatStyle::SFS_InlineOnly; 8264 verifyFormat("class C {\n" 8265 " int f() { return 42; }\n" 8266 "};", 8267 MergeInlineOnly); 8268 verifyFormat("int f() {\n" 8269 " return 42;\n" 8270 "}", 8271 MergeInlineOnly); 8272 8273 // SFS_InlineOnly does not imply SFS_Empty 8274 verifyFormat("class C {\n" 8275 " int f() {}\n" 8276 "};", 8277 MergeInlineOnly); 8278 verifyFormat("int f() {\n" 8279 "}", 8280 MergeInlineOnly); 8281 8282 // Also verify behavior when BraceWrapping.AfterFunction = true 8283 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8284 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8285 verifyFormat("class C {\n" 8286 " int f() { return 42; }\n" 8287 "};", 8288 MergeInlineOnly); 8289 verifyFormat("int f()\n" 8290 "{\n" 8291 " return 42;\n" 8292 "}", 8293 MergeInlineOnly); 8294 8295 // SFS_InlineOnly does not imply SFS_Empty 8296 verifyFormat("int f()\n" 8297 "{\n" 8298 "}", 8299 MergeInlineOnly); 8300 verifyFormat("class C {\n" 8301 " int f() {}\n" 8302 "};", 8303 MergeInlineOnly); 8304 } 8305 8306 TEST_F(FormatTest, SplitEmptyFunction) { 8307 FormatStyle Style = getLLVMStyle(); 8308 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8309 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8310 Style.BraceWrapping.AfterFunction = true; 8311 Style.BraceWrapping.SplitEmptyFunction = false; 8312 Style.ColumnLimit = 40; 8313 8314 verifyFormat("int f()\n" 8315 "{}", 8316 Style); 8317 verifyFormat("int f()\n" 8318 "{\n" 8319 " return 42;\n" 8320 "}", 8321 Style); 8322 verifyFormat("int f()\n" 8323 "{\n" 8324 " // some comment\n" 8325 "}", 8326 Style); 8327 8328 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8329 verifyFormat("int f() {}", Style); 8330 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8331 "{}", 8332 Style); 8333 verifyFormat("int f()\n" 8334 "{\n" 8335 " return 0;\n" 8336 "}", 8337 Style); 8338 8339 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8340 verifyFormat("class Foo {\n" 8341 " int f() {}\n" 8342 "};\n", 8343 Style); 8344 verifyFormat("class Foo {\n" 8345 " int f() { return 0; }\n" 8346 "};\n", 8347 Style); 8348 verifyFormat("class Foo {\n" 8349 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8350 " {}\n" 8351 "};\n", 8352 Style); 8353 verifyFormat("class Foo {\n" 8354 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8355 " {\n" 8356 " return 0;\n" 8357 " }\n" 8358 "};\n", 8359 Style); 8360 8361 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8362 verifyFormat("int f() {}", Style); 8363 verifyFormat("int f() { return 0; }", Style); 8364 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8365 "{}", 8366 Style); 8367 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8368 "{\n" 8369 " return 0;\n" 8370 "}", 8371 Style); 8372 } 8373 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8374 FormatStyle Style = getLLVMStyle(); 8375 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8376 verifyFormat("#ifdef A\n" 8377 "int f() {}\n" 8378 "#else\n" 8379 "int g() {}\n" 8380 "#endif", 8381 Style); 8382 } 8383 8384 TEST_F(FormatTest, SplitEmptyClass) { 8385 FormatStyle Style = getLLVMStyle(); 8386 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8387 Style.BraceWrapping.AfterClass = true; 8388 Style.BraceWrapping.SplitEmptyRecord = false; 8389 8390 verifyFormat("class Foo\n" 8391 "{};", 8392 Style); 8393 verifyFormat("/* something */ class Foo\n" 8394 "{};", 8395 Style); 8396 verifyFormat("template <typename X> class Foo\n" 8397 "{};", 8398 Style); 8399 verifyFormat("class Foo\n" 8400 "{\n" 8401 " Foo();\n" 8402 "};", 8403 Style); 8404 verifyFormat("typedef class Foo\n" 8405 "{\n" 8406 "} Foo_t;", 8407 Style); 8408 } 8409 8410 TEST_F(FormatTest, SplitEmptyStruct) { 8411 FormatStyle Style = getLLVMStyle(); 8412 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8413 Style.BraceWrapping.AfterStruct = true; 8414 Style.BraceWrapping.SplitEmptyRecord = false; 8415 8416 verifyFormat("struct Foo\n" 8417 "{};", 8418 Style); 8419 verifyFormat("/* something */ struct Foo\n" 8420 "{};", 8421 Style); 8422 verifyFormat("template <typename X> struct Foo\n" 8423 "{};", 8424 Style); 8425 verifyFormat("struct Foo\n" 8426 "{\n" 8427 " Foo();\n" 8428 "};", 8429 Style); 8430 verifyFormat("typedef struct Foo\n" 8431 "{\n" 8432 "} Foo_t;", 8433 Style); 8434 //typedef struct Bar {} Bar_t; 8435 } 8436 8437 TEST_F(FormatTest, SplitEmptyUnion) { 8438 FormatStyle Style = getLLVMStyle(); 8439 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8440 Style.BraceWrapping.AfterUnion = true; 8441 Style.BraceWrapping.SplitEmptyRecord = false; 8442 8443 verifyFormat("union Foo\n" 8444 "{};", 8445 Style); 8446 verifyFormat("/* something */ union Foo\n" 8447 "{};", 8448 Style); 8449 verifyFormat("union Foo\n" 8450 "{\n" 8451 " A,\n" 8452 "};", 8453 Style); 8454 verifyFormat("typedef union Foo\n" 8455 "{\n" 8456 "} Foo_t;", 8457 Style); 8458 } 8459 8460 TEST_F(FormatTest, SplitEmptyNamespace) { 8461 FormatStyle Style = getLLVMStyle(); 8462 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8463 Style.BraceWrapping.AfterNamespace = true; 8464 Style.BraceWrapping.SplitEmptyNamespace = false; 8465 8466 verifyFormat("namespace Foo\n" 8467 "{};", 8468 Style); 8469 verifyFormat("/* something */ namespace Foo\n" 8470 "{};", 8471 Style); 8472 verifyFormat("inline namespace Foo\n" 8473 "{};", 8474 Style); 8475 verifyFormat("/* something */ inline namespace Foo\n" 8476 "{};", 8477 Style); 8478 verifyFormat("export namespace Foo\n" 8479 "{};", 8480 Style); 8481 verifyFormat("namespace Foo\n" 8482 "{\n" 8483 "void Bar();\n" 8484 "};", 8485 Style); 8486 } 8487 8488 TEST_F(FormatTest, NeverMergeShortRecords) { 8489 FormatStyle Style = getLLVMStyle(); 8490 8491 verifyFormat("class Foo {\n" 8492 " Foo();\n" 8493 "};", 8494 Style); 8495 verifyFormat("typedef class Foo {\n" 8496 " Foo();\n" 8497 "} Foo_t;", 8498 Style); 8499 verifyFormat("struct Foo {\n" 8500 " Foo();\n" 8501 "};", 8502 Style); 8503 verifyFormat("typedef struct Foo {\n" 8504 " Foo();\n" 8505 "} Foo_t;", 8506 Style); 8507 verifyFormat("union Foo {\n" 8508 " A,\n" 8509 "};", 8510 Style); 8511 verifyFormat("typedef union Foo {\n" 8512 " A,\n" 8513 "} Foo_t;", 8514 Style); 8515 verifyFormat("namespace Foo {\n" 8516 "void Bar();\n" 8517 "};", 8518 Style); 8519 8520 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8521 Style.BraceWrapping.AfterClass = true; 8522 Style.BraceWrapping.AfterStruct = true; 8523 Style.BraceWrapping.AfterUnion = true; 8524 Style.BraceWrapping.AfterNamespace = true; 8525 verifyFormat("class Foo\n" 8526 "{\n" 8527 " Foo();\n" 8528 "};", 8529 Style); 8530 verifyFormat("typedef class Foo\n" 8531 "{\n" 8532 " Foo();\n" 8533 "} Foo_t;", 8534 Style); 8535 verifyFormat("struct Foo\n" 8536 "{\n" 8537 " Foo();\n" 8538 "};", 8539 Style); 8540 verifyFormat("typedef struct Foo\n" 8541 "{\n" 8542 " Foo();\n" 8543 "} Foo_t;", 8544 Style); 8545 verifyFormat("union Foo\n" 8546 "{\n" 8547 " A,\n" 8548 "};", 8549 Style); 8550 verifyFormat("typedef union Foo\n" 8551 "{\n" 8552 " A,\n" 8553 "} Foo_t;", 8554 Style); 8555 verifyFormat("namespace Foo\n" 8556 "{\n" 8557 "void Bar();\n" 8558 "};", 8559 Style); 8560 } 8561 8562 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 8563 // Elaborate type variable declarations. 8564 verifyFormat("struct foo a = {bar};\nint n;"); 8565 verifyFormat("class foo a = {bar};\nint n;"); 8566 verifyFormat("union foo a = {bar};\nint n;"); 8567 8568 // Elaborate types inside function definitions. 8569 verifyFormat("struct foo f() {}\nint n;"); 8570 verifyFormat("class foo f() {}\nint n;"); 8571 verifyFormat("union foo f() {}\nint n;"); 8572 8573 // Templates. 8574 verifyFormat("template <class X> void f() {}\nint n;"); 8575 verifyFormat("template <struct X> void f() {}\nint n;"); 8576 verifyFormat("template <union X> void f() {}\nint n;"); 8577 8578 // Actual definitions... 8579 verifyFormat("struct {\n} n;"); 8580 verifyFormat( 8581 "template <template <class T, class Y>, class Z> class X {\n} n;"); 8582 verifyFormat("union Z {\n int n;\n} x;"); 8583 verifyFormat("class MACRO Z {\n} n;"); 8584 verifyFormat("class MACRO(X) Z {\n} n;"); 8585 verifyFormat("class __attribute__(X) Z {\n} n;"); 8586 verifyFormat("class __declspec(X) Z {\n} n;"); 8587 verifyFormat("class A##B##C {\n} n;"); 8588 verifyFormat("class alignas(16) Z {\n} n;"); 8589 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 8590 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 8591 8592 // Redefinition from nested context: 8593 verifyFormat("class A::B::C {\n} n;"); 8594 8595 // Template definitions. 8596 verifyFormat( 8597 "template <typename F>\n" 8598 "Matcher(const Matcher<F> &Other,\n" 8599 " typename enable_if_c<is_base_of<F, T>::value &&\n" 8600 " !is_same<F, T>::value>::type * = 0)\n" 8601 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 8602 8603 // FIXME: This is still incorrectly handled at the formatter side. 8604 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 8605 verifyFormat("int i = SomeFunction(a<b, a> b);"); 8606 8607 // FIXME: 8608 // This now gets parsed incorrectly as class definition. 8609 // verifyFormat("class A<int> f() {\n}\nint n;"); 8610 8611 // Elaborate types where incorrectly parsing the structural element would 8612 // break the indent. 8613 verifyFormat("if (true)\n" 8614 " class X x;\n" 8615 "else\n" 8616 " f();\n"); 8617 8618 // This is simply incomplete. Formatting is not important, but must not crash. 8619 verifyFormat("class A:"); 8620 } 8621 8622 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 8623 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 8624 format("#error Leave all white!!!!! space* alone!\n")); 8625 EXPECT_EQ( 8626 "#warning Leave all white!!!!! space* alone!\n", 8627 format("#warning Leave all white!!!!! space* alone!\n")); 8628 EXPECT_EQ("#error 1", format(" # error 1")); 8629 EXPECT_EQ("#warning 1", format(" # warning 1")); 8630 } 8631 8632 TEST_F(FormatTest, FormatHashIfExpressions) { 8633 verifyFormat("#if AAAA && BBBB"); 8634 verifyFormat("#if (AAAA && BBBB)"); 8635 verifyFormat("#elif (AAAA && BBBB)"); 8636 // FIXME: Come up with a better indentation for #elif. 8637 verifyFormat( 8638 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 8639 " defined(BBBBBBBB)\n" 8640 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 8641 " defined(BBBBBBBB)\n" 8642 "#endif", 8643 getLLVMStyleWithColumns(65)); 8644 } 8645 8646 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 8647 FormatStyle AllowsMergedIf = getGoogleStyle(); 8648 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 8649 FormatStyle::SIS_WithoutElse; 8650 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 8651 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 8652 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 8653 EXPECT_EQ("if (true) return 42;", 8654 format("if (true)\nreturn 42;", AllowsMergedIf)); 8655 FormatStyle ShortMergedIf = AllowsMergedIf; 8656 ShortMergedIf.ColumnLimit = 25; 8657 verifyFormat("#define A \\\n" 8658 " if (true) return 42;", 8659 ShortMergedIf); 8660 verifyFormat("#define A \\\n" 8661 " f(); \\\n" 8662 " if (true)\n" 8663 "#define B", 8664 ShortMergedIf); 8665 verifyFormat("#define A \\\n" 8666 " f(); \\\n" 8667 " if (true)\n" 8668 "g();", 8669 ShortMergedIf); 8670 verifyFormat("{\n" 8671 "#ifdef A\n" 8672 " // Comment\n" 8673 " if (true) continue;\n" 8674 "#endif\n" 8675 " // Comment\n" 8676 " if (true) continue;\n" 8677 "}", 8678 ShortMergedIf); 8679 ShortMergedIf.ColumnLimit = 33; 8680 verifyFormat("#define A \\\n" 8681 " if constexpr (true) return 42;", 8682 ShortMergedIf); 8683 verifyFormat("#define A \\\n" 8684 " if CONSTEXPR (true) return 42;", 8685 ShortMergedIf); 8686 ShortMergedIf.ColumnLimit = 29; 8687 verifyFormat("#define A \\\n" 8688 " if (aaaaaaaaaa) return 1; \\\n" 8689 " return 2;", 8690 ShortMergedIf); 8691 ShortMergedIf.ColumnLimit = 28; 8692 verifyFormat("#define A \\\n" 8693 " if (aaaaaaaaaa) \\\n" 8694 " return 1; \\\n" 8695 " return 2;", 8696 ShortMergedIf); 8697 verifyFormat("#define A \\\n" 8698 " if constexpr (aaaaaaa) \\\n" 8699 " return 1; \\\n" 8700 " return 2;", 8701 ShortMergedIf); 8702 verifyFormat("#define A \\\n" 8703 " if CONSTEXPR (aaaaaaa) \\\n" 8704 " return 1; \\\n" 8705 " return 2;", 8706 ShortMergedIf); 8707 } 8708 8709 TEST_F(FormatTest, FormatStarDependingOnContext) { 8710 verifyFormat("void f(int *a);"); 8711 verifyFormat("void f() { f(fint * b); }"); 8712 verifyFormat("class A {\n void f(int *a);\n};"); 8713 verifyFormat("class A {\n int *a;\n};"); 8714 verifyFormat("namespace a {\n" 8715 "namespace b {\n" 8716 "class A {\n" 8717 " void f() {}\n" 8718 " int *a;\n" 8719 "};\n" 8720 "} // namespace b\n" 8721 "} // namespace a"); 8722 } 8723 8724 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 8725 verifyFormat("while"); 8726 verifyFormat("operator"); 8727 } 8728 8729 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 8730 // This code would be painfully slow to format if we didn't skip it. 8731 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 8732 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8733 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8734 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8735 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8736 "A(1, 1)\n" 8737 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 8738 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8739 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8740 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8741 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8742 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8743 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8744 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8745 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8746 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 8747 // Deeply nested part is untouched, rest is formatted. 8748 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 8749 format(std::string("int i;\n") + Code + "int j;\n", 8750 getLLVMStyle(), SC_ExpectIncomplete)); 8751 } 8752 8753 //===----------------------------------------------------------------------===// 8754 // Objective-C tests. 8755 //===----------------------------------------------------------------------===// 8756 8757 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 8758 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 8759 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 8760 format("-(NSUInteger)indexOfObject:(id)anObject;")); 8761 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 8762 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 8763 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 8764 format("-(NSInteger)Method3:(id)anObject;")); 8765 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 8766 format("-(NSInteger)Method4:(id)anObject;")); 8767 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 8768 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 8769 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 8770 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 8771 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 8772 "forAllCells:(BOOL)flag;", 8773 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 8774 "forAllCells:(BOOL)flag;")); 8775 8776 // Very long objectiveC method declaration. 8777 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 8778 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 8779 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 8780 " inRange:(NSRange)range\n" 8781 " outRange:(NSRange)out_range\n" 8782 " outRange1:(NSRange)out_range1\n" 8783 " outRange2:(NSRange)out_range2\n" 8784 " outRange3:(NSRange)out_range3\n" 8785 " outRange4:(NSRange)out_range4\n" 8786 " outRange5:(NSRange)out_range5\n" 8787 " outRange6:(NSRange)out_range6\n" 8788 " outRange7:(NSRange)out_range7\n" 8789 " outRange8:(NSRange)out_range8\n" 8790 " outRange9:(NSRange)out_range9;"); 8791 8792 // When the function name has to be wrapped. 8793 FormatStyle Style = getLLVMStyle(); 8794 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 8795 // and always indents instead. 8796 Style.IndentWrappedFunctionNames = false; 8797 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 8798 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 8799 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 8800 "}", 8801 Style); 8802 Style.IndentWrappedFunctionNames = true; 8803 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 8804 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 8805 " anotherName:(NSString)dddddddddddddd {\n" 8806 "}", 8807 Style); 8808 8809 verifyFormat("- (int)sum:(vector<int>)numbers;"); 8810 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 8811 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 8812 // protocol lists (but not for template classes): 8813 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 8814 8815 verifyFormat("- (int (*)())foo:(int (*)())f;"); 8816 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 8817 8818 // If there's no return type (very rare in practice!), LLVM and Google style 8819 // agree. 8820 verifyFormat("- foo;"); 8821 verifyFormat("- foo:(int)f;"); 8822 verifyGoogleFormat("- foo:(int)foo;"); 8823 } 8824 8825 8826 TEST_F(FormatTest, BreaksStringLiterals) { 8827 EXPECT_EQ("\"some text \"\n" 8828 "\"other\";", 8829 format("\"some text other\";", getLLVMStyleWithColumns(12))); 8830 EXPECT_EQ("\"some text \"\n" 8831 "\"other\";", 8832 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 8833 EXPECT_EQ( 8834 "#define A \\\n" 8835 " \"some \" \\\n" 8836 " \"text \" \\\n" 8837 " \"other\";", 8838 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 8839 EXPECT_EQ( 8840 "#define A \\\n" 8841 " \"so \" \\\n" 8842 " \"text \" \\\n" 8843 " \"other\";", 8844 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 8845 8846 EXPECT_EQ("\"some text\"", 8847 format("\"some text\"", getLLVMStyleWithColumns(1))); 8848 EXPECT_EQ("\"some text\"", 8849 format("\"some text\"", getLLVMStyleWithColumns(11))); 8850 EXPECT_EQ("\"some \"\n" 8851 "\"text\"", 8852 format("\"some text\"", getLLVMStyleWithColumns(10))); 8853 EXPECT_EQ("\"some \"\n" 8854 "\"text\"", 8855 format("\"some text\"", getLLVMStyleWithColumns(7))); 8856 EXPECT_EQ("\"some\"\n" 8857 "\" tex\"\n" 8858 "\"t\"", 8859 format("\"some text\"", getLLVMStyleWithColumns(6))); 8860 EXPECT_EQ("\"some\"\n" 8861 "\" tex\"\n" 8862 "\" and\"", 8863 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 8864 EXPECT_EQ("\"some\"\n" 8865 "\"/tex\"\n" 8866 "\"/and\"", 8867 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 8868 8869 EXPECT_EQ("variable =\n" 8870 " \"long string \"\n" 8871 " \"literal\";", 8872 format("variable = \"long string literal\";", 8873 getLLVMStyleWithColumns(20))); 8874 8875 EXPECT_EQ("variable = f(\n" 8876 " \"long string \"\n" 8877 " \"literal\",\n" 8878 " short,\n" 8879 " loooooooooooooooooooong);", 8880 format("variable = f(\"long string literal\", short, " 8881 "loooooooooooooooooooong);", 8882 getLLVMStyleWithColumns(20))); 8883 8884 EXPECT_EQ( 8885 "f(g(\"long string \"\n" 8886 " \"literal\"),\n" 8887 " b);", 8888 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 8889 EXPECT_EQ("f(g(\"long string \"\n" 8890 " \"literal\",\n" 8891 " a),\n" 8892 " b);", 8893 format("f(g(\"long string literal\", a), b);", 8894 getLLVMStyleWithColumns(20))); 8895 EXPECT_EQ( 8896 "f(\"one two\".split(\n" 8897 " variable));", 8898 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 8899 EXPECT_EQ("f(\"one two three four five six \"\n" 8900 " \"seven\".split(\n" 8901 " really_looooong_variable));", 8902 format("f(\"one two three four five six seven\"." 8903 "split(really_looooong_variable));", 8904 getLLVMStyleWithColumns(33))); 8905 8906 EXPECT_EQ("f(\"some \"\n" 8907 " \"text\",\n" 8908 " other);", 8909 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 8910 8911 // Only break as a last resort. 8912 verifyFormat( 8913 "aaaaaaaaaaaaaaaaaaaa(\n" 8914 " aaaaaaaaaaaaaaaaaaaa,\n" 8915 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 8916 8917 EXPECT_EQ("\"splitmea\"\n" 8918 "\"trandomp\"\n" 8919 "\"oint\"", 8920 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 8921 8922 EXPECT_EQ("\"split/\"\n" 8923 "\"pathat/\"\n" 8924 "\"slashes\"", 8925 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 8926 8927 EXPECT_EQ("\"split/\"\n" 8928 "\"pathat/\"\n" 8929 "\"slashes\"", 8930 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 8931 EXPECT_EQ("\"split at \"\n" 8932 "\"spaces/at/\"\n" 8933 "\"slashes.at.any$\"\n" 8934 "\"non-alphanumeric%\"\n" 8935 "\"1111111111characte\"\n" 8936 "\"rs\"", 8937 format("\"split at " 8938 "spaces/at/" 8939 "slashes.at." 8940 "any$non-" 8941 "alphanumeric%" 8942 "1111111111characte" 8943 "rs\"", 8944 getLLVMStyleWithColumns(20))); 8945 8946 // Verify that splitting the strings understands 8947 // Style::AlwaysBreakBeforeMultilineStrings. 8948 EXPECT_EQ( 8949 "aaaaaaaaaaaa(\n" 8950 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 8951 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 8952 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 8953 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 8954 "aaaaaaaaaaaaaaaaaaaaaa\");", 8955 getGoogleStyle())); 8956 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 8957 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 8958 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 8959 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 8960 "aaaaaaaaaaaaaaaaaaaaaa\";", 8961 getGoogleStyle())); 8962 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 8963 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 8964 format("llvm::outs() << " 8965 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 8966 "aaaaaaaaaaaaaaaaaaa\";")); 8967 EXPECT_EQ("ffff(\n" 8968 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 8969 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 8970 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 8971 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 8972 getGoogleStyle())); 8973 8974 FormatStyle Style = getLLVMStyleWithColumns(12); 8975 Style.BreakStringLiterals = false; 8976 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 8977 8978 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 8979 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 8980 EXPECT_EQ("#define A \\\n" 8981 " \"some \" \\\n" 8982 " \"text \" \\\n" 8983 " \"other\";", 8984 format("#define A \"some text other\";", AlignLeft)); 8985 } 8986 8987 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 8988 EXPECT_EQ("C a = \"some more \"\n" 8989 " \"text\";", 8990 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 8991 } 8992 8993 TEST_F(FormatTest, FullyRemoveEmptyLines) { 8994 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 8995 NoEmptyLines.MaxEmptyLinesToKeep = 0; 8996 EXPECT_EQ("int i = a(b());", 8997 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 8998 } 8999 9000 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 9001 EXPECT_EQ( 9002 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9003 "(\n" 9004 " \"x\t\");", 9005 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9006 "aaaaaaa(" 9007 "\"x\t\");")); 9008 } 9009 9010 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 9011 EXPECT_EQ( 9012 "u8\"utf8 string \"\n" 9013 "u8\"literal\";", 9014 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 9015 EXPECT_EQ( 9016 "u\"utf16 string \"\n" 9017 "u\"literal\";", 9018 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 9019 EXPECT_EQ( 9020 "U\"utf32 string \"\n" 9021 "U\"literal\";", 9022 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 9023 EXPECT_EQ("L\"wide string \"\n" 9024 "L\"literal\";", 9025 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 9026 EXPECT_EQ("@\"NSString \"\n" 9027 "@\"literal\";", 9028 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 9029 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 9030 9031 // This input makes clang-format try to split the incomplete unicode escape 9032 // sequence, which used to lead to a crasher. 9033 verifyNoCrash( 9034 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 9035 getLLVMStyleWithColumns(60)); 9036 } 9037 9038 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 9039 FormatStyle Style = getGoogleStyleWithColumns(15); 9040 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 9041 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 9042 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 9043 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 9044 EXPECT_EQ("u8R\"x(raw literal)x\";", 9045 format("u8R\"x(raw literal)x\";", Style)); 9046 } 9047 9048 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 9049 FormatStyle Style = getLLVMStyleWithColumns(20); 9050 EXPECT_EQ( 9051 "_T(\"aaaaaaaaaaaaaa\")\n" 9052 "_T(\"aaaaaaaaaaaaaa\")\n" 9053 "_T(\"aaaaaaaaaaaa\")", 9054 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 9055 EXPECT_EQ("f(x,\n" 9056 " _T(\"aaaaaaaaaaaa\")\n" 9057 " _T(\"aaa\"),\n" 9058 " z);", 9059 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 9060 9061 // FIXME: Handle embedded spaces in one iteration. 9062 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 9063 // "_T(\"aaaaaaaaaaaaa\")\n" 9064 // "_T(\"aaaaaaaaaaaaa\")\n" 9065 // "_T(\"a\")", 9066 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9067 // getLLVMStyleWithColumns(20))); 9068 EXPECT_EQ( 9069 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9070 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 9071 EXPECT_EQ("f(\n" 9072 "#if !TEST\n" 9073 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9074 "#endif\n" 9075 ");", 9076 format("f(\n" 9077 "#if !TEST\n" 9078 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9079 "#endif\n" 9080 ");")); 9081 EXPECT_EQ("f(\n" 9082 "\n" 9083 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 9084 format("f(\n" 9085 "\n" 9086 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 9087 } 9088 9089 TEST_F(FormatTest, BreaksStringLiteralOperands) { 9090 // In a function call with two operands, the second can be broken with no line 9091 // break before it. 9092 EXPECT_EQ("func(a, \"long long \"\n" 9093 " \"long long\");", 9094 format("func(a, \"long long long long\");", 9095 getLLVMStyleWithColumns(24))); 9096 // In a function call with three operands, the second must be broken with a 9097 // line break before it. 9098 EXPECT_EQ("func(a,\n" 9099 " \"long long long \"\n" 9100 " \"long\",\n" 9101 " c);", 9102 format("func(a, \"long long long long\", c);", 9103 getLLVMStyleWithColumns(24))); 9104 // In a function call with three operands, the third must be broken with a 9105 // line break before it. 9106 EXPECT_EQ("func(a, b,\n" 9107 " \"long long long \"\n" 9108 " \"long\");", 9109 format("func(a, b, \"long long long long\");", 9110 getLLVMStyleWithColumns(24))); 9111 // In a function call with three operands, both the second and the third must 9112 // be broken with a line break before them. 9113 EXPECT_EQ("func(a,\n" 9114 " \"long long long \"\n" 9115 " \"long\",\n" 9116 " \"long long long \"\n" 9117 " \"long\");", 9118 format("func(a, \"long long long long\", \"long long long long\");", 9119 getLLVMStyleWithColumns(24))); 9120 // In a chain of << with two operands, the second can be broken with no line 9121 // break before it. 9122 EXPECT_EQ("a << \"line line \"\n" 9123 " \"line\";", 9124 format("a << \"line line line\";", 9125 getLLVMStyleWithColumns(20))); 9126 // In a chain of << with three operands, the second can be broken with no line 9127 // break before it. 9128 EXPECT_EQ("abcde << \"line \"\n" 9129 " \"line line\"\n" 9130 " << c;", 9131 format("abcde << \"line line line\" << c;", 9132 getLLVMStyleWithColumns(20))); 9133 // In a chain of << with three operands, the third must be broken with a line 9134 // break before it. 9135 EXPECT_EQ("a << b\n" 9136 " << \"line line \"\n" 9137 " \"line\";", 9138 format("a << b << \"line line line\";", 9139 getLLVMStyleWithColumns(20))); 9140 // In a chain of << with three operands, the second can be broken with no line 9141 // break before it and the third must be broken with a line break before it. 9142 EXPECT_EQ("abcd << \"line line \"\n" 9143 " \"line\"\n" 9144 " << \"line line \"\n" 9145 " \"line\";", 9146 format("abcd << \"line line line\" << \"line line line\";", 9147 getLLVMStyleWithColumns(20))); 9148 // In a chain of binary operators with two operands, the second can be broken 9149 // with no line break before it. 9150 EXPECT_EQ("abcd + \"line line \"\n" 9151 " \"line line\";", 9152 format("abcd + \"line line line line\";", 9153 getLLVMStyleWithColumns(20))); 9154 // In a chain of binary operators with three operands, the second must be 9155 // broken with a line break before it. 9156 EXPECT_EQ("abcd +\n" 9157 " \"line line \"\n" 9158 " \"line line\" +\n" 9159 " e;", 9160 format("abcd + \"line line line line\" + e;", 9161 getLLVMStyleWithColumns(20))); 9162 // In a function call with two operands, with AlignAfterOpenBracket enabled, 9163 // the first must be broken with a line break before it. 9164 FormatStyle Style = getLLVMStyleWithColumns(25); 9165 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 9166 EXPECT_EQ("someFunction(\n" 9167 " \"long long long \"\n" 9168 " \"long\",\n" 9169 " a);", 9170 format("someFunction(\"long long long long\", a);", Style)); 9171 } 9172 9173 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 9174 EXPECT_EQ( 9175 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9176 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9177 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9178 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9179 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9180 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 9181 } 9182 9183 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 9184 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 9185 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 9186 EXPECT_EQ("fffffffffff(g(R\"x(\n" 9187 "multiline raw string literal xxxxxxxxxxxxxx\n" 9188 ")x\",\n" 9189 " a),\n" 9190 " b);", 9191 format("fffffffffff(g(R\"x(\n" 9192 "multiline raw string literal xxxxxxxxxxxxxx\n" 9193 ")x\", a), b);", 9194 getGoogleStyleWithColumns(20))); 9195 EXPECT_EQ("fffffffffff(\n" 9196 " g(R\"x(qqq\n" 9197 "multiline raw string literal xxxxxxxxxxxxxx\n" 9198 ")x\",\n" 9199 " a),\n" 9200 " b);", 9201 format("fffffffffff(g(R\"x(qqq\n" 9202 "multiline raw string literal xxxxxxxxxxxxxx\n" 9203 ")x\", a), b);", 9204 getGoogleStyleWithColumns(20))); 9205 9206 EXPECT_EQ("fffffffffff(R\"x(\n" 9207 "multiline raw string literal xxxxxxxxxxxxxx\n" 9208 ")x\");", 9209 format("fffffffffff(R\"x(\n" 9210 "multiline raw string literal xxxxxxxxxxxxxx\n" 9211 ")x\");", 9212 getGoogleStyleWithColumns(20))); 9213 EXPECT_EQ("fffffffffff(R\"x(\n" 9214 "multiline raw string literal xxxxxxxxxxxxxx\n" 9215 ")x\" + bbbbbb);", 9216 format("fffffffffff(R\"x(\n" 9217 "multiline raw string literal xxxxxxxxxxxxxx\n" 9218 ")x\" + bbbbbb);", 9219 getGoogleStyleWithColumns(20))); 9220 EXPECT_EQ("fffffffffff(\n" 9221 " R\"x(\n" 9222 "multiline raw string literal xxxxxxxxxxxxxx\n" 9223 ")x\" +\n" 9224 " bbbbbb);", 9225 format("fffffffffff(\n" 9226 " R\"x(\n" 9227 "multiline raw string literal xxxxxxxxxxxxxx\n" 9228 ")x\" + bbbbbb);", 9229 getGoogleStyleWithColumns(20))); 9230 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 9231 format("fffffffffff(\n" 9232 " R\"(single line raw string)\" + bbbbbb);")); 9233 } 9234 9235 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 9236 verifyFormat("string a = \"unterminated;"); 9237 EXPECT_EQ("function(\"unterminated,\n" 9238 " OtherParameter);", 9239 format("function( \"unterminated,\n" 9240 " OtherParameter);")); 9241 } 9242 9243 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9244 FormatStyle Style = getLLVMStyle(); 9245 Style.Standard = FormatStyle::LS_Cpp03; 9246 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9247 format("#define x(_a) printf(\"foo\"_a);", Style)); 9248 } 9249 9250 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9251 9252 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9253 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9254 " \"ddeeefff\");", 9255 format("someFunction(\"aaabbbcccdddeeefff\");", 9256 getLLVMStyleWithColumns(25))); 9257 EXPECT_EQ("someFunction1234567890(\n" 9258 " \"aaabbbcccdddeeefff\");", 9259 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9260 getLLVMStyleWithColumns(26))); 9261 EXPECT_EQ("someFunction1234567890(\n" 9262 " \"aaabbbcccdddeeeff\"\n" 9263 " \"f\");", 9264 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9265 getLLVMStyleWithColumns(25))); 9266 EXPECT_EQ("someFunction1234567890(\n" 9267 " \"aaabbbcccdddeeeff\"\n" 9268 " \"f\");", 9269 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9270 getLLVMStyleWithColumns(24))); 9271 EXPECT_EQ("someFunction(\n" 9272 " \"aaabbbcc ddde \"\n" 9273 " \"efff\");", 9274 format("someFunction(\"aaabbbcc ddde efff\");", 9275 getLLVMStyleWithColumns(25))); 9276 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9277 " \"ddeeefff\");", 9278 format("someFunction(\"aaabbbccc ddeeefff\");", 9279 getLLVMStyleWithColumns(25))); 9280 EXPECT_EQ("someFunction1234567890(\n" 9281 " \"aaabb \"\n" 9282 " \"cccdddeeefff\");", 9283 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9284 getLLVMStyleWithColumns(25))); 9285 EXPECT_EQ("#define A \\\n" 9286 " string s = \\\n" 9287 " \"123456789\" \\\n" 9288 " \"0\"; \\\n" 9289 " int i;", 9290 format("#define A string s = \"1234567890\"; int i;", 9291 getLLVMStyleWithColumns(20))); 9292 EXPECT_EQ("someFunction(\n" 9293 " \"aaabbbcc \"\n" 9294 " \"dddeeefff\");", 9295 format("someFunction(\"aaabbbcc dddeeefff\");", 9296 getLLVMStyleWithColumns(25))); 9297 } 9298 9299 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9300 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9301 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9302 EXPECT_EQ("\"test\"\n" 9303 "\"\\n\"", 9304 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9305 EXPECT_EQ("\"tes\\\\\"\n" 9306 "\"n\"", 9307 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9308 EXPECT_EQ("\"\\\\\\\\\"\n" 9309 "\"\\n\"", 9310 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9311 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9312 EXPECT_EQ("\"\\uff01\"\n" 9313 "\"test\"", 9314 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9315 EXPECT_EQ("\"\\Uff01ff02\"", 9316 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9317 EXPECT_EQ("\"\\x000000000001\"\n" 9318 "\"next\"", 9319 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9320 EXPECT_EQ("\"\\x000000000001next\"", 9321 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9322 EXPECT_EQ("\"\\x000000000001\"", 9323 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9324 EXPECT_EQ("\"test\"\n" 9325 "\"\\000000\"\n" 9326 "\"000001\"", 9327 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9328 EXPECT_EQ("\"test\\000\"\n" 9329 "\"00000000\"\n" 9330 "\"1\"", 9331 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9332 } 9333 9334 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9335 verifyFormat("void f() {\n" 9336 " return g() {}\n" 9337 " void h() {}"); 9338 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9339 "g();\n" 9340 "}"); 9341 } 9342 9343 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9344 verifyFormat( 9345 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9346 } 9347 9348 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9349 verifyFormat("class X {\n" 9350 " void f() {\n" 9351 " }\n" 9352 "};", 9353 getLLVMStyleWithColumns(12)); 9354 } 9355 9356 TEST_F(FormatTest, ConfigurableIndentWidth) { 9357 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9358 EightIndent.IndentWidth = 8; 9359 EightIndent.ContinuationIndentWidth = 8; 9360 verifyFormat("void f() {\n" 9361 " someFunction();\n" 9362 " if (true) {\n" 9363 " f();\n" 9364 " }\n" 9365 "}", 9366 EightIndent); 9367 verifyFormat("class X {\n" 9368 " void f() {\n" 9369 " }\n" 9370 "};", 9371 EightIndent); 9372 verifyFormat("int x[] = {\n" 9373 " call(),\n" 9374 " call()};", 9375 EightIndent); 9376 } 9377 9378 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9379 verifyFormat("double\n" 9380 "f();", 9381 getLLVMStyleWithColumns(8)); 9382 } 9383 9384 TEST_F(FormatTest, ConfigurableUseOfTab) { 9385 FormatStyle Tab = getLLVMStyleWithColumns(42); 9386 Tab.IndentWidth = 8; 9387 Tab.UseTab = FormatStyle::UT_Always; 9388 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9389 9390 EXPECT_EQ("if (aaaaaaaa && // q\n" 9391 " bb)\t\t// w\n" 9392 "\t;", 9393 format("if (aaaaaaaa &&// q\n" 9394 "bb)// w\n" 9395 ";", 9396 Tab)); 9397 EXPECT_EQ("if (aaa && bbb) // w\n" 9398 "\t;", 9399 format("if(aaa&&bbb)// w\n" 9400 ";", 9401 Tab)); 9402 9403 verifyFormat("class X {\n" 9404 "\tvoid f() {\n" 9405 "\t\tsomeFunction(parameter1,\n" 9406 "\t\t\t parameter2);\n" 9407 "\t}\n" 9408 "};", 9409 Tab); 9410 verifyFormat("#define A \\\n" 9411 "\tvoid f() { \\\n" 9412 "\t\tsomeFunction( \\\n" 9413 "\t\t parameter1, \\\n" 9414 "\t\t parameter2); \\\n" 9415 "\t}", 9416 Tab); 9417 verifyFormat("int a;\t // x\n" 9418 "int bbbbbbbb; // x\n", 9419 Tab); 9420 9421 Tab.TabWidth = 4; 9422 Tab.IndentWidth = 8; 9423 verifyFormat("class TabWidth4Indent8 {\n" 9424 "\t\tvoid f() {\n" 9425 "\t\t\t\tsomeFunction(parameter1,\n" 9426 "\t\t\t\t\t\t\t parameter2);\n" 9427 "\t\t}\n" 9428 "};", 9429 Tab); 9430 9431 Tab.TabWidth = 4; 9432 Tab.IndentWidth = 4; 9433 verifyFormat("class TabWidth4Indent4 {\n" 9434 "\tvoid f() {\n" 9435 "\t\tsomeFunction(parameter1,\n" 9436 "\t\t\t\t\t parameter2);\n" 9437 "\t}\n" 9438 "};", 9439 Tab); 9440 9441 Tab.TabWidth = 8; 9442 Tab.IndentWidth = 4; 9443 verifyFormat("class TabWidth8Indent4 {\n" 9444 " void f() {\n" 9445 "\tsomeFunction(parameter1,\n" 9446 "\t\t parameter2);\n" 9447 " }\n" 9448 "};", 9449 Tab); 9450 9451 Tab.TabWidth = 8; 9452 Tab.IndentWidth = 8; 9453 EXPECT_EQ("/*\n" 9454 "\t a\t\tcomment\n" 9455 "\t in multiple lines\n" 9456 " */", 9457 format(" /*\t \t \n" 9458 " \t \t a\t\tcomment\t \t\n" 9459 " \t \t in multiple lines\t\n" 9460 " \t */", 9461 Tab)); 9462 9463 Tab.UseTab = FormatStyle::UT_ForIndentation; 9464 verifyFormat("{\n" 9465 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9466 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9467 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9468 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9469 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9470 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9471 "};", 9472 Tab); 9473 verifyFormat("enum AA {\n" 9474 "\ta1, // Force multiple lines\n" 9475 "\ta2,\n" 9476 "\ta3\n" 9477 "};", 9478 Tab); 9479 EXPECT_EQ("if (aaaaaaaa && // q\n" 9480 " bb) // w\n" 9481 "\t;", 9482 format("if (aaaaaaaa &&// q\n" 9483 "bb)// w\n" 9484 ";", 9485 Tab)); 9486 verifyFormat("class X {\n" 9487 "\tvoid f() {\n" 9488 "\t\tsomeFunction(parameter1,\n" 9489 "\t\t parameter2);\n" 9490 "\t}\n" 9491 "};", 9492 Tab); 9493 verifyFormat("{\n" 9494 "\tQ(\n" 9495 "\t {\n" 9496 "\t\t int a;\n" 9497 "\t\t someFunction(aaaaaaaa,\n" 9498 "\t\t bbbbbbb);\n" 9499 "\t },\n" 9500 "\t p);\n" 9501 "}", 9502 Tab); 9503 EXPECT_EQ("{\n" 9504 "\t/* aaaa\n" 9505 "\t bbbb */\n" 9506 "}", 9507 format("{\n" 9508 "/* aaaa\n" 9509 " bbbb */\n" 9510 "}", 9511 Tab)); 9512 EXPECT_EQ("{\n" 9513 "\t/*\n" 9514 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9515 "\t bbbbbbbbbbbbb\n" 9516 "\t*/\n" 9517 "}", 9518 format("{\n" 9519 "/*\n" 9520 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9521 "*/\n" 9522 "}", 9523 Tab)); 9524 EXPECT_EQ("{\n" 9525 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9526 "\t// bbbbbbbbbbbbb\n" 9527 "}", 9528 format("{\n" 9529 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9530 "}", 9531 Tab)); 9532 EXPECT_EQ("{\n" 9533 "\t/*\n" 9534 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9535 "\t bbbbbbbbbbbbb\n" 9536 "\t*/\n" 9537 "}", 9538 format("{\n" 9539 "\t/*\n" 9540 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9541 "\t*/\n" 9542 "}", 9543 Tab)); 9544 EXPECT_EQ("{\n" 9545 "\t/*\n" 9546 "\n" 9547 "\t*/\n" 9548 "}", 9549 format("{\n" 9550 "\t/*\n" 9551 "\n" 9552 "\t*/\n" 9553 "}", 9554 Tab)); 9555 EXPECT_EQ("{\n" 9556 "\t/*\n" 9557 " asdf\n" 9558 "\t*/\n" 9559 "}", 9560 format("{\n" 9561 "\t/*\n" 9562 " asdf\n" 9563 "\t*/\n" 9564 "}", 9565 Tab)); 9566 9567 Tab.UseTab = FormatStyle::UT_Never; 9568 EXPECT_EQ("/*\n" 9569 " a\t\tcomment\n" 9570 " in multiple lines\n" 9571 " */", 9572 format(" /*\t \t \n" 9573 " \t \t a\t\tcomment\t \t\n" 9574 " \t \t in multiple lines\t\n" 9575 " \t */", 9576 Tab)); 9577 EXPECT_EQ("/* some\n" 9578 " comment */", 9579 format(" \t \t /* some\n" 9580 " \t \t comment */", 9581 Tab)); 9582 EXPECT_EQ("int a; /* some\n" 9583 " comment */", 9584 format(" \t \t int a; /* some\n" 9585 " \t \t comment */", 9586 Tab)); 9587 9588 EXPECT_EQ("int a; /* some\n" 9589 "comment */", 9590 format(" \t \t int\ta; /* some\n" 9591 " \t \t comment */", 9592 Tab)); 9593 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9594 " comment */", 9595 format(" \t \t f(\"\t\t\"); /* some\n" 9596 " \t \t comment */", 9597 Tab)); 9598 EXPECT_EQ("{\n" 9599 " /*\n" 9600 " * Comment\n" 9601 " */\n" 9602 " int i;\n" 9603 "}", 9604 format("{\n" 9605 "\t/*\n" 9606 "\t * Comment\n" 9607 "\t */\n" 9608 "\t int i;\n" 9609 "}")); 9610 9611 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 9612 Tab.TabWidth = 8; 9613 Tab.IndentWidth = 8; 9614 EXPECT_EQ("if (aaaaaaaa && // q\n" 9615 " bb) // w\n" 9616 "\t;", 9617 format("if (aaaaaaaa &&// q\n" 9618 "bb)// w\n" 9619 ";", 9620 Tab)); 9621 EXPECT_EQ("if (aaa && bbb) // w\n" 9622 "\t;", 9623 format("if(aaa&&bbb)// w\n" 9624 ";", 9625 Tab)); 9626 verifyFormat("class X {\n" 9627 "\tvoid f() {\n" 9628 "\t\tsomeFunction(parameter1,\n" 9629 "\t\t\t parameter2);\n" 9630 "\t}\n" 9631 "};", 9632 Tab); 9633 verifyFormat("#define A \\\n" 9634 "\tvoid f() { \\\n" 9635 "\t\tsomeFunction( \\\n" 9636 "\t\t parameter1, \\\n" 9637 "\t\t parameter2); \\\n" 9638 "\t}", 9639 Tab); 9640 Tab.TabWidth = 4; 9641 Tab.IndentWidth = 8; 9642 verifyFormat("class TabWidth4Indent8 {\n" 9643 "\t\tvoid f() {\n" 9644 "\t\t\t\tsomeFunction(parameter1,\n" 9645 "\t\t\t\t\t\t\t parameter2);\n" 9646 "\t\t}\n" 9647 "};", 9648 Tab); 9649 Tab.TabWidth = 4; 9650 Tab.IndentWidth = 4; 9651 verifyFormat("class TabWidth4Indent4 {\n" 9652 "\tvoid f() {\n" 9653 "\t\tsomeFunction(parameter1,\n" 9654 "\t\t\t\t\t parameter2);\n" 9655 "\t}\n" 9656 "};", 9657 Tab); 9658 Tab.TabWidth = 8; 9659 Tab.IndentWidth = 4; 9660 verifyFormat("class TabWidth8Indent4 {\n" 9661 " void f() {\n" 9662 "\tsomeFunction(parameter1,\n" 9663 "\t\t parameter2);\n" 9664 " }\n" 9665 "};", 9666 Tab); 9667 Tab.TabWidth = 8; 9668 Tab.IndentWidth = 8; 9669 EXPECT_EQ("/*\n" 9670 "\t a\t\tcomment\n" 9671 "\t in multiple lines\n" 9672 " */", 9673 format(" /*\t \t \n" 9674 " \t \t a\t\tcomment\t \t\n" 9675 " \t \t in multiple lines\t\n" 9676 " \t */", 9677 Tab)); 9678 verifyFormat("{\n" 9679 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9680 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9681 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9682 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9683 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9684 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9685 "};", 9686 Tab); 9687 verifyFormat("enum AA {\n" 9688 "\ta1, // Force multiple lines\n" 9689 "\ta2,\n" 9690 "\ta3\n" 9691 "};", 9692 Tab); 9693 EXPECT_EQ("if (aaaaaaaa && // q\n" 9694 " bb) // w\n" 9695 "\t;", 9696 format("if (aaaaaaaa &&// q\n" 9697 "bb)// w\n" 9698 ";", 9699 Tab)); 9700 verifyFormat("class X {\n" 9701 "\tvoid f() {\n" 9702 "\t\tsomeFunction(parameter1,\n" 9703 "\t\t\t parameter2);\n" 9704 "\t}\n" 9705 "};", 9706 Tab); 9707 verifyFormat("{\n" 9708 "\tQ(\n" 9709 "\t {\n" 9710 "\t\t int a;\n" 9711 "\t\t someFunction(aaaaaaaa,\n" 9712 "\t\t\t\t bbbbbbb);\n" 9713 "\t },\n" 9714 "\t p);\n" 9715 "}", 9716 Tab); 9717 EXPECT_EQ("{\n" 9718 "\t/* aaaa\n" 9719 "\t bbbb */\n" 9720 "}", 9721 format("{\n" 9722 "/* aaaa\n" 9723 " bbbb */\n" 9724 "}", 9725 Tab)); 9726 EXPECT_EQ("{\n" 9727 "\t/*\n" 9728 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9729 "\t bbbbbbbbbbbbb\n" 9730 "\t*/\n" 9731 "}", 9732 format("{\n" 9733 "/*\n" 9734 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9735 "*/\n" 9736 "}", 9737 Tab)); 9738 EXPECT_EQ("{\n" 9739 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9740 "\t// bbbbbbbbbbbbb\n" 9741 "}", 9742 format("{\n" 9743 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9744 "}", 9745 Tab)); 9746 EXPECT_EQ("{\n" 9747 "\t/*\n" 9748 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9749 "\t bbbbbbbbbbbbb\n" 9750 "\t*/\n" 9751 "}", 9752 format("{\n" 9753 "\t/*\n" 9754 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9755 "\t*/\n" 9756 "}", 9757 Tab)); 9758 EXPECT_EQ("{\n" 9759 "\t/*\n" 9760 "\n" 9761 "\t*/\n" 9762 "}", 9763 format("{\n" 9764 "\t/*\n" 9765 "\n" 9766 "\t*/\n" 9767 "}", 9768 Tab)); 9769 EXPECT_EQ("{\n" 9770 "\t/*\n" 9771 " asdf\n" 9772 "\t*/\n" 9773 "}", 9774 format("{\n" 9775 "\t/*\n" 9776 " asdf\n" 9777 "\t*/\n" 9778 "}", 9779 Tab)); 9780 EXPECT_EQ("/*\n" 9781 "\t a\t\tcomment\n" 9782 "\t in multiple lines\n" 9783 " */", 9784 format(" /*\t \t \n" 9785 " \t \t a\t\tcomment\t \t\n" 9786 " \t \t in multiple lines\t\n" 9787 " \t */", 9788 Tab)); 9789 EXPECT_EQ("/* some\n" 9790 " comment */", 9791 format(" \t \t /* some\n" 9792 " \t \t comment */", 9793 Tab)); 9794 EXPECT_EQ("int a; /* some\n" 9795 " comment */", 9796 format(" \t \t int a; /* some\n" 9797 " \t \t comment */", 9798 Tab)); 9799 EXPECT_EQ("int a; /* some\n" 9800 "comment */", 9801 format(" \t \t int\ta; /* some\n" 9802 " \t \t comment */", 9803 Tab)); 9804 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9805 " comment */", 9806 format(" \t \t f(\"\t\t\"); /* some\n" 9807 " \t \t comment */", 9808 Tab)); 9809 EXPECT_EQ("{\n" 9810 " /*\n" 9811 " * Comment\n" 9812 " */\n" 9813 " int i;\n" 9814 "}", 9815 format("{\n" 9816 "\t/*\n" 9817 "\t * Comment\n" 9818 "\t */\n" 9819 "\t int i;\n" 9820 "}")); 9821 Tab.AlignConsecutiveAssignments = true; 9822 Tab.AlignConsecutiveDeclarations = true; 9823 Tab.TabWidth = 4; 9824 Tab.IndentWidth = 4; 9825 verifyFormat("class Assign {\n" 9826 "\tvoid f() {\n" 9827 "\t\tint x = 123;\n" 9828 "\t\tint random = 4;\n" 9829 "\t\tstd::string alphabet =\n" 9830 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 9831 "\t}\n" 9832 "};", 9833 Tab); 9834 } 9835 9836 TEST_F(FormatTest, CalculatesOriginalColumn) { 9837 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9838 "q\"; /* some\n" 9839 " comment */", 9840 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9841 "q\"; /* some\n" 9842 " comment */", 9843 getLLVMStyle())); 9844 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 9845 "/* some\n" 9846 " comment */", 9847 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 9848 " /* some\n" 9849 " comment */", 9850 getLLVMStyle())); 9851 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9852 "qqq\n" 9853 "/* some\n" 9854 " comment */", 9855 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9856 "qqq\n" 9857 " /* some\n" 9858 " comment */", 9859 getLLVMStyle())); 9860 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9861 "wwww; /* some\n" 9862 " comment */", 9863 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9864 "wwww; /* some\n" 9865 " comment */", 9866 getLLVMStyle())); 9867 } 9868 9869 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 9870 FormatStyle NoSpace = getLLVMStyle(); 9871 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 9872 9873 verifyFormat("while(true)\n" 9874 " continue;", 9875 NoSpace); 9876 verifyFormat("for(;;)\n" 9877 " continue;", 9878 NoSpace); 9879 verifyFormat("if(true)\n" 9880 " f();\n" 9881 "else if(true)\n" 9882 " f();", 9883 NoSpace); 9884 verifyFormat("do {\n" 9885 " do_something();\n" 9886 "} while(something());", 9887 NoSpace); 9888 verifyFormat("switch(x) {\n" 9889 "default:\n" 9890 " break;\n" 9891 "}", 9892 NoSpace); 9893 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 9894 verifyFormat("size_t x = sizeof(x);", NoSpace); 9895 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 9896 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 9897 verifyFormat("alignas(128) char a[128];", NoSpace); 9898 verifyFormat("size_t x = alignof(MyType);", NoSpace); 9899 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 9900 verifyFormat("int f() throw(Deprecated);", NoSpace); 9901 verifyFormat("typedef void (*cb)(int);", NoSpace); 9902 verifyFormat("T A::operator()();", NoSpace); 9903 verifyFormat("X A::operator++(T);", NoSpace); 9904 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 9905 9906 FormatStyle Space = getLLVMStyle(); 9907 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 9908 9909 verifyFormat("int f ();", Space); 9910 verifyFormat("void f (int a, T b) {\n" 9911 " while (true)\n" 9912 " continue;\n" 9913 "}", 9914 Space); 9915 verifyFormat("if (true)\n" 9916 " f ();\n" 9917 "else if (true)\n" 9918 " f ();", 9919 Space); 9920 verifyFormat("do {\n" 9921 " do_something ();\n" 9922 "} while (something ());", 9923 Space); 9924 verifyFormat("switch (x) {\n" 9925 "default:\n" 9926 " break;\n" 9927 "}", 9928 Space); 9929 verifyFormat("A::A () : a (1) {}", Space); 9930 verifyFormat("void f () __attribute__ ((asdf));", Space); 9931 verifyFormat("*(&a + 1);\n" 9932 "&((&a)[1]);\n" 9933 "a[(b + c) * d];\n" 9934 "(((a + 1) * 2) + 3) * 4;", 9935 Space); 9936 verifyFormat("#define A(x) x", Space); 9937 verifyFormat("#define A (x) x", Space); 9938 verifyFormat("#if defined(x)\n" 9939 "#endif", 9940 Space); 9941 verifyFormat("auto i = std::make_unique<int> (5);", Space); 9942 verifyFormat("size_t x = sizeof (x);", Space); 9943 verifyFormat("auto f (int x) -> decltype (x);", Space); 9944 verifyFormat("int f (T x) noexcept (x.create ());", Space); 9945 verifyFormat("alignas (128) char a[128];", Space); 9946 verifyFormat("size_t x = alignof (MyType);", Space); 9947 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 9948 verifyFormat("int f () throw (Deprecated);", Space); 9949 verifyFormat("typedef void (*cb) (int);", Space); 9950 verifyFormat("T A::operator() ();", Space); 9951 verifyFormat("X A::operator++ (T);", Space); 9952 verifyFormat("auto lambda = [] () { return 0; };", Space); 9953 verifyFormat("int x = int (y);", Space); 9954 9955 FormatStyle SomeSpace = getLLVMStyle(); 9956 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 9957 9958 verifyFormat("[]() -> float {}", SomeSpace); 9959 verifyFormat("[] (auto foo) {}", SomeSpace); 9960 verifyFormat("[foo]() -> int {}", SomeSpace); 9961 verifyFormat("int f();", SomeSpace); 9962 verifyFormat("void f (int a, T b) {\n" 9963 " while (true)\n" 9964 " continue;\n" 9965 "}", 9966 SomeSpace); 9967 verifyFormat("if (true)\n" 9968 " f();\n" 9969 "else if (true)\n" 9970 " f();", 9971 SomeSpace); 9972 verifyFormat("do {\n" 9973 " do_something();\n" 9974 "} while (something());", 9975 SomeSpace); 9976 verifyFormat("switch (x) {\n" 9977 "default:\n" 9978 " break;\n" 9979 "}", 9980 SomeSpace); 9981 verifyFormat("A::A() : a (1) {}", SomeSpace); 9982 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 9983 verifyFormat("*(&a + 1);\n" 9984 "&((&a)[1]);\n" 9985 "a[(b + c) * d];\n" 9986 "(((a + 1) * 2) + 3) * 4;", 9987 SomeSpace); 9988 verifyFormat("#define A(x) x", SomeSpace); 9989 verifyFormat("#define A (x) x", SomeSpace); 9990 verifyFormat("#if defined(x)\n" 9991 "#endif", 9992 SomeSpace); 9993 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 9994 verifyFormat("size_t x = sizeof (x);", SomeSpace); 9995 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 9996 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 9997 verifyFormat("alignas (128) char a[128];", SomeSpace); 9998 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 9999 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 10000 SomeSpace); 10001 verifyFormat("int f() throw (Deprecated);", SomeSpace); 10002 verifyFormat("typedef void (*cb) (int);", SomeSpace); 10003 verifyFormat("T A::operator()();", SomeSpace); 10004 verifyFormat("X A::operator++ (T);", SomeSpace); 10005 verifyFormat("int x = int (y);", SomeSpace); 10006 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 10007 } 10008 10009 TEST_F(FormatTest, SpaceAfterLogicalNot) { 10010 FormatStyle Spaces = getLLVMStyle(); 10011 Spaces.SpaceAfterLogicalNot = true; 10012 10013 verifyFormat("bool x = ! y", Spaces); 10014 verifyFormat("if (! isFailure())", Spaces); 10015 verifyFormat("if (! (a && b))", Spaces); 10016 verifyFormat("\"Error!\"", Spaces); 10017 verifyFormat("! ! x", Spaces); 10018 } 10019 10020 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 10021 FormatStyle Spaces = getLLVMStyle(); 10022 10023 Spaces.SpacesInParentheses = true; 10024 verifyFormat("do_something( ::globalVar );", Spaces); 10025 verifyFormat("call( x, y, z );", Spaces); 10026 verifyFormat("call();", Spaces); 10027 verifyFormat("std::function<void( int, int )> callback;", Spaces); 10028 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 10029 Spaces); 10030 verifyFormat("while ( (bool)1 )\n" 10031 " continue;", 10032 Spaces); 10033 verifyFormat("for ( ;; )\n" 10034 " continue;", 10035 Spaces); 10036 verifyFormat("if ( true )\n" 10037 " f();\n" 10038 "else if ( true )\n" 10039 " f();", 10040 Spaces); 10041 verifyFormat("do {\n" 10042 " do_something( (int)i );\n" 10043 "} while ( something() );", 10044 Spaces); 10045 verifyFormat("switch ( x ) {\n" 10046 "default:\n" 10047 " break;\n" 10048 "}", 10049 Spaces); 10050 10051 Spaces.SpacesInParentheses = false; 10052 Spaces.SpacesInCStyleCastParentheses = true; 10053 verifyFormat("Type *A = ( Type * )P;", Spaces); 10054 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 10055 verifyFormat("x = ( int32 )y;", Spaces); 10056 verifyFormat("int a = ( int )(2.0f);", Spaces); 10057 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 10058 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 10059 verifyFormat("#define x (( int )-1)", Spaces); 10060 10061 // Run the first set of tests again with: 10062 Spaces.SpacesInParentheses = false; 10063 Spaces.SpaceInEmptyParentheses = true; 10064 Spaces.SpacesInCStyleCastParentheses = true; 10065 verifyFormat("call(x, y, z);", Spaces); 10066 verifyFormat("call( );", Spaces); 10067 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10068 verifyFormat("while (( bool )1)\n" 10069 " continue;", 10070 Spaces); 10071 verifyFormat("for (;;)\n" 10072 " continue;", 10073 Spaces); 10074 verifyFormat("if (true)\n" 10075 " f( );\n" 10076 "else if (true)\n" 10077 " f( );", 10078 Spaces); 10079 verifyFormat("do {\n" 10080 " do_something(( int )i);\n" 10081 "} while (something( ));", 10082 Spaces); 10083 verifyFormat("switch (x) {\n" 10084 "default:\n" 10085 " break;\n" 10086 "}", 10087 Spaces); 10088 10089 // Run the first set of tests again with: 10090 Spaces.SpaceAfterCStyleCast = true; 10091 verifyFormat("call(x, y, z);", Spaces); 10092 verifyFormat("call( );", Spaces); 10093 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10094 verifyFormat("while (( bool ) 1)\n" 10095 " continue;", 10096 Spaces); 10097 verifyFormat("for (;;)\n" 10098 " continue;", 10099 Spaces); 10100 verifyFormat("if (true)\n" 10101 " f( );\n" 10102 "else if (true)\n" 10103 " f( );", 10104 Spaces); 10105 verifyFormat("do {\n" 10106 " do_something(( int ) i);\n" 10107 "} while (something( ));", 10108 Spaces); 10109 verifyFormat("switch (x) {\n" 10110 "default:\n" 10111 " break;\n" 10112 "}", 10113 Spaces); 10114 10115 // Run subset of tests again with: 10116 Spaces.SpacesInCStyleCastParentheses = false; 10117 Spaces.SpaceAfterCStyleCast = true; 10118 verifyFormat("while ((bool) 1)\n" 10119 " continue;", 10120 Spaces); 10121 verifyFormat("do {\n" 10122 " do_something((int) i);\n" 10123 "} while (something( ));", 10124 Spaces); 10125 } 10126 10127 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 10128 verifyFormat("int a[5];"); 10129 verifyFormat("a[3] += 42;"); 10130 10131 FormatStyle Spaces = getLLVMStyle(); 10132 Spaces.SpacesInSquareBrackets = true; 10133 // Lambdas unchanged. 10134 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 10135 verifyFormat("return [i, args...] {};", Spaces); 10136 10137 // Not lambdas. 10138 verifyFormat("int a[ 5 ];", Spaces); 10139 verifyFormat("a[ 3 ] += 42;", Spaces); 10140 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 10141 verifyFormat("double &operator[](int i) { return 0; }\n" 10142 "int i;", 10143 Spaces); 10144 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 10145 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 10146 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 10147 } 10148 10149 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 10150 verifyFormat("int a = 5;"); 10151 verifyFormat("a += 42;"); 10152 verifyFormat("a or_eq 8;"); 10153 10154 FormatStyle Spaces = getLLVMStyle(); 10155 Spaces.SpaceBeforeAssignmentOperators = false; 10156 verifyFormat("int a= 5;", Spaces); 10157 verifyFormat("a+= 42;", Spaces); 10158 verifyFormat("a or_eq 8;", Spaces); 10159 } 10160 10161 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 10162 verifyFormat("class Foo : public Bar {};"); 10163 verifyFormat("Foo::Foo() : foo(1) {}"); 10164 verifyFormat("for (auto a : b) {\n}"); 10165 verifyFormat("int x = a ? b : c;"); 10166 verifyFormat("{\n" 10167 "label0:\n" 10168 " int x = 0;\n" 10169 "}"); 10170 verifyFormat("switch (x) {\n" 10171 "case 1:\n" 10172 "default:\n" 10173 "}"); 10174 10175 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 10176 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 10177 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 10178 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 10179 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 10180 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 10181 verifyFormat("{\n" 10182 "label1:\n" 10183 " int x = 0;\n" 10184 "}", 10185 CtorInitializerStyle); 10186 verifyFormat("switch (x) {\n" 10187 "case 1:\n" 10188 "default:\n" 10189 "}", 10190 CtorInitializerStyle); 10191 CtorInitializerStyle.BreakConstructorInitializers = 10192 FormatStyle::BCIS_AfterColon; 10193 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 10194 " aaaaaaaaaaaaaaaa(1),\n" 10195 " bbbbbbbbbbbbbbbb(2) {}", 10196 CtorInitializerStyle); 10197 CtorInitializerStyle.BreakConstructorInitializers = 10198 FormatStyle::BCIS_BeforeComma; 10199 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10200 " : aaaaaaaaaaaaaaaa(1)\n" 10201 " , bbbbbbbbbbbbbbbb(2) {}", 10202 CtorInitializerStyle); 10203 CtorInitializerStyle.BreakConstructorInitializers = 10204 FormatStyle::BCIS_BeforeColon; 10205 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10206 " : aaaaaaaaaaaaaaaa(1),\n" 10207 " bbbbbbbbbbbbbbbb(2) {}", 10208 CtorInitializerStyle); 10209 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 10210 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10211 ": aaaaaaaaaaaaaaaa(1),\n" 10212 " bbbbbbbbbbbbbbbb(2) {}", 10213 CtorInitializerStyle); 10214 10215 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 10216 InheritanceStyle.SpaceBeforeInheritanceColon = false; 10217 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 10218 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 10219 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 10220 verifyFormat("int x = a ? b : c;", InheritanceStyle); 10221 verifyFormat("{\n" 10222 "label2:\n" 10223 " int x = 0;\n" 10224 "}", 10225 InheritanceStyle); 10226 verifyFormat("switch (x) {\n" 10227 "case 1:\n" 10228 "default:\n" 10229 "}", 10230 InheritanceStyle); 10231 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 10232 verifyFormat("class Foooooooooooooooooooooo:\n" 10233 " public aaaaaaaaaaaaaaaaaa,\n" 10234 " public bbbbbbbbbbbbbbbbbb {\n" 10235 "}", 10236 InheritanceStyle); 10237 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 10238 verifyFormat("class Foooooooooooooooooooooo\n" 10239 " : public aaaaaaaaaaaaaaaaaa\n" 10240 " , public bbbbbbbbbbbbbbbbbb {\n" 10241 "}", 10242 InheritanceStyle); 10243 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 10244 verifyFormat("class Foooooooooooooooooooooo\n" 10245 " : public aaaaaaaaaaaaaaaaaa,\n" 10246 " public bbbbbbbbbbbbbbbbbb {\n" 10247 "}", 10248 InheritanceStyle); 10249 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 10250 verifyFormat("class Foooooooooooooooooooooo\n" 10251 ": public aaaaaaaaaaaaaaaaaa,\n" 10252 " public bbbbbbbbbbbbbbbbbb {}", 10253 InheritanceStyle); 10254 10255 FormatStyle ForLoopStyle = getLLVMStyle(); 10256 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 10257 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 10258 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 10259 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 10260 verifyFormat("int x = a ? b : c;", ForLoopStyle); 10261 verifyFormat("{\n" 10262 "label2:\n" 10263 " int x = 0;\n" 10264 "}", 10265 ForLoopStyle); 10266 verifyFormat("switch (x) {\n" 10267 "case 1:\n" 10268 "default:\n" 10269 "}", 10270 ForLoopStyle); 10271 10272 FormatStyle NoSpaceStyle = getLLVMStyle(); 10273 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 10274 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 10275 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 10276 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 10277 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 10278 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 10279 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 10280 verifyFormat("{\n" 10281 "label3:\n" 10282 " int x = 0;\n" 10283 "}", 10284 NoSpaceStyle); 10285 verifyFormat("switch (x) {\n" 10286 "case 1:\n" 10287 "default:\n" 10288 "}", 10289 NoSpaceStyle); 10290 } 10291 10292 TEST_F(FormatTest, AlignConsecutiveMacros) { 10293 FormatStyle Style = getLLVMStyle(); 10294 Style.AlignConsecutiveAssignments = true; 10295 Style.AlignConsecutiveDeclarations = true; 10296 Style.AlignConsecutiveMacros = false; 10297 10298 verifyFormat("#define a 3\n" 10299 "#define bbbb 4\n" 10300 "#define ccc (5)", 10301 Style); 10302 10303 verifyFormat("#define f(x) (x * x)\n" 10304 "#define fff(x, y, z) (x * y + z)\n" 10305 "#define ffff(x, y) (x - y)", 10306 Style); 10307 10308 verifyFormat("#define foo(x, y) (x + y)\n" 10309 "#define bar (5, 6)(2 + 2)", 10310 Style); 10311 10312 verifyFormat("#define a 3\n" 10313 "#define bbbb 4\n" 10314 "#define ccc (5)\n" 10315 "#define f(x) (x * x)\n" 10316 "#define fff(x, y, z) (x * y + z)\n" 10317 "#define ffff(x, y) (x - y)", 10318 Style); 10319 10320 Style.AlignConsecutiveMacros = true; 10321 verifyFormat("#define a 3\n" 10322 "#define bbbb 4\n" 10323 "#define ccc (5)", 10324 Style); 10325 10326 verifyFormat("#define f(x) (x * x)\n" 10327 "#define fff(x, y, z) (x * y + z)\n" 10328 "#define ffff(x, y) (x - y)", 10329 Style); 10330 10331 verifyFormat("#define foo(x, y) (x + y)\n" 10332 "#define bar (5, 6)(2 + 2)", 10333 Style); 10334 10335 verifyFormat("#define a 3\n" 10336 "#define bbbb 4\n" 10337 "#define ccc (5)\n" 10338 "#define f(x) (x * x)\n" 10339 "#define fff(x, y, z) (x * y + z)\n" 10340 "#define ffff(x, y) (x - y)", 10341 Style); 10342 10343 verifyFormat("#define a 5\n" 10344 "#define foo(x, y) (x + y)\n" 10345 "#define CCC (6)\n" 10346 "auto lambda = []() {\n" 10347 " auto ii = 0;\n" 10348 " float j = 0;\n" 10349 " return 0;\n" 10350 "};\n" 10351 "int i = 0;\n" 10352 "float i2 = 0;\n" 10353 "auto v = type{\n" 10354 " i = 1, //\n" 10355 " (i = 2), //\n" 10356 " i = 3 //\n" 10357 "};", 10358 Style); 10359 10360 Style.AlignConsecutiveMacros = false; 10361 Style.ColumnLimit = 20; 10362 10363 verifyFormat("#define a \\\n" 10364 " \"aabbbbbbbbbbbb\"\n" 10365 "#define D \\\n" 10366 " \"aabbbbbbbbbbbb\" \\\n" 10367 " \"ccddeeeeeeeee\"\n" 10368 "#define B \\\n" 10369 " \"QQQQQQQQQQQQQ\" \\\n" 10370 " \"FFFFFFFFFFFFF\" \\\n" 10371 " \"LLLLLLLL\"\n", 10372 Style); 10373 10374 Style.AlignConsecutiveMacros = true; 10375 verifyFormat("#define a \\\n" 10376 " \"aabbbbbbbbbbbb\"\n" 10377 "#define D \\\n" 10378 " \"aabbbbbbbbbbbb\" \\\n" 10379 " \"ccddeeeeeeeee\"\n" 10380 "#define B \\\n" 10381 " \"QQQQQQQQQQQQQ\" \\\n" 10382 " \"FFFFFFFFFFFFF\" \\\n" 10383 " \"LLLLLLLL\"\n", 10384 Style); 10385 } 10386 10387 TEST_F(FormatTest, AlignConsecutiveAssignments) { 10388 FormatStyle Alignment = getLLVMStyle(); 10389 Alignment.AlignConsecutiveMacros = true; 10390 Alignment.AlignConsecutiveAssignments = false; 10391 verifyFormat("int a = 5;\n" 10392 "int oneTwoThree = 123;", 10393 Alignment); 10394 verifyFormat("int a = 5;\n" 10395 "int oneTwoThree = 123;", 10396 Alignment); 10397 10398 Alignment.AlignConsecutiveAssignments = true; 10399 verifyFormat("int a = 5;\n" 10400 "int oneTwoThree = 123;", 10401 Alignment); 10402 verifyFormat("int a = method();\n" 10403 "int oneTwoThree = 133;", 10404 Alignment); 10405 verifyFormat("a &= 5;\n" 10406 "bcd *= 5;\n" 10407 "ghtyf += 5;\n" 10408 "dvfvdb -= 5;\n" 10409 "a /= 5;\n" 10410 "vdsvsv %= 5;\n" 10411 "sfdbddfbdfbb ^= 5;\n" 10412 "dvsdsv |= 5;\n" 10413 "int dsvvdvsdvvv = 123;", 10414 Alignment); 10415 verifyFormat("int i = 1, j = 10;\n" 10416 "something = 2000;", 10417 Alignment); 10418 verifyFormat("something = 2000;\n" 10419 "int i = 1, j = 10;\n", 10420 Alignment); 10421 verifyFormat("something = 2000;\n" 10422 "another = 911;\n" 10423 "int i = 1, j = 10;\n" 10424 "oneMore = 1;\n" 10425 "i = 2;", 10426 Alignment); 10427 verifyFormat("int a = 5;\n" 10428 "int one = 1;\n" 10429 "method();\n" 10430 "int oneTwoThree = 123;\n" 10431 "int oneTwo = 12;", 10432 Alignment); 10433 verifyFormat("int oneTwoThree = 123;\n" 10434 "int oneTwo = 12;\n" 10435 "method();\n", 10436 Alignment); 10437 verifyFormat("int oneTwoThree = 123; // comment\n" 10438 "int oneTwo = 12; // comment", 10439 Alignment); 10440 EXPECT_EQ("int a = 5;\n" 10441 "\n" 10442 "int oneTwoThree = 123;", 10443 format("int a = 5;\n" 10444 "\n" 10445 "int oneTwoThree= 123;", 10446 Alignment)); 10447 EXPECT_EQ("int a = 5;\n" 10448 "int one = 1;\n" 10449 "\n" 10450 "int oneTwoThree = 123;", 10451 format("int a = 5;\n" 10452 "int one = 1;\n" 10453 "\n" 10454 "int oneTwoThree = 123;", 10455 Alignment)); 10456 EXPECT_EQ("int a = 5;\n" 10457 "int one = 1;\n" 10458 "\n" 10459 "int oneTwoThree = 123;\n" 10460 "int oneTwo = 12;", 10461 format("int a = 5;\n" 10462 "int one = 1;\n" 10463 "\n" 10464 "int oneTwoThree = 123;\n" 10465 "int oneTwo = 12;", 10466 Alignment)); 10467 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10468 verifyFormat("#define A \\\n" 10469 " int aaaa = 12; \\\n" 10470 " int b = 23; \\\n" 10471 " int ccc = 234; \\\n" 10472 " int dddddddddd = 2345;", 10473 Alignment); 10474 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10475 verifyFormat("#define A \\\n" 10476 " int aaaa = 12; \\\n" 10477 " int b = 23; \\\n" 10478 " int ccc = 234; \\\n" 10479 " int dddddddddd = 2345;", 10480 Alignment); 10481 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10482 verifyFormat("#define A " 10483 " \\\n" 10484 " int aaaa = 12; " 10485 " \\\n" 10486 " int b = 23; " 10487 " \\\n" 10488 " int ccc = 234; " 10489 " \\\n" 10490 " int dddddddddd = 2345;", 10491 Alignment); 10492 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10493 "k = 4, int l = 5,\n" 10494 " int m = 6) {\n" 10495 " int j = 10;\n" 10496 " otherThing = 1;\n" 10497 "}", 10498 Alignment); 10499 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10500 " int i = 1;\n" 10501 " int j = 2;\n" 10502 " int big = 10000;\n" 10503 "}", 10504 Alignment); 10505 verifyFormat("class C {\n" 10506 "public:\n" 10507 " int i = 1;\n" 10508 " virtual void f() = 0;\n" 10509 "};", 10510 Alignment); 10511 verifyFormat("int i = 1;\n" 10512 "if (SomeType t = getSomething()) {\n" 10513 "}\n" 10514 "int j = 2;\n" 10515 "int big = 10000;", 10516 Alignment); 10517 verifyFormat("int j = 7;\n" 10518 "for (int k = 0; k < N; ++k) {\n" 10519 "}\n" 10520 "int j = 2;\n" 10521 "int big = 10000;\n" 10522 "}", 10523 Alignment); 10524 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10525 verifyFormat("int i = 1;\n" 10526 "LooooooooooongType loooooooooooooooooooooongVariable\n" 10527 " = someLooooooooooooooooongFunction();\n" 10528 "int j = 2;", 10529 Alignment); 10530 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 10531 verifyFormat("int i = 1;\n" 10532 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 10533 " someLooooooooooooooooongFunction();\n" 10534 "int j = 2;", 10535 Alignment); 10536 10537 verifyFormat("auto lambda = []() {\n" 10538 " auto i = 0;\n" 10539 " return 0;\n" 10540 "};\n" 10541 "int i = 0;\n" 10542 "auto v = type{\n" 10543 " i = 1, //\n" 10544 " (i = 2), //\n" 10545 " i = 3 //\n" 10546 "};", 10547 Alignment); 10548 10549 verifyFormat( 10550 "int i = 1;\n" 10551 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 10552 " loooooooooooooooooooooongParameterB);\n" 10553 "int j = 2;", 10554 Alignment); 10555 10556 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 10557 " typename B = very_long_type_name_1,\n" 10558 " typename T_2 = very_long_type_name_2>\n" 10559 "auto foo() {}\n", 10560 Alignment); 10561 verifyFormat("int a, b = 1;\n" 10562 "int c = 2;\n" 10563 "int dd = 3;\n", 10564 Alignment); 10565 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10566 "float b[1][] = {{3.f}};\n", 10567 Alignment); 10568 verifyFormat("for (int i = 0; i < 1; i++)\n" 10569 " int x = 1;\n", 10570 Alignment); 10571 verifyFormat("for (i = 0; i < 1; i++)\n" 10572 " x = 1;\n" 10573 "y = 1;\n", 10574 Alignment); 10575 } 10576 10577 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 10578 FormatStyle Alignment = getLLVMStyle(); 10579 Alignment.AlignConsecutiveMacros = true; 10580 Alignment.AlignConsecutiveDeclarations = false; 10581 verifyFormat("float const a = 5;\n" 10582 "int oneTwoThree = 123;", 10583 Alignment); 10584 verifyFormat("int a = 5;\n" 10585 "float const oneTwoThree = 123;", 10586 Alignment); 10587 10588 Alignment.AlignConsecutiveDeclarations = true; 10589 verifyFormat("float const a = 5;\n" 10590 "int oneTwoThree = 123;", 10591 Alignment); 10592 verifyFormat("int a = method();\n" 10593 "float const oneTwoThree = 133;", 10594 Alignment); 10595 verifyFormat("int i = 1, j = 10;\n" 10596 "something = 2000;", 10597 Alignment); 10598 verifyFormat("something = 2000;\n" 10599 "int i = 1, j = 10;\n", 10600 Alignment); 10601 verifyFormat("float something = 2000;\n" 10602 "double another = 911;\n" 10603 "int i = 1, j = 10;\n" 10604 "const int *oneMore = 1;\n" 10605 "unsigned i = 2;", 10606 Alignment); 10607 verifyFormat("float a = 5;\n" 10608 "int one = 1;\n" 10609 "method();\n" 10610 "const double oneTwoThree = 123;\n" 10611 "const unsigned int oneTwo = 12;", 10612 Alignment); 10613 verifyFormat("int oneTwoThree{0}; // comment\n" 10614 "unsigned oneTwo; // comment", 10615 Alignment); 10616 EXPECT_EQ("float const a = 5;\n" 10617 "\n" 10618 "int oneTwoThree = 123;", 10619 format("float const a = 5;\n" 10620 "\n" 10621 "int oneTwoThree= 123;", 10622 Alignment)); 10623 EXPECT_EQ("float a = 5;\n" 10624 "int one = 1;\n" 10625 "\n" 10626 "unsigned oneTwoThree = 123;", 10627 format("float a = 5;\n" 10628 "int one = 1;\n" 10629 "\n" 10630 "unsigned oneTwoThree = 123;", 10631 Alignment)); 10632 EXPECT_EQ("float a = 5;\n" 10633 "int one = 1;\n" 10634 "\n" 10635 "unsigned oneTwoThree = 123;\n" 10636 "int oneTwo = 12;", 10637 format("float a = 5;\n" 10638 "int one = 1;\n" 10639 "\n" 10640 "unsigned oneTwoThree = 123;\n" 10641 "int oneTwo = 12;", 10642 Alignment)); 10643 // Function prototype alignment 10644 verifyFormat("int a();\n" 10645 "double b();", 10646 Alignment); 10647 verifyFormat("int a(int x);\n" 10648 "double b();", 10649 Alignment); 10650 unsigned OldColumnLimit = Alignment.ColumnLimit; 10651 // We need to set ColumnLimit to zero, in order to stress nested alignments, 10652 // otherwise the function parameters will be re-flowed onto a single line. 10653 Alignment.ColumnLimit = 0; 10654 EXPECT_EQ("int a(int x,\n" 10655 " float y);\n" 10656 "double b(int x,\n" 10657 " double y);", 10658 format("int a(int x,\n" 10659 " float y);\n" 10660 "double b(int x,\n" 10661 " double y);", 10662 Alignment)); 10663 // This ensures that function parameters of function declarations are 10664 // correctly indented when their owning functions are indented. 10665 // The failure case here is for 'double y' to not be indented enough. 10666 EXPECT_EQ("double a(int x);\n" 10667 "int b(int y,\n" 10668 " double z);", 10669 format("double a(int x);\n" 10670 "int b(int y,\n" 10671 " double z);", 10672 Alignment)); 10673 // Set ColumnLimit low so that we induce wrapping immediately after 10674 // the function name and opening paren. 10675 Alignment.ColumnLimit = 13; 10676 verifyFormat("int function(\n" 10677 " int x,\n" 10678 " bool y);", 10679 Alignment); 10680 Alignment.ColumnLimit = OldColumnLimit; 10681 // Ensure function pointers don't screw up recursive alignment 10682 verifyFormat("int a(int x, void (*fp)(int y));\n" 10683 "double b();", 10684 Alignment); 10685 Alignment.AlignConsecutiveAssignments = true; 10686 // Ensure recursive alignment is broken by function braces, so that the 10687 // "a = 1" does not align with subsequent assignments inside the function 10688 // body. 10689 verifyFormat("int func(int a = 1) {\n" 10690 " int b = 2;\n" 10691 " int cc = 3;\n" 10692 "}", 10693 Alignment); 10694 verifyFormat("float something = 2000;\n" 10695 "double another = 911;\n" 10696 "int i = 1, j = 10;\n" 10697 "const int *oneMore = 1;\n" 10698 "unsigned i = 2;", 10699 Alignment); 10700 verifyFormat("int oneTwoThree = {0}; // comment\n" 10701 "unsigned oneTwo = 0; // comment", 10702 Alignment); 10703 // Make sure that scope is correctly tracked, in the absence of braces 10704 verifyFormat("for (int i = 0; i < n; i++)\n" 10705 " j = i;\n" 10706 "double x = 1;\n", 10707 Alignment); 10708 verifyFormat("if (int i = 0)\n" 10709 " j = i;\n" 10710 "double x = 1;\n", 10711 Alignment); 10712 // Ensure operator[] and operator() are comprehended 10713 verifyFormat("struct test {\n" 10714 " long long int foo();\n" 10715 " int operator[](int a);\n" 10716 " double bar();\n" 10717 "};\n", 10718 Alignment); 10719 verifyFormat("struct test {\n" 10720 " long long int foo();\n" 10721 " int operator()(int a);\n" 10722 " double bar();\n" 10723 "};\n", 10724 Alignment); 10725 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 10726 " int const i = 1;\n" 10727 " int * j = 2;\n" 10728 " int big = 10000;\n" 10729 "\n" 10730 " unsigned oneTwoThree = 123;\n" 10731 " int oneTwo = 12;\n" 10732 " method();\n" 10733 " float k = 2;\n" 10734 " int ll = 10000;\n" 10735 "}", 10736 format("void SomeFunction(int parameter= 0) {\n" 10737 " int const i= 1;\n" 10738 " int *j=2;\n" 10739 " int big = 10000;\n" 10740 "\n" 10741 "unsigned oneTwoThree =123;\n" 10742 "int oneTwo = 12;\n" 10743 " method();\n" 10744 "float k= 2;\n" 10745 "int ll=10000;\n" 10746 "}", 10747 Alignment)); 10748 Alignment.AlignConsecutiveAssignments = false; 10749 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10750 verifyFormat("#define A \\\n" 10751 " int aaaa = 12; \\\n" 10752 " float b = 23; \\\n" 10753 " const int ccc = 234; \\\n" 10754 " unsigned dddddddddd = 2345;", 10755 Alignment); 10756 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10757 verifyFormat("#define A \\\n" 10758 " int aaaa = 12; \\\n" 10759 " float b = 23; \\\n" 10760 " const int ccc = 234; \\\n" 10761 " unsigned dddddddddd = 2345;", 10762 Alignment); 10763 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10764 Alignment.ColumnLimit = 30; 10765 verifyFormat("#define A \\\n" 10766 " int aaaa = 12; \\\n" 10767 " float b = 23; \\\n" 10768 " const int ccc = 234; \\\n" 10769 " int dddddddddd = 2345;", 10770 Alignment); 10771 Alignment.ColumnLimit = 80; 10772 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10773 "k = 4, int l = 5,\n" 10774 " int m = 6) {\n" 10775 " const int j = 10;\n" 10776 " otherThing = 1;\n" 10777 "}", 10778 Alignment); 10779 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10780 " int const i = 1;\n" 10781 " int * j = 2;\n" 10782 " int big = 10000;\n" 10783 "}", 10784 Alignment); 10785 verifyFormat("class C {\n" 10786 "public:\n" 10787 " int i = 1;\n" 10788 " virtual void f() = 0;\n" 10789 "};", 10790 Alignment); 10791 verifyFormat("float i = 1;\n" 10792 "if (SomeType t = getSomething()) {\n" 10793 "}\n" 10794 "const unsigned j = 2;\n" 10795 "int big = 10000;", 10796 Alignment); 10797 verifyFormat("float j = 7;\n" 10798 "for (int k = 0; k < N; ++k) {\n" 10799 "}\n" 10800 "unsigned j = 2;\n" 10801 "int big = 10000;\n" 10802 "}", 10803 Alignment); 10804 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10805 verifyFormat("float i = 1;\n" 10806 "LooooooooooongType loooooooooooooooooooooongVariable\n" 10807 " = someLooooooooooooooooongFunction();\n" 10808 "int j = 2;", 10809 Alignment); 10810 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 10811 verifyFormat("int i = 1;\n" 10812 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 10813 " someLooooooooooooooooongFunction();\n" 10814 "int j = 2;", 10815 Alignment); 10816 10817 Alignment.AlignConsecutiveAssignments = true; 10818 verifyFormat("auto lambda = []() {\n" 10819 " auto ii = 0;\n" 10820 " float j = 0;\n" 10821 " return 0;\n" 10822 "};\n" 10823 "int i = 0;\n" 10824 "float i2 = 0;\n" 10825 "auto v = type{\n" 10826 " i = 1, //\n" 10827 " (i = 2), //\n" 10828 " i = 3 //\n" 10829 "};", 10830 Alignment); 10831 Alignment.AlignConsecutiveAssignments = false; 10832 10833 verifyFormat( 10834 "int i = 1;\n" 10835 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 10836 " loooooooooooooooooooooongParameterB);\n" 10837 "int j = 2;", 10838 Alignment); 10839 10840 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 10841 // We expect declarations and assignments to align, as long as it doesn't 10842 // exceed the column limit, starting a new alignment sequence whenever it 10843 // happens. 10844 Alignment.AlignConsecutiveAssignments = true; 10845 Alignment.ColumnLimit = 30; 10846 verifyFormat("float ii = 1;\n" 10847 "unsigned j = 2;\n" 10848 "int someVerylongVariable = 1;\n" 10849 "AnotherLongType ll = 123456;\n" 10850 "VeryVeryLongType k = 2;\n" 10851 "int myvar = 1;", 10852 Alignment); 10853 Alignment.ColumnLimit = 80; 10854 Alignment.AlignConsecutiveAssignments = false; 10855 10856 verifyFormat( 10857 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 10858 " typename LongType, typename B>\n" 10859 "auto foo() {}\n", 10860 Alignment); 10861 verifyFormat("float a, b = 1;\n" 10862 "int c = 2;\n" 10863 "int dd = 3;\n", 10864 Alignment); 10865 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10866 "float b[1][] = {{3.f}};\n", 10867 Alignment); 10868 Alignment.AlignConsecutiveAssignments = true; 10869 verifyFormat("float a, b = 1;\n" 10870 "int c = 2;\n" 10871 "int dd = 3;\n", 10872 Alignment); 10873 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10874 "float b[1][] = {{3.f}};\n", 10875 Alignment); 10876 Alignment.AlignConsecutiveAssignments = false; 10877 10878 Alignment.ColumnLimit = 30; 10879 Alignment.BinPackParameters = false; 10880 verifyFormat("void foo(float a,\n" 10881 " float b,\n" 10882 " int c,\n" 10883 " uint32_t *d) {\n" 10884 " int * e = 0;\n" 10885 " float f = 0;\n" 10886 " double g = 0;\n" 10887 "}\n" 10888 "void bar(ino_t a,\n" 10889 " int b,\n" 10890 " uint32_t *c,\n" 10891 " bool d) {}\n", 10892 Alignment); 10893 Alignment.BinPackParameters = true; 10894 Alignment.ColumnLimit = 80; 10895 10896 // Bug 33507 10897 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 10898 verifyFormat( 10899 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 10900 " static const Version verVs2017;\n" 10901 " return true;\n" 10902 "});\n", 10903 Alignment); 10904 Alignment.PointerAlignment = FormatStyle::PAS_Right; 10905 10906 // See llvm.org/PR35641 10907 Alignment.AlignConsecutiveDeclarations = true; 10908 verifyFormat("int func() { //\n" 10909 " int b;\n" 10910 " unsigned c;\n" 10911 "}", 10912 Alignment); 10913 10914 // See PR37175 10915 FormatStyle Style = getMozillaStyle(); 10916 Style.AlignConsecutiveDeclarations = true; 10917 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 10918 "foo(int a);", 10919 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 10920 } 10921 10922 TEST_F(FormatTest, LinuxBraceBreaking) { 10923 FormatStyle LinuxBraceStyle = getLLVMStyle(); 10924 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 10925 verifyFormat("namespace a\n" 10926 "{\n" 10927 "class A\n" 10928 "{\n" 10929 " void f()\n" 10930 " {\n" 10931 " if (true) {\n" 10932 " a();\n" 10933 " b();\n" 10934 " } else {\n" 10935 " a();\n" 10936 " }\n" 10937 " }\n" 10938 " void g() { return; }\n" 10939 "};\n" 10940 "struct B {\n" 10941 " int x;\n" 10942 "};\n" 10943 "} // namespace a\n", 10944 LinuxBraceStyle); 10945 verifyFormat("enum X {\n" 10946 " Y = 0,\n" 10947 "}\n", 10948 LinuxBraceStyle); 10949 verifyFormat("struct S {\n" 10950 " int Type;\n" 10951 " union {\n" 10952 " int x;\n" 10953 " double y;\n" 10954 " } Value;\n" 10955 " class C\n" 10956 " {\n" 10957 " MyFavoriteType Value;\n" 10958 " } Class;\n" 10959 "}\n", 10960 LinuxBraceStyle); 10961 } 10962 10963 TEST_F(FormatTest, MozillaBraceBreaking) { 10964 FormatStyle MozillaBraceStyle = getLLVMStyle(); 10965 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 10966 MozillaBraceStyle.FixNamespaceComments = false; 10967 verifyFormat("namespace a {\n" 10968 "class A\n" 10969 "{\n" 10970 " void f()\n" 10971 " {\n" 10972 " if (true) {\n" 10973 " a();\n" 10974 " b();\n" 10975 " }\n" 10976 " }\n" 10977 " void g() { return; }\n" 10978 "};\n" 10979 "enum E\n" 10980 "{\n" 10981 " A,\n" 10982 " // foo\n" 10983 " B,\n" 10984 " C\n" 10985 "};\n" 10986 "struct B\n" 10987 "{\n" 10988 " int x;\n" 10989 "};\n" 10990 "}\n", 10991 MozillaBraceStyle); 10992 verifyFormat("struct S\n" 10993 "{\n" 10994 " int Type;\n" 10995 " union\n" 10996 " {\n" 10997 " int x;\n" 10998 " double y;\n" 10999 " } Value;\n" 11000 " class C\n" 11001 " {\n" 11002 " MyFavoriteType Value;\n" 11003 " } Class;\n" 11004 "}\n", 11005 MozillaBraceStyle); 11006 } 11007 11008 TEST_F(FormatTest, StroustrupBraceBreaking) { 11009 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 11010 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11011 verifyFormat("namespace a {\n" 11012 "class A {\n" 11013 " void f()\n" 11014 " {\n" 11015 " if (true) {\n" 11016 " a();\n" 11017 " b();\n" 11018 " }\n" 11019 " }\n" 11020 " void g() { return; }\n" 11021 "};\n" 11022 "struct B {\n" 11023 " int x;\n" 11024 "};\n" 11025 "} // namespace a\n", 11026 StroustrupBraceStyle); 11027 11028 verifyFormat("void foo()\n" 11029 "{\n" 11030 " if (a) {\n" 11031 " a();\n" 11032 " }\n" 11033 " else {\n" 11034 " b();\n" 11035 " }\n" 11036 "}\n", 11037 StroustrupBraceStyle); 11038 11039 verifyFormat("#ifdef _DEBUG\n" 11040 "int foo(int i = 0)\n" 11041 "#else\n" 11042 "int foo(int i = 5)\n" 11043 "#endif\n" 11044 "{\n" 11045 " return i;\n" 11046 "}", 11047 StroustrupBraceStyle); 11048 11049 verifyFormat("void foo() {}\n" 11050 "void bar()\n" 11051 "#ifdef _DEBUG\n" 11052 "{\n" 11053 " foo();\n" 11054 "}\n" 11055 "#else\n" 11056 "{\n" 11057 "}\n" 11058 "#endif", 11059 StroustrupBraceStyle); 11060 11061 verifyFormat("void foobar() { int i = 5; }\n" 11062 "#ifdef _DEBUG\n" 11063 "void bar() {}\n" 11064 "#else\n" 11065 "void bar() { foobar(); }\n" 11066 "#endif", 11067 StroustrupBraceStyle); 11068 } 11069 11070 TEST_F(FormatTest, AllmanBraceBreaking) { 11071 FormatStyle AllmanBraceStyle = getLLVMStyle(); 11072 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 11073 11074 EXPECT_EQ("namespace a\n" 11075 "{\n" 11076 "void f();\n" 11077 "void g();\n" 11078 "} // namespace a\n", 11079 format("namespace a\n" 11080 "{\n" 11081 "void f();\n" 11082 "void g();\n" 11083 "}\n", 11084 AllmanBraceStyle)); 11085 11086 verifyFormat("namespace a\n" 11087 "{\n" 11088 "class A\n" 11089 "{\n" 11090 " void f()\n" 11091 " {\n" 11092 " if (true)\n" 11093 " {\n" 11094 " a();\n" 11095 " b();\n" 11096 " }\n" 11097 " }\n" 11098 " void g() { return; }\n" 11099 "};\n" 11100 "struct B\n" 11101 "{\n" 11102 " int x;\n" 11103 "};\n" 11104 "union C\n" 11105 "{\n" 11106 "};\n" 11107 "} // namespace a", 11108 AllmanBraceStyle); 11109 11110 verifyFormat("void f()\n" 11111 "{\n" 11112 " if (true)\n" 11113 " {\n" 11114 " a();\n" 11115 " }\n" 11116 " else if (false)\n" 11117 " {\n" 11118 " b();\n" 11119 " }\n" 11120 " else\n" 11121 " {\n" 11122 " c();\n" 11123 " }\n" 11124 "}\n", 11125 AllmanBraceStyle); 11126 11127 verifyFormat("void f()\n" 11128 "{\n" 11129 " for (int i = 0; i < 10; ++i)\n" 11130 " {\n" 11131 " a();\n" 11132 " }\n" 11133 " while (false)\n" 11134 " {\n" 11135 " b();\n" 11136 " }\n" 11137 " do\n" 11138 " {\n" 11139 " c();\n" 11140 " } while (false)\n" 11141 "}\n", 11142 AllmanBraceStyle); 11143 11144 verifyFormat("void f(int a)\n" 11145 "{\n" 11146 " switch (a)\n" 11147 " {\n" 11148 " case 0:\n" 11149 " break;\n" 11150 " case 1:\n" 11151 " {\n" 11152 " break;\n" 11153 " }\n" 11154 " case 2:\n" 11155 " {\n" 11156 " }\n" 11157 " break;\n" 11158 " default:\n" 11159 " break;\n" 11160 " }\n" 11161 "}\n", 11162 AllmanBraceStyle); 11163 11164 verifyFormat("enum X\n" 11165 "{\n" 11166 " Y = 0,\n" 11167 "}\n", 11168 AllmanBraceStyle); 11169 verifyFormat("enum X\n" 11170 "{\n" 11171 " Y = 0\n" 11172 "}\n", 11173 AllmanBraceStyle); 11174 11175 verifyFormat("@interface BSApplicationController ()\n" 11176 "{\n" 11177 "@private\n" 11178 " id _extraIvar;\n" 11179 "}\n" 11180 "@end\n", 11181 AllmanBraceStyle); 11182 11183 verifyFormat("#ifdef _DEBUG\n" 11184 "int foo(int i = 0)\n" 11185 "#else\n" 11186 "int foo(int i = 5)\n" 11187 "#endif\n" 11188 "{\n" 11189 " return i;\n" 11190 "}", 11191 AllmanBraceStyle); 11192 11193 verifyFormat("void foo() {}\n" 11194 "void bar()\n" 11195 "#ifdef _DEBUG\n" 11196 "{\n" 11197 " foo();\n" 11198 "}\n" 11199 "#else\n" 11200 "{\n" 11201 "}\n" 11202 "#endif", 11203 AllmanBraceStyle); 11204 11205 verifyFormat("void foobar() { int i = 5; }\n" 11206 "#ifdef _DEBUG\n" 11207 "void bar() {}\n" 11208 "#else\n" 11209 "void bar() { foobar(); }\n" 11210 "#endif", 11211 AllmanBraceStyle); 11212 11213 // This shouldn't affect ObjC blocks.. 11214 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 11215 " // ...\n" 11216 " int i;\n" 11217 "}];", 11218 AllmanBraceStyle); 11219 verifyFormat("void (^block)(void) = ^{\n" 11220 " // ...\n" 11221 " int i;\n" 11222 "};", 11223 AllmanBraceStyle); 11224 // .. or dict literals. 11225 verifyFormat("void f()\n" 11226 "{\n" 11227 " // ...\n" 11228 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 11229 "}", 11230 AllmanBraceStyle); 11231 verifyFormat("void f()\n" 11232 "{\n" 11233 " // ...\n" 11234 " [object someMethod:@{a : @\"b\"}];\n" 11235 "}", 11236 AllmanBraceStyle); 11237 verifyFormat("int f()\n" 11238 "{ // comment\n" 11239 " return 42;\n" 11240 "}", 11241 AllmanBraceStyle); 11242 11243 AllmanBraceStyle.ColumnLimit = 19; 11244 verifyFormat("void f() { int i; }", AllmanBraceStyle); 11245 AllmanBraceStyle.ColumnLimit = 18; 11246 verifyFormat("void f()\n" 11247 "{\n" 11248 " int i;\n" 11249 "}", 11250 AllmanBraceStyle); 11251 AllmanBraceStyle.ColumnLimit = 80; 11252 11253 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 11254 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 11255 FormatStyle::SIS_WithoutElse; 11256 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 11257 verifyFormat("void f(bool b)\n" 11258 "{\n" 11259 " if (b)\n" 11260 " {\n" 11261 " return;\n" 11262 " }\n" 11263 "}\n", 11264 BreakBeforeBraceShortIfs); 11265 verifyFormat("void f(bool b)\n" 11266 "{\n" 11267 " if constexpr (b)\n" 11268 " {\n" 11269 " return;\n" 11270 " }\n" 11271 "}\n", 11272 BreakBeforeBraceShortIfs); 11273 verifyFormat("void f(bool b)\n" 11274 "{\n" 11275 " if CONSTEXPR (b)\n" 11276 " {\n" 11277 " return;\n" 11278 " }\n" 11279 "}\n", 11280 BreakBeforeBraceShortIfs); 11281 verifyFormat("void f(bool b)\n" 11282 "{\n" 11283 " if (b) return;\n" 11284 "}\n", 11285 BreakBeforeBraceShortIfs); 11286 verifyFormat("void f(bool b)\n" 11287 "{\n" 11288 " if constexpr (b) return;\n" 11289 "}\n", 11290 BreakBeforeBraceShortIfs); 11291 verifyFormat("void f(bool b)\n" 11292 "{\n" 11293 " if CONSTEXPR (b) return;\n" 11294 "}\n", 11295 BreakBeforeBraceShortIfs); 11296 verifyFormat("void f(bool b)\n" 11297 "{\n" 11298 " while (b)\n" 11299 " {\n" 11300 " return;\n" 11301 " }\n" 11302 "}\n", 11303 BreakBeforeBraceShortIfs); 11304 } 11305 11306 TEST_F(FormatTest, GNUBraceBreaking) { 11307 FormatStyle GNUBraceStyle = getLLVMStyle(); 11308 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 11309 verifyFormat("namespace a\n" 11310 "{\n" 11311 "class A\n" 11312 "{\n" 11313 " void f()\n" 11314 " {\n" 11315 " int a;\n" 11316 " {\n" 11317 " int b;\n" 11318 " }\n" 11319 " if (true)\n" 11320 " {\n" 11321 " a();\n" 11322 " b();\n" 11323 " }\n" 11324 " }\n" 11325 " void g() { return; }\n" 11326 "}\n" 11327 "} // namespace a", 11328 GNUBraceStyle); 11329 11330 verifyFormat("void f()\n" 11331 "{\n" 11332 " if (true)\n" 11333 " {\n" 11334 " a();\n" 11335 " }\n" 11336 " else if (false)\n" 11337 " {\n" 11338 " b();\n" 11339 " }\n" 11340 " else\n" 11341 " {\n" 11342 " c();\n" 11343 " }\n" 11344 "}\n", 11345 GNUBraceStyle); 11346 11347 verifyFormat("void f()\n" 11348 "{\n" 11349 " for (int i = 0; i < 10; ++i)\n" 11350 " {\n" 11351 " a();\n" 11352 " }\n" 11353 " while (false)\n" 11354 " {\n" 11355 " b();\n" 11356 " }\n" 11357 " do\n" 11358 " {\n" 11359 " c();\n" 11360 " }\n" 11361 " while (false);\n" 11362 "}\n", 11363 GNUBraceStyle); 11364 11365 verifyFormat("void f(int a)\n" 11366 "{\n" 11367 " switch (a)\n" 11368 " {\n" 11369 " case 0:\n" 11370 " break;\n" 11371 " case 1:\n" 11372 " {\n" 11373 " break;\n" 11374 " }\n" 11375 " case 2:\n" 11376 " {\n" 11377 " }\n" 11378 " break;\n" 11379 " default:\n" 11380 " break;\n" 11381 " }\n" 11382 "}\n", 11383 GNUBraceStyle); 11384 11385 verifyFormat("enum X\n" 11386 "{\n" 11387 " Y = 0,\n" 11388 "}\n", 11389 GNUBraceStyle); 11390 11391 verifyFormat("@interface BSApplicationController ()\n" 11392 "{\n" 11393 "@private\n" 11394 " id _extraIvar;\n" 11395 "}\n" 11396 "@end\n", 11397 GNUBraceStyle); 11398 11399 verifyFormat("#ifdef _DEBUG\n" 11400 "int foo(int i = 0)\n" 11401 "#else\n" 11402 "int foo(int i = 5)\n" 11403 "#endif\n" 11404 "{\n" 11405 " return i;\n" 11406 "}", 11407 GNUBraceStyle); 11408 11409 verifyFormat("void foo() {}\n" 11410 "void bar()\n" 11411 "#ifdef _DEBUG\n" 11412 "{\n" 11413 " foo();\n" 11414 "}\n" 11415 "#else\n" 11416 "{\n" 11417 "}\n" 11418 "#endif", 11419 GNUBraceStyle); 11420 11421 verifyFormat("void foobar() { int i = 5; }\n" 11422 "#ifdef _DEBUG\n" 11423 "void bar() {}\n" 11424 "#else\n" 11425 "void bar() { foobar(); }\n" 11426 "#endif", 11427 GNUBraceStyle); 11428 } 11429 11430 TEST_F(FormatTest, WebKitBraceBreaking) { 11431 FormatStyle WebKitBraceStyle = getLLVMStyle(); 11432 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 11433 WebKitBraceStyle.FixNamespaceComments = false; 11434 verifyFormat("namespace a {\n" 11435 "class A {\n" 11436 " void f()\n" 11437 " {\n" 11438 " if (true) {\n" 11439 " a();\n" 11440 " b();\n" 11441 " }\n" 11442 " }\n" 11443 " void g() { return; }\n" 11444 "};\n" 11445 "enum E {\n" 11446 " A,\n" 11447 " // foo\n" 11448 " B,\n" 11449 " C\n" 11450 "};\n" 11451 "struct B {\n" 11452 " int x;\n" 11453 "};\n" 11454 "}\n", 11455 WebKitBraceStyle); 11456 verifyFormat("struct S {\n" 11457 " int Type;\n" 11458 " union {\n" 11459 " int x;\n" 11460 " double y;\n" 11461 " } Value;\n" 11462 " class C {\n" 11463 " MyFavoriteType Value;\n" 11464 " } Class;\n" 11465 "};\n", 11466 WebKitBraceStyle); 11467 } 11468 11469 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 11470 verifyFormat("void f() {\n" 11471 " try {\n" 11472 " } catch (const Exception &e) {\n" 11473 " }\n" 11474 "}\n", 11475 getLLVMStyle()); 11476 } 11477 11478 TEST_F(FormatTest, UnderstandsPragmas) { 11479 verifyFormat("#pragma omp reduction(| : var)"); 11480 verifyFormat("#pragma omp reduction(+ : var)"); 11481 11482 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 11483 "(including parentheses).", 11484 format("#pragma mark Any non-hyphenated or hyphenated string " 11485 "(including parentheses).")); 11486 } 11487 11488 TEST_F(FormatTest, UnderstandPragmaOption) { 11489 verifyFormat("#pragma option -C -A"); 11490 11491 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 11492 } 11493 11494 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 11495 FormatStyle Style = getLLVMStyle(); 11496 Style.ColumnLimit = 20; 11497 11498 // See PR41213 11499 EXPECT_EQ("/*\n" 11500 " *\t9012345\n" 11501 " * /8901\n" 11502 " */", 11503 format("/*\n" 11504 " *\t9012345 /8901\n" 11505 " */", 11506 Style)); 11507 EXPECT_EQ("/*\n" 11508 " *345678\n" 11509 " *\t/8901\n" 11510 " */", 11511 format("/*\n" 11512 " *345678\t/8901\n" 11513 " */", 11514 Style)); 11515 11516 verifyFormat("int a; // the\n" 11517 " // comment", Style); 11518 EXPECT_EQ("int a; /* first line\n" 11519 " * second\n" 11520 " * line third\n" 11521 " * line\n" 11522 " */", 11523 format("int a; /* first line\n" 11524 " * second\n" 11525 " * line third\n" 11526 " * line\n" 11527 " */", 11528 Style)); 11529 EXPECT_EQ("int a; // first line\n" 11530 " // second\n" 11531 " // line third\n" 11532 " // line", 11533 format("int a; // first line\n" 11534 " // second line\n" 11535 " // third line", 11536 Style)); 11537 11538 Style.PenaltyExcessCharacter = 90; 11539 verifyFormat("int a; // the comment", Style); 11540 EXPECT_EQ("int a; // the comment\n" 11541 " // aaa", 11542 format("int a; // the comment aaa", Style)); 11543 EXPECT_EQ("int a; /* first line\n" 11544 " * second line\n" 11545 " * third line\n" 11546 " */", 11547 format("int a; /* first line\n" 11548 " * second line\n" 11549 " * third line\n" 11550 " */", 11551 Style)); 11552 EXPECT_EQ("int a; // first line\n" 11553 " // second line\n" 11554 " // third line", 11555 format("int a; // first line\n" 11556 " // second line\n" 11557 " // third line", 11558 Style)); 11559 // FIXME: Investigate why this is not getting the same layout as the test 11560 // above. 11561 EXPECT_EQ("int a; /* first line\n" 11562 " * second line\n" 11563 " * third line\n" 11564 " */", 11565 format("int a; /* first line second line third line" 11566 "\n*/", 11567 Style)); 11568 11569 EXPECT_EQ("// foo bar baz bazfoo\n" 11570 "// foo bar foo bar\n", 11571 format("// foo bar baz bazfoo\n" 11572 "// foo bar foo bar\n", 11573 Style)); 11574 EXPECT_EQ("// foo bar baz bazfoo\n" 11575 "// foo bar foo bar\n", 11576 format("// foo bar baz bazfoo\n" 11577 "// foo bar foo bar\n", 11578 Style)); 11579 11580 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 11581 // next one. 11582 EXPECT_EQ("// foo bar baz bazfoo\n" 11583 "// bar foo bar\n", 11584 format("// foo bar baz bazfoo bar\n" 11585 "// foo bar\n", 11586 Style)); 11587 11588 EXPECT_EQ("// foo bar baz bazfoo\n" 11589 "// foo bar baz bazfoo\n" 11590 "// bar foo bar\n", 11591 format("// foo bar baz bazfoo\n" 11592 "// foo bar baz bazfoo bar\n" 11593 "// foo bar\n", 11594 Style)); 11595 11596 EXPECT_EQ("// foo bar baz bazfoo\n" 11597 "// foo bar baz bazfoo\n" 11598 "// bar foo bar\n", 11599 format("// foo bar baz bazfoo\n" 11600 "// foo bar baz bazfoo bar\n" 11601 "// foo bar\n", 11602 Style)); 11603 11604 // Make sure we do not keep protruding characters if strict mode reflow is 11605 // cheaper than keeping protruding characters. 11606 Style.ColumnLimit = 21; 11607 EXPECT_EQ("// foo foo foo foo\n" 11608 "// foo foo foo foo\n" 11609 "// foo foo foo foo\n", 11610 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", 11611 Style)); 11612 11613 EXPECT_EQ("int a = /* long block\n" 11614 " comment */\n" 11615 " 42;", 11616 format("int a = /* long block comment */ 42;", Style)); 11617 } 11618 11619 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 11620 for (size_t i = 1; i < Styles.size(); ++i) \ 11621 EXPECT_EQ(Styles[0], Styles[i]) << "Style #" << i << " of " << Styles.size() \ 11622 << " differs from Style #0" 11623 11624 TEST_F(FormatTest, GetsPredefinedStyleByName) { 11625 SmallVector<FormatStyle, 3> Styles; 11626 Styles.resize(3); 11627 11628 Styles[0] = getLLVMStyle(); 11629 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 11630 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 11631 EXPECT_ALL_STYLES_EQUAL(Styles); 11632 11633 Styles[0] = getGoogleStyle(); 11634 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 11635 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 11636 EXPECT_ALL_STYLES_EQUAL(Styles); 11637 11638 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 11639 EXPECT_TRUE( 11640 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 11641 EXPECT_TRUE( 11642 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 11643 EXPECT_ALL_STYLES_EQUAL(Styles); 11644 11645 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 11646 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 11647 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 11648 EXPECT_ALL_STYLES_EQUAL(Styles); 11649 11650 Styles[0] = getMozillaStyle(); 11651 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 11652 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 11653 EXPECT_ALL_STYLES_EQUAL(Styles); 11654 11655 Styles[0] = getWebKitStyle(); 11656 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 11657 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 11658 EXPECT_ALL_STYLES_EQUAL(Styles); 11659 11660 Styles[0] = getGNUStyle(); 11661 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 11662 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 11663 EXPECT_ALL_STYLES_EQUAL(Styles); 11664 11665 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 11666 } 11667 11668 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 11669 SmallVector<FormatStyle, 8> Styles; 11670 Styles.resize(2); 11671 11672 Styles[0] = getGoogleStyle(); 11673 Styles[1] = getLLVMStyle(); 11674 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 11675 EXPECT_ALL_STYLES_EQUAL(Styles); 11676 11677 Styles.resize(5); 11678 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 11679 Styles[1] = getLLVMStyle(); 11680 Styles[1].Language = FormatStyle::LK_JavaScript; 11681 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 11682 11683 Styles[2] = getLLVMStyle(); 11684 Styles[2].Language = FormatStyle::LK_JavaScript; 11685 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 11686 "BasedOnStyle: Google", 11687 &Styles[2]) 11688 .value()); 11689 11690 Styles[3] = getLLVMStyle(); 11691 Styles[3].Language = FormatStyle::LK_JavaScript; 11692 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 11693 "Language: JavaScript", 11694 &Styles[3]) 11695 .value()); 11696 11697 Styles[4] = getLLVMStyle(); 11698 Styles[4].Language = FormatStyle::LK_JavaScript; 11699 EXPECT_EQ(0, parseConfiguration("---\n" 11700 "BasedOnStyle: LLVM\n" 11701 "IndentWidth: 123\n" 11702 "---\n" 11703 "BasedOnStyle: Google\n" 11704 "Language: JavaScript", 11705 &Styles[4]) 11706 .value()); 11707 EXPECT_ALL_STYLES_EQUAL(Styles); 11708 } 11709 11710 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 11711 Style.FIELD = false; \ 11712 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 11713 EXPECT_TRUE(Style.FIELD); \ 11714 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 11715 EXPECT_FALSE(Style.FIELD); 11716 11717 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 11718 11719 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 11720 Style.STRUCT.FIELD = false; \ 11721 EXPECT_EQ(0, \ 11722 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 11723 .value()); \ 11724 EXPECT_TRUE(Style.STRUCT.FIELD); \ 11725 EXPECT_EQ(0, \ 11726 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 11727 .value()); \ 11728 EXPECT_FALSE(Style.STRUCT.FIELD); 11729 11730 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 11731 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 11732 11733 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 11734 EXPECT_NE(VALUE, Style.FIELD); \ 11735 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 11736 EXPECT_EQ(VALUE, Style.FIELD) 11737 11738 TEST_F(FormatTest, ParsesConfigurationBools) { 11739 FormatStyle Style = {}; 11740 Style.Language = FormatStyle::LK_Cpp; 11741 CHECK_PARSE_BOOL(AlignOperands); 11742 CHECK_PARSE_BOOL(AlignTrailingComments); 11743 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 11744 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 11745 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 11746 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 11747 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 11748 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 11749 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 11750 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 11751 CHECK_PARSE_BOOL(BinPackArguments); 11752 CHECK_PARSE_BOOL(BinPackParameters); 11753 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 11754 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 11755 CHECK_PARSE_BOOL(BreakStringLiterals); 11756 CHECK_PARSE_BOOL(CompactNamespaces); 11757 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 11758 CHECK_PARSE_BOOL(DerivePointerAlignment); 11759 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 11760 CHECK_PARSE_BOOL(DisableFormat); 11761 CHECK_PARSE_BOOL(IndentCaseLabels); 11762 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 11763 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 11764 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 11765 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 11766 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 11767 CHECK_PARSE_BOOL(ReflowComments); 11768 CHECK_PARSE_BOOL(SortIncludes); 11769 CHECK_PARSE_BOOL(SortUsingDeclarations); 11770 CHECK_PARSE_BOOL(SpacesInParentheses); 11771 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 11772 CHECK_PARSE_BOOL(SpacesInAngles); 11773 CHECK_PARSE_BOOL(SpaceInEmptyBlock); 11774 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 11775 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 11776 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 11777 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 11778 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 11779 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 11780 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 11781 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 11782 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 11783 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 11784 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 11785 11786 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 11787 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 11788 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterControlStatement); 11789 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 11790 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 11791 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 11792 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 11793 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 11794 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 11795 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 11796 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 11797 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 11798 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 11799 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 11800 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 11801 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 11802 } 11803 11804 #undef CHECK_PARSE_BOOL 11805 11806 TEST_F(FormatTest, ParsesConfiguration) { 11807 FormatStyle Style = {}; 11808 Style.Language = FormatStyle::LK_Cpp; 11809 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 11810 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 11811 ConstructorInitializerIndentWidth, 1234u); 11812 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 11813 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 11814 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 11815 CHECK_PARSE("PenaltyBreakAssignment: 1234", 11816 PenaltyBreakAssignment, 1234u); 11817 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 11818 PenaltyBreakBeforeFirstCallParameter, 1234u); 11819 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 11820 PenaltyBreakTemplateDeclaration, 1234u); 11821 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 11822 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 11823 PenaltyReturnTypeOnItsOwnLine, 1234u); 11824 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 11825 SpacesBeforeTrailingComments, 1234u); 11826 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 11827 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 11828 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 11829 11830 Style.PointerAlignment = FormatStyle::PAS_Middle; 11831 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 11832 FormatStyle::PAS_Left); 11833 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 11834 FormatStyle::PAS_Right); 11835 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 11836 FormatStyle::PAS_Middle); 11837 // For backward compatibility: 11838 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 11839 FormatStyle::PAS_Left); 11840 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 11841 FormatStyle::PAS_Right); 11842 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 11843 FormatStyle::PAS_Middle); 11844 11845 Style.Standard = FormatStyle::LS_Auto; 11846 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 11847 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11); 11848 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 11849 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 11850 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 11851 11852 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11853 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 11854 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 11855 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 11856 FormatStyle::BOS_None); 11857 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 11858 FormatStyle::BOS_All); 11859 // For backward compatibility: 11860 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 11861 FormatStyle::BOS_None); 11862 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 11863 FormatStyle::BOS_All); 11864 11865 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 11866 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 11867 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 11868 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 11869 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 11870 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 11871 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 11872 // For backward compatibility: 11873 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 11874 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 11875 11876 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 11877 CHECK_PARSE("BreakInheritanceList: BeforeComma", 11878 BreakInheritanceList, FormatStyle::BILS_BeforeComma); 11879 CHECK_PARSE("BreakInheritanceList: AfterColon", 11880 BreakInheritanceList, FormatStyle::BILS_AfterColon); 11881 CHECK_PARSE("BreakInheritanceList: BeforeColon", 11882 BreakInheritanceList, FormatStyle::BILS_BeforeColon); 11883 // For backward compatibility: 11884 CHECK_PARSE("BreakBeforeInheritanceComma: true", 11885 BreakInheritanceList, FormatStyle::BILS_BeforeComma); 11886 11887 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 11888 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 11889 FormatStyle::BAS_Align); 11890 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 11891 FormatStyle::BAS_DontAlign); 11892 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 11893 FormatStyle::BAS_AlwaysBreak); 11894 // For backward compatibility: 11895 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 11896 FormatStyle::BAS_DontAlign); 11897 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 11898 FormatStyle::BAS_Align); 11899 11900 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11901 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 11902 FormatStyle::ENAS_DontAlign); 11903 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 11904 FormatStyle::ENAS_Left); 11905 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 11906 FormatStyle::ENAS_Right); 11907 // For backward compatibility: 11908 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 11909 FormatStyle::ENAS_Left); 11910 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 11911 FormatStyle::ENAS_Right); 11912 11913 Style.UseTab = FormatStyle::UT_ForIndentation; 11914 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 11915 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 11916 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 11917 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 11918 FormatStyle::UT_ForContinuationAndIndentation); 11919 // For backward compatibility: 11920 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 11921 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 11922 11923 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 11924 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never", 11925 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 11926 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty", 11927 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty); 11928 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always", 11929 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 11930 // For backward compatibility: 11931 CHECK_PARSE("AllowShortBlocksOnASingleLine: false", 11932 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 11933 CHECK_PARSE("AllowShortBlocksOnASingleLine: true", 11934 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 11935 11936 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 11937 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 11938 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 11939 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 11940 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 11941 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 11942 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 11943 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 11944 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 11945 // For backward compatibility: 11946 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 11947 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 11948 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 11949 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 11950 11951 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 11952 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 11953 FormatStyle::SBPO_Never); 11954 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 11955 FormatStyle::SBPO_Always); 11956 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 11957 FormatStyle::SBPO_ControlStatements); 11958 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 11959 FormatStyle::SBPO_NonEmptyParentheses); 11960 // For backward compatibility: 11961 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 11962 FormatStyle::SBPO_Never); 11963 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 11964 FormatStyle::SBPO_ControlStatements); 11965 11966 Style.ColumnLimit = 123; 11967 FormatStyle BaseStyle = getLLVMStyle(); 11968 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 11969 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 11970 11971 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11972 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 11973 FormatStyle::BS_Attach); 11974 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 11975 FormatStyle::BS_Linux); 11976 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 11977 FormatStyle::BS_Mozilla); 11978 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 11979 FormatStyle::BS_Stroustrup); 11980 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 11981 FormatStyle::BS_Allman); 11982 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 11983 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 11984 FormatStyle::BS_WebKit); 11985 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 11986 FormatStyle::BS_Custom); 11987 11988 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 11989 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 11990 FormatStyle::RTBS_None); 11991 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 11992 FormatStyle::RTBS_All); 11993 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 11994 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 11995 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 11996 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 11997 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 11998 AlwaysBreakAfterReturnType, 11999 FormatStyle::RTBS_TopLevelDefinitions); 12000 12001 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 12002 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", AlwaysBreakTemplateDeclarations, 12003 FormatStyle::BTDS_No); 12004 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", AlwaysBreakTemplateDeclarations, 12005 FormatStyle::BTDS_MultiLine); 12006 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", AlwaysBreakTemplateDeclarations, 12007 FormatStyle::BTDS_Yes); 12008 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", AlwaysBreakTemplateDeclarations, 12009 FormatStyle::BTDS_MultiLine); 12010 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", AlwaysBreakTemplateDeclarations, 12011 FormatStyle::BTDS_Yes); 12012 12013 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 12014 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 12015 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 12016 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 12017 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 12018 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 12019 AlwaysBreakAfterDefinitionReturnType, 12020 FormatStyle::DRTBS_TopLevel); 12021 12022 Style.NamespaceIndentation = FormatStyle::NI_All; 12023 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 12024 FormatStyle::NI_None); 12025 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 12026 FormatStyle::NI_Inner); 12027 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 12028 FormatStyle::NI_All); 12029 12030 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 12031 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 12032 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12033 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 12034 AllowShortIfStatementsOnASingleLine, 12035 FormatStyle::SIS_WithoutElse); 12036 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 12037 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 12038 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 12039 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12040 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 12041 AllowShortIfStatementsOnASingleLine, 12042 FormatStyle::SIS_WithoutElse); 12043 12044 // FIXME: This is required because parsing a configuration simply overwrites 12045 // the first N elements of the list instead of resetting it. 12046 Style.ForEachMacros.clear(); 12047 std::vector<std::string> BoostForeach; 12048 BoostForeach.push_back("BOOST_FOREACH"); 12049 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 12050 std::vector<std::string> BoostAndQForeach; 12051 BoostAndQForeach.push_back("BOOST_FOREACH"); 12052 BoostAndQForeach.push_back("Q_FOREACH"); 12053 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 12054 BoostAndQForeach); 12055 12056 Style.StatementMacros.clear(); 12057 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 12058 std::vector<std::string>{"QUNUSED"}); 12059 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 12060 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 12061 12062 Style.NamespaceMacros.clear(); 12063 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 12064 std::vector<std::string>{"TESTSUITE"}); 12065 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 12066 std::vector<std::string>({"TESTSUITE", "SUITE"})); 12067 12068 Style.IncludeStyle.IncludeCategories.clear(); 12069 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 12070 {"abc/.*", 2}, {".*", 1}}; 12071 CHECK_PARSE("IncludeCategories:\n" 12072 " - Regex: abc/.*\n" 12073 " Priority: 2\n" 12074 " - Regex: .*\n" 12075 " Priority: 1", 12076 IncludeStyle.IncludeCategories, ExpectedCategories); 12077 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 12078 "abc$"); 12079 12080 Style.RawStringFormats.clear(); 12081 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 12082 { 12083 FormatStyle::LK_TextProto, 12084 {"pb", "proto"}, 12085 {"PARSE_TEXT_PROTO"}, 12086 /*CanonicalDelimiter=*/"", 12087 "llvm", 12088 }, 12089 { 12090 FormatStyle::LK_Cpp, 12091 {"cc", "cpp"}, 12092 {"C_CODEBLOCK", "CPPEVAL"}, 12093 /*CanonicalDelimiter=*/"cc", 12094 /*BasedOnStyle=*/"", 12095 }, 12096 }; 12097 12098 CHECK_PARSE("RawStringFormats:\n" 12099 " - Language: TextProto\n" 12100 " Delimiters:\n" 12101 " - 'pb'\n" 12102 " - 'proto'\n" 12103 " EnclosingFunctions:\n" 12104 " - 'PARSE_TEXT_PROTO'\n" 12105 " BasedOnStyle: llvm\n" 12106 " - Language: Cpp\n" 12107 " Delimiters:\n" 12108 " - 'cc'\n" 12109 " - 'cpp'\n" 12110 " EnclosingFunctions:\n" 12111 " - 'C_CODEBLOCK'\n" 12112 " - 'CPPEVAL'\n" 12113 " CanonicalDelimiter: 'cc'", 12114 RawStringFormats, ExpectedRawStringFormats); 12115 } 12116 12117 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 12118 FormatStyle Style = {}; 12119 Style.Language = FormatStyle::LK_Cpp; 12120 CHECK_PARSE("Language: Cpp\n" 12121 "IndentWidth: 12", 12122 IndentWidth, 12u); 12123 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 12124 "IndentWidth: 34", 12125 &Style), 12126 ParseError::Unsuitable); 12127 EXPECT_EQ(12u, Style.IndentWidth); 12128 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12129 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12130 12131 Style.Language = FormatStyle::LK_JavaScript; 12132 CHECK_PARSE("Language: JavaScript\n" 12133 "IndentWidth: 12", 12134 IndentWidth, 12u); 12135 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 12136 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 12137 "IndentWidth: 34", 12138 &Style), 12139 ParseError::Unsuitable); 12140 EXPECT_EQ(23u, Style.IndentWidth); 12141 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12142 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12143 12144 CHECK_PARSE("BasedOnStyle: LLVM\n" 12145 "IndentWidth: 67", 12146 IndentWidth, 67u); 12147 12148 CHECK_PARSE("---\n" 12149 "Language: JavaScript\n" 12150 "IndentWidth: 12\n" 12151 "---\n" 12152 "Language: Cpp\n" 12153 "IndentWidth: 34\n" 12154 "...\n", 12155 IndentWidth, 12u); 12156 12157 Style.Language = FormatStyle::LK_Cpp; 12158 CHECK_PARSE("---\n" 12159 "Language: JavaScript\n" 12160 "IndentWidth: 12\n" 12161 "---\n" 12162 "Language: Cpp\n" 12163 "IndentWidth: 34\n" 12164 "...\n", 12165 IndentWidth, 34u); 12166 CHECK_PARSE("---\n" 12167 "IndentWidth: 78\n" 12168 "---\n" 12169 "Language: JavaScript\n" 12170 "IndentWidth: 56\n" 12171 "...\n", 12172 IndentWidth, 78u); 12173 12174 Style.ColumnLimit = 123; 12175 Style.IndentWidth = 234; 12176 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 12177 Style.TabWidth = 345; 12178 EXPECT_FALSE(parseConfiguration("---\n" 12179 "IndentWidth: 456\n" 12180 "BreakBeforeBraces: Allman\n" 12181 "---\n" 12182 "Language: JavaScript\n" 12183 "IndentWidth: 111\n" 12184 "TabWidth: 111\n" 12185 "---\n" 12186 "Language: Cpp\n" 12187 "BreakBeforeBraces: Stroustrup\n" 12188 "TabWidth: 789\n" 12189 "...\n", 12190 &Style)); 12191 EXPECT_EQ(123u, Style.ColumnLimit); 12192 EXPECT_EQ(456u, Style.IndentWidth); 12193 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 12194 EXPECT_EQ(789u, Style.TabWidth); 12195 12196 EXPECT_EQ(parseConfiguration("---\n" 12197 "Language: JavaScript\n" 12198 "IndentWidth: 56\n" 12199 "---\n" 12200 "IndentWidth: 78\n" 12201 "...\n", 12202 &Style), 12203 ParseError::Error); 12204 EXPECT_EQ(parseConfiguration("---\n" 12205 "Language: JavaScript\n" 12206 "IndentWidth: 56\n" 12207 "---\n" 12208 "Language: JavaScript\n" 12209 "IndentWidth: 78\n" 12210 "...\n", 12211 &Style), 12212 ParseError::Error); 12213 12214 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12215 } 12216 12217 #undef CHECK_PARSE 12218 12219 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 12220 FormatStyle Style = {}; 12221 Style.Language = FormatStyle::LK_JavaScript; 12222 Style.BreakBeforeTernaryOperators = true; 12223 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 12224 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 12225 12226 Style.BreakBeforeTernaryOperators = true; 12227 EXPECT_EQ(0, parseConfiguration("---\n" 12228 "BasedOnStyle: Google\n" 12229 "---\n" 12230 "Language: JavaScript\n" 12231 "IndentWidth: 76\n" 12232 "...\n", 12233 &Style) 12234 .value()); 12235 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 12236 EXPECT_EQ(76u, Style.IndentWidth); 12237 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12238 } 12239 12240 TEST_F(FormatTest, ConfigurationRoundTripTest) { 12241 FormatStyle Style = getLLVMStyle(); 12242 std::string YAML = configurationAsText(Style); 12243 FormatStyle ParsedStyle = {}; 12244 ParsedStyle.Language = FormatStyle::LK_Cpp; 12245 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 12246 EXPECT_EQ(Style, ParsedStyle); 12247 } 12248 12249 TEST_F(FormatTest, WorksFor8bitEncodings) { 12250 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 12251 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 12252 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 12253 "\"\xef\xee\xf0\xf3...\"", 12254 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 12255 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 12256 "\xef\xee\xf0\xf3...\"", 12257 getLLVMStyleWithColumns(12))); 12258 } 12259 12260 TEST_F(FormatTest, HandlesUTF8BOM) { 12261 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 12262 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 12263 format("\xef\xbb\xbf#include <iostream>")); 12264 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 12265 format("\xef\xbb\xbf\n#include <iostream>")); 12266 } 12267 12268 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 12269 #if !defined(_MSC_VER) 12270 12271 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 12272 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 12273 getLLVMStyleWithColumns(35)); 12274 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 12275 getLLVMStyleWithColumns(31)); 12276 verifyFormat("// Однажды в студёную зимнюю пору...", 12277 getLLVMStyleWithColumns(36)); 12278 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 12279 verifyFormat("/* Однажды в студёную зимнюю пору... */", 12280 getLLVMStyleWithColumns(39)); 12281 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 12282 getLLVMStyleWithColumns(35)); 12283 } 12284 12285 TEST_F(FormatTest, SplitsUTF8Strings) { 12286 // Non-printable characters' width is currently considered to be the length in 12287 // bytes in UTF8. The characters can be displayed in very different manner 12288 // (zero-width, single width with a substitution glyph, expanded to their code 12289 // (e.g. "<8d>"), so there's no single correct way to handle them. 12290 EXPECT_EQ("\"aaaaÄ\"\n" 12291 "\"\xc2\x8d\";", 12292 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 12293 EXPECT_EQ("\"aaaaaaaÄ\"\n" 12294 "\"\xc2\x8d\";", 12295 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 12296 EXPECT_EQ("\"Однажды, в \"\n" 12297 "\"студёную \"\n" 12298 "\"зимнюю \"\n" 12299 "\"пору,\"", 12300 format("\"Однажды, в студёную зимнюю пору,\"", 12301 getLLVMStyleWithColumns(13))); 12302 EXPECT_EQ( 12303 "\"一 二 三 \"\n" 12304 "\"四 五六 \"\n" 12305 "\"七 八 九 \"\n" 12306 "\"十\"", 12307 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 12308 EXPECT_EQ("\"一\t\"\n" 12309 "\"二 \t\"\n" 12310 "\"三 四 \"\n" 12311 "\"五\t\"\n" 12312 "\"六 \t\"\n" 12313 "\"七 \"\n" 12314 "\"八九十\tqq\"", 12315 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 12316 getLLVMStyleWithColumns(11))); 12317 12318 // UTF8 character in an escape sequence. 12319 EXPECT_EQ("\"aaaaaa\"\n" 12320 "\"\\\xC2\x8D\"", 12321 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 12322 } 12323 12324 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 12325 EXPECT_EQ("const char *sssss =\n" 12326 " \"一二三四五六七八\\\n" 12327 " 九 十\";", 12328 format("const char *sssss = \"一二三四五六七八\\\n" 12329 " 九 十\";", 12330 getLLVMStyleWithColumns(30))); 12331 } 12332 12333 TEST_F(FormatTest, SplitsUTF8LineComments) { 12334 EXPECT_EQ("// aaaaÄ\xc2\x8d", 12335 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 12336 EXPECT_EQ("// Я из лесу\n" 12337 "// вышел; был\n" 12338 "// сильный\n" 12339 "// мороз.", 12340 format("// Я из лесу вышел; был сильный мороз.", 12341 getLLVMStyleWithColumns(13))); 12342 EXPECT_EQ("// 一二三\n" 12343 "// 四五六七\n" 12344 "// 八 九\n" 12345 "// 十", 12346 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 12347 } 12348 12349 TEST_F(FormatTest, SplitsUTF8BlockComments) { 12350 EXPECT_EQ("/* Гляжу,\n" 12351 " * поднимается\n" 12352 " * медленно в\n" 12353 " * гору\n" 12354 " * Лошадка,\n" 12355 " * везущая\n" 12356 " * хворосту\n" 12357 " * воз. */", 12358 format("/* Гляжу, поднимается медленно в гору\n" 12359 " * Лошадка, везущая хворосту воз. */", 12360 getLLVMStyleWithColumns(13))); 12361 EXPECT_EQ( 12362 "/* 一二三\n" 12363 " * 四五六七\n" 12364 " * 八 九\n" 12365 " * 十 */", 12366 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 12367 EXPECT_EQ("/* �������� ��������\n" 12368 " * ��������\n" 12369 " * ������-�� */", 12370 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 12371 } 12372 12373 #endif // _MSC_VER 12374 12375 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 12376 FormatStyle Style = getLLVMStyle(); 12377 12378 Style.ConstructorInitializerIndentWidth = 4; 12379 verifyFormat( 12380 "SomeClass::Constructor()\n" 12381 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12382 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12383 Style); 12384 12385 Style.ConstructorInitializerIndentWidth = 2; 12386 verifyFormat( 12387 "SomeClass::Constructor()\n" 12388 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12389 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12390 Style); 12391 12392 Style.ConstructorInitializerIndentWidth = 0; 12393 verifyFormat( 12394 "SomeClass::Constructor()\n" 12395 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12396 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12397 Style); 12398 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 12399 verifyFormat( 12400 "SomeLongTemplateVariableName<\n" 12401 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 12402 Style); 12403 verifyFormat( 12404 "bool smaller = 1 < bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 12405 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 12406 Style); 12407 12408 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 12409 verifyFormat( 12410 "SomeClass::Constructor() :\n" 12411 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 12412 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 12413 Style); 12414 } 12415 12416 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 12417 FormatStyle Style = getLLVMStyle(); 12418 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 12419 Style.ConstructorInitializerIndentWidth = 4; 12420 verifyFormat("SomeClass::Constructor()\n" 12421 " : a(a)\n" 12422 " , b(b)\n" 12423 " , c(c) {}", 12424 Style); 12425 verifyFormat("SomeClass::Constructor()\n" 12426 " : a(a) {}", 12427 Style); 12428 12429 Style.ColumnLimit = 0; 12430 verifyFormat("SomeClass::Constructor()\n" 12431 " : a(a) {}", 12432 Style); 12433 verifyFormat("SomeClass::Constructor() noexcept\n" 12434 " : a(a) {}", 12435 Style); 12436 verifyFormat("SomeClass::Constructor()\n" 12437 " : a(a)\n" 12438 " , b(b)\n" 12439 " , c(c) {}", 12440 Style); 12441 verifyFormat("SomeClass::Constructor()\n" 12442 " : a(a) {\n" 12443 " foo();\n" 12444 " bar();\n" 12445 "}", 12446 Style); 12447 12448 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 12449 verifyFormat("SomeClass::Constructor()\n" 12450 " : a(a)\n" 12451 " , b(b)\n" 12452 " , c(c) {\n}", 12453 Style); 12454 verifyFormat("SomeClass::Constructor()\n" 12455 " : a(a) {\n}", 12456 Style); 12457 12458 Style.ColumnLimit = 80; 12459 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 12460 Style.ConstructorInitializerIndentWidth = 2; 12461 verifyFormat("SomeClass::Constructor()\n" 12462 " : a(a)\n" 12463 " , b(b)\n" 12464 " , c(c) {}", 12465 Style); 12466 12467 Style.ConstructorInitializerIndentWidth = 0; 12468 verifyFormat("SomeClass::Constructor()\n" 12469 ": a(a)\n" 12470 ", b(b)\n" 12471 ", c(c) {}", 12472 Style); 12473 12474 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 12475 Style.ConstructorInitializerIndentWidth = 4; 12476 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 12477 verifyFormat( 12478 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 12479 Style); 12480 verifyFormat( 12481 "SomeClass::Constructor()\n" 12482 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 12483 Style); 12484 Style.ConstructorInitializerIndentWidth = 4; 12485 Style.ColumnLimit = 60; 12486 verifyFormat("SomeClass::Constructor()\n" 12487 " : aaaaaaaa(aaaaaaaa)\n" 12488 " , aaaaaaaa(aaaaaaaa)\n" 12489 " , aaaaaaaa(aaaaaaaa) {}", 12490 Style); 12491 } 12492 12493 TEST_F(FormatTest, Destructors) { 12494 verifyFormat("void F(int &i) { i.~int(); }"); 12495 verifyFormat("void F(int &i) { i->~int(); }"); 12496 } 12497 12498 TEST_F(FormatTest, FormatsWithWebKitStyle) { 12499 FormatStyle Style = getWebKitStyle(); 12500 12501 // Don't indent in outer namespaces. 12502 verifyFormat("namespace outer {\n" 12503 "int i;\n" 12504 "namespace inner {\n" 12505 " int i;\n" 12506 "} // namespace inner\n" 12507 "} // namespace outer\n" 12508 "namespace other_outer {\n" 12509 "int i;\n" 12510 "}", 12511 Style); 12512 12513 // Don't indent case labels. 12514 verifyFormat("switch (variable) {\n" 12515 "case 1:\n" 12516 "case 2:\n" 12517 " doSomething();\n" 12518 " break;\n" 12519 "default:\n" 12520 " ++variable;\n" 12521 "}", 12522 Style); 12523 12524 // Wrap before binary operators. 12525 EXPECT_EQ("void f()\n" 12526 "{\n" 12527 " if (aaaaaaaaaaaaaaaa\n" 12528 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 12529 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 12530 " return;\n" 12531 "}", 12532 format("void f() {\n" 12533 "if (aaaaaaaaaaaaaaaa\n" 12534 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 12535 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 12536 "return;\n" 12537 "}", 12538 Style)); 12539 12540 // Allow functions on a single line. 12541 verifyFormat("void f() { return; }", Style); 12542 12543 // Allow empty blocks on a single line and insert a space in empty blocks. 12544 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 12545 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 12546 // However, don't merge non-empty short loops. 12547 EXPECT_EQ("while (true) {\n" 12548 " continue;\n" 12549 "}", format("while (true) { continue; }", Style)); 12550 12551 // Constructor initializers are formatted one per line with the "," on the 12552 // new line. 12553 verifyFormat("Constructor()\n" 12554 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 12555 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 12556 " aaaaaaaaaaaaaa)\n" 12557 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 12558 "{\n" 12559 "}", 12560 Style); 12561 verifyFormat("SomeClass::Constructor()\n" 12562 " : a(a)\n" 12563 "{\n" 12564 "}", 12565 Style); 12566 EXPECT_EQ("SomeClass::Constructor()\n" 12567 " : a(a)\n" 12568 "{\n" 12569 "}", 12570 format("SomeClass::Constructor():a(a){}", Style)); 12571 verifyFormat("SomeClass::Constructor()\n" 12572 " : a(a)\n" 12573 " , b(b)\n" 12574 " , c(c)\n" 12575 "{\n" 12576 "}", 12577 Style); 12578 verifyFormat("SomeClass::Constructor()\n" 12579 " : a(a)\n" 12580 "{\n" 12581 " foo();\n" 12582 " bar();\n" 12583 "}", 12584 Style); 12585 12586 // Access specifiers should be aligned left. 12587 verifyFormat("class C {\n" 12588 "public:\n" 12589 " int i;\n" 12590 "};", 12591 Style); 12592 12593 // Do not align comments. 12594 verifyFormat("int a; // Do not\n" 12595 "double b; // align comments.", 12596 Style); 12597 12598 // Do not align operands. 12599 EXPECT_EQ("ASSERT(aaaa\n" 12600 " || bbbb);", 12601 format("ASSERT ( aaaa\n||bbbb);", Style)); 12602 12603 // Accept input's line breaks. 12604 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 12605 " || bbbbbbbbbbbbbbb) {\n" 12606 " i++;\n" 12607 "}", 12608 format("if (aaaaaaaaaaaaaaa\n" 12609 "|| bbbbbbbbbbbbbbb) { i++; }", 12610 Style)); 12611 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 12612 " i++;\n" 12613 "}", 12614 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 12615 12616 // Don't automatically break all macro definitions (llvm.org/PR17842). 12617 verifyFormat("#define aNumber 10", Style); 12618 // However, generally keep the line breaks that the user authored. 12619 EXPECT_EQ("#define aNumber \\\n" 12620 " 10", 12621 format("#define aNumber \\\n" 12622 " 10", 12623 Style)); 12624 12625 // Keep empty and one-element array literals on a single line. 12626 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 12627 " copyItems:YES];", 12628 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 12629 "copyItems:YES];", 12630 Style)); 12631 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 12632 " copyItems:YES];", 12633 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 12634 " copyItems:YES];", 12635 Style)); 12636 // FIXME: This does not seem right, there should be more indentation before 12637 // the array literal's entries. Nested blocks have the same problem. 12638 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 12639 " @\"a\",\n" 12640 " @\"a\"\n" 12641 "]\n" 12642 " copyItems:YES];", 12643 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 12644 " @\"a\",\n" 12645 " @\"a\"\n" 12646 " ]\n" 12647 " copyItems:YES];", 12648 Style)); 12649 EXPECT_EQ( 12650 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 12651 " copyItems:YES];", 12652 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 12653 " copyItems:YES];", 12654 Style)); 12655 12656 verifyFormat("[self.a b:c c:d];", Style); 12657 EXPECT_EQ("[self.a b:c\n" 12658 " c:d];", 12659 format("[self.a b:c\n" 12660 "c:d];", 12661 Style)); 12662 } 12663 12664 TEST_F(FormatTest, FormatsLambdas) { 12665 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 12666 verifyFormat( 12667 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 12668 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 12669 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 12670 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 12671 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 12672 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 12673 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 12674 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 12675 verifyFormat("int x = f(*+[] {});"); 12676 verifyFormat("void f() {\n" 12677 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 12678 "}\n"); 12679 verifyFormat("void f() {\n" 12680 " other(x.begin(), //\n" 12681 " x.end(), //\n" 12682 " [&](int, int) { return 1; });\n" 12683 "}\n"); 12684 verifyFormat("void f() {\n" 12685 " other.other.other.other.other(\n" 12686 " x.begin(), x.end(),\n" 12687 " [something, rather](int, int, int, int, int, int, int) { return 1; });\n" 12688 "}\n"); 12689 verifyFormat("void f() {\n" 12690 " other.other.other.other.other(\n" 12691 " x.begin(), x.end(),\n" 12692 " [something, rather](int, int, int, int, int, int, int) {\n" 12693 " //\n" 12694 " });\n" 12695 "}\n"); 12696 verifyFormat("SomeFunction([]() { // A cool function...\n" 12697 " return 43;\n" 12698 "});"); 12699 EXPECT_EQ("SomeFunction([]() {\n" 12700 "#define A a\n" 12701 " return 43;\n" 12702 "});", 12703 format("SomeFunction([](){\n" 12704 "#define A a\n" 12705 "return 43;\n" 12706 "});")); 12707 verifyFormat("void f() {\n" 12708 " SomeFunction([](decltype(x), A *a) {});\n" 12709 "}"); 12710 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 12711 " [](const aaaaaaaaaa &a) { return a; });"); 12712 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 12713 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 12714 "});"); 12715 verifyFormat("Constructor()\n" 12716 " : Field([] { // comment\n" 12717 " int i;\n" 12718 " }) {}"); 12719 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 12720 " return some_parameter.size();\n" 12721 "};"); 12722 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 12723 " [](const string &s) { return s; };"); 12724 verifyFormat("int i = aaaaaa ? 1 //\n" 12725 " : [] {\n" 12726 " return 2; //\n" 12727 " }();"); 12728 verifyFormat("llvm::errs() << \"number of twos is \"\n" 12729 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 12730 " return x == 2; // force break\n" 12731 " });"); 12732 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 12733 " [=](int iiiiiiiiiiii) {\n" 12734 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 12735 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 12736 " });", 12737 getLLVMStyleWithColumns(60)); 12738 verifyFormat("SomeFunction({[&] {\n" 12739 " // comment\n" 12740 " },\n" 12741 " [&] {\n" 12742 " // comment\n" 12743 " }});"); 12744 verifyFormat("SomeFunction({[&] {\n" 12745 " // comment\n" 12746 "}});"); 12747 verifyFormat("virtual aaaaaaaaaaaaaaaa(\n" 12748 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 12749 " aaaaa aaaaaaaaa);"); 12750 12751 // Lambdas with return types. 12752 verifyFormat("int c = []() -> int { return 2; }();\n"); 12753 verifyFormat("int c = []() -> int * { return 2; }();\n"); 12754 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 12755 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 12756 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 12757 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 12758 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 12759 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 12760 verifyFormat("[a, a]() -> a<1> {};"); 12761 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 12762 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 12763 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 12764 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 12765 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 12766 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 12767 verifyFormat("[]() -> foo<!5> { return {}; };"); 12768 verifyFormat("[]() -> foo<~5> { return {}; };"); 12769 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 12770 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 12771 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 12772 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 12773 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 12774 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 12775 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 12776 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 12777 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 12778 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 12779 verifyFormat("namespace bar {\n" 12780 "// broken:\n" 12781 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 12782 "} // namespace bar"); 12783 verifyFormat("namespace bar {\n" 12784 "// broken:\n" 12785 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 12786 "} // namespace bar"); 12787 verifyFormat("namespace bar {\n" 12788 "// broken:\n" 12789 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 12790 "} // namespace bar"); 12791 verifyFormat("namespace bar {\n" 12792 "// broken:\n" 12793 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 12794 "} // namespace bar"); 12795 verifyFormat("namespace bar {\n" 12796 "// broken:\n" 12797 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 12798 "} // namespace bar"); 12799 verifyFormat("namespace bar {\n" 12800 "// broken:\n" 12801 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 12802 "} // namespace bar"); 12803 verifyFormat("namespace bar {\n" 12804 "// broken:\n" 12805 "auto foo{[]() -> foo<!5> { return {}; }};\n" 12806 "} // namespace bar"); 12807 verifyFormat("namespace bar {\n" 12808 "// broken:\n" 12809 "auto foo{[]() -> foo<~5> { return {}; }};\n" 12810 "} // namespace bar"); 12811 verifyFormat("namespace bar {\n" 12812 "// broken:\n" 12813 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 12814 "} // namespace bar"); 12815 verifyFormat("namespace bar {\n" 12816 "// broken:\n" 12817 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 12818 "} // namespace bar"); 12819 verifyFormat("namespace bar {\n" 12820 "// broken:\n" 12821 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 12822 "} // namespace bar"); 12823 verifyFormat("namespace bar {\n" 12824 "// broken:\n" 12825 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 12826 "} // namespace bar"); 12827 verifyFormat("namespace bar {\n" 12828 "// broken:\n" 12829 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 12830 "} // namespace bar"); 12831 verifyFormat("namespace bar {\n" 12832 "// broken:\n" 12833 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 12834 "} // namespace bar"); 12835 verifyFormat("namespace bar {\n" 12836 "// broken:\n" 12837 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 12838 "} // namespace bar"); 12839 verifyFormat("namespace bar {\n" 12840 "// broken:\n" 12841 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 12842 "} // namespace bar"); 12843 verifyFormat("namespace bar {\n" 12844 "// broken:\n" 12845 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 12846 "} // namespace bar"); 12847 verifyFormat("namespace bar {\n" 12848 "// broken:\n" 12849 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 12850 "} // namespace bar"); 12851 verifyFormat("[]() -> a<1> {};"); 12852 verifyFormat("[]() -> a<1> { ; };"); 12853 verifyFormat("[]() -> a<1> { ; }();"); 12854 verifyFormat("[a, a]() -> a<true> {};"); 12855 verifyFormat("[]() -> a<true> {};"); 12856 verifyFormat("[]() -> a<true> { ; };"); 12857 verifyFormat("[]() -> a<true> { ; }();"); 12858 verifyFormat("[a, a]() -> a<false> {};"); 12859 verifyFormat("[]() -> a<false> {};"); 12860 verifyFormat("[]() -> a<false> { ; };"); 12861 verifyFormat("[]() -> a<false> { ; }();"); 12862 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 12863 verifyFormat("namespace bar {\n" 12864 "auto foo{[]() -> foo<false> { ; }};\n" 12865 "} // namespace bar"); 12866 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 12867 " int j) -> int {\n" 12868 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 12869 "};"); 12870 verifyFormat( 12871 "aaaaaaaaaaaaaaaaaaaaaa(\n" 12872 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 12873 " return aaaaaaaaaaaaaaaaa;\n" 12874 " });", 12875 getLLVMStyleWithColumns(70)); 12876 verifyFormat("[]() //\n" 12877 " -> int {\n" 12878 " return 1; //\n" 12879 "};"); 12880 12881 // Multiple lambdas in the same parentheses change indentation rules. These 12882 // lambdas are forced to start on new lines. 12883 verifyFormat("SomeFunction(\n" 12884 " []() {\n" 12885 " //\n" 12886 " },\n" 12887 " []() {\n" 12888 " //\n" 12889 " });"); 12890 12891 // A lambda passed as arg0 is always pushed to the next line. 12892 verifyFormat("SomeFunction(\n" 12893 " [this] {\n" 12894 " //\n" 12895 " },\n" 12896 " 1);\n"); 12897 12898 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like the arg0 12899 // case above. 12900 auto Style = getGoogleStyle(); 12901 Style.BinPackArguments = false; 12902 verifyFormat("SomeFunction(\n" 12903 " a,\n" 12904 " [this] {\n" 12905 " //\n" 12906 " },\n" 12907 " b);\n", 12908 Style); 12909 verifyFormat("SomeFunction(\n" 12910 " a,\n" 12911 " [this] {\n" 12912 " //\n" 12913 " },\n" 12914 " b);\n"); 12915 12916 // A lambda with a very long line forces arg0 to be pushed out irrespective of 12917 // the BinPackArguments value (as long as the code is wide enough). 12918 verifyFormat("something->SomeFunction(\n" 12919 " a,\n" 12920 " [this] {\n" 12921 " D0000000000000000000000000000000000000000000000000000000000001();\n" 12922 " },\n" 12923 " b);\n"); 12924 12925 // A multi-line lambda is pulled up as long as the introducer fits on the previous 12926 // line and there are no further args. 12927 verifyFormat("function(1, [this, that] {\n" 12928 " //\n" 12929 "});\n"); 12930 verifyFormat("function([this, that] {\n" 12931 " //\n" 12932 "});\n"); 12933 // FIXME: this format is not ideal and we should consider forcing the first arg 12934 // onto its own line. 12935 verifyFormat("function(a, b, c, //\n" 12936 " d, [this, that] {\n" 12937 " //\n" 12938 " });\n"); 12939 12940 // Multiple lambdas are treated correctly even when there is a short arg0. 12941 verifyFormat("SomeFunction(\n" 12942 " 1,\n" 12943 " [this] {\n" 12944 " //\n" 12945 " },\n" 12946 " [this] {\n" 12947 " //\n" 12948 " },\n" 12949 " 1);\n"); 12950 12951 // More complex introducers. 12952 verifyFormat("return [i, args...] {};"); 12953 12954 // Not lambdas. 12955 verifyFormat("constexpr char hello[]{\"hello\"};"); 12956 verifyFormat("double &operator[](int i) { return 0; }\n" 12957 "int i;"); 12958 verifyFormat("std::unique_ptr<int[]> foo() {}"); 12959 verifyFormat("int i = a[a][a]->f();"); 12960 verifyFormat("int i = (*b)[a]->f();"); 12961 12962 // Other corner cases. 12963 verifyFormat("void f() {\n" 12964 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 12965 " );\n" 12966 "}"); 12967 12968 // Lambdas created through weird macros. 12969 verifyFormat("void f() {\n" 12970 " MACRO((const AA &a) { return 1; });\n" 12971 " MACRO((AA &a) { return 1; });\n" 12972 "}"); 12973 12974 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 12975 " doo_dah();\n" 12976 " doo_dah();\n" 12977 " })) {\n" 12978 "}"); 12979 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 12980 " doo_dah();\n" 12981 " doo_dah();\n" 12982 " })) {\n" 12983 "}"); 12984 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n" 12985 " doo_dah();\n" 12986 " doo_dah();\n" 12987 " })) {\n" 12988 "}"); 12989 verifyFormat("auto lambda = []() {\n" 12990 " int a = 2\n" 12991 "#if A\n" 12992 " + 2\n" 12993 "#endif\n" 12994 " ;\n" 12995 "};"); 12996 12997 // Lambdas with complex multiline introducers. 12998 verifyFormat( 12999 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13000 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 13001 " -> ::std::unordered_set<\n" 13002 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 13003 " //\n" 13004 " });"); 13005 13006 FormatStyle DoNotMerge = getLLVMStyle(); 13007 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 13008 verifyFormat("auto c = []() {\n" 13009 " return b;\n" 13010 "};", 13011 "auto c = []() { return b; };", DoNotMerge); 13012 verifyFormat("auto c = []() {\n" 13013 "};", 13014 " auto c = []() {};", DoNotMerge); 13015 13016 FormatStyle MergeEmptyOnly = getLLVMStyle(); 13017 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 13018 verifyFormat("auto c = []() {\n" 13019 " return b;\n" 13020 "};", 13021 "auto c = []() {\n" 13022 " return b;\n" 13023 " };", 13024 MergeEmptyOnly); 13025 verifyFormat("auto c = []() {};", 13026 "auto c = []() {\n" 13027 "};", 13028 MergeEmptyOnly); 13029 13030 FormatStyle MergeInline = getLLVMStyle(); 13031 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 13032 verifyFormat("auto c = []() {\n" 13033 " return b;\n" 13034 "};", 13035 "auto c = []() { return b; };", MergeInline); 13036 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 13037 MergeInline); 13038 verifyFormat("function([]() { return b; }, a)", 13039 "function([]() { return b; }, a)", MergeInline); 13040 verifyFormat("function(a, []() { return b; })", 13041 "function(a, []() { return b; })", MergeInline); 13042 } 13043 13044 TEST_F(FormatTest, EmptyLinesInLambdas) { 13045 verifyFormat("auto lambda = []() {\n" 13046 " x(); //\n" 13047 "};", 13048 "auto lambda = []() {\n" 13049 "\n" 13050 " x(); //\n" 13051 "\n" 13052 "};"); 13053 } 13054 13055 TEST_F(FormatTest, FormatsBlocks) { 13056 FormatStyle ShortBlocks = getLLVMStyle(); 13057 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13058 verifyFormat("int (^Block)(int, int);", ShortBlocks); 13059 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 13060 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 13061 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 13062 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 13063 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 13064 13065 verifyFormat("foo(^{ bar(); });", ShortBlocks); 13066 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 13067 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 13068 13069 verifyFormat("[operation setCompletionBlock:^{\n" 13070 " [self onOperationDone];\n" 13071 "}];"); 13072 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 13073 " [self onOperationDone];\n" 13074 "}]};"); 13075 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 13076 " f();\n" 13077 "}];"); 13078 verifyFormat("int a = [operation block:^int(int *i) {\n" 13079 " return 1;\n" 13080 "}];"); 13081 verifyFormat("[myObject doSomethingWith:arg1\n" 13082 " aaa:^int(int *a) {\n" 13083 " return 1;\n" 13084 " }\n" 13085 " bbb:f(a * bbbbbbbb)];"); 13086 13087 verifyFormat("[operation setCompletionBlock:^{\n" 13088 " [self.delegate newDataAvailable];\n" 13089 "}];", 13090 getLLVMStyleWithColumns(60)); 13091 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 13092 " NSString *path = [self sessionFilePath];\n" 13093 " if (path) {\n" 13094 " // ...\n" 13095 " }\n" 13096 "});"); 13097 verifyFormat("[[SessionService sharedService]\n" 13098 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13099 " if (window) {\n" 13100 " [self windowDidLoad:window];\n" 13101 " } else {\n" 13102 " [self errorLoadingWindow];\n" 13103 " }\n" 13104 " }];"); 13105 verifyFormat("void (^largeBlock)(void) = ^{\n" 13106 " // ...\n" 13107 "};\n", 13108 getLLVMStyleWithColumns(40)); 13109 verifyFormat("[[SessionService sharedService]\n" 13110 " loadWindowWithCompletionBlock: //\n" 13111 " ^(SessionWindow *window) {\n" 13112 " if (window) {\n" 13113 " [self windowDidLoad:window];\n" 13114 " } else {\n" 13115 " [self errorLoadingWindow];\n" 13116 " }\n" 13117 " }];", 13118 getLLVMStyleWithColumns(60)); 13119 verifyFormat("[myObject doSomethingWith:arg1\n" 13120 " firstBlock:^(Foo *a) {\n" 13121 " // ...\n" 13122 " int i;\n" 13123 " }\n" 13124 " secondBlock:^(Bar *b) {\n" 13125 " // ...\n" 13126 " int i;\n" 13127 " }\n" 13128 " thirdBlock:^Foo(Bar *b) {\n" 13129 " // ...\n" 13130 " int i;\n" 13131 " }];"); 13132 verifyFormat("[myObject doSomethingWith:arg1\n" 13133 " firstBlock:-1\n" 13134 " secondBlock:^(Bar *b) {\n" 13135 " // ...\n" 13136 " int i;\n" 13137 " }];"); 13138 13139 verifyFormat("f(^{\n" 13140 " @autoreleasepool {\n" 13141 " if (a) {\n" 13142 " g();\n" 13143 " }\n" 13144 " }\n" 13145 "});"); 13146 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 13147 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 13148 "};"); 13149 13150 FormatStyle FourIndent = getLLVMStyle(); 13151 FourIndent.ObjCBlockIndentWidth = 4; 13152 verifyFormat("[operation setCompletionBlock:^{\n" 13153 " [self onOperationDone];\n" 13154 "}];", 13155 FourIndent); 13156 } 13157 13158 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 13159 FormatStyle ZeroColumn = getLLVMStyle(); 13160 ZeroColumn.ColumnLimit = 0; 13161 13162 verifyFormat("[[SessionService sharedService] " 13163 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13164 " if (window) {\n" 13165 " [self windowDidLoad:window];\n" 13166 " } else {\n" 13167 " [self errorLoadingWindow];\n" 13168 " }\n" 13169 "}];", 13170 ZeroColumn); 13171 EXPECT_EQ("[[SessionService sharedService]\n" 13172 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13173 " if (window) {\n" 13174 " [self windowDidLoad:window];\n" 13175 " } else {\n" 13176 " [self errorLoadingWindow];\n" 13177 " }\n" 13178 " }];", 13179 format("[[SessionService sharedService]\n" 13180 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13181 " if (window) {\n" 13182 " [self windowDidLoad:window];\n" 13183 " } else {\n" 13184 " [self errorLoadingWindow];\n" 13185 " }\n" 13186 "}];", 13187 ZeroColumn)); 13188 verifyFormat("[myObject doSomethingWith:arg1\n" 13189 " firstBlock:^(Foo *a) {\n" 13190 " // ...\n" 13191 " int i;\n" 13192 " }\n" 13193 " secondBlock:^(Bar *b) {\n" 13194 " // ...\n" 13195 " int i;\n" 13196 " }\n" 13197 " thirdBlock:^Foo(Bar *b) {\n" 13198 " // ...\n" 13199 " int i;\n" 13200 " }];", 13201 ZeroColumn); 13202 verifyFormat("f(^{\n" 13203 " @autoreleasepool {\n" 13204 " if (a) {\n" 13205 " g();\n" 13206 " }\n" 13207 " }\n" 13208 "});", 13209 ZeroColumn); 13210 verifyFormat("void (^largeBlock)(void) = ^{\n" 13211 " // ...\n" 13212 "};", 13213 ZeroColumn); 13214 13215 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13216 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 13217 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 13218 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 13219 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 13220 " int i;\n" 13221 "};", 13222 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 13223 } 13224 13225 TEST_F(FormatTest, SupportsCRLF) { 13226 EXPECT_EQ("int a;\r\n" 13227 "int b;\r\n" 13228 "int c;\r\n", 13229 format("int a;\r\n" 13230 " int b;\r\n" 13231 " int c;\r\n", 13232 getLLVMStyle())); 13233 EXPECT_EQ("int a;\r\n" 13234 "int b;\r\n" 13235 "int c;\r\n", 13236 format("int a;\r\n" 13237 " int b;\n" 13238 " int c;\r\n", 13239 getLLVMStyle())); 13240 EXPECT_EQ("int a;\n" 13241 "int b;\n" 13242 "int c;\n", 13243 format("int a;\r\n" 13244 " int b;\n" 13245 " int c;\n", 13246 getLLVMStyle())); 13247 EXPECT_EQ("\"aaaaaaa \"\r\n" 13248 "\"bbbbbbb\";\r\n", 13249 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 13250 EXPECT_EQ("#define A \\\r\n" 13251 " b; \\\r\n" 13252 " c; \\\r\n" 13253 " d;\r\n", 13254 format("#define A \\\r\n" 13255 " b; \\\r\n" 13256 " c; d; \r\n", 13257 getGoogleStyle())); 13258 13259 EXPECT_EQ("/*\r\n" 13260 "multi line block comments\r\n" 13261 "should not introduce\r\n" 13262 "an extra carriage return\r\n" 13263 "*/\r\n", 13264 format("/*\r\n" 13265 "multi line block comments\r\n" 13266 "should not introduce\r\n" 13267 "an extra carriage return\r\n" 13268 "*/\r\n")); 13269 EXPECT_EQ("/*\r\n" 13270 "\r\n" 13271 "*/", 13272 format("/*\r\n" 13273 " \r\r\r\n" 13274 "*/")); 13275 } 13276 13277 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 13278 verifyFormat("MY_CLASS(C) {\n" 13279 " int i;\n" 13280 " int j;\n" 13281 "};"); 13282 } 13283 13284 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 13285 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 13286 TwoIndent.ContinuationIndentWidth = 2; 13287 13288 EXPECT_EQ("int i =\n" 13289 " longFunction(\n" 13290 " arg);", 13291 format("int i = longFunction(arg);", TwoIndent)); 13292 13293 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 13294 SixIndent.ContinuationIndentWidth = 6; 13295 13296 EXPECT_EQ("int i =\n" 13297 " longFunction(\n" 13298 " arg);", 13299 format("int i = longFunction(arg);", SixIndent)); 13300 } 13301 13302 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 13303 FormatStyle Style = getLLVMStyle(); 13304 verifyFormat("int Foo::getter(\n" 13305 " //\n" 13306 ") const {\n" 13307 " return foo;\n" 13308 "}", 13309 Style); 13310 verifyFormat("void Foo::setter(\n" 13311 " //\n" 13312 ") {\n" 13313 " foo = 1;\n" 13314 "}", 13315 Style); 13316 } 13317 13318 TEST_F(FormatTest, SpacesInAngles) { 13319 FormatStyle Spaces = getLLVMStyle(); 13320 Spaces.SpacesInAngles = true; 13321 13322 verifyFormat("static_cast< int >(arg);", Spaces); 13323 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 13324 verifyFormat("f< int, float >();", Spaces); 13325 verifyFormat("template <> g() {}", Spaces); 13326 verifyFormat("template < std::vector< int > > f() {}", Spaces); 13327 verifyFormat("std::function< void(int, int) > fct;", Spaces); 13328 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 13329 Spaces); 13330 13331 Spaces.Standard = FormatStyle::LS_Cpp03; 13332 Spaces.SpacesInAngles = true; 13333 verifyFormat("A< A< int > >();", Spaces); 13334 13335 Spaces.SpacesInAngles = false; 13336 verifyFormat("A<A<int> >();", Spaces); 13337 13338 Spaces.Standard = FormatStyle::LS_Cpp11; 13339 Spaces.SpacesInAngles = true; 13340 verifyFormat("A< A< int > >();", Spaces); 13341 13342 Spaces.SpacesInAngles = false; 13343 verifyFormat("A<A<int>>();", Spaces); 13344 } 13345 13346 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 13347 FormatStyle Style = getLLVMStyle(); 13348 Style.SpaceAfterTemplateKeyword = false; 13349 verifyFormat("template<int> void foo();", Style); 13350 } 13351 13352 TEST_F(FormatTest, TripleAngleBrackets) { 13353 verifyFormat("f<<<1, 1>>>();"); 13354 verifyFormat("f<<<1, 1, 1, s>>>();"); 13355 verifyFormat("f<<<a, b, c, d>>>();"); 13356 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 13357 verifyFormat("f<param><<<1, 1>>>();"); 13358 verifyFormat("f<1><<<1, 1>>>();"); 13359 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 13360 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 13361 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 13362 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 13363 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 13364 } 13365 13366 TEST_F(FormatTest, MergeLessLessAtEnd) { 13367 verifyFormat("<<"); 13368 EXPECT_EQ("< < <", format("\\\n<<<")); 13369 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 13370 "aaallvm::outs() <<"); 13371 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 13372 "aaaallvm::outs()\n <<"); 13373 } 13374 13375 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 13376 std::string code = "#if A\n" 13377 "#if B\n" 13378 "a.\n" 13379 "#endif\n" 13380 " a = 1;\n" 13381 "#else\n" 13382 "#endif\n" 13383 "#if C\n" 13384 "#else\n" 13385 "#endif\n"; 13386 EXPECT_EQ(code, format(code)); 13387 } 13388 13389 TEST_F(FormatTest, HandleConflictMarkers) { 13390 // Git/SVN conflict markers. 13391 EXPECT_EQ("int a;\n" 13392 "void f() {\n" 13393 " callme(some(parameter1,\n" 13394 "<<<<<<< text by the vcs\n" 13395 " parameter2),\n" 13396 "||||||| text by the vcs\n" 13397 " parameter2),\n" 13398 " parameter3,\n" 13399 "======= text by the vcs\n" 13400 " parameter2, parameter3),\n" 13401 ">>>>>>> text by the vcs\n" 13402 " otherparameter);\n", 13403 format("int a;\n" 13404 "void f() {\n" 13405 " callme(some(parameter1,\n" 13406 "<<<<<<< text by the vcs\n" 13407 " parameter2),\n" 13408 "||||||| text by the vcs\n" 13409 " parameter2),\n" 13410 " parameter3,\n" 13411 "======= text by the vcs\n" 13412 " parameter2,\n" 13413 " parameter3),\n" 13414 ">>>>>>> text by the vcs\n" 13415 " otherparameter);\n")); 13416 13417 // Perforce markers. 13418 EXPECT_EQ("void f() {\n" 13419 " function(\n" 13420 ">>>> text by the vcs\n" 13421 " parameter,\n" 13422 "==== text by the vcs\n" 13423 " parameter,\n" 13424 "==== text by the vcs\n" 13425 " parameter,\n" 13426 "<<<< text by the vcs\n" 13427 " parameter);\n", 13428 format("void f() {\n" 13429 " function(\n" 13430 ">>>> text by the vcs\n" 13431 " parameter,\n" 13432 "==== text by the vcs\n" 13433 " parameter,\n" 13434 "==== text by the vcs\n" 13435 " parameter,\n" 13436 "<<<< text by the vcs\n" 13437 " parameter);\n")); 13438 13439 EXPECT_EQ("<<<<<<<\n" 13440 "|||||||\n" 13441 "=======\n" 13442 ">>>>>>>", 13443 format("<<<<<<<\n" 13444 "|||||||\n" 13445 "=======\n" 13446 ">>>>>>>")); 13447 13448 EXPECT_EQ("<<<<<<<\n" 13449 "|||||||\n" 13450 "int i;\n" 13451 "=======\n" 13452 ">>>>>>>", 13453 format("<<<<<<<\n" 13454 "|||||||\n" 13455 "int i;\n" 13456 "=======\n" 13457 ">>>>>>>")); 13458 13459 // FIXME: Handle parsing of macros around conflict markers correctly: 13460 EXPECT_EQ("#define Macro \\\n" 13461 "<<<<<<<\n" 13462 "Something \\\n" 13463 "|||||||\n" 13464 "Else \\\n" 13465 "=======\n" 13466 "Other \\\n" 13467 ">>>>>>>\n" 13468 " End int i;\n", 13469 format("#define Macro \\\n" 13470 "<<<<<<<\n" 13471 " Something \\\n" 13472 "|||||||\n" 13473 " Else \\\n" 13474 "=======\n" 13475 " Other \\\n" 13476 ">>>>>>>\n" 13477 " End\n" 13478 "int i;\n")); 13479 } 13480 13481 TEST_F(FormatTest, DisableRegions) { 13482 EXPECT_EQ("int i;\n" 13483 "// clang-format off\n" 13484 " int j;\n" 13485 "// clang-format on\n" 13486 "int k;", 13487 format(" int i;\n" 13488 " // clang-format off\n" 13489 " int j;\n" 13490 " // clang-format on\n" 13491 " int k;")); 13492 EXPECT_EQ("int i;\n" 13493 "/* clang-format off */\n" 13494 " int j;\n" 13495 "/* clang-format on */\n" 13496 "int k;", 13497 format(" int i;\n" 13498 " /* clang-format off */\n" 13499 " int j;\n" 13500 " /* clang-format on */\n" 13501 " int k;")); 13502 13503 // Don't reflow comments within disabled regions. 13504 EXPECT_EQ( 13505 "// clang-format off\n" 13506 "// long long long long long long line\n" 13507 "/* clang-format on */\n" 13508 "/* long long long\n" 13509 " * long long long\n" 13510 " * line */\n" 13511 "int i;\n" 13512 "/* clang-format off */\n" 13513 "/* long long long long long long line */\n", 13514 format("// clang-format off\n" 13515 "// long long long long long long line\n" 13516 "/* clang-format on */\n" 13517 "/* long long long long long long line */\n" 13518 "int i;\n" 13519 "/* clang-format off */\n" 13520 "/* long long long long long long line */\n", 13521 getLLVMStyleWithColumns(20))); 13522 } 13523 13524 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 13525 format("? ) ="); 13526 verifyNoCrash("#define a\\\n /**/}"); 13527 } 13528 13529 TEST_F(FormatTest, FormatsTableGenCode) { 13530 FormatStyle Style = getLLVMStyle(); 13531 Style.Language = FormatStyle::LK_TableGen; 13532 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 13533 } 13534 13535 TEST_F(FormatTest, ArrayOfTemplates) { 13536 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 13537 format("auto a = new unique_ptr<int > [ 10];")); 13538 13539 FormatStyle Spaces = getLLVMStyle(); 13540 Spaces.SpacesInSquareBrackets = true; 13541 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 13542 format("auto a = new unique_ptr<int > [10];", Spaces)); 13543 } 13544 13545 TEST_F(FormatTest, ArrayAsTemplateType) { 13546 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 13547 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 13548 13549 FormatStyle Spaces = getLLVMStyle(); 13550 Spaces.SpacesInSquareBrackets = true; 13551 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 13552 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 13553 } 13554 13555 TEST_F(FormatTest, NoSpaceAfterSuper) { 13556 verifyFormat("__super::FooBar();"); 13557 } 13558 13559 TEST(FormatStyle, GetStyleWithEmptyFileName) { 13560 llvm::vfs::InMemoryFileSystem FS; 13561 auto Style1 = getStyle("file", "", "Google", "", &FS); 13562 ASSERT_TRUE((bool)Style1); 13563 ASSERT_EQ(*Style1, getGoogleStyle()); 13564 } 13565 13566 TEST(FormatStyle, GetStyleOfFile) { 13567 llvm::vfs::InMemoryFileSystem FS; 13568 // Test 1: format file in the same directory. 13569 ASSERT_TRUE( 13570 FS.addFile("/a/.clang-format", 0, 13571 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 13572 ASSERT_TRUE( 13573 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13574 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 13575 ASSERT_TRUE((bool)Style1); 13576 ASSERT_EQ(*Style1, getLLVMStyle()); 13577 13578 // Test 2.1: fallback to default. 13579 ASSERT_TRUE( 13580 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13581 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 13582 ASSERT_TRUE((bool)Style2); 13583 ASSERT_EQ(*Style2, getMozillaStyle()); 13584 13585 // Test 2.2: no format on 'none' fallback style. 13586 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 13587 ASSERT_TRUE((bool)Style2); 13588 ASSERT_EQ(*Style2, getNoStyle()); 13589 13590 // Test 2.3: format if config is found with no based style while fallback is 13591 // 'none'. 13592 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 13593 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 13594 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 13595 ASSERT_TRUE((bool)Style2); 13596 ASSERT_EQ(*Style2, getLLVMStyle()); 13597 13598 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 13599 Style2 = getStyle("{}", "a.h", "none", "", &FS); 13600 ASSERT_TRUE((bool)Style2); 13601 ASSERT_EQ(*Style2, getLLVMStyle()); 13602 13603 // Test 3: format file in parent directory. 13604 ASSERT_TRUE( 13605 FS.addFile("/c/.clang-format", 0, 13606 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 13607 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 13608 llvm::MemoryBuffer::getMemBuffer("int i;"))); 13609 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 13610 ASSERT_TRUE((bool)Style3); 13611 ASSERT_EQ(*Style3, getGoogleStyle()); 13612 13613 // Test 4: error on invalid fallback style 13614 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 13615 ASSERT_FALSE((bool)Style4); 13616 llvm::consumeError(Style4.takeError()); 13617 13618 // Test 5: error on invalid yaml on command line 13619 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 13620 ASSERT_FALSE((bool)Style5); 13621 llvm::consumeError(Style5.takeError()); 13622 13623 // Test 6: error on invalid style 13624 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 13625 ASSERT_FALSE((bool)Style6); 13626 llvm::consumeError(Style6.takeError()); 13627 13628 // Test 7: found config file, error on parsing it 13629 ASSERT_TRUE( 13630 FS.addFile("/d/.clang-format", 0, 13631 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 13632 "InvalidKey: InvalidValue"))); 13633 ASSERT_TRUE( 13634 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13635 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 13636 ASSERT_FALSE((bool)Style7); 13637 llvm::consumeError(Style7.takeError()); 13638 13639 // Test 8: inferred per-language defaults apply. 13640 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 13641 ASSERT_TRUE((bool)StyleTd); 13642 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 13643 } 13644 13645 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 13646 // Column limit is 20. 13647 std::string Code = "Type *a =\n" 13648 " new Type();\n" 13649 "g(iiiii, 0, jjjjj,\n" 13650 " 0, kkkkk, 0, mm);\n" 13651 "int bad = format ;"; 13652 std::string Expected = "auto a = new Type();\n" 13653 "g(iiiii, nullptr,\n" 13654 " jjjjj, nullptr,\n" 13655 " kkkkk, nullptr,\n" 13656 " mm);\n" 13657 "int bad = format ;"; 13658 FileID ID = Context.createInMemoryFile("format.cpp", Code); 13659 tooling::Replacements Replaces = toReplacements( 13660 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 13661 "auto "), 13662 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 13663 "nullptr"), 13664 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 13665 "nullptr"), 13666 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 13667 "nullptr")}); 13668 13669 format::FormatStyle Style = format::getLLVMStyle(); 13670 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 13671 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 13672 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 13673 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 13674 auto Result = applyAllReplacements(Code, *FormattedReplaces); 13675 EXPECT_TRUE(static_cast<bool>(Result)); 13676 EXPECT_EQ(Expected, *Result); 13677 } 13678 13679 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 13680 std::string Code = "#include \"a.h\"\n" 13681 "#include \"c.h\"\n" 13682 "\n" 13683 "int main() {\n" 13684 " return 0;\n" 13685 "}"; 13686 std::string Expected = "#include \"a.h\"\n" 13687 "#include \"b.h\"\n" 13688 "#include \"c.h\"\n" 13689 "\n" 13690 "int main() {\n" 13691 " return 0;\n" 13692 "}"; 13693 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 13694 tooling::Replacements Replaces = toReplacements( 13695 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 13696 "#include \"b.h\"\n")}); 13697 13698 format::FormatStyle Style = format::getLLVMStyle(); 13699 Style.SortIncludes = true; 13700 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 13701 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 13702 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 13703 auto Result = applyAllReplacements(Code, *FormattedReplaces); 13704 EXPECT_TRUE(static_cast<bool>(Result)); 13705 EXPECT_EQ(Expected, *Result); 13706 } 13707 13708 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 13709 EXPECT_EQ("using std::cin;\n" 13710 "using std::cout;", 13711 format("using std::cout;\n" 13712 "using std::cin;", getGoogleStyle())); 13713 } 13714 13715 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 13716 format::FormatStyle Style = format::getLLVMStyle(); 13717 Style.Standard = FormatStyle::LS_Cpp03; 13718 // cpp03 recognize this string as identifier u8 and literal character 'a' 13719 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 13720 } 13721 13722 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 13723 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 13724 // all modes, including C++11, C++14 and C++17 13725 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 13726 } 13727 13728 TEST_F(FormatTest, DoNotFormatLikelyXml) { 13729 EXPECT_EQ("<!-- ;> -->", 13730 format("<!-- ;> -->", getGoogleStyle())); 13731 EXPECT_EQ(" <!-- >; -->", 13732 format(" <!-- >; -->", getGoogleStyle())); 13733 } 13734 13735 TEST_F(FormatTest, StructuredBindings) { 13736 // Structured bindings is a C++17 feature. 13737 // all modes, including C++11, C++14 and C++17 13738 verifyFormat("auto [a, b] = f();"); 13739 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 13740 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 13741 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 13742 EXPECT_EQ("auto const volatile [a, b] = f();", 13743 format("auto const volatile[a, b] = f();")); 13744 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 13745 EXPECT_EQ("auto &[a, b, c] = f();", 13746 format("auto &[ a , b,c ] = f();")); 13747 EXPECT_EQ("auto &&[a, b, c] = f();", 13748 format("auto &&[ a , b,c ] = f();")); 13749 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 13750 EXPECT_EQ("auto const volatile &&[a, b] = f();", 13751 format("auto const volatile &&[a, b] = f();")); 13752 EXPECT_EQ("auto const &&[a, b] = f();", format("auto const && [a, b] = f();")); 13753 EXPECT_EQ("const auto &[a, b] = f();", format("const auto & [a, b] = f();")); 13754 EXPECT_EQ("const auto volatile &&[a, b] = f();", 13755 format("const auto volatile &&[a, b] = f();")); 13756 EXPECT_EQ("volatile const auto &&[a, b] = f();", 13757 format("volatile const auto &&[a, b] = f();")); 13758 EXPECT_EQ("const auto &&[a, b] = f();", format("const auto && [a, b] = f();")); 13759 13760 // Make sure we don't mistake structured bindings for lambdas. 13761 FormatStyle PointerMiddle = getLLVMStyle(); 13762 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 13763 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 13764 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 13765 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 13766 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 13767 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 13768 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 13769 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 13770 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 13771 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 13772 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 13773 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 13774 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 13775 13776 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 13777 format("for (const auto && [a, b] : some_range) {\n}")); 13778 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 13779 format("for (const auto & [a, b] : some_range) {\n}")); 13780 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 13781 format("for (const auto[a, b] : some_range) {\n}")); 13782 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 13783 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 13784 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 13785 EXPECT_EQ("auto const &[x, y](expr);", format("auto const & [x,y] (expr);")); 13786 EXPECT_EQ("auto const &&[x, y](expr);", format("auto const && [x,y] (expr);")); 13787 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 13788 EXPECT_EQ("auto const &[x, y]{expr};", format("auto const & [x,y] {expr};")); 13789 EXPECT_EQ("auto const &&[x, y]{expr};", format("auto const && [x,y] {expr};")); 13790 13791 format::FormatStyle Spaces = format::getLLVMStyle(); 13792 Spaces.SpacesInSquareBrackets = true; 13793 verifyFormat("auto [ a, b ] = f();", Spaces); 13794 verifyFormat("auto &&[ a, b ] = f();", Spaces); 13795 verifyFormat("auto &[ a, b ] = f();", Spaces); 13796 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 13797 verifyFormat("auto const &[ a, b ] = f();", Spaces); 13798 } 13799 13800 TEST_F(FormatTest, FileAndCode) { 13801 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 13802 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 13803 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 13804 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 13805 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@interface Foo\n@end\n")); 13806 EXPECT_EQ( 13807 FormatStyle::LK_ObjC, 13808 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 13809 EXPECT_EQ(FormatStyle::LK_ObjC, 13810 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 13811 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 13812 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 13813 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo", "@interface Foo\n@end\n")); 13814 EXPECT_EQ(FormatStyle::LK_ObjC, 13815 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 13816 EXPECT_EQ( 13817 FormatStyle::LK_ObjC, 13818 guessLanguage("foo.h", 13819 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 13820 EXPECT_EQ( 13821 FormatStyle::LK_Cpp, 13822 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 13823 } 13824 13825 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 13826 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 13827 EXPECT_EQ(FormatStyle::LK_ObjC, 13828 guessLanguage("foo.h", "array[[calculator getIndex]];")); 13829 EXPECT_EQ(FormatStyle::LK_Cpp, 13830 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 13831 EXPECT_EQ( 13832 FormatStyle::LK_Cpp, 13833 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 13834 EXPECT_EQ(FormatStyle::LK_ObjC, 13835 guessLanguage("foo.h", "[[noreturn foo] bar];")); 13836 EXPECT_EQ(FormatStyle::LK_Cpp, 13837 guessLanguage("foo.h", "[[clang::fallthrough]];")); 13838 EXPECT_EQ(FormatStyle::LK_ObjC, 13839 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 13840 EXPECT_EQ(FormatStyle::LK_Cpp, 13841 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 13842 EXPECT_EQ(FormatStyle::LK_Cpp, 13843 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 13844 EXPECT_EQ(FormatStyle::LK_ObjC, 13845 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 13846 EXPECT_EQ(FormatStyle::LK_Cpp, 13847 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 13848 EXPECT_EQ( 13849 FormatStyle::LK_Cpp, 13850 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 13851 EXPECT_EQ( 13852 FormatStyle::LK_Cpp, 13853 guessLanguage("foo.h", 13854 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 13855 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 13856 } 13857 13858 TEST_F(FormatTest, GuessLanguageWithCaret) { 13859 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 13860 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 13861 EXPECT_EQ(FormatStyle::LK_ObjC, 13862 guessLanguage("foo.h", "int(^)(char, float);")); 13863 EXPECT_EQ(FormatStyle::LK_ObjC, 13864 guessLanguage("foo.h", "int(^foo)(char, float);")); 13865 EXPECT_EQ(FormatStyle::LK_ObjC, 13866 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 13867 EXPECT_EQ(FormatStyle::LK_ObjC, 13868 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 13869 EXPECT_EQ( 13870 FormatStyle::LK_ObjC, 13871 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 13872 } 13873 13874 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 13875 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13876 "void f() {\n" 13877 " asm (\"mov %[e], %[d]\"\n" 13878 " : [d] \"=rm\" (d)\n" 13879 " [e] \"rm\" (*e));\n" 13880 "}")); 13881 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13882 "void f() {\n" 13883 " _asm (\"mov %[e], %[d]\"\n" 13884 " : [d] \"=rm\" (d)\n" 13885 " [e] \"rm\" (*e));\n" 13886 "}")); 13887 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13888 "void f() {\n" 13889 " __asm (\"mov %[e], %[d]\"\n" 13890 " : [d] \"=rm\" (d)\n" 13891 " [e] \"rm\" (*e));\n" 13892 "}")); 13893 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13894 "void f() {\n" 13895 " __asm__ (\"mov %[e], %[d]\"\n" 13896 " : [d] \"=rm\" (d)\n" 13897 " [e] \"rm\" (*e));\n" 13898 "}")); 13899 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13900 "void f() {\n" 13901 " asm (\"mov %[e], %[d]\"\n" 13902 " : [d] \"=rm\" (d),\n" 13903 " [e] \"rm\" (*e));\n" 13904 "}")); 13905 EXPECT_EQ(FormatStyle::LK_Cpp, 13906 guessLanguage("foo.h", "void f() {\n" 13907 " asm volatile (\"mov %[e], %[d]\"\n" 13908 " : [d] \"=rm\" (d)\n" 13909 " [e] \"rm\" (*e));\n" 13910 "}")); 13911 } 13912 13913 TEST_F(FormatTest, GuessLanguageWithChildLines) { 13914 EXPECT_EQ(FormatStyle::LK_Cpp, 13915 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 13916 EXPECT_EQ(FormatStyle::LK_ObjC, 13917 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 13918 EXPECT_EQ( 13919 FormatStyle::LK_Cpp, 13920 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 13921 EXPECT_EQ( 13922 FormatStyle::LK_ObjC, 13923 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 13924 } 13925 13926 TEST_F(FormatTest, TypenameMacros) { 13927 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 13928 13929 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 13930 FormatStyle Google = getGoogleStyleWithColumns(0); 13931 Google.TypenameMacros = TypenameMacros; 13932 verifyFormat("struct foo {\n" 13933 " int bar;\n" 13934 " TAILQ_ENTRY(a) bleh;\n" 13935 "};", Google); 13936 13937 FormatStyle Macros = getLLVMStyle(); 13938 Macros.TypenameMacros = TypenameMacros; 13939 13940 verifyFormat("STACK_OF(int) a;", Macros); 13941 verifyFormat("STACK_OF(int) *a;", Macros); 13942 verifyFormat("STACK_OF(int const *) *a;", Macros); 13943 verifyFormat("STACK_OF(int *const) *a;", Macros); 13944 verifyFormat("STACK_OF(int, string) a;", Macros); 13945 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 13946 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 13947 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 13948 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 13949 13950 Macros.PointerAlignment = FormatStyle::PAS_Left; 13951 verifyFormat("STACK_OF(int)* a;", Macros); 13952 verifyFormat("STACK_OF(int*)* a;", Macros); 13953 } 13954 13955 } // end namespace 13956 } // end namespace format 13957 } // end namespace clang 13958