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