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<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 6622 6623 // template closer followed by a token that starts with > or = 6624 verifyFormat("bool b = a<1> > 1;"); 6625 verifyFormat("bool b = a<1> >= 1;"); 6626 verifyFormat("int i = a<1> >> 1;"); 6627 FormatStyle Style = getLLVMStyle(); 6628 Style.SpaceBeforeAssignmentOperators = false; 6629 verifyFormat("bool b= a<1> == 1;", Style); 6630 verifyFormat("a<int> = 1;", Style); 6631 verifyFormat("a<int> >>= 1;", Style); 6632 6633 verifyFormat("test >> a >> b;"); 6634 verifyFormat("test << a >> b;"); 6635 6636 verifyFormat("f<int>();"); 6637 verifyFormat("template <typename T> void f() {}"); 6638 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 6639 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 6640 "sizeof(char)>::type>;"); 6641 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 6642 verifyFormat("f(a.operator()<A>());"); 6643 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6644 " .template operator()<A>());", 6645 getLLVMStyleWithColumns(35)); 6646 6647 // Not template parameters. 6648 verifyFormat("return a < b && c > d;"); 6649 verifyFormat("void f() {\n" 6650 " while (a < b && c > d) {\n" 6651 " }\n" 6652 "}"); 6653 verifyFormat("template <typename... Types>\n" 6654 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 6655 6656 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6657 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 6658 getLLVMStyleWithColumns(60)); 6659 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 6660 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 6661 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 6662 } 6663 6664 TEST_F(FormatTest, BitshiftOperatorWidth) { 6665 EXPECT_EQ("int a = 1 << 2; /* foo\n" 6666 " bar */", 6667 format("int a=1<<2; /* foo\n" 6668 " bar */")); 6669 6670 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 6671 " bar */", 6672 format("int b =256>>1 ; /* foo\n" 6673 " bar */")); 6674 } 6675 6676 TEST_F(FormatTest, UnderstandsBinaryOperators) { 6677 verifyFormat("COMPARE(a, ==, b);"); 6678 verifyFormat("auto s = sizeof...(Ts) - 1;"); 6679 } 6680 6681 TEST_F(FormatTest, UnderstandsPointersToMembers) { 6682 verifyFormat("int A::*x;"); 6683 verifyFormat("int (S::*func)(void *);"); 6684 verifyFormat("void f() { int (S::*func)(void *); }"); 6685 verifyFormat("typedef bool *(Class::*Member)() const;"); 6686 verifyFormat("void f() {\n" 6687 " (a->*f)();\n" 6688 " a->*x;\n" 6689 " (a.*f)();\n" 6690 " ((*a).*f)();\n" 6691 " a.*x;\n" 6692 "}"); 6693 verifyFormat("void f() {\n" 6694 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 6695 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 6696 "}"); 6697 verifyFormat( 6698 "(aaaaaaaaaa->*bbbbbbb)(\n" 6699 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6700 FormatStyle Style = getLLVMStyle(); 6701 Style.PointerAlignment = FormatStyle::PAS_Left; 6702 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 6703 } 6704 6705 TEST_F(FormatTest, UnderstandsUnaryOperators) { 6706 verifyFormat("int a = -2;"); 6707 verifyFormat("f(-1, -2, -3);"); 6708 verifyFormat("a[-1] = 5;"); 6709 verifyFormat("int a = 5 + -2;"); 6710 verifyFormat("if (i == -1) {\n}"); 6711 verifyFormat("if (i != -1) {\n}"); 6712 verifyFormat("if (i > -1) {\n}"); 6713 verifyFormat("if (i < -1) {\n}"); 6714 verifyFormat("++(a->f());"); 6715 verifyFormat("--(a->f());"); 6716 verifyFormat("(a->f())++;"); 6717 verifyFormat("a[42]++;"); 6718 verifyFormat("if (!(a->f())) {\n}"); 6719 verifyFormat("if (!+i) {\n}"); 6720 verifyFormat("~&a;"); 6721 6722 verifyFormat("a-- > b;"); 6723 verifyFormat("b ? -a : c;"); 6724 verifyFormat("n * sizeof char16;"); 6725 verifyFormat("n * alignof char16;", getGoogleStyle()); 6726 verifyFormat("sizeof(char);"); 6727 verifyFormat("alignof(char);", getGoogleStyle()); 6728 6729 verifyFormat("return -1;"); 6730 verifyFormat("switch (a) {\n" 6731 "case -1:\n" 6732 " break;\n" 6733 "}"); 6734 verifyFormat("#define X -1"); 6735 verifyFormat("#define X -kConstant"); 6736 6737 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 6738 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 6739 6740 verifyFormat("int a = /* confusing comment */ -1;"); 6741 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 6742 verifyFormat("int a = i /* confusing comment */++;"); 6743 } 6744 6745 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 6746 verifyFormat("if (!aaaaaaaaaa( // break\n" 6747 " aaaaa)) {\n" 6748 "}"); 6749 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 6750 " aaaaa));"); 6751 verifyFormat("*aaa = aaaaaaa( // break\n" 6752 " bbbbbb);"); 6753 } 6754 6755 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 6756 verifyFormat("bool operator<();"); 6757 verifyFormat("bool operator>();"); 6758 verifyFormat("bool operator=();"); 6759 verifyFormat("bool operator==();"); 6760 verifyFormat("bool operator!=();"); 6761 verifyFormat("int operator+();"); 6762 verifyFormat("int operator++();"); 6763 verifyFormat("int operator++(int) volatile noexcept;"); 6764 verifyFormat("bool operator,();"); 6765 verifyFormat("bool operator();"); 6766 verifyFormat("bool operator()();"); 6767 verifyFormat("bool operator[]();"); 6768 verifyFormat("operator bool();"); 6769 verifyFormat("operator int();"); 6770 verifyFormat("operator void *();"); 6771 verifyFormat("operator SomeType<int>();"); 6772 verifyFormat("operator SomeType<int, int>();"); 6773 verifyFormat("operator SomeType<SomeType<int>>();"); 6774 verifyFormat("void *operator new(std::size_t size);"); 6775 verifyFormat("void *operator new[](std::size_t size);"); 6776 verifyFormat("void operator delete(void *ptr);"); 6777 verifyFormat("void operator delete[](void *ptr);"); 6778 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 6779 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 6780 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 6781 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 6782 6783 verifyFormat( 6784 "ostream &operator<<(ostream &OutputStream,\n" 6785 " SomeReallyLongType WithSomeReallyLongValue);"); 6786 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 6787 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 6788 " return left.group < right.group;\n" 6789 "}"); 6790 verifyFormat("SomeType &operator=(const SomeType &S);"); 6791 verifyFormat("f.template operator()<int>();"); 6792 6793 verifyGoogleFormat("operator void*();"); 6794 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 6795 verifyGoogleFormat("operator ::A();"); 6796 6797 verifyFormat("using A::operator+;"); 6798 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 6799 "int i;"); 6800 } 6801 6802 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 6803 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 6804 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 6805 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 6806 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 6807 verifyFormat("Deleted &operator=(const Deleted &) &;"); 6808 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 6809 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 6810 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 6811 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 6812 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 6813 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 6814 verifyFormat("void Fn(T const &) const &;"); 6815 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 6816 verifyFormat("template <typename T>\n" 6817 "void F(T) && = delete;", 6818 getGoogleStyle()); 6819 6820 FormatStyle AlignLeft = getLLVMStyle(); 6821 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 6822 verifyFormat("void A::b() && {}", AlignLeft); 6823 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 6824 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 6825 AlignLeft); 6826 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 6827 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 6828 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 6829 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 6830 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 6831 verifyFormat("auto Function(T) & -> void;", AlignLeft); 6832 verifyFormat("void Fn(T const&) const&;", AlignLeft); 6833 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 6834 6835 FormatStyle Spaces = getLLVMStyle(); 6836 Spaces.SpacesInCStyleCastParentheses = true; 6837 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 6838 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 6839 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 6840 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 6841 6842 Spaces.SpacesInCStyleCastParentheses = false; 6843 Spaces.SpacesInParentheses = true; 6844 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 6845 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", Spaces); 6846 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 6847 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 6848 } 6849 6850 TEST_F(FormatTest, UnderstandsNewAndDelete) { 6851 verifyFormat("void f() {\n" 6852 " A *a = new A;\n" 6853 " A *a = new (placement) A;\n" 6854 " delete a;\n" 6855 " delete (A *)a;\n" 6856 "}"); 6857 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 6858 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 6859 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6860 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 6861 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 6862 verifyFormat("delete[] h->p;"); 6863 } 6864 6865 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 6866 verifyFormat("int *f(int *a) {}"); 6867 verifyFormat("int main(int argc, char **argv) {}"); 6868 verifyFormat("Test::Test(int b) : a(b * b) {}"); 6869 verifyIndependentOfContext("f(a, *a);"); 6870 verifyFormat("void g() { f(*a); }"); 6871 verifyIndependentOfContext("int a = b * 10;"); 6872 verifyIndependentOfContext("int a = 10 * b;"); 6873 verifyIndependentOfContext("int a = b * c;"); 6874 verifyIndependentOfContext("int a += b * c;"); 6875 verifyIndependentOfContext("int a -= b * c;"); 6876 verifyIndependentOfContext("int a *= b * c;"); 6877 verifyIndependentOfContext("int a /= b * c;"); 6878 verifyIndependentOfContext("int a = *b;"); 6879 verifyIndependentOfContext("int a = *b * c;"); 6880 verifyIndependentOfContext("int a = b * *c;"); 6881 verifyIndependentOfContext("int a = b * (10);"); 6882 verifyIndependentOfContext("S << b * (10);"); 6883 verifyIndependentOfContext("return 10 * b;"); 6884 verifyIndependentOfContext("return *b * *c;"); 6885 verifyIndependentOfContext("return a & ~b;"); 6886 verifyIndependentOfContext("f(b ? *c : *d);"); 6887 verifyIndependentOfContext("int a = b ? *c : *d;"); 6888 verifyIndependentOfContext("*b = a;"); 6889 verifyIndependentOfContext("a * ~b;"); 6890 verifyIndependentOfContext("a * !b;"); 6891 verifyIndependentOfContext("a * +b;"); 6892 verifyIndependentOfContext("a * -b;"); 6893 verifyIndependentOfContext("a * ++b;"); 6894 verifyIndependentOfContext("a * --b;"); 6895 verifyIndependentOfContext("a[4] * b;"); 6896 verifyIndependentOfContext("a[a * a] = 1;"); 6897 verifyIndependentOfContext("f() * b;"); 6898 verifyIndependentOfContext("a * [self dostuff];"); 6899 verifyIndependentOfContext("int x = a * (a + b);"); 6900 verifyIndependentOfContext("(a *)(a + b);"); 6901 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 6902 verifyIndependentOfContext("int *pa = (int *)&a;"); 6903 verifyIndependentOfContext("return sizeof(int **);"); 6904 verifyIndependentOfContext("return sizeof(int ******);"); 6905 verifyIndependentOfContext("return (int **&)a;"); 6906 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 6907 verifyFormat("void f(Type (*parameter)[10]) {}"); 6908 verifyFormat("void f(Type (¶meter)[10]) {}"); 6909 verifyGoogleFormat("return sizeof(int**);"); 6910 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 6911 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 6912 verifyFormat("auto a = [](int **&, int ***) {};"); 6913 verifyFormat("auto PointerBinding = [](const char *S) {};"); 6914 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 6915 verifyFormat("[](const decltype(*a) &value) {}"); 6916 verifyFormat("decltype(a * b) F();"); 6917 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 6918 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 6919 verifyIndependentOfContext("typedef void (*f)(int *a);"); 6920 verifyIndependentOfContext("int i{a * b};"); 6921 verifyIndependentOfContext("aaa && aaa->f();"); 6922 verifyIndependentOfContext("int x = ~*p;"); 6923 verifyFormat("Constructor() : a(a), area(width * height) {}"); 6924 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 6925 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 6926 verifyFormat("void f() { f(a, c * d); }"); 6927 verifyFormat("void f() { f(new a(), c * d); }"); 6928 verifyFormat("void f(const MyOverride &override);"); 6929 verifyFormat("void f(const MyFinal &final);"); 6930 verifyIndependentOfContext("bool a = f() && override.f();"); 6931 verifyIndependentOfContext("bool a = f() && final.f();"); 6932 6933 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 6934 6935 verifyIndependentOfContext("A<int *> a;"); 6936 verifyIndependentOfContext("A<int **> a;"); 6937 verifyIndependentOfContext("A<int *, int *> a;"); 6938 verifyIndependentOfContext("A<int *[]> a;"); 6939 verifyIndependentOfContext( 6940 "const char *const p = reinterpret_cast<const char *const>(q);"); 6941 verifyIndependentOfContext("A<int **, int **> a;"); 6942 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 6943 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 6944 verifyFormat("for (; a && b;) {\n}"); 6945 verifyFormat("bool foo = true && [] { return false; }();"); 6946 6947 verifyFormat( 6948 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6949 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6950 6951 verifyGoogleFormat("int const* a = &b;"); 6952 verifyGoogleFormat("**outparam = 1;"); 6953 verifyGoogleFormat("*outparam = a * b;"); 6954 verifyGoogleFormat("int main(int argc, char** argv) {}"); 6955 verifyGoogleFormat("A<int*> a;"); 6956 verifyGoogleFormat("A<int**> a;"); 6957 verifyGoogleFormat("A<int*, int*> a;"); 6958 verifyGoogleFormat("A<int**, int**> a;"); 6959 verifyGoogleFormat("f(b ? *c : *d);"); 6960 verifyGoogleFormat("int a = b ? *c : *d;"); 6961 verifyGoogleFormat("Type* t = **x;"); 6962 verifyGoogleFormat("Type* t = *++*x;"); 6963 verifyGoogleFormat("*++*x;"); 6964 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 6965 verifyGoogleFormat("Type* t = x++ * y;"); 6966 verifyGoogleFormat( 6967 "const char* const p = reinterpret_cast<const char* const>(q);"); 6968 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 6969 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 6970 verifyGoogleFormat("template <typename T>\n" 6971 "void f(int i = 0, SomeType** temps = NULL);"); 6972 6973 FormatStyle Left = getLLVMStyle(); 6974 Left.PointerAlignment = FormatStyle::PAS_Left; 6975 verifyFormat("x = *a(x) = *a(y);", Left); 6976 verifyFormat("for (;; *a = b) {\n}", Left); 6977 verifyFormat("return *this += 1;", Left); 6978 verifyFormat("throw *x;", Left); 6979 verifyFormat("delete *x;", Left); 6980 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 6981 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 6982 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 6983 6984 verifyIndependentOfContext("a = *(x + y);"); 6985 verifyIndependentOfContext("a = &(x + y);"); 6986 verifyIndependentOfContext("*(x + y).call();"); 6987 verifyIndependentOfContext("&(x + y)->call();"); 6988 verifyFormat("void f() { &(*I).first; }"); 6989 6990 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 6991 verifyFormat( 6992 "int *MyValues = {\n" 6993 " *A, // Operator detection might be confused by the '{'\n" 6994 " *BB // Operator detection might be confused by previous comment\n" 6995 "};"); 6996 6997 verifyIndependentOfContext("if (int *a = &b)"); 6998 verifyIndependentOfContext("if (int &a = *b)"); 6999 verifyIndependentOfContext("if (a & b[i])"); 7000 verifyIndependentOfContext("if constexpr (a & b[i])"); 7001 verifyIndependentOfContext("if CONSTEXPR (a & b[i])"); 7002 verifyIndependentOfContext("if (a * (b * c))"); 7003 verifyIndependentOfContext("if constexpr (a * (b * c))"); 7004 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))"); 7005 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 7006 verifyIndependentOfContext("if (*b[i])"); 7007 verifyIndependentOfContext("if (int *a = (&b))"); 7008 verifyIndependentOfContext("while (int *a = &b)"); 7009 verifyIndependentOfContext("while (a * (b * c))"); 7010 verifyIndependentOfContext("size = sizeof *a;"); 7011 verifyIndependentOfContext("if (a && (b = c))"); 7012 verifyFormat("void f() {\n" 7013 " for (const int &v : Values) {\n" 7014 " }\n" 7015 "}"); 7016 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 7017 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 7018 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 7019 7020 verifyFormat("#define A (!a * b)"); 7021 verifyFormat("#define MACRO \\\n" 7022 " int *i = a * b; \\\n" 7023 " void f(a *b);", 7024 getLLVMStyleWithColumns(19)); 7025 7026 verifyIndependentOfContext("A = new SomeType *[Length];"); 7027 verifyIndependentOfContext("A = new SomeType *[Length]();"); 7028 verifyIndependentOfContext("T **t = new T *;"); 7029 verifyIndependentOfContext("T **t = new T *();"); 7030 verifyGoogleFormat("A = new SomeType*[Length]();"); 7031 verifyGoogleFormat("A = new SomeType*[Length];"); 7032 verifyGoogleFormat("T** t = new T*;"); 7033 verifyGoogleFormat("T** t = new T*();"); 7034 7035 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 7036 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 7037 verifyFormat("template <bool a, bool b> " 7038 "typename t::if<x && y>::type f() {}"); 7039 verifyFormat("template <int *y> f() {}"); 7040 verifyFormat("vector<int *> v;"); 7041 verifyFormat("vector<int *const> v;"); 7042 verifyFormat("vector<int *const **const *> v;"); 7043 verifyFormat("vector<int *volatile> v;"); 7044 verifyFormat("vector<a * b> v;"); 7045 verifyFormat("foo<b && false>();"); 7046 verifyFormat("foo<b & 1>();"); 7047 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 7048 verifyFormat( 7049 "template <class T, class = typename std::enable_if<\n" 7050 " std::is_integral<T>::value &&\n" 7051 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 7052 "void F();", 7053 getLLVMStyleWithColumns(70)); 7054 verifyFormat( 7055 "template <class T,\n" 7056 " class = typename std::enable_if<\n" 7057 " std::is_integral<T>::value &&\n" 7058 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 7059 " class U>\n" 7060 "void F();", 7061 getLLVMStyleWithColumns(70)); 7062 verifyFormat( 7063 "template <class T,\n" 7064 " class = typename ::std::enable_if<\n" 7065 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 7066 "void F();", 7067 getGoogleStyleWithColumns(68)); 7068 7069 verifyIndependentOfContext("MACRO(int *i);"); 7070 verifyIndependentOfContext("MACRO(auto *a);"); 7071 verifyIndependentOfContext("MACRO(const A *a);"); 7072 verifyIndependentOfContext("MACRO(A *const a);"); 7073 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 7074 verifyFormat("void f() { f(float{1}, a * a); }"); 7075 // FIXME: Is there a way to make this work? 7076 // verifyIndependentOfContext("MACRO(A *a);"); 7077 7078 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 7079 verifyFormat("return options != nullptr && operator==(*options);"); 7080 7081 EXPECT_EQ("#define OP(x) \\\n" 7082 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7083 " return s << a.DebugString(); \\\n" 7084 " }", 7085 format("#define OP(x) \\\n" 7086 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7087 " return s << a.DebugString(); \\\n" 7088 " }", 7089 getLLVMStyleWithColumns(50))); 7090 7091 // FIXME: We cannot handle this case yet; we might be able to figure out that 7092 // foo<x> d > v; doesn't make sense. 7093 verifyFormat("foo<a<b && c> d> v;"); 7094 7095 FormatStyle PointerMiddle = getLLVMStyle(); 7096 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7097 verifyFormat("delete *x;", PointerMiddle); 7098 verifyFormat("int * x;", PointerMiddle); 7099 verifyFormat("int *[] x;", PointerMiddle); 7100 verifyFormat("template <int * y> f() {}", PointerMiddle); 7101 verifyFormat("int * f(int * a) {}", PointerMiddle); 7102 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7103 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7104 verifyFormat("A<int *> a;", PointerMiddle); 7105 verifyFormat("A<int **> a;", PointerMiddle); 7106 verifyFormat("A<int *, int *> a;", PointerMiddle); 7107 verifyFormat("A<int *[]> a;", PointerMiddle); 7108 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7109 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7110 verifyFormat("T ** t = new T *;", PointerMiddle); 7111 7112 // Member function reference qualifiers aren't binary operators. 7113 verifyFormat("string // break\n" 7114 "operator()() & {}"); 7115 verifyFormat("string // break\n" 7116 "operator()() && {}"); 7117 verifyGoogleFormat("template <typename T>\n" 7118 "auto x() & -> int {}"); 7119 } 7120 7121 TEST_F(FormatTest, UnderstandsAttributes) { 7122 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7123 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7124 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7125 FormatStyle AfterType = getLLVMStyle(); 7126 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7127 verifyFormat("__attribute__((nodebug)) void\n" 7128 "foo() {}\n", 7129 AfterType); 7130 } 7131 7132 TEST_F(FormatTest, UnderstandsSquareAttributes) { 7133 verifyFormat("SomeType s [[unused]] (InitValue);"); 7134 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 7135 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 7136 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 7137 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 7138 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7139 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7140 7141 // Make sure we do not mistake attributes for array subscripts. 7142 verifyFormat("int a() {}\n" 7143 "[[unused]] int b() {}\n"); 7144 verifyFormat("NSArray *arr;\n" 7145 "arr[[Foo() bar]];"); 7146 7147 // On the other hand, we still need to correctly find array subscripts. 7148 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 7149 7150 // Make sure that we do not mistake Objective-C method inside array literals 7151 // as attributes, even if those method names are also keywords. 7152 verifyFormat("@[ [foo bar] ];"); 7153 verifyFormat("@[ [NSArray class] ];"); 7154 verifyFormat("@[ [foo enum] ];"); 7155 7156 // Make sure we do not parse attributes as lambda introducers. 7157 FormatStyle MultiLineFunctions = getLLVMStyle(); 7158 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7159 verifyFormat("[[unused]] int b() {\n" 7160 " return 42;\n" 7161 "}\n", 7162 MultiLineFunctions); 7163 } 7164 7165 TEST_F(FormatTest, UnderstandsEllipsis) { 7166 verifyFormat("int printf(const char *fmt, ...);"); 7167 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 7168 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 7169 7170 FormatStyle PointersLeft = getLLVMStyle(); 7171 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 7172 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 7173 } 7174 7175 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 7176 EXPECT_EQ("int *a;\n" 7177 "int *a;\n" 7178 "int *a;", 7179 format("int *a;\n" 7180 "int* a;\n" 7181 "int *a;", 7182 getGoogleStyle())); 7183 EXPECT_EQ("int* a;\n" 7184 "int* a;\n" 7185 "int* a;", 7186 format("int* a;\n" 7187 "int* a;\n" 7188 "int *a;", 7189 getGoogleStyle())); 7190 EXPECT_EQ("int *a;\n" 7191 "int *a;\n" 7192 "int *a;", 7193 format("int *a;\n" 7194 "int * a;\n" 7195 "int * a;", 7196 getGoogleStyle())); 7197 EXPECT_EQ("auto x = [] {\n" 7198 " int *a;\n" 7199 " int *a;\n" 7200 " int *a;\n" 7201 "};", 7202 format("auto x=[]{int *a;\n" 7203 "int * a;\n" 7204 "int * a;};", 7205 getGoogleStyle())); 7206 } 7207 7208 TEST_F(FormatTest, UnderstandsRvalueReferences) { 7209 verifyFormat("int f(int &&a) {}"); 7210 verifyFormat("int f(int a, char &&b) {}"); 7211 verifyFormat("void f() { int &&a = b; }"); 7212 verifyGoogleFormat("int f(int a, char&& b) {}"); 7213 verifyGoogleFormat("void f() { int&& a = b; }"); 7214 7215 verifyIndependentOfContext("A<int &&> a;"); 7216 verifyIndependentOfContext("A<int &&, int &&> a;"); 7217 verifyGoogleFormat("A<int&&> a;"); 7218 verifyGoogleFormat("A<int&&, int&&> a;"); 7219 7220 // Not rvalue references: 7221 verifyFormat("template <bool B, bool C> class A {\n" 7222 " static_assert(B && C, \"Something is wrong\");\n" 7223 "};"); 7224 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 7225 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 7226 verifyFormat("#define A(a, b) (a && b)"); 7227 } 7228 7229 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 7230 verifyFormat("void f() {\n" 7231 " x[aaaaaaaaa -\n" 7232 " b] = 23;\n" 7233 "}", 7234 getLLVMStyleWithColumns(15)); 7235 } 7236 7237 TEST_F(FormatTest, FormatsCasts) { 7238 verifyFormat("Type *A = static_cast<Type *>(P);"); 7239 verifyFormat("Type *A = (Type *)P;"); 7240 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7241 verifyFormat("int a = (int)(2.0f);"); 7242 verifyFormat("int a = (int)2.0f;"); 7243 verifyFormat("x[(int32)y];"); 7244 verifyFormat("x = (int32)y;"); 7245 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7246 verifyFormat("int a = (int)*b;"); 7247 verifyFormat("int a = (int)2.0f;"); 7248 verifyFormat("int a = (int)~0;"); 7249 verifyFormat("int a = (int)++a;"); 7250 verifyFormat("int a = (int)sizeof(int);"); 7251 verifyFormat("int a = (int)+2;"); 7252 verifyFormat("my_int a = (my_int)2.0f;"); 7253 verifyFormat("my_int a = (my_int)sizeof(int);"); 7254 verifyFormat("return (my_int)aaa;"); 7255 verifyFormat("#define x ((int)-1)"); 7256 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7257 verifyFormat("#define p(q) ((int *)&q)"); 7258 verifyFormat("fn(a)(b) + 1;"); 7259 7260 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7261 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7262 verifyFormat("my_int a = (my_int)~0;"); 7263 verifyFormat("my_int a = (my_int)++a;"); 7264 verifyFormat("my_int a = (my_int)-2;"); 7265 verifyFormat("my_int a = (my_int)1;"); 7266 verifyFormat("my_int a = (my_int *)1;"); 7267 verifyFormat("my_int a = (const my_int)-1;"); 7268 verifyFormat("my_int a = (const my_int *)-1;"); 7269 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7270 verifyFormat("my_int a = (ns::my_int)-2;"); 7271 verifyFormat("case (my_int)ONE:"); 7272 verifyFormat("auto x = (X)this;"); 7273 7274 // FIXME: single value wrapped with paren will be treated as cast. 7275 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7276 7277 verifyFormat("{ (void)F; }"); 7278 7279 // Don't break after a cast's 7280 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7281 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7282 " bbbbbbbbbbbbbbbbbbbbbb);"); 7283 7284 // These are not casts. 7285 verifyFormat("void f(int *) {}"); 7286 verifyFormat("f(foo)->b;"); 7287 verifyFormat("f(foo).b;"); 7288 verifyFormat("f(foo)(b);"); 7289 verifyFormat("f(foo)[b];"); 7290 verifyFormat("[](foo) { return 4; }(bar);"); 7291 verifyFormat("(*funptr)(foo)[4];"); 7292 verifyFormat("funptrs[4](foo)[4];"); 7293 verifyFormat("void f(int *);"); 7294 verifyFormat("void f(int *) = 0;"); 7295 verifyFormat("void f(SmallVector<int>) {}"); 7296 verifyFormat("void f(SmallVector<int>);"); 7297 verifyFormat("void f(SmallVector<int>) = 0;"); 7298 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7299 verifyFormat("int a = sizeof(int) * b;"); 7300 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7301 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7302 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7303 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7304 7305 // These are not casts, but at some point were confused with casts. 7306 verifyFormat("virtual void foo(int *) override;"); 7307 verifyFormat("virtual void foo(char &) const;"); 7308 verifyFormat("virtual void foo(int *a, char *) const;"); 7309 verifyFormat("int a = sizeof(int *) + b;"); 7310 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7311 verifyFormat("bool b = f(g<int>) && c;"); 7312 verifyFormat("typedef void (*f)(int i) func;"); 7313 7314 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7315 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7316 // FIXME: The indentation here is not ideal. 7317 verifyFormat( 7318 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7319 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7320 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7321 } 7322 7323 TEST_F(FormatTest, FormatsFunctionTypes) { 7324 verifyFormat("A<bool()> a;"); 7325 verifyFormat("A<SomeType()> a;"); 7326 verifyFormat("A<void (*)(int, std::string)> a;"); 7327 verifyFormat("A<void *(int)>;"); 7328 verifyFormat("void *(*a)(int *, SomeType *);"); 7329 verifyFormat("int (*func)(void *);"); 7330 verifyFormat("void f() { int (*func)(void *); }"); 7331 verifyFormat("template <class CallbackClass>\n" 7332 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7333 7334 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7335 verifyGoogleFormat("void* (*a)(int);"); 7336 verifyGoogleFormat( 7337 "template <class CallbackClass>\n" 7338 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7339 7340 // Other constructs can look somewhat like function types: 7341 verifyFormat("A<sizeof(*x)> a;"); 7342 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7343 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7344 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7345 verifyFormat("int x = f(&h)();"); 7346 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7347 verifyFormat("std::function<\n" 7348 " LooooooooooongTemplatedType<\n" 7349 " SomeType>*(\n" 7350 " LooooooooooooooooongType type)>\n" 7351 " function;", 7352 getGoogleStyleWithColumns(40)); 7353 } 7354 7355 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7356 verifyFormat("A (*foo_)[6];"); 7357 verifyFormat("vector<int> (*foo_)[6];"); 7358 } 7359 7360 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7361 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7362 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7363 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7364 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7365 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7366 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7367 7368 // Different ways of ()-initializiation. 7369 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7370 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7371 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7372 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7373 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7374 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7375 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7376 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7377 7378 // Lambdas should not confuse the variable declaration heuristic. 7379 verifyFormat("LooooooooooooooooongType\n" 7380 " variable(nullptr, [](A *a) {});", 7381 getLLVMStyleWithColumns(40)); 7382 } 7383 7384 TEST_F(FormatTest, BreaksLongDeclarations) { 7385 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7386 " AnotherNameForTheLongType;"); 7387 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7388 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7389 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7390 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7391 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7392 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7393 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7394 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7395 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7396 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7397 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7398 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7399 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7400 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7401 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7402 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7403 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7404 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7405 FormatStyle Indented = getLLVMStyle(); 7406 Indented.IndentWrappedFunctionNames = true; 7407 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7408 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7409 Indented); 7410 verifyFormat( 7411 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7412 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7413 Indented); 7414 verifyFormat( 7415 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7416 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7417 Indented); 7418 verifyFormat( 7419 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7420 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7421 Indented); 7422 7423 // FIXME: Without the comment, this breaks after "(". 7424 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7425 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7426 getGoogleStyle()); 7427 7428 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7429 " int LoooooooooooooooooooongParam2) {}"); 7430 verifyFormat( 7431 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7432 " SourceLocation L, IdentifierIn *II,\n" 7433 " Type *T) {}"); 7434 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7435 "ReallyReaaallyLongFunctionName(\n" 7436 " const std::string &SomeParameter,\n" 7437 " const SomeType<string, SomeOtherTemplateParameter>\n" 7438 " &ReallyReallyLongParameterName,\n" 7439 " const SomeType<string, SomeOtherTemplateParameter>\n" 7440 " &AnotherLongParameterName) {}"); 7441 verifyFormat("template <typename A>\n" 7442 "SomeLoooooooooooooooooooooongType<\n" 7443 " typename some_namespace::SomeOtherType<A>::Type>\n" 7444 "Function() {}"); 7445 7446 verifyGoogleFormat( 7447 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7448 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7449 verifyGoogleFormat( 7450 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7451 " SourceLocation L) {}"); 7452 verifyGoogleFormat( 7453 "some_namespace::LongReturnType\n" 7454 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7455 " int first_long_parameter, int second_parameter) {}"); 7456 7457 verifyGoogleFormat("template <typename T>\n" 7458 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7459 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7460 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7461 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7462 7463 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7464 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7465 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7466 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7467 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7468 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 7469 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7470 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 7471 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 7472 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7473 7474 verifyFormat("template <typename T> // Templates on own line.\n" 7475 "static int // Some comment.\n" 7476 "MyFunction(int a);", 7477 getLLVMStyle()); 7478 } 7479 7480 TEST_F(FormatTest, FormatsArrays) { 7481 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7482 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 7483 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 7484 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 7485 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 7486 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 7487 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7488 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7489 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7490 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 7491 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7492 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7493 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7494 verifyFormat( 7495 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 7496 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7497 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 7498 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 7499 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7500 7501 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 7502 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 7503 verifyFormat( 7504 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 7505 " .aaaaaaa[0]\n" 7506 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7507 verifyFormat("a[::b::c];"); 7508 7509 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 7510 7511 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 7512 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 7513 } 7514 7515 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 7516 verifyFormat("(a)->b();"); 7517 verifyFormat("--a;"); 7518 } 7519 7520 TEST_F(FormatTest, HandlesIncludeDirectives) { 7521 verifyFormat("#include <string>\n" 7522 "#include <a/b/c.h>\n" 7523 "#include \"a/b/string\"\n" 7524 "#include \"string.h\"\n" 7525 "#include \"string.h\"\n" 7526 "#include <a-a>\n" 7527 "#include < path with space >\n" 7528 "#include_next <test.h>" 7529 "#include \"abc.h\" // this is included for ABC\n" 7530 "#include \"some long include\" // with a comment\n" 7531 "#include \"some very long include path\"\n" 7532 "#include <some/very/long/include/path>\n", 7533 getLLVMStyleWithColumns(35)); 7534 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 7535 EXPECT_EQ("#include <a>", format("#include<a>")); 7536 7537 verifyFormat("#import <string>"); 7538 verifyFormat("#import <a/b/c.h>"); 7539 verifyFormat("#import \"a/b/string\""); 7540 verifyFormat("#import \"string.h\""); 7541 verifyFormat("#import \"string.h\""); 7542 verifyFormat("#if __has_include(<strstream>)\n" 7543 "#include <strstream>\n" 7544 "#endif"); 7545 7546 verifyFormat("#define MY_IMPORT <a/b>"); 7547 7548 verifyFormat("#if __has_include(<a/b>)"); 7549 verifyFormat("#if __has_include_next(<a/b>)"); 7550 verifyFormat("#define F __has_include(<a/b>)"); 7551 verifyFormat("#define F __has_include_next(<a/b>)"); 7552 7553 // Protocol buffer definition or missing "#". 7554 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 7555 getLLVMStyleWithColumns(30)); 7556 7557 FormatStyle Style = getLLVMStyle(); 7558 Style.AlwaysBreakBeforeMultilineStrings = true; 7559 Style.ColumnLimit = 0; 7560 verifyFormat("#import \"abc.h\"", Style); 7561 7562 // But 'import' might also be a regular C++ namespace. 7563 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7564 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7565 } 7566 7567 //===----------------------------------------------------------------------===// 7568 // Error recovery tests. 7569 //===----------------------------------------------------------------------===// 7570 7571 TEST_F(FormatTest, IncompleteParameterLists) { 7572 FormatStyle NoBinPacking = getLLVMStyle(); 7573 NoBinPacking.BinPackParameters = false; 7574 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 7575 " double *min_x,\n" 7576 " double *max_x,\n" 7577 " double *min_y,\n" 7578 " double *max_y,\n" 7579 " double *min_z,\n" 7580 " double *max_z, ) {}", 7581 NoBinPacking); 7582 } 7583 7584 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 7585 verifyFormat("void f() { return; }\n42"); 7586 verifyFormat("void f() {\n" 7587 " if (0)\n" 7588 " return;\n" 7589 "}\n" 7590 "42"); 7591 verifyFormat("void f() { return }\n42"); 7592 verifyFormat("void f() {\n" 7593 " if (0)\n" 7594 " return\n" 7595 "}\n" 7596 "42"); 7597 } 7598 7599 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 7600 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 7601 EXPECT_EQ("void f() {\n" 7602 " if (a)\n" 7603 " return\n" 7604 "}", 7605 format("void f ( ) { if ( a ) return }")); 7606 EXPECT_EQ("namespace N {\n" 7607 "void f()\n" 7608 "}", 7609 format("namespace N { void f() }")); 7610 EXPECT_EQ("namespace N {\n" 7611 "void f() {}\n" 7612 "void g()\n" 7613 "} // namespace N", 7614 format("namespace N { void f( ) { } void g( ) }")); 7615 } 7616 7617 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 7618 verifyFormat("int aaaaaaaa =\n" 7619 " // Overlylongcomment\n" 7620 " b;", 7621 getLLVMStyleWithColumns(20)); 7622 verifyFormat("function(\n" 7623 " ShortArgument,\n" 7624 " LoooooooooooongArgument);\n", 7625 getLLVMStyleWithColumns(20)); 7626 } 7627 7628 TEST_F(FormatTest, IncorrectAccessSpecifier) { 7629 verifyFormat("public:"); 7630 verifyFormat("class A {\n" 7631 "public\n" 7632 " void f() {}\n" 7633 "};"); 7634 verifyFormat("public\n" 7635 "int qwerty;"); 7636 verifyFormat("public\n" 7637 "B {}"); 7638 verifyFormat("public\n" 7639 "{}"); 7640 verifyFormat("public\n" 7641 "B { int x; }"); 7642 } 7643 7644 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 7645 verifyFormat("{"); 7646 verifyFormat("#})"); 7647 verifyNoCrash("(/**/[:!] ?[)."); 7648 } 7649 7650 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 7651 // Found by oss-fuzz: 7652 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 7653 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 7654 Style.ColumnLimit = 60; 7655 verifyNoCrash( 7656 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 7657 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 7658 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 7659 Style); 7660 } 7661 7662 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 7663 verifyFormat("do {\n}"); 7664 verifyFormat("do {\n}\n" 7665 "f();"); 7666 verifyFormat("do {\n}\n" 7667 "wheeee(fun);"); 7668 verifyFormat("do {\n" 7669 " f();\n" 7670 "}"); 7671 } 7672 7673 TEST_F(FormatTest, IncorrectCodeMissingParens) { 7674 verifyFormat("if {\n foo;\n foo();\n}"); 7675 verifyFormat("switch {\n foo;\n foo();\n}"); 7676 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 7677 verifyFormat("while {\n foo;\n foo();\n}"); 7678 verifyFormat("do {\n foo;\n foo();\n} while;"); 7679 } 7680 7681 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 7682 verifyIncompleteFormat("namespace {\n" 7683 "class Foo { Foo (\n" 7684 "};\n" 7685 "} // namespace"); 7686 } 7687 7688 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 7689 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 7690 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 7691 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 7692 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 7693 7694 EXPECT_EQ("{\n" 7695 " {\n" 7696 " breakme(\n" 7697 " qwe);\n" 7698 " }\n", 7699 format("{\n" 7700 " {\n" 7701 " breakme(qwe);\n" 7702 "}\n", 7703 getLLVMStyleWithColumns(10))); 7704 } 7705 7706 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 7707 verifyFormat("int x = {\n" 7708 " avariable,\n" 7709 " b(alongervariable)};", 7710 getLLVMStyleWithColumns(25)); 7711 } 7712 7713 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 7714 verifyFormat("return (a)(b){1, 2, 3};"); 7715 } 7716 7717 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 7718 verifyFormat("vector<int> x{1, 2, 3, 4};"); 7719 verifyFormat("vector<int> x{\n" 7720 " 1,\n" 7721 " 2,\n" 7722 " 3,\n" 7723 " 4,\n" 7724 "};"); 7725 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 7726 verifyFormat("f({1, 2});"); 7727 verifyFormat("auto v = Foo{-1};"); 7728 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 7729 verifyFormat("Class::Class : member{1, 2, 3} {}"); 7730 verifyFormat("new vector<int>{1, 2, 3};"); 7731 verifyFormat("new int[3]{1, 2, 3};"); 7732 verifyFormat("new int{1};"); 7733 verifyFormat("return {arg1, arg2};"); 7734 verifyFormat("return {arg1, SomeType{parameter}};"); 7735 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 7736 verifyFormat("new T{arg1, arg2};"); 7737 verifyFormat("f(MyMap[{composite, key}]);"); 7738 verifyFormat("class Class {\n" 7739 " T member = {arg1, arg2};\n" 7740 "};"); 7741 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 7742 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 7743 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 7744 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 7745 verifyFormat("int a = std::is_integral<int>{} + 0;"); 7746 7747 verifyFormat("int foo(int i) { return fo1{}(i); }"); 7748 verifyFormat("int foo(int i) { return fo1{}(i); }"); 7749 verifyFormat("auto i = decltype(x){};"); 7750 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 7751 verifyFormat("Node n{1, Node{1000}, //\n" 7752 " 2};"); 7753 verifyFormat("Aaaa aaaaaaa{\n" 7754 " {\n" 7755 " aaaa,\n" 7756 " },\n" 7757 "};"); 7758 verifyFormat("class C : public D {\n" 7759 " SomeClass SC{2};\n" 7760 "};"); 7761 verifyFormat("class C : public A {\n" 7762 " class D : public B {\n" 7763 " void f() { int i{2}; }\n" 7764 " };\n" 7765 "};"); 7766 verifyFormat("#define A {a, a},"); 7767 7768 // Avoid breaking between equal sign and opening brace 7769 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 7770 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 7771 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 7772 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 7773 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 7774 " {\"ccccccccccccccccccccc\", 2}};", 7775 AvoidBreakingFirstArgument); 7776 7777 // Binpacking only if there is no trailing comma 7778 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 7779 " cccccccccc, dddddddddd};", 7780 getLLVMStyleWithColumns(50)); 7781 verifyFormat("const Aaaaaa aaaaa = {\n" 7782 " aaaaaaaaaaa,\n" 7783 " bbbbbbbbbbb,\n" 7784 " ccccccccccc,\n" 7785 " ddddddddddd,\n" 7786 "};", getLLVMStyleWithColumns(50)); 7787 7788 // Cases where distinguising braced lists and blocks is hard. 7789 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 7790 verifyFormat("void f() {\n" 7791 " return; // comment\n" 7792 "}\n" 7793 "SomeType t;"); 7794 verifyFormat("void f() {\n" 7795 " if (a) {\n" 7796 " f();\n" 7797 " }\n" 7798 "}\n" 7799 "SomeType t;"); 7800 7801 // In combination with BinPackArguments = false. 7802 FormatStyle NoBinPacking = getLLVMStyle(); 7803 NoBinPacking.BinPackArguments = false; 7804 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 7805 " bbbbb,\n" 7806 " ccccc,\n" 7807 " ddddd,\n" 7808 " eeeee,\n" 7809 " ffffff,\n" 7810 " ggggg,\n" 7811 " hhhhhh,\n" 7812 " iiiiii,\n" 7813 " jjjjjj,\n" 7814 " kkkkkk};", 7815 NoBinPacking); 7816 verifyFormat("const Aaaaaa aaaaa = {\n" 7817 " aaaaa,\n" 7818 " bbbbb,\n" 7819 " ccccc,\n" 7820 " ddddd,\n" 7821 " eeeee,\n" 7822 " ffffff,\n" 7823 " ggggg,\n" 7824 " hhhhhh,\n" 7825 " iiiiii,\n" 7826 " jjjjjj,\n" 7827 " kkkkkk,\n" 7828 "};", 7829 NoBinPacking); 7830 verifyFormat( 7831 "const Aaaaaa aaaaa = {\n" 7832 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 7833 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 7834 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 7835 "};", 7836 NoBinPacking); 7837 7838 // FIXME: The alignment of these trailing comments might be bad. Then again, 7839 // this might be utterly useless in real code. 7840 verifyFormat("Constructor::Constructor()\n" 7841 " : some_value{ //\n" 7842 " aaaaaaa, //\n" 7843 " bbbbbbb} {}"); 7844 7845 // In braced lists, the first comment is always assumed to belong to the 7846 // first element. Thus, it can be moved to the next or previous line as 7847 // appropriate. 7848 EXPECT_EQ("function({// First element:\n" 7849 " 1,\n" 7850 " // Second element:\n" 7851 " 2});", 7852 format("function({\n" 7853 " // First element:\n" 7854 " 1,\n" 7855 " // Second element:\n" 7856 " 2});")); 7857 EXPECT_EQ("std::vector<int> MyNumbers{\n" 7858 " // First element:\n" 7859 " 1,\n" 7860 " // Second element:\n" 7861 " 2};", 7862 format("std::vector<int> MyNumbers{// First element:\n" 7863 " 1,\n" 7864 " // Second element:\n" 7865 " 2};", 7866 getLLVMStyleWithColumns(30))); 7867 // A trailing comma should still lead to an enforced line break and no 7868 // binpacking. 7869 EXPECT_EQ("vector<int> SomeVector = {\n" 7870 " // aaa\n" 7871 " 1,\n" 7872 " 2,\n" 7873 "};", 7874 format("vector<int> SomeVector = { // aaa\n" 7875 " 1, 2, };")); 7876 7877 FormatStyle ExtraSpaces = getLLVMStyle(); 7878 ExtraSpaces.Cpp11BracedListStyle = false; 7879 ExtraSpaces.ColumnLimit = 75; 7880 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 7881 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 7882 verifyFormat("f({ 1, 2 });", ExtraSpaces); 7883 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 7884 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 7885 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 7886 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 7887 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 7888 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 7889 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 7890 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 7891 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 7892 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 7893 verifyFormat("class Class {\n" 7894 " T member = { arg1, arg2 };\n" 7895 "};", 7896 ExtraSpaces); 7897 verifyFormat( 7898 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7899 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 7900 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 7901 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 7902 ExtraSpaces); 7903 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 7904 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 7905 ExtraSpaces); 7906 verifyFormat( 7907 "someFunction(OtherParam,\n" 7908 " BracedList{ // comment 1 (Forcing interesting break)\n" 7909 " param1, param2,\n" 7910 " // comment 2\n" 7911 " param3, param4 });", 7912 ExtraSpaces); 7913 verifyFormat( 7914 "std::this_thread::sleep_for(\n" 7915 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 7916 ExtraSpaces); 7917 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 7918 " aaaaaaa,\n" 7919 " aaaaaaaaaa,\n" 7920 " aaaaa,\n" 7921 " aaaaaaaaaaaaaaa,\n" 7922 " aaa,\n" 7923 " aaaaaaaaaa,\n" 7924 " a,\n" 7925 " aaaaaaaaaaaaaaaaaaaaa,\n" 7926 " aaaaaaaaaaaa,\n" 7927 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 7928 " aaaaaaa,\n" 7929 " a};"); 7930 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 7931 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 7932 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 7933 7934 // Avoid breaking between initializer/equal sign and opening brace 7935 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 7936 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 7937 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 7938 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 7939 " { \"ccccccccccccccccccccc\", 2 }\n" 7940 "};", 7941 ExtraSpaces); 7942 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 7943 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 7944 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 7945 " { \"ccccccccccccccccccccc\", 2 }\n" 7946 "};", 7947 ExtraSpaces); 7948 7949 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 7950 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 7951 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 7952 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 7953 } 7954 7955 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 7956 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7957 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7958 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7959 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7960 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7961 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 7962 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 7963 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7964 " 1, 22, 333, 4444, 55555, //\n" 7965 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7966 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 7967 verifyFormat( 7968 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7969 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7970 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 7971 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 7972 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 7973 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 7974 " 7777777};"); 7975 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 7976 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 7977 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 7978 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 7979 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 7980 " // Separating comment.\n" 7981 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 7982 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 7983 " // Leading comment\n" 7984 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 7985 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 7986 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 7987 " 1, 1, 1, 1};", 7988 getLLVMStyleWithColumns(39)); 7989 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 7990 " 1, 1, 1, 1};", 7991 getLLVMStyleWithColumns(38)); 7992 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 7993 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 7994 getLLVMStyleWithColumns(43)); 7995 verifyFormat( 7996 "static unsigned SomeValues[10][3] = {\n" 7997 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 7998 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 7999 verifyFormat("static auto fields = new vector<string>{\n" 8000 " \"aaaaaaaaaaaaa\",\n" 8001 " \"aaaaaaaaaaaaa\",\n" 8002 " \"aaaaaaaaaaaa\",\n" 8003 " \"aaaaaaaaaaaaaa\",\n" 8004 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8005 " \"aaaaaaaaaaaa\",\n" 8006 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8007 "};"); 8008 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 8009 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 8010 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 8011 " 3, cccccccccccccccccccccc};", 8012 getLLVMStyleWithColumns(60)); 8013 8014 // Trailing commas. 8015 verifyFormat("vector<int> x = {\n" 8016 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 8017 "};", 8018 getLLVMStyleWithColumns(39)); 8019 verifyFormat("vector<int> x = {\n" 8020 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 8021 "};", 8022 getLLVMStyleWithColumns(39)); 8023 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8024 " 1, 1, 1, 1,\n" 8025 " /**/ /**/};", 8026 getLLVMStyleWithColumns(39)); 8027 8028 // Trailing comment in the first line. 8029 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 8030 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 8031 " 111111111, 222222222, 3333333333, 444444444, //\n" 8032 " 11111111, 22222222, 333333333, 44444444};"); 8033 // Trailing comment in the last line. 8034 verifyFormat("int aaaaa[] = {\n" 8035 " 1, 2, 3, // comment\n" 8036 " 4, 5, 6 // comment\n" 8037 "};"); 8038 8039 // With nested lists, we should either format one item per line or all nested 8040 // lists one on line. 8041 // FIXME: For some nested lists, we can do better. 8042 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 8043 " {aaaaaaaaaaaaaaaaaaa},\n" 8044 " {aaaaaaaaaaaaaaaaaaaaa},\n" 8045 " {aaaaaaaaaaaaaaaaa}};", 8046 getLLVMStyleWithColumns(60)); 8047 verifyFormat( 8048 "SomeStruct my_struct_array = {\n" 8049 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 8050 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 8051 " {aaa, aaa},\n" 8052 " {aaa, aaa},\n" 8053 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 8054 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 8055 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 8056 8057 // No column layout should be used here. 8058 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 8059 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 8060 8061 verifyNoCrash("a<,"); 8062 8063 // No braced initializer here. 8064 verifyFormat("void f() {\n" 8065 " struct Dummy {};\n" 8066 " f(v);\n" 8067 "}"); 8068 8069 // Long lists should be formatted in columns even if they are nested. 8070 verifyFormat( 8071 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8072 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8073 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8074 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8075 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8076 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 8077 8078 // Allow "single-column" layout even if that violates the column limit. There 8079 // isn't going to be a better way. 8080 verifyFormat("std::vector<int> a = {\n" 8081 " aaaaaaaa,\n" 8082 " aaaaaaaa,\n" 8083 " aaaaaaaa,\n" 8084 " aaaaaaaa,\n" 8085 " aaaaaaaaaa,\n" 8086 " aaaaaaaa,\n" 8087 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 8088 getLLVMStyleWithColumns(30)); 8089 verifyFormat("vector<int> aaaa = {\n" 8090 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8091 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8092 " aaaaaa.aaaaaaa,\n" 8093 " aaaaaa.aaaaaaa,\n" 8094 " aaaaaa.aaaaaaa,\n" 8095 " aaaaaa.aaaaaaa,\n" 8096 "};"); 8097 8098 // Don't create hanging lists. 8099 verifyFormat("someFunction(Param, {List1, List2,\n" 8100 " List3});", 8101 getLLVMStyleWithColumns(35)); 8102 verifyFormat("someFunction(Param, Param,\n" 8103 " {List1, List2,\n" 8104 " List3});", 8105 getLLVMStyleWithColumns(35)); 8106 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 8107 " aaaaaaaaaaaaaaaaaaaaaaa);"); 8108 } 8109 8110 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 8111 FormatStyle DoNotMerge = getLLVMStyle(); 8112 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8113 8114 verifyFormat("void f() { return 42; }"); 8115 verifyFormat("void f() {\n" 8116 " return 42;\n" 8117 "}", 8118 DoNotMerge); 8119 verifyFormat("void f() {\n" 8120 " // Comment\n" 8121 "}"); 8122 verifyFormat("{\n" 8123 "#error {\n" 8124 " int a;\n" 8125 "}"); 8126 verifyFormat("{\n" 8127 " int a;\n" 8128 "#error {\n" 8129 "}"); 8130 verifyFormat("void f() {} // comment"); 8131 verifyFormat("void f() { int a; } // comment"); 8132 verifyFormat("void f() {\n" 8133 "} // comment", 8134 DoNotMerge); 8135 verifyFormat("void f() {\n" 8136 " int a;\n" 8137 "} // comment", 8138 DoNotMerge); 8139 verifyFormat("void f() {\n" 8140 "} // comment", 8141 getLLVMStyleWithColumns(15)); 8142 8143 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 8144 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 8145 8146 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 8147 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 8148 verifyFormat("class C {\n" 8149 " C()\n" 8150 " : iiiiiiii(nullptr),\n" 8151 " kkkkkkk(nullptr),\n" 8152 " mmmmmmm(nullptr),\n" 8153 " nnnnnnn(nullptr) {}\n" 8154 "};", 8155 getGoogleStyle()); 8156 8157 FormatStyle NoColumnLimit = getLLVMStyle(); 8158 NoColumnLimit.ColumnLimit = 0; 8159 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 8160 EXPECT_EQ("class C {\n" 8161 " A() : b(0) {}\n" 8162 "};", 8163 format("class C{A():b(0){}};", NoColumnLimit)); 8164 EXPECT_EQ("A()\n" 8165 " : b(0) {\n" 8166 "}", 8167 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 8168 8169 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 8170 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 8171 FormatStyle::SFS_None; 8172 EXPECT_EQ("A()\n" 8173 " : b(0) {\n" 8174 "}", 8175 format("A():b(0){}", DoNotMergeNoColumnLimit)); 8176 EXPECT_EQ("A()\n" 8177 " : b(0) {\n" 8178 "}", 8179 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 8180 8181 verifyFormat("#define A \\\n" 8182 " void f() { \\\n" 8183 " int i; \\\n" 8184 " }", 8185 getLLVMStyleWithColumns(20)); 8186 verifyFormat("#define A \\\n" 8187 " void f() { int i; }", 8188 getLLVMStyleWithColumns(21)); 8189 verifyFormat("#define A \\\n" 8190 " void f() { \\\n" 8191 " int i; \\\n" 8192 " } \\\n" 8193 " int j;", 8194 getLLVMStyleWithColumns(22)); 8195 verifyFormat("#define A \\\n" 8196 " void f() { int i; } \\\n" 8197 " int j;", 8198 getLLVMStyleWithColumns(23)); 8199 } 8200 8201 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 8202 FormatStyle MergeEmptyOnly = getLLVMStyle(); 8203 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8204 verifyFormat("class C {\n" 8205 " int f() {}\n" 8206 "};", 8207 MergeEmptyOnly); 8208 verifyFormat("class C {\n" 8209 " int f() {\n" 8210 " return 42;\n" 8211 " }\n" 8212 "};", 8213 MergeEmptyOnly); 8214 verifyFormat("int f() {}", MergeEmptyOnly); 8215 verifyFormat("int f() {\n" 8216 " return 42;\n" 8217 "}", 8218 MergeEmptyOnly); 8219 8220 // Also verify behavior when BraceWrapping.AfterFunction = true 8221 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8222 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 8223 verifyFormat("int f() {}", MergeEmptyOnly); 8224 verifyFormat("class C {\n" 8225 " int f() {}\n" 8226 "};", 8227 MergeEmptyOnly); 8228 } 8229 8230 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 8231 FormatStyle MergeInlineOnly = getLLVMStyle(); 8232 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8233 verifyFormat("class C {\n" 8234 " int f() { return 42; }\n" 8235 "};", 8236 MergeInlineOnly); 8237 verifyFormat("int f() {\n" 8238 " return 42;\n" 8239 "}", 8240 MergeInlineOnly); 8241 8242 // SFS_Inline implies SFS_Empty 8243 verifyFormat("class C {\n" 8244 " int f() {}\n" 8245 "};", 8246 MergeInlineOnly); 8247 verifyFormat("int f() {}", MergeInlineOnly); 8248 8249 // Also verify behavior when BraceWrapping.AfterFunction = true 8250 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8251 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8252 verifyFormat("class C {\n" 8253 " int f() { return 42; }\n" 8254 "};", 8255 MergeInlineOnly); 8256 verifyFormat("int f()\n" 8257 "{\n" 8258 " return 42;\n" 8259 "}", 8260 MergeInlineOnly); 8261 8262 // SFS_Inline implies SFS_Empty 8263 verifyFormat("int f() {}", MergeInlineOnly); 8264 verifyFormat("class C {\n" 8265 " int f() {}\n" 8266 "};", 8267 MergeInlineOnly); 8268 } 8269 8270 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8271 FormatStyle MergeInlineOnly = getLLVMStyle(); 8272 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8273 FormatStyle::SFS_InlineOnly; 8274 verifyFormat("class C {\n" 8275 " int f() { return 42; }\n" 8276 "};", 8277 MergeInlineOnly); 8278 verifyFormat("int f() {\n" 8279 " return 42;\n" 8280 "}", 8281 MergeInlineOnly); 8282 8283 // SFS_InlineOnly does not imply SFS_Empty 8284 verifyFormat("class C {\n" 8285 " int f() {}\n" 8286 "};", 8287 MergeInlineOnly); 8288 verifyFormat("int f() {\n" 8289 "}", 8290 MergeInlineOnly); 8291 8292 // Also verify behavior when BraceWrapping.AfterFunction = true 8293 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8294 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8295 verifyFormat("class C {\n" 8296 " int f() { return 42; }\n" 8297 "};", 8298 MergeInlineOnly); 8299 verifyFormat("int f()\n" 8300 "{\n" 8301 " return 42;\n" 8302 "}", 8303 MergeInlineOnly); 8304 8305 // SFS_InlineOnly does not imply SFS_Empty 8306 verifyFormat("int f()\n" 8307 "{\n" 8308 "}", 8309 MergeInlineOnly); 8310 verifyFormat("class C {\n" 8311 " int f() {}\n" 8312 "};", 8313 MergeInlineOnly); 8314 } 8315 8316 TEST_F(FormatTest, SplitEmptyFunction) { 8317 FormatStyle Style = getLLVMStyle(); 8318 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8319 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8320 Style.BraceWrapping.AfterFunction = true; 8321 Style.BraceWrapping.SplitEmptyFunction = false; 8322 Style.ColumnLimit = 40; 8323 8324 verifyFormat("int f()\n" 8325 "{}", 8326 Style); 8327 verifyFormat("int f()\n" 8328 "{\n" 8329 " return 42;\n" 8330 "}", 8331 Style); 8332 verifyFormat("int f()\n" 8333 "{\n" 8334 " // some comment\n" 8335 "}", 8336 Style); 8337 8338 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8339 verifyFormat("int f() {}", Style); 8340 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8341 "{}", 8342 Style); 8343 verifyFormat("int f()\n" 8344 "{\n" 8345 " return 0;\n" 8346 "}", 8347 Style); 8348 8349 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8350 verifyFormat("class Foo {\n" 8351 " int f() {}\n" 8352 "};\n", 8353 Style); 8354 verifyFormat("class Foo {\n" 8355 " int f() { return 0; }\n" 8356 "};\n", 8357 Style); 8358 verifyFormat("class Foo {\n" 8359 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8360 " {}\n" 8361 "};\n", 8362 Style); 8363 verifyFormat("class Foo {\n" 8364 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8365 " {\n" 8366 " return 0;\n" 8367 " }\n" 8368 "};\n", 8369 Style); 8370 8371 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8372 verifyFormat("int f() {}", Style); 8373 verifyFormat("int f() { return 0; }", Style); 8374 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8375 "{}", 8376 Style); 8377 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8378 "{\n" 8379 " return 0;\n" 8380 "}", 8381 Style); 8382 } 8383 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8384 FormatStyle Style = getLLVMStyle(); 8385 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8386 verifyFormat("#ifdef A\n" 8387 "int f() {}\n" 8388 "#else\n" 8389 "int g() {}\n" 8390 "#endif", 8391 Style); 8392 } 8393 8394 TEST_F(FormatTest, SplitEmptyClass) { 8395 FormatStyle Style = getLLVMStyle(); 8396 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8397 Style.BraceWrapping.AfterClass = true; 8398 Style.BraceWrapping.SplitEmptyRecord = false; 8399 8400 verifyFormat("class Foo\n" 8401 "{};", 8402 Style); 8403 verifyFormat("/* something */ class Foo\n" 8404 "{};", 8405 Style); 8406 verifyFormat("template <typename X> class Foo\n" 8407 "{};", 8408 Style); 8409 verifyFormat("class Foo\n" 8410 "{\n" 8411 " Foo();\n" 8412 "};", 8413 Style); 8414 verifyFormat("typedef class Foo\n" 8415 "{\n" 8416 "} Foo_t;", 8417 Style); 8418 } 8419 8420 TEST_F(FormatTest, SplitEmptyStruct) { 8421 FormatStyle Style = getLLVMStyle(); 8422 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8423 Style.BraceWrapping.AfterStruct = true; 8424 Style.BraceWrapping.SplitEmptyRecord = false; 8425 8426 verifyFormat("struct Foo\n" 8427 "{};", 8428 Style); 8429 verifyFormat("/* something */ struct Foo\n" 8430 "{};", 8431 Style); 8432 verifyFormat("template <typename X> struct Foo\n" 8433 "{};", 8434 Style); 8435 verifyFormat("struct Foo\n" 8436 "{\n" 8437 " Foo();\n" 8438 "};", 8439 Style); 8440 verifyFormat("typedef struct Foo\n" 8441 "{\n" 8442 "} Foo_t;", 8443 Style); 8444 //typedef struct Bar {} Bar_t; 8445 } 8446 8447 TEST_F(FormatTest, SplitEmptyUnion) { 8448 FormatStyle Style = getLLVMStyle(); 8449 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8450 Style.BraceWrapping.AfterUnion = true; 8451 Style.BraceWrapping.SplitEmptyRecord = false; 8452 8453 verifyFormat("union Foo\n" 8454 "{};", 8455 Style); 8456 verifyFormat("/* something */ union Foo\n" 8457 "{};", 8458 Style); 8459 verifyFormat("union Foo\n" 8460 "{\n" 8461 " A,\n" 8462 "};", 8463 Style); 8464 verifyFormat("typedef union Foo\n" 8465 "{\n" 8466 "} Foo_t;", 8467 Style); 8468 } 8469 8470 TEST_F(FormatTest, SplitEmptyNamespace) { 8471 FormatStyle Style = getLLVMStyle(); 8472 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8473 Style.BraceWrapping.AfterNamespace = true; 8474 Style.BraceWrapping.SplitEmptyNamespace = false; 8475 8476 verifyFormat("namespace Foo\n" 8477 "{};", 8478 Style); 8479 verifyFormat("/* something */ namespace Foo\n" 8480 "{};", 8481 Style); 8482 verifyFormat("inline namespace Foo\n" 8483 "{};", 8484 Style); 8485 verifyFormat("/* something */ inline namespace Foo\n" 8486 "{};", 8487 Style); 8488 verifyFormat("export namespace Foo\n" 8489 "{};", 8490 Style); 8491 verifyFormat("namespace Foo\n" 8492 "{\n" 8493 "void Bar();\n" 8494 "};", 8495 Style); 8496 } 8497 8498 TEST_F(FormatTest, NeverMergeShortRecords) { 8499 FormatStyle Style = getLLVMStyle(); 8500 8501 verifyFormat("class Foo {\n" 8502 " Foo();\n" 8503 "};", 8504 Style); 8505 verifyFormat("typedef class Foo {\n" 8506 " Foo();\n" 8507 "} Foo_t;", 8508 Style); 8509 verifyFormat("struct Foo {\n" 8510 " Foo();\n" 8511 "};", 8512 Style); 8513 verifyFormat("typedef struct Foo {\n" 8514 " Foo();\n" 8515 "} Foo_t;", 8516 Style); 8517 verifyFormat("union Foo {\n" 8518 " A,\n" 8519 "};", 8520 Style); 8521 verifyFormat("typedef union Foo {\n" 8522 " A,\n" 8523 "} Foo_t;", 8524 Style); 8525 verifyFormat("namespace Foo {\n" 8526 "void Bar();\n" 8527 "};", 8528 Style); 8529 8530 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8531 Style.BraceWrapping.AfterClass = true; 8532 Style.BraceWrapping.AfterStruct = true; 8533 Style.BraceWrapping.AfterUnion = true; 8534 Style.BraceWrapping.AfterNamespace = true; 8535 verifyFormat("class Foo\n" 8536 "{\n" 8537 " Foo();\n" 8538 "};", 8539 Style); 8540 verifyFormat("typedef class Foo\n" 8541 "{\n" 8542 " Foo();\n" 8543 "} Foo_t;", 8544 Style); 8545 verifyFormat("struct Foo\n" 8546 "{\n" 8547 " Foo();\n" 8548 "};", 8549 Style); 8550 verifyFormat("typedef struct Foo\n" 8551 "{\n" 8552 " Foo();\n" 8553 "} Foo_t;", 8554 Style); 8555 verifyFormat("union Foo\n" 8556 "{\n" 8557 " A,\n" 8558 "};", 8559 Style); 8560 verifyFormat("typedef union Foo\n" 8561 "{\n" 8562 " A,\n" 8563 "} Foo_t;", 8564 Style); 8565 verifyFormat("namespace Foo\n" 8566 "{\n" 8567 "void Bar();\n" 8568 "};", 8569 Style); 8570 } 8571 8572 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 8573 // Elaborate type variable declarations. 8574 verifyFormat("struct foo a = {bar};\nint n;"); 8575 verifyFormat("class foo a = {bar};\nint n;"); 8576 verifyFormat("union foo a = {bar};\nint n;"); 8577 8578 // Elaborate types inside function definitions. 8579 verifyFormat("struct foo f() {}\nint n;"); 8580 verifyFormat("class foo f() {}\nint n;"); 8581 verifyFormat("union foo f() {}\nint n;"); 8582 8583 // Templates. 8584 verifyFormat("template <class X> void f() {}\nint n;"); 8585 verifyFormat("template <struct X> void f() {}\nint n;"); 8586 verifyFormat("template <union X> void f() {}\nint n;"); 8587 8588 // Actual definitions... 8589 verifyFormat("struct {\n} n;"); 8590 verifyFormat( 8591 "template <template <class T, class Y>, class Z> class X {\n} n;"); 8592 verifyFormat("union Z {\n int n;\n} x;"); 8593 verifyFormat("class MACRO Z {\n} n;"); 8594 verifyFormat("class MACRO(X) Z {\n} n;"); 8595 verifyFormat("class __attribute__(X) Z {\n} n;"); 8596 verifyFormat("class __declspec(X) Z {\n} n;"); 8597 verifyFormat("class A##B##C {\n} n;"); 8598 verifyFormat("class alignas(16) Z {\n} n;"); 8599 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 8600 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 8601 8602 // Redefinition from nested context: 8603 verifyFormat("class A::B::C {\n} n;"); 8604 8605 // Template definitions. 8606 verifyFormat( 8607 "template <typename F>\n" 8608 "Matcher(const Matcher<F> &Other,\n" 8609 " typename enable_if_c<is_base_of<F, T>::value &&\n" 8610 " !is_same<F, T>::value>::type * = 0)\n" 8611 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 8612 8613 // FIXME: This is still incorrectly handled at the formatter side. 8614 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 8615 verifyFormat("int i = SomeFunction(a<b, a> b);"); 8616 8617 // FIXME: 8618 // This now gets parsed incorrectly as class definition. 8619 // verifyFormat("class A<int> f() {\n}\nint n;"); 8620 8621 // Elaborate types where incorrectly parsing the structural element would 8622 // break the indent. 8623 verifyFormat("if (true)\n" 8624 " class X x;\n" 8625 "else\n" 8626 " f();\n"); 8627 8628 // This is simply incomplete. Formatting is not important, but must not crash. 8629 verifyFormat("class A:"); 8630 } 8631 8632 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 8633 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 8634 format("#error Leave all white!!!!! space* alone!\n")); 8635 EXPECT_EQ( 8636 "#warning Leave all white!!!!! space* alone!\n", 8637 format("#warning Leave all white!!!!! space* alone!\n")); 8638 EXPECT_EQ("#error 1", format(" # error 1")); 8639 EXPECT_EQ("#warning 1", format(" # warning 1")); 8640 } 8641 8642 TEST_F(FormatTest, FormatHashIfExpressions) { 8643 verifyFormat("#if AAAA && BBBB"); 8644 verifyFormat("#if (AAAA && BBBB)"); 8645 verifyFormat("#elif (AAAA && BBBB)"); 8646 // FIXME: Come up with a better indentation for #elif. 8647 verifyFormat( 8648 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 8649 " defined(BBBBBBBB)\n" 8650 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 8651 " defined(BBBBBBBB)\n" 8652 "#endif", 8653 getLLVMStyleWithColumns(65)); 8654 } 8655 8656 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 8657 FormatStyle AllowsMergedIf = getGoogleStyle(); 8658 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 8659 FormatStyle::SIS_WithoutElse; 8660 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 8661 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 8662 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 8663 EXPECT_EQ("if (true) return 42;", 8664 format("if (true)\nreturn 42;", AllowsMergedIf)); 8665 FormatStyle ShortMergedIf = AllowsMergedIf; 8666 ShortMergedIf.ColumnLimit = 25; 8667 verifyFormat("#define A \\\n" 8668 " if (true) return 42;", 8669 ShortMergedIf); 8670 verifyFormat("#define A \\\n" 8671 " f(); \\\n" 8672 " if (true)\n" 8673 "#define B", 8674 ShortMergedIf); 8675 verifyFormat("#define A \\\n" 8676 " f(); \\\n" 8677 " if (true)\n" 8678 "g();", 8679 ShortMergedIf); 8680 verifyFormat("{\n" 8681 "#ifdef A\n" 8682 " // Comment\n" 8683 " if (true) continue;\n" 8684 "#endif\n" 8685 " // Comment\n" 8686 " if (true) continue;\n" 8687 "}", 8688 ShortMergedIf); 8689 ShortMergedIf.ColumnLimit = 33; 8690 verifyFormat("#define A \\\n" 8691 " if constexpr (true) return 42;", 8692 ShortMergedIf); 8693 verifyFormat("#define A \\\n" 8694 " if CONSTEXPR (true) return 42;", 8695 ShortMergedIf); 8696 ShortMergedIf.ColumnLimit = 29; 8697 verifyFormat("#define A \\\n" 8698 " if (aaaaaaaaaa) return 1; \\\n" 8699 " return 2;", 8700 ShortMergedIf); 8701 ShortMergedIf.ColumnLimit = 28; 8702 verifyFormat("#define A \\\n" 8703 " if (aaaaaaaaaa) \\\n" 8704 " return 1; \\\n" 8705 " return 2;", 8706 ShortMergedIf); 8707 verifyFormat("#define A \\\n" 8708 " if constexpr (aaaaaaa) \\\n" 8709 " return 1; \\\n" 8710 " return 2;", 8711 ShortMergedIf); 8712 verifyFormat("#define A \\\n" 8713 " if CONSTEXPR (aaaaaaa) \\\n" 8714 " return 1; \\\n" 8715 " return 2;", 8716 ShortMergedIf); 8717 } 8718 8719 TEST_F(FormatTest, FormatStarDependingOnContext) { 8720 verifyFormat("void f(int *a);"); 8721 verifyFormat("void f() { f(fint * b); }"); 8722 verifyFormat("class A {\n void f(int *a);\n};"); 8723 verifyFormat("class A {\n int *a;\n};"); 8724 verifyFormat("namespace a {\n" 8725 "namespace b {\n" 8726 "class A {\n" 8727 " void f() {}\n" 8728 " int *a;\n" 8729 "};\n" 8730 "} // namespace b\n" 8731 "} // namespace a"); 8732 } 8733 8734 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 8735 verifyFormat("while"); 8736 verifyFormat("operator"); 8737 } 8738 8739 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 8740 // This code would be painfully slow to format if we didn't skip it. 8741 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 8742 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8743 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8744 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8745 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8746 "A(1, 1)\n" 8747 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 8748 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8749 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8750 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8751 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8752 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8753 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8754 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8755 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8756 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 8757 // Deeply nested part is untouched, rest is formatted. 8758 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 8759 format(std::string("int i;\n") + Code + "int j;\n", 8760 getLLVMStyle(), SC_ExpectIncomplete)); 8761 } 8762 8763 //===----------------------------------------------------------------------===// 8764 // Objective-C tests. 8765 //===----------------------------------------------------------------------===// 8766 8767 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 8768 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 8769 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 8770 format("-(NSUInteger)indexOfObject:(id)anObject;")); 8771 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 8772 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 8773 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 8774 format("-(NSInteger)Method3:(id)anObject;")); 8775 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 8776 format("-(NSInteger)Method4:(id)anObject;")); 8777 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 8778 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 8779 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 8780 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 8781 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 8782 "forAllCells:(BOOL)flag;", 8783 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 8784 "forAllCells:(BOOL)flag;")); 8785 8786 // Very long objectiveC method declaration. 8787 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 8788 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 8789 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 8790 " inRange:(NSRange)range\n" 8791 " outRange:(NSRange)out_range\n" 8792 " outRange1:(NSRange)out_range1\n" 8793 " outRange2:(NSRange)out_range2\n" 8794 " outRange3:(NSRange)out_range3\n" 8795 " outRange4:(NSRange)out_range4\n" 8796 " outRange5:(NSRange)out_range5\n" 8797 " outRange6:(NSRange)out_range6\n" 8798 " outRange7:(NSRange)out_range7\n" 8799 " outRange8:(NSRange)out_range8\n" 8800 " outRange9:(NSRange)out_range9;"); 8801 8802 // When the function name has to be wrapped. 8803 FormatStyle Style = getLLVMStyle(); 8804 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 8805 // and always indents instead. 8806 Style.IndentWrappedFunctionNames = false; 8807 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 8808 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 8809 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 8810 "}", 8811 Style); 8812 Style.IndentWrappedFunctionNames = true; 8813 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 8814 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 8815 " anotherName:(NSString)dddddddddddddd {\n" 8816 "}", 8817 Style); 8818 8819 verifyFormat("- (int)sum:(vector<int>)numbers;"); 8820 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 8821 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 8822 // protocol lists (but not for template classes): 8823 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 8824 8825 verifyFormat("- (int (*)())foo:(int (*)())f;"); 8826 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 8827 8828 // If there's no return type (very rare in practice!), LLVM and Google style 8829 // agree. 8830 verifyFormat("- foo;"); 8831 verifyFormat("- foo:(int)f;"); 8832 verifyGoogleFormat("- foo:(int)foo;"); 8833 } 8834 8835 8836 TEST_F(FormatTest, BreaksStringLiterals) { 8837 EXPECT_EQ("\"some text \"\n" 8838 "\"other\";", 8839 format("\"some text other\";", getLLVMStyleWithColumns(12))); 8840 EXPECT_EQ("\"some text \"\n" 8841 "\"other\";", 8842 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 8843 EXPECT_EQ( 8844 "#define A \\\n" 8845 " \"some \" \\\n" 8846 " \"text \" \\\n" 8847 " \"other\";", 8848 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 8849 EXPECT_EQ( 8850 "#define A \\\n" 8851 " \"so \" \\\n" 8852 " \"text \" \\\n" 8853 " \"other\";", 8854 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 8855 8856 EXPECT_EQ("\"some text\"", 8857 format("\"some text\"", getLLVMStyleWithColumns(1))); 8858 EXPECT_EQ("\"some text\"", 8859 format("\"some text\"", getLLVMStyleWithColumns(11))); 8860 EXPECT_EQ("\"some \"\n" 8861 "\"text\"", 8862 format("\"some text\"", getLLVMStyleWithColumns(10))); 8863 EXPECT_EQ("\"some \"\n" 8864 "\"text\"", 8865 format("\"some text\"", getLLVMStyleWithColumns(7))); 8866 EXPECT_EQ("\"some\"\n" 8867 "\" tex\"\n" 8868 "\"t\"", 8869 format("\"some text\"", getLLVMStyleWithColumns(6))); 8870 EXPECT_EQ("\"some\"\n" 8871 "\" tex\"\n" 8872 "\" and\"", 8873 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 8874 EXPECT_EQ("\"some\"\n" 8875 "\"/tex\"\n" 8876 "\"/and\"", 8877 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 8878 8879 EXPECT_EQ("variable =\n" 8880 " \"long string \"\n" 8881 " \"literal\";", 8882 format("variable = \"long string literal\";", 8883 getLLVMStyleWithColumns(20))); 8884 8885 EXPECT_EQ("variable = f(\n" 8886 " \"long string \"\n" 8887 " \"literal\",\n" 8888 " short,\n" 8889 " loooooooooooooooooooong);", 8890 format("variable = f(\"long string literal\", short, " 8891 "loooooooooooooooooooong);", 8892 getLLVMStyleWithColumns(20))); 8893 8894 EXPECT_EQ( 8895 "f(g(\"long string \"\n" 8896 " \"literal\"),\n" 8897 " b);", 8898 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 8899 EXPECT_EQ("f(g(\"long string \"\n" 8900 " \"literal\",\n" 8901 " a),\n" 8902 " b);", 8903 format("f(g(\"long string literal\", a), b);", 8904 getLLVMStyleWithColumns(20))); 8905 EXPECT_EQ( 8906 "f(\"one two\".split(\n" 8907 " variable));", 8908 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 8909 EXPECT_EQ("f(\"one two three four five six \"\n" 8910 " \"seven\".split(\n" 8911 " really_looooong_variable));", 8912 format("f(\"one two three four five six seven\"." 8913 "split(really_looooong_variable));", 8914 getLLVMStyleWithColumns(33))); 8915 8916 EXPECT_EQ("f(\"some \"\n" 8917 " \"text\",\n" 8918 " other);", 8919 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 8920 8921 // Only break as a last resort. 8922 verifyFormat( 8923 "aaaaaaaaaaaaaaaaaaaa(\n" 8924 " aaaaaaaaaaaaaaaaaaaa,\n" 8925 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 8926 8927 EXPECT_EQ("\"splitmea\"\n" 8928 "\"trandomp\"\n" 8929 "\"oint\"", 8930 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 8931 8932 EXPECT_EQ("\"split/\"\n" 8933 "\"pathat/\"\n" 8934 "\"slashes\"", 8935 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 8936 8937 EXPECT_EQ("\"split/\"\n" 8938 "\"pathat/\"\n" 8939 "\"slashes\"", 8940 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 8941 EXPECT_EQ("\"split at \"\n" 8942 "\"spaces/at/\"\n" 8943 "\"slashes.at.any$\"\n" 8944 "\"non-alphanumeric%\"\n" 8945 "\"1111111111characte\"\n" 8946 "\"rs\"", 8947 format("\"split at " 8948 "spaces/at/" 8949 "slashes.at." 8950 "any$non-" 8951 "alphanumeric%" 8952 "1111111111characte" 8953 "rs\"", 8954 getLLVMStyleWithColumns(20))); 8955 8956 // Verify that splitting the strings understands 8957 // Style::AlwaysBreakBeforeMultilineStrings. 8958 EXPECT_EQ( 8959 "aaaaaaaaaaaa(\n" 8960 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 8961 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 8962 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 8963 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 8964 "aaaaaaaaaaaaaaaaaaaaaa\");", 8965 getGoogleStyle())); 8966 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 8967 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 8968 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 8969 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 8970 "aaaaaaaaaaaaaaaaaaaaaa\";", 8971 getGoogleStyle())); 8972 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 8973 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 8974 format("llvm::outs() << " 8975 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 8976 "aaaaaaaaaaaaaaaaaaa\";")); 8977 EXPECT_EQ("ffff(\n" 8978 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 8979 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 8980 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 8981 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 8982 getGoogleStyle())); 8983 8984 FormatStyle Style = getLLVMStyleWithColumns(12); 8985 Style.BreakStringLiterals = false; 8986 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 8987 8988 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 8989 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 8990 EXPECT_EQ("#define A \\\n" 8991 " \"some \" \\\n" 8992 " \"text \" \\\n" 8993 " \"other\";", 8994 format("#define A \"some text other\";", AlignLeft)); 8995 } 8996 8997 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 8998 EXPECT_EQ("C a = \"some more \"\n" 8999 " \"text\";", 9000 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 9001 } 9002 9003 TEST_F(FormatTest, FullyRemoveEmptyLines) { 9004 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 9005 NoEmptyLines.MaxEmptyLinesToKeep = 0; 9006 EXPECT_EQ("int i = a(b());", 9007 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 9008 } 9009 9010 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 9011 EXPECT_EQ( 9012 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9013 "(\n" 9014 " \"x\t\");", 9015 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9016 "aaaaaaa(" 9017 "\"x\t\");")); 9018 } 9019 9020 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 9021 EXPECT_EQ( 9022 "u8\"utf8 string \"\n" 9023 "u8\"literal\";", 9024 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 9025 EXPECT_EQ( 9026 "u\"utf16 string \"\n" 9027 "u\"literal\";", 9028 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 9029 EXPECT_EQ( 9030 "U\"utf32 string \"\n" 9031 "U\"literal\";", 9032 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 9033 EXPECT_EQ("L\"wide string \"\n" 9034 "L\"literal\";", 9035 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 9036 EXPECT_EQ("@\"NSString \"\n" 9037 "@\"literal\";", 9038 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 9039 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 9040 9041 // This input makes clang-format try to split the incomplete unicode escape 9042 // sequence, which used to lead to a crasher. 9043 verifyNoCrash( 9044 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 9045 getLLVMStyleWithColumns(60)); 9046 } 9047 9048 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 9049 FormatStyle Style = getGoogleStyleWithColumns(15); 9050 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 9051 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 9052 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 9053 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 9054 EXPECT_EQ("u8R\"x(raw literal)x\";", 9055 format("u8R\"x(raw literal)x\";", Style)); 9056 } 9057 9058 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 9059 FormatStyle Style = getLLVMStyleWithColumns(20); 9060 EXPECT_EQ( 9061 "_T(\"aaaaaaaaaaaaaa\")\n" 9062 "_T(\"aaaaaaaaaaaaaa\")\n" 9063 "_T(\"aaaaaaaaaaaa\")", 9064 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 9065 EXPECT_EQ("f(x,\n" 9066 " _T(\"aaaaaaaaaaaa\")\n" 9067 " _T(\"aaa\"),\n" 9068 " z);", 9069 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 9070 9071 // FIXME: Handle embedded spaces in one iteration. 9072 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 9073 // "_T(\"aaaaaaaaaaaaa\")\n" 9074 // "_T(\"aaaaaaaaaaaaa\")\n" 9075 // "_T(\"a\")", 9076 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9077 // getLLVMStyleWithColumns(20))); 9078 EXPECT_EQ( 9079 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9080 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 9081 EXPECT_EQ("f(\n" 9082 "#if !TEST\n" 9083 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9084 "#endif\n" 9085 ");", 9086 format("f(\n" 9087 "#if !TEST\n" 9088 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9089 "#endif\n" 9090 ");")); 9091 EXPECT_EQ("f(\n" 9092 "\n" 9093 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 9094 format("f(\n" 9095 "\n" 9096 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 9097 } 9098 9099 TEST_F(FormatTest, BreaksStringLiteralOperands) { 9100 // In a function call with two operands, the second can be broken with no line 9101 // break before it. 9102 EXPECT_EQ("func(a, \"long long \"\n" 9103 " \"long long\");", 9104 format("func(a, \"long long long long\");", 9105 getLLVMStyleWithColumns(24))); 9106 // In a function call with three operands, the second must be broken with a 9107 // line break before it. 9108 EXPECT_EQ("func(a,\n" 9109 " \"long long long \"\n" 9110 " \"long\",\n" 9111 " c);", 9112 format("func(a, \"long long long long\", c);", 9113 getLLVMStyleWithColumns(24))); 9114 // In a function call with three operands, the third must be broken with a 9115 // line break before it. 9116 EXPECT_EQ("func(a, b,\n" 9117 " \"long long long \"\n" 9118 " \"long\");", 9119 format("func(a, b, \"long long long long\");", 9120 getLLVMStyleWithColumns(24))); 9121 // In a function call with three operands, both the second and the third must 9122 // be broken with a line break before them. 9123 EXPECT_EQ("func(a,\n" 9124 " \"long long long \"\n" 9125 " \"long\",\n" 9126 " \"long long long \"\n" 9127 " \"long\");", 9128 format("func(a, \"long long long long\", \"long long long long\");", 9129 getLLVMStyleWithColumns(24))); 9130 // In a chain of << with two operands, the second can be broken with no line 9131 // break before it. 9132 EXPECT_EQ("a << \"line line \"\n" 9133 " \"line\";", 9134 format("a << \"line line line\";", 9135 getLLVMStyleWithColumns(20))); 9136 // In a chain of << with three operands, the second can be broken with no line 9137 // break before it. 9138 EXPECT_EQ("abcde << \"line \"\n" 9139 " \"line line\"\n" 9140 " << c;", 9141 format("abcde << \"line line line\" << c;", 9142 getLLVMStyleWithColumns(20))); 9143 // In a chain of << with three operands, the third must be broken with a line 9144 // break before it. 9145 EXPECT_EQ("a << b\n" 9146 " << \"line line \"\n" 9147 " \"line\";", 9148 format("a << b << \"line line line\";", 9149 getLLVMStyleWithColumns(20))); 9150 // In a chain of << with three operands, the second can be broken with no line 9151 // break before it and the third must be broken with a line break before it. 9152 EXPECT_EQ("abcd << \"line line \"\n" 9153 " \"line\"\n" 9154 " << \"line line \"\n" 9155 " \"line\";", 9156 format("abcd << \"line line line\" << \"line line line\";", 9157 getLLVMStyleWithColumns(20))); 9158 // In a chain of binary operators with two operands, the second can be broken 9159 // with no line break before it. 9160 EXPECT_EQ("abcd + \"line line \"\n" 9161 " \"line line\";", 9162 format("abcd + \"line line line line\";", 9163 getLLVMStyleWithColumns(20))); 9164 // In a chain of binary operators with three operands, the second must be 9165 // broken with a line break before it. 9166 EXPECT_EQ("abcd +\n" 9167 " \"line line \"\n" 9168 " \"line line\" +\n" 9169 " e;", 9170 format("abcd + \"line line line line\" + e;", 9171 getLLVMStyleWithColumns(20))); 9172 // In a function call with two operands, with AlignAfterOpenBracket enabled, 9173 // the first must be broken with a line break before it. 9174 FormatStyle Style = getLLVMStyleWithColumns(25); 9175 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 9176 EXPECT_EQ("someFunction(\n" 9177 " \"long long long \"\n" 9178 " \"long\",\n" 9179 " a);", 9180 format("someFunction(\"long long long long\", a);", Style)); 9181 } 9182 9183 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 9184 EXPECT_EQ( 9185 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9186 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9187 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9188 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9189 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9190 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 9191 } 9192 9193 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 9194 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 9195 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 9196 EXPECT_EQ("fffffffffff(g(R\"x(\n" 9197 "multiline raw string literal xxxxxxxxxxxxxx\n" 9198 ")x\",\n" 9199 " a),\n" 9200 " b);", 9201 format("fffffffffff(g(R\"x(\n" 9202 "multiline raw string literal xxxxxxxxxxxxxx\n" 9203 ")x\", a), b);", 9204 getGoogleStyleWithColumns(20))); 9205 EXPECT_EQ("fffffffffff(\n" 9206 " g(R\"x(qqq\n" 9207 "multiline raw string literal xxxxxxxxxxxxxx\n" 9208 ")x\",\n" 9209 " a),\n" 9210 " b);", 9211 format("fffffffffff(g(R\"x(qqq\n" 9212 "multiline raw string literal xxxxxxxxxxxxxx\n" 9213 ")x\", a), b);", 9214 getGoogleStyleWithColumns(20))); 9215 9216 EXPECT_EQ("fffffffffff(R\"x(\n" 9217 "multiline raw string literal xxxxxxxxxxxxxx\n" 9218 ")x\");", 9219 format("fffffffffff(R\"x(\n" 9220 "multiline raw string literal xxxxxxxxxxxxxx\n" 9221 ")x\");", 9222 getGoogleStyleWithColumns(20))); 9223 EXPECT_EQ("fffffffffff(R\"x(\n" 9224 "multiline raw string literal xxxxxxxxxxxxxx\n" 9225 ")x\" + bbbbbb);", 9226 format("fffffffffff(R\"x(\n" 9227 "multiline raw string literal xxxxxxxxxxxxxx\n" 9228 ")x\" + bbbbbb);", 9229 getGoogleStyleWithColumns(20))); 9230 EXPECT_EQ("fffffffffff(\n" 9231 " R\"x(\n" 9232 "multiline raw string literal xxxxxxxxxxxxxx\n" 9233 ")x\" +\n" 9234 " bbbbbb);", 9235 format("fffffffffff(\n" 9236 " R\"x(\n" 9237 "multiline raw string literal xxxxxxxxxxxxxx\n" 9238 ")x\" + bbbbbb);", 9239 getGoogleStyleWithColumns(20))); 9240 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 9241 format("fffffffffff(\n" 9242 " R\"(single line raw string)\" + bbbbbb);")); 9243 } 9244 9245 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 9246 verifyFormat("string a = \"unterminated;"); 9247 EXPECT_EQ("function(\"unterminated,\n" 9248 " OtherParameter);", 9249 format("function( \"unterminated,\n" 9250 " OtherParameter);")); 9251 } 9252 9253 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9254 FormatStyle Style = getLLVMStyle(); 9255 Style.Standard = FormatStyle::LS_Cpp03; 9256 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9257 format("#define x(_a) printf(\"foo\"_a);", Style)); 9258 } 9259 9260 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9261 9262 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9263 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9264 " \"ddeeefff\");", 9265 format("someFunction(\"aaabbbcccdddeeefff\");", 9266 getLLVMStyleWithColumns(25))); 9267 EXPECT_EQ("someFunction1234567890(\n" 9268 " \"aaabbbcccdddeeefff\");", 9269 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9270 getLLVMStyleWithColumns(26))); 9271 EXPECT_EQ("someFunction1234567890(\n" 9272 " \"aaabbbcccdddeeeff\"\n" 9273 " \"f\");", 9274 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9275 getLLVMStyleWithColumns(25))); 9276 EXPECT_EQ("someFunction1234567890(\n" 9277 " \"aaabbbcccdddeeeff\"\n" 9278 " \"f\");", 9279 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9280 getLLVMStyleWithColumns(24))); 9281 EXPECT_EQ("someFunction(\n" 9282 " \"aaabbbcc ddde \"\n" 9283 " \"efff\");", 9284 format("someFunction(\"aaabbbcc ddde efff\");", 9285 getLLVMStyleWithColumns(25))); 9286 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9287 " \"ddeeefff\");", 9288 format("someFunction(\"aaabbbccc ddeeefff\");", 9289 getLLVMStyleWithColumns(25))); 9290 EXPECT_EQ("someFunction1234567890(\n" 9291 " \"aaabb \"\n" 9292 " \"cccdddeeefff\");", 9293 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9294 getLLVMStyleWithColumns(25))); 9295 EXPECT_EQ("#define A \\\n" 9296 " string s = \\\n" 9297 " \"123456789\" \\\n" 9298 " \"0\"; \\\n" 9299 " int i;", 9300 format("#define A string s = \"1234567890\"; int i;", 9301 getLLVMStyleWithColumns(20))); 9302 EXPECT_EQ("someFunction(\n" 9303 " \"aaabbbcc \"\n" 9304 " \"dddeeefff\");", 9305 format("someFunction(\"aaabbbcc dddeeefff\");", 9306 getLLVMStyleWithColumns(25))); 9307 } 9308 9309 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9310 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9311 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9312 EXPECT_EQ("\"test\"\n" 9313 "\"\\n\"", 9314 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9315 EXPECT_EQ("\"tes\\\\\"\n" 9316 "\"n\"", 9317 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9318 EXPECT_EQ("\"\\\\\\\\\"\n" 9319 "\"\\n\"", 9320 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9321 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9322 EXPECT_EQ("\"\\uff01\"\n" 9323 "\"test\"", 9324 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9325 EXPECT_EQ("\"\\Uff01ff02\"", 9326 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9327 EXPECT_EQ("\"\\x000000000001\"\n" 9328 "\"next\"", 9329 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9330 EXPECT_EQ("\"\\x000000000001next\"", 9331 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9332 EXPECT_EQ("\"\\x000000000001\"", 9333 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9334 EXPECT_EQ("\"test\"\n" 9335 "\"\\000000\"\n" 9336 "\"000001\"", 9337 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9338 EXPECT_EQ("\"test\\000\"\n" 9339 "\"00000000\"\n" 9340 "\"1\"", 9341 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9342 } 9343 9344 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9345 verifyFormat("void f() {\n" 9346 " return g() {}\n" 9347 " void h() {}"); 9348 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9349 "g();\n" 9350 "}"); 9351 } 9352 9353 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9354 verifyFormat( 9355 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9356 } 9357 9358 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9359 verifyFormat("class X {\n" 9360 " void f() {\n" 9361 " }\n" 9362 "};", 9363 getLLVMStyleWithColumns(12)); 9364 } 9365 9366 TEST_F(FormatTest, ConfigurableIndentWidth) { 9367 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9368 EightIndent.IndentWidth = 8; 9369 EightIndent.ContinuationIndentWidth = 8; 9370 verifyFormat("void f() {\n" 9371 " someFunction();\n" 9372 " if (true) {\n" 9373 " f();\n" 9374 " }\n" 9375 "}", 9376 EightIndent); 9377 verifyFormat("class X {\n" 9378 " void f() {\n" 9379 " }\n" 9380 "};", 9381 EightIndent); 9382 verifyFormat("int x[] = {\n" 9383 " call(),\n" 9384 " call()};", 9385 EightIndent); 9386 } 9387 9388 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9389 verifyFormat("double\n" 9390 "f();", 9391 getLLVMStyleWithColumns(8)); 9392 } 9393 9394 TEST_F(FormatTest, ConfigurableUseOfTab) { 9395 FormatStyle Tab = getLLVMStyleWithColumns(42); 9396 Tab.IndentWidth = 8; 9397 Tab.UseTab = FormatStyle::UT_Always; 9398 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9399 9400 EXPECT_EQ("if (aaaaaaaa && // q\n" 9401 " bb)\t\t// w\n" 9402 "\t;", 9403 format("if (aaaaaaaa &&// q\n" 9404 "bb)// w\n" 9405 ";", 9406 Tab)); 9407 EXPECT_EQ("if (aaa && bbb) // w\n" 9408 "\t;", 9409 format("if(aaa&&bbb)// w\n" 9410 ";", 9411 Tab)); 9412 9413 verifyFormat("class X {\n" 9414 "\tvoid f() {\n" 9415 "\t\tsomeFunction(parameter1,\n" 9416 "\t\t\t parameter2);\n" 9417 "\t}\n" 9418 "};", 9419 Tab); 9420 verifyFormat("#define A \\\n" 9421 "\tvoid f() { \\\n" 9422 "\t\tsomeFunction( \\\n" 9423 "\t\t parameter1, \\\n" 9424 "\t\t parameter2); \\\n" 9425 "\t}", 9426 Tab); 9427 verifyFormat("int a;\t // x\n" 9428 "int bbbbbbbb; // x\n", 9429 Tab); 9430 9431 Tab.TabWidth = 4; 9432 Tab.IndentWidth = 8; 9433 verifyFormat("class TabWidth4Indent8 {\n" 9434 "\t\tvoid f() {\n" 9435 "\t\t\t\tsomeFunction(parameter1,\n" 9436 "\t\t\t\t\t\t\t parameter2);\n" 9437 "\t\t}\n" 9438 "};", 9439 Tab); 9440 9441 Tab.TabWidth = 4; 9442 Tab.IndentWidth = 4; 9443 verifyFormat("class TabWidth4Indent4 {\n" 9444 "\tvoid f() {\n" 9445 "\t\tsomeFunction(parameter1,\n" 9446 "\t\t\t\t\t parameter2);\n" 9447 "\t}\n" 9448 "};", 9449 Tab); 9450 9451 Tab.TabWidth = 8; 9452 Tab.IndentWidth = 4; 9453 verifyFormat("class TabWidth8Indent4 {\n" 9454 " void f() {\n" 9455 "\tsomeFunction(parameter1,\n" 9456 "\t\t parameter2);\n" 9457 " }\n" 9458 "};", 9459 Tab); 9460 9461 Tab.TabWidth = 8; 9462 Tab.IndentWidth = 8; 9463 EXPECT_EQ("/*\n" 9464 "\t a\t\tcomment\n" 9465 "\t in multiple lines\n" 9466 " */", 9467 format(" /*\t \t \n" 9468 " \t \t a\t\tcomment\t \t\n" 9469 " \t \t in multiple lines\t\n" 9470 " \t */", 9471 Tab)); 9472 9473 Tab.UseTab = FormatStyle::UT_ForIndentation; 9474 verifyFormat("{\n" 9475 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9476 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9477 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9478 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9479 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9480 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9481 "};", 9482 Tab); 9483 verifyFormat("enum AA {\n" 9484 "\ta1, // Force multiple lines\n" 9485 "\ta2,\n" 9486 "\ta3\n" 9487 "};", 9488 Tab); 9489 EXPECT_EQ("if (aaaaaaaa && // q\n" 9490 " bb) // w\n" 9491 "\t;", 9492 format("if (aaaaaaaa &&// q\n" 9493 "bb)// w\n" 9494 ";", 9495 Tab)); 9496 verifyFormat("class X {\n" 9497 "\tvoid f() {\n" 9498 "\t\tsomeFunction(parameter1,\n" 9499 "\t\t parameter2);\n" 9500 "\t}\n" 9501 "};", 9502 Tab); 9503 verifyFormat("{\n" 9504 "\tQ(\n" 9505 "\t {\n" 9506 "\t\t int a;\n" 9507 "\t\t someFunction(aaaaaaaa,\n" 9508 "\t\t bbbbbbb);\n" 9509 "\t },\n" 9510 "\t p);\n" 9511 "}", 9512 Tab); 9513 EXPECT_EQ("{\n" 9514 "\t/* aaaa\n" 9515 "\t bbbb */\n" 9516 "}", 9517 format("{\n" 9518 "/* aaaa\n" 9519 " bbbb */\n" 9520 "}", 9521 Tab)); 9522 EXPECT_EQ("{\n" 9523 "\t/*\n" 9524 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9525 "\t bbbbbbbbbbbbb\n" 9526 "\t*/\n" 9527 "}", 9528 format("{\n" 9529 "/*\n" 9530 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9531 "*/\n" 9532 "}", 9533 Tab)); 9534 EXPECT_EQ("{\n" 9535 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9536 "\t// bbbbbbbbbbbbb\n" 9537 "}", 9538 format("{\n" 9539 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9540 "}", 9541 Tab)); 9542 EXPECT_EQ("{\n" 9543 "\t/*\n" 9544 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9545 "\t bbbbbbbbbbbbb\n" 9546 "\t*/\n" 9547 "}", 9548 format("{\n" 9549 "\t/*\n" 9550 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9551 "\t*/\n" 9552 "}", 9553 Tab)); 9554 EXPECT_EQ("{\n" 9555 "\t/*\n" 9556 "\n" 9557 "\t*/\n" 9558 "}", 9559 format("{\n" 9560 "\t/*\n" 9561 "\n" 9562 "\t*/\n" 9563 "}", 9564 Tab)); 9565 EXPECT_EQ("{\n" 9566 "\t/*\n" 9567 " asdf\n" 9568 "\t*/\n" 9569 "}", 9570 format("{\n" 9571 "\t/*\n" 9572 " asdf\n" 9573 "\t*/\n" 9574 "}", 9575 Tab)); 9576 9577 Tab.UseTab = FormatStyle::UT_Never; 9578 EXPECT_EQ("/*\n" 9579 " a\t\tcomment\n" 9580 " in multiple lines\n" 9581 " */", 9582 format(" /*\t \t \n" 9583 " \t \t a\t\tcomment\t \t\n" 9584 " \t \t in multiple lines\t\n" 9585 " \t */", 9586 Tab)); 9587 EXPECT_EQ("/* some\n" 9588 " comment */", 9589 format(" \t \t /* some\n" 9590 " \t \t comment */", 9591 Tab)); 9592 EXPECT_EQ("int a; /* some\n" 9593 " comment */", 9594 format(" \t \t int a; /* some\n" 9595 " \t \t comment */", 9596 Tab)); 9597 9598 EXPECT_EQ("int a; /* some\n" 9599 "comment */", 9600 format(" \t \t int\ta; /* some\n" 9601 " \t \t comment */", 9602 Tab)); 9603 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9604 " comment */", 9605 format(" \t \t f(\"\t\t\"); /* some\n" 9606 " \t \t comment */", 9607 Tab)); 9608 EXPECT_EQ("{\n" 9609 " /*\n" 9610 " * Comment\n" 9611 " */\n" 9612 " int i;\n" 9613 "}", 9614 format("{\n" 9615 "\t/*\n" 9616 "\t * Comment\n" 9617 "\t */\n" 9618 "\t int i;\n" 9619 "}")); 9620 9621 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 9622 Tab.TabWidth = 8; 9623 Tab.IndentWidth = 8; 9624 EXPECT_EQ("if (aaaaaaaa && // q\n" 9625 " bb) // w\n" 9626 "\t;", 9627 format("if (aaaaaaaa &&// q\n" 9628 "bb)// w\n" 9629 ";", 9630 Tab)); 9631 EXPECT_EQ("if (aaa && bbb) // w\n" 9632 "\t;", 9633 format("if(aaa&&bbb)// w\n" 9634 ";", 9635 Tab)); 9636 verifyFormat("class X {\n" 9637 "\tvoid f() {\n" 9638 "\t\tsomeFunction(parameter1,\n" 9639 "\t\t\t parameter2);\n" 9640 "\t}\n" 9641 "};", 9642 Tab); 9643 verifyFormat("#define A \\\n" 9644 "\tvoid f() { \\\n" 9645 "\t\tsomeFunction( \\\n" 9646 "\t\t parameter1, \\\n" 9647 "\t\t parameter2); \\\n" 9648 "\t}", 9649 Tab); 9650 Tab.TabWidth = 4; 9651 Tab.IndentWidth = 8; 9652 verifyFormat("class TabWidth4Indent8 {\n" 9653 "\t\tvoid f() {\n" 9654 "\t\t\t\tsomeFunction(parameter1,\n" 9655 "\t\t\t\t\t\t\t parameter2);\n" 9656 "\t\t}\n" 9657 "};", 9658 Tab); 9659 Tab.TabWidth = 4; 9660 Tab.IndentWidth = 4; 9661 verifyFormat("class TabWidth4Indent4 {\n" 9662 "\tvoid f() {\n" 9663 "\t\tsomeFunction(parameter1,\n" 9664 "\t\t\t\t\t parameter2);\n" 9665 "\t}\n" 9666 "};", 9667 Tab); 9668 Tab.TabWidth = 8; 9669 Tab.IndentWidth = 4; 9670 verifyFormat("class TabWidth8Indent4 {\n" 9671 " void f() {\n" 9672 "\tsomeFunction(parameter1,\n" 9673 "\t\t parameter2);\n" 9674 " }\n" 9675 "};", 9676 Tab); 9677 Tab.TabWidth = 8; 9678 Tab.IndentWidth = 8; 9679 EXPECT_EQ("/*\n" 9680 "\t a\t\tcomment\n" 9681 "\t in multiple lines\n" 9682 " */", 9683 format(" /*\t \t \n" 9684 " \t \t a\t\tcomment\t \t\n" 9685 " \t \t in multiple lines\t\n" 9686 " \t */", 9687 Tab)); 9688 verifyFormat("{\n" 9689 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9690 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9691 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9692 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9693 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9694 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9695 "};", 9696 Tab); 9697 verifyFormat("enum AA {\n" 9698 "\ta1, // Force multiple lines\n" 9699 "\ta2,\n" 9700 "\ta3\n" 9701 "};", 9702 Tab); 9703 EXPECT_EQ("if (aaaaaaaa && // q\n" 9704 " bb) // w\n" 9705 "\t;", 9706 format("if (aaaaaaaa &&// q\n" 9707 "bb)// w\n" 9708 ";", 9709 Tab)); 9710 verifyFormat("class X {\n" 9711 "\tvoid f() {\n" 9712 "\t\tsomeFunction(parameter1,\n" 9713 "\t\t\t parameter2);\n" 9714 "\t}\n" 9715 "};", 9716 Tab); 9717 verifyFormat("{\n" 9718 "\tQ(\n" 9719 "\t {\n" 9720 "\t\t int a;\n" 9721 "\t\t someFunction(aaaaaaaa,\n" 9722 "\t\t\t\t bbbbbbb);\n" 9723 "\t },\n" 9724 "\t p);\n" 9725 "}", 9726 Tab); 9727 EXPECT_EQ("{\n" 9728 "\t/* aaaa\n" 9729 "\t bbbb */\n" 9730 "}", 9731 format("{\n" 9732 "/* aaaa\n" 9733 " bbbb */\n" 9734 "}", 9735 Tab)); 9736 EXPECT_EQ("{\n" 9737 "\t/*\n" 9738 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9739 "\t bbbbbbbbbbbbb\n" 9740 "\t*/\n" 9741 "}", 9742 format("{\n" 9743 "/*\n" 9744 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9745 "*/\n" 9746 "}", 9747 Tab)); 9748 EXPECT_EQ("{\n" 9749 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9750 "\t// bbbbbbbbbbbbb\n" 9751 "}", 9752 format("{\n" 9753 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9754 "}", 9755 Tab)); 9756 EXPECT_EQ("{\n" 9757 "\t/*\n" 9758 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9759 "\t bbbbbbbbbbbbb\n" 9760 "\t*/\n" 9761 "}", 9762 format("{\n" 9763 "\t/*\n" 9764 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9765 "\t*/\n" 9766 "}", 9767 Tab)); 9768 EXPECT_EQ("{\n" 9769 "\t/*\n" 9770 "\n" 9771 "\t*/\n" 9772 "}", 9773 format("{\n" 9774 "\t/*\n" 9775 "\n" 9776 "\t*/\n" 9777 "}", 9778 Tab)); 9779 EXPECT_EQ("{\n" 9780 "\t/*\n" 9781 " asdf\n" 9782 "\t*/\n" 9783 "}", 9784 format("{\n" 9785 "\t/*\n" 9786 " asdf\n" 9787 "\t*/\n" 9788 "}", 9789 Tab)); 9790 EXPECT_EQ("/*\n" 9791 "\t a\t\tcomment\n" 9792 "\t in multiple lines\n" 9793 " */", 9794 format(" /*\t \t \n" 9795 " \t \t a\t\tcomment\t \t\n" 9796 " \t \t in multiple lines\t\n" 9797 " \t */", 9798 Tab)); 9799 EXPECT_EQ("/* some\n" 9800 " comment */", 9801 format(" \t \t /* some\n" 9802 " \t \t comment */", 9803 Tab)); 9804 EXPECT_EQ("int a; /* some\n" 9805 " comment */", 9806 format(" \t \t int a; /* some\n" 9807 " \t \t comment */", 9808 Tab)); 9809 EXPECT_EQ("int a; /* some\n" 9810 "comment */", 9811 format(" \t \t int\ta; /* some\n" 9812 " \t \t comment */", 9813 Tab)); 9814 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9815 " comment */", 9816 format(" \t \t f(\"\t\t\"); /* some\n" 9817 " \t \t comment */", 9818 Tab)); 9819 EXPECT_EQ("{\n" 9820 " /*\n" 9821 " * Comment\n" 9822 " */\n" 9823 " int i;\n" 9824 "}", 9825 format("{\n" 9826 "\t/*\n" 9827 "\t * Comment\n" 9828 "\t */\n" 9829 "\t int i;\n" 9830 "}")); 9831 Tab.AlignConsecutiveAssignments = true; 9832 Tab.AlignConsecutiveDeclarations = true; 9833 Tab.TabWidth = 4; 9834 Tab.IndentWidth = 4; 9835 verifyFormat("class Assign {\n" 9836 "\tvoid f() {\n" 9837 "\t\tint x = 123;\n" 9838 "\t\tint random = 4;\n" 9839 "\t\tstd::string alphabet =\n" 9840 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 9841 "\t}\n" 9842 "};", 9843 Tab); 9844 } 9845 9846 TEST_F(FormatTest, CalculatesOriginalColumn) { 9847 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9848 "q\"; /* some\n" 9849 " comment */", 9850 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9851 "q\"; /* some\n" 9852 " comment */", 9853 getLLVMStyle())); 9854 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 9855 "/* some\n" 9856 " comment */", 9857 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 9858 " /* some\n" 9859 " comment */", 9860 getLLVMStyle())); 9861 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9862 "qqq\n" 9863 "/* some\n" 9864 " comment */", 9865 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9866 "qqq\n" 9867 " /* some\n" 9868 " comment */", 9869 getLLVMStyle())); 9870 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9871 "wwww; /* some\n" 9872 " comment */", 9873 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9874 "wwww; /* some\n" 9875 " comment */", 9876 getLLVMStyle())); 9877 } 9878 9879 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 9880 FormatStyle NoSpace = getLLVMStyle(); 9881 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 9882 9883 verifyFormat("while(true)\n" 9884 " continue;", 9885 NoSpace); 9886 verifyFormat("for(;;)\n" 9887 " continue;", 9888 NoSpace); 9889 verifyFormat("if(true)\n" 9890 " f();\n" 9891 "else if(true)\n" 9892 " f();", 9893 NoSpace); 9894 verifyFormat("do {\n" 9895 " do_something();\n" 9896 "} while(something());", 9897 NoSpace); 9898 verifyFormat("switch(x) {\n" 9899 "default:\n" 9900 " break;\n" 9901 "}", 9902 NoSpace); 9903 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 9904 verifyFormat("size_t x = sizeof(x);", NoSpace); 9905 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 9906 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 9907 verifyFormat("alignas(128) char a[128];", NoSpace); 9908 verifyFormat("size_t x = alignof(MyType);", NoSpace); 9909 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 9910 verifyFormat("int f() throw(Deprecated);", NoSpace); 9911 verifyFormat("typedef void (*cb)(int);", NoSpace); 9912 verifyFormat("T A::operator()();", NoSpace); 9913 verifyFormat("X A::operator++(T);", NoSpace); 9914 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 9915 9916 FormatStyle Space = getLLVMStyle(); 9917 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 9918 9919 verifyFormat("int f ();", Space); 9920 verifyFormat("void f (int a, T b) {\n" 9921 " while (true)\n" 9922 " continue;\n" 9923 "}", 9924 Space); 9925 verifyFormat("if (true)\n" 9926 " f ();\n" 9927 "else if (true)\n" 9928 " f ();", 9929 Space); 9930 verifyFormat("do {\n" 9931 " do_something ();\n" 9932 "} while (something ());", 9933 Space); 9934 verifyFormat("switch (x) {\n" 9935 "default:\n" 9936 " break;\n" 9937 "}", 9938 Space); 9939 verifyFormat("A::A () : a (1) {}", Space); 9940 verifyFormat("void f () __attribute__ ((asdf));", Space); 9941 verifyFormat("*(&a + 1);\n" 9942 "&((&a)[1]);\n" 9943 "a[(b + c) * d];\n" 9944 "(((a + 1) * 2) + 3) * 4;", 9945 Space); 9946 verifyFormat("#define A(x) x", Space); 9947 verifyFormat("#define A (x) x", Space); 9948 verifyFormat("#if defined(x)\n" 9949 "#endif", 9950 Space); 9951 verifyFormat("auto i = std::make_unique<int> (5);", Space); 9952 verifyFormat("size_t x = sizeof (x);", Space); 9953 verifyFormat("auto f (int x) -> decltype (x);", Space); 9954 verifyFormat("int f (T x) noexcept (x.create ());", Space); 9955 verifyFormat("alignas (128) char a[128];", Space); 9956 verifyFormat("size_t x = alignof (MyType);", Space); 9957 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 9958 verifyFormat("int f () throw (Deprecated);", Space); 9959 verifyFormat("typedef void (*cb) (int);", Space); 9960 verifyFormat("T A::operator() ();", Space); 9961 verifyFormat("X A::operator++ (T);", Space); 9962 verifyFormat("auto lambda = [] () { return 0; };", Space); 9963 verifyFormat("int x = int (y);", Space); 9964 9965 FormatStyle SomeSpace = getLLVMStyle(); 9966 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 9967 9968 verifyFormat("[]() -> float {}", SomeSpace); 9969 verifyFormat("[] (auto foo) {}", SomeSpace); 9970 verifyFormat("[foo]() -> int {}", SomeSpace); 9971 verifyFormat("int f();", SomeSpace); 9972 verifyFormat("void f (int a, T b) {\n" 9973 " while (true)\n" 9974 " continue;\n" 9975 "}", 9976 SomeSpace); 9977 verifyFormat("if (true)\n" 9978 " f();\n" 9979 "else if (true)\n" 9980 " f();", 9981 SomeSpace); 9982 verifyFormat("do {\n" 9983 " do_something();\n" 9984 "} while (something());", 9985 SomeSpace); 9986 verifyFormat("switch (x) {\n" 9987 "default:\n" 9988 " break;\n" 9989 "}", 9990 SomeSpace); 9991 verifyFormat("A::A() : a (1) {}", SomeSpace); 9992 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 9993 verifyFormat("*(&a + 1);\n" 9994 "&((&a)[1]);\n" 9995 "a[(b + c) * d];\n" 9996 "(((a + 1) * 2) + 3) * 4;", 9997 SomeSpace); 9998 verifyFormat("#define A(x) x", SomeSpace); 9999 verifyFormat("#define A (x) x", SomeSpace); 10000 verifyFormat("#if defined(x)\n" 10001 "#endif", 10002 SomeSpace); 10003 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 10004 verifyFormat("size_t x = sizeof (x);", SomeSpace); 10005 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 10006 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 10007 verifyFormat("alignas (128) char a[128];", SomeSpace); 10008 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 10009 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 10010 SomeSpace); 10011 verifyFormat("int f() throw (Deprecated);", SomeSpace); 10012 verifyFormat("typedef void (*cb) (int);", SomeSpace); 10013 verifyFormat("T A::operator()();", SomeSpace); 10014 verifyFormat("X A::operator++ (T);", SomeSpace); 10015 verifyFormat("int x = int (y);", SomeSpace); 10016 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 10017 } 10018 10019 TEST_F(FormatTest, SpaceAfterLogicalNot) { 10020 FormatStyle Spaces = getLLVMStyle(); 10021 Spaces.SpaceAfterLogicalNot = true; 10022 10023 verifyFormat("bool x = ! y", Spaces); 10024 verifyFormat("if (! isFailure())", Spaces); 10025 verifyFormat("if (! (a && b))", Spaces); 10026 verifyFormat("\"Error!\"", Spaces); 10027 verifyFormat("! ! x", Spaces); 10028 } 10029 10030 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 10031 FormatStyle Spaces = getLLVMStyle(); 10032 10033 Spaces.SpacesInParentheses = true; 10034 verifyFormat("do_something( ::globalVar );", Spaces); 10035 verifyFormat("call( x, y, z );", Spaces); 10036 verifyFormat("call();", Spaces); 10037 verifyFormat("std::function<void( int, int )> callback;", Spaces); 10038 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 10039 Spaces); 10040 verifyFormat("while ( (bool)1 )\n" 10041 " continue;", 10042 Spaces); 10043 verifyFormat("for ( ;; )\n" 10044 " continue;", 10045 Spaces); 10046 verifyFormat("if ( true )\n" 10047 " f();\n" 10048 "else if ( true )\n" 10049 " f();", 10050 Spaces); 10051 verifyFormat("do {\n" 10052 " do_something( (int)i );\n" 10053 "} while ( something() );", 10054 Spaces); 10055 verifyFormat("switch ( x ) {\n" 10056 "default:\n" 10057 " break;\n" 10058 "}", 10059 Spaces); 10060 10061 Spaces.SpacesInParentheses = false; 10062 Spaces.SpacesInCStyleCastParentheses = true; 10063 verifyFormat("Type *A = ( Type * )P;", Spaces); 10064 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 10065 verifyFormat("x = ( int32 )y;", Spaces); 10066 verifyFormat("int a = ( int )(2.0f);", Spaces); 10067 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 10068 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 10069 verifyFormat("#define x (( int )-1)", Spaces); 10070 10071 // Run the first set of tests again with: 10072 Spaces.SpacesInParentheses = false; 10073 Spaces.SpaceInEmptyParentheses = true; 10074 Spaces.SpacesInCStyleCastParentheses = true; 10075 verifyFormat("call(x, y, z);", Spaces); 10076 verifyFormat("call( );", Spaces); 10077 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10078 verifyFormat("while (( bool )1)\n" 10079 " continue;", 10080 Spaces); 10081 verifyFormat("for (;;)\n" 10082 " continue;", 10083 Spaces); 10084 verifyFormat("if (true)\n" 10085 " f( );\n" 10086 "else if (true)\n" 10087 " f( );", 10088 Spaces); 10089 verifyFormat("do {\n" 10090 " do_something(( int )i);\n" 10091 "} while (something( ));", 10092 Spaces); 10093 verifyFormat("switch (x) {\n" 10094 "default:\n" 10095 " break;\n" 10096 "}", 10097 Spaces); 10098 10099 // Run the first set of tests again with: 10100 Spaces.SpaceAfterCStyleCast = true; 10101 verifyFormat("call(x, y, z);", Spaces); 10102 verifyFormat("call( );", Spaces); 10103 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10104 verifyFormat("while (( bool ) 1)\n" 10105 " continue;", 10106 Spaces); 10107 verifyFormat("for (;;)\n" 10108 " continue;", 10109 Spaces); 10110 verifyFormat("if (true)\n" 10111 " f( );\n" 10112 "else if (true)\n" 10113 " f( );", 10114 Spaces); 10115 verifyFormat("do {\n" 10116 " do_something(( int ) i);\n" 10117 "} while (something( ));", 10118 Spaces); 10119 verifyFormat("switch (x) {\n" 10120 "default:\n" 10121 " break;\n" 10122 "}", 10123 Spaces); 10124 10125 // Run subset of tests again with: 10126 Spaces.SpacesInCStyleCastParentheses = false; 10127 Spaces.SpaceAfterCStyleCast = true; 10128 verifyFormat("while ((bool) 1)\n" 10129 " continue;", 10130 Spaces); 10131 verifyFormat("do {\n" 10132 " do_something((int) i);\n" 10133 "} while (something( ));", 10134 Spaces); 10135 } 10136 10137 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 10138 verifyFormat("int a[5];"); 10139 verifyFormat("a[3] += 42;"); 10140 10141 FormatStyle Spaces = getLLVMStyle(); 10142 Spaces.SpacesInSquareBrackets = true; 10143 // Lambdas unchanged. 10144 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 10145 verifyFormat("return [i, args...] {};", Spaces); 10146 10147 // Not lambdas. 10148 verifyFormat("int a[ 5 ];", Spaces); 10149 verifyFormat("a[ 3 ] += 42;", Spaces); 10150 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 10151 verifyFormat("double &operator[](int i) { return 0; }\n" 10152 "int i;", 10153 Spaces); 10154 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 10155 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 10156 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 10157 } 10158 10159 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 10160 verifyFormat("int a = 5;"); 10161 verifyFormat("a += 42;"); 10162 verifyFormat("a or_eq 8;"); 10163 10164 FormatStyle Spaces = getLLVMStyle(); 10165 Spaces.SpaceBeforeAssignmentOperators = false; 10166 verifyFormat("int a= 5;", Spaces); 10167 verifyFormat("a+= 42;", Spaces); 10168 verifyFormat("a or_eq 8;", Spaces); 10169 } 10170 10171 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 10172 verifyFormat("class Foo : public Bar {};"); 10173 verifyFormat("Foo::Foo() : foo(1) {}"); 10174 verifyFormat("for (auto a : b) {\n}"); 10175 verifyFormat("int x = a ? b : c;"); 10176 verifyFormat("{\n" 10177 "label0:\n" 10178 " int x = 0;\n" 10179 "}"); 10180 verifyFormat("switch (x) {\n" 10181 "case 1:\n" 10182 "default:\n" 10183 "}"); 10184 10185 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 10186 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 10187 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 10188 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 10189 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 10190 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 10191 verifyFormat("{\n" 10192 "label1:\n" 10193 " int x = 0;\n" 10194 "}", 10195 CtorInitializerStyle); 10196 verifyFormat("switch (x) {\n" 10197 "case 1:\n" 10198 "default:\n" 10199 "}", 10200 CtorInitializerStyle); 10201 CtorInitializerStyle.BreakConstructorInitializers = 10202 FormatStyle::BCIS_AfterColon; 10203 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 10204 " aaaaaaaaaaaaaaaa(1),\n" 10205 " bbbbbbbbbbbbbbbb(2) {}", 10206 CtorInitializerStyle); 10207 CtorInitializerStyle.BreakConstructorInitializers = 10208 FormatStyle::BCIS_BeforeComma; 10209 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10210 " : aaaaaaaaaaaaaaaa(1)\n" 10211 " , bbbbbbbbbbbbbbbb(2) {}", 10212 CtorInitializerStyle); 10213 CtorInitializerStyle.BreakConstructorInitializers = 10214 FormatStyle::BCIS_BeforeColon; 10215 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10216 " : aaaaaaaaaaaaaaaa(1),\n" 10217 " bbbbbbbbbbbbbbbb(2) {}", 10218 CtorInitializerStyle); 10219 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 10220 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10221 ": aaaaaaaaaaaaaaaa(1),\n" 10222 " bbbbbbbbbbbbbbbb(2) {}", 10223 CtorInitializerStyle); 10224 10225 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 10226 InheritanceStyle.SpaceBeforeInheritanceColon = false; 10227 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 10228 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 10229 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 10230 verifyFormat("int x = a ? b : c;", InheritanceStyle); 10231 verifyFormat("{\n" 10232 "label2:\n" 10233 " int x = 0;\n" 10234 "}", 10235 InheritanceStyle); 10236 verifyFormat("switch (x) {\n" 10237 "case 1:\n" 10238 "default:\n" 10239 "}", 10240 InheritanceStyle); 10241 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 10242 verifyFormat("class Foooooooooooooooooooooo:\n" 10243 " public aaaaaaaaaaaaaaaaaa,\n" 10244 " public bbbbbbbbbbbbbbbbbb {\n" 10245 "}", 10246 InheritanceStyle); 10247 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 10248 verifyFormat("class Foooooooooooooooooooooo\n" 10249 " : public aaaaaaaaaaaaaaaaaa\n" 10250 " , public bbbbbbbbbbbbbbbbbb {\n" 10251 "}", 10252 InheritanceStyle); 10253 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 10254 verifyFormat("class Foooooooooooooooooooooo\n" 10255 " : public aaaaaaaaaaaaaaaaaa,\n" 10256 " public bbbbbbbbbbbbbbbbbb {\n" 10257 "}", 10258 InheritanceStyle); 10259 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 10260 verifyFormat("class Foooooooooooooooooooooo\n" 10261 ": public aaaaaaaaaaaaaaaaaa,\n" 10262 " public bbbbbbbbbbbbbbbbbb {}", 10263 InheritanceStyle); 10264 10265 FormatStyle ForLoopStyle = getLLVMStyle(); 10266 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 10267 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 10268 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 10269 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 10270 verifyFormat("int x = a ? b : c;", ForLoopStyle); 10271 verifyFormat("{\n" 10272 "label2:\n" 10273 " int x = 0;\n" 10274 "}", 10275 ForLoopStyle); 10276 verifyFormat("switch (x) {\n" 10277 "case 1:\n" 10278 "default:\n" 10279 "}", 10280 ForLoopStyle); 10281 10282 FormatStyle NoSpaceStyle = getLLVMStyle(); 10283 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 10284 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 10285 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 10286 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 10287 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 10288 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 10289 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 10290 verifyFormat("{\n" 10291 "label3:\n" 10292 " int x = 0;\n" 10293 "}", 10294 NoSpaceStyle); 10295 verifyFormat("switch (x) {\n" 10296 "case 1:\n" 10297 "default:\n" 10298 "}", 10299 NoSpaceStyle); 10300 } 10301 10302 TEST_F(FormatTest, AlignConsecutiveMacros) { 10303 FormatStyle Style = getLLVMStyle(); 10304 Style.AlignConsecutiveAssignments = true; 10305 Style.AlignConsecutiveDeclarations = true; 10306 Style.AlignConsecutiveMacros = false; 10307 10308 verifyFormat("#define a 3\n" 10309 "#define bbbb 4\n" 10310 "#define ccc (5)", 10311 Style); 10312 10313 verifyFormat("#define f(x) (x * x)\n" 10314 "#define fff(x, y, z) (x * y + z)\n" 10315 "#define ffff(x, y) (x - y)", 10316 Style); 10317 10318 verifyFormat("#define foo(x, y) (x + y)\n" 10319 "#define bar (5, 6)(2 + 2)", 10320 Style); 10321 10322 verifyFormat("#define a 3\n" 10323 "#define bbbb 4\n" 10324 "#define ccc (5)\n" 10325 "#define f(x) (x * x)\n" 10326 "#define fff(x, y, z) (x * y + z)\n" 10327 "#define ffff(x, y) (x - y)", 10328 Style); 10329 10330 Style.AlignConsecutiveMacros = true; 10331 verifyFormat("#define a 3\n" 10332 "#define bbbb 4\n" 10333 "#define ccc (5)", 10334 Style); 10335 10336 verifyFormat("#define f(x) (x * x)\n" 10337 "#define fff(x, y, z) (x * y + z)\n" 10338 "#define ffff(x, y) (x - y)", 10339 Style); 10340 10341 verifyFormat("#define foo(x, y) (x + y)\n" 10342 "#define bar (5, 6)(2 + 2)", 10343 Style); 10344 10345 verifyFormat("#define a 3\n" 10346 "#define bbbb 4\n" 10347 "#define ccc (5)\n" 10348 "#define f(x) (x * x)\n" 10349 "#define fff(x, y, z) (x * y + z)\n" 10350 "#define ffff(x, y) (x - y)", 10351 Style); 10352 10353 verifyFormat("#define a 5\n" 10354 "#define foo(x, y) (x + y)\n" 10355 "#define CCC (6)\n" 10356 "auto lambda = []() {\n" 10357 " auto ii = 0;\n" 10358 " float j = 0;\n" 10359 " return 0;\n" 10360 "};\n" 10361 "int i = 0;\n" 10362 "float i2 = 0;\n" 10363 "auto v = type{\n" 10364 " i = 1, //\n" 10365 " (i = 2), //\n" 10366 " i = 3 //\n" 10367 "};", 10368 Style); 10369 10370 Style.AlignConsecutiveMacros = false; 10371 Style.ColumnLimit = 20; 10372 10373 verifyFormat("#define a \\\n" 10374 " \"aabbbbbbbbbbbb\"\n" 10375 "#define D \\\n" 10376 " \"aabbbbbbbbbbbb\" \\\n" 10377 " \"ccddeeeeeeeee\"\n" 10378 "#define B \\\n" 10379 " \"QQQQQQQQQQQQQ\" \\\n" 10380 " \"FFFFFFFFFFFFF\" \\\n" 10381 " \"LLLLLLLL\"\n", 10382 Style); 10383 10384 Style.AlignConsecutiveMacros = true; 10385 verifyFormat("#define a \\\n" 10386 " \"aabbbbbbbbbbbb\"\n" 10387 "#define D \\\n" 10388 " \"aabbbbbbbbbbbb\" \\\n" 10389 " \"ccddeeeeeeeee\"\n" 10390 "#define B \\\n" 10391 " \"QQQQQQQQQQQQQ\" \\\n" 10392 " \"FFFFFFFFFFFFF\" \\\n" 10393 " \"LLLLLLLL\"\n", 10394 Style); 10395 } 10396 10397 TEST_F(FormatTest, AlignConsecutiveAssignments) { 10398 FormatStyle Alignment = getLLVMStyle(); 10399 Alignment.AlignConsecutiveMacros = true; 10400 Alignment.AlignConsecutiveAssignments = false; 10401 verifyFormat("int a = 5;\n" 10402 "int oneTwoThree = 123;", 10403 Alignment); 10404 verifyFormat("int a = 5;\n" 10405 "int oneTwoThree = 123;", 10406 Alignment); 10407 10408 Alignment.AlignConsecutiveAssignments = true; 10409 verifyFormat("int a = 5;\n" 10410 "int oneTwoThree = 123;", 10411 Alignment); 10412 verifyFormat("int a = method();\n" 10413 "int oneTwoThree = 133;", 10414 Alignment); 10415 verifyFormat("a &= 5;\n" 10416 "bcd *= 5;\n" 10417 "ghtyf += 5;\n" 10418 "dvfvdb -= 5;\n" 10419 "a /= 5;\n" 10420 "vdsvsv %= 5;\n" 10421 "sfdbddfbdfbb ^= 5;\n" 10422 "dvsdsv |= 5;\n" 10423 "int dsvvdvsdvvv = 123;", 10424 Alignment); 10425 verifyFormat("int i = 1, j = 10;\n" 10426 "something = 2000;", 10427 Alignment); 10428 verifyFormat("something = 2000;\n" 10429 "int i = 1, j = 10;\n", 10430 Alignment); 10431 verifyFormat("something = 2000;\n" 10432 "another = 911;\n" 10433 "int i = 1, j = 10;\n" 10434 "oneMore = 1;\n" 10435 "i = 2;", 10436 Alignment); 10437 verifyFormat("int a = 5;\n" 10438 "int one = 1;\n" 10439 "method();\n" 10440 "int oneTwoThree = 123;\n" 10441 "int oneTwo = 12;", 10442 Alignment); 10443 verifyFormat("int oneTwoThree = 123;\n" 10444 "int oneTwo = 12;\n" 10445 "method();\n", 10446 Alignment); 10447 verifyFormat("int oneTwoThree = 123; // comment\n" 10448 "int oneTwo = 12; // comment", 10449 Alignment); 10450 EXPECT_EQ("int a = 5;\n" 10451 "\n" 10452 "int oneTwoThree = 123;", 10453 format("int a = 5;\n" 10454 "\n" 10455 "int oneTwoThree= 123;", 10456 Alignment)); 10457 EXPECT_EQ("int a = 5;\n" 10458 "int one = 1;\n" 10459 "\n" 10460 "int oneTwoThree = 123;", 10461 format("int a = 5;\n" 10462 "int one = 1;\n" 10463 "\n" 10464 "int oneTwoThree = 123;", 10465 Alignment)); 10466 EXPECT_EQ("int a = 5;\n" 10467 "int one = 1;\n" 10468 "\n" 10469 "int oneTwoThree = 123;\n" 10470 "int oneTwo = 12;", 10471 format("int a = 5;\n" 10472 "int one = 1;\n" 10473 "\n" 10474 "int oneTwoThree = 123;\n" 10475 "int oneTwo = 12;", 10476 Alignment)); 10477 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10478 verifyFormat("#define A \\\n" 10479 " int aaaa = 12; \\\n" 10480 " int b = 23; \\\n" 10481 " int ccc = 234; \\\n" 10482 " int dddddddddd = 2345;", 10483 Alignment); 10484 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10485 verifyFormat("#define A \\\n" 10486 " int aaaa = 12; \\\n" 10487 " int b = 23; \\\n" 10488 " int ccc = 234; \\\n" 10489 " int dddddddddd = 2345;", 10490 Alignment); 10491 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10492 verifyFormat("#define A " 10493 " \\\n" 10494 " int aaaa = 12; " 10495 " \\\n" 10496 " int b = 23; " 10497 " \\\n" 10498 " int ccc = 234; " 10499 " \\\n" 10500 " int dddddddddd = 2345;", 10501 Alignment); 10502 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10503 "k = 4, int l = 5,\n" 10504 " int m = 6) {\n" 10505 " int j = 10;\n" 10506 " otherThing = 1;\n" 10507 "}", 10508 Alignment); 10509 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10510 " int i = 1;\n" 10511 " int j = 2;\n" 10512 " int big = 10000;\n" 10513 "}", 10514 Alignment); 10515 verifyFormat("class C {\n" 10516 "public:\n" 10517 " int i = 1;\n" 10518 " virtual void f() = 0;\n" 10519 "};", 10520 Alignment); 10521 verifyFormat("int i = 1;\n" 10522 "if (SomeType t = getSomething()) {\n" 10523 "}\n" 10524 "int j = 2;\n" 10525 "int big = 10000;", 10526 Alignment); 10527 verifyFormat("int j = 7;\n" 10528 "for (int k = 0; k < N; ++k) {\n" 10529 "}\n" 10530 "int j = 2;\n" 10531 "int big = 10000;\n" 10532 "}", 10533 Alignment); 10534 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10535 verifyFormat("int i = 1;\n" 10536 "LooooooooooongType loooooooooooooooooooooongVariable\n" 10537 " = someLooooooooooooooooongFunction();\n" 10538 "int j = 2;", 10539 Alignment); 10540 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 10541 verifyFormat("int i = 1;\n" 10542 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 10543 " someLooooooooooooooooongFunction();\n" 10544 "int j = 2;", 10545 Alignment); 10546 10547 verifyFormat("auto lambda = []() {\n" 10548 " auto i = 0;\n" 10549 " return 0;\n" 10550 "};\n" 10551 "int i = 0;\n" 10552 "auto v = type{\n" 10553 " i = 1, //\n" 10554 " (i = 2), //\n" 10555 " i = 3 //\n" 10556 "};", 10557 Alignment); 10558 10559 verifyFormat( 10560 "int i = 1;\n" 10561 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 10562 " loooooooooooooooooooooongParameterB);\n" 10563 "int j = 2;", 10564 Alignment); 10565 10566 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 10567 " typename B = very_long_type_name_1,\n" 10568 " typename T_2 = very_long_type_name_2>\n" 10569 "auto foo() {}\n", 10570 Alignment); 10571 verifyFormat("int a, b = 1;\n" 10572 "int c = 2;\n" 10573 "int dd = 3;\n", 10574 Alignment); 10575 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10576 "float b[1][] = {{3.f}};\n", 10577 Alignment); 10578 verifyFormat("for (int i = 0; i < 1; i++)\n" 10579 " int x = 1;\n", 10580 Alignment); 10581 verifyFormat("for (i = 0; i < 1; i++)\n" 10582 " x = 1;\n" 10583 "y = 1;\n", 10584 Alignment); 10585 } 10586 10587 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 10588 FormatStyle Alignment = getLLVMStyle(); 10589 Alignment.AlignConsecutiveMacros = true; 10590 Alignment.AlignConsecutiveDeclarations = false; 10591 verifyFormat("float const a = 5;\n" 10592 "int oneTwoThree = 123;", 10593 Alignment); 10594 verifyFormat("int a = 5;\n" 10595 "float const oneTwoThree = 123;", 10596 Alignment); 10597 10598 Alignment.AlignConsecutiveDeclarations = true; 10599 verifyFormat("float const a = 5;\n" 10600 "int oneTwoThree = 123;", 10601 Alignment); 10602 verifyFormat("int a = method();\n" 10603 "float const oneTwoThree = 133;", 10604 Alignment); 10605 verifyFormat("int i = 1, j = 10;\n" 10606 "something = 2000;", 10607 Alignment); 10608 verifyFormat("something = 2000;\n" 10609 "int i = 1, j = 10;\n", 10610 Alignment); 10611 verifyFormat("float something = 2000;\n" 10612 "double another = 911;\n" 10613 "int i = 1, j = 10;\n" 10614 "const int *oneMore = 1;\n" 10615 "unsigned i = 2;", 10616 Alignment); 10617 verifyFormat("float a = 5;\n" 10618 "int one = 1;\n" 10619 "method();\n" 10620 "const double oneTwoThree = 123;\n" 10621 "const unsigned int oneTwo = 12;", 10622 Alignment); 10623 verifyFormat("int oneTwoThree{0}; // comment\n" 10624 "unsigned oneTwo; // comment", 10625 Alignment); 10626 EXPECT_EQ("float const a = 5;\n" 10627 "\n" 10628 "int oneTwoThree = 123;", 10629 format("float const a = 5;\n" 10630 "\n" 10631 "int oneTwoThree= 123;", 10632 Alignment)); 10633 EXPECT_EQ("float a = 5;\n" 10634 "int one = 1;\n" 10635 "\n" 10636 "unsigned oneTwoThree = 123;", 10637 format("float a = 5;\n" 10638 "int one = 1;\n" 10639 "\n" 10640 "unsigned oneTwoThree = 123;", 10641 Alignment)); 10642 EXPECT_EQ("float a = 5;\n" 10643 "int one = 1;\n" 10644 "\n" 10645 "unsigned oneTwoThree = 123;\n" 10646 "int oneTwo = 12;", 10647 format("float a = 5;\n" 10648 "int one = 1;\n" 10649 "\n" 10650 "unsigned oneTwoThree = 123;\n" 10651 "int oneTwo = 12;", 10652 Alignment)); 10653 // Function prototype alignment 10654 verifyFormat("int a();\n" 10655 "double b();", 10656 Alignment); 10657 verifyFormat("int a(int x);\n" 10658 "double b();", 10659 Alignment); 10660 unsigned OldColumnLimit = Alignment.ColumnLimit; 10661 // We need to set ColumnLimit to zero, in order to stress nested alignments, 10662 // otherwise the function parameters will be re-flowed onto a single line. 10663 Alignment.ColumnLimit = 0; 10664 EXPECT_EQ("int a(int x,\n" 10665 " float y);\n" 10666 "double b(int x,\n" 10667 " double y);", 10668 format("int a(int x,\n" 10669 " float y);\n" 10670 "double b(int x,\n" 10671 " double y);", 10672 Alignment)); 10673 // This ensures that function parameters of function declarations are 10674 // correctly indented when their owning functions are indented. 10675 // The failure case here is for 'double y' to not be indented enough. 10676 EXPECT_EQ("double a(int x);\n" 10677 "int b(int y,\n" 10678 " double z);", 10679 format("double a(int x);\n" 10680 "int b(int y,\n" 10681 " double z);", 10682 Alignment)); 10683 // Set ColumnLimit low so that we induce wrapping immediately after 10684 // the function name and opening paren. 10685 Alignment.ColumnLimit = 13; 10686 verifyFormat("int function(\n" 10687 " int x,\n" 10688 " bool y);", 10689 Alignment); 10690 Alignment.ColumnLimit = OldColumnLimit; 10691 // Ensure function pointers don't screw up recursive alignment 10692 verifyFormat("int a(int x, void (*fp)(int y));\n" 10693 "double b();", 10694 Alignment); 10695 Alignment.AlignConsecutiveAssignments = true; 10696 // Ensure recursive alignment is broken by function braces, so that the 10697 // "a = 1" does not align with subsequent assignments inside the function 10698 // body. 10699 verifyFormat("int func(int a = 1) {\n" 10700 " int b = 2;\n" 10701 " int cc = 3;\n" 10702 "}", 10703 Alignment); 10704 verifyFormat("float something = 2000;\n" 10705 "double another = 911;\n" 10706 "int i = 1, j = 10;\n" 10707 "const int *oneMore = 1;\n" 10708 "unsigned i = 2;", 10709 Alignment); 10710 verifyFormat("int oneTwoThree = {0}; // comment\n" 10711 "unsigned oneTwo = 0; // comment", 10712 Alignment); 10713 // Make sure that scope is correctly tracked, in the absence of braces 10714 verifyFormat("for (int i = 0; i < n; i++)\n" 10715 " j = i;\n" 10716 "double x = 1;\n", 10717 Alignment); 10718 verifyFormat("if (int i = 0)\n" 10719 " j = i;\n" 10720 "double x = 1;\n", 10721 Alignment); 10722 // Ensure operator[] and operator() are comprehended 10723 verifyFormat("struct test {\n" 10724 " long long int foo();\n" 10725 " int operator[](int a);\n" 10726 " double bar();\n" 10727 "};\n", 10728 Alignment); 10729 verifyFormat("struct test {\n" 10730 " long long int foo();\n" 10731 " int operator()(int a);\n" 10732 " double bar();\n" 10733 "};\n", 10734 Alignment); 10735 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 10736 " int const i = 1;\n" 10737 " int * j = 2;\n" 10738 " int big = 10000;\n" 10739 "\n" 10740 " unsigned oneTwoThree = 123;\n" 10741 " int oneTwo = 12;\n" 10742 " method();\n" 10743 " float k = 2;\n" 10744 " int ll = 10000;\n" 10745 "}", 10746 format("void SomeFunction(int parameter= 0) {\n" 10747 " int const i= 1;\n" 10748 " int *j=2;\n" 10749 " int big = 10000;\n" 10750 "\n" 10751 "unsigned oneTwoThree =123;\n" 10752 "int oneTwo = 12;\n" 10753 " method();\n" 10754 "float k= 2;\n" 10755 "int ll=10000;\n" 10756 "}", 10757 Alignment)); 10758 Alignment.AlignConsecutiveAssignments = false; 10759 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10760 verifyFormat("#define A \\\n" 10761 " int aaaa = 12; \\\n" 10762 " float b = 23; \\\n" 10763 " const int ccc = 234; \\\n" 10764 " unsigned dddddddddd = 2345;", 10765 Alignment); 10766 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10767 verifyFormat("#define A \\\n" 10768 " int aaaa = 12; \\\n" 10769 " float b = 23; \\\n" 10770 " const int ccc = 234; \\\n" 10771 " unsigned dddddddddd = 2345;", 10772 Alignment); 10773 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10774 Alignment.ColumnLimit = 30; 10775 verifyFormat("#define A \\\n" 10776 " int aaaa = 12; \\\n" 10777 " float b = 23; \\\n" 10778 " const int ccc = 234; \\\n" 10779 " int dddddddddd = 2345;", 10780 Alignment); 10781 Alignment.ColumnLimit = 80; 10782 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10783 "k = 4, int l = 5,\n" 10784 " int m = 6) {\n" 10785 " const int j = 10;\n" 10786 " otherThing = 1;\n" 10787 "}", 10788 Alignment); 10789 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10790 " int const i = 1;\n" 10791 " int * j = 2;\n" 10792 " int big = 10000;\n" 10793 "}", 10794 Alignment); 10795 verifyFormat("class C {\n" 10796 "public:\n" 10797 " int i = 1;\n" 10798 " virtual void f() = 0;\n" 10799 "};", 10800 Alignment); 10801 verifyFormat("float i = 1;\n" 10802 "if (SomeType t = getSomething()) {\n" 10803 "}\n" 10804 "const unsigned j = 2;\n" 10805 "int big = 10000;", 10806 Alignment); 10807 verifyFormat("float j = 7;\n" 10808 "for (int k = 0; k < N; ++k) {\n" 10809 "}\n" 10810 "unsigned j = 2;\n" 10811 "int big = 10000;\n" 10812 "}", 10813 Alignment); 10814 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10815 verifyFormat("float i = 1;\n" 10816 "LooooooooooongType loooooooooooooooooooooongVariable\n" 10817 " = someLooooooooooooooooongFunction();\n" 10818 "int j = 2;", 10819 Alignment); 10820 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 10821 verifyFormat("int i = 1;\n" 10822 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 10823 " someLooooooooooooooooongFunction();\n" 10824 "int j = 2;", 10825 Alignment); 10826 10827 Alignment.AlignConsecutiveAssignments = true; 10828 verifyFormat("auto lambda = []() {\n" 10829 " auto ii = 0;\n" 10830 " float j = 0;\n" 10831 " return 0;\n" 10832 "};\n" 10833 "int i = 0;\n" 10834 "float i2 = 0;\n" 10835 "auto v = type{\n" 10836 " i = 1, //\n" 10837 " (i = 2), //\n" 10838 " i = 3 //\n" 10839 "};", 10840 Alignment); 10841 Alignment.AlignConsecutiveAssignments = false; 10842 10843 verifyFormat( 10844 "int i = 1;\n" 10845 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 10846 " loooooooooooooooooooooongParameterB);\n" 10847 "int j = 2;", 10848 Alignment); 10849 10850 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 10851 // We expect declarations and assignments to align, as long as it doesn't 10852 // exceed the column limit, starting a new alignment sequence whenever it 10853 // happens. 10854 Alignment.AlignConsecutiveAssignments = true; 10855 Alignment.ColumnLimit = 30; 10856 verifyFormat("float ii = 1;\n" 10857 "unsigned j = 2;\n" 10858 "int someVerylongVariable = 1;\n" 10859 "AnotherLongType ll = 123456;\n" 10860 "VeryVeryLongType k = 2;\n" 10861 "int myvar = 1;", 10862 Alignment); 10863 Alignment.ColumnLimit = 80; 10864 Alignment.AlignConsecutiveAssignments = false; 10865 10866 verifyFormat( 10867 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 10868 " typename LongType, typename B>\n" 10869 "auto foo() {}\n", 10870 Alignment); 10871 verifyFormat("float a, b = 1;\n" 10872 "int c = 2;\n" 10873 "int dd = 3;\n", 10874 Alignment); 10875 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10876 "float b[1][] = {{3.f}};\n", 10877 Alignment); 10878 Alignment.AlignConsecutiveAssignments = true; 10879 verifyFormat("float a, b = 1;\n" 10880 "int c = 2;\n" 10881 "int dd = 3;\n", 10882 Alignment); 10883 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10884 "float b[1][] = {{3.f}};\n", 10885 Alignment); 10886 Alignment.AlignConsecutiveAssignments = false; 10887 10888 Alignment.ColumnLimit = 30; 10889 Alignment.BinPackParameters = false; 10890 verifyFormat("void foo(float a,\n" 10891 " float b,\n" 10892 " int c,\n" 10893 " uint32_t *d) {\n" 10894 " int * e = 0;\n" 10895 " float f = 0;\n" 10896 " double g = 0;\n" 10897 "}\n" 10898 "void bar(ino_t a,\n" 10899 " int b,\n" 10900 " uint32_t *c,\n" 10901 " bool d) {}\n", 10902 Alignment); 10903 Alignment.BinPackParameters = true; 10904 Alignment.ColumnLimit = 80; 10905 10906 // Bug 33507 10907 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 10908 verifyFormat( 10909 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 10910 " static const Version verVs2017;\n" 10911 " return true;\n" 10912 "});\n", 10913 Alignment); 10914 Alignment.PointerAlignment = FormatStyle::PAS_Right; 10915 10916 // See llvm.org/PR35641 10917 Alignment.AlignConsecutiveDeclarations = true; 10918 verifyFormat("int func() { //\n" 10919 " int b;\n" 10920 " unsigned c;\n" 10921 "}", 10922 Alignment); 10923 10924 // See PR37175 10925 FormatStyle Style = getMozillaStyle(); 10926 Style.AlignConsecutiveDeclarations = true; 10927 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 10928 "foo(int a);", 10929 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 10930 } 10931 10932 TEST_F(FormatTest, LinuxBraceBreaking) { 10933 FormatStyle LinuxBraceStyle = getLLVMStyle(); 10934 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 10935 verifyFormat("namespace a\n" 10936 "{\n" 10937 "class A\n" 10938 "{\n" 10939 " void f()\n" 10940 " {\n" 10941 " if (true) {\n" 10942 " a();\n" 10943 " b();\n" 10944 " } else {\n" 10945 " a();\n" 10946 " }\n" 10947 " }\n" 10948 " void g() { return; }\n" 10949 "};\n" 10950 "struct B {\n" 10951 " int x;\n" 10952 "};\n" 10953 "} // namespace a\n", 10954 LinuxBraceStyle); 10955 verifyFormat("enum X {\n" 10956 " Y = 0,\n" 10957 "}\n", 10958 LinuxBraceStyle); 10959 verifyFormat("struct S {\n" 10960 " int Type;\n" 10961 " union {\n" 10962 " int x;\n" 10963 " double y;\n" 10964 " } Value;\n" 10965 " class C\n" 10966 " {\n" 10967 " MyFavoriteType Value;\n" 10968 " } Class;\n" 10969 "}\n", 10970 LinuxBraceStyle); 10971 } 10972 10973 TEST_F(FormatTest, MozillaBraceBreaking) { 10974 FormatStyle MozillaBraceStyle = getLLVMStyle(); 10975 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 10976 MozillaBraceStyle.FixNamespaceComments = false; 10977 verifyFormat("namespace a {\n" 10978 "class A\n" 10979 "{\n" 10980 " void f()\n" 10981 " {\n" 10982 " if (true) {\n" 10983 " a();\n" 10984 " b();\n" 10985 " }\n" 10986 " }\n" 10987 " void g() { return; }\n" 10988 "};\n" 10989 "enum E\n" 10990 "{\n" 10991 " A,\n" 10992 " // foo\n" 10993 " B,\n" 10994 " C\n" 10995 "};\n" 10996 "struct B\n" 10997 "{\n" 10998 " int x;\n" 10999 "};\n" 11000 "}\n", 11001 MozillaBraceStyle); 11002 verifyFormat("struct S\n" 11003 "{\n" 11004 " int Type;\n" 11005 " union\n" 11006 " {\n" 11007 " int x;\n" 11008 " double y;\n" 11009 " } Value;\n" 11010 " class C\n" 11011 " {\n" 11012 " MyFavoriteType Value;\n" 11013 " } Class;\n" 11014 "}\n", 11015 MozillaBraceStyle); 11016 } 11017 11018 TEST_F(FormatTest, StroustrupBraceBreaking) { 11019 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 11020 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11021 verifyFormat("namespace a {\n" 11022 "class A {\n" 11023 " void f()\n" 11024 " {\n" 11025 " if (true) {\n" 11026 " a();\n" 11027 " b();\n" 11028 " }\n" 11029 " }\n" 11030 " void g() { return; }\n" 11031 "};\n" 11032 "struct B {\n" 11033 " int x;\n" 11034 "};\n" 11035 "} // namespace a\n", 11036 StroustrupBraceStyle); 11037 11038 verifyFormat("void foo()\n" 11039 "{\n" 11040 " if (a) {\n" 11041 " a();\n" 11042 " }\n" 11043 " else {\n" 11044 " b();\n" 11045 " }\n" 11046 "}\n", 11047 StroustrupBraceStyle); 11048 11049 verifyFormat("#ifdef _DEBUG\n" 11050 "int foo(int i = 0)\n" 11051 "#else\n" 11052 "int foo(int i = 5)\n" 11053 "#endif\n" 11054 "{\n" 11055 " return i;\n" 11056 "}", 11057 StroustrupBraceStyle); 11058 11059 verifyFormat("void foo() {}\n" 11060 "void bar()\n" 11061 "#ifdef _DEBUG\n" 11062 "{\n" 11063 " foo();\n" 11064 "}\n" 11065 "#else\n" 11066 "{\n" 11067 "}\n" 11068 "#endif", 11069 StroustrupBraceStyle); 11070 11071 verifyFormat("void foobar() { int i = 5; }\n" 11072 "#ifdef _DEBUG\n" 11073 "void bar() {}\n" 11074 "#else\n" 11075 "void bar() { foobar(); }\n" 11076 "#endif", 11077 StroustrupBraceStyle); 11078 } 11079 11080 TEST_F(FormatTest, AllmanBraceBreaking) { 11081 FormatStyle AllmanBraceStyle = getLLVMStyle(); 11082 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 11083 11084 EXPECT_EQ("namespace a\n" 11085 "{\n" 11086 "void f();\n" 11087 "void g();\n" 11088 "} // namespace a\n", 11089 format("namespace a\n" 11090 "{\n" 11091 "void f();\n" 11092 "void g();\n" 11093 "}\n", 11094 AllmanBraceStyle)); 11095 11096 verifyFormat("namespace a\n" 11097 "{\n" 11098 "class A\n" 11099 "{\n" 11100 " void f()\n" 11101 " {\n" 11102 " if (true)\n" 11103 " {\n" 11104 " a();\n" 11105 " b();\n" 11106 " }\n" 11107 " }\n" 11108 " void g() { return; }\n" 11109 "};\n" 11110 "struct B\n" 11111 "{\n" 11112 " int x;\n" 11113 "};\n" 11114 "union C\n" 11115 "{\n" 11116 "};\n" 11117 "} // namespace a", 11118 AllmanBraceStyle); 11119 11120 verifyFormat("void f()\n" 11121 "{\n" 11122 " if (true)\n" 11123 " {\n" 11124 " a();\n" 11125 " }\n" 11126 " else if (false)\n" 11127 " {\n" 11128 " b();\n" 11129 " }\n" 11130 " else\n" 11131 " {\n" 11132 " c();\n" 11133 " }\n" 11134 "}\n", 11135 AllmanBraceStyle); 11136 11137 verifyFormat("void f()\n" 11138 "{\n" 11139 " for (int i = 0; i < 10; ++i)\n" 11140 " {\n" 11141 " a();\n" 11142 " }\n" 11143 " while (false)\n" 11144 " {\n" 11145 " b();\n" 11146 " }\n" 11147 " do\n" 11148 " {\n" 11149 " c();\n" 11150 " } while (false)\n" 11151 "}\n", 11152 AllmanBraceStyle); 11153 11154 verifyFormat("void f(int a)\n" 11155 "{\n" 11156 " switch (a)\n" 11157 " {\n" 11158 " case 0:\n" 11159 " break;\n" 11160 " case 1:\n" 11161 " {\n" 11162 " break;\n" 11163 " }\n" 11164 " case 2:\n" 11165 " {\n" 11166 " }\n" 11167 " break;\n" 11168 " default:\n" 11169 " break;\n" 11170 " }\n" 11171 "}\n", 11172 AllmanBraceStyle); 11173 11174 verifyFormat("enum X\n" 11175 "{\n" 11176 " Y = 0,\n" 11177 "}\n", 11178 AllmanBraceStyle); 11179 verifyFormat("enum X\n" 11180 "{\n" 11181 " Y = 0\n" 11182 "}\n", 11183 AllmanBraceStyle); 11184 11185 verifyFormat("@interface BSApplicationController ()\n" 11186 "{\n" 11187 "@private\n" 11188 " id _extraIvar;\n" 11189 "}\n" 11190 "@end\n", 11191 AllmanBraceStyle); 11192 11193 verifyFormat("#ifdef _DEBUG\n" 11194 "int foo(int i = 0)\n" 11195 "#else\n" 11196 "int foo(int i = 5)\n" 11197 "#endif\n" 11198 "{\n" 11199 " return i;\n" 11200 "}", 11201 AllmanBraceStyle); 11202 11203 verifyFormat("void foo() {}\n" 11204 "void bar()\n" 11205 "#ifdef _DEBUG\n" 11206 "{\n" 11207 " foo();\n" 11208 "}\n" 11209 "#else\n" 11210 "{\n" 11211 "}\n" 11212 "#endif", 11213 AllmanBraceStyle); 11214 11215 verifyFormat("void foobar() { int i = 5; }\n" 11216 "#ifdef _DEBUG\n" 11217 "void bar() {}\n" 11218 "#else\n" 11219 "void bar() { foobar(); }\n" 11220 "#endif", 11221 AllmanBraceStyle); 11222 11223 // This shouldn't affect ObjC blocks.. 11224 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 11225 " // ...\n" 11226 " int i;\n" 11227 "}];", 11228 AllmanBraceStyle); 11229 verifyFormat("void (^block)(void) = ^{\n" 11230 " // ...\n" 11231 " int i;\n" 11232 "};", 11233 AllmanBraceStyle); 11234 // .. or dict literals. 11235 verifyFormat("void f()\n" 11236 "{\n" 11237 " // ...\n" 11238 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 11239 "}", 11240 AllmanBraceStyle); 11241 verifyFormat("void f()\n" 11242 "{\n" 11243 " // ...\n" 11244 " [object someMethod:@{a : @\"b\"}];\n" 11245 "}", 11246 AllmanBraceStyle); 11247 verifyFormat("int f()\n" 11248 "{ // comment\n" 11249 " return 42;\n" 11250 "}", 11251 AllmanBraceStyle); 11252 11253 AllmanBraceStyle.ColumnLimit = 19; 11254 verifyFormat("void f() { int i; }", AllmanBraceStyle); 11255 AllmanBraceStyle.ColumnLimit = 18; 11256 verifyFormat("void f()\n" 11257 "{\n" 11258 " int i;\n" 11259 "}", 11260 AllmanBraceStyle); 11261 AllmanBraceStyle.ColumnLimit = 80; 11262 11263 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 11264 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 11265 FormatStyle::SIS_WithoutElse; 11266 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 11267 verifyFormat("void f(bool b)\n" 11268 "{\n" 11269 " if (b)\n" 11270 " {\n" 11271 " return;\n" 11272 " }\n" 11273 "}\n", 11274 BreakBeforeBraceShortIfs); 11275 verifyFormat("void f(bool b)\n" 11276 "{\n" 11277 " if constexpr (b)\n" 11278 " {\n" 11279 " return;\n" 11280 " }\n" 11281 "}\n", 11282 BreakBeforeBraceShortIfs); 11283 verifyFormat("void f(bool b)\n" 11284 "{\n" 11285 " if CONSTEXPR (b)\n" 11286 " {\n" 11287 " return;\n" 11288 " }\n" 11289 "}\n", 11290 BreakBeforeBraceShortIfs); 11291 verifyFormat("void f(bool b)\n" 11292 "{\n" 11293 " if (b) return;\n" 11294 "}\n", 11295 BreakBeforeBraceShortIfs); 11296 verifyFormat("void f(bool b)\n" 11297 "{\n" 11298 " if constexpr (b) return;\n" 11299 "}\n", 11300 BreakBeforeBraceShortIfs); 11301 verifyFormat("void f(bool b)\n" 11302 "{\n" 11303 " if CONSTEXPR (b) return;\n" 11304 "}\n", 11305 BreakBeforeBraceShortIfs); 11306 verifyFormat("void f(bool b)\n" 11307 "{\n" 11308 " while (b)\n" 11309 " {\n" 11310 " return;\n" 11311 " }\n" 11312 "}\n", 11313 BreakBeforeBraceShortIfs); 11314 } 11315 11316 TEST_F(FormatTest, GNUBraceBreaking) { 11317 FormatStyle GNUBraceStyle = getLLVMStyle(); 11318 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 11319 verifyFormat("namespace a\n" 11320 "{\n" 11321 "class A\n" 11322 "{\n" 11323 " void f()\n" 11324 " {\n" 11325 " int a;\n" 11326 " {\n" 11327 " int b;\n" 11328 " }\n" 11329 " if (true)\n" 11330 " {\n" 11331 " a();\n" 11332 " b();\n" 11333 " }\n" 11334 " }\n" 11335 " void g() { return; }\n" 11336 "}\n" 11337 "} // namespace a", 11338 GNUBraceStyle); 11339 11340 verifyFormat("void f()\n" 11341 "{\n" 11342 " if (true)\n" 11343 " {\n" 11344 " a();\n" 11345 " }\n" 11346 " else if (false)\n" 11347 " {\n" 11348 " b();\n" 11349 " }\n" 11350 " else\n" 11351 " {\n" 11352 " c();\n" 11353 " }\n" 11354 "}\n", 11355 GNUBraceStyle); 11356 11357 verifyFormat("void f()\n" 11358 "{\n" 11359 " for (int i = 0; i < 10; ++i)\n" 11360 " {\n" 11361 " a();\n" 11362 " }\n" 11363 " while (false)\n" 11364 " {\n" 11365 " b();\n" 11366 " }\n" 11367 " do\n" 11368 " {\n" 11369 " c();\n" 11370 " }\n" 11371 " while (false);\n" 11372 "}\n", 11373 GNUBraceStyle); 11374 11375 verifyFormat("void f(int a)\n" 11376 "{\n" 11377 " switch (a)\n" 11378 " {\n" 11379 " case 0:\n" 11380 " break;\n" 11381 " case 1:\n" 11382 " {\n" 11383 " break;\n" 11384 " }\n" 11385 " case 2:\n" 11386 " {\n" 11387 " }\n" 11388 " break;\n" 11389 " default:\n" 11390 " break;\n" 11391 " }\n" 11392 "}\n", 11393 GNUBraceStyle); 11394 11395 verifyFormat("enum X\n" 11396 "{\n" 11397 " Y = 0,\n" 11398 "}\n", 11399 GNUBraceStyle); 11400 11401 verifyFormat("@interface BSApplicationController ()\n" 11402 "{\n" 11403 "@private\n" 11404 " id _extraIvar;\n" 11405 "}\n" 11406 "@end\n", 11407 GNUBraceStyle); 11408 11409 verifyFormat("#ifdef _DEBUG\n" 11410 "int foo(int i = 0)\n" 11411 "#else\n" 11412 "int foo(int i = 5)\n" 11413 "#endif\n" 11414 "{\n" 11415 " return i;\n" 11416 "}", 11417 GNUBraceStyle); 11418 11419 verifyFormat("void foo() {}\n" 11420 "void bar()\n" 11421 "#ifdef _DEBUG\n" 11422 "{\n" 11423 " foo();\n" 11424 "}\n" 11425 "#else\n" 11426 "{\n" 11427 "}\n" 11428 "#endif", 11429 GNUBraceStyle); 11430 11431 verifyFormat("void foobar() { int i = 5; }\n" 11432 "#ifdef _DEBUG\n" 11433 "void bar() {}\n" 11434 "#else\n" 11435 "void bar() { foobar(); }\n" 11436 "#endif", 11437 GNUBraceStyle); 11438 } 11439 11440 TEST_F(FormatTest, WebKitBraceBreaking) { 11441 FormatStyle WebKitBraceStyle = getLLVMStyle(); 11442 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 11443 WebKitBraceStyle.FixNamespaceComments = false; 11444 verifyFormat("namespace a {\n" 11445 "class A {\n" 11446 " void f()\n" 11447 " {\n" 11448 " if (true) {\n" 11449 " a();\n" 11450 " b();\n" 11451 " }\n" 11452 " }\n" 11453 " void g() { return; }\n" 11454 "};\n" 11455 "enum E {\n" 11456 " A,\n" 11457 " // foo\n" 11458 " B,\n" 11459 " C\n" 11460 "};\n" 11461 "struct B {\n" 11462 " int x;\n" 11463 "};\n" 11464 "}\n", 11465 WebKitBraceStyle); 11466 verifyFormat("struct S {\n" 11467 " int Type;\n" 11468 " union {\n" 11469 " int x;\n" 11470 " double y;\n" 11471 " } Value;\n" 11472 " class C {\n" 11473 " MyFavoriteType Value;\n" 11474 " } Class;\n" 11475 "};\n", 11476 WebKitBraceStyle); 11477 } 11478 11479 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 11480 verifyFormat("void f() {\n" 11481 " try {\n" 11482 " } catch (const Exception &e) {\n" 11483 " }\n" 11484 "}\n", 11485 getLLVMStyle()); 11486 } 11487 11488 TEST_F(FormatTest, UnderstandsPragmas) { 11489 verifyFormat("#pragma omp reduction(| : var)"); 11490 verifyFormat("#pragma omp reduction(+ : var)"); 11491 11492 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 11493 "(including parentheses).", 11494 format("#pragma mark Any non-hyphenated or hyphenated string " 11495 "(including parentheses).")); 11496 } 11497 11498 TEST_F(FormatTest, UnderstandPragmaOption) { 11499 verifyFormat("#pragma option -C -A"); 11500 11501 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 11502 } 11503 11504 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 11505 FormatStyle Style = getLLVMStyle(); 11506 Style.ColumnLimit = 20; 11507 11508 // See PR41213 11509 EXPECT_EQ("/*\n" 11510 " *\t9012345\n" 11511 " * /8901\n" 11512 " */", 11513 format("/*\n" 11514 " *\t9012345 /8901\n" 11515 " */", 11516 Style)); 11517 EXPECT_EQ("/*\n" 11518 " *345678\n" 11519 " *\t/8901\n" 11520 " */", 11521 format("/*\n" 11522 " *345678\t/8901\n" 11523 " */", 11524 Style)); 11525 11526 verifyFormat("int a; // the\n" 11527 " // comment", Style); 11528 EXPECT_EQ("int a; /* first line\n" 11529 " * second\n" 11530 " * line third\n" 11531 " * line\n" 11532 " */", 11533 format("int a; /* first line\n" 11534 " * second\n" 11535 " * line third\n" 11536 " * line\n" 11537 " */", 11538 Style)); 11539 EXPECT_EQ("int a; // first line\n" 11540 " // second\n" 11541 " // line third\n" 11542 " // line", 11543 format("int a; // first line\n" 11544 " // second line\n" 11545 " // third line", 11546 Style)); 11547 11548 Style.PenaltyExcessCharacter = 90; 11549 verifyFormat("int a; // the comment", Style); 11550 EXPECT_EQ("int a; // the comment\n" 11551 " // aaa", 11552 format("int a; // the comment aaa", Style)); 11553 EXPECT_EQ("int a; /* first line\n" 11554 " * second line\n" 11555 " * third line\n" 11556 " */", 11557 format("int a; /* first line\n" 11558 " * second line\n" 11559 " * third line\n" 11560 " */", 11561 Style)); 11562 EXPECT_EQ("int a; // first line\n" 11563 " // second line\n" 11564 " // third line", 11565 format("int a; // first line\n" 11566 " // second line\n" 11567 " // third line", 11568 Style)); 11569 // FIXME: Investigate why this is not getting the same layout as the test 11570 // above. 11571 EXPECT_EQ("int a; /* first line\n" 11572 " * second line\n" 11573 " * third line\n" 11574 " */", 11575 format("int a; /* first line second line third line" 11576 "\n*/", 11577 Style)); 11578 11579 EXPECT_EQ("// foo bar baz bazfoo\n" 11580 "// foo bar foo bar\n", 11581 format("// foo bar baz bazfoo\n" 11582 "// foo bar foo bar\n", 11583 Style)); 11584 EXPECT_EQ("// foo bar baz bazfoo\n" 11585 "// foo bar foo bar\n", 11586 format("// foo bar baz bazfoo\n" 11587 "// foo bar foo bar\n", 11588 Style)); 11589 11590 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 11591 // next one. 11592 EXPECT_EQ("// foo bar baz bazfoo\n" 11593 "// bar foo bar\n", 11594 format("// foo bar baz bazfoo bar\n" 11595 "// foo bar\n", 11596 Style)); 11597 11598 EXPECT_EQ("// foo bar baz bazfoo\n" 11599 "// foo bar baz bazfoo\n" 11600 "// bar foo bar\n", 11601 format("// foo bar baz bazfoo\n" 11602 "// foo bar baz bazfoo bar\n" 11603 "// foo bar\n", 11604 Style)); 11605 11606 EXPECT_EQ("// foo bar baz bazfoo\n" 11607 "// foo bar baz bazfoo\n" 11608 "// bar foo bar\n", 11609 format("// foo bar baz bazfoo\n" 11610 "// foo bar baz bazfoo bar\n" 11611 "// foo bar\n", 11612 Style)); 11613 11614 // Make sure we do not keep protruding characters if strict mode reflow is 11615 // cheaper than keeping protruding characters. 11616 Style.ColumnLimit = 21; 11617 EXPECT_EQ("// foo foo foo foo\n" 11618 "// foo foo foo foo\n" 11619 "// foo foo foo foo\n", 11620 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", 11621 Style)); 11622 11623 EXPECT_EQ("int a = /* long block\n" 11624 " comment */\n" 11625 " 42;", 11626 format("int a = /* long block comment */ 42;", Style)); 11627 } 11628 11629 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 11630 for (size_t i = 1; i < Styles.size(); ++i) \ 11631 EXPECT_EQ(Styles[0], Styles[i]) << "Style #" << i << " of " << Styles.size() \ 11632 << " differs from Style #0" 11633 11634 TEST_F(FormatTest, GetsPredefinedStyleByName) { 11635 SmallVector<FormatStyle, 3> Styles; 11636 Styles.resize(3); 11637 11638 Styles[0] = getLLVMStyle(); 11639 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 11640 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 11641 EXPECT_ALL_STYLES_EQUAL(Styles); 11642 11643 Styles[0] = getGoogleStyle(); 11644 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 11645 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 11646 EXPECT_ALL_STYLES_EQUAL(Styles); 11647 11648 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 11649 EXPECT_TRUE( 11650 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 11651 EXPECT_TRUE( 11652 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 11653 EXPECT_ALL_STYLES_EQUAL(Styles); 11654 11655 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 11656 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 11657 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 11658 EXPECT_ALL_STYLES_EQUAL(Styles); 11659 11660 Styles[0] = getMozillaStyle(); 11661 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 11662 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 11663 EXPECT_ALL_STYLES_EQUAL(Styles); 11664 11665 Styles[0] = getWebKitStyle(); 11666 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 11667 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 11668 EXPECT_ALL_STYLES_EQUAL(Styles); 11669 11670 Styles[0] = getGNUStyle(); 11671 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 11672 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 11673 EXPECT_ALL_STYLES_EQUAL(Styles); 11674 11675 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 11676 } 11677 11678 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 11679 SmallVector<FormatStyle, 8> Styles; 11680 Styles.resize(2); 11681 11682 Styles[0] = getGoogleStyle(); 11683 Styles[1] = getLLVMStyle(); 11684 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 11685 EXPECT_ALL_STYLES_EQUAL(Styles); 11686 11687 Styles.resize(5); 11688 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 11689 Styles[1] = getLLVMStyle(); 11690 Styles[1].Language = FormatStyle::LK_JavaScript; 11691 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 11692 11693 Styles[2] = getLLVMStyle(); 11694 Styles[2].Language = FormatStyle::LK_JavaScript; 11695 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 11696 "BasedOnStyle: Google", 11697 &Styles[2]) 11698 .value()); 11699 11700 Styles[3] = getLLVMStyle(); 11701 Styles[3].Language = FormatStyle::LK_JavaScript; 11702 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 11703 "Language: JavaScript", 11704 &Styles[3]) 11705 .value()); 11706 11707 Styles[4] = getLLVMStyle(); 11708 Styles[4].Language = FormatStyle::LK_JavaScript; 11709 EXPECT_EQ(0, parseConfiguration("---\n" 11710 "BasedOnStyle: LLVM\n" 11711 "IndentWidth: 123\n" 11712 "---\n" 11713 "BasedOnStyle: Google\n" 11714 "Language: JavaScript", 11715 &Styles[4]) 11716 .value()); 11717 EXPECT_ALL_STYLES_EQUAL(Styles); 11718 } 11719 11720 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 11721 Style.FIELD = false; \ 11722 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 11723 EXPECT_TRUE(Style.FIELD); \ 11724 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 11725 EXPECT_FALSE(Style.FIELD); 11726 11727 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 11728 11729 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 11730 Style.STRUCT.FIELD = false; \ 11731 EXPECT_EQ(0, \ 11732 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 11733 .value()); \ 11734 EXPECT_TRUE(Style.STRUCT.FIELD); \ 11735 EXPECT_EQ(0, \ 11736 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 11737 .value()); \ 11738 EXPECT_FALSE(Style.STRUCT.FIELD); 11739 11740 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 11741 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 11742 11743 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 11744 EXPECT_NE(VALUE, Style.FIELD); \ 11745 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 11746 EXPECT_EQ(VALUE, Style.FIELD) 11747 11748 TEST_F(FormatTest, ParsesConfigurationBools) { 11749 FormatStyle Style = {}; 11750 Style.Language = FormatStyle::LK_Cpp; 11751 CHECK_PARSE_BOOL(AlignOperands); 11752 CHECK_PARSE_BOOL(AlignTrailingComments); 11753 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 11754 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 11755 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 11756 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 11757 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 11758 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 11759 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 11760 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 11761 CHECK_PARSE_BOOL(BinPackArguments); 11762 CHECK_PARSE_BOOL(BinPackParameters); 11763 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 11764 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 11765 CHECK_PARSE_BOOL(BreakStringLiterals); 11766 CHECK_PARSE_BOOL(CompactNamespaces); 11767 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 11768 CHECK_PARSE_BOOL(DerivePointerAlignment); 11769 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 11770 CHECK_PARSE_BOOL(DisableFormat); 11771 CHECK_PARSE_BOOL(IndentCaseLabels); 11772 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 11773 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 11774 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 11775 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 11776 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 11777 CHECK_PARSE_BOOL(ReflowComments); 11778 CHECK_PARSE_BOOL(SortIncludes); 11779 CHECK_PARSE_BOOL(SortUsingDeclarations); 11780 CHECK_PARSE_BOOL(SpacesInParentheses); 11781 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 11782 CHECK_PARSE_BOOL(SpacesInAngles); 11783 CHECK_PARSE_BOOL(SpaceInEmptyBlock); 11784 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 11785 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 11786 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 11787 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 11788 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 11789 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 11790 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 11791 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 11792 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 11793 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 11794 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 11795 11796 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 11797 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 11798 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterControlStatement); 11799 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 11800 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 11801 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 11802 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 11803 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 11804 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 11805 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 11806 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 11807 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 11808 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 11809 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 11810 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 11811 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 11812 } 11813 11814 #undef CHECK_PARSE_BOOL 11815 11816 TEST_F(FormatTest, ParsesConfiguration) { 11817 FormatStyle Style = {}; 11818 Style.Language = FormatStyle::LK_Cpp; 11819 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 11820 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 11821 ConstructorInitializerIndentWidth, 1234u); 11822 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 11823 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 11824 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 11825 CHECK_PARSE("PenaltyBreakAssignment: 1234", 11826 PenaltyBreakAssignment, 1234u); 11827 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 11828 PenaltyBreakBeforeFirstCallParameter, 1234u); 11829 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 11830 PenaltyBreakTemplateDeclaration, 1234u); 11831 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 11832 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 11833 PenaltyReturnTypeOnItsOwnLine, 1234u); 11834 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 11835 SpacesBeforeTrailingComments, 1234u); 11836 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 11837 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 11838 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 11839 11840 Style.PointerAlignment = FormatStyle::PAS_Middle; 11841 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 11842 FormatStyle::PAS_Left); 11843 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 11844 FormatStyle::PAS_Right); 11845 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 11846 FormatStyle::PAS_Middle); 11847 // For backward compatibility: 11848 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 11849 FormatStyle::PAS_Left); 11850 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 11851 FormatStyle::PAS_Right); 11852 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 11853 FormatStyle::PAS_Middle); 11854 11855 Style.Standard = FormatStyle::LS_Auto; 11856 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 11857 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11); 11858 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 11859 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 11860 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 11861 11862 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11863 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 11864 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 11865 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 11866 FormatStyle::BOS_None); 11867 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 11868 FormatStyle::BOS_All); 11869 // For backward compatibility: 11870 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 11871 FormatStyle::BOS_None); 11872 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 11873 FormatStyle::BOS_All); 11874 11875 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 11876 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 11877 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 11878 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 11879 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 11880 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 11881 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 11882 // For backward compatibility: 11883 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 11884 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 11885 11886 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 11887 CHECK_PARSE("BreakInheritanceList: BeforeComma", 11888 BreakInheritanceList, FormatStyle::BILS_BeforeComma); 11889 CHECK_PARSE("BreakInheritanceList: AfterColon", 11890 BreakInheritanceList, FormatStyle::BILS_AfterColon); 11891 CHECK_PARSE("BreakInheritanceList: BeforeColon", 11892 BreakInheritanceList, FormatStyle::BILS_BeforeColon); 11893 // For backward compatibility: 11894 CHECK_PARSE("BreakBeforeInheritanceComma: true", 11895 BreakInheritanceList, FormatStyle::BILS_BeforeComma); 11896 11897 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 11898 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 11899 FormatStyle::BAS_Align); 11900 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 11901 FormatStyle::BAS_DontAlign); 11902 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 11903 FormatStyle::BAS_AlwaysBreak); 11904 // For backward compatibility: 11905 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 11906 FormatStyle::BAS_DontAlign); 11907 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 11908 FormatStyle::BAS_Align); 11909 11910 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11911 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 11912 FormatStyle::ENAS_DontAlign); 11913 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 11914 FormatStyle::ENAS_Left); 11915 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 11916 FormatStyle::ENAS_Right); 11917 // For backward compatibility: 11918 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 11919 FormatStyle::ENAS_Left); 11920 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 11921 FormatStyle::ENAS_Right); 11922 11923 Style.UseTab = FormatStyle::UT_ForIndentation; 11924 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 11925 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 11926 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 11927 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 11928 FormatStyle::UT_ForContinuationAndIndentation); 11929 // For backward compatibility: 11930 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 11931 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 11932 11933 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 11934 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never", 11935 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 11936 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty", 11937 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty); 11938 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always", 11939 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 11940 // For backward compatibility: 11941 CHECK_PARSE("AllowShortBlocksOnASingleLine: false", 11942 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 11943 CHECK_PARSE("AllowShortBlocksOnASingleLine: true", 11944 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 11945 11946 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 11947 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 11948 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 11949 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 11950 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 11951 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 11952 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 11953 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 11954 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 11955 // For backward compatibility: 11956 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 11957 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 11958 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 11959 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 11960 11961 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 11962 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 11963 FormatStyle::SBPO_Never); 11964 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 11965 FormatStyle::SBPO_Always); 11966 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 11967 FormatStyle::SBPO_ControlStatements); 11968 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 11969 FormatStyle::SBPO_NonEmptyParentheses); 11970 // For backward compatibility: 11971 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 11972 FormatStyle::SBPO_Never); 11973 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 11974 FormatStyle::SBPO_ControlStatements); 11975 11976 Style.ColumnLimit = 123; 11977 FormatStyle BaseStyle = getLLVMStyle(); 11978 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 11979 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 11980 11981 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11982 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 11983 FormatStyle::BS_Attach); 11984 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 11985 FormatStyle::BS_Linux); 11986 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 11987 FormatStyle::BS_Mozilla); 11988 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 11989 FormatStyle::BS_Stroustrup); 11990 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 11991 FormatStyle::BS_Allman); 11992 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 11993 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 11994 FormatStyle::BS_WebKit); 11995 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 11996 FormatStyle::BS_Custom); 11997 11998 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 11999 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 12000 FormatStyle::RTBS_None); 12001 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 12002 FormatStyle::RTBS_All); 12003 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 12004 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 12005 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 12006 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 12007 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 12008 AlwaysBreakAfterReturnType, 12009 FormatStyle::RTBS_TopLevelDefinitions); 12010 12011 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 12012 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", AlwaysBreakTemplateDeclarations, 12013 FormatStyle::BTDS_No); 12014 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", AlwaysBreakTemplateDeclarations, 12015 FormatStyle::BTDS_MultiLine); 12016 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", AlwaysBreakTemplateDeclarations, 12017 FormatStyle::BTDS_Yes); 12018 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", AlwaysBreakTemplateDeclarations, 12019 FormatStyle::BTDS_MultiLine); 12020 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", AlwaysBreakTemplateDeclarations, 12021 FormatStyle::BTDS_Yes); 12022 12023 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 12024 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 12025 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 12026 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 12027 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 12028 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 12029 AlwaysBreakAfterDefinitionReturnType, 12030 FormatStyle::DRTBS_TopLevel); 12031 12032 Style.NamespaceIndentation = FormatStyle::NI_All; 12033 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 12034 FormatStyle::NI_None); 12035 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 12036 FormatStyle::NI_Inner); 12037 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 12038 FormatStyle::NI_All); 12039 12040 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 12041 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 12042 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12043 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 12044 AllowShortIfStatementsOnASingleLine, 12045 FormatStyle::SIS_WithoutElse); 12046 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 12047 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 12048 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 12049 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12050 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 12051 AllowShortIfStatementsOnASingleLine, 12052 FormatStyle::SIS_WithoutElse); 12053 12054 // FIXME: This is required because parsing a configuration simply overwrites 12055 // the first N elements of the list instead of resetting it. 12056 Style.ForEachMacros.clear(); 12057 std::vector<std::string> BoostForeach; 12058 BoostForeach.push_back("BOOST_FOREACH"); 12059 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 12060 std::vector<std::string> BoostAndQForeach; 12061 BoostAndQForeach.push_back("BOOST_FOREACH"); 12062 BoostAndQForeach.push_back("Q_FOREACH"); 12063 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 12064 BoostAndQForeach); 12065 12066 Style.StatementMacros.clear(); 12067 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 12068 std::vector<std::string>{"QUNUSED"}); 12069 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 12070 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 12071 12072 Style.NamespaceMacros.clear(); 12073 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 12074 std::vector<std::string>{"TESTSUITE"}); 12075 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 12076 std::vector<std::string>({"TESTSUITE", "SUITE"})); 12077 12078 Style.IncludeStyle.IncludeCategories.clear(); 12079 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 12080 {"abc/.*", 2}, {".*", 1}}; 12081 CHECK_PARSE("IncludeCategories:\n" 12082 " - Regex: abc/.*\n" 12083 " Priority: 2\n" 12084 " - Regex: .*\n" 12085 " Priority: 1", 12086 IncludeStyle.IncludeCategories, ExpectedCategories); 12087 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 12088 "abc$"); 12089 12090 Style.RawStringFormats.clear(); 12091 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 12092 { 12093 FormatStyle::LK_TextProto, 12094 {"pb", "proto"}, 12095 {"PARSE_TEXT_PROTO"}, 12096 /*CanonicalDelimiter=*/"", 12097 "llvm", 12098 }, 12099 { 12100 FormatStyle::LK_Cpp, 12101 {"cc", "cpp"}, 12102 {"C_CODEBLOCK", "CPPEVAL"}, 12103 /*CanonicalDelimiter=*/"cc", 12104 /*BasedOnStyle=*/"", 12105 }, 12106 }; 12107 12108 CHECK_PARSE("RawStringFormats:\n" 12109 " - Language: TextProto\n" 12110 " Delimiters:\n" 12111 " - 'pb'\n" 12112 " - 'proto'\n" 12113 " EnclosingFunctions:\n" 12114 " - 'PARSE_TEXT_PROTO'\n" 12115 " BasedOnStyle: llvm\n" 12116 " - Language: Cpp\n" 12117 " Delimiters:\n" 12118 " - 'cc'\n" 12119 " - 'cpp'\n" 12120 " EnclosingFunctions:\n" 12121 " - 'C_CODEBLOCK'\n" 12122 " - 'CPPEVAL'\n" 12123 " CanonicalDelimiter: 'cc'", 12124 RawStringFormats, ExpectedRawStringFormats); 12125 } 12126 12127 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 12128 FormatStyle Style = {}; 12129 Style.Language = FormatStyle::LK_Cpp; 12130 CHECK_PARSE("Language: Cpp\n" 12131 "IndentWidth: 12", 12132 IndentWidth, 12u); 12133 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 12134 "IndentWidth: 34", 12135 &Style), 12136 ParseError::Unsuitable); 12137 EXPECT_EQ(12u, Style.IndentWidth); 12138 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12139 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12140 12141 Style.Language = FormatStyle::LK_JavaScript; 12142 CHECK_PARSE("Language: JavaScript\n" 12143 "IndentWidth: 12", 12144 IndentWidth, 12u); 12145 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 12146 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 12147 "IndentWidth: 34", 12148 &Style), 12149 ParseError::Unsuitable); 12150 EXPECT_EQ(23u, Style.IndentWidth); 12151 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12152 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12153 12154 CHECK_PARSE("BasedOnStyle: LLVM\n" 12155 "IndentWidth: 67", 12156 IndentWidth, 67u); 12157 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, 12u); 12166 12167 Style.Language = FormatStyle::LK_Cpp; 12168 CHECK_PARSE("---\n" 12169 "Language: JavaScript\n" 12170 "IndentWidth: 12\n" 12171 "---\n" 12172 "Language: Cpp\n" 12173 "IndentWidth: 34\n" 12174 "...\n", 12175 IndentWidth, 34u); 12176 CHECK_PARSE("---\n" 12177 "IndentWidth: 78\n" 12178 "---\n" 12179 "Language: JavaScript\n" 12180 "IndentWidth: 56\n" 12181 "...\n", 12182 IndentWidth, 78u); 12183 12184 Style.ColumnLimit = 123; 12185 Style.IndentWidth = 234; 12186 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 12187 Style.TabWidth = 345; 12188 EXPECT_FALSE(parseConfiguration("---\n" 12189 "IndentWidth: 456\n" 12190 "BreakBeforeBraces: Allman\n" 12191 "---\n" 12192 "Language: JavaScript\n" 12193 "IndentWidth: 111\n" 12194 "TabWidth: 111\n" 12195 "---\n" 12196 "Language: Cpp\n" 12197 "BreakBeforeBraces: Stroustrup\n" 12198 "TabWidth: 789\n" 12199 "...\n", 12200 &Style)); 12201 EXPECT_EQ(123u, Style.ColumnLimit); 12202 EXPECT_EQ(456u, Style.IndentWidth); 12203 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 12204 EXPECT_EQ(789u, Style.TabWidth); 12205 12206 EXPECT_EQ(parseConfiguration("---\n" 12207 "Language: JavaScript\n" 12208 "IndentWidth: 56\n" 12209 "---\n" 12210 "IndentWidth: 78\n" 12211 "...\n", 12212 &Style), 12213 ParseError::Error); 12214 EXPECT_EQ(parseConfiguration("---\n" 12215 "Language: JavaScript\n" 12216 "IndentWidth: 56\n" 12217 "---\n" 12218 "Language: JavaScript\n" 12219 "IndentWidth: 78\n" 12220 "...\n", 12221 &Style), 12222 ParseError::Error); 12223 12224 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12225 } 12226 12227 #undef CHECK_PARSE 12228 12229 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 12230 FormatStyle Style = {}; 12231 Style.Language = FormatStyle::LK_JavaScript; 12232 Style.BreakBeforeTernaryOperators = true; 12233 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 12234 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 12235 12236 Style.BreakBeforeTernaryOperators = true; 12237 EXPECT_EQ(0, parseConfiguration("---\n" 12238 "BasedOnStyle: Google\n" 12239 "---\n" 12240 "Language: JavaScript\n" 12241 "IndentWidth: 76\n" 12242 "...\n", 12243 &Style) 12244 .value()); 12245 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 12246 EXPECT_EQ(76u, Style.IndentWidth); 12247 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12248 } 12249 12250 TEST_F(FormatTest, ConfigurationRoundTripTest) { 12251 FormatStyle Style = getLLVMStyle(); 12252 std::string YAML = configurationAsText(Style); 12253 FormatStyle ParsedStyle = {}; 12254 ParsedStyle.Language = FormatStyle::LK_Cpp; 12255 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 12256 EXPECT_EQ(Style, ParsedStyle); 12257 } 12258 12259 TEST_F(FormatTest, WorksFor8bitEncodings) { 12260 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 12261 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 12262 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 12263 "\"\xef\xee\xf0\xf3...\"", 12264 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 12265 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 12266 "\xef\xee\xf0\xf3...\"", 12267 getLLVMStyleWithColumns(12))); 12268 } 12269 12270 TEST_F(FormatTest, HandlesUTF8BOM) { 12271 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 12272 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 12273 format("\xef\xbb\xbf#include <iostream>")); 12274 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 12275 format("\xef\xbb\xbf\n#include <iostream>")); 12276 } 12277 12278 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 12279 #if !defined(_MSC_VER) 12280 12281 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 12282 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 12283 getLLVMStyleWithColumns(35)); 12284 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 12285 getLLVMStyleWithColumns(31)); 12286 verifyFormat("// Однажды в студёную зимнюю пору...", 12287 getLLVMStyleWithColumns(36)); 12288 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 12289 verifyFormat("/* Однажды в студёную зимнюю пору... */", 12290 getLLVMStyleWithColumns(39)); 12291 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 12292 getLLVMStyleWithColumns(35)); 12293 } 12294 12295 TEST_F(FormatTest, SplitsUTF8Strings) { 12296 // Non-printable characters' width is currently considered to be the length in 12297 // bytes in UTF8. The characters can be displayed in very different manner 12298 // (zero-width, single width with a substitution glyph, expanded to their code 12299 // (e.g. "<8d>"), so there's no single correct way to handle them. 12300 EXPECT_EQ("\"aaaaÄ\"\n" 12301 "\"\xc2\x8d\";", 12302 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 12303 EXPECT_EQ("\"aaaaaaaÄ\"\n" 12304 "\"\xc2\x8d\";", 12305 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 12306 EXPECT_EQ("\"Однажды, в \"\n" 12307 "\"студёную \"\n" 12308 "\"зимнюю \"\n" 12309 "\"пору,\"", 12310 format("\"Однажды, в студёную зимнюю пору,\"", 12311 getLLVMStyleWithColumns(13))); 12312 EXPECT_EQ( 12313 "\"一 二 三 \"\n" 12314 "\"四 五六 \"\n" 12315 "\"七 八 九 \"\n" 12316 "\"十\"", 12317 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 12318 EXPECT_EQ("\"一\t\"\n" 12319 "\"二 \t\"\n" 12320 "\"三 四 \"\n" 12321 "\"五\t\"\n" 12322 "\"六 \t\"\n" 12323 "\"七 \"\n" 12324 "\"八九十\tqq\"", 12325 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 12326 getLLVMStyleWithColumns(11))); 12327 12328 // UTF8 character in an escape sequence. 12329 EXPECT_EQ("\"aaaaaa\"\n" 12330 "\"\\\xC2\x8D\"", 12331 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 12332 } 12333 12334 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 12335 EXPECT_EQ("const char *sssss =\n" 12336 " \"一二三四五六七八\\\n" 12337 " 九 十\";", 12338 format("const char *sssss = \"一二三四五六七八\\\n" 12339 " 九 十\";", 12340 getLLVMStyleWithColumns(30))); 12341 } 12342 12343 TEST_F(FormatTest, SplitsUTF8LineComments) { 12344 EXPECT_EQ("// aaaaÄ\xc2\x8d", 12345 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 12346 EXPECT_EQ("// Я из лесу\n" 12347 "// вышел; был\n" 12348 "// сильный\n" 12349 "// мороз.", 12350 format("// Я из лесу вышел; был сильный мороз.", 12351 getLLVMStyleWithColumns(13))); 12352 EXPECT_EQ("// 一二三\n" 12353 "// 四五六七\n" 12354 "// 八 九\n" 12355 "// 十", 12356 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 12357 } 12358 12359 TEST_F(FormatTest, SplitsUTF8BlockComments) { 12360 EXPECT_EQ("/* Гляжу,\n" 12361 " * поднимается\n" 12362 " * медленно в\n" 12363 " * гору\n" 12364 " * Лошадка,\n" 12365 " * везущая\n" 12366 " * хворосту\n" 12367 " * воз. */", 12368 format("/* Гляжу, поднимается медленно в гору\n" 12369 " * Лошадка, везущая хворосту воз. */", 12370 getLLVMStyleWithColumns(13))); 12371 EXPECT_EQ( 12372 "/* 一二三\n" 12373 " * 四五六七\n" 12374 " * 八 九\n" 12375 " * 十 */", 12376 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 12377 EXPECT_EQ("/* �������� ��������\n" 12378 " * ��������\n" 12379 " * ������-�� */", 12380 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 12381 } 12382 12383 #endif // _MSC_VER 12384 12385 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 12386 FormatStyle Style = getLLVMStyle(); 12387 12388 Style.ConstructorInitializerIndentWidth = 4; 12389 verifyFormat( 12390 "SomeClass::Constructor()\n" 12391 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12392 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12393 Style); 12394 12395 Style.ConstructorInitializerIndentWidth = 2; 12396 verifyFormat( 12397 "SomeClass::Constructor()\n" 12398 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12399 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12400 Style); 12401 12402 Style.ConstructorInitializerIndentWidth = 0; 12403 verifyFormat( 12404 "SomeClass::Constructor()\n" 12405 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12406 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12407 Style); 12408 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 12409 verifyFormat( 12410 "SomeLongTemplateVariableName<\n" 12411 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 12412 Style); 12413 verifyFormat( 12414 "bool smaller = 1 < bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 12415 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 12416 Style); 12417 12418 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 12419 verifyFormat( 12420 "SomeClass::Constructor() :\n" 12421 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 12422 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 12423 Style); 12424 } 12425 12426 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 12427 FormatStyle Style = getLLVMStyle(); 12428 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 12429 Style.ConstructorInitializerIndentWidth = 4; 12430 verifyFormat("SomeClass::Constructor()\n" 12431 " : a(a)\n" 12432 " , b(b)\n" 12433 " , c(c) {}", 12434 Style); 12435 verifyFormat("SomeClass::Constructor()\n" 12436 " : a(a) {}", 12437 Style); 12438 12439 Style.ColumnLimit = 0; 12440 verifyFormat("SomeClass::Constructor()\n" 12441 " : a(a) {}", 12442 Style); 12443 verifyFormat("SomeClass::Constructor() noexcept\n" 12444 " : a(a) {}", 12445 Style); 12446 verifyFormat("SomeClass::Constructor()\n" 12447 " : a(a)\n" 12448 " , b(b)\n" 12449 " , c(c) {}", 12450 Style); 12451 verifyFormat("SomeClass::Constructor()\n" 12452 " : a(a) {\n" 12453 " foo();\n" 12454 " bar();\n" 12455 "}", 12456 Style); 12457 12458 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 12459 verifyFormat("SomeClass::Constructor()\n" 12460 " : a(a)\n" 12461 " , b(b)\n" 12462 " , c(c) {\n}", 12463 Style); 12464 verifyFormat("SomeClass::Constructor()\n" 12465 " : a(a) {\n}", 12466 Style); 12467 12468 Style.ColumnLimit = 80; 12469 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 12470 Style.ConstructorInitializerIndentWidth = 2; 12471 verifyFormat("SomeClass::Constructor()\n" 12472 " : a(a)\n" 12473 " , b(b)\n" 12474 " , c(c) {}", 12475 Style); 12476 12477 Style.ConstructorInitializerIndentWidth = 0; 12478 verifyFormat("SomeClass::Constructor()\n" 12479 ": a(a)\n" 12480 ", b(b)\n" 12481 ", c(c) {}", 12482 Style); 12483 12484 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 12485 Style.ConstructorInitializerIndentWidth = 4; 12486 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 12487 verifyFormat( 12488 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 12489 Style); 12490 verifyFormat( 12491 "SomeClass::Constructor()\n" 12492 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 12493 Style); 12494 Style.ConstructorInitializerIndentWidth = 4; 12495 Style.ColumnLimit = 60; 12496 verifyFormat("SomeClass::Constructor()\n" 12497 " : aaaaaaaa(aaaaaaaa)\n" 12498 " , aaaaaaaa(aaaaaaaa)\n" 12499 " , aaaaaaaa(aaaaaaaa) {}", 12500 Style); 12501 } 12502 12503 TEST_F(FormatTest, Destructors) { 12504 verifyFormat("void F(int &i) { i.~int(); }"); 12505 verifyFormat("void F(int &i) { i->~int(); }"); 12506 } 12507 12508 TEST_F(FormatTest, FormatsWithWebKitStyle) { 12509 FormatStyle Style = getWebKitStyle(); 12510 12511 // Don't indent in outer namespaces. 12512 verifyFormat("namespace outer {\n" 12513 "int i;\n" 12514 "namespace inner {\n" 12515 " int i;\n" 12516 "} // namespace inner\n" 12517 "} // namespace outer\n" 12518 "namespace other_outer {\n" 12519 "int i;\n" 12520 "}", 12521 Style); 12522 12523 // Don't indent case labels. 12524 verifyFormat("switch (variable) {\n" 12525 "case 1:\n" 12526 "case 2:\n" 12527 " doSomething();\n" 12528 " break;\n" 12529 "default:\n" 12530 " ++variable;\n" 12531 "}", 12532 Style); 12533 12534 // Wrap before binary operators. 12535 EXPECT_EQ("void f()\n" 12536 "{\n" 12537 " if (aaaaaaaaaaaaaaaa\n" 12538 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 12539 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 12540 " return;\n" 12541 "}", 12542 format("void f() {\n" 12543 "if (aaaaaaaaaaaaaaaa\n" 12544 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 12545 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 12546 "return;\n" 12547 "}", 12548 Style)); 12549 12550 // Allow functions on a single line. 12551 verifyFormat("void f() { return; }", Style); 12552 12553 // Allow empty blocks on a single line and insert a space in empty blocks. 12554 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 12555 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 12556 // However, don't merge non-empty short loops. 12557 EXPECT_EQ("while (true) {\n" 12558 " continue;\n" 12559 "}", format("while (true) { continue; }", Style)); 12560 12561 // Constructor initializers are formatted one per line with the "," on the 12562 // new line. 12563 verifyFormat("Constructor()\n" 12564 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 12565 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 12566 " aaaaaaaaaaaaaa)\n" 12567 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 12568 "{\n" 12569 "}", 12570 Style); 12571 verifyFormat("SomeClass::Constructor()\n" 12572 " : a(a)\n" 12573 "{\n" 12574 "}", 12575 Style); 12576 EXPECT_EQ("SomeClass::Constructor()\n" 12577 " : a(a)\n" 12578 "{\n" 12579 "}", 12580 format("SomeClass::Constructor():a(a){}", Style)); 12581 verifyFormat("SomeClass::Constructor()\n" 12582 " : a(a)\n" 12583 " , b(b)\n" 12584 " , c(c)\n" 12585 "{\n" 12586 "}", 12587 Style); 12588 verifyFormat("SomeClass::Constructor()\n" 12589 " : a(a)\n" 12590 "{\n" 12591 " foo();\n" 12592 " bar();\n" 12593 "}", 12594 Style); 12595 12596 // Access specifiers should be aligned left. 12597 verifyFormat("class C {\n" 12598 "public:\n" 12599 " int i;\n" 12600 "};", 12601 Style); 12602 12603 // Do not align comments. 12604 verifyFormat("int a; // Do not\n" 12605 "double b; // align comments.", 12606 Style); 12607 12608 // Do not align operands. 12609 EXPECT_EQ("ASSERT(aaaa\n" 12610 " || bbbb);", 12611 format("ASSERT ( aaaa\n||bbbb);", Style)); 12612 12613 // Accept input's line breaks. 12614 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 12615 " || bbbbbbbbbbbbbbb) {\n" 12616 " i++;\n" 12617 "}", 12618 format("if (aaaaaaaaaaaaaaa\n" 12619 "|| bbbbbbbbbbbbbbb) { i++; }", 12620 Style)); 12621 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 12622 " i++;\n" 12623 "}", 12624 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 12625 12626 // Don't automatically break all macro definitions (llvm.org/PR17842). 12627 verifyFormat("#define aNumber 10", Style); 12628 // However, generally keep the line breaks that the user authored. 12629 EXPECT_EQ("#define aNumber \\\n" 12630 " 10", 12631 format("#define aNumber \\\n" 12632 " 10", 12633 Style)); 12634 12635 // Keep empty and one-element array literals on a single line. 12636 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 12637 " copyItems:YES];", 12638 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 12639 "copyItems:YES];", 12640 Style)); 12641 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 12642 " copyItems:YES];", 12643 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 12644 " copyItems:YES];", 12645 Style)); 12646 // FIXME: This does not seem right, there should be more indentation before 12647 // the array literal's entries. Nested blocks have the same problem. 12648 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 12649 " @\"a\",\n" 12650 " @\"a\"\n" 12651 "]\n" 12652 " copyItems:YES];", 12653 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 12654 " @\"a\",\n" 12655 " @\"a\"\n" 12656 " ]\n" 12657 " copyItems:YES];", 12658 Style)); 12659 EXPECT_EQ( 12660 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 12661 " copyItems:YES];", 12662 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 12663 " copyItems:YES];", 12664 Style)); 12665 12666 verifyFormat("[self.a b:c c:d];", Style); 12667 EXPECT_EQ("[self.a b:c\n" 12668 " c:d];", 12669 format("[self.a b:c\n" 12670 "c:d];", 12671 Style)); 12672 } 12673 12674 TEST_F(FormatTest, FormatsLambdas) { 12675 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 12676 verifyFormat( 12677 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 12678 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 12679 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 12680 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 12681 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 12682 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 12683 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 12684 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 12685 verifyFormat("int x = f(*+[] {});"); 12686 verifyFormat("void f() {\n" 12687 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 12688 "}\n"); 12689 verifyFormat("void f() {\n" 12690 " other(x.begin(), //\n" 12691 " x.end(), //\n" 12692 " [&](int, int) { return 1; });\n" 12693 "}\n"); 12694 verifyFormat("void f() {\n" 12695 " other.other.other.other.other(\n" 12696 " x.begin(), x.end(),\n" 12697 " [something, rather](int, int, int, int, int, int, int) { return 1; });\n" 12698 "}\n"); 12699 verifyFormat("void f() {\n" 12700 " other.other.other.other.other(\n" 12701 " x.begin(), x.end(),\n" 12702 " [something, rather](int, int, int, int, int, int, int) {\n" 12703 " //\n" 12704 " });\n" 12705 "}\n"); 12706 verifyFormat("SomeFunction([]() { // A cool function...\n" 12707 " return 43;\n" 12708 "});"); 12709 EXPECT_EQ("SomeFunction([]() {\n" 12710 "#define A a\n" 12711 " return 43;\n" 12712 "});", 12713 format("SomeFunction([](){\n" 12714 "#define A a\n" 12715 "return 43;\n" 12716 "});")); 12717 verifyFormat("void f() {\n" 12718 " SomeFunction([](decltype(x), A *a) {});\n" 12719 "}"); 12720 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 12721 " [](const aaaaaaaaaa &a) { return a; });"); 12722 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 12723 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 12724 "});"); 12725 verifyFormat("Constructor()\n" 12726 " : Field([] { // comment\n" 12727 " int i;\n" 12728 " }) {}"); 12729 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 12730 " return some_parameter.size();\n" 12731 "};"); 12732 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 12733 " [](const string &s) { return s; };"); 12734 verifyFormat("int i = aaaaaa ? 1 //\n" 12735 " : [] {\n" 12736 " return 2; //\n" 12737 " }();"); 12738 verifyFormat("llvm::errs() << \"number of twos is \"\n" 12739 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 12740 " return x == 2; // force break\n" 12741 " });"); 12742 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 12743 " [=](int iiiiiiiiiiii) {\n" 12744 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 12745 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 12746 " });", 12747 getLLVMStyleWithColumns(60)); 12748 verifyFormat("SomeFunction({[&] {\n" 12749 " // comment\n" 12750 " },\n" 12751 " [&] {\n" 12752 " // comment\n" 12753 " }});"); 12754 verifyFormat("SomeFunction({[&] {\n" 12755 " // comment\n" 12756 "}});"); 12757 verifyFormat("virtual aaaaaaaaaaaaaaaa(\n" 12758 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 12759 " aaaaa aaaaaaaaa);"); 12760 12761 // Lambdas with return types. 12762 verifyFormat("int c = []() -> int { return 2; }();\n"); 12763 verifyFormat("int c = []() -> int * { return 2; }();\n"); 12764 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 12765 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 12766 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 12767 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 12768 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 12769 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 12770 verifyFormat("[a, a]() -> a<1> {};"); 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> { return {}; };"); 12778 verifyFormat("[]() -> foo<~5> { return {}; };"); 12779 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 12780 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 12781 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 12782 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 12783 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 12784 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 12785 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 12786 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 12787 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 12788 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 12789 verifyFormat("namespace bar {\n" 12790 "// broken:\n" 12791 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 12792 "} // namespace bar"); 12793 verifyFormat("namespace bar {\n" 12794 "// broken:\n" 12795 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 12796 "} // namespace bar"); 12797 verifyFormat("namespace bar {\n" 12798 "// broken:\n" 12799 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 12800 "} // namespace bar"); 12801 verifyFormat("namespace bar {\n" 12802 "// broken:\n" 12803 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 12804 "} // namespace bar"); 12805 verifyFormat("namespace bar {\n" 12806 "// broken:\n" 12807 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 12808 "} // namespace bar"); 12809 verifyFormat("namespace bar {\n" 12810 "// broken:\n" 12811 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 12812 "} // namespace bar"); 12813 verifyFormat("namespace bar {\n" 12814 "// broken:\n" 12815 "auto foo{[]() -> foo<!5> { return {}; }};\n" 12816 "} // namespace bar"); 12817 verifyFormat("namespace bar {\n" 12818 "// broken:\n" 12819 "auto foo{[]() -> foo<~5> { return {}; }};\n" 12820 "} // namespace bar"); 12821 verifyFormat("namespace bar {\n" 12822 "// broken:\n" 12823 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 12824 "} // namespace bar"); 12825 verifyFormat("namespace bar {\n" 12826 "// broken:\n" 12827 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 12828 "} // namespace bar"); 12829 verifyFormat("namespace bar {\n" 12830 "// broken:\n" 12831 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 12832 "} // namespace bar"); 12833 verifyFormat("namespace bar {\n" 12834 "// broken:\n" 12835 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 12836 "} // namespace bar"); 12837 verifyFormat("namespace bar {\n" 12838 "// broken:\n" 12839 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 12840 "} // namespace bar"); 12841 verifyFormat("namespace bar {\n" 12842 "// broken:\n" 12843 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 12844 "} // namespace bar"); 12845 verifyFormat("namespace bar {\n" 12846 "// broken:\n" 12847 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 12848 "} // namespace bar"); 12849 verifyFormat("namespace bar {\n" 12850 "// broken:\n" 12851 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 12852 "} // namespace bar"); 12853 verifyFormat("namespace bar {\n" 12854 "// broken:\n" 12855 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 12856 "} // namespace bar"); 12857 verifyFormat("namespace bar {\n" 12858 "// broken:\n" 12859 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 12860 "} // namespace bar"); 12861 verifyFormat("[]() -> a<1> {};"); 12862 verifyFormat("[]() -> a<1> { ; };"); 12863 verifyFormat("[]() -> a<1> { ; }();"); 12864 verifyFormat("[a, a]() -> a<true> {};"); 12865 verifyFormat("[]() -> a<true> {};"); 12866 verifyFormat("[]() -> a<true> { ; };"); 12867 verifyFormat("[]() -> a<true> { ; }();"); 12868 verifyFormat("[a, a]() -> a<false> {};"); 12869 verifyFormat("[]() -> a<false> {};"); 12870 verifyFormat("[]() -> a<false> { ; };"); 12871 verifyFormat("[]() -> a<false> { ; }();"); 12872 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 12873 verifyFormat("namespace bar {\n" 12874 "auto foo{[]() -> foo<false> { ; }};\n" 12875 "} // namespace bar"); 12876 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 12877 " int j) -> int {\n" 12878 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 12879 "};"); 12880 verifyFormat( 12881 "aaaaaaaaaaaaaaaaaaaaaa(\n" 12882 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 12883 " return aaaaaaaaaaaaaaaaa;\n" 12884 " });", 12885 getLLVMStyleWithColumns(70)); 12886 verifyFormat("[]() //\n" 12887 " -> int {\n" 12888 " return 1; //\n" 12889 "};"); 12890 12891 // Multiple lambdas in the same parentheses change indentation rules. These 12892 // lambdas are forced to start on new lines. 12893 verifyFormat("SomeFunction(\n" 12894 " []() {\n" 12895 " //\n" 12896 " },\n" 12897 " []() {\n" 12898 " //\n" 12899 " });"); 12900 12901 // A lambda passed as arg0 is always pushed to the next line. 12902 verifyFormat("SomeFunction(\n" 12903 " [this] {\n" 12904 " //\n" 12905 " },\n" 12906 " 1);\n"); 12907 12908 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like the arg0 12909 // case above. 12910 auto Style = getGoogleStyle(); 12911 Style.BinPackArguments = false; 12912 verifyFormat("SomeFunction(\n" 12913 " a,\n" 12914 " [this] {\n" 12915 " //\n" 12916 " },\n" 12917 " b);\n", 12918 Style); 12919 verifyFormat("SomeFunction(\n" 12920 " a,\n" 12921 " [this] {\n" 12922 " //\n" 12923 " },\n" 12924 " b);\n"); 12925 12926 // A lambda with a very long line forces arg0 to be pushed out irrespective of 12927 // the BinPackArguments value (as long as the code is wide enough). 12928 verifyFormat("something->SomeFunction(\n" 12929 " a,\n" 12930 " [this] {\n" 12931 " D0000000000000000000000000000000000000000000000000000000000001();\n" 12932 " },\n" 12933 " b);\n"); 12934 12935 // A multi-line lambda is pulled up as long as the introducer fits on the previous 12936 // line and there are no further args. 12937 verifyFormat("function(1, [this, that] {\n" 12938 " //\n" 12939 "});\n"); 12940 verifyFormat("function([this, that] {\n" 12941 " //\n" 12942 "});\n"); 12943 // FIXME: this format is not ideal and we should consider forcing the first arg 12944 // onto its own line. 12945 verifyFormat("function(a, b, c, //\n" 12946 " d, [this, that] {\n" 12947 " //\n" 12948 " });\n"); 12949 12950 // Multiple lambdas are treated correctly even when there is a short arg0. 12951 verifyFormat("SomeFunction(\n" 12952 " 1,\n" 12953 " [this] {\n" 12954 " //\n" 12955 " },\n" 12956 " [this] {\n" 12957 " //\n" 12958 " },\n" 12959 " 1);\n"); 12960 12961 // More complex introducers. 12962 verifyFormat("return [i, args...] {};"); 12963 12964 // Not lambdas. 12965 verifyFormat("constexpr char hello[]{\"hello\"};"); 12966 verifyFormat("double &operator[](int i) { return 0; }\n" 12967 "int i;"); 12968 verifyFormat("std::unique_ptr<int[]> foo() {}"); 12969 verifyFormat("int i = a[a][a]->f();"); 12970 verifyFormat("int i = (*b)[a]->f();"); 12971 12972 // Other corner cases. 12973 verifyFormat("void f() {\n" 12974 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 12975 " );\n" 12976 "}"); 12977 12978 // Lambdas created through weird macros. 12979 verifyFormat("void f() {\n" 12980 " MACRO((const AA &a) { return 1; });\n" 12981 " MACRO((AA &a) { return 1; });\n" 12982 "}"); 12983 12984 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 12985 " doo_dah();\n" 12986 " doo_dah();\n" 12987 " })) {\n" 12988 "}"); 12989 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 12990 " doo_dah();\n" 12991 " doo_dah();\n" 12992 " })) {\n" 12993 "}"); 12994 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n" 12995 " doo_dah();\n" 12996 " doo_dah();\n" 12997 " })) {\n" 12998 "}"); 12999 verifyFormat("auto lambda = []() {\n" 13000 " int a = 2\n" 13001 "#if A\n" 13002 " + 2\n" 13003 "#endif\n" 13004 " ;\n" 13005 "};"); 13006 13007 // Lambdas with complex multiline introducers. 13008 verifyFormat( 13009 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13010 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 13011 " -> ::std::unordered_set<\n" 13012 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 13013 " //\n" 13014 " });"); 13015 13016 FormatStyle DoNotMerge = getLLVMStyle(); 13017 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 13018 verifyFormat("auto c = []() {\n" 13019 " return b;\n" 13020 "};", 13021 "auto c = []() { return b; };", DoNotMerge); 13022 verifyFormat("auto c = []() {\n" 13023 "};", 13024 " auto c = []() {};", DoNotMerge); 13025 13026 FormatStyle MergeEmptyOnly = getLLVMStyle(); 13027 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 13028 verifyFormat("auto c = []() {\n" 13029 " return b;\n" 13030 "};", 13031 "auto c = []() {\n" 13032 " return b;\n" 13033 " };", 13034 MergeEmptyOnly); 13035 verifyFormat("auto c = []() {};", 13036 "auto c = []() {\n" 13037 "};", 13038 MergeEmptyOnly); 13039 13040 FormatStyle MergeInline = getLLVMStyle(); 13041 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 13042 verifyFormat("auto c = []() {\n" 13043 " return b;\n" 13044 "};", 13045 "auto c = []() { return b; };", MergeInline); 13046 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 13047 MergeInline); 13048 verifyFormat("function([]() { return b; }, a)", 13049 "function([]() { return b; }, a)", MergeInline); 13050 verifyFormat("function(a, []() { return b; })", 13051 "function(a, []() { return b; })", MergeInline); 13052 } 13053 13054 TEST_F(FormatTest, EmptyLinesInLambdas) { 13055 verifyFormat("auto lambda = []() {\n" 13056 " x(); //\n" 13057 "};", 13058 "auto lambda = []() {\n" 13059 "\n" 13060 " x(); //\n" 13061 "\n" 13062 "};"); 13063 } 13064 13065 TEST_F(FormatTest, FormatsBlocks) { 13066 FormatStyle ShortBlocks = getLLVMStyle(); 13067 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13068 verifyFormat("int (^Block)(int, int);", ShortBlocks); 13069 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 13070 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 13071 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 13072 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 13073 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 13074 13075 verifyFormat("foo(^{ bar(); });", ShortBlocks); 13076 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 13077 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 13078 13079 verifyFormat("[operation setCompletionBlock:^{\n" 13080 " [self onOperationDone];\n" 13081 "}];"); 13082 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 13083 " [self onOperationDone];\n" 13084 "}]};"); 13085 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 13086 " f();\n" 13087 "}];"); 13088 verifyFormat("int a = [operation block:^int(int *i) {\n" 13089 " return 1;\n" 13090 "}];"); 13091 verifyFormat("[myObject doSomethingWith:arg1\n" 13092 " aaa:^int(int *a) {\n" 13093 " return 1;\n" 13094 " }\n" 13095 " bbb:f(a * bbbbbbbb)];"); 13096 13097 verifyFormat("[operation setCompletionBlock:^{\n" 13098 " [self.delegate newDataAvailable];\n" 13099 "}];", 13100 getLLVMStyleWithColumns(60)); 13101 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 13102 " NSString *path = [self sessionFilePath];\n" 13103 " if (path) {\n" 13104 " // ...\n" 13105 " }\n" 13106 "});"); 13107 verifyFormat("[[SessionService sharedService]\n" 13108 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13109 " if (window) {\n" 13110 " [self windowDidLoad:window];\n" 13111 " } else {\n" 13112 " [self errorLoadingWindow];\n" 13113 " }\n" 13114 " }];"); 13115 verifyFormat("void (^largeBlock)(void) = ^{\n" 13116 " // ...\n" 13117 "};\n", 13118 getLLVMStyleWithColumns(40)); 13119 verifyFormat("[[SessionService sharedService]\n" 13120 " loadWindowWithCompletionBlock: //\n" 13121 " ^(SessionWindow *window) {\n" 13122 " if (window) {\n" 13123 " [self windowDidLoad:window];\n" 13124 " } else {\n" 13125 " [self errorLoadingWindow];\n" 13126 " }\n" 13127 " }];", 13128 getLLVMStyleWithColumns(60)); 13129 verifyFormat("[myObject doSomethingWith:arg1\n" 13130 " firstBlock:^(Foo *a) {\n" 13131 " // ...\n" 13132 " int i;\n" 13133 " }\n" 13134 " secondBlock:^(Bar *b) {\n" 13135 " // ...\n" 13136 " int i;\n" 13137 " }\n" 13138 " thirdBlock:^Foo(Bar *b) {\n" 13139 " // ...\n" 13140 " int i;\n" 13141 " }];"); 13142 verifyFormat("[myObject doSomethingWith:arg1\n" 13143 " firstBlock:-1\n" 13144 " secondBlock:^(Bar *b) {\n" 13145 " // ...\n" 13146 " int i;\n" 13147 " }];"); 13148 13149 verifyFormat("f(^{\n" 13150 " @autoreleasepool {\n" 13151 " if (a) {\n" 13152 " g();\n" 13153 " }\n" 13154 " }\n" 13155 "});"); 13156 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 13157 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 13158 "};"); 13159 13160 FormatStyle FourIndent = getLLVMStyle(); 13161 FourIndent.ObjCBlockIndentWidth = 4; 13162 verifyFormat("[operation setCompletionBlock:^{\n" 13163 " [self onOperationDone];\n" 13164 "}];", 13165 FourIndent); 13166 } 13167 13168 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 13169 FormatStyle ZeroColumn = getLLVMStyle(); 13170 ZeroColumn.ColumnLimit = 0; 13171 13172 verifyFormat("[[SessionService sharedService] " 13173 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13174 " if (window) {\n" 13175 " [self windowDidLoad:window];\n" 13176 " } else {\n" 13177 " [self errorLoadingWindow];\n" 13178 " }\n" 13179 "}];", 13180 ZeroColumn); 13181 EXPECT_EQ("[[SessionService sharedService]\n" 13182 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13183 " if (window) {\n" 13184 " [self windowDidLoad:window];\n" 13185 " } else {\n" 13186 " [self errorLoadingWindow];\n" 13187 " }\n" 13188 " }];", 13189 format("[[SessionService sharedService]\n" 13190 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13191 " if (window) {\n" 13192 " [self windowDidLoad:window];\n" 13193 " } else {\n" 13194 " [self errorLoadingWindow];\n" 13195 " }\n" 13196 "}];", 13197 ZeroColumn)); 13198 verifyFormat("[myObject doSomethingWith:arg1\n" 13199 " firstBlock:^(Foo *a) {\n" 13200 " // ...\n" 13201 " int i;\n" 13202 " }\n" 13203 " secondBlock:^(Bar *b) {\n" 13204 " // ...\n" 13205 " int i;\n" 13206 " }\n" 13207 " thirdBlock:^Foo(Bar *b) {\n" 13208 " // ...\n" 13209 " int i;\n" 13210 " }];", 13211 ZeroColumn); 13212 verifyFormat("f(^{\n" 13213 " @autoreleasepool {\n" 13214 " if (a) {\n" 13215 " g();\n" 13216 " }\n" 13217 " }\n" 13218 "});", 13219 ZeroColumn); 13220 verifyFormat("void (^largeBlock)(void) = ^{\n" 13221 " // ...\n" 13222 "};", 13223 ZeroColumn); 13224 13225 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13226 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 13227 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 13228 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 13229 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 13230 " int i;\n" 13231 "};", 13232 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 13233 } 13234 13235 TEST_F(FormatTest, SupportsCRLF) { 13236 EXPECT_EQ("int a;\r\n" 13237 "int b;\r\n" 13238 "int c;\r\n", 13239 format("int a;\r\n" 13240 " int b;\r\n" 13241 " int c;\r\n", 13242 getLLVMStyle())); 13243 EXPECT_EQ("int a;\r\n" 13244 "int b;\r\n" 13245 "int c;\r\n", 13246 format("int a;\r\n" 13247 " int b;\n" 13248 " int c;\r\n", 13249 getLLVMStyle())); 13250 EXPECT_EQ("int a;\n" 13251 "int b;\n" 13252 "int c;\n", 13253 format("int a;\r\n" 13254 " int b;\n" 13255 " int c;\n", 13256 getLLVMStyle())); 13257 EXPECT_EQ("\"aaaaaaa \"\r\n" 13258 "\"bbbbbbb\";\r\n", 13259 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 13260 EXPECT_EQ("#define A \\\r\n" 13261 " b; \\\r\n" 13262 " c; \\\r\n" 13263 " d;\r\n", 13264 format("#define A \\\r\n" 13265 " b; \\\r\n" 13266 " c; d; \r\n", 13267 getGoogleStyle())); 13268 13269 EXPECT_EQ("/*\r\n" 13270 "multi line block comments\r\n" 13271 "should not introduce\r\n" 13272 "an extra carriage return\r\n" 13273 "*/\r\n", 13274 format("/*\r\n" 13275 "multi line block comments\r\n" 13276 "should not introduce\r\n" 13277 "an extra carriage return\r\n" 13278 "*/\r\n")); 13279 EXPECT_EQ("/*\r\n" 13280 "\r\n" 13281 "*/", 13282 format("/*\r\n" 13283 " \r\r\r\n" 13284 "*/")); 13285 } 13286 13287 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 13288 verifyFormat("MY_CLASS(C) {\n" 13289 " int i;\n" 13290 " int j;\n" 13291 "};"); 13292 } 13293 13294 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 13295 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 13296 TwoIndent.ContinuationIndentWidth = 2; 13297 13298 EXPECT_EQ("int i =\n" 13299 " longFunction(\n" 13300 " arg);", 13301 format("int i = longFunction(arg);", TwoIndent)); 13302 13303 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 13304 SixIndent.ContinuationIndentWidth = 6; 13305 13306 EXPECT_EQ("int i =\n" 13307 " longFunction(\n" 13308 " arg);", 13309 format("int i = longFunction(arg);", SixIndent)); 13310 } 13311 13312 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 13313 FormatStyle Style = getLLVMStyle(); 13314 verifyFormat("int Foo::getter(\n" 13315 " //\n" 13316 ") const {\n" 13317 " return foo;\n" 13318 "}", 13319 Style); 13320 verifyFormat("void Foo::setter(\n" 13321 " //\n" 13322 ") {\n" 13323 " foo = 1;\n" 13324 "}", 13325 Style); 13326 } 13327 13328 TEST_F(FormatTest, SpacesInAngles) { 13329 FormatStyle Spaces = getLLVMStyle(); 13330 Spaces.SpacesInAngles = true; 13331 13332 verifyFormat("static_cast< int >(arg);", Spaces); 13333 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 13334 verifyFormat("f< int, float >();", Spaces); 13335 verifyFormat("template <> g() {}", Spaces); 13336 verifyFormat("template < std::vector< int > > f() {}", Spaces); 13337 verifyFormat("std::function< void(int, int) > fct;", Spaces); 13338 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 13339 Spaces); 13340 13341 Spaces.Standard = FormatStyle::LS_Cpp03; 13342 Spaces.SpacesInAngles = true; 13343 verifyFormat("A< A< int > >();", Spaces); 13344 13345 Spaces.SpacesInAngles = false; 13346 verifyFormat("A<A<int> >();", Spaces); 13347 13348 Spaces.Standard = FormatStyle::LS_Cpp11; 13349 Spaces.SpacesInAngles = true; 13350 verifyFormat("A< A< int > >();", Spaces); 13351 13352 Spaces.SpacesInAngles = false; 13353 verifyFormat("A<A<int>>();", Spaces); 13354 } 13355 13356 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 13357 FormatStyle Style = getLLVMStyle(); 13358 Style.SpaceAfterTemplateKeyword = false; 13359 verifyFormat("template<int> void foo();", Style); 13360 } 13361 13362 TEST_F(FormatTest, TripleAngleBrackets) { 13363 verifyFormat("f<<<1, 1>>>();"); 13364 verifyFormat("f<<<1, 1, 1, s>>>();"); 13365 verifyFormat("f<<<a, b, c, d>>>();"); 13366 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 13367 verifyFormat("f<param><<<1, 1>>>();"); 13368 verifyFormat("f<1><<<1, 1>>>();"); 13369 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 13370 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 13371 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 13372 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 13373 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 13374 } 13375 13376 TEST_F(FormatTest, MergeLessLessAtEnd) { 13377 verifyFormat("<<"); 13378 EXPECT_EQ("< < <", format("\\\n<<<")); 13379 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 13380 "aaallvm::outs() <<"); 13381 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 13382 "aaaallvm::outs()\n <<"); 13383 } 13384 13385 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 13386 std::string code = "#if A\n" 13387 "#if B\n" 13388 "a.\n" 13389 "#endif\n" 13390 " a = 1;\n" 13391 "#else\n" 13392 "#endif\n" 13393 "#if C\n" 13394 "#else\n" 13395 "#endif\n"; 13396 EXPECT_EQ(code, format(code)); 13397 } 13398 13399 TEST_F(FormatTest, HandleConflictMarkers) { 13400 // Git/SVN conflict markers. 13401 EXPECT_EQ("int a;\n" 13402 "void f() {\n" 13403 " callme(some(parameter1,\n" 13404 "<<<<<<< text by the vcs\n" 13405 " parameter2),\n" 13406 "||||||| text by the vcs\n" 13407 " parameter2),\n" 13408 " parameter3,\n" 13409 "======= text by the vcs\n" 13410 " parameter2, parameter3),\n" 13411 ">>>>>>> text by the vcs\n" 13412 " otherparameter);\n", 13413 format("int a;\n" 13414 "void f() {\n" 13415 " callme(some(parameter1,\n" 13416 "<<<<<<< text by the vcs\n" 13417 " parameter2),\n" 13418 "||||||| text by the vcs\n" 13419 " parameter2),\n" 13420 " parameter3,\n" 13421 "======= text by the vcs\n" 13422 " parameter2,\n" 13423 " parameter3),\n" 13424 ">>>>>>> text by the vcs\n" 13425 " otherparameter);\n")); 13426 13427 // Perforce markers. 13428 EXPECT_EQ("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 format("void f() {\n" 13439 " function(\n" 13440 ">>>> text by the vcs\n" 13441 " parameter,\n" 13442 "==== text by the vcs\n" 13443 " parameter,\n" 13444 "==== text by the vcs\n" 13445 " parameter,\n" 13446 "<<<< text by the vcs\n" 13447 " parameter);\n")); 13448 13449 EXPECT_EQ("<<<<<<<\n" 13450 "|||||||\n" 13451 "=======\n" 13452 ">>>>>>>", 13453 format("<<<<<<<\n" 13454 "|||||||\n" 13455 "=======\n" 13456 ">>>>>>>")); 13457 13458 EXPECT_EQ("<<<<<<<\n" 13459 "|||||||\n" 13460 "int i;\n" 13461 "=======\n" 13462 ">>>>>>>", 13463 format("<<<<<<<\n" 13464 "|||||||\n" 13465 "int i;\n" 13466 "=======\n" 13467 ">>>>>>>")); 13468 13469 // FIXME: Handle parsing of macros around conflict markers correctly: 13470 EXPECT_EQ("#define Macro \\\n" 13471 "<<<<<<<\n" 13472 "Something \\\n" 13473 "|||||||\n" 13474 "Else \\\n" 13475 "=======\n" 13476 "Other \\\n" 13477 ">>>>>>>\n" 13478 " End int i;\n", 13479 format("#define Macro \\\n" 13480 "<<<<<<<\n" 13481 " Something \\\n" 13482 "|||||||\n" 13483 " Else \\\n" 13484 "=======\n" 13485 " Other \\\n" 13486 ">>>>>>>\n" 13487 " End\n" 13488 "int i;\n")); 13489 } 13490 13491 TEST_F(FormatTest, DisableRegions) { 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 EXPECT_EQ("int i;\n" 13503 "/* clang-format off */\n" 13504 " int j;\n" 13505 "/* clang-format on */\n" 13506 "int k;", 13507 format(" int i;\n" 13508 " /* clang-format off */\n" 13509 " int j;\n" 13510 " /* clang-format on */\n" 13511 " int k;")); 13512 13513 // Don't reflow comments within disabled regions. 13514 EXPECT_EQ( 13515 "// clang-format off\n" 13516 "// long long long long long long line\n" 13517 "/* clang-format on */\n" 13518 "/* long long long\n" 13519 " * long long long\n" 13520 " * line */\n" 13521 "int i;\n" 13522 "/* clang-format off */\n" 13523 "/* long long long long long long line */\n", 13524 format("// clang-format off\n" 13525 "// long long long long long long line\n" 13526 "/* clang-format on */\n" 13527 "/* long long long long long long line */\n" 13528 "int i;\n" 13529 "/* clang-format off */\n" 13530 "/* long long long long long long line */\n", 13531 getLLVMStyleWithColumns(20))); 13532 } 13533 13534 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 13535 format("? ) ="); 13536 verifyNoCrash("#define a\\\n /**/}"); 13537 } 13538 13539 TEST_F(FormatTest, FormatsTableGenCode) { 13540 FormatStyle Style = getLLVMStyle(); 13541 Style.Language = FormatStyle::LK_TableGen; 13542 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 13543 } 13544 13545 TEST_F(FormatTest, ArrayOfTemplates) { 13546 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 13547 format("auto a = new unique_ptr<int > [ 10];")); 13548 13549 FormatStyle Spaces = getLLVMStyle(); 13550 Spaces.SpacesInSquareBrackets = true; 13551 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 13552 format("auto a = new unique_ptr<int > [10];", Spaces)); 13553 } 13554 13555 TEST_F(FormatTest, ArrayAsTemplateType) { 13556 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 13557 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 13558 13559 FormatStyle Spaces = getLLVMStyle(); 13560 Spaces.SpacesInSquareBrackets = true; 13561 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 13562 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 13563 } 13564 13565 TEST_F(FormatTest, NoSpaceAfterSuper) { 13566 verifyFormat("__super::FooBar();"); 13567 } 13568 13569 TEST(FormatStyle, GetStyleWithEmptyFileName) { 13570 llvm::vfs::InMemoryFileSystem FS; 13571 auto Style1 = getStyle("file", "", "Google", "", &FS); 13572 ASSERT_TRUE((bool)Style1); 13573 ASSERT_EQ(*Style1, getGoogleStyle()); 13574 } 13575 13576 TEST(FormatStyle, GetStyleOfFile) { 13577 llvm::vfs::InMemoryFileSystem FS; 13578 // Test 1: format file in the same directory. 13579 ASSERT_TRUE( 13580 FS.addFile("/a/.clang-format", 0, 13581 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 13582 ASSERT_TRUE( 13583 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13584 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 13585 ASSERT_TRUE((bool)Style1); 13586 ASSERT_EQ(*Style1, getLLVMStyle()); 13587 13588 // Test 2.1: fallback to default. 13589 ASSERT_TRUE( 13590 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13591 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 13592 ASSERT_TRUE((bool)Style2); 13593 ASSERT_EQ(*Style2, getMozillaStyle()); 13594 13595 // Test 2.2: no format on 'none' fallback style. 13596 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 13597 ASSERT_TRUE((bool)Style2); 13598 ASSERT_EQ(*Style2, getNoStyle()); 13599 13600 // Test 2.3: format if config is found with no based style while fallback is 13601 // 'none'. 13602 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 13603 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 13604 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 13605 ASSERT_TRUE((bool)Style2); 13606 ASSERT_EQ(*Style2, getLLVMStyle()); 13607 13608 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 13609 Style2 = getStyle("{}", "a.h", "none", "", &FS); 13610 ASSERT_TRUE((bool)Style2); 13611 ASSERT_EQ(*Style2, getLLVMStyle()); 13612 13613 // Test 3: format file in parent directory. 13614 ASSERT_TRUE( 13615 FS.addFile("/c/.clang-format", 0, 13616 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 13617 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 13618 llvm::MemoryBuffer::getMemBuffer("int i;"))); 13619 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 13620 ASSERT_TRUE((bool)Style3); 13621 ASSERT_EQ(*Style3, getGoogleStyle()); 13622 13623 // Test 4: error on invalid fallback style 13624 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 13625 ASSERT_FALSE((bool)Style4); 13626 llvm::consumeError(Style4.takeError()); 13627 13628 // Test 5: error on invalid yaml on command line 13629 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 13630 ASSERT_FALSE((bool)Style5); 13631 llvm::consumeError(Style5.takeError()); 13632 13633 // Test 6: error on invalid style 13634 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 13635 ASSERT_FALSE((bool)Style6); 13636 llvm::consumeError(Style6.takeError()); 13637 13638 // Test 7: found config file, error on parsing it 13639 ASSERT_TRUE( 13640 FS.addFile("/d/.clang-format", 0, 13641 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 13642 "InvalidKey: InvalidValue"))); 13643 ASSERT_TRUE( 13644 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13645 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 13646 ASSERT_FALSE((bool)Style7); 13647 llvm::consumeError(Style7.takeError()); 13648 13649 // Test 8: inferred per-language defaults apply. 13650 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 13651 ASSERT_TRUE((bool)StyleTd); 13652 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 13653 } 13654 13655 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 13656 // Column limit is 20. 13657 std::string Code = "Type *a =\n" 13658 " new Type();\n" 13659 "g(iiiii, 0, jjjjj,\n" 13660 " 0, kkkkk, 0, mm);\n" 13661 "int bad = format ;"; 13662 std::string Expected = "auto a = new Type();\n" 13663 "g(iiiii, nullptr,\n" 13664 " jjjjj, nullptr,\n" 13665 " kkkkk, nullptr,\n" 13666 " mm);\n" 13667 "int bad = format ;"; 13668 FileID ID = Context.createInMemoryFile("format.cpp", Code); 13669 tooling::Replacements Replaces = toReplacements( 13670 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 13671 "auto "), 13672 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 13673 "nullptr"), 13674 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 13675 "nullptr"), 13676 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 13677 "nullptr")}); 13678 13679 format::FormatStyle Style = format::getLLVMStyle(); 13680 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 13681 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 13682 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 13683 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 13684 auto Result = applyAllReplacements(Code, *FormattedReplaces); 13685 EXPECT_TRUE(static_cast<bool>(Result)); 13686 EXPECT_EQ(Expected, *Result); 13687 } 13688 13689 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 13690 std::string Code = "#include \"a.h\"\n" 13691 "#include \"c.h\"\n" 13692 "\n" 13693 "int main() {\n" 13694 " return 0;\n" 13695 "}"; 13696 std::string Expected = "#include \"a.h\"\n" 13697 "#include \"b.h\"\n" 13698 "#include \"c.h\"\n" 13699 "\n" 13700 "int main() {\n" 13701 " return 0;\n" 13702 "}"; 13703 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 13704 tooling::Replacements Replaces = toReplacements( 13705 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 13706 "#include \"b.h\"\n")}); 13707 13708 format::FormatStyle Style = format::getLLVMStyle(); 13709 Style.SortIncludes = true; 13710 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 13711 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 13712 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 13713 auto Result = applyAllReplacements(Code, *FormattedReplaces); 13714 EXPECT_TRUE(static_cast<bool>(Result)); 13715 EXPECT_EQ(Expected, *Result); 13716 } 13717 13718 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 13719 EXPECT_EQ("using std::cin;\n" 13720 "using std::cout;", 13721 format("using std::cout;\n" 13722 "using std::cin;", getGoogleStyle())); 13723 } 13724 13725 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 13726 format::FormatStyle Style = format::getLLVMStyle(); 13727 Style.Standard = FormatStyle::LS_Cpp03; 13728 // cpp03 recognize this string as identifier u8 and literal character 'a' 13729 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 13730 } 13731 13732 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 13733 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 13734 // all modes, including C++11, C++14 and C++17 13735 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 13736 } 13737 13738 TEST_F(FormatTest, DoNotFormatLikelyXml) { 13739 EXPECT_EQ("<!-- ;> -->", 13740 format("<!-- ;> -->", getGoogleStyle())); 13741 EXPECT_EQ(" <!-- >; -->", 13742 format(" <!-- >; -->", getGoogleStyle())); 13743 } 13744 13745 TEST_F(FormatTest, StructuredBindings) { 13746 // Structured bindings is a C++17 feature. 13747 // all modes, including C++11, C++14 and C++17 13748 verifyFormat("auto [a, b] = f();"); 13749 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 13750 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 13751 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 13752 EXPECT_EQ("auto const volatile [a, b] = f();", 13753 format("auto const volatile[a, b] = f();")); 13754 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 13755 EXPECT_EQ("auto &[a, b, c] = f();", 13756 format("auto &[ a , b,c ] = f();")); 13757 EXPECT_EQ("auto &&[a, b, c] = f();", 13758 format("auto &&[ a , b,c ] = f();")); 13759 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 13760 EXPECT_EQ("auto const volatile &&[a, b] = f();", 13761 format("auto const volatile &&[a, b] = f();")); 13762 EXPECT_EQ("auto const &&[a, b] = f();", format("auto const && [a, b] = f();")); 13763 EXPECT_EQ("const auto &[a, b] = f();", format("const auto & [a, b] = f();")); 13764 EXPECT_EQ("const auto volatile &&[a, b] = f();", 13765 format("const auto volatile &&[a, b] = f();")); 13766 EXPECT_EQ("volatile const auto &&[a, b] = f();", 13767 format("volatile const auto &&[a, b] = f();")); 13768 EXPECT_EQ("const auto &&[a, b] = f();", format("const auto && [a, b] = f();")); 13769 13770 // Make sure we don't mistake structured bindings for lambdas. 13771 FormatStyle PointerMiddle = getLLVMStyle(); 13772 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 13773 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 13774 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 13775 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 13776 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 13777 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 13778 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 13779 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 13780 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 13781 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 13782 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 13783 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 13784 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 13785 13786 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 13787 format("for (const auto && [a, b] : some_range) {\n}")); 13788 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 13789 format("for (const auto & [a, b] : some_range) {\n}")); 13790 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 13791 format("for (const auto[a, b] : some_range) {\n}")); 13792 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 13793 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 13794 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 13795 EXPECT_EQ("auto const &[x, y](expr);", format("auto const & [x,y] (expr);")); 13796 EXPECT_EQ("auto const &&[x, y](expr);", format("auto const && [x,y] (expr);")); 13797 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 13798 EXPECT_EQ("auto const &[x, y]{expr};", format("auto const & [x,y] {expr};")); 13799 EXPECT_EQ("auto const &&[x, y]{expr};", format("auto const && [x,y] {expr};")); 13800 13801 format::FormatStyle Spaces = format::getLLVMStyle(); 13802 Spaces.SpacesInSquareBrackets = true; 13803 verifyFormat("auto [ a, b ] = f();", Spaces); 13804 verifyFormat("auto &&[ a, b ] = f();", Spaces); 13805 verifyFormat("auto &[ a, b ] = f();", Spaces); 13806 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 13807 verifyFormat("auto const &[ a, b ] = f();", Spaces); 13808 } 13809 13810 TEST_F(FormatTest, FileAndCode) { 13811 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 13812 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 13813 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 13814 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 13815 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@interface Foo\n@end\n")); 13816 EXPECT_EQ( 13817 FormatStyle::LK_ObjC, 13818 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 13819 EXPECT_EQ(FormatStyle::LK_ObjC, 13820 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 13821 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 13822 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 13823 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo", "@interface Foo\n@end\n")); 13824 EXPECT_EQ(FormatStyle::LK_ObjC, 13825 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 13826 EXPECT_EQ( 13827 FormatStyle::LK_ObjC, 13828 guessLanguage("foo.h", 13829 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 13830 EXPECT_EQ( 13831 FormatStyle::LK_Cpp, 13832 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 13833 } 13834 13835 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 13836 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 13837 EXPECT_EQ(FormatStyle::LK_ObjC, 13838 guessLanguage("foo.h", "array[[calculator getIndex]];")); 13839 EXPECT_EQ(FormatStyle::LK_Cpp, 13840 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 13841 EXPECT_EQ( 13842 FormatStyle::LK_Cpp, 13843 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 13844 EXPECT_EQ(FormatStyle::LK_ObjC, 13845 guessLanguage("foo.h", "[[noreturn foo] bar];")); 13846 EXPECT_EQ(FormatStyle::LK_Cpp, 13847 guessLanguage("foo.h", "[[clang::fallthrough]];")); 13848 EXPECT_EQ(FormatStyle::LK_ObjC, 13849 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 13850 EXPECT_EQ(FormatStyle::LK_Cpp, 13851 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 13852 EXPECT_EQ(FormatStyle::LK_Cpp, 13853 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 13854 EXPECT_EQ(FormatStyle::LK_ObjC, 13855 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 13856 EXPECT_EQ(FormatStyle::LK_Cpp, 13857 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 13858 EXPECT_EQ( 13859 FormatStyle::LK_Cpp, 13860 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 13861 EXPECT_EQ( 13862 FormatStyle::LK_Cpp, 13863 guessLanguage("foo.h", 13864 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 13865 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 13866 } 13867 13868 TEST_F(FormatTest, GuessLanguageWithCaret) { 13869 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 13870 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 13871 EXPECT_EQ(FormatStyle::LK_ObjC, 13872 guessLanguage("foo.h", "int(^)(char, float);")); 13873 EXPECT_EQ(FormatStyle::LK_ObjC, 13874 guessLanguage("foo.h", "int(^foo)(char, float);")); 13875 EXPECT_EQ(FormatStyle::LK_ObjC, 13876 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 13877 EXPECT_EQ(FormatStyle::LK_ObjC, 13878 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 13879 EXPECT_EQ( 13880 FormatStyle::LK_ObjC, 13881 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 13882 } 13883 13884 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 13885 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13886 "void f() {\n" 13887 " asm (\"mov %[e], %[d]\"\n" 13888 " : [d] \"=rm\" (d)\n" 13889 " [e] \"rm\" (*e));\n" 13890 "}")); 13891 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13892 "void f() {\n" 13893 " _asm (\"mov %[e], %[d]\"\n" 13894 " : [d] \"=rm\" (d)\n" 13895 " [e] \"rm\" (*e));\n" 13896 "}")); 13897 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13898 "void f() {\n" 13899 " __asm (\"mov %[e], %[d]\"\n" 13900 " : [d] \"=rm\" (d)\n" 13901 " [e] \"rm\" (*e));\n" 13902 "}")); 13903 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13904 "void f() {\n" 13905 " __asm__ (\"mov %[e], %[d]\"\n" 13906 " : [d] \"=rm\" (d)\n" 13907 " [e] \"rm\" (*e));\n" 13908 "}")); 13909 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13910 "void f() {\n" 13911 " asm (\"mov %[e], %[d]\"\n" 13912 " : [d] \"=rm\" (d),\n" 13913 " [e] \"rm\" (*e));\n" 13914 "}")); 13915 EXPECT_EQ(FormatStyle::LK_Cpp, 13916 guessLanguage("foo.h", "void f() {\n" 13917 " asm volatile (\"mov %[e], %[d]\"\n" 13918 " : [d] \"=rm\" (d)\n" 13919 " [e] \"rm\" (*e));\n" 13920 "}")); 13921 } 13922 13923 TEST_F(FormatTest, GuessLanguageWithChildLines) { 13924 EXPECT_EQ(FormatStyle::LK_Cpp, 13925 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 13926 EXPECT_EQ(FormatStyle::LK_ObjC, 13927 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 13928 EXPECT_EQ( 13929 FormatStyle::LK_Cpp, 13930 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 13931 EXPECT_EQ( 13932 FormatStyle::LK_ObjC, 13933 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 13934 } 13935 13936 TEST_F(FormatTest, TypenameMacros) { 13937 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 13938 13939 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 13940 FormatStyle Google = getGoogleStyleWithColumns(0); 13941 Google.TypenameMacros = TypenameMacros; 13942 verifyFormat("struct foo {\n" 13943 " int bar;\n" 13944 " TAILQ_ENTRY(a) bleh;\n" 13945 "};", Google); 13946 13947 FormatStyle Macros = getLLVMStyle(); 13948 Macros.TypenameMacros = TypenameMacros; 13949 13950 verifyFormat("STACK_OF(int) a;", Macros); 13951 verifyFormat("STACK_OF(int) *a;", Macros); 13952 verifyFormat("STACK_OF(int const *) *a;", Macros); 13953 verifyFormat("STACK_OF(int *const) *a;", Macros); 13954 verifyFormat("STACK_OF(int, string) a;", Macros); 13955 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 13956 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 13957 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 13958 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 13959 13960 Macros.PointerAlignment = FormatStyle::PAS_Left; 13961 verifyFormat("STACK_OF(int)* a;", Macros); 13962 verifyFormat("STACK_OF(int*)* a;", Macros); 13963 } 13964 13965 } // end namespace 13966 } // end namespace format 13967 } // end namespace clang 13968