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 { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck }; 33 34 std::string format(llvm::StringRef Code, 35 const FormatStyle &Style = getLLVMStyle(), 36 StatusCheck CheckComplete = SC_ExpectComplete) { 37 LLVM_DEBUG(llvm::errs() << "---\n"); 38 LLVM_DEBUG(llvm::errs() << Code << "\n\n"); 39 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size())); 40 FormattingAttemptStatus Status; 41 tooling::Replacements Replaces = 42 reformat(Style, Code, Ranges, "<stdin>", &Status); 43 if (CheckComplete != SC_DoNotCheck) { 44 bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete; 45 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete) 46 << Code << "\n\n"; 47 } 48 ReplacementCount = Replaces.size(); 49 auto Result = applyAllReplacements(Code, Replaces); 50 EXPECT_TRUE(static_cast<bool>(Result)); 51 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); 52 return *Result; 53 } 54 55 FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) { 56 Style.ColumnLimit = ColumnLimit; 57 return Style; 58 } 59 60 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 61 return getStyleWithColumns(getLLVMStyle(), ColumnLimit); 62 } 63 64 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) { 65 return getStyleWithColumns(getGoogleStyle(), ColumnLimit); 66 } 67 68 void verifyFormat(llvm::StringRef Expected, llvm::StringRef Code, 69 const FormatStyle &Style = getLLVMStyle()) { 70 EXPECT_EQ(Expected.str(), format(Expected, Style)) 71 << "Expected code is not stable"; 72 EXPECT_EQ(Expected.str(), format(Code, Style)); 73 if (Style.Language == FormatStyle::LK_Cpp) { 74 // Objective-C++ is a superset of C++, so everything checked for C++ 75 // needs to be checked for Objective-C++ as well. 76 FormatStyle ObjCStyle = Style; 77 ObjCStyle.Language = FormatStyle::LK_ObjC; 78 EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle)); 79 } 80 } 81 82 void verifyFormat(llvm::StringRef Code, 83 const FormatStyle &Style = getLLVMStyle()) { 84 verifyFormat(Code, test::messUp(Code), Style); 85 } 86 87 void verifyIncompleteFormat(llvm::StringRef Code, 88 const FormatStyle &Style = getLLVMStyle()) { 89 EXPECT_EQ(Code.str(), 90 format(test::messUp(Code), Style, SC_ExpectIncomplete)); 91 } 92 93 void verifyGoogleFormat(llvm::StringRef Code) { 94 verifyFormat(Code, getGoogleStyle()); 95 } 96 97 void verifyIndependentOfContext(llvm::StringRef text) { 98 verifyFormat(text); 99 verifyFormat(llvm::Twine("void f() { " + text + " }").str()); 100 } 101 102 /// \brief Verify that clang-format does not crash on the given input. 103 void verifyNoCrash(llvm::StringRef Code, 104 const FormatStyle &Style = getLLVMStyle()) { 105 format(Code, Style, SC_DoNotCheck); 106 } 107 108 int ReplacementCount; 109 }; 110 111 TEST_F(FormatTest, MessUp) { 112 EXPECT_EQ("1 2 3", test::messUp("1 2 3")); 113 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n")); 114 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc")); 115 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc")); 116 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne")); 117 } 118 119 TEST_F(FormatTest, DefaultLLVMStyleIsCpp) { 120 EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language); 121 } 122 123 TEST_F(FormatTest, LLVMStyleOverride) { 124 EXPECT_EQ(FormatStyle::LK_Proto, 125 getLLVMStyle(FormatStyle::LK_Proto).Language); 126 } 127 128 //===----------------------------------------------------------------------===// 129 // Basic function tests. 130 //===----------------------------------------------------------------------===// 131 132 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { 133 EXPECT_EQ(";", format(";")); 134 } 135 136 TEST_F(FormatTest, FormatsGlobalStatementsAt0) { 137 EXPECT_EQ("int i;", format(" int i;")); 138 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;")); 139 EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); 140 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); 141 } 142 143 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { 144 EXPECT_EQ("int i;", format("int\ni;")); 145 } 146 147 TEST_F(FormatTest, FormatsNestedBlockStatements) { 148 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}")); 149 } 150 151 TEST_F(FormatTest, FormatsNestedCall) { 152 verifyFormat("Method(f1, f2(f3));"); 153 verifyFormat("Method(f1(f2, f3()));"); 154 verifyFormat("Method(f1(f2, (f3())));"); 155 } 156 157 TEST_F(FormatTest, NestedNameSpecifiers) { 158 verifyFormat("vector<::Type> v;"); 159 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())"); 160 verifyFormat("static constexpr bool Bar = decltype(bar())::value;"); 161 verifyFormat("bool a = 2 < ::SomeFunction();"); 162 verifyFormat("ALWAYS_INLINE ::std::string getName();"); 163 verifyFormat("some::string getName();"); 164 } 165 166 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { 167 EXPECT_EQ("if (a) {\n" 168 " f();\n" 169 "}", 170 format("if(a){f();}")); 171 EXPECT_EQ(4, ReplacementCount); 172 EXPECT_EQ("if (a) {\n" 173 " f();\n" 174 "}", 175 format("if (a) {\n" 176 " f();\n" 177 "}")); 178 EXPECT_EQ(0, ReplacementCount); 179 EXPECT_EQ("/*\r\n" 180 "\r\n" 181 "*/\r\n", 182 format("/*\r\n" 183 "\r\n" 184 "*/\r\n")); 185 EXPECT_EQ(0, ReplacementCount); 186 } 187 188 TEST_F(FormatTest, RemovesEmptyLines) { 189 EXPECT_EQ("class C {\n" 190 " int i;\n" 191 "};", 192 format("class C {\n" 193 " int i;\n" 194 "\n" 195 "};")); 196 197 // Don't remove empty lines at the start of namespaces or extern "C" blocks. 198 EXPECT_EQ("namespace N {\n" 199 "\n" 200 "int i;\n" 201 "}", 202 format("namespace N {\n" 203 "\n" 204 "int i;\n" 205 "}", 206 getGoogleStyle())); 207 EXPECT_EQ("/* something */ namespace N {\n" 208 "\n" 209 "int i;\n" 210 "}", 211 format("/* something */ namespace N {\n" 212 "\n" 213 "int i;\n" 214 "}", 215 getGoogleStyle())); 216 EXPECT_EQ("inline namespace N {\n" 217 "\n" 218 "int i;\n" 219 "}", 220 format("inline namespace N {\n" 221 "\n" 222 "int i;\n" 223 "}", 224 getGoogleStyle())); 225 EXPECT_EQ("/* something */ inline namespace N {\n" 226 "\n" 227 "int i;\n" 228 "}", 229 format("/* something */ inline namespace N {\n" 230 "\n" 231 "int i;\n" 232 "}", 233 getGoogleStyle())); 234 EXPECT_EQ("export namespace N {\n" 235 "\n" 236 "int i;\n" 237 "}", 238 format("export namespace N {\n" 239 "\n" 240 "int i;\n" 241 "}", 242 getGoogleStyle())); 243 EXPECT_EQ("extern /**/ \"C\" /**/ {\n" 244 "\n" 245 "int i;\n" 246 "}", 247 format("extern /**/ \"C\" /**/ {\n" 248 "\n" 249 "int i;\n" 250 "}", 251 getGoogleStyle())); 252 253 // ...but do keep inlining and removing empty lines for non-block extern "C" 254 // functions. 255 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle()); 256 EXPECT_EQ("extern \"C\" int f() {\n" 257 " int i = 42;\n" 258 " return i;\n" 259 "}", 260 format("extern \"C\" int f() {\n" 261 "\n" 262 " int i = 42;\n" 263 " return i;\n" 264 "}", 265 getGoogleStyle())); 266 267 // Remove empty lines at the beginning and end of blocks. 268 EXPECT_EQ("void f() {\n" 269 "\n" 270 " if (a) {\n" 271 "\n" 272 " f();\n" 273 " }\n" 274 "}", 275 format("void f() {\n" 276 "\n" 277 " if (a) {\n" 278 "\n" 279 " f();\n" 280 "\n" 281 " }\n" 282 "\n" 283 "}", 284 getLLVMStyle())); 285 EXPECT_EQ("void f() {\n" 286 " if (a) {\n" 287 " f();\n" 288 " }\n" 289 "}", 290 format("void f() {\n" 291 "\n" 292 " if (a) {\n" 293 "\n" 294 " f();\n" 295 "\n" 296 " }\n" 297 "\n" 298 "}", 299 getGoogleStyle())); 300 301 // Don't remove empty lines in more complex control statements. 302 EXPECT_EQ("void f() {\n" 303 " if (a) {\n" 304 " f();\n" 305 "\n" 306 " } else if (b) {\n" 307 " f();\n" 308 " }\n" 309 "}", 310 format("void f() {\n" 311 " if (a) {\n" 312 " f();\n" 313 "\n" 314 " } else if (b) {\n" 315 " f();\n" 316 "\n" 317 " }\n" 318 "\n" 319 "}")); 320 321 // Don't remove empty lines before namespace endings. 322 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 323 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 324 EXPECT_EQ("namespace {\n" 325 "int i;\n" 326 "\n" 327 "}", 328 format("namespace {\n" 329 "int i;\n" 330 "\n" 331 "}", 332 LLVMWithNoNamespaceFix)); 333 EXPECT_EQ("namespace {\n" 334 "int i;\n" 335 "}", 336 format("namespace {\n" 337 "int i;\n" 338 "}", 339 LLVMWithNoNamespaceFix)); 340 EXPECT_EQ("namespace {\n" 341 "int i;\n" 342 "\n" 343 "};", 344 format("namespace {\n" 345 "int i;\n" 346 "\n" 347 "};", 348 LLVMWithNoNamespaceFix)); 349 EXPECT_EQ("namespace {\n" 350 "int i;\n" 351 "};", 352 format("namespace {\n" 353 "int i;\n" 354 "};", 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 = 648 FormatStyle::BWACS_Always; 649 650 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 651 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 652 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 653 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 654 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 655 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 656 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 657 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 658 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 659 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 660 verifyFormat("if (true)\n" 661 "{\n" 662 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 663 "}", 664 AllowSimpleBracedStatements); 665 verifyFormat("if (true)\n" 666 "{ //\n" 667 " f();\n" 668 "}", 669 AllowSimpleBracedStatements); 670 verifyFormat("if (true)\n" 671 "{\n" 672 " f();\n" 673 " f();\n" 674 "}", 675 AllowSimpleBracedStatements); 676 verifyFormat("if (true)\n" 677 "{\n" 678 " f();\n" 679 "} else\n" 680 "{\n" 681 " f();\n" 682 "}", 683 AllowSimpleBracedStatements); 684 685 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 686 FormatStyle::SIS_Never; 687 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 688 verifyFormat("if (true)\n" 689 "{\n" 690 " f();\n" 691 "}", 692 AllowSimpleBracedStatements); 693 verifyFormat("if (true)\n" 694 "{\n" 695 " f();\n" 696 "} else\n" 697 "{\n" 698 " f();\n" 699 "}", 700 AllowSimpleBracedStatements); 701 702 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 703 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 704 verifyFormat("while (true)\n" 705 "{\n" 706 " f();\n" 707 "}", 708 AllowSimpleBracedStatements); 709 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 710 verifyFormat("for (;;)\n" 711 "{\n" 712 " f();\n" 713 "}", 714 AllowSimpleBracedStatements); 715 } 716 717 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) { 718 FormatStyle Style = getLLVMStyleWithColumns(60); 719 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 720 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 721 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 722 EXPECT_EQ("#define A \\\n" 723 " if (HANDLEwernufrnuLwrmviferuvnierv) \\\n" 724 " { RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; }\n" 725 "X;", 726 format("#define A \\\n" 727 " if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n" 728 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n" 729 " }\n" 730 "X;", 731 Style)); 732 } 733 734 TEST_F(FormatTest, ParseIfElse) { 735 verifyFormat("if (true)\n" 736 " if (true)\n" 737 " if (true)\n" 738 " f();\n" 739 " else\n" 740 " g();\n" 741 " else\n" 742 " h();\n" 743 "else\n" 744 " i();"); 745 verifyFormat("if (true)\n" 746 " if (true)\n" 747 " if (true) {\n" 748 " if (true)\n" 749 " f();\n" 750 " } else {\n" 751 " g();\n" 752 " }\n" 753 " else\n" 754 " h();\n" 755 "else {\n" 756 " i();\n" 757 "}"); 758 verifyFormat("if (true)\n" 759 " if constexpr (true)\n" 760 " if (true) {\n" 761 " if constexpr (true)\n" 762 " f();\n" 763 " } else {\n" 764 " g();\n" 765 " }\n" 766 " else\n" 767 " h();\n" 768 "else {\n" 769 " i();\n" 770 "}"); 771 verifyFormat("if (true)\n" 772 " if CONSTEXPR (true)\n" 773 " if (true) {\n" 774 " if CONSTEXPR (true)\n" 775 " f();\n" 776 " } else {\n" 777 " g();\n" 778 " }\n" 779 " else\n" 780 " h();\n" 781 "else {\n" 782 " i();\n" 783 "}"); 784 verifyFormat("void f() {\n" 785 " if (a) {\n" 786 " } else {\n" 787 " }\n" 788 "}"); 789 } 790 791 TEST_F(FormatTest, ElseIf) { 792 verifyFormat("if (a) {\n} else if (b) {\n}"); 793 verifyFormat("if (a)\n" 794 " f();\n" 795 "else if (b)\n" 796 " g();\n" 797 "else\n" 798 " h();"); 799 verifyFormat("if constexpr (a)\n" 800 " f();\n" 801 "else if constexpr (b)\n" 802 " g();\n" 803 "else\n" 804 " h();"); 805 verifyFormat("if CONSTEXPR (a)\n" 806 " f();\n" 807 "else if CONSTEXPR (b)\n" 808 " g();\n" 809 "else\n" 810 " h();"); 811 verifyFormat("if (a) {\n" 812 " f();\n" 813 "}\n" 814 "// or else ..\n" 815 "else {\n" 816 " g()\n" 817 "}"); 818 819 verifyFormat("if (a) {\n" 820 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 821 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 822 "}"); 823 verifyFormat("if (a) {\n" 824 "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 825 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 826 "}"); 827 verifyFormat("if (a) {\n" 828 "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 829 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 830 "}"); 831 verifyFormat("if (a) {\n" 832 "} else if (\n" 833 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 834 "}", 835 getLLVMStyleWithColumns(62)); 836 verifyFormat("if (a) {\n" 837 "} else if constexpr (\n" 838 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 839 "}", 840 getLLVMStyleWithColumns(62)); 841 verifyFormat("if (a) {\n" 842 "} else if CONSTEXPR (\n" 843 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 844 "}", 845 getLLVMStyleWithColumns(62)); 846 } 847 848 TEST_F(FormatTest, FormatsForLoop) { 849 verifyFormat( 850 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 851 " ++VeryVeryLongLoopVariable)\n" 852 " ;"); 853 verifyFormat("for (;;)\n" 854 " f();"); 855 verifyFormat("for (;;) {\n}"); 856 verifyFormat("for (;;) {\n" 857 " f();\n" 858 "}"); 859 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 860 861 verifyFormat( 862 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 863 " E = UnwrappedLines.end();\n" 864 " I != E; ++I) {\n}"); 865 866 verifyFormat( 867 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 868 " ++IIIII) {\n}"); 869 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 870 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 871 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 872 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 873 " I = FD->getDeclsInPrototypeScope().begin(),\n" 874 " E = FD->getDeclsInPrototypeScope().end();\n" 875 " I != E; ++I) {\n}"); 876 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n" 877 " I = Container.begin(),\n" 878 " E = Container.end();\n" 879 " I != E; ++I) {\n}", 880 getLLVMStyleWithColumns(76)); 881 882 verifyFormat( 883 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 884 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 885 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 886 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 887 " ++aaaaaaaaaaa) {\n}"); 888 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 889 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n" 890 " ++i) {\n}"); 891 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 892 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 893 "}"); 894 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 895 " aaaaaaaaaa);\n" 896 " iter; ++iter) {\n" 897 "}"); 898 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 899 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 900 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n" 901 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {"); 902 903 // These should not be formatted as Objective-C for-in loops. 904 verifyFormat("for (Foo *x = 0; x != in; x++) {\n}"); 905 verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}"); 906 verifyFormat("Foo *x;\nfor (x in y) {\n}"); 907 verifyFormat( 908 "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}"); 909 910 FormatStyle NoBinPacking = getLLVMStyle(); 911 NoBinPacking.BinPackParameters = false; 912 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 913 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 914 " aaaaaaaaaaaaaaaa,\n" 915 " aaaaaaaaaaaaaaaa,\n" 916 " aaaaaaaaaaaaaaaa);\n" 917 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 918 "}", 919 NoBinPacking); 920 verifyFormat( 921 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 922 " E = UnwrappedLines.end();\n" 923 " I != E;\n" 924 " ++I) {\n}", 925 NoBinPacking); 926 927 FormatStyle AlignLeft = getLLVMStyle(); 928 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 929 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft); 930 } 931 932 TEST_F(FormatTest, RangeBasedForLoops) { 933 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 934 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 935 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 936 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 937 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 938 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 939 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n" 940 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}"); 941 } 942 943 TEST_F(FormatTest, ForEachLoops) { 944 verifyFormat("void f() {\n" 945 " foreach (Item *item, itemlist) {}\n" 946 " Q_FOREACH (Item *item, itemlist) {}\n" 947 " BOOST_FOREACH (Item *item, itemlist) {}\n" 948 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 949 "}"); 950 951 // As function-like macros. 952 verifyFormat("#define foreach(x, y)\n" 953 "#define Q_FOREACH(x, y)\n" 954 "#define BOOST_FOREACH(x, y)\n" 955 "#define UNKNOWN_FOREACH(x, y)\n"); 956 957 // Not as function-like macros. 958 verifyFormat("#define foreach (x, y)\n" 959 "#define Q_FOREACH (x, y)\n" 960 "#define BOOST_FOREACH (x, y)\n" 961 "#define UNKNOWN_FOREACH (x, y)\n"); 962 } 963 964 TEST_F(FormatTest, FormatsWhileLoop) { 965 verifyFormat("while (true) {\n}"); 966 verifyFormat("while (true)\n" 967 " f();"); 968 verifyFormat("while () {\n}"); 969 verifyFormat("while () {\n" 970 " f();\n" 971 "}"); 972 } 973 974 TEST_F(FormatTest, FormatsDoWhile) { 975 verifyFormat("do {\n" 976 " do_something();\n" 977 "} while (something());"); 978 verifyFormat("do\n" 979 " do_something();\n" 980 "while (something());"); 981 } 982 983 TEST_F(FormatTest, FormatsSwitchStatement) { 984 verifyFormat("switch (x) {\n" 985 "case 1:\n" 986 " f();\n" 987 " break;\n" 988 "case kFoo:\n" 989 "case ns::kBar:\n" 990 "case kBaz:\n" 991 " break;\n" 992 "default:\n" 993 " g();\n" 994 " break;\n" 995 "}"); 996 verifyFormat("switch (x) {\n" 997 "case 1: {\n" 998 " f();\n" 999 " break;\n" 1000 "}\n" 1001 "case 2: {\n" 1002 " break;\n" 1003 "}\n" 1004 "}"); 1005 verifyFormat("switch (x) {\n" 1006 "case 1: {\n" 1007 " f();\n" 1008 " {\n" 1009 " g();\n" 1010 " h();\n" 1011 " }\n" 1012 " break;\n" 1013 "}\n" 1014 "}"); 1015 verifyFormat("switch (x) {\n" 1016 "case 1: {\n" 1017 " f();\n" 1018 " if (foo) {\n" 1019 " g();\n" 1020 " h();\n" 1021 " }\n" 1022 " break;\n" 1023 "}\n" 1024 "}"); 1025 verifyFormat("switch (x) {\n" 1026 "case 1: {\n" 1027 " f();\n" 1028 " g();\n" 1029 "} break;\n" 1030 "}"); 1031 verifyFormat("switch (test)\n" 1032 " ;"); 1033 verifyFormat("switch (x) {\n" 1034 "default: {\n" 1035 " // Do nothing.\n" 1036 "}\n" 1037 "}"); 1038 verifyFormat("switch (x) {\n" 1039 "// comment\n" 1040 "// if 1, do f()\n" 1041 "case 1:\n" 1042 " f();\n" 1043 "}"); 1044 verifyFormat("switch (x) {\n" 1045 "case 1:\n" 1046 " // Do amazing stuff\n" 1047 " {\n" 1048 " f();\n" 1049 " g();\n" 1050 " }\n" 1051 " break;\n" 1052 "}"); 1053 verifyFormat("#define A \\\n" 1054 " switch (x) { \\\n" 1055 " case a: \\\n" 1056 " foo = b; \\\n" 1057 " }", 1058 getLLVMStyleWithColumns(20)); 1059 verifyFormat("#define OPERATION_CASE(name) \\\n" 1060 " case OP_name: \\\n" 1061 " return operations::Operation##name\n", 1062 getLLVMStyleWithColumns(40)); 1063 verifyFormat("switch (x) {\n" 1064 "case 1:;\n" 1065 "default:;\n" 1066 " int i;\n" 1067 "}"); 1068 1069 verifyGoogleFormat("switch (x) {\n" 1070 " case 1:\n" 1071 " f();\n" 1072 " break;\n" 1073 " case kFoo:\n" 1074 " case ns::kBar:\n" 1075 " case kBaz:\n" 1076 " break;\n" 1077 " default:\n" 1078 " g();\n" 1079 " break;\n" 1080 "}"); 1081 verifyGoogleFormat("switch (x) {\n" 1082 " case 1: {\n" 1083 " f();\n" 1084 " break;\n" 1085 " }\n" 1086 "}"); 1087 verifyGoogleFormat("switch (test)\n" 1088 " ;"); 1089 1090 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 1091 " case OP_name: \\\n" 1092 " return operations::Operation##name\n"); 1093 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 1094 " // Get the correction operation class.\n" 1095 " switch (OpCode) {\n" 1096 " CASE(Add);\n" 1097 " CASE(Subtract);\n" 1098 " default:\n" 1099 " return operations::Unknown;\n" 1100 " }\n" 1101 "#undef OPERATION_CASE\n" 1102 "}"); 1103 verifyFormat("DEBUG({\n" 1104 " switch (x) {\n" 1105 " case A:\n" 1106 " f();\n" 1107 " break;\n" 1108 " // fallthrough\n" 1109 " case B:\n" 1110 " g();\n" 1111 " break;\n" 1112 " }\n" 1113 "});"); 1114 EXPECT_EQ("DEBUG({\n" 1115 " switch (x) {\n" 1116 " case A:\n" 1117 " f();\n" 1118 " break;\n" 1119 " // On B:\n" 1120 " case B:\n" 1121 " g();\n" 1122 " break;\n" 1123 " }\n" 1124 "});", 1125 format("DEBUG({\n" 1126 " switch (x) {\n" 1127 " case A:\n" 1128 " f();\n" 1129 " break;\n" 1130 " // On B:\n" 1131 " case B:\n" 1132 " g();\n" 1133 " break;\n" 1134 " }\n" 1135 "});", 1136 getLLVMStyle())); 1137 EXPECT_EQ("switch (n) {\n" 1138 "case 0: {\n" 1139 " return false;\n" 1140 "}\n" 1141 "default: {\n" 1142 " return true;\n" 1143 "}\n" 1144 "}", 1145 format("switch (n)\n" 1146 "{\n" 1147 "case 0: {\n" 1148 " return false;\n" 1149 "}\n" 1150 "default: {\n" 1151 " return true;\n" 1152 "}\n" 1153 "}", 1154 getLLVMStyle())); 1155 verifyFormat("switch (a) {\n" 1156 "case (b):\n" 1157 " return;\n" 1158 "}"); 1159 1160 verifyFormat("switch (a) {\n" 1161 "case some_namespace::\n" 1162 " some_constant:\n" 1163 " return;\n" 1164 "}", 1165 getLLVMStyleWithColumns(34)); 1166 1167 FormatStyle Style = getLLVMStyle(); 1168 Style.IndentCaseLabels = true; 1169 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 1170 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1171 Style.BraceWrapping.AfterCaseLabel = true; 1172 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1173 EXPECT_EQ("switch (n)\n" 1174 "{\n" 1175 " case 0:\n" 1176 " {\n" 1177 " return false;\n" 1178 " }\n" 1179 " default:\n" 1180 " {\n" 1181 " return true;\n" 1182 " }\n" 1183 "}", 1184 format("switch (n) {\n" 1185 " case 0: {\n" 1186 " return false;\n" 1187 " }\n" 1188 " default: {\n" 1189 " return true;\n" 1190 " }\n" 1191 "}", 1192 Style)); 1193 Style.BraceWrapping.AfterCaseLabel = false; 1194 EXPECT_EQ("switch (n)\n" 1195 "{\n" 1196 " case 0: {\n" 1197 " return false;\n" 1198 " }\n" 1199 " default: {\n" 1200 " return true;\n" 1201 " }\n" 1202 "}", 1203 format("switch (n) {\n" 1204 " case 0:\n" 1205 " {\n" 1206 " return false;\n" 1207 " }\n" 1208 " default:\n" 1209 " {\n" 1210 " return true;\n" 1211 " }\n" 1212 "}", 1213 Style)); 1214 } 1215 1216 TEST_F(FormatTest, CaseRanges) { 1217 verifyFormat("switch (x) {\n" 1218 "case 'A' ... 'Z':\n" 1219 "case 1 ... 5:\n" 1220 "case a ... b:\n" 1221 " break;\n" 1222 "}"); 1223 } 1224 1225 TEST_F(FormatTest, ShortCaseLabels) { 1226 FormatStyle Style = getLLVMStyle(); 1227 Style.AllowShortCaseLabelsOnASingleLine = true; 1228 verifyFormat("switch (a) {\n" 1229 "case 1: x = 1; break;\n" 1230 "case 2: return;\n" 1231 "case 3:\n" 1232 "case 4:\n" 1233 "case 5: return;\n" 1234 "case 6: // comment\n" 1235 " return;\n" 1236 "case 7:\n" 1237 " // comment\n" 1238 " return;\n" 1239 "case 8:\n" 1240 " x = 8; // comment\n" 1241 " break;\n" 1242 "default: y = 1; break;\n" 1243 "}", 1244 Style); 1245 verifyFormat("switch (a) {\n" 1246 "case 0: return; // comment\n" 1247 "case 1: break; // comment\n" 1248 "case 2: return;\n" 1249 "// comment\n" 1250 "case 3: return;\n" 1251 "// comment 1\n" 1252 "// comment 2\n" 1253 "// comment 3\n" 1254 "case 4: break; /* comment */\n" 1255 "case 5:\n" 1256 " // comment\n" 1257 " break;\n" 1258 "case 6: /* comment */ x = 1; break;\n" 1259 "case 7: x = /* comment */ 1; break;\n" 1260 "case 8:\n" 1261 " x = 1; /* comment */\n" 1262 " break;\n" 1263 "case 9:\n" 1264 " break; // comment line 1\n" 1265 " // comment line 2\n" 1266 "}", 1267 Style); 1268 EXPECT_EQ("switch (a) {\n" 1269 "case 1:\n" 1270 " x = 8;\n" 1271 " // fall through\n" 1272 "case 2: x = 8;\n" 1273 "// comment\n" 1274 "case 3:\n" 1275 " return; /* comment line 1\n" 1276 " * comment line 2 */\n" 1277 "case 4: i = 8;\n" 1278 "// something else\n" 1279 "#if FOO\n" 1280 "case 5: break;\n" 1281 "#endif\n" 1282 "}", 1283 format("switch (a) {\n" 1284 "case 1: x = 8;\n" 1285 " // fall through\n" 1286 "case 2:\n" 1287 " x = 8;\n" 1288 "// comment\n" 1289 "case 3:\n" 1290 " return; /* comment line 1\n" 1291 " * comment line 2 */\n" 1292 "case 4:\n" 1293 " i = 8;\n" 1294 "// something else\n" 1295 "#if FOO\n" 1296 "case 5: break;\n" 1297 "#endif\n" 1298 "}", 1299 Style)); 1300 EXPECT_EQ("switch (a) {\n" 1301 "case 0:\n" 1302 " return; // long long long long long long long long long long " 1303 "long long comment\n" 1304 " // line\n" 1305 "}", 1306 format("switch (a) {\n" 1307 "case 0: return; // long long long long long long long long " 1308 "long long long long comment line\n" 1309 "}", 1310 Style)); 1311 EXPECT_EQ("switch (a) {\n" 1312 "case 0:\n" 1313 " return; /* long long long long long long long long long long " 1314 "long long comment\n" 1315 " line */\n" 1316 "}", 1317 format("switch (a) {\n" 1318 "case 0: return; /* long long long long long long long long " 1319 "long long long long comment line */\n" 1320 "}", 1321 Style)); 1322 verifyFormat("switch (a) {\n" 1323 "#if FOO\n" 1324 "case 0: return 0;\n" 1325 "#endif\n" 1326 "}", 1327 Style); 1328 verifyFormat("switch (a) {\n" 1329 "case 1: {\n" 1330 "}\n" 1331 "case 2: {\n" 1332 " return;\n" 1333 "}\n" 1334 "case 3: {\n" 1335 " x = 1;\n" 1336 " return;\n" 1337 "}\n" 1338 "case 4:\n" 1339 " if (x)\n" 1340 " return;\n" 1341 "}", 1342 Style); 1343 Style.ColumnLimit = 21; 1344 verifyFormat("switch (a) {\n" 1345 "case 1: x = 1; break;\n" 1346 "case 2: return;\n" 1347 "case 3:\n" 1348 "case 4:\n" 1349 "case 5: return;\n" 1350 "default:\n" 1351 " y = 1;\n" 1352 " break;\n" 1353 "}", 1354 Style); 1355 Style.ColumnLimit = 80; 1356 Style.AllowShortCaseLabelsOnASingleLine = false; 1357 Style.IndentCaseLabels = true; 1358 EXPECT_EQ("switch (n) {\n" 1359 " default /*comments*/:\n" 1360 " return true;\n" 1361 " case 0:\n" 1362 " return false;\n" 1363 "}", 1364 format("switch (n) {\n" 1365 "default/*comments*/:\n" 1366 " return true;\n" 1367 "case 0:\n" 1368 " return false;\n" 1369 "}", 1370 Style)); 1371 Style.AllowShortCaseLabelsOnASingleLine = true; 1372 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1373 Style.BraceWrapping.AfterCaseLabel = true; 1374 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1375 EXPECT_EQ("switch (n)\n" 1376 "{\n" 1377 " case 0:\n" 1378 " {\n" 1379 " return false;\n" 1380 " }\n" 1381 " default:\n" 1382 " {\n" 1383 " return true;\n" 1384 " }\n" 1385 "}", 1386 format("switch (n) {\n" 1387 " case 0: {\n" 1388 " return false;\n" 1389 " }\n" 1390 " default:\n" 1391 " {\n" 1392 " return true;\n" 1393 " }\n" 1394 "}", 1395 Style)); 1396 } 1397 1398 TEST_F(FormatTest, FormatsLabels) { 1399 verifyFormat("void f() {\n" 1400 " some_code();\n" 1401 "test_label:\n" 1402 " some_other_code();\n" 1403 " {\n" 1404 " some_more_code();\n" 1405 " another_label:\n" 1406 " some_more_code();\n" 1407 " }\n" 1408 "}"); 1409 verifyFormat("{\n" 1410 " some_code();\n" 1411 "test_label:\n" 1412 " some_other_code();\n" 1413 "}"); 1414 verifyFormat("{\n" 1415 " some_code();\n" 1416 "test_label:;\n" 1417 " int i = 0;\n" 1418 "}"); 1419 FormatStyle Style = getLLVMStyle(); 1420 Style.IndentGotoLabels = false; 1421 verifyFormat("void f() {\n" 1422 " some_code();\n" 1423 "test_label:\n" 1424 " some_other_code();\n" 1425 " {\n" 1426 " some_more_code();\n" 1427 "another_label:\n" 1428 " some_more_code();\n" 1429 " }\n" 1430 "}", 1431 Style); 1432 verifyFormat("{\n" 1433 " some_code();\n" 1434 "test_label:\n" 1435 " some_other_code();\n" 1436 "}", 1437 Style); 1438 verifyFormat("{\n" 1439 " some_code();\n" 1440 "test_label:;\n" 1441 " int i = 0;\n" 1442 "}"); 1443 } 1444 1445 TEST_F(FormatTest, MultiLineControlStatements) { 1446 FormatStyle Style = getLLVMStyle(); 1447 Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom; 1448 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine; 1449 Style.ColumnLimit = 20; 1450 // Short lines should keep opening brace on same line. 1451 EXPECT_EQ("if (foo) {\n" 1452 " bar();\n" 1453 "}", 1454 format("if(foo){bar();}", Style)); 1455 EXPECT_EQ("if (foo) {\n" 1456 " bar();\n" 1457 "} else {\n" 1458 " baz();\n" 1459 "}", 1460 format("if(foo){bar();}else{baz();}", Style)); 1461 EXPECT_EQ("if (foo && bar) {\n" 1462 " baz();\n" 1463 "}", 1464 format("if(foo&&bar){baz();}", Style)); 1465 EXPECT_EQ("if (foo) {\n" 1466 " bar();\n" 1467 "} else if (baz) {\n" 1468 " quux();\n" 1469 "}", 1470 format("if(foo){bar();}else if(baz){quux();}", Style)); 1471 EXPECT_EQ( 1472 "if (foo) {\n" 1473 " bar();\n" 1474 "} else if (baz) {\n" 1475 " quux();\n" 1476 "} else {\n" 1477 " foobar();\n" 1478 "}", 1479 format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style)); 1480 EXPECT_EQ("for (;;) {\n" 1481 " foo();\n" 1482 "}", 1483 format("for(;;){foo();}")); 1484 EXPECT_EQ("while (1) {\n" 1485 " foo();\n" 1486 "}", 1487 format("while(1){foo();}", Style)); 1488 EXPECT_EQ("switch (foo) {\n" 1489 "case bar:\n" 1490 " return;\n" 1491 "}", 1492 format("switch(foo){case bar:return;}", Style)); 1493 EXPECT_EQ("try {\n" 1494 " foo();\n" 1495 "} catch (...) {\n" 1496 " bar();\n" 1497 "}", 1498 format("try{foo();}catch(...){bar();}", Style)); 1499 EXPECT_EQ("do {\n" 1500 " foo();\n" 1501 "} while (bar &&\n" 1502 " baz);", 1503 format("do{foo();}while(bar&&baz);", Style)); 1504 // Long lines should put opening brace on new line. 1505 EXPECT_EQ("if (foo && bar &&\n" 1506 " baz)\n" 1507 "{\n" 1508 " quux();\n" 1509 "}", 1510 format("if(foo&&bar&&baz){quux();}", Style)); 1511 EXPECT_EQ("if (foo && bar &&\n" 1512 " baz)\n" 1513 "{\n" 1514 " quux();\n" 1515 "}", 1516 format("if (foo && bar &&\n" 1517 " baz) {\n" 1518 " quux();\n" 1519 "}", 1520 Style)); 1521 EXPECT_EQ("if (foo) {\n" 1522 " bar();\n" 1523 "} else if (baz ||\n" 1524 " quux)\n" 1525 "{\n" 1526 " foobar();\n" 1527 "}", 1528 format("if(foo){bar();}else if(baz||quux){foobar();}", Style)); 1529 EXPECT_EQ( 1530 "if (foo) {\n" 1531 " bar();\n" 1532 "} else if (baz ||\n" 1533 " quux)\n" 1534 "{\n" 1535 " foobar();\n" 1536 "} else {\n" 1537 " barbaz();\n" 1538 "}", 1539 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1540 Style)); 1541 EXPECT_EQ("for (int i = 0;\n" 1542 " i < 10; ++i)\n" 1543 "{\n" 1544 " foo();\n" 1545 "}", 1546 format("for(int i=0;i<10;++i){foo();}", Style)); 1547 EXPECT_EQ("while (foo || bar ||\n" 1548 " baz)\n" 1549 "{\n" 1550 " quux();\n" 1551 "}", 1552 format("while(foo||bar||baz){quux();}", Style)); 1553 EXPECT_EQ("switch (\n" 1554 " foo = barbaz)\n" 1555 "{\n" 1556 "case quux:\n" 1557 " return;\n" 1558 "}", 1559 format("switch(foo=barbaz){case quux:return;}", Style)); 1560 EXPECT_EQ("try {\n" 1561 " foo();\n" 1562 "} catch (\n" 1563 " Exception &bar)\n" 1564 "{\n" 1565 " baz();\n" 1566 "}", 1567 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1568 } 1569 1570 //===----------------------------------------------------------------------===// 1571 // Tests for classes, namespaces, etc. 1572 //===----------------------------------------------------------------------===// 1573 1574 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1575 verifyFormat("class A {};"); 1576 } 1577 1578 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1579 verifyFormat("class A {\n" 1580 "public:\n" 1581 "public: // comment\n" 1582 "protected:\n" 1583 "private:\n" 1584 " void f() {}\n" 1585 "};"); 1586 verifyFormat("export class A {\n" 1587 "public:\n" 1588 "public: // comment\n" 1589 "protected:\n" 1590 "private:\n" 1591 " void f() {}\n" 1592 "};"); 1593 verifyGoogleFormat("class A {\n" 1594 " public:\n" 1595 " protected:\n" 1596 " private:\n" 1597 " void f() {}\n" 1598 "};"); 1599 verifyGoogleFormat("export class A {\n" 1600 " public:\n" 1601 " protected:\n" 1602 " private:\n" 1603 " void f() {}\n" 1604 "};"); 1605 verifyFormat("class A {\n" 1606 "public slots:\n" 1607 " void f1() {}\n" 1608 "public Q_SLOTS:\n" 1609 " void f2() {}\n" 1610 "protected slots:\n" 1611 " void f3() {}\n" 1612 "protected Q_SLOTS:\n" 1613 " void f4() {}\n" 1614 "private slots:\n" 1615 " void f5() {}\n" 1616 "private Q_SLOTS:\n" 1617 " void f6() {}\n" 1618 "signals:\n" 1619 " void g1();\n" 1620 "Q_SIGNALS:\n" 1621 " void g2();\n" 1622 "};"); 1623 1624 // Don't interpret 'signals' the wrong way. 1625 verifyFormat("signals.set();"); 1626 verifyFormat("for (Signals signals : f()) {\n}"); 1627 verifyFormat("{\n" 1628 " signals.set(); // This needs indentation.\n" 1629 "}"); 1630 verifyFormat("void f() {\n" 1631 "label:\n" 1632 " signals.baz();\n" 1633 "}"); 1634 } 1635 1636 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1637 EXPECT_EQ("class A {\n" 1638 "public:\n" 1639 " void f();\n" 1640 "\n" 1641 "private:\n" 1642 " void g() {}\n" 1643 " // test\n" 1644 "protected:\n" 1645 " int h;\n" 1646 "};", 1647 format("class A {\n" 1648 "public:\n" 1649 "void f();\n" 1650 "private:\n" 1651 "void g() {}\n" 1652 "// test\n" 1653 "protected:\n" 1654 "int h;\n" 1655 "};")); 1656 EXPECT_EQ("class A {\n" 1657 "protected:\n" 1658 "public:\n" 1659 " void f();\n" 1660 "};", 1661 format("class A {\n" 1662 "protected:\n" 1663 "\n" 1664 "public:\n" 1665 "\n" 1666 " void f();\n" 1667 "};")); 1668 1669 // Even ensure proper spacing inside macros. 1670 EXPECT_EQ("#define B \\\n" 1671 " class A { \\\n" 1672 " protected: \\\n" 1673 " public: \\\n" 1674 " void f(); \\\n" 1675 " };", 1676 format("#define B \\\n" 1677 " class A { \\\n" 1678 " protected: \\\n" 1679 " \\\n" 1680 " public: \\\n" 1681 " \\\n" 1682 " void f(); \\\n" 1683 " };", 1684 getGoogleStyle())); 1685 // But don't remove empty lines after macros ending in access specifiers. 1686 EXPECT_EQ("#define A private:\n" 1687 "\n" 1688 "int i;", 1689 format("#define A private:\n" 1690 "\n" 1691 "int i;")); 1692 } 1693 1694 TEST_F(FormatTest, FormatsClasses) { 1695 verifyFormat("class A : public B {};"); 1696 verifyFormat("class A : public ::B {};"); 1697 1698 verifyFormat( 1699 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1700 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1701 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1702 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1703 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1704 verifyFormat( 1705 "class A : public B, public C, public D, public E, public F {};"); 1706 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1707 " public C,\n" 1708 " public D,\n" 1709 " public E,\n" 1710 " public F,\n" 1711 " public G {};"); 1712 1713 verifyFormat("class\n" 1714 " ReallyReallyLongClassName {\n" 1715 " int i;\n" 1716 "};", 1717 getLLVMStyleWithColumns(32)); 1718 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1719 " aaaaaaaaaaaaaaaa> {};"); 1720 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1721 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1722 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1723 verifyFormat("template <class R, class C>\n" 1724 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1725 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1726 verifyFormat("class ::A::B {};"); 1727 } 1728 1729 TEST_F(FormatTest, BreakInheritanceStyle) { 1730 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1731 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1732 FormatStyle::BILS_BeforeComma; 1733 verifyFormat("class MyClass : public X {};", 1734 StyleWithInheritanceBreakBeforeComma); 1735 verifyFormat("class MyClass\n" 1736 " : public X\n" 1737 " , public Y {};", 1738 StyleWithInheritanceBreakBeforeComma); 1739 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1740 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1741 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1742 StyleWithInheritanceBreakBeforeComma); 1743 verifyFormat("struct aaaaaaaaaaaaa\n" 1744 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1745 " aaaaaaaaaaaaaaaa> {};", 1746 StyleWithInheritanceBreakBeforeComma); 1747 1748 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1749 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1750 FormatStyle::BILS_AfterColon; 1751 verifyFormat("class MyClass : public X {};", 1752 StyleWithInheritanceBreakAfterColon); 1753 verifyFormat("class MyClass : public X, public Y {};", 1754 StyleWithInheritanceBreakAfterColon); 1755 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1756 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1757 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1758 StyleWithInheritanceBreakAfterColon); 1759 verifyFormat("struct aaaaaaaaaaaaa :\n" 1760 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1761 " aaaaaaaaaaaaaaaa> {};", 1762 StyleWithInheritanceBreakAfterColon); 1763 } 1764 1765 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1766 verifyFormat("class A {\n} a, b;"); 1767 verifyFormat("struct A {\n} a, b;"); 1768 verifyFormat("union A {\n} a;"); 1769 } 1770 1771 TEST_F(FormatTest, FormatsEnum) { 1772 verifyFormat("enum {\n" 1773 " Zero,\n" 1774 " One = 1,\n" 1775 " Two = One + 1,\n" 1776 " Three = (One + Two),\n" 1777 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1778 " Five = (One, Two, Three, Four, 5)\n" 1779 "};"); 1780 verifyGoogleFormat("enum {\n" 1781 " Zero,\n" 1782 " One = 1,\n" 1783 " Two = One + 1,\n" 1784 " Three = (One + Two),\n" 1785 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1786 " Five = (One, Two, Three, Four, 5)\n" 1787 "};"); 1788 verifyFormat("enum Enum {};"); 1789 verifyFormat("enum {};"); 1790 verifyFormat("enum X E {} d;"); 1791 verifyFormat("enum __attribute__((...)) E {} d;"); 1792 verifyFormat("enum __declspec__((...)) E {} d;"); 1793 verifyFormat("enum {\n" 1794 " Bar = Foo<int, int>::value\n" 1795 "};", 1796 getLLVMStyleWithColumns(30)); 1797 1798 verifyFormat("enum ShortEnum { A, B, C };"); 1799 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1800 1801 EXPECT_EQ("enum KeepEmptyLines {\n" 1802 " ONE,\n" 1803 "\n" 1804 " TWO,\n" 1805 "\n" 1806 " THREE\n" 1807 "}", 1808 format("enum KeepEmptyLines {\n" 1809 " ONE,\n" 1810 "\n" 1811 " TWO,\n" 1812 "\n" 1813 "\n" 1814 " THREE\n" 1815 "}")); 1816 verifyFormat("enum E { // comment\n" 1817 " ONE,\n" 1818 " TWO\n" 1819 "};\n" 1820 "int i;"); 1821 // Not enums. 1822 verifyFormat("enum X f() {\n" 1823 " a();\n" 1824 " return 42;\n" 1825 "}"); 1826 verifyFormat("enum X Type::f() {\n" 1827 " a();\n" 1828 " return 42;\n" 1829 "}"); 1830 verifyFormat("enum ::X f() {\n" 1831 " a();\n" 1832 " return 42;\n" 1833 "}"); 1834 verifyFormat("enum ns::X f() {\n" 1835 " a();\n" 1836 " return 42;\n" 1837 "}"); 1838 } 1839 1840 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1841 verifyFormat("enum Type {\n" 1842 " One = 0; // These semicolons should be commas.\n" 1843 " Two = 1;\n" 1844 "};"); 1845 verifyFormat("namespace n {\n" 1846 "enum Type {\n" 1847 " One,\n" 1848 " Two, // missing };\n" 1849 " int i;\n" 1850 "}\n" 1851 "void g() {}"); 1852 } 1853 1854 TEST_F(FormatTest, FormatsEnumStruct) { 1855 verifyFormat("enum struct {\n" 1856 " Zero,\n" 1857 " One = 1,\n" 1858 " Two = One + 1,\n" 1859 " Three = (One + Two),\n" 1860 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1861 " Five = (One, Two, Three, Four, 5)\n" 1862 "};"); 1863 verifyFormat("enum struct Enum {};"); 1864 verifyFormat("enum struct {};"); 1865 verifyFormat("enum struct X E {} d;"); 1866 verifyFormat("enum struct __attribute__((...)) E {} d;"); 1867 verifyFormat("enum struct __declspec__((...)) E {} d;"); 1868 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1869 } 1870 1871 TEST_F(FormatTest, FormatsEnumClass) { 1872 verifyFormat("enum class {\n" 1873 " Zero,\n" 1874 " One = 1,\n" 1875 " Two = One + 1,\n" 1876 " Three = (One + Two),\n" 1877 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1878 " Five = (One, Two, Three, Four, 5)\n" 1879 "};"); 1880 verifyFormat("enum class Enum {};"); 1881 verifyFormat("enum class {};"); 1882 verifyFormat("enum class X E {} d;"); 1883 verifyFormat("enum class __attribute__((...)) E {} d;"); 1884 verifyFormat("enum class __declspec__((...)) E {} d;"); 1885 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 1886 } 1887 1888 TEST_F(FormatTest, FormatsEnumTypes) { 1889 verifyFormat("enum X : int {\n" 1890 " A, // Force multiple lines.\n" 1891 " B\n" 1892 "};"); 1893 verifyFormat("enum X : int { A, B };"); 1894 verifyFormat("enum X : std::uint32_t { A, B };"); 1895 } 1896 1897 TEST_F(FormatTest, FormatsTypedefEnum) { 1898 FormatStyle Style = getLLVMStyle(); 1899 Style.ColumnLimit = 40; 1900 verifyFormat("typedef enum {} EmptyEnum;"); 1901 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1902 verifyFormat("typedef enum {\n" 1903 " ZERO = 0,\n" 1904 " ONE = 1,\n" 1905 " TWO = 2,\n" 1906 " THREE = 3\n" 1907 "} LongEnum;", 1908 Style); 1909 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1910 Style.BraceWrapping.AfterEnum = true; 1911 verifyFormat("typedef enum {} EmptyEnum;"); 1912 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1913 verifyFormat("typedef enum\n" 1914 "{\n" 1915 " ZERO = 0,\n" 1916 " ONE = 1,\n" 1917 " TWO = 2,\n" 1918 " THREE = 3\n" 1919 "} LongEnum;", 1920 Style); 1921 } 1922 1923 TEST_F(FormatTest, FormatsNSEnums) { 1924 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1925 verifyGoogleFormat( 1926 "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1927 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 1928 " // Information about someDecentlyLongValue.\n" 1929 " someDecentlyLongValue,\n" 1930 " // Information about anotherDecentlyLongValue.\n" 1931 " anotherDecentlyLongValue,\n" 1932 " // Information about aThirdDecentlyLongValue.\n" 1933 " aThirdDecentlyLongValue\n" 1934 "};"); 1935 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n" 1936 " // Information about someDecentlyLongValue.\n" 1937 " someDecentlyLongValue,\n" 1938 " // Information about anotherDecentlyLongValue.\n" 1939 " anotherDecentlyLongValue,\n" 1940 " // Information about aThirdDecentlyLongValue.\n" 1941 " aThirdDecentlyLongValue\n" 1942 "};"); 1943 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 1944 " a = 1,\n" 1945 " b = 2,\n" 1946 " c = 3,\n" 1947 "};"); 1948 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 1949 " a = 1,\n" 1950 " b = 2,\n" 1951 " c = 3,\n" 1952 "};"); 1953 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n" 1954 " a = 1,\n" 1955 " b = 2,\n" 1956 " c = 3,\n" 1957 "};"); 1958 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 1959 " a = 1,\n" 1960 " b = 2,\n" 1961 " c = 3,\n" 1962 "};"); 1963 } 1964 1965 TEST_F(FormatTest, FormatsBitfields) { 1966 verifyFormat("struct Bitfields {\n" 1967 " unsigned sClass : 8;\n" 1968 " unsigned ValueKind : 2;\n" 1969 "};"); 1970 verifyFormat("struct A {\n" 1971 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 1972 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 1973 "};"); 1974 verifyFormat("struct MyStruct {\n" 1975 " uchar data;\n" 1976 " uchar : 8;\n" 1977 " uchar : 8;\n" 1978 " uchar other;\n" 1979 "};"); 1980 } 1981 1982 TEST_F(FormatTest, FormatsNamespaces) { 1983 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 1984 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 1985 1986 verifyFormat("namespace some_namespace {\n" 1987 "class A {};\n" 1988 "void f() { f(); }\n" 1989 "}", 1990 LLVMWithNoNamespaceFix); 1991 verifyFormat("namespace N::inline D {\n" 1992 "class A {};\n" 1993 "void f() { f(); }\n" 1994 "}", 1995 LLVMWithNoNamespaceFix); 1996 verifyFormat("namespace N::inline D::E {\n" 1997 "class A {};\n" 1998 "void f() { f(); }\n" 1999 "}", 2000 LLVMWithNoNamespaceFix); 2001 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n" 2002 "class A {};\n" 2003 "void f() { f(); }\n" 2004 "}", 2005 LLVMWithNoNamespaceFix); 2006 verifyFormat("/* something */ namespace some_namespace {\n" 2007 "class A {};\n" 2008 "void f() { f(); }\n" 2009 "}", 2010 LLVMWithNoNamespaceFix); 2011 verifyFormat("namespace {\n" 2012 "class A {};\n" 2013 "void f() { f(); }\n" 2014 "}", 2015 LLVMWithNoNamespaceFix); 2016 verifyFormat("/* something */ namespace {\n" 2017 "class A {};\n" 2018 "void f() { f(); }\n" 2019 "}", 2020 LLVMWithNoNamespaceFix); 2021 verifyFormat("inline namespace X {\n" 2022 "class A {};\n" 2023 "void f() { f(); }\n" 2024 "}", 2025 LLVMWithNoNamespaceFix); 2026 verifyFormat("/* something */ inline namespace X {\n" 2027 "class A {};\n" 2028 "void f() { f(); }\n" 2029 "}", 2030 LLVMWithNoNamespaceFix); 2031 verifyFormat("export namespace X {\n" 2032 "class A {};\n" 2033 "void f() { f(); }\n" 2034 "}", 2035 LLVMWithNoNamespaceFix); 2036 verifyFormat("using namespace some_namespace;\n" 2037 "class A {};\n" 2038 "void f() { f(); }", 2039 LLVMWithNoNamespaceFix); 2040 2041 // This code is more common than we thought; if we 2042 // layout this correctly the semicolon will go into 2043 // its own line, which is undesirable. 2044 verifyFormat("namespace {};", LLVMWithNoNamespaceFix); 2045 verifyFormat("namespace {\n" 2046 "class A {};\n" 2047 "};", 2048 LLVMWithNoNamespaceFix); 2049 2050 verifyFormat("namespace {\n" 2051 "int SomeVariable = 0; // comment\n" 2052 "} // namespace", 2053 LLVMWithNoNamespaceFix); 2054 EXPECT_EQ("#ifndef HEADER_GUARD\n" 2055 "#define HEADER_GUARD\n" 2056 "namespace my_namespace {\n" 2057 "int i;\n" 2058 "} // my_namespace\n" 2059 "#endif // HEADER_GUARD", 2060 format("#ifndef HEADER_GUARD\n" 2061 " #define HEADER_GUARD\n" 2062 " namespace my_namespace {\n" 2063 "int i;\n" 2064 "} // my_namespace\n" 2065 "#endif // HEADER_GUARD", 2066 LLVMWithNoNamespaceFix)); 2067 2068 EXPECT_EQ("namespace A::B {\n" 2069 "class C {};\n" 2070 "}", 2071 format("namespace A::B {\n" 2072 "class C {};\n" 2073 "}", 2074 LLVMWithNoNamespaceFix)); 2075 2076 FormatStyle Style = getLLVMStyle(); 2077 Style.NamespaceIndentation = FormatStyle::NI_All; 2078 EXPECT_EQ("namespace out {\n" 2079 " int i;\n" 2080 " namespace in {\n" 2081 " int i;\n" 2082 " } // namespace in\n" 2083 "} // namespace out", 2084 format("namespace out {\n" 2085 "int i;\n" 2086 "namespace in {\n" 2087 "int i;\n" 2088 "} // namespace in\n" 2089 "} // namespace out", 2090 Style)); 2091 2092 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2093 EXPECT_EQ("namespace out {\n" 2094 "int i;\n" 2095 "namespace in {\n" 2096 " int i;\n" 2097 "} // namespace in\n" 2098 "} // namespace out", 2099 format("namespace out {\n" 2100 "int i;\n" 2101 "namespace in {\n" 2102 "int i;\n" 2103 "} // namespace in\n" 2104 "} // namespace out", 2105 Style)); 2106 } 2107 2108 TEST_F(FormatTest, NamespaceMacros) { 2109 FormatStyle Style = getLLVMStyle(); 2110 Style.NamespaceMacros.push_back("TESTSUITE"); 2111 2112 verifyFormat("TESTSUITE(A) {\n" 2113 "int foo();\n" 2114 "} // TESTSUITE(A)", 2115 Style); 2116 2117 verifyFormat("TESTSUITE(A, B) {\n" 2118 "int foo();\n" 2119 "} // TESTSUITE(A)", 2120 Style); 2121 2122 // Properly indent according to NamespaceIndentation style 2123 Style.NamespaceIndentation = FormatStyle::NI_All; 2124 verifyFormat("TESTSUITE(A) {\n" 2125 " int foo();\n" 2126 "} // TESTSUITE(A)", 2127 Style); 2128 verifyFormat("TESTSUITE(A) {\n" 2129 " namespace B {\n" 2130 " int foo();\n" 2131 " } // namespace B\n" 2132 "} // TESTSUITE(A)", 2133 Style); 2134 verifyFormat("namespace A {\n" 2135 " TESTSUITE(B) {\n" 2136 " int foo();\n" 2137 " } // TESTSUITE(B)\n" 2138 "} // namespace A", 2139 Style); 2140 2141 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2142 verifyFormat("TESTSUITE(A) {\n" 2143 "TESTSUITE(B) {\n" 2144 " int foo();\n" 2145 "} // TESTSUITE(B)\n" 2146 "} // TESTSUITE(A)", 2147 Style); 2148 verifyFormat("TESTSUITE(A) {\n" 2149 "namespace B {\n" 2150 " int foo();\n" 2151 "} // namespace B\n" 2152 "} // TESTSUITE(A)", 2153 Style); 2154 verifyFormat("namespace A {\n" 2155 "TESTSUITE(B) {\n" 2156 " int foo();\n" 2157 "} // TESTSUITE(B)\n" 2158 "} // namespace A", 2159 Style); 2160 2161 // Properly merge namespace-macros blocks in CompactNamespaces mode 2162 Style.NamespaceIndentation = FormatStyle::NI_None; 2163 Style.CompactNamespaces = true; 2164 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n" 2165 "}} // TESTSUITE(A::B)", 2166 Style); 2167 2168 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2169 "}} // TESTSUITE(out::in)", 2170 format("TESTSUITE(out) {\n" 2171 "TESTSUITE(in) {\n" 2172 "} // TESTSUITE(in)\n" 2173 "} // TESTSUITE(out)", 2174 Style)); 2175 2176 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2177 "}} // TESTSUITE(out::in)", 2178 format("TESTSUITE(out) {\n" 2179 "TESTSUITE(in) {\n" 2180 "} // TESTSUITE(in)\n" 2181 "} // TESTSUITE(out)", 2182 Style)); 2183 2184 // Do not merge different namespaces/macros 2185 EXPECT_EQ("namespace out {\n" 2186 "TESTSUITE(in) {\n" 2187 "} // TESTSUITE(in)\n" 2188 "} // namespace out", 2189 format("namespace out {\n" 2190 "TESTSUITE(in) {\n" 2191 "} // TESTSUITE(in)\n" 2192 "} // namespace out", 2193 Style)); 2194 EXPECT_EQ("TESTSUITE(out) {\n" 2195 "namespace in {\n" 2196 "} // namespace in\n" 2197 "} // TESTSUITE(out)", 2198 format("TESTSUITE(out) {\n" 2199 "namespace in {\n" 2200 "} // namespace in\n" 2201 "} // TESTSUITE(out)", 2202 Style)); 2203 Style.NamespaceMacros.push_back("FOOBAR"); 2204 EXPECT_EQ("TESTSUITE(out) {\n" 2205 "FOOBAR(in) {\n" 2206 "} // FOOBAR(in)\n" 2207 "} // TESTSUITE(out)", 2208 format("TESTSUITE(out) {\n" 2209 "FOOBAR(in) {\n" 2210 "} // FOOBAR(in)\n" 2211 "} // TESTSUITE(out)", 2212 Style)); 2213 } 2214 2215 TEST_F(FormatTest, FormatsCompactNamespaces) { 2216 FormatStyle Style = getLLVMStyle(); 2217 Style.CompactNamespaces = true; 2218 Style.NamespaceMacros.push_back("TESTSUITE"); 2219 2220 verifyFormat("namespace A { namespace B {\n" 2221 "}} // namespace A::B", 2222 Style); 2223 2224 EXPECT_EQ("namespace out { namespace in {\n" 2225 "}} // namespace out::in", 2226 format("namespace out {\n" 2227 "namespace in {\n" 2228 "} // namespace in\n" 2229 "} // namespace out", 2230 Style)); 2231 2232 // Only namespaces which have both consecutive opening and end get compacted 2233 EXPECT_EQ("namespace out {\n" 2234 "namespace in1 {\n" 2235 "} // namespace in1\n" 2236 "namespace in2 {\n" 2237 "} // namespace in2\n" 2238 "} // namespace out", 2239 format("namespace out {\n" 2240 "namespace in1 {\n" 2241 "} // namespace in1\n" 2242 "namespace in2 {\n" 2243 "} // namespace in2\n" 2244 "} // namespace out", 2245 Style)); 2246 2247 EXPECT_EQ("namespace out {\n" 2248 "int i;\n" 2249 "namespace in {\n" 2250 "int j;\n" 2251 "} // namespace in\n" 2252 "int k;\n" 2253 "} // namespace out", 2254 format("namespace out { int i;\n" 2255 "namespace in { int j; } // namespace in\n" 2256 "int k; } // namespace out", 2257 Style)); 2258 2259 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 2260 "}}} // namespace A::B::C\n", 2261 format("namespace A { namespace B {\n" 2262 "namespace C {\n" 2263 "}} // namespace B::C\n" 2264 "} // namespace A\n", 2265 Style)); 2266 2267 Style.ColumnLimit = 40; 2268 EXPECT_EQ("namespace aaaaaaaaaa {\n" 2269 "namespace bbbbbbbbbb {\n" 2270 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 2271 format("namespace aaaaaaaaaa {\n" 2272 "namespace bbbbbbbbbb {\n" 2273 "} // namespace bbbbbbbbbb\n" 2274 "} // namespace aaaaaaaaaa", 2275 Style)); 2276 2277 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 2278 "namespace cccccc {\n" 2279 "}}} // namespace aaaaaa::bbbbbb::cccccc", 2280 format("namespace aaaaaa {\n" 2281 "namespace bbbbbb {\n" 2282 "namespace cccccc {\n" 2283 "} // namespace cccccc\n" 2284 "} // namespace bbbbbb\n" 2285 "} // namespace aaaaaa", 2286 Style)); 2287 Style.ColumnLimit = 80; 2288 2289 // Extra semicolon after 'inner' closing brace prevents merging 2290 EXPECT_EQ("namespace out { namespace in {\n" 2291 "}; } // namespace out::in", 2292 format("namespace out {\n" 2293 "namespace in {\n" 2294 "}; // namespace in\n" 2295 "} // namespace out", 2296 Style)); 2297 2298 // Extra semicolon after 'outer' closing brace is conserved 2299 EXPECT_EQ("namespace out { namespace in {\n" 2300 "}}; // namespace out::in", 2301 format("namespace out {\n" 2302 "namespace in {\n" 2303 "} // namespace in\n" 2304 "}; // namespace out", 2305 Style)); 2306 2307 Style.NamespaceIndentation = FormatStyle::NI_All; 2308 EXPECT_EQ("namespace out { namespace in {\n" 2309 " int i;\n" 2310 "}} // namespace out::in", 2311 format("namespace out {\n" 2312 "namespace in {\n" 2313 "int i;\n" 2314 "} // namespace in\n" 2315 "} // namespace out", 2316 Style)); 2317 EXPECT_EQ("namespace out { namespace mid {\n" 2318 " namespace in {\n" 2319 " int j;\n" 2320 " } // namespace in\n" 2321 " int k;\n" 2322 "}} // namespace out::mid", 2323 format("namespace out { namespace mid {\n" 2324 "namespace in { int j; } // namespace in\n" 2325 "int k; }} // namespace out::mid", 2326 Style)); 2327 2328 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2329 EXPECT_EQ("namespace out { namespace in {\n" 2330 " int i;\n" 2331 "}} // namespace out::in", 2332 format("namespace out {\n" 2333 "namespace in {\n" 2334 "int i;\n" 2335 "} // namespace in\n" 2336 "} // namespace out", 2337 Style)); 2338 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 2339 " int i;\n" 2340 "}}} // namespace out::mid::in", 2341 format("namespace out {\n" 2342 "namespace mid {\n" 2343 "namespace in {\n" 2344 "int i;\n" 2345 "} // namespace in\n" 2346 "} // namespace mid\n" 2347 "} // namespace out", 2348 Style)); 2349 } 2350 2351 TEST_F(FormatTest, FormatsExternC) { 2352 verifyFormat("extern \"C\" {\nint a;"); 2353 verifyFormat("extern \"C\" {}"); 2354 verifyFormat("extern \"C\" {\n" 2355 "int foo();\n" 2356 "}"); 2357 verifyFormat("extern \"C\" int foo() {}"); 2358 verifyFormat("extern \"C\" int foo();"); 2359 verifyFormat("extern \"C\" int foo() {\n" 2360 " int i = 42;\n" 2361 " return i;\n" 2362 "}"); 2363 2364 FormatStyle Style = getLLVMStyle(); 2365 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2366 Style.BraceWrapping.AfterFunction = true; 2367 verifyFormat("extern \"C\" int foo() {}", Style); 2368 verifyFormat("extern \"C\" int foo();", Style); 2369 verifyFormat("extern \"C\" int foo()\n" 2370 "{\n" 2371 " int i = 42;\n" 2372 " return i;\n" 2373 "}", 2374 Style); 2375 2376 Style.BraceWrapping.AfterExternBlock = true; 2377 Style.BraceWrapping.SplitEmptyRecord = false; 2378 verifyFormat("extern \"C\"\n" 2379 "{}", 2380 Style); 2381 verifyFormat("extern \"C\"\n" 2382 "{\n" 2383 " int foo();\n" 2384 "}", 2385 Style); 2386 } 2387 2388 TEST_F(FormatTest, FormatsInlineASM) { 2389 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2390 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2391 verifyFormat( 2392 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2393 " \"cpuid\\n\\t\"\n" 2394 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2395 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2396 " : \"a\"(value));"); 2397 EXPECT_EQ( 2398 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2399 " __asm {\n" 2400 " mov edx,[that] // vtable in edx\n" 2401 " mov eax,methodIndex\n" 2402 " call [edx][eax*4] // stdcall\n" 2403 " }\n" 2404 "}", 2405 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2406 " __asm {\n" 2407 " mov edx,[that] // vtable in edx\n" 2408 " mov eax,methodIndex\n" 2409 " call [edx][eax*4] // stdcall\n" 2410 " }\n" 2411 "}")); 2412 EXPECT_EQ("_asm {\n" 2413 " xor eax, eax;\n" 2414 " cpuid;\n" 2415 "}", 2416 format("_asm {\n" 2417 " xor eax, eax;\n" 2418 " cpuid;\n" 2419 "}")); 2420 verifyFormat("void function() {\n" 2421 " // comment\n" 2422 " asm(\"\");\n" 2423 "}"); 2424 EXPECT_EQ("__asm {\n" 2425 "}\n" 2426 "int i;", 2427 format("__asm {\n" 2428 "}\n" 2429 "int i;")); 2430 } 2431 2432 TEST_F(FormatTest, FormatTryCatch) { 2433 verifyFormat("try {\n" 2434 " throw a * b;\n" 2435 "} catch (int a) {\n" 2436 " // Do nothing.\n" 2437 "} catch (...) {\n" 2438 " exit(42);\n" 2439 "}"); 2440 2441 // Function-level try statements. 2442 verifyFormat("int f() try { return 4; } catch (...) {\n" 2443 " return 5;\n" 2444 "}"); 2445 verifyFormat("class A {\n" 2446 " int a;\n" 2447 " A() try : a(0) {\n" 2448 " } catch (...) {\n" 2449 " throw;\n" 2450 " }\n" 2451 "};\n"); 2452 2453 // Incomplete try-catch blocks. 2454 verifyIncompleteFormat("try {} catch ("); 2455 } 2456 2457 TEST_F(FormatTest, FormatSEHTryCatch) { 2458 verifyFormat("__try {\n" 2459 " int a = b * c;\n" 2460 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2461 " // Do nothing.\n" 2462 "}"); 2463 2464 verifyFormat("__try {\n" 2465 " int a = b * c;\n" 2466 "} __finally {\n" 2467 " // Do nothing.\n" 2468 "}"); 2469 2470 verifyFormat("DEBUG({\n" 2471 " __try {\n" 2472 " } __finally {\n" 2473 " }\n" 2474 "});\n"); 2475 } 2476 2477 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2478 verifyFormat("try {\n" 2479 " f();\n" 2480 "} catch {\n" 2481 " g();\n" 2482 "}"); 2483 verifyFormat("try {\n" 2484 " f();\n" 2485 "} catch (A a) MACRO(x) {\n" 2486 " g();\n" 2487 "} catch (B b) MACRO(x) {\n" 2488 " g();\n" 2489 "}"); 2490 } 2491 2492 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2493 FormatStyle Style = getLLVMStyle(); 2494 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2495 FormatStyle::BS_WebKit}) { 2496 Style.BreakBeforeBraces = BraceStyle; 2497 verifyFormat("try {\n" 2498 " // something\n" 2499 "} catch (...) {\n" 2500 " // something\n" 2501 "}", 2502 Style); 2503 } 2504 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2505 verifyFormat("try {\n" 2506 " // something\n" 2507 "}\n" 2508 "catch (...) {\n" 2509 " // something\n" 2510 "}", 2511 Style); 2512 verifyFormat("__try {\n" 2513 " // something\n" 2514 "}\n" 2515 "__finally {\n" 2516 " // something\n" 2517 "}", 2518 Style); 2519 verifyFormat("@try {\n" 2520 " // something\n" 2521 "}\n" 2522 "@finally {\n" 2523 " // something\n" 2524 "}", 2525 Style); 2526 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2527 verifyFormat("try\n" 2528 "{\n" 2529 " // something\n" 2530 "}\n" 2531 "catch (...)\n" 2532 "{\n" 2533 " // something\n" 2534 "}", 2535 Style); 2536 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 2537 verifyFormat("try\n" 2538 " {\n" 2539 " // something white\n" 2540 " }\n" 2541 "catch (...)\n" 2542 " {\n" 2543 " // something white\n" 2544 " }", 2545 Style); 2546 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2547 verifyFormat("try\n" 2548 " {\n" 2549 " // something\n" 2550 " }\n" 2551 "catch (...)\n" 2552 " {\n" 2553 " // something\n" 2554 " }", 2555 Style); 2556 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2557 Style.BraceWrapping.BeforeCatch = true; 2558 verifyFormat("try {\n" 2559 " // something\n" 2560 "}\n" 2561 "catch (...) {\n" 2562 " // something\n" 2563 "}", 2564 Style); 2565 } 2566 2567 TEST_F(FormatTest, StaticInitializers) { 2568 verifyFormat("static SomeClass SC = {1, 'a'};"); 2569 2570 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2571 " 100000000, " 2572 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2573 2574 // Here, everything other than the "}" would fit on a line. 2575 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2576 " 10000000000000000000000000};"); 2577 EXPECT_EQ("S s = {a,\n" 2578 "\n" 2579 " b};", 2580 format("S s = {\n" 2581 " a,\n" 2582 "\n" 2583 " b\n" 2584 "};")); 2585 2586 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2587 // line. However, the formatting looks a bit off and this probably doesn't 2588 // happen often in practice. 2589 verifyFormat("static int Variable[1] = {\n" 2590 " {1000000000000000000000000000000000000}};", 2591 getLLVMStyleWithColumns(40)); 2592 } 2593 2594 TEST_F(FormatTest, DesignatedInitializers) { 2595 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2596 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2597 " .bbbbbbbbbb = 2,\n" 2598 " .cccccccccc = 3,\n" 2599 " .dddddddddd = 4,\n" 2600 " .eeeeeeeeee = 5};"); 2601 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2602 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2603 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2604 " .ccccccccccccccccccccccccccc = 3,\n" 2605 " .ddddddddddddddddddddddddddd = 4,\n" 2606 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2607 2608 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2609 2610 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2611 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2612 " [2] = bbbbbbbbbb,\n" 2613 " [3] = cccccccccc,\n" 2614 " [4] = dddddddddd,\n" 2615 " [5] = eeeeeeeeee};"); 2616 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2617 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2618 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2619 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2620 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2621 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2622 } 2623 2624 TEST_F(FormatTest, NestedStaticInitializers) { 2625 verifyFormat("static A x = {{{}}};\n"); 2626 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2627 " {init1, init2, init3, init4}}};", 2628 getLLVMStyleWithColumns(50)); 2629 2630 verifyFormat("somes Status::global_reps[3] = {\n" 2631 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2632 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2633 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2634 getLLVMStyleWithColumns(60)); 2635 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2636 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2637 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2638 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2639 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2640 " {rect.fRight - rect.fLeft, rect.fBottom - " 2641 "rect.fTop}};"); 2642 2643 verifyFormat( 2644 "SomeArrayOfSomeType a = {\n" 2645 " {{1, 2, 3},\n" 2646 " {1, 2, 3},\n" 2647 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2648 " 333333333333333333333333333333},\n" 2649 " {1, 2, 3},\n" 2650 " {1, 2, 3}}};"); 2651 verifyFormat( 2652 "SomeArrayOfSomeType a = {\n" 2653 " {{1, 2, 3}},\n" 2654 " {{1, 2, 3}},\n" 2655 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2656 " 333333333333333333333333333333}},\n" 2657 " {{1, 2, 3}},\n" 2658 " {{1, 2, 3}}};"); 2659 2660 verifyFormat("struct {\n" 2661 " unsigned bit;\n" 2662 " const char *const name;\n" 2663 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2664 " {kOsWin, \"Windows\"},\n" 2665 " {kOsLinux, \"Linux\"},\n" 2666 " {kOsCrOS, \"Chrome OS\"}};"); 2667 verifyFormat("struct {\n" 2668 " unsigned bit;\n" 2669 " const char *const name;\n" 2670 "} kBitsToOs[] = {\n" 2671 " {kOsMac, \"Mac\"},\n" 2672 " {kOsWin, \"Windows\"},\n" 2673 " {kOsLinux, \"Linux\"},\n" 2674 " {kOsCrOS, \"Chrome OS\"},\n" 2675 "};"); 2676 } 2677 2678 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2679 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2680 " \\\n" 2681 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2682 } 2683 2684 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2685 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2686 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2687 2688 // Do break defaulted and deleted functions. 2689 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2690 " default;", 2691 getLLVMStyleWithColumns(40)); 2692 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2693 " delete;", 2694 getLLVMStyleWithColumns(40)); 2695 } 2696 2697 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2698 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2699 getLLVMStyleWithColumns(40)); 2700 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2701 getLLVMStyleWithColumns(40)); 2702 EXPECT_EQ("#define Q \\\n" 2703 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2704 " \"aaaaaaaa.cpp\"", 2705 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2706 getLLVMStyleWithColumns(40))); 2707 } 2708 2709 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2710 EXPECT_EQ("# 123 \"A string literal\"", 2711 format(" # 123 \"A string literal\"")); 2712 } 2713 2714 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2715 EXPECT_EQ("#;", format("#;")); 2716 verifyFormat("#\n;\n;\n;"); 2717 } 2718 2719 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2720 EXPECT_EQ("#line 42 \"test\"\n", 2721 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2722 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2723 getLLVMStyleWithColumns(12))); 2724 } 2725 2726 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2727 EXPECT_EQ("#line 42 \"test\"", 2728 format("# \\\n line \\\n 42 \\\n \"test\"")); 2729 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2730 } 2731 2732 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2733 verifyFormat("#define A \\x20"); 2734 verifyFormat("#define A \\ x20"); 2735 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2736 verifyFormat("#define A ''"); 2737 verifyFormat("#define A ''qqq"); 2738 verifyFormat("#define A `qqq"); 2739 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2740 EXPECT_EQ("const char *c = STRINGIFY(\n" 2741 "\\na : b);", 2742 format("const char * c = STRINGIFY(\n" 2743 "\\na : b);")); 2744 2745 verifyFormat("a\r\\"); 2746 verifyFormat("a\v\\"); 2747 verifyFormat("a\f\\"); 2748 } 2749 2750 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2751 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2752 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2753 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2754 // FIXME: We never break before the macro name. 2755 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2756 2757 verifyFormat("#define A A\n#define A A"); 2758 verifyFormat("#define A(X) A\n#define A A"); 2759 2760 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2761 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2762 } 2763 2764 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2765 EXPECT_EQ("// somecomment\n" 2766 "#include \"a.h\"\n" 2767 "#define A( \\\n" 2768 " A, B)\n" 2769 "#include \"b.h\"\n" 2770 "// somecomment\n", 2771 format(" // somecomment\n" 2772 " #include \"a.h\"\n" 2773 "#define A(A,\\\n" 2774 " B)\n" 2775 " #include \"b.h\"\n" 2776 " // somecomment\n", 2777 getLLVMStyleWithColumns(13))); 2778 } 2779 2780 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2781 2782 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2783 EXPECT_EQ("#define A \\\n" 2784 " c; \\\n" 2785 " e;\n" 2786 "f;", 2787 format("#define A c; e;\n" 2788 "f;", 2789 getLLVMStyleWithColumns(14))); 2790 } 2791 2792 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2793 2794 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2795 EXPECT_EQ("int x,\n" 2796 "#define A\n" 2797 " y;", 2798 format("int x,\n#define A\ny;")); 2799 } 2800 2801 TEST_F(FormatTest, HashInMacroDefinition) { 2802 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2803 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2804 verifyFormat("#define A \\\n" 2805 " { \\\n" 2806 " f(#c); \\\n" 2807 " }", 2808 getLLVMStyleWithColumns(11)); 2809 2810 verifyFormat("#define A(X) \\\n" 2811 " void function##X()", 2812 getLLVMStyleWithColumns(22)); 2813 2814 verifyFormat("#define A(a, b, c) \\\n" 2815 " void a##b##c()", 2816 getLLVMStyleWithColumns(22)); 2817 2818 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2819 } 2820 2821 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2822 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2823 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2824 2825 FormatStyle Style = getLLVMStyle(); 2826 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 2827 verifyFormat("#define true ((foo)1)", Style); 2828 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 2829 verifyFormat("#define false((foo)0)", Style); 2830 } 2831 2832 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2833 EXPECT_EQ("#define A b;", format("#define A \\\n" 2834 " \\\n" 2835 " b;", 2836 getLLVMStyleWithColumns(25))); 2837 EXPECT_EQ("#define A \\\n" 2838 " \\\n" 2839 " a; \\\n" 2840 " b;", 2841 format("#define A \\\n" 2842 " \\\n" 2843 " a; \\\n" 2844 " b;", 2845 getLLVMStyleWithColumns(11))); 2846 EXPECT_EQ("#define A \\\n" 2847 " a; \\\n" 2848 " \\\n" 2849 " b;", 2850 format("#define A \\\n" 2851 " a; \\\n" 2852 " \\\n" 2853 " b;", 2854 getLLVMStyleWithColumns(11))); 2855 } 2856 2857 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 2858 verifyIncompleteFormat("#define A :"); 2859 verifyFormat("#define SOMECASES \\\n" 2860 " case 1: \\\n" 2861 " case 2\n", 2862 getLLVMStyleWithColumns(20)); 2863 verifyFormat("#define MACRO(a) \\\n" 2864 " if (a) \\\n" 2865 " f(); \\\n" 2866 " else \\\n" 2867 " g()", 2868 getLLVMStyleWithColumns(18)); 2869 verifyFormat("#define A template <typename T>"); 2870 verifyIncompleteFormat("#define STR(x) #x\n" 2871 "f(STR(this_is_a_string_literal{));"); 2872 verifyFormat("#pragma omp threadprivate( \\\n" 2873 " y)), // expected-warning", 2874 getLLVMStyleWithColumns(28)); 2875 verifyFormat("#d, = };"); 2876 verifyFormat("#if \"a"); 2877 verifyIncompleteFormat("({\n" 2878 "#define b \\\n" 2879 " } \\\n" 2880 " a\n" 2881 "a", 2882 getLLVMStyleWithColumns(15)); 2883 verifyFormat("#define A \\\n" 2884 " { \\\n" 2885 " {\n" 2886 "#define B \\\n" 2887 " } \\\n" 2888 " }", 2889 getLLVMStyleWithColumns(15)); 2890 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 2891 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 2892 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 2893 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 2894 } 2895 2896 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 2897 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 2898 EXPECT_EQ("class A : public QObject {\n" 2899 " Q_OBJECT\n" 2900 "\n" 2901 " A() {}\n" 2902 "};", 2903 format("class A : public QObject {\n" 2904 " Q_OBJECT\n" 2905 "\n" 2906 " A() {\n}\n" 2907 "} ;")); 2908 EXPECT_EQ("MACRO\n" 2909 "/*static*/ int i;", 2910 format("MACRO\n" 2911 " /*static*/ int i;")); 2912 EXPECT_EQ("SOME_MACRO\n" 2913 "namespace {\n" 2914 "void f();\n" 2915 "} // namespace", 2916 format("SOME_MACRO\n" 2917 " namespace {\n" 2918 "void f( );\n" 2919 "} // namespace")); 2920 // Only if the identifier contains at least 5 characters. 2921 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 2922 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 2923 // Only if everything is upper case. 2924 EXPECT_EQ("class A : public QObject {\n" 2925 " Q_Object A() {}\n" 2926 "};", 2927 format("class A : public QObject {\n" 2928 " Q_Object\n" 2929 " A() {\n}\n" 2930 "} ;")); 2931 2932 // Only if the next line can actually start an unwrapped line. 2933 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 2934 format("SOME_WEIRD_LOG_MACRO\n" 2935 "<< SomeThing;")); 2936 2937 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 2938 "(n, buffers))\n", 2939 getChromiumStyle(FormatStyle::LK_Cpp)); 2940 2941 // See PR41483 2942 EXPECT_EQ("/**/ FOO(a)\n" 2943 "FOO(b)", 2944 format("/**/ FOO(a)\n" 2945 "FOO(b)")); 2946 } 2947 2948 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 2949 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2950 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2951 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2952 "class X {};\n" 2953 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2954 "int *createScopDetectionPass() { return 0; }", 2955 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2956 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2957 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2958 " class X {};\n" 2959 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2960 " int *createScopDetectionPass() { return 0; }")); 2961 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 2962 // braces, so that inner block is indented one level more. 2963 EXPECT_EQ("int q() {\n" 2964 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2965 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2966 " IPC_END_MESSAGE_MAP()\n" 2967 "}", 2968 format("int q() {\n" 2969 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2970 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2971 " IPC_END_MESSAGE_MAP()\n" 2972 "}")); 2973 2974 // Same inside macros. 2975 EXPECT_EQ("#define LIST(L) \\\n" 2976 " L(A) \\\n" 2977 " L(B) \\\n" 2978 " L(C)", 2979 format("#define LIST(L) \\\n" 2980 " L(A) \\\n" 2981 " L(B) \\\n" 2982 " L(C)", 2983 getGoogleStyle())); 2984 2985 // These must not be recognized as macros. 2986 EXPECT_EQ("int q() {\n" 2987 " f(x);\n" 2988 " f(x) {}\n" 2989 " f(x)->g();\n" 2990 " f(x)->*g();\n" 2991 " f(x).g();\n" 2992 " f(x) = x;\n" 2993 " f(x) += x;\n" 2994 " f(x) -= x;\n" 2995 " f(x) *= x;\n" 2996 " f(x) /= x;\n" 2997 " f(x) %= x;\n" 2998 " f(x) &= x;\n" 2999 " f(x) |= x;\n" 3000 " f(x) ^= x;\n" 3001 " f(x) >>= x;\n" 3002 " f(x) <<= x;\n" 3003 " f(x)[y].z();\n" 3004 " LOG(INFO) << x;\n" 3005 " ifstream(x) >> x;\n" 3006 "}\n", 3007 format("int q() {\n" 3008 " f(x)\n;\n" 3009 " f(x)\n {}\n" 3010 " f(x)\n->g();\n" 3011 " f(x)\n->*g();\n" 3012 " f(x)\n.g();\n" 3013 " f(x)\n = x;\n" 3014 " f(x)\n += x;\n" 3015 " f(x)\n -= x;\n" 3016 " f(x)\n *= x;\n" 3017 " f(x)\n /= x;\n" 3018 " f(x)\n %= x;\n" 3019 " f(x)\n &= x;\n" 3020 " f(x)\n |= x;\n" 3021 " f(x)\n ^= x;\n" 3022 " f(x)\n >>= x;\n" 3023 " f(x)\n <<= x;\n" 3024 " f(x)\n[y].z();\n" 3025 " LOG(INFO)\n << x;\n" 3026 " ifstream(x)\n >> x;\n" 3027 "}\n")); 3028 EXPECT_EQ("int q() {\n" 3029 " F(x)\n" 3030 " if (1) {\n" 3031 " }\n" 3032 " F(x)\n" 3033 " while (1) {\n" 3034 " }\n" 3035 " F(x)\n" 3036 " G(x);\n" 3037 " F(x)\n" 3038 " try {\n" 3039 " Q();\n" 3040 " } catch (...) {\n" 3041 " }\n" 3042 "}\n", 3043 format("int q() {\n" 3044 "F(x)\n" 3045 "if (1) {}\n" 3046 "F(x)\n" 3047 "while (1) {}\n" 3048 "F(x)\n" 3049 "G(x);\n" 3050 "F(x)\n" 3051 "try { Q(); } catch (...) {}\n" 3052 "}\n")); 3053 EXPECT_EQ("class A {\n" 3054 " A() : t(0) {}\n" 3055 " A(int i) noexcept() : {}\n" 3056 " A(X x)\n" // FIXME: function-level try blocks are broken. 3057 " try : t(0) {\n" 3058 " } catch (...) {\n" 3059 " }\n" 3060 "};", 3061 format("class A {\n" 3062 " A()\n : t(0) {}\n" 3063 " A(int i)\n noexcept() : {}\n" 3064 " A(X x)\n" 3065 " try : t(0) {} catch (...) {}\n" 3066 "};")); 3067 FormatStyle Style = getLLVMStyle(); 3068 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 3069 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 3070 Style.BraceWrapping.AfterFunction = true; 3071 EXPECT_EQ("void f()\n" 3072 "try\n" 3073 "{\n" 3074 "}", 3075 format("void f() try {\n" 3076 "}", 3077 Style)); 3078 EXPECT_EQ("class SomeClass {\n" 3079 "public:\n" 3080 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3081 "};", 3082 format("class SomeClass {\n" 3083 "public:\n" 3084 " SomeClass()\n" 3085 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3086 "};")); 3087 EXPECT_EQ("class SomeClass {\n" 3088 "public:\n" 3089 " SomeClass()\n" 3090 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3091 "};", 3092 format("class SomeClass {\n" 3093 "public:\n" 3094 " SomeClass()\n" 3095 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3096 "};", 3097 getLLVMStyleWithColumns(40))); 3098 3099 verifyFormat("MACRO(>)"); 3100 3101 // Some macros contain an implicit semicolon. 3102 Style = getLLVMStyle(); 3103 Style.StatementMacros.push_back("FOO"); 3104 verifyFormat("FOO(a) int b = 0;"); 3105 verifyFormat("FOO(a)\n" 3106 "int b = 0;", 3107 Style); 3108 verifyFormat("FOO(a);\n" 3109 "int b = 0;", 3110 Style); 3111 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 3112 "int b = 0;", 3113 Style); 3114 verifyFormat("FOO()\n" 3115 "int b = 0;", 3116 Style); 3117 verifyFormat("FOO\n" 3118 "int b = 0;", 3119 Style); 3120 verifyFormat("void f() {\n" 3121 " FOO(a)\n" 3122 " return a;\n" 3123 "}", 3124 Style); 3125 verifyFormat("FOO(a)\n" 3126 "FOO(b)", 3127 Style); 3128 verifyFormat("int a = 0;\n" 3129 "FOO(b)\n" 3130 "int c = 0;", 3131 Style); 3132 verifyFormat("int a = 0;\n" 3133 "int x = FOO(a)\n" 3134 "int b = 0;", 3135 Style); 3136 verifyFormat("void foo(int a) { FOO(a) }\n" 3137 "uint32_t bar() {}", 3138 Style); 3139 } 3140 3141 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 3142 verifyFormat("#define A \\\n" 3143 " f({ \\\n" 3144 " g(); \\\n" 3145 " });", 3146 getLLVMStyleWithColumns(11)); 3147 } 3148 3149 TEST_F(FormatTest, IndentPreprocessorDirectives) { 3150 FormatStyle Style = getLLVMStyle(); 3151 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 3152 Style.ColumnLimit = 40; 3153 verifyFormat("#ifdef _WIN32\n" 3154 "#define A 0\n" 3155 "#ifdef VAR2\n" 3156 "#define B 1\n" 3157 "#include <someheader.h>\n" 3158 "#define MACRO \\\n" 3159 " some_very_long_func_aaaaaaaaaa();\n" 3160 "#endif\n" 3161 "#else\n" 3162 "#define A 1\n" 3163 "#endif", 3164 Style); 3165 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 3166 verifyFormat("#ifdef _WIN32\n" 3167 "# define A 0\n" 3168 "# ifdef VAR2\n" 3169 "# define B 1\n" 3170 "# include <someheader.h>\n" 3171 "# define MACRO \\\n" 3172 " some_very_long_func_aaaaaaaaaa();\n" 3173 "# endif\n" 3174 "#else\n" 3175 "# define A 1\n" 3176 "#endif", 3177 Style); 3178 verifyFormat("#if A\n" 3179 "# define MACRO \\\n" 3180 " void a(int x) { \\\n" 3181 " b(); \\\n" 3182 " c(); \\\n" 3183 " d(); \\\n" 3184 " e(); \\\n" 3185 " f(); \\\n" 3186 " }\n" 3187 "#endif", 3188 Style); 3189 // Comments before include guard. 3190 verifyFormat("// file comment\n" 3191 "// file comment\n" 3192 "#ifndef HEADER_H\n" 3193 "#define HEADER_H\n" 3194 "code();\n" 3195 "#endif", 3196 Style); 3197 // Test with include guards. 3198 verifyFormat("#ifndef HEADER_H\n" 3199 "#define HEADER_H\n" 3200 "code();\n" 3201 "#endif", 3202 Style); 3203 // Include guards must have a #define with the same variable immediately 3204 // after #ifndef. 3205 verifyFormat("#ifndef NOT_GUARD\n" 3206 "# define FOO\n" 3207 "code();\n" 3208 "#endif", 3209 Style); 3210 3211 // Include guards must cover the entire file. 3212 verifyFormat("code();\n" 3213 "code();\n" 3214 "#ifndef NOT_GUARD\n" 3215 "# define NOT_GUARD\n" 3216 "code();\n" 3217 "#endif", 3218 Style); 3219 verifyFormat("#ifndef NOT_GUARD\n" 3220 "# define NOT_GUARD\n" 3221 "code();\n" 3222 "#endif\n" 3223 "code();", 3224 Style); 3225 // Test with trailing blank lines. 3226 verifyFormat("#ifndef HEADER_H\n" 3227 "#define HEADER_H\n" 3228 "code();\n" 3229 "#endif\n", 3230 Style); 3231 // Include guards don't have #else. 3232 verifyFormat("#ifndef NOT_GUARD\n" 3233 "# define NOT_GUARD\n" 3234 "code();\n" 3235 "#else\n" 3236 "#endif", 3237 Style); 3238 verifyFormat("#ifndef NOT_GUARD\n" 3239 "# define NOT_GUARD\n" 3240 "code();\n" 3241 "#elif FOO\n" 3242 "#endif", 3243 Style); 3244 // Non-identifier #define after potential include guard. 3245 verifyFormat("#ifndef FOO\n" 3246 "# define 1\n" 3247 "#endif\n", 3248 Style); 3249 // #if closes past last non-preprocessor line. 3250 verifyFormat("#ifndef FOO\n" 3251 "#define FOO\n" 3252 "#if 1\n" 3253 "int i;\n" 3254 "# define A 0\n" 3255 "#endif\n" 3256 "#endif\n", 3257 Style); 3258 // Don't crash if there is an #elif directive without a condition. 3259 verifyFormat("#if 1\n" 3260 "int x;\n" 3261 "#elif\n" 3262 "int y;\n" 3263 "#else\n" 3264 "int z;\n" 3265 "#endif", 3266 Style); 3267 // FIXME: This doesn't handle the case where there's code between the 3268 // #ifndef and #define but all other conditions hold. This is because when 3269 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 3270 // previous code line yet, so we can't detect it. 3271 EXPECT_EQ("#ifndef NOT_GUARD\n" 3272 "code();\n" 3273 "#define NOT_GUARD\n" 3274 "code();\n" 3275 "#endif", 3276 format("#ifndef NOT_GUARD\n" 3277 "code();\n" 3278 "# define NOT_GUARD\n" 3279 "code();\n" 3280 "#endif", 3281 Style)); 3282 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 3283 // be outside an include guard. Examples are #pragma once and 3284 // #pragma GCC diagnostic, or anything else that does not change the meaning 3285 // of the file if it's included multiple times. 3286 EXPECT_EQ("#ifdef WIN32\n" 3287 "# pragma once\n" 3288 "#endif\n" 3289 "#ifndef HEADER_H\n" 3290 "# define HEADER_H\n" 3291 "code();\n" 3292 "#endif", 3293 format("#ifdef WIN32\n" 3294 "# pragma once\n" 3295 "#endif\n" 3296 "#ifndef HEADER_H\n" 3297 "#define HEADER_H\n" 3298 "code();\n" 3299 "#endif", 3300 Style)); 3301 // FIXME: This does not detect when there is a single non-preprocessor line 3302 // in front of an include-guard-like structure where other conditions hold 3303 // because ScopedLineState hides the line. 3304 EXPECT_EQ("code();\n" 3305 "#ifndef HEADER_H\n" 3306 "#define HEADER_H\n" 3307 "code();\n" 3308 "#endif", 3309 format("code();\n" 3310 "#ifndef HEADER_H\n" 3311 "# define HEADER_H\n" 3312 "code();\n" 3313 "#endif", 3314 Style)); 3315 // Keep comments aligned with #, otherwise indent comments normally. These 3316 // tests cannot use verifyFormat because messUp manipulates leading 3317 // whitespace. 3318 { 3319 const char *Expected = "" 3320 "void f() {\n" 3321 "#if 1\n" 3322 "// Preprocessor aligned.\n" 3323 "# define A 0\n" 3324 " // Code. Separated by blank line.\n" 3325 "\n" 3326 "# define B 0\n" 3327 " // Code. Not aligned with #\n" 3328 "# define C 0\n" 3329 "#endif"; 3330 const char *ToFormat = "" 3331 "void f() {\n" 3332 "#if 1\n" 3333 "// Preprocessor aligned.\n" 3334 "# define A 0\n" 3335 "// Code. Separated by blank line.\n" 3336 "\n" 3337 "# define B 0\n" 3338 " // Code. Not aligned with #\n" 3339 "# define C 0\n" 3340 "#endif"; 3341 EXPECT_EQ(Expected, format(ToFormat, Style)); 3342 EXPECT_EQ(Expected, format(Expected, Style)); 3343 } 3344 // Keep block quotes aligned. 3345 { 3346 const char *Expected = "" 3347 "void f() {\n" 3348 "#if 1\n" 3349 "/* Preprocessor aligned. */\n" 3350 "# define A 0\n" 3351 " /* Code. Separated by blank line. */\n" 3352 "\n" 3353 "# define B 0\n" 3354 " /* Code. Not aligned with # */\n" 3355 "# define C 0\n" 3356 "#endif"; 3357 const char *ToFormat = "" 3358 "void f() {\n" 3359 "#if 1\n" 3360 "/* Preprocessor aligned. */\n" 3361 "# define A 0\n" 3362 "/* Code. Separated by blank line. */\n" 3363 "\n" 3364 "# define B 0\n" 3365 " /* Code. Not aligned with # */\n" 3366 "# define C 0\n" 3367 "#endif"; 3368 EXPECT_EQ(Expected, format(ToFormat, Style)); 3369 EXPECT_EQ(Expected, format(Expected, Style)); 3370 } 3371 // Keep comments aligned with un-indented directives. 3372 { 3373 const char *Expected = "" 3374 "void f() {\n" 3375 "// Preprocessor aligned.\n" 3376 "#define A 0\n" 3377 " // Code. Separated by blank line.\n" 3378 "\n" 3379 "#define B 0\n" 3380 " // Code. Not aligned with #\n" 3381 "#define C 0\n"; 3382 const char *ToFormat = "" 3383 "void f() {\n" 3384 "// Preprocessor aligned.\n" 3385 "#define A 0\n" 3386 "// Code. Separated by blank line.\n" 3387 "\n" 3388 "#define B 0\n" 3389 " // Code. Not aligned with #\n" 3390 "#define C 0\n"; 3391 EXPECT_EQ(Expected, format(ToFormat, Style)); 3392 EXPECT_EQ(Expected, format(Expected, Style)); 3393 } 3394 // Test AfterHash with tabs. 3395 { 3396 FormatStyle Tabbed = Style; 3397 Tabbed.UseTab = FormatStyle::UT_Always; 3398 Tabbed.IndentWidth = 8; 3399 Tabbed.TabWidth = 8; 3400 verifyFormat("#ifdef _WIN32\n" 3401 "#\tdefine A 0\n" 3402 "#\tifdef VAR2\n" 3403 "#\t\tdefine B 1\n" 3404 "#\t\tinclude <someheader.h>\n" 3405 "#\t\tdefine MACRO \\\n" 3406 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3407 "#\tendif\n" 3408 "#else\n" 3409 "#\tdefine A 1\n" 3410 "#endif", 3411 Tabbed); 3412 } 3413 3414 // Regression test: Multiline-macro inside include guards. 3415 verifyFormat("#ifndef HEADER_H\n" 3416 "#define HEADER_H\n" 3417 "#define A() \\\n" 3418 " int i; \\\n" 3419 " int j;\n" 3420 "#endif // HEADER_H", 3421 getLLVMStyleWithColumns(20)); 3422 3423 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3424 // Basic before hash indent tests 3425 verifyFormat("#ifdef _WIN32\n" 3426 " #define A 0\n" 3427 " #ifdef VAR2\n" 3428 " #define B 1\n" 3429 " #include <someheader.h>\n" 3430 " #define MACRO \\\n" 3431 " some_very_long_func_aaaaaaaaaa();\n" 3432 " #endif\n" 3433 "#else\n" 3434 " #define A 1\n" 3435 "#endif", 3436 Style); 3437 verifyFormat("#if A\n" 3438 " #define MACRO \\\n" 3439 " void a(int x) { \\\n" 3440 " b(); \\\n" 3441 " c(); \\\n" 3442 " d(); \\\n" 3443 " e(); \\\n" 3444 " f(); \\\n" 3445 " }\n" 3446 "#endif", 3447 Style); 3448 // Keep comments aligned with indented directives. These 3449 // tests cannot use verifyFormat because messUp manipulates leading 3450 // whitespace. 3451 { 3452 const char *Expected = "void f() {\n" 3453 "// Aligned to preprocessor.\n" 3454 "#if 1\n" 3455 " // Aligned to code.\n" 3456 " int a;\n" 3457 " #if 1\n" 3458 " // Aligned to preprocessor.\n" 3459 " #define A 0\n" 3460 " // Aligned to code.\n" 3461 " int b;\n" 3462 " #endif\n" 3463 "#endif\n" 3464 "}"; 3465 const char *ToFormat = "void f() {\n" 3466 "// Aligned to preprocessor.\n" 3467 "#if 1\n" 3468 "// Aligned to code.\n" 3469 "int a;\n" 3470 "#if 1\n" 3471 "// Aligned to preprocessor.\n" 3472 "#define A 0\n" 3473 "// Aligned to code.\n" 3474 "int b;\n" 3475 "#endif\n" 3476 "#endif\n" 3477 "}"; 3478 EXPECT_EQ(Expected, format(ToFormat, Style)); 3479 EXPECT_EQ(Expected, format(Expected, Style)); 3480 } 3481 { 3482 const char *Expected = "void f() {\n" 3483 "/* Aligned to preprocessor. */\n" 3484 "#if 1\n" 3485 " /* Aligned to code. */\n" 3486 " int a;\n" 3487 " #if 1\n" 3488 " /* Aligned to preprocessor. */\n" 3489 " #define A 0\n" 3490 " /* Aligned to code. */\n" 3491 " int b;\n" 3492 " #endif\n" 3493 "#endif\n" 3494 "}"; 3495 const char *ToFormat = "void f() {\n" 3496 "/* Aligned to preprocessor. */\n" 3497 "#if 1\n" 3498 "/* Aligned to code. */\n" 3499 "int a;\n" 3500 "#if 1\n" 3501 "/* Aligned to preprocessor. */\n" 3502 "#define A 0\n" 3503 "/* Aligned to code. */\n" 3504 "int b;\n" 3505 "#endif\n" 3506 "#endif\n" 3507 "}"; 3508 EXPECT_EQ(Expected, format(ToFormat, Style)); 3509 EXPECT_EQ(Expected, format(Expected, Style)); 3510 } 3511 3512 // Test single comment before preprocessor 3513 verifyFormat("// Comment\n" 3514 "\n" 3515 "#if 1\n" 3516 "#endif", 3517 Style); 3518 } 3519 3520 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3521 verifyFormat("{\n { a #c; }\n}"); 3522 } 3523 3524 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3525 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3526 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3527 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3528 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3529 } 3530 3531 TEST_F(FormatTest, EscapedNewlines) { 3532 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3533 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3534 format("#define A \\\nint i;\\\n int j;", Narrow)); 3535 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3536 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3537 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3538 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3539 3540 FormatStyle AlignLeft = getLLVMStyle(); 3541 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3542 EXPECT_EQ("#define MACRO(x) \\\n" 3543 "private: \\\n" 3544 " int x(int a);\n", 3545 format("#define MACRO(x) \\\n" 3546 "private: \\\n" 3547 " int x(int a);\n", 3548 AlignLeft)); 3549 3550 // CRLF line endings 3551 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3552 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3553 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3554 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3555 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3556 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3557 EXPECT_EQ("#define MACRO(x) \\\r\n" 3558 "private: \\\r\n" 3559 " int x(int a);\r\n", 3560 format("#define MACRO(x) \\\r\n" 3561 "private: \\\r\n" 3562 " int x(int a);\r\n", 3563 AlignLeft)); 3564 3565 FormatStyle DontAlign = getLLVMStyle(); 3566 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3567 DontAlign.MaxEmptyLinesToKeep = 3; 3568 // FIXME: can't use verifyFormat here because the newline before 3569 // "public:" is not inserted the first time it's reformatted 3570 EXPECT_EQ("#define A \\\n" 3571 " class Foo { \\\n" 3572 " void bar(); \\\n" 3573 "\\\n" 3574 "\\\n" 3575 "\\\n" 3576 " public: \\\n" 3577 " void baz(); \\\n" 3578 " };", 3579 format("#define A \\\n" 3580 " class Foo { \\\n" 3581 " void bar(); \\\n" 3582 "\\\n" 3583 "\\\n" 3584 "\\\n" 3585 " public: \\\n" 3586 " void baz(); \\\n" 3587 " };", 3588 DontAlign)); 3589 } 3590 3591 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3592 verifyFormat("#define A \\\n" 3593 " int v( \\\n" 3594 " a); \\\n" 3595 " int i;", 3596 getLLVMStyleWithColumns(11)); 3597 } 3598 3599 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3600 EXPECT_EQ( 3601 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3602 " \\\n" 3603 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3604 "\n" 3605 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3606 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3607 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3608 "\\\n" 3609 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3610 " \n" 3611 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3612 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3613 } 3614 3615 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3616 EXPECT_EQ("int\n" 3617 "#define A\n" 3618 " a;", 3619 format("int\n#define A\na;")); 3620 verifyFormat("functionCallTo(\n" 3621 " someOtherFunction(\n" 3622 " withSomeParameters, whichInSequence,\n" 3623 " areLongerThanALine(andAnotherCall,\n" 3624 "#define A B\n" 3625 " withMoreParamters,\n" 3626 " whichStronglyInfluenceTheLayout),\n" 3627 " andMoreParameters),\n" 3628 " trailing);", 3629 getLLVMStyleWithColumns(69)); 3630 verifyFormat("Foo::Foo()\n" 3631 "#ifdef BAR\n" 3632 " : baz(0)\n" 3633 "#endif\n" 3634 "{\n" 3635 "}"); 3636 verifyFormat("void f() {\n" 3637 " if (true)\n" 3638 "#ifdef A\n" 3639 " f(42);\n" 3640 " x();\n" 3641 "#else\n" 3642 " g();\n" 3643 " x();\n" 3644 "#endif\n" 3645 "}"); 3646 verifyFormat("void f(param1, param2,\n" 3647 " param3,\n" 3648 "#ifdef A\n" 3649 " param4(param5,\n" 3650 "#ifdef A1\n" 3651 " param6,\n" 3652 "#ifdef A2\n" 3653 " param7),\n" 3654 "#else\n" 3655 " param8),\n" 3656 " param9,\n" 3657 "#endif\n" 3658 " param10,\n" 3659 "#endif\n" 3660 " param11)\n" 3661 "#else\n" 3662 " param12)\n" 3663 "#endif\n" 3664 "{\n" 3665 " x();\n" 3666 "}", 3667 getLLVMStyleWithColumns(28)); 3668 verifyFormat("#if 1\n" 3669 "int i;"); 3670 verifyFormat("#if 1\n" 3671 "#endif\n" 3672 "#if 1\n" 3673 "#else\n" 3674 "#endif\n"); 3675 verifyFormat("DEBUG({\n" 3676 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3677 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3678 "});\n" 3679 "#if a\n" 3680 "#else\n" 3681 "#endif"); 3682 3683 verifyIncompleteFormat("void f(\n" 3684 "#if A\n" 3685 ");\n" 3686 "#else\n" 3687 "#endif"); 3688 } 3689 3690 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3691 verifyFormat("#endif\n" 3692 "#if B"); 3693 } 3694 3695 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3696 FormatStyle SingleLine = getLLVMStyle(); 3697 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3698 verifyFormat("#if 0\n" 3699 "#elif 1\n" 3700 "#endif\n" 3701 "void foo() {\n" 3702 " if (test) foo2();\n" 3703 "}", 3704 SingleLine); 3705 } 3706 3707 TEST_F(FormatTest, LayoutBlockInsideParens) { 3708 verifyFormat("functionCall({ int i; });"); 3709 verifyFormat("functionCall({\n" 3710 " int i;\n" 3711 " int j;\n" 3712 "});"); 3713 verifyFormat("functionCall(\n" 3714 " {\n" 3715 " int i;\n" 3716 " int j;\n" 3717 " },\n" 3718 " aaaa, bbbb, cccc);"); 3719 verifyFormat("functionA(functionB({\n" 3720 " int i;\n" 3721 " int j;\n" 3722 " }),\n" 3723 " aaaa, bbbb, cccc);"); 3724 verifyFormat("functionCall(\n" 3725 " {\n" 3726 " int i;\n" 3727 " int j;\n" 3728 " },\n" 3729 " aaaa, bbbb, // comment\n" 3730 " cccc);"); 3731 verifyFormat("functionA(functionB({\n" 3732 " int i;\n" 3733 " int j;\n" 3734 " }),\n" 3735 " aaaa, bbbb, // comment\n" 3736 " cccc);"); 3737 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3738 verifyFormat("functionCall(aaaa, bbbb, {\n" 3739 " int i;\n" 3740 " int j;\n" 3741 "});"); 3742 verifyFormat( 3743 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3744 " {\n" 3745 " int i; // break\n" 3746 " },\n" 3747 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3748 " ccccccccccccccccc));"); 3749 verifyFormat("DEBUG({\n" 3750 " if (a)\n" 3751 " f();\n" 3752 "});"); 3753 } 3754 3755 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3756 EXPECT_EQ("SOME_MACRO { int i; }\n" 3757 "int i;", 3758 format(" SOME_MACRO {int i;} int i;")); 3759 } 3760 3761 TEST_F(FormatTest, LayoutNestedBlocks) { 3762 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3763 " struct s {\n" 3764 " int i;\n" 3765 " };\n" 3766 " s kBitsToOs[] = {{10}};\n" 3767 " for (int i = 0; i < 10; ++i)\n" 3768 " return;\n" 3769 "}"); 3770 verifyFormat("call(parameter, {\n" 3771 " something();\n" 3772 " // Comment using all columns.\n" 3773 " somethingelse();\n" 3774 "});", 3775 getLLVMStyleWithColumns(40)); 3776 verifyFormat("DEBUG( //\n" 3777 " { f(); }, a);"); 3778 verifyFormat("DEBUG( //\n" 3779 " {\n" 3780 " f(); //\n" 3781 " },\n" 3782 " a);"); 3783 3784 EXPECT_EQ("call(parameter, {\n" 3785 " something();\n" 3786 " // Comment too\n" 3787 " // looooooooooong.\n" 3788 " somethingElse();\n" 3789 "});", 3790 format("call(parameter, {\n" 3791 " something();\n" 3792 " // Comment too looooooooooong.\n" 3793 " somethingElse();\n" 3794 "});", 3795 getLLVMStyleWithColumns(29))); 3796 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3797 EXPECT_EQ("DEBUG({ // comment\n" 3798 " int i;\n" 3799 "});", 3800 format("DEBUG({ // comment\n" 3801 "int i;\n" 3802 "});")); 3803 EXPECT_EQ("DEBUG({\n" 3804 " int i;\n" 3805 "\n" 3806 " // comment\n" 3807 " int j;\n" 3808 "});", 3809 format("DEBUG({\n" 3810 " int i;\n" 3811 "\n" 3812 " // comment\n" 3813 " int j;\n" 3814 "});")); 3815 3816 verifyFormat("DEBUG({\n" 3817 " if (a)\n" 3818 " return;\n" 3819 "});"); 3820 verifyGoogleFormat("DEBUG({\n" 3821 " if (a) return;\n" 3822 "});"); 3823 FormatStyle Style = getGoogleStyle(); 3824 Style.ColumnLimit = 45; 3825 verifyFormat("Debug(\n" 3826 " aaaaa,\n" 3827 " {\n" 3828 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 3829 " },\n" 3830 " a);", 3831 Style); 3832 3833 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 3834 3835 verifyNoCrash("^{v^{a}}"); 3836 } 3837 3838 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 3839 EXPECT_EQ("#define MACRO() \\\n" 3840 " Debug(aaa, /* force line break */ \\\n" 3841 " { \\\n" 3842 " int i; \\\n" 3843 " int j; \\\n" 3844 " })", 3845 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 3846 " { int i; int j; })", 3847 getGoogleStyle())); 3848 3849 EXPECT_EQ("#define A \\\n" 3850 " [] { \\\n" 3851 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3852 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 3853 " }", 3854 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3855 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 3856 getGoogleStyle())); 3857 } 3858 3859 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 3860 EXPECT_EQ("{}", format("{}")); 3861 verifyFormat("enum E {};"); 3862 verifyFormat("enum E {}"); 3863 FormatStyle Style = getLLVMStyle(); 3864 Style.SpaceInEmptyBlock = true; 3865 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 3866 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 3867 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 3868 } 3869 3870 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 3871 FormatStyle Style = getLLVMStyle(); 3872 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 3873 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 3874 verifyFormat("FOO_BEGIN\n" 3875 " FOO_ENTRY\n" 3876 "FOO_END", 3877 Style); 3878 verifyFormat("FOO_BEGIN\n" 3879 " NESTED_FOO_BEGIN\n" 3880 " NESTED_FOO_ENTRY\n" 3881 " NESTED_FOO_END\n" 3882 "FOO_END", 3883 Style); 3884 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 3885 " int x;\n" 3886 " x = 1;\n" 3887 "FOO_END(Baz)", 3888 Style); 3889 } 3890 3891 //===----------------------------------------------------------------------===// 3892 // Line break tests. 3893 //===----------------------------------------------------------------------===// 3894 3895 TEST_F(FormatTest, PreventConfusingIndents) { 3896 verifyFormat( 3897 "void f() {\n" 3898 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 3899 " parameter, parameter, parameter)),\n" 3900 " SecondLongCall(parameter));\n" 3901 "}"); 3902 verifyFormat( 3903 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3904 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3905 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3906 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 3907 verifyFormat( 3908 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3909 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 3910 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 3911 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 3912 verifyFormat( 3913 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 3914 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 3915 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 3916 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 3917 verifyFormat("int a = bbbb && ccc &&\n" 3918 " fffff(\n" 3919 "#define A Just forcing a new line\n" 3920 " ddd);"); 3921 } 3922 3923 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 3924 verifyFormat( 3925 "bool aaaaaaa =\n" 3926 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 3927 " bbbbbbbb();"); 3928 verifyFormat( 3929 "bool aaaaaaa =\n" 3930 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 3931 " bbbbbbbb();"); 3932 3933 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3934 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 3935 " ccccccccc == ddddddddddd;"); 3936 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3937 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 3938 " ccccccccc == ddddddddddd;"); 3939 verifyFormat( 3940 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 3941 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 3942 " ccccccccc == ddddddddddd;"); 3943 3944 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3945 " aaaaaa) &&\n" 3946 " bbbbbb && cccccc;"); 3947 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3948 " aaaaaa) >>\n" 3949 " bbbbbb;"); 3950 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 3951 " SourceMgr.getSpellingColumnNumber(\n" 3952 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 3953 " 1);"); 3954 3955 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3956 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 3957 " cccccc) {\n}"); 3958 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3959 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3960 " cccccc) {\n}"); 3961 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3962 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3963 " cccccc) {\n}"); 3964 verifyFormat("b = a &&\n" 3965 " // Comment\n" 3966 " b.c && d;"); 3967 3968 // If the LHS of a comparison is not a binary expression itself, the 3969 // additional linebreak confuses many people. 3970 verifyFormat( 3971 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3972 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 3973 "}"); 3974 verifyFormat( 3975 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3976 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3977 "}"); 3978 verifyFormat( 3979 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 3980 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3981 "}"); 3982 verifyFormat( 3983 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3984 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 3985 "}"); 3986 // Even explicit parentheses stress the precedence enough to make the 3987 // additional break unnecessary. 3988 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3989 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3990 "}"); 3991 // This cases is borderline, but with the indentation it is still readable. 3992 verifyFormat( 3993 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3994 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3995 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 3996 "}", 3997 getLLVMStyleWithColumns(75)); 3998 3999 // If the LHS is a binary expression, we should still use the additional break 4000 // as otherwise the formatting hides the operator precedence. 4001 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4002 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4003 " 5) {\n" 4004 "}"); 4005 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4006 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 4007 " 5) {\n" 4008 "}"); 4009 4010 FormatStyle OnePerLine = getLLVMStyle(); 4011 OnePerLine.BinPackParameters = false; 4012 verifyFormat( 4013 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4014 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4015 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 4016 OnePerLine); 4017 4018 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 4019 " .aaa(aaaaaaaaaaaaa) *\n" 4020 " aaaaaaa +\n" 4021 " aaaaaaa;", 4022 getLLVMStyleWithColumns(40)); 4023 } 4024 4025 TEST_F(FormatTest, ExpressionIndentation) { 4026 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4027 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4028 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4029 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4030 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 4031 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 4032 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4033 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 4034 " ccccccccccccccccccccccccccccccccccccccccc;"); 4035 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4036 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4037 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4038 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4039 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4040 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4041 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4042 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4043 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4044 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4045 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4046 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4047 verifyFormat("if () {\n" 4048 "} else if (aaaaa && bbbbb > // break\n" 4049 " ccccc) {\n" 4050 "}"); 4051 verifyFormat("if () {\n" 4052 "} else if constexpr (aaaaa && bbbbb > // break\n" 4053 " ccccc) {\n" 4054 "}"); 4055 verifyFormat("if () {\n" 4056 "} else if CONSTEXPR (aaaaa && bbbbb > // break\n" 4057 " ccccc) {\n" 4058 "}"); 4059 verifyFormat("if () {\n" 4060 "} else if (aaaaa &&\n" 4061 " bbbbb > // break\n" 4062 " ccccc &&\n" 4063 " ddddd) {\n" 4064 "}"); 4065 4066 // Presence of a trailing comment used to change indentation of b. 4067 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 4068 " b;\n" 4069 "return aaaaaaaaaaaaaaaaaaa +\n" 4070 " b; //", 4071 getLLVMStyleWithColumns(30)); 4072 } 4073 4074 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 4075 // Not sure what the best system is here. Like this, the LHS can be found 4076 // immediately above an operator (everything with the same or a higher 4077 // indent). The RHS is aligned right of the operator and so compasses 4078 // everything until something with the same indent as the operator is found. 4079 // FIXME: Is this a good system? 4080 FormatStyle Style = getLLVMStyle(); 4081 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 4082 verifyFormat( 4083 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4084 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4085 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4086 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4087 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4088 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4089 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4090 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4091 " > ccccccccccccccccccccccccccccccccccccccccc;", 4092 Style); 4093 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4094 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4095 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4096 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4097 Style); 4098 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4099 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4100 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4101 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4102 Style); 4103 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4104 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4105 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4106 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4107 Style); 4108 verifyFormat("if () {\n" 4109 "} else if (aaaaa\n" 4110 " && bbbbb // break\n" 4111 " > ccccc) {\n" 4112 "}", 4113 Style); 4114 verifyFormat("return (a)\n" 4115 " // comment\n" 4116 " + b;", 4117 Style); 4118 verifyFormat( 4119 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4120 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4121 " + cc;", 4122 Style); 4123 4124 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4125 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4126 Style); 4127 4128 // Forced by comments. 4129 verifyFormat( 4130 "unsigned ContentSize =\n" 4131 " sizeof(int16_t) // DWARF ARange version number\n" 4132 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4133 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4134 " + sizeof(int8_t); // Segment Size (in bytes)"); 4135 4136 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 4137 " == boost::fusion::at_c<1>(iiii).second;", 4138 Style); 4139 4140 Style.ColumnLimit = 60; 4141 verifyFormat("zzzzzzzzzz\n" 4142 " = bbbbbbbbbbbbbbbbb\n" 4143 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 4144 Style); 4145 4146 Style.ColumnLimit = 80; 4147 Style.IndentWidth = 4; 4148 Style.TabWidth = 4; 4149 Style.UseTab = FormatStyle::UT_Always; 4150 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4151 Style.AlignOperands = false; 4152 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 4153 "\t&& (someOtherLongishConditionPart1\n" 4154 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 4155 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && " 4156 "(someOtherLongishConditionPart1 || " 4157 "someOtherEvenLongerNestedConditionPart2);", 4158 Style)); 4159 } 4160 4161 TEST_F(FormatTest, EnforcedOperatorWraps) { 4162 // Here we'd like to wrap after the || operators, but a comment is forcing an 4163 // earlier wrap. 4164 verifyFormat("bool x = aaaaa //\n" 4165 " || bbbbb\n" 4166 " //\n" 4167 " || cccc;"); 4168 } 4169 4170 TEST_F(FormatTest, NoOperandAlignment) { 4171 FormatStyle Style = getLLVMStyle(); 4172 Style.AlignOperands = false; 4173 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 4174 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4175 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4176 Style); 4177 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4178 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4179 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4180 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4181 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4182 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4183 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4184 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4185 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4186 " > ccccccccccccccccccccccccccccccccccccccccc;", 4187 Style); 4188 4189 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4190 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4191 " + cc;", 4192 Style); 4193 verifyFormat("int a = aa\n" 4194 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4195 " * cccccccccccccccccccccccccccccccccccc;\n", 4196 Style); 4197 4198 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4199 verifyFormat("return (a > b\n" 4200 " // comment1\n" 4201 " // comment2\n" 4202 " || c);", 4203 Style); 4204 } 4205 4206 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 4207 FormatStyle Style = getLLVMStyle(); 4208 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4209 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4210 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4211 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4212 Style); 4213 } 4214 4215 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 4216 FormatStyle Style = getLLVMStyle(); 4217 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4218 Style.BinPackArguments = false; 4219 Style.ColumnLimit = 40; 4220 verifyFormat("void test() {\n" 4221 " someFunction(\n" 4222 " this + argument + is + quite\n" 4223 " + long + so + it + gets + wrapped\n" 4224 " + but + remains + bin - packed);\n" 4225 "}", 4226 Style); 4227 verifyFormat("void test() {\n" 4228 " someFunction(arg1,\n" 4229 " this + argument + is\n" 4230 " + quite + long + so\n" 4231 " + it + gets + wrapped\n" 4232 " + but + remains + bin\n" 4233 " - packed,\n" 4234 " arg3);\n" 4235 "}", 4236 Style); 4237 verifyFormat("void test() {\n" 4238 " someFunction(\n" 4239 " arg1,\n" 4240 " this + argument + has\n" 4241 " + anotherFunc(nested,\n" 4242 " calls + whose\n" 4243 " + arguments\n" 4244 " + are + also\n" 4245 " + wrapped,\n" 4246 " in + addition)\n" 4247 " + to + being + bin - packed,\n" 4248 " arg3);\n" 4249 "}", 4250 Style); 4251 4252 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4253 verifyFormat("void test() {\n" 4254 " someFunction(\n" 4255 " arg1,\n" 4256 " this + argument + has +\n" 4257 " anotherFunc(nested,\n" 4258 " calls + whose +\n" 4259 " arguments +\n" 4260 " are + also +\n" 4261 " wrapped,\n" 4262 " in + addition) +\n" 4263 " to + being + bin - packed,\n" 4264 " arg3);\n" 4265 "}", 4266 Style); 4267 } 4268 4269 TEST_F(FormatTest, ConstructorInitializers) { 4270 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4271 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 4272 getLLVMStyleWithColumns(45)); 4273 verifyFormat("Constructor()\n" 4274 " : Inttializer(FitsOnTheLine) {}", 4275 getLLVMStyleWithColumns(44)); 4276 verifyFormat("Constructor()\n" 4277 " : Inttializer(FitsOnTheLine) {}", 4278 getLLVMStyleWithColumns(43)); 4279 4280 verifyFormat("template <typename T>\n" 4281 "Constructor() : Initializer(FitsOnTheLine) {}", 4282 getLLVMStyleWithColumns(45)); 4283 4284 verifyFormat( 4285 "SomeClass::Constructor()\n" 4286 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4287 4288 verifyFormat( 4289 "SomeClass::Constructor()\n" 4290 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4291 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 4292 verifyFormat( 4293 "SomeClass::Constructor()\n" 4294 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4295 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4296 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4297 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4298 " : aaaaaaaaaa(aaaaaa) {}"); 4299 4300 verifyFormat("Constructor()\n" 4301 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4302 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4303 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4304 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 4305 4306 verifyFormat("Constructor()\n" 4307 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4308 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4309 4310 verifyFormat("Constructor(int Parameter = 0)\n" 4311 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4312 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 4313 verifyFormat("Constructor()\n" 4314 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4315 "}", 4316 getLLVMStyleWithColumns(60)); 4317 verifyFormat("Constructor()\n" 4318 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4319 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 4320 4321 // Here a line could be saved by splitting the second initializer onto two 4322 // lines, but that is not desirable. 4323 verifyFormat("Constructor()\n" 4324 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4325 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4326 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4327 4328 FormatStyle OnePerLine = getLLVMStyle(); 4329 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4330 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 4331 verifyFormat("SomeClass::Constructor()\n" 4332 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4333 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4334 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4335 OnePerLine); 4336 verifyFormat("SomeClass::Constructor()\n" 4337 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4338 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4339 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4340 OnePerLine); 4341 verifyFormat("MyClass::MyClass(int var)\n" 4342 " : some_var_(var), // 4 space indent\n" 4343 " some_other_var_(var + 1) { // lined up\n" 4344 "}", 4345 OnePerLine); 4346 verifyFormat("Constructor()\n" 4347 " : aaaaa(aaaaaa),\n" 4348 " aaaaa(aaaaaa),\n" 4349 " aaaaa(aaaaaa),\n" 4350 " aaaaa(aaaaaa),\n" 4351 " aaaaa(aaaaaa) {}", 4352 OnePerLine); 4353 verifyFormat("Constructor()\n" 4354 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4355 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4356 OnePerLine); 4357 OnePerLine.BinPackParameters = false; 4358 verifyFormat( 4359 "Constructor()\n" 4360 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4361 " aaaaaaaaaaa().aaa(),\n" 4362 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4363 OnePerLine); 4364 OnePerLine.ColumnLimit = 60; 4365 verifyFormat("Constructor()\n" 4366 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4367 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4368 OnePerLine); 4369 4370 EXPECT_EQ("Constructor()\n" 4371 " : // Comment forcing unwanted break.\n" 4372 " aaaa(aaaa) {}", 4373 format("Constructor() :\n" 4374 " // Comment forcing unwanted break.\n" 4375 " aaaa(aaaa) {}")); 4376 } 4377 4378 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 4379 FormatStyle Style = getLLVMStyle(); 4380 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4381 Style.ColumnLimit = 60; 4382 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4383 Style.AllowAllConstructorInitializersOnNextLine = true; 4384 Style.BinPackParameters = false; 4385 4386 for (int i = 0; i < 4; ++i) { 4387 // Test all combinations of parameters that should not have an effect. 4388 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4389 Style.AllowAllArgumentsOnNextLine = i & 2; 4390 4391 Style.AllowAllConstructorInitializersOnNextLine = true; 4392 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4393 verifyFormat("Constructor()\n" 4394 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4395 Style); 4396 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4397 4398 Style.AllowAllConstructorInitializersOnNextLine = false; 4399 verifyFormat("Constructor()\n" 4400 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4401 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4402 Style); 4403 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4404 4405 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4406 Style.AllowAllConstructorInitializersOnNextLine = true; 4407 verifyFormat("Constructor()\n" 4408 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4409 Style); 4410 4411 Style.AllowAllConstructorInitializersOnNextLine = false; 4412 verifyFormat("Constructor()\n" 4413 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4414 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4415 Style); 4416 4417 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4418 Style.AllowAllConstructorInitializersOnNextLine = true; 4419 verifyFormat("Constructor() :\n" 4420 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4421 Style); 4422 4423 Style.AllowAllConstructorInitializersOnNextLine = false; 4424 verifyFormat("Constructor() :\n" 4425 " aaaaaaaaaaaaaaaaaa(a),\n" 4426 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4427 Style); 4428 } 4429 4430 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4431 // AllowAllConstructorInitializersOnNextLine in all 4432 // BreakConstructorInitializers modes 4433 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4434 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4435 Style.AllowAllConstructorInitializersOnNextLine = false; 4436 verifyFormat("SomeClassWithALongName::Constructor(\n" 4437 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4438 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4439 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4440 Style); 4441 4442 Style.AllowAllConstructorInitializersOnNextLine = true; 4443 verifyFormat("SomeClassWithALongName::Constructor(\n" 4444 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4445 " int bbbbbbbbbbbbb,\n" 4446 " int cccccccccccccccc)\n" 4447 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4448 Style); 4449 4450 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4451 Style.AllowAllConstructorInitializersOnNextLine = false; 4452 verifyFormat("SomeClassWithALongName::Constructor(\n" 4453 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4454 " int bbbbbbbbbbbbb)\n" 4455 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4456 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4457 Style); 4458 4459 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4460 4461 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4462 verifyFormat("SomeClassWithALongName::Constructor(\n" 4463 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4464 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4465 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4466 Style); 4467 4468 Style.AllowAllConstructorInitializersOnNextLine = true; 4469 verifyFormat("SomeClassWithALongName::Constructor(\n" 4470 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4471 " int bbbbbbbbbbbbb,\n" 4472 " int cccccccccccccccc)\n" 4473 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4474 Style); 4475 4476 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4477 Style.AllowAllConstructorInitializersOnNextLine = false; 4478 verifyFormat("SomeClassWithALongName::Constructor(\n" 4479 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4480 " int bbbbbbbbbbbbb)\n" 4481 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4482 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4483 Style); 4484 4485 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4486 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4487 verifyFormat("SomeClassWithALongName::Constructor(\n" 4488 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4489 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4490 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4491 Style); 4492 4493 Style.AllowAllConstructorInitializersOnNextLine = true; 4494 verifyFormat("SomeClassWithALongName::Constructor(\n" 4495 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4496 " int bbbbbbbbbbbbb,\n" 4497 " int cccccccccccccccc) :\n" 4498 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4499 Style); 4500 4501 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4502 Style.AllowAllConstructorInitializersOnNextLine = false; 4503 verifyFormat("SomeClassWithALongName::Constructor(\n" 4504 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4505 " int bbbbbbbbbbbbb) :\n" 4506 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4507 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4508 Style); 4509 } 4510 4511 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4512 FormatStyle Style = getLLVMStyle(); 4513 Style.ColumnLimit = 60; 4514 Style.BinPackArguments = false; 4515 for (int i = 0; i < 4; ++i) { 4516 // Test all combinations of parameters that should not have an effect. 4517 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4518 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4519 4520 Style.AllowAllArgumentsOnNextLine = true; 4521 verifyFormat("void foo() {\n" 4522 " FunctionCallWithReallyLongName(\n" 4523 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4524 "}", 4525 Style); 4526 Style.AllowAllArgumentsOnNextLine = false; 4527 verifyFormat("void foo() {\n" 4528 " FunctionCallWithReallyLongName(\n" 4529 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4530 " bbbbbbbbbbbb);\n" 4531 "}", 4532 Style); 4533 4534 Style.AllowAllArgumentsOnNextLine = true; 4535 verifyFormat("void foo() {\n" 4536 " auto VariableWithReallyLongName = {\n" 4537 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4538 "}", 4539 Style); 4540 Style.AllowAllArgumentsOnNextLine = false; 4541 verifyFormat("void foo() {\n" 4542 " auto VariableWithReallyLongName = {\n" 4543 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4544 " bbbbbbbbbbbb};\n" 4545 "}", 4546 Style); 4547 } 4548 4549 // This parameter should not affect declarations. 4550 Style.BinPackParameters = false; 4551 Style.AllowAllArgumentsOnNextLine = false; 4552 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4553 verifyFormat("void FunctionCallWithReallyLongName(\n" 4554 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4555 Style); 4556 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4557 verifyFormat("void FunctionCallWithReallyLongName(\n" 4558 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4559 " int bbbbbbbbbbbb);", 4560 Style); 4561 } 4562 4563 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4564 FormatStyle Style = getLLVMStyle(); 4565 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4566 4567 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4568 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4569 getStyleWithColumns(Style, 45)); 4570 verifyFormat("Constructor() :\n" 4571 " Initializer(FitsOnTheLine) {}", 4572 getStyleWithColumns(Style, 44)); 4573 verifyFormat("Constructor() :\n" 4574 " Initializer(FitsOnTheLine) {}", 4575 getStyleWithColumns(Style, 43)); 4576 4577 verifyFormat("template <typename T>\n" 4578 "Constructor() : Initializer(FitsOnTheLine) {}", 4579 getStyleWithColumns(Style, 50)); 4580 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4581 verifyFormat( 4582 "SomeClass::Constructor() :\n" 4583 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4584 Style); 4585 4586 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4587 verifyFormat( 4588 "SomeClass::Constructor() :\n" 4589 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4590 Style); 4591 4592 verifyFormat( 4593 "SomeClass::Constructor() :\n" 4594 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4595 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4596 Style); 4597 verifyFormat( 4598 "SomeClass::Constructor() :\n" 4599 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4600 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4601 Style); 4602 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4603 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4604 " aaaaaaaaaa(aaaaaa) {}", 4605 Style); 4606 4607 verifyFormat("Constructor() :\n" 4608 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4609 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4610 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4611 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4612 Style); 4613 4614 verifyFormat("Constructor() :\n" 4615 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4616 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4617 Style); 4618 4619 verifyFormat("Constructor(int Parameter = 0) :\n" 4620 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4621 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4622 Style); 4623 verifyFormat("Constructor() :\n" 4624 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4625 "}", 4626 getStyleWithColumns(Style, 60)); 4627 verifyFormat("Constructor() :\n" 4628 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4629 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4630 Style); 4631 4632 // Here a line could be saved by splitting the second initializer onto two 4633 // lines, but that is not desirable. 4634 verifyFormat("Constructor() :\n" 4635 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4636 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4637 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4638 Style); 4639 4640 FormatStyle OnePerLine = Style; 4641 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4642 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4643 verifyFormat("SomeClass::Constructor() :\n" 4644 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4645 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4646 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4647 OnePerLine); 4648 verifyFormat("SomeClass::Constructor() :\n" 4649 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4650 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4651 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4652 OnePerLine); 4653 verifyFormat("MyClass::MyClass(int var) :\n" 4654 " some_var_(var), // 4 space indent\n" 4655 " some_other_var_(var + 1) { // lined up\n" 4656 "}", 4657 OnePerLine); 4658 verifyFormat("Constructor() :\n" 4659 " aaaaa(aaaaaa),\n" 4660 " aaaaa(aaaaaa),\n" 4661 " aaaaa(aaaaaa),\n" 4662 " aaaaa(aaaaaa),\n" 4663 " aaaaa(aaaaaa) {}", 4664 OnePerLine); 4665 verifyFormat("Constructor() :\n" 4666 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4667 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4668 OnePerLine); 4669 OnePerLine.BinPackParameters = false; 4670 verifyFormat("Constructor() :\n" 4671 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4672 " aaaaaaaaaaa().aaa(),\n" 4673 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4674 OnePerLine); 4675 OnePerLine.ColumnLimit = 60; 4676 verifyFormat("Constructor() :\n" 4677 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4678 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4679 OnePerLine); 4680 4681 EXPECT_EQ("Constructor() :\n" 4682 " // Comment forcing unwanted break.\n" 4683 " aaaa(aaaa) {}", 4684 format("Constructor() :\n" 4685 " // Comment forcing unwanted break.\n" 4686 " aaaa(aaaa) {}", 4687 Style)); 4688 4689 Style.ColumnLimit = 0; 4690 verifyFormat("SomeClass::Constructor() :\n" 4691 " a(a) {}", 4692 Style); 4693 verifyFormat("SomeClass::Constructor() noexcept :\n" 4694 " a(a) {}", 4695 Style); 4696 verifyFormat("SomeClass::Constructor() :\n" 4697 " a(a), b(b), c(c) {}", 4698 Style); 4699 verifyFormat("SomeClass::Constructor() :\n" 4700 " a(a) {\n" 4701 " foo();\n" 4702 " bar();\n" 4703 "}", 4704 Style); 4705 4706 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4707 verifyFormat("SomeClass::Constructor() :\n" 4708 " a(a), b(b), c(c) {\n" 4709 "}", 4710 Style); 4711 verifyFormat("SomeClass::Constructor() :\n" 4712 " a(a) {\n" 4713 "}", 4714 Style); 4715 4716 Style.ColumnLimit = 80; 4717 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4718 Style.ConstructorInitializerIndentWidth = 2; 4719 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style); 4720 verifyFormat("SomeClass::Constructor() :\n" 4721 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4722 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 4723 Style); 4724 4725 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as 4726 // well 4727 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 4728 verifyFormat( 4729 "class SomeClass\n" 4730 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4731 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4732 Style); 4733 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 4734 verifyFormat( 4735 "class SomeClass\n" 4736 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4737 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4738 Style); 4739 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 4740 verifyFormat( 4741 "class SomeClass :\n" 4742 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4743 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4744 Style); 4745 } 4746 4747 #ifndef EXPENSIVE_CHECKS 4748 // Expensive checks enables libstdc++ checking which includes validating the 4749 // state of ranges used in std::priority_queue - this blows out the 4750 // runtime/scalability of the function and makes this test unacceptably slow. 4751 TEST_F(FormatTest, MemoizationTests) { 4752 // This breaks if the memoization lookup does not take \c Indent and 4753 // \c LastSpace into account. 4754 verifyFormat( 4755 "extern CFRunLoopTimerRef\n" 4756 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 4757 " CFTimeInterval interval, CFOptionFlags flags,\n" 4758 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 4759 " CFRunLoopTimerContext *context) {}"); 4760 4761 // Deep nesting somewhat works around our memoization. 4762 verifyFormat( 4763 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4764 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4765 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4766 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4767 " aaaaa())))))))))))))))))))))))))))))))))))))));", 4768 getLLVMStyleWithColumns(65)); 4769 verifyFormat( 4770 "aaaaa(\n" 4771 " aaaaa,\n" 4772 " aaaaa(\n" 4773 " aaaaa,\n" 4774 " aaaaa(\n" 4775 " aaaaa,\n" 4776 " aaaaa(\n" 4777 " aaaaa,\n" 4778 " aaaaa(\n" 4779 " aaaaa,\n" 4780 " aaaaa(\n" 4781 " aaaaa,\n" 4782 " aaaaa(\n" 4783 " aaaaa,\n" 4784 " aaaaa(\n" 4785 " aaaaa,\n" 4786 " aaaaa(\n" 4787 " aaaaa,\n" 4788 " aaaaa(\n" 4789 " aaaaa,\n" 4790 " aaaaa(\n" 4791 " aaaaa,\n" 4792 " aaaaa(\n" 4793 " aaaaa,\n" 4794 " aaaaa))))))))))));", 4795 getLLVMStyleWithColumns(65)); 4796 verifyFormat( 4797 "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" 4798 " a),\n" 4799 " a),\n" 4800 " a),\n" 4801 " a),\n" 4802 " a),\n" 4803 " a),\n" 4804 " a),\n" 4805 " a),\n" 4806 " a),\n" 4807 " a),\n" 4808 " a),\n" 4809 " a),\n" 4810 " a),\n" 4811 " a),\n" 4812 " a),\n" 4813 " a),\n" 4814 " a)", 4815 getLLVMStyleWithColumns(65)); 4816 4817 // This test takes VERY long when memoization is broken. 4818 FormatStyle OnePerLine = getLLVMStyle(); 4819 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4820 OnePerLine.BinPackParameters = false; 4821 std::string input = "Constructor()\n" 4822 " : aaaa(a,\n"; 4823 for (unsigned i = 0, e = 80; i != e; ++i) { 4824 input += " a,\n"; 4825 } 4826 input += " a) {}"; 4827 verifyFormat(input, OnePerLine); 4828 } 4829 #endif 4830 4831 TEST_F(FormatTest, BreaksAsHighAsPossible) { 4832 verifyFormat( 4833 "void f() {\n" 4834 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 4835 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 4836 " f();\n" 4837 "}"); 4838 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 4839 " Intervals[i - 1].getRange().getLast()) {\n}"); 4840 } 4841 4842 TEST_F(FormatTest, BreaksFunctionDeclarations) { 4843 // Principially, we break function declarations in a certain order: 4844 // 1) break amongst arguments. 4845 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 4846 " Cccccccccccccc cccccccccccccc);"); 4847 verifyFormat("template <class TemplateIt>\n" 4848 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 4849 " TemplateIt *stop) {}"); 4850 4851 // 2) break after return type. 4852 verifyFormat( 4853 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4854 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 4855 getGoogleStyle()); 4856 4857 // 3) break after (. 4858 verifyFormat( 4859 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 4860 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 4861 getGoogleStyle()); 4862 4863 // 4) break before after nested name specifiers. 4864 verifyFormat( 4865 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4866 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 4867 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 4868 getGoogleStyle()); 4869 4870 // However, there are exceptions, if a sufficient amount of lines can be 4871 // saved. 4872 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 4873 // more adjusting. 4874 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4875 " Cccccccccccccc cccccccccc,\n" 4876 " Cccccccccccccc cccccccccc,\n" 4877 " Cccccccccccccc cccccccccc,\n" 4878 " Cccccccccccccc cccccccccc);"); 4879 verifyFormat( 4880 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4881 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4882 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4883 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 4884 getGoogleStyle()); 4885 verifyFormat( 4886 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4887 " Cccccccccccccc cccccccccc,\n" 4888 " Cccccccccccccc cccccccccc,\n" 4889 " Cccccccccccccc cccccccccc,\n" 4890 " Cccccccccccccc cccccccccc,\n" 4891 " Cccccccccccccc cccccccccc,\n" 4892 " Cccccccccccccc cccccccccc);"); 4893 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4894 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4895 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4896 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4897 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 4898 4899 // Break after multi-line parameters. 4900 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4901 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4902 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4903 " bbbb bbbb);"); 4904 verifyFormat("void SomeLoooooooooooongFunction(\n" 4905 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 4906 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4907 " int bbbbbbbbbbbbb);"); 4908 4909 // Treat overloaded operators like other functions. 4910 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4911 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 4912 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4913 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 4914 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4915 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 4916 verifyGoogleFormat( 4917 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 4918 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4919 verifyGoogleFormat( 4920 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 4921 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4922 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4923 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4924 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 4925 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4926 verifyGoogleFormat( 4927 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 4928 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4929 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 4930 verifyGoogleFormat("template <typename T>\n" 4931 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4932 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 4933 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 4934 4935 FormatStyle Style = getLLVMStyle(); 4936 Style.PointerAlignment = FormatStyle::PAS_Left; 4937 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4938 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 4939 Style); 4940 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 4941 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4942 Style); 4943 } 4944 4945 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 4946 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 4947 // Prefer keeping `::` followed by `operator` together. 4948 EXPECT_EQ("const aaaa::bbbbbbb &\n" 4949 "ccccccccc::operator++() {\n" 4950 " stuff();\n" 4951 "}", 4952 format("const aaaa::bbbbbbb\n" 4953 "&ccccccccc::operator++() { stuff(); }", 4954 getLLVMStyleWithColumns(40))); 4955 } 4956 4957 TEST_F(FormatTest, TrailingReturnType) { 4958 verifyFormat("auto foo() -> int;\n"); 4959 // correct trailing return type spacing 4960 verifyFormat("auto operator->() -> int;\n"); 4961 verifyFormat("auto operator++(int) -> int;\n"); 4962 4963 verifyFormat("struct S {\n" 4964 " auto bar() const -> int;\n" 4965 "};"); 4966 verifyFormat("template <size_t Order, typename T>\n" 4967 "auto load_img(const std::string &filename)\n" 4968 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 4969 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 4970 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 4971 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 4972 verifyFormat("template <typename T>\n" 4973 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 4974 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 4975 4976 // Not trailing return types. 4977 verifyFormat("void f() { auto a = b->c(); }"); 4978 } 4979 4980 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 4981 // Avoid breaking before trailing 'const' or other trailing annotations, if 4982 // they are not function-like. 4983 FormatStyle Style = getGoogleStyle(); 4984 Style.ColumnLimit = 47; 4985 verifyFormat("void someLongFunction(\n" 4986 " int someLoooooooooooooongParameter) const {\n}", 4987 getLLVMStyleWithColumns(47)); 4988 verifyFormat("LoooooongReturnType\n" 4989 "someLoooooooongFunction() const {}", 4990 getLLVMStyleWithColumns(47)); 4991 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 4992 " const {}", 4993 Style); 4994 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4995 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 4996 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4997 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 4998 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4999 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 5000 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 5001 " aaaaaaaaaaa aaaaa) const override;"); 5002 verifyGoogleFormat( 5003 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5004 " const override;"); 5005 5006 // Even if the first parameter has to be wrapped. 5007 verifyFormat("void someLongFunction(\n" 5008 " int someLongParameter) const {}", 5009 getLLVMStyleWithColumns(46)); 5010 verifyFormat("void someLongFunction(\n" 5011 " int someLongParameter) const {}", 5012 Style); 5013 verifyFormat("void someLongFunction(\n" 5014 " int someLongParameter) override {}", 5015 Style); 5016 verifyFormat("void someLongFunction(\n" 5017 " int someLongParameter) OVERRIDE {}", 5018 Style); 5019 verifyFormat("void someLongFunction(\n" 5020 " int someLongParameter) final {}", 5021 Style); 5022 verifyFormat("void someLongFunction(\n" 5023 " int someLongParameter) FINAL {}", 5024 Style); 5025 verifyFormat("void someLongFunction(\n" 5026 " int parameter) const override {}", 5027 Style); 5028 5029 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 5030 verifyFormat("void someLongFunction(\n" 5031 " int someLongParameter) const\n" 5032 "{\n" 5033 "}", 5034 Style); 5035 5036 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 5037 verifyFormat("void someLongFunction(\n" 5038 " int someLongParameter) const\n" 5039 " {\n" 5040 " }", 5041 Style); 5042 5043 // Unless these are unknown annotations. 5044 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 5045 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5046 " LONG_AND_UGLY_ANNOTATION;"); 5047 5048 // Breaking before function-like trailing annotations is fine to keep them 5049 // close to their arguments. 5050 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5051 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5052 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5053 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5054 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5055 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 5056 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 5057 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 5058 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 5059 5060 verifyFormat( 5061 "void aaaaaaaaaaaaaaaaaa()\n" 5062 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 5063 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 5064 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5065 " __attribute__((unused));"); 5066 verifyGoogleFormat( 5067 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5068 " GUARDED_BY(aaaaaaaaaaaa);"); 5069 verifyGoogleFormat( 5070 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5071 " GUARDED_BY(aaaaaaaaaaaa);"); 5072 verifyGoogleFormat( 5073 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5074 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5075 verifyGoogleFormat( 5076 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5077 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5078 } 5079 5080 TEST_F(FormatTest, FunctionAnnotations) { 5081 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5082 "int OldFunction(const string ¶meter) {}"); 5083 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5084 "string OldFunction(const string ¶meter) {}"); 5085 verifyFormat("template <typename T>\n" 5086 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5087 "string OldFunction(const string ¶meter) {}"); 5088 5089 // Not function annotations. 5090 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5091 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 5092 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 5093 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 5094 verifyFormat("MACRO(abc).function() // wrap\n" 5095 " << abc;"); 5096 verifyFormat("MACRO(abc)->function() // wrap\n" 5097 " << abc;"); 5098 verifyFormat("MACRO(abc)::function() // wrap\n" 5099 " << abc;"); 5100 } 5101 5102 TEST_F(FormatTest, BreaksDesireably) { 5103 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5104 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5105 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 5106 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5107 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 5108 "}"); 5109 5110 verifyFormat( 5111 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5112 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 5113 5114 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5115 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5116 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5117 5118 verifyFormat( 5119 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5120 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5121 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5122 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5123 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 5124 5125 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5126 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5127 5128 verifyFormat( 5129 "void f() {\n" 5130 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 5131 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5132 "}"); 5133 verifyFormat( 5134 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5135 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5136 verifyFormat( 5137 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5138 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5139 verifyFormat( 5140 "aaaaaa(aaa,\n" 5141 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5142 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5143 " aaaa);"); 5144 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5145 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5146 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5147 5148 // Indent consistently independent of call expression and unary operator. 5149 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5150 " dddddddddddddddddddddddddddddd));"); 5151 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5152 " dddddddddddddddddddddddddddddd));"); 5153 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 5154 " dddddddddddddddddddddddddddddd));"); 5155 5156 // This test case breaks on an incorrect memoization, i.e. an optimization not 5157 // taking into account the StopAt value. 5158 verifyFormat( 5159 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5160 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5161 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5162 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5163 5164 verifyFormat("{\n {\n {\n" 5165 " Annotation.SpaceRequiredBefore =\n" 5166 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 5167 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 5168 " }\n }\n}"); 5169 5170 // Break on an outer level if there was a break on an inner level. 5171 EXPECT_EQ("f(g(h(a, // comment\n" 5172 " b, c),\n" 5173 " d, e),\n" 5174 " x, y);", 5175 format("f(g(h(a, // comment\n" 5176 " b, c), d, e), x, y);")); 5177 5178 // Prefer breaking similar line breaks. 5179 verifyFormat( 5180 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 5181 " NSTrackingMouseEnteredAndExited |\n" 5182 " NSTrackingActiveAlways;"); 5183 } 5184 5185 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 5186 FormatStyle NoBinPacking = getGoogleStyle(); 5187 NoBinPacking.BinPackParameters = false; 5188 NoBinPacking.BinPackArguments = true; 5189 verifyFormat("void f() {\n" 5190 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 5191 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5192 "}", 5193 NoBinPacking); 5194 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 5195 " int aaaaaaaaaaaaaaaaaaaa,\n" 5196 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5197 NoBinPacking); 5198 5199 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5200 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5201 " vector<int> bbbbbbbbbbbbbbb);", 5202 NoBinPacking); 5203 // FIXME: This behavior difference is probably not wanted. However, currently 5204 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 5205 // template arguments from BreakBeforeParameter being set because of the 5206 // one-per-line formatting. 5207 verifyFormat( 5208 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5209 " aaaaaaaaaa> aaaaaaaaaa);", 5210 NoBinPacking); 5211 verifyFormat( 5212 "void fffffffffff(\n" 5213 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 5214 " aaaaaaaaaa);"); 5215 } 5216 5217 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 5218 FormatStyle NoBinPacking = getGoogleStyle(); 5219 NoBinPacking.BinPackParameters = false; 5220 NoBinPacking.BinPackArguments = false; 5221 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 5222 " aaaaaaaaaaaaaaaaaaaa,\n" 5223 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 5224 NoBinPacking); 5225 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 5226 " aaaaaaaaaaaaa,\n" 5227 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 5228 NoBinPacking); 5229 verifyFormat( 5230 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5231 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5232 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5233 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5234 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 5235 NoBinPacking); 5236 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5237 " .aaaaaaaaaaaaaaaaaa();", 5238 NoBinPacking); 5239 verifyFormat("void f() {\n" 5240 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5241 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 5242 "}", 5243 NoBinPacking); 5244 5245 verifyFormat( 5246 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5247 " aaaaaaaaaaaa,\n" 5248 " aaaaaaaaaaaa);", 5249 NoBinPacking); 5250 verifyFormat( 5251 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 5252 " ddddddddddddddddddddddddddddd),\n" 5253 " test);", 5254 NoBinPacking); 5255 5256 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5257 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 5258 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 5259 " aaaaaaaaaaaaaaaaaa;", 5260 NoBinPacking); 5261 verifyFormat("a(\"a\"\n" 5262 " \"a\",\n" 5263 " a);"); 5264 5265 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5266 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 5267 " aaaaaaaaa,\n" 5268 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5269 NoBinPacking); 5270 verifyFormat( 5271 "void f() {\n" 5272 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5273 " .aaaaaaa();\n" 5274 "}", 5275 NoBinPacking); 5276 verifyFormat( 5277 "template <class SomeType, class SomeOtherType>\n" 5278 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 5279 NoBinPacking); 5280 } 5281 5282 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 5283 FormatStyle Style = getLLVMStyleWithColumns(15); 5284 Style.ExperimentalAutoDetectBinPacking = true; 5285 EXPECT_EQ("aaa(aaaa,\n" 5286 " aaaa,\n" 5287 " aaaa);\n" 5288 "aaa(aaaa,\n" 5289 " aaaa,\n" 5290 " aaaa);", 5291 format("aaa(aaaa,\n" // one-per-line 5292 " aaaa,\n" 5293 " aaaa );\n" 5294 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5295 Style)); 5296 EXPECT_EQ("aaa(aaaa, aaaa,\n" 5297 " aaaa);\n" 5298 "aaa(aaaa, aaaa,\n" 5299 " aaaa);", 5300 format("aaa(aaaa, aaaa,\n" // bin-packed 5301 " aaaa );\n" 5302 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5303 Style)); 5304 } 5305 5306 TEST_F(FormatTest, FormatsBuilderPattern) { 5307 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 5308 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 5309 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 5310 " .StartsWith(\".init\", ORDER_INIT)\n" 5311 " .StartsWith(\".fini\", ORDER_FINI)\n" 5312 " .StartsWith(\".hash\", ORDER_HASH)\n" 5313 " .Default(ORDER_TEXT);\n"); 5314 5315 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 5316 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 5317 verifyFormat("aaaaaaa->aaaaaaa\n" 5318 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5319 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5320 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5321 verifyFormat( 5322 "aaaaaaa->aaaaaaa\n" 5323 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5324 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5325 verifyFormat( 5326 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 5327 " aaaaaaaaaaaaaa);"); 5328 verifyFormat( 5329 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 5330 " aaaaaa->aaaaaaaaaaaa()\n" 5331 " ->aaaaaaaaaaaaaaaa(\n" 5332 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5333 " ->aaaaaaaaaaaaaaaaa();"); 5334 verifyGoogleFormat( 5335 "void f() {\n" 5336 " someo->Add((new util::filetools::Handler(dir))\n" 5337 " ->OnEvent1(NewPermanentCallback(\n" 5338 " this, &HandlerHolderClass::EventHandlerCBA))\n" 5339 " ->OnEvent2(NewPermanentCallback(\n" 5340 " this, &HandlerHolderClass::EventHandlerCBB))\n" 5341 " ->OnEvent3(NewPermanentCallback(\n" 5342 " this, &HandlerHolderClass::EventHandlerCBC))\n" 5343 " ->OnEvent5(NewPermanentCallback(\n" 5344 " this, &HandlerHolderClass::EventHandlerCBD))\n" 5345 " ->OnEvent6(NewPermanentCallback(\n" 5346 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 5347 "}"); 5348 5349 verifyFormat( 5350 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 5351 verifyFormat("aaaaaaaaaaaaaaa()\n" 5352 " .aaaaaaaaaaaaaaa()\n" 5353 " .aaaaaaaaaaaaaaa()\n" 5354 " .aaaaaaaaaaaaaaa()\n" 5355 " .aaaaaaaaaaaaaaa();"); 5356 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5357 " .aaaaaaaaaaaaaaa()\n" 5358 " .aaaaaaaaaaaaaaa()\n" 5359 " .aaaaaaaaaaaaaaa();"); 5360 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5361 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5362 " .aaaaaaaaaaaaaaa();"); 5363 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 5364 " ->aaaaaaaaaaaaaae(0)\n" 5365 " ->aaaaaaaaaaaaaaa();"); 5366 5367 // Don't linewrap after very short segments. 5368 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5369 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5370 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5371 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5372 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5373 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5374 verifyFormat("aaa()\n" 5375 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5376 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5377 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5378 5379 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5380 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5381 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 5382 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5383 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 5384 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 5385 5386 // Prefer not to break after empty parentheses. 5387 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 5388 " First->LastNewlineOffset);"); 5389 5390 // Prefer not to create "hanging" indents. 5391 verifyFormat( 5392 "return !soooooooooooooome_map\n" 5393 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5394 " .second;"); 5395 verifyFormat( 5396 "return aaaaaaaaaaaaaaaa\n" 5397 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 5398 " .aaaa(aaaaaaaaaaaaaa);"); 5399 // No hanging indent here. 5400 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5401 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5402 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5403 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5404 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5405 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5406 getLLVMStyleWithColumns(60)); 5407 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5408 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5409 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5410 getLLVMStyleWithColumns(59)); 5411 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5412 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5413 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5414 5415 // Dont break if only closing statements before member call 5416 verifyFormat("test() {\n" 5417 " ([]() -> {\n" 5418 " int b = 32;\n" 5419 " return 3;\n" 5420 " }).foo();\n" 5421 "}"); 5422 verifyFormat("test() {\n" 5423 " (\n" 5424 " []() -> {\n" 5425 " int b = 32;\n" 5426 " return 3;\n" 5427 " },\n" 5428 " foo, bar)\n" 5429 " .foo();\n" 5430 "}"); 5431 verifyFormat("test() {\n" 5432 " ([]() -> {\n" 5433 " int b = 32;\n" 5434 " return 3;\n" 5435 " })\n" 5436 " .foo()\n" 5437 " .bar();\n" 5438 "}"); 5439 verifyFormat("test() {\n" 5440 " ([]() -> {\n" 5441 " int b = 32;\n" 5442 " return 3;\n" 5443 " })\n" 5444 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5445 " \"bbbb\");\n" 5446 "}", 5447 getLLVMStyleWithColumns(30)); 5448 } 5449 5450 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5451 verifyFormat( 5452 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5453 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5454 verifyFormat( 5455 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5456 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5457 5458 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5459 " ccccccccccccccccccccccccc) {\n}"); 5460 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5461 " ccccccccccccccccccccccccc) {\n}"); 5462 5463 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5464 " ccccccccccccccccccccccccc) {\n}"); 5465 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5466 " ccccccccccccccccccccccccc) {\n}"); 5467 5468 verifyFormat( 5469 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5470 " ccccccccccccccccccccccccc) {\n}"); 5471 verifyFormat( 5472 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5473 " ccccccccccccccccccccccccc) {\n}"); 5474 5475 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5476 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5477 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5478 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5479 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5480 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5481 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5482 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5483 5484 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5485 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5486 " aaaaaaaaaaaaaaa != aa) {\n}"); 5487 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5488 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5489 " aaaaaaaaaaaaaaa != aa) {\n}"); 5490 } 5491 5492 TEST_F(FormatTest, BreaksAfterAssignments) { 5493 verifyFormat( 5494 "unsigned Cost =\n" 5495 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5496 " SI->getPointerAddressSpaceee());\n"); 5497 verifyFormat( 5498 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5499 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5500 5501 verifyFormat( 5502 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5503 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5504 verifyFormat("unsigned OriginalStartColumn =\n" 5505 " SourceMgr.getSpellingColumnNumber(\n" 5506 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5507 " 1;"); 5508 } 5509 5510 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5511 FormatStyle Style = getLLVMStyle(); 5512 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5513 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5514 Style); 5515 5516 Style.PenaltyBreakAssignment = 20; 5517 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5518 " cccccccccccccccccccccccccc;", 5519 Style); 5520 } 5521 5522 TEST_F(FormatTest, AlignsAfterAssignments) { 5523 verifyFormat( 5524 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5525 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5526 verifyFormat( 5527 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5528 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5529 verifyFormat( 5530 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5531 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5532 verifyFormat( 5533 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5534 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5535 verifyFormat( 5536 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5537 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5538 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5539 } 5540 5541 TEST_F(FormatTest, AlignsAfterReturn) { 5542 verifyFormat( 5543 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5544 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5545 verifyFormat( 5546 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5547 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5548 verifyFormat( 5549 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5550 " aaaaaaaaaaaaaaaaaaaaaa();"); 5551 verifyFormat( 5552 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5553 " aaaaaaaaaaaaaaaaaaaaaa());"); 5554 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5555 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5556 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5557 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5558 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5559 verifyFormat("return\n" 5560 " // true if code is one of a or b.\n" 5561 " code == a || code == b;"); 5562 } 5563 5564 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5565 verifyFormat( 5566 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5567 " aaaaaaaaa aaaaaaa) {}"); 5568 verifyFormat( 5569 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5570 " aaaaaaaaaaa aaaaaaaaa);"); 5571 verifyFormat( 5572 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5573 " aaaaaaaaaaaaaaaaaaaaa));"); 5574 FormatStyle Style = getLLVMStyle(); 5575 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5576 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5577 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5578 Style); 5579 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5580 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5581 Style); 5582 verifyFormat("SomeLongVariableName->someFunction(\n" 5583 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5584 Style); 5585 verifyFormat( 5586 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5587 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5588 Style); 5589 verifyFormat( 5590 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5591 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5592 Style); 5593 verifyFormat( 5594 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5595 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5596 Style); 5597 5598 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5599 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5600 " b));", 5601 Style); 5602 5603 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5604 Style.BinPackArguments = false; 5605 Style.BinPackParameters = false; 5606 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5607 " aaaaaaaaaaa aaaaaaaa,\n" 5608 " aaaaaaaaa aaaaaaa,\n" 5609 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5610 Style); 5611 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5612 " aaaaaaaaaaa aaaaaaaaa,\n" 5613 " aaaaaaaaaaa aaaaaaaaa,\n" 5614 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5615 Style); 5616 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5617 " aaaaaaaaaaaaaaa,\n" 5618 " aaaaaaaaaaaaaaaaaaaaa,\n" 5619 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5620 Style); 5621 verifyFormat( 5622 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5623 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5624 Style); 5625 verifyFormat( 5626 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5627 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5628 Style); 5629 verifyFormat( 5630 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5631 " aaaaaaaaaaaaaaaaaaaaa(\n" 5632 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5633 " aaaaaaaaaaaaaaaa);", 5634 Style); 5635 verifyFormat( 5636 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5637 " aaaaaaaaaaaaaaaaaaaaa(\n" 5638 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5639 " aaaaaaaaaaaaaaaa);", 5640 Style); 5641 } 5642 5643 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5644 FormatStyle Style = getLLVMStyleWithColumns(40); 5645 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5646 " bbbbbbbbbbbbbbbbbbbbbb);", 5647 Style); 5648 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5649 Style.AlignOperands = false; 5650 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5651 " bbbbbbbbbbbbbbbbbbbbbb);", 5652 Style); 5653 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5654 Style.AlignOperands = true; 5655 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5656 " bbbbbbbbbbbbbbbbbbbbbb);", 5657 Style); 5658 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5659 Style.AlignOperands = false; 5660 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5661 " bbbbbbbbbbbbbbbbbbbbbb);", 5662 Style); 5663 } 5664 5665 TEST_F(FormatTest, BreaksConditionalExpressions) { 5666 verifyFormat( 5667 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5668 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5669 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5670 verifyFormat( 5671 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5672 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5673 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5674 verifyFormat( 5675 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5676 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5677 verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5678 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5679 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5680 verifyFormat( 5681 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5682 " : aaaaaaaaaaaaa);"); 5683 verifyFormat( 5684 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5685 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5686 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5687 " aaaaaaaaaaaaa);"); 5688 verifyFormat( 5689 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5690 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5691 " aaaaaaaaaaaaa);"); 5692 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5693 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5694 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5695 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5696 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5697 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5698 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5699 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5700 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5701 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5702 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5703 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5704 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5705 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5706 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5707 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5708 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5709 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5710 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5711 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5712 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5713 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5714 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5715 " : aaaaaaaaaaaaaaaa;"); 5716 verifyFormat( 5717 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5718 " ? aaaaaaaaaaaaaaa\n" 5719 " : aaaaaaaaaaaaaaa;"); 5720 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5721 " aaaaaaaaa\n" 5722 " ? b\n" 5723 " : c);"); 5724 verifyFormat("return aaaa == bbbb\n" 5725 " // comment\n" 5726 " ? aaaa\n" 5727 " : bbbb;"); 5728 verifyFormat("unsigned Indent =\n" 5729 " format(TheLine.First,\n" 5730 " IndentForLevel[TheLine.Level] >= 0\n" 5731 " ? IndentForLevel[TheLine.Level]\n" 5732 " : TheLine * 2,\n" 5733 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5734 getLLVMStyleWithColumns(60)); 5735 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5736 " ? aaaaaaaaaaaaaaa\n" 5737 " : bbbbbbbbbbbbbbb //\n" 5738 " ? ccccccccccccccc\n" 5739 " : ddddddddddddddd;"); 5740 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5741 " ? aaaaaaaaaaaaaaa\n" 5742 " : (bbbbbbbbbbbbbbb //\n" 5743 " ? ccccccccccccccc\n" 5744 " : ddddddddddddddd);"); 5745 verifyFormat( 5746 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5747 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5748 " aaaaaaaaaaaaaaaaaaaaa +\n" 5749 " aaaaaaaaaaaaaaaaaaaaa\n" 5750 " : aaaaaaaaaa;"); 5751 verifyFormat( 5752 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5753 " : aaaaaaaaaaaaaaaaaaaaaa\n" 5754 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5755 5756 FormatStyle NoBinPacking = getLLVMStyle(); 5757 NoBinPacking.BinPackArguments = false; 5758 verifyFormat( 5759 "void f() {\n" 5760 " g(aaa,\n" 5761 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5762 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5763 " ? aaaaaaaaaaaaaaa\n" 5764 " : aaaaaaaaaaaaaaa);\n" 5765 "}", 5766 NoBinPacking); 5767 verifyFormat( 5768 "void f() {\n" 5769 " g(aaa,\n" 5770 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5771 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5772 " ?: aaaaaaaaaaaaaaa);\n" 5773 "}", 5774 NoBinPacking); 5775 5776 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 5777 " // comment.\n" 5778 " ccccccccccccccccccccccccccccccccccccccc\n" 5779 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5780 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 5781 5782 // Assignments in conditional expressions. Apparently not uncommon :-(. 5783 verifyFormat("return a != b\n" 5784 " // comment\n" 5785 " ? a = b\n" 5786 " : a = b;"); 5787 verifyFormat("return a != b\n" 5788 " // comment\n" 5789 " ? a = a != b\n" 5790 " // comment\n" 5791 " ? a = b\n" 5792 " : a\n" 5793 " : a;\n"); 5794 verifyFormat("return a != b\n" 5795 " // comment\n" 5796 " ? a\n" 5797 " : a = a != b\n" 5798 " // comment\n" 5799 " ? a = b\n" 5800 " : a;"); 5801 } 5802 5803 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 5804 FormatStyle Style = getLLVMStyle(); 5805 Style.BreakBeforeTernaryOperators = false; 5806 Style.ColumnLimit = 70; 5807 verifyFormat( 5808 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5809 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5810 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5811 Style); 5812 verifyFormat( 5813 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5814 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5815 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5816 Style); 5817 verifyFormat( 5818 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5819 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5820 Style); 5821 verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n" 5822 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5823 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5824 Style); 5825 verifyFormat( 5826 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 5827 " aaaaaaaaaaaaa);", 5828 Style); 5829 verifyFormat( 5830 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5831 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5832 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5833 " aaaaaaaaaaaaa);", 5834 Style); 5835 verifyFormat( 5836 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5837 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5838 " aaaaaaaaaaaaa);", 5839 Style); 5840 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5841 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5842 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5843 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5844 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5845 Style); 5846 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5847 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5848 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5849 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5850 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5851 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5852 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5853 Style); 5854 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5855 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 5856 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5857 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5858 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5859 Style); 5860 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5861 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5862 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5863 Style); 5864 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5865 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5866 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5867 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5868 Style); 5869 verifyFormat( 5870 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5871 " aaaaaaaaaaaaaaa :\n" 5872 " aaaaaaaaaaaaaaa;", 5873 Style); 5874 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5875 " aaaaaaaaa ?\n" 5876 " b :\n" 5877 " c);", 5878 Style); 5879 verifyFormat("unsigned Indent =\n" 5880 " format(TheLine.First,\n" 5881 " IndentForLevel[TheLine.Level] >= 0 ?\n" 5882 " IndentForLevel[TheLine.Level] :\n" 5883 " TheLine * 2,\n" 5884 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5885 Style); 5886 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5887 " aaaaaaaaaaaaaaa :\n" 5888 " bbbbbbbbbbbbbbb ? //\n" 5889 " ccccccccccccccc :\n" 5890 " ddddddddddddddd;", 5891 Style); 5892 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5893 " aaaaaaaaaaaaaaa :\n" 5894 " (bbbbbbbbbbbbbbb ? //\n" 5895 " ccccccccccccccc :\n" 5896 " ddddddddddddddd);", 5897 Style); 5898 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5899 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 5900 " ccccccccccccccccccccccccccc;", 5901 Style); 5902 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5903 " aaaaa :\n" 5904 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 5905 Style); 5906 } 5907 5908 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 5909 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 5910 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 5911 verifyFormat("bool a = true, b = false;"); 5912 5913 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5914 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 5915 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 5916 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 5917 verifyFormat( 5918 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 5919 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 5920 " d = e && f;"); 5921 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 5922 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 5923 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5924 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 5925 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 5926 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 5927 5928 FormatStyle Style = getGoogleStyle(); 5929 Style.PointerAlignment = FormatStyle::PAS_Left; 5930 Style.DerivePointerAlignment = false; 5931 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5932 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 5933 " *b = bbbbbbbbbbbbbbbbbbb;", 5934 Style); 5935 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5936 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 5937 Style); 5938 verifyFormat("vector<int*> a, b;", Style); 5939 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 5940 } 5941 5942 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 5943 verifyFormat("arr[foo ? bar : baz];"); 5944 verifyFormat("f()[foo ? bar : baz];"); 5945 verifyFormat("(a + b)[foo ? bar : baz];"); 5946 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 5947 } 5948 5949 TEST_F(FormatTest, AlignsStringLiterals) { 5950 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 5951 " \"short literal\");"); 5952 verifyFormat( 5953 "looooooooooooooooooooooooongFunction(\n" 5954 " \"short literal\"\n" 5955 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 5956 verifyFormat("someFunction(\"Always break between multi-line\"\n" 5957 " \" string literals\",\n" 5958 " and, other, parameters);"); 5959 EXPECT_EQ("fun + \"1243\" /* comment */\n" 5960 " \"5678\";", 5961 format("fun + \"1243\" /* comment */\n" 5962 " \"5678\";", 5963 getLLVMStyleWithColumns(28))); 5964 EXPECT_EQ( 5965 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 5966 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 5967 " \"aaaaaaaaaaaaaaaa\";", 5968 format("aaaaaa =" 5969 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 5970 "aaaaaaaaaaaaaaaaaaaaa\" " 5971 "\"aaaaaaaaaaaaaaaa\";")); 5972 verifyFormat("a = a + \"a\"\n" 5973 " \"a\"\n" 5974 " \"a\";"); 5975 verifyFormat("f(\"a\", \"b\"\n" 5976 " \"c\");"); 5977 5978 verifyFormat( 5979 "#define LL_FORMAT \"ll\"\n" 5980 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 5981 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 5982 5983 verifyFormat("#define A(X) \\\n" 5984 " \"aaaaa\" #X \"bbbbbb\" \\\n" 5985 " \"ccccc\"", 5986 getLLVMStyleWithColumns(23)); 5987 verifyFormat("#define A \"def\"\n" 5988 "f(\"abc\" A \"ghi\"\n" 5989 " \"jkl\");"); 5990 5991 verifyFormat("f(L\"a\"\n" 5992 " L\"b\");"); 5993 verifyFormat("#define A(X) \\\n" 5994 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 5995 " L\"ccccc\"", 5996 getLLVMStyleWithColumns(25)); 5997 5998 verifyFormat("f(@\"a\"\n" 5999 " @\"b\");"); 6000 verifyFormat("NSString s = @\"a\"\n" 6001 " @\"b\"\n" 6002 " @\"c\";"); 6003 verifyFormat("NSString s = @\"a\"\n" 6004 " \"b\"\n" 6005 " \"c\";"); 6006 } 6007 6008 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 6009 FormatStyle Style = getLLVMStyle(); 6010 // No declarations or definitions should be moved to own line. 6011 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 6012 verifyFormat("class A {\n" 6013 " int f() { return 1; }\n" 6014 " int g();\n" 6015 "};\n" 6016 "int f() { return 1; }\n" 6017 "int g();\n", 6018 Style); 6019 6020 // All declarations and definitions should have the return type moved to its 6021 // own 6022 // line. 6023 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 6024 verifyFormat("class E {\n" 6025 " int\n" 6026 " f() {\n" 6027 " return 1;\n" 6028 " }\n" 6029 " int\n" 6030 " g();\n" 6031 "};\n" 6032 "int\n" 6033 "f() {\n" 6034 " return 1;\n" 6035 "}\n" 6036 "int\n" 6037 "g();\n", 6038 Style); 6039 6040 // Top-level definitions, and no kinds of declarations should have the 6041 // return type moved to its own line. 6042 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 6043 verifyFormat("class B {\n" 6044 " int f() { return 1; }\n" 6045 " int g();\n" 6046 "};\n" 6047 "int\n" 6048 "f() {\n" 6049 " return 1;\n" 6050 "}\n" 6051 "int g();\n", 6052 Style); 6053 6054 // Top-level definitions and declarations should have the return type moved 6055 // to its own line. 6056 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 6057 verifyFormat("class C {\n" 6058 " int f() { return 1; }\n" 6059 " int g();\n" 6060 "};\n" 6061 "int\n" 6062 "f() {\n" 6063 " return 1;\n" 6064 "}\n" 6065 "int\n" 6066 "g();\n", 6067 Style); 6068 6069 // All definitions should have the return type moved to its own line, but no 6070 // kinds of declarations. 6071 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 6072 verifyFormat("class D {\n" 6073 " int\n" 6074 " f() {\n" 6075 " return 1;\n" 6076 " }\n" 6077 " int g();\n" 6078 "};\n" 6079 "int\n" 6080 "f() {\n" 6081 " return 1;\n" 6082 "}\n" 6083 "int g();\n", 6084 Style); 6085 verifyFormat("const char *\n" 6086 "f(void) {\n" // Break here. 6087 " return \"\";\n" 6088 "}\n" 6089 "const char *bar(void);\n", // No break here. 6090 Style); 6091 verifyFormat("template <class T>\n" 6092 "T *\n" 6093 "f(T &c) {\n" // Break here. 6094 " return NULL;\n" 6095 "}\n" 6096 "template <class T> T *f(T &c);\n", // No break here. 6097 Style); 6098 verifyFormat("class C {\n" 6099 " int\n" 6100 " operator+() {\n" 6101 " return 1;\n" 6102 " }\n" 6103 " int\n" 6104 " operator()() {\n" 6105 " return 1;\n" 6106 " }\n" 6107 "};\n", 6108 Style); 6109 verifyFormat("void\n" 6110 "A::operator()() {}\n" 6111 "void\n" 6112 "A::operator>>() {}\n" 6113 "void\n" 6114 "A::operator+() {}\n", 6115 Style); 6116 verifyFormat("void *operator new(std::size_t s);", // No break here. 6117 Style); 6118 verifyFormat("void *\n" 6119 "operator new(std::size_t s) {}", 6120 Style); 6121 verifyFormat("void *\n" 6122 "operator delete[](void *ptr) {}", 6123 Style); 6124 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 6125 verifyFormat("const char *\n" 6126 "f(void)\n" // Break here. 6127 "{\n" 6128 " return \"\";\n" 6129 "}\n" 6130 "const char *bar(void);\n", // No break here. 6131 Style); 6132 verifyFormat("template <class T>\n" 6133 "T *\n" // Problem here: no line break 6134 "f(T &c)\n" // Break here. 6135 "{\n" 6136 " return NULL;\n" 6137 "}\n" 6138 "template <class T> T *f(T &c);\n", // No break here. 6139 Style); 6140 verifyFormat("int\n" 6141 "foo(A<bool> a)\n" 6142 "{\n" 6143 " return a;\n" 6144 "}\n", 6145 Style); 6146 verifyFormat("int\n" 6147 "foo(A<8> a)\n" 6148 "{\n" 6149 " return a;\n" 6150 "}\n", 6151 Style); 6152 verifyFormat("int\n" 6153 "foo(A<B<bool>, 8> a)\n" 6154 "{\n" 6155 " return a;\n" 6156 "}\n", 6157 Style); 6158 verifyFormat("int\n" 6159 "foo(A<B<8>, bool> a)\n" 6160 "{\n" 6161 " return a;\n" 6162 "}\n", 6163 Style); 6164 verifyFormat("int\n" 6165 "foo(A<B<bool>, bool> a)\n" 6166 "{\n" 6167 " return a;\n" 6168 "}\n", 6169 Style); 6170 verifyFormat("int\n" 6171 "foo(A<B<8>, 8> a)\n" 6172 "{\n" 6173 " return a;\n" 6174 "}\n", 6175 Style); 6176 6177 Style = getGNUStyle(); 6178 6179 // Test for comments at the end of function declarations. 6180 verifyFormat("void\n" 6181 "foo (int a, /*abc*/ int b) // def\n" 6182 "{\n" 6183 "}\n", 6184 Style); 6185 6186 verifyFormat("void\n" 6187 "foo (int a, /* abc */ int b) /* def */\n" 6188 "{\n" 6189 "}\n", 6190 Style); 6191 6192 // Definitions that should not break after return type 6193 verifyFormat("void foo (int a, int b); // def\n", Style); 6194 verifyFormat("void foo (int a, int b); /* def */\n", Style); 6195 verifyFormat("void foo (int a, int b);\n", Style); 6196 } 6197 6198 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 6199 FormatStyle NoBreak = getLLVMStyle(); 6200 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 6201 FormatStyle Break = getLLVMStyle(); 6202 Break.AlwaysBreakBeforeMultilineStrings = true; 6203 verifyFormat("aaaa = \"bbbb\"\n" 6204 " \"cccc\";", 6205 NoBreak); 6206 verifyFormat("aaaa =\n" 6207 " \"bbbb\"\n" 6208 " \"cccc\";", 6209 Break); 6210 verifyFormat("aaaa(\"bbbb\"\n" 6211 " \"cccc\");", 6212 NoBreak); 6213 verifyFormat("aaaa(\n" 6214 " \"bbbb\"\n" 6215 " \"cccc\");", 6216 Break); 6217 verifyFormat("aaaa(qqq, \"bbbb\"\n" 6218 " \"cccc\");", 6219 NoBreak); 6220 verifyFormat("aaaa(qqq,\n" 6221 " \"bbbb\"\n" 6222 " \"cccc\");", 6223 Break); 6224 verifyFormat("aaaa(qqq,\n" 6225 " L\"bbbb\"\n" 6226 " L\"cccc\");", 6227 Break); 6228 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 6229 " \"bbbb\"));", 6230 Break); 6231 verifyFormat("string s = someFunction(\n" 6232 " \"abc\"\n" 6233 " \"abc\");", 6234 Break); 6235 6236 // As we break before unary operators, breaking right after them is bad. 6237 verifyFormat("string foo = abc ? \"x\"\n" 6238 " \"blah blah blah blah blah blah\"\n" 6239 " : \"y\";", 6240 Break); 6241 6242 // Don't break if there is no column gain. 6243 verifyFormat("f(\"aaaa\"\n" 6244 " \"bbbb\");", 6245 Break); 6246 6247 // Treat literals with escaped newlines like multi-line string literals. 6248 EXPECT_EQ("x = \"a\\\n" 6249 "b\\\n" 6250 "c\";", 6251 format("x = \"a\\\n" 6252 "b\\\n" 6253 "c\";", 6254 NoBreak)); 6255 EXPECT_EQ("xxxx =\n" 6256 " \"a\\\n" 6257 "b\\\n" 6258 "c\";", 6259 format("xxxx = \"a\\\n" 6260 "b\\\n" 6261 "c\";", 6262 Break)); 6263 6264 EXPECT_EQ("NSString *const kString =\n" 6265 " @\"aaaa\"\n" 6266 " @\"bbbb\";", 6267 format("NSString *const kString = @\"aaaa\"\n" 6268 "@\"bbbb\";", 6269 Break)); 6270 6271 Break.ColumnLimit = 0; 6272 verifyFormat("const char *hello = \"hello llvm\";", Break); 6273 } 6274 6275 TEST_F(FormatTest, AlignsPipes) { 6276 verifyFormat( 6277 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6278 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6279 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6280 verifyFormat( 6281 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 6282 " << aaaaaaaaaaaaaaaaaaaa;"); 6283 verifyFormat( 6284 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6285 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6286 verifyFormat( 6287 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 6288 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6289 verifyFormat( 6290 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 6291 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 6292 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 6293 verifyFormat( 6294 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6295 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6296 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6297 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6298 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6299 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6300 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6301 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 6302 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 6303 verifyFormat( 6304 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6305 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6306 verifyFormat( 6307 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 6308 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6309 6310 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 6311 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 6312 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6313 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6314 " aaaaaaaaaaaaaaaaaaaaa)\n" 6315 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6316 verifyFormat("LOG_IF(aaa == //\n" 6317 " bbb)\n" 6318 " << a << b;"); 6319 6320 // But sometimes, breaking before the first "<<" is desirable. 6321 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6322 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 6323 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 6324 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6325 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6326 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 6327 " << BEF << IsTemplate << Description << E->getType();"); 6328 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6329 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6330 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6331 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6332 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6333 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6334 " << aaa;"); 6335 6336 verifyFormat( 6337 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6338 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6339 6340 // Incomplete string literal. 6341 EXPECT_EQ("llvm::errs() << \"\n" 6342 " << a;", 6343 format("llvm::errs() << \"\n<<a;")); 6344 6345 verifyFormat("void f() {\n" 6346 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 6347 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 6348 "}"); 6349 6350 // Handle 'endl'. 6351 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 6352 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6353 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6354 6355 // Handle '\n'. 6356 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 6357 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6358 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 6359 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 6360 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 6361 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 6362 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6363 } 6364 6365 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 6366 verifyFormat("return out << \"somepacket = {\\n\"\n" 6367 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 6368 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 6369 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 6370 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 6371 " << \"}\";"); 6372 6373 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6374 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6375 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 6376 verifyFormat( 6377 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 6378 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 6379 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 6380 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 6381 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 6382 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 6383 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6384 verifyFormat( 6385 "void f() {\n" 6386 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 6387 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 6388 "}"); 6389 6390 // Breaking before the first "<<" is generally not desirable. 6391 verifyFormat( 6392 "llvm::errs()\n" 6393 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6394 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6395 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6396 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6397 getLLVMStyleWithColumns(70)); 6398 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6399 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6400 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6401 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6402 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6403 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6404 getLLVMStyleWithColumns(70)); 6405 6406 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6407 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6408 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6409 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6410 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6411 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 6412 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 6413 " (aaaa + aaaa);", 6414 getLLVMStyleWithColumns(40)); 6415 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 6416 " (aaaaaaa + aaaaa));", 6417 getLLVMStyleWithColumns(40)); 6418 verifyFormat( 6419 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 6420 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 6421 " bbbbbbbbbbbbbbbbbbbbbbb);"); 6422 } 6423 6424 TEST_F(FormatTest, UnderstandsEquals) { 6425 verifyFormat( 6426 "aaaaaaaaaaaaaaaaa =\n" 6427 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6428 verifyFormat( 6429 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6430 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6431 verifyFormat( 6432 "if (a) {\n" 6433 " f();\n" 6434 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6435 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 6436 "}"); 6437 6438 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6439 " 100000000 + 10000000) {\n}"); 6440 } 6441 6442 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 6443 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6444 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 6445 6446 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6447 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 6448 6449 verifyFormat( 6450 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 6451 " Parameter2);"); 6452 6453 verifyFormat( 6454 "ShortObject->shortFunction(\n" 6455 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 6456 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 6457 6458 verifyFormat("loooooooooooooongFunction(\n" 6459 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 6460 6461 verifyFormat( 6462 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 6463 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 6464 6465 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6466 " .WillRepeatedly(Return(SomeValue));"); 6467 verifyFormat("void f() {\n" 6468 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6469 " .Times(2)\n" 6470 " .WillRepeatedly(Return(SomeValue));\n" 6471 "}"); 6472 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 6473 " ccccccccccccccccccccccc);"); 6474 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6475 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6476 " .aaaaa(aaaaa),\n" 6477 " aaaaaaaaaaaaaaaaaaaaa);"); 6478 verifyFormat("void f() {\n" 6479 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6480 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 6481 "}"); 6482 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6483 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6484 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6485 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6486 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6487 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6488 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6489 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6490 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 6491 "}"); 6492 6493 // Here, it is not necessary to wrap at "." or "->". 6494 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 6495 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6496 verifyFormat( 6497 "aaaaaaaaaaa->aaaaaaaaa(\n" 6498 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6499 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 6500 6501 verifyFormat( 6502 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6503 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 6504 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 6505 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6506 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 6507 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6508 6509 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6510 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6511 " .a();"); 6512 6513 FormatStyle NoBinPacking = getLLVMStyle(); 6514 NoBinPacking.BinPackParameters = false; 6515 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6516 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6517 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 6518 " aaaaaaaaaaaaaaaaaaa,\n" 6519 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6520 NoBinPacking); 6521 6522 // If there is a subsequent call, change to hanging indentation. 6523 verifyFormat( 6524 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6525 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 6526 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6527 verifyFormat( 6528 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6529 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 6530 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6531 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6532 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6533 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6534 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6535 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6536 } 6537 6538 TEST_F(FormatTest, WrapsTemplateDeclarations) { 6539 verifyFormat("template <typename T>\n" 6540 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6541 verifyFormat("template <typename T>\n" 6542 "// T should be one of {A, B}.\n" 6543 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6544 verifyFormat( 6545 "template <typename T>\n" 6546 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 6547 verifyFormat("template <typename T>\n" 6548 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 6549 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 6550 verifyFormat( 6551 "template <typename T>\n" 6552 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 6553 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 6554 verifyFormat( 6555 "template <typename T>\n" 6556 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 6557 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 6558 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6559 verifyFormat("template <typename T>\n" 6560 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6561 " int aaaaaaaaaaaaaaaaaaaaaa);"); 6562 verifyFormat( 6563 "template <typename T1, typename T2 = char, typename T3 = char,\n" 6564 " typename T4 = char>\n" 6565 "void f();"); 6566 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 6567 " template <typename> class cccccccccccccccccccccc,\n" 6568 " typename ddddddddddddd>\n" 6569 "class C {};"); 6570 verifyFormat( 6571 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 6572 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6573 6574 verifyFormat("void f() {\n" 6575 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 6576 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 6577 "}"); 6578 6579 verifyFormat("template <typename T> class C {};"); 6580 verifyFormat("template <typename T> void f();"); 6581 verifyFormat("template <typename T> void f() {}"); 6582 verifyFormat( 6583 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6584 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6585 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 6586 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6587 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6588 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 6589 " bbbbbbbbbbbbbbbbbbbbbbbb);", 6590 getLLVMStyleWithColumns(72)); 6591 EXPECT_EQ("static_cast<A< //\n" 6592 " B> *>(\n" 6593 "\n" 6594 ");", 6595 format("static_cast<A<//\n" 6596 " B>*>(\n" 6597 "\n" 6598 " );")); 6599 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6600 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 6601 6602 FormatStyle AlwaysBreak = getLLVMStyle(); 6603 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 6604 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 6605 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 6606 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 6607 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6608 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6609 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 6610 verifyFormat("template <template <typename> class Fooooooo,\n" 6611 " template <typename> class Baaaaaaar>\n" 6612 "struct C {};", 6613 AlwaysBreak); 6614 verifyFormat("template <typename T> // T can be A, B or C.\n" 6615 "struct C {};", 6616 AlwaysBreak); 6617 verifyFormat("template <enum E> class A {\n" 6618 "public:\n" 6619 " E *f();\n" 6620 "};"); 6621 6622 FormatStyle NeverBreak = getLLVMStyle(); 6623 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 6624 verifyFormat("template <typename T> class C {};", NeverBreak); 6625 verifyFormat("template <typename T> void f();", NeverBreak); 6626 verifyFormat("template <typename T> void f() {}", NeverBreak); 6627 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6628 "bbbbbbbbbbbbbbbbbbbb) {}", 6629 NeverBreak); 6630 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6631 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6632 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 6633 NeverBreak); 6634 verifyFormat("template <template <typename> class Fooooooo,\n" 6635 " template <typename> class Baaaaaaar>\n" 6636 "struct C {};", 6637 NeverBreak); 6638 verifyFormat("template <typename T> // T can be A, B or C.\n" 6639 "struct C {};", 6640 NeverBreak); 6641 verifyFormat("template <enum E> class A {\n" 6642 "public:\n" 6643 " E *f();\n" 6644 "};", 6645 NeverBreak); 6646 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 6647 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6648 "bbbbbbbbbbbbbbbbbbbb) {}", 6649 NeverBreak); 6650 } 6651 6652 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 6653 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 6654 Style.ColumnLimit = 60; 6655 EXPECT_EQ("// Baseline - no comments.\n" 6656 "template <\n" 6657 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6658 "void f() {}", 6659 format("// Baseline - no comments.\n" 6660 "template <\n" 6661 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6662 "void f() {}", 6663 Style)); 6664 6665 EXPECT_EQ("template <\n" 6666 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6667 "void f() {}", 6668 format("template <\n" 6669 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6670 "void f() {}", 6671 Style)); 6672 6673 EXPECT_EQ( 6674 "template <\n" 6675 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6676 "void f() {}", 6677 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6678 "void f() {}", 6679 Style)); 6680 6681 EXPECT_EQ( 6682 "template <\n" 6683 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6684 " // multiline\n" 6685 "void f() {}", 6686 format("template <\n" 6687 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6688 " // multiline\n" 6689 "void f() {}", 6690 Style)); 6691 6692 EXPECT_EQ( 6693 "template <typename aaaaaaaaaa<\n" 6694 " bbbbbbbbbbbb>::value> // trailing loooong\n" 6695 "void f() {}", 6696 format( 6697 "template <\n" 6698 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 6699 "void f() {}", 6700 Style)); 6701 } 6702 6703 TEST_F(FormatTest, WrapsTemplateParameters) { 6704 FormatStyle Style = getLLVMStyle(); 6705 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6706 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6707 verifyFormat( 6708 "template <typename... a> struct q {};\n" 6709 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6710 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6711 " y;", 6712 Style); 6713 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6714 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6715 verifyFormat( 6716 "template <typename... a> struct r {};\n" 6717 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6718 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6719 " y;", 6720 Style); 6721 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6722 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6723 verifyFormat("template <typename... a> struct s {};\n" 6724 "extern s<\n" 6725 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6726 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6727 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6728 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6729 " y;", 6730 Style); 6731 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6732 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6733 verifyFormat("template <typename... a> struct t {};\n" 6734 "extern t<\n" 6735 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6736 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6737 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6738 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6739 " y;", 6740 Style); 6741 } 6742 6743 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 6744 verifyFormat( 6745 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6746 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6747 verifyFormat( 6748 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6749 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6750 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6751 6752 // FIXME: Should we have the extra indent after the second break? 6753 verifyFormat( 6754 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6755 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6756 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6757 6758 verifyFormat( 6759 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 6760 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 6761 6762 // Breaking at nested name specifiers is generally not desirable. 6763 verifyFormat( 6764 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6765 " aaaaaaaaaaaaaaaaaaaaaaa);"); 6766 6767 verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 6768 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6769 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6770 " aaaaaaaaaaaaaaaaaaaaa);", 6771 getLLVMStyleWithColumns(74)); 6772 6773 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6774 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6775 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6776 } 6777 6778 TEST_F(FormatTest, UnderstandsTemplateParameters) { 6779 verifyFormat("A<int> a;"); 6780 verifyFormat("A<A<A<int>>> a;"); 6781 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 6782 verifyFormat("bool x = a < 1 || 2 > a;"); 6783 verifyFormat("bool x = 5 < f<int>();"); 6784 verifyFormat("bool x = f<int>() > 5;"); 6785 verifyFormat("bool x = 5 < a<int>::x;"); 6786 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 6787 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 6788 6789 verifyGoogleFormat("A<A<int>> a;"); 6790 verifyGoogleFormat("A<A<A<int>>> a;"); 6791 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 6792 verifyGoogleFormat("A<A<int> > a;"); 6793 verifyGoogleFormat("A<A<A<int> > > a;"); 6794 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 6795 verifyGoogleFormat("A<::A<int>> a;"); 6796 verifyGoogleFormat("A<::A> a;"); 6797 verifyGoogleFormat("A< ::A> a;"); 6798 verifyGoogleFormat("A< ::A<int> > a;"); 6799 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 6800 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 6801 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 6802 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 6803 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 6804 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 6805 6806 verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 6807 6808 // template closer followed by a token that starts with > or = 6809 verifyFormat("bool b = a<1> > 1;"); 6810 verifyFormat("bool b = a<1> >= 1;"); 6811 verifyFormat("int i = a<1> >> 1;"); 6812 FormatStyle Style = getLLVMStyle(); 6813 Style.SpaceBeforeAssignmentOperators = false; 6814 verifyFormat("bool b= a<1> == 1;", Style); 6815 verifyFormat("a<int> = 1;", Style); 6816 verifyFormat("a<int> >>= 1;", Style); 6817 6818 verifyFormat("test >> a >> b;"); 6819 verifyFormat("test << a >> b;"); 6820 6821 verifyFormat("f<int>();"); 6822 verifyFormat("template <typename T> void f() {}"); 6823 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 6824 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 6825 "sizeof(char)>::type>;"); 6826 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 6827 verifyFormat("f(a.operator()<A>());"); 6828 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6829 " .template operator()<A>());", 6830 getLLVMStyleWithColumns(35)); 6831 6832 // Not template parameters. 6833 verifyFormat("return a < b && c > d;"); 6834 verifyFormat("void f() {\n" 6835 " while (a < b && c > d) {\n" 6836 " }\n" 6837 "}"); 6838 verifyFormat("template <typename... Types>\n" 6839 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 6840 6841 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6842 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 6843 getLLVMStyleWithColumns(60)); 6844 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 6845 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 6846 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 6847 } 6848 6849 TEST_F(FormatTest, BitshiftOperatorWidth) { 6850 EXPECT_EQ("int a = 1 << 2; /* foo\n" 6851 " bar */", 6852 format("int a=1<<2; /* foo\n" 6853 " bar */")); 6854 6855 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 6856 " bar */", 6857 format("int b =256>>1 ; /* foo\n" 6858 " bar */")); 6859 } 6860 6861 TEST_F(FormatTest, UnderstandsBinaryOperators) { 6862 verifyFormat("COMPARE(a, ==, b);"); 6863 verifyFormat("auto s = sizeof...(Ts) - 1;"); 6864 } 6865 6866 TEST_F(FormatTest, UnderstandsPointersToMembers) { 6867 verifyFormat("int A::*x;"); 6868 verifyFormat("int (S::*func)(void *);"); 6869 verifyFormat("void f() { int (S::*func)(void *); }"); 6870 verifyFormat("typedef bool *(Class::*Member)() const;"); 6871 verifyFormat("void f() {\n" 6872 " (a->*f)();\n" 6873 " a->*x;\n" 6874 " (a.*f)();\n" 6875 " ((*a).*f)();\n" 6876 " a.*x;\n" 6877 "}"); 6878 verifyFormat("void f() {\n" 6879 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 6880 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 6881 "}"); 6882 verifyFormat( 6883 "(aaaaaaaaaa->*bbbbbbb)(\n" 6884 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6885 FormatStyle Style = getLLVMStyle(); 6886 Style.PointerAlignment = FormatStyle::PAS_Left; 6887 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 6888 } 6889 6890 TEST_F(FormatTest, UnderstandsUnaryOperators) { 6891 verifyFormat("int a = -2;"); 6892 verifyFormat("f(-1, -2, -3);"); 6893 verifyFormat("a[-1] = 5;"); 6894 verifyFormat("int a = 5 + -2;"); 6895 verifyFormat("if (i == -1) {\n}"); 6896 verifyFormat("if (i != -1) {\n}"); 6897 verifyFormat("if (i > -1) {\n}"); 6898 verifyFormat("if (i < -1) {\n}"); 6899 verifyFormat("++(a->f());"); 6900 verifyFormat("--(a->f());"); 6901 verifyFormat("(a->f())++;"); 6902 verifyFormat("a[42]++;"); 6903 verifyFormat("if (!(a->f())) {\n}"); 6904 verifyFormat("if (!+i) {\n}"); 6905 verifyFormat("~&a;"); 6906 6907 verifyFormat("a-- > b;"); 6908 verifyFormat("b ? -a : c;"); 6909 verifyFormat("n * sizeof char16;"); 6910 verifyFormat("n * alignof char16;", getGoogleStyle()); 6911 verifyFormat("sizeof(char);"); 6912 verifyFormat("alignof(char);", getGoogleStyle()); 6913 6914 verifyFormat("return -1;"); 6915 verifyFormat("throw -1;"); 6916 verifyFormat("switch (a) {\n" 6917 "case -1:\n" 6918 " break;\n" 6919 "}"); 6920 verifyFormat("#define X -1"); 6921 verifyFormat("#define X -kConstant"); 6922 6923 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 6924 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 6925 6926 verifyFormat("int a = /* confusing comment */ -1;"); 6927 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 6928 verifyFormat("int a = i /* confusing comment */++;"); 6929 } 6930 6931 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 6932 verifyFormat("if (!aaaaaaaaaa( // break\n" 6933 " aaaaa)) {\n" 6934 "}"); 6935 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 6936 " aaaaa));"); 6937 verifyFormat("*aaa = aaaaaaa( // break\n" 6938 " bbbbbb);"); 6939 } 6940 6941 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 6942 verifyFormat("bool operator<();"); 6943 verifyFormat("bool operator>();"); 6944 verifyFormat("bool operator=();"); 6945 verifyFormat("bool operator==();"); 6946 verifyFormat("bool operator!=();"); 6947 verifyFormat("int operator+();"); 6948 verifyFormat("int operator++();"); 6949 verifyFormat("int operator++(int) volatile noexcept;"); 6950 verifyFormat("bool operator,();"); 6951 verifyFormat("bool operator();"); 6952 verifyFormat("bool operator()();"); 6953 verifyFormat("bool operator[]();"); 6954 verifyFormat("operator bool();"); 6955 verifyFormat("operator int();"); 6956 verifyFormat("operator void *();"); 6957 verifyFormat("operator SomeType<int>();"); 6958 verifyFormat("operator SomeType<int, int>();"); 6959 verifyFormat("operator SomeType<SomeType<int>>();"); 6960 verifyFormat("void *operator new(std::size_t size);"); 6961 verifyFormat("void *operator new[](std::size_t size);"); 6962 verifyFormat("void operator delete(void *ptr);"); 6963 verifyFormat("void operator delete[](void *ptr);"); 6964 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 6965 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 6966 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 6967 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 6968 6969 verifyFormat( 6970 "ostream &operator<<(ostream &OutputStream,\n" 6971 " SomeReallyLongType WithSomeReallyLongValue);"); 6972 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 6973 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 6974 " return left.group < right.group;\n" 6975 "}"); 6976 verifyFormat("SomeType &operator=(const SomeType &S);"); 6977 verifyFormat("f.template operator()<int>();"); 6978 6979 verifyGoogleFormat("operator void*();"); 6980 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 6981 verifyGoogleFormat("operator ::A();"); 6982 6983 verifyFormat("using A::operator+;"); 6984 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 6985 "int i;"); 6986 } 6987 6988 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 6989 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 6990 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 6991 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 6992 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 6993 verifyFormat("Deleted &operator=(const Deleted &) &;"); 6994 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 6995 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 6996 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 6997 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 6998 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 6999 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 7000 verifyFormat("void Fn(T const &) const &;"); 7001 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 7002 verifyFormat("template <typename T>\n" 7003 "void F(T) && = delete;", 7004 getGoogleStyle()); 7005 7006 FormatStyle AlignLeft = getLLVMStyle(); 7007 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 7008 verifyFormat("void A::b() && {}", AlignLeft); 7009 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 7010 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 7011 AlignLeft); 7012 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 7013 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 7014 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 7015 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 7016 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 7017 verifyFormat("auto Function(T) & -> void;", AlignLeft); 7018 verifyFormat("void Fn(T const&) const&;", AlignLeft); 7019 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 7020 7021 FormatStyle Spaces = getLLVMStyle(); 7022 Spaces.SpacesInCStyleCastParentheses = true; 7023 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 7024 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 7025 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 7026 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 7027 7028 Spaces.SpacesInCStyleCastParentheses = false; 7029 Spaces.SpacesInParentheses = true; 7030 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 7031 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", 7032 Spaces); 7033 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 7034 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 7035 7036 FormatStyle BreakTemplate = getLLVMStyle(); 7037 BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 7038 7039 verifyFormat("struct f {\n" 7040 " template <class T>\n" 7041 " int &foo(const std::string &str) &noexcept {}\n" 7042 "};", 7043 BreakTemplate); 7044 7045 verifyFormat("struct f {\n" 7046 " template <class T>\n" 7047 " int &foo(const std::string &str) &&noexcept {}\n" 7048 "};", 7049 BreakTemplate); 7050 7051 verifyFormat("struct f {\n" 7052 " template <class T>\n" 7053 " int &foo(const std::string &str) const &noexcept {}\n" 7054 "};", 7055 BreakTemplate); 7056 7057 verifyFormat("struct f {\n" 7058 " template <class T>\n" 7059 " int &foo(const std::string &str) const &noexcept {}\n" 7060 "};", 7061 BreakTemplate); 7062 7063 verifyFormat("struct f {\n" 7064 " template <class T>\n" 7065 " auto foo(const std::string &str) &&noexcept -> int & {}\n" 7066 "};", 7067 BreakTemplate); 7068 7069 FormatStyle AlignLeftBreakTemplate = getLLVMStyle(); 7070 AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations = 7071 FormatStyle::BTDS_Yes; 7072 AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left; 7073 7074 verifyFormat("struct f {\n" 7075 " template <class T>\n" 7076 " int& foo(const std::string& str) & noexcept {}\n" 7077 "};", 7078 AlignLeftBreakTemplate); 7079 7080 verifyFormat("struct f {\n" 7081 " template <class T>\n" 7082 " int& foo(const std::string& str) && noexcept {}\n" 7083 "};", 7084 AlignLeftBreakTemplate); 7085 7086 verifyFormat("struct f {\n" 7087 " template <class T>\n" 7088 " int& foo(const std::string& str) const& noexcept {}\n" 7089 "};", 7090 AlignLeftBreakTemplate); 7091 7092 verifyFormat("struct f {\n" 7093 " template <class T>\n" 7094 " int& foo(const std::string& str) const&& noexcept {}\n" 7095 "};", 7096 AlignLeftBreakTemplate); 7097 7098 verifyFormat("struct f {\n" 7099 " template <class T>\n" 7100 " auto foo(const std::string& str) && noexcept -> int& {}\n" 7101 "};", 7102 AlignLeftBreakTemplate); 7103 7104 // The `&` in `Type&` should not be confused with a trailing `&` of 7105 // DEPRECATED(reason) member function. 7106 verifyFormat("struct f {\n" 7107 " template <class T>\n" 7108 " DEPRECATED(reason)\n" 7109 " Type &foo(arguments) {}\n" 7110 "};", 7111 BreakTemplate); 7112 7113 verifyFormat("struct f {\n" 7114 " template <class T>\n" 7115 " DEPRECATED(reason)\n" 7116 " Type& foo(arguments) {}\n" 7117 "};", 7118 AlignLeftBreakTemplate); 7119 7120 verifyFormat("void (*foopt)(int) = &func;"); 7121 } 7122 7123 TEST_F(FormatTest, UnderstandsNewAndDelete) { 7124 verifyFormat("void f() {\n" 7125 " A *a = new A;\n" 7126 " A *a = new (placement) A;\n" 7127 " delete a;\n" 7128 " delete (A *)a;\n" 7129 "}"); 7130 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7131 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7132 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7133 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7134 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7135 verifyFormat("delete[] h->p;"); 7136 } 7137 7138 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 7139 verifyFormat("int *f(int *a) {}"); 7140 verifyFormat("int main(int argc, char **argv) {}"); 7141 verifyFormat("Test::Test(int b) : a(b * b) {}"); 7142 verifyIndependentOfContext("f(a, *a);"); 7143 verifyFormat("void g() { f(*a); }"); 7144 verifyIndependentOfContext("int a = b * 10;"); 7145 verifyIndependentOfContext("int a = 10 * b;"); 7146 verifyIndependentOfContext("int a = b * c;"); 7147 verifyIndependentOfContext("int a += b * c;"); 7148 verifyIndependentOfContext("int a -= b * c;"); 7149 verifyIndependentOfContext("int a *= b * c;"); 7150 verifyIndependentOfContext("int a /= b * c;"); 7151 verifyIndependentOfContext("int a = *b;"); 7152 verifyIndependentOfContext("int a = *b * c;"); 7153 verifyIndependentOfContext("int a = b * *c;"); 7154 verifyIndependentOfContext("int a = b * (10);"); 7155 verifyIndependentOfContext("S << b * (10);"); 7156 verifyIndependentOfContext("return 10 * b;"); 7157 verifyIndependentOfContext("return *b * *c;"); 7158 verifyIndependentOfContext("return a & ~b;"); 7159 verifyIndependentOfContext("f(b ? *c : *d);"); 7160 verifyIndependentOfContext("int a = b ? *c : *d;"); 7161 verifyIndependentOfContext("*b = a;"); 7162 verifyIndependentOfContext("a * ~b;"); 7163 verifyIndependentOfContext("a * !b;"); 7164 verifyIndependentOfContext("a * +b;"); 7165 verifyIndependentOfContext("a * -b;"); 7166 verifyIndependentOfContext("a * ++b;"); 7167 verifyIndependentOfContext("a * --b;"); 7168 verifyIndependentOfContext("a[4] * b;"); 7169 verifyIndependentOfContext("a[a * a] = 1;"); 7170 verifyIndependentOfContext("f() * b;"); 7171 verifyIndependentOfContext("a * [self dostuff];"); 7172 verifyIndependentOfContext("int x = a * (a + b);"); 7173 verifyIndependentOfContext("(a *)(a + b);"); 7174 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 7175 verifyIndependentOfContext("int *pa = (int *)&a;"); 7176 verifyIndependentOfContext("return sizeof(int **);"); 7177 verifyIndependentOfContext("return sizeof(int ******);"); 7178 verifyIndependentOfContext("return (int **&)a;"); 7179 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 7180 verifyFormat("void f(Type (*parameter)[10]) {}"); 7181 verifyFormat("void f(Type (¶meter)[10]) {}"); 7182 verifyGoogleFormat("return sizeof(int**);"); 7183 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 7184 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 7185 verifyFormat("auto a = [](int **&, int ***) {};"); 7186 verifyFormat("auto PointerBinding = [](const char *S) {};"); 7187 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 7188 verifyFormat("[](const decltype(*a) &value) {}"); 7189 verifyFormat("decltype(a * b) F();"); 7190 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 7191 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 7192 verifyIndependentOfContext("typedef void (*f)(int *a);"); 7193 verifyIndependentOfContext("int i{a * b};"); 7194 verifyIndependentOfContext("aaa && aaa->f();"); 7195 verifyIndependentOfContext("int x = ~*p;"); 7196 verifyFormat("Constructor() : a(a), area(width * height) {}"); 7197 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 7198 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 7199 verifyFormat("void f() { f(a, c * d); }"); 7200 verifyFormat("void f() { f(new a(), c * d); }"); 7201 verifyFormat("void f(const MyOverride &override);"); 7202 verifyFormat("void f(const MyFinal &final);"); 7203 verifyIndependentOfContext("bool a = f() && override.f();"); 7204 verifyIndependentOfContext("bool a = f() && final.f();"); 7205 7206 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 7207 7208 verifyIndependentOfContext("A<int *> a;"); 7209 verifyIndependentOfContext("A<int **> a;"); 7210 verifyIndependentOfContext("A<int *, int *> a;"); 7211 verifyIndependentOfContext("A<int *[]> a;"); 7212 verifyIndependentOfContext( 7213 "const char *const p = reinterpret_cast<const char *const>(q);"); 7214 verifyIndependentOfContext("A<int **, int **> a;"); 7215 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 7216 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 7217 verifyFormat("for (; a && b;) {\n}"); 7218 verifyFormat("bool foo = true && [] { return false; }();"); 7219 7220 verifyFormat( 7221 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7222 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7223 7224 verifyGoogleFormat("int const* a = &b;"); 7225 verifyGoogleFormat("**outparam = 1;"); 7226 verifyGoogleFormat("*outparam = a * b;"); 7227 verifyGoogleFormat("int main(int argc, char** argv) {}"); 7228 verifyGoogleFormat("A<int*> a;"); 7229 verifyGoogleFormat("A<int**> a;"); 7230 verifyGoogleFormat("A<int*, int*> a;"); 7231 verifyGoogleFormat("A<int**, int**> a;"); 7232 verifyGoogleFormat("f(b ? *c : *d);"); 7233 verifyGoogleFormat("int a = b ? *c : *d;"); 7234 verifyGoogleFormat("Type* t = **x;"); 7235 verifyGoogleFormat("Type* t = *++*x;"); 7236 verifyGoogleFormat("*++*x;"); 7237 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 7238 verifyGoogleFormat("Type* t = x++ * y;"); 7239 verifyGoogleFormat( 7240 "const char* const p = reinterpret_cast<const char* const>(q);"); 7241 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 7242 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 7243 verifyGoogleFormat("template <typename T>\n" 7244 "void f(int i = 0, SomeType** temps = NULL);"); 7245 7246 FormatStyle Left = getLLVMStyle(); 7247 Left.PointerAlignment = FormatStyle::PAS_Left; 7248 verifyFormat("x = *a(x) = *a(y);", Left); 7249 verifyFormat("for (;; *a = b) {\n}", Left); 7250 verifyFormat("return *this += 1;", Left); 7251 verifyFormat("throw *x;", Left); 7252 verifyFormat("delete *x;", Left); 7253 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 7254 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 7255 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 7256 7257 verifyIndependentOfContext("a = *(x + y);"); 7258 verifyIndependentOfContext("a = &(x + y);"); 7259 verifyIndependentOfContext("*(x + y).call();"); 7260 verifyIndependentOfContext("&(x + y)->call();"); 7261 verifyFormat("void f() { &(*I).first; }"); 7262 7263 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 7264 verifyFormat( 7265 "int *MyValues = {\n" 7266 " *A, // Operator detection might be confused by the '{'\n" 7267 " *BB // Operator detection might be confused by previous comment\n" 7268 "};"); 7269 7270 verifyIndependentOfContext("if (int *a = &b)"); 7271 verifyIndependentOfContext("if (int &a = *b)"); 7272 verifyIndependentOfContext("if (a & b[i])"); 7273 verifyIndependentOfContext("if constexpr (a & b[i])"); 7274 verifyIndependentOfContext("if CONSTEXPR (a & b[i])"); 7275 verifyIndependentOfContext("if (a * (b * c))"); 7276 verifyIndependentOfContext("if constexpr (a * (b * c))"); 7277 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))"); 7278 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 7279 verifyIndependentOfContext("if (*b[i])"); 7280 verifyIndependentOfContext("if (int *a = (&b))"); 7281 verifyIndependentOfContext("while (int *a = &b)"); 7282 verifyIndependentOfContext("while (a * (b * c))"); 7283 verifyIndependentOfContext("size = sizeof *a;"); 7284 verifyIndependentOfContext("if (a && (b = c))"); 7285 verifyFormat("void f() {\n" 7286 " for (const int &v : Values) {\n" 7287 " }\n" 7288 "}"); 7289 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 7290 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 7291 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 7292 7293 verifyFormat("#define A (!a * b)"); 7294 verifyFormat("#define MACRO \\\n" 7295 " int *i = a * b; \\\n" 7296 " void f(a *b);", 7297 getLLVMStyleWithColumns(19)); 7298 7299 verifyIndependentOfContext("A = new SomeType *[Length];"); 7300 verifyIndependentOfContext("A = new SomeType *[Length]();"); 7301 verifyIndependentOfContext("T **t = new T *;"); 7302 verifyIndependentOfContext("T **t = new T *();"); 7303 verifyGoogleFormat("A = new SomeType*[Length]();"); 7304 verifyGoogleFormat("A = new SomeType*[Length];"); 7305 verifyGoogleFormat("T** t = new T*;"); 7306 verifyGoogleFormat("T** t = new T*();"); 7307 7308 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 7309 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 7310 verifyFormat("template <bool a, bool b> " 7311 "typename t::if<x && y>::type f() {}"); 7312 verifyFormat("template <int *y> f() {}"); 7313 verifyFormat("vector<int *> v;"); 7314 verifyFormat("vector<int *const> v;"); 7315 verifyFormat("vector<int *const **const *> v;"); 7316 verifyFormat("vector<int *volatile> v;"); 7317 verifyFormat("vector<a * b> v;"); 7318 verifyFormat("foo<b && false>();"); 7319 verifyFormat("foo<b & 1>();"); 7320 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 7321 verifyFormat( 7322 "template <class T, class = typename std::enable_if<\n" 7323 " std::is_integral<T>::value &&\n" 7324 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 7325 "void F();", 7326 getLLVMStyleWithColumns(70)); 7327 verifyFormat("template <class T,\n" 7328 " class = typename std::enable_if<\n" 7329 " std::is_integral<T>::value &&\n" 7330 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 7331 " class U>\n" 7332 "void F();", 7333 getLLVMStyleWithColumns(70)); 7334 verifyFormat( 7335 "template <class T,\n" 7336 " class = typename ::std::enable_if<\n" 7337 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 7338 "void F();", 7339 getGoogleStyleWithColumns(68)); 7340 7341 verifyIndependentOfContext("MACRO(int *i);"); 7342 verifyIndependentOfContext("MACRO(auto *a);"); 7343 verifyIndependentOfContext("MACRO(const A *a);"); 7344 verifyIndependentOfContext("MACRO(A *const a);"); 7345 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 7346 verifyFormat("void f() { f(float{1}, a * a); }"); 7347 // FIXME: Is there a way to make this work? 7348 // verifyIndependentOfContext("MACRO(A *a);"); 7349 7350 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 7351 verifyFormat("return options != nullptr && operator==(*options);"); 7352 7353 EXPECT_EQ("#define OP(x) \\\n" 7354 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7355 " return s << a.DebugString(); \\\n" 7356 " }", 7357 format("#define OP(x) \\\n" 7358 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7359 " return s << a.DebugString(); \\\n" 7360 " }", 7361 getLLVMStyleWithColumns(50))); 7362 7363 // FIXME: We cannot handle this case yet; we might be able to figure out that 7364 // foo<x> d > v; doesn't make sense. 7365 verifyFormat("foo<a<b && c> d> v;"); 7366 7367 FormatStyle PointerMiddle = getLLVMStyle(); 7368 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7369 verifyFormat("delete *x;", PointerMiddle); 7370 verifyFormat("int * x;", PointerMiddle); 7371 verifyFormat("int *[] x;", PointerMiddle); 7372 verifyFormat("template <int * y> f() {}", PointerMiddle); 7373 verifyFormat("int * f(int * a) {}", PointerMiddle); 7374 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7375 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7376 verifyFormat("A<int *> a;", PointerMiddle); 7377 verifyFormat("A<int **> a;", PointerMiddle); 7378 verifyFormat("A<int *, int *> a;", PointerMiddle); 7379 verifyFormat("A<int *[]> a;", PointerMiddle); 7380 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7381 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7382 verifyFormat("T ** t = new T *;", PointerMiddle); 7383 7384 // Member function reference qualifiers aren't binary operators. 7385 verifyFormat("string // break\n" 7386 "operator()() & {}"); 7387 verifyFormat("string // break\n" 7388 "operator()() && {}"); 7389 verifyGoogleFormat("template <typename T>\n" 7390 "auto x() & -> int {}"); 7391 } 7392 7393 TEST_F(FormatTest, UnderstandsAttributes) { 7394 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7395 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7396 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7397 FormatStyle AfterType = getLLVMStyle(); 7398 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7399 verifyFormat("__attribute__((nodebug)) void\n" 7400 "foo() {}\n", 7401 AfterType); 7402 } 7403 7404 TEST_F(FormatTest, UnderstandsSquareAttributes) { 7405 verifyFormat("SomeType s [[unused]] (InitValue);"); 7406 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 7407 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 7408 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 7409 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 7410 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7411 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7412 7413 // Make sure we do not mistake attributes for array subscripts. 7414 verifyFormat("int a() {}\n" 7415 "[[unused]] int b() {}\n"); 7416 verifyFormat("NSArray *arr;\n" 7417 "arr[[Foo() bar]];"); 7418 7419 // On the other hand, we still need to correctly find array subscripts. 7420 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 7421 7422 // Make sure that we do not mistake Objective-C method inside array literals 7423 // as attributes, even if those method names are also keywords. 7424 verifyFormat("@[ [foo bar] ];"); 7425 verifyFormat("@[ [NSArray class] ];"); 7426 verifyFormat("@[ [foo enum] ];"); 7427 7428 // Make sure we do not parse attributes as lambda introducers. 7429 FormatStyle MultiLineFunctions = getLLVMStyle(); 7430 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7431 verifyFormat("[[unused]] int b() {\n" 7432 " return 42;\n" 7433 "}\n", 7434 MultiLineFunctions); 7435 } 7436 7437 TEST_F(FormatTest, UnderstandsEllipsis) { 7438 verifyFormat("int printf(const char *fmt, ...);"); 7439 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 7440 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 7441 7442 FormatStyle PointersLeft = getLLVMStyle(); 7443 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 7444 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 7445 } 7446 7447 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 7448 EXPECT_EQ("int *a;\n" 7449 "int *a;\n" 7450 "int *a;", 7451 format("int *a;\n" 7452 "int* a;\n" 7453 "int *a;", 7454 getGoogleStyle())); 7455 EXPECT_EQ("int* a;\n" 7456 "int* a;\n" 7457 "int* a;", 7458 format("int* a;\n" 7459 "int* a;\n" 7460 "int *a;", 7461 getGoogleStyle())); 7462 EXPECT_EQ("int *a;\n" 7463 "int *a;\n" 7464 "int *a;", 7465 format("int *a;\n" 7466 "int * a;\n" 7467 "int * a;", 7468 getGoogleStyle())); 7469 EXPECT_EQ("auto x = [] {\n" 7470 " int *a;\n" 7471 " int *a;\n" 7472 " int *a;\n" 7473 "};", 7474 format("auto x=[]{int *a;\n" 7475 "int * a;\n" 7476 "int * a;};", 7477 getGoogleStyle())); 7478 } 7479 7480 TEST_F(FormatTest, UnderstandsRvalueReferences) { 7481 verifyFormat("int f(int &&a) {}"); 7482 verifyFormat("int f(int a, char &&b) {}"); 7483 verifyFormat("void f() { int &&a = b; }"); 7484 verifyGoogleFormat("int f(int a, char&& b) {}"); 7485 verifyGoogleFormat("void f() { int&& a = b; }"); 7486 7487 verifyIndependentOfContext("A<int &&> a;"); 7488 verifyIndependentOfContext("A<int &&, int &&> a;"); 7489 verifyGoogleFormat("A<int&&> a;"); 7490 verifyGoogleFormat("A<int&&, int&&> a;"); 7491 7492 // Not rvalue references: 7493 verifyFormat("template <bool B, bool C> class A {\n" 7494 " static_assert(B && C, \"Something is wrong\");\n" 7495 "};"); 7496 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 7497 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 7498 verifyFormat("#define A(a, b) (a && b)"); 7499 } 7500 7501 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 7502 verifyFormat("void f() {\n" 7503 " x[aaaaaaaaa -\n" 7504 " b] = 23;\n" 7505 "}", 7506 getLLVMStyleWithColumns(15)); 7507 } 7508 7509 TEST_F(FormatTest, FormatsCasts) { 7510 verifyFormat("Type *A = static_cast<Type *>(P);"); 7511 verifyFormat("Type *A = (Type *)P;"); 7512 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7513 verifyFormat("int a = (int)(2.0f);"); 7514 verifyFormat("int a = (int)2.0f;"); 7515 verifyFormat("x[(int32)y];"); 7516 verifyFormat("x = (int32)y;"); 7517 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7518 verifyFormat("int a = (int)*b;"); 7519 verifyFormat("int a = (int)2.0f;"); 7520 verifyFormat("int a = (int)~0;"); 7521 verifyFormat("int a = (int)++a;"); 7522 verifyFormat("int a = (int)sizeof(int);"); 7523 verifyFormat("int a = (int)+2;"); 7524 verifyFormat("my_int a = (my_int)2.0f;"); 7525 verifyFormat("my_int a = (my_int)sizeof(int);"); 7526 verifyFormat("return (my_int)aaa;"); 7527 verifyFormat("#define x ((int)-1)"); 7528 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7529 verifyFormat("#define p(q) ((int *)&q)"); 7530 verifyFormat("fn(a)(b) + 1;"); 7531 7532 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7533 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7534 verifyFormat("my_int a = (my_int)~0;"); 7535 verifyFormat("my_int a = (my_int)++a;"); 7536 verifyFormat("my_int a = (my_int)-2;"); 7537 verifyFormat("my_int a = (my_int)1;"); 7538 verifyFormat("my_int a = (my_int *)1;"); 7539 verifyFormat("my_int a = (const my_int)-1;"); 7540 verifyFormat("my_int a = (const my_int *)-1;"); 7541 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7542 verifyFormat("my_int a = (ns::my_int)-2;"); 7543 verifyFormat("case (my_int)ONE:"); 7544 verifyFormat("auto x = (X)this;"); 7545 // Casts in Obj-C style calls used to not be recognized as such. 7546 verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle()); 7547 7548 // FIXME: single value wrapped with paren will be treated as cast. 7549 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7550 7551 verifyFormat("{ (void)F; }"); 7552 7553 // Don't break after a cast's 7554 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7555 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7556 " bbbbbbbbbbbbbbbbbbbbbb);"); 7557 7558 // These are not casts. 7559 verifyFormat("void f(int *) {}"); 7560 verifyFormat("f(foo)->b;"); 7561 verifyFormat("f(foo).b;"); 7562 verifyFormat("f(foo)(b);"); 7563 verifyFormat("f(foo)[b];"); 7564 verifyFormat("[](foo) { return 4; }(bar);"); 7565 verifyFormat("(*funptr)(foo)[4];"); 7566 verifyFormat("funptrs[4](foo)[4];"); 7567 verifyFormat("void f(int *);"); 7568 verifyFormat("void f(int *) = 0;"); 7569 verifyFormat("void f(SmallVector<int>) {}"); 7570 verifyFormat("void f(SmallVector<int>);"); 7571 verifyFormat("void f(SmallVector<int>) = 0;"); 7572 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7573 verifyFormat("int a = sizeof(int) * b;"); 7574 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7575 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7576 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7577 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7578 7579 // These are not casts, but at some point were confused with casts. 7580 verifyFormat("virtual void foo(int *) override;"); 7581 verifyFormat("virtual void foo(char &) const;"); 7582 verifyFormat("virtual void foo(int *a, char *) const;"); 7583 verifyFormat("int a = sizeof(int *) + b;"); 7584 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7585 verifyFormat("bool b = f(g<int>) && c;"); 7586 verifyFormat("typedef void (*f)(int i) func;"); 7587 verifyFormat("void operator++(int) noexcept;"); 7588 verifyFormat("void operator++(int &) noexcept;"); 7589 verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t " 7590 "&) noexcept;"); 7591 verifyFormat( 7592 "void operator delete(std::size_t, const std::nothrow_t &) noexcept;"); 7593 verifyFormat("void operator delete(const std::nothrow_t &) noexcept;"); 7594 verifyFormat("void operator delete(std::nothrow_t &) noexcept;"); 7595 verifyFormat("void operator delete(nothrow_t &) noexcept;"); 7596 verifyFormat("void operator delete(foo &) noexcept;"); 7597 verifyFormat("void operator delete(foo) noexcept;"); 7598 verifyFormat("void operator delete(int) noexcept;"); 7599 verifyFormat("void operator delete(int &) noexcept;"); 7600 verifyFormat("void operator delete(int &) volatile noexcept;"); 7601 verifyFormat("void operator delete(int &) const"); 7602 verifyFormat("void operator delete(int &) = default"); 7603 verifyFormat("void operator delete(int &) = delete"); 7604 verifyFormat("void operator delete(int &) [[noreturn]]"); 7605 verifyFormat("void operator delete(int &) throw();"); 7606 verifyFormat("void operator delete(int &) throw(int);"); 7607 verifyFormat("auto operator delete(int &) -> int;"); 7608 verifyFormat("auto operator delete(int &) override"); 7609 verifyFormat("auto operator delete(int &) final"); 7610 7611 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7612 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7613 // FIXME: The indentation here is not ideal. 7614 verifyFormat( 7615 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7616 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7617 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7618 } 7619 7620 TEST_F(FormatTest, FormatsFunctionTypes) { 7621 verifyFormat("A<bool()> a;"); 7622 verifyFormat("A<SomeType()> a;"); 7623 verifyFormat("A<void (*)(int, std::string)> a;"); 7624 verifyFormat("A<void *(int)>;"); 7625 verifyFormat("void *(*a)(int *, SomeType *);"); 7626 verifyFormat("int (*func)(void *);"); 7627 verifyFormat("void f() { int (*func)(void *); }"); 7628 verifyFormat("template <class CallbackClass>\n" 7629 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7630 7631 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7632 verifyGoogleFormat("void* (*a)(int);"); 7633 verifyGoogleFormat( 7634 "template <class CallbackClass>\n" 7635 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7636 7637 // Other constructs can look somewhat like function types: 7638 verifyFormat("A<sizeof(*x)> a;"); 7639 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7640 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7641 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7642 verifyFormat("int x = f(&h)();"); 7643 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7644 verifyFormat("std::function<\n" 7645 " LooooooooooongTemplatedType<\n" 7646 " SomeType>*(\n" 7647 " LooooooooooooooooongType type)>\n" 7648 " function;", 7649 getGoogleStyleWithColumns(40)); 7650 } 7651 7652 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7653 verifyFormat("A (*foo_)[6];"); 7654 verifyFormat("vector<int> (*foo_)[6];"); 7655 } 7656 7657 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7658 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7659 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7660 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7661 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7662 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7663 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7664 7665 // Different ways of ()-initializiation. 7666 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7667 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7668 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7669 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7670 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7671 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7672 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7673 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7674 7675 // Lambdas should not confuse the variable declaration heuristic. 7676 verifyFormat("LooooooooooooooooongType\n" 7677 " variable(nullptr, [](A *a) {});", 7678 getLLVMStyleWithColumns(40)); 7679 } 7680 7681 TEST_F(FormatTest, BreaksLongDeclarations) { 7682 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7683 " AnotherNameForTheLongType;"); 7684 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7685 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7686 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7687 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7688 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7689 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7690 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7691 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7692 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7693 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7694 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7695 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7696 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7697 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7698 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7699 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7700 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7701 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7702 FormatStyle Indented = getLLVMStyle(); 7703 Indented.IndentWrappedFunctionNames = true; 7704 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7705 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7706 Indented); 7707 verifyFormat( 7708 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7709 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7710 Indented); 7711 verifyFormat( 7712 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7713 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7714 Indented); 7715 verifyFormat( 7716 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7717 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7718 Indented); 7719 7720 // FIXME: Without the comment, this breaks after "(". 7721 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7722 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7723 getGoogleStyle()); 7724 7725 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7726 " int LoooooooooooooooooooongParam2) {}"); 7727 verifyFormat( 7728 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7729 " SourceLocation L, IdentifierIn *II,\n" 7730 " Type *T) {}"); 7731 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7732 "ReallyReaaallyLongFunctionName(\n" 7733 " const std::string &SomeParameter,\n" 7734 " const SomeType<string, SomeOtherTemplateParameter>\n" 7735 " &ReallyReallyLongParameterName,\n" 7736 " const SomeType<string, SomeOtherTemplateParameter>\n" 7737 " &AnotherLongParameterName) {}"); 7738 verifyFormat("template <typename A>\n" 7739 "SomeLoooooooooooooooooooooongType<\n" 7740 " typename some_namespace::SomeOtherType<A>::Type>\n" 7741 "Function() {}"); 7742 7743 verifyGoogleFormat( 7744 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7745 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7746 verifyGoogleFormat( 7747 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7748 " SourceLocation L) {}"); 7749 verifyGoogleFormat( 7750 "some_namespace::LongReturnType\n" 7751 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7752 " int first_long_parameter, int second_parameter) {}"); 7753 7754 verifyGoogleFormat("template <typename T>\n" 7755 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7756 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7757 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7758 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7759 7760 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7761 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7762 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7763 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7764 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7765 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 7766 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7767 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 7768 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 7769 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7770 7771 verifyFormat("template <typename T> // Templates on own line.\n" 7772 "static int // Some comment.\n" 7773 "MyFunction(int a);", 7774 getLLVMStyle()); 7775 } 7776 7777 TEST_F(FormatTest, FormatsArrays) { 7778 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7779 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 7780 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 7781 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 7782 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 7783 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 7784 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7785 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7786 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7787 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 7788 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7789 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7790 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7791 verifyFormat( 7792 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 7793 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7794 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 7795 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 7796 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7797 7798 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 7799 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 7800 verifyFormat( 7801 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 7802 " .aaaaaaa[0]\n" 7803 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7804 verifyFormat("a[::b::c];"); 7805 7806 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 7807 7808 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 7809 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 7810 } 7811 7812 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 7813 verifyFormat("(a)->b();"); 7814 verifyFormat("--a;"); 7815 } 7816 7817 TEST_F(FormatTest, HandlesIncludeDirectives) { 7818 verifyFormat("#include <string>\n" 7819 "#include <a/b/c.h>\n" 7820 "#include \"a/b/string\"\n" 7821 "#include \"string.h\"\n" 7822 "#include \"string.h\"\n" 7823 "#include <a-a>\n" 7824 "#include < path with space >\n" 7825 "#include_next <test.h>" 7826 "#include \"abc.h\" // this is included for ABC\n" 7827 "#include \"some long include\" // with a comment\n" 7828 "#include \"some very long include path\"\n" 7829 "#include <some/very/long/include/path>\n", 7830 getLLVMStyleWithColumns(35)); 7831 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 7832 EXPECT_EQ("#include <a>", format("#include<a>")); 7833 7834 verifyFormat("#import <string>"); 7835 verifyFormat("#import <a/b/c.h>"); 7836 verifyFormat("#import \"a/b/string\""); 7837 verifyFormat("#import \"string.h\""); 7838 verifyFormat("#import \"string.h\""); 7839 verifyFormat("#if __has_include(<strstream>)\n" 7840 "#include <strstream>\n" 7841 "#endif"); 7842 7843 verifyFormat("#define MY_IMPORT <a/b>"); 7844 7845 verifyFormat("#if __has_include(<a/b>)"); 7846 verifyFormat("#if __has_include_next(<a/b>)"); 7847 verifyFormat("#define F __has_include(<a/b>)"); 7848 verifyFormat("#define F __has_include_next(<a/b>)"); 7849 7850 // Protocol buffer definition or missing "#". 7851 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 7852 getLLVMStyleWithColumns(30)); 7853 7854 FormatStyle Style = getLLVMStyle(); 7855 Style.AlwaysBreakBeforeMultilineStrings = true; 7856 Style.ColumnLimit = 0; 7857 verifyFormat("#import \"abc.h\"", Style); 7858 7859 // But 'import' might also be a regular C++ namespace. 7860 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7861 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7862 } 7863 7864 //===----------------------------------------------------------------------===// 7865 // Error recovery tests. 7866 //===----------------------------------------------------------------------===// 7867 7868 TEST_F(FormatTest, IncompleteParameterLists) { 7869 FormatStyle NoBinPacking = getLLVMStyle(); 7870 NoBinPacking.BinPackParameters = false; 7871 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 7872 " double *min_x,\n" 7873 " double *max_x,\n" 7874 " double *min_y,\n" 7875 " double *max_y,\n" 7876 " double *min_z,\n" 7877 " double *max_z, ) {}", 7878 NoBinPacking); 7879 } 7880 7881 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 7882 verifyFormat("void f() { return; }\n42"); 7883 verifyFormat("void f() {\n" 7884 " if (0)\n" 7885 " return;\n" 7886 "}\n" 7887 "42"); 7888 verifyFormat("void f() { return }\n42"); 7889 verifyFormat("void f() {\n" 7890 " if (0)\n" 7891 " return\n" 7892 "}\n" 7893 "42"); 7894 } 7895 7896 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 7897 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 7898 EXPECT_EQ("void f() {\n" 7899 " if (a)\n" 7900 " return\n" 7901 "}", 7902 format("void f ( ) { if ( a ) return }")); 7903 EXPECT_EQ("namespace N {\n" 7904 "void f()\n" 7905 "}", 7906 format("namespace N { void f() }")); 7907 EXPECT_EQ("namespace N {\n" 7908 "void f() {}\n" 7909 "void g()\n" 7910 "} // namespace N", 7911 format("namespace N { void f( ) { } void g( ) }")); 7912 } 7913 7914 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 7915 verifyFormat("int aaaaaaaa =\n" 7916 " // Overlylongcomment\n" 7917 " b;", 7918 getLLVMStyleWithColumns(20)); 7919 verifyFormat("function(\n" 7920 " ShortArgument,\n" 7921 " LoooooooooooongArgument);\n", 7922 getLLVMStyleWithColumns(20)); 7923 } 7924 7925 TEST_F(FormatTest, IncorrectAccessSpecifier) { 7926 verifyFormat("public:"); 7927 verifyFormat("class A {\n" 7928 "public\n" 7929 " void f() {}\n" 7930 "};"); 7931 verifyFormat("public\n" 7932 "int qwerty;"); 7933 verifyFormat("public\n" 7934 "B {}"); 7935 verifyFormat("public\n" 7936 "{}"); 7937 verifyFormat("public\n" 7938 "B { int x; }"); 7939 } 7940 7941 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 7942 verifyFormat("{"); 7943 verifyFormat("#})"); 7944 verifyNoCrash("(/**/[:!] ?[)."); 7945 } 7946 7947 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 7948 // Found by oss-fuzz: 7949 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 7950 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 7951 Style.ColumnLimit = 60; 7952 verifyNoCrash( 7953 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 7954 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 7955 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 7956 Style); 7957 } 7958 7959 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 7960 verifyFormat("do {\n}"); 7961 verifyFormat("do {\n}\n" 7962 "f();"); 7963 verifyFormat("do {\n}\n" 7964 "wheeee(fun);"); 7965 verifyFormat("do {\n" 7966 " f();\n" 7967 "}"); 7968 } 7969 7970 TEST_F(FormatTest, IncorrectCodeMissingParens) { 7971 verifyFormat("if {\n foo;\n foo();\n}"); 7972 verifyFormat("switch {\n foo;\n foo();\n}"); 7973 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 7974 verifyFormat("while {\n foo;\n foo();\n}"); 7975 verifyFormat("do {\n foo;\n foo();\n} while;"); 7976 } 7977 7978 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 7979 verifyIncompleteFormat("namespace {\n" 7980 "class Foo { Foo (\n" 7981 "};\n" 7982 "} // namespace"); 7983 } 7984 7985 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 7986 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 7987 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 7988 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 7989 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 7990 7991 EXPECT_EQ("{\n" 7992 " {\n" 7993 " breakme(\n" 7994 " qwe);\n" 7995 " }\n", 7996 format("{\n" 7997 " {\n" 7998 " breakme(qwe);\n" 7999 "}\n", 8000 getLLVMStyleWithColumns(10))); 8001 } 8002 8003 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 8004 verifyFormat("int x = {\n" 8005 " avariable,\n" 8006 " b(alongervariable)};", 8007 getLLVMStyleWithColumns(25)); 8008 } 8009 8010 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 8011 verifyFormat("return (a)(b){1, 2, 3};"); 8012 } 8013 8014 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 8015 verifyFormat("vector<int> x{1, 2, 3, 4};"); 8016 verifyFormat("vector<int> x{\n" 8017 " 1,\n" 8018 " 2,\n" 8019 " 3,\n" 8020 " 4,\n" 8021 "};"); 8022 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 8023 verifyFormat("f({1, 2});"); 8024 verifyFormat("auto v = Foo{-1};"); 8025 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 8026 verifyFormat("Class::Class : member{1, 2, 3} {}"); 8027 verifyFormat("new vector<int>{1, 2, 3};"); 8028 verifyFormat("new int[3]{1, 2, 3};"); 8029 verifyFormat("new int{1};"); 8030 verifyFormat("return {arg1, arg2};"); 8031 verifyFormat("return {arg1, SomeType{parameter}};"); 8032 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 8033 verifyFormat("new T{arg1, arg2};"); 8034 verifyFormat("f(MyMap[{composite, key}]);"); 8035 verifyFormat("class Class {\n" 8036 " T member = {arg1, arg2};\n" 8037 "};"); 8038 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 8039 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 8040 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 8041 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 8042 verifyFormat("int a = std::is_integral<int>{} + 0;"); 8043 8044 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8045 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8046 verifyFormat("auto i = decltype(x){};"); 8047 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 8048 verifyFormat("Node n{1, Node{1000}, //\n" 8049 " 2};"); 8050 verifyFormat("Aaaa aaaaaaa{\n" 8051 " {\n" 8052 " aaaa,\n" 8053 " },\n" 8054 "};"); 8055 verifyFormat("class C : public D {\n" 8056 " SomeClass SC{2};\n" 8057 "};"); 8058 verifyFormat("class C : public A {\n" 8059 " class D : public B {\n" 8060 " void f() { int i{2}; }\n" 8061 " };\n" 8062 "};"); 8063 verifyFormat("#define A {a, a},"); 8064 8065 // Avoid breaking between equal sign and opening brace 8066 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 8067 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 8068 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 8069 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 8070 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 8071 " {\"ccccccccccccccccccccc\", 2}};", 8072 AvoidBreakingFirstArgument); 8073 8074 // Binpacking only if there is no trailing comma 8075 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 8076 " cccccccccc, dddddddddd};", 8077 getLLVMStyleWithColumns(50)); 8078 verifyFormat("const Aaaaaa aaaaa = {\n" 8079 " aaaaaaaaaaa,\n" 8080 " bbbbbbbbbbb,\n" 8081 " ccccccccccc,\n" 8082 " ddddddddddd,\n" 8083 "};", 8084 getLLVMStyleWithColumns(50)); 8085 8086 // Cases where distinguising braced lists and blocks is hard. 8087 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 8088 verifyFormat("void f() {\n" 8089 " return; // comment\n" 8090 "}\n" 8091 "SomeType t;"); 8092 verifyFormat("void f() {\n" 8093 " if (a) {\n" 8094 " f();\n" 8095 " }\n" 8096 "}\n" 8097 "SomeType t;"); 8098 8099 // In combination with BinPackArguments = false. 8100 FormatStyle NoBinPacking = getLLVMStyle(); 8101 NoBinPacking.BinPackArguments = false; 8102 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 8103 " bbbbb,\n" 8104 " ccccc,\n" 8105 " ddddd,\n" 8106 " eeeee,\n" 8107 " ffffff,\n" 8108 " ggggg,\n" 8109 " hhhhhh,\n" 8110 " iiiiii,\n" 8111 " jjjjjj,\n" 8112 " kkkkkk};", 8113 NoBinPacking); 8114 verifyFormat("const Aaaaaa aaaaa = {\n" 8115 " aaaaa,\n" 8116 " bbbbb,\n" 8117 " ccccc,\n" 8118 " ddddd,\n" 8119 " eeeee,\n" 8120 " ffffff,\n" 8121 " ggggg,\n" 8122 " hhhhhh,\n" 8123 " iiiiii,\n" 8124 " jjjjjj,\n" 8125 " kkkkkk,\n" 8126 "};", 8127 NoBinPacking); 8128 verifyFormat( 8129 "const Aaaaaa aaaaa = {\n" 8130 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 8131 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 8132 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 8133 "};", 8134 NoBinPacking); 8135 8136 NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 8137 EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n" 8138 " CDDDP83848_BMCR_REGISTER,\n" 8139 " CDDDP83848_BMSR_REGISTER,\n" 8140 " CDDDP83848_RBR_REGISTER};", 8141 format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n" 8142 " CDDDP83848_BMSR_REGISTER,\n" 8143 " CDDDP83848_RBR_REGISTER};", 8144 NoBinPacking)); 8145 8146 // FIXME: The alignment of these trailing comments might be bad. Then again, 8147 // this might be utterly useless in real code. 8148 verifyFormat("Constructor::Constructor()\n" 8149 " : some_value{ //\n" 8150 " aaaaaaa, //\n" 8151 " bbbbbbb} {}"); 8152 8153 // In braced lists, the first comment is always assumed to belong to the 8154 // first element. Thus, it can be moved to the next or previous line as 8155 // appropriate. 8156 EXPECT_EQ("function({// First element:\n" 8157 " 1,\n" 8158 " // Second element:\n" 8159 " 2});", 8160 format("function({\n" 8161 " // First element:\n" 8162 " 1,\n" 8163 " // Second element:\n" 8164 " 2});")); 8165 EXPECT_EQ("std::vector<int> MyNumbers{\n" 8166 " // First element:\n" 8167 " 1,\n" 8168 " // Second element:\n" 8169 " 2};", 8170 format("std::vector<int> MyNumbers{// First element:\n" 8171 " 1,\n" 8172 " // Second element:\n" 8173 " 2};", 8174 getLLVMStyleWithColumns(30))); 8175 // A trailing comma should still lead to an enforced line break and no 8176 // binpacking. 8177 EXPECT_EQ("vector<int> SomeVector = {\n" 8178 " // aaa\n" 8179 " 1,\n" 8180 " 2,\n" 8181 "};", 8182 format("vector<int> SomeVector = { // aaa\n" 8183 " 1, 2, };")); 8184 8185 FormatStyle ExtraSpaces = getLLVMStyle(); 8186 ExtraSpaces.Cpp11BracedListStyle = false; 8187 ExtraSpaces.ColumnLimit = 75; 8188 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 8189 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 8190 verifyFormat("f({ 1, 2 });", ExtraSpaces); 8191 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 8192 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 8193 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 8194 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 8195 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 8196 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 8197 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 8198 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 8199 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 8200 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 8201 verifyFormat("class Class {\n" 8202 " T member = { arg1, arg2 };\n" 8203 "};", 8204 ExtraSpaces); 8205 verifyFormat( 8206 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8207 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 8208 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 8209 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 8210 ExtraSpaces); 8211 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 8212 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 8213 ExtraSpaces); 8214 verifyFormat( 8215 "someFunction(OtherParam,\n" 8216 " BracedList{ // comment 1 (Forcing interesting break)\n" 8217 " param1, param2,\n" 8218 " // comment 2\n" 8219 " param3, param4 });", 8220 ExtraSpaces); 8221 verifyFormat( 8222 "std::this_thread::sleep_for(\n" 8223 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 8224 ExtraSpaces); 8225 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 8226 " aaaaaaa,\n" 8227 " aaaaaaaaaa,\n" 8228 " aaaaa,\n" 8229 " aaaaaaaaaaaaaaa,\n" 8230 " aaa,\n" 8231 " aaaaaaaaaa,\n" 8232 " a,\n" 8233 " aaaaaaaaaaaaaaaaaaaaa,\n" 8234 " aaaaaaaaaaaa,\n" 8235 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 8236 " aaaaaaa,\n" 8237 " a};"); 8238 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 8239 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 8240 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 8241 8242 // Avoid breaking between initializer/equal sign and opening brace 8243 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 8244 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 8245 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8246 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8247 " { \"ccccccccccccccccccccc\", 2 }\n" 8248 "};", 8249 ExtraSpaces); 8250 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 8251 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8252 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8253 " { \"ccccccccccccccccccccc\", 2 }\n" 8254 "};", 8255 ExtraSpaces); 8256 8257 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 8258 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 8259 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 8260 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 8261 8262 FormatStyle SpaceBetweenBraces = getLLVMStyle(); 8263 SpaceBetweenBraces.SpacesInAngles = true; 8264 SpaceBetweenBraces.SpacesInParentheses = true; 8265 SpaceBetweenBraces.SpacesInSquareBrackets = true; 8266 verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces); 8267 verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces); 8268 verifyFormat("vector< int > x{ // comment 1\n" 8269 " 1, 2, 3, 4 };", 8270 SpaceBetweenBraces); 8271 SpaceBetweenBraces.ColumnLimit = 20; 8272 EXPECT_EQ("vector< int > x{\n" 8273 " 1, 2, 3, 4 };", 8274 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8275 SpaceBetweenBraces.ColumnLimit = 24; 8276 EXPECT_EQ("vector< int > x{ 1, 2,\n" 8277 " 3, 4 };", 8278 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8279 EXPECT_EQ("vector< int > x{\n" 8280 " 1,\n" 8281 " 2,\n" 8282 " 3,\n" 8283 " 4,\n" 8284 "};", 8285 format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces)); 8286 verifyFormat("vector< int > x{};", SpaceBetweenBraces); 8287 SpaceBetweenBraces.SpaceInEmptyParentheses = true; 8288 verifyFormat("vector< int > x{ };", SpaceBetweenBraces); 8289 } 8290 8291 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 8292 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8293 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8294 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8295 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8296 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8297 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8298 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 8299 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8300 " 1, 22, 333, 4444, 55555, //\n" 8301 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8302 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8303 verifyFormat( 8304 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8305 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8306 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 8307 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8308 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8309 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8310 " 7777777};"); 8311 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8312 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8313 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8314 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8315 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8316 " // Separating comment.\n" 8317 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8318 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8319 " // Leading comment\n" 8320 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8321 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8322 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8323 " 1, 1, 1, 1};", 8324 getLLVMStyleWithColumns(39)); 8325 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8326 " 1, 1, 1, 1};", 8327 getLLVMStyleWithColumns(38)); 8328 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 8329 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 8330 getLLVMStyleWithColumns(43)); 8331 verifyFormat( 8332 "static unsigned SomeValues[10][3] = {\n" 8333 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 8334 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 8335 verifyFormat("static auto fields = new vector<string>{\n" 8336 " \"aaaaaaaaaaaaa\",\n" 8337 " \"aaaaaaaaaaaaa\",\n" 8338 " \"aaaaaaaaaaaa\",\n" 8339 " \"aaaaaaaaaaaaaa\",\n" 8340 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8341 " \"aaaaaaaaaaaa\",\n" 8342 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8343 "};"); 8344 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 8345 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 8346 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 8347 " 3, cccccccccccccccccccccc};", 8348 getLLVMStyleWithColumns(60)); 8349 8350 // Trailing commas. 8351 verifyFormat("vector<int> x = {\n" 8352 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 8353 "};", 8354 getLLVMStyleWithColumns(39)); 8355 verifyFormat("vector<int> x = {\n" 8356 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 8357 "};", 8358 getLLVMStyleWithColumns(39)); 8359 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8360 " 1, 1, 1, 1,\n" 8361 " /**/ /**/};", 8362 getLLVMStyleWithColumns(39)); 8363 8364 // Trailing comment in the first line. 8365 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 8366 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 8367 " 111111111, 222222222, 3333333333, 444444444, //\n" 8368 " 11111111, 22222222, 333333333, 44444444};"); 8369 // Trailing comment in the last line. 8370 verifyFormat("int aaaaa[] = {\n" 8371 " 1, 2, 3, // comment\n" 8372 " 4, 5, 6 // comment\n" 8373 "};"); 8374 8375 // With nested lists, we should either format one item per line or all nested 8376 // lists one on line. 8377 // FIXME: For some nested lists, we can do better. 8378 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 8379 " {aaaaaaaaaaaaaaaaaaa},\n" 8380 " {aaaaaaaaaaaaaaaaaaaaa},\n" 8381 " {aaaaaaaaaaaaaaaaa}};", 8382 getLLVMStyleWithColumns(60)); 8383 verifyFormat( 8384 "SomeStruct my_struct_array = {\n" 8385 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 8386 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 8387 " {aaa, aaa},\n" 8388 " {aaa, aaa},\n" 8389 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 8390 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 8391 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 8392 8393 // No column layout should be used here. 8394 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 8395 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 8396 8397 verifyNoCrash("a<,"); 8398 8399 // No braced initializer here. 8400 verifyFormat("void f() {\n" 8401 " struct Dummy {};\n" 8402 " f(v);\n" 8403 "}"); 8404 8405 // Long lists should be formatted in columns even if they are nested. 8406 verifyFormat( 8407 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8408 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8409 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8410 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8411 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8412 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 8413 8414 // Allow "single-column" layout even if that violates the column limit. There 8415 // isn't going to be a better way. 8416 verifyFormat("std::vector<int> a = {\n" 8417 " aaaaaaaa,\n" 8418 " aaaaaaaa,\n" 8419 " aaaaaaaa,\n" 8420 " aaaaaaaa,\n" 8421 " aaaaaaaaaa,\n" 8422 " aaaaaaaa,\n" 8423 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 8424 getLLVMStyleWithColumns(30)); 8425 verifyFormat("vector<int> aaaa = {\n" 8426 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8427 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8428 " aaaaaa.aaaaaaa,\n" 8429 " aaaaaa.aaaaaaa,\n" 8430 " aaaaaa.aaaaaaa,\n" 8431 " aaaaaa.aaaaaaa,\n" 8432 "};"); 8433 8434 // Don't create hanging lists. 8435 verifyFormat("someFunction(Param, {List1, List2,\n" 8436 " List3});", 8437 getLLVMStyleWithColumns(35)); 8438 verifyFormat("someFunction(Param, Param,\n" 8439 " {List1, List2,\n" 8440 " List3});", 8441 getLLVMStyleWithColumns(35)); 8442 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 8443 " aaaaaaaaaaaaaaaaaaaaaaa);"); 8444 } 8445 8446 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 8447 FormatStyle DoNotMerge = getLLVMStyle(); 8448 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8449 8450 verifyFormat("void f() { return 42; }"); 8451 verifyFormat("void f() {\n" 8452 " return 42;\n" 8453 "}", 8454 DoNotMerge); 8455 verifyFormat("void f() {\n" 8456 " // Comment\n" 8457 "}"); 8458 verifyFormat("{\n" 8459 "#error {\n" 8460 " int a;\n" 8461 "}"); 8462 verifyFormat("{\n" 8463 " int a;\n" 8464 "#error {\n" 8465 "}"); 8466 verifyFormat("void f() {} // comment"); 8467 verifyFormat("void f() { int a; } // comment"); 8468 verifyFormat("void f() {\n" 8469 "} // comment", 8470 DoNotMerge); 8471 verifyFormat("void f() {\n" 8472 " int a;\n" 8473 "} // comment", 8474 DoNotMerge); 8475 verifyFormat("void f() {\n" 8476 "} // comment", 8477 getLLVMStyleWithColumns(15)); 8478 8479 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 8480 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 8481 8482 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 8483 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 8484 verifyFormat("class C {\n" 8485 " C()\n" 8486 " : iiiiiiii(nullptr),\n" 8487 " kkkkkkk(nullptr),\n" 8488 " mmmmmmm(nullptr),\n" 8489 " nnnnnnn(nullptr) {}\n" 8490 "};", 8491 getGoogleStyle()); 8492 8493 FormatStyle NoColumnLimit = getLLVMStyle(); 8494 NoColumnLimit.ColumnLimit = 0; 8495 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 8496 EXPECT_EQ("class C {\n" 8497 " A() : b(0) {}\n" 8498 "};", 8499 format("class C{A():b(0){}};", NoColumnLimit)); 8500 EXPECT_EQ("A()\n" 8501 " : b(0) {\n" 8502 "}", 8503 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 8504 8505 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 8506 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 8507 FormatStyle::SFS_None; 8508 EXPECT_EQ("A()\n" 8509 " : b(0) {\n" 8510 "}", 8511 format("A():b(0){}", DoNotMergeNoColumnLimit)); 8512 EXPECT_EQ("A()\n" 8513 " : b(0) {\n" 8514 "}", 8515 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 8516 8517 verifyFormat("#define A \\\n" 8518 " void f() { \\\n" 8519 " int i; \\\n" 8520 " }", 8521 getLLVMStyleWithColumns(20)); 8522 verifyFormat("#define A \\\n" 8523 " void f() { int i; }", 8524 getLLVMStyleWithColumns(21)); 8525 verifyFormat("#define A \\\n" 8526 " void f() { \\\n" 8527 " int i; \\\n" 8528 " } \\\n" 8529 " int j;", 8530 getLLVMStyleWithColumns(22)); 8531 verifyFormat("#define A \\\n" 8532 " void f() { int i; } \\\n" 8533 " int j;", 8534 getLLVMStyleWithColumns(23)); 8535 } 8536 8537 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 8538 FormatStyle MergeEmptyOnly = getLLVMStyle(); 8539 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8540 verifyFormat("class C {\n" 8541 " int f() {}\n" 8542 "};", 8543 MergeEmptyOnly); 8544 verifyFormat("class C {\n" 8545 " int f() {\n" 8546 " return 42;\n" 8547 " }\n" 8548 "};", 8549 MergeEmptyOnly); 8550 verifyFormat("int f() {}", MergeEmptyOnly); 8551 verifyFormat("int f() {\n" 8552 " return 42;\n" 8553 "}", 8554 MergeEmptyOnly); 8555 8556 // Also verify behavior when BraceWrapping.AfterFunction = true 8557 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8558 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 8559 verifyFormat("int f() {}", MergeEmptyOnly); 8560 verifyFormat("class C {\n" 8561 " int f() {}\n" 8562 "};", 8563 MergeEmptyOnly); 8564 } 8565 8566 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 8567 FormatStyle MergeInlineOnly = getLLVMStyle(); 8568 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8569 verifyFormat("class C {\n" 8570 " int f() { return 42; }\n" 8571 "};", 8572 MergeInlineOnly); 8573 verifyFormat("int f() {\n" 8574 " return 42;\n" 8575 "}", 8576 MergeInlineOnly); 8577 8578 // SFS_Inline implies SFS_Empty 8579 verifyFormat("class C {\n" 8580 " int f() {}\n" 8581 "};", 8582 MergeInlineOnly); 8583 verifyFormat("int f() {}", MergeInlineOnly); 8584 8585 // Also verify behavior when BraceWrapping.AfterFunction = true 8586 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8587 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8588 verifyFormat("class C {\n" 8589 " int f() { return 42; }\n" 8590 "};", 8591 MergeInlineOnly); 8592 verifyFormat("int f()\n" 8593 "{\n" 8594 " return 42;\n" 8595 "}", 8596 MergeInlineOnly); 8597 8598 // SFS_Inline implies SFS_Empty 8599 verifyFormat("int f() {}", MergeInlineOnly); 8600 verifyFormat("class C {\n" 8601 " int f() {}\n" 8602 "};", 8603 MergeInlineOnly); 8604 } 8605 8606 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8607 FormatStyle MergeInlineOnly = getLLVMStyle(); 8608 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8609 FormatStyle::SFS_InlineOnly; 8610 verifyFormat("class C {\n" 8611 " int f() { return 42; }\n" 8612 "};", 8613 MergeInlineOnly); 8614 verifyFormat("int f() {\n" 8615 " return 42;\n" 8616 "}", 8617 MergeInlineOnly); 8618 8619 // SFS_InlineOnly does not imply SFS_Empty 8620 verifyFormat("class C {\n" 8621 " int f() {}\n" 8622 "};", 8623 MergeInlineOnly); 8624 verifyFormat("int f() {\n" 8625 "}", 8626 MergeInlineOnly); 8627 8628 // Also verify behavior when BraceWrapping.AfterFunction = true 8629 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8630 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8631 verifyFormat("class C {\n" 8632 " int f() { return 42; }\n" 8633 "};", 8634 MergeInlineOnly); 8635 verifyFormat("int f()\n" 8636 "{\n" 8637 " return 42;\n" 8638 "}", 8639 MergeInlineOnly); 8640 8641 // SFS_InlineOnly does not imply SFS_Empty 8642 verifyFormat("int f()\n" 8643 "{\n" 8644 "}", 8645 MergeInlineOnly); 8646 verifyFormat("class C {\n" 8647 " int f() {}\n" 8648 "};", 8649 MergeInlineOnly); 8650 } 8651 8652 TEST_F(FormatTest, SplitEmptyFunction) { 8653 FormatStyle Style = getLLVMStyle(); 8654 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8655 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8656 Style.BraceWrapping.AfterFunction = true; 8657 Style.BraceWrapping.SplitEmptyFunction = false; 8658 Style.ColumnLimit = 40; 8659 8660 verifyFormat("int f()\n" 8661 "{}", 8662 Style); 8663 verifyFormat("int f()\n" 8664 "{\n" 8665 " return 42;\n" 8666 "}", 8667 Style); 8668 verifyFormat("int f()\n" 8669 "{\n" 8670 " // some comment\n" 8671 "}", 8672 Style); 8673 8674 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8675 verifyFormat("int f() {}", Style); 8676 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8677 "{}", 8678 Style); 8679 verifyFormat("int f()\n" 8680 "{\n" 8681 " return 0;\n" 8682 "}", 8683 Style); 8684 8685 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8686 verifyFormat("class Foo {\n" 8687 " int f() {}\n" 8688 "};\n", 8689 Style); 8690 verifyFormat("class Foo {\n" 8691 " int f() { return 0; }\n" 8692 "};\n", 8693 Style); 8694 verifyFormat("class Foo {\n" 8695 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8696 " {}\n" 8697 "};\n", 8698 Style); 8699 verifyFormat("class Foo {\n" 8700 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8701 " {\n" 8702 " return 0;\n" 8703 " }\n" 8704 "};\n", 8705 Style); 8706 8707 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8708 verifyFormat("int f() {}", Style); 8709 verifyFormat("int f() { return 0; }", Style); 8710 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8711 "{}", 8712 Style); 8713 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8714 "{\n" 8715 " return 0;\n" 8716 "}", 8717 Style); 8718 } 8719 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8720 FormatStyle Style = getLLVMStyle(); 8721 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8722 verifyFormat("#ifdef A\n" 8723 "int f() {}\n" 8724 "#else\n" 8725 "int g() {}\n" 8726 "#endif", 8727 Style); 8728 } 8729 8730 TEST_F(FormatTest, SplitEmptyClass) { 8731 FormatStyle Style = getLLVMStyle(); 8732 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8733 Style.BraceWrapping.AfterClass = true; 8734 Style.BraceWrapping.SplitEmptyRecord = false; 8735 8736 verifyFormat("class Foo\n" 8737 "{};", 8738 Style); 8739 verifyFormat("/* something */ class Foo\n" 8740 "{};", 8741 Style); 8742 verifyFormat("template <typename X> class Foo\n" 8743 "{};", 8744 Style); 8745 verifyFormat("class Foo\n" 8746 "{\n" 8747 " Foo();\n" 8748 "};", 8749 Style); 8750 verifyFormat("typedef class Foo\n" 8751 "{\n" 8752 "} Foo_t;", 8753 Style); 8754 } 8755 8756 TEST_F(FormatTest, SplitEmptyStruct) { 8757 FormatStyle Style = getLLVMStyle(); 8758 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8759 Style.BraceWrapping.AfterStruct = true; 8760 Style.BraceWrapping.SplitEmptyRecord = false; 8761 8762 verifyFormat("struct Foo\n" 8763 "{};", 8764 Style); 8765 verifyFormat("/* something */ struct Foo\n" 8766 "{};", 8767 Style); 8768 verifyFormat("template <typename X> struct Foo\n" 8769 "{};", 8770 Style); 8771 verifyFormat("struct Foo\n" 8772 "{\n" 8773 " Foo();\n" 8774 "};", 8775 Style); 8776 verifyFormat("typedef struct Foo\n" 8777 "{\n" 8778 "} Foo_t;", 8779 Style); 8780 // typedef struct Bar {} Bar_t; 8781 } 8782 8783 TEST_F(FormatTest, SplitEmptyUnion) { 8784 FormatStyle Style = getLLVMStyle(); 8785 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8786 Style.BraceWrapping.AfterUnion = true; 8787 Style.BraceWrapping.SplitEmptyRecord = false; 8788 8789 verifyFormat("union Foo\n" 8790 "{};", 8791 Style); 8792 verifyFormat("/* something */ union Foo\n" 8793 "{};", 8794 Style); 8795 verifyFormat("union Foo\n" 8796 "{\n" 8797 " A,\n" 8798 "};", 8799 Style); 8800 verifyFormat("typedef union Foo\n" 8801 "{\n" 8802 "} Foo_t;", 8803 Style); 8804 } 8805 8806 TEST_F(FormatTest, SplitEmptyNamespace) { 8807 FormatStyle Style = getLLVMStyle(); 8808 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8809 Style.BraceWrapping.AfterNamespace = true; 8810 Style.BraceWrapping.SplitEmptyNamespace = false; 8811 8812 verifyFormat("namespace Foo\n" 8813 "{};", 8814 Style); 8815 verifyFormat("/* something */ namespace Foo\n" 8816 "{};", 8817 Style); 8818 verifyFormat("inline namespace Foo\n" 8819 "{};", 8820 Style); 8821 verifyFormat("/* something */ inline namespace Foo\n" 8822 "{};", 8823 Style); 8824 verifyFormat("export namespace Foo\n" 8825 "{};", 8826 Style); 8827 verifyFormat("namespace Foo\n" 8828 "{\n" 8829 "void Bar();\n" 8830 "};", 8831 Style); 8832 } 8833 8834 TEST_F(FormatTest, NeverMergeShortRecords) { 8835 FormatStyle Style = getLLVMStyle(); 8836 8837 verifyFormat("class Foo {\n" 8838 " Foo();\n" 8839 "};", 8840 Style); 8841 verifyFormat("typedef class Foo {\n" 8842 " Foo();\n" 8843 "} Foo_t;", 8844 Style); 8845 verifyFormat("struct Foo {\n" 8846 " Foo();\n" 8847 "};", 8848 Style); 8849 verifyFormat("typedef struct Foo {\n" 8850 " Foo();\n" 8851 "} Foo_t;", 8852 Style); 8853 verifyFormat("union Foo {\n" 8854 " A,\n" 8855 "};", 8856 Style); 8857 verifyFormat("typedef union Foo {\n" 8858 " A,\n" 8859 "} Foo_t;", 8860 Style); 8861 verifyFormat("namespace Foo {\n" 8862 "void Bar();\n" 8863 "};", 8864 Style); 8865 8866 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8867 Style.BraceWrapping.AfterClass = true; 8868 Style.BraceWrapping.AfterStruct = true; 8869 Style.BraceWrapping.AfterUnion = true; 8870 Style.BraceWrapping.AfterNamespace = true; 8871 verifyFormat("class Foo\n" 8872 "{\n" 8873 " Foo();\n" 8874 "};", 8875 Style); 8876 verifyFormat("typedef class Foo\n" 8877 "{\n" 8878 " Foo();\n" 8879 "} Foo_t;", 8880 Style); 8881 verifyFormat("struct Foo\n" 8882 "{\n" 8883 " Foo();\n" 8884 "};", 8885 Style); 8886 verifyFormat("typedef struct Foo\n" 8887 "{\n" 8888 " Foo();\n" 8889 "} Foo_t;", 8890 Style); 8891 verifyFormat("union Foo\n" 8892 "{\n" 8893 " A,\n" 8894 "};", 8895 Style); 8896 verifyFormat("typedef union Foo\n" 8897 "{\n" 8898 " A,\n" 8899 "} Foo_t;", 8900 Style); 8901 verifyFormat("namespace Foo\n" 8902 "{\n" 8903 "void Bar();\n" 8904 "};", 8905 Style); 8906 } 8907 8908 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 8909 // Elaborate type variable declarations. 8910 verifyFormat("struct foo a = {bar};\nint n;"); 8911 verifyFormat("class foo a = {bar};\nint n;"); 8912 verifyFormat("union foo a = {bar};\nint n;"); 8913 8914 // Elaborate types inside function definitions. 8915 verifyFormat("struct foo f() {}\nint n;"); 8916 verifyFormat("class foo f() {}\nint n;"); 8917 verifyFormat("union foo f() {}\nint n;"); 8918 8919 // Templates. 8920 verifyFormat("template <class X> void f() {}\nint n;"); 8921 verifyFormat("template <struct X> void f() {}\nint n;"); 8922 verifyFormat("template <union X> void f() {}\nint n;"); 8923 8924 // Actual definitions... 8925 verifyFormat("struct {\n} n;"); 8926 verifyFormat( 8927 "template <template <class T, class Y>, class Z> class X {\n} n;"); 8928 verifyFormat("union Z {\n int n;\n} x;"); 8929 verifyFormat("class MACRO Z {\n} n;"); 8930 verifyFormat("class MACRO(X) Z {\n} n;"); 8931 verifyFormat("class __attribute__(X) Z {\n} n;"); 8932 verifyFormat("class __declspec(X) Z {\n} n;"); 8933 verifyFormat("class A##B##C {\n} n;"); 8934 verifyFormat("class alignas(16) Z {\n} n;"); 8935 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 8936 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 8937 8938 // Redefinition from nested context: 8939 verifyFormat("class A::B::C {\n} n;"); 8940 8941 // Template definitions. 8942 verifyFormat( 8943 "template <typename F>\n" 8944 "Matcher(const Matcher<F> &Other,\n" 8945 " typename enable_if_c<is_base_of<F, T>::value &&\n" 8946 " !is_same<F, T>::value>::type * = 0)\n" 8947 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 8948 8949 // FIXME: This is still incorrectly handled at the formatter side. 8950 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 8951 verifyFormat("int i = SomeFunction(a<b, a> b);"); 8952 8953 // FIXME: 8954 // This now gets parsed incorrectly as class definition. 8955 // verifyFormat("class A<int> f() {\n}\nint n;"); 8956 8957 // Elaborate types where incorrectly parsing the structural element would 8958 // break the indent. 8959 verifyFormat("if (true)\n" 8960 " class X x;\n" 8961 "else\n" 8962 " f();\n"); 8963 8964 // This is simply incomplete. Formatting is not important, but must not crash. 8965 verifyFormat("class A:"); 8966 } 8967 8968 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 8969 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 8970 format("#error Leave all white!!!!! space* alone!\n")); 8971 EXPECT_EQ( 8972 "#warning Leave all white!!!!! space* alone!\n", 8973 format("#warning Leave all white!!!!! space* alone!\n")); 8974 EXPECT_EQ("#error 1", format(" # error 1")); 8975 EXPECT_EQ("#warning 1", format(" # warning 1")); 8976 } 8977 8978 TEST_F(FormatTest, FormatHashIfExpressions) { 8979 verifyFormat("#if AAAA && BBBB"); 8980 verifyFormat("#if (AAAA && BBBB)"); 8981 verifyFormat("#elif (AAAA && BBBB)"); 8982 // FIXME: Come up with a better indentation for #elif. 8983 verifyFormat( 8984 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 8985 " defined(BBBBBBBB)\n" 8986 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 8987 " defined(BBBBBBBB)\n" 8988 "#endif", 8989 getLLVMStyleWithColumns(65)); 8990 } 8991 8992 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 8993 FormatStyle AllowsMergedIf = getGoogleStyle(); 8994 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 8995 FormatStyle::SIS_WithoutElse; 8996 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 8997 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 8998 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 8999 EXPECT_EQ("if (true) return 42;", 9000 format("if (true)\nreturn 42;", AllowsMergedIf)); 9001 FormatStyle ShortMergedIf = AllowsMergedIf; 9002 ShortMergedIf.ColumnLimit = 25; 9003 verifyFormat("#define A \\\n" 9004 " if (true) return 42;", 9005 ShortMergedIf); 9006 verifyFormat("#define A \\\n" 9007 " f(); \\\n" 9008 " if (true)\n" 9009 "#define B", 9010 ShortMergedIf); 9011 verifyFormat("#define A \\\n" 9012 " f(); \\\n" 9013 " if (true)\n" 9014 "g();", 9015 ShortMergedIf); 9016 verifyFormat("{\n" 9017 "#ifdef A\n" 9018 " // Comment\n" 9019 " if (true) continue;\n" 9020 "#endif\n" 9021 " // Comment\n" 9022 " if (true) continue;\n" 9023 "}", 9024 ShortMergedIf); 9025 ShortMergedIf.ColumnLimit = 33; 9026 verifyFormat("#define A \\\n" 9027 " if constexpr (true) return 42;", 9028 ShortMergedIf); 9029 verifyFormat("#define A \\\n" 9030 " if CONSTEXPR (true) return 42;", 9031 ShortMergedIf); 9032 ShortMergedIf.ColumnLimit = 29; 9033 verifyFormat("#define A \\\n" 9034 " if (aaaaaaaaaa) return 1; \\\n" 9035 " return 2;", 9036 ShortMergedIf); 9037 ShortMergedIf.ColumnLimit = 28; 9038 verifyFormat("#define A \\\n" 9039 " if (aaaaaaaaaa) \\\n" 9040 " return 1; \\\n" 9041 " return 2;", 9042 ShortMergedIf); 9043 verifyFormat("#define A \\\n" 9044 " if constexpr (aaaaaaa) \\\n" 9045 " return 1; \\\n" 9046 " return 2;", 9047 ShortMergedIf); 9048 verifyFormat("#define A \\\n" 9049 " if CONSTEXPR (aaaaaaa) \\\n" 9050 " return 1; \\\n" 9051 " return 2;", 9052 ShortMergedIf); 9053 } 9054 9055 TEST_F(FormatTest, FormatStarDependingOnContext) { 9056 verifyFormat("void f(int *a);"); 9057 verifyFormat("void f() { f(fint * b); }"); 9058 verifyFormat("class A {\n void f(int *a);\n};"); 9059 verifyFormat("class A {\n int *a;\n};"); 9060 verifyFormat("namespace a {\n" 9061 "namespace b {\n" 9062 "class A {\n" 9063 " void f() {}\n" 9064 " int *a;\n" 9065 "};\n" 9066 "} // namespace b\n" 9067 "} // namespace a"); 9068 } 9069 9070 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 9071 verifyFormat("while"); 9072 verifyFormat("operator"); 9073 } 9074 9075 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 9076 // This code would be painfully slow to format if we didn't skip it. 9077 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 9078 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9079 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9080 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9081 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9082 "A(1, 1)\n" 9083 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 9084 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9085 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9086 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9087 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9088 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9089 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9090 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9091 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9092 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 9093 // Deeply nested part is untouched, rest is formatted. 9094 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 9095 format(std::string("int i;\n") + Code + "int j;\n", 9096 getLLVMStyle(), SC_ExpectIncomplete)); 9097 } 9098 9099 //===----------------------------------------------------------------------===// 9100 // Objective-C tests. 9101 //===----------------------------------------------------------------------===// 9102 9103 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 9104 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 9105 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 9106 format("-(NSUInteger)indexOfObject:(id)anObject;")); 9107 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 9108 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 9109 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 9110 format("-(NSInteger)Method3:(id)anObject;")); 9111 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 9112 format("-(NSInteger)Method4:(id)anObject;")); 9113 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 9114 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 9115 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 9116 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 9117 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9118 "forAllCells:(BOOL)flag;", 9119 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9120 "forAllCells:(BOOL)flag;")); 9121 9122 // Very long objectiveC method declaration. 9123 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 9124 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 9125 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 9126 " inRange:(NSRange)range\n" 9127 " outRange:(NSRange)out_range\n" 9128 " outRange1:(NSRange)out_range1\n" 9129 " outRange2:(NSRange)out_range2\n" 9130 " outRange3:(NSRange)out_range3\n" 9131 " outRange4:(NSRange)out_range4\n" 9132 " outRange5:(NSRange)out_range5\n" 9133 " outRange6:(NSRange)out_range6\n" 9134 " outRange7:(NSRange)out_range7\n" 9135 " outRange8:(NSRange)out_range8\n" 9136 " outRange9:(NSRange)out_range9;"); 9137 9138 // When the function name has to be wrapped. 9139 FormatStyle Style = getLLVMStyle(); 9140 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 9141 // and always indents instead. 9142 Style.IndentWrappedFunctionNames = false; 9143 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9144 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 9145 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 9146 "}", 9147 Style); 9148 Style.IndentWrappedFunctionNames = true; 9149 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9150 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 9151 " anotherName:(NSString)dddddddddddddd {\n" 9152 "}", 9153 Style); 9154 9155 verifyFormat("- (int)sum:(vector<int>)numbers;"); 9156 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 9157 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 9158 // protocol lists (but not for template classes): 9159 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 9160 9161 verifyFormat("- (int (*)())foo:(int (*)())f;"); 9162 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 9163 9164 // If there's no return type (very rare in practice!), LLVM and Google style 9165 // agree. 9166 verifyFormat("- foo;"); 9167 verifyFormat("- foo:(int)f;"); 9168 verifyGoogleFormat("- foo:(int)foo;"); 9169 } 9170 9171 TEST_F(FormatTest, BreaksStringLiterals) { 9172 EXPECT_EQ("\"some text \"\n" 9173 "\"other\";", 9174 format("\"some text other\";", getLLVMStyleWithColumns(12))); 9175 EXPECT_EQ("\"some text \"\n" 9176 "\"other\";", 9177 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 9178 EXPECT_EQ( 9179 "#define A \\\n" 9180 " \"some \" \\\n" 9181 " \"text \" \\\n" 9182 " \"other\";", 9183 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 9184 EXPECT_EQ( 9185 "#define A \\\n" 9186 " \"so \" \\\n" 9187 " \"text \" \\\n" 9188 " \"other\";", 9189 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 9190 9191 EXPECT_EQ("\"some text\"", 9192 format("\"some text\"", getLLVMStyleWithColumns(1))); 9193 EXPECT_EQ("\"some text\"", 9194 format("\"some text\"", getLLVMStyleWithColumns(11))); 9195 EXPECT_EQ("\"some \"\n" 9196 "\"text\"", 9197 format("\"some text\"", getLLVMStyleWithColumns(10))); 9198 EXPECT_EQ("\"some \"\n" 9199 "\"text\"", 9200 format("\"some text\"", getLLVMStyleWithColumns(7))); 9201 EXPECT_EQ("\"some\"\n" 9202 "\" tex\"\n" 9203 "\"t\"", 9204 format("\"some text\"", getLLVMStyleWithColumns(6))); 9205 EXPECT_EQ("\"some\"\n" 9206 "\" tex\"\n" 9207 "\" and\"", 9208 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 9209 EXPECT_EQ("\"some\"\n" 9210 "\"/tex\"\n" 9211 "\"/and\"", 9212 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 9213 9214 EXPECT_EQ("variable =\n" 9215 " \"long string \"\n" 9216 " \"literal\";", 9217 format("variable = \"long string literal\";", 9218 getLLVMStyleWithColumns(20))); 9219 9220 EXPECT_EQ("variable = f(\n" 9221 " \"long string \"\n" 9222 " \"literal\",\n" 9223 " short,\n" 9224 " loooooooooooooooooooong);", 9225 format("variable = f(\"long string literal\", short, " 9226 "loooooooooooooooooooong);", 9227 getLLVMStyleWithColumns(20))); 9228 9229 EXPECT_EQ( 9230 "f(g(\"long string \"\n" 9231 " \"literal\"),\n" 9232 " b);", 9233 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 9234 EXPECT_EQ("f(g(\"long string \"\n" 9235 " \"literal\",\n" 9236 " a),\n" 9237 " b);", 9238 format("f(g(\"long string literal\", a), b);", 9239 getLLVMStyleWithColumns(20))); 9240 EXPECT_EQ( 9241 "f(\"one two\".split(\n" 9242 " variable));", 9243 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 9244 EXPECT_EQ("f(\"one two three four five six \"\n" 9245 " \"seven\".split(\n" 9246 " really_looooong_variable));", 9247 format("f(\"one two three four five six seven\"." 9248 "split(really_looooong_variable));", 9249 getLLVMStyleWithColumns(33))); 9250 9251 EXPECT_EQ("f(\"some \"\n" 9252 " \"text\",\n" 9253 " other);", 9254 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 9255 9256 // Only break as a last resort. 9257 verifyFormat( 9258 "aaaaaaaaaaaaaaaaaaaa(\n" 9259 " aaaaaaaaaaaaaaaaaaaa,\n" 9260 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 9261 9262 EXPECT_EQ("\"splitmea\"\n" 9263 "\"trandomp\"\n" 9264 "\"oint\"", 9265 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 9266 9267 EXPECT_EQ("\"split/\"\n" 9268 "\"pathat/\"\n" 9269 "\"slashes\"", 9270 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9271 9272 EXPECT_EQ("\"split/\"\n" 9273 "\"pathat/\"\n" 9274 "\"slashes\"", 9275 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9276 EXPECT_EQ("\"split at \"\n" 9277 "\"spaces/at/\"\n" 9278 "\"slashes.at.any$\"\n" 9279 "\"non-alphanumeric%\"\n" 9280 "\"1111111111characte\"\n" 9281 "\"rs\"", 9282 format("\"split at " 9283 "spaces/at/" 9284 "slashes.at." 9285 "any$non-" 9286 "alphanumeric%" 9287 "1111111111characte" 9288 "rs\"", 9289 getLLVMStyleWithColumns(20))); 9290 9291 // Verify that splitting the strings understands 9292 // Style::AlwaysBreakBeforeMultilineStrings. 9293 EXPECT_EQ("aaaaaaaaaaaa(\n" 9294 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 9295 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 9296 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 9297 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9298 "aaaaaaaaaaaaaaaaaaaaaa\");", 9299 getGoogleStyle())); 9300 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9301 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 9302 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 9303 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9304 "aaaaaaaaaaaaaaaaaaaaaa\";", 9305 getGoogleStyle())); 9306 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9307 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9308 format("llvm::outs() << " 9309 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 9310 "aaaaaaaaaaaaaaaaaaa\";")); 9311 EXPECT_EQ("ffff(\n" 9312 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9313 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9314 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 9315 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9316 getGoogleStyle())); 9317 9318 FormatStyle Style = getLLVMStyleWithColumns(12); 9319 Style.BreakStringLiterals = false; 9320 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 9321 9322 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 9323 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9324 EXPECT_EQ("#define A \\\n" 9325 " \"some \" \\\n" 9326 " \"text \" \\\n" 9327 " \"other\";", 9328 format("#define A \"some text other\";", AlignLeft)); 9329 } 9330 9331 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 9332 EXPECT_EQ("C a = \"some more \"\n" 9333 " \"text\";", 9334 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 9335 } 9336 9337 TEST_F(FormatTest, FullyRemoveEmptyLines) { 9338 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 9339 NoEmptyLines.MaxEmptyLinesToKeep = 0; 9340 EXPECT_EQ("int i = a(b());", 9341 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 9342 } 9343 9344 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 9345 EXPECT_EQ( 9346 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9347 "(\n" 9348 " \"x\t\");", 9349 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9350 "aaaaaaa(" 9351 "\"x\t\");")); 9352 } 9353 9354 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 9355 EXPECT_EQ( 9356 "u8\"utf8 string \"\n" 9357 "u8\"literal\";", 9358 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 9359 EXPECT_EQ( 9360 "u\"utf16 string \"\n" 9361 "u\"literal\";", 9362 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 9363 EXPECT_EQ( 9364 "U\"utf32 string \"\n" 9365 "U\"literal\";", 9366 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 9367 EXPECT_EQ("L\"wide string \"\n" 9368 "L\"literal\";", 9369 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 9370 EXPECT_EQ("@\"NSString \"\n" 9371 "@\"literal\";", 9372 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 9373 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 9374 9375 // This input makes clang-format try to split the incomplete unicode escape 9376 // sequence, which used to lead to a crasher. 9377 verifyNoCrash( 9378 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 9379 getLLVMStyleWithColumns(60)); 9380 } 9381 9382 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 9383 FormatStyle Style = getGoogleStyleWithColumns(15); 9384 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 9385 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 9386 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 9387 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 9388 EXPECT_EQ("u8R\"x(raw literal)x\";", 9389 format("u8R\"x(raw literal)x\";", Style)); 9390 } 9391 9392 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 9393 FormatStyle Style = getLLVMStyleWithColumns(20); 9394 EXPECT_EQ( 9395 "_T(\"aaaaaaaaaaaaaa\")\n" 9396 "_T(\"aaaaaaaaaaaaaa\")\n" 9397 "_T(\"aaaaaaaaaaaa\")", 9398 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 9399 EXPECT_EQ("f(x,\n" 9400 " _T(\"aaaaaaaaaaaa\")\n" 9401 " _T(\"aaa\"),\n" 9402 " z);", 9403 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 9404 9405 // FIXME: Handle embedded spaces in one iteration. 9406 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 9407 // "_T(\"aaaaaaaaaaaaa\")\n" 9408 // "_T(\"aaaaaaaaaaaaa\")\n" 9409 // "_T(\"a\")", 9410 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9411 // getLLVMStyleWithColumns(20))); 9412 EXPECT_EQ( 9413 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9414 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 9415 EXPECT_EQ("f(\n" 9416 "#if !TEST\n" 9417 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9418 "#endif\n" 9419 ");", 9420 format("f(\n" 9421 "#if !TEST\n" 9422 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9423 "#endif\n" 9424 ");")); 9425 EXPECT_EQ("f(\n" 9426 "\n" 9427 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 9428 format("f(\n" 9429 "\n" 9430 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 9431 } 9432 9433 TEST_F(FormatTest, BreaksStringLiteralOperands) { 9434 // In a function call with two operands, the second can be broken with no line 9435 // break before it. 9436 EXPECT_EQ( 9437 "func(a, \"long long \"\n" 9438 " \"long long\");", 9439 format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24))); 9440 // In a function call with three operands, the second must be broken with a 9441 // line break before it. 9442 EXPECT_EQ("func(a,\n" 9443 " \"long long long \"\n" 9444 " \"long\",\n" 9445 " c);", 9446 format("func(a, \"long long long long\", c);", 9447 getLLVMStyleWithColumns(24))); 9448 // In a function call with three operands, the third must be broken with a 9449 // line break before it. 9450 EXPECT_EQ("func(a, b,\n" 9451 " \"long long long \"\n" 9452 " \"long\");", 9453 format("func(a, b, \"long long long long\");", 9454 getLLVMStyleWithColumns(24))); 9455 // In a function call with three operands, both the second and the third must 9456 // be broken with a line break before them. 9457 EXPECT_EQ("func(a,\n" 9458 " \"long long long \"\n" 9459 " \"long\",\n" 9460 " \"long long long \"\n" 9461 " \"long\");", 9462 format("func(a, \"long long long long\", \"long long long long\");", 9463 getLLVMStyleWithColumns(24))); 9464 // In a chain of << with two operands, the second can be broken with no line 9465 // break before it. 9466 EXPECT_EQ("a << \"line line \"\n" 9467 " \"line\";", 9468 format("a << \"line line line\";", getLLVMStyleWithColumns(20))); 9469 // In a chain of << with three operands, the second can be broken with no line 9470 // break before it. 9471 EXPECT_EQ( 9472 "abcde << \"line \"\n" 9473 " \"line line\"\n" 9474 " << c;", 9475 format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20))); 9476 // In a chain of << with three operands, the third must be broken with a line 9477 // break before it. 9478 EXPECT_EQ( 9479 "a << b\n" 9480 " << \"line line \"\n" 9481 " \"line\";", 9482 format("a << b << \"line line line\";", getLLVMStyleWithColumns(20))); 9483 // In a chain of << with three operands, the second can be broken with no line 9484 // break before it and the third must be broken with a line break before it. 9485 EXPECT_EQ("abcd << \"line line \"\n" 9486 " \"line\"\n" 9487 " << \"line line \"\n" 9488 " \"line\";", 9489 format("abcd << \"line line line\" << \"line line line\";", 9490 getLLVMStyleWithColumns(20))); 9491 // In a chain of binary operators with two operands, the second can be broken 9492 // with no line break before it. 9493 EXPECT_EQ( 9494 "abcd + \"line line \"\n" 9495 " \"line line\";", 9496 format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20))); 9497 // In a chain of binary operators with three operands, the second must be 9498 // broken with a line break before it. 9499 EXPECT_EQ("abcd +\n" 9500 " \"line line \"\n" 9501 " \"line line\" +\n" 9502 " e;", 9503 format("abcd + \"line line line line\" + e;", 9504 getLLVMStyleWithColumns(20))); 9505 // In a function call with two operands, with AlignAfterOpenBracket enabled, 9506 // the first must be broken with a line break before it. 9507 FormatStyle Style = getLLVMStyleWithColumns(25); 9508 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 9509 EXPECT_EQ("someFunction(\n" 9510 " \"long long long \"\n" 9511 " \"long\",\n" 9512 " a);", 9513 format("someFunction(\"long long long long\", a);", Style)); 9514 } 9515 9516 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 9517 EXPECT_EQ( 9518 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9519 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9520 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9521 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9522 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9523 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 9524 } 9525 9526 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 9527 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 9528 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 9529 EXPECT_EQ("fffffffffff(g(R\"x(\n" 9530 "multiline raw string literal xxxxxxxxxxxxxx\n" 9531 ")x\",\n" 9532 " a),\n" 9533 " b);", 9534 format("fffffffffff(g(R\"x(\n" 9535 "multiline raw string literal xxxxxxxxxxxxxx\n" 9536 ")x\", a), b);", 9537 getGoogleStyleWithColumns(20))); 9538 EXPECT_EQ("fffffffffff(\n" 9539 " g(R\"x(qqq\n" 9540 "multiline raw string literal xxxxxxxxxxxxxx\n" 9541 ")x\",\n" 9542 " a),\n" 9543 " b);", 9544 format("fffffffffff(g(R\"x(qqq\n" 9545 "multiline raw string literal xxxxxxxxxxxxxx\n" 9546 ")x\", a), b);", 9547 getGoogleStyleWithColumns(20))); 9548 9549 EXPECT_EQ("fffffffffff(R\"x(\n" 9550 "multiline raw string literal xxxxxxxxxxxxxx\n" 9551 ")x\");", 9552 format("fffffffffff(R\"x(\n" 9553 "multiline raw string literal xxxxxxxxxxxxxx\n" 9554 ")x\");", 9555 getGoogleStyleWithColumns(20))); 9556 EXPECT_EQ("fffffffffff(R\"x(\n" 9557 "multiline raw string literal xxxxxxxxxxxxxx\n" 9558 ")x\" + bbbbbb);", 9559 format("fffffffffff(R\"x(\n" 9560 "multiline raw string literal xxxxxxxxxxxxxx\n" 9561 ")x\" + bbbbbb);", 9562 getGoogleStyleWithColumns(20))); 9563 EXPECT_EQ("fffffffffff(\n" 9564 " R\"x(\n" 9565 "multiline raw string literal xxxxxxxxxxxxxx\n" 9566 ")x\" +\n" 9567 " bbbbbb);", 9568 format("fffffffffff(\n" 9569 " R\"x(\n" 9570 "multiline raw string literal xxxxxxxxxxxxxx\n" 9571 ")x\" + bbbbbb);", 9572 getGoogleStyleWithColumns(20))); 9573 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 9574 format("fffffffffff(\n" 9575 " R\"(single line raw string)\" + bbbbbb);")); 9576 } 9577 9578 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 9579 verifyFormat("string a = \"unterminated;"); 9580 EXPECT_EQ("function(\"unterminated,\n" 9581 " OtherParameter);", 9582 format("function( \"unterminated,\n" 9583 " OtherParameter);")); 9584 } 9585 9586 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9587 FormatStyle Style = getLLVMStyle(); 9588 Style.Standard = FormatStyle::LS_Cpp03; 9589 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9590 format("#define x(_a) printf(\"foo\"_a);", Style)); 9591 } 9592 9593 TEST_F(FormatTest, CppLexVersion) { 9594 FormatStyle Style = getLLVMStyle(); 9595 // Formatting of x * y differs if x is a type. 9596 verifyFormat("void foo() { MACRO(a * b); }", Style); 9597 verifyFormat("void foo() { MACRO(int *b); }", Style); 9598 9599 // LLVM style uses latest lexer. 9600 verifyFormat("void foo() { MACRO(char8_t *b); }", Style); 9601 Style.Standard = FormatStyle::LS_Cpp17; 9602 // But in c++17, char8_t isn't a keyword. 9603 verifyFormat("void foo() { MACRO(char8_t * b); }", Style); 9604 } 9605 9606 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9607 9608 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9609 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9610 " \"ddeeefff\");", 9611 format("someFunction(\"aaabbbcccdddeeefff\");", 9612 getLLVMStyleWithColumns(25))); 9613 EXPECT_EQ("someFunction1234567890(\n" 9614 " \"aaabbbcccdddeeefff\");", 9615 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9616 getLLVMStyleWithColumns(26))); 9617 EXPECT_EQ("someFunction1234567890(\n" 9618 " \"aaabbbcccdddeeeff\"\n" 9619 " \"f\");", 9620 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9621 getLLVMStyleWithColumns(25))); 9622 EXPECT_EQ("someFunction1234567890(\n" 9623 " \"aaabbbcccdddeeeff\"\n" 9624 " \"f\");", 9625 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9626 getLLVMStyleWithColumns(24))); 9627 EXPECT_EQ("someFunction(\n" 9628 " \"aaabbbcc ddde \"\n" 9629 " \"efff\");", 9630 format("someFunction(\"aaabbbcc ddde efff\");", 9631 getLLVMStyleWithColumns(25))); 9632 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9633 " \"ddeeefff\");", 9634 format("someFunction(\"aaabbbccc ddeeefff\");", 9635 getLLVMStyleWithColumns(25))); 9636 EXPECT_EQ("someFunction1234567890(\n" 9637 " \"aaabb \"\n" 9638 " \"cccdddeeefff\");", 9639 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9640 getLLVMStyleWithColumns(25))); 9641 EXPECT_EQ("#define A \\\n" 9642 " string s = \\\n" 9643 " \"123456789\" \\\n" 9644 " \"0\"; \\\n" 9645 " int i;", 9646 format("#define A string s = \"1234567890\"; int i;", 9647 getLLVMStyleWithColumns(20))); 9648 EXPECT_EQ("someFunction(\n" 9649 " \"aaabbbcc \"\n" 9650 " \"dddeeefff\");", 9651 format("someFunction(\"aaabbbcc dddeeefff\");", 9652 getLLVMStyleWithColumns(25))); 9653 } 9654 9655 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9656 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9657 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9658 EXPECT_EQ("\"test\"\n" 9659 "\"\\n\"", 9660 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9661 EXPECT_EQ("\"tes\\\\\"\n" 9662 "\"n\"", 9663 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9664 EXPECT_EQ("\"\\\\\\\\\"\n" 9665 "\"\\n\"", 9666 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9667 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9668 EXPECT_EQ("\"\\uff01\"\n" 9669 "\"test\"", 9670 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9671 EXPECT_EQ("\"\\Uff01ff02\"", 9672 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9673 EXPECT_EQ("\"\\x000000000001\"\n" 9674 "\"next\"", 9675 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9676 EXPECT_EQ("\"\\x000000000001next\"", 9677 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9678 EXPECT_EQ("\"\\x000000000001\"", 9679 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9680 EXPECT_EQ("\"test\"\n" 9681 "\"\\000000\"\n" 9682 "\"000001\"", 9683 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9684 EXPECT_EQ("\"test\\000\"\n" 9685 "\"00000000\"\n" 9686 "\"1\"", 9687 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9688 } 9689 9690 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9691 verifyFormat("void f() {\n" 9692 " return g() {}\n" 9693 " void h() {}"); 9694 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9695 "g();\n" 9696 "}"); 9697 } 9698 9699 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9700 verifyFormat( 9701 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9702 } 9703 9704 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9705 verifyFormat("class X {\n" 9706 " void f() {\n" 9707 " }\n" 9708 "};", 9709 getLLVMStyleWithColumns(12)); 9710 } 9711 9712 TEST_F(FormatTest, ConfigurableIndentWidth) { 9713 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9714 EightIndent.IndentWidth = 8; 9715 EightIndent.ContinuationIndentWidth = 8; 9716 verifyFormat("void f() {\n" 9717 " someFunction();\n" 9718 " if (true) {\n" 9719 " f();\n" 9720 " }\n" 9721 "}", 9722 EightIndent); 9723 verifyFormat("class X {\n" 9724 " void f() {\n" 9725 " }\n" 9726 "};", 9727 EightIndent); 9728 verifyFormat("int x[] = {\n" 9729 " call(),\n" 9730 " call()};", 9731 EightIndent); 9732 } 9733 9734 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9735 verifyFormat("double\n" 9736 "f();", 9737 getLLVMStyleWithColumns(8)); 9738 } 9739 9740 TEST_F(FormatTest, ConfigurableUseOfTab) { 9741 FormatStyle Tab = getLLVMStyleWithColumns(42); 9742 Tab.IndentWidth = 8; 9743 Tab.UseTab = FormatStyle::UT_Always; 9744 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9745 9746 EXPECT_EQ("if (aaaaaaaa && // q\n" 9747 " bb)\t\t// w\n" 9748 "\t;", 9749 format("if (aaaaaaaa &&// q\n" 9750 "bb)// w\n" 9751 ";", 9752 Tab)); 9753 EXPECT_EQ("if (aaa && bbb) // w\n" 9754 "\t;", 9755 format("if(aaa&&bbb)// w\n" 9756 ";", 9757 Tab)); 9758 9759 verifyFormat("class X {\n" 9760 "\tvoid f() {\n" 9761 "\t\tsomeFunction(parameter1,\n" 9762 "\t\t\t parameter2);\n" 9763 "\t}\n" 9764 "};", 9765 Tab); 9766 verifyFormat("#define A \\\n" 9767 "\tvoid f() { \\\n" 9768 "\t\tsomeFunction( \\\n" 9769 "\t\t parameter1, \\\n" 9770 "\t\t parameter2); \\\n" 9771 "\t}", 9772 Tab); 9773 verifyFormat("int a;\t // x\n" 9774 "int bbbbbbbb; // x\n", 9775 Tab); 9776 9777 Tab.TabWidth = 4; 9778 Tab.IndentWidth = 8; 9779 verifyFormat("class TabWidth4Indent8 {\n" 9780 "\t\tvoid f() {\n" 9781 "\t\t\t\tsomeFunction(parameter1,\n" 9782 "\t\t\t\t\t\t\t parameter2);\n" 9783 "\t\t}\n" 9784 "};", 9785 Tab); 9786 9787 Tab.TabWidth = 4; 9788 Tab.IndentWidth = 4; 9789 verifyFormat("class TabWidth4Indent4 {\n" 9790 "\tvoid f() {\n" 9791 "\t\tsomeFunction(parameter1,\n" 9792 "\t\t\t\t\t parameter2);\n" 9793 "\t}\n" 9794 "};", 9795 Tab); 9796 9797 Tab.TabWidth = 8; 9798 Tab.IndentWidth = 4; 9799 verifyFormat("class TabWidth8Indent4 {\n" 9800 " void f() {\n" 9801 "\tsomeFunction(parameter1,\n" 9802 "\t\t parameter2);\n" 9803 " }\n" 9804 "};", 9805 Tab); 9806 9807 Tab.TabWidth = 8; 9808 Tab.IndentWidth = 8; 9809 EXPECT_EQ("/*\n" 9810 "\t a\t\tcomment\n" 9811 "\t in multiple lines\n" 9812 " */", 9813 format(" /*\t \t \n" 9814 " \t \t a\t\tcomment\t \t\n" 9815 " \t \t in multiple lines\t\n" 9816 " \t */", 9817 Tab)); 9818 9819 Tab.UseTab = FormatStyle::UT_ForIndentation; 9820 verifyFormat("{\n" 9821 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9822 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9823 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9824 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9825 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9826 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9827 "};", 9828 Tab); 9829 verifyFormat("enum AA {\n" 9830 "\ta1, // Force multiple lines\n" 9831 "\ta2,\n" 9832 "\ta3\n" 9833 "};", 9834 Tab); 9835 EXPECT_EQ("if (aaaaaaaa && // q\n" 9836 " bb) // w\n" 9837 "\t;", 9838 format("if (aaaaaaaa &&// q\n" 9839 "bb)// w\n" 9840 ";", 9841 Tab)); 9842 verifyFormat("class X {\n" 9843 "\tvoid f() {\n" 9844 "\t\tsomeFunction(parameter1,\n" 9845 "\t\t parameter2);\n" 9846 "\t}\n" 9847 "};", 9848 Tab); 9849 verifyFormat("{\n" 9850 "\tQ(\n" 9851 "\t {\n" 9852 "\t\t int a;\n" 9853 "\t\t someFunction(aaaaaaaa,\n" 9854 "\t\t bbbbbbb);\n" 9855 "\t },\n" 9856 "\t p);\n" 9857 "}", 9858 Tab); 9859 EXPECT_EQ("{\n" 9860 "\t/* aaaa\n" 9861 "\t bbbb */\n" 9862 "}", 9863 format("{\n" 9864 "/* aaaa\n" 9865 " bbbb */\n" 9866 "}", 9867 Tab)); 9868 EXPECT_EQ("{\n" 9869 "\t/*\n" 9870 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9871 "\t bbbbbbbbbbbbb\n" 9872 "\t*/\n" 9873 "}", 9874 format("{\n" 9875 "/*\n" 9876 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9877 "*/\n" 9878 "}", 9879 Tab)); 9880 EXPECT_EQ("{\n" 9881 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9882 "\t// bbbbbbbbbbbbb\n" 9883 "}", 9884 format("{\n" 9885 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9886 "}", 9887 Tab)); 9888 EXPECT_EQ("{\n" 9889 "\t/*\n" 9890 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9891 "\t bbbbbbbbbbbbb\n" 9892 "\t*/\n" 9893 "}", 9894 format("{\n" 9895 "\t/*\n" 9896 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9897 "\t*/\n" 9898 "}", 9899 Tab)); 9900 EXPECT_EQ("{\n" 9901 "\t/*\n" 9902 "\n" 9903 "\t*/\n" 9904 "}", 9905 format("{\n" 9906 "\t/*\n" 9907 "\n" 9908 "\t*/\n" 9909 "}", 9910 Tab)); 9911 EXPECT_EQ("{\n" 9912 "\t/*\n" 9913 " asdf\n" 9914 "\t*/\n" 9915 "}", 9916 format("{\n" 9917 "\t/*\n" 9918 " asdf\n" 9919 "\t*/\n" 9920 "}", 9921 Tab)); 9922 9923 Tab.UseTab = FormatStyle::UT_Never; 9924 EXPECT_EQ("/*\n" 9925 " a\t\tcomment\n" 9926 " in multiple lines\n" 9927 " */", 9928 format(" /*\t \t \n" 9929 " \t \t a\t\tcomment\t \t\n" 9930 " \t \t in multiple lines\t\n" 9931 " \t */", 9932 Tab)); 9933 EXPECT_EQ("/* some\n" 9934 " comment */", 9935 format(" \t \t /* some\n" 9936 " \t \t comment */", 9937 Tab)); 9938 EXPECT_EQ("int a; /* some\n" 9939 " comment */", 9940 format(" \t \t int a; /* some\n" 9941 " \t \t comment */", 9942 Tab)); 9943 9944 EXPECT_EQ("int a; /* some\n" 9945 "comment */", 9946 format(" \t \t int\ta; /* some\n" 9947 " \t \t comment */", 9948 Tab)); 9949 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9950 " comment */", 9951 format(" \t \t f(\"\t\t\"); /* some\n" 9952 " \t \t comment */", 9953 Tab)); 9954 EXPECT_EQ("{\n" 9955 " /*\n" 9956 " * Comment\n" 9957 " */\n" 9958 " int i;\n" 9959 "}", 9960 format("{\n" 9961 "\t/*\n" 9962 "\t * Comment\n" 9963 "\t */\n" 9964 "\t int i;\n" 9965 "}")); 9966 9967 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 9968 Tab.TabWidth = 8; 9969 Tab.IndentWidth = 8; 9970 EXPECT_EQ("if (aaaaaaaa && // q\n" 9971 " bb) // w\n" 9972 "\t;", 9973 format("if (aaaaaaaa &&// q\n" 9974 "bb)// w\n" 9975 ";", 9976 Tab)); 9977 EXPECT_EQ("if (aaa && bbb) // w\n" 9978 "\t;", 9979 format("if(aaa&&bbb)// w\n" 9980 ";", 9981 Tab)); 9982 verifyFormat("class X {\n" 9983 "\tvoid f() {\n" 9984 "\t\tsomeFunction(parameter1,\n" 9985 "\t\t\t parameter2);\n" 9986 "\t}\n" 9987 "};", 9988 Tab); 9989 verifyFormat("#define A \\\n" 9990 "\tvoid f() { \\\n" 9991 "\t\tsomeFunction( \\\n" 9992 "\t\t parameter1, \\\n" 9993 "\t\t parameter2); \\\n" 9994 "\t}", 9995 Tab); 9996 Tab.TabWidth = 4; 9997 Tab.IndentWidth = 8; 9998 verifyFormat("class TabWidth4Indent8 {\n" 9999 "\t\tvoid f() {\n" 10000 "\t\t\t\tsomeFunction(parameter1,\n" 10001 "\t\t\t\t\t\t\t parameter2);\n" 10002 "\t\t}\n" 10003 "};", 10004 Tab); 10005 Tab.TabWidth = 4; 10006 Tab.IndentWidth = 4; 10007 verifyFormat("class TabWidth4Indent4 {\n" 10008 "\tvoid f() {\n" 10009 "\t\tsomeFunction(parameter1,\n" 10010 "\t\t\t\t\t parameter2);\n" 10011 "\t}\n" 10012 "};", 10013 Tab); 10014 Tab.TabWidth = 8; 10015 Tab.IndentWidth = 4; 10016 verifyFormat("class TabWidth8Indent4 {\n" 10017 " void f() {\n" 10018 "\tsomeFunction(parameter1,\n" 10019 "\t\t parameter2);\n" 10020 " }\n" 10021 "};", 10022 Tab); 10023 Tab.TabWidth = 8; 10024 Tab.IndentWidth = 8; 10025 EXPECT_EQ("/*\n" 10026 "\t a\t\tcomment\n" 10027 "\t in multiple lines\n" 10028 " */", 10029 format(" /*\t \t \n" 10030 " \t \t a\t\tcomment\t \t\n" 10031 " \t \t in multiple lines\t\n" 10032 " \t */", 10033 Tab)); 10034 verifyFormat("{\n" 10035 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10036 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10037 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10038 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10039 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10040 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10041 "};", 10042 Tab); 10043 verifyFormat("enum AA {\n" 10044 "\ta1, // Force multiple lines\n" 10045 "\ta2,\n" 10046 "\ta3\n" 10047 "};", 10048 Tab); 10049 EXPECT_EQ("if (aaaaaaaa && // q\n" 10050 " bb) // w\n" 10051 "\t;", 10052 format("if (aaaaaaaa &&// q\n" 10053 "bb)// w\n" 10054 ";", 10055 Tab)); 10056 verifyFormat("class X {\n" 10057 "\tvoid f() {\n" 10058 "\t\tsomeFunction(parameter1,\n" 10059 "\t\t\t parameter2);\n" 10060 "\t}\n" 10061 "};", 10062 Tab); 10063 verifyFormat("{\n" 10064 "\tQ(\n" 10065 "\t {\n" 10066 "\t\t int a;\n" 10067 "\t\t someFunction(aaaaaaaa,\n" 10068 "\t\t\t\t bbbbbbb);\n" 10069 "\t },\n" 10070 "\t p);\n" 10071 "}", 10072 Tab); 10073 EXPECT_EQ("{\n" 10074 "\t/* aaaa\n" 10075 "\t bbbb */\n" 10076 "}", 10077 format("{\n" 10078 "/* aaaa\n" 10079 " bbbb */\n" 10080 "}", 10081 Tab)); 10082 EXPECT_EQ("{\n" 10083 "\t/*\n" 10084 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10085 "\t bbbbbbbbbbbbb\n" 10086 "\t*/\n" 10087 "}", 10088 format("{\n" 10089 "/*\n" 10090 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10091 "*/\n" 10092 "}", 10093 Tab)); 10094 EXPECT_EQ("{\n" 10095 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10096 "\t// bbbbbbbbbbbbb\n" 10097 "}", 10098 format("{\n" 10099 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10100 "}", 10101 Tab)); 10102 EXPECT_EQ("{\n" 10103 "\t/*\n" 10104 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10105 "\t bbbbbbbbbbbbb\n" 10106 "\t*/\n" 10107 "}", 10108 format("{\n" 10109 "\t/*\n" 10110 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10111 "\t*/\n" 10112 "}", 10113 Tab)); 10114 EXPECT_EQ("{\n" 10115 "\t/*\n" 10116 "\n" 10117 "\t*/\n" 10118 "}", 10119 format("{\n" 10120 "\t/*\n" 10121 "\n" 10122 "\t*/\n" 10123 "}", 10124 Tab)); 10125 EXPECT_EQ("{\n" 10126 "\t/*\n" 10127 " asdf\n" 10128 "\t*/\n" 10129 "}", 10130 format("{\n" 10131 "\t/*\n" 10132 " asdf\n" 10133 "\t*/\n" 10134 "}", 10135 Tab)); 10136 EXPECT_EQ("/*\n" 10137 "\t a\t\tcomment\n" 10138 "\t in multiple lines\n" 10139 " */", 10140 format(" /*\t \t \n" 10141 " \t \t a\t\tcomment\t \t\n" 10142 " \t \t in multiple lines\t\n" 10143 " \t */", 10144 Tab)); 10145 EXPECT_EQ("/* some\n" 10146 " comment */", 10147 format(" \t \t /* some\n" 10148 " \t \t comment */", 10149 Tab)); 10150 EXPECT_EQ("int a; /* some\n" 10151 " comment */", 10152 format(" \t \t int a; /* some\n" 10153 " \t \t comment */", 10154 Tab)); 10155 EXPECT_EQ("int a; /* some\n" 10156 "comment */", 10157 format(" \t \t int\ta; /* some\n" 10158 " \t \t comment */", 10159 Tab)); 10160 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10161 " comment */", 10162 format(" \t \t f(\"\t\t\"); /* some\n" 10163 " \t \t comment */", 10164 Tab)); 10165 EXPECT_EQ("{\n" 10166 " /*\n" 10167 " * Comment\n" 10168 " */\n" 10169 " int i;\n" 10170 "}", 10171 format("{\n" 10172 "\t/*\n" 10173 "\t * Comment\n" 10174 "\t */\n" 10175 "\t int i;\n" 10176 "}")); 10177 Tab.AlignConsecutiveAssignments = true; 10178 Tab.AlignConsecutiveDeclarations = true; 10179 Tab.TabWidth = 4; 10180 Tab.IndentWidth = 4; 10181 verifyFormat("class Assign {\n" 10182 "\tvoid f() {\n" 10183 "\t\tint x = 123;\n" 10184 "\t\tint random = 4;\n" 10185 "\t\tstd::string alphabet =\n" 10186 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 10187 "\t}\n" 10188 "};", 10189 Tab); 10190 } 10191 10192 TEST_F(FormatTest, ZeroTabWidth) { 10193 FormatStyle Tab = getLLVMStyleWithColumns(42); 10194 Tab.IndentWidth = 8; 10195 Tab.UseTab = FormatStyle::UT_Never; 10196 Tab.TabWidth = 0; 10197 EXPECT_EQ("void a(){\n" 10198 " // line starts with '\t'\n" 10199 "};", 10200 format("void a(){\n" 10201 "\t// line starts with '\t'\n" 10202 "};", 10203 Tab)); 10204 10205 EXPECT_EQ("void a(){\n" 10206 " // line starts with '\t'\n" 10207 "};", 10208 format("void a(){\n" 10209 "\t\t// line starts with '\t'\n" 10210 "};", 10211 Tab)); 10212 10213 Tab.UseTab = FormatStyle::UT_ForIndentation; 10214 EXPECT_EQ("void a(){\n" 10215 " // line starts with '\t'\n" 10216 "};", 10217 format("void a(){\n" 10218 "\t// line starts with '\t'\n" 10219 "};", 10220 Tab)); 10221 10222 EXPECT_EQ("void a(){\n" 10223 " // line starts with '\t'\n" 10224 "};", 10225 format("void a(){\n" 10226 "\t\t// line starts with '\t'\n" 10227 "};", 10228 Tab)); 10229 10230 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10231 EXPECT_EQ("void a(){\n" 10232 " // line starts with '\t'\n" 10233 "};", 10234 format("void a(){\n" 10235 "\t// line starts with '\t'\n" 10236 "};", 10237 Tab)); 10238 10239 EXPECT_EQ("void a(){\n" 10240 " // line starts with '\t'\n" 10241 "};", 10242 format("void a(){\n" 10243 "\t\t// line starts with '\t'\n" 10244 "};", 10245 Tab)); 10246 10247 Tab.UseTab = FormatStyle::UT_Always; 10248 EXPECT_EQ("void a(){\n" 10249 "// line starts with '\t'\n" 10250 "};", 10251 format("void a(){\n" 10252 "\t// line starts with '\t'\n" 10253 "};", 10254 Tab)); 10255 10256 EXPECT_EQ("void a(){\n" 10257 "// line starts with '\t'\n" 10258 "};", 10259 format("void a(){\n" 10260 "\t\t// line starts with '\t'\n" 10261 "};", 10262 Tab)); 10263 } 10264 10265 TEST_F(FormatTest, CalculatesOriginalColumn) { 10266 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10267 "q\"; /* some\n" 10268 " comment */", 10269 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10270 "q\"; /* some\n" 10271 " comment */", 10272 getLLVMStyle())); 10273 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10274 "/* some\n" 10275 " comment */", 10276 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10277 " /* some\n" 10278 " comment */", 10279 getLLVMStyle())); 10280 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10281 "qqq\n" 10282 "/* some\n" 10283 " comment */", 10284 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10285 "qqq\n" 10286 " /* some\n" 10287 " comment */", 10288 getLLVMStyle())); 10289 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10290 "wwww; /* some\n" 10291 " comment */", 10292 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10293 "wwww; /* some\n" 10294 " comment */", 10295 getLLVMStyle())); 10296 } 10297 10298 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 10299 FormatStyle NoSpace = getLLVMStyle(); 10300 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 10301 10302 verifyFormat("while(true)\n" 10303 " continue;", 10304 NoSpace); 10305 verifyFormat("for(;;)\n" 10306 " continue;", 10307 NoSpace); 10308 verifyFormat("if(true)\n" 10309 " f();\n" 10310 "else if(true)\n" 10311 " f();", 10312 NoSpace); 10313 verifyFormat("do {\n" 10314 " do_something();\n" 10315 "} while(something());", 10316 NoSpace); 10317 verifyFormat("switch(x) {\n" 10318 "default:\n" 10319 " break;\n" 10320 "}", 10321 NoSpace); 10322 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 10323 verifyFormat("size_t x = sizeof(x);", NoSpace); 10324 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 10325 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 10326 verifyFormat("alignas(128) char a[128];", NoSpace); 10327 verifyFormat("size_t x = alignof(MyType);", NoSpace); 10328 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 10329 verifyFormat("int f() throw(Deprecated);", NoSpace); 10330 verifyFormat("typedef void (*cb)(int);", NoSpace); 10331 verifyFormat("T A::operator()();", NoSpace); 10332 verifyFormat("X A::operator++(T);", NoSpace); 10333 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 10334 10335 FormatStyle Space = getLLVMStyle(); 10336 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 10337 10338 verifyFormat("int f ();", Space); 10339 verifyFormat("void f (int a, T b) {\n" 10340 " while (true)\n" 10341 " continue;\n" 10342 "}", 10343 Space); 10344 verifyFormat("if (true)\n" 10345 " f ();\n" 10346 "else if (true)\n" 10347 " f ();", 10348 Space); 10349 verifyFormat("do {\n" 10350 " do_something ();\n" 10351 "} while (something ());", 10352 Space); 10353 verifyFormat("switch (x) {\n" 10354 "default:\n" 10355 " break;\n" 10356 "}", 10357 Space); 10358 verifyFormat("A::A () : a (1) {}", Space); 10359 verifyFormat("void f () __attribute__ ((asdf));", Space); 10360 verifyFormat("*(&a + 1);\n" 10361 "&((&a)[1]);\n" 10362 "a[(b + c) * d];\n" 10363 "(((a + 1) * 2) + 3) * 4;", 10364 Space); 10365 verifyFormat("#define A(x) x", Space); 10366 verifyFormat("#define A (x) x", Space); 10367 verifyFormat("#if defined(x)\n" 10368 "#endif", 10369 Space); 10370 verifyFormat("auto i = std::make_unique<int> (5);", Space); 10371 verifyFormat("size_t x = sizeof (x);", Space); 10372 verifyFormat("auto f (int x) -> decltype (x);", Space); 10373 verifyFormat("int f (T x) noexcept (x.create ());", Space); 10374 verifyFormat("alignas (128) char a[128];", Space); 10375 verifyFormat("size_t x = alignof (MyType);", Space); 10376 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 10377 verifyFormat("int f () throw (Deprecated);", Space); 10378 verifyFormat("typedef void (*cb) (int);", Space); 10379 verifyFormat("T A::operator() ();", Space); 10380 verifyFormat("X A::operator++ (T);", Space); 10381 verifyFormat("auto lambda = [] () { return 0; };", Space); 10382 verifyFormat("int x = int (y);", Space); 10383 10384 FormatStyle SomeSpace = getLLVMStyle(); 10385 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 10386 10387 verifyFormat("[]() -> float {}", SomeSpace); 10388 verifyFormat("[] (auto foo) {}", SomeSpace); 10389 verifyFormat("[foo]() -> int {}", SomeSpace); 10390 verifyFormat("int f();", SomeSpace); 10391 verifyFormat("void f (int a, T b) {\n" 10392 " while (true)\n" 10393 " continue;\n" 10394 "}", 10395 SomeSpace); 10396 verifyFormat("if (true)\n" 10397 " f();\n" 10398 "else if (true)\n" 10399 " f();", 10400 SomeSpace); 10401 verifyFormat("do {\n" 10402 " do_something();\n" 10403 "} while (something());", 10404 SomeSpace); 10405 verifyFormat("switch (x) {\n" 10406 "default:\n" 10407 " break;\n" 10408 "}", 10409 SomeSpace); 10410 verifyFormat("A::A() : a (1) {}", SomeSpace); 10411 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 10412 verifyFormat("*(&a + 1);\n" 10413 "&((&a)[1]);\n" 10414 "a[(b + c) * d];\n" 10415 "(((a + 1) * 2) + 3) * 4;", 10416 SomeSpace); 10417 verifyFormat("#define A(x) x", SomeSpace); 10418 verifyFormat("#define A (x) x", SomeSpace); 10419 verifyFormat("#if defined(x)\n" 10420 "#endif", 10421 SomeSpace); 10422 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 10423 verifyFormat("size_t x = sizeof (x);", SomeSpace); 10424 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 10425 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 10426 verifyFormat("alignas (128) char a[128];", SomeSpace); 10427 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 10428 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 10429 SomeSpace); 10430 verifyFormat("int f() throw (Deprecated);", SomeSpace); 10431 verifyFormat("typedef void (*cb) (int);", SomeSpace); 10432 verifyFormat("T A::operator()();", SomeSpace); 10433 verifyFormat("X A::operator++ (T);", SomeSpace); 10434 verifyFormat("int x = int (y);", SomeSpace); 10435 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 10436 } 10437 10438 TEST_F(FormatTest, SpaceAfterLogicalNot) { 10439 FormatStyle Spaces = getLLVMStyle(); 10440 Spaces.SpaceAfterLogicalNot = true; 10441 10442 verifyFormat("bool x = ! y", Spaces); 10443 verifyFormat("if (! isFailure())", Spaces); 10444 verifyFormat("if (! (a && b))", Spaces); 10445 verifyFormat("\"Error!\"", Spaces); 10446 verifyFormat("! ! x", Spaces); 10447 } 10448 10449 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 10450 FormatStyle Spaces = getLLVMStyle(); 10451 10452 Spaces.SpacesInParentheses = true; 10453 verifyFormat("do_something( ::globalVar );", Spaces); 10454 verifyFormat("call( x, y, z );", Spaces); 10455 verifyFormat("call();", Spaces); 10456 verifyFormat("std::function<void( int, int )> callback;", Spaces); 10457 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 10458 Spaces); 10459 verifyFormat("while ( (bool)1 )\n" 10460 " continue;", 10461 Spaces); 10462 verifyFormat("for ( ;; )\n" 10463 " continue;", 10464 Spaces); 10465 verifyFormat("if ( true )\n" 10466 " f();\n" 10467 "else if ( true )\n" 10468 " f();", 10469 Spaces); 10470 verifyFormat("do {\n" 10471 " do_something( (int)i );\n" 10472 "} while ( something() );", 10473 Spaces); 10474 verifyFormat("switch ( x ) {\n" 10475 "default:\n" 10476 " break;\n" 10477 "}", 10478 Spaces); 10479 10480 Spaces.SpacesInParentheses = false; 10481 Spaces.SpacesInCStyleCastParentheses = true; 10482 verifyFormat("Type *A = ( Type * )P;", Spaces); 10483 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 10484 verifyFormat("x = ( int32 )y;", Spaces); 10485 verifyFormat("int a = ( int )(2.0f);", Spaces); 10486 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 10487 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 10488 verifyFormat("#define x (( int )-1)", Spaces); 10489 10490 // Run the first set of tests again with: 10491 Spaces.SpacesInParentheses = false; 10492 Spaces.SpaceInEmptyParentheses = true; 10493 Spaces.SpacesInCStyleCastParentheses = true; 10494 verifyFormat("call(x, y, z);", Spaces); 10495 verifyFormat("call( );", Spaces); 10496 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10497 verifyFormat("while (( bool )1)\n" 10498 " continue;", 10499 Spaces); 10500 verifyFormat("for (;;)\n" 10501 " continue;", 10502 Spaces); 10503 verifyFormat("if (true)\n" 10504 " f( );\n" 10505 "else if (true)\n" 10506 " f( );", 10507 Spaces); 10508 verifyFormat("do {\n" 10509 " do_something(( int )i);\n" 10510 "} while (something( ));", 10511 Spaces); 10512 verifyFormat("switch (x) {\n" 10513 "default:\n" 10514 " break;\n" 10515 "}", 10516 Spaces); 10517 10518 // Run the first set of tests again with: 10519 Spaces.SpaceAfterCStyleCast = true; 10520 verifyFormat("call(x, y, z);", Spaces); 10521 verifyFormat("call( );", Spaces); 10522 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10523 verifyFormat("while (( bool ) 1)\n" 10524 " continue;", 10525 Spaces); 10526 verifyFormat("for (;;)\n" 10527 " continue;", 10528 Spaces); 10529 verifyFormat("if (true)\n" 10530 " f( );\n" 10531 "else if (true)\n" 10532 " f( );", 10533 Spaces); 10534 verifyFormat("do {\n" 10535 " do_something(( int ) i);\n" 10536 "} while (something( ));", 10537 Spaces); 10538 verifyFormat("switch (x) {\n" 10539 "default:\n" 10540 " break;\n" 10541 "}", 10542 Spaces); 10543 10544 // Run subset of tests again with: 10545 Spaces.SpacesInCStyleCastParentheses = false; 10546 Spaces.SpaceAfterCStyleCast = true; 10547 verifyFormat("while ((bool) 1)\n" 10548 " continue;", 10549 Spaces); 10550 verifyFormat("do {\n" 10551 " do_something((int) i);\n" 10552 "} while (something( ));", 10553 Spaces); 10554 } 10555 10556 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 10557 verifyFormat("int a[5];"); 10558 verifyFormat("a[3] += 42;"); 10559 10560 FormatStyle Spaces = getLLVMStyle(); 10561 Spaces.SpacesInSquareBrackets = true; 10562 // Not lambdas. 10563 verifyFormat("int a[ 5 ];", Spaces); 10564 verifyFormat("a[ 3 ] += 42;", Spaces); 10565 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 10566 verifyFormat("double &operator[](int i) { return 0; }\n" 10567 "int i;", 10568 Spaces); 10569 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 10570 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 10571 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 10572 // Lambdas. 10573 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 10574 verifyFormat("return [ i, args... ] {};", Spaces); 10575 verifyFormat("int foo = [ &bar ]() {};", Spaces); 10576 verifyFormat("int foo = [ = ]() {};", Spaces); 10577 verifyFormat("int foo = [ =, &bar ]() {};", Spaces); 10578 verifyFormat("int foo = [ &bar, = ]() {};", Spaces); 10579 } 10580 10581 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 10582 verifyFormat("int a = 5;"); 10583 verifyFormat("a += 42;"); 10584 verifyFormat("a or_eq 8;"); 10585 10586 FormatStyle Spaces = getLLVMStyle(); 10587 Spaces.SpaceBeforeAssignmentOperators = false; 10588 verifyFormat("int a= 5;", Spaces); 10589 verifyFormat("a+= 42;", Spaces); 10590 verifyFormat("a or_eq 8;", Spaces); 10591 } 10592 10593 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 10594 verifyFormat("class Foo : public Bar {};"); 10595 verifyFormat("Foo::Foo() : foo(1) {}"); 10596 verifyFormat("for (auto a : b) {\n}"); 10597 verifyFormat("int x = a ? b : c;"); 10598 verifyFormat("{\n" 10599 "label0:\n" 10600 " int x = 0;\n" 10601 "}"); 10602 verifyFormat("switch (x) {\n" 10603 "case 1:\n" 10604 "default:\n" 10605 "}"); 10606 10607 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 10608 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 10609 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 10610 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 10611 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 10612 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 10613 verifyFormat("{\n" 10614 "label1:\n" 10615 " int x = 0;\n" 10616 "}", 10617 CtorInitializerStyle); 10618 verifyFormat("switch (x) {\n" 10619 "case 1:\n" 10620 "default:\n" 10621 "}", 10622 CtorInitializerStyle); 10623 CtorInitializerStyle.BreakConstructorInitializers = 10624 FormatStyle::BCIS_AfterColon; 10625 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 10626 " aaaaaaaaaaaaaaaa(1),\n" 10627 " bbbbbbbbbbbbbbbb(2) {}", 10628 CtorInitializerStyle); 10629 CtorInitializerStyle.BreakConstructorInitializers = 10630 FormatStyle::BCIS_BeforeComma; 10631 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10632 " : aaaaaaaaaaaaaaaa(1)\n" 10633 " , bbbbbbbbbbbbbbbb(2) {}", 10634 CtorInitializerStyle); 10635 CtorInitializerStyle.BreakConstructorInitializers = 10636 FormatStyle::BCIS_BeforeColon; 10637 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10638 " : aaaaaaaaaaaaaaaa(1),\n" 10639 " bbbbbbbbbbbbbbbb(2) {}", 10640 CtorInitializerStyle); 10641 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 10642 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10643 ": aaaaaaaaaaaaaaaa(1),\n" 10644 " bbbbbbbbbbbbbbbb(2) {}", 10645 CtorInitializerStyle); 10646 10647 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 10648 InheritanceStyle.SpaceBeforeInheritanceColon = false; 10649 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 10650 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 10651 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 10652 verifyFormat("int x = a ? b : c;", InheritanceStyle); 10653 verifyFormat("{\n" 10654 "label2:\n" 10655 " int x = 0;\n" 10656 "}", 10657 InheritanceStyle); 10658 verifyFormat("switch (x) {\n" 10659 "case 1:\n" 10660 "default:\n" 10661 "}", 10662 InheritanceStyle); 10663 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 10664 verifyFormat("class Foooooooooooooooooooooo:\n" 10665 " public aaaaaaaaaaaaaaaaaa,\n" 10666 " public bbbbbbbbbbbbbbbbbb {\n" 10667 "}", 10668 InheritanceStyle); 10669 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 10670 verifyFormat("class Foooooooooooooooooooooo\n" 10671 " : public aaaaaaaaaaaaaaaaaa\n" 10672 " , public bbbbbbbbbbbbbbbbbb {\n" 10673 "}", 10674 InheritanceStyle); 10675 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 10676 verifyFormat("class Foooooooooooooooooooooo\n" 10677 " : public aaaaaaaaaaaaaaaaaa,\n" 10678 " public bbbbbbbbbbbbbbbbbb {\n" 10679 "}", 10680 InheritanceStyle); 10681 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 10682 verifyFormat("class Foooooooooooooooooooooo\n" 10683 ": public aaaaaaaaaaaaaaaaaa,\n" 10684 " public bbbbbbbbbbbbbbbbbb {}", 10685 InheritanceStyle); 10686 10687 FormatStyle ForLoopStyle = getLLVMStyle(); 10688 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 10689 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 10690 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 10691 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 10692 verifyFormat("int x = a ? b : c;", ForLoopStyle); 10693 verifyFormat("{\n" 10694 "label2:\n" 10695 " int x = 0;\n" 10696 "}", 10697 ForLoopStyle); 10698 verifyFormat("switch (x) {\n" 10699 "case 1:\n" 10700 "default:\n" 10701 "}", 10702 ForLoopStyle); 10703 10704 FormatStyle NoSpaceStyle = getLLVMStyle(); 10705 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 10706 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 10707 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 10708 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 10709 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 10710 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 10711 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 10712 verifyFormat("{\n" 10713 "label3:\n" 10714 " int x = 0;\n" 10715 "}", 10716 NoSpaceStyle); 10717 verifyFormat("switch (x) {\n" 10718 "case 1:\n" 10719 "default:\n" 10720 "}", 10721 NoSpaceStyle); 10722 } 10723 10724 TEST_F(FormatTest, AlignConsecutiveMacros) { 10725 FormatStyle Style = getLLVMStyle(); 10726 Style.AlignConsecutiveAssignments = true; 10727 Style.AlignConsecutiveDeclarations = true; 10728 Style.AlignConsecutiveMacros = false; 10729 10730 verifyFormat("#define a 3\n" 10731 "#define bbbb 4\n" 10732 "#define ccc (5)", 10733 Style); 10734 10735 verifyFormat("#define f(x) (x * x)\n" 10736 "#define fff(x, y, z) (x * y + z)\n" 10737 "#define ffff(x, y) (x - y)", 10738 Style); 10739 10740 verifyFormat("#define foo(x, y) (x + y)\n" 10741 "#define bar (5, 6)(2 + 2)", 10742 Style); 10743 10744 verifyFormat("#define a 3\n" 10745 "#define bbbb 4\n" 10746 "#define ccc (5)\n" 10747 "#define f(x) (x * x)\n" 10748 "#define fff(x, y, z) (x * y + z)\n" 10749 "#define ffff(x, y) (x - y)", 10750 Style); 10751 10752 Style.AlignConsecutiveMacros = true; 10753 verifyFormat("#define a 3\n" 10754 "#define bbbb 4\n" 10755 "#define ccc (5)", 10756 Style); 10757 10758 verifyFormat("#define f(x) (x * x)\n" 10759 "#define fff(x, y, z) (x * y + z)\n" 10760 "#define ffff(x, y) (x - y)", 10761 Style); 10762 10763 verifyFormat("#define foo(x, y) (x + y)\n" 10764 "#define bar (5, 6)(2 + 2)", 10765 Style); 10766 10767 verifyFormat("#define a 3\n" 10768 "#define bbbb 4\n" 10769 "#define ccc (5)\n" 10770 "#define f(x) (x * x)\n" 10771 "#define fff(x, y, z) (x * y + z)\n" 10772 "#define ffff(x, y) (x - y)", 10773 Style); 10774 10775 verifyFormat("#define a 5\n" 10776 "#define foo(x, y) (x + y)\n" 10777 "#define CCC (6)\n" 10778 "auto lambda = []() {\n" 10779 " auto ii = 0;\n" 10780 " float j = 0;\n" 10781 " return 0;\n" 10782 "};\n" 10783 "int i = 0;\n" 10784 "float i2 = 0;\n" 10785 "auto v = type{\n" 10786 " i = 1, //\n" 10787 " (i = 2), //\n" 10788 " i = 3 //\n" 10789 "};", 10790 Style); 10791 10792 Style.AlignConsecutiveMacros = false; 10793 Style.ColumnLimit = 20; 10794 10795 verifyFormat("#define a \\\n" 10796 " \"aabbbbbbbbbbbb\"\n" 10797 "#define D \\\n" 10798 " \"aabbbbbbbbbbbb\" \\\n" 10799 " \"ccddeeeeeeeee\"\n" 10800 "#define B \\\n" 10801 " \"QQQQQQQQQQQQQ\" \\\n" 10802 " \"FFFFFFFFFFFFF\" \\\n" 10803 " \"LLLLLLLL\"\n", 10804 Style); 10805 10806 Style.AlignConsecutiveMacros = true; 10807 verifyFormat("#define a \\\n" 10808 " \"aabbbbbbbbbbbb\"\n" 10809 "#define D \\\n" 10810 " \"aabbbbbbbbbbbb\" \\\n" 10811 " \"ccddeeeeeeeee\"\n" 10812 "#define B \\\n" 10813 " \"QQQQQQQQQQQQQ\" \\\n" 10814 " \"FFFFFFFFFFFFF\" \\\n" 10815 " \"LLLLLLLL\"\n", 10816 Style); 10817 } 10818 10819 TEST_F(FormatTest, AlignConsecutiveAssignments) { 10820 FormatStyle Alignment = getLLVMStyle(); 10821 Alignment.AlignConsecutiveMacros = true; 10822 Alignment.AlignConsecutiveAssignments = false; 10823 verifyFormat("int a = 5;\n" 10824 "int oneTwoThree = 123;", 10825 Alignment); 10826 verifyFormat("int a = 5;\n" 10827 "int oneTwoThree = 123;", 10828 Alignment); 10829 10830 Alignment.AlignConsecutiveAssignments = true; 10831 verifyFormat("int a = 5;\n" 10832 "int oneTwoThree = 123;", 10833 Alignment); 10834 verifyFormat("int a = method();\n" 10835 "int oneTwoThree = 133;", 10836 Alignment); 10837 verifyFormat("a &= 5;\n" 10838 "bcd *= 5;\n" 10839 "ghtyf += 5;\n" 10840 "dvfvdb -= 5;\n" 10841 "a /= 5;\n" 10842 "vdsvsv %= 5;\n" 10843 "sfdbddfbdfbb ^= 5;\n" 10844 "dvsdsv |= 5;\n" 10845 "int dsvvdvsdvvv = 123;", 10846 Alignment); 10847 verifyFormat("int i = 1, j = 10;\n" 10848 "something = 2000;", 10849 Alignment); 10850 verifyFormat("something = 2000;\n" 10851 "int i = 1, j = 10;\n", 10852 Alignment); 10853 verifyFormat("something = 2000;\n" 10854 "another = 911;\n" 10855 "int i = 1, j = 10;\n" 10856 "oneMore = 1;\n" 10857 "i = 2;", 10858 Alignment); 10859 verifyFormat("int a = 5;\n" 10860 "int one = 1;\n" 10861 "method();\n" 10862 "int oneTwoThree = 123;\n" 10863 "int oneTwo = 12;", 10864 Alignment); 10865 verifyFormat("int oneTwoThree = 123;\n" 10866 "int oneTwo = 12;\n" 10867 "method();\n", 10868 Alignment); 10869 verifyFormat("int oneTwoThree = 123; // comment\n" 10870 "int oneTwo = 12; // comment", 10871 Alignment); 10872 EXPECT_EQ("int a = 5;\n" 10873 "\n" 10874 "int oneTwoThree = 123;", 10875 format("int a = 5;\n" 10876 "\n" 10877 "int oneTwoThree= 123;", 10878 Alignment)); 10879 EXPECT_EQ("int a = 5;\n" 10880 "int one = 1;\n" 10881 "\n" 10882 "int oneTwoThree = 123;", 10883 format("int a = 5;\n" 10884 "int one = 1;\n" 10885 "\n" 10886 "int oneTwoThree = 123;", 10887 Alignment)); 10888 EXPECT_EQ("int a = 5;\n" 10889 "int one = 1;\n" 10890 "\n" 10891 "int oneTwoThree = 123;\n" 10892 "int oneTwo = 12;", 10893 format("int a = 5;\n" 10894 "int one = 1;\n" 10895 "\n" 10896 "int oneTwoThree = 123;\n" 10897 "int oneTwo = 12;", 10898 Alignment)); 10899 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10900 verifyFormat("#define A \\\n" 10901 " int aaaa = 12; \\\n" 10902 " int b = 23; \\\n" 10903 " int ccc = 234; \\\n" 10904 " int dddddddddd = 2345;", 10905 Alignment); 10906 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10907 verifyFormat("#define A \\\n" 10908 " int aaaa = 12; \\\n" 10909 " int b = 23; \\\n" 10910 " int ccc = 234; \\\n" 10911 " int dddddddddd = 2345;", 10912 Alignment); 10913 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10914 verifyFormat("#define A " 10915 " \\\n" 10916 " int aaaa = 12; " 10917 " \\\n" 10918 " int b = 23; " 10919 " \\\n" 10920 " int ccc = 234; " 10921 " \\\n" 10922 " int dddddddddd = 2345;", 10923 Alignment); 10924 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10925 "k = 4, int l = 5,\n" 10926 " int m = 6) {\n" 10927 " int j = 10;\n" 10928 " otherThing = 1;\n" 10929 "}", 10930 Alignment); 10931 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10932 " int i = 1;\n" 10933 " int j = 2;\n" 10934 " int big = 10000;\n" 10935 "}", 10936 Alignment); 10937 verifyFormat("class C {\n" 10938 "public:\n" 10939 " int i = 1;\n" 10940 " virtual void f() = 0;\n" 10941 "};", 10942 Alignment); 10943 verifyFormat("int i = 1;\n" 10944 "if (SomeType t = getSomething()) {\n" 10945 "}\n" 10946 "int j = 2;\n" 10947 "int big = 10000;", 10948 Alignment); 10949 verifyFormat("int j = 7;\n" 10950 "for (int k = 0; k < N; ++k) {\n" 10951 "}\n" 10952 "int j = 2;\n" 10953 "int big = 10000;\n" 10954 "}", 10955 Alignment); 10956 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10957 verifyFormat("int i = 1;\n" 10958 "LooooooooooongType loooooooooooooooooooooongVariable\n" 10959 " = someLooooooooooooooooongFunction();\n" 10960 "int j = 2;", 10961 Alignment); 10962 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 10963 verifyFormat("int i = 1;\n" 10964 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 10965 " someLooooooooooooooooongFunction();\n" 10966 "int j = 2;", 10967 Alignment); 10968 10969 verifyFormat("auto lambda = []() {\n" 10970 " auto i = 0;\n" 10971 " return 0;\n" 10972 "};\n" 10973 "int i = 0;\n" 10974 "auto v = type{\n" 10975 " i = 1, //\n" 10976 " (i = 2), //\n" 10977 " i = 3 //\n" 10978 "};", 10979 Alignment); 10980 10981 verifyFormat( 10982 "int i = 1;\n" 10983 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 10984 " loooooooooooooooooooooongParameterB);\n" 10985 "int j = 2;", 10986 Alignment); 10987 10988 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 10989 " typename B = very_long_type_name_1,\n" 10990 " typename T_2 = very_long_type_name_2>\n" 10991 "auto foo() {}\n", 10992 Alignment); 10993 verifyFormat("int a, b = 1;\n" 10994 "int c = 2;\n" 10995 "int dd = 3;\n", 10996 Alignment); 10997 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10998 "float b[1][] = {{3.f}};\n", 10999 Alignment); 11000 verifyFormat("for (int i = 0; i < 1; i++)\n" 11001 " int x = 1;\n", 11002 Alignment); 11003 verifyFormat("for (i = 0; i < 1; i++)\n" 11004 " x = 1;\n" 11005 "y = 1;\n", 11006 Alignment); 11007 } 11008 11009 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 11010 FormatStyle Alignment = getLLVMStyle(); 11011 Alignment.AlignConsecutiveMacros = true; 11012 Alignment.AlignConsecutiveDeclarations = false; 11013 verifyFormat("float const a = 5;\n" 11014 "int oneTwoThree = 123;", 11015 Alignment); 11016 verifyFormat("int a = 5;\n" 11017 "float const oneTwoThree = 123;", 11018 Alignment); 11019 11020 Alignment.AlignConsecutiveDeclarations = true; 11021 verifyFormat("float const a = 5;\n" 11022 "int oneTwoThree = 123;", 11023 Alignment); 11024 verifyFormat("int a = method();\n" 11025 "float const oneTwoThree = 133;", 11026 Alignment); 11027 verifyFormat("int i = 1, j = 10;\n" 11028 "something = 2000;", 11029 Alignment); 11030 verifyFormat("something = 2000;\n" 11031 "int i = 1, j = 10;\n", 11032 Alignment); 11033 verifyFormat("float something = 2000;\n" 11034 "double another = 911;\n" 11035 "int i = 1, j = 10;\n" 11036 "const int *oneMore = 1;\n" 11037 "unsigned i = 2;", 11038 Alignment); 11039 verifyFormat("float a = 5;\n" 11040 "int one = 1;\n" 11041 "method();\n" 11042 "const double oneTwoThree = 123;\n" 11043 "const unsigned int oneTwo = 12;", 11044 Alignment); 11045 verifyFormat("int oneTwoThree{0}; // comment\n" 11046 "unsigned oneTwo; // comment", 11047 Alignment); 11048 EXPECT_EQ("float const a = 5;\n" 11049 "\n" 11050 "int oneTwoThree = 123;", 11051 format("float const a = 5;\n" 11052 "\n" 11053 "int oneTwoThree= 123;", 11054 Alignment)); 11055 EXPECT_EQ("float a = 5;\n" 11056 "int one = 1;\n" 11057 "\n" 11058 "unsigned oneTwoThree = 123;", 11059 format("float a = 5;\n" 11060 "int one = 1;\n" 11061 "\n" 11062 "unsigned oneTwoThree = 123;", 11063 Alignment)); 11064 EXPECT_EQ("float a = 5;\n" 11065 "int one = 1;\n" 11066 "\n" 11067 "unsigned oneTwoThree = 123;\n" 11068 "int oneTwo = 12;", 11069 format("float a = 5;\n" 11070 "int one = 1;\n" 11071 "\n" 11072 "unsigned oneTwoThree = 123;\n" 11073 "int oneTwo = 12;", 11074 Alignment)); 11075 // Function prototype alignment 11076 verifyFormat("int a();\n" 11077 "double b();", 11078 Alignment); 11079 verifyFormat("int a(int x);\n" 11080 "double b();", 11081 Alignment); 11082 unsigned OldColumnLimit = Alignment.ColumnLimit; 11083 // We need to set ColumnLimit to zero, in order to stress nested alignments, 11084 // otherwise the function parameters will be re-flowed onto a single line. 11085 Alignment.ColumnLimit = 0; 11086 EXPECT_EQ("int a(int x,\n" 11087 " float y);\n" 11088 "double b(int x,\n" 11089 " double y);", 11090 format("int a(int x,\n" 11091 " float y);\n" 11092 "double b(int x,\n" 11093 " double y);", 11094 Alignment)); 11095 // This ensures that function parameters of function declarations are 11096 // correctly indented when their owning functions are indented. 11097 // The failure case here is for 'double y' to not be indented enough. 11098 EXPECT_EQ("double a(int x);\n" 11099 "int b(int y,\n" 11100 " double z);", 11101 format("double a(int x);\n" 11102 "int b(int y,\n" 11103 " double z);", 11104 Alignment)); 11105 // Set ColumnLimit low so that we induce wrapping immediately after 11106 // the function name and opening paren. 11107 Alignment.ColumnLimit = 13; 11108 verifyFormat("int function(\n" 11109 " int x,\n" 11110 " bool y);", 11111 Alignment); 11112 Alignment.ColumnLimit = OldColumnLimit; 11113 // Ensure function pointers don't screw up recursive alignment 11114 verifyFormat("int a(int x, void (*fp)(int y));\n" 11115 "double b();", 11116 Alignment); 11117 Alignment.AlignConsecutiveAssignments = true; 11118 // Ensure recursive alignment is broken by function braces, so that the 11119 // "a = 1" does not align with subsequent assignments inside the function 11120 // body. 11121 verifyFormat("int func(int a = 1) {\n" 11122 " int b = 2;\n" 11123 " int cc = 3;\n" 11124 "}", 11125 Alignment); 11126 verifyFormat("float something = 2000;\n" 11127 "double another = 911;\n" 11128 "int i = 1, j = 10;\n" 11129 "const int *oneMore = 1;\n" 11130 "unsigned i = 2;", 11131 Alignment); 11132 verifyFormat("int oneTwoThree = {0}; // comment\n" 11133 "unsigned oneTwo = 0; // comment", 11134 Alignment); 11135 // Make sure that scope is correctly tracked, in the absence of braces 11136 verifyFormat("for (int i = 0; i < n; i++)\n" 11137 " j = i;\n" 11138 "double x = 1;\n", 11139 Alignment); 11140 verifyFormat("if (int i = 0)\n" 11141 " j = i;\n" 11142 "double x = 1;\n", 11143 Alignment); 11144 // Ensure operator[] and operator() are comprehended 11145 verifyFormat("struct test {\n" 11146 " long long int foo();\n" 11147 " int operator[](int a);\n" 11148 " double bar();\n" 11149 "};\n", 11150 Alignment); 11151 verifyFormat("struct test {\n" 11152 " long long int foo();\n" 11153 " int operator()(int a);\n" 11154 " double bar();\n" 11155 "};\n", 11156 Alignment); 11157 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 11158 " int const i = 1;\n" 11159 " int * j = 2;\n" 11160 " int big = 10000;\n" 11161 "\n" 11162 " unsigned oneTwoThree = 123;\n" 11163 " int oneTwo = 12;\n" 11164 " method();\n" 11165 " float k = 2;\n" 11166 " int ll = 10000;\n" 11167 "}", 11168 format("void SomeFunction(int parameter= 0) {\n" 11169 " int const i= 1;\n" 11170 " int *j=2;\n" 11171 " int big = 10000;\n" 11172 "\n" 11173 "unsigned oneTwoThree =123;\n" 11174 "int oneTwo = 12;\n" 11175 " method();\n" 11176 "float k= 2;\n" 11177 "int ll=10000;\n" 11178 "}", 11179 Alignment)); 11180 Alignment.AlignConsecutiveAssignments = false; 11181 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11182 verifyFormat("#define A \\\n" 11183 " int aaaa = 12; \\\n" 11184 " float b = 23; \\\n" 11185 " const int ccc = 234; \\\n" 11186 " unsigned dddddddddd = 2345;", 11187 Alignment); 11188 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11189 verifyFormat("#define A \\\n" 11190 " int aaaa = 12; \\\n" 11191 " float b = 23; \\\n" 11192 " const int ccc = 234; \\\n" 11193 " unsigned dddddddddd = 2345;", 11194 Alignment); 11195 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11196 Alignment.ColumnLimit = 30; 11197 verifyFormat("#define A \\\n" 11198 " int aaaa = 12; \\\n" 11199 " float b = 23; \\\n" 11200 " const int ccc = 234; \\\n" 11201 " int dddddddddd = 2345;", 11202 Alignment); 11203 Alignment.ColumnLimit = 80; 11204 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11205 "k = 4, int l = 5,\n" 11206 " int m = 6) {\n" 11207 " const int j = 10;\n" 11208 " otherThing = 1;\n" 11209 "}", 11210 Alignment); 11211 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11212 " int const i = 1;\n" 11213 " int * j = 2;\n" 11214 " int big = 10000;\n" 11215 "}", 11216 Alignment); 11217 verifyFormat("class C {\n" 11218 "public:\n" 11219 " int i = 1;\n" 11220 " virtual void f() = 0;\n" 11221 "};", 11222 Alignment); 11223 verifyFormat("float i = 1;\n" 11224 "if (SomeType t = getSomething()) {\n" 11225 "}\n" 11226 "const unsigned j = 2;\n" 11227 "int big = 10000;", 11228 Alignment); 11229 verifyFormat("float j = 7;\n" 11230 "for (int k = 0; k < N; ++k) {\n" 11231 "}\n" 11232 "unsigned j = 2;\n" 11233 "int big = 10000;\n" 11234 "}", 11235 Alignment); 11236 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11237 verifyFormat("float i = 1;\n" 11238 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11239 " = someLooooooooooooooooongFunction();\n" 11240 "int j = 2;", 11241 Alignment); 11242 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11243 verifyFormat("int i = 1;\n" 11244 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11245 " someLooooooooooooooooongFunction();\n" 11246 "int j = 2;", 11247 Alignment); 11248 11249 Alignment.AlignConsecutiveAssignments = true; 11250 verifyFormat("auto lambda = []() {\n" 11251 " auto ii = 0;\n" 11252 " float j = 0;\n" 11253 " return 0;\n" 11254 "};\n" 11255 "int i = 0;\n" 11256 "float i2 = 0;\n" 11257 "auto v = type{\n" 11258 " i = 1, //\n" 11259 " (i = 2), //\n" 11260 " i = 3 //\n" 11261 "};", 11262 Alignment); 11263 Alignment.AlignConsecutiveAssignments = false; 11264 11265 verifyFormat( 11266 "int i = 1;\n" 11267 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11268 " loooooooooooooooooooooongParameterB);\n" 11269 "int j = 2;", 11270 Alignment); 11271 11272 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 11273 // We expect declarations and assignments to align, as long as it doesn't 11274 // exceed the column limit, starting a new alignment sequence whenever it 11275 // happens. 11276 Alignment.AlignConsecutiveAssignments = true; 11277 Alignment.ColumnLimit = 30; 11278 verifyFormat("float ii = 1;\n" 11279 "unsigned j = 2;\n" 11280 "int someVerylongVariable = 1;\n" 11281 "AnotherLongType ll = 123456;\n" 11282 "VeryVeryLongType k = 2;\n" 11283 "int myvar = 1;", 11284 Alignment); 11285 Alignment.ColumnLimit = 80; 11286 Alignment.AlignConsecutiveAssignments = false; 11287 11288 verifyFormat( 11289 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 11290 " typename LongType, typename B>\n" 11291 "auto foo() {}\n", 11292 Alignment); 11293 verifyFormat("float a, b = 1;\n" 11294 "int c = 2;\n" 11295 "int dd = 3;\n", 11296 Alignment); 11297 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11298 "float b[1][] = {{3.f}};\n", 11299 Alignment); 11300 Alignment.AlignConsecutiveAssignments = true; 11301 verifyFormat("float a, b = 1;\n" 11302 "int c = 2;\n" 11303 "int dd = 3;\n", 11304 Alignment); 11305 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11306 "float b[1][] = {{3.f}};\n", 11307 Alignment); 11308 Alignment.AlignConsecutiveAssignments = false; 11309 11310 Alignment.ColumnLimit = 30; 11311 Alignment.BinPackParameters = false; 11312 verifyFormat("void foo(float a,\n" 11313 " float b,\n" 11314 " int c,\n" 11315 " uint32_t *d) {\n" 11316 " int * e = 0;\n" 11317 " float f = 0;\n" 11318 " double g = 0;\n" 11319 "}\n" 11320 "void bar(ino_t a,\n" 11321 " int b,\n" 11322 " uint32_t *c,\n" 11323 " bool d) {}\n", 11324 Alignment); 11325 Alignment.BinPackParameters = true; 11326 Alignment.ColumnLimit = 80; 11327 11328 // Bug 33507 11329 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 11330 verifyFormat( 11331 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 11332 " static const Version verVs2017;\n" 11333 " return true;\n" 11334 "});\n", 11335 Alignment); 11336 Alignment.PointerAlignment = FormatStyle::PAS_Right; 11337 11338 // See llvm.org/PR35641 11339 Alignment.AlignConsecutiveDeclarations = true; 11340 verifyFormat("int func() { //\n" 11341 " int b;\n" 11342 " unsigned c;\n" 11343 "}", 11344 Alignment); 11345 11346 // See PR37175 11347 FormatStyle Style = getMozillaStyle(); 11348 Style.AlignConsecutiveDeclarations = true; 11349 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 11350 "foo(int a);", 11351 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 11352 } 11353 11354 TEST_F(FormatTest, LinuxBraceBreaking) { 11355 FormatStyle LinuxBraceStyle = getLLVMStyle(); 11356 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 11357 verifyFormat("namespace a\n" 11358 "{\n" 11359 "class A\n" 11360 "{\n" 11361 " void f()\n" 11362 " {\n" 11363 " if (true) {\n" 11364 " a();\n" 11365 " b();\n" 11366 " } else {\n" 11367 " a();\n" 11368 " }\n" 11369 " }\n" 11370 " void g() { return; }\n" 11371 "};\n" 11372 "struct B {\n" 11373 " int x;\n" 11374 "};\n" 11375 "} // namespace a\n", 11376 LinuxBraceStyle); 11377 verifyFormat("enum X {\n" 11378 " Y = 0,\n" 11379 "}\n", 11380 LinuxBraceStyle); 11381 verifyFormat("struct S {\n" 11382 " int Type;\n" 11383 " union {\n" 11384 " int x;\n" 11385 " double y;\n" 11386 " } Value;\n" 11387 " class C\n" 11388 " {\n" 11389 " MyFavoriteType Value;\n" 11390 " } Class;\n" 11391 "}\n", 11392 LinuxBraceStyle); 11393 } 11394 11395 TEST_F(FormatTest, MozillaBraceBreaking) { 11396 FormatStyle MozillaBraceStyle = getLLVMStyle(); 11397 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 11398 MozillaBraceStyle.FixNamespaceComments = false; 11399 verifyFormat("namespace a {\n" 11400 "class A\n" 11401 "{\n" 11402 " void f()\n" 11403 " {\n" 11404 " if (true) {\n" 11405 " a();\n" 11406 " b();\n" 11407 " }\n" 11408 " }\n" 11409 " void g() { return; }\n" 11410 "};\n" 11411 "enum E\n" 11412 "{\n" 11413 " A,\n" 11414 " // foo\n" 11415 " B,\n" 11416 " C\n" 11417 "};\n" 11418 "struct B\n" 11419 "{\n" 11420 " int x;\n" 11421 "};\n" 11422 "}\n", 11423 MozillaBraceStyle); 11424 verifyFormat("struct S\n" 11425 "{\n" 11426 " int Type;\n" 11427 " union\n" 11428 " {\n" 11429 " int x;\n" 11430 " double y;\n" 11431 " } Value;\n" 11432 " class C\n" 11433 " {\n" 11434 " MyFavoriteType Value;\n" 11435 " } Class;\n" 11436 "}\n", 11437 MozillaBraceStyle); 11438 } 11439 11440 TEST_F(FormatTest, StroustrupBraceBreaking) { 11441 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 11442 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11443 verifyFormat("namespace a {\n" 11444 "class A {\n" 11445 " void f()\n" 11446 " {\n" 11447 " if (true) {\n" 11448 " a();\n" 11449 " b();\n" 11450 " }\n" 11451 " }\n" 11452 " void g() { return; }\n" 11453 "};\n" 11454 "struct B {\n" 11455 " int x;\n" 11456 "};\n" 11457 "} // namespace a\n", 11458 StroustrupBraceStyle); 11459 11460 verifyFormat("void foo()\n" 11461 "{\n" 11462 " if (a) {\n" 11463 " a();\n" 11464 " }\n" 11465 " else {\n" 11466 " b();\n" 11467 " }\n" 11468 "}\n", 11469 StroustrupBraceStyle); 11470 11471 verifyFormat("#ifdef _DEBUG\n" 11472 "int foo(int i = 0)\n" 11473 "#else\n" 11474 "int foo(int i = 5)\n" 11475 "#endif\n" 11476 "{\n" 11477 " return i;\n" 11478 "}", 11479 StroustrupBraceStyle); 11480 11481 verifyFormat("void foo() {}\n" 11482 "void bar()\n" 11483 "#ifdef _DEBUG\n" 11484 "{\n" 11485 " foo();\n" 11486 "}\n" 11487 "#else\n" 11488 "{\n" 11489 "}\n" 11490 "#endif", 11491 StroustrupBraceStyle); 11492 11493 verifyFormat("void foobar() { int i = 5; }\n" 11494 "#ifdef _DEBUG\n" 11495 "void bar() {}\n" 11496 "#else\n" 11497 "void bar() { foobar(); }\n" 11498 "#endif", 11499 StroustrupBraceStyle); 11500 } 11501 11502 TEST_F(FormatTest, AllmanBraceBreaking) { 11503 FormatStyle AllmanBraceStyle = getLLVMStyle(); 11504 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 11505 11506 EXPECT_EQ("namespace a\n" 11507 "{\n" 11508 "void f();\n" 11509 "void g();\n" 11510 "} // namespace a\n", 11511 format("namespace a\n" 11512 "{\n" 11513 "void f();\n" 11514 "void g();\n" 11515 "}\n", 11516 AllmanBraceStyle)); 11517 11518 verifyFormat("namespace a\n" 11519 "{\n" 11520 "class A\n" 11521 "{\n" 11522 " void f()\n" 11523 " {\n" 11524 " if (true)\n" 11525 " {\n" 11526 " a();\n" 11527 " b();\n" 11528 " }\n" 11529 " }\n" 11530 " void g() { return; }\n" 11531 "};\n" 11532 "struct B\n" 11533 "{\n" 11534 " int x;\n" 11535 "};\n" 11536 "union C\n" 11537 "{\n" 11538 "};\n" 11539 "} // namespace a", 11540 AllmanBraceStyle); 11541 11542 verifyFormat("void f()\n" 11543 "{\n" 11544 " if (true)\n" 11545 " {\n" 11546 " a();\n" 11547 " }\n" 11548 " else if (false)\n" 11549 " {\n" 11550 " b();\n" 11551 " }\n" 11552 " else\n" 11553 " {\n" 11554 " c();\n" 11555 " }\n" 11556 "}\n", 11557 AllmanBraceStyle); 11558 11559 verifyFormat("void f()\n" 11560 "{\n" 11561 " for (int i = 0; i < 10; ++i)\n" 11562 " {\n" 11563 " a();\n" 11564 " }\n" 11565 " while (false)\n" 11566 " {\n" 11567 " b();\n" 11568 " }\n" 11569 " do\n" 11570 " {\n" 11571 " c();\n" 11572 " } while (false)\n" 11573 "}\n", 11574 AllmanBraceStyle); 11575 11576 verifyFormat("void f(int a)\n" 11577 "{\n" 11578 " switch (a)\n" 11579 " {\n" 11580 " case 0:\n" 11581 " break;\n" 11582 " case 1:\n" 11583 " {\n" 11584 " break;\n" 11585 " }\n" 11586 " case 2:\n" 11587 " {\n" 11588 " }\n" 11589 " break;\n" 11590 " default:\n" 11591 " break;\n" 11592 " }\n" 11593 "}\n", 11594 AllmanBraceStyle); 11595 11596 verifyFormat("enum X\n" 11597 "{\n" 11598 " Y = 0,\n" 11599 "}\n", 11600 AllmanBraceStyle); 11601 verifyFormat("enum X\n" 11602 "{\n" 11603 " Y = 0\n" 11604 "}\n", 11605 AllmanBraceStyle); 11606 11607 verifyFormat("@interface BSApplicationController ()\n" 11608 "{\n" 11609 "@private\n" 11610 " id _extraIvar;\n" 11611 "}\n" 11612 "@end\n", 11613 AllmanBraceStyle); 11614 11615 verifyFormat("#ifdef _DEBUG\n" 11616 "int foo(int i = 0)\n" 11617 "#else\n" 11618 "int foo(int i = 5)\n" 11619 "#endif\n" 11620 "{\n" 11621 " return i;\n" 11622 "}", 11623 AllmanBraceStyle); 11624 11625 verifyFormat("void foo() {}\n" 11626 "void bar()\n" 11627 "#ifdef _DEBUG\n" 11628 "{\n" 11629 " foo();\n" 11630 "}\n" 11631 "#else\n" 11632 "{\n" 11633 "}\n" 11634 "#endif", 11635 AllmanBraceStyle); 11636 11637 verifyFormat("void foobar() { int i = 5; }\n" 11638 "#ifdef _DEBUG\n" 11639 "void bar() {}\n" 11640 "#else\n" 11641 "void bar() { foobar(); }\n" 11642 "#endif", 11643 AllmanBraceStyle); 11644 11645 // This shouldn't affect ObjC blocks.. 11646 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 11647 " // ...\n" 11648 " int i;\n" 11649 "}];", 11650 AllmanBraceStyle); 11651 verifyFormat("void (^block)(void) = ^{\n" 11652 " // ...\n" 11653 " int i;\n" 11654 "};", 11655 AllmanBraceStyle); 11656 // .. or dict literals. 11657 verifyFormat("void f()\n" 11658 "{\n" 11659 " // ...\n" 11660 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 11661 "}", 11662 AllmanBraceStyle); 11663 verifyFormat("void f()\n" 11664 "{\n" 11665 " // ...\n" 11666 " [object someMethod:@{a : @\"b\"}];\n" 11667 "}", 11668 AllmanBraceStyle); 11669 verifyFormat("int f()\n" 11670 "{ // comment\n" 11671 " return 42;\n" 11672 "}", 11673 AllmanBraceStyle); 11674 11675 AllmanBraceStyle.ColumnLimit = 19; 11676 verifyFormat("void f() { int i; }", AllmanBraceStyle); 11677 AllmanBraceStyle.ColumnLimit = 18; 11678 verifyFormat("void f()\n" 11679 "{\n" 11680 " int i;\n" 11681 "}", 11682 AllmanBraceStyle); 11683 AllmanBraceStyle.ColumnLimit = 80; 11684 11685 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 11686 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 11687 FormatStyle::SIS_WithoutElse; 11688 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 11689 verifyFormat("void f(bool b)\n" 11690 "{\n" 11691 " if (b)\n" 11692 " {\n" 11693 " return;\n" 11694 " }\n" 11695 "}\n", 11696 BreakBeforeBraceShortIfs); 11697 verifyFormat("void f(bool b)\n" 11698 "{\n" 11699 " if constexpr (b)\n" 11700 " {\n" 11701 " return;\n" 11702 " }\n" 11703 "}\n", 11704 BreakBeforeBraceShortIfs); 11705 verifyFormat("void f(bool b)\n" 11706 "{\n" 11707 " if CONSTEXPR (b)\n" 11708 " {\n" 11709 " return;\n" 11710 " }\n" 11711 "}\n", 11712 BreakBeforeBraceShortIfs); 11713 verifyFormat("void f(bool b)\n" 11714 "{\n" 11715 " if (b) return;\n" 11716 "}\n", 11717 BreakBeforeBraceShortIfs); 11718 verifyFormat("void f(bool b)\n" 11719 "{\n" 11720 " if constexpr (b) return;\n" 11721 "}\n", 11722 BreakBeforeBraceShortIfs); 11723 verifyFormat("void f(bool b)\n" 11724 "{\n" 11725 " if CONSTEXPR (b) return;\n" 11726 "}\n", 11727 BreakBeforeBraceShortIfs); 11728 verifyFormat("void f(bool b)\n" 11729 "{\n" 11730 " while (b)\n" 11731 " {\n" 11732 " return;\n" 11733 " }\n" 11734 "}\n", 11735 BreakBeforeBraceShortIfs); 11736 } 11737 11738 TEST_F(FormatTest, WhitesmithsBraceBreaking) { 11739 FormatStyle WhitesmithsBraceStyle = getLLVMStyle(); 11740 WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 11741 11742 // Make a few changes to the style for testing purposes 11743 WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine = 11744 FormatStyle::SFS_Empty; 11745 WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 11746 WhitesmithsBraceStyle.ColumnLimit = 0; 11747 11748 // FIXME: this test case can't decide whether there should be a blank line 11749 // after the ~D() line or not. It adds one if one doesn't exist in the test 11750 // and it removes the line if one exists. 11751 /* 11752 verifyFormat("class A;\n" 11753 "namespace B\n" 11754 " {\n" 11755 "class C;\n" 11756 "// Comment\n" 11757 "class D\n" 11758 " {\n" 11759 "public:\n" 11760 " D();\n" 11761 " ~D() {}\n" 11762 "private:\n" 11763 " enum E\n" 11764 " {\n" 11765 " F\n" 11766 " }\n" 11767 " };\n" 11768 " } // namespace B\n", 11769 WhitesmithsBraceStyle); 11770 */ 11771 11772 verifyFormat("namespace a\n" 11773 " {\n" 11774 "class A\n" 11775 " {\n" 11776 " void f()\n" 11777 " {\n" 11778 " if (true)\n" 11779 " {\n" 11780 " a();\n" 11781 " b();\n" 11782 " }\n" 11783 " }\n" 11784 " void g()\n" 11785 " {\n" 11786 " return;\n" 11787 " }\n" 11788 " };\n" 11789 "struct B\n" 11790 " {\n" 11791 " int x;\n" 11792 " };\n" 11793 " } // namespace a", 11794 WhitesmithsBraceStyle); 11795 11796 verifyFormat("void f()\n" 11797 " {\n" 11798 " if (true)\n" 11799 " {\n" 11800 " a();\n" 11801 " }\n" 11802 " else if (false)\n" 11803 " {\n" 11804 " b();\n" 11805 " }\n" 11806 " else\n" 11807 " {\n" 11808 " c();\n" 11809 " }\n" 11810 " }\n", 11811 WhitesmithsBraceStyle); 11812 11813 verifyFormat("void f()\n" 11814 " {\n" 11815 " for (int i = 0; i < 10; ++i)\n" 11816 " {\n" 11817 " a();\n" 11818 " }\n" 11819 " while (false)\n" 11820 " {\n" 11821 " b();\n" 11822 " }\n" 11823 " do\n" 11824 " {\n" 11825 " c();\n" 11826 " } while (false)\n" 11827 " }\n", 11828 WhitesmithsBraceStyle); 11829 11830 // FIXME: the block and the break under case 2 in this test don't get indented 11831 // correctly 11832 /* 11833 verifyFormat("void switchTest1(int a)\n" 11834 " {\n" 11835 " switch (a)\n" 11836 " {\n" 11837 " case 2:\n" 11838 " {\n" 11839 " }\n" 11840 " break;\n" 11841 " }\n" 11842 " }\n", 11843 WhitesmithsBraceStyle); 11844 */ 11845 11846 // FIXME: the block and the break under case 2 in this test don't get indented 11847 // correctly 11848 /* 11849 verifyFormat("void switchTest2(int a)\n" 11850 " {\n" 11851 " switch (a)\n" 11852 " {\n" 11853 " case 0:\n" 11854 " break;\n" 11855 " case 1:\n" 11856 " {\n" 11857 " break;\n" 11858 " }\n" 11859 " case 2:\n" 11860 " {\n" 11861 " }\n" 11862 " break;\n" 11863 " default:\n" 11864 " break;\n" 11865 " }\n" 11866 " }\n", 11867 WhitesmithsBraceStyle); 11868 */ 11869 11870 verifyFormat("enum X\n" 11871 " {\n" 11872 " Y = 0, // testing\n" 11873 " }\n", 11874 WhitesmithsBraceStyle); 11875 11876 verifyFormat("enum X\n" 11877 " {\n" 11878 " Y = 0\n" 11879 " }\n", 11880 WhitesmithsBraceStyle); 11881 verifyFormat("enum X\n" 11882 " {\n" 11883 " Y = 0,\n" 11884 " Z = 1\n" 11885 " };\n", 11886 WhitesmithsBraceStyle); 11887 11888 verifyFormat("@interface BSApplicationController ()\n" 11889 " {\n" 11890 "@private\n" 11891 " id _extraIvar;\n" 11892 " }\n" 11893 "@end\n", 11894 WhitesmithsBraceStyle); 11895 11896 verifyFormat("#ifdef _DEBUG\n" 11897 "int foo(int i = 0)\n" 11898 "#else\n" 11899 "int foo(int i = 5)\n" 11900 "#endif\n" 11901 " {\n" 11902 " return i;\n" 11903 " }", 11904 WhitesmithsBraceStyle); 11905 11906 verifyFormat("void foo() {}\n" 11907 "void bar()\n" 11908 "#ifdef _DEBUG\n" 11909 " {\n" 11910 " foo();\n" 11911 " }\n" 11912 "#else\n" 11913 " {\n" 11914 " }\n" 11915 "#endif", 11916 WhitesmithsBraceStyle); 11917 11918 verifyFormat("void foobar()\n" 11919 " {\n" 11920 " int i = 5;\n" 11921 " }\n" 11922 "#ifdef _DEBUG\n" 11923 "void bar()\n" 11924 " {\n" 11925 " }\n" 11926 "#else\n" 11927 "void bar()\n" 11928 " {\n" 11929 " foobar();\n" 11930 " }\n" 11931 "#endif", 11932 WhitesmithsBraceStyle); 11933 11934 // This shouldn't affect ObjC blocks.. 11935 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 11936 " // ...\n" 11937 " int i;\n" 11938 "}];", 11939 WhitesmithsBraceStyle); 11940 verifyFormat("void (^block)(void) = ^{\n" 11941 " // ...\n" 11942 " int i;\n" 11943 "};", 11944 WhitesmithsBraceStyle); 11945 // .. or dict literals. 11946 verifyFormat("void f()\n" 11947 " {\n" 11948 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 11949 " }", 11950 WhitesmithsBraceStyle); 11951 11952 verifyFormat("int f()\n" 11953 " { // comment\n" 11954 " return 42;\n" 11955 " }", 11956 WhitesmithsBraceStyle); 11957 11958 FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle; 11959 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 11960 FormatStyle::SIS_Always; 11961 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 11962 verifyFormat("void f(bool b)\n" 11963 " {\n" 11964 " if (b)\n" 11965 " {\n" 11966 " return;\n" 11967 " }\n" 11968 " }\n", 11969 BreakBeforeBraceShortIfs); 11970 verifyFormat("void f(bool b)\n" 11971 " {\n" 11972 " if (b) return;\n" 11973 " }\n", 11974 BreakBeforeBraceShortIfs); 11975 verifyFormat("void f(bool b)\n" 11976 " {\n" 11977 " while (b)\n" 11978 " {\n" 11979 " return;\n" 11980 " }\n" 11981 " }\n", 11982 BreakBeforeBraceShortIfs); 11983 } 11984 11985 TEST_F(FormatTest, GNUBraceBreaking) { 11986 FormatStyle GNUBraceStyle = getLLVMStyle(); 11987 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 11988 verifyFormat("namespace a\n" 11989 "{\n" 11990 "class A\n" 11991 "{\n" 11992 " void f()\n" 11993 " {\n" 11994 " int a;\n" 11995 " {\n" 11996 " int b;\n" 11997 " }\n" 11998 " if (true)\n" 11999 " {\n" 12000 " a();\n" 12001 " b();\n" 12002 " }\n" 12003 " }\n" 12004 " void g() { return; }\n" 12005 "}\n" 12006 "} // namespace a", 12007 GNUBraceStyle); 12008 12009 verifyFormat("void f()\n" 12010 "{\n" 12011 " if (true)\n" 12012 " {\n" 12013 " a();\n" 12014 " }\n" 12015 " else if (false)\n" 12016 " {\n" 12017 " b();\n" 12018 " }\n" 12019 " else\n" 12020 " {\n" 12021 " c();\n" 12022 " }\n" 12023 "}\n", 12024 GNUBraceStyle); 12025 12026 verifyFormat("void f()\n" 12027 "{\n" 12028 " for (int i = 0; i < 10; ++i)\n" 12029 " {\n" 12030 " a();\n" 12031 " }\n" 12032 " while (false)\n" 12033 " {\n" 12034 " b();\n" 12035 " }\n" 12036 " do\n" 12037 " {\n" 12038 " c();\n" 12039 " }\n" 12040 " while (false);\n" 12041 "}\n", 12042 GNUBraceStyle); 12043 12044 verifyFormat("void f(int a)\n" 12045 "{\n" 12046 " switch (a)\n" 12047 " {\n" 12048 " case 0:\n" 12049 " break;\n" 12050 " case 1:\n" 12051 " {\n" 12052 " break;\n" 12053 " }\n" 12054 " case 2:\n" 12055 " {\n" 12056 " }\n" 12057 " break;\n" 12058 " default:\n" 12059 " break;\n" 12060 " }\n" 12061 "}\n", 12062 GNUBraceStyle); 12063 12064 verifyFormat("enum X\n" 12065 "{\n" 12066 " Y = 0,\n" 12067 "}\n", 12068 GNUBraceStyle); 12069 12070 verifyFormat("@interface BSApplicationController ()\n" 12071 "{\n" 12072 "@private\n" 12073 " id _extraIvar;\n" 12074 "}\n" 12075 "@end\n", 12076 GNUBraceStyle); 12077 12078 verifyFormat("#ifdef _DEBUG\n" 12079 "int foo(int i = 0)\n" 12080 "#else\n" 12081 "int foo(int i = 5)\n" 12082 "#endif\n" 12083 "{\n" 12084 " return i;\n" 12085 "}", 12086 GNUBraceStyle); 12087 12088 verifyFormat("void foo() {}\n" 12089 "void bar()\n" 12090 "#ifdef _DEBUG\n" 12091 "{\n" 12092 " foo();\n" 12093 "}\n" 12094 "#else\n" 12095 "{\n" 12096 "}\n" 12097 "#endif", 12098 GNUBraceStyle); 12099 12100 verifyFormat("void foobar() { int i = 5; }\n" 12101 "#ifdef _DEBUG\n" 12102 "void bar() {}\n" 12103 "#else\n" 12104 "void bar() { foobar(); }\n" 12105 "#endif", 12106 GNUBraceStyle); 12107 } 12108 12109 TEST_F(FormatTest, WebKitBraceBreaking) { 12110 FormatStyle WebKitBraceStyle = getLLVMStyle(); 12111 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 12112 WebKitBraceStyle.FixNamespaceComments = false; 12113 verifyFormat("namespace a {\n" 12114 "class A {\n" 12115 " void f()\n" 12116 " {\n" 12117 " if (true) {\n" 12118 " a();\n" 12119 " b();\n" 12120 " }\n" 12121 " }\n" 12122 " void g() { return; }\n" 12123 "};\n" 12124 "enum E {\n" 12125 " A,\n" 12126 " // foo\n" 12127 " B,\n" 12128 " C\n" 12129 "};\n" 12130 "struct B {\n" 12131 " int x;\n" 12132 "};\n" 12133 "}\n", 12134 WebKitBraceStyle); 12135 verifyFormat("struct S {\n" 12136 " int Type;\n" 12137 " union {\n" 12138 " int x;\n" 12139 " double y;\n" 12140 " } Value;\n" 12141 " class C {\n" 12142 " MyFavoriteType Value;\n" 12143 " } Class;\n" 12144 "};\n", 12145 WebKitBraceStyle); 12146 } 12147 12148 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 12149 verifyFormat("void f() {\n" 12150 " try {\n" 12151 " } catch (const Exception &e) {\n" 12152 " }\n" 12153 "}\n", 12154 getLLVMStyle()); 12155 } 12156 12157 TEST_F(FormatTest, UnderstandsPragmas) { 12158 verifyFormat("#pragma omp reduction(| : var)"); 12159 verifyFormat("#pragma omp reduction(+ : var)"); 12160 12161 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 12162 "(including parentheses).", 12163 format("#pragma mark Any non-hyphenated or hyphenated string " 12164 "(including parentheses).")); 12165 } 12166 12167 TEST_F(FormatTest, UnderstandPragmaOption) { 12168 verifyFormat("#pragma option -C -A"); 12169 12170 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 12171 } 12172 12173 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 12174 FormatStyle Style = getLLVMStyle(); 12175 Style.ColumnLimit = 20; 12176 12177 // See PR41213 12178 EXPECT_EQ("/*\n" 12179 " *\t9012345\n" 12180 " * /8901\n" 12181 " */", 12182 format("/*\n" 12183 " *\t9012345 /8901\n" 12184 " */", 12185 Style)); 12186 EXPECT_EQ("/*\n" 12187 " *345678\n" 12188 " *\t/8901\n" 12189 " */", 12190 format("/*\n" 12191 " *345678\t/8901\n" 12192 " */", 12193 Style)); 12194 12195 verifyFormat("int a; // the\n" 12196 " // comment", 12197 Style); 12198 EXPECT_EQ("int a; /* first line\n" 12199 " * second\n" 12200 " * line third\n" 12201 " * line\n" 12202 " */", 12203 format("int a; /* first line\n" 12204 " * second\n" 12205 " * line third\n" 12206 " * line\n" 12207 " */", 12208 Style)); 12209 EXPECT_EQ("int a; // first line\n" 12210 " // second\n" 12211 " // line third\n" 12212 " // line", 12213 format("int a; // first line\n" 12214 " // second line\n" 12215 " // third line", 12216 Style)); 12217 12218 Style.PenaltyExcessCharacter = 90; 12219 verifyFormat("int a; // the comment", Style); 12220 EXPECT_EQ("int a; // the comment\n" 12221 " // aaa", 12222 format("int a; // the comment aaa", Style)); 12223 EXPECT_EQ("int a; /* first line\n" 12224 " * second line\n" 12225 " * third line\n" 12226 " */", 12227 format("int a; /* first line\n" 12228 " * second line\n" 12229 " * third line\n" 12230 " */", 12231 Style)); 12232 EXPECT_EQ("int a; // first line\n" 12233 " // second line\n" 12234 " // third line", 12235 format("int a; // first line\n" 12236 " // second line\n" 12237 " // third line", 12238 Style)); 12239 // FIXME: Investigate why this is not getting the same layout as the test 12240 // above. 12241 EXPECT_EQ("int a; /* first line\n" 12242 " * second line\n" 12243 " * third line\n" 12244 " */", 12245 format("int a; /* first line second line third line" 12246 "\n*/", 12247 Style)); 12248 12249 EXPECT_EQ("// foo bar baz bazfoo\n" 12250 "// foo bar foo bar\n", 12251 format("// foo bar baz bazfoo\n" 12252 "// foo bar foo bar\n", 12253 Style)); 12254 EXPECT_EQ("// foo bar baz bazfoo\n" 12255 "// foo bar foo bar\n", 12256 format("// foo bar baz bazfoo\n" 12257 "// foo bar foo bar\n", 12258 Style)); 12259 12260 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 12261 // next one. 12262 EXPECT_EQ("// foo bar baz bazfoo\n" 12263 "// bar foo bar\n", 12264 format("// foo bar baz bazfoo bar\n" 12265 "// foo bar\n", 12266 Style)); 12267 12268 EXPECT_EQ("// foo bar baz bazfoo\n" 12269 "// foo bar baz bazfoo\n" 12270 "// bar foo bar\n", 12271 format("// foo bar baz bazfoo\n" 12272 "// foo bar baz bazfoo bar\n" 12273 "// foo bar\n", 12274 Style)); 12275 12276 EXPECT_EQ("// foo bar baz bazfoo\n" 12277 "// foo bar baz bazfoo\n" 12278 "// bar foo bar\n", 12279 format("// foo bar baz bazfoo\n" 12280 "// foo bar baz bazfoo bar\n" 12281 "// foo bar\n", 12282 Style)); 12283 12284 // Make sure we do not keep protruding characters if strict mode reflow is 12285 // cheaper than keeping protruding characters. 12286 Style.ColumnLimit = 21; 12287 EXPECT_EQ( 12288 "// foo foo foo foo\n" 12289 "// foo foo foo foo\n" 12290 "// foo foo foo foo\n", 12291 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style)); 12292 12293 EXPECT_EQ("int a = /* long block\n" 12294 " comment */\n" 12295 " 42;", 12296 format("int a = /* long block comment */ 42;", Style)); 12297 } 12298 12299 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 12300 for (size_t i = 1; i < Styles.size(); ++i) \ 12301 EXPECT_EQ(Styles[0], Styles[i]) \ 12302 << "Style #" << i << " of " << Styles.size() << " differs from Style #0" 12303 12304 TEST_F(FormatTest, GetsPredefinedStyleByName) { 12305 SmallVector<FormatStyle, 3> Styles; 12306 Styles.resize(3); 12307 12308 Styles[0] = getLLVMStyle(); 12309 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 12310 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 12311 EXPECT_ALL_STYLES_EQUAL(Styles); 12312 12313 Styles[0] = getGoogleStyle(); 12314 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 12315 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 12316 EXPECT_ALL_STYLES_EQUAL(Styles); 12317 12318 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12319 EXPECT_TRUE( 12320 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 12321 EXPECT_TRUE( 12322 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 12323 EXPECT_ALL_STYLES_EQUAL(Styles); 12324 12325 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 12326 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 12327 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 12328 EXPECT_ALL_STYLES_EQUAL(Styles); 12329 12330 Styles[0] = getMozillaStyle(); 12331 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 12332 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 12333 EXPECT_ALL_STYLES_EQUAL(Styles); 12334 12335 Styles[0] = getWebKitStyle(); 12336 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 12337 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 12338 EXPECT_ALL_STYLES_EQUAL(Styles); 12339 12340 Styles[0] = getGNUStyle(); 12341 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 12342 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 12343 EXPECT_ALL_STYLES_EQUAL(Styles); 12344 12345 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 12346 } 12347 12348 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 12349 SmallVector<FormatStyle, 8> Styles; 12350 Styles.resize(2); 12351 12352 Styles[0] = getGoogleStyle(); 12353 Styles[1] = getLLVMStyle(); 12354 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12355 EXPECT_ALL_STYLES_EQUAL(Styles); 12356 12357 Styles.resize(5); 12358 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12359 Styles[1] = getLLVMStyle(); 12360 Styles[1].Language = FormatStyle::LK_JavaScript; 12361 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12362 12363 Styles[2] = getLLVMStyle(); 12364 Styles[2].Language = FormatStyle::LK_JavaScript; 12365 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 12366 "BasedOnStyle: Google", 12367 &Styles[2]) 12368 .value()); 12369 12370 Styles[3] = getLLVMStyle(); 12371 Styles[3].Language = FormatStyle::LK_JavaScript; 12372 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 12373 "Language: JavaScript", 12374 &Styles[3]) 12375 .value()); 12376 12377 Styles[4] = getLLVMStyle(); 12378 Styles[4].Language = FormatStyle::LK_JavaScript; 12379 EXPECT_EQ(0, parseConfiguration("---\n" 12380 "BasedOnStyle: LLVM\n" 12381 "IndentWidth: 123\n" 12382 "---\n" 12383 "BasedOnStyle: Google\n" 12384 "Language: JavaScript", 12385 &Styles[4]) 12386 .value()); 12387 EXPECT_ALL_STYLES_EQUAL(Styles); 12388 } 12389 12390 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 12391 Style.FIELD = false; \ 12392 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 12393 EXPECT_TRUE(Style.FIELD); \ 12394 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 12395 EXPECT_FALSE(Style.FIELD); 12396 12397 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 12398 12399 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 12400 Style.STRUCT.FIELD = false; \ 12401 EXPECT_EQ(0, \ 12402 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 12403 .value()); \ 12404 EXPECT_TRUE(Style.STRUCT.FIELD); \ 12405 EXPECT_EQ(0, \ 12406 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 12407 .value()); \ 12408 EXPECT_FALSE(Style.STRUCT.FIELD); 12409 12410 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 12411 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 12412 12413 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 12414 EXPECT_NE(VALUE, Style.FIELD); \ 12415 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 12416 EXPECT_EQ(VALUE, Style.FIELD) 12417 12418 TEST_F(FormatTest, ParsesConfigurationBools) { 12419 FormatStyle Style = {}; 12420 Style.Language = FormatStyle::LK_Cpp; 12421 CHECK_PARSE_BOOL(AlignOperands); 12422 CHECK_PARSE_BOOL(AlignTrailingComments); 12423 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 12424 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 12425 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 12426 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 12427 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 12428 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 12429 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 12430 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 12431 CHECK_PARSE_BOOL(BinPackArguments); 12432 CHECK_PARSE_BOOL(BinPackParameters); 12433 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 12434 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 12435 CHECK_PARSE_BOOL(BreakStringLiterals); 12436 CHECK_PARSE_BOOL(CompactNamespaces); 12437 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 12438 CHECK_PARSE_BOOL(DerivePointerAlignment); 12439 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 12440 CHECK_PARSE_BOOL(DisableFormat); 12441 CHECK_PARSE_BOOL(IndentCaseLabels); 12442 CHECK_PARSE_BOOL(IndentGotoLabels); 12443 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 12444 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 12445 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 12446 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 12447 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 12448 CHECK_PARSE_BOOL(ReflowComments); 12449 CHECK_PARSE_BOOL(SortIncludes); 12450 CHECK_PARSE_BOOL(SortUsingDeclarations); 12451 CHECK_PARSE_BOOL(SpacesInParentheses); 12452 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 12453 CHECK_PARSE_BOOL(SpacesInAngles); 12454 CHECK_PARSE_BOOL(SpaceInEmptyBlock); 12455 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 12456 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 12457 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 12458 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 12459 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 12460 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 12461 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 12462 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 12463 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 12464 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 12465 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 12466 12467 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 12468 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 12469 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 12470 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 12471 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 12472 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 12473 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 12474 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 12475 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 12476 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 12477 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 12478 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 12479 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 12480 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 12481 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 12482 } 12483 12484 #undef CHECK_PARSE_BOOL 12485 12486 TEST_F(FormatTest, ParsesConfiguration) { 12487 FormatStyle Style = {}; 12488 Style.Language = FormatStyle::LK_Cpp; 12489 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 12490 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 12491 ConstructorInitializerIndentWidth, 1234u); 12492 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 12493 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 12494 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 12495 CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u); 12496 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 12497 PenaltyBreakBeforeFirstCallParameter, 1234u); 12498 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 12499 PenaltyBreakTemplateDeclaration, 1234u); 12500 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 12501 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 12502 PenaltyReturnTypeOnItsOwnLine, 1234u); 12503 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 12504 SpacesBeforeTrailingComments, 1234u); 12505 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 12506 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 12507 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 12508 12509 Style.PointerAlignment = FormatStyle::PAS_Middle; 12510 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 12511 FormatStyle::PAS_Left); 12512 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 12513 FormatStyle::PAS_Right); 12514 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 12515 FormatStyle::PAS_Middle); 12516 // For backward compatibility: 12517 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 12518 FormatStyle::PAS_Left); 12519 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 12520 FormatStyle::PAS_Right); 12521 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 12522 FormatStyle::PAS_Middle); 12523 12524 Style.Standard = FormatStyle::LS_Auto; 12525 CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03); 12526 CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11); 12527 CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14); 12528 CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17); 12529 CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20); 12530 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 12531 CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest); 12532 // Legacy aliases: 12533 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 12534 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest); 12535 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 12536 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 12537 12538 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 12539 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 12540 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 12541 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 12542 FormatStyle::BOS_None); 12543 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 12544 FormatStyle::BOS_All); 12545 // For backward compatibility: 12546 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 12547 FormatStyle::BOS_None); 12548 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 12549 FormatStyle::BOS_All); 12550 12551 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 12552 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 12553 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 12554 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 12555 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 12556 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 12557 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 12558 // For backward compatibility: 12559 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 12560 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 12561 12562 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 12563 CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList, 12564 FormatStyle::BILS_BeforeComma); 12565 CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList, 12566 FormatStyle::BILS_AfterColon); 12567 CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList, 12568 FormatStyle::BILS_BeforeColon); 12569 // For backward compatibility: 12570 CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList, 12571 FormatStyle::BILS_BeforeComma); 12572 12573 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 12574 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 12575 FormatStyle::BAS_Align); 12576 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 12577 FormatStyle::BAS_DontAlign); 12578 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 12579 FormatStyle::BAS_AlwaysBreak); 12580 // For backward compatibility: 12581 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 12582 FormatStyle::BAS_DontAlign); 12583 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 12584 FormatStyle::BAS_Align); 12585 12586 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 12587 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 12588 FormatStyle::ENAS_DontAlign); 12589 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 12590 FormatStyle::ENAS_Left); 12591 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 12592 FormatStyle::ENAS_Right); 12593 // For backward compatibility: 12594 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 12595 FormatStyle::ENAS_Left); 12596 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 12597 FormatStyle::ENAS_Right); 12598 12599 Style.UseTab = FormatStyle::UT_ForIndentation; 12600 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 12601 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 12602 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 12603 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 12604 FormatStyle::UT_ForContinuationAndIndentation); 12605 // For backward compatibility: 12606 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 12607 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 12608 12609 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 12610 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never", 12611 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12612 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty", 12613 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty); 12614 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always", 12615 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12616 // For backward compatibility: 12617 CHECK_PARSE("AllowShortBlocksOnASingleLine: false", 12618 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12619 CHECK_PARSE("AllowShortBlocksOnASingleLine: true", 12620 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12621 12622 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 12623 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 12624 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12625 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 12626 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 12627 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 12628 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 12629 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 12630 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12631 // For backward compatibility: 12632 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 12633 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12634 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 12635 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12636 12637 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 12638 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 12639 FormatStyle::SBPO_Never); 12640 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 12641 FormatStyle::SBPO_Always); 12642 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 12643 FormatStyle::SBPO_ControlStatements); 12644 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 12645 FormatStyle::SBPO_NonEmptyParentheses); 12646 // For backward compatibility: 12647 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 12648 FormatStyle::SBPO_Never); 12649 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 12650 FormatStyle::SBPO_ControlStatements); 12651 12652 Style.ColumnLimit = 123; 12653 FormatStyle BaseStyle = getLLVMStyle(); 12654 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 12655 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 12656 12657 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 12658 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 12659 FormatStyle::BS_Attach); 12660 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 12661 FormatStyle::BS_Linux); 12662 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 12663 FormatStyle::BS_Mozilla); 12664 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 12665 FormatStyle::BS_Stroustrup); 12666 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 12667 FormatStyle::BS_Allman); 12668 CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces, 12669 FormatStyle::BS_Whitesmiths); 12670 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 12671 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 12672 FormatStyle::BS_WebKit); 12673 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 12674 FormatStyle::BS_Custom); 12675 12676 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never; 12677 CHECK_PARSE("BraceWrapping:\n" 12678 " AfterControlStatement: MultiLine", 12679 BraceWrapping.AfterControlStatement, 12680 FormatStyle::BWACS_MultiLine); 12681 CHECK_PARSE("BraceWrapping:\n" 12682 " AfterControlStatement: Always", 12683 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 12684 CHECK_PARSE("BraceWrapping:\n" 12685 " AfterControlStatement: Never", 12686 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 12687 // For backward compatibility: 12688 CHECK_PARSE("BraceWrapping:\n" 12689 " AfterControlStatement: true", 12690 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 12691 CHECK_PARSE("BraceWrapping:\n" 12692 " AfterControlStatement: false", 12693 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 12694 12695 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 12696 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 12697 FormatStyle::RTBS_None); 12698 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 12699 FormatStyle::RTBS_All); 12700 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 12701 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 12702 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 12703 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 12704 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 12705 AlwaysBreakAfterReturnType, 12706 FormatStyle::RTBS_TopLevelDefinitions); 12707 12708 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 12709 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", 12710 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No); 12711 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", 12712 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 12713 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", 12714 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 12715 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", 12716 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 12717 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", 12718 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 12719 12720 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 12721 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 12722 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 12723 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 12724 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 12725 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 12726 AlwaysBreakAfterDefinitionReturnType, 12727 FormatStyle::DRTBS_TopLevel); 12728 12729 Style.NamespaceIndentation = FormatStyle::NI_All; 12730 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 12731 FormatStyle::NI_None); 12732 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 12733 FormatStyle::NI_Inner); 12734 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 12735 FormatStyle::NI_All); 12736 12737 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 12738 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 12739 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12740 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 12741 AllowShortIfStatementsOnASingleLine, 12742 FormatStyle::SIS_WithoutElse); 12743 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 12744 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 12745 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 12746 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12747 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 12748 AllowShortIfStatementsOnASingleLine, 12749 FormatStyle::SIS_WithoutElse); 12750 12751 // FIXME: This is required because parsing a configuration simply overwrites 12752 // the first N elements of the list instead of resetting it. 12753 Style.ForEachMacros.clear(); 12754 std::vector<std::string> BoostForeach; 12755 BoostForeach.push_back("BOOST_FOREACH"); 12756 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 12757 std::vector<std::string> BoostAndQForeach; 12758 BoostAndQForeach.push_back("BOOST_FOREACH"); 12759 BoostAndQForeach.push_back("Q_FOREACH"); 12760 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 12761 BoostAndQForeach); 12762 12763 Style.StatementMacros.clear(); 12764 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 12765 std::vector<std::string>{"QUNUSED"}); 12766 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 12767 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 12768 12769 Style.NamespaceMacros.clear(); 12770 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 12771 std::vector<std::string>{"TESTSUITE"}); 12772 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 12773 std::vector<std::string>({"TESTSUITE", "SUITE"})); 12774 12775 Style.IncludeStyle.IncludeCategories.clear(); 12776 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 12777 {"abc/.*", 2, 0}, {".*", 1, 0}}; 12778 CHECK_PARSE("IncludeCategories:\n" 12779 " - Regex: abc/.*\n" 12780 " Priority: 2\n" 12781 " - Regex: .*\n" 12782 " Priority: 1", 12783 IncludeStyle.IncludeCategories, ExpectedCategories); 12784 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 12785 "abc$"); 12786 12787 Style.RawStringFormats.clear(); 12788 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 12789 { 12790 FormatStyle::LK_TextProto, 12791 {"pb", "proto"}, 12792 {"PARSE_TEXT_PROTO"}, 12793 /*CanonicalDelimiter=*/"", 12794 "llvm", 12795 }, 12796 { 12797 FormatStyle::LK_Cpp, 12798 {"cc", "cpp"}, 12799 {"C_CODEBLOCK", "CPPEVAL"}, 12800 /*CanonicalDelimiter=*/"cc", 12801 /*BasedOnStyle=*/"", 12802 }, 12803 }; 12804 12805 CHECK_PARSE("RawStringFormats:\n" 12806 " - Language: TextProto\n" 12807 " Delimiters:\n" 12808 " - 'pb'\n" 12809 " - 'proto'\n" 12810 " EnclosingFunctions:\n" 12811 " - 'PARSE_TEXT_PROTO'\n" 12812 " BasedOnStyle: llvm\n" 12813 " - Language: Cpp\n" 12814 " Delimiters:\n" 12815 " - 'cc'\n" 12816 " - 'cpp'\n" 12817 " EnclosingFunctions:\n" 12818 " - 'C_CODEBLOCK'\n" 12819 " - 'CPPEVAL'\n" 12820 " CanonicalDelimiter: 'cc'", 12821 RawStringFormats, ExpectedRawStringFormats); 12822 } 12823 12824 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 12825 FormatStyle Style = {}; 12826 Style.Language = FormatStyle::LK_Cpp; 12827 CHECK_PARSE("Language: Cpp\n" 12828 "IndentWidth: 12", 12829 IndentWidth, 12u); 12830 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 12831 "IndentWidth: 34", 12832 &Style), 12833 ParseError::Unsuitable); 12834 EXPECT_EQ(12u, Style.IndentWidth); 12835 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12836 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12837 12838 Style.Language = FormatStyle::LK_JavaScript; 12839 CHECK_PARSE("Language: JavaScript\n" 12840 "IndentWidth: 12", 12841 IndentWidth, 12u); 12842 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 12843 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 12844 "IndentWidth: 34", 12845 &Style), 12846 ParseError::Unsuitable); 12847 EXPECT_EQ(23u, Style.IndentWidth); 12848 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12849 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12850 12851 CHECK_PARSE("BasedOnStyle: LLVM\n" 12852 "IndentWidth: 67", 12853 IndentWidth, 67u); 12854 12855 CHECK_PARSE("---\n" 12856 "Language: JavaScript\n" 12857 "IndentWidth: 12\n" 12858 "---\n" 12859 "Language: Cpp\n" 12860 "IndentWidth: 34\n" 12861 "...\n", 12862 IndentWidth, 12u); 12863 12864 Style.Language = FormatStyle::LK_Cpp; 12865 CHECK_PARSE("---\n" 12866 "Language: JavaScript\n" 12867 "IndentWidth: 12\n" 12868 "---\n" 12869 "Language: Cpp\n" 12870 "IndentWidth: 34\n" 12871 "...\n", 12872 IndentWidth, 34u); 12873 CHECK_PARSE("---\n" 12874 "IndentWidth: 78\n" 12875 "---\n" 12876 "Language: JavaScript\n" 12877 "IndentWidth: 56\n" 12878 "...\n", 12879 IndentWidth, 78u); 12880 12881 Style.ColumnLimit = 123; 12882 Style.IndentWidth = 234; 12883 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 12884 Style.TabWidth = 345; 12885 EXPECT_FALSE(parseConfiguration("---\n" 12886 "IndentWidth: 456\n" 12887 "BreakBeforeBraces: Allman\n" 12888 "---\n" 12889 "Language: JavaScript\n" 12890 "IndentWidth: 111\n" 12891 "TabWidth: 111\n" 12892 "---\n" 12893 "Language: Cpp\n" 12894 "BreakBeforeBraces: Stroustrup\n" 12895 "TabWidth: 789\n" 12896 "...\n", 12897 &Style)); 12898 EXPECT_EQ(123u, Style.ColumnLimit); 12899 EXPECT_EQ(456u, Style.IndentWidth); 12900 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 12901 EXPECT_EQ(789u, Style.TabWidth); 12902 12903 EXPECT_EQ(parseConfiguration("---\n" 12904 "Language: JavaScript\n" 12905 "IndentWidth: 56\n" 12906 "---\n" 12907 "IndentWidth: 78\n" 12908 "...\n", 12909 &Style), 12910 ParseError::Error); 12911 EXPECT_EQ(parseConfiguration("---\n" 12912 "Language: JavaScript\n" 12913 "IndentWidth: 56\n" 12914 "---\n" 12915 "Language: JavaScript\n" 12916 "IndentWidth: 78\n" 12917 "...\n", 12918 &Style), 12919 ParseError::Error); 12920 12921 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12922 } 12923 12924 #undef CHECK_PARSE 12925 12926 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 12927 FormatStyle Style = {}; 12928 Style.Language = FormatStyle::LK_JavaScript; 12929 Style.BreakBeforeTernaryOperators = true; 12930 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 12931 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 12932 12933 Style.BreakBeforeTernaryOperators = true; 12934 EXPECT_EQ(0, parseConfiguration("---\n" 12935 "BasedOnStyle: Google\n" 12936 "---\n" 12937 "Language: JavaScript\n" 12938 "IndentWidth: 76\n" 12939 "...\n", 12940 &Style) 12941 .value()); 12942 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 12943 EXPECT_EQ(76u, Style.IndentWidth); 12944 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12945 } 12946 12947 TEST_F(FormatTest, ConfigurationRoundTripTest) { 12948 FormatStyle Style = getLLVMStyle(); 12949 std::string YAML = configurationAsText(Style); 12950 FormatStyle ParsedStyle = {}; 12951 ParsedStyle.Language = FormatStyle::LK_Cpp; 12952 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 12953 EXPECT_EQ(Style, ParsedStyle); 12954 } 12955 12956 TEST_F(FormatTest, WorksFor8bitEncodings) { 12957 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 12958 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 12959 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 12960 "\"\xef\xee\xf0\xf3...\"", 12961 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 12962 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 12963 "\xef\xee\xf0\xf3...\"", 12964 getLLVMStyleWithColumns(12))); 12965 } 12966 12967 TEST_F(FormatTest, HandlesUTF8BOM) { 12968 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 12969 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 12970 format("\xef\xbb\xbf#include <iostream>")); 12971 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 12972 format("\xef\xbb\xbf\n#include <iostream>")); 12973 } 12974 12975 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 12976 #if !defined(_MSC_VER) 12977 12978 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 12979 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 12980 getLLVMStyleWithColumns(35)); 12981 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 12982 getLLVMStyleWithColumns(31)); 12983 verifyFormat("// Однажды в студёную зимнюю пору...", 12984 getLLVMStyleWithColumns(36)); 12985 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 12986 verifyFormat("/* Однажды в студёную зимнюю пору... */", 12987 getLLVMStyleWithColumns(39)); 12988 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 12989 getLLVMStyleWithColumns(35)); 12990 } 12991 12992 TEST_F(FormatTest, SplitsUTF8Strings) { 12993 // Non-printable characters' width is currently considered to be the length in 12994 // bytes in UTF8. The characters can be displayed in very different manner 12995 // (zero-width, single width with a substitution glyph, expanded to their code 12996 // (e.g. "<8d>"), so there's no single correct way to handle them. 12997 EXPECT_EQ("\"aaaaÄ\"\n" 12998 "\"\xc2\x8d\";", 12999 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13000 EXPECT_EQ("\"aaaaaaaÄ\"\n" 13001 "\"\xc2\x8d\";", 13002 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13003 EXPECT_EQ("\"Однажды, в \"\n" 13004 "\"студёную \"\n" 13005 "\"зимнюю \"\n" 13006 "\"пору,\"", 13007 format("\"Однажды, в студёную зимнюю пору,\"", 13008 getLLVMStyleWithColumns(13))); 13009 EXPECT_EQ( 13010 "\"一 二 三 \"\n" 13011 "\"四 五六 \"\n" 13012 "\"七 八 九 \"\n" 13013 "\"十\"", 13014 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 13015 EXPECT_EQ("\"一\t\"\n" 13016 "\"二 \t\"\n" 13017 "\"三 四 \"\n" 13018 "\"五\t\"\n" 13019 "\"六 \t\"\n" 13020 "\"七 \"\n" 13021 "\"八九十\tqq\"", 13022 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 13023 getLLVMStyleWithColumns(11))); 13024 13025 // UTF8 character in an escape sequence. 13026 EXPECT_EQ("\"aaaaaa\"\n" 13027 "\"\\\xC2\x8D\"", 13028 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 13029 } 13030 13031 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 13032 EXPECT_EQ("const char *sssss =\n" 13033 " \"一二三四五六七八\\\n" 13034 " 九 十\";", 13035 format("const char *sssss = \"一二三四五六七八\\\n" 13036 " 九 十\";", 13037 getLLVMStyleWithColumns(30))); 13038 } 13039 13040 TEST_F(FormatTest, SplitsUTF8LineComments) { 13041 EXPECT_EQ("// aaaaÄ\xc2\x8d", 13042 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 13043 EXPECT_EQ("// Я из лесу\n" 13044 "// вышел; был\n" 13045 "// сильный\n" 13046 "// мороз.", 13047 format("// Я из лесу вышел; был сильный мороз.", 13048 getLLVMStyleWithColumns(13))); 13049 EXPECT_EQ("// 一二三\n" 13050 "// 四五六七\n" 13051 "// 八 九\n" 13052 "// 十", 13053 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 13054 } 13055 13056 TEST_F(FormatTest, SplitsUTF8BlockComments) { 13057 EXPECT_EQ("/* Гляжу,\n" 13058 " * поднимается\n" 13059 " * медленно в\n" 13060 " * гору\n" 13061 " * Лошадка,\n" 13062 " * везущая\n" 13063 " * хворосту\n" 13064 " * воз. */", 13065 format("/* Гляжу, поднимается медленно в гору\n" 13066 " * Лошадка, везущая хворосту воз. */", 13067 getLLVMStyleWithColumns(13))); 13068 EXPECT_EQ( 13069 "/* 一二三\n" 13070 " * 四五六七\n" 13071 " * 八 九\n" 13072 " * 十 */", 13073 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 13074 EXPECT_EQ("/* �������� ��������\n" 13075 " * ��������\n" 13076 " * ������-�� */", 13077 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 13078 } 13079 13080 #endif // _MSC_VER 13081 13082 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 13083 FormatStyle Style = getLLVMStyle(); 13084 13085 Style.ConstructorInitializerIndentWidth = 4; 13086 verifyFormat( 13087 "SomeClass::Constructor()\n" 13088 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13089 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13090 Style); 13091 13092 Style.ConstructorInitializerIndentWidth = 2; 13093 verifyFormat( 13094 "SomeClass::Constructor()\n" 13095 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13096 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13097 Style); 13098 13099 Style.ConstructorInitializerIndentWidth = 0; 13100 verifyFormat( 13101 "SomeClass::Constructor()\n" 13102 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13103 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13104 Style); 13105 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 13106 verifyFormat( 13107 "SomeLongTemplateVariableName<\n" 13108 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 13109 Style); 13110 verifyFormat("bool smaller = 1 < " 13111 "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 13112 " " 13113 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 13114 Style); 13115 13116 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 13117 verifyFormat("SomeClass::Constructor() :\n" 13118 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 13119 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 13120 Style); 13121 } 13122 13123 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 13124 FormatStyle Style = getLLVMStyle(); 13125 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 13126 Style.ConstructorInitializerIndentWidth = 4; 13127 verifyFormat("SomeClass::Constructor()\n" 13128 " : a(a)\n" 13129 " , b(b)\n" 13130 " , c(c) {}", 13131 Style); 13132 verifyFormat("SomeClass::Constructor()\n" 13133 " : a(a) {}", 13134 Style); 13135 13136 Style.ColumnLimit = 0; 13137 verifyFormat("SomeClass::Constructor()\n" 13138 " : a(a) {}", 13139 Style); 13140 verifyFormat("SomeClass::Constructor() noexcept\n" 13141 " : a(a) {}", 13142 Style); 13143 verifyFormat("SomeClass::Constructor()\n" 13144 " : a(a)\n" 13145 " , b(b)\n" 13146 " , c(c) {}", 13147 Style); 13148 verifyFormat("SomeClass::Constructor()\n" 13149 " : a(a) {\n" 13150 " foo();\n" 13151 " bar();\n" 13152 "}", 13153 Style); 13154 13155 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 13156 verifyFormat("SomeClass::Constructor()\n" 13157 " : a(a)\n" 13158 " , b(b)\n" 13159 " , c(c) {\n}", 13160 Style); 13161 verifyFormat("SomeClass::Constructor()\n" 13162 " : a(a) {\n}", 13163 Style); 13164 13165 Style.ColumnLimit = 80; 13166 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 13167 Style.ConstructorInitializerIndentWidth = 2; 13168 verifyFormat("SomeClass::Constructor()\n" 13169 " : a(a)\n" 13170 " , b(b)\n" 13171 " , c(c) {}", 13172 Style); 13173 13174 Style.ConstructorInitializerIndentWidth = 0; 13175 verifyFormat("SomeClass::Constructor()\n" 13176 ": a(a)\n" 13177 ", b(b)\n" 13178 ", c(c) {}", 13179 Style); 13180 13181 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 13182 Style.ConstructorInitializerIndentWidth = 4; 13183 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 13184 verifyFormat( 13185 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 13186 Style); 13187 verifyFormat( 13188 "SomeClass::Constructor()\n" 13189 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 13190 Style); 13191 Style.ConstructorInitializerIndentWidth = 4; 13192 Style.ColumnLimit = 60; 13193 verifyFormat("SomeClass::Constructor()\n" 13194 " : aaaaaaaa(aaaaaaaa)\n" 13195 " , aaaaaaaa(aaaaaaaa)\n" 13196 " , aaaaaaaa(aaaaaaaa) {}", 13197 Style); 13198 } 13199 13200 TEST_F(FormatTest, Destructors) { 13201 verifyFormat("void F(int &i) { i.~int(); }"); 13202 verifyFormat("void F(int &i) { i->~int(); }"); 13203 } 13204 13205 TEST_F(FormatTest, FormatsWithWebKitStyle) { 13206 FormatStyle Style = getWebKitStyle(); 13207 13208 // Don't indent in outer namespaces. 13209 verifyFormat("namespace outer {\n" 13210 "int i;\n" 13211 "namespace inner {\n" 13212 " int i;\n" 13213 "} // namespace inner\n" 13214 "} // namespace outer\n" 13215 "namespace other_outer {\n" 13216 "int i;\n" 13217 "}", 13218 Style); 13219 13220 // Don't indent case labels. 13221 verifyFormat("switch (variable) {\n" 13222 "case 1:\n" 13223 "case 2:\n" 13224 " doSomething();\n" 13225 " break;\n" 13226 "default:\n" 13227 " ++variable;\n" 13228 "}", 13229 Style); 13230 13231 // Wrap before binary operators. 13232 EXPECT_EQ("void f()\n" 13233 "{\n" 13234 " if (aaaaaaaaaaaaaaaa\n" 13235 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 13236 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13237 " return;\n" 13238 "}", 13239 format("void f() {\n" 13240 "if (aaaaaaaaaaaaaaaa\n" 13241 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 13242 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13243 "return;\n" 13244 "}", 13245 Style)); 13246 13247 // Allow functions on a single line. 13248 verifyFormat("void f() { return; }", Style); 13249 13250 // Allow empty blocks on a single line and insert a space in empty blocks. 13251 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 13252 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 13253 // However, don't merge non-empty short loops. 13254 EXPECT_EQ("while (true) {\n" 13255 " continue;\n" 13256 "}", 13257 format("while (true) { continue; }", Style)); 13258 13259 // Constructor initializers are formatted one per line with the "," on the 13260 // new line. 13261 verifyFormat("Constructor()\n" 13262 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 13263 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 13264 " aaaaaaaaaaaaaa)\n" 13265 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 13266 "{\n" 13267 "}", 13268 Style); 13269 verifyFormat("SomeClass::Constructor()\n" 13270 " : a(a)\n" 13271 "{\n" 13272 "}", 13273 Style); 13274 EXPECT_EQ("SomeClass::Constructor()\n" 13275 " : a(a)\n" 13276 "{\n" 13277 "}", 13278 format("SomeClass::Constructor():a(a){}", Style)); 13279 verifyFormat("SomeClass::Constructor()\n" 13280 " : a(a)\n" 13281 " , b(b)\n" 13282 " , c(c)\n" 13283 "{\n" 13284 "}", 13285 Style); 13286 verifyFormat("SomeClass::Constructor()\n" 13287 " : a(a)\n" 13288 "{\n" 13289 " foo();\n" 13290 " bar();\n" 13291 "}", 13292 Style); 13293 13294 // Access specifiers should be aligned left. 13295 verifyFormat("class C {\n" 13296 "public:\n" 13297 " int i;\n" 13298 "};", 13299 Style); 13300 13301 // Do not align comments. 13302 verifyFormat("int a; // Do not\n" 13303 "double b; // align comments.", 13304 Style); 13305 13306 // Do not align operands. 13307 EXPECT_EQ("ASSERT(aaaa\n" 13308 " || bbbb);", 13309 format("ASSERT ( aaaa\n||bbbb);", Style)); 13310 13311 // Accept input's line breaks. 13312 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 13313 " || bbbbbbbbbbbbbbb) {\n" 13314 " i++;\n" 13315 "}", 13316 format("if (aaaaaaaaaaaaaaa\n" 13317 "|| bbbbbbbbbbbbbbb) { i++; }", 13318 Style)); 13319 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 13320 " i++;\n" 13321 "}", 13322 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 13323 13324 // Don't automatically break all macro definitions (llvm.org/PR17842). 13325 verifyFormat("#define aNumber 10", Style); 13326 // However, generally keep the line breaks that the user authored. 13327 EXPECT_EQ("#define aNumber \\\n" 13328 " 10", 13329 format("#define aNumber \\\n" 13330 " 10", 13331 Style)); 13332 13333 // Keep empty and one-element array literals on a single line. 13334 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 13335 " copyItems:YES];", 13336 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 13337 "copyItems:YES];", 13338 Style)); 13339 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 13340 " copyItems:YES];", 13341 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 13342 " copyItems:YES];", 13343 Style)); 13344 // FIXME: This does not seem right, there should be more indentation before 13345 // the array literal's entries. Nested blocks have the same problem. 13346 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13347 " @\"a\",\n" 13348 " @\"a\"\n" 13349 "]\n" 13350 " copyItems:YES];", 13351 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13352 " @\"a\",\n" 13353 " @\"a\"\n" 13354 " ]\n" 13355 " copyItems:YES];", 13356 Style)); 13357 EXPECT_EQ( 13358 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13359 " copyItems:YES];", 13360 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13361 " copyItems:YES];", 13362 Style)); 13363 13364 verifyFormat("[self.a b:c c:d];", Style); 13365 EXPECT_EQ("[self.a b:c\n" 13366 " c:d];", 13367 format("[self.a b:c\n" 13368 "c:d];", 13369 Style)); 13370 } 13371 13372 TEST_F(FormatTest, FormatsLambdas) { 13373 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 13374 verifyFormat( 13375 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 13376 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 13377 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 13378 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 13379 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 13380 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 13381 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 13382 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 13383 verifyFormat("int x = f(*+[] {});"); 13384 verifyFormat("void f() {\n" 13385 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 13386 "}\n"); 13387 verifyFormat("void f() {\n" 13388 " other(x.begin(), //\n" 13389 " x.end(), //\n" 13390 " [&](int, int) { return 1; });\n" 13391 "}\n"); 13392 verifyFormat("void f() {\n" 13393 " other.other.other.other.other(\n" 13394 " x.begin(), x.end(),\n" 13395 " [something, rather](int, int, int, int, int, int, int) { " 13396 "return 1; });\n" 13397 "}\n"); 13398 verifyFormat( 13399 "void f() {\n" 13400 " other.other.other.other.other(\n" 13401 " x.begin(), x.end(),\n" 13402 " [something, rather](int, int, int, int, int, int, int) {\n" 13403 " //\n" 13404 " });\n" 13405 "}\n"); 13406 verifyFormat("SomeFunction([]() { // A cool function...\n" 13407 " return 43;\n" 13408 "});"); 13409 EXPECT_EQ("SomeFunction([]() {\n" 13410 "#define A a\n" 13411 " return 43;\n" 13412 "});", 13413 format("SomeFunction([](){\n" 13414 "#define A a\n" 13415 "return 43;\n" 13416 "});")); 13417 verifyFormat("void f() {\n" 13418 " SomeFunction([](decltype(x), A *a) {});\n" 13419 "}"); 13420 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13421 " [](const aaaaaaaaaa &a) { return a; });"); 13422 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 13423 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 13424 "});"); 13425 verifyFormat("Constructor()\n" 13426 " : Field([] { // comment\n" 13427 " int i;\n" 13428 " }) {}"); 13429 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 13430 " return some_parameter.size();\n" 13431 "};"); 13432 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 13433 " [](const string &s) { return s; };"); 13434 verifyFormat("int i = aaaaaa ? 1 //\n" 13435 " : [] {\n" 13436 " return 2; //\n" 13437 " }();"); 13438 verifyFormat("llvm::errs() << \"number of twos is \"\n" 13439 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 13440 " return x == 2; // force break\n" 13441 " });"); 13442 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13443 " [=](int iiiiiiiiiiii) {\n" 13444 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 13445 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 13446 " });", 13447 getLLVMStyleWithColumns(60)); 13448 verifyFormat("SomeFunction({[&] {\n" 13449 " // comment\n" 13450 " },\n" 13451 " [&] {\n" 13452 " // comment\n" 13453 " }});"); 13454 verifyFormat("SomeFunction({[&] {\n" 13455 " // comment\n" 13456 "}});"); 13457 verifyFormat( 13458 "virtual aaaaaaaaaaaaaaaa(\n" 13459 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 13460 " aaaaa aaaaaaaaa);"); 13461 13462 // Lambdas with return types. 13463 verifyFormat("int c = []() -> int { return 2; }();\n"); 13464 verifyFormat("int c = []() -> int * { return 2; }();\n"); 13465 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 13466 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 13467 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 13468 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 13469 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 13470 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 13471 verifyFormat("[a, a]() -> a<1> {};"); 13472 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 13473 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 13474 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 13475 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 13476 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 13477 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 13478 verifyFormat("[]() -> foo<!5> { return {}; };"); 13479 verifyFormat("[]() -> foo<~5> { return {}; };"); 13480 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 13481 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 13482 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 13483 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 13484 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 13485 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 13486 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 13487 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 13488 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 13489 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 13490 verifyFormat("namespace bar {\n" 13491 "// broken:\n" 13492 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 13493 "} // namespace bar"); 13494 verifyFormat("namespace bar {\n" 13495 "// broken:\n" 13496 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 13497 "} // namespace bar"); 13498 verifyFormat("namespace bar {\n" 13499 "// broken:\n" 13500 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 13501 "} // namespace bar"); 13502 verifyFormat("namespace bar {\n" 13503 "// broken:\n" 13504 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 13505 "} // namespace bar"); 13506 verifyFormat("namespace bar {\n" 13507 "// broken:\n" 13508 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 13509 "} // namespace bar"); 13510 verifyFormat("namespace bar {\n" 13511 "// broken:\n" 13512 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 13513 "} // namespace bar"); 13514 verifyFormat("namespace bar {\n" 13515 "// broken:\n" 13516 "auto foo{[]() -> foo<!5> { return {}; }};\n" 13517 "} // namespace bar"); 13518 verifyFormat("namespace bar {\n" 13519 "// broken:\n" 13520 "auto foo{[]() -> foo<~5> { return {}; }};\n" 13521 "} // namespace bar"); 13522 verifyFormat("namespace bar {\n" 13523 "// broken:\n" 13524 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 13525 "} // namespace bar"); 13526 verifyFormat("namespace bar {\n" 13527 "// broken:\n" 13528 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 13529 "} // namespace bar"); 13530 verifyFormat("namespace bar {\n" 13531 "// broken:\n" 13532 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 13533 "} // namespace bar"); 13534 verifyFormat("namespace bar {\n" 13535 "// broken:\n" 13536 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 13537 "} // namespace bar"); 13538 verifyFormat("namespace bar {\n" 13539 "// broken:\n" 13540 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 13541 "} // namespace bar"); 13542 verifyFormat("namespace bar {\n" 13543 "// broken:\n" 13544 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 13545 "} // namespace bar"); 13546 verifyFormat("namespace bar {\n" 13547 "// broken:\n" 13548 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 13549 "} // namespace bar"); 13550 verifyFormat("namespace bar {\n" 13551 "// broken:\n" 13552 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 13553 "} // namespace bar"); 13554 verifyFormat("namespace bar {\n" 13555 "// broken:\n" 13556 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 13557 "} // namespace bar"); 13558 verifyFormat("namespace bar {\n" 13559 "// broken:\n" 13560 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 13561 "} // namespace bar"); 13562 verifyFormat("[]() -> a<1> {};"); 13563 verifyFormat("[]() -> a<1> { ; };"); 13564 verifyFormat("[]() -> a<1> { ; }();"); 13565 verifyFormat("[a, a]() -> a<true> {};"); 13566 verifyFormat("[]() -> a<true> {};"); 13567 verifyFormat("[]() -> a<true> { ; };"); 13568 verifyFormat("[]() -> a<true> { ; }();"); 13569 verifyFormat("[a, a]() -> a<false> {};"); 13570 verifyFormat("[]() -> a<false> {};"); 13571 verifyFormat("[]() -> a<false> { ; };"); 13572 verifyFormat("[]() -> a<false> { ; }();"); 13573 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 13574 verifyFormat("namespace bar {\n" 13575 "auto foo{[]() -> foo<false> { ; }};\n" 13576 "} // namespace bar"); 13577 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 13578 " int j) -> int {\n" 13579 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 13580 "};"); 13581 verifyFormat( 13582 "aaaaaaaaaaaaaaaaaaaaaa(\n" 13583 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 13584 " return aaaaaaaaaaaaaaaaa;\n" 13585 " });", 13586 getLLVMStyleWithColumns(70)); 13587 verifyFormat("[]() //\n" 13588 " -> int {\n" 13589 " return 1; //\n" 13590 "};"); 13591 13592 // Lambdas with explicit template argument lists. 13593 verifyFormat( 13594 "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n"); 13595 13596 // Multiple lambdas in the same parentheses change indentation rules. These 13597 // lambdas are forced to start on new lines. 13598 verifyFormat("SomeFunction(\n" 13599 " []() {\n" 13600 " //\n" 13601 " },\n" 13602 " []() {\n" 13603 " //\n" 13604 " });"); 13605 13606 // A lambda passed as arg0 is always pushed to the next line. 13607 verifyFormat("SomeFunction(\n" 13608 " [this] {\n" 13609 " //\n" 13610 " },\n" 13611 " 1);\n"); 13612 13613 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like 13614 // the arg0 case above. 13615 auto Style = getGoogleStyle(); 13616 Style.BinPackArguments = false; 13617 verifyFormat("SomeFunction(\n" 13618 " a,\n" 13619 " [this] {\n" 13620 " //\n" 13621 " },\n" 13622 " b);\n", 13623 Style); 13624 verifyFormat("SomeFunction(\n" 13625 " a,\n" 13626 " [this] {\n" 13627 " //\n" 13628 " },\n" 13629 " b);\n"); 13630 13631 // A lambda with a very long line forces arg0 to be pushed out irrespective of 13632 // the BinPackArguments value (as long as the code is wide enough). 13633 verifyFormat( 13634 "something->SomeFunction(\n" 13635 " a,\n" 13636 " [this] {\n" 13637 " " 13638 "D0000000000000000000000000000000000000000000000000000000000001();\n" 13639 " },\n" 13640 " b);\n"); 13641 13642 // A multi-line lambda is pulled up as long as the introducer fits on the 13643 // previous line and there are no further args. 13644 verifyFormat("function(1, [this, that] {\n" 13645 " //\n" 13646 "});\n"); 13647 verifyFormat("function([this, that] {\n" 13648 " //\n" 13649 "});\n"); 13650 // FIXME: this format is not ideal and we should consider forcing the first 13651 // arg onto its own line. 13652 verifyFormat("function(a, b, c, //\n" 13653 " d, [this, that] {\n" 13654 " //\n" 13655 " });\n"); 13656 13657 // Multiple lambdas are treated correctly even when there is a short arg0. 13658 verifyFormat("SomeFunction(\n" 13659 " 1,\n" 13660 " [this] {\n" 13661 " //\n" 13662 " },\n" 13663 " [this] {\n" 13664 " //\n" 13665 " },\n" 13666 " 1);\n"); 13667 13668 // More complex introducers. 13669 verifyFormat("return [i, args...] {};"); 13670 13671 // Not lambdas. 13672 verifyFormat("constexpr char hello[]{\"hello\"};"); 13673 verifyFormat("double &operator[](int i) { return 0; }\n" 13674 "int i;"); 13675 verifyFormat("std::unique_ptr<int[]> foo() {}"); 13676 verifyFormat("int i = a[a][a]->f();"); 13677 verifyFormat("int i = (*b)[a]->f();"); 13678 13679 // Other corner cases. 13680 verifyFormat("void f() {\n" 13681 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 13682 " );\n" 13683 "}"); 13684 13685 // Lambdas created through weird macros. 13686 verifyFormat("void f() {\n" 13687 " MACRO((const AA &a) { return 1; });\n" 13688 " MACRO((AA &a) { return 1; });\n" 13689 "}"); 13690 13691 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 13692 " doo_dah();\n" 13693 " doo_dah();\n" 13694 " })) {\n" 13695 "}"); 13696 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 13697 " doo_dah();\n" 13698 " doo_dah();\n" 13699 " })) {\n" 13700 "}"); 13701 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n" 13702 " doo_dah();\n" 13703 " doo_dah();\n" 13704 " })) {\n" 13705 "}"); 13706 verifyFormat("auto lambda = []() {\n" 13707 " int a = 2\n" 13708 "#if A\n" 13709 " + 2\n" 13710 "#endif\n" 13711 " ;\n" 13712 "};"); 13713 13714 // Lambdas with complex multiline introducers. 13715 verifyFormat( 13716 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13717 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 13718 " -> ::std::unordered_set<\n" 13719 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 13720 " //\n" 13721 " });"); 13722 13723 FormatStyle DoNotMerge = getLLVMStyle(); 13724 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 13725 verifyFormat("auto c = []() {\n" 13726 " return b;\n" 13727 "};", 13728 "auto c = []() { return b; };", DoNotMerge); 13729 verifyFormat("auto c = []() {\n" 13730 "};", 13731 " auto c = []() {};", DoNotMerge); 13732 13733 FormatStyle MergeEmptyOnly = getLLVMStyle(); 13734 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 13735 verifyFormat("auto c = []() {\n" 13736 " return b;\n" 13737 "};", 13738 "auto c = []() {\n" 13739 " return b;\n" 13740 " };", 13741 MergeEmptyOnly); 13742 verifyFormat("auto c = []() {};", 13743 "auto c = []() {\n" 13744 "};", 13745 MergeEmptyOnly); 13746 13747 FormatStyle MergeInline = getLLVMStyle(); 13748 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 13749 verifyFormat("auto c = []() {\n" 13750 " return b;\n" 13751 "};", 13752 "auto c = []() { return b; };", MergeInline); 13753 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 13754 MergeInline); 13755 verifyFormat("function([]() { return b; }, a)", 13756 "function([]() { return b; }, a)", MergeInline); 13757 verifyFormat("function(a, []() { return b; })", 13758 "function(a, []() { return b; })", MergeInline); 13759 } 13760 13761 TEST_F(FormatTest, EmptyLinesInLambdas) { 13762 verifyFormat("auto lambda = []() {\n" 13763 " x(); //\n" 13764 "};", 13765 "auto lambda = []() {\n" 13766 "\n" 13767 " x(); //\n" 13768 "\n" 13769 "};"); 13770 } 13771 13772 TEST_F(FormatTest, FormatsBlocks) { 13773 FormatStyle ShortBlocks = getLLVMStyle(); 13774 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13775 verifyFormat("int (^Block)(int, int);", ShortBlocks); 13776 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 13777 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 13778 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 13779 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 13780 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 13781 13782 verifyFormat("foo(^{ bar(); });", ShortBlocks); 13783 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 13784 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 13785 13786 verifyFormat("[operation setCompletionBlock:^{\n" 13787 " [self onOperationDone];\n" 13788 "}];"); 13789 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 13790 " [self onOperationDone];\n" 13791 "}]};"); 13792 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 13793 " f();\n" 13794 "}];"); 13795 verifyFormat("int a = [operation block:^int(int *i) {\n" 13796 " return 1;\n" 13797 "}];"); 13798 verifyFormat("[myObject doSomethingWith:arg1\n" 13799 " aaa:^int(int *a) {\n" 13800 " return 1;\n" 13801 " }\n" 13802 " bbb:f(a * bbbbbbbb)];"); 13803 13804 verifyFormat("[operation setCompletionBlock:^{\n" 13805 " [self.delegate newDataAvailable];\n" 13806 "}];", 13807 getLLVMStyleWithColumns(60)); 13808 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 13809 " NSString *path = [self sessionFilePath];\n" 13810 " if (path) {\n" 13811 " // ...\n" 13812 " }\n" 13813 "});"); 13814 verifyFormat("[[SessionService sharedService]\n" 13815 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13816 " if (window) {\n" 13817 " [self windowDidLoad:window];\n" 13818 " } else {\n" 13819 " [self errorLoadingWindow];\n" 13820 " }\n" 13821 " }];"); 13822 verifyFormat("void (^largeBlock)(void) = ^{\n" 13823 " // ...\n" 13824 "};\n", 13825 getLLVMStyleWithColumns(40)); 13826 verifyFormat("[[SessionService sharedService]\n" 13827 " loadWindowWithCompletionBlock: //\n" 13828 " ^(SessionWindow *window) {\n" 13829 " if (window) {\n" 13830 " [self windowDidLoad:window];\n" 13831 " } else {\n" 13832 " [self errorLoadingWindow];\n" 13833 " }\n" 13834 " }];", 13835 getLLVMStyleWithColumns(60)); 13836 verifyFormat("[myObject doSomethingWith:arg1\n" 13837 " firstBlock:^(Foo *a) {\n" 13838 " // ...\n" 13839 " int i;\n" 13840 " }\n" 13841 " secondBlock:^(Bar *b) {\n" 13842 " // ...\n" 13843 " int i;\n" 13844 " }\n" 13845 " thirdBlock:^Foo(Bar *b) {\n" 13846 " // ...\n" 13847 " int i;\n" 13848 " }];"); 13849 verifyFormat("[myObject doSomethingWith:arg1\n" 13850 " firstBlock:-1\n" 13851 " secondBlock:^(Bar *b) {\n" 13852 " // ...\n" 13853 " int i;\n" 13854 " }];"); 13855 13856 verifyFormat("f(^{\n" 13857 " @autoreleasepool {\n" 13858 " if (a) {\n" 13859 " g();\n" 13860 " }\n" 13861 " }\n" 13862 "});"); 13863 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 13864 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 13865 "};"); 13866 13867 FormatStyle FourIndent = getLLVMStyle(); 13868 FourIndent.ObjCBlockIndentWidth = 4; 13869 verifyFormat("[operation setCompletionBlock:^{\n" 13870 " [self onOperationDone];\n" 13871 "}];", 13872 FourIndent); 13873 } 13874 13875 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 13876 FormatStyle ZeroColumn = getLLVMStyle(); 13877 ZeroColumn.ColumnLimit = 0; 13878 13879 verifyFormat("[[SessionService sharedService] " 13880 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13881 " if (window) {\n" 13882 " [self windowDidLoad:window];\n" 13883 " } else {\n" 13884 " [self errorLoadingWindow];\n" 13885 " }\n" 13886 "}];", 13887 ZeroColumn); 13888 EXPECT_EQ("[[SessionService sharedService]\n" 13889 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13890 " if (window) {\n" 13891 " [self windowDidLoad:window];\n" 13892 " } else {\n" 13893 " [self errorLoadingWindow];\n" 13894 " }\n" 13895 " }];", 13896 format("[[SessionService sharedService]\n" 13897 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13898 " if (window) {\n" 13899 " [self windowDidLoad:window];\n" 13900 " } else {\n" 13901 " [self errorLoadingWindow];\n" 13902 " }\n" 13903 "}];", 13904 ZeroColumn)); 13905 verifyFormat("[myObject doSomethingWith:arg1\n" 13906 " firstBlock:^(Foo *a) {\n" 13907 " // ...\n" 13908 " int i;\n" 13909 " }\n" 13910 " secondBlock:^(Bar *b) {\n" 13911 " // ...\n" 13912 " int i;\n" 13913 " }\n" 13914 " thirdBlock:^Foo(Bar *b) {\n" 13915 " // ...\n" 13916 " int i;\n" 13917 " }];", 13918 ZeroColumn); 13919 verifyFormat("f(^{\n" 13920 " @autoreleasepool {\n" 13921 " if (a) {\n" 13922 " g();\n" 13923 " }\n" 13924 " }\n" 13925 "});", 13926 ZeroColumn); 13927 verifyFormat("void (^largeBlock)(void) = ^{\n" 13928 " // ...\n" 13929 "};", 13930 ZeroColumn); 13931 13932 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13933 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 13934 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 13935 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 13936 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 13937 " int i;\n" 13938 "};", 13939 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 13940 } 13941 13942 TEST_F(FormatTest, SupportsCRLF) { 13943 EXPECT_EQ("int a;\r\n" 13944 "int b;\r\n" 13945 "int c;\r\n", 13946 format("int a;\r\n" 13947 " int b;\r\n" 13948 " int c;\r\n", 13949 getLLVMStyle())); 13950 EXPECT_EQ("int a;\r\n" 13951 "int b;\r\n" 13952 "int c;\r\n", 13953 format("int a;\r\n" 13954 " int b;\n" 13955 " int c;\r\n", 13956 getLLVMStyle())); 13957 EXPECT_EQ("int a;\n" 13958 "int b;\n" 13959 "int c;\n", 13960 format("int a;\r\n" 13961 " int b;\n" 13962 " int c;\n", 13963 getLLVMStyle())); 13964 EXPECT_EQ("\"aaaaaaa \"\r\n" 13965 "\"bbbbbbb\";\r\n", 13966 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 13967 EXPECT_EQ("#define A \\\r\n" 13968 " b; \\\r\n" 13969 " c; \\\r\n" 13970 " d;\r\n", 13971 format("#define A \\\r\n" 13972 " b; \\\r\n" 13973 " c; d; \r\n", 13974 getGoogleStyle())); 13975 13976 EXPECT_EQ("/*\r\n" 13977 "multi line block comments\r\n" 13978 "should not introduce\r\n" 13979 "an extra carriage return\r\n" 13980 "*/\r\n", 13981 format("/*\r\n" 13982 "multi line block comments\r\n" 13983 "should not introduce\r\n" 13984 "an extra carriage return\r\n" 13985 "*/\r\n")); 13986 EXPECT_EQ("/*\r\n" 13987 "\r\n" 13988 "*/", 13989 format("/*\r\n" 13990 " \r\r\r\n" 13991 "*/")); 13992 } 13993 13994 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 13995 verifyFormat("MY_CLASS(C) {\n" 13996 " int i;\n" 13997 " int j;\n" 13998 "};"); 13999 } 14000 14001 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 14002 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 14003 TwoIndent.ContinuationIndentWidth = 2; 14004 14005 EXPECT_EQ("int i =\n" 14006 " longFunction(\n" 14007 " arg);", 14008 format("int i = longFunction(arg);", TwoIndent)); 14009 14010 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 14011 SixIndent.ContinuationIndentWidth = 6; 14012 14013 EXPECT_EQ("int i =\n" 14014 " longFunction(\n" 14015 " arg);", 14016 format("int i = longFunction(arg);", SixIndent)); 14017 } 14018 14019 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 14020 FormatStyle Style = getLLVMStyle(); 14021 verifyFormat("int Foo::getter(\n" 14022 " //\n" 14023 ") const {\n" 14024 " return foo;\n" 14025 "}", 14026 Style); 14027 verifyFormat("void Foo::setter(\n" 14028 " //\n" 14029 ") {\n" 14030 " foo = 1;\n" 14031 "}", 14032 Style); 14033 } 14034 14035 TEST_F(FormatTest, SpacesInAngles) { 14036 FormatStyle Spaces = getLLVMStyle(); 14037 Spaces.SpacesInAngles = true; 14038 14039 verifyFormat("static_cast< int >(arg);", Spaces); 14040 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 14041 verifyFormat("f< int, float >();", Spaces); 14042 verifyFormat("template <> g() {}", Spaces); 14043 verifyFormat("template < std::vector< int > > f() {}", Spaces); 14044 verifyFormat("std::function< void(int, int) > fct;", Spaces); 14045 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 14046 Spaces); 14047 14048 Spaces.Standard = FormatStyle::LS_Cpp03; 14049 Spaces.SpacesInAngles = true; 14050 verifyFormat("A< A< int > >();", Spaces); 14051 14052 Spaces.SpacesInAngles = false; 14053 verifyFormat("A<A<int> >();", Spaces); 14054 14055 Spaces.Standard = FormatStyle::LS_Cpp11; 14056 Spaces.SpacesInAngles = true; 14057 verifyFormat("A< A< int > >();", Spaces); 14058 14059 Spaces.SpacesInAngles = false; 14060 verifyFormat("A<A<int>>();", Spaces); 14061 } 14062 14063 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 14064 FormatStyle Style = getLLVMStyle(); 14065 Style.SpaceAfterTemplateKeyword = false; 14066 verifyFormat("template<int> void foo();", Style); 14067 } 14068 14069 TEST_F(FormatTest, TripleAngleBrackets) { 14070 verifyFormat("f<<<1, 1>>>();"); 14071 verifyFormat("f<<<1, 1, 1, s>>>();"); 14072 verifyFormat("f<<<a, b, c, d>>>();"); 14073 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 14074 verifyFormat("f<param><<<1, 1>>>();"); 14075 verifyFormat("f<1><<<1, 1>>>();"); 14076 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 14077 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14078 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 14079 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 14080 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 14081 } 14082 14083 TEST_F(FormatTest, MergeLessLessAtEnd) { 14084 verifyFormat("<<"); 14085 EXPECT_EQ("< < <", format("\\\n<<<")); 14086 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14087 "aaallvm::outs() <<"); 14088 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14089 "aaaallvm::outs()\n <<"); 14090 } 14091 14092 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 14093 std::string code = "#if A\n" 14094 "#if B\n" 14095 "a.\n" 14096 "#endif\n" 14097 " a = 1;\n" 14098 "#else\n" 14099 "#endif\n" 14100 "#if C\n" 14101 "#else\n" 14102 "#endif\n"; 14103 EXPECT_EQ(code, format(code)); 14104 } 14105 14106 TEST_F(FormatTest, HandleConflictMarkers) { 14107 // Git/SVN conflict markers. 14108 EXPECT_EQ("int a;\n" 14109 "void f() {\n" 14110 " callme(some(parameter1,\n" 14111 "<<<<<<< text by the vcs\n" 14112 " parameter2),\n" 14113 "||||||| text by the vcs\n" 14114 " parameter2),\n" 14115 " parameter3,\n" 14116 "======= text by the vcs\n" 14117 " parameter2, parameter3),\n" 14118 ">>>>>>> text by the vcs\n" 14119 " otherparameter);\n", 14120 format("int a;\n" 14121 "void f() {\n" 14122 " callme(some(parameter1,\n" 14123 "<<<<<<< text by the vcs\n" 14124 " parameter2),\n" 14125 "||||||| text by the vcs\n" 14126 " parameter2),\n" 14127 " parameter3,\n" 14128 "======= text by the vcs\n" 14129 " parameter2,\n" 14130 " parameter3),\n" 14131 ">>>>>>> text by the vcs\n" 14132 " otherparameter);\n")); 14133 14134 // Perforce markers. 14135 EXPECT_EQ("void f() {\n" 14136 " function(\n" 14137 ">>>> text by the vcs\n" 14138 " parameter,\n" 14139 "==== text by the vcs\n" 14140 " parameter,\n" 14141 "==== text by the vcs\n" 14142 " parameter,\n" 14143 "<<<< text by the vcs\n" 14144 " parameter);\n", 14145 format("void f() {\n" 14146 " function(\n" 14147 ">>>> text by the vcs\n" 14148 " parameter,\n" 14149 "==== text by the vcs\n" 14150 " parameter,\n" 14151 "==== text by the vcs\n" 14152 " parameter,\n" 14153 "<<<< text by the vcs\n" 14154 " parameter);\n")); 14155 14156 EXPECT_EQ("<<<<<<<\n" 14157 "|||||||\n" 14158 "=======\n" 14159 ">>>>>>>", 14160 format("<<<<<<<\n" 14161 "|||||||\n" 14162 "=======\n" 14163 ">>>>>>>")); 14164 14165 EXPECT_EQ("<<<<<<<\n" 14166 "|||||||\n" 14167 "int i;\n" 14168 "=======\n" 14169 ">>>>>>>", 14170 format("<<<<<<<\n" 14171 "|||||||\n" 14172 "int i;\n" 14173 "=======\n" 14174 ">>>>>>>")); 14175 14176 // FIXME: Handle parsing of macros around conflict markers correctly: 14177 EXPECT_EQ("#define Macro \\\n" 14178 "<<<<<<<\n" 14179 "Something \\\n" 14180 "|||||||\n" 14181 "Else \\\n" 14182 "=======\n" 14183 "Other \\\n" 14184 ">>>>>>>\n" 14185 " End int i;\n", 14186 format("#define Macro \\\n" 14187 "<<<<<<<\n" 14188 " Something \\\n" 14189 "|||||||\n" 14190 " Else \\\n" 14191 "=======\n" 14192 " Other \\\n" 14193 ">>>>>>>\n" 14194 " End\n" 14195 "int i;\n")); 14196 } 14197 14198 TEST_F(FormatTest, DisableRegions) { 14199 EXPECT_EQ("int i;\n" 14200 "// clang-format off\n" 14201 " int j;\n" 14202 "// clang-format on\n" 14203 "int k;", 14204 format(" int i;\n" 14205 " // clang-format off\n" 14206 " int j;\n" 14207 " // clang-format on\n" 14208 " int k;")); 14209 EXPECT_EQ("int i;\n" 14210 "/* clang-format off */\n" 14211 " int j;\n" 14212 "/* clang-format on */\n" 14213 "int k;", 14214 format(" int i;\n" 14215 " /* clang-format off */\n" 14216 " int j;\n" 14217 " /* clang-format on */\n" 14218 " int k;")); 14219 14220 // Don't reflow comments within disabled regions. 14221 EXPECT_EQ("// clang-format off\n" 14222 "// long long long long long long line\n" 14223 "/* clang-format on */\n" 14224 "/* long long long\n" 14225 " * long long long\n" 14226 " * line */\n" 14227 "int i;\n" 14228 "/* clang-format off */\n" 14229 "/* long long long long long long line */\n", 14230 format("// clang-format off\n" 14231 "// long long long long long long line\n" 14232 "/* clang-format on */\n" 14233 "/* long long long long long long line */\n" 14234 "int i;\n" 14235 "/* clang-format off */\n" 14236 "/* long long long long long long line */\n", 14237 getLLVMStyleWithColumns(20))); 14238 } 14239 14240 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 14241 format("? ) ="); 14242 verifyNoCrash("#define a\\\n /**/}"); 14243 } 14244 14245 TEST_F(FormatTest, FormatsTableGenCode) { 14246 FormatStyle Style = getLLVMStyle(); 14247 Style.Language = FormatStyle::LK_TableGen; 14248 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 14249 } 14250 14251 TEST_F(FormatTest, ArrayOfTemplates) { 14252 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 14253 format("auto a = new unique_ptr<int > [ 10];")); 14254 14255 FormatStyle Spaces = getLLVMStyle(); 14256 Spaces.SpacesInSquareBrackets = true; 14257 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 14258 format("auto a = new unique_ptr<int > [10];", Spaces)); 14259 } 14260 14261 TEST_F(FormatTest, ArrayAsTemplateType) { 14262 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 14263 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 14264 14265 FormatStyle Spaces = getLLVMStyle(); 14266 Spaces.SpacesInSquareBrackets = true; 14267 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 14268 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 14269 } 14270 14271 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); } 14272 14273 TEST(FormatStyle, GetStyleWithEmptyFileName) { 14274 llvm::vfs::InMemoryFileSystem FS; 14275 auto Style1 = getStyle("file", "", "Google", "", &FS); 14276 ASSERT_TRUE((bool)Style1); 14277 ASSERT_EQ(*Style1, getGoogleStyle()); 14278 } 14279 14280 TEST(FormatStyle, GetStyleOfFile) { 14281 llvm::vfs::InMemoryFileSystem FS; 14282 // Test 1: format file in the same directory. 14283 ASSERT_TRUE( 14284 FS.addFile("/a/.clang-format", 0, 14285 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 14286 ASSERT_TRUE( 14287 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14288 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 14289 ASSERT_TRUE((bool)Style1); 14290 ASSERT_EQ(*Style1, getLLVMStyle()); 14291 14292 // Test 2.1: fallback to default. 14293 ASSERT_TRUE( 14294 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14295 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 14296 ASSERT_TRUE((bool)Style2); 14297 ASSERT_EQ(*Style2, getMozillaStyle()); 14298 14299 // Test 2.2: no format on 'none' fallback style. 14300 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 14301 ASSERT_TRUE((bool)Style2); 14302 ASSERT_EQ(*Style2, getNoStyle()); 14303 14304 // Test 2.3: format if config is found with no based style while fallback is 14305 // 'none'. 14306 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 14307 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 14308 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 14309 ASSERT_TRUE((bool)Style2); 14310 ASSERT_EQ(*Style2, getLLVMStyle()); 14311 14312 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 14313 Style2 = getStyle("{}", "a.h", "none", "", &FS); 14314 ASSERT_TRUE((bool)Style2); 14315 ASSERT_EQ(*Style2, getLLVMStyle()); 14316 14317 // Test 3: format file in parent directory. 14318 ASSERT_TRUE( 14319 FS.addFile("/c/.clang-format", 0, 14320 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 14321 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 14322 llvm::MemoryBuffer::getMemBuffer("int i;"))); 14323 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 14324 ASSERT_TRUE((bool)Style3); 14325 ASSERT_EQ(*Style3, getGoogleStyle()); 14326 14327 // Test 4: error on invalid fallback style 14328 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 14329 ASSERT_FALSE((bool)Style4); 14330 llvm::consumeError(Style4.takeError()); 14331 14332 // Test 5: error on invalid yaml on command line 14333 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 14334 ASSERT_FALSE((bool)Style5); 14335 llvm::consumeError(Style5.takeError()); 14336 14337 // Test 6: error on invalid style 14338 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 14339 ASSERT_FALSE((bool)Style6); 14340 llvm::consumeError(Style6.takeError()); 14341 14342 // Test 7: found config file, error on parsing it 14343 ASSERT_TRUE( 14344 FS.addFile("/d/.clang-format", 0, 14345 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 14346 "InvalidKey: InvalidValue"))); 14347 ASSERT_TRUE( 14348 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14349 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 14350 ASSERT_FALSE((bool)Style7); 14351 llvm::consumeError(Style7.takeError()); 14352 14353 // Test 8: inferred per-language defaults apply. 14354 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 14355 ASSERT_TRUE((bool)StyleTd); 14356 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 14357 } 14358 14359 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 14360 // Column limit is 20. 14361 std::string Code = "Type *a =\n" 14362 " new Type();\n" 14363 "g(iiiii, 0, jjjjj,\n" 14364 " 0, kkkkk, 0, mm);\n" 14365 "int bad = format ;"; 14366 std::string Expected = "auto a = new Type();\n" 14367 "g(iiiii, nullptr,\n" 14368 " jjjjj, nullptr,\n" 14369 " kkkkk, nullptr,\n" 14370 " mm);\n" 14371 "int bad = format ;"; 14372 FileID ID = Context.createInMemoryFile("format.cpp", Code); 14373 tooling::Replacements Replaces = toReplacements( 14374 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 14375 "auto "), 14376 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 14377 "nullptr"), 14378 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 14379 "nullptr"), 14380 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 14381 "nullptr")}); 14382 14383 format::FormatStyle Style = format::getLLVMStyle(); 14384 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 14385 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 14386 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 14387 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 14388 auto Result = applyAllReplacements(Code, *FormattedReplaces); 14389 EXPECT_TRUE(static_cast<bool>(Result)); 14390 EXPECT_EQ(Expected, *Result); 14391 } 14392 14393 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 14394 std::string Code = "#include \"a.h\"\n" 14395 "#include \"c.h\"\n" 14396 "\n" 14397 "int main() {\n" 14398 " return 0;\n" 14399 "}"; 14400 std::string Expected = "#include \"a.h\"\n" 14401 "#include \"b.h\"\n" 14402 "#include \"c.h\"\n" 14403 "\n" 14404 "int main() {\n" 14405 " return 0;\n" 14406 "}"; 14407 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 14408 tooling::Replacements Replaces = toReplacements( 14409 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 14410 "#include \"b.h\"\n")}); 14411 14412 format::FormatStyle Style = format::getLLVMStyle(); 14413 Style.SortIncludes = true; 14414 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 14415 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 14416 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 14417 auto Result = applyAllReplacements(Code, *FormattedReplaces); 14418 EXPECT_TRUE(static_cast<bool>(Result)); 14419 EXPECT_EQ(Expected, *Result); 14420 } 14421 14422 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 14423 EXPECT_EQ("using std::cin;\n" 14424 "using std::cout;", 14425 format("using std::cout;\n" 14426 "using std::cin;", 14427 getGoogleStyle())); 14428 } 14429 14430 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 14431 format::FormatStyle Style = format::getLLVMStyle(); 14432 Style.Standard = FormatStyle::LS_Cpp03; 14433 // cpp03 recognize this string as identifier u8 and literal character 'a' 14434 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 14435 } 14436 14437 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 14438 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 14439 // all modes, including C++11, C++14 and C++17 14440 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 14441 } 14442 14443 TEST_F(FormatTest, DoNotFormatLikelyXml) { 14444 EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle())); 14445 EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle())); 14446 } 14447 14448 TEST_F(FormatTest, StructuredBindings) { 14449 // Structured bindings is a C++17 feature. 14450 // all modes, including C++11, C++14 and C++17 14451 verifyFormat("auto [a, b] = f();"); 14452 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 14453 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 14454 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 14455 EXPECT_EQ("auto const volatile [a, b] = f();", 14456 format("auto const volatile[a, b] = f();")); 14457 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 14458 EXPECT_EQ("auto &[a, b, c] = f();", 14459 format("auto &[ a , b,c ] = f();")); 14460 EXPECT_EQ("auto &&[a, b, c] = f();", 14461 format("auto &&[ a , b,c ] = f();")); 14462 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 14463 EXPECT_EQ("auto const volatile &&[a, b] = f();", 14464 format("auto const volatile &&[a, b] = f();")); 14465 EXPECT_EQ("auto const &&[a, b] = f();", 14466 format("auto const && [a, b] = f();")); 14467 EXPECT_EQ("const auto &[a, b] = f();", 14468 format("const auto & [a, b] = f();")); 14469 EXPECT_EQ("const auto volatile &&[a, b] = f();", 14470 format("const auto volatile &&[a, b] = f();")); 14471 EXPECT_EQ("volatile const auto &&[a, b] = f();", 14472 format("volatile const auto &&[a, b] = f();")); 14473 EXPECT_EQ("const auto &&[a, b] = f();", 14474 format("const auto && [a, b] = f();")); 14475 14476 // Make sure we don't mistake structured bindings for lambdas. 14477 FormatStyle PointerMiddle = getLLVMStyle(); 14478 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 14479 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 14480 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 14481 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 14482 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 14483 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 14484 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 14485 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 14486 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 14487 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 14488 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 14489 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 14490 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 14491 14492 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 14493 format("for (const auto && [a, b] : some_range) {\n}")); 14494 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 14495 format("for (const auto & [a, b] : some_range) {\n}")); 14496 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 14497 format("for (const auto[a, b] : some_range) {\n}")); 14498 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 14499 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 14500 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 14501 EXPECT_EQ("auto const &[x, y](expr);", 14502 format("auto const & [x,y] (expr);")); 14503 EXPECT_EQ("auto const &&[x, y](expr);", 14504 format("auto const && [x,y] (expr);")); 14505 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 14506 EXPECT_EQ("auto const &[x, y]{expr};", 14507 format("auto const & [x,y] {expr};")); 14508 EXPECT_EQ("auto const &&[x, y]{expr};", 14509 format("auto const && [x,y] {expr};")); 14510 14511 format::FormatStyle Spaces = format::getLLVMStyle(); 14512 Spaces.SpacesInSquareBrackets = true; 14513 verifyFormat("auto [ a, b ] = f();", Spaces); 14514 verifyFormat("auto &&[ a, b ] = f();", Spaces); 14515 verifyFormat("auto &[ a, b ] = f();", Spaces); 14516 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 14517 verifyFormat("auto const &[ a, b ] = f();", Spaces); 14518 } 14519 14520 TEST_F(FormatTest, FileAndCode) { 14521 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 14522 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 14523 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 14524 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 14525 EXPECT_EQ(FormatStyle::LK_ObjC, 14526 guessLanguage("foo.h", "@interface Foo\n@end\n")); 14527 EXPECT_EQ( 14528 FormatStyle::LK_ObjC, 14529 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 14530 EXPECT_EQ(FormatStyle::LK_ObjC, 14531 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 14532 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 14533 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 14534 EXPECT_EQ(FormatStyle::LK_ObjC, 14535 guessLanguage("foo", "@interface Foo\n@end\n")); 14536 EXPECT_EQ(FormatStyle::LK_ObjC, 14537 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 14538 EXPECT_EQ( 14539 FormatStyle::LK_ObjC, 14540 guessLanguage("foo.h", 14541 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 14542 EXPECT_EQ( 14543 FormatStyle::LK_Cpp, 14544 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 14545 } 14546 14547 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 14548 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 14549 EXPECT_EQ(FormatStyle::LK_ObjC, 14550 guessLanguage("foo.h", "array[[calculator getIndex]];")); 14551 EXPECT_EQ(FormatStyle::LK_Cpp, 14552 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 14553 EXPECT_EQ( 14554 FormatStyle::LK_Cpp, 14555 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 14556 EXPECT_EQ(FormatStyle::LK_ObjC, 14557 guessLanguage("foo.h", "[[noreturn foo] bar];")); 14558 EXPECT_EQ(FormatStyle::LK_Cpp, 14559 guessLanguage("foo.h", "[[clang::fallthrough]];")); 14560 EXPECT_EQ(FormatStyle::LK_ObjC, 14561 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 14562 EXPECT_EQ(FormatStyle::LK_Cpp, 14563 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 14564 EXPECT_EQ(FormatStyle::LK_Cpp, 14565 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 14566 EXPECT_EQ(FormatStyle::LK_ObjC, 14567 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 14568 EXPECT_EQ(FormatStyle::LK_Cpp, 14569 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 14570 EXPECT_EQ( 14571 FormatStyle::LK_Cpp, 14572 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 14573 EXPECT_EQ( 14574 FormatStyle::LK_Cpp, 14575 guessLanguage("foo.h", 14576 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 14577 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 14578 } 14579 14580 TEST_F(FormatTest, GuessLanguageWithCaret) { 14581 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 14582 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 14583 EXPECT_EQ(FormatStyle::LK_ObjC, 14584 guessLanguage("foo.h", "int(^)(char, float);")); 14585 EXPECT_EQ(FormatStyle::LK_ObjC, 14586 guessLanguage("foo.h", "int(^foo)(char, float);")); 14587 EXPECT_EQ(FormatStyle::LK_ObjC, 14588 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 14589 EXPECT_EQ(FormatStyle::LK_ObjC, 14590 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 14591 EXPECT_EQ( 14592 FormatStyle::LK_ObjC, 14593 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 14594 } 14595 14596 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 14597 EXPECT_EQ(FormatStyle::LK_Cpp, 14598 guessLanguage("foo.h", "void f() {\n" 14599 " asm (\"mov %[e], %[d]\"\n" 14600 " : [d] \"=rm\" (d)\n" 14601 " [e] \"rm\" (*e));\n" 14602 "}")); 14603 EXPECT_EQ(FormatStyle::LK_Cpp, 14604 guessLanguage("foo.h", "void f() {\n" 14605 " _asm (\"mov %[e], %[d]\"\n" 14606 " : [d] \"=rm\" (d)\n" 14607 " [e] \"rm\" (*e));\n" 14608 "}")); 14609 EXPECT_EQ(FormatStyle::LK_Cpp, 14610 guessLanguage("foo.h", "void f() {\n" 14611 " __asm (\"mov %[e], %[d]\"\n" 14612 " : [d] \"=rm\" (d)\n" 14613 " [e] \"rm\" (*e));\n" 14614 "}")); 14615 EXPECT_EQ(FormatStyle::LK_Cpp, 14616 guessLanguage("foo.h", "void f() {\n" 14617 " __asm__ (\"mov %[e], %[d]\"\n" 14618 " : [d] \"=rm\" (d)\n" 14619 " [e] \"rm\" (*e));\n" 14620 "}")); 14621 EXPECT_EQ(FormatStyle::LK_Cpp, 14622 guessLanguage("foo.h", "void f() {\n" 14623 " asm (\"mov %[e], %[d]\"\n" 14624 " : [d] \"=rm\" (d),\n" 14625 " [e] \"rm\" (*e));\n" 14626 "}")); 14627 EXPECT_EQ(FormatStyle::LK_Cpp, 14628 guessLanguage("foo.h", "void f() {\n" 14629 " asm volatile (\"mov %[e], %[d]\"\n" 14630 " : [d] \"=rm\" (d)\n" 14631 " [e] \"rm\" (*e));\n" 14632 "}")); 14633 } 14634 14635 TEST_F(FormatTest, GuessLanguageWithChildLines) { 14636 EXPECT_EQ(FormatStyle::LK_Cpp, 14637 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 14638 EXPECT_EQ(FormatStyle::LK_ObjC, 14639 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 14640 EXPECT_EQ( 14641 FormatStyle::LK_Cpp, 14642 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 14643 EXPECT_EQ( 14644 FormatStyle::LK_ObjC, 14645 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 14646 } 14647 14648 TEST_F(FormatTest, TypenameMacros) { 14649 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 14650 14651 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 14652 FormatStyle Google = getGoogleStyleWithColumns(0); 14653 Google.TypenameMacros = TypenameMacros; 14654 verifyFormat("struct foo {\n" 14655 " int bar;\n" 14656 " TAILQ_ENTRY(a) bleh;\n" 14657 "};", 14658 Google); 14659 14660 FormatStyle Macros = getLLVMStyle(); 14661 Macros.TypenameMacros = TypenameMacros; 14662 14663 verifyFormat("STACK_OF(int) a;", Macros); 14664 verifyFormat("STACK_OF(int) *a;", Macros); 14665 verifyFormat("STACK_OF(int const *) *a;", Macros); 14666 verifyFormat("STACK_OF(int *const) *a;", Macros); 14667 verifyFormat("STACK_OF(int, string) a;", Macros); 14668 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 14669 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 14670 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 14671 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 14672 14673 Macros.PointerAlignment = FormatStyle::PAS_Left; 14674 verifyFormat("STACK_OF(int)* a;", Macros); 14675 verifyFormat("STACK_OF(int*)* a;", Macros); 14676 } 14677 14678 TEST_F(FormatTest, AmbersandInLamda) { 14679 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899 14680 FormatStyle AlignStyle = getLLVMStyle(); 14681 AlignStyle.PointerAlignment = FormatStyle::PAS_Left; 14682 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 14683 AlignStyle.PointerAlignment = FormatStyle::PAS_Right; 14684 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 14685 } 14686 14687 TEST_F(FormatTest, AlternativeOperators) { 14688 // Test case for ensuring alternate operators are not 14689 // combined with their right most neighbour. 14690 verifyFormat("int a and b;"); 14691 verifyFormat("int a and_eq b;"); 14692 verifyFormat("int a bitand b;"); 14693 verifyFormat("int a bitor b;"); 14694 verifyFormat("int a compl b;"); 14695 verifyFormat("int a not b;"); 14696 verifyFormat("int a not_eq b;"); 14697 verifyFormat("int a or b;"); 14698 verifyFormat("int a xor b;"); 14699 verifyFormat("int a xor_eq b;"); 14700 verifyFormat("return this not_eq bitand other;"); 14701 verifyFormat("bool operator not_eq(const X bitand other)"); 14702 14703 verifyFormat("int a and 5;"); 14704 verifyFormat("int a and_eq 5;"); 14705 verifyFormat("int a bitand 5;"); 14706 verifyFormat("int a bitor 5;"); 14707 verifyFormat("int a compl 5;"); 14708 verifyFormat("int a not 5;"); 14709 verifyFormat("int a not_eq 5;"); 14710 verifyFormat("int a or 5;"); 14711 verifyFormat("int a xor 5;"); 14712 verifyFormat("int a xor_eq 5;"); 14713 14714 verifyFormat("int a compl(5);"); 14715 verifyFormat("int a not(5);"); 14716 14717 /* FIXME handle alternate tokens 14718 * https://en.cppreference.com/w/cpp/language/operator_alternative 14719 // alternative tokens 14720 verifyFormat("compl foo();"); // ~foo(); 14721 verifyFormat("foo() <%%>;"); // foo(); 14722 verifyFormat("void foo() <%%>;"); // void foo(){} 14723 verifyFormat("int a <:1:>;"); // int a[1];[ 14724 verifyFormat("%:define ABC abc"); // #define ABC abc 14725 verifyFormat("%:%:"); // ## 14726 */ 14727 } 14728 14729 TEST_F(FormatTest, STLWhileNotDefineChed) { 14730 verifyFormat("#if defined(while)\n" 14731 "#define while EMIT WARNING C4005\n" 14732 "#endif // while"); 14733 } 14734 14735 } // namespace 14736 } // namespace format 14737 } // namespace clang 14738