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 = true; 648 649 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 650 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 651 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 652 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 653 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 654 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 655 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 656 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 657 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 658 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 659 verifyFormat("if (true)\n" 660 "{\n" 661 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 662 "}", 663 AllowSimpleBracedStatements); 664 verifyFormat("if (true)\n" 665 "{ //\n" 666 " f();\n" 667 "}", 668 AllowSimpleBracedStatements); 669 verifyFormat("if (true)\n" 670 "{\n" 671 " f();\n" 672 " f();\n" 673 "}", 674 AllowSimpleBracedStatements); 675 verifyFormat("if (true)\n" 676 "{\n" 677 " f();\n" 678 "} else\n" 679 "{\n" 680 " f();\n" 681 "}", 682 AllowSimpleBracedStatements); 683 684 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 685 FormatStyle::SIS_Never; 686 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 687 verifyFormat("if (true)\n" 688 "{\n" 689 " f();\n" 690 "}", 691 AllowSimpleBracedStatements); 692 verifyFormat("if (true)\n" 693 "{\n" 694 " f();\n" 695 "} else\n" 696 "{\n" 697 " f();\n" 698 "}", 699 AllowSimpleBracedStatements); 700 701 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 702 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 703 verifyFormat("while (true)\n" 704 "{\n" 705 " f();\n" 706 "}", 707 AllowSimpleBracedStatements); 708 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 709 verifyFormat("for (;;)\n" 710 "{\n" 711 " f();\n" 712 "}", 713 AllowSimpleBracedStatements); 714 } 715 716 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) { 717 FormatStyle Style = getLLVMStyleWithColumns(60); 718 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 719 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 720 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 721 EXPECT_EQ("#define A \\\n" 722 " if (HANDLEwernufrnuLwrmviferuvnierv) \\\n" 723 " { RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; }\n" 724 "X;", 725 format("#define A \\\n" 726 " if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n" 727 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n" 728 " }\n" 729 "X;", 730 Style)); 731 } 732 733 TEST_F(FormatTest, ParseIfElse) { 734 verifyFormat("if (true)\n" 735 " if (true)\n" 736 " if (true)\n" 737 " f();\n" 738 " else\n" 739 " g();\n" 740 " else\n" 741 " h();\n" 742 "else\n" 743 " i();"); 744 verifyFormat("if (true)\n" 745 " if (true)\n" 746 " if (true) {\n" 747 " if (true)\n" 748 " f();\n" 749 " } else {\n" 750 " g();\n" 751 " }\n" 752 " else\n" 753 " h();\n" 754 "else {\n" 755 " i();\n" 756 "}"); 757 verifyFormat("if (true)\n" 758 " if constexpr (true)\n" 759 " if (true) {\n" 760 " if constexpr (true)\n" 761 " f();\n" 762 " } else {\n" 763 " g();\n" 764 " }\n" 765 " else\n" 766 " h();\n" 767 "else {\n" 768 " i();\n" 769 "}"); 770 verifyFormat("if (true)\n" 771 " if CONSTEXPR (true)\n" 772 " if (true) {\n" 773 " if CONSTEXPR (true)\n" 774 " f();\n" 775 " } else {\n" 776 " g();\n" 777 " }\n" 778 " else\n" 779 " h();\n" 780 "else {\n" 781 " i();\n" 782 "}"); 783 verifyFormat("void f() {\n" 784 " if (a) {\n" 785 " } else {\n" 786 " }\n" 787 "}"); 788 } 789 790 TEST_F(FormatTest, ElseIf) { 791 verifyFormat("if (a) {\n} else if (b) {\n}"); 792 verifyFormat("if (a)\n" 793 " f();\n" 794 "else if (b)\n" 795 " g();\n" 796 "else\n" 797 " h();"); 798 verifyFormat("if constexpr (a)\n" 799 " f();\n" 800 "else if constexpr (b)\n" 801 " g();\n" 802 "else\n" 803 " h();"); 804 verifyFormat("if CONSTEXPR (a)\n" 805 " f();\n" 806 "else if CONSTEXPR (b)\n" 807 " g();\n" 808 "else\n" 809 " h();"); 810 verifyFormat("if (a) {\n" 811 " f();\n" 812 "}\n" 813 "// or else ..\n" 814 "else {\n" 815 " g()\n" 816 "}"); 817 818 verifyFormat("if (a) {\n" 819 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 820 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 821 "}"); 822 verifyFormat("if (a) {\n" 823 "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 824 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 825 "}"); 826 verifyFormat("if (a) {\n" 827 "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 828 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 829 "}"); 830 verifyFormat("if (a) {\n" 831 "} else if (\n" 832 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 833 "}", 834 getLLVMStyleWithColumns(62)); 835 verifyFormat("if (a) {\n" 836 "} else if constexpr (\n" 837 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 838 "}", 839 getLLVMStyleWithColumns(62)); 840 verifyFormat("if (a) {\n" 841 "} else if CONSTEXPR (\n" 842 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 843 "}", 844 getLLVMStyleWithColumns(62)); 845 } 846 847 TEST_F(FormatTest, FormatsForLoop) { 848 verifyFormat( 849 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 850 " ++VeryVeryLongLoopVariable)\n" 851 " ;"); 852 verifyFormat("for (;;)\n" 853 " f();"); 854 verifyFormat("for (;;) {\n}"); 855 verifyFormat("for (;;) {\n" 856 " f();\n" 857 "}"); 858 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 859 860 verifyFormat( 861 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 862 " E = UnwrappedLines.end();\n" 863 " I != E; ++I) {\n}"); 864 865 verifyFormat( 866 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 867 " ++IIIII) {\n}"); 868 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 869 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 870 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 871 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 872 " I = FD->getDeclsInPrototypeScope().begin(),\n" 873 " E = FD->getDeclsInPrototypeScope().end();\n" 874 " I != E; ++I) {\n}"); 875 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n" 876 " I = Container.begin(),\n" 877 " E = Container.end();\n" 878 " I != E; ++I) {\n}", 879 getLLVMStyleWithColumns(76)); 880 881 verifyFormat( 882 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 883 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 884 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 885 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 886 " ++aaaaaaaaaaa) {\n}"); 887 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 888 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n" 889 " ++i) {\n}"); 890 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 891 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 892 "}"); 893 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 894 " aaaaaaaaaa);\n" 895 " iter; ++iter) {\n" 896 "}"); 897 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 898 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 899 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n" 900 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {"); 901 902 // These should not be formatted as Objective-C for-in loops. 903 verifyFormat("for (Foo *x = 0; x != in; x++) {\n}"); 904 verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}"); 905 verifyFormat("Foo *x;\nfor (x in y) {\n}"); 906 verifyFormat( 907 "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}"); 908 909 FormatStyle NoBinPacking = getLLVMStyle(); 910 NoBinPacking.BinPackParameters = false; 911 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 912 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 913 " aaaaaaaaaaaaaaaa,\n" 914 " aaaaaaaaaaaaaaaa,\n" 915 " aaaaaaaaaaaaaaaa);\n" 916 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 917 "}", 918 NoBinPacking); 919 verifyFormat( 920 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 921 " E = UnwrappedLines.end();\n" 922 " I != E;\n" 923 " ++I) {\n}", 924 NoBinPacking); 925 926 FormatStyle AlignLeft = getLLVMStyle(); 927 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 928 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft); 929 } 930 931 TEST_F(FormatTest, RangeBasedForLoops) { 932 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 933 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 934 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 935 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 936 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 937 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 938 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n" 939 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}"); 940 } 941 942 TEST_F(FormatTest, ForEachLoops) { 943 verifyFormat("void f() {\n" 944 " foreach (Item *item, itemlist) {}\n" 945 " Q_FOREACH (Item *item, itemlist) {}\n" 946 " BOOST_FOREACH (Item *item, itemlist) {}\n" 947 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 948 "}"); 949 950 // As function-like macros. 951 verifyFormat("#define foreach(x, y)\n" 952 "#define Q_FOREACH(x, y)\n" 953 "#define BOOST_FOREACH(x, y)\n" 954 "#define UNKNOWN_FOREACH(x, y)\n"); 955 956 // Not as function-like macros. 957 verifyFormat("#define foreach (x, y)\n" 958 "#define Q_FOREACH (x, y)\n" 959 "#define BOOST_FOREACH (x, y)\n" 960 "#define UNKNOWN_FOREACH (x, y)\n"); 961 } 962 963 TEST_F(FormatTest, FormatsWhileLoop) { 964 verifyFormat("while (true) {\n}"); 965 verifyFormat("while (true)\n" 966 " f();"); 967 verifyFormat("while () {\n}"); 968 verifyFormat("while () {\n" 969 " f();\n" 970 "}"); 971 } 972 973 TEST_F(FormatTest, FormatsDoWhile) { 974 verifyFormat("do {\n" 975 " do_something();\n" 976 "} while (something());"); 977 verifyFormat("do\n" 978 " do_something();\n" 979 "while (something());"); 980 } 981 982 TEST_F(FormatTest, FormatsSwitchStatement) { 983 verifyFormat("switch (x) {\n" 984 "case 1:\n" 985 " f();\n" 986 " break;\n" 987 "case kFoo:\n" 988 "case ns::kBar:\n" 989 "case kBaz:\n" 990 " break;\n" 991 "default:\n" 992 " g();\n" 993 " break;\n" 994 "}"); 995 verifyFormat("switch (x) {\n" 996 "case 1: {\n" 997 " f();\n" 998 " break;\n" 999 "}\n" 1000 "case 2: {\n" 1001 " break;\n" 1002 "}\n" 1003 "}"); 1004 verifyFormat("switch (x) {\n" 1005 "case 1: {\n" 1006 " f();\n" 1007 " {\n" 1008 " g();\n" 1009 " h();\n" 1010 " }\n" 1011 " break;\n" 1012 "}\n" 1013 "}"); 1014 verifyFormat("switch (x) {\n" 1015 "case 1: {\n" 1016 " f();\n" 1017 " if (foo) {\n" 1018 " g();\n" 1019 " h();\n" 1020 " }\n" 1021 " break;\n" 1022 "}\n" 1023 "}"); 1024 verifyFormat("switch (x) {\n" 1025 "case 1: {\n" 1026 " f();\n" 1027 " g();\n" 1028 "} break;\n" 1029 "}"); 1030 verifyFormat("switch (test)\n" 1031 " ;"); 1032 verifyFormat("switch (x) {\n" 1033 "default: {\n" 1034 " // Do nothing.\n" 1035 "}\n" 1036 "}"); 1037 verifyFormat("switch (x) {\n" 1038 "// comment\n" 1039 "// if 1, do f()\n" 1040 "case 1:\n" 1041 " f();\n" 1042 "}"); 1043 verifyFormat("switch (x) {\n" 1044 "case 1:\n" 1045 " // Do amazing stuff\n" 1046 " {\n" 1047 " f();\n" 1048 " g();\n" 1049 " }\n" 1050 " break;\n" 1051 "}"); 1052 verifyFormat("#define A \\\n" 1053 " switch (x) { \\\n" 1054 " case a: \\\n" 1055 " foo = b; \\\n" 1056 " }", 1057 getLLVMStyleWithColumns(20)); 1058 verifyFormat("#define OPERATION_CASE(name) \\\n" 1059 " case OP_name: \\\n" 1060 " return operations::Operation##name\n", 1061 getLLVMStyleWithColumns(40)); 1062 verifyFormat("switch (x) {\n" 1063 "case 1:;\n" 1064 "default:;\n" 1065 " int i;\n" 1066 "}"); 1067 1068 verifyGoogleFormat("switch (x) {\n" 1069 " case 1:\n" 1070 " f();\n" 1071 " break;\n" 1072 " case kFoo:\n" 1073 " case ns::kBar:\n" 1074 " case kBaz:\n" 1075 " break;\n" 1076 " default:\n" 1077 " g();\n" 1078 " break;\n" 1079 "}"); 1080 verifyGoogleFormat("switch (x) {\n" 1081 " case 1: {\n" 1082 " f();\n" 1083 " break;\n" 1084 " }\n" 1085 "}"); 1086 verifyGoogleFormat("switch (test)\n" 1087 " ;"); 1088 1089 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 1090 " case OP_name: \\\n" 1091 " return operations::Operation##name\n"); 1092 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 1093 " // Get the correction operation class.\n" 1094 " switch (OpCode) {\n" 1095 " CASE(Add);\n" 1096 " CASE(Subtract);\n" 1097 " default:\n" 1098 " return operations::Unknown;\n" 1099 " }\n" 1100 "#undef OPERATION_CASE\n" 1101 "}"); 1102 verifyFormat("DEBUG({\n" 1103 " switch (x) {\n" 1104 " case A:\n" 1105 " f();\n" 1106 " break;\n" 1107 " // fallthrough\n" 1108 " case B:\n" 1109 " g();\n" 1110 " break;\n" 1111 " }\n" 1112 "});"); 1113 EXPECT_EQ("DEBUG({\n" 1114 " switch (x) {\n" 1115 " case A:\n" 1116 " f();\n" 1117 " break;\n" 1118 " // On B:\n" 1119 " case B:\n" 1120 " g();\n" 1121 " break;\n" 1122 " }\n" 1123 "});", 1124 format("DEBUG({\n" 1125 " switch (x) {\n" 1126 " case A:\n" 1127 " f();\n" 1128 " break;\n" 1129 " // On B:\n" 1130 " case B:\n" 1131 " g();\n" 1132 " break;\n" 1133 " }\n" 1134 "});", 1135 getLLVMStyle())); 1136 EXPECT_EQ("switch (n) {\n" 1137 "case 0: {\n" 1138 " return false;\n" 1139 "}\n" 1140 "default: {\n" 1141 " return true;\n" 1142 "}\n" 1143 "}", 1144 format("switch (n)\n" 1145 "{\n" 1146 "case 0: {\n" 1147 " return false;\n" 1148 "}\n" 1149 "default: {\n" 1150 " return true;\n" 1151 "}\n" 1152 "}", 1153 getLLVMStyle())); 1154 verifyFormat("switch (a) {\n" 1155 "case (b):\n" 1156 " return;\n" 1157 "}"); 1158 1159 verifyFormat("switch (a) {\n" 1160 "case some_namespace::\n" 1161 " some_constant:\n" 1162 " return;\n" 1163 "}", 1164 getLLVMStyleWithColumns(34)); 1165 1166 FormatStyle Style = getLLVMStyle(); 1167 Style.IndentCaseLabels = true; 1168 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 1169 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1170 Style.BraceWrapping.AfterCaseLabel = true; 1171 Style.BraceWrapping.AfterControlStatement = true; 1172 EXPECT_EQ("switch (n)\n" 1173 "{\n" 1174 " case 0:\n" 1175 " {\n" 1176 " return false;\n" 1177 " }\n" 1178 " default:\n" 1179 " {\n" 1180 " return true;\n" 1181 " }\n" 1182 "}", 1183 format("switch (n) {\n" 1184 " case 0: {\n" 1185 " return false;\n" 1186 " }\n" 1187 " default: {\n" 1188 " return true;\n" 1189 " }\n" 1190 "}", 1191 Style)); 1192 Style.BraceWrapping.AfterCaseLabel = false; 1193 EXPECT_EQ("switch (n)\n" 1194 "{\n" 1195 " case 0: {\n" 1196 " return false;\n" 1197 " }\n" 1198 " default: {\n" 1199 " return true;\n" 1200 " }\n" 1201 "}", 1202 format("switch (n) {\n" 1203 " case 0:\n" 1204 " {\n" 1205 " return false;\n" 1206 " }\n" 1207 " default:\n" 1208 " {\n" 1209 " return true;\n" 1210 " }\n" 1211 "}", 1212 Style)); 1213 } 1214 1215 TEST_F(FormatTest, CaseRanges) { 1216 verifyFormat("switch (x) {\n" 1217 "case 'A' ... 'Z':\n" 1218 "case 1 ... 5:\n" 1219 "case a ... b:\n" 1220 " break;\n" 1221 "}"); 1222 } 1223 1224 TEST_F(FormatTest, ShortCaseLabels) { 1225 FormatStyle Style = getLLVMStyle(); 1226 Style.AllowShortCaseLabelsOnASingleLine = true; 1227 verifyFormat("switch (a) {\n" 1228 "case 1: x = 1; break;\n" 1229 "case 2: return;\n" 1230 "case 3:\n" 1231 "case 4:\n" 1232 "case 5: return;\n" 1233 "case 6: // comment\n" 1234 " return;\n" 1235 "case 7:\n" 1236 " // comment\n" 1237 " return;\n" 1238 "case 8:\n" 1239 " x = 8; // comment\n" 1240 " break;\n" 1241 "default: y = 1; break;\n" 1242 "}", 1243 Style); 1244 verifyFormat("switch (a) {\n" 1245 "case 0: return; // comment\n" 1246 "case 1: break; // comment\n" 1247 "case 2: return;\n" 1248 "// comment\n" 1249 "case 3: return;\n" 1250 "// comment 1\n" 1251 "// comment 2\n" 1252 "// comment 3\n" 1253 "case 4: break; /* comment */\n" 1254 "case 5:\n" 1255 " // comment\n" 1256 " break;\n" 1257 "case 6: /* comment */ x = 1; break;\n" 1258 "case 7: x = /* comment */ 1; break;\n" 1259 "case 8:\n" 1260 " x = 1; /* comment */\n" 1261 " break;\n" 1262 "case 9:\n" 1263 " break; // comment line 1\n" 1264 " // comment line 2\n" 1265 "}", 1266 Style); 1267 EXPECT_EQ("switch (a) {\n" 1268 "case 1:\n" 1269 " x = 8;\n" 1270 " // fall through\n" 1271 "case 2: x = 8;\n" 1272 "// comment\n" 1273 "case 3:\n" 1274 " return; /* comment line 1\n" 1275 " * comment line 2 */\n" 1276 "case 4: i = 8;\n" 1277 "// something else\n" 1278 "#if FOO\n" 1279 "case 5: break;\n" 1280 "#endif\n" 1281 "}", 1282 format("switch (a) {\n" 1283 "case 1: x = 8;\n" 1284 " // fall through\n" 1285 "case 2:\n" 1286 " x = 8;\n" 1287 "// comment\n" 1288 "case 3:\n" 1289 " return; /* comment line 1\n" 1290 " * comment line 2 */\n" 1291 "case 4:\n" 1292 " i = 8;\n" 1293 "// something else\n" 1294 "#if FOO\n" 1295 "case 5: break;\n" 1296 "#endif\n" 1297 "}", 1298 Style)); 1299 EXPECT_EQ("switch (a) {\n" 1300 "case 0:\n" 1301 " return; // long long long long long long long long long long " 1302 "long long comment\n" 1303 " // line\n" 1304 "}", 1305 format("switch (a) {\n" 1306 "case 0: return; // long long long long long long long long " 1307 "long long long long comment line\n" 1308 "}", 1309 Style)); 1310 EXPECT_EQ("switch (a) {\n" 1311 "case 0:\n" 1312 " return; /* long long long long long long long long long long " 1313 "long long comment\n" 1314 " line */\n" 1315 "}", 1316 format("switch (a) {\n" 1317 "case 0: return; /* long long long long long long long long " 1318 "long long long long comment line */\n" 1319 "}", 1320 Style)); 1321 verifyFormat("switch (a) {\n" 1322 "#if FOO\n" 1323 "case 0: return 0;\n" 1324 "#endif\n" 1325 "}", 1326 Style); 1327 verifyFormat("switch (a) {\n" 1328 "case 1: {\n" 1329 "}\n" 1330 "case 2: {\n" 1331 " return;\n" 1332 "}\n" 1333 "case 3: {\n" 1334 " x = 1;\n" 1335 " return;\n" 1336 "}\n" 1337 "case 4:\n" 1338 " if (x)\n" 1339 " return;\n" 1340 "}", 1341 Style); 1342 Style.ColumnLimit = 21; 1343 verifyFormat("switch (a) {\n" 1344 "case 1: x = 1; break;\n" 1345 "case 2: return;\n" 1346 "case 3:\n" 1347 "case 4:\n" 1348 "case 5: return;\n" 1349 "default:\n" 1350 " y = 1;\n" 1351 " break;\n" 1352 "}", 1353 Style); 1354 Style.ColumnLimit = 80; 1355 Style.AllowShortCaseLabelsOnASingleLine = false; 1356 Style.IndentCaseLabels = true; 1357 EXPECT_EQ("switch (n) {\n" 1358 " default /*comments*/:\n" 1359 " return true;\n" 1360 " case 0:\n" 1361 " return false;\n" 1362 "}", 1363 format("switch (n) {\n" 1364 "default/*comments*/:\n" 1365 " return true;\n" 1366 "case 0:\n" 1367 " return false;\n" 1368 "}", 1369 Style)); 1370 Style.AllowShortCaseLabelsOnASingleLine = true; 1371 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1372 Style.BraceWrapping.AfterCaseLabel = true; 1373 Style.BraceWrapping.AfterControlStatement = true; 1374 EXPECT_EQ("switch (n)\n" 1375 "{\n" 1376 " case 0:\n" 1377 " {\n" 1378 " return false;\n" 1379 " }\n" 1380 " default:\n" 1381 " {\n" 1382 " return true;\n" 1383 " }\n" 1384 "}", 1385 format("switch (n) {\n" 1386 " case 0: {\n" 1387 " return false;\n" 1388 " }\n" 1389 " default:\n" 1390 " {\n" 1391 " return true;\n" 1392 " }\n" 1393 "}", 1394 Style)); 1395 } 1396 1397 TEST_F(FormatTest, FormatsLabels) { 1398 verifyFormat("void f() {\n" 1399 " some_code();\n" 1400 "test_label:\n" 1401 " some_other_code();\n" 1402 " {\n" 1403 " some_more_code();\n" 1404 " another_label:\n" 1405 " some_more_code();\n" 1406 " }\n" 1407 "}"); 1408 verifyFormat("{\n" 1409 " some_code();\n" 1410 "test_label:\n" 1411 " some_other_code();\n" 1412 "}"); 1413 verifyFormat("{\n" 1414 " some_code();\n" 1415 "test_label:;\n" 1416 " int i = 0;\n" 1417 "}"); 1418 FormatStyle Style = getLLVMStyle(); 1419 Style.IndentGotoLabels = false; 1420 verifyFormat("void f() {\n" 1421 " some_code();\n" 1422 "test_label:\n" 1423 " some_other_code();\n" 1424 " {\n" 1425 " some_more_code();\n" 1426 "another_label:\n" 1427 " some_more_code();\n" 1428 " }\n" 1429 "}", 1430 Style); 1431 verifyFormat("{\n" 1432 " some_code();\n" 1433 "test_label:\n" 1434 " some_other_code();\n" 1435 "}", 1436 Style); 1437 verifyFormat("{\n" 1438 " some_code();\n" 1439 "test_label:;\n" 1440 " int i = 0;\n" 1441 "}"); 1442 } 1443 1444 //===----------------------------------------------------------------------===// 1445 // Tests for classes, namespaces, etc. 1446 //===----------------------------------------------------------------------===// 1447 1448 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1449 verifyFormat("class A {};"); 1450 } 1451 1452 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1453 verifyFormat("class A {\n" 1454 "public:\n" 1455 "public: // comment\n" 1456 "protected:\n" 1457 "private:\n" 1458 " void f() {}\n" 1459 "};"); 1460 verifyFormat("export class A {\n" 1461 "public:\n" 1462 "public: // comment\n" 1463 "protected:\n" 1464 "private:\n" 1465 " void f() {}\n" 1466 "};"); 1467 verifyGoogleFormat("class A {\n" 1468 " public:\n" 1469 " protected:\n" 1470 " private:\n" 1471 " void f() {}\n" 1472 "};"); 1473 verifyGoogleFormat("export class A {\n" 1474 " public:\n" 1475 " protected:\n" 1476 " private:\n" 1477 " void f() {}\n" 1478 "};"); 1479 verifyFormat("class A {\n" 1480 "public slots:\n" 1481 " void f1() {}\n" 1482 "public Q_SLOTS:\n" 1483 " void f2() {}\n" 1484 "protected slots:\n" 1485 " void f3() {}\n" 1486 "protected Q_SLOTS:\n" 1487 " void f4() {}\n" 1488 "private slots:\n" 1489 " void f5() {}\n" 1490 "private Q_SLOTS:\n" 1491 " void f6() {}\n" 1492 "signals:\n" 1493 " void g1();\n" 1494 "Q_SIGNALS:\n" 1495 " void g2();\n" 1496 "};"); 1497 1498 // Don't interpret 'signals' the wrong way. 1499 verifyFormat("signals.set();"); 1500 verifyFormat("for (Signals signals : f()) {\n}"); 1501 verifyFormat("{\n" 1502 " signals.set(); // This needs indentation.\n" 1503 "}"); 1504 verifyFormat("void f() {\n" 1505 "label:\n" 1506 " signals.baz();\n" 1507 "}"); 1508 } 1509 1510 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1511 EXPECT_EQ("class A {\n" 1512 "public:\n" 1513 " void f();\n" 1514 "\n" 1515 "private:\n" 1516 " void g() {}\n" 1517 " // test\n" 1518 "protected:\n" 1519 " int h;\n" 1520 "};", 1521 format("class A {\n" 1522 "public:\n" 1523 "void f();\n" 1524 "private:\n" 1525 "void g() {}\n" 1526 "// test\n" 1527 "protected:\n" 1528 "int h;\n" 1529 "};")); 1530 EXPECT_EQ("class A {\n" 1531 "protected:\n" 1532 "public:\n" 1533 " void f();\n" 1534 "};", 1535 format("class A {\n" 1536 "protected:\n" 1537 "\n" 1538 "public:\n" 1539 "\n" 1540 " void f();\n" 1541 "};")); 1542 1543 // Even ensure proper spacing inside macros. 1544 EXPECT_EQ("#define B \\\n" 1545 " class A { \\\n" 1546 " protected: \\\n" 1547 " public: \\\n" 1548 " void f(); \\\n" 1549 " };", 1550 format("#define B \\\n" 1551 " class A { \\\n" 1552 " protected: \\\n" 1553 " \\\n" 1554 " public: \\\n" 1555 " \\\n" 1556 " void f(); \\\n" 1557 " };", 1558 getGoogleStyle())); 1559 // But don't remove empty lines after macros ending in access specifiers. 1560 EXPECT_EQ("#define A private:\n" 1561 "\n" 1562 "int i;", 1563 format("#define A private:\n" 1564 "\n" 1565 "int i;")); 1566 } 1567 1568 TEST_F(FormatTest, FormatsClasses) { 1569 verifyFormat("class A : public B {};"); 1570 verifyFormat("class A : public ::B {};"); 1571 1572 verifyFormat( 1573 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1574 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1575 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1576 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1577 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1578 verifyFormat( 1579 "class A : public B, public C, public D, public E, public F {};"); 1580 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1581 " public C,\n" 1582 " public D,\n" 1583 " public E,\n" 1584 " public F,\n" 1585 " public G {};"); 1586 1587 verifyFormat("class\n" 1588 " ReallyReallyLongClassName {\n" 1589 " int i;\n" 1590 "};", 1591 getLLVMStyleWithColumns(32)); 1592 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1593 " aaaaaaaaaaaaaaaa> {};"); 1594 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1595 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1596 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1597 verifyFormat("template <class R, class C>\n" 1598 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1599 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1600 verifyFormat("class ::A::B {};"); 1601 } 1602 1603 TEST_F(FormatTest, BreakInheritanceStyle) { 1604 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1605 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1606 FormatStyle::BILS_BeforeComma; 1607 verifyFormat("class MyClass : public X {};", 1608 StyleWithInheritanceBreakBeforeComma); 1609 verifyFormat("class MyClass\n" 1610 " : public X\n" 1611 " , public Y {};", 1612 StyleWithInheritanceBreakBeforeComma); 1613 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1614 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1615 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1616 StyleWithInheritanceBreakBeforeComma); 1617 verifyFormat("struct aaaaaaaaaaaaa\n" 1618 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1619 " aaaaaaaaaaaaaaaa> {};", 1620 StyleWithInheritanceBreakBeforeComma); 1621 1622 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1623 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1624 FormatStyle::BILS_AfterColon; 1625 verifyFormat("class MyClass : public X {};", 1626 StyleWithInheritanceBreakAfterColon); 1627 verifyFormat("class MyClass : public X, public Y {};", 1628 StyleWithInheritanceBreakAfterColon); 1629 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1630 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1631 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1632 StyleWithInheritanceBreakAfterColon); 1633 verifyFormat("struct aaaaaaaaaaaaa :\n" 1634 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1635 " aaaaaaaaaaaaaaaa> {};", 1636 StyleWithInheritanceBreakAfterColon); 1637 } 1638 1639 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1640 verifyFormat("class A {\n} a, b;"); 1641 verifyFormat("struct A {\n} a, b;"); 1642 verifyFormat("union A {\n} a;"); 1643 } 1644 1645 TEST_F(FormatTest, FormatsEnum) { 1646 verifyFormat("enum {\n" 1647 " Zero,\n" 1648 " One = 1,\n" 1649 " Two = One + 1,\n" 1650 " Three = (One + Two),\n" 1651 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1652 " Five = (One, Two, Three, Four, 5)\n" 1653 "};"); 1654 verifyGoogleFormat("enum {\n" 1655 " Zero,\n" 1656 " One = 1,\n" 1657 " Two = One + 1,\n" 1658 " Three = (One + Two),\n" 1659 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1660 " Five = (One, Two, Three, Four, 5)\n" 1661 "};"); 1662 verifyFormat("enum Enum {};"); 1663 verifyFormat("enum {};"); 1664 verifyFormat("enum X E {} d;"); 1665 verifyFormat("enum __attribute__((...)) E {} d;"); 1666 verifyFormat("enum __declspec__((...)) E {} d;"); 1667 verifyFormat("enum {\n" 1668 " Bar = Foo<int, int>::value\n" 1669 "};", 1670 getLLVMStyleWithColumns(30)); 1671 1672 verifyFormat("enum ShortEnum { A, B, C };"); 1673 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1674 1675 EXPECT_EQ("enum KeepEmptyLines {\n" 1676 " ONE,\n" 1677 "\n" 1678 " TWO,\n" 1679 "\n" 1680 " THREE\n" 1681 "}", 1682 format("enum KeepEmptyLines {\n" 1683 " ONE,\n" 1684 "\n" 1685 " TWO,\n" 1686 "\n" 1687 "\n" 1688 " THREE\n" 1689 "}")); 1690 verifyFormat("enum E { // comment\n" 1691 " ONE,\n" 1692 " TWO\n" 1693 "};\n" 1694 "int i;"); 1695 // Not enums. 1696 verifyFormat("enum X f() {\n" 1697 " a();\n" 1698 " return 42;\n" 1699 "}"); 1700 verifyFormat("enum X Type::f() {\n" 1701 " a();\n" 1702 " return 42;\n" 1703 "}"); 1704 verifyFormat("enum ::X f() {\n" 1705 " a();\n" 1706 " return 42;\n" 1707 "}"); 1708 verifyFormat("enum ns::X f() {\n" 1709 " a();\n" 1710 " return 42;\n" 1711 "}"); 1712 } 1713 1714 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1715 verifyFormat("enum Type {\n" 1716 " One = 0; // These semicolons should be commas.\n" 1717 " Two = 1;\n" 1718 "};"); 1719 verifyFormat("namespace n {\n" 1720 "enum Type {\n" 1721 " One,\n" 1722 " Two, // missing };\n" 1723 " int i;\n" 1724 "}\n" 1725 "void g() {}"); 1726 } 1727 1728 TEST_F(FormatTest, FormatsEnumStruct) { 1729 verifyFormat("enum struct {\n" 1730 " Zero,\n" 1731 " One = 1,\n" 1732 " Two = One + 1,\n" 1733 " Three = (One + Two),\n" 1734 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1735 " Five = (One, Two, Three, Four, 5)\n" 1736 "};"); 1737 verifyFormat("enum struct Enum {};"); 1738 verifyFormat("enum struct {};"); 1739 verifyFormat("enum struct X E {} d;"); 1740 verifyFormat("enum struct __attribute__((...)) E {} d;"); 1741 verifyFormat("enum struct __declspec__((...)) E {} d;"); 1742 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1743 } 1744 1745 TEST_F(FormatTest, FormatsEnumClass) { 1746 verifyFormat("enum class {\n" 1747 " Zero,\n" 1748 " One = 1,\n" 1749 " Two = One + 1,\n" 1750 " Three = (One + Two),\n" 1751 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1752 " Five = (One, Two, Three, Four, 5)\n" 1753 "};"); 1754 verifyFormat("enum class Enum {};"); 1755 verifyFormat("enum class {};"); 1756 verifyFormat("enum class X E {} d;"); 1757 verifyFormat("enum class __attribute__((...)) E {} d;"); 1758 verifyFormat("enum class __declspec__((...)) E {} d;"); 1759 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 1760 } 1761 1762 TEST_F(FormatTest, FormatsEnumTypes) { 1763 verifyFormat("enum X : int {\n" 1764 " A, // Force multiple lines.\n" 1765 " B\n" 1766 "};"); 1767 verifyFormat("enum X : int { A, B };"); 1768 verifyFormat("enum X : std::uint32_t { A, B };"); 1769 } 1770 1771 TEST_F(FormatTest, FormatsTypedefEnum) { 1772 FormatStyle Style = getLLVMStyle(); 1773 Style.ColumnLimit = 40; 1774 verifyFormat("typedef enum {} EmptyEnum;"); 1775 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1776 verifyFormat("typedef enum {\n" 1777 " ZERO = 0,\n" 1778 " ONE = 1,\n" 1779 " TWO = 2,\n" 1780 " THREE = 3\n" 1781 "} LongEnum;", 1782 Style); 1783 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1784 Style.BraceWrapping.AfterEnum = true; 1785 verifyFormat("typedef enum {} EmptyEnum;"); 1786 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1787 verifyFormat("typedef enum\n" 1788 "{\n" 1789 " ZERO = 0,\n" 1790 " ONE = 1,\n" 1791 " TWO = 2,\n" 1792 " THREE = 3\n" 1793 "} LongEnum;", 1794 Style); 1795 } 1796 1797 TEST_F(FormatTest, FormatsNSEnums) { 1798 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1799 verifyGoogleFormat( 1800 "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1801 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 1802 " // Information about someDecentlyLongValue.\n" 1803 " someDecentlyLongValue,\n" 1804 " // Information about anotherDecentlyLongValue.\n" 1805 " anotherDecentlyLongValue,\n" 1806 " // Information about aThirdDecentlyLongValue.\n" 1807 " aThirdDecentlyLongValue\n" 1808 "};"); 1809 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n" 1810 " // Information about someDecentlyLongValue.\n" 1811 " someDecentlyLongValue,\n" 1812 " // Information about anotherDecentlyLongValue.\n" 1813 " anotherDecentlyLongValue,\n" 1814 " // Information about aThirdDecentlyLongValue.\n" 1815 " aThirdDecentlyLongValue\n" 1816 "};"); 1817 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 1818 " a = 1,\n" 1819 " b = 2,\n" 1820 " c = 3,\n" 1821 "};"); 1822 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 1823 " a = 1,\n" 1824 " b = 2,\n" 1825 " c = 3,\n" 1826 "};"); 1827 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n" 1828 " a = 1,\n" 1829 " b = 2,\n" 1830 " c = 3,\n" 1831 "};"); 1832 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 1833 " a = 1,\n" 1834 " b = 2,\n" 1835 " c = 3,\n" 1836 "};"); 1837 } 1838 1839 TEST_F(FormatTest, FormatsBitfields) { 1840 verifyFormat("struct Bitfields {\n" 1841 " unsigned sClass : 8;\n" 1842 " unsigned ValueKind : 2;\n" 1843 "};"); 1844 verifyFormat("struct A {\n" 1845 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 1846 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 1847 "};"); 1848 verifyFormat("struct MyStruct {\n" 1849 " uchar data;\n" 1850 " uchar : 8;\n" 1851 " uchar : 8;\n" 1852 " uchar other;\n" 1853 "};"); 1854 } 1855 1856 TEST_F(FormatTest, FormatsNamespaces) { 1857 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 1858 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 1859 1860 verifyFormat("namespace some_namespace {\n" 1861 "class A {};\n" 1862 "void f() { f(); }\n" 1863 "}", 1864 LLVMWithNoNamespaceFix); 1865 verifyFormat("namespace N::inline D {\n" 1866 "class A {};\n" 1867 "void f() { f(); }\n" 1868 "}", 1869 LLVMWithNoNamespaceFix); 1870 verifyFormat("namespace N::inline D::E {\n" 1871 "class A {};\n" 1872 "void f() { f(); }\n" 1873 "}", 1874 LLVMWithNoNamespaceFix); 1875 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n" 1876 "class A {};\n" 1877 "void f() { f(); }\n" 1878 "}", 1879 LLVMWithNoNamespaceFix); 1880 verifyFormat("/* something */ namespace some_namespace {\n" 1881 "class A {};\n" 1882 "void f() { f(); }\n" 1883 "}", 1884 LLVMWithNoNamespaceFix); 1885 verifyFormat("namespace {\n" 1886 "class A {};\n" 1887 "void f() { f(); }\n" 1888 "}", 1889 LLVMWithNoNamespaceFix); 1890 verifyFormat("/* something */ namespace {\n" 1891 "class A {};\n" 1892 "void f() { f(); }\n" 1893 "}", 1894 LLVMWithNoNamespaceFix); 1895 verifyFormat("inline namespace X {\n" 1896 "class A {};\n" 1897 "void f() { f(); }\n" 1898 "}", 1899 LLVMWithNoNamespaceFix); 1900 verifyFormat("/* something */ inline namespace X {\n" 1901 "class A {};\n" 1902 "void f() { f(); }\n" 1903 "}", 1904 LLVMWithNoNamespaceFix); 1905 verifyFormat("export namespace X {\n" 1906 "class A {};\n" 1907 "void f() { f(); }\n" 1908 "}", 1909 LLVMWithNoNamespaceFix); 1910 verifyFormat("using namespace some_namespace;\n" 1911 "class A {};\n" 1912 "void f() { f(); }", 1913 LLVMWithNoNamespaceFix); 1914 1915 // This code is more common than we thought; if we 1916 // layout this correctly the semicolon will go into 1917 // its own line, which is undesirable. 1918 verifyFormat("namespace {};", LLVMWithNoNamespaceFix); 1919 verifyFormat("namespace {\n" 1920 "class A {};\n" 1921 "};", 1922 LLVMWithNoNamespaceFix); 1923 1924 verifyFormat("namespace {\n" 1925 "int SomeVariable = 0; // comment\n" 1926 "} // namespace", 1927 LLVMWithNoNamespaceFix); 1928 EXPECT_EQ("#ifndef HEADER_GUARD\n" 1929 "#define HEADER_GUARD\n" 1930 "namespace my_namespace {\n" 1931 "int i;\n" 1932 "} // my_namespace\n" 1933 "#endif // HEADER_GUARD", 1934 format("#ifndef HEADER_GUARD\n" 1935 " #define HEADER_GUARD\n" 1936 " namespace my_namespace {\n" 1937 "int i;\n" 1938 "} // my_namespace\n" 1939 "#endif // HEADER_GUARD", 1940 LLVMWithNoNamespaceFix)); 1941 1942 EXPECT_EQ("namespace A::B {\n" 1943 "class C {};\n" 1944 "}", 1945 format("namespace A::B {\n" 1946 "class C {};\n" 1947 "}", 1948 LLVMWithNoNamespaceFix)); 1949 1950 FormatStyle Style = getLLVMStyle(); 1951 Style.NamespaceIndentation = FormatStyle::NI_All; 1952 EXPECT_EQ("namespace out {\n" 1953 " int i;\n" 1954 " namespace in {\n" 1955 " int i;\n" 1956 " } // namespace in\n" 1957 "} // namespace out", 1958 format("namespace out {\n" 1959 "int i;\n" 1960 "namespace in {\n" 1961 "int i;\n" 1962 "} // namespace in\n" 1963 "} // namespace out", 1964 Style)); 1965 1966 Style.NamespaceIndentation = FormatStyle::NI_Inner; 1967 EXPECT_EQ("namespace out {\n" 1968 "int i;\n" 1969 "namespace in {\n" 1970 " int i;\n" 1971 "} // namespace in\n" 1972 "} // namespace out", 1973 format("namespace out {\n" 1974 "int i;\n" 1975 "namespace in {\n" 1976 "int i;\n" 1977 "} // namespace in\n" 1978 "} // namespace out", 1979 Style)); 1980 } 1981 1982 TEST_F(FormatTest, NamespaceMacros) { 1983 FormatStyle Style = getLLVMStyle(); 1984 Style.NamespaceMacros.push_back("TESTSUITE"); 1985 1986 verifyFormat("TESTSUITE(A) {\n" 1987 "int foo();\n" 1988 "} // TESTSUITE(A)", 1989 Style); 1990 1991 verifyFormat("TESTSUITE(A, B) {\n" 1992 "int foo();\n" 1993 "} // TESTSUITE(A)", 1994 Style); 1995 1996 // Properly indent according to NamespaceIndentation style 1997 Style.NamespaceIndentation = FormatStyle::NI_All; 1998 verifyFormat("TESTSUITE(A) {\n" 1999 " int foo();\n" 2000 "} // TESTSUITE(A)", 2001 Style); 2002 verifyFormat("TESTSUITE(A) {\n" 2003 " namespace B {\n" 2004 " int foo();\n" 2005 " } // namespace B\n" 2006 "} // TESTSUITE(A)", 2007 Style); 2008 verifyFormat("namespace A {\n" 2009 " TESTSUITE(B) {\n" 2010 " int foo();\n" 2011 " } // TESTSUITE(B)\n" 2012 "} // namespace A", 2013 Style); 2014 2015 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2016 verifyFormat("TESTSUITE(A) {\n" 2017 "TESTSUITE(B) {\n" 2018 " int foo();\n" 2019 "} // TESTSUITE(B)\n" 2020 "} // TESTSUITE(A)", 2021 Style); 2022 verifyFormat("TESTSUITE(A) {\n" 2023 "namespace B {\n" 2024 " int foo();\n" 2025 "} // namespace B\n" 2026 "} // TESTSUITE(A)", 2027 Style); 2028 verifyFormat("namespace A {\n" 2029 "TESTSUITE(B) {\n" 2030 " int foo();\n" 2031 "} // TESTSUITE(B)\n" 2032 "} // namespace A", 2033 Style); 2034 2035 // Properly merge namespace-macros blocks in CompactNamespaces mode 2036 Style.NamespaceIndentation = FormatStyle::NI_None; 2037 Style.CompactNamespaces = true; 2038 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n" 2039 "}} // TESTSUITE(A::B)", 2040 Style); 2041 2042 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2043 "}} // TESTSUITE(out::in)", 2044 format("TESTSUITE(out) {\n" 2045 "TESTSUITE(in) {\n" 2046 "} // TESTSUITE(in)\n" 2047 "} // TESTSUITE(out)", 2048 Style)); 2049 2050 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2051 "}} // TESTSUITE(out::in)", 2052 format("TESTSUITE(out) {\n" 2053 "TESTSUITE(in) {\n" 2054 "} // TESTSUITE(in)\n" 2055 "} // TESTSUITE(out)", 2056 Style)); 2057 2058 // Do not merge different namespaces/macros 2059 EXPECT_EQ("namespace out {\n" 2060 "TESTSUITE(in) {\n" 2061 "} // TESTSUITE(in)\n" 2062 "} // namespace out", 2063 format("namespace out {\n" 2064 "TESTSUITE(in) {\n" 2065 "} // TESTSUITE(in)\n" 2066 "} // namespace out", 2067 Style)); 2068 EXPECT_EQ("TESTSUITE(out) {\n" 2069 "namespace in {\n" 2070 "} // namespace in\n" 2071 "} // TESTSUITE(out)", 2072 format("TESTSUITE(out) {\n" 2073 "namespace in {\n" 2074 "} // namespace in\n" 2075 "} // TESTSUITE(out)", 2076 Style)); 2077 Style.NamespaceMacros.push_back("FOOBAR"); 2078 EXPECT_EQ("TESTSUITE(out) {\n" 2079 "FOOBAR(in) {\n" 2080 "} // FOOBAR(in)\n" 2081 "} // TESTSUITE(out)", 2082 format("TESTSUITE(out) {\n" 2083 "FOOBAR(in) {\n" 2084 "} // FOOBAR(in)\n" 2085 "} // TESTSUITE(out)", 2086 Style)); 2087 } 2088 2089 TEST_F(FormatTest, FormatsCompactNamespaces) { 2090 FormatStyle Style = getLLVMStyle(); 2091 Style.CompactNamespaces = true; 2092 Style.NamespaceMacros.push_back("TESTSUITE"); 2093 2094 verifyFormat("namespace A { namespace B {\n" 2095 "}} // namespace A::B", 2096 Style); 2097 2098 EXPECT_EQ("namespace out { namespace in {\n" 2099 "}} // namespace out::in", 2100 format("namespace out {\n" 2101 "namespace in {\n" 2102 "} // namespace in\n" 2103 "} // namespace out", 2104 Style)); 2105 2106 // Only namespaces which have both consecutive opening and end get compacted 2107 EXPECT_EQ("namespace out {\n" 2108 "namespace in1 {\n" 2109 "} // namespace in1\n" 2110 "namespace in2 {\n" 2111 "} // namespace in2\n" 2112 "} // namespace out", 2113 format("namespace out {\n" 2114 "namespace in1 {\n" 2115 "} // namespace in1\n" 2116 "namespace in2 {\n" 2117 "} // namespace in2\n" 2118 "} // namespace out", 2119 Style)); 2120 2121 EXPECT_EQ("namespace out {\n" 2122 "int i;\n" 2123 "namespace in {\n" 2124 "int j;\n" 2125 "} // namespace in\n" 2126 "int k;\n" 2127 "} // namespace out", 2128 format("namespace out { int i;\n" 2129 "namespace in { int j; } // namespace in\n" 2130 "int k; } // namespace out", 2131 Style)); 2132 2133 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 2134 "}}} // namespace A::B::C\n", 2135 format("namespace A { namespace B {\n" 2136 "namespace C {\n" 2137 "}} // namespace B::C\n" 2138 "} // namespace A\n", 2139 Style)); 2140 2141 Style.ColumnLimit = 40; 2142 EXPECT_EQ("namespace aaaaaaaaaa {\n" 2143 "namespace bbbbbbbbbb {\n" 2144 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 2145 format("namespace aaaaaaaaaa {\n" 2146 "namespace bbbbbbbbbb {\n" 2147 "} // namespace bbbbbbbbbb\n" 2148 "} // namespace aaaaaaaaaa", 2149 Style)); 2150 2151 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 2152 "namespace cccccc {\n" 2153 "}}} // namespace aaaaaa::bbbbbb::cccccc", 2154 format("namespace aaaaaa {\n" 2155 "namespace bbbbbb {\n" 2156 "namespace cccccc {\n" 2157 "} // namespace cccccc\n" 2158 "} // namespace bbbbbb\n" 2159 "} // namespace aaaaaa", 2160 Style)); 2161 Style.ColumnLimit = 80; 2162 2163 // Extra semicolon after 'inner' closing brace prevents merging 2164 EXPECT_EQ("namespace out { namespace in {\n" 2165 "}; } // namespace out::in", 2166 format("namespace out {\n" 2167 "namespace in {\n" 2168 "}; // namespace in\n" 2169 "} // namespace out", 2170 Style)); 2171 2172 // Extra semicolon after 'outer' closing brace is conserved 2173 EXPECT_EQ("namespace out { namespace in {\n" 2174 "}}; // namespace out::in", 2175 format("namespace out {\n" 2176 "namespace in {\n" 2177 "} // namespace in\n" 2178 "}; // namespace out", 2179 Style)); 2180 2181 Style.NamespaceIndentation = FormatStyle::NI_All; 2182 EXPECT_EQ("namespace out { namespace in {\n" 2183 " int i;\n" 2184 "}} // namespace out::in", 2185 format("namespace out {\n" 2186 "namespace in {\n" 2187 "int i;\n" 2188 "} // namespace in\n" 2189 "} // namespace out", 2190 Style)); 2191 EXPECT_EQ("namespace out { namespace mid {\n" 2192 " namespace in {\n" 2193 " int j;\n" 2194 " } // namespace in\n" 2195 " int k;\n" 2196 "}} // namespace out::mid", 2197 format("namespace out { namespace mid {\n" 2198 "namespace in { int j; } // namespace in\n" 2199 "int k; }} // namespace out::mid", 2200 Style)); 2201 2202 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2203 EXPECT_EQ("namespace out { namespace in {\n" 2204 " int i;\n" 2205 "}} // namespace out::in", 2206 format("namespace out {\n" 2207 "namespace in {\n" 2208 "int i;\n" 2209 "} // namespace in\n" 2210 "} // namespace out", 2211 Style)); 2212 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 2213 " int i;\n" 2214 "}}} // namespace out::mid::in", 2215 format("namespace out {\n" 2216 "namespace mid {\n" 2217 "namespace in {\n" 2218 "int i;\n" 2219 "} // namespace in\n" 2220 "} // namespace mid\n" 2221 "} // namespace out", 2222 Style)); 2223 } 2224 2225 TEST_F(FormatTest, FormatsExternC) { 2226 verifyFormat("extern \"C\" {\nint a;"); 2227 verifyFormat("extern \"C\" {}"); 2228 verifyFormat("extern \"C\" {\n" 2229 "int foo();\n" 2230 "}"); 2231 verifyFormat("extern \"C\" int foo() {}"); 2232 verifyFormat("extern \"C\" int foo();"); 2233 verifyFormat("extern \"C\" int foo() {\n" 2234 " int i = 42;\n" 2235 " return i;\n" 2236 "}"); 2237 2238 FormatStyle Style = getLLVMStyle(); 2239 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2240 Style.BraceWrapping.AfterFunction = true; 2241 verifyFormat("extern \"C\" int foo() {}", Style); 2242 verifyFormat("extern \"C\" int foo();", Style); 2243 verifyFormat("extern \"C\" int foo()\n" 2244 "{\n" 2245 " int i = 42;\n" 2246 " return i;\n" 2247 "}", 2248 Style); 2249 2250 Style.BraceWrapping.AfterExternBlock = true; 2251 Style.BraceWrapping.SplitEmptyRecord = false; 2252 verifyFormat("extern \"C\"\n" 2253 "{}", 2254 Style); 2255 verifyFormat("extern \"C\"\n" 2256 "{\n" 2257 " int foo();\n" 2258 "}", 2259 Style); 2260 } 2261 2262 TEST_F(FormatTest, FormatsInlineASM) { 2263 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2264 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2265 verifyFormat( 2266 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2267 " \"cpuid\\n\\t\"\n" 2268 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2269 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2270 " : \"a\"(value));"); 2271 EXPECT_EQ( 2272 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2273 " __asm {\n" 2274 " mov edx,[that] // vtable in edx\n" 2275 " mov eax,methodIndex\n" 2276 " call [edx][eax*4] // stdcall\n" 2277 " }\n" 2278 "}", 2279 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2280 " __asm {\n" 2281 " mov edx,[that] // vtable in edx\n" 2282 " mov eax,methodIndex\n" 2283 " call [edx][eax*4] // stdcall\n" 2284 " }\n" 2285 "}")); 2286 EXPECT_EQ("_asm {\n" 2287 " xor eax, eax;\n" 2288 " cpuid;\n" 2289 "}", 2290 format("_asm {\n" 2291 " xor eax, eax;\n" 2292 " cpuid;\n" 2293 "}")); 2294 verifyFormat("void function() {\n" 2295 " // comment\n" 2296 " asm(\"\");\n" 2297 "}"); 2298 EXPECT_EQ("__asm {\n" 2299 "}\n" 2300 "int i;", 2301 format("__asm {\n" 2302 "}\n" 2303 "int i;")); 2304 } 2305 2306 TEST_F(FormatTest, FormatTryCatch) { 2307 verifyFormat("try {\n" 2308 " throw a * b;\n" 2309 "} catch (int a) {\n" 2310 " // Do nothing.\n" 2311 "} catch (...) {\n" 2312 " exit(42);\n" 2313 "}"); 2314 2315 // Function-level try statements. 2316 verifyFormat("int f() try { return 4; } catch (...) {\n" 2317 " return 5;\n" 2318 "}"); 2319 verifyFormat("class A {\n" 2320 " int a;\n" 2321 " A() try : a(0) {\n" 2322 " } catch (...) {\n" 2323 " throw;\n" 2324 " }\n" 2325 "};\n"); 2326 2327 // Incomplete try-catch blocks. 2328 verifyIncompleteFormat("try {} catch ("); 2329 } 2330 2331 TEST_F(FormatTest, FormatSEHTryCatch) { 2332 verifyFormat("__try {\n" 2333 " int a = b * c;\n" 2334 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2335 " // Do nothing.\n" 2336 "}"); 2337 2338 verifyFormat("__try {\n" 2339 " int a = b * c;\n" 2340 "} __finally {\n" 2341 " // Do nothing.\n" 2342 "}"); 2343 2344 verifyFormat("DEBUG({\n" 2345 " __try {\n" 2346 " } __finally {\n" 2347 " }\n" 2348 "});\n"); 2349 } 2350 2351 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2352 verifyFormat("try {\n" 2353 " f();\n" 2354 "} catch {\n" 2355 " g();\n" 2356 "}"); 2357 verifyFormat("try {\n" 2358 " f();\n" 2359 "} catch (A a) MACRO(x) {\n" 2360 " g();\n" 2361 "} catch (B b) MACRO(x) {\n" 2362 " g();\n" 2363 "}"); 2364 } 2365 2366 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2367 FormatStyle Style = getLLVMStyle(); 2368 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2369 FormatStyle::BS_WebKit}) { 2370 Style.BreakBeforeBraces = BraceStyle; 2371 verifyFormat("try {\n" 2372 " // something\n" 2373 "} catch (...) {\n" 2374 " // something\n" 2375 "}", 2376 Style); 2377 } 2378 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2379 verifyFormat("try {\n" 2380 " // something\n" 2381 "}\n" 2382 "catch (...) {\n" 2383 " // something\n" 2384 "}", 2385 Style); 2386 verifyFormat("__try {\n" 2387 " // something\n" 2388 "}\n" 2389 "__finally {\n" 2390 " // something\n" 2391 "}", 2392 Style); 2393 verifyFormat("@try {\n" 2394 " // something\n" 2395 "}\n" 2396 "@finally {\n" 2397 " // something\n" 2398 "}", 2399 Style); 2400 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2401 verifyFormat("try\n" 2402 "{\n" 2403 " // something\n" 2404 "}\n" 2405 "catch (...)\n" 2406 "{\n" 2407 " // something\n" 2408 "}", 2409 Style); 2410 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 2411 verifyFormat("try\n" 2412 " {\n" 2413 " // something white\n" 2414 " }\n" 2415 "catch (...)\n" 2416 " {\n" 2417 " // something white\n" 2418 " }", 2419 Style); 2420 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2421 verifyFormat("try\n" 2422 " {\n" 2423 " // something\n" 2424 " }\n" 2425 "catch (...)\n" 2426 " {\n" 2427 " // something\n" 2428 " }", 2429 Style); 2430 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2431 Style.BraceWrapping.BeforeCatch = true; 2432 verifyFormat("try {\n" 2433 " // something\n" 2434 "}\n" 2435 "catch (...) {\n" 2436 " // something\n" 2437 "}", 2438 Style); 2439 } 2440 2441 TEST_F(FormatTest, StaticInitializers) { 2442 verifyFormat("static SomeClass SC = {1, 'a'};"); 2443 2444 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2445 " 100000000, " 2446 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2447 2448 // Here, everything other than the "}" would fit on a line. 2449 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2450 " 10000000000000000000000000};"); 2451 EXPECT_EQ("S s = {a,\n" 2452 "\n" 2453 " b};", 2454 format("S s = {\n" 2455 " a,\n" 2456 "\n" 2457 " b\n" 2458 "};")); 2459 2460 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2461 // line. However, the formatting looks a bit off and this probably doesn't 2462 // happen often in practice. 2463 verifyFormat("static int Variable[1] = {\n" 2464 " {1000000000000000000000000000000000000}};", 2465 getLLVMStyleWithColumns(40)); 2466 } 2467 2468 TEST_F(FormatTest, DesignatedInitializers) { 2469 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2470 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2471 " .bbbbbbbbbb = 2,\n" 2472 " .cccccccccc = 3,\n" 2473 " .dddddddddd = 4,\n" 2474 " .eeeeeeeeee = 5};"); 2475 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2476 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2477 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2478 " .ccccccccccccccccccccccccccc = 3,\n" 2479 " .ddddddddddddddddddddddddddd = 4,\n" 2480 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2481 2482 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2483 2484 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2485 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2486 " [2] = bbbbbbbbbb,\n" 2487 " [3] = cccccccccc,\n" 2488 " [4] = dddddddddd,\n" 2489 " [5] = eeeeeeeeee};"); 2490 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2491 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2492 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2493 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2494 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2495 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2496 } 2497 2498 TEST_F(FormatTest, NestedStaticInitializers) { 2499 verifyFormat("static A x = {{{}}};\n"); 2500 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2501 " {init1, init2, init3, init4}}};", 2502 getLLVMStyleWithColumns(50)); 2503 2504 verifyFormat("somes Status::global_reps[3] = {\n" 2505 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2506 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2507 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2508 getLLVMStyleWithColumns(60)); 2509 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2510 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2511 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2512 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2513 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2514 " {rect.fRight - rect.fLeft, rect.fBottom - " 2515 "rect.fTop}};"); 2516 2517 verifyFormat( 2518 "SomeArrayOfSomeType a = {\n" 2519 " {{1, 2, 3},\n" 2520 " {1, 2, 3},\n" 2521 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2522 " 333333333333333333333333333333},\n" 2523 " {1, 2, 3},\n" 2524 " {1, 2, 3}}};"); 2525 verifyFormat( 2526 "SomeArrayOfSomeType a = {\n" 2527 " {{1, 2, 3}},\n" 2528 " {{1, 2, 3}},\n" 2529 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2530 " 333333333333333333333333333333}},\n" 2531 " {{1, 2, 3}},\n" 2532 " {{1, 2, 3}}};"); 2533 2534 verifyFormat("struct {\n" 2535 " unsigned bit;\n" 2536 " const char *const name;\n" 2537 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2538 " {kOsWin, \"Windows\"},\n" 2539 " {kOsLinux, \"Linux\"},\n" 2540 " {kOsCrOS, \"Chrome OS\"}};"); 2541 verifyFormat("struct {\n" 2542 " unsigned bit;\n" 2543 " const char *const name;\n" 2544 "} kBitsToOs[] = {\n" 2545 " {kOsMac, \"Mac\"},\n" 2546 " {kOsWin, \"Windows\"},\n" 2547 " {kOsLinux, \"Linux\"},\n" 2548 " {kOsCrOS, \"Chrome OS\"},\n" 2549 "};"); 2550 } 2551 2552 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2553 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2554 " \\\n" 2555 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2556 } 2557 2558 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2559 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2560 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2561 2562 // Do break defaulted and deleted functions. 2563 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2564 " default;", 2565 getLLVMStyleWithColumns(40)); 2566 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2567 " delete;", 2568 getLLVMStyleWithColumns(40)); 2569 } 2570 2571 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2572 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2573 getLLVMStyleWithColumns(40)); 2574 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2575 getLLVMStyleWithColumns(40)); 2576 EXPECT_EQ("#define Q \\\n" 2577 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2578 " \"aaaaaaaa.cpp\"", 2579 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2580 getLLVMStyleWithColumns(40))); 2581 } 2582 2583 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2584 EXPECT_EQ("# 123 \"A string literal\"", 2585 format(" # 123 \"A string literal\"")); 2586 } 2587 2588 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2589 EXPECT_EQ("#;", format("#;")); 2590 verifyFormat("#\n;\n;\n;"); 2591 } 2592 2593 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2594 EXPECT_EQ("#line 42 \"test\"\n", 2595 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2596 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2597 getLLVMStyleWithColumns(12))); 2598 } 2599 2600 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2601 EXPECT_EQ("#line 42 \"test\"", 2602 format("# \\\n line \\\n 42 \\\n \"test\"")); 2603 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2604 } 2605 2606 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2607 verifyFormat("#define A \\x20"); 2608 verifyFormat("#define A \\ x20"); 2609 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2610 verifyFormat("#define A ''"); 2611 verifyFormat("#define A ''qqq"); 2612 verifyFormat("#define A `qqq"); 2613 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2614 EXPECT_EQ("const char *c = STRINGIFY(\n" 2615 "\\na : b);", 2616 format("const char * c = STRINGIFY(\n" 2617 "\\na : b);")); 2618 2619 verifyFormat("a\r\\"); 2620 verifyFormat("a\v\\"); 2621 verifyFormat("a\f\\"); 2622 } 2623 2624 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2625 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2626 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2627 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2628 // FIXME: We never break before the macro name. 2629 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2630 2631 verifyFormat("#define A A\n#define A A"); 2632 verifyFormat("#define A(X) A\n#define A A"); 2633 2634 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2635 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2636 } 2637 2638 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2639 EXPECT_EQ("// somecomment\n" 2640 "#include \"a.h\"\n" 2641 "#define A( \\\n" 2642 " A, B)\n" 2643 "#include \"b.h\"\n" 2644 "// somecomment\n", 2645 format(" // somecomment\n" 2646 " #include \"a.h\"\n" 2647 "#define A(A,\\\n" 2648 " B)\n" 2649 " #include \"b.h\"\n" 2650 " // somecomment\n", 2651 getLLVMStyleWithColumns(13))); 2652 } 2653 2654 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2655 2656 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2657 EXPECT_EQ("#define A \\\n" 2658 " c; \\\n" 2659 " e;\n" 2660 "f;", 2661 format("#define A c; e;\n" 2662 "f;", 2663 getLLVMStyleWithColumns(14))); 2664 } 2665 2666 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2667 2668 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2669 EXPECT_EQ("int x,\n" 2670 "#define A\n" 2671 " y;", 2672 format("int x,\n#define A\ny;")); 2673 } 2674 2675 TEST_F(FormatTest, HashInMacroDefinition) { 2676 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2677 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2678 verifyFormat("#define A \\\n" 2679 " { \\\n" 2680 " f(#c); \\\n" 2681 " }", 2682 getLLVMStyleWithColumns(11)); 2683 2684 verifyFormat("#define A(X) \\\n" 2685 " void function##X()", 2686 getLLVMStyleWithColumns(22)); 2687 2688 verifyFormat("#define A(a, b, c) \\\n" 2689 " void a##b##c()", 2690 getLLVMStyleWithColumns(22)); 2691 2692 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2693 } 2694 2695 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2696 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2697 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2698 2699 FormatStyle Style = getLLVMStyle(); 2700 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 2701 verifyFormat("#define true ((foo)1)", Style); 2702 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 2703 verifyFormat("#define false((foo)0)", Style); 2704 } 2705 2706 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2707 EXPECT_EQ("#define A b;", format("#define A \\\n" 2708 " \\\n" 2709 " b;", 2710 getLLVMStyleWithColumns(25))); 2711 EXPECT_EQ("#define A \\\n" 2712 " \\\n" 2713 " a; \\\n" 2714 " b;", 2715 format("#define A \\\n" 2716 " \\\n" 2717 " a; \\\n" 2718 " b;", 2719 getLLVMStyleWithColumns(11))); 2720 EXPECT_EQ("#define A \\\n" 2721 " a; \\\n" 2722 " \\\n" 2723 " b;", 2724 format("#define A \\\n" 2725 " a; \\\n" 2726 " \\\n" 2727 " b;", 2728 getLLVMStyleWithColumns(11))); 2729 } 2730 2731 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 2732 verifyIncompleteFormat("#define A :"); 2733 verifyFormat("#define SOMECASES \\\n" 2734 " case 1: \\\n" 2735 " case 2\n", 2736 getLLVMStyleWithColumns(20)); 2737 verifyFormat("#define MACRO(a) \\\n" 2738 " if (a) \\\n" 2739 " f(); \\\n" 2740 " else \\\n" 2741 " g()", 2742 getLLVMStyleWithColumns(18)); 2743 verifyFormat("#define A template <typename T>"); 2744 verifyIncompleteFormat("#define STR(x) #x\n" 2745 "f(STR(this_is_a_string_literal{));"); 2746 verifyFormat("#pragma omp threadprivate( \\\n" 2747 " y)), // expected-warning", 2748 getLLVMStyleWithColumns(28)); 2749 verifyFormat("#d, = };"); 2750 verifyFormat("#if \"a"); 2751 verifyIncompleteFormat("({\n" 2752 "#define b \\\n" 2753 " } \\\n" 2754 " a\n" 2755 "a", 2756 getLLVMStyleWithColumns(15)); 2757 verifyFormat("#define A \\\n" 2758 " { \\\n" 2759 " {\n" 2760 "#define B \\\n" 2761 " } \\\n" 2762 " }", 2763 getLLVMStyleWithColumns(15)); 2764 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 2765 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 2766 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 2767 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 2768 } 2769 2770 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 2771 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 2772 EXPECT_EQ("class A : public QObject {\n" 2773 " Q_OBJECT\n" 2774 "\n" 2775 " A() {}\n" 2776 "};", 2777 format("class A : public QObject {\n" 2778 " Q_OBJECT\n" 2779 "\n" 2780 " A() {\n}\n" 2781 "} ;")); 2782 EXPECT_EQ("MACRO\n" 2783 "/*static*/ int i;", 2784 format("MACRO\n" 2785 " /*static*/ int i;")); 2786 EXPECT_EQ("SOME_MACRO\n" 2787 "namespace {\n" 2788 "void f();\n" 2789 "} // namespace", 2790 format("SOME_MACRO\n" 2791 " namespace {\n" 2792 "void f( );\n" 2793 "} // namespace")); 2794 // Only if the identifier contains at least 5 characters. 2795 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 2796 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 2797 // Only if everything is upper case. 2798 EXPECT_EQ("class A : public QObject {\n" 2799 " Q_Object A() {}\n" 2800 "};", 2801 format("class A : public QObject {\n" 2802 " Q_Object\n" 2803 " A() {\n}\n" 2804 "} ;")); 2805 2806 // Only if the next line can actually start an unwrapped line. 2807 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 2808 format("SOME_WEIRD_LOG_MACRO\n" 2809 "<< SomeThing;")); 2810 2811 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 2812 "(n, buffers))\n", 2813 getChromiumStyle(FormatStyle::LK_Cpp)); 2814 2815 // See PR41483 2816 EXPECT_EQ("/**/ FOO(a)\n" 2817 "FOO(b)", 2818 format("/**/ FOO(a)\n" 2819 "FOO(b)")); 2820 } 2821 2822 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 2823 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2824 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2825 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2826 "class X {};\n" 2827 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2828 "int *createScopDetectionPass() { return 0; }", 2829 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2830 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2831 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2832 " class X {};\n" 2833 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2834 " int *createScopDetectionPass() { return 0; }")); 2835 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 2836 // braces, so that inner block is indented one level more. 2837 EXPECT_EQ("int q() {\n" 2838 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2839 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2840 " IPC_END_MESSAGE_MAP()\n" 2841 "}", 2842 format("int q() {\n" 2843 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2844 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2845 " IPC_END_MESSAGE_MAP()\n" 2846 "}")); 2847 2848 // Same inside macros. 2849 EXPECT_EQ("#define LIST(L) \\\n" 2850 " L(A) \\\n" 2851 " L(B) \\\n" 2852 " L(C)", 2853 format("#define LIST(L) \\\n" 2854 " L(A) \\\n" 2855 " L(B) \\\n" 2856 " L(C)", 2857 getGoogleStyle())); 2858 2859 // These must not be recognized as macros. 2860 EXPECT_EQ("int q() {\n" 2861 " f(x);\n" 2862 " f(x) {}\n" 2863 " f(x)->g();\n" 2864 " f(x)->*g();\n" 2865 " f(x).g();\n" 2866 " f(x) = x;\n" 2867 " f(x) += x;\n" 2868 " f(x) -= x;\n" 2869 " f(x) *= x;\n" 2870 " f(x) /= x;\n" 2871 " f(x) %= x;\n" 2872 " f(x) &= x;\n" 2873 " f(x) |= x;\n" 2874 " f(x) ^= x;\n" 2875 " f(x) >>= x;\n" 2876 " f(x) <<= x;\n" 2877 " f(x)[y].z();\n" 2878 " LOG(INFO) << x;\n" 2879 " ifstream(x) >> x;\n" 2880 "}\n", 2881 format("int q() {\n" 2882 " f(x)\n;\n" 2883 " f(x)\n {}\n" 2884 " f(x)\n->g();\n" 2885 " f(x)\n->*g();\n" 2886 " f(x)\n.g();\n" 2887 " f(x)\n = x;\n" 2888 " f(x)\n += x;\n" 2889 " f(x)\n -= x;\n" 2890 " f(x)\n *= x;\n" 2891 " f(x)\n /= x;\n" 2892 " f(x)\n %= x;\n" 2893 " f(x)\n &= x;\n" 2894 " f(x)\n |= x;\n" 2895 " f(x)\n ^= x;\n" 2896 " f(x)\n >>= x;\n" 2897 " f(x)\n <<= x;\n" 2898 " f(x)\n[y].z();\n" 2899 " LOG(INFO)\n << x;\n" 2900 " ifstream(x)\n >> x;\n" 2901 "}\n")); 2902 EXPECT_EQ("int q() {\n" 2903 " F(x)\n" 2904 " if (1) {\n" 2905 " }\n" 2906 " F(x)\n" 2907 " while (1) {\n" 2908 " }\n" 2909 " F(x)\n" 2910 " G(x);\n" 2911 " F(x)\n" 2912 " try {\n" 2913 " Q();\n" 2914 " } catch (...) {\n" 2915 " }\n" 2916 "}\n", 2917 format("int q() {\n" 2918 "F(x)\n" 2919 "if (1) {}\n" 2920 "F(x)\n" 2921 "while (1) {}\n" 2922 "F(x)\n" 2923 "G(x);\n" 2924 "F(x)\n" 2925 "try { Q(); } catch (...) {}\n" 2926 "}\n")); 2927 EXPECT_EQ("class A {\n" 2928 " A() : t(0) {}\n" 2929 " A(int i) noexcept() : {}\n" 2930 " A(X x)\n" // FIXME: function-level try blocks are broken. 2931 " try : t(0) {\n" 2932 " } catch (...) {\n" 2933 " }\n" 2934 "};", 2935 format("class A {\n" 2936 " A()\n : t(0) {}\n" 2937 " A(int i)\n noexcept() : {}\n" 2938 " A(X x)\n" 2939 " try : t(0) {} catch (...) {}\n" 2940 "};")); 2941 FormatStyle Style = getLLVMStyle(); 2942 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2943 Style.BraceWrapping.AfterControlStatement = true; 2944 Style.BraceWrapping.AfterFunction = true; 2945 EXPECT_EQ("void f()\n" 2946 "try\n" 2947 "{\n" 2948 "}", 2949 format("void f() try {\n" 2950 "}", 2951 Style)); 2952 EXPECT_EQ("class SomeClass {\n" 2953 "public:\n" 2954 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2955 "};", 2956 format("class SomeClass {\n" 2957 "public:\n" 2958 " SomeClass()\n" 2959 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2960 "};")); 2961 EXPECT_EQ("class SomeClass {\n" 2962 "public:\n" 2963 " SomeClass()\n" 2964 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2965 "};", 2966 format("class SomeClass {\n" 2967 "public:\n" 2968 " SomeClass()\n" 2969 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2970 "};", 2971 getLLVMStyleWithColumns(40))); 2972 2973 verifyFormat("MACRO(>)"); 2974 2975 // Some macros contain an implicit semicolon. 2976 Style = getLLVMStyle(); 2977 Style.StatementMacros.push_back("FOO"); 2978 verifyFormat("FOO(a) int b = 0;"); 2979 verifyFormat("FOO(a)\n" 2980 "int b = 0;", 2981 Style); 2982 verifyFormat("FOO(a);\n" 2983 "int b = 0;", 2984 Style); 2985 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 2986 "int b = 0;", 2987 Style); 2988 verifyFormat("FOO()\n" 2989 "int b = 0;", 2990 Style); 2991 verifyFormat("FOO\n" 2992 "int b = 0;", 2993 Style); 2994 verifyFormat("void f() {\n" 2995 " FOO(a)\n" 2996 " return a;\n" 2997 "}", 2998 Style); 2999 verifyFormat("FOO(a)\n" 3000 "FOO(b)", 3001 Style); 3002 verifyFormat("int a = 0;\n" 3003 "FOO(b)\n" 3004 "int c = 0;", 3005 Style); 3006 verifyFormat("int a = 0;\n" 3007 "int x = FOO(a)\n" 3008 "int b = 0;", 3009 Style); 3010 verifyFormat("void foo(int a) { FOO(a) }\n" 3011 "uint32_t bar() {}", 3012 Style); 3013 } 3014 3015 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 3016 verifyFormat("#define A \\\n" 3017 " f({ \\\n" 3018 " g(); \\\n" 3019 " });", 3020 getLLVMStyleWithColumns(11)); 3021 } 3022 3023 TEST_F(FormatTest, IndentPreprocessorDirectives) { 3024 FormatStyle Style = getLLVMStyle(); 3025 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 3026 Style.ColumnLimit = 40; 3027 verifyFormat("#ifdef _WIN32\n" 3028 "#define A 0\n" 3029 "#ifdef VAR2\n" 3030 "#define B 1\n" 3031 "#include <someheader.h>\n" 3032 "#define MACRO \\\n" 3033 " some_very_long_func_aaaaaaaaaa();\n" 3034 "#endif\n" 3035 "#else\n" 3036 "#define A 1\n" 3037 "#endif", 3038 Style); 3039 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 3040 verifyFormat("#ifdef _WIN32\n" 3041 "# define A 0\n" 3042 "# ifdef VAR2\n" 3043 "# define B 1\n" 3044 "# include <someheader.h>\n" 3045 "# define MACRO \\\n" 3046 " some_very_long_func_aaaaaaaaaa();\n" 3047 "# endif\n" 3048 "#else\n" 3049 "# define A 1\n" 3050 "#endif", 3051 Style); 3052 verifyFormat("#if A\n" 3053 "# define MACRO \\\n" 3054 " void a(int x) { \\\n" 3055 " b(); \\\n" 3056 " c(); \\\n" 3057 " d(); \\\n" 3058 " e(); \\\n" 3059 " f(); \\\n" 3060 " }\n" 3061 "#endif", 3062 Style); 3063 // Comments before include guard. 3064 verifyFormat("// file comment\n" 3065 "// file comment\n" 3066 "#ifndef HEADER_H\n" 3067 "#define HEADER_H\n" 3068 "code();\n" 3069 "#endif", 3070 Style); 3071 // Test with include guards. 3072 verifyFormat("#ifndef HEADER_H\n" 3073 "#define HEADER_H\n" 3074 "code();\n" 3075 "#endif", 3076 Style); 3077 // Include guards must have a #define with the same variable immediately 3078 // after #ifndef. 3079 verifyFormat("#ifndef NOT_GUARD\n" 3080 "# define FOO\n" 3081 "code();\n" 3082 "#endif", 3083 Style); 3084 3085 // Include guards must cover the entire file. 3086 verifyFormat("code();\n" 3087 "code();\n" 3088 "#ifndef NOT_GUARD\n" 3089 "# define NOT_GUARD\n" 3090 "code();\n" 3091 "#endif", 3092 Style); 3093 verifyFormat("#ifndef NOT_GUARD\n" 3094 "# define NOT_GUARD\n" 3095 "code();\n" 3096 "#endif\n" 3097 "code();", 3098 Style); 3099 // Test with trailing blank lines. 3100 verifyFormat("#ifndef HEADER_H\n" 3101 "#define HEADER_H\n" 3102 "code();\n" 3103 "#endif\n", 3104 Style); 3105 // Include guards don't have #else. 3106 verifyFormat("#ifndef NOT_GUARD\n" 3107 "# define NOT_GUARD\n" 3108 "code();\n" 3109 "#else\n" 3110 "#endif", 3111 Style); 3112 verifyFormat("#ifndef NOT_GUARD\n" 3113 "# define NOT_GUARD\n" 3114 "code();\n" 3115 "#elif FOO\n" 3116 "#endif", 3117 Style); 3118 // Non-identifier #define after potential include guard. 3119 verifyFormat("#ifndef FOO\n" 3120 "# define 1\n" 3121 "#endif\n", 3122 Style); 3123 // #if closes past last non-preprocessor line. 3124 verifyFormat("#ifndef FOO\n" 3125 "#define FOO\n" 3126 "#if 1\n" 3127 "int i;\n" 3128 "# define A 0\n" 3129 "#endif\n" 3130 "#endif\n", 3131 Style); 3132 // Don't crash if there is an #elif directive without a condition. 3133 verifyFormat("#if 1\n" 3134 "int x;\n" 3135 "#elif\n" 3136 "int y;\n" 3137 "#else\n" 3138 "int z;\n" 3139 "#endif", 3140 Style); 3141 // FIXME: This doesn't handle the case where there's code between the 3142 // #ifndef and #define but all other conditions hold. This is because when 3143 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 3144 // previous code line yet, so we can't detect it. 3145 EXPECT_EQ("#ifndef NOT_GUARD\n" 3146 "code();\n" 3147 "#define NOT_GUARD\n" 3148 "code();\n" 3149 "#endif", 3150 format("#ifndef NOT_GUARD\n" 3151 "code();\n" 3152 "# define NOT_GUARD\n" 3153 "code();\n" 3154 "#endif", 3155 Style)); 3156 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 3157 // be outside an include guard. Examples are #pragma once and 3158 // #pragma GCC diagnostic, or anything else that does not change the meaning 3159 // of the file if it's included multiple times. 3160 EXPECT_EQ("#ifdef WIN32\n" 3161 "# pragma once\n" 3162 "#endif\n" 3163 "#ifndef HEADER_H\n" 3164 "# define HEADER_H\n" 3165 "code();\n" 3166 "#endif", 3167 format("#ifdef WIN32\n" 3168 "# pragma once\n" 3169 "#endif\n" 3170 "#ifndef HEADER_H\n" 3171 "#define HEADER_H\n" 3172 "code();\n" 3173 "#endif", 3174 Style)); 3175 // FIXME: This does not detect when there is a single non-preprocessor line 3176 // in front of an include-guard-like structure where other conditions hold 3177 // because ScopedLineState hides the line. 3178 EXPECT_EQ("code();\n" 3179 "#ifndef HEADER_H\n" 3180 "#define HEADER_H\n" 3181 "code();\n" 3182 "#endif", 3183 format("code();\n" 3184 "#ifndef HEADER_H\n" 3185 "# define HEADER_H\n" 3186 "code();\n" 3187 "#endif", 3188 Style)); 3189 // Keep comments aligned with #, otherwise indent comments normally. These 3190 // tests cannot use verifyFormat because messUp manipulates leading 3191 // whitespace. 3192 { 3193 const char *Expected = "" 3194 "void f() {\n" 3195 "#if 1\n" 3196 "// Preprocessor aligned.\n" 3197 "# define A 0\n" 3198 " // Code. Separated by blank line.\n" 3199 "\n" 3200 "# define B 0\n" 3201 " // Code. Not aligned with #\n" 3202 "# define C 0\n" 3203 "#endif"; 3204 const char *ToFormat = "" 3205 "void f() {\n" 3206 "#if 1\n" 3207 "// Preprocessor aligned.\n" 3208 "# define A 0\n" 3209 "// Code. Separated by blank line.\n" 3210 "\n" 3211 "# define B 0\n" 3212 " // Code. Not aligned with #\n" 3213 "# define C 0\n" 3214 "#endif"; 3215 EXPECT_EQ(Expected, format(ToFormat, Style)); 3216 EXPECT_EQ(Expected, format(Expected, Style)); 3217 } 3218 // Keep block quotes aligned. 3219 { 3220 const char *Expected = "" 3221 "void f() {\n" 3222 "#if 1\n" 3223 "/* Preprocessor aligned. */\n" 3224 "# define A 0\n" 3225 " /* Code. Separated by blank line. */\n" 3226 "\n" 3227 "# define B 0\n" 3228 " /* Code. Not aligned with # */\n" 3229 "# define C 0\n" 3230 "#endif"; 3231 const char *ToFormat = "" 3232 "void f() {\n" 3233 "#if 1\n" 3234 "/* Preprocessor aligned. */\n" 3235 "# define A 0\n" 3236 "/* Code. Separated by blank line. */\n" 3237 "\n" 3238 "# define B 0\n" 3239 " /* Code. Not aligned with # */\n" 3240 "# define C 0\n" 3241 "#endif"; 3242 EXPECT_EQ(Expected, format(ToFormat, Style)); 3243 EXPECT_EQ(Expected, format(Expected, Style)); 3244 } 3245 // Keep comments aligned with un-indented directives. 3246 { 3247 const char *Expected = "" 3248 "void f() {\n" 3249 "// Preprocessor aligned.\n" 3250 "#define A 0\n" 3251 " // Code. Separated by blank line.\n" 3252 "\n" 3253 "#define B 0\n" 3254 " // Code. Not aligned with #\n" 3255 "#define C 0\n"; 3256 const char *ToFormat = "" 3257 "void f() {\n" 3258 "// Preprocessor aligned.\n" 3259 "#define A 0\n" 3260 "// Code. Separated by blank line.\n" 3261 "\n" 3262 "#define B 0\n" 3263 " // Code. Not aligned with #\n" 3264 "#define C 0\n"; 3265 EXPECT_EQ(Expected, format(ToFormat, Style)); 3266 EXPECT_EQ(Expected, format(Expected, Style)); 3267 } 3268 // Test AfterHash with tabs. 3269 { 3270 FormatStyle Tabbed = Style; 3271 Tabbed.UseTab = FormatStyle::UT_Always; 3272 Tabbed.IndentWidth = 8; 3273 Tabbed.TabWidth = 8; 3274 verifyFormat("#ifdef _WIN32\n" 3275 "#\tdefine A 0\n" 3276 "#\tifdef VAR2\n" 3277 "#\t\tdefine B 1\n" 3278 "#\t\tinclude <someheader.h>\n" 3279 "#\t\tdefine MACRO \\\n" 3280 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3281 "#\tendif\n" 3282 "#else\n" 3283 "#\tdefine A 1\n" 3284 "#endif", 3285 Tabbed); 3286 } 3287 3288 // Regression test: Multiline-macro inside include guards. 3289 verifyFormat("#ifndef HEADER_H\n" 3290 "#define HEADER_H\n" 3291 "#define A() \\\n" 3292 " int i; \\\n" 3293 " int j;\n" 3294 "#endif // HEADER_H", 3295 getLLVMStyleWithColumns(20)); 3296 3297 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3298 // Basic before hash indent tests 3299 verifyFormat("#ifdef _WIN32\n" 3300 " #define A 0\n" 3301 " #ifdef VAR2\n" 3302 " #define B 1\n" 3303 " #include <someheader.h>\n" 3304 " #define MACRO \\\n" 3305 " some_very_long_func_aaaaaaaaaa();\n" 3306 " #endif\n" 3307 "#else\n" 3308 " #define A 1\n" 3309 "#endif", 3310 Style); 3311 verifyFormat("#if A\n" 3312 " #define MACRO \\\n" 3313 " void a(int x) { \\\n" 3314 " b(); \\\n" 3315 " c(); \\\n" 3316 " d(); \\\n" 3317 " e(); \\\n" 3318 " f(); \\\n" 3319 " }\n" 3320 "#endif", 3321 Style); 3322 // Keep comments aligned with indented directives. These 3323 // tests cannot use verifyFormat because messUp manipulates leading 3324 // whitespace. 3325 { 3326 const char *Expected = "void f() {\n" 3327 "// Aligned to preprocessor.\n" 3328 "#if 1\n" 3329 " // Aligned to code.\n" 3330 " int a;\n" 3331 " #if 1\n" 3332 " // Aligned to preprocessor.\n" 3333 " #define A 0\n" 3334 " // Aligned to code.\n" 3335 " int b;\n" 3336 " #endif\n" 3337 "#endif\n" 3338 "}"; 3339 const char *ToFormat = "void f() {\n" 3340 "// Aligned to preprocessor.\n" 3341 "#if 1\n" 3342 "// Aligned to code.\n" 3343 "int a;\n" 3344 "#if 1\n" 3345 "// Aligned to preprocessor.\n" 3346 "#define A 0\n" 3347 "// Aligned to code.\n" 3348 "int b;\n" 3349 "#endif\n" 3350 "#endif\n" 3351 "}"; 3352 EXPECT_EQ(Expected, format(ToFormat, Style)); 3353 EXPECT_EQ(Expected, format(Expected, Style)); 3354 } 3355 { 3356 const char *Expected = "void f() {\n" 3357 "/* Aligned to preprocessor. */\n" 3358 "#if 1\n" 3359 " /* Aligned to code. */\n" 3360 " int a;\n" 3361 " #if 1\n" 3362 " /* Aligned to preprocessor. */\n" 3363 " #define A 0\n" 3364 " /* Aligned to code. */\n" 3365 " int b;\n" 3366 " #endif\n" 3367 "#endif\n" 3368 "}"; 3369 const char *ToFormat = "void f() {\n" 3370 "/* Aligned to preprocessor. */\n" 3371 "#if 1\n" 3372 "/* Aligned to code. */\n" 3373 "int a;\n" 3374 "#if 1\n" 3375 "/* Aligned to preprocessor. */\n" 3376 "#define A 0\n" 3377 "/* Aligned to code. */\n" 3378 "int b;\n" 3379 "#endif\n" 3380 "#endif\n" 3381 "}"; 3382 EXPECT_EQ(Expected, format(ToFormat, Style)); 3383 EXPECT_EQ(Expected, format(Expected, Style)); 3384 } 3385 3386 // Test single comment before preprocessor 3387 verifyFormat("// Comment\n" 3388 "\n" 3389 "#if 1\n" 3390 "#endif", 3391 Style); 3392 } 3393 3394 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3395 verifyFormat("{\n { a #c; }\n}"); 3396 } 3397 3398 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3399 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3400 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3401 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3402 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3403 } 3404 3405 TEST_F(FormatTest, EscapedNewlines) { 3406 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3407 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3408 format("#define A \\\nint i;\\\n int j;", Narrow)); 3409 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3410 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3411 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3412 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3413 3414 FormatStyle AlignLeft = getLLVMStyle(); 3415 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3416 EXPECT_EQ("#define MACRO(x) \\\n" 3417 "private: \\\n" 3418 " int x(int a);\n", 3419 format("#define MACRO(x) \\\n" 3420 "private: \\\n" 3421 " int x(int a);\n", 3422 AlignLeft)); 3423 3424 // CRLF line endings 3425 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3426 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3427 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3428 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3429 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3430 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3431 EXPECT_EQ("#define MACRO(x) \\\r\n" 3432 "private: \\\r\n" 3433 " int x(int a);\r\n", 3434 format("#define MACRO(x) \\\r\n" 3435 "private: \\\r\n" 3436 " int x(int a);\r\n", 3437 AlignLeft)); 3438 3439 FormatStyle DontAlign = getLLVMStyle(); 3440 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3441 DontAlign.MaxEmptyLinesToKeep = 3; 3442 // FIXME: can't use verifyFormat here because the newline before 3443 // "public:" is not inserted the first time it's reformatted 3444 EXPECT_EQ("#define A \\\n" 3445 " class Foo { \\\n" 3446 " void bar(); \\\n" 3447 "\\\n" 3448 "\\\n" 3449 "\\\n" 3450 " public: \\\n" 3451 " void baz(); \\\n" 3452 " };", 3453 format("#define A \\\n" 3454 " class Foo { \\\n" 3455 " void bar(); \\\n" 3456 "\\\n" 3457 "\\\n" 3458 "\\\n" 3459 " public: \\\n" 3460 " void baz(); \\\n" 3461 " };", 3462 DontAlign)); 3463 } 3464 3465 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3466 verifyFormat("#define A \\\n" 3467 " int v( \\\n" 3468 " a); \\\n" 3469 " int i;", 3470 getLLVMStyleWithColumns(11)); 3471 } 3472 3473 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3474 EXPECT_EQ( 3475 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3476 " \\\n" 3477 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3478 "\n" 3479 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3480 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3481 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3482 "\\\n" 3483 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3484 " \n" 3485 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3486 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3487 } 3488 3489 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3490 EXPECT_EQ("int\n" 3491 "#define A\n" 3492 " a;", 3493 format("int\n#define A\na;")); 3494 verifyFormat("functionCallTo(\n" 3495 " someOtherFunction(\n" 3496 " withSomeParameters, whichInSequence,\n" 3497 " areLongerThanALine(andAnotherCall,\n" 3498 "#define A B\n" 3499 " withMoreParamters,\n" 3500 " whichStronglyInfluenceTheLayout),\n" 3501 " andMoreParameters),\n" 3502 " trailing);", 3503 getLLVMStyleWithColumns(69)); 3504 verifyFormat("Foo::Foo()\n" 3505 "#ifdef BAR\n" 3506 " : baz(0)\n" 3507 "#endif\n" 3508 "{\n" 3509 "}"); 3510 verifyFormat("void f() {\n" 3511 " if (true)\n" 3512 "#ifdef A\n" 3513 " f(42);\n" 3514 " x();\n" 3515 "#else\n" 3516 " g();\n" 3517 " x();\n" 3518 "#endif\n" 3519 "}"); 3520 verifyFormat("void f(param1, param2,\n" 3521 " param3,\n" 3522 "#ifdef A\n" 3523 " param4(param5,\n" 3524 "#ifdef A1\n" 3525 " param6,\n" 3526 "#ifdef A2\n" 3527 " param7),\n" 3528 "#else\n" 3529 " param8),\n" 3530 " param9,\n" 3531 "#endif\n" 3532 " param10,\n" 3533 "#endif\n" 3534 " param11)\n" 3535 "#else\n" 3536 " param12)\n" 3537 "#endif\n" 3538 "{\n" 3539 " x();\n" 3540 "}", 3541 getLLVMStyleWithColumns(28)); 3542 verifyFormat("#if 1\n" 3543 "int i;"); 3544 verifyFormat("#if 1\n" 3545 "#endif\n" 3546 "#if 1\n" 3547 "#else\n" 3548 "#endif\n"); 3549 verifyFormat("DEBUG({\n" 3550 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3551 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3552 "});\n" 3553 "#if a\n" 3554 "#else\n" 3555 "#endif"); 3556 3557 verifyIncompleteFormat("void f(\n" 3558 "#if A\n" 3559 ");\n" 3560 "#else\n" 3561 "#endif"); 3562 } 3563 3564 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3565 verifyFormat("#endif\n" 3566 "#if B"); 3567 } 3568 3569 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3570 FormatStyle SingleLine = getLLVMStyle(); 3571 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3572 verifyFormat("#if 0\n" 3573 "#elif 1\n" 3574 "#endif\n" 3575 "void foo() {\n" 3576 " if (test) foo2();\n" 3577 "}", 3578 SingleLine); 3579 } 3580 3581 TEST_F(FormatTest, LayoutBlockInsideParens) { 3582 verifyFormat("functionCall({ int i; });"); 3583 verifyFormat("functionCall({\n" 3584 " int i;\n" 3585 " int j;\n" 3586 "});"); 3587 verifyFormat("functionCall(\n" 3588 " {\n" 3589 " int i;\n" 3590 " int j;\n" 3591 " },\n" 3592 " aaaa, bbbb, cccc);"); 3593 verifyFormat("functionA(functionB({\n" 3594 " int i;\n" 3595 " int j;\n" 3596 " }),\n" 3597 " aaaa, bbbb, cccc);"); 3598 verifyFormat("functionCall(\n" 3599 " {\n" 3600 " int i;\n" 3601 " int j;\n" 3602 " },\n" 3603 " aaaa, bbbb, // comment\n" 3604 " cccc);"); 3605 verifyFormat("functionA(functionB({\n" 3606 " int i;\n" 3607 " int j;\n" 3608 " }),\n" 3609 " aaaa, bbbb, // comment\n" 3610 " cccc);"); 3611 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3612 verifyFormat("functionCall(aaaa, bbbb, {\n" 3613 " int i;\n" 3614 " int j;\n" 3615 "});"); 3616 verifyFormat( 3617 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3618 " {\n" 3619 " int i; // break\n" 3620 " },\n" 3621 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3622 " ccccccccccccccccc));"); 3623 verifyFormat("DEBUG({\n" 3624 " if (a)\n" 3625 " f();\n" 3626 "});"); 3627 } 3628 3629 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3630 EXPECT_EQ("SOME_MACRO { int i; }\n" 3631 "int i;", 3632 format(" SOME_MACRO {int i;} int i;")); 3633 } 3634 3635 TEST_F(FormatTest, LayoutNestedBlocks) { 3636 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3637 " struct s {\n" 3638 " int i;\n" 3639 " };\n" 3640 " s kBitsToOs[] = {{10}};\n" 3641 " for (int i = 0; i < 10; ++i)\n" 3642 " return;\n" 3643 "}"); 3644 verifyFormat("call(parameter, {\n" 3645 " something();\n" 3646 " // Comment using all columns.\n" 3647 " somethingelse();\n" 3648 "});", 3649 getLLVMStyleWithColumns(40)); 3650 verifyFormat("DEBUG( //\n" 3651 " { f(); }, a);"); 3652 verifyFormat("DEBUG( //\n" 3653 " {\n" 3654 " f(); //\n" 3655 " },\n" 3656 " a);"); 3657 3658 EXPECT_EQ("call(parameter, {\n" 3659 " something();\n" 3660 " // Comment too\n" 3661 " // looooooooooong.\n" 3662 " somethingElse();\n" 3663 "});", 3664 format("call(parameter, {\n" 3665 " something();\n" 3666 " // Comment too looooooooooong.\n" 3667 " somethingElse();\n" 3668 "});", 3669 getLLVMStyleWithColumns(29))); 3670 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3671 EXPECT_EQ("DEBUG({ // comment\n" 3672 " int i;\n" 3673 "});", 3674 format("DEBUG({ // comment\n" 3675 "int i;\n" 3676 "});")); 3677 EXPECT_EQ("DEBUG({\n" 3678 " int i;\n" 3679 "\n" 3680 " // comment\n" 3681 " int j;\n" 3682 "});", 3683 format("DEBUG({\n" 3684 " int i;\n" 3685 "\n" 3686 " // comment\n" 3687 " int j;\n" 3688 "});")); 3689 3690 verifyFormat("DEBUG({\n" 3691 " if (a)\n" 3692 " return;\n" 3693 "});"); 3694 verifyGoogleFormat("DEBUG({\n" 3695 " if (a) return;\n" 3696 "});"); 3697 FormatStyle Style = getGoogleStyle(); 3698 Style.ColumnLimit = 45; 3699 verifyFormat("Debug(\n" 3700 " aaaaa,\n" 3701 " {\n" 3702 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 3703 " },\n" 3704 " a);", 3705 Style); 3706 3707 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 3708 3709 verifyNoCrash("^{v^{a}}"); 3710 } 3711 3712 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 3713 EXPECT_EQ("#define MACRO() \\\n" 3714 " Debug(aaa, /* force line break */ \\\n" 3715 " { \\\n" 3716 " int i; \\\n" 3717 " int j; \\\n" 3718 " })", 3719 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 3720 " { int i; int j; })", 3721 getGoogleStyle())); 3722 3723 EXPECT_EQ("#define A \\\n" 3724 " [] { \\\n" 3725 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3726 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 3727 " }", 3728 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3729 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 3730 getGoogleStyle())); 3731 } 3732 3733 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 3734 EXPECT_EQ("{}", format("{}")); 3735 verifyFormat("enum E {};"); 3736 verifyFormat("enum E {}"); 3737 FormatStyle Style = getLLVMStyle(); 3738 Style.SpaceInEmptyBlock = true; 3739 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 3740 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 3741 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 3742 } 3743 3744 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 3745 FormatStyle Style = getLLVMStyle(); 3746 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 3747 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 3748 verifyFormat("FOO_BEGIN\n" 3749 " FOO_ENTRY\n" 3750 "FOO_END", 3751 Style); 3752 verifyFormat("FOO_BEGIN\n" 3753 " NESTED_FOO_BEGIN\n" 3754 " NESTED_FOO_ENTRY\n" 3755 " NESTED_FOO_END\n" 3756 "FOO_END", 3757 Style); 3758 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 3759 " int x;\n" 3760 " x = 1;\n" 3761 "FOO_END(Baz)", 3762 Style); 3763 } 3764 3765 //===----------------------------------------------------------------------===// 3766 // Line break tests. 3767 //===----------------------------------------------------------------------===// 3768 3769 TEST_F(FormatTest, PreventConfusingIndents) { 3770 verifyFormat( 3771 "void f() {\n" 3772 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 3773 " parameter, parameter, parameter)),\n" 3774 " SecondLongCall(parameter));\n" 3775 "}"); 3776 verifyFormat( 3777 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3778 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3779 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3780 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 3781 verifyFormat( 3782 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3783 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 3784 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 3785 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 3786 verifyFormat( 3787 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 3788 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 3789 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 3790 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 3791 verifyFormat("int a = bbbb && ccc &&\n" 3792 " fffff(\n" 3793 "#define A Just forcing a new line\n" 3794 " ddd);"); 3795 } 3796 3797 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 3798 verifyFormat( 3799 "bool aaaaaaa =\n" 3800 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 3801 " bbbbbbbb();"); 3802 verifyFormat( 3803 "bool aaaaaaa =\n" 3804 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 3805 " bbbbbbbb();"); 3806 3807 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3808 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 3809 " ccccccccc == ddddddddddd;"); 3810 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3811 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 3812 " ccccccccc == ddddddddddd;"); 3813 verifyFormat( 3814 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 3815 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 3816 " ccccccccc == ddddddddddd;"); 3817 3818 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3819 " aaaaaa) &&\n" 3820 " bbbbbb && cccccc;"); 3821 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3822 " aaaaaa) >>\n" 3823 " bbbbbb;"); 3824 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 3825 " SourceMgr.getSpellingColumnNumber(\n" 3826 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 3827 " 1);"); 3828 3829 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3830 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 3831 " cccccc) {\n}"); 3832 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3833 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3834 " cccccc) {\n}"); 3835 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3836 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3837 " cccccc) {\n}"); 3838 verifyFormat("b = a &&\n" 3839 " // Comment\n" 3840 " b.c && d;"); 3841 3842 // If the LHS of a comparison is not a binary expression itself, the 3843 // additional linebreak confuses many people. 3844 verifyFormat( 3845 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3846 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 3847 "}"); 3848 verifyFormat( 3849 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3850 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3851 "}"); 3852 verifyFormat( 3853 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 3854 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3855 "}"); 3856 verifyFormat( 3857 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3858 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 3859 "}"); 3860 // Even explicit parentheses stress the precedence enough to make the 3861 // additional break unnecessary. 3862 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3863 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3864 "}"); 3865 // This cases is borderline, but with the indentation it is still readable. 3866 verifyFormat( 3867 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3868 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3869 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 3870 "}", 3871 getLLVMStyleWithColumns(75)); 3872 3873 // If the LHS is a binary expression, we should still use the additional break 3874 // as otherwise the formatting hides the operator precedence. 3875 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3876 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3877 " 5) {\n" 3878 "}"); 3879 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3880 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 3881 " 5) {\n" 3882 "}"); 3883 3884 FormatStyle OnePerLine = getLLVMStyle(); 3885 OnePerLine.BinPackParameters = false; 3886 verifyFormat( 3887 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3888 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3889 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 3890 OnePerLine); 3891 3892 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 3893 " .aaa(aaaaaaaaaaaaa) *\n" 3894 " aaaaaaa +\n" 3895 " aaaaaaa;", 3896 getLLVMStyleWithColumns(40)); 3897 } 3898 3899 TEST_F(FormatTest, ExpressionIndentation) { 3900 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3901 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3902 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3903 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3904 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 3905 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 3906 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3907 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 3908 " ccccccccccccccccccccccccccccccccccccccccc;"); 3909 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3910 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3911 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3912 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3913 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3914 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3915 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3916 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3917 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3918 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3919 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3920 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3921 verifyFormat("if () {\n" 3922 "} else if (aaaaa && bbbbb > // break\n" 3923 " ccccc) {\n" 3924 "}"); 3925 verifyFormat("if () {\n" 3926 "} else if constexpr (aaaaa && bbbbb > // break\n" 3927 " ccccc) {\n" 3928 "}"); 3929 verifyFormat("if () {\n" 3930 "} else if CONSTEXPR (aaaaa && bbbbb > // break\n" 3931 " ccccc) {\n" 3932 "}"); 3933 verifyFormat("if () {\n" 3934 "} else if (aaaaa &&\n" 3935 " bbbbb > // break\n" 3936 " ccccc &&\n" 3937 " ddddd) {\n" 3938 "}"); 3939 3940 // Presence of a trailing comment used to change indentation of b. 3941 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 3942 " b;\n" 3943 "return aaaaaaaaaaaaaaaaaaa +\n" 3944 " b; //", 3945 getLLVMStyleWithColumns(30)); 3946 } 3947 3948 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 3949 // Not sure what the best system is here. Like this, the LHS can be found 3950 // immediately above an operator (everything with the same or a higher 3951 // indent). The RHS is aligned right of the operator and so compasses 3952 // everything until something with the same indent as the operator is found. 3953 // FIXME: Is this a good system? 3954 FormatStyle Style = getLLVMStyle(); 3955 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 3956 verifyFormat( 3957 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3958 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3959 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3960 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3961 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3962 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3963 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3964 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3965 " > ccccccccccccccccccccccccccccccccccccccccc;", 3966 Style); 3967 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3968 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3969 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3970 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3971 Style); 3972 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3973 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3974 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3975 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3976 Style); 3977 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3978 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3979 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3980 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3981 Style); 3982 verifyFormat("if () {\n" 3983 "} else if (aaaaa\n" 3984 " && bbbbb // break\n" 3985 " > ccccc) {\n" 3986 "}", 3987 Style); 3988 verifyFormat("return (a)\n" 3989 " // comment\n" 3990 " + b;", 3991 Style); 3992 verifyFormat( 3993 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3994 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3995 " + cc;", 3996 Style); 3997 3998 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3999 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4000 Style); 4001 4002 // Forced by comments. 4003 verifyFormat( 4004 "unsigned ContentSize =\n" 4005 " sizeof(int16_t) // DWARF ARange version number\n" 4006 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4007 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4008 " + sizeof(int8_t); // Segment Size (in bytes)"); 4009 4010 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 4011 " == boost::fusion::at_c<1>(iiii).second;", 4012 Style); 4013 4014 Style.ColumnLimit = 60; 4015 verifyFormat("zzzzzzzzzz\n" 4016 " = bbbbbbbbbbbbbbbbb\n" 4017 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 4018 Style); 4019 4020 Style.ColumnLimit = 80; 4021 Style.IndentWidth = 4; 4022 Style.TabWidth = 4; 4023 Style.UseTab = FormatStyle::UT_Always; 4024 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4025 Style.AlignOperands = false; 4026 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 4027 "\t&& (someOtherLongishConditionPart1\n" 4028 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 4029 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && " 4030 "(someOtherLongishConditionPart1 || " 4031 "someOtherEvenLongerNestedConditionPart2);", 4032 Style)); 4033 } 4034 4035 TEST_F(FormatTest, EnforcedOperatorWraps) { 4036 // Here we'd like to wrap after the || operators, but a comment is forcing an 4037 // earlier wrap. 4038 verifyFormat("bool x = aaaaa //\n" 4039 " || bbbbb\n" 4040 " //\n" 4041 " || cccc;"); 4042 } 4043 4044 TEST_F(FormatTest, NoOperandAlignment) { 4045 FormatStyle Style = getLLVMStyle(); 4046 Style.AlignOperands = false; 4047 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 4048 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4049 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4050 Style); 4051 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4052 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4053 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4054 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4055 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4056 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4057 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4058 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4059 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4060 " > ccccccccccccccccccccccccccccccccccccccccc;", 4061 Style); 4062 4063 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4064 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4065 " + cc;", 4066 Style); 4067 verifyFormat("int a = aa\n" 4068 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4069 " * cccccccccccccccccccccccccccccccccccc;\n", 4070 Style); 4071 4072 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4073 verifyFormat("return (a > b\n" 4074 " // comment1\n" 4075 " // comment2\n" 4076 " || c);", 4077 Style); 4078 } 4079 4080 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 4081 FormatStyle Style = getLLVMStyle(); 4082 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4083 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4084 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4085 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4086 Style); 4087 } 4088 4089 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 4090 FormatStyle Style = getLLVMStyle(); 4091 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4092 Style.BinPackArguments = false; 4093 Style.ColumnLimit = 40; 4094 verifyFormat("void test() {\n" 4095 " someFunction(\n" 4096 " this + argument + is + quite\n" 4097 " + long + so + it + gets + wrapped\n" 4098 " + but + remains + bin - packed);\n" 4099 "}", 4100 Style); 4101 verifyFormat("void test() {\n" 4102 " someFunction(arg1,\n" 4103 " this + argument + is\n" 4104 " + quite + long + so\n" 4105 " + it + gets + wrapped\n" 4106 " + but + remains + bin\n" 4107 " - packed,\n" 4108 " arg3);\n" 4109 "}", 4110 Style); 4111 verifyFormat("void test() {\n" 4112 " someFunction(\n" 4113 " arg1,\n" 4114 " this + argument + has\n" 4115 " + anotherFunc(nested,\n" 4116 " calls + whose\n" 4117 " + arguments\n" 4118 " + are + also\n" 4119 " + wrapped,\n" 4120 " in + addition)\n" 4121 " + to + being + bin - packed,\n" 4122 " arg3);\n" 4123 "}", 4124 Style); 4125 4126 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4127 verifyFormat("void test() {\n" 4128 " someFunction(\n" 4129 " arg1,\n" 4130 " this + argument + has +\n" 4131 " anotherFunc(nested,\n" 4132 " calls + whose +\n" 4133 " arguments +\n" 4134 " are + also +\n" 4135 " wrapped,\n" 4136 " in + addition) +\n" 4137 " to + being + bin - packed,\n" 4138 " arg3);\n" 4139 "}", 4140 Style); 4141 } 4142 4143 TEST_F(FormatTest, ConstructorInitializers) { 4144 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4145 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 4146 getLLVMStyleWithColumns(45)); 4147 verifyFormat("Constructor()\n" 4148 " : Inttializer(FitsOnTheLine) {}", 4149 getLLVMStyleWithColumns(44)); 4150 verifyFormat("Constructor()\n" 4151 " : Inttializer(FitsOnTheLine) {}", 4152 getLLVMStyleWithColumns(43)); 4153 4154 verifyFormat("template <typename T>\n" 4155 "Constructor() : Initializer(FitsOnTheLine) {}", 4156 getLLVMStyleWithColumns(45)); 4157 4158 verifyFormat( 4159 "SomeClass::Constructor()\n" 4160 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4161 4162 verifyFormat( 4163 "SomeClass::Constructor()\n" 4164 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4165 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 4166 verifyFormat( 4167 "SomeClass::Constructor()\n" 4168 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4169 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4170 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4171 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4172 " : aaaaaaaaaa(aaaaaa) {}"); 4173 4174 verifyFormat("Constructor()\n" 4175 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4176 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4177 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4178 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 4179 4180 verifyFormat("Constructor()\n" 4181 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4182 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4183 4184 verifyFormat("Constructor(int Parameter = 0)\n" 4185 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4186 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 4187 verifyFormat("Constructor()\n" 4188 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4189 "}", 4190 getLLVMStyleWithColumns(60)); 4191 verifyFormat("Constructor()\n" 4192 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4193 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 4194 4195 // Here a line could be saved by splitting the second initializer onto two 4196 // lines, but that is not desirable. 4197 verifyFormat("Constructor()\n" 4198 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4199 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4200 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4201 4202 FormatStyle OnePerLine = getLLVMStyle(); 4203 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4204 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 4205 verifyFormat("SomeClass::Constructor()\n" 4206 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4207 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4208 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4209 OnePerLine); 4210 verifyFormat("SomeClass::Constructor()\n" 4211 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4212 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4213 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4214 OnePerLine); 4215 verifyFormat("MyClass::MyClass(int var)\n" 4216 " : some_var_(var), // 4 space indent\n" 4217 " some_other_var_(var + 1) { // lined up\n" 4218 "}", 4219 OnePerLine); 4220 verifyFormat("Constructor()\n" 4221 " : aaaaa(aaaaaa),\n" 4222 " aaaaa(aaaaaa),\n" 4223 " aaaaa(aaaaaa),\n" 4224 " aaaaa(aaaaaa),\n" 4225 " aaaaa(aaaaaa) {}", 4226 OnePerLine); 4227 verifyFormat("Constructor()\n" 4228 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4229 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4230 OnePerLine); 4231 OnePerLine.BinPackParameters = false; 4232 verifyFormat( 4233 "Constructor()\n" 4234 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4235 " aaaaaaaaaaa().aaa(),\n" 4236 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4237 OnePerLine); 4238 OnePerLine.ColumnLimit = 60; 4239 verifyFormat("Constructor()\n" 4240 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4241 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4242 OnePerLine); 4243 4244 EXPECT_EQ("Constructor()\n" 4245 " : // Comment forcing unwanted break.\n" 4246 " aaaa(aaaa) {}", 4247 format("Constructor() :\n" 4248 " // Comment forcing unwanted break.\n" 4249 " aaaa(aaaa) {}")); 4250 } 4251 4252 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 4253 FormatStyle Style = getLLVMStyle(); 4254 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4255 Style.ColumnLimit = 60; 4256 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4257 Style.AllowAllConstructorInitializersOnNextLine = true; 4258 Style.BinPackParameters = false; 4259 4260 for (int i = 0; i < 4; ++i) { 4261 // Test all combinations of parameters that should not have an effect. 4262 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4263 Style.AllowAllArgumentsOnNextLine = i & 2; 4264 4265 Style.AllowAllConstructorInitializersOnNextLine = true; 4266 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4267 verifyFormat("Constructor()\n" 4268 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4269 Style); 4270 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4271 4272 Style.AllowAllConstructorInitializersOnNextLine = false; 4273 verifyFormat("Constructor()\n" 4274 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4275 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4276 Style); 4277 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4278 4279 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4280 Style.AllowAllConstructorInitializersOnNextLine = true; 4281 verifyFormat("Constructor()\n" 4282 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4283 Style); 4284 4285 Style.AllowAllConstructorInitializersOnNextLine = false; 4286 verifyFormat("Constructor()\n" 4287 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4288 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4289 Style); 4290 4291 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4292 Style.AllowAllConstructorInitializersOnNextLine = true; 4293 verifyFormat("Constructor() :\n" 4294 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4295 Style); 4296 4297 Style.AllowAllConstructorInitializersOnNextLine = false; 4298 verifyFormat("Constructor() :\n" 4299 " aaaaaaaaaaaaaaaaaa(a),\n" 4300 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4301 Style); 4302 } 4303 4304 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4305 // AllowAllConstructorInitializersOnNextLine in all 4306 // BreakConstructorInitializers modes 4307 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4308 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4309 Style.AllowAllConstructorInitializersOnNextLine = false; 4310 verifyFormat("SomeClassWithALongName::Constructor(\n" 4311 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4312 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4313 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4314 Style); 4315 4316 Style.AllowAllConstructorInitializersOnNextLine = true; 4317 verifyFormat("SomeClassWithALongName::Constructor(\n" 4318 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4319 " int bbbbbbbbbbbbb,\n" 4320 " int cccccccccccccccc)\n" 4321 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4322 Style); 4323 4324 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4325 Style.AllowAllConstructorInitializersOnNextLine = false; 4326 verifyFormat("SomeClassWithALongName::Constructor(\n" 4327 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4328 " int bbbbbbbbbbbbb)\n" 4329 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4330 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4331 Style); 4332 4333 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4334 4335 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4336 verifyFormat("SomeClassWithALongName::Constructor(\n" 4337 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4338 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4339 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4340 Style); 4341 4342 Style.AllowAllConstructorInitializersOnNextLine = true; 4343 verifyFormat("SomeClassWithALongName::Constructor(\n" 4344 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4345 " int bbbbbbbbbbbbb,\n" 4346 " int cccccccccccccccc)\n" 4347 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4348 Style); 4349 4350 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4351 Style.AllowAllConstructorInitializersOnNextLine = false; 4352 verifyFormat("SomeClassWithALongName::Constructor(\n" 4353 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4354 " int bbbbbbbbbbbbb)\n" 4355 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4356 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4357 Style); 4358 4359 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4360 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4361 verifyFormat("SomeClassWithALongName::Constructor(\n" 4362 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4363 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4364 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4365 Style); 4366 4367 Style.AllowAllConstructorInitializersOnNextLine = true; 4368 verifyFormat("SomeClassWithALongName::Constructor(\n" 4369 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4370 " int bbbbbbbbbbbbb,\n" 4371 " int cccccccccccccccc) :\n" 4372 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4373 Style); 4374 4375 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4376 Style.AllowAllConstructorInitializersOnNextLine = false; 4377 verifyFormat("SomeClassWithALongName::Constructor(\n" 4378 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4379 " int bbbbbbbbbbbbb) :\n" 4380 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4381 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4382 Style); 4383 } 4384 4385 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4386 FormatStyle Style = getLLVMStyle(); 4387 Style.ColumnLimit = 60; 4388 Style.BinPackArguments = false; 4389 for (int i = 0; i < 4; ++i) { 4390 // Test all combinations of parameters that should not have an effect. 4391 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4392 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4393 4394 Style.AllowAllArgumentsOnNextLine = true; 4395 verifyFormat("void foo() {\n" 4396 " FunctionCallWithReallyLongName(\n" 4397 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4398 "}", 4399 Style); 4400 Style.AllowAllArgumentsOnNextLine = false; 4401 verifyFormat("void foo() {\n" 4402 " FunctionCallWithReallyLongName(\n" 4403 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4404 " bbbbbbbbbbbb);\n" 4405 "}", 4406 Style); 4407 4408 Style.AllowAllArgumentsOnNextLine = true; 4409 verifyFormat("void foo() {\n" 4410 " auto VariableWithReallyLongName = {\n" 4411 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4412 "}", 4413 Style); 4414 Style.AllowAllArgumentsOnNextLine = false; 4415 verifyFormat("void foo() {\n" 4416 " auto VariableWithReallyLongName = {\n" 4417 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4418 " bbbbbbbbbbbb};\n" 4419 "}", 4420 Style); 4421 } 4422 4423 // This parameter should not affect declarations. 4424 Style.BinPackParameters = false; 4425 Style.AllowAllArgumentsOnNextLine = false; 4426 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4427 verifyFormat("void FunctionCallWithReallyLongName(\n" 4428 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4429 Style); 4430 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4431 verifyFormat("void FunctionCallWithReallyLongName(\n" 4432 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4433 " int bbbbbbbbbbbb);", 4434 Style); 4435 } 4436 4437 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4438 FormatStyle Style = getLLVMStyle(); 4439 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4440 4441 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4442 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4443 getStyleWithColumns(Style, 45)); 4444 verifyFormat("Constructor() :\n" 4445 " Initializer(FitsOnTheLine) {}", 4446 getStyleWithColumns(Style, 44)); 4447 verifyFormat("Constructor() :\n" 4448 " Initializer(FitsOnTheLine) {}", 4449 getStyleWithColumns(Style, 43)); 4450 4451 verifyFormat("template <typename T>\n" 4452 "Constructor() : Initializer(FitsOnTheLine) {}", 4453 getStyleWithColumns(Style, 50)); 4454 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4455 verifyFormat( 4456 "SomeClass::Constructor() :\n" 4457 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4458 Style); 4459 4460 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4461 verifyFormat( 4462 "SomeClass::Constructor() :\n" 4463 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4464 Style); 4465 4466 verifyFormat( 4467 "SomeClass::Constructor() :\n" 4468 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4469 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4470 Style); 4471 verifyFormat( 4472 "SomeClass::Constructor() :\n" 4473 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4474 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4475 Style); 4476 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4477 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4478 " aaaaaaaaaa(aaaaaa) {}", 4479 Style); 4480 4481 verifyFormat("Constructor() :\n" 4482 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4483 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4484 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4485 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4486 Style); 4487 4488 verifyFormat("Constructor() :\n" 4489 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4490 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4491 Style); 4492 4493 verifyFormat("Constructor(int Parameter = 0) :\n" 4494 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4495 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4496 Style); 4497 verifyFormat("Constructor() :\n" 4498 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4499 "}", 4500 getStyleWithColumns(Style, 60)); 4501 verifyFormat("Constructor() :\n" 4502 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4503 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4504 Style); 4505 4506 // Here a line could be saved by splitting the second initializer onto two 4507 // lines, but that is not desirable. 4508 verifyFormat("Constructor() :\n" 4509 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4510 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4511 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4512 Style); 4513 4514 FormatStyle OnePerLine = Style; 4515 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4516 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4517 verifyFormat("SomeClass::Constructor() :\n" 4518 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4519 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4520 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4521 OnePerLine); 4522 verifyFormat("SomeClass::Constructor() :\n" 4523 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4524 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4525 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4526 OnePerLine); 4527 verifyFormat("MyClass::MyClass(int var) :\n" 4528 " some_var_(var), // 4 space indent\n" 4529 " some_other_var_(var + 1) { // lined up\n" 4530 "}", 4531 OnePerLine); 4532 verifyFormat("Constructor() :\n" 4533 " aaaaa(aaaaaa),\n" 4534 " aaaaa(aaaaaa),\n" 4535 " aaaaa(aaaaaa),\n" 4536 " aaaaa(aaaaaa),\n" 4537 " aaaaa(aaaaaa) {}", 4538 OnePerLine); 4539 verifyFormat("Constructor() :\n" 4540 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4541 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4542 OnePerLine); 4543 OnePerLine.BinPackParameters = false; 4544 verifyFormat("Constructor() :\n" 4545 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4546 " aaaaaaaaaaa().aaa(),\n" 4547 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4548 OnePerLine); 4549 OnePerLine.ColumnLimit = 60; 4550 verifyFormat("Constructor() :\n" 4551 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4552 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4553 OnePerLine); 4554 4555 EXPECT_EQ("Constructor() :\n" 4556 " // Comment forcing unwanted break.\n" 4557 " aaaa(aaaa) {}", 4558 format("Constructor() :\n" 4559 " // Comment forcing unwanted break.\n" 4560 " aaaa(aaaa) {}", 4561 Style)); 4562 4563 Style.ColumnLimit = 0; 4564 verifyFormat("SomeClass::Constructor() :\n" 4565 " a(a) {}", 4566 Style); 4567 verifyFormat("SomeClass::Constructor() noexcept :\n" 4568 " a(a) {}", 4569 Style); 4570 verifyFormat("SomeClass::Constructor() :\n" 4571 " a(a), b(b), c(c) {}", 4572 Style); 4573 verifyFormat("SomeClass::Constructor() :\n" 4574 " a(a) {\n" 4575 " foo();\n" 4576 " bar();\n" 4577 "}", 4578 Style); 4579 4580 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4581 verifyFormat("SomeClass::Constructor() :\n" 4582 " a(a), b(b), c(c) {\n" 4583 "}", 4584 Style); 4585 verifyFormat("SomeClass::Constructor() :\n" 4586 " a(a) {\n" 4587 "}", 4588 Style); 4589 4590 Style.ColumnLimit = 80; 4591 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4592 Style.ConstructorInitializerIndentWidth = 2; 4593 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style); 4594 verifyFormat("SomeClass::Constructor() :\n" 4595 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4596 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 4597 Style); 4598 4599 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as 4600 // well 4601 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 4602 verifyFormat( 4603 "class SomeClass\n" 4604 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4605 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4606 Style); 4607 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 4608 verifyFormat( 4609 "class SomeClass\n" 4610 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4611 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4612 Style); 4613 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 4614 verifyFormat( 4615 "class SomeClass :\n" 4616 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4617 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4618 Style); 4619 } 4620 4621 #ifndef EXPENSIVE_CHECKS 4622 // Expensive checks enables libstdc++ checking which includes validating the 4623 // state of ranges used in std::priority_queue - this blows out the 4624 // runtime/scalability of the function and makes this test unacceptably slow. 4625 TEST_F(FormatTest, MemoizationTests) { 4626 // This breaks if the memoization lookup does not take \c Indent and 4627 // \c LastSpace into account. 4628 verifyFormat( 4629 "extern CFRunLoopTimerRef\n" 4630 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 4631 " CFTimeInterval interval, CFOptionFlags flags,\n" 4632 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 4633 " CFRunLoopTimerContext *context) {}"); 4634 4635 // Deep nesting somewhat works around our memoization. 4636 verifyFormat( 4637 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4638 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4639 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4640 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4641 " aaaaa())))))))))))))))))))))))))))))))))))))));", 4642 getLLVMStyleWithColumns(65)); 4643 verifyFormat( 4644 "aaaaa(\n" 4645 " aaaaa,\n" 4646 " aaaaa(\n" 4647 " aaaaa,\n" 4648 " aaaaa(\n" 4649 " aaaaa,\n" 4650 " aaaaa(\n" 4651 " aaaaa,\n" 4652 " aaaaa(\n" 4653 " aaaaa,\n" 4654 " aaaaa(\n" 4655 " aaaaa,\n" 4656 " aaaaa(\n" 4657 " aaaaa,\n" 4658 " aaaaa(\n" 4659 " aaaaa,\n" 4660 " aaaaa(\n" 4661 " aaaaa,\n" 4662 " aaaaa(\n" 4663 " aaaaa,\n" 4664 " aaaaa(\n" 4665 " aaaaa,\n" 4666 " aaaaa(\n" 4667 " aaaaa,\n" 4668 " aaaaa))))))))))));", 4669 getLLVMStyleWithColumns(65)); 4670 verifyFormat( 4671 "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" 4672 " a),\n" 4673 " a),\n" 4674 " a),\n" 4675 " a),\n" 4676 " a),\n" 4677 " a),\n" 4678 " a),\n" 4679 " a),\n" 4680 " a),\n" 4681 " a),\n" 4682 " a),\n" 4683 " a),\n" 4684 " a),\n" 4685 " a),\n" 4686 " a),\n" 4687 " a),\n" 4688 " a)", 4689 getLLVMStyleWithColumns(65)); 4690 4691 // This test takes VERY long when memoization is broken. 4692 FormatStyle OnePerLine = getLLVMStyle(); 4693 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4694 OnePerLine.BinPackParameters = false; 4695 std::string input = "Constructor()\n" 4696 " : aaaa(a,\n"; 4697 for (unsigned i = 0, e = 80; i != e; ++i) { 4698 input += " a,\n"; 4699 } 4700 input += " a) {}"; 4701 verifyFormat(input, OnePerLine); 4702 } 4703 #endif 4704 4705 TEST_F(FormatTest, BreaksAsHighAsPossible) { 4706 verifyFormat( 4707 "void f() {\n" 4708 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 4709 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 4710 " f();\n" 4711 "}"); 4712 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 4713 " Intervals[i - 1].getRange().getLast()) {\n}"); 4714 } 4715 4716 TEST_F(FormatTest, BreaksFunctionDeclarations) { 4717 // Principially, we break function declarations in a certain order: 4718 // 1) break amongst arguments. 4719 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 4720 " Cccccccccccccc cccccccccccccc);"); 4721 verifyFormat("template <class TemplateIt>\n" 4722 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 4723 " TemplateIt *stop) {}"); 4724 4725 // 2) break after return type. 4726 verifyFormat( 4727 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4728 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 4729 getGoogleStyle()); 4730 4731 // 3) break after (. 4732 verifyFormat( 4733 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 4734 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 4735 getGoogleStyle()); 4736 4737 // 4) break before after nested name specifiers. 4738 verifyFormat( 4739 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4740 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 4741 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 4742 getGoogleStyle()); 4743 4744 // However, there are exceptions, if a sufficient amount of lines can be 4745 // saved. 4746 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 4747 // more adjusting. 4748 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4749 " Cccccccccccccc cccccccccc,\n" 4750 " Cccccccccccccc cccccccccc,\n" 4751 " Cccccccccccccc cccccccccc,\n" 4752 " Cccccccccccccc cccccccccc);"); 4753 verifyFormat( 4754 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4755 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4756 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4757 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 4758 getGoogleStyle()); 4759 verifyFormat( 4760 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4761 " Cccccccccccccc cccccccccc,\n" 4762 " Cccccccccccccc cccccccccc,\n" 4763 " Cccccccccccccc cccccccccc,\n" 4764 " Cccccccccccccc cccccccccc,\n" 4765 " Cccccccccccccc cccccccccc,\n" 4766 " Cccccccccccccc cccccccccc);"); 4767 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4768 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4769 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4770 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4771 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 4772 4773 // Break after multi-line parameters. 4774 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4775 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4776 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4777 " bbbb bbbb);"); 4778 verifyFormat("void SomeLoooooooooooongFunction(\n" 4779 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 4780 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4781 " int bbbbbbbbbbbbb);"); 4782 4783 // Treat overloaded operators like other functions. 4784 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4785 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 4786 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4787 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 4788 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4789 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 4790 verifyGoogleFormat( 4791 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 4792 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4793 verifyGoogleFormat( 4794 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 4795 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4796 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4797 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4798 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 4799 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4800 verifyGoogleFormat( 4801 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 4802 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4803 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 4804 verifyGoogleFormat("template <typename T>\n" 4805 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4806 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 4807 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 4808 4809 FormatStyle Style = getLLVMStyle(); 4810 Style.PointerAlignment = FormatStyle::PAS_Left; 4811 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4812 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 4813 Style); 4814 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 4815 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4816 Style); 4817 } 4818 4819 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 4820 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 4821 // Prefer keeping `::` followed by `operator` together. 4822 EXPECT_EQ("const aaaa::bbbbbbb &\n" 4823 "ccccccccc::operator++() {\n" 4824 " stuff();\n" 4825 "}", 4826 format("const aaaa::bbbbbbb\n" 4827 "&ccccccccc::operator++() { stuff(); }", 4828 getLLVMStyleWithColumns(40))); 4829 } 4830 4831 TEST_F(FormatTest, TrailingReturnType) { 4832 verifyFormat("auto foo() -> int;\n"); 4833 verifyFormat("struct S {\n" 4834 " auto bar() const -> int;\n" 4835 "};"); 4836 verifyFormat("template <size_t Order, typename T>\n" 4837 "auto load_img(const std::string &filename)\n" 4838 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 4839 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 4840 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 4841 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 4842 verifyFormat("template <typename T>\n" 4843 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 4844 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 4845 4846 // Not trailing return types. 4847 verifyFormat("void f() { auto a = b->c(); }"); 4848 } 4849 4850 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 4851 // Avoid breaking before trailing 'const' or other trailing annotations, if 4852 // they are not function-like. 4853 FormatStyle Style = getGoogleStyle(); 4854 Style.ColumnLimit = 47; 4855 verifyFormat("void someLongFunction(\n" 4856 " int someLoooooooooooooongParameter) const {\n}", 4857 getLLVMStyleWithColumns(47)); 4858 verifyFormat("LoooooongReturnType\n" 4859 "someLoooooooongFunction() const {}", 4860 getLLVMStyleWithColumns(47)); 4861 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 4862 " const {}", 4863 Style); 4864 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4865 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 4866 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4867 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 4868 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4869 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 4870 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 4871 " aaaaaaaaaaa aaaaa) const override;"); 4872 verifyGoogleFormat( 4873 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4874 " const override;"); 4875 4876 // Even if the first parameter has to be wrapped. 4877 verifyFormat("void someLongFunction(\n" 4878 " int someLongParameter) const {}", 4879 getLLVMStyleWithColumns(46)); 4880 verifyFormat("void someLongFunction(\n" 4881 " int someLongParameter) const {}", 4882 Style); 4883 verifyFormat("void someLongFunction(\n" 4884 " int someLongParameter) override {}", 4885 Style); 4886 verifyFormat("void someLongFunction(\n" 4887 " int someLongParameter) OVERRIDE {}", 4888 Style); 4889 verifyFormat("void someLongFunction(\n" 4890 " int someLongParameter) final {}", 4891 Style); 4892 verifyFormat("void someLongFunction(\n" 4893 " int someLongParameter) FINAL {}", 4894 Style); 4895 verifyFormat("void someLongFunction(\n" 4896 " int parameter) const override {}", 4897 Style); 4898 4899 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 4900 verifyFormat("void someLongFunction(\n" 4901 " int someLongParameter) const\n" 4902 "{\n" 4903 "}", 4904 Style); 4905 4906 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 4907 verifyFormat("void someLongFunction(\n" 4908 " int someLongParameter) const\n" 4909 " {\n" 4910 " }", 4911 Style); 4912 4913 // Unless these are unknown annotations. 4914 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 4915 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4916 " LONG_AND_UGLY_ANNOTATION;"); 4917 4918 // Breaking before function-like trailing annotations is fine to keep them 4919 // close to their arguments. 4920 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4921 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 4922 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 4923 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 4924 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 4925 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 4926 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 4927 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 4928 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 4929 4930 verifyFormat( 4931 "void aaaaaaaaaaaaaaaaaa()\n" 4932 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 4933 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 4934 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4935 " __attribute__((unused));"); 4936 verifyGoogleFormat( 4937 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4938 " GUARDED_BY(aaaaaaaaaaaa);"); 4939 verifyGoogleFormat( 4940 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4941 " GUARDED_BY(aaaaaaaaaaaa);"); 4942 verifyGoogleFormat( 4943 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 4944 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4945 verifyGoogleFormat( 4946 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 4947 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 4948 } 4949 4950 TEST_F(FormatTest, FunctionAnnotations) { 4951 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4952 "int OldFunction(const string ¶meter) {}"); 4953 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4954 "string OldFunction(const string ¶meter) {}"); 4955 verifyFormat("template <typename T>\n" 4956 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4957 "string OldFunction(const string ¶meter) {}"); 4958 4959 // Not function annotations. 4960 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4961 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 4962 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 4963 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 4964 verifyFormat("MACRO(abc).function() // wrap\n" 4965 " << abc;"); 4966 verifyFormat("MACRO(abc)->function() // wrap\n" 4967 " << abc;"); 4968 verifyFormat("MACRO(abc)::function() // wrap\n" 4969 " << abc;"); 4970 } 4971 4972 TEST_F(FormatTest, BreaksDesireably) { 4973 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 4974 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 4975 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 4976 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4977 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 4978 "}"); 4979 4980 verifyFormat( 4981 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4982 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4983 4984 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4985 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4986 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4987 4988 verifyFormat( 4989 "aaaaaaaa(aaaaaaaaaaaaa,\n" 4990 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4991 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 4992 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4993 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 4994 4995 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4996 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4997 4998 verifyFormat( 4999 "void f() {\n" 5000 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 5001 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5002 "}"); 5003 verifyFormat( 5004 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5005 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5006 verifyFormat( 5007 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5008 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5009 verifyFormat( 5010 "aaaaaa(aaa,\n" 5011 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5012 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5013 " aaaa);"); 5014 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5015 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5016 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5017 5018 // Indent consistently independent of call expression and unary operator. 5019 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5020 " dddddddddddddddddddddddddddddd));"); 5021 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5022 " dddddddddddddddddddddddddddddd));"); 5023 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 5024 " dddddddddddddddddddddddddddddd));"); 5025 5026 // This test case breaks on an incorrect memoization, i.e. an optimization not 5027 // taking into account the StopAt value. 5028 verifyFormat( 5029 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5030 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5031 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5032 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5033 5034 verifyFormat("{\n {\n {\n" 5035 " Annotation.SpaceRequiredBefore =\n" 5036 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 5037 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 5038 " }\n }\n}"); 5039 5040 // Break on an outer level if there was a break on an inner level. 5041 EXPECT_EQ("f(g(h(a, // comment\n" 5042 " b, c),\n" 5043 " d, e),\n" 5044 " x, y);", 5045 format("f(g(h(a, // comment\n" 5046 " b, c), d, e), x, y);")); 5047 5048 // Prefer breaking similar line breaks. 5049 verifyFormat( 5050 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 5051 " NSTrackingMouseEnteredAndExited |\n" 5052 " NSTrackingActiveAlways;"); 5053 } 5054 5055 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 5056 FormatStyle NoBinPacking = getGoogleStyle(); 5057 NoBinPacking.BinPackParameters = false; 5058 NoBinPacking.BinPackArguments = true; 5059 verifyFormat("void f() {\n" 5060 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 5061 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5062 "}", 5063 NoBinPacking); 5064 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 5065 " int aaaaaaaaaaaaaaaaaaaa,\n" 5066 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5067 NoBinPacking); 5068 5069 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5070 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5071 " vector<int> bbbbbbbbbbbbbbb);", 5072 NoBinPacking); 5073 // FIXME: This behavior difference is probably not wanted. However, currently 5074 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 5075 // template arguments from BreakBeforeParameter being set because of the 5076 // one-per-line formatting. 5077 verifyFormat( 5078 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5079 " aaaaaaaaaa> aaaaaaaaaa);", 5080 NoBinPacking); 5081 verifyFormat( 5082 "void fffffffffff(\n" 5083 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 5084 " aaaaaaaaaa);"); 5085 } 5086 5087 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 5088 FormatStyle NoBinPacking = getGoogleStyle(); 5089 NoBinPacking.BinPackParameters = false; 5090 NoBinPacking.BinPackArguments = false; 5091 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 5092 " aaaaaaaaaaaaaaaaaaaa,\n" 5093 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 5094 NoBinPacking); 5095 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 5096 " aaaaaaaaaaaaa,\n" 5097 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 5098 NoBinPacking); 5099 verifyFormat( 5100 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5101 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5102 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5103 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5104 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 5105 NoBinPacking); 5106 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5107 " .aaaaaaaaaaaaaaaaaa();", 5108 NoBinPacking); 5109 verifyFormat("void f() {\n" 5110 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5111 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 5112 "}", 5113 NoBinPacking); 5114 5115 verifyFormat( 5116 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5117 " aaaaaaaaaaaa,\n" 5118 " aaaaaaaaaaaa);", 5119 NoBinPacking); 5120 verifyFormat( 5121 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 5122 " ddddddddddddddddddddddddddddd),\n" 5123 " test);", 5124 NoBinPacking); 5125 5126 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5127 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 5128 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 5129 " aaaaaaaaaaaaaaaaaa;", 5130 NoBinPacking); 5131 verifyFormat("a(\"a\"\n" 5132 " \"a\",\n" 5133 " a);"); 5134 5135 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5136 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 5137 " aaaaaaaaa,\n" 5138 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5139 NoBinPacking); 5140 verifyFormat( 5141 "void f() {\n" 5142 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5143 " .aaaaaaa();\n" 5144 "}", 5145 NoBinPacking); 5146 verifyFormat( 5147 "template <class SomeType, class SomeOtherType>\n" 5148 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 5149 NoBinPacking); 5150 } 5151 5152 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 5153 FormatStyle Style = getLLVMStyleWithColumns(15); 5154 Style.ExperimentalAutoDetectBinPacking = true; 5155 EXPECT_EQ("aaa(aaaa,\n" 5156 " aaaa,\n" 5157 " aaaa);\n" 5158 "aaa(aaaa,\n" 5159 " aaaa,\n" 5160 " aaaa);", 5161 format("aaa(aaaa,\n" // one-per-line 5162 " aaaa,\n" 5163 " aaaa );\n" 5164 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5165 Style)); 5166 EXPECT_EQ("aaa(aaaa, aaaa,\n" 5167 " aaaa);\n" 5168 "aaa(aaaa, aaaa,\n" 5169 " aaaa);", 5170 format("aaa(aaaa, aaaa,\n" // bin-packed 5171 " aaaa );\n" 5172 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5173 Style)); 5174 } 5175 5176 TEST_F(FormatTest, FormatsBuilderPattern) { 5177 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 5178 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 5179 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 5180 " .StartsWith(\".init\", ORDER_INIT)\n" 5181 " .StartsWith(\".fini\", ORDER_FINI)\n" 5182 " .StartsWith(\".hash\", ORDER_HASH)\n" 5183 " .Default(ORDER_TEXT);\n"); 5184 5185 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 5186 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 5187 verifyFormat("aaaaaaa->aaaaaaa\n" 5188 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5189 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5190 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5191 verifyFormat( 5192 "aaaaaaa->aaaaaaa\n" 5193 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5194 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5195 verifyFormat( 5196 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 5197 " aaaaaaaaaaaaaa);"); 5198 verifyFormat( 5199 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 5200 " aaaaaa->aaaaaaaaaaaa()\n" 5201 " ->aaaaaaaaaaaaaaaa(\n" 5202 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5203 " ->aaaaaaaaaaaaaaaaa();"); 5204 verifyGoogleFormat( 5205 "void f() {\n" 5206 " someo->Add((new util::filetools::Handler(dir))\n" 5207 " ->OnEvent1(NewPermanentCallback(\n" 5208 " this, &HandlerHolderClass::EventHandlerCBA))\n" 5209 " ->OnEvent2(NewPermanentCallback(\n" 5210 " this, &HandlerHolderClass::EventHandlerCBB))\n" 5211 " ->OnEvent3(NewPermanentCallback(\n" 5212 " this, &HandlerHolderClass::EventHandlerCBC))\n" 5213 " ->OnEvent5(NewPermanentCallback(\n" 5214 " this, &HandlerHolderClass::EventHandlerCBD))\n" 5215 " ->OnEvent6(NewPermanentCallback(\n" 5216 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 5217 "}"); 5218 5219 verifyFormat( 5220 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 5221 verifyFormat("aaaaaaaaaaaaaaa()\n" 5222 " .aaaaaaaaaaaaaaa()\n" 5223 " .aaaaaaaaaaaaaaa()\n" 5224 " .aaaaaaaaaaaaaaa()\n" 5225 " .aaaaaaaaaaaaaaa();"); 5226 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5227 " .aaaaaaaaaaaaaaa()\n" 5228 " .aaaaaaaaaaaaaaa()\n" 5229 " .aaaaaaaaaaaaaaa();"); 5230 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5231 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5232 " .aaaaaaaaaaaaaaa();"); 5233 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 5234 " ->aaaaaaaaaaaaaae(0)\n" 5235 " ->aaaaaaaaaaaaaaa();"); 5236 5237 // Don't linewrap after very short segments. 5238 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5239 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5240 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5241 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5242 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5243 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5244 verifyFormat("aaa()\n" 5245 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5246 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5247 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5248 5249 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5250 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5251 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 5252 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5253 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 5254 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 5255 5256 // Prefer not to break after empty parentheses. 5257 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 5258 " First->LastNewlineOffset);"); 5259 5260 // Prefer not to create "hanging" indents. 5261 verifyFormat( 5262 "return !soooooooooooooome_map\n" 5263 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5264 " .second;"); 5265 verifyFormat( 5266 "return aaaaaaaaaaaaaaaa\n" 5267 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 5268 " .aaaa(aaaaaaaaaaaaaa);"); 5269 // No hanging indent here. 5270 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5271 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5272 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5273 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5274 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5275 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5276 getLLVMStyleWithColumns(60)); 5277 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5278 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5279 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5280 getLLVMStyleWithColumns(59)); 5281 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5282 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5283 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5284 5285 // Dont break if only closing statements before member call 5286 verifyFormat("test() {\n" 5287 " ([]() -> {\n" 5288 " int b = 32;\n" 5289 " return 3;\n" 5290 " }).foo();\n" 5291 "}"); 5292 verifyFormat("test() {\n" 5293 " (\n" 5294 " []() -> {\n" 5295 " int b = 32;\n" 5296 " return 3;\n" 5297 " },\n" 5298 " foo, bar)\n" 5299 " .foo();\n" 5300 "}"); 5301 verifyFormat("test() {\n" 5302 " ([]() -> {\n" 5303 " int b = 32;\n" 5304 " return 3;\n" 5305 " })\n" 5306 " .foo()\n" 5307 " .bar();\n" 5308 "}"); 5309 verifyFormat("test() {\n" 5310 " ([]() -> {\n" 5311 " int b = 32;\n" 5312 " return 3;\n" 5313 " })\n" 5314 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5315 " \"bbbb\");\n" 5316 "}", 5317 getLLVMStyleWithColumns(30)); 5318 } 5319 5320 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5321 verifyFormat( 5322 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5323 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5324 verifyFormat( 5325 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5326 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5327 5328 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5329 " ccccccccccccccccccccccccc) {\n}"); 5330 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5331 " ccccccccccccccccccccccccc) {\n}"); 5332 5333 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5334 " ccccccccccccccccccccccccc) {\n}"); 5335 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5336 " ccccccccccccccccccccccccc) {\n}"); 5337 5338 verifyFormat( 5339 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5340 " ccccccccccccccccccccccccc) {\n}"); 5341 verifyFormat( 5342 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5343 " ccccccccccccccccccccccccc) {\n}"); 5344 5345 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5346 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5347 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5348 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5349 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5350 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5351 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5352 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5353 5354 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5355 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5356 " aaaaaaaaaaaaaaa != aa) {\n}"); 5357 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5358 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5359 " aaaaaaaaaaaaaaa != aa) {\n}"); 5360 } 5361 5362 TEST_F(FormatTest, BreaksAfterAssignments) { 5363 verifyFormat( 5364 "unsigned Cost =\n" 5365 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5366 " SI->getPointerAddressSpaceee());\n"); 5367 verifyFormat( 5368 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5369 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5370 5371 verifyFormat( 5372 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5373 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5374 verifyFormat("unsigned OriginalStartColumn =\n" 5375 " SourceMgr.getSpellingColumnNumber(\n" 5376 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5377 " 1;"); 5378 } 5379 5380 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5381 FormatStyle Style = getLLVMStyle(); 5382 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5383 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5384 Style); 5385 5386 Style.PenaltyBreakAssignment = 20; 5387 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5388 " cccccccccccccccccccccccccc;", 5389 Style); 5390 } 5391 5392 TEST_F(FormatTest, AlignsAfterAssignments) { 5393 verifyFormat( 5394 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5395 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5396 verifyFormat( 5397 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5398 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5399 verifyFormat( 5400 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5401 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5402 verifyFormat( 5403 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5404 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5405 verifyFormat( 5406 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5407 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5408 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5409 } 5410 5411 TEST_F(FormatTest, AlignsAfterReturn) { 5412 verifyFormat( 5413 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5414 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5415 verifyFormat( 5416 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5417 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5418 verifyFormat( 5419 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5420 " aaaaaaaaaaaaaaaaaaaaaa();"); 5421 verifyFormat( 5422 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5423 " aaaaaaaaaaaaaaaaaaaaaa());"); 5424 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5425 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5426 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5427 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5428 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5429 verifyFormat("return\n" 5430 " // true if code is one of a or b.\n" 5431 " code == a || code == b;"); 5432 } 5433 5434 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5435 verifyFormat( 5436 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5437 " aaaaaaaaa aaaaaaa) {}"); 5438 verifyFormat( 5439 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5440 " aaaaaaaaaaa aaaaaaaaa);"); 5441 verifyFormat( 5442 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5443 " aaaaaaaaaaaaaaaaaaaaa));"); 5444 FormatStyle Style = getLLVMStyle(); 5445 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5446 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5447 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5448 Style); 5449 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5450 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5451 Style); 5452 verifyFormat("SomeLongVariableName->someFunction(\n" 5453 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5454 Style); 5455 verifyFormat( 5456 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5457 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5458 Style); 5459 verifyFormat( 5460 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5461 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5462 Style); 5463 verifyFormat( 5464 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5465 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5466 Style); 5467 5468 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5469 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5470 " b));", 5471 Style); 5472 5473 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5474 Style.BinPackArguments = false; 5475 Style.BinPackParameters = false; 5476 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5477 " aaaaaaaaaaa aaaaaaaa,\n" 5478 " aaaaaaaaa aaaaaaa,\n" 5479 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5480 Style); 5481 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5482 " aaaaaaaaaaa aaaaaaaaa,\n" 5483 " aaaaaaaaaaa aaaaaaaaa,\n" 5484 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5485 Style); 5486 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5487 " aaaaaaaaaaaaaaa,\n" 5488 " aaaaaaaaaaaaaaaaaaaaa,\n" 5489 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5490 Style); 5491 verifyFormat( 5492 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5493 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5494 Style); 5495 verifyFormat( 5496 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5497 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5498 Style); 5499 verifyFormat( 5500 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5501 " aaaaaaaaaaaaaaaaaaaaa(\n" 5502 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5503 " aaaaaaaaaaaaaaaa);", 5504 Style); 5505 verifyFormat( 5506 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5507 " aaaaaaaaaaaaaaaaaaaaa(\n" 5508 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5509 " aaaaaaaaaaaaaaaa);", 5510 Style); 5511 } 5512 5513 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5514 FormatStyle Style = getLLVMStyleWithColumns(40); 5515 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5516 " bbbbbbbbbbbbbbbbbbbbbb);", 5517 Style); 5518 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5519 Style.AlignOperands = false; 5520 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5521 " bbbbbbbbbbbbbbbbbbbbbb);", 5522 Style); 5523 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5524 Style.AlignOperands = true; 5525 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5526 " bbbbbbbbbbbbbbbbbbbbbb);", 5527 Style); 5528 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5529 Style.AlignOperands = false; 5530 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5531 " bbbbbbbbbbbbbbbbbbbbbb);", 5532 Style); 5533 } 5534 5535 TEST_F(FormatTest, BreaksConditionalExpressions) { 5536 verifyFormat( 5537 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5538 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5539 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5540 verifyFormat( 5541 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5542 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5543 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5544 verifyFormat( 5545 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5546 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5547 verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5548 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5549 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5550 verifyFormat( 5551 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5552 " : aaaaaaaaaaaaa);"); 5553 verifyFormat( 5554 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5555 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5556 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5557 " aaaaaaaaaaaaa);"); 5558 verifyFormat( 5559 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5560 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5561 " aaaaaaaaaaaaa);"); 5562 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5563 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5564 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5565 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5566 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5567 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5568 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5569 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5570 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5571 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5572 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5573 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5574 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5575 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5576 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5577 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5578 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5579 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5580 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5581 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5582 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5583 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5584 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5585 " : aaaaaaaaaaaaaaaa;"); 5586 verifyFormat( 5587 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5588 " ? aaaaaaaaaaaaaaa\n" 5589 " : aaaaaaaaaaaaaaa;"); 5590 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5591 " aaaaaaaaa\n" 5592 " ? b\n" 5593 " : c);"); 5594 verifyFormat("return aaaa == bbbb\n" 5595 " // comment\n" 5596 " ? aaaa\n" 5597 " : bbbb;"); 5598 verifyFormat("unsigned Indent =\n" 5599 " format(TheLine.First,\n" 5600 " IndentForLevel[TheLine.Level] >= 0\n" 5601 " ? IndentForLevel[TheLine.Level]\n" 5602 " : TheLine * 2,\n" 5603 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5604 getLLVMStyleWithColumns(60)); 5605 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5606 " ? aaaaaaaaaaaaaaa\n" 5607 " : bbbbbbbbbbbbbbb //\n" 5608 " ? ccccccccccccccc\n" 5609 " : ddddddddddddddd;"); 5610 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5611 " ? aaaaaaaaaaaaaaa\n" 5612 " : (bbbbbbbbbbbbbbb //\n" 5613 " ? ccccccccccccccc\n" 5614 " : ddddddddddddddd);"); 5615 verifyFormat( 5616 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5617 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5618 " aaaaaaaaaaaaaaaaaaaaa +\n" 5619 " aaaaaaaaaaaaaaaaaaaaa\n" 5620 " : aaaaaaaaaa;"); 5621 verifyFormat( 5622 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5623 " : aaaaaaaaaaaaaaaaaaaaaa\n" 5624 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5625 5626 FormatStyle NoBinPacking = getLLVMStyle(); 5627 NoBinPacking.BinPackArguments = false; 5628 verifyFormat( 5629 "void f() {\n" 5630 " g(aaa,\n" 5631 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5632 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5633 " ? aaaaaaaaaaaaaaa\n" 5634 " : aaaaaaaaaaaaaaa);\n" 5635 "}", 5636 NoBinPacking); 5637 verifyFormat( 5638 "void f() {\n" 5639 " g(aaa,\n" 5640 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5641 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5642 " ?: aaaaaaaaaaaaaaa);\n" 5643 "}", 5644 NoBinPacking); 5645 5646 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 5647 " // comment.\n" 5648 " ccccccccccccccccccccccccccccccccccccccc\n" 5649 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5650 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 5651 5652 // Assignments in conditional expressions. Apparently not uncommon :-(. 5653 verifyFormat("return a != b\n" 5654 " // comment\n" 5655 " ? a = b\n" 5656 " : a = b;"); 5657 verifyFormat("return a != b\n" 5658 " // comment\n" 5659 " ? a = a != b\n" 5660 " // comment\n" 5661 " ? a = b\n" 5662 " : a\n" 5663 " : a;\n"); 5664 verifyFormat("return a != b\n" 5665 " // comment\n" 5666 " ? a\n" 5667 " : a = a != b\n" 5668 " // comment\n" 5669 " ? a = b\n" 5670 " : a;"); 5671 } 5672 5673 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 5674 FormatStyle Style = getLLVMStyle(); 5675 Style.BreakBeforeTernaryOperators = false; 5676 Style.ColumnLimit = 70; 5677 verifyFormat( 5678 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5679 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5680 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5681 Style); 5682 verifyFormat( 5683 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5684 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5685 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5686 Style); 5687 verifyFormat( 5688 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5689 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5690 Style); 5691 verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n" 5692 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5693 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5694 Style); 5695 verifyFormat( 5696 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 5697 " aaaaaaaaaaaaa);", 5698 Style); 5699 verifyFormat( 5700 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5701 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5702 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5703 " aaaaaaaaaaaaa);", 5704 Style); 5705 verifyFormat( 5706 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5707 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5708 " aaaaaaaaaaaaa);", 5709 Style); 5710 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5711 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5712 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5713 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5714 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5715 Style); 5716 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5717 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5718 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5719 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5720 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5721 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5722 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5723 Style); 5724 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5725 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 5726 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5727 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5728 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5729 Style); 5730 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5731 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5732 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5733 Style); 5734 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5735 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5736 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5737 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5738 Style); 5739 verifyFormat( 5740 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5741 " aaaaaaaaaaaaaaa :\n" 5742 " aaaaaaaaaaaaaaa;", 5743 Style); 5744 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5745 " aaaaaaaaa ?\n" 5746 " b :\n" 5747 " c);", 5748 Style); 5749 verifyFormat("unsigned Indent =\n" 5750 " format(TheLine.First,\n" 5751 " IndentForLevel[TheLine.Level] >= 0 ?\n" 5752 " IndentForLevel[TheLine.Level] :\n" 5753 " TheLine * 2,\n" 5754 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5755 Style); 5756 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5757 " aaaaaaaaaaaaaaa :\n" 5758 " bbbbbbbbbbbbbbb ? //\n" 5759 " ccccccccccccccc :\n" 5760 " ddddddddddddddd;", 5761 Style); 5762 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5763 " aaaaaaaaaaaaaaa :\n" 5764 " (bbbbbbbbbbbbbbb ? //\n" 5765 " ccccccccccccccc :\n" 5766 " ddddddddddddddd);", 5767 Style); 5768 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5769 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 5770 " ccccccccccccccccccccccccccc;", 5771 Style); 5772 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5773 " aaaaa :\n" 5774 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 5775 Style); 5776 } 5777 5778 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 5779 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 5780 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 5781 verifyFormat("bool a = true, b = false;"); 5782 5783 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5784 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 5785 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 5786 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 5787 verifyFormat( 5788 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 5789 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 5790 " d = e && f;"); 5791 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 5792 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 5793 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5794 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 5795 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 5796 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 5797 5798 FormatStyle Style = getGoogleStyle(); 5799 Style.PointerAlignment = FormatStyle::PAS_Left; 5800 Style.DerivePointerAlignment = false; 5801 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5802 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 5803 " *b = bbbbbbbbbbbbbbbbbbb;", 5804 Style); 5805 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5806 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 5807 Style); 5808 verifyFormat("vector<int*> a, b;", Style); 5809 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 5810 } 5811 5812 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 5813 verifyFormat("arr[foo ? bar : baz];"); 5814 verifyFormat("f()[foo ? bar : baz];"); 5815 verifyFormat("(a + b)[foo ? bar : baz];"); 5816 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 5817 } 5818 5819 TEST_F(FormatTest, AlignsStringLiterals) { 5820 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 5821 " \"short literal\");"); 5822 verifyFormat( 5823 "looooooooooooooooooooooooongFunction(\n" 5824 " \"short literal\"\n" 5825 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 5826 verifyFormat("someFunction(\"Always break between multi-line\"\n" 5827 " \" string literals\",\n" 5828 " and, other, parameters);"); 5829 EXPECT_EQ("fun + \"1243\" /* comment */\n" 5830 " \"5678\";", 5831 format("fun + \"1243\" /* comment */\n" 5832 " \"5678\";", 5833 getLLVMStyleWithColumns(28))); 5834 EXPECT_EQ( 5835 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 5836 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 5837 " \"aaaaaaaaaaaaaaaa\";", 5838 format("aaaaaa =" 5839 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 5840 "aaaaaaaaaaaaaaaaaaaaa\" " 5841 "\"aaaaaaaaaaaaaaaa\";")); 5842 verifyFormat("a = a + \"a\"\n" 5843 " \"a\"\n" 5844 " \"a\";"); 5845 verifyFormat("f(\"a\", \"b\"\n" 5846 " \"c\");"); 5847 5848 verifyFormat( 5849 "#define LL_FORMAT \"ll\"\n" 5850 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 5851 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 5852 5853 verifyFormat("#define A(X) \\\n" 5854 " \"aaaaa\" #X \"bbbbbb\" \\\n" 5855 " \"ccccc\"", 5856 getLLVMStyleWithColumns(23)); 5857 verifyFormat("#define A \"def\"\n" 5858 "f(\"abc\" A \"ghi\"\n" 5859 " \"jkl\");"); 5860 5861 verifyFormat("f(L\"a\"\n" 5862 " L\"b\");"); 5863 verifyFormat("#define A(X) \\\n" 5864 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 5865 " L\"ccccc\"", 5866 getLLVMStyleWithColumns(25)); 5867 5868 verifyFormat("f(@\"a\"\n" 5869 " @\"b\");"); 5870 verifyFormat("NSString s = @\"a\"\n" 5871 " @\"b\"\n" 5872 " @\"c\";"); 5873 verifyFormat("NSString s = @\"a\"\n" 5874 " \"b\"\n" 5875 " \"c\";"); 5876 } 5877 5878 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 5879 FormatStyle Style = getLLVMStyle(); 5880 // No declarations or definitions should be moved to own line. 5881 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 5882 verifyFormat("class A {\n" 5883 " int f() { return 1; }\n" 5884 " int g();\n" 5885 "};\n" 5886 "int f() { return 1; }\n" 5887 "int g();\n", 5888 Style); 5889 5890 // All declarations and definitions should have the return type moved to its 5891 // own 5892 // line. 5893 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 5894 verifyFormat("class E {\n" 5895 " int\n" 5896 " f() {\n" 5897 " return 1;\n" 5898 " }\n" 5899 " int\n" 5900 " g();\n" 5901 "};\n" 5902 "int\n" 5903 "f() {\n" 5904 " return 1;\n" 5905 "}\n" 5906 "int\n" 5907 "g();\n", 5908 Style); 5909 5910 // Top-level definitions, and no kinds of declarations should have the 5911 // return type moved to its own line. 5912 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 5913 verifyFormat("class B {\n" 5914 " int f() { return 1; }\n" 5915 " int g();\n" 5916 "};\n" 5917 "int\n" 5918 "f() {\n" 5919 " return 1;\n" 5920 "}\n" 5921 "int g();\n", 5922 Style); 5923 5924 // Top-level definitions and declarations should have the return type moved 5925 // to its own line. 5926 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 5927 verifyFormat("class C {\n" 5928 " int f() { return 1; }\n" 5929 " int g();\n" 5930 "};\n" 5931 "int\n" 5932 "f() {\n" 5933 " return 1;\n" 5934 "}\n" 5935 "int\n" 5936 "g();\n", 5937 Style); 5938 5939 // All definitions should have the return type moved to its own line, but no 5940 // kinds of declarations. 5941 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 5942 verifyFormat("class D {\n" 5943 " int\n" 5944 " f() {\n" 5945 " return 1;\n" 5946 " }\n" 5947 " int g();\n" 5948 "};\n" 5949 "int\n" 5950 "f() {\n" 5951 " return 1;\n" 5952 "}\n" 5953 "int g();\n", 5954 Style); 5955 verifyFormat("const char *\n" 5956 "f(void) {\n" // Break here. 5957 " return \"\";\n" 5958 "}\n" 5959 "const char *bar(void);\n", // No break here. 5960 Style); 5961 verifyFormat("template <class T>\n" 5962 "T *\n" 5963 "f(T &c) {\n" // Break here. 5964 " return NULL;\n" 5965 "}\n" 5966 "template <class T> T *f(T &c);\n", // No break here. 5967 Style); 5968 verifyFormat("class C {\n" 5969 " int\n" 5970 " operator+() {\n" 5971 " return 1;\n" 5972 " }\n" 5973 " int\n" 5974 " operator()() {\n" 5975 " return 1;\n" 5976 " }\n" 5977 "};\n", 5978 Style); 5979 verifyFormat("void\n" 5980 "A::operator()() {}\n" 5981 "void\n" 5982 "A::operator>>() {}\n" 5983 "void\n" 5984 "A::operator+() {}\n", 5985 Style); 5986 verifyFormat("void *operator new(std::size_t s);", // No break here. 5987 Style); 5988 verifyFormat("void *\n" 5989 "operator new(std::size_t s) {}", 5990 Style); 5991 verifyFormat("void *\n" 5992 "operator delete[](void *ptr) {}", 5993 Style); 5994 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 5995 verifyFormat("const char *\n" 5996 "f(void)\n" // Break here. 5997 "{\n" 5998 " return \"\";\n" 5999 "}\n" 6000 "const char *bar(void);\n", // No break here. 6001 Style); 6002 verifyFormat("template <class T>\n" 6003 "T *\n" // Problem here: no line break 6004 "f(T &c)\n" // Break here. 6005 "{\n" 6006 " return NULL;\n" 6007 "}\n" 6008 "template <class T> T *f(T &c);\n", // No break here. 6009 Style); 6010 verifyFormat("int\n" 6011 "foo(A<bool> a)\n" 6012 "{\n" 6013 " return a;\n" 6014 "}\n", 6015 Style); 6016 verifyFormat("int\n" 6017 "foo(A<8> a)\n" 6018 "{\n" 6019 " return a;\n" 6020 "}\n", 6021 Style); 6022 verifyFormat("int\n" 6023 "foo(A<B<bool>, 8> a)\n" 6024 "{\n" 6025 " return a;\n" 6026 "}\n", 6027 Style); 6028 verifyFormat("int\n" 6029 "foo(A<B<8>, bool> a)\n" 6030 "{\n" 6031 " return a;\n" 6032 "}\n", 6033 Style); 6034 verifyFormat("int\n" 6035 "foo(A<B<bool>, bool> a)\n" 6036 "{\n" 6037 " return a;\n" 6038 "}\n", 6039 Style); 6040 verifyFormat("int\n" 6041 "foo(A<B<8>, 8> a)\n" 6042 "{\n" 6043 " return a;\n" 6044 "}\n", 6045 Style); 6046 6047 Style = getGNUStyle(); 6048 6049 // Test for comments at the end of function declarations. 6050 verifyFormat("void\n" 6051 "foo (int a, /*abc*/ int b) // def\n" 6052 "{\n" 6053 "}\n", 6054 Style); 6055 6056 verifyFormat("void\n" 6057 "foo (int a, /* abc */ int b) /* def */\n" 6058 "{\n" 6059 "}\n", 6060 Style); 6061 6062 // Definitions that should not break after return type 6063 verifyFormat("void foo (int a, int b); // def\n", Style); 6064 verifyFormat("void foo (int a, int b); /* def */\n", Style); 6065 verifyFormat("void foo (int a, int b);\n", Style); 6066 } 6067 6068 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 6069 FormatStyle NoBreak = getLLVMStyle(); 6070 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 6071 FormatStyle Break = getLLVMStyle(); 6072 Break.AlwaysBreakBeforeMultilineStrings = true; 6073 verifyFormat("aaaa = \"bbbb\"\n" 6074 " \"cccc\";", 6075 NoBreak); 6076 verifyFormat("aaaa =\n" 6077 " \"bbbb\"\n" 6078 " \"cccc\";", 6079 Break); 6080 verifyFormat("aaaa(\"bbbb\"\n" 6081 " \"cccc\");", 6082 NoBreak); 6083 verifyFormat("aaaa(\n" 6084 " \"bbbb\"\n" 6085 " \"cccc\");", 6086 Break); 6087 verifyFormat("aaaa(qqq, \"bbbb\"\n" 6088 " \"cccc\");", 6089 NoBreak); 6090 verifyFormat("aaaa(qqq,\n" 6091 " \"bbbb\"\n" 6092 " \"cccc\");", 6093 Break); 6094 verifyFormat("aaaa(qqq,\n" 6095 " L\"bbbb\"\n" 6096 " L\"cccc\");", 6097 Break); 6098 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 6099 " \"bbbb\"));", 6100 Break); 6101 verifyFormat("string s = someFunction(\n" 6102 " \"abc\"\n" 6103 " \"abc\");", 6104 Break); 6105 6106 // As we break before unary operators, breaking right after them is bad. 6107 verifyFormat("string foo = abc ? \"x\"\n" 6108 " \"blah blah blah blah blah blah\"\n" 6109 " : \"y\";", 6110 Break); 6111 6112 // Don't break if there is no column gain. 6113 verifyFormat("f(\"aaaa\"\n" 6114 " \"bbbb\");", 6115 Break); 6116 6117 // Treat literals with escaped newlines like multi-line string literals. 6118 EXPECT_EQ("x = \"a\\\n" 6119 "b\\\n" 6120 "c\";", 6121 format("x = \"a\\\n" 6122 "b\\\n" 6123 "c\";", 6124 NoBreak)); 6125 EXPECT_EQ("xxxx =\n" 6126 " \"a\\\n" 6127 "b\\\n" 6128 "c\";", 6129 format("xxxx = \"a\\\n" 6130 "b\\\n" 6131 "c\";", 6132 Break)); 6133 6134 EXPECT_EQ("NSString *const kString =\n" 6135 " @\"aaaa\"\n" 6136 " @\"bbbb\";", 6137 format("NSString *const kString = @\"aaaa\"\n" 6138 "@\"bbbb\";", 6139 Break)); 6140 6141 Break.ColumnLimit = 0; 6142 verifyFormat("const char *hello = \"hello llvm\";", Break); 6143 } 6144 6145 TEST_F(FormatTest, AlignsPipes) { 6146 verifyFormat( 6147 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6148 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6149 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6150 verifyFormat( 6151 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 6152 " << aaaaaaaaaaaaaaaaaaaa;"); 6153 verifyFormat( 6154 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6155 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6156 verifyFormat( 6157 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 6158 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6159 verifyFormat( 6160 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 6161 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 6162 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 6163 verifyFormat( 6164 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6165 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6166 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6167 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6168 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6169 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6170 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6171 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 6172 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 6173 verifyFormat( 6174 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6175 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6176 verifyFormat( 6177 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 6178 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6179 6180 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 6181 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 6182 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6183 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6184 " aaaaaaaaaaaaaaaaaaaaa)\n" 6185 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6186 verifyFormat("LOG_IF(aaa == //\n" 6187 " bbb)\n" 6188 " << a << b;"); 6189 6190 // But sometimes, breaking before the first "<<" is desirable. 6191 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6192 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 6193 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 6194 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6195 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6196 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 6197 " << BEF << IsTemplate << Description << E->getType();"); 6198 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6199 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6200 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6201 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6202 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6203 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6204 " << aaa;"); 6205 6206 verifyFormat( 6207 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6208 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6209 6210 // Incomplete string literal. 6211 EXPECT_EQ("llvm::errs() << \"\n" 6212 " << a;", 6213 format("llvm::errs() << \"\n<<a;")); 6214 6215 verifyFormat("void f() {\n" 6216 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 6217 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 6218 "}"); 6219 6220 // Handle 'endl'. 6221 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 6222 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6223 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6224 6225 // Handle '\n'. 6226 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 6227 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6228 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 6229 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 6230 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 6231 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 6232 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6233 } 6234 6235 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 6236 verifyFormat("return out << \"somepacket = {\\n\"\n" 6237 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 6238 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 6239 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 6240 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 6241 " << \"}\";"); 6242 6243 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6244 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6245 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 6246 verifyFormat( 6247 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 6248 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 6249 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 6250 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 6251 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 6252 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 6253 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6254 verifyFormat( 6255 "void f() {\n" 6256 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 6257 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 6258 "}"); 6259 6260 // Breaking before the first "<<" is generally not desirable. 6261 verifyFormat( 6262 "llvm::errs()\n" 6263 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6264 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6265 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6266 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6267 getLLVMStyleWithColumns(70)); 6268 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6269 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6270 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6271 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6272 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6273 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6274 getLLVMStyleWithColumns(70)); 6275 6276 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6277 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6278 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6279 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6280 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6281 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 6282 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 6283 " (aaaa + aaaa);", 6284 getLLVMStyleWithColumns(40)); 6285 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 6286 " (aaaaaaa + aaaaa));", 6287 getLLVMStyleWithColumns(40)); 6288 verifyFormat( 6289 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 6290 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 6291 " bbbbbbbbbbbbbbbbbbbbbbb);"); 6292 } 6293 6294 TEST_F(FormatTest, UnderstandsEquals) { 6295 verifyFormat( 6296 "aaaaaaaaaaaaaaaaa =\n" 6297 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6298 verifyFormat( 6299 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6300 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6301 verifyFormat( 6302 "if (a) {\n" 6303 " f();\n" 6304 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6305 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 6306 "}"); 6307 6308 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6309 " 100000000 + 10000000) {\n}"); 6310 } 6311 6312 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 6313 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6314 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 6315 6316 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6317 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 6318 6319 verifyFormat( 6320 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 6321 " Parameter2);"); 6322 6323 verifyFormat( 6324 "ShortObject->shortFunction(\n" 6325 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 6326 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 6327 6328 verifyFormat("loooooooooooooongFunction(\n" 6329 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 6330 6331 verifyFormat( 6332 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 6333 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 6334 6335 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6336 " .WillRepeatedly(Return(SomeValue));"); 6337 verifyFormat("void f() {\n" 6338 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6339 " .Times(2)\n" 6340 " .WillRepeatedly(Return(SomeValue));\n" 6341 "}"); 6342 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 6343 " ccccccccccccccccccccccc);"); 6344 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6345 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6346 " .aaaaa(aaaaa),\n" 6347 " aaaaaaaaaaaaaaaaaaaaa);"); 6348 verifyFormat("void f() {\n" 6349 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6350 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 6351 "}"); 6352 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6353 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6354 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6355 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6356 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6357 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6358 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6359 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6360 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 6361 "}"); 6362 6363 // Here, it is not necessary to wrap at "." or "->". 6364 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 6365 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6366 verifyFormat( 6367 "aaaaaaaaaaa->aaaaaaaaa(\n" 6368 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6369 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 6370 6371 verifyFormat( 6372 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6373 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 6374 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 6375 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6376 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 6377 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6378 6379 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6380 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6381 " .a();"); 6382 6383 FormatStyle NoBinPacking = getLLVMStyle(); 6384 NoBinPacking.BinPackParameters = false; 6385 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6386 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6387 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 6388 " aaaaaaaaaaaaaaaaaaa,\n" 6389 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6390 NoBinPacking); 6391 6392 // If there is a subsequent call, change to hanging indentation. 6393 verifyFormat( 6394 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6395 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 6396 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6397 verifyFormat( 6398 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6399 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 6400 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6401 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6402 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6403 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6404 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6405 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6406 } 6407 6408 TEST_F(FormatTest, WrapsTemplateDeclarations) { 6409 verifyFormat("template <typename T>\n" 6410 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6411 verifyFormat("template <typename T>\n" 6412 "// T should be one of {A, B}.\n" 6413 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6414 verifyFormat( 6415 "template <typename T>\n" 6416 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 6417 verifyFormat("template <typename T>\n" 6418 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 6419 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 6420 verifyFormat( 6421 "template <typename T>\n" 6422 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 6423 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 6424 verifyFormat( 6425 "template <typename T>\n" 6426 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 6427 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 6428 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6429 verifyFormat("template <typename T>\n" 6430 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6431 " int aaaaaaaaaaaaaaaaaaaaaa);"); 6432 verifyFormat( 6433 "template <typename T1, typename T2 = char, typename T3 = char,\n" 6434 " typename T4 = char>\n" 6435 "void f();"); 6436 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 6437 " template <typename> class cccccccccccccccccccccc,\n" 6438 " typename ddddddddddddd>\n" 6439 "class C {};"); 6440 verifyFormat( 6441 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 6442 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6443 6444 verifyFormat("void f() {\n" 6445 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 6446 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 6447 "}"); 6448 6449 verifyFormat("template <typename T> class C {};"); 6450 verifyFormat("template <typename T> void f();"); 6451 verifyFormat("template <typename T> void f() {}"); 6452 verifyFormat( 6453 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6454 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6455 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 6456 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6457 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6458 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 6459 " bbbbbbbbbbbbbbbbbbbbbbbb);", 6460 getLLVMStyleWithColumns(72)); 6461 EXPECT_EQ("static_cast<A< //\n" 6462 " B> *>(\n" 6463 "\n" 6464 ");", 6465 format("static_cast<A<//\n" 6466 " B>*>(\n" 6467 "\n" 6468 " );")); 6469 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6470 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 6471 6472 FormatStyle AlwaysBreak = getLLVMStyle(); 6473 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 6474 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 6475 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 6476 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 6477 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6478 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6479 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 6480 verifyFormat("template <template <typename> class Fooooooo,\n" 6481 " template <typename> class Baaaaaaar>\n" 6482 "struct C {};", 6483 AlwaysBreak); 6484 verifyFormat("template <typename T> // T can be A, B or C.\n" 6485 "struct C {};", 6486 AlwaysBreak); 6487 verifyFormat("template <enum E> class A {\n" 6488 "public:\n" 6489 " E *f();\n" 6490 "};"); 6491 6492 FormatStyle NeverBreak = getLLVMStyle(); 6493 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 6494 verifyFormat("template <typename T> class C {};", NeverBreak); 6495 verifyFormat("template <typename T> void f();", NeverBreak); 6496 verifyFormat("template <typename T> void f() {}", NeverBreak); 6497 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6498 "bbbbbbbbbbbbbbbbbbbb) {}", 6499 NeverBreak); 6500 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6501 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6502 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 6503 NeverBreak); 6504 verifyFormat("template <template <typename> class Fooooooo,\n" 6505 " template <typename> class Baaaaaaar>\n" 6506 "struct C {};", 6507 NeverBreak); 6508 verifyFormat("template <typename T> // T can be A, B or C.\n" 6509 "struct C {};", 6510 NeverBreak); 6511 verifyFormat("template <enum E> class A {\n" 6512 "public:\n" 6513 " E *f();\n" 6514 "};", 6515 NeverBreak); 6516 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 6517 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6518 "bbbbbbbbbbbbbbbbbbbb) {}", 6519 NeverBreak); 6520 } 6521 6522 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 6523 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 6524 Style.ColumnLimit = 60; 6525 EXPECT_EQ("// Baseline - no comments.\n" 6526 "template <\n" 6527 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6528 "void f() {}", 6529 format("// Baseline - no comments.\n" 6530 "template <\n" 6531 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6532 "void f() {}", 6533 Style)); 6534 6535 EXPECT_EQ("template <\n" 6536 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6537 "void f() {}", 6538 format("template <\n" 6539 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6540 "void f() {}", 6541 Style)); 6542 6543 EXPECT_EQ( 6544 "template <\n" 6545 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6546 "void f() {}", 6547 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6548 "void f() {}", 6549 Style)); 6550 6551 EXPECT_EQ( 6552 "template <\n" 6553 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6554 " // multiline\n" 6555 "void f() {}", 6556 format("template <\n" 6557 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6558 " // multiline\n" 6559 "void f() {}", 6560 Style)); 6561 6562 EXPECT_EQ( 6563 "template <typename aaaaaaaaaa<\n" 6564 " bbbbbbbbbbbb>::value> // trailing loooong\n" 6565 "void f() {}", 6566 format( 6567 "template <\n" 6568 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 6569 "void f() {}", 6570 Style)); 6571 } 6572 6573 TEST_F(FormatTest, WrapsTemplateParameters) { 6574 FormatStyle Style = getLLVMStyle(); 6575 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6576 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6577 verifyFormat( 6578 "template <typename... a> struct q {};\n" 6579 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6580 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6581 " y;", 6582 Style); 6583 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6584 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6585 verifyFormat( 6586 "template <typename... a> struct r {};\n" 6587 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6588 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6589 " y;", 6590 Style); 6591 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6592 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6593 verifyFormat("template <typename... a> struct s {};\n" 6594 "extern s<\n" 6595 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6596 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6597 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6598 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6599 " y;", 6600 Style); 6601 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6602 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6603 verifyFormat("template <typename... a> struct t {};\n" 6604 "extern t<\n" 6605 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6606 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6607 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6608 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6609 " y;", 6610 Style); 6611 } 6612 6613 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 6614 verifyFormat( 6615 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6616 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6617 verifyFormat( 6618 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6619 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6620 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6621 6622 // FIXME: Should we have the extra indent after the second break? 6623 verifyFormat( 6624 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6625 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6626 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6627 6628 verifyFormat( 6629 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 6630 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 6631 6632 // Breaking at nested name specifiers is generally not desirable. 6633 verifyFormat( 6634 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6635 " aaaaaaaaaaaaaaaaaaaaaaa);"); 6636 6637 verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 6638 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6639 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6640 " aaaaaaaaaaaaaaaaaaaaa);", 6641 getLLVMStyleWithColumns(74)); 6642 6643 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6644 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6645 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6646 } 6647 6648 TEST_F(FormatTest, UnderstandsTemplateParameters) { 6649 verifyFormat("A<int> a;"); 6650 verifyFormat("A<A<A<int>>> a;"); 6651 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 6652 verifyFormat("bool x = a < 1 || 2 > a;"); 6653 verifyFormat("bool x = 5 < f<int>();"); 6654 verifyFormat("bool x = f<int>() > 5;"); 6655 verifyFormat("bool x = 5 < a<int>::x;"); 6656 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 6657 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 6658 6659 verifyGoogleFormat("A<A<int>> a;"); 6660 verifyGoogleFormat("A<A<A<int>>> a;"); 6661 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 6662 verifyGoogleFormat("A<A<int> > a;"); 6663 verifyGoogleFormat("A<A<A<int> > > a;"); 6664 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 6665 verifyGoogleFormat("A<::A<int>> a;"); 6666 verifyGoogleFormat("A<::A> a;"); 6667 verifyGoogleFormat("A< ::A> a;"); 6668 verifyGoogleFormat("A< ::A<int> > a;"); 6669 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 6670 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 6671 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 6672 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 6673 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 6674 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 6675 6676 verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 6677 6678 // template closer followed by a token that starts with > or = 6679 verifyFormat("bool b = a<1> > 1;"); 6680 verifyFormat("bool b = a<1> >= 1;"); 6681 verifyFormat("int i = a<1> >> 1;"); 6682 FormatStyle Style = getLLVMStyle(); 6683 Style.SpaceBeforeAssignmentOperators = false; 6684 verifyFormat("bool b= a<1> == 1;", Style); 6685 verifyFormat("a<int> = 1;", Style); 6686 verifyFormat("a<int> >>= 1;", Style); 6687 6688 verifyFormat("test >> a >> b;"); 6689 verifyFormat("test << a >> b;"); 6690 6691 verifyFormat("f<int>();"); 6692 verifyFormat("template <typename T> void f() {}"); 6693 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 6694 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 6695 "sizeof(char)>::type>;"); 6696 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 6697 verifyFormat("f(a.operator()<A>());"); 6698 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6699 " .template operator()<A>());", 6700 getLLVMStyleWithColumns(35)); 6701 6702 // Not template parameters. 6703 verifyFormat("return a < b && c > d;"); 6704 verifyFormat("void f() {\n" 6705 " while (a < b && c > d) {\n" 6706 " }\n" 6707 "}"); 6708 verifyFormat("template <typename... Types>\n" 6709 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 6710 6711 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6712 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 6713 getLLVMStyleWithColumns(60)); 6714 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 6715 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 6716 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 6717 } 6718 6719 TEST_F(FormatTest, BitshiftOperatorWidth) { 6720 EXPECT_EQ("int a = 1 << 2; /* foo\n" 6721 " bar */", 6722 format("int a=1<<2; /* foo\n" 6723 " bar */")); 6724 6725 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 6726 " bar */", 6727 format("int b =256>>1 ; /* foo\n" 6728 " bar */")); 6729 } 6730 6731 TEST_F(FormatTest, UnderstandsBinaryOperators) { 6732 verifyFormat("COMPARE(a, ==, b);"); 6733 verifyFormat("auto s = sizeof...(Ts) - 1;"); 6734 } 6735 6736 TEST_F(FormatTest, UnderstandsPointersToMembers) { 6737 verifyFormat("int A::*x;"); 6738 verifyFormat("int (S::*func)(void *);"); 6739 verifyFormat("void f() { int (S::*func)(void *); }"); 6740 verifyFormat("typedef bool *(Class::*Member)() const;"); 6741 verifyFormat("void f() {\n" 6742 " (a->*f)();\n" 6743 " a->*x;\n" 6744 " (a.*f)();\n" 6745 " ((*a).*f)();\n" 6746 " a.*x;\n" 6747 "}"); 6748 verifyFormat("void f() {\n" 6749 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 6750 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 6751 "}"); 6752 verifyFormat( 6753 "(aaaaaaaaaa->*bbbbbbb)(\n" 6754 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6755 FormatStyle Style = getLLVMStyle(); 6756 Style.PointerAlignment = FormatStyle::PAS_Left; 6757 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 6758 } 6759 6760 TEST_F(FormatTest, UnderstandsUnaryOperators) { 6761 verifyFormat("int a = -2;"); 6762 verifyFormat("f(-1, -2, -3);"); 6763 verifyFormat("a[-1] = 5;"); 6764 verifyFormat("int a = 5 + -2;"); 6765 verifyFormat("if (i == -1) {\n}"); 6766 verifyFormat("if (i != -1) {\n}"); 6767 verifyFormat("if (i > -1) {\n}"); 6768 verifyFormat("if (i < -1) {\n}"); 6769 verifyFormat("++(a->f());"); 6770 verifyFormat("--(a->f());"); 6771 verifyFormat("(a->f())++;"); 6772 verifyFormat("a[42]++;"); 6773 verifyFormat("if (!(a->f())) {\n}"); 6774 verifyFormat("if (!+i) {\n}"); 6775 verifyFormat("~&a;"); 6776 6777 verifyFormat("a-- > b;"); 6778 verifyFormat("b ? -a : c;"); 6779 verifyFormat("n * sizeof char16;"); 6780 verifyFormat("n * alignof char16;", getGoogleStyle()); 6781 verifyFormat("sizeof(char);"); 6782 verifyFormat("alignof(char);", getGoogleStyle()); 6783 6784 verifyFormat("return -1;"); 6785 verifyFormat("switch (a) {\n" 6786 "case -1:\n" 6787 " break;\n" 6788 "}"); 6789 verifyFormat("#define X -1"); 6790 verifyFormat("#define X -kConstant"); 6791 6792 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 6793 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 6794 6795 verifyFormat("int a = /* confusing comment */ -1;"); 6796 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 6797 verifyFormat("int a = i /* confusing comment */++;"); 6798 } 6799 6800 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 6801 verifyFormat("if (!aaaaaaaaaa( // break\n" 6802 " aaaaa)) {\n" 6803 "}"); 6804 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 6805 " aaaaa));"); 6806 verifyFormat("*aaa = aaaaaaa( // break\n" 6807 " bbbbbb);"); 6808 } 6809 6810 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 6811 verifyFormat("bool operator<();"); 6812 verifyFormat("bool operator>();"); 6813 verifyFormat("bool operator=();"); 6814 verifyFormat("bool operator==();"); 6815 verifyFormat("bool operator!=();"); 6816 verifyFormat("int operator+();"); 6817 verifyFormat("int operator++();"); 6818 verifyFormat("int operator++(int) volatile noexcept;"); 6819 verifyFormat("bool operator,();"); 6820 verifyFormat("bool operator();"); 6821 verifyFormat("bool operator()();"); 6822 verifyFormat("bool operator[]();"); 6823 verifyFormat("operator bool();"); 6824 verifyFormat("operator int();"); 6825 verifyFormat("operator void *();"); 6826 verifyFormat("operator SomeType<int>();"); 6827 verifyFormat("operator SomeType<int, int>();"); 6828 verifyFormat("operator SomeType<SomeType<int>>();"); 6829 verifyFormat("void *operator new(std::size_t size);"); 6830 verifyFormat("void *operator new[](std::size_t size);"); 6831 verifyFormat("void operator delete(void *ptr);"); 6832 verifyFormat("void operator delete[](void *ptr);"); 6833 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 6834 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 6835 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 6836 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 6837 6838 verifyFormat( 6839 "ostream &operator<<(ostream &OutputStream,\n" 6840 " SomeReallyLongType WithSomeReallyLongValue);"); 6841 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 6842 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 6843 " return left.group < right.group;\n" 6844 "}"); 6845 verifyFormat("SomeType &operator=(const SomeType &S);"); 6846 verifyFormat("f.template operator()<int>();"); 6847 6848 verifyGoogleFormat("operator void*();"); 6849 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 6850 verifyGoogleFormat("operator ::A();"); 6851 6852 verifyFormat("using A::operator+;"); 6853 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 6854 "int i;"); 6855 } 6856 6857 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 6858 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 6859 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 6860 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 6861 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 6862 verifyFormat("Deleted &operator=(const Deleted &) &;"); 6863 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 6864 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 6865 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 6866 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 6867 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 6868 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 6869 verifyFormat("void Fn(T const &) const &;"); 6870 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 6871 verifyFormat("template <typename T>\n" 6872 "void F(T) && = delete;", 6873 getGoogleStyle()); 6874 6875 FormatStyle AlignLeft = getLLVMStyle(); 6876 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 6877 verifyFormat("void A::b() && {}", AlignLeft); 6878 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 6879 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 6880 AlignLeft); 6881 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 6882 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 6883 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 6884 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 6885 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 6886 verifyFormat("auto Function(T) & -> void;", AlignLeft); 6887 verifyFormat("void Fn(T const&) const&;", AlignLeft); 6888 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 6889 6890 FormatStyle Spaces = getLLVMStyle(); 6891 Spaces.SpacesInCStyleCastParentheses = true; 6892 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 6893 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 6894 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 6895 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 6896 6897 Spaces.SpacesInCStyleCastParentheses = false; 6898 Spaces.SpacesInParentheses = true; 6899 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 6900 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", 6901 Spaces); 6902 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 6903 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 6904 6905 FormatStyle BreakTemplate = getLLVMStyle(); 6906 BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 6907 6908 verifyFormat("struct f {\n" 6909 " template <class T>\n" 6910 " int &foo(const std::string &str) & noexcept {}\n" 6911 "};", 6912 BreakTemplate); 6913 6914 verifyFormat("struct f {\n" 6915 " template <class T>\n" 6916 " int &foo(const std::string &str) && noexcept {}\n" 6917 "};", 6918 BreakTemplate); 6919 6920 verifyFormat("struct f {\n" 6921 " template <class T>\n" 6922 " int &foo(const std::string &str) const & noexcept {}\n" 6923 "};", 6924 BreakTemplate); 6925 6926 verifyFormat("struct f {\n" 6927 " template <class T>\n" 6928 " int &foo(const std::string &str) const & noexcept {}\n" 6929 "};", 6930 BreakTemplate); 6931 6932 verifyFormat("struct f {\n" 6933 " template <class T>\n" 6934 " auto foo(const std::string &str) && noexcept -> int & {}\n" 6935 "};", 6936 BreakTemplate); 6937 6938 FormatStyle AlignLeftBreakTemplate = getLLVMStyle(); 6939 AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations = 6940 FormatStyle::BTDS_Yes; 6941 AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left; 6942 6943 verifyFormat("struct f {\n" 6944 " template <class T>\n" 6945 " int& foo(const std::string& str) & noexcept {}\n" 6946 "};", 6947 AlignLeftBreakTemplate); 6948 6949 verifyFormat("struct f {\n" 6950 " template <class T>\n" 6951 " int& foo(const std::string& str) && noexcept {}\n" 6952 "};", 6953 AlignLeftBreakTemplate); 6954 6955 verifyFormat("struct f {\n" 6956 " template <class T>\n" 6957 " int& foo(const std::string& str) const & noexcept {}\n" 6958 "};", 6959 AlignLeftBreakTemplate); 6960 6961 verifyFormat("struct f {\n" 6962 " template <class T>\n" 6963 " int& foo(const std::string& str) const & noexcept {}\n" 6964 "};", 6965 AlignLeftBreakTemplate); 6966 6967 verifyFormat("struct f {\n" 6968 " template <class T>\n" 6969 " auto foo(const std::string& str) && noexcept -> int& {}\n" 6970 "};", 6971 AlignLeftBreakTemplate); 6972 } 6973 6974 TEST_F(FormatTest, UnderstandsNewAndDelete) { 6975 verifyFormat("void f() {\n" 6976 " A *a = new A;\n" 6977 " A *a = new (placement) A;\n" 6978 " delete a;\n" 6979 " delete (A *)a;\n" 6980 "}"); 6981 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 6982 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 6983 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6984 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 6985 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 6986 verifyFormat("delete[] h->p;"); 6987 } 6988 6989 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 6990 verifyFormat("int *f(int *a) {}"); 6991 verifyFormat("int main(int argc, char **argv) {}"); 6992 verifyFormat("Test::Test(int b) : a(b * b) {}"); 6993 verifyIndependentOfContext("f(a, *a);"); 6994 verifyFormat("void g() { f(*a); }"); 6995 verifyIndependentOfContext("int a = b * 10;"); 6996 verifyIndependentOfContext("int a = 10 * b;"); 6997 verifyIndependentOfContext("int a = b * c;"); 6998 verifyIndependentOfContext("int a += b * c;"); 6999 verifyIndependentOfContext("int a -= b * c;"); 7000 verifyIndependentOfContext("int a *= b * c;"); 7001 verifyIndependentOfContext("int a /= b * c;"); 7002 verifyIndependentOfContext("int a = *b;"); 7003 verifyIndependentOfContext("int a = *b * c;"); 7004 verifyIndependentOfContext("int a = b * *c;"); 7005 verifyIndependentOfContext("int a = b * (10);"); 7006 verifyIndependentOfContext("S << b * (10);"); 7007 verifyIndependentOfContext("return 10 * b;"); 7008 verifyIndependentOfContext("return *b * *c;"); 7009 verifyIndependentOfContext("return a & ~b;"); 7010 verifyIndependentOfContext("f(b ? *c : *d);"); 7011 verifyIndependentOfContext("int a = b ? *c : *d;"); 7012 verifyIndependentOfContext("*b = a;"); 7013 verifyIndependentOfContext("a * ~b;"); 7014 verifyIndependentOfContext("a * !b;"); 7015 verifyIndependentOfContext("a * +b;"); 7016 verifyIndependentOfContext("a * -b;"); 7017 verifyIndependentOfContext("a * ++b;"); 7018 verifyIndependentOfContext("a * --b;"); 7019 verifyIndependentOfContext("a[4] * b;"); 7020 verifyIndependentOfContext("a[a * a] = 1;"); 7021 verifyIndependentOfContext("f() * b;"); 7022 verifyIndependentOfContext("a * [self dostuff];"); 7023 verifyIndependentOfContext("int x = a * (a + b);"); 7024 verifyIndependentOfContext("(a *)(a + b);"); 7025 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 7026 verifyIndependentOfContext("int *pa = (int *)&a;"); 7027 verifyIndependentOfContext("return sizeof(int **);"); 7028 verifyIndependentOfContext("return sizeof(int ******);"); 7029 verifyIndependentOfContext("return (int **&)a;"); 7030 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 7031 verifyFormat("void f(Type (*parameter)[10]) {}"); 7032 verifyFormat("void f(Type (¶meter)[10]) {}"); 7033 verifyGoogleFormat("return sizeof(int**);"); 7034 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 7035 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 7036 verifyFormat("auto a = [](int **&, int ***) {};"); 7037 verifyFormat("auto PointerBinding = [](const char *S) {};"); 7038 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 7039 verifyFormat("[](const decltype(*a) &value) {}"); 7040 verifyFormat("decltype(a * b) F();"); 7041 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 7042 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 7043 verifyIndependentOfContext("typedef void (*f)(int *a);"); 7044 verifyIndependentOfContext("int i{a * b};"); 7045 verifyIndependentOfContext("aaa && aaa->f();"); 7046 verifyIndependentOfContext("int x = ~*p;"); 7047 verifyFormat("Constructor() : a(a), area(width * height) {}"); 7048 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 7049 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 7050 verifyFormat("void f() { f(a, c * d); }"); 7051 verifyFormat("void f() { f(new a(), c * d); }"); 7052 verifyFormat("void f(const MyOverride &override);"); 7053 verifyFormat("void f(const MyFinal &final);"); 7054 verifyIndependentOfContext("bool a = f() && override.f();"); 7055 verifyIndependentOfContext("bool a = f() && final.f();"); 7056 7057 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 7058 7059 verifyIndependentOfContext("A<int *> a;"); 7060 verifyIndependentOfContext("A<int **> a;"); 7061 verifyIndependentOfContext("A<int *, int *> a;"); 7062 verifyIndependentOfContext("A<int *[]> a;"); 7063 verifyIndependentOfContext( 7064 "const char *const p = reinterpret_cast<const char *const>(q);"); 7065 verifyIndependentOfContext("A<int **, int **> a;"); 7066 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 7067 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 7068 verifyFormat("for (; a && b;) {\n}"); 7069 verifyFormat("bool foo = true && [] { return false; }();"); 7070 7071 verifyFormat( 7072 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7073 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7074 7075 verifyGoogleFormat("int const* a = &b;"); 7076 verifyGoogleFormat("**outparam = 1;"); 7077 verifyGoogleFormat("*outparam = a * b;"); 7078 verifyGoogleFormat("int main(int argc, char** argv) {}"); 7079 verifyGoogleFormat("A<int*> a;"); 7080 verifyGoogleFormat("A<int**> a;"); 7081 verifyGoogleFormat("A<int*, int*> a;"); 7082 verifyGoogleFormat("A<int**, int**> a;"); 7083 verifyGoogleFormat("f(b ? *c : *d);"); 7084 verifyGoogleFormat("int a = b ? *c : *d;"); 7085 verifyGoogleFormat("Type* t = **x;"); 7086 verifyGoogleFormat("Type* t = *++*x;"); 7087 verifyGoogleFormat("*++*x;"); 7088 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 7089 verifyGoogleFormat("Type* t = x++ * y;"); 7090 verifyGoogleFormat( 7091 "const char* const p = reinterpret_cast<const char* const>(q);"); 7092 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 7093 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 7094 verifyGoogleFormat("template <typename T>\n" 7095 "void f(int i = 0, SomeType** temps = NULL);"); 7096 7097 FormatStyle Left = getLLVMStyle(); 7098 Left.PointerAlignment = FormatStyle::PAS_Left; 7099 verifyFormat("x = *a(x) = *a(y);", Left); 7100 verifyFormat("for (;; *a = b) {\n}", Left); 7101 verifyFormat("return *this += 1;", Left); 7102 verifyFormat("throw *x;", Left); 7103 verifyFormat("delete *x;", Left); 7104 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 7105 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 7106 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 7107 7108 verifyIndependentOfContext("a = *(x + y);"); 7109 verifyIndependentOfContext("a = &(x + y);"); 7110 verifyIndependentOfContext("*(x + y).call();"); 7111 verifyIndependentOfContext("&(x + y)->call();"); 7112 verifyFormat("void f() { &(*I).first; }"); 7113 7114 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 7115 verifyFormat( 7116 "int *MyValues = {\n" 7117 " *A, // Operator detection might be confused by the '{'\n" 7118 " *BB // Operator detection might be confused by previous comment\n" 7119 "};"); 7120 7121 verifyIndependentOfContext("if (int *a = &b)"); 7122 verifyIndependentOfContext("if (int &a = *b)"); 7123 verifyIndependentOfContext("if (a & b[i])"); 7124 verifyIndependentOfContext("if constexpr (a & b[i])"); 7125 verifyIndependentOfContext("if CONSTEXPR (a & b[i])"); 7126 verifyIndependentOfContext("if (a * (b * c))"); 7127 verifyIndependentOfContext("if constexpr (a * (b * c))"); 7128 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))"); 7129 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 7130 verifyIndependentOfContext("if (*b[i])"); 7131 verifyIndependentOfContext("if (int *a = (&b))"); 7132 verifyIndependentOfContext("while (int *a = &b)"); 7133 verifyIndependentOfContext("while (a * (b * c))"); 7134 verifyIndependentOfContext("size = sizeof *a;"); 7135 verifyIndependentOfContext("if (a && (b = c))"); 7136 verifyFormat("void f() {\n" 7137 " for (const int &v : Values) {\n" 7138 " }\n" 7139 "}"); 7140 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 7141 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 7142 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 7143 7144 verifyFormat("#define A (!a * b)"); 7145 verifyFormat("#define MACRO \\\n" 7146 " int *i = a * b; \\\n" 7147 " void f(a *b);", 7148 getLLVMStyleWithColumns(19)); 7149 7150 verifyIndependentOfContext("A = new SomeType *[Length];"); 7151 verifyIndependentOfContext("A = new SomeType *[Length]();"); 7152 verifyIndependentOfContext("T **t = new T *;"); 7153 verifyIndependentOfContext("T **t = new T *();"); 7154 verifyGoogleFormat("A = new SomeType*[Length]();"); 7155 verifyGoogleFormat("A = new SomeType*[Length];"); 7156 verifyGoogleFormat("T** t = new T*;"); 7157 verifyGoogleFormat("T** t = new T*();"); 7158 7159 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 7160 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 7161 verifyFormat("template <bool a, bool b> " 7162 "typename t::if<x && y>::type f() {}"); 7163 verifyFormat("template <int *y> f() {}"); 7164 verifyFormat("vector<int *> v;"); 7165 verifyFormat("vector<int *const> v;"); 7166 verifyFormat("vector<int *const **const *> v;"); 7167 verifyFormat("vector<int *volatile> v;"); 7168 verifyFormat("vector<a * b> v;"); 7169 verifyFormat("foo<b && false>();"); 7170 verifyFormat("foo<b & 1>();"); 7171 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 7172 verifyFormat( 7173 "template <class T, class = typename std::enable_if<\n" 7174 " std::is_integral<T>::value &&\n" 7175 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 7176 "void F();", 7177 getLLVMStyleWithColumns(70)); 7178 verifyFormat("template <class T,\n" 7179 " class = typename std::enable_if<\n" 7180 " std::is_integral<T>::value &&\n" 7181 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 7182 " class U>\n" 7183 "void F();", 7184 getLLVMStyleWithColumns(70)); 7185 verifyFormat( 7186 "template <class T,\n" 7187 " class = typename ::std::enable_if<\n" 7188 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 7189 "void F();", 7190 getGoogleStyleWithColumns(68)); 7191 7192 verifyIndependentOfContext("MACRO(int *i);"); 7193 verifyIndependentOfContext("MACRO(auto *a);"); 7194 verifyIndependentOfContext("MACRO(const A *a);"); 7195 verifyIndependentOfContext("MACRO(A *const a);"); 7196 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 7197 verifyFormat("void f() { f(float{1}, a * a); }"); 7198 // FIXME: Is there a way to make this work? 7199 // verifyIndependentOfContext("MACRO(A *a);"); 7200 7201 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 7202 verifyFormat("return options != nullptr && operator==(*options);"); 7203 7204 EXPECT_EQ("#define OP(x) \\\n" 7205 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7206 " return s << a.DebugString(); \\\n" 7207 " }", 7208 format("#define OP(x) \\\n" 7209 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7210 " return s << a.DebugString(); \\\n" 7211 " }", 7212 getLLVMStyleWithColumns(50))); 7213 7214 // FIXME: We cannot handle this case yet; we might be able to figure out that 7215 // foo<x> d > v; doesn't make sense. 7216 verifyFormat("foo<a<b && c> d> v;"); 7217 7218 FormatStyle PointerMiddle = getLLVMStyle(); 7219 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7220 verifyFormat("delete *x;", PointerMiddle); 7221 verifyFormat("int * x;", PointerMiddle); 7222 verifyFormat("int *[] x;", PointerMiddle); 7223 verifyFormat("template <int * y> f() {}", PointerMiddle); 7224 verifyFormat("int * f(int * a) {}", PointerMiddle); 7225 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7226 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7227 verifyFormat("A<int *> a;", PointerMiddle); 7228 verifyFormat("A<int **> a;", PointerMiddle); 7229 verifyFormat("A<int *, int *> a;", PointerMiddle); 7230 verifyFormat("A<int *[]> a;", PointerMiddle); 7231 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7232 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7233 verifyFormat("T ** t = new T *;", PointerMiddle); 7234 7235 // Member function reference qualifiers aren't binary operators. 7236 verifyFormat("string // break\n" 7237 "operator()() & {}"); 7238 verifyFormat("string // break\n" 7239 "operator()() && {}"); 7240 verifyGoogleFormat("template <typename T>\n" 7241 "auto x() & -> int {}"); 7242 } 7243 7244 TEST_F(FormatTest, UnderstandsAttributes) { 7245 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7246 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7247 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7248 FormatStyle AfterType = getLLVMStyle(); 7249 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7250 verifyFormat("__attribute__((nodebug)) void\n" 7251 "foo() {}\n", 7252 AfterType); 7253 } 7254 7255 TEST_F(FormatTest, UnderstandsSquareAttributes) { 7256 verifyFormat("SomeType s [[unused]] (InitValue);"); 7257 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 7258 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 7259 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 7260 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 7261 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7262 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7263 7264 // Make sure we do not mistake attributes for array subscripts. 7265 verifyFormat("int a() {}\n" 7266 "[[unused]] int b() {}\n"); 7267 verifyFormat("NSArray *arr;\n" 7268 "arr[[Foo() bar]];"); 7269 7270 // On the other hand, we still need to correctly find array subscripts. 7271 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 7272 7273 // Make sure that we do not mistake Objective-C method inside array literals 7274 // as attributes, even if those method names are also keywords. 7275 verifyFormat("@[ [foo bar] ];"); 7276 verifyFormat("@[ [NSArray class] ];"); 7277 verifyFormat("@[ [foo enum] ];"); 7278 7279 // Make sure we do not parse attributes as lambda introducers. 7280 FormatStyle MultiLineFunctions = getLLVMStyle(); 7281 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7282 verifyFormat("[[unused]] int b() {\n" 7283 " return 42;\n" 7284 "}\n", 7285 MultiLineFunctions); 7286 } 7287 7288 TEST_F(FormatTest, UnderstandsEllipsis) { 7289 verifyFormat("int printf(const char *fmt, ...);"); 7290 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 7291 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 7292 7293 FormatStyle PointersLeft = getLLVMStyle(); 7294 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 7295 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 7296 } 7297 7298 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 7299 EXPECT_EQ("int *a;\n" 7300 "int *a;\n" 7301 "int *a;", 7302 format("int *a;\n" 7303 "int* a;\n" 7304 "int *a;", 7305 getGoogleStyle())); 7306 EXPECT_EQ("int* a;\n" 7307 "int* a;\n" 7308 "int* a;", 7309 format("int* a;\n" 7310 "int* a;\n" 7311 "int *a;", 7312 getGoogleStyle())); 7313 EXPECT_EQ("int *a;\n" 7314 "int *a;\n" 7315 "int *a;", 7316 format("int *a;\n" 7317 "int * a;\n" 7318 "int * a;", 7319 getGoogleStyle())); 7320 EXPECT_EQ("auto x = [] {\n" 7321 " int *a;\n" 7322 " int *a;\n" 7323 " int *a;\n" 7324 "};", 7325 format("auto x=[]{int *a;\n" 7326 "int * a;\n" 7327 "int * a;};", 7328 getGoogleStyle())); 7329 } 7330 7331 TEST_F(FormatTest, UnderstandsRvalueReferences) { 7332 verifyFormat("int f(int &&a) {}"); 7333 verifyFormat("int f(int a, char &&b) {}"); 7334 verifyFormat("void f() { int &&a = b; }"); 7335 verifyGoogleFormat("int f(int a, char&& b) {}"); 7336 verifyGoogleFormat("void f() { int&& a = b; }"); 7337 7338 verifyIndependentOfContext("A<int &&> a;"); 7339 verifyIndependentOfContext("A<int &&, int &&> a;"); 7340 verifyGoogleFormat("A<int&&> a;"); 7341 verifyGoogleFormat("A<int&&, int&&> a;"); 7342 7343 // Not rvalue references: 7344 verifyFormat("template <bool B, bool C> class A {\n" 7345 " static_assert(B && C, \"Something is wrong\");\n" 7346 "};"); 7347 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 7348 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 7349 verifyFormat("#define A(a, b) (a && b)"); 7350 } 7351 7352 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 7353 verifyFormat("void f() {\n" 7354 " x[aaaaaaaaa -\n" 7355 " b] = 23;\n" 7356 "}", 7357 getLLVMStyleWithColumns(15)); 7358 } 7359 7360 TEST_F(FormatTest, FormatsCasts) { 7361 verifyFormat("Type *A = static_cast<Type *>(P);"); 7362 verifyFormat("Type *A = (Type *)P;"); 7363 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7364 verifyFormat("int a = (int)(2.0f);"); 7365 verifyFormat("int a = (int)2.0f;"); 7366 verifyFormat("x[(int32)y];"); 7367 verifyFormat("x = (int32)y;"); 7368 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7369 verifyFormat("int a = (int)*b;"); 7370 verifyFormat("int a = (int)2.0f;"); 7371 verifyFormat("int a = (int)~0;"); 7372 verifyFormat("int a = (int)++a;"); 7373 verifyFormat("int a = (int)sizeof(int);"); 7374 verifyFormat("int a = (int)+2;"); 7375 verifyFormat("my_int a = (my_int)2.0f;"); 7376 verifyFormat("my_int a = (my_int)sizeof(int);"); 7377 verifyFormat("return (my_int)aaa;"); 7378 verifyFormat("#define x ((int)-1)"); 7379 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7380 verifyFormat("#define p(q) ((int *)&q)"); 7381 verifyFormat("fn(a)(b) + 1;"); 7382 7383 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7384 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7385 verifyFormat("my_int a = (my_int)~0;"); 7386 verifyFormat("my_int a = (my_int)++a;"); 7387 verifyFormat("my_int a = (my_int)-2;"); 7388 verifyFormat("my_int a = (my_int)1;"); 7389 verifyFormat("my_int a = (my_int *)1;"); 7390 verifyFormat("my_int a = (const my_int)-1;"); 7391 verifyFormat("my_int a = (const my_int *)-1;"); 7392 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7393 verifyFormat("my_int a = (ns::my_int)-2;"); 7394 verifyFormat("case (my_int)ONE:"); 7395 verifyFormat("auto x = (X)this;"); 7396 7397 // FIXME: single value wrapped with paren will be treated as cast. 7398 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7399 7400 verifyFormat("{ (void)F; }"); 7401 7402 // Don't break after a cast's 7403 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7404 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7405 " bbbbbbbbbbbbbbbbbbbbbb);"); 7406 7407 // These are not casts. 7408 verifyFormat("void f(int *) {}"); 7409 verifyFormat("f(foo)->b;"); 7410 verifyFormat("f(foo).b;"); 7411 verifyFormat("f(foo)(b);"); 7412 verifyFormat("f(foo)[b];"); 7413 verifyFormat("[](foo) { return 4; }(bar);"); 7414 verifyFormat("(*funptr)(foo)[4];"); 7415 verifyFormat("funptrs[4](foo)[4];"); 7416 verifyFormat("void f(int *);"); 7417 verifyFormat("void f(int *) = 0;"); 7418 verifyFormat("void f(SmallVector<int>) {}"); 7419 verifyFormat("void f(SmallVector<int>);"); 7420 verifyFormat("void f(SmallVector<int>) = 0;"); 7421 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7422 verifyFormat("int a = sizeof(int) * b;"); 7423 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7424 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7425 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7426 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7427 7428 // These are not casts, but at some point were confused with casts. 7429 verifyFormat("virtual void foo(int *) override;"); 7430 verifyFormat("virtual void foo(char &) const;"); 7431 verifyFormat("virtual void foo(int *a, char *) const;"); 7432 verifyFormat("int a = sizeof(int *) + b;"); 7433 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7434 verifyFormat("bool b = f(g<int>) && c;"); 7435 verifyFormat("typedef void (*f)(int i) func;"); 7436 7437 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7438 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7439 // FIXME: The indentation here is not ideal. 7440 verifyFormat( 7441 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7442 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7443 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7444 } 7445 7446 TEST_F(FormatTest, FormatsFunctionTypes) { 7447 verifyFormat("A<bool()> a;"); 7448 verifyFormat("A<SomeType()> a;"); 7449 verifyFormat("A<void (*)(int, std::string)> a;"); 7450 verifyFormat("A<void *(int)>;"); 7451 verifyFormat("void *(*a)(int *, SomeType *);"); 7452 verifyFormat("int (*func)(void *);"); 7453 verifyFormat("void f() { int (*func)(void *); }"); 7454 verifyFormat("template <class CallbackClass>\n" 7455 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7456 7457 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7458 verifyGoogleFormat("void* (*a)(int);"); 7459 verifyGoogleFormat( 7460 "template <class CallbackClass>\n" 7461 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7462 7463 // Other constructs can look somewhat like function types: 7464 verifyFormat("A<sizeof(*x)> a;"); 7465 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7466 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7467 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7468 verifyFormat("int x = f(&h)();"); 7469 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7470 verifyFormat("std::function<\n" 7471 " LooooooooooongTemplatedType<\n" 7472 " SomeType>*(\n" 7473 " LooooooooooooooooongType type)>\n" 7474 " function;", 7475 getGoogleStyleWithColumns(40)); 7476 } 7477 7478 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7479 verifyFormat("A (*foo_)[6];"); 7480 verifyFormat("vector<int> (*foo_)[6];"); 7481 } 7482 7483 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7484 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7485 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7486 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7487 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7488 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7489 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7490 7491 // Different ways of ()-initializiation. 7492 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7493 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7494 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7495 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7496 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7497 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7498 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7499 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7500 7501 // Lambdas should not confuse the variable declaration heuristic. 7502 verifyFormat("LooooooooooooooooongType\n" 7503 " variable(nullptr, [](A *a) {});", 7504 getLLVMStyleWithColumns(40)); 7505 } 7506 7507 TEST_F(FormatTest, BreaksLongDeclarations) { 7508 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7509 " AnotherNameForTheLongType;"); 7510 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7511 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7512 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7513 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7514 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7515 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7516 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7517 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7518 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7519 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7520 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7521 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7522 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7523 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7524 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7525 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7526 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7527 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7528 FormatStyle Indented = getLLVMStyle(); 7529 Indented.IndentWrappedFunctionNames = true; 7530 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7531 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7532 Indented); 7533 verifyFormat( 7534 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7535 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7536 Indented); 7537 verifyFormat( 7538 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7539 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7540 Indented); 7541 verifyFormat( 7542 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7543 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7544 Indented); 7545 7546 // FIXME: Without the comment, this breaks after "(". 7547 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7548 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7549 getGoogleStyle()); 7550 7551 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7552 " int LoooooooooooooooooooongParam2) {}"); 7553 verifyFormat( 7554 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7555 " SourceLocation L, IdentifierIn *II,\n" 7556 " Type *T) {}"); 7557 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7558 "ReallyReaaallyLongFunctionName(\n" 7559 " const std::string &SomeParameter,\n" 7560 " const SomeType<string, SomeOtherTemplateParameter>\n" 7561 " &ReallyReallyLongParameterName,\n" 7562 " const SomeType<string, SomeOtherTemplateParameter>\n" 7563 " &AnotherLongParameterName) {}"); 7564 verifyFormat("template <typename A>\n" 7565 "SomeLoooooooooooooooooooooongType<\n" 7566 " typename some_namespace::SomeOtherType<A>::Type>\n" 7567 "Function() {}"); 7568 7569 verifyGoogleFormat( 7570 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7571 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7572 verifyGoogleFormat( 7573 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7574 " SourceLocation L) {}"); 7575 verifyGoogleFormat( 7576 "some_namespace::LongReturnType\n" 7577 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7578 " int first_long_parameter, int second_parameter) {}"); 7579 7580 verifyGoogleFormat("template <typename T>\n" 7581 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7582 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7583 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7584 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7585 7586 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7587 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7588 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7589 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7590 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7591 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 7592 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7593 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 7594 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 7595 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7596 7597 verifyFormat("template <typename T> // Templates on own line.\n" 7598 "static int // Some comment.\n" 7599 "MyFunction(int a);", 7600 getLLVMStyle()); 7601 } 7602 7603 TEST_F(FormatTest, FormatsArrays) { 7604 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7605 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 7606 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 7607 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 7608 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 7609 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 7610 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7611 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7612 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7613 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 7614 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7615 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7616 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7617 verifyFormat( 7618 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 7619 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7620 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 7621 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 7622 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7623 7624 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 7625 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 7626 verifyFormat( 7627 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 7628 " .aaaaaaa[0]\n" 7629 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7630 verifyFormat("a[::b::c];"); 7631 7632 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 7633 7634 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 7635 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 7636 } 7637 7638 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 7639 verifyFormat("(a)->b();"); 7640 verifyFormat("--a;"); 7641 } 7642 7643 TEST_F(FormatTest, HandlesIncludeDirectives) { 7644 verifyFormat("#include <string>\n" 7645 "#include <a/b/c.h>\n" 7646 "#include \"a/b/string\"\n" 7647 "#include \"string.h\"\n" 7648 "#include \"string.h\"\n" 7649 "#include <a-a>\n" 7650 "#include < path with space >\n" 7651 "#include_next <test.h>" 7652 "#include \"abc.h\" // this is included for ABC\n" 7653 "#include \"some long include\" // with a comment\n" 7654 "#include \"some very long include path\"\n" 7655 "#include <some/very/long/include/path>\n", 7656 getLLVMStyleWithColumns(35)); 7657 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 7658 EXPECT_EQ("#include <a>", format("#include<a>")); 7659 7660 verifyFormat("#import <string>"); 7661 verifyFormat("#import <a/b/c.h>"); 7662 verifyFormat("#import \"a/b/string\""); 7663 verifyFormat("#import \"string.h\""); 7664 verifyFormat("#import \"string.h\""); 7665 verifyFormat("#if __has_include(<strstream>)\n" 7666 "#include <strstream>\n" 7667 "#endif"); 7668 7669 verifyFormat("#define MY_IMPORT <a/b>"); 7670 7671 verifyFormat("#if __has_include(<a/b>)"); 7672 verifyFormat("#if __has_include_next(<a/b>)"); 7673 verifyFormat("#define F __has_include(<a/b>)"); 7674 verifyFormat("#define F __has_include_next(<a/b>)"); 7675 7676 // Protocol buffer definition or missing "#". 7677 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 7678 getLLVMStyleWithColumns(30)); 7679 7680 FormatStyle Style = getLLVMStyle(); 7681 Style.AlwaysBreakBeforeMultilineStrings = true; 7682 Style.ColumnLimit = 0; 7683 verifyFormat("#import \"abc.h\"", Style); 7684 7685 // But 'import' might also be a regular C++ namespace. 7686 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7687 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7688 } 7689 7690 //===----------------------------------------------------------------------===// 7691 // Error recovery tests. 7692 //===----------------------------------------------------------------------===// 7693 7694 TEST_F(FormatTest, IncompleteParameterLists) { 7695 FormatStyle NoBinPacking = getLLVMStyle(); 7696 NoBinPacking.BinPackParameters = false; 7697 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 7698 " double *min_x,\n" 7699 " double *max_x,\n" 7700 " double *min_y,\n" 7701 " double *max_y,\n" 7702 " double *min_z,\n" 7703 " double *max_z, ) {}", 7704 NoBinPacking); 7705 } 7706 7707 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 7708 verifyFormat("void f() { return; }\n42"); 7709 verifyFormat("void f() {\n" 7710 " if (0)\n" 7711 " return;\n" 7712 "}\n" 7713 "42"); 7714 verifyFormat("void f() { return }\n42"); 7715 verifyFormat("void f() {\n" 7716 " if (0)\n" 7717 " return\n" 7718 "}\n" 7719 "42"); 7720 } 7721 7722 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 7723 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 7724 EXPECT_EQ("void f() {\n" 7725 " if (a)\n" 7726 " return\n" 7727 "}", 7728 format("void f ( ) { if ( a ) return }")); 7729 EXPECT_EQ("namespace N {\n" 7730 "void f()\n" 7731 "}", 7732 format("namespace N { void f() }")); 7733 EXPECT_EQ("namespace N {\n" 7734 "void f() {}\n" 7735 "void g()\n" 7736 "} // namespace N", 7737 format("namespace N { void f( ) { } void g( ) }")); 7738 } 7739 7740 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 7741 verifyFormat("int aaaaaaaa =\n" 7742 " // Overlylongcomment\n" 7743 " b;", 7744 getLLVMStyleWithColumns(20)); 7745 verifyFormat("function(\n" 7746 " ShortArgument,\n" 7747 " LoooooooooooongArgument);\n", 7748 getLLVMStyleWithColumns(20)); 7749 } 7750 7751 TEST_F(FormatTest, IncorrectAccessSpecifier) { 7752 verifyFormat("public:"); 7753 verifyFormat("class A {\n" 7754 "public\n" 7755 " void f() {}\n" 7756 "};"); 7757 verifyFormat("public\n" 7758 "int qwerty;"); 7759 verifyFormat("public\n" 7760 "B {}"); 7761 verifyFormat("public\n" 7762 "{}"); 7763 verifyFormat("public\n" 7764 "B { int x; }"); 7765 } 7766 7767 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 7768 verifyFormat("{"); 7769 verifyFormat("#})"); 7770 verifyNoCrash("(/**/[:!] ?[)."); 7771 } 7772 7773 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 7774 // Found by oss-fuzz: 7775 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 7776 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 7777 Style.ColumnLimit = 60; 7778 verifyNoCrash( 7779 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 7780 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 7781 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 7782 Style); 7783 } 7784 7785 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 7786 verifyFormat("do {\n}"); 7787 verifyFormat("do {\n}\n" 7788 "f();"); 7789 verifyFormat("do {\n}\n" 7790 "wheeee(fun);"); 7791 verifyFormat("do {\n" 7792 " f();\n" 7793 "}"); 7794 } 7795 7796 TEST_F(FormatTest, IncorrectCodeMissingParens) { 7797 verifyFormat("if {\n foo;\n foo();\n}"); 7798 verifyFormat("switch {\n foo;\n foo();\n}"); 7799 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 7800 verifyFormat("while {\n foo;\n foo();\n}"); 7801 verifyFormat("do {\n foo;\n foo();\n} while;"); 7802 } 7803 7804 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 7805 verifyIncompleteFormat("namespace {\n" 7806 "class Foo { Foo (\n" 7807 "};\n" 7808 "} // namespace"); 7809 } 7810 7811 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 7812 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 7813 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 7814 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 7815 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 7816 7817 EXPECT_EQ("{\n" 7818 " {\n" 7819 " breakme(\n" 7820 " qwe);\n" 7821 " }\n", 7822 format("{\n" 7823 " {\n" 7824 " breakme(qwe);\n" 7825 "}\n", 7826 getLLVMStyleWithColumns(10))); 7827 } 7828 7829 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 7830 verifyFormat("int x = {\n" 7831 " avariable,\n" 7832 " b(alongervariable)};", 7833 getLLVMStyleWithColumns(25)); 7834 } 7835 7836 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 7837 verifyFormat("return (a)(b){1, 2, 3};"); 7838 } 7839 7840 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 7841 verifyFormat("vector<int> x{1, 2, 3, 4};"); 7842 verifyFormat("vector<int> x{\n" 7843 " 1,\n" 7844 " 2,\n" 7845 " 3,\n" 7846 " 4,\n" 7847 "};"); 7848 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 7849 verifyFormat("f({1, 2});"); 7850 verifyFormat("auto v = Foo{-1};"); 7851 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 7852 verifyFormat("Class::Class : member{1, 2, 3} {}"); 7853 verifyFormat("new vector<int>{1, 2, 3};"); 7854 verifyFormat("new int[3]{1, 2, 3};"); 7855 verifyFormat("new int{1};"); 7856 verifyFormat("return {arg1, arg2};"); 7857 verifyFormat("return {arg1, SomeType{parameter}};"); 7858 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 7859 verifyFormat("new T{arg1, arg2};"); 7860 verifyFormat("f(MyMap[{composite, key}]);"); 7861 verifyFormat("class Class {\n" 7862 " T member = {arg1, arg2};\n" 7863 "};"); 7864 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 7865 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 7866 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 7867 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 7868 verifyFormat("int a = std::is_integral<int>{} + 0;"); 7869 7870 verifyFormat("int foo(int i) { return fo1{}(i); }"); 7871 verifyFormat("int foo(int i) { return fo1{}(i); }"); 7872 verifyFormat("auto i = decltype(x){};"); 7873 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 7874 verifyFormat("Node n{1, Node{1000}, //\n" 7875 " 2};"); 7876 verifyFormat("Aaaa aaaaaaa{\n" 7877 " {\n" 7878 " aaaa,\n" 7879 " },\n" 7880 "};"); 7881 verifyFormat("class C : public D {\n" 7882 " SomeClass SC{2};\n" 7883 "};"); 7884 verifyFormat("class C : public A {\n" 7885 " class D : public B {\n" 7886 " void f() { int i{2}; }\n" 7887 " };\n" 7888 "};"); 7889 verifyFormat("#define A {a, a},"); 7890 7891 // Avoid breaking between equal sign and opening brace 7892 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 7893 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 7894 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 7895 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 7896 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 7897 " {\"ccccccccccccccccccccc\", 2}};", 7898 AvoidBreakingFirstArgument); 7899 7900 // Binpacking only if there is no trailing comma 7901 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 7902 " cccccccccc, dddddddddd};", 7903 getLLVMStyleWithColumns(50)); 7904 verifyFormat("const Aaaaaa aaaaa = {\n" 7905 " aaaaaaaaaaa,\n" 7906 " bbbbbbbbbbb,\n" 7907 " ccccccccccc,\n" 7908 " ddddddddddd,\n" 7909 "};", 7910 getLLVMStyleWithColumns(50)); 7911 7912 // Cases where distinguising braced lists and blocks is hard. 7913 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 7914 verifyFormat("void f() {\n" 7915 " return; // comment\n" 7916 "}\n" 7917 "SomeType t;"); 7918 verifyFormat("void f() {\n" 7919 " if (a) {\n" 7920 " f();\n" 7921 " }\n" 7922 "}\n" 7923 "SomeType t;"); 7924 7925 // In combination with BinPackArguments = false. 7926 FormatStyle NoBinPacking = getLLVMStyle(); 7927 NoBinPacking.BinPackArguments = false; 7928 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 7929 " bbbbb,\n" 7930 " ccccc,\n" 7931 " ddddd,\n" 7932 " eeeee,\n" 7933 " ffffff,\n" 7934 " ggggg,\n" 7935 " hhhhhh,\n" 7936 " iiiiii,\n" 7937 " jjjjjj,\n" 7938 " kkkkkk};", 7939 NoBinPacking); 7940 verifyFormat("const Aaaaaa aaaaa = {\n" 7941 " aaaaa,\n" 7942 " bbbbb,\n" 7943 " ccccc,\n" 7944 " ddddd,\n" 7945 " eeeee,\n" 7946 " ffffff,\n" 7947 " ggggg,\n" 7948 " hhhhhh,\n" 7949 " iiiiii,\n" 7950 " jjjjjj,\n" 7951 " kkkkkk,\n" 7952 "};", 7953 NoBinPacking); 7954 verifyFormat( 7955 "const Aaaaaa aaaaa = {\n" 7956 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 7957 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 7958 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 7959 "};", 7960 NoBinPacking); 7961 7962 NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 7963 EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n" 7964 " CDDDP83848_BMCR_REGISTER,\n" 7965 " CDDDP83848_BMSR_REGISTER,\n" 7966 " CDDDP83848_RBR_REGISTER};", 7967 format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n" 7968 " CDDDP83848_BMSR_REGISTER,\n" 7969 " CDDDP83848_RBR_REGISTER};", 7970 NoBinPacking)); 7971 7972 // FIXME: The alignment of these trailing comments might be bad. Then again, 7973 // this might be utterly useless in real code. 7974 verifyFormat("Constructor::Constructor()\n" 7975 " : some_value{ //\n" 7976 " aaaaaaa, //\n" 7977 " bbbbbbb} {}"); 7978 7979 // In braced lists, the first comment is always assumed to belong to the 7980 // first element. Thus, it can be moved to the next or previous line as 7981 // appropriate. 7982 EXPECT_EQ("function({// First element:\n" 7983 " 1,\n" 7984 " // Second element:\n" 7985 " 2});", 7986 format("function({\n" 7987 " // First element:\n" 7988 " 1,\n" 7989 " // Second element:\n" 7990 " 2});")); 7991 EXPECT_EQ("std::vector<int> MyNumbers{\n" 7992 " // First element:\n" 7993 " 1,\n" 7994 " // Second element:\n" 7995 " 2};", 7996 format("std::vector<int> MyNumbers{// First element:\n" 7997 " 1,\n" 7998 " // Second element:\n" 7999 " 2};", 8000 getLLVMStyleWithColumns(30))); 8001 // A trailing comma should still lead to an enforced line break and no 8002 // binpacking. 8003 EXPECT_EQ("vector<int> SomeVector = {\n" 8004 " // aaa\n" 8005 " 1,\n" 8006 " 2,\n" 8007 "};", 8008 format("vector<int> SomeVector = { // aaa\n" 8009 " 1, 2, };")); 8010 8011 FormatStyle ExtraSpaces = getLLVMStyle(); 8012 ExtraSpaces.Cpp11BracedListStyle = false; 8013 ExtraSpaces.ColumnLimit = 75; 8014 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 8015 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 8016 verifyFormat("f({ 1, 2 });", ExtraSpaces); 8017 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 8018 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 8019 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 8020 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 8021 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 8022 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 8023 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 8024 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 8025 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 8026 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 8027 verifyFormat("class Class {\n" 8028 " T member = { arg1, arg2 };\n" 8029 "};", 8030 ExtraSpaces); 8031 verifyFormat( 8032 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8033 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 8034 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 8035 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 8036 ExtraSpaces); 8037 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 8038 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 8039 ExtraSpaces); 8040 verifyFormat( 8041 "someFunction(OtherParam,\n" 8042 " BracedList{ // comment 1 (Forcing interesting break)\n" 8043 " param1, param2,\n" 8044 " // comment 2\n" 8045 " param3, param4 });", 8046 ExtraSpaces); 8047 verifyFormat( 8048 "std::this_thread::sleep_for(\n" 8049 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 8050 ExtraSpaces); 8051 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 8052 " aaaaaaa,\n" 8053 " aaaaaaaaaa,\n" 8054 " aaaaa,\n" 8055 " aaaaaaaaaaaaaaa,\n" 8056 " aaa,\n" 8057 " aaaaaaaaaa,\n" 8058 " a,\n" 8059 " aaaaaaaaaaaaaaaaaaaaa,\n" 8060 " aaaaaaaaaaaa,\n" 8061 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 8062 " aaaaaaa,\n" 8063 " a};"); 8064 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 8065 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 8066 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 8067 8068 // Avoid breaking between initializer/equal sign and opening brace 8069 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 8070 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 8071 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8072 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8073 " { \"ccccccccccccccccccccc\", 2 }\n" 8074 "};", 8075 ExtraSpaces); 8076 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 8077 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8078 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8079 " { \"ccccccccccccccccccccc\", 2 }\n" 8080 "};", 8081 ExtraSpaces); 8082 8083 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 8084 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 8085 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 8086 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 8087 } 8088 8089 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 8090 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8091 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8092 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8093 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8094 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8095 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8096 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 8097 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8098 " 1, 22, 333, 4444, 55555, //\n" 8099 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8100 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8101 verifyFormat( 8102 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8103 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8104 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 8105 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8106 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8107 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8108 " 7777777};"); 8109 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8110 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8111 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8112 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8113 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8114 " // Separating comment.\n" 8115 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8116 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8117 " // Leading comment\n" 8118 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8119 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8120 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8121 " 1, 1, 1, 1};", 8122 getLLVMStyleWithColumns(39)); 8123 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8124 " 1, 1, 1, 1};", 8125 getLLVMStyleWithColumns(38)); 8126 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 8127 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 8128 getLLVMStyleWithColumns(43)); 8129 verifyFormat( 8130 "static unsigned SomeValues[10][3] = {\n" 8131 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 8132 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 8133 verifyFormat("static auto fields = new vector<string>{\n" 8134 " \"aaaaaaaaaaaaa\",\n" 8135 " \"aaaaaaaaaaaaa\",\n" 8136 " \"aaaaaaaaaaaa\",\n" 8137 " \"aaaaaaaaaaaaaa\",\n" 8138 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8139 " \"aaaaaaaaaaaa\",\n" 8140 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8141 "};"); 8142 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 8143 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 8144 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 8145 " 3, cccccccccccccccccccccc};", 8146 getLLVMStyleWithColumns(60)); 8147 8148 // Trailing commas. 8149 verifyFormat("vector<int> x = {\n" 8150 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 8151 "};", 8152 getLLVMStyleWithColumns(39)); 8153 verifyFormat("vector<int> x = {\n" 8154 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 8155 "};", 8156 getLLVMStyleWithColumns(39)); 8157 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8158 " 1, 1, 1, 1,\n" 8159 " /**/ /**/};", 8160 getLLVMStyleWithColumns(39)); 8161 8162 // Trailing comment in the first line. 8163 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 8164 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 8165 " 111111111, 222222222, 3333333333, 444444444, //\n" 8166 " 11111111, 22222222, 333333333, 44444444};"); 8167 // Trailing comment in the last line. 8168 verifyFormat("int aaaaa[] = {\n" 8169 " 1, 2, 3, // comment\n" 8170 " 4, 5, 6 // comment\n" 8171 "};"); 8172 8173 // With nested lists, we should either format one item per line or all nested 8174 // lists one on line. 8175 // FIXME: For some nested lists, we can do better. 8176 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 8177 " {aaaaaaaaaaaaaaaaaaa},\n" 8178 " {aaaaaaaaaaaaaaaaaaaaa},\n" 8179 " {aaaaaaaaaaaaaaaaa}};", 8180 getLLVMStyleWithColumns(60)); 8181 verifyFormat( 8182 "SomeStruct my_struct_array = {\n" 8183 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 8184 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 8185 " {aaa, aaa},\n" 8186 " {aaa, aaa},\n" 8187 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 8188 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 8189 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 8190 8191 // No column layout should be used here. 8192 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 8193 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 8194 8195 verifyNoCrash("a<,"); 8196 8197 // No braced initializer here. 8198 verifyFormat("void f() {\n" 8199 " struct Dummy {};\n" 8200 " f(v);\n" 8201 "}"); 8202 8203 // Long lists should be formatted in columns even if they are nested. 8204 verifyFormat( 8205 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8206 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8207 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8208 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8209 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8210 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 8211 8212 // Allow "single-column" layout even if that violates the column limit. There 8213 // isn't going to be a better way. 8214 verifyFormat("std::vector<int> a = {\n" 8215 " aaaaaaaa,\n" 8216 " aaaaaaaa,\n" 8217 " aaaaaaaa,\n" 8218 " aaaaaaaa,\n" 8219 " aaaaaaaaaa,\n" 8220 " aaaaaaaa,\n" 8221 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 8222 getLLVMStyleWithColumns(30)); 8223 verifyFormat("vector<int> aaaa = {\n" 8224 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8225 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8226 " aaaaaa.aaaaaaa,\n" 8227 " aaaaaa.aaaaaaa,\n" 8228 " aaaaaa.aaaaaaa,\n" 8229 " aaaaaa.aaaaaaa,\n" 8230 "};"); 8231 8232 // Don't create hanging lists. 8233 verifyFormat("someFunction(Param, {List1, List2,\n" 8234 " List3});", 8235 getLLVMStyleWithColumns(35)); 8236 verifyFormat("someFunction(Param, Param,\n" 8237 " {List1, List2,\n" 8238 " List3});", 8239 getLLVMStyleWithColumns(35)); 8240 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 8241 " aaaaaaaaaaaaaaaaaaaaaaa);"); 8242 } 8243 8244 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 8245 FormatStyle DoNotMerge = getLLVMStyle(); 8246 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8247 8248 verifyFormat("void f() { return 42; }"); 8249 verifyFormat("void f() {\n" 8250 " return 42;\n" 8251 "}", 8252 DoNotMerge); 8253 verifyFormat("void f() {\n" 8254 " // Comment\n" 8255 "}"); 8256 verifyFormat("{\n" 8257 "#error {\n" 8258 " int a;\n" 8259 "}"); 8260 verifyFormat("{\n" 8261 " int a;\n" 8262 "#error {\n" 8263 "}"); 8264 verifyFormat("void f() {} // comment"); 8265 verifyFormat("void f() { int a; } // comment"); 8266 verifyFormat("void f() {\n" 8267 "} // comment", 8268 DoNotMerge); 8269 verifyFormat("void f() {\n" 8270 " int a;\n" 8271 "} // comment", 8272 DoNotMerge); 8273 verifyFormat("void f() {\n" 8274 "} // comment", 8275 getLLVMStyleWithColumns(15)); 8276 8277 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 8278 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 8279 8280 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 8281 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 8282 verifyFormat("class C {\n" 8283 " C()\n" 8284 " : iiiiiiii(nullptr),\n" 8285 " kkkkkkk(nullptr),\n" 8286 " mmmmmmm(nullptr),\n" 8287 " nnnnnnn(nullptr) {}\n" 8288 "};", 8289 getGoogleStyle()); 8290 8291 FormatStyle NoColumnLimit = getLLVMStyle(); 8292 NoColumnLimit.ColumnLimit = 0; 8293 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 8294 EXPECT_EQ("class C {\n" 8295 " A() : b(0) {}\n" 8296 "};", 8297 format("class C{A():b(0){}};", NoColumnLimit)); 8298 EXPECT_EQ("A()\n" 8299 " : b(0) {\n" 8300 "}", 8301 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 8302 8303 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 8304 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 8305 FormatStyle::SFS_None; 8306 EXPECT_EQ("A()\n" 8307 " : b(0) {\n" 8308 "}", 8309 format("A():b(0){}", DoNotMergeNoColumnLimit)); 8310 EXPECT_EQ("A()\n" 8311 " : b(0) {\n" 8312 "}", 8313 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 8314 8315 verifyFormat("#define A \\\n" 8316 " void f() { \\\n" 8317 " int i; \\\n" 8318 " }", 8319 getLLVMStyleWithColumns(20)); 8320 verifyFormat("#define A \\\n" 8321 " void f() { int i; }", 8322 getLLVMStyleWithColumns(21)); 8323 verifyFormat("#define A \\\n" 8324 " void f() { \\\n" 8325 " int i; \\\n" 8326 " } \\\n" 8327 " int j;", 8328 getLLVMStyleWithColumns(22)); 8329 verifyFormat("#define A \\\n" 8330 " void f() { int i; } \\\n" 8331 " int j;", 8332 getLLVMStyleWithColumns(23)); 8333 } 8334 8335 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 8336 FormatStyle MergeEmptyOnly = getLLVMStyle(); 8337 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8338 verifyFormat("class C {\n" 8339 " int f() {}\n" 8340 "};", 8341 MergeEmptyOnly); 8342 verifyFormat("class C {\n" 8343 " int f() {\n" 8344 " return 42;\n" 8345 " }\n" 8346 "};", 8347 MergeEmptyOnly); 8348 verifyFormat("int f() {}", MergeEmptyOnly); 8349 verifyFormat("int f() {\n" 8350 " return 42;\n" 8351 "}", 8352 MergeEmptyOnly); 8353 8354 // Also verify behavior when BraceWrapping.AfterFunction = true 8355 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8356 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 8357 verifyFormat("int f() {}", MergeEmptyOnly); 8358 verifyFormat("class C {\n" 8359 " int f() {}\n" 8360 "};", 8361 MergeEmptyOnly); 8362 } 8363 8364 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 8365 FormatStyle MergeInlineOnly = getLLVMStyle(); 8366 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8367 verifyFormat("class C {\n" 8368 " int f() { return 42; }\n" 8369 "};", 8370 MergeInlineOnly); 8371 verifyFormat("int f() {\n" 8372 " return 42;\n" 8373 "}", 8374 MergeInlineOnly); 8375 8376 // SFS_Inline implies SFS_Empty 8377 verifyFormat("class C {\n" 8378 " int f() {}\n" 8379 "};", 8380 MergeInlineOnly); 8381 verifyFormat("int f() {}", MergeInlineOnly); 8382 8383 // Also verify behavior when BraceWrapping.AfterFunction = true 8384 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8385 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8386 verifyFormat("class C {\n" 8387 " int f() { return 42; }\n" 8388 "};", 8389 MergeInlineOnly); 8390 verifyFormat("int f()\n" 8391 "{\n" 8392 " return 42;\n" 8393 "}", 8394 MergeInlineOnly); 8395 8396 // SFS_Inline implies SFS_Empty 8397 verifyFormat("int f() {}", MergeInlineOnly); 8398 verifyFormat("class C {\n" 8399 " int f() {}\n" 8400 "};", 8401 MergeInlineOnly); 8402 } 8403 8404 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8405 FormatStyle MergeInlineOnly = getLLVMStyle(); 8406 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8407 FormatStyle::SFS_InlineOnly; 8408 verifyFormat("class C {\n" 8409 " int f() { return 42; }\n" 8410 "};", 8411 MergeInlineOnly); 8412 verifyFormat("int f() {\n" 8413 " return 42;\n" 8414 "}", 8415 MergeInlineOnly); 8416 8417 // SFS_InlineOnly does not imply SFS_Empty 8418 verifyFormat("class C {\n" 8419 " int f() {}\n" 8420 "};", 8421 MergeInlineOnly); 8422 verifyFormat("int f() {\n" 8423 "}", 8424 MergeInlineOnly); 8425 8426 // Also verify behavior when BraceWrapping.AfterFunction = true 8427 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8428 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8429 verifyFormat("class C {\n" 8430 " int f() { return 42; }\n" 8431 "};", 8432 MergeInlineOnly); 8433 verifyFormat("int f()\n" 8434 "{\n" 8435 " return 42;\n" 8436 "}", 8437 MergeInlineOnly); 8438 8439 // SFS_InlineOnly does not imply SFS_Empty 8440 verifyFormat("int f()\n" 8441 "{\n" 8442 "}", 8443 MergeInlineOnly); 8444 verifyFormat("class C {\n" 8445 " int f() {}\n" 8446 "};", 8447 MergeInlineOnly); 8448 } 8449 8450 TEST_F(FormatTest, SplitEmptyFunction) { 8451 FormatStyle Style = getLLVMStyle(); 8452 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8453 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8454 Style.BraceWrapping.AfterFunction = true; 8455 Style.BraceWrapping.SplitEmptyFunction = false; 8456 Style.ColumnLimit = 40; 8457 8458 verifyFormat("int f()\n" 8459 "{}", 8460 Style); 8461 verifyFormat("int f()\n" 8462 "{\n" 8463 " return 42;\n" 8464 "}", 8465 Style); 8466 verifyFormat("int f()\n" 8467 "{\n" 8468 " // some comment\n" 8469 "}", 8470 Style); 8471 8472 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8473 verifyFormat("int f() {}", Style); 8474 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8475 "{}", 8476 Style); 8477 verifyFormat("int f()\n" 8478 "{\n" 8479 " return 0;\n" 8480 "}", 8481 Style); 8482 8483 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8484 verifyFormat("class Foo {\n" 8485 " int f() {}\n" 8486 "};\n", 8487 Style); 8488 verifyFormat("class Foo {\n" 8489 " int f() { return 0; }\n" 8490 "};\n", 8491 Style); 8492 verifyFormat("class Foo {\n" 8493 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8494 " {}\n" 8495 "};\n", 8496 Style); 8497 verifyFormat("class Foo {\n" 8498 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8499 " {\n" 8500 " return 0;\n" 8501 " }\n" 8502 "};\n", 8503 Style); 8504 8505 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8506 verifyFormat("int f() {}", Style); 8507 verifyFormat("int f() { return 0; }", Style); 8508 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8509 "{}", 8510 Style); 8511 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8512 "{\n" 8513 " return 0;\n" 8514 "}", 8515 Style); 8516 } 8517 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8518 FormatStyle Style = getLLVMStyle(); 8519 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8520 verifyFormat("#ifdef A\n" 8521 "int f() {}\n" 8522 "#else\n" 8523 "int g() {}\n" 8524 "#endif", 8525 Style); 8526 } 8527 8528 TEST_F(FormatTest, SplitEmptyClass) { 8529 FormatStyle Style = getLLVMStyle(); 8530 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8531 Style.BraceWrapping.AfterClass = true; 8532 Style.BraceWrapping.SplitEmptyRecord = false; 8533 8534 verifyFormat("class Foo\n" 8535 "{};", 8536 Style); 8537 verifyFormat("/* something */ class Foo\n" 8538 "{};", 8539 Style); 8540 verifyFormat("template <typename X> class Foo\n" 8541 "{};", 8542 Style); 8543 verifyFormat("class Foo\n" 8544 "{\n" 8545 " Foo();\n" 8546 "};", 8547 Style); 8548 verifyFormat("typedef class Foo\n" 8549 "{\n" 8550 "} Foo_t;", 8551 Style); 8552 } 8553 8554 TEST_F(FormatTest, SplitEmptyStruct) { 8555 FormatStyle Style = getLLVMStyle(); 8556 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8557 Style.BraceWrapping.AfterStruct = true; 8558 Style.BraceWrapping.SplitEmptyRecord = false; 8559 8560 verifyFormat("struct Foo\n" 8561 "{};", 8562 Style); 8563 verifyFormat("/* something */ struct Foo\n" 8564 "{};", 8565 Style); 8566 verifyFormat("template <typename X> struct Foo\n" 8567 "{};", 8568 Style); 8569 verifyFormat("struct Foo\n" 8570 "{\n" 8571 " Foo();\n" 8572 "};", 8573 Style); 8574 verifyFormat("typedef struct Foo\n" 8575 "{\n" 8576 "} Foo_t;", 8577 Style); 8578 // typedef struct Bar {} Bar_t; 8579 } 8580 8581 TEST_F(FormatTest, SplitEmptyUnion) { 8582 FormatStyle Style = getLLVMStyle(); 8583 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8584 Style.BraceWrapping.AfterUnion = true; 8585 Style.BraceWrapping.SplitEmptyRecord = false; 8586 8587 verifyFormat("union Foo\n" 8588 "{};", 8589 Style); 8590 verifyFormat("/* something */ union Foo\n" 8591 "{};", 8592 Style); 8593 verifyFormat("union Foo\n" 8594 "{\n" 8595 " A,\n" 8596 "};", 8597 Style); 8598 verifyFormat("typedef union Foo\n" 8599 "{\n" 8600 "} Foo_t;", 8601 Style); 8602 } 8603 8604 TEST_F(FormatTest, SplitEmptyNamespace) { 8605 FormatStyle Style = getLLVMStyle(); 8606 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8607 Style.BraceWrapping.AfterNamespace = true; 8608 Style.BraceWrapping.SplitEmptyNamespace = false; 8609 8610 verifyFormat("namespace Foo\n" 8611 "{};", 8612 Style); 8613 verifyFormat("/* something */ namespace Foo\n" 8614 "{};", 8615 Style); 8616 verifyFormat("inline namespace Foo\n" 8617 "{};", 8618 Style); 8619 verifyFormat("/* something */ inline namespace Foo\n" 8620 "{};", 8621 Style); 8622 verifyFormat("export namespace Foo\n" 8623 "{};", 8624 Style); 8625 verifyFormat("namespace Foo\n" 8626 "{\n" 8627 "void Bar();\n" 8628 "};", 8629 Style); 8630 } 8631 8632 TEST_F(FormatTest, NeverMergeShortRecords) { 8633 FormatStyle Style = getLLVMStyle(); 8634 8635 verifyFormat("class Foo {\n" 8636 " Foo();\n" 8637 "};", 8638 Style); 8639 verifyFormat("typedef class Foo {\n" 8640 " Foo();\n" 8641 "} Foo_t;", 8642 Style); 8643 verifyFormat("struct Foo {\n" 8644 " Foo();\n" 8645 "};", 8646 Style); 8647 verifyFormat("typedef struct Foo {\n" 8648 " Foo();\n" 8649 "} Foo_t;", 8650 Style); 8651 verifyFormat("union Foo {\n" 8652 " A,\n" 8653 "};", 8654 Style); 8655 verifyFormat("typedef union Foo {\n" 8656 " A,\n" 8657 "} Foo_t;", 8658 Style); 8659 verifyFormat("namespace Foo {\n" 8660 "void Bar();\n" 8661 "};", 8662 Style); 8663 8664 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8665 Style.BraceWrapping.AfterClass = true; 8666 Style.BraceWrapping.AfterStruct = true; 8667 Style.BraceWrapping.AfterUnion = true; 8668 Style.BraceWrapping.AfterNamespace = true; 8669 verifyFormat("class Foo\n" 8670 "{\n" 8671 " Foo();\n" 8672 "};", 8673 Style); 8674 verifyFormat("typedef class Foo\n" 8675 "{\n" 8676 " Foo();\n" 8677 "} Foo_t;", 8678 Style); 8679 verifyFormat("struct Foo\n" 8680 "{\n" 8681 " Foo();\n" 8682 "};", 8683 Style); 8684 verifyFormat("typedef struct Foo\n" 8685 "{\n" 8686 " Foo();\n" 8687 "} Foo_t;", 8688 Style); 8689 verifyFormat("union Foo\n" 8690 "{\n" 8691 " A,\n" 8692 "};", 8693 Style); 8694 verifyFormat("typedef union Foo\n" 8695 "{\n" 8696 " A,\n" 8697 "} Foo_t;", 8698 Style); 8699 verifyFormat("namespace Foo\n" 8700 "{\n" 8701 "void Bar();\n" 8702 "};", 8703 Style); 8704 } 8705 8706 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 8707 // Elaborate type variable declarations. 8708 verifyFormat("struct foo a = {bar};\nint n;"); 8709 verifyFormat("class foo a = {bar};\nint n;"); 8710 verifyFormat("union foo a = {bar};\nint n;"); 8711 8712 // Elaborate types inside function definitions. 8713 verifyFormat("struct foo f() {}\nint n;"); 8714 verifyFormat("class foo f() {}\nint n;"); 8715 verifyFormat("union foo f() {}\nint n;"); 8716 8717 // Templates. 8718 verifyFormat("template <class X> void f() {}\nint n;"); 8719 verifyFormat("template <struct X> void f() {}\nint n;"); 8720 verifyFormat("template <union X> void f() {}\nint n;"); 8721 8722 // Actual definitions... 8723 verifyFormat("struct {\n} n;"); 8724 verifyFormat( 8725 "template <template <class T, class Y>, class Z> class X {\n} n;"); 8726 verifyFormat("union Z {\n int n;\n} x;"); 8727 verifyFormat("class MACRO Z {\n} n;"); 8728 verifyFormat("class MACRO(X) Z {\n} n;"); 8729 verifyFormat("class __attribute__(X) Z {\n} n;"); 8730 verifyFormat("class __declspec(X) Z {\n} n;"); 8731 verifyFormat("class A##B##C {\n} n;"); 8732 verifyFormat("class alignas(16) Z {\n} n;"); 8733 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 8734 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 8735 8736 // Redefinition from nested context: 8737 verifyFormat("class A::B::C {\n} n;"); 8738 8739 // Template definitions. 8740 verifyFormat( 8741 "template <typename F>\n" 8742 "Matcher(const Matcher<F> &Other,\n" 8743 " typename enable_if_c<is_base_of<F, T>::value &&\n" 8744 " !is_same<F, T>::value>::type * = 0)\n" 8745 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 8746 8747 // FIXME: This is still incorrectly handled at the formatter side. 8748 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 8749 verifyFormat("int i = SomeFunction(a<b, a> b);"); 8750 8751 // FIXME: 8752 // This now gets parsed incorrectly as class definition. 8753 // verifyFormat("class A<int> f() {\n}\nint n;"); 8754 8755 // Elaborate types where incorrectly parsing the structural element would 8756 // break the indent. 8757 verifyFormat("if (true)\n" 8758 " class X x;\n" 8759 "else\n" 8760 " f();\n"); 8761 8762 // This is simply incomplete. Formatting is not important, but must not crash. 8763 verifyFormat("class A:"); 8764 } 8765 8766 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 8767 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 8768 format("#error Leave all white!!!!! space* alone!\n")); 8769 EXPECT_EQ( 8770 "#warning Leave all white!!!!! space* alone!\n", 8771 format("#warning Leave all white!!!!! space* alone!\n")); 8772 EXPECT_EQ("#error 1", format(" # error 1")); 8773 EXPECT_EQ("#warning 1", format(" # warning 1")); 8774 } 8775 8776 TEST_F(FormatTest, FormatHashIfExpressions) { 8777 verifyFormat("#if AAAA && BBBB"); 8778 verifyFormat("#if (AAAA && BBBB)"); 8779 verifyFormat("#elif (AAAA && BBBB)"); 8780 // FIXME: Come up with a better indentation for #elif. 8781 verifyFormat( 8782 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 8783 " defined(BBBBBBBB)\n" 8784 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 8785 " defined(BBBBBBBB)\n" 8786 "#endif", 8787 getLLVMStyleWithColumns(65)); 8788 } 8789 8790 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 8791 FormatStyle AllowsMergedIf = getGoogleStyle(); 8792 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 8793 FormatStyle::SIS_WithoutElse; 8794 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 8795 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 8796 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 8797 EXPECT_EQ("if (true) return 42;", 8798 format("if (true)\nreturn 42;", AllowsMergedIf)); 8799 FormatStyle ShortMergedIf = AllowsMergedIf; 8800 ShortMergedIf.ColumnLimit = 25; 8801 verifyFormat("#define A \\\n" 8802 " if (true) return 42;", 8803 ShortMergedIf); 8804 verifyFormat("#define A \\\n" 8805 " f(); \\\n" 8806 " if (true)\n" 8807 "#define B", 8808 ShortMergedIf); 8809 verifyFormat("#define A \\\n" 8810 " f(); \\\n" 8811 " if (true)\n" 8812 "g();", 8813 ShortMergedIf); 8814 verifyFormat("{\n" 8815 "#ifdef A\n" 8816 " // Comment\n" 8817 " if (true) continue;\n" 8818 "#endif\n" 8819 " // Comment\n" 8820 " if (true) continue;\n" 8821 "}", 8822 ShortMergedIf); 8823 ShortMergedIf.ColumnLimit = 33; 8824 verifyFormat("#define A \\\n" 8825 " if constexpr (true) return 42;", 8826 ShortMergedIf); 8827 verifyFormat("#define A \\\n" 8828 " if CONSTEXPR (true) return 42;", 8829 ShortMergedIf); 8830 ShortMergedIf.ColumnLimit = 29; 8831 verifyFormat("#define A \\\n" 8832 " if (aaaaaaaaaa) return 1; \\\n" 8833 " return 2;", 8834 ShortMergedIf); 8835 ShortMergedIf.ColumnLimit = 28; 8836 verifyFormat("#define A \\\n" 8837 " if (aaaaaaaaaa) \\\n" 8838 " return 1; \\\n" 8839 " return 2;", 8840 ShortMergedIf); 8841 verifyFormat("#define A \\\n" 8842 " if constexpr (aaaaaaa) \\\n" 8843 " return 1; \\\n" 8844 " return 2;", 8845 ShortMergedIf); 8846 verifyFormat("#define A \\\n" 8847 " if CONSTEXPR (aaaaaaa) \\\n" 8848 " return 1; \\\n" 8849 " return 2;", 8850 ShortMergedIf); 8851 } 8852 8853 TEST_F(FormatTest, FormatStarDependingOnContext) { 8854 verifyFormat("void f(int *a);"); 8855 verifyFormat("void f() { f(fint * b); }"); 8856 verifyFormat("class A {\n void f(int *a);\n};"); 8857 verifyFormat("class A {\n int *a;\n};"); 8858 verifyFormat("namespace a {\n" 8859 "namespace b {\n" 8860 "class A {\n" 8861 " void f() {}\n" 8862 " int *a;\n" 8863 "};\n" 8864 "} // namespace b\n" 8865 "} // namespace a"); 8866 } 8867 8868 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 8869 verifyFormat("while"); 8870 verifyFormat("operator"); 8871 } 8872 8873 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 8874 // This code would be painfully slow to format if we didn't skip it. 8875 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 8876 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8877 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8878 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8879 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8880 "A(1, 1)\n" 8881 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 8882 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8883 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8884 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8885 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8886 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8887 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8888 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8889 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8890 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 8891 // Deeply nested part is untouched, rest is formatted. 8892 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 8893 format(std::string("int i;\n") + Code + "int j;\n", 8894 getLLVMStyle(), SC_ExpectIncomplete)); 8895 } 8896 8897 //===----------------------------------------------------------------------===// 8898 // Objective-C tests. 8899 //===----------------------------------------------------------------------===// 8900 8901 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 8902 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 8903 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 8904 format("-(NSUInteger)indexOfObject:(id)anObject;")); 8905 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 8906 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 8907 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 8908 format("-(NSInteger)Method3:(id)anObject;")); 8909 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 8910 format("-(NSInteger)Method4:(id)anObject;")); 8911 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 8912 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 8913 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 8914 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 8915 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 8916 "forAllCells:(BOOL)flag;", 8917 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 8918 "forAllCells:(BOOL)flag;")); 8919 8920 // Very long objectiveC method declaration. 8921 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 8922 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 8923 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 8924 " inRange:(NSRange)range\n" 8925 " outRange:(NSRange)out_range\n" 8926 " outRange1:(NSRange)out_range1\n" 8927 " outRange2:(NSRange)out_range2\n" 8928 " outRange3:(NSRange)out_range3\n" 8929 " outRange4:(NSRange)out_range4\n" 8930 " outRange5:(NSRange)out_range5\n" 8931 " outRange6:(NSRange)out_range6\n" 8932 " outRange7:(NSRange)out_range7\n" 8933 " outRange8:(NSRange)out_range8\n" 8934 " outRange9:(NSRange)out_range9;"); 8935 8936 // When the function name has to be wrapped. 8937 FormatStyle Style = getLLVMStyle(); 8938 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 8939 // and always indents instead. 8940 Style.IndentWrappedFunctionNames = false; 8941 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 8942 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 8943 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 8944 "}", 8945 Style); 8946 Style.IndentWrappedFunctionNames = true; 8947 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 8948 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 8949 " anotherName:(NSString)dddddddddddddd {\n" 8950 "}", 8951 Style); 8952 8953 verifyFormat("- (int)sum:(vector<int>)numbers;"); 8954 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 8955 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 8956 // protocol lists (but not for template classes): 8957 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 8958 8959 verifyFormat("- (int (*)())foo:(int (*)())f;"); 8960 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 8961 8962 // If there's no return type (very rare in practice!), LLVM and Google style 8963 // agree. 8964 verifyFormat("- foo;"); 8965 verifyFormat("- foo:(int)f;"); 8966 verifyGoogleFormat("- foo:(int)foo;"); 8967 } 8968 8969 TEST_F(FormatTest, BreaksStringLiterals) { 8970 EXPECT_EQ("\"some text \"\n" 8971 "\"other\";", 8972 format("\"some text other\";", getLLVMStyleWithColumns(12))); 8973 EXPECT_EQ("\"some text \"\n" 8974 "\"other\";", 8975 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 8976 EXPECT_EQ( 8977 "#define A \\\n" 8978 " \"some \" \\\n" 8979 " \"text \" \\\n" 8980 " \"other\";", 8981 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 8982 EXPECT_EQ( 8983 "#define A \\\n" 8984 " \"so \" \\\n" 8985 " \"text \" \\\n" 8986 " \"other\";", 8987 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 8988 8989 EXPECT_EQ("\"some text\"", 8990 format("\"some text\"", getLLVMStyleWithColumns(1))); 8991 EXPECT_EQ("\"some text\"", 8992 format("\"some text\"", getLLVMStyleWithColumns(11))); 8993 EXPECT_EQ("\"some \"\n" 8994 "\"text\"", 8995 format("\"some text\"", getLLVMStyleWithColumns(10))); 8996 EXPECT_EQ("\"some \"\n" 8997 "\"text\"", 8998 format("\"some text\"", getLLVMStyleWithColumns(7))); 8999 EXPECT_EQ("\"some\"\n" 9000 "\" tex\"\n" 9001 "\"t\"", 9002 format("\"some text\"", getLLVMStyleWithColumns(6))); 9003 EXPECT_EQ("\"some\"\n" 9004 "\" tex\"\n" 9005 "\" and\"", 9006 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 9007 EXPECT_EQ("\"some\"\n" 9008 "\"/tex\"\n" 9009 "\"/and\"", 9010 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 9011 9012 EXPECT_EQ("variable =\n" 9013 " \"long string \"\n" 9014 " \"literal\";", 9015 format("variable = \"long string literal\";", 9016 getLLVMStyleWithColumns(20))); 9017 9018 EXPECT_EQ("variable = f(\n" 9019 " \"long string \"\n" 9020 " \"literal\",\n" 9021 " short,\n" 9022 " loooooooooooooooooooong);", 9023 format("variable = f(\"long string literal\", short, " 9024 "loooooooooooooooooooong);", 9025 getLLVMStyleWithColumns(20))); 9026 9027 EXPECT_EQ( 9028 "f(g(\"long string \"\n" 9029 " \"literal\"),\n" 9030 " b);", 9031 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 9032 EXPECT_EQ("f(g(\"long string \"\n" 9033 " \"literal\",\n" 9034 " a),\n" 9035 " b);", 9036 format("f(g(\"long string literal\", a), b);", 9037 getLLVMStyleWithColumns(20))); 9038 EXPECT_EQ( 9039 "f(\"one two\".split(\n" 9040 " variable));", 9041 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 9042 EXPECT_EQ("f(\"one two three four five six \"\n" 9043 " \"seven\".split(\n" 9044 " really_looooong_variable));", 9045 format("f(\"one two three four five six seven\"." 9046 "split(really_looooong_variable));", 9047 getLLVMStyleWithColumns(33))); 9048 9049 EXPECT_EQ("f(\"some \"\n" 9050 " \"text\",\n" 9051 " other);", 9052 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 9053 9054 // Only break as a last resort. 9055 verifyFormat( 9056 "aaaaaaaaaaaaaaaaaaaa(\n" 9057 " aaaaaaaaaaaaaaaaaaaa,\n" 9058 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 9059 9060 EXPECT_EQ("\"splitmea\"\n" 9061 "\"trandomp\"\n" 9062 "\"oint\"", 9063 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 9064 9065 EXPECT_EQ("\"split/\"\n" 9066 "\"pathat/\"\n" 9067 "\"slashes\"", 9068 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9069 9070 EXPECT_EQ("\"split/\"\n" 9071 "\"pathat/\"\n" 9072 "\"slashes\"", 9073 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9074 EXPECT_EQ("\"split at \"\n" 9075 "\"spaces/at/\"\n" 9076 "\"slashes.at.any$\"\n" 9077 "\"non-alphanumeric%\"\n" 9078 "\"1111111111characte\"\n" 9079 "\"rs\"", 9080 format("\"split at " 9081 "spaces/at/" 9082 "slashes.at." 9083 "any$non-" 9084 "alphanumeric%" 9085 "1111111111characte" 9086 "rs\"", 9087 getLLVMStyleWithColumns(20))); 9088 9089 // Verify that splitting the strings understands 9090 // Style::AlwaysBreakBeforeMultilineStrings. 9091 EXPECT_EQ("aaaaaaaaaaaa(\n" 9092 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 9093 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 9094 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 9095 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9096 "aaaaaaaaaaaaaaaaaaaaaa\");", 9097 getGoogleStyle())); 9098 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9099 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 9100 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 9101 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9102 "aaaaaaaaaaaaaaaaaaaaaa\";", 9103 getGoogleStyle())); 9104 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9105 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9106 format("llvm::outs() << " 9107 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 9108 "aaaaaaaaaaaaaaaaaaa\";")); 9109 EXPECT_EQ("ffff(\n" 9110 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9111 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9112 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 9113 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9114 getGoogleStyle())); 9115 9116 FormatStyle Style = getLLVMStyleWithColumns(12); 9117 Style.BreakStringLiterals = false; 9118 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 9119 9120 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 9121 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9122 EXPECT_EQ("#define A \\\n" 9123 " \"some \" \\\n" 9124 " \"text \" \\\n" 9125 " \"other\";", 9126 format("#define A \"some text other\";", AlignLeft)); 9127 } 9128 9129 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 9130 EXPECT_EQ("C a = \"some more \"\n" 9131 " \"text\";", 9132 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 9133 } 9134 9135 TEST_F(FormatTest, FullyRemoveEmptyLines) { 9136 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 9137 NoEmptyLines.MaxEmptyLinesToKeep = 0; 9138 EXPECT_EQ("int i = a(b());", 9139 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 9140 } 9141 9142 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 9143 EXPECT_EQ( 9144 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9145 "(\n" 9146 " \"x\t\");", 9147 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9148 "aaaaaaa(" 9149 "\"x\t\");")); 9150 } 9151 9152 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 9153 EXPECT_EQ( 9154 "u8\"utf8 string \"\n" 9155 "u8\"literal\";", 9156 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 9157 EXPECT_EQ( 9158 "u\"utf16 string \"\n" 9159 "u\"literal\";", 9160 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 9161 EXPECT_EQ( 9162 "U\"utf32 string \"\n" 9163 "U\"literal\";", 9164 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 9165 EXPECT_EQ("L\"wide string \"\n" 9166 "L\"literal\";", 9167 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 9168 EXPECT_EQ("@\"NSString \"\n" 9169 "@\"literal\";", 9170 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 9171 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 9172 9173 // This input makes clang-format try to split the incomplete unicode escape 9174 // sequence, which used to lead to a crasher. 9175 verifyNoCrash( 9176 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 9177 getLLVMStyleWithColumns(60)); 9178 } 9179 9180 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 9181 FormatStyle Style = getGoogleStyleWithColumns(15); 9182 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 9183 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 9184 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 9185 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 9186 EXPECT_EQ("u8R\"x(raw literal)x\";", 9187 format("u8R\"x(raw literal)x\";", Style)); 9188 } 9189 9190 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 9191 FormatStyle Style = getLLVMStyleWithColumns(20); 9192 EXPECT_EQ( 9193 "_T(\"aaaaaaaaaaaaaa\")\n" 9194 "_T(\"aaaaaaaaaaaaaa\")\n" 9195 "_T(\"aaaaaaaaaaaa\")", 9196 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 9197 EXPECT_EQ("f(x,\n" 9198 " _T(\"aaaaaaaaaaaa\")\n" 9199 " _T(\"aaa\"),\n" 9200 " z);", 9201 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 9202 9203 // FIXME: Handle embedded spaces in one iteration. 9204 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 9205 // "_T(\"aaaaaaaaaaaaa\")\n" 9206 // "_T(\"aaaaaaaaaaaaa\")\n" 9207 // "_T(\"a\")", 9208 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9209 // getLLVMStyleWithColumns(20))); 9210 EXPECT_EQ( 9211 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9212 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 9213 EXPECT_EQ("f(\n" 9214 "#if !TEST\n" 9215 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9216 "#endif\n" 9217 ");", 9218 format("f(\n" 9219 "#if !TEST\n" 9220 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9221 "#endif\n" 9222 ");")); 9223 EXPECT_EQ("f(\n" 9224 "\n" 9225 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 9226 format("f(\n" 9227 "\n" 9228 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 9229 } 9230 9231 TEST_F(FormatTest, BreaksStringLiteralOperands) { 9232 // In a function call with two operands, the second can be broken with no line 9233 // break before it. 9234 EXPECT_EQ( 9235 "func(a, \"long long \"\n" 9236 " \"long long\");", 9237 format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24))); 9238 // In a function call with three operands, the second must be broken with a 9239 // line break before it. 9240 EXPECT_EQ("func(a,\n" 9241 " \"long long long \"\n" 9242 " \"long\",\n" 9243 " c);", 9244 format("func(a, \"long long long long\", c);", 9245 getLLVMStyleWithColumns(24))); 9246 // In a function call with three operands, the third must be broken with a 9247 // line break before it. 9248 EXPECT_EQ("func(a, b,\n" 9249 " \"long long long \"\n" 9250 " \"long\");", 9251 format("func(a, b, \"long long long long\");", 9252 getLLVMStyleWithColumns(24))); 9253 // In a function call with three operands, both the second and the third must 9254 // be broken with a line break before them. 9255 EXPECT_EQ("func(a,\n" 9256 " \"long long long \"\n" 9257 " \"long\",\n" 9258 " \"long long long \"\n" 9259 " \"long\");", 9260 format("func(a, \"long long long long\", \"long long long long\");", 9261 getLLVMStyleWithColumns(24))); 9262 // In a chain of << with two operands, the second can be broken with no line 9263 // break before it. 9264 EXPECT_EQ("a << \"line line \"\n" 9265 " \"line\";", 9266 format("a << \"line line line\";", getLLVMStyleWithColumns(20))); 9267 // In a chain of << with three operands, the second can be broken with no line 9268 // break before it. 9269 EXPECT_EQ( 9270 "abcde << \"line \"\n" 9271 " \"line line\"\n" 9272 " << c;", 9273 format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20))); 9274 // In a chain of << with three operands, the third must be broken with a line 9275 // break before it. 9276 EXPECT_EQ( 9277 "a << b\n" 9278 " << \"line line \"\n" 9279 " \"line\";", 9280 format("a << b << \"line line line\";", getLLVMStyleWithColumns(20))); 9281 // In a chain of << with three operands, the second can be broken with no line 9282 // break before it and the third must be broken with a line break before it. 9283 EXPECT_EQ("abcd << \"line line \"\n" 9284 " \"line\"\n" 9285 " << \"line line \"\n" 9286 " \"line\";", 9287 format("abcd << \"line line line\" << \"line line line\";", 9288 getLLVMStyleWithColumns(20))); 9289 // In a chain of binary operators with two operands, the second can be broken 9290 // with no line break before it. 9291 EXPECT_EQ( 9292 "abcd + \"line line \"\n" 9293 " \"line line\";", 9294 format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20))); 9295 // In a chain of binary operators with three operands, the second must be 9296 // broken with a line break before it. 9297 EXPECT_EQ("abcd +\n" 9298 " \"line line \"\n" 9299 " \"line line\" +\n" 9300 " e;", 9301 format("abcd + \"line line line line\" + e;", 9302 getLLVMStyleWithColumns(20))); 9303 // In a function call with two operands, with AlignAfterOpenBracket enabled, 9304 // the first must be broken with a line break before it. 9305 FormatStyle Style = getLLVMStyleWithColumns(25); 9306 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 9307 EXPECT_EQ("someFunction(\n" 9308 " \"long long long \"\n" 9309 " \"long\",\n" 9310 " a);", 9311 format("someFunction(\"long long long long\", a);", Style)); 9312 } 9313 9314 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 9315 EXPECT_EQ( 9316 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9317 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9318 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9319 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9320 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9321 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 9322 } 9323 9324 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 9325 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 9326 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 9327 EXPECT_EQ("fffffffffff(g(R\"x(\n" 9328 "multiline raw string literal xxxxxxxxxxxxxx\n" 9329 ")x\",\n" 9330 " a),\n" 9331 " b);", 9332 format("fffffffffff(g(R\"x(\n" 9333 "multiline raw string literal xxxxxxxxxxxxxx\n" 9334 ")x\", a), b);", 9335 getGoogleStyleWithColumns(20))); 9336 EXPECT_EQ("fffffffffff(\n" 9337 " g(R\"x(qqq\n" 9338 "multiline raw string literal xxxxxxxxxxxxxx\n" 9339 ")x\",\n" 9340 " a),\n" 9341 " b);", 9342 format("fffffffffff(g(R\"x(qqq\n" 9343 "multiline raw string literal xxxxxxxxxxxxxx\n" 9344 ")x\", a), b);", 9345 getGoogleStyleWithColumns(20))); 9346 9347 EXPECT_EQ("fffffffffff(R\"x(\n" 9348 "multiline raw string literal xxxxxxxxxxxxxx\n" 9349 ")x\");", 9350 format("fffffffffff(R\"x(\n" 9351 "multiline raw string literal xxxxxxxxxxxxxx\n" 9352 ")x\");", 9353 getGoogleStyleWithColumns(20))); 9354 EXPECT_EQ("fffffffffff(R\"x(\n" 9355 "multiline raw string literal xxxxxxxxxxxxxx\n" 9356 ")x\" + bbbbbb);", 9357 format("fffffffffff(R\"x(\n" 9358 "multiline raw string literal xxxxxxxxxxxxxx\n" 9359 ")x\" + bbbbbb);", 9360 getGoogleStyleWithColumns(20))); 9361 EXPECT_EQ("fffffffffff(\n" 9362 " R\"x(\n" 9363 "multiline raw string literal xxxxxxxxxxxxxx\n" 9364 ")x\" +\n" 9365 " bbbbbb);", 9366 format("fffffffffff(\n" 9367 " R\"x(\n" 9368 "multiline raw string literal xxxxxxxxxxxxxx\n" 9369 ")x\" + bbbbbb);", 9370 getGoogleStyleWithColumns(20))); 9371 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 9372 format("fffffffffff(\n" 9373 " R\"(single line raw string)\" + bbbbbb);")); 9374 } 9375 9376 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 9377 verifyFormat("string a = \"unterminated;"); 9378 EXPECT_EQ("function(\"unterminated,\n" 9379 " OtherParameter);", 9380 format("function( \"unterminated,\n" 9381 " OtherParameter);")); 9382 } 9383 9384 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9385 FormatStyle Style = getLLVMStyle(); 9386 Style.Standard = FormatStyle::LS_Cpp03; 9387 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9388 format("#define x(_a) printf(\"foo\"_a);", Style)); 9389 } 9390 9391 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9392 9393 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9394 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9395 " \"ddeeefff\");", 9396 format("someFunction(\"aaabbbcccdddeeefff\");", 9397 getLLVMStyleWithColumns(25))); 9398 EXPECT_EQ("someFunction1234567890(\n" 9399 " \"aaabbbcccdddeeefff\");", 9400 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9401 getLLVMStyleWithColumns(26))); 9402 EXPECT_EQ("someFunction1234567890(\n" 9403 " \"aaabbbcccdddeeeff\"\n" 9404 " \"f\");", 9405 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9406 getLLVMStyleWithColumns(25))); 9407 EXPECT_EQ("someFunction1234567890(\n" 9408 " \"aaabbbcccdddeeeff\"\n" 9409 " \"f\");", 9410 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9411 getLLVMStyleWithColumns(24))); 9412 EXPECT_EQ("someFunction(\n" 9413 " \"aaabbbcc ddde \"\n" 9414 " \"efff\");", 9415 format("someFunction(\"aaabbbcc ddde efff\");", 9416 getLLVMStyleWithColumns(25))); 9417 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9418 " \"ddeeefff\");", 9419 format("someFunction(\"aaabbbccc ddeeefff\");", 9420 getLLVMStyleWithColumns(25))); 9421 EXPECT_EQ("someFunction1234567890(\n" 9422 " \"aaabb \"\n" 9423 " \"cccdddeeefff\");", 9424 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9425 getLLVMStyleWithColumns(25))); 9426 EXPECT_EQ("#define A \\\n" 9427 " string s = \\\n" 9428 " \"123456789\" \\\n" 9429 " \"0\"; \\\n" 9430 " int i;", 9431 format("#define A string s = \"1234567890\"; int i;", 9432 getLLVMStyleWithColumns(20))); 9433 EXPECT_EQ("someFunction(\n" 9434 " \"aaabbbcc \"\n" 9435 " \"dddeeefff\");", 9436 format("someFunction(\"aaabbbcc dddeeefff\");", 9437 getLLVMStyleWithColumns(25))); 9438 } 9439 9440 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9441 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9442 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9443 EXPECT_EQ("\"test\"\n" 9444 "\"\\n\"", 9445 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9446 EXPECT_EQ("\"tes\\\\\"\n" 9447 "\"n\"", 9448 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9449 EXPECT_EQ("\"\\\\\\\\\"\n" 9450 "\"\\n\"", 9451 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9452 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9453 EXPECT_EQ("\"\\uff01\"\n" 9454 "\"test\"", 9455 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9456 EXPECT_EQ("\"\\Uff01ff02\"", 9457 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9458 EXPECT_EQ("\"\\x000000000001\"\n" 9459 "\"next\"", 9460 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9461 EXPECT_EQ("\"\\x000000000001next\"", 9462 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9463 EXPECT_EQ("\"\\x000000000001\"", 9464 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9465 EXPECT_EQ("\"test\"\n" 9466 "\"\\000000\"\n" 9467 "\"000001\"", 9468 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9469 EXPECT_EQ("\"test\\000\"\n" 9470 "\"00000000\"\n" 9471 "\"1\"", 9472 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9473 } 9474 9475 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9476 verifyFormat("void f() {\n" 9477 " return g() {}\n" 9478 " void h() {}"); 9479 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9480 "g();\n" 9481 "}"); 9482 } 9483 9484 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9485 verifyFormat( 9486 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9487 } 9488 9489 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9490 verifyFormat("class X {\n" 9491 " void f() {\n" 9492 " }\n" 9493 "};", 9494 getLLVMStyleWithColumns(12)); 9495 } 9496 9497 TEST_F(FormatTest, ConfigurableIndentWidth) { 9498 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9499 EightIndent.IndentWidth = 8; 9500 EightIndent.ContinuationIndentWidth = 8; 9501 verifyFormat("void f() {\n" 9502 " someFunction();\n" 9503 " if (true) {\n" 9504 " f();\n" 9505 " }\n" 9506 "}", 9507 EightIndent); 9508 verifyFormat("class X {\n" 9509 " void f() {\n" 9510 " }\n" 9511 "};", 9512 EightIndent); 9513 verifyFormat("int x[] = {\n" 9514 " call(),\n" 9515 " call()};", 9516 EightIndent); 9517 } 9518 9519 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9520 verifyFormat("double\n" 9521 "f();", 9522 getLLVMStyleWithColumns(8)); 9523 } 9524 9525 TEST_F(FormatTest, ConfigurableUseOfTab) { 9526 FormatStyle Tab = getLLVMStyleWithColumns(42); 9527 Tab.IndentWidth = 8; 9528 Tab.UseTab = FormatStyle::UT_Always; 9529 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9530 9531 EXPECT_EQ("if (aaaaaaaa && // q\n" 9532 " bb)\t\t// w\n" 9533 "\t;", 9534 format("if (aaaaaaaa &&// q\n" 9535 "bb)// w\n" 9536 ";", 9537 Tab)); 9538 EXPECT_EQ("if (aaa && bbb) // w\n" 9539 "\t;", 9540 format("if(aaa&&bbb)// w\n" 9541 ";", 9542 Tab)); 9543 9544 verifyFormat("class X {\n" 9545 "\tvoid f() {\n" 9546 "\t\tsomeFunction(parameter1,\n" 9547 "\t\t\t parameter2);\n" 9548 "\t}\n" 9549 "};", 9550 Tab); 9551 verifyFormat("#define A \\\n" 9552 "\tvoid f() { \\\n" 9553 "\t\tsomeFunction( \\\n" 9554 "\t\t parameter1, \\\n" 9555 "\t\t parameter2); \\\n" 9556 "\t}", 9557 Tab); 9558 verifyFormat("int a;\t // x\n" 9559 "int bbbbbbbb; // x\n", 9560 Tab); 9561 9562 Tab.TabWidth = 4; 9563 Tab.IndentWidth = 8; 9564 verifyFormat("class TabWidth4Indent8 {\n" 9565 "\t\tvoid f() {\n" 9566 "\t\t\t\tsomeFunction(parameter1,\n" 9567 "\t\t\t\t\t\t\t parameter2);\n" 9568 "\t\t}\n" 9569 "};", 9570 Tab); 9571 9572 Tab.TabWidth = 4; 9573 Tab.IndentWidth = 4; 9574 verifyFormat("class TabWidth4Indent4 {\n" 9575 "\tvoid f() {\n" 9576 "\t\tsomeFunction(parameter1,\n" 9577 "\t\t\t\t\t parameter2);\n" 9578 "\t}\n" 9579 "};", 9580 Tab); 9581 9582 Tab.TabWidth = 8; 9583 Tab.IndentWidth = 4; 9584 verifyFormat("class TabWidth8Indent4 {\n" 9585 " void f() {\n" 9586 "\tsomeFunction(parameter1,\n" 9587 "\t\t parameter2);\n" 9588 " }\n" 9589 "};", 9590 Tab); 9591 9592 Tab.TabWidth = 8; 9593 Tab.IndentWidth = 8; 9594 EXPECT_EQ("/*\n" 9595 "\t a\t\tcomment\n" 9596 "\t in multiple lines\n" 9597 " */", 9598 format(" /*\t \t \n" 9599 " \t \t a\t\tcomment\t \t\n" 9600 " \t \t in multiple lines\t\n" 9601 " \t */", 9602 Tab)); 9603 9604 Tab.UseTab = FormatStyle::UT_ForIndentation; 9605 verifyFormat("{\n" 9606 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9607 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9608 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9609 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9610 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9611 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9612 "};", 9613 Tab); 9614 verifyFormat("enum AA {\n" 9615 "\ta1, // Force multiple lines\n" 9616 "\ta2,\n" 9617 "\ta3\n" 9618 "};", 9619 Tab); 9620 EXPECT_EQ("if (aaaaaaaa && // q\n" 9621 " bb) // w\n" 9622 "\t;", 9623 format("if (aaaaaaaa &&// q\n" 9624 "bb)// w\n" 9625 ";", 9626 Tab)); 9627 verifyFormat("class X {\n" 9628 "\tvoid f() {\n" 9629 "\t\tsomeFunction(parameter1,\n" 9630 "\t\t parameter2);\n" 9631 "\t}\n" 9632 "};", 9633 Tab); 9634 verifyFormat("{\n" 9635 "\tQ(\n" 9636 "\t {\n" 9637 "\t\t int a;\n" 9638 "\t\t someFunction(aaaaaaaa,\n" 9639 "\t\t bbbbbbb);\n" 9640 "\t },\n" 9641 "\t p);\n" 9642 "}", 9643 Tab); 9644 EXPECT_EQ("{\n" 9645 "\t/* aaaa\n" 9646 "\t bbbb */\n" 9647 "}", 9648 format("{\n" 9649 "/* aaaa\n" 9650 " bbbb */\n" 9651 "}", 9652 Tab)); 9653 EXPECT_EQ("{\n" 9654 "\t/*\n" 9655 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9656 "\t bbbbbbbbbbbbb\n" 9657 "\t*/\n" 9658 "}", 9659 format("{\n" 9660 "/*\n" 9661 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9662 "*/\n" 9663 "}", 9664 Tab)); 9665 EXPECT_EQ("{\n" 9666 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9667 "\t// bbbbbbbbbbbbb\n" 9668 "}", 9669 format("{\n" 9670 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9671 "}", 9672 Tab)); 9673 EXPECT_EQ("{\n" 9674 "\t/*\n" 9675 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9676 "\t bbbbbbbbbbbbb\n" 9677 "\t*/\n" 9678 "}", 9679 format("{\n" 9680 "\t/*\n" 9681 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9682 "\t*/\n" 9683 "}", 9684 Tab)); 9685 EXPECT_EQ("{\n" 9686 "\t/*\n" 9687 "\n" 9688 "\t*/\n" 9689 "}", 9690 format("{\n" 9691 "\t/*\n" 9692 "\n" 9693 "\t*/\n" 9694 "}", 9695 Tab)); 9696 EXPECT_EQ("{\n" 9697 "\t/*\n" 9698 " asdf\n" 9699 "\t*/\n" 9700 "}", 9701 format("{\n" 9702 "\t/*\n" 9703 " asdf\n" 9704 "\t*/\n" 9705 "}", 9706 Tab)); 9707 9708 Tab.UseTab = FormatStyle::UT_Never; 9709 EXPECT_EQ("/*\n" 9710 " a\t\tcomment\n" 9711 " in multiple lines\n" 9712 " */", 9713 format(" /*\t \t \n" 9714 " \t \t a\t\tcomment\t \t\n" 9715 " \t \t in multiple lines\t\n" 9716 " \t */", 9717 Tab)); 9718 EXPECT_EQ("/* some\n" 9719 " comment */", 9720 format(" \t \t /* some\n" 9721 " \t \t comment */", 9722 Tab)); 9723 EXPECT_EQ("int a; /* some\n" 9724 " comment */", 9725 format(" \t \t int a; /* some\n" 9726 " \t \t comment */", 9727 Tab)); 9728 9729 EXPECT_EQ("int a; /* some\n" 9730 "comment */", 9731 format(" \t \t int\ta; /* some\n" 9732 " \t \t comment */", 9733 Tab)); 9734 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9735 " comment */", 9736 format(" \t \t f(\"\t\t\"); /* some\n" 9737 " \t \t comment */", 9738 Tab)); 9739 EXPECT_EQ("{\n" 9740 " /*\n" 9741 " * Comment\n" 9742 " */\n" 9743 " int i;\n" 9744 "}", 9745 format("{\n" 9746 "\t/*\n" 9747 "\t * Comment\n" 9748 "\t */\n" 9749 "\t int i;\n" 9750 "}")); 9751 9752 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 9753 Tab.TabWidth = 8; 9754 Tab.IndentWidth = 8; 9755 EXPECT_EQ("if (aaaaaaaa && // q\n" 9756 " bb) // w\n" 9757 "\t;", 9758 format("if (aaaaaaaa &&// q\n" 9759 "bb)// w\n" 9760 ";", 9761 Tab)); 9762 EXPECT_EQ("if (aaa && bbb) // w\n" 9763 "\t;", 9764 format("if(aaa&&bbb)// w\n" 9765 ";", 9766 Tab)); 9767 verifyFormat("class X {\n" 9768 "\tvoid f() {\n" 9769 "\t\tsomeFunction(parameter1,\n" 9770 "\t\t\t parameter2);\n" 9771 "\t}\n" 9772 "};", 9773 Tab); 9774 verifyFormat("#define A \\\n" 9775 "\tvoid f() { \\\n" 9776 "\t\tsomeFunction( \\\n" 9777 "\t\t parameter1, \\\n" 9778 "\t\t parameter2); \\\n" 9779 "\t}", 9780 Tab); 9781 Tab.TabWidth = 4; 9782 Tab.IndentWidth = 8; 9783 verifyFormat("class TabWidth4Indent8 {\n" 9784 "\t\tvoid f() {\n" 9785 "\t\t\t\tsomeFunction(parameter1,\n" 9786 "\t\t\t\t\t\t\t parameter2);\n" 9787 "\t\t}\n" 9788 "};", 9789 Tab); 9790 Tab.TabWidth = 4; 9791 Tab.IndentWidth = 4; 9792 verifyFormat("class TabWidth4Indent4 {\n" 9793 "\tvoid f() {\n" 9794 "\t\tsomeFunction(parameter1,\n" 9795 "\t\t\t\t\t parameter2);\n" 9796 "\t}\n" 9797 "};", 9798 Tab); 9799 Tab.TabWidth = 8; 9800 Tab.IndentWidth = 4; 9801 verifyFormat("class TabWidth8Indent4 {\n" 9802 " void f() {\n" 9803 "\tsomeFunction(parameter1,\n" 9804 "\t\t parameter2);\n" 9805 " }\n" 9806 "};", 9807 Tab); 9808 Tab.TabWidth = 8; 9809 Tab.IndentWidth = 8; 9810 EXPECT_EQ("/*\n" 9811 "\t a\t\tcomment\n" 9812 "\t in multiple lines\n" 9813 " */", 9814 format(" /*\t \t \n" 9815 " \t \t a\t\tcomment\t \t\n" 9816 " \t \t in multiple lines\t\n" 9817 " \t */", 9818 Tab)); 9819 verifyFormat("{\n" 9820 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9821 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9822 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9823 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9824 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9825 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9826 "};", 9827 Tab); 9828 verifyFormat("enum AA {\n" 9829 "\ta1, // Force multiple lines\n" 9830 "\ta2,\n" 9831 "\ta3\n" 9832 "};", 9833 Tab); 9834 EXPECT_EQ("if (aaaaaaaa && // q\n" 9835 " bb) // w\n" 9836 "\t;", 9837 format("if (aaaaaaaa &&// q\n" 9838 "bb)// w\n" 9839 ";", 9840 Tab)); 9841 verifyFormat("class X {\n" 9842 "\tvoid f() {\n" 9843 "\t\tsomeFunction(parameter1,\n" 9844 "\t\t\t parameter2);\n" 9845 "\t}\n" 9846 "};", 9847 Tab); 9848 verifyFormat("{\n" 9849 "\tQ(\n" 9850 "\t {\n" 9851 "\t\t int a;\n" 9852 "\t\t someFunction(aaaaaaaa,\n" 9853 "\t\t\t\t bbbbbbb);\n" 9854 "\t },\n" 9855 "\t p);\n" 9856 "}", 9857 Tab); 9858 EXPECT_EQ("{\n" 9859 "\t/* aaaa\n" 9860 "\t bbbb */\n" 9861 "}", 9862 format("{\n" 9863 "/* aaaa\n" 9864 " bbbb */\n" 9865 "}", 9866 Tab)); 9867 EXPECT_EQ("{\n" 9868 "\t/*\n" 9869 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9870 "\t bbbbbbbbbbbbb\n" 9871 "\t*/\n" 9872 "}", 9873 format("{\n" 9874 "/*\n" 9875 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9876 "*/\n" 9877 "}", 9878 Tab)); 9879 EXPECT_EQ("{\n" 9880 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9881 "\t// bbbbbbbbbbbbb\n" 9882 "}", 9883 format("{\n" 9884 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9885 "}", 9886 Tab)); 9887 EXPECT_EQ("{\n" 9888 "\t/*\n" 9889 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9890 "\t bbbbbbbbbbbbb\n" 9891 "\t*/\n" 9892 "}", 9893 format("{\n" 9894 "\t/*\n" 9895 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9896 "\t*/\n" 9897 "}", 9898 Tab)); 9899 EXPECT_EQ("{\n" 9900 "\t/*\n" 9901 "\n" 9902 "\t*/\n" 9903 "}", 9904 format("{\n" 9905 "\t/*\n" 9906 "\n" 9907 "\t*/\n" 9908 "}", 9909 Tab)); 9910 EXPECT_EQ("{\n" 9911 "\t/*\n" 9912 " asdf\n" 9913 "\t*/\n" 9914 "}", 9915 format("{\n" 9916 "\t/*\n" 9917 " asdf\n" 9918 "\t*/\n" 9919 "}", 9920 Tab)); 9921 EXPECT_EQ("/*\n" 9922 "\t a\t\tcomment\n" 9923 "\t in multiple lines\n" 9924 " */", 9925 format(" /*\t \t \n" 9926 " \t \t a\t\tcomment\t \t\n" 9927 " \t \t in multiple lines\t\n" 9928 " \t */", 9929 Tab)); 9930 EXPECT_EQ("/* some\n" 9931 " comment */", 9932 format(" \t \t /* some\n" 9933 " \t \t comment */", 9934 Tab)); 9935 EXPECT_EQ("int a; /* some\n" 9936 " comment */", 9937 format(" \t \t int a; /* some\n" 9938 " \t \t comment */", 9939 Tab)); 9940 EXPECT_EQ("int a; /* some\n" 9941 "comment */", 9942 format(" \t \t int\ta; /* some\n" 9943 " \t \t comment */", 9944 Tab)); 9945 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9946 " comment */", 9947 format(" \t \t f(\"\t\t\"); /* some\n" 9948 " \t \t comment */", 9949 Tab)); 9950 EXPECT_EQ("{\n" 9951 " /*\n" 9952 " * Comment\n" 9953 " */\n" 9954 " int i;\n" 9955 "}", 9956 format("{\n" 9957 "\t/*\n" 9958 "\t * Comment\n" 9959 "\t */\n" 9960 "\t int i;\n" 9961 "}")); 9962 Tab.AlignConsecutiveAssignments = true; 9963 Tab.AlignConsecutiveDeclarations = true; 9964 Tab.TabWidth = 4; 9965 Tab.IndentWidth = 4; 9966 verifyFormat("class Assign {\n" 9967 "\tvoid f() {\n" 9968 "\t\tint x = 123;\n" 9969 "\t\tint random = 4;\n" 9970 "\t\tstd::string alphabet =\n" 9971 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 9972 "\t}\n" 9973 "};", 9974 Tab); 9975 } 9976 9977 TEST_F(FormatTest, ZeroTabWidth) { 9978 FormatStyle Tab = getLLVMStyleWithColumns(42); 9979 Tab.IndentWidth = 8; 9980 Tab.UseTab = FormatStyle::UT_Never; 9981 Tab.TabWidth = 0; 9982 EXPECT_EQ("void a(){\n" 9983 " // line starts with '\t'\n" 9984 "};", 9985 format("void a(){\n" 9986 "\t// line starts with '\t'\n" 9987 "};", 9988 Tab)); 9989 9990 EXPECT_EQ("void a(){\n" 9991 " // line starts with '\t'\n" 9992 "};", 9993 format("void a(){\n" 9994 "\t\t// line starts with '\t'\n" 9995 "};", 9996 Tab)); 9997 9998 Tab.UseTab = FormatStyle::UT_ForIndentation; 9999 EXPECT_EQ("void a(){\n" 10000 " // line starts with '\t'\n" 10001 "};", 10002 format("void a(){\n" 10003 "\t// line starts with '\t'\n" 10004 "};", 10005 Tab)); 10006 10007 EXPECT_EQ("void a(){\n" 10008 " // line starts with '\t'\n" 10009 "};", 10010 format("void a(){\n" 10011 "\t\t// line starts with '\t'\n" 10012 "};", 10013 Tab)); 10014 10015 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10016 EXPECT_EQ("void a(){\n" 10017 " // line starts with '\t'\n" 10018 "};", 10019 format("void a(){\n" 10020 "\t// line starts with '\t'\n" 10021 "};", 10022 Tab)); 10023 10024 EXPECT_EQ("void a(){\n" 10025 " // line starts with '\t'\n" 10026 "};", 10027 format("void a(){\n" 10028 "\t\t// line starts with '\t'\n" 10029 "};", 10030 Tab)); 10031 10032 Tab.UseTab = FormatStyle::UT_Always; 10033 EXPECT_EQ("void a(){\n" 10034 "// line starts with '\t'\n" 10035 "};", 10036 format("void a(){\n" 10037 "\t// line starts with '\t'\n" 10038 "};", 10039 Tab)); 10040 10041 EXPECT_EQ("void a(){\n" 10042 "// line starts with '\t'\n" 10043 "};", 10044 format("void a(){\n" 10045 "\t\t// line starts with '\t'\n" 10046 "};", 10047 Tab)); 10048 } 10049 10050 TEST_F(FormatTest, CalculatesOriginalColumn) { 10051 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10052 "q\"; /* some\n" 10053 " comment */", 10054 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10055 "q\"; /* some\n" 10056 " comment */", 10057 getLLVMStyle())); 10058 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10059 "/* some\n" 10060 " comment */", 10061 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10062 " /* some\n" 10063 " comment */", 10064 getLLVMStyle())); 10065 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10066 "qqq\n" 10067 "/* some\n" 10068 " comment */", 10069 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10070 "qqq\n" 10071 " /* some\n" 10072 " comment */", 10073 getLLVMStyle())); 10074 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10075 "wwww; /* some\n" 10076 " comment */", 10077 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10078 "wwww; /* some\n" 10079 " comment */", 10080 getLLVMStyle())); 10081 } 10082 10083 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 10084 FormatStyle NoSpace = getLLVMStyle(); 10085 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 10086 10087 verifyFormat("while(true)\n" 10088 " continue;", 10089 NoSpace); 10090 verifyFormat("for(;;)\n" 10091 " continue;", 10092 NoSpace); 10093 verifyFormat("if(true)\n" 10094 " f();\n" 10095 "else if(true)\n" 10096 " f();", 10097 NoSpace); 10098 verifyFormat("do {\n" 10099 " do_something();\n" 10100 "} while(something());", 10101 NoSpace); 10102 verifyFormat("switch(x) {\n" 10103 "default:\n" 10104 " break;\n" 10105 "}", 10106 NoSpace); 10107 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 10108 verifyFormat("size_t x = sizeof(x);", NoSpace); 10109 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 10110 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 10111 verifyFormat("alignas(128) char a[128];", NoSpace); 10112 verifyFormat("size_t x = alignof(MyType);", NoSpace); 10113 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 10114 verifyFormat("int f() throw(Deprecated);", NoSpace); 10115 verifyFormat("typedef void (*cb)(int);", NoSpace); 10116 verifyFormat("T A::operator()();", NoSpace); 10117 verifyFormat("X A::operator++(T);", NoSpace); 10118 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 10119 10120 FormatStyle Space = getLLVMStyle(); 10121 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 10122 10123 verifyFormat("int f ();", Space); 10124 verifyFormat("void f (int a, T b) {\n" 10125 " while (true)\n" 10126 " continue;\n" 10127 "}", 10128 Space); 10129 verifyFormat("if (true)\n" 10130 " f ();\n" 10131 "else if (true)\n" 10132 " f ();", 10133 Space); 10134 verifyFormat("do {\n" 10135 " do_something ();\n" 10136 "} while (something ());", 10137 Space); 10138 verifyFormat("switch (x) {\n" 10139 "default:\n" 10140 " break;\n" 10141 "}", 10142 Space); 10143 verifyFormat("A::A () : a (1) {}", Space); 10144 verifyFormat("void f () __attribute__ ((asdf));", Space); 10145 verifyFormat("*(&a + 1);\n" 10146 "&((&a)[1]);\n" 10147 "a[(b + c) * d];\n" 10148 "(((a + 1) * 2) + 3) * 4;", 10149 Space); 10150 verifyFormat("#define A(x) x", Space); 10151 verifyFormat("#define A (x) x", Space); 10152 verifyFormat("#if defined(x)\n" 10153 "#endif", 10154 Space); 10155 verifyFormat("auto i = std::make_unique<int> (5);", Space); 10156 verifyFormat("size_t x = sizeof (x);", Space); 10157 verifyFormat("auto f (int x) -> decltype (x);", Space); 10158 verifyFormat("int f (T x) noexcept (x.create ());", Space); 10159 verifyFormat("alignas (128) char a[128];", Space); 10160 verifyFormat("size_t x = alignof (MyType);", Space); 10161 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 10162 verifyFormat("int f () throw (Deprecated);", Space); 10163 verifyFormat("typedef void (*cb) (int);", Space); 10164 verifyFormat("T A::operator() ();", Space); 10165 verifyFormat("X A::operator++ (T);", Space); 10166 verifyFormat("auto lambda = [] () { return 0; };", Space); 10167 verifyFormat("int x = int (y);", Space); 10168 10169 FormatStyle SomeSpace = getLLVMStyle(); 10170 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 10171 10172 verifyFormat("[]() -> float {}", SomeSpace); 10173 verifyFormat("[] (auto foo) {}", SomeSpace); 10174 verifyFormat("[foo]() -> int {}", SomeSpace); 10175 verifyFormat("int f();", SomeSpace); 10176 verifyFormat("void f (int a, T b) {\n" 10177 " while (true)\n" 10178 " continue;\n" 10179 "}", 10180 SomeSpace); 10181 verifyFormat("if (true)\n" 10182 " f();\n" 10183 "else if (true)\n" 10184 " f();", 10185 SomeSpace); 10186 verifyFormat("do {\n" 10187 " do_something();\n" 10188 "} while (something());", 10189 SomeSpace); 10190 verifyFormat("switch (x) {\n" 10191 "default:\n" 10192 " break;\n" 10193 "}", 10194 SomeSpace); 10195 verifyFormat("A::A() : a (1) {}", SomeSpace); 10196 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 10197 verifyFormat("*(&a + 1);\n" 10198 "&((&a)[1]);\n" 10199 "a[(b + c) * d];\n" 10200 "(((a + 1) * 2) + 3) * 4;", 10201 SomeSpace); 10202 verifyFormat("#define A(x) x", SomeSpace); 10203 verifyFormat("#define A (x) x", SomeSpace); 10204 verifyFormat("#if defined(x)\n" 10205 "#endif", 10206 SomeSpace); 10207 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 10208 verifyFormat("size_t x = sizeof (x);", SomeSpace); 10209 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 10210 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 10211 verifyFormat("alignas (128) char a[128];", SomeSpace); 10212 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 10213 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 10214 SomeSpace); 10215 verifyFormat("int f() throw (Deprecated);", SomeSpace); 10216 verifyFormat("typedef void (*cb) (int);", SomeSpace); 10217 verifyFormat("T A::operator()();", SomeSpace); 10218 verifyFormat("X A::operator++ (T);", SomeSpace); 10219 verifyFormat("int x = int (y);", SomeSpace); 10220 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 10221 } 10222 10223 TEST_F(FormatTest, SpaceAfterLogicalNot) { 10224 FormatStyle Spaces = getLLVMStyle(); 10225 Spaces.SpaceAfterLogicalNot = true; 10226 10227 verifyFormat("bool x = ! y", Spaces); 10228 verifyFormat("if (! isFailure())", Spaces); 10229 verifyFormat("if (! (a && b))", Spaces); 10230 verifyFormat("\"Error!\"", Spaces); 10231 verifyFormat("! ! x", Spaces); 10232 } 10233 10234 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 10235 FormatStyle Spaces = getLLVMStyle(); 10236 10237 Spaces.SpacesInParentheses = true; 10238 verifyFormat("do_something( ::globalVar );", Spaces); 10239 verifyFormat("call( x, y, z );", Spaces); 10240 verifyFormat("call();", Spaces); 10241 verifyFormat("std::function<void( int, int )> callback;", Spaces); 10242 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 10243 Spaces); 10244 verifyFormat("while ( (bool)1 )\n" 10245 " continue;", 10246 Spaces); 10247 verifyFormat("for ( ;; )\n" 10248 " continue;", 10249 Spaces); 10250 verifyFormat("if ( true )\n" 10251 " f();\n" 10252 "else if ( true )\n" 10253 " f();", 10254 Spaces); 10255 verifyFormat("do {\n" 10256 " do_something( (int)i );\n" 10257 "} while ( something() );", 10258 Spaces); 10259 verifyFormat("switch ( x ) {\n" 10260 "default:\n" 10261 " break;\n" 10262 "}", 10263 Spaces); 10264 10265 Spaces.SpacesInParentheses = false; 10266 Spaces.SpacesInCStyleCastParentheses = true; 10267 verifyFormat("Type *A = ( Type * )P;", Spaces); 10268 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 10269 verifyFormat("x = ( int32 )y;", Spaces); 10270 verifyFormat("int a = ( int )(2.0f);", Spaces); 10271 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 10272 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 10273 verifyFormat("#define x (( int )-1)", Spaces); 10274 10275 // Run the first set of tests again with: 10276 Spaces.SpacesInParentheses = false; 10277 Spaces.SpaceInEmptyParentheses = true; 10278 Spaces.SpacesInCStyleCastParentheses = true; 10279 verifyFormat("call(x, y, z);", Spaces); 10280 verifyFormat("call( );", Spaces); 10281 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10282 verifyFormat("while (( bool )1)\n" 10283 " continue;", 10284 Spaces); 10285 verifyFormat("for (;;)\n" 10286 " continue;", 10287 Spaces); 10288 verifyFormat("if (true)\n" 10289 " f( );\n" 10290 "else if (true)\n" 10291 " f( );", 10292 Spaces); 10293 verifyFormat("do {\n" 10294 " do_something(( int )i);\n" 10295 "} while (something( ));", 10296 Spaces); 10297 verifyFormat("switch (x) {\n" 10298 "default:\n" 10299 " break;\n" 10300 "}", 10301 Spaces); 10302 10303 // Run the first set of tests again with: 10304 Spaces.SpaceAfterCStyleCast = true; 10305 verifyFormat("call(x, y, z);", Spaces); 10306 verifyFormat("call( );", Spaces); 10307 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10308 verifyFormat("while (( bool ) 1)\n" 10309 " continue;", 10310 Spaces); 10311 verifyFormat("for (;;)\n" 10312 " continue;", 10313 Spaces); 10314 verifyFormat("if (true)\n" 10315 " f( );\n" 10316 "else if (true)\n" 10317 " f( );", 10318 Spaces); 10319 verifyFormat("do {\n" 10320 " do_something(( int ) i);\n" 10321 "} while (something( ));", 10322 Spaces); 10323 verifyFormat("switch (x) {\n" 10324 "default:\n" 10325 " break;\n" 10326 "}", 10327 Spaces); 10328 10329 // Run subset of tests again with: 10330 Spaces.SpacesInCStyleCastParentheses = false; 10331 Spaces.SpaceAfterCStyleCast = true; 10332 verifyFormat("while ((bool) 1)\n" 10333 " continue;", 10334 Spaces); 10335 verifyFormat("do {\n" 10336 " do_something((int) i);\n" 10337 "} while (something( ));", 10338 Spaces); 10339 } 10340 10341 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 10342 verifyFormat("int a[5];"); 10343 verifyFormat("a[3] += 42;"); 10344 10345 FormatStyle Spaces = getLLVMStyle(); 10346 Spaces.SpacesInSquareBrackets = true; 10347 // Lambdas unchanged. 10348 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 10349 verifyFormat("return [i, args...] {};", Spaces); 10350 10351 // Not lambdas. 10352 verifyFormat("int a[ 5 ];", Spaces); 10353 verifyFormat("a[ 3 ] += 42;", Spaces); 10354 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 10355 verifyFormat("double &operator[](int i) { return 0; }\n" 10356 "int i;", 10357 Spaces); 10358 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 10359 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 10360 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 10361 } 10362 10363 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 10364 verifyFormat("int a = 5;"); 10365 verifyFormat("a += 42;"); 10366 verifyFormat("a or_eq 8;"); 10367 10368 FormatStyle Spaces = getLLVMStyle(); 10369 Spaces.SpaceBeforeAssignmentOperators = false; 10370 verifyFormat("int a= 5;", Spaces); 10371 verifyFormat("a+= 42;", Spaces); 10372 verifyFormat("a or_eq 8;", Spaces); 10373 } 10374 10375 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 10376 verifyFormat("class Foo : public Bar {};"); 10377 verifyFormat("Foo::Foo() : foo(1) {}"); 10378 verifyFormat("for (auto a : b) {\n}"); 10379 verifyFormat("int x = a ? b : c;"); 10380 verifyFormat("{\n" 10381 "label0:\n" 10382 " int x = 0;\n" 10383 "}"); 10384 verifyFormat("switch (x) {\n" 10385 "case 1:\n" 10386 "default:\n" 10387 "}"); 10388 10389 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 10390 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 10391 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 10392 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 10393 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 10394 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 10395 verifyFormat("{\n" 10396 "label1:\n" 10397 " int x = 0;\n" 10398 "}", 10399 CtorInitializerStyle); 10400 verifyFormat("switch (x) {\n" 10401 "case 1:\n" 10402 "default:\n" 10403 "}", 10404 CtorInitializerStyle); 10405 CtorInitializerStyle.BreakConstructorInitializers = 10406 FormatStyle::BCIS_AfterColon; 10407 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 10408 " aaaaaaaaaaaaaaaa(1),\n" 10409 " bbbbbbbbbbbbbbbb(2) {}", 10410 CtorInitializerStyle); 10411 CtorInitializerStyle.BreakConstructorInitializers = 10412 FormatStyle::BCIS_BeforeComma; 10413 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10414 " : aaaaaaaaaaaaaaaa(1)\n" 10415 " , bbbbbbbbbbbbbbbb(2) {}", 10416 CtorInitializerStyle); 10417 CtorInitializerStyle.BreakConstructorInitializers = 10418 FormatStyle::BCIS_BeforeColon; 10419 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10420 " : aaaaaaaaaaaaaaaa(1),\n" 10421 " bbbbbbbbbbbbbbbb(2) {}", 10422 CtorInitializerStyle); 10423 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 10424 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10425 ": aaaaaaaaaaaaaaaa(1),\n" 10426 " bbbbbbbbbbbbbbbb(2) {}", 10427 CtorInitializerStyle); 10428 10429 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 10430 InheritanceStyle.SpaceBeforeInheritanceColon = false; 10431 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 10432 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 10433 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 10434 verifyFormat("int x = a ? b : c;", InheritanceStyle); 10435 verifyFormat("{\n" 10436 "label2:\n" 10437 " int x = 0;\n" 10438 "}", 10439 InheritanceStyle); 10440 verifyFormat("switch (x) {\n" 10441 "case 1:\n" 10442 "default:\n" 10443 "}", 10444 InheritanceStyle); 10445 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 10446 verifyFormat("class Foooooooooooooooooooooo:\n" 10447 " public aaaaaaaaaaaaaaaaaa,\n" 10448 " public bbbbbbbbbbbbbbbbbb {\n" 10449 "}", 10450 InheritanceStyle); 10451 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 10452 verifyFormat("class Foooooooooooooooooooooo\n" 10453 " : public aaaaaaaaaaaaaaaaaa\n" 10454 " , public bbbbbbbbbbbbbbbbbb {\n" 10455 "}", 10456 InheritanceStyle); 10457 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 10458 verifyFormat("class Foooooooooooooooooooooo\n" 10459 " : public aaaaaaaaaaaaaaaaaa,\n" 10460 " public bbbbbbbbbbbbbbbbbb {\n" 10461 "}", 10462 InheritanceStyle); 10463 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 10464 verifyFormat("class Foooooooooooooooooooooo\n" 10465 ": public aaaaaaaaaaaaaaaaaa,\n" 10466 " public bbbbbbbbbbbbbbbbbb {}", 10467 InheritanceStyle); 10468 10469 FormatStyle ForLoopStyle = getLLVMStyle(); 10470 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 10471 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 10472 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 10473 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 10474 verifyFormat("int x = a ? b : c;", ForLoopStyle); 10475 verifyFormat("{\n" 10476 "label2:\n" 10477 " int x = 0;\n" 10478 "}", 10479 ForLoopStyle); 10480 verifyFormat("switch (x) {\n" 10481 "case 1:\n" 10482 "default:\n" 10483 "}", 10484 ForLoopStyle); 10485 10486 FormatStyle NoSpaceStyle = getLLVMStyle(); 10487 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 10488 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 10489 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 10490 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 10491 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 10492 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 10493 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 10494 verifyFormat("{\n" 10495 "label3:\n" 10496 " int x = 0;\n" 10497 "}", 10498 NoSpaceStyle); 10499 verifyFormat("switch (x) {\n" 10500 "case 1:\n" 10501 "default:\n" 10502 "}", 10503 NoSpaceStyle); 10504 } 10505 10506 TEST_F(FormatTest, AlignConsecutiveMacros) { 10507 FormatStyle Style = getLLVMStyle(); 10508 Style.AlignConsecutiveAssignments = true; 10509 Style.AlignConsecutiveDeclarations = true; 10510 Style.AlignConsecutiveMacros = false; 10511 10512 verifyFormat("#define a 3\n" 10513 "#define bbbb 4\n" 10514 "#define ccc (5)", 10515 Style); 10516 10517 verifyFormat("#define f(x) (x * x)\n" 10518 "#define fff(x, y, z) (x * y + z)\n" 10519 "#define ffff(x, y) (x - y)", 10520 Style); 10521 10522 verifyFormat("#define foo(x, y) (x + y)\n" 10523 "#define bar (5, 6)(2 + 2)", 10524 Style); 10525 10526 verifyFormat("#define a 3\n" 10527 "#define bbbb 4\n" 10528 "#define ccc (5)\n" 10529 "#define f(x) (x * x)\n" 10530 "#define fff(x, y, z) (x * y + z)\n" 10531 "#define ffff(x, y) (x - y)", 10532 Style); 10533 10534 Style.AlignConsecutiveMacros = true; 10535 verifyFormat("#define a 3\n" 10536 "#define bbbb 4\n" 10537 "#define ccc (5)", 10538 Style); 10539 10540 verifyFormat("#define f(x) (x * x)\n" 10541 "#define fff(x, y, z) (x * y + z)\n" 10542 "#define ffff(x, y) (x - y)", 10543 Style); 10544 10545 verifyFormat("#define foo(x, y) (x + y)\n" 10546 "#define bar (5, 6)(2 + 2)", 10547 Style); 10548 10549 verifyFormat("#define a 3\n" 10550 "#define bbbb 4\n" 10551 "#define ccc (5)\n" 10552 "#define f(x) (x * x)\n" 10553 "#define fff(x, y, z) (x * y + z)\n" 10554 "#define ffff(x, y) (x - y)", 10555 Style); 10556 10557 verifyFormat("#define a 5\n" 10558 "#define foo(x, y) (x + y)\n" 10559 "#define CCC (6)\n" 10560 "auto lambda = []() {\n" 10561 " auto ii = 0;\n" 10562 " float j = 0;\n" 10563 " return 0;\n" 10564 "};\n" 10565 "int i = 0;\n" 10566 "float i2 = 0;\n" 10567 "auto v = type{\n" 10568 " i = 1, //\n" 10569 " (i = 2), //\n" 10570 " i = 3 //\n" 10571 "};", 10572 Style); 10573 10574 Style.AlignConsecutiveMacros = false; 10575 Style.ColumnLimit = 20; 10576 10577 verifyFormat("#define a \\\n" 10578 " \"aabbbbbbbbbbbb\"\n" 10579 "#define D \\\n" 10580 " \"aabbbbbbbbbbbb\" \\\n" 10581 " \"ccddeeeeeeeee\"\n" 10582 "#define B \\\n" 10583 " \"QQQQQQQQQQQQQ\" \\\n" 10584 " \"FFFFFFFFFFFFF\" \\\n" 10585 " \"LLLLLLLL\"\n", 10586 Style); 10587 10588 Style.AlignConsecutiveMacros = true; 10589 verifyFormat("#define a \\\n" 10590 " \"aabbbbbbbbbbbb\"\n" 10591 "#define D \\\n" 10592 " \"aabbbbbbbbbbbb\" \\\n" 10593 " \"ccddeeeeeeeee\"\n" 10594 "#define B \\\n" 10595 " \"QQQQQQQQQQQQQ\" \\\n" 10596 " \"FFFFFFFFFFFFF\" \\\n" 10597 " \"LLLLLLLL\"\n", 10598 Style); 10599 } 10600 10601 TEST_F(FormatTest, AlignConsecutiveAssignments) { 10602 FormatStyle Alignment = getLLVMStyle(); 10603 Alignment.AlignConsecutiveMacros = true; 10604 Alignment.AlignConsecutiveAssignments = false; 10605 verifyFormat("int a = 5;\n" 10606 "int oneTwoThree = 123;", 10607 Alignment); 10608 verifyFormat("int a = 5;\n" 10609 "int oneTwoThree = 123;", 10610 Alignment); 10611 10612 Alignment.AlignConsecutiveAssignments = true; 10613 verifyFormat("int a = 5;\n" 10614 "int oneTwoThree = 123;", 10615 Alignment); 10616 verifyFormat("int a = method();\n" 10617 "int oneTwoThree = 133;", 10618 Alignment); 10619 verifyFormat("a &= 5;\n" 10620 "bcd *= 5;\n" 10621 "ghtyf += 5;\n" 10622 "dvfvdb -= 5;\n" 10623 "a /= 5;\n" 10624 "vdsvsv %= 5;\n" 10625 "sfdbddfbdfbb ^= 5;\n" 10626 "dvsdsv |= 5;\n" 10627 "int dsvvdvsdvvv = 123;", 10628 Alignment); 10629 verifyFormat("int i = 1, j = 10;\n" 10630 "something = 2000;", 10631 Alignment); 10632 verifyFormat("something = 2000;\n" 10633 "int i = 1, j = 10;\n", 10634 Alignment); 10635 verifyFormat("something = 2000;\n" 10636 "another = 911;\n" 10637 "int i = 1, j = 10;\n" 10638 "oneMore = 1;\n" 10639 "i = 2;", 10640 Alignment); 10641 verifyFormat("int a = 5;\n" 10642 "int one = 1;\n" 10643 "method();\n" 10644 "int oneTwoThree = 123;\n" 10645 "int oneTwo = 12;", 10646 Alignment); 10647 verifyFormat("int oneTwoThree = 123;\n" 10648 "int oneTwo = 12;\n" 10649 "method();\n", 10650 Alignment); 10651 verifyFormat("int oneTwoThree = 123; // comment\n" 10652 "int oneTwo = 12; // comment", 10653 Alignment); 10654 EXPECT_EQ("int a = 5;\n" 10655 "\n" 10656 "int oneTwoThree = 123;", 10657 format("int a = 5;\n" 10658 "\n" 10659 "int oneTwoThree= 123;", 10660 Alignment)); 10661 EXPECT_EQ("int a = 5;\n" 10662 "int one = 1;\n" 10663 "\n" 10664 "int oneTwoThree = 123;", 10665 format("int a = 5;\n" 10666 "int one = 1;\n" 10667 "\n" 10668 "int oneTwoThree = 123;", 10669 Alignment)); 10670 EXPECT_EQ("int a = 5;\n" 10671 "int one = 1;\n" 10672 "\n" 10673 "int oneTwoThree = 123;\n" 10674 "int oneTwo = 12;", 10675 format("int a = 5;\n" 10676 "int one = 1;\n" 10677 "\n" 10678 "int oneTwoThree = 123;\n" 10679 "int oneTwo = 12;", 10680 Alignment)); 10681 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10682 verifyFormat("#define A \\\n" 10683 " int aaaa = 12; \\\n" 10684 " int b = 23; \\\n" 10685 " int ccc = 234; \\\n" 10686 " int dddddddddd = 2345;", 10687 Alignment); 10688 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10689 verifyFormat("#define A \\\n" 10690 " int aaaa = 12; \\\n" 10691 " int b = 23; \\\n" 10692 " int ccc = 234; \\\n" 10693 " int dddddddddd = 2345;", 10694 Alignment); 10695 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10696 verifyFormat("#define A " 10697 " \\\n" 10698 " int aaaa = 12; " 10699 " \\\n" 10700 " int b = 23; " 10701 " \\\n" 10702 " int ccc = 234; " 10703 " \\\n" 10704 " int dddddddddd = 2345;", 10705 Alignment); 10706 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10707 "k = 4, int l = 5,\n" 10708 " int m = 6) {\n" 10709 " int j = 10;\n" 10710 " otherThing = 1;\n" 10711 "}", 10712 Alignment); 10713 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10714 " int i = 1;\n" 10715 " int j = 2;\n" 10716 " int big = 10000;\n" 10717 "}", 10718 Alignment); 10719 verifyFormat("class C {\n" 10720 "public:\n" 10721 " int i = 1;\n" 10722 " virtual void f() = 0;\n" 10723 "};", 10724 Alignment); 10725 verifyFormat("int i = 1;\n" 10726 "if (SomeType t = getSomething()) {\n" 10727 "}\n" 10728 "int j = 2;\n" 10729 "int big = 10000;", 10730 Alignment); 10731 verifyFormat("int j = 7;\n" 10732 "for (int k = 0; k < N; ++k) {\n" 10733 "}\n" 10734 "int j = 2;\n" 10735 "int big = 10000;\n" 10736 "}", 10737 Alignment); 10738 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10739 verifyFormat("int i = 1;\n" 10740 "LooooooooooongType loooooooooooooooooooooongVariable\n" 10741 " = someLooooooooooooooooongFunction();\n" 10742 "int j = 2;", 10743 Alignment); 10744 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 10745 verifyFormat("int i = 1;\n" 10746 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 10747 " someLooooooooooooooooongFunction();\n" 10748 "int j = 2;", 10749 Alignment); 10750 10751 verifyFormat("auto lambda = []() {\n" 10752 " auto i = 0;\n" 10753 " return 0;\n" 10754 "};\n" 10755 "int i = 0;\n" 10756 "auto v = type{\n" 10757 " i = 1, //\n" 10758 " (i = 2), //\n" 10759 " i = 3 //\n" 10760 "};", 10761 Alignment); 10762 10763 verifyFormat( 10764 "int i = 1;\n" 10765 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 10766 " loooooooooooooooooooooongParameterB);\n" 10767 "int j = 2;", 10768 Alignment); 10769 10770 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 10771 " typename B = very_long_type_name_1,\n" 10772 " typename T_2 = very_long_type_name_2>\n" 10773 "auto foo() {}\n", 10774 Alignment); 10775 verifyFormat("int a, b = 1;\n" 10776 "int c = 2;\n" 10777 "int dd = 3;\n", 10778 Alignment); 10779 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10780 "float b[1][] = {{3.f}};\n", 10781 Alignment); 10782 verifyFormat("for (int i = 0; i < 1; i++)\n" 10783 " int x = 1;\n", 10784 Alignment); 10785 verifyFormat("for (i = 0; i < 1; i++)\n" 10786 " x = 1;\n" 10787 "y = 1;\n", 10788 Alignment); 10789 } 10790 10791 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 10792 FormatStyle Alignment = getLLVMStyle(); 10793 Alignment.AlignConsecutiveMacros = true; 10794 Alignment.AlignConsecutiveDeclarations = false; 10795 verifyFormat("float const a = 5;\n" 10796 "int oneTwoThree = 123;", 10797 Alignment); 10798 verifyFormat("int a = 5;\n" 10799 "float const oneTwoThree = 123;", 10800 Alignment); 10801 10802 Alignment.AlignConsecutiveDeclarations = true; 10803 verifyFormat("float const a = 5;\n" 10804 "int oneTwoThree = 123;", 10805 Alignment); 10806 verifyFormat("int a = method();\n" 10807 "float const oneTwoThree = 133;", 10808 Alignment); 10809 verifyFormat("int i = 1, j = 10;\n" 10810 "something = 2000;", 10811 Alignment); 10812 verifyFormat("something = 2000;\n" 10813 "int i = 1, j = 10;\n", 10814 Alignment); 10815 verifyFormat("float something = 2000;\n" 10816 "double another = 911;\n" 10817 "int i = 1, j = 10;\n" 10818 "const int *oneMore = 1;\n" 10819 "unsigned i = 2;", 10820 Alignment); 10821 verifyFormat("float a = 5;\n" 10822 "int one = 1;\n" 10823 "method();\n" 10824 "const double oneTwoThree = 123;\n" 10825 "const unsigned int oneTwo = 12;", 10826 Alignment); 10827 verifyFormat("int oneTwoThree{0}; // comment\n" 10828 "unsigned oneTwo; // comment", 10829 Alignment); 10830 EXPECT_EQ("float const a = 5;\n" 10831 "\n" 10832 "int oneTwoThree = 123;", 10833 format("float const a = 5;\n" 10834 "\n" 10835 "int oneTwoThree= 123;", 10836 Alignment)); 10837 EXPECT_EQ("float a = 5;\n" 10838 "int one = 1;\n" 10839 "\n" 10840 "unsigned oneTwoThree = 123;", 10841 format("float a = 5;\n" 10842 "int one = 1;\n" 10843 "\n" 10844 "unsigned oneTwoThree = 123;", 10845 Alignment)); 10846 EXPECT_EQ("float a = 5;\n" 10847 "int one = 1;\n" 10848 "\n" 10849 "unsigned oneTwoThree = 123;\n" 10850 "int oneTwo = 12;", 10851 format("float a = 5;\n" 10852 "int one = 1;\n" 10853 "\n" 10854 "unsigned oneTwoThree = 123;\n" 10855 "int oneTwo = 12;", 10856 Alignment)); 10857 // Function prototype alignment 10858 verifyFormat("int a();\n" 10859 "double b();", 10860 Alignment); 10861 verifyFormat("int a(int x);\n" 10862 "double b();", 10863 Alignment); 10864 unsigned OldColumnLimit = Alignment.ColumnLimit; 10865 // We need to set ColumnLimit to zero, in order to stress nested alignments, 10866 // otherwise the function parameters will be re-flowed onto a single line. 10867 Alignment.ColumnLimit = 0; 10868 EXPECT_EQ("int a(int x,\n" 10869 " float y);\n" 10870 "double b(int x,\n" 10871 " double y);", 10872 format("int a(int x,\n" 10873 " float y);\n" 10874 "double b(int x,\n" 10875 " double y);", 10876 Alignment)); 10877 // This ensures that function parameters of function declarations are 10878 // correctly indented when their owning functions are indented. 10879 // The failure case here is for 'double y' to not be indented enough. 10880 EXPECT_EQ("double a(int x);\n" 10881 "int b(int y,\n" 10882 " double z);", 10883 format("double a(int x);\n" 10884 "int b(int y,\n" 10885 " double z);", 10886 Alignment)); 10887 // Set ColumnLimit low so that we induce wrapping immediately after 10888 // the function name and opening paren. 10889 Alignment.ColumnLimit = 13; 10890 verifyFormat("int function(\n" 10891 " int x,\n" 10892 " bool y);", 10893 Alignment); 10894 Alignment.ColumnLimit = OldColumnLimit; 10895 // Ensure function pointers don't screw up recursive alignment 10896 verifyFormat("int a(int x, void (*fp)(int y));\n" 10897 "double b();", 10898 Alignment); 10899 Alignment.AlignConsecutiveAssignments = true; 10900 // Ensure recursive alignment is broken by function braces, so that the 10901 // "a = 1" does not align with subsequent assignments inside the function 10902 // body. 10903 verifyFormat("int func(int a = 1) {\n" 10904 " int b = 2;\n" 10905 " int cc = 3;\n" 10906 "}", 10907 Alignment); 10908 verifyFormat("float something = 2000;\n" 10909 "double another = 911;\n" 10910 "int i = 1, j = 10;\n" 10911 "const int *oneMore = 1;\n" 10912 "unsigned i = 2;", 10913 Alignment); 10914 verifyFormat("int oneTwoThree = {0}; // comment\n" 10915 "unsigned oneTwo = 0; // comment", 10916 Alignment); 10917 // Make sure that scope is correctly tracked, in the absence of braces 10918 verifyFormat("for (int i = 0; i < n; i++)\n" 10919 " j = i;\n" 10920 "double x = 1;\n", 10921 Alignment); 10922 verifyFormat("if (int i = 0)\n" 10923 " j = i;\n" 10924 "double x = 1;\n", 10925 Alignment); 10926 // Ensure operator[] and operator() are comprehended 10927 verifyFormat("struct test {\n" 10928 " long long int foo();\n" 10929 " int operator[](int a);\n" 10930 " double bar();\n" 10931 "};\n", 10932 Alignment); 10933 verifyFormat("struct test {\n" 10934 " long long int foo();\n" 10935 " int operator()(int a);\n" 10936 " double bar();\n" 10937 "};\n", 10938 Alignment); 10939 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 10940 " int const i = 1;\n" 10941 " int * j = 2;\n" 10942 " int big = 10000;\n" 10943 "\n" 10944 " unsigned oneTwoThree = 123;\n" 10945 " int oneTwo = 12;\n" 10946 " method();\n" 10947 " float k = 2;\n" 10948 " int ll = 10000;\n" 10949 "}", 10950 format("void SomeFunction(int parameter= 0) {\n" 10951 " int const i= 1;\n" 10952 " int *j=2;\n" 10953 " int big = 10000;\n" 10954 "\n" 10955 "unsigned oneTwoThree =123;\n" 10956 "int oneTwo = 12;\n" 10957 " method();\n" 10958 "float k= 2;\n" 10959 "int ll=10000;\n" 10960 "}", 10961 Alignment)); 10962 Alignment.AlignConsecutiveAssignments = false; 10963 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10964 verifyFormat("#define A \\\n" 10965 " int aaaa = 12; \\\n" 10966 " float b = 23; \\\n" 10967 " const int ccc = 234; \\\n" 10968 " unsigned dddddddddd = 2345;", 10969 Alignment); 10970 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10971 verifyFormat("#define A \\\n" 10972 " int aaaa = 12; \\\n" 10973 " float b = 23; \\\n" 10974 " const int ccc = 234; \\\n" 10975 " unsigned dddddddddd = 2345;", 10976 Alignment); 10977 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10978 Alignment.ColumnLimit = 30; 10979 verifyFormat("#define A \\\n" 10980 " int aaaa = 12; \\\n" 10981 " float b = 23; \\\n" 10982 " const int ccc = 234; \\\n" 10983 " int dddddddddd = 2345;", 10984 Alignment); 10985 Alignment.ColumnLimit = 80; 10986 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10987 "k = 4, int l = 5,\n" 10988 " int m = 6) {\n" 10989 " const int j = 10;\n" 10990 " otherThing = 1;\n" 10991 "}", 10992 Alignment); 10993 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10994 " int const i = 1;\n" 10995 " int * j = 2;\n" 10996 " int big = 10000;\n" 10997 "}", 10998 Alignment); 10999 verifyFormat("class C {\n" 11000 "public:\n" 11001 " int i = 1;\n" 11002 " virtual void f() = 0;\n" 11003 "};", 11004 Alignment); 11005 verifyFormat("float i = 1;\n" 11006 "if (SomeType t = getSomething()) {\n" 11007 "}\n" 11008 "const unsigned j = 2;\n" 11009 "int big = 10000;", 11010 Alignment); 11011 verifyFormat("float j = 7;\n" 11012 "for (int k = 0; k < N; ++k) {\n" 11013 "}\n" 11014 "unsigned j = 2;\n" 11015 "int big = 10000;\n" 11016 "}", 11017 Alignment); 11018 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11019 verifyFormat("float i = 1;\n" 11020 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11021 " = someLooooooooooooooooongFunction();\n" 11022 "int j = 2;", 11023 Alignment); 11024 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11025 verifyFormat("int i = 1;\n" 11026 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11027 " someLooooooooooooooooongFunction();\n" 11028 "int j = 2;", 11029 Alignment); 11030 11031 Alignment.AlignConsecutiveAssignments = true; 11032 verifyFormat("auto lambda = []() {\n" 11033 " auto ii = 0;\n" 11034 " float j = 0;\n" 11035 " return 0;\n" 11036 "};\n" 11037 "int i = 0;\n" 11038 "float i2 = 0;\n" 11039 "auto v = type{\n" 11040 " i = 1, //\n" 11041 " (i = 2), //\n" 11042 " i = 3 //\n" 11043 "};", 11044 Alignment); 11045 Alignment.AlignConsecutiveAssignments = false; 11046 11047 verifyFormat( 11048 "int i = 1;\n" 11049 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11050 " loooooooooooooooooooooongParameterB);\n" 11051 "int j = 2;", 11052 Alignment); 11053 11054 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 11055 // We expect declarations and assignments to align, as long as it doesn't 11056 // exceed the column limit, starting a new alignment sequence whenever it 11057 // happens. 11058 Alignment.AlignConsecutiveAssignments = true; 11059 Alignment.ColumnLimit = 30; 11060 verifyFormat("float ii = 1;\n" 11061 "unsigned j = 2;\n" 11062 "int someVerylongVariable = 1;\n" 11063 "AnotherLongType ll = 123456;\n" 11064 "VeryVeryLongType k = 2;\n" 11065 "int myvar = 1;", 11066 Alignment); 11067 Alignment.ColumnLimit = 80; 11068 Alignment.AlignConsecutiveAssignments = false; 11069 11070 verifyFormat( 11071 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 11072 " typename LongType, typename B>\n" 11073 "auto foo() {}\n", 11074 Alignment); 11075 verifyFormat("float a, b = 1;\n" 11076 "int c = 2;\n" 11077 "int dd = 3;\n", 11078 Alignment); 11079 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11080 "float b[1][] = {{3.f}};\n", 11081 Alignment); 11082 Alignment.AlignConsecutiveAssignments = true; 11083 verifyFormat("float a, b = 1;\n" 11084 "int c = 2;\n" 11085 "int dd = 3;\n", 11086 Alignment); 11087 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11088 "float b[1][] = {{3.f}};\n", 11089 Alignment); 11090 Alignment.AlignConsecutiveAssignments = false; 11091 11092 Alignment.ColumnLimit = 30; 11093 Alignment.BinPackParameters = false; 11094 verifyFormat("void foo(float a,\n" 11095 " float b,\n" 11096 " int c,\n" 11097 " uint32_t *d) {\n" 11098 " int * e = 0;\n" 11099 " float f = 0;\n" 11100 " double g = 0;\n" 11101 "}\n" 11102 "void bar(ino_t a,\n" 11103 " int b,\n" 11104 " uint32_t *c,\n" 11105 " bool d) {}\n", 11106 Alignment); 11107 Alignment.BinPackParameters = true; 11108 Alignment.ColumnLimit = 80; 11109 11110 // Bug 33507 11111 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 11112 verifyFormat( 11113 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 11114 " static const Version verVs2017;\n" 11115 " return true;\n" 11116 "});\n", 11117 Alignment); 11118 Alignment.PointerAlignment = FormatStyle::PAS_Right; 11119 11120 // See llvm.org/PR35641 11121 Alignment.AlignConsecutiveDeclarations = true; 11122 verifyFormat("int func() { //\n" 11123 " int b;\n" 11124 " unsigned c;\n" 11125 "}", 11126 Alignment); 11127 11128 // See PR37175 11129 FormatStyle Style = getMozillaStyle(); 11130 Style.AlignConsecutiveDeclarations = true; 11131 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 11132 "foo(int a);", 11133 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 11134 } 11135 11136 TEST_F(FormatTest, LinuxBraceBreaking) { 11137 FormatStyle LinuxBraceStyle = getLLVMStyle(); 11138 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 11139 verifyFormat("namespace a\n" 11140 "{\n" 11141 "class A\n" 11142 "{\n" 11143 " void f()\n" 11144 " {\n" 11145 " if (true) {\n" 11146 " a();\n" 11147 " b();\n" 11148 " } else {\n" 11149 " a();\n" 11150 " }\n" 11151 " }\n" 11152 " void g() { return; }\n" 11153 "};\n" 11154 "struct B {\n" 11155 " int x;\n" 11156 "};\n" 11157 "} // namespace a\n", 11158 LinuxBraceStyle); 11159 verifyFormat("enum X {\n" 11160 " Y = 0,\n" 11161 "}\n", 11162 LinuxBraceStyle); 11163 verifyFormat("struct S {\n" 11164 " int Type;\n" 11165 " union {\n" 11166 " int x;\n" 11167 " double y;\n" 11168 " } Value;\n" 11169 " class C\n" 11170 " {\n" 11171 " MyFavoriteType Value;\n" 11172 " } Class;\n" 11173 "}\n", 11174 LinuxBraceStyle); 11175 } 11176 11177 TEST_F(FormatTest, MozillaBraceBreaking) { 11178 FormatStyle MozillaBraceStyle = getLLVMStyle(); 11179 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 11180 MozillaBraceStyle.FixNamespaceComments = false; 11181 verifyFormat("namespace a {\n" 11182 "class A\n" 11183 "{\n" 11184 " void f()\n" 11185 " {\n" 11186 " if (true) {\n" 11187 " a();\n" 11188 " b();\n" 11189 " }\n" 11190 " }\n" 11191 " void g() { return; }\n" 11192 "};\n" 11193 "enum E\n" 11194 "{\n" 11195 " A,\n" 11196 " // foo\n" 11197 " B,\n" 11198 " C\n" 11199 "};\n" 11200 "struct B\n" 11201 "{\n" 11202 " int x;\n" 11203 "};\n" 11204 "}\n", 11205 MozillaBraceStyle); 11206 verifyFormat("struct S\n" 11207 "{\n" 11208 " int Type;\n" 11209 " union\n" 11210 " {\n" 11211 " int x;\n" 11212 " double y;\n" 11213 " } Value;\n" 11214 " class C\n" 11215 " {\n" 11216 " MyFavoriteType Value;\n" 11217 " } Class;\n" 11218 "}\n", 11219 MozillaBraceStyle); 11220 } 11221 11222 TEST_F(FormatTest, StroustrupBraceBreaking) { 11223 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 11224 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11225 verifyFormat("namespace a {\n" 11226 "class A {\n" 11227 " void f()\n" 11228 " {\n" 11229 " if (true) {\n" 11230 " a();\n" 11231 " b();\n" 11232 " }\n" 11233 " }\n" 11234 " void g() { return; }\n" 11235 "};\n" 11236 "struct B {\n" 11237 " int x;\n" 11238 "};\n" 11239 "} // namespace a\n", 11240 StroustrupBraceStyle); 11241 11242 verifyFormat("void foo()\n" 11243 "{\n" 11244 " if (a) {\n" 11245 " a();\n" 11246 " }\n" 11247 " else {\n" 11248 " b();\n" 11249 " }\n" 11250 "}\n", 11251 StroustrupBraceStyle); 11252 11253 verifyFormat("#ifdef _DEBUG\n" 11254 "int foo(int i = 0)\n" 11255 "#else\n" 11256 "int foo(int i = 5)\n" 11257 "#endif\n" 11258 "{\n" 11259 " return i;\n" 11260 "}", 11261 StroustrupBraceStyle); 11262 11263 verifyFormat("void foo() {}\n" 11264 "void bar()\n" 11265 "#ifdef _DEBUG\n" 11266 "{\n" 11267 " foo();\n" 11268 "}\n" 11269 "#else\n" 11270 "{\n" 11271 "}\n" 11272 "#endif", 11273 StroustrupBraceStyle); 11274 11275 verifyFormat("void foobar() { int i = 5; }\n" 11276 "#ifdef _DEBUG\n" 11277 "void bar() {}\n" 11278 "#else\n" 11279 "void bar() { foobar(); }\n" 11280 "#endif", 11281 StroustrupBraceStyle); 11282 } 11283 11284 TEST_F(FormatTest, AllmanBraceBreaking) { 11285 FormatStyle AllmanBraceStyle = getLLVMStyle(); 11286 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 11287 11288 EXPECT_EQ("namespace a\n" 11289 "{\n" 11290 "void f();\n" 11291 "void g();\n" 11292 "} // namespace a\n", 11293 format("namespace a\n" 11294 "{\n" 11295 "void f();\n" 11296 "void g();\n" 11297 "}\n", 11298 AllmanBraceStyle)); 11299 11300 verifyFormat("namespace a\n" 11301 "{\n" 11302 "class A\n" 11303 "{\n" 11304 " void f()\n" 11305 " {\n" 11306 " if (true)\n" 11307 " {\n" 11308 " a();\n" 11309 " b();\n" 11310 " }\n" 11311 " }\n" 11312 " void g() { return; }\n" 11313 "};\n" 11314 "struct B\n" 11315 "{\n" 11316 " int x;\n" 11317 "};\n" 11318 "union C\n" 11319 "{\n" 11320 "};\n" 11321 "} // namespace a", 11322 AllmanBraceStyle); 11323 11324 verifyFormat("void f()\n" 11325 "{\n" 11326 " if (true)\n" 11327 " {\n" 11328 " a();\n" 11329 " }\n" 11330 " else if (false)\n" 11331 " {\n" 11332 " b();\n" 11333 " }\n" 11334 " else\n" 11335 " {\n" 11336 " c();\n" 11337 " }\n" 11338 "}\n", 11339 AllmanBraceStyle); 11340 11341 verifyFormat("void f()\n" 11342 "{\n" 11343 " for (int i = 0; i < 10; ++i)\n" 11344 " {\n" 11345 " a();\n" 11346 " }\n" 11347 " while (false)\n" 11348 " {\n" 11349 " b();\n" 11350 " }\n" 11351 " do\n" 11352 " {\n" 11353 " c();\n" 11354 " } while (false)\n" 11355 "}\n", 11356 AllmanBraceStyle); 11357 11358 verifyFormat("void f(int a)\n" 11359 "{\n" 11360 " switch (a)\n" 11361 " {\n" 11362 " case 0:\n" 11363 " break;\n" 11364 " case 1:\n" 11365 " {\n" 11366 " break;\n" 11367 " }\n" 11368 " case 2:\n" 11369 " {\n" 11370 " }\n" 11371 " break;\n" 11372 " default:\n" 11373 " break;\n" 11374 " }\n" 11375 "}\n", 11376 AllmanBraceStyle); 11377 11378 verifyFormat("enum X\n" 11379 "{\n" 11380 " Y = 0,\n" 11381 "}\n", 11382 AllmanBraceStyle); 11383 verifyFormat("enum X\n" 11384 "{\n" 11385 " Y = 0\n" 11386 "}\n", 11387 AllmanBraceStyle); 11388 11389 verifyFormat("@interface BSApplicationController ()\n" 11390 "{\n" 11391 "@private\n" 11392 " id _extraIvar;\n" 11393 "}\n" 11394 "@end\n", 11395 AllmanBraceStyle); 11396 11397 verifyFormat("#ifdef _DEBUG\n" 11398 "int foo(int i = 0)\n" 11399 "#else\n" 11400 "int foo(int i = 5)\n" 11401 "#endif\n" 11402 "{\n" 11403 " return i;\n" 11404 "}", 11405 AllmanBraceStyle); 11406 11407 verifyFormat("void foo() {}\n" 11408 "void bar()\n" 11409 "#ifdef _DEBUG\n" 11410 "{\n" 11411 " foo();\n" 11412 "}\n" 11413 "#else\n" 11414 "{\n" 11415 "}\n" 11416 "#endif", 11417 AllmanBraceStyle); 11418 11419 verifyFormat("void foobar() { int i = 5; }\n" 11420 "#ifdef _DEBUG\n" 11421 "void bar() {}\n" 11422 "#else\n" 11423 "void bar() { foobar(); }\n" 11424 "#endif", 11425 AllmanBraceStyle); 11426 11427 // This shouldn't affect ObjC blocks.. 11428 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 11429 " // ...\n" 11430 " int i;\n" 11431 "}];", 11432 AllmanBraceStyle); 11433 verifyFormat("void (^block)(void) = ^{\n" 11434 " // ...\n" 11435 " int i;\n" 11436 "};", 11437 AllmanBraceStyle); 11438 // .. or dict literals. 11439 verifyFormat("void f()\n" 11440 "{\n" 11441 " // ...\n" 11442 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 11443 "}", 11444 AllmanBraceStyle); 11445 verifyFormat("void f()\n" 11446 "{\n" 11447 " // ...\n" 11448 " [object someMethod:@{a : @\"b\"}];\n" 11449 "}", 11450 AllmanBraceStyle); 11451 verifyFormat("int f()\n" 11452 "{ // comment\n" 11453 " return 42;\n" 11454 "}", 11455 AllmanBraceStyle); 11456 11457 AllmanBraceStyle.ColumnLimit = 19; 11458 verifyFormat("void f() { int i; }", AllmanBraceStyle); 11459 AllmanBraceStyle.ColumnLimit = 18; 11460 verifyFormat("void f()\n" 11461 "{\n" 11462 " int i;\n" 11463 "}", 11464 AllmanBraceStyle); 11465 AllmanBraceStyle.ColumnLimit = 80; 11466 11467 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 11468 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 11469 FormatStyle::SIS_WithoutElse; 11470 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 11471 verifyFormat("void f(bool b)\n" 11472 "{\n" 11473 " if (b)\n" 11474 " {\n" 11475 " return;\n" 11476 " }\n" 11477 "}\n", 11478 BreakBeforeBraceShortIfs); 11479 verifyFormat("void f(bool b)\n" 11480 "{\n" 11481 " if constexpr (b)\n" 11482 " {\n" 11483 " return;\n" 11484 " }\n" 11485 "}\n", 11486 BreakBeforeBraceShortIfs); 11487 verifyFormat("void f(bool b)\n" 11488 "{\n" 11489 " if CONSTEXPR (b)\n" 11490 " {\n" 11491 " return;\n" 11492 " }\n" 11493 "}\n", 11494 BreakBeforeBraceShortIfs); 11495 verifyFormat("void f(bool b)\n" 11496 "{\n" 11497 " if (b) return;\n" 11498 "}\n", 11499 BreakBeforeBraceShortIfs); 11500 verifyFormat("void f(bool b)\n" 11501 "{\n" 11502 " if constexpr (b) return;\n" 11503 "}\n", 11504 BreakBeforeBraceShortIfs); 11505 verifyFormat("void f(bool b)\n" 11506 "{\n" 11507 " if CONSTEXPR (b) return;\n" 11508 "}\n", 11509 BreakBeforeBraceShortIfs); 11510 verifyFormat("void f(bool b)\n" 11511 "{\n" 11512 " while (b)\n" 11513 " {\n" 11514 " return;\n" 11515 " }\n" 11516 "}\n", 11517 BreakBeforeBraceShortIfs); 11518 } 11519 11520 TEST_F(FormatTest, WhitesmithsBraceBreaking) { 11521 FormatStyle WhitesmithsBraceStyle = getLLVMStyle(); 11522 WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 11523 11524 // Make a few changes to the style for testing purposes 11525 WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine = 11526 FormatStyle::SFS_Empty; 11527 WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 11528 WhitesmithsBraceStyle.ColumnLimit = 0; 11529 11530 // FIXME: this test case can't decide whether there should be a blank line 11531 // after the ~D() line or not. It adds one if one doesn't exist in the test 11532 // and it removes the line if one exists. 11533 /* 11534 verifyFormat("class A;\n" 11535 "namespace B\n" 11536 " {\n" 11537 "class C;\n" 11538 "// Comment\n" 11539 "class D\n" 11540 " {\n" 11541 "public:\n" 11542 " D();\n" 11543 " ~D() {}\n" 11544 "private:\n" 11545 " enum E\n" 11546 " {\n" 11547 " F\n" 11548 " }\n" 11549 " };\n" 11550 " } // namespace B\n", 11551 WhitesmithsBraceStyle); 11552 */ 11553 11554 verifyFormat("namespace a\n" 11555 " {\n" 11556 "class A\n" 11557 " {\n" 11558 " void f()\n" 11559 " {\n" 11560 " if (true)\n" 11561 " {\n" 11562 " a();\n" 11563 " b();\n" 11564 " }\n" 11565 " }\n" 11566 " void g()\n" 11567 " {\n" 11568 " return;\n" 11569 " }\n" 11570 " };\n" 11571 "struct B\n" 11572 " {\n" 11573 " int x;\n" 11574 " };\n" 11575 " } // namespace a", 11576 WhitesmithsBraceStyle); 11577 11578 verifyFormat("void f()\n" 11579 " {\n" 11580 " if (true)\n" 11581 " {\n" 11582 " a();\n" 11583 " }\n" 11584 " else if (false)\n" 11585 " {\n" 11586 " b();\n" 11587 " }\n" 11588 " else\n" 11589 " {\n" 11590 " c();\n" 11591 " }\n" 11592 " }\n", 11593 WhitesmithsBraceStyle); 11594 11595 verifyFormat("void f()\n" 11596 " {\n" 11597 " for (int i = 0; i < 10; ++i)\n" 11598 " {\n" 11599 " a();\n" 11600 " }\n" 11601 " while (false)\n" 11602 " {\n" 11603 " b();\n" 11604 " }\n" 11605 " do\n" 11606 " {\n" 11607 " c();\n" 11608 " } while (false)\n" 11609 " }\n", 11610 WhitesmithsBraceStyle); 11611 11612 // FIXME: the block and the break under case 2 in this test don't get indented 11613 // correctly 11614 /* 11615 verifyFormat("void switchTest1(int a)\n" 11616 " {\n" 11617 " switch (a)\n" 11618 " {\n" 11619 " case 2:\n" 11620 " {\n" 11621 " }\n" 11622 " break;\n" 11623 " }\n" 11624 " }\n", 11625 WhitesmithsBraceStyle); 11626 */ 11627 11628 // FIXME: the block and the break under case 2 in this test don't get indented 11629 // correctly 11630 /* 11631 verifyFormat("void switchTest2(int a)\n" 11632 " {\n" 11633 " switch (a)\n" 11634 " {\n" 11635 " case 0:\n" 11636 " break;\n" 11637 " case 1:\n" 11638 " {\n" 11639 " break;\n" 11640 " }\n" 11641 " case 2:\n" 11642 " {\n" 11643 " }\n" 11644 " break;\n" 11645 " default:\n" 11646 " break;\n" 11647 " }\n" 11648 " }\n", 11649 WhitesmithsBraceStyle); 11650 */ 11651 11652 verifyFormat("enum X\n" 11653 " {\n" 11654 " Y = 0, // testing\n" 11655 " }\n", 11656 WhitesmithsBraceStyle); 11657 11658 verifyFormat("enum X\n" 11659 " {\n" 11660 " Y = 0\n" 11661 " }\n", 11662 WhitesmithsBraceStyle); 11663 verifyFormat("enum X\n" 11664 " {\n" 11665 " Y = 0,\n" 11666 " Z = 1\n" 11667 " };\n", 11668 WhitesmithsBraceStyle); 11669 11670 verifyFormat("@interface BSApplicationController ()\n" 11671 " {\n" 11672 "@private\n" 11673 " id _extraIvar;\n" 11674 " }\n" 11675 "@end\n", 11676 WhitesmithsBraceStyle); 11677 11678 verifyFormat("#ifdef _DEBUG\n" 11679 "int foo(int i = 0)\n" 11680 "#else\n" 11681 "int foo(int i = 5)\n" 11682 "#endif\n" 11683 " {\n" 11684 " return i;\n" 11685 " }", 11686 WhitesmithsBraceStyle); 11687 11688 verifyFormat("void foo() {}\n" 11689 "void bar()\n" 11690 "#ifdef _DEBUG\n" 11691 " {\n" 11692 " foo();\n" 11693 " }\n" 11694 "#else\n" 11695 " {\n" 11696 " }\n" 11697 "#endif", 11698 WhitesmithsBraceStyle); 11699 11700 verifyFormat("void foobar()\n" 11701 " {\n" 11702 " int i = 5;\n" 11703 " }\n" 11704 "#ifdef _DEBUG\n" 11705 "void bar()\n" 11706 " {\n" 11707 " }\n" 11708 "#else\n" 11709 "void bar()\n" 11710 " {\n" 11711 " foobar();\n" 11712 " }\n" 11713 "#endif", 11714 WhitesmithsBraceStyle); 11715 11716 // This shouldn't affect ObjC blocks.. 11717 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 11718 " // ...\n" 11719 " int i;\n" 11720 "}];", 11721 WhitesmithsBraceStyle); 11722 verifyFormat("void (^block)(void) = ^{\n" 11723 " // ...\n" 11724 " int i;\n" 11725 "};", 11726 WhitesmithsBraceStyle); 11727 // .. or dict literals. 11728 verifyFormat("void f()\n" 11729 " {\n" 11730 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 11731 " }", 11732 WhitesmithsBraceStyle); 11733 11734 verifyFormat("int f()\n" 11735 " { // comment\n" 11736 " return 42;\n" 11737 " }", 11738 WhitesmithsBraceStyle); 11739 11740 FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle; 11741 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 11742 FormatStyle::SIS_Always; 11743 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 11744 verifyFormat("void f(bool b)\n" 11745 " {\n" 11746 " if (b)\n" 11747 " {\n" 11748 " return;\n" 11749 " }\n" 11750 " }\n", 11751 BreakBeforeBraceShortIfs); 11752 verifyFormat("void f(bool b)\n" 11753 " {\n" 11754 " if (b) return;\n" 11755 " }\n", 11756 BreakBeforeBraceShortIfs); 11757 verifyFormat("void f(bool b)\n" 11758 " {\n" 11759 " while (b)\n" 11760 " {\n" 11761 " return;\n" 11762 " }\n" 11763 " }\n", 11764 BreakBeforeBraceShortIfs); 11765 } 11766 11767 TEST_F(FormatTest, GNUBraceBreaking) { 11768 FormatStyle GNUBraceStyle = getLLVMStyle(); 11769 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 11770 verifyFormat("namespace a\n" 11771 "{\n" 11772 "class A\n" 11773 "{\n" 11774 " void f()\n" 11775 " {\n" 11776 " int a;\n" 11777 " {\n" 11778 " int b;\n" 11779 " }\n" 11780 " if (true)\n" 11781 " {\n" 11782 " a();\n" 11783 " b();\n" 11784 " }\n" 11785 " }\n" 11786 " void g() { return; }\n" 11787 "}\n" 11788 "} // namespace a", 11789 GNUBraceStyle); 11790 11791 verifyFormat("void f()\n" 11792 "{\n" 11793 " if (true)\n" 11794 " {\n" 11795 " a();\n" 11796 " }\n" 11797 " else if (false)\n" 11798 " {\n" 11799 " b();\n" 11800 " }\n" 11801 " else\n" 11802 " {\n" 11803 " c();\n" 11804 " }\n" 11805 "}\n", 11806 GNUBraceStyle); 11807 11808 verifyFormat("void f()\n" 11809 "{\n" 11810 " for (int i = 0; i < 10; ++i)\n" 11811 " {\n" 11812 " a();\n" 11813 " }\n" 11814 " while (false)\n" 11815 " {\n" 11816 " b();\n" 11817 " }\n" 11818 " do\n" 11819 " {\n" 11820 " c();\n" 11821 " }\n" 11822 " while (false);\n" 11823 "}\n", 11824 GNUBraceStyle); 11825 11826 verifyFormat("void f(int a)\n" 11827 "{\n" 11828 " switch (a)\n" 11829 " {\n" 11830 " case 0:\n" 11831 " break;\n" 11832 " case 1:\n" 11833 " {\n" 11834 " break;\n" 11835 " }\n" 11836 " case 2:\n" 11837 " {\n" 11838 " }\n" 11839 " break;\n" 11840 " default:\n" 11841 " break;\n" 11842 " }\n" 11843 "}\n", 11844 GNUBraceStyle); 11845 11846 verifyFormat("enum X\n" 11847 "{\n" 11848 " Y = 0,\n" 11849 "}\n", 11850 GNUBraceStyle); 11851 11852 verifyFormat("@interface BSApplicationController ()\n" 11853 "{\n" 11854 "@private\n" 11855 " id _extraIvar;\n" 11856 "}\n" 11857 "@end\n", 11858 GNUBraceStyle); 11859 11860 verifyFormat("#ifdef _DEBUG\n" 11861 "int foo(int i = 0)\n" 11862 "#else\n" 11863 "int foo(int i = 5)\n" 11864 "#endif\n" 11865 "{\n" 11866 " return i;\n" 11867 "}", 11868 GNUBraceStyle); 11869 11870 verifyFormat("void foo() {}\n" 11871 "void bar()\n" 11872 "#ifdef _DEBUG\n" 11873 "{\n" 11874 " foo();\n" 11875 "}\n" 11876 "#else\n" 11877 "{\n" 11878 "}\n" 11879 "#endif", 11880 GNUBraceStyle); 11881 11882 verifyFormat("void foobar() { int i = 5; }\n" 11883 "#ifdef _DEBUG\n" 11884 "void bar() {}\n" 11885 "#else\n" 11886 "void bar() { foobar(); }\n" 11887 "#endif", 11888 GNUBraceStyle); 11889 } 11890 11891 TEST_F(FormatTest, WebKitBraceBreaking) { 11892 FormatStyle WebKitBraceStyle = getLLVMStyle(); 11893 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 11894 WebKitBraceStyle.FixNamespaceComments = false; 11895 verifyFormat("namespace a {\n" 11896 "class A {\n" 11897 " void f()\n" 11898 " {\n" 11899 " if (true) {\n" 11900 " a();\n" 11901 " b();\n" 11902 " }\n" 11903 " }\n" 11904 " void g() { return; }\n" 11905 "};\n" 11906 "enum E {\n" 11907 " A,\n" 11908 " // foo\n" 11909 " B,\n" 11910 " C\n" 11911 "};\n" 11912 "struct B {\n" 11913 " int x;\n" 11914 "};\n" 11915 "}\n", 11916 WebKitBraceStyle); 11917 verifyFormat("struct S {\n" 11918 " int Type;\n" 11919 " union {\n" 11920 " int x;\n" 11921 " double y;\n" 11922 " } Value;\n" 11923 " class C {\n" 11924 " MyFavoriteType Value;\n" 11925 " } Class;\n" 11926 "};\n", 11927 WebKitBraceStyle); 11928 } 11929 11930 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 11931 verifyFormat("void f() {\n" 11932 " try {\n" 11933 " } catch (const Exception &e) {\n" 11934 " }\n" 11935 "}\n", 11936 getLLVMStyle()); 11937 } 11938 11939 TEST_F(FormatTest, UnderstandsPragmas) { 11940 verifyFormat("#pragma omp reduction(| : var)"); 11941 verifyFormat("#pragma omp reduction(+ : var)"); 11942 11943 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 11944 "(including parentheses).", 11945 format("#pragma mark Any non-hyphenated or hyphenated string " 11946 "(including parentheses).")); 11947 } 11948 11949 TEST_F(FormatTest, UnderstandPragmaOption) { 11950 verifyFormat("#pragma option -C -A"); 11951 11952 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 11953 } 11954 11955 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 11956 FormatStyle Style = getLLVMStyle(); 11957 Style.ColumnLimit = 20; 11958 11959 // See PR41213 11960 EXPECT_EQ("/*\n" 11961 " *\t9012345\n" 11962 " * /8901\n" 11963 " */", 11964 format("/*\n" 11965 " *\t9012345 /8901\n" 11966 " */", 11967 Style)); 11968 EXPECT_EQ("/*\n" 11969 " *345678\n" 11970 " *\t/8901\n" 11971 " */", 11972 format("/*\n" 11973 " *345678\t/8901\n" 11974 " */", 11975 Style)); 11976 11977 verifyFormat("int a; // the\n" 11978 " // comment", 11979 Style); 11980 EXPECT_EQ("int a; /* first line\n" 11981 " * second\n" 11982 " * line third\n" 11983 " * line\n" 11984 " */", 11985 format("int a; /* first line\n" 11986 " * second\n" 11987 " * line third\n" 11988 " * line\n" 11989 " */", 11990 Style)); 11991 EXPECT_EQ("int a; // first line\n" 11992 " // second\n" 11993 " // line third\n" 11994 " // line", 11995 format("int a; // first line\n" 11996 " // second line\n" 11997 " // third line", 11998 Style)); 11999 12000 Style.PenaltyExcessCharacter = 90; 12001 verifyFormat("int a; // the comment", Style); 12002 EXPECT_EQ("int a; // the comment\n" 12003 " // aaa", 12004 format("int a; // the comment aaa", Style)); 12005 EXPECT_EQ("int a; /* first line\n" 12006 " * second line\n" 12007 " * third line\n" 12008 " */", 12009 format("int a; /* first line\n" 12010 " * second line\n" 12011 " * third line\n" 12012 " */", 12013 Style)); 12014 EXPECT_EQ("int a; // first line\n" 12015 " // second line\n" 12016 " // third line", 12017 format("int a; // first line\n" 12018 " // second line\n" 12019 " // third line", 12020 Style)); 12021 // FIXME: Investigate why this is not getting the same layout as the test 12022 // above. 12023 EXPECT_EQ("int a; /* first line\n" 12024 " * second line\n" 12025 " * third line\n" 12026 " */", 12027 format("int a; /* first line second line third line" 12028 "\n*/", 12029 Style)); 12030 12031 EXPECT_EQ("// foo bar baz bazfoo\n" 12032 "// foo bar foo bar\n", 12033 format("// foo bar baz bazfoo\n" 12034 "// foo bar foo bar\n", 12035 Style)); 12036 EXPECT_EQ("// foo bar baz bazfoo\n" 12037 "// foo bar foo bar\n", 12038 format("// foo bar baz bazfoo\n" 12039 "// foo bar foo bar\n", 12040 Style)); 12041 12042 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 12043 // next one. 12044 EXPECT_EQ("// foo bar baz bazfoo\n" 12045 "// bar foo bar\n", 12046 format("// foo bar baz bazfoo bar\n" 12047 "// foo bar\n", 12048 Style)); 12049 12050 EXPECT_EQ("// foo bar baz bazfoo\n" 12051 "// foo bar baz bazfoo\n" 12052 "// bar foo bar\n", 12053 format("// foo bar baz bazfoo\n" 12054 "// foo bar baz bazfoo bar\n" 12055 "// foo bar\n", 12056 Style)); 12057 12058 EXPECT_EQ("// foo bar baz bazfoo\n" 12059 "// foo bar baz bazfoo\n" 12060 "// bar foo bar\n", 12061 format("// foo bar baz bazfoo\n" 12062 "// foo bar baz bazfoo bar\n" 12063 "// foo bar\n", 12064 Style)); 12065 12066 // Make sure we do not keep protruding characters if strict mode reflow is 12067 // cheaper than keeping protruding characters. 12068 Style.ColumnLimit = 21; 12069 EXPECT_EQ( 12070 "// foo foo foo foo\n" 12071 "// foo foo foo foo\n" 12072 "// foo foo foo foo\n", 12073 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style)); 12074 12075 EXPECT_EQ("int a = /* long block\n" 12076 " comment */\n" 12077 " 42;", 12078 format("int a = /* long block comment */ 42;", Style)); 12079 } 12080 12081 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 12082 for (size_t i = 1; i < Styles.size(); ++i) \ 12083 EXPECT_EQ(Styles[0], Styles[i]) \ 12084 << "Style #" << i << " of " << Styles.size() << " differs from Style #0" 12085 12086 TEST_F(FormatTest, GetsPredefinedStyleByName) { 12087 SmallVector<FormatStyle, 3> Styles; 12088 Styles.resize(3); 12089 12090 Styles[0] = getLLVMStyle(); 12091 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 12092 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 12093 EXPECT_ALL_STYLES_EQUAL(Styles); 12094 12095 Styles[0] = getGoogleStyle(); 12096 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 12097 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 12098 EXPECT_ALL_STYLES_EQUAL(Styles); 12099 12100 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12101 EXPECT_TRUE( 12102 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 12103 EXPECT_TRUE( 12104 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 12105 EXPECT_ALL_STYLES_EQUAL(Styles); 12106 12107 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 12108 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 12109 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 12110 EXPECT_ALL_STYLES_EQUAL(Styles); 12111 12112 Styles[0] = getMozillaStyle(); 12113 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 12114 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 12115 EXPECT_ALL_STYLES_EQUAL(Styles); 12116 12117 Styles[0] = getWebKitStyle(); 12118 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 12119 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 12120 EXPECT_ALL_STYLES_EQUAL(Styles); 12121 12122 Styles[0] = getGNUStyle(); 12123 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 12124 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 12125 EXPECT_ALL_STYLES_EQUAL(Styles); 12126 12127 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 12128 } 12129 12130 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 12131 SmallVector<FormatStyle, 8> Styles; 12132 Styles.resize(2); 12133 12134 Styles[0] = getGoogleStyle(); 12135 Styles[1] = getLLVMStyle(); 12136 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12137 EXPECT_ALL_STYLES_EQUAL(Styles); 12138 12139 Styles.resize(5); 12140 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12141 Styles[1] = getLLVMStyle(); 12142 Styles[1].Language = FormatStyle::LK_JavaScript; 12143 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12144 12145 Styles[2] = getLLVMStyle(); 12146 Styles[2].Language = FormatStyle::LK_JavaScript; 12147 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 12148 "BasedOnStyle: Google", 12149 &Styles[2]) 12150 .value()); 12151 12152 Styles[3] = getLLVMStyle(); 12153 Styles[3].Language = FormatStyle::LK_JavaScript; 12154 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 12155 "Language: JavaScript", 12156 &Styles[3]) 12157 .value()); 12158 12159 Styles[4] = getLLVMStyle(); 12160 Styles[4].Language = FormatStyle::LK_JavaScript; 12161 EXPECT_EQ(0, parseConfiguration("---\n" 12162 "BasedOnStyle: LLVM\n" 12163 "IndentWidth: 123\n" 12164 "---\n" 12165 "BasedOnStyle: Google\n" 12166 "Language: JavaScript", 12167 &Styles[4]) 12168 .value()); 12169 EXPECT_ALL_STYLES_EQUAL(Styles); 12170 } 12171 12172 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 12173 Style.FIELD = false; \ 12174 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 12175 EXPECT_TRUE(Style.FIELD); \ 12176 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 12177 EXPECT_FALSE(Style.FIELD); 12178 12179 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 12180 12181 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 12182 Style.STRUCT.FIELD = false; \ 12183 EXPECT_EQ(0, \ 12184 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 12185 .value()); \ 12186 EXPECT_TRUE(Style.STRUCT.FIELD); \ 12187 EXPECT_EQ(0, \ 12188 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 12189 .value()); \ 12190 EXPECT_FALSE(Style.STRUCT.FIELD); 12191 12192 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 12193 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 12194 12195 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 12196 EXPECT_NE(VALUE, Style.FIELD); \ 12197 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 12198 EXPECT_EQ(VALUE, Style.FIELD) 12199 12200 TEST_F(FormatTest, ParsesConfigurationBools) { 12201 FormatStyle Style = {}; 12202 Style.Language = FormatStyle::LK_Cpp; 12203 CHECK_PARSE_BOOL(AlignOperands); 12204 CHECK_PARSE_BOOL(AlignTrailingComments); 12205 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 12206 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 12207 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 12208 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 12209 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 12210 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 12211 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 12212 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 12213 CHECK_PARSE_BOOL(BinPackArguments); 12214 CHECK_PARSE_BOOL(BinPackParameters); 12215 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 12216 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 12217 CHECK_PARSE_BOOL(BreakStringLiterals); 12218 CHECK_PARSE_BOOL(CompactNamespaces); 12219 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 12220 CHECK_PARSE_BOOL(DerivePointerAlignment); 12221 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 12222 CHECK_PARSE_BOOL(DisableFormat); 12223 CHECK_PARSE_BOOL(IndentCaseLabels); 12224 CHECK_PARSE_BOOL(IndentGotoLabels); 12225 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 12226 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 12227 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 12228 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 12229 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 12230 CHECK_PARSE_BOOL(ReflowComments); 12231 CHECK_PARSE_BOOL(SortIncludes); 12232 CHECK_PARSE_BOOL(SortUsingDeclarations); 12233 CHECK_PARSE_BOOL(SpacesInParentheses); 12234 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 12235 CHECK_PARSE_BOOL(SpacesInAngles); 12236 CHECK_PARSE_BOOL(SpaceInEmptyBlock); 12237 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 12238 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 12239 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 12240 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 12241 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 12242 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 12243 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 12244 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 12245 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 12246 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 12247 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 12248 12249 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 12250 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 12251 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterControlStatement); 12252 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 12253 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 12254 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 12255 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 12256 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 12257 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 12258 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 12259 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 12260 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 12261 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 12262 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 12263 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 12264 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 12265 } 12266 12267 #undef CHECK_PARSE_BOOL 12268 12269 TEST_F(FormatTest, ParsesConfiguration) { 12270 FormatStyle Style = {}; 12271 Style.Language = FormatStyle::LK_Cpp; 12272 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 12273 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 12274 ConstructorInitializerIndentWidth, 1234u); 12275 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 12276 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 12277 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 12278 CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u); 12279 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 12280 PenaltyBreakBeforeFirstCallParameter, 1234u); 12281 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 12282 PenaltyBreakTemplateDeclaration, 1234u); 12283 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 12284 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 12285 PenaltyReturnTypeOnItsOwnLine, 1234u); 12286 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 12287 SpacesBeforeTrailingComments, 1234u); 12288 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 12289 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 12290 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 12291 12292 Style.PointerAlignment = FormatStyle::PAS_Middle; 12293 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 12294 FormatStyle::PAS_Left); 12295 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 12296 FormatStyle::PAS_Right); 12297 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 12298 FormatStyle::PAS_Middle); 12299 // For backward compatibility: 12300 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 12301 FormatStyle::PAS_Left); 12302 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 12303 FormatStyle::PAS_Right); 12304 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 12305 FormatStyle::PAS_Middle); 12306 12307 Style.Standard = FormatStyle::LS_Auto; 12308 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 12309 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11); 12310 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 12311 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 12312 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 12313 12314 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 12315 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 12316 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 12317 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 12318 FormatStyle::BOS_None); 12319 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 12320 FormatStyle::BOS_All); 12321 // For backward compatibility: 12322 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 12323 FormatStyle::BOS_None); 12324 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 12325 FormatStyle::BOS_All); 12326 12327 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 12328 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 12329 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 12330 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 12331 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 12332 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 12333 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 12334 // For backward compatibility: 12335 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 12336 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 12337 12338 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 12339 CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList, 12340 FormatStyle::BILS_BeforeComma); 12341 CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList, 12342 FormatStyle::BILS_AfterColon); 12343 CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList, 12344 FormatStyle::BILS_BeforeColon); 12345 // For backward compatibility: 12346 CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList, 12347 FormatStyle::BILS_BeforeComma); 12348 12349 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 12350 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 12351 FormatStyle::BAS_Align); 12352 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 12353 FormatStyle::BAS_DontAlign); 12354 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 12355 FormatStyle::BAS_AlwaysBreak); 12356 // For backward compatibility: 12357 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 12358 FormatStyle::BAS_DontAlign); 12359 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 12360 FormatStyle::BAS_Align); 12361 12362 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 12363 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 12364 FormatStyle::ENAS_DontAlign); 12365 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 12366 FormatStyle::ENAS_Left); 12367 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 12368 FormatStyle::ENAS_Right); 12369 // For backward compatibility: 12370 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 12371 FormatStyle::ENAS_Left); 12372 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 12373 FormatStyle::ENAS_Right); 12374 12375 Style.UseTab = FormatStyle::UT_ForIndentation; 12376 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 12377 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 12378 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 12379 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 12380 FormatStyle::UT_ForContinuationAndIndentation); 12381 // For backward compatibility: 12382 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 12383 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 12384 12385 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 12386 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never", 12387 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12388 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty", 12389 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty); 12390 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always", 12391 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12392 // For backward compatibility: 12393 CHECK_PARSE("AllowShortBlocksOnASingleLine: false", 12394 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12395 CHECK_PARSE("AllowShortBlocksOnASingleLine: true", 12396 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12397 12398 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 12399 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 12400 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12401 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 12402 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 12403 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 12404 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 12405 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 12406 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12407 // For backward compatibility: 12408 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 12409 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12410 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 12411 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12412 12413 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 12414 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 12415 FormatStyle::SBPO_Never); 12416 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 12417 FormatStyle::SBPO_Always); 12418 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 12419 FormatStyle::SBPO_ControlStatements); 12420 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 12421 FormatStyle::SBPO_NonEmptyParentheses); 12422 // For backward compatibility: 12423 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 12424 FormatStyle::SBPO_Never); 12425 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 12426 FormatStyle::SBPO_ControlStatements); 12427 12428 Style.ColumnLimit = 123; 12429 FormatStyle BaseStyle = getLLVMStyle(); 12430 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 12431 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 12432 12433 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 12434 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 12435 FormatStyle::BS_Attach); 12436 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 12437 FormatStyle::BS_Linux); 12438 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 12439 FormatStyle::BS_Mozilla); 12440 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 12441 FormatStyle::BS_Stroustrup); 12442 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 12443 FormatStyle::BS_Allman); 12444 CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces, 12445 FormatStyle::BS_Whitesmiths); 12446 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 12447 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 12448 FormatStyle::BS_WebKit); 12449 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 12450 FormatStyle::BS_Custom); 12451 12452 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 12453 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 12454 FormatStyle::RTBS_None); 12455 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 12456 FormatStyle::RTBS_All); 12457 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 12458 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 12459 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 12460 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 12461 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 12462 AlwaysBreakAfterReturnType, 12463 FormatStyle::RTBS_TopLevelDefinitions); 12464 12465 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 12466 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", 12467 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No); 12468 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", 12469 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 12470 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", 12471 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 12472 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", 12473 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 12474 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", 12475 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 12476 12477 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 12478 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 12479 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 12480 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 12481 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 12482 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 12483 AlwaysBreakAfterDefinitionReturnType, 12484 FormatStyle::DRTBS_TopLevel); 12485 12486 Style.NamespaceIndentation = FormatStyle::NI_All; 12487 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 12488 FormatStyle::NI_None); 12489 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 12490 FormatStyle::NI_Inner); 12491 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 12492 FormatStyle::NI_All); 12493 12494 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 12495 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 12496 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12497 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 12498 AllowShortIfStatementsOnASingleLine, 12499 FormatStyle::SIS_WithoutElse); 12500 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 12501 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 12502 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 12503 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12504 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 12505 AllowShortIfStatementsOnASingleLine, 12506 FormatStyle::SIS_WithoutElse); 12507 12508 // FIXME: This is required because parsing a configuration simply overwrites 12509 // the first N elements of the list instead of resetting it. 12510 Style.ForEachMacros.clear(); 12511 std::vector<std::string> BoostForeach; 12512 BoostForeach.push_back("BOOST_FOREACH"); 12513 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 12514 std::vector<std::string> BoostAndQForeach; 12515 BoostAndQForeach.push_back("BOOST_FOREACH"); 12516 BoostAndQForeach.push_back("Q_FOREACH"); 12517 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 12518 BoostAndQForeach); 12519 12520 Style.StatementMacros.clear(); 12521 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 12522 std::vector<std::string>{"QUNUSED"}); 12523 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 12524 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 12525 12526 Style.NamespaceMacros.clear(); 12527 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 12528 std::vector<std::string>{"TESTSUITE"}); 12529 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 12530 std::vector<std::string>({"TESTSUITE", "SUITE"})); 12531 12532 Style.IncludeStyle.IncludeCategories.clear(); 12533 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 12534 {"abc/.*", 2, 0}, {".*", 1, 0}}; 12535 CHECK_PARSE("IncludeCategories:\n" 12536 " - Regex: abc/.*\n" 12537 " Priority: 2\n" 12538 " - Regex: .*\n" 12539 " Priority: 1", 12540 IncludeStyle.IncludeCategories, ExpectedCategories); 12541 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 12542 "abc$"); 12543 12544 Style.RawStringFormats.clear(); 12545 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 12546 { 12547 FormatStyle::LK_TextProto, 12548 {"pb", "proto"}, 12549 {"PARSE_TEXT_PROTO"}, 12550 /*CanonicalDelimiter=*/"", 12551 "llvm", 12552 }, 12553 { 12554 FormatStyle::LK_Cpp, 12555 {"cc", "cpp"}, 12556 {"C_CODEBLOCK", "CPPEVAL"}, 12557 /*CanonicalDelimiter=*/"cc", 12558 /*BasedOnStyle=*/"", 12559 }, 12560 }; 12561 12562 CHECK_PARSE("RawStringFormats:\n" 12563 " - Language: TextProto\n" 12564 " Delimiters:\n" 12565 " - 'pb'\n" 12566 " - 'proto'\n" 12567 " EnclosingFunctions:\n" 12568 " - 'PARSE_TEXT_PROTO'\n" 12569 " BasedOnStyle: llvm\n" 12570 " - Language: Cpp\n" 12571 " Delimiters:\n" 12572 " - 'cc'\n" 12573 " - 'cpp'\n" 12574 " EnclosingFunctions:\n" 12575 " - 'C_CODEBLOCK'\n" 12576 " - 'CPPEVAL'\n" 12577 " CanonicalDelimiter: 'cc'", 12578 RawStringFormats, ExpectedRawStringFormats); 12579 } 12580 12581 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 12582 FormatStyle Style = {}; 12583 Style.Language = FormatStyle::LK_Cpp; 12584 CHECK_PARSE("Language: Cpp\n" 12585 "IndentWidth: 12", 12586 IndentWidth, 12u); 12587 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 12588 "IndentWidth: 34", 12589 &Style), 12590 ParseError::Unsuitable); 12591 EXPECT_EQ(12u, Style.IndentWidth); 12592 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12593 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12594 12595 Style.Language = FormatStyle::LK_JavaScript; 12596 CHECK_PARSE("Language: JavaScript\n" 12597 "IndentWidth: 12", 12598 IndentWidth, 12u); 12599 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 12600 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 12601 "IndentWidth: 34", 12602 &Style), 12603 ParseError::Unsuitable); 12604 EXPECT_EQ(23u, Style.IndentWidth); 12605 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12606 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12607 12608 CHECK_PARSE("BasedOnStyle: LLVM\n" 12609 "IndentWidth: 67", 12610 IndentWidth, 67u); 12611 12612 CHECK_PARSE("---\n" 12613 "Language: JavaScript\n" 12614 "IndentWidth: 12\n" 12615 "---\n" 12616 "Language: Cpp\n" 12617 "IndentWidth: 34\n" 12618 "...\n", 12619 IndentWidth, 12u); 12620 12621 Style.Language = FormatStyle::LK_Cpp; 12622 CHECK_PARSE("---\n" 12623 "Language: JavaScript\n" 12624 "IndentWidth: 12\n" 12625 "---\n" 12626 "Language: Cpp\n" 12627 "IndentWidth: 34\n" 12628 "...\n", 12629 IndentWidth, 34u); 12630 CHECK_PARSE("---\n" 12631 "IndentWidth: 78\n" 12632 "---\n" 12633 "Language: JavaScript\n" 12634 "IndentWidth: 56\n" 12635 "...\n", 12636 IndentWidth, 78u); 12637 12638 Style.ColumnLimit = 123; 12639 Style.IndentWidth = 234; 12640 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 12641 Style.TabWidth = 345; 12642 EXPECT_FALSE(parseConfiguration("---\n" 12643 "IndentWidth: 456\n" 12644 "BreakBeforeBraces: Allman\n" 12645 "---\n" 12646 "Language: JavaScript\n" 12647 "IndentWidth: 111\n" 12648 "TabWidth: 111\n" 12649 "---\n" 12650 "Language: Cpp\n" 12651 "BreakBeforeBraces: Stroustrup\n" 12652 "TabWidth: 789\n" 12653 "...\n", 12654 &Style)); 12655 EXPECT_EQ(123u, Style.ColumnLimit); 12656 EXPECT_EQ(456u, Style.IndentWidth); 12657 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 12658 EXPECT_EQ(789u, Style.TabWidth); 12659 12660 EXPECT_EQ(parseConfiguration("---\n" 12661 "Language: JavaScript\n" 12662 "IndentWidth: 56\n" 12663 "---\n" 12664 "IndentWidth: 78\n" 12665 "...\n", 12666 &Style), 12667 ParseError::Error); 12668 EXPECT_EQ(parseConfiguration("---\n" 12669 "Language: JavaScript\n" 12670 "IndentWidth: 56\n" 12671 "---\n" 12672 "Language: JavaScript\n" 12673 "IndentWidth: 78\n" 12674 "...\n", 12675 &Style), 12676 ParseError::Error); 12677 12678 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12679 } 12680 12681 #undef CHECK_PARSE 12682 12683 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 12684 FormatStyle Style = {}; 12685 Style.Language = FormatStyle::LK_JavaScript; 12686 Style.BreakBeforeTernaryOperators = true; 12687 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 12688 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 12689 12690 Style.BreakBeforeTernaryOperators = true; 12691 EXPECT_EQ(0, parseConfiguration("---\n" 12692 "BasedOnStyle: Google\n" 12693 "---\n" 12694 "Language: JavaScript\n" 12695 "IndentWidth: 76\n" 12696 "...\n", 12697 &Style) 12698 .value()); 12699 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 12700 EXPECT_EQ(76u, Style.IndentWidth); 12701 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12702 } 12703 12704 TEST_F(FormatTest, ConfigurationRoundTripTest) { 12705 FormatStyle Style = getLLVMStyle(); 12706 std::string YAML = configurationAsText(Style); 12707 FormatStyle ParsedStyle = {}; 12708 ParsedStyle.Language = FormatStyle::LK_Cpp; 12709 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 12710 EXPECT_EQ(Style, ParsedStyle); 12711 } 12712 12713 TEST_F(FormatTest, WorksFor8bitEncodings) { 12714 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 12715 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 12716 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 12717 "\"\xef\xee\xf0\xf3...\"", 12718 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 12719 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 12720 "\xef\xee\xf0\xf3...\"", 12721 getLLVMStyleWithColumns(12))); 12722 } 12723 12724 TEST_F(FormatTest, HandlesUTF8BOM) { 12725 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 12726 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 12727 format("\xef\xbb\xbf#include <iostream>")); 12728 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 12729 format("\xef\xbb\xbf\n#include <iostream>")); 12730 } 12731 12732 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 12733 #if !defined(_MSC_VER) 12734 12735 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 12736 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 12737 getLLVMStyleWithColumns(35)); 12738 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 12739 getLLVMStyleWithColumns(31)); 12740 verifyFormat("// Однажды в студёную зимнюю пору...", 12741 getLLVMStyleWithColumns(36)); 12742 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 12743 verifyFormat("/* Однажды в студёную зимнюю пору... */", 12744 getLLVMStyleWithColumns(39)); 12745 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 12746 getLLVMStyleWithColumns(35)); 12747 } 12748 12749 TEST_F(FormatTest, SplitsUTF8Strings) { 12750 // Non-printable characters' width is currently considered to be the length in 12751 // bytes in UTF8. The characters can be displayed in very different manner 12752 // (zero-width, single width with a substitution glyph, expanded to their code 12753 // (e.g. "<8d>"), so there's no single correct way to handle them. 12754 EXPECT_EQ("\"aaaaÄ\"\n" 12755 "\"\xc2\x8d\";", 12756 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 12757 EXPECT_EQ("\"aaaaaaaÄ\"\n" 12758 "\"\xc2\x8d\";", 12759 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 12760 EXPECT_EQ("\"Однажды, в \"\n" 12761 "\"студёную \"\n" 12762 "\"зимнюю \"\n" 12763 "\"пору,\"", 12764 format("\"Однажды, в студёную зимнюю пору,\"", 12765 getLLVMStyleWithColumns(13))); 12766 EXPECT_EQ( 12767 "\"一 二 三 \"\n" 12768 "\"四 五六 \"\n" 12769 "\"七 八 九 \"\n" 12770 "\"十\"", 12771 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 12772 EXPECT_EQ("\"一\t\"\n" 12773 "\"二 \t\"\n" 12774 "\"三 四 \"\n" 12775 "\"五\t\"\n" 12776 "\"六 \t\"\n" 12777 "\"七 \"\n" 12778 "\"八九十\tqq\"", 12779 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 12780 getLLVMStyleWithColumns(11))); 12781 12782 // UTF8 character in an escape sequence. 12783 EXPECT_EQ("\"aaaaaa\"\n" 12784 "\"\\\xC2\x8D\"", 12785 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 12786 } 12787 12788 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 12789 EXPECT_EQ("const char *sssss =\n" 12790 " \"一二三四五六七八\\\n" 12791 " 九 十\";", 12792 format("const char *sssss = \"一二三四五六七八\\\n" 12793 " 九 十\";", 12794 getLLVMStyleWithColumns(30))); 12795 } 12796 12797 TEST_F(FormatTest, SplitsUTF8LineComments) { 12798 EXPECT_EQ("// aaaaÄ\xc2\x8d", 12799 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 12800 EXPECT_EQ("// Я из лесу\n" 12801 "// вышел; был\n" 12802 "// сильный\n" 12803 "// мороз.", 12804 format("// Я из лесу вышел; был сильный мороз.", 12805 getLLVMStyleWithColumns(13))); 12806 EXPECT_EQ("// 一二三\n" 12807 "// 四五六七\n" 12808 "// 八 九\n" 12809 "// 十", 12810 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 12811 } 12812 12813 TEST_F(FormatTest, SplitsUTF8BlockComments) { 12814 EXPECT_EQ("/* Гляжу,\n" 12815 " * поднимается\n" 12816 " * медленно в\n" 12817 " * гору\n" 12818 " * Лошадка,\n" 12819 " * везущая\n" 12820 " * хворосту\n" 12821 " * воз. */", 12822 format("/* Гляжу, поднимается медленно в гору\n" 12823 " * Лошадка, везущая хворосту воз. */", 12824 getLLVMStyleWithColumns(13))); 12825 EXPECT_EQ( 12826 "/* 一二三\n" 12827 " * 四五六七\n" 12828 " * 八 九\n" 12829 " * 十 */", 12830 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 12831 EXPECT_EQ("/* �������� ��������\n" 12832 " * ��������\n" 12833 " * ������-�� */", 12834 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 12835 } 12836 12837 #endif // _MSC_VER 12838 12839 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 12840 FormatStyle Style = getLLVMStyle(); 12841 12842 Style.ConstructorInitializerIndentWidth = 4; 12843 verifyFormat( 12844 "SomeClass::Constructor()\n" 12845 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12846 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12847 Style); 12848 12849 Style.ConstructorInitializerIndentWidth = 2; 12850 verifyFormat( 12851 "SomeClass::Constructor()\n" 12852 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12853 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12854 Style); 12855 12856 Style.ConstructorInitializerIndentWidth = 0; 12857 verifyFormat( 12858 "SomeClass::Constructor()\n" 12859 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12860 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12861 Style); 12862 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 12863 verifyFormat( 12864 "SomeLongTemplateVariableName<\n" 12865 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 12866 Style); 12867 verifyFormat("bool smaller = 1 < " 12868 "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 12869 " " 12870 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 12871 Style); 12872 12873 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 12874 verifyFormat("SomeClass::Constructor() :\n" 12875 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 12876 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 12877 Style); 12878 } 12879 12880 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 12881 FormatStyle Style = getLLVMStyle(); 12882 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 12883 Style.ConstructorInitializerIndentWidth = 4; 12884 verifyFormat("SomeClass::Constructor()\n" 12885 " : a(a)\n" 12886 " , b(b)\n" 12887 " , c(c) {}", 12888 Style); 12889 verifyFormat("SomeClass::Constructor()\n" 12890 " : a(a) {}", 12891 Style); 12892 12893 Style.ColumnLimit = 0; 12894 verifyFormat("SomeClass::Constructor()\n" 12895 " : a(a) {}", 12896 Style); 12897 verifyFormat("SomeClass::Constructor() noexcept\n" 12898 " : a(a) {}", 12899 Style); 12900 verifyFormat("SomeClass::Constructor()\n" 12901 " : a(a)\n" 12902 " , b(b)\n" 12903 " , c(c) {}", 12904 Style); 12905 verifyFormat("SomeClass::Constructor()\n" 12906 " : a(a) {\n" 12907 " foo();\n" 12908 " bar();\n" 12909 "}", 12910 Style); 12911 12912 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 12913 verifyFormat("SomeClass::Constructor()\n" 12914 " : a(a)\n" 12915 " , b(b)\n" 12916 " , c(c) {\n}", 12917 Style); 12918 verifyFormat("SomeClass::Constructor()\n" 12919 " : a(a) {\n}", 12920 Style); 12921 12922 Style.ColumnLimit = 80; 12923 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 12924 Style.ConstructorInitializerIndentWidth = 2; 12925 verifyFormat("SomeClass::Constructor()\n" 12926 " : a(a)\n" 12927 " , b(b)\n" 12928 " , c(c) {}", 12929 Style); 12930 12931 Style.ConstructorInitializerIndentWidth = 0; 12932 verifyFormat("SomeClass::Constructor()\n" 12933 ": a(a)\n" 12934 ", b(b)\n" 12935 ", c(c) {}", 12936 Style); 12937 12938 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 12939 Style.ConstructorInitializerIndentWidth = 4; 12940 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 12941 verifyFormat( 12942 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 12943 Style); 12944 verifyFormat( 12945 "SomeClass::Constructor()\n" 12946 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 12947 Style); 12948 Style.ConstructorInitializerIndentWidth = 4; 12949 Style.ColumnLimit = 60; 12950 verifyFormat("SomeClass::Constructor()\n" 12951 " : aaaaaaaa(aaaaaaaa)\n" 12952 " , aaaaaaaa(aaaaaaaa)\n" 12953 " , aaaaaaaa(aaaaaaaa) {}", 12954 Style); 12955 } 12956 12957 TEST_F(FormatTest, Destructors) { 12958 verifyFormat("void F(int &i) { i.~int(); }"); 12959 verifyFormat("void F(int &i) { i->~int(); }"); 12960 } 12961 12962 TEST_F(FormatTest, FormatsWithWebKitStyle) { 12963 FormatStyle Style = getWebKitStyle(); 12964 12965 // Don't indent in outer namespaces. 12966 verifyFormat("namespace outer {\n" 12967 "int i;\n" 12968 "namespace inner {\n" 12969 " int i;\n" 12970 "} // namespace inner\n" 12971 "} // namespace outer\n" 12972 "namespace other_outer {\n" 12973 "int i;\n" 12974 "}", 12975 Style); 12976 12977 // Don't indent case labels. 12978 verifyFormat("switch (variable) {\n" 12979 "case 1:\n" 12980 "case 2:\n" 12981 " doSomething();\n" 12982 " break;\n" 12983 "default:\n" 12984 " ++variable;\n" 12985 "}", 12986 Style); 12987 12988 // Wrap before binary operators. 12989 EXPECT_EQ("void f()\n" 12990 "{\n" 12991 " if (aaaaaaaaaaaaaaaa\n" 12992 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 12993 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 12994 " return;\n" 12995 "}", 12996 format("void f() {\n" 12997 "if (aaaaaaaaaaaaaaaa\n" 12998 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 12999 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13000 "return;\n" 13001 "}", 13002 Style)); 13003 13004 // Allow functions on a single line. 13005 verifyFormat("void f() { return; }", Style); 13006 13007 // Allow empty blocks on a single line and insert a space in empty blocks. 13008 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 13009 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 13010 // However, don't merge non-empty short loops. 13011 EXPECT_EQ("while (true) {\n" 13012 " continue;\n" 13013 "}", 13014 format("while (true) { continue; }", Style)); 13015 13016 // Constructor initializers are formatted one per line with the "," on the 13017 // new line. 13018 verifyFormat("Constructor()\n" 13019 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 13020 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 13021 " aaaaaaaaaaaaaa)\n" 13022 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 13023 "{\n" 13024 "}", 13025 Style); 13026 verifyFormat("SomeClass::Constructor()\n" 13027 " : a(a)\n" 13028 "{\n" 13029 "}", 13030 Style); 13031 EXPECT_EQ("SomeClass::Constructor()\n" 13032 " : a(a)\n" 13033 "{\n" 13034 "}", 13035 format("SomeClass::Constructor():a(a){}", Style)); 13036 verifyFormat("SomeClass::Constructor()\n" 13037 " : a(a)\n" 13038 " , b(b)\n" 13039 " , c(c)\n" 13040 "{\n" 13041 "}", 13042 Style); 13043 verifyFormat("SomeClass::Constructor()\n" 13044 " : a(a)\n" 13045 "{\n" 13046 " foo();\n" 13047 " bar();\n" 13048 "}", 13049 Style); 13050 13051 // Access specifiers should be aligned left. 13052 verifyFormat("class C {\n" 13053 "public:\n" 13054 " int i;\n" 13055 "};", 13056 Style); 13057 13058 // Do not align comments. 13059 verifyFormat("int a; // Do not\n" 13060 "double b; // align comments.", 13061 Style); 13062 13063 // Do not align operands. 13064 EXPECT_EQ("ASSERT(aaaa\n" 13065 " || bbbb);", 13066 format("ASSERT ( aaaa\n||bbbb);", Style)); 13067 13068 // Accept input's line breaks. 13069 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 13070 " || bbbbbbbbbbbbbbb) {\n" 13071 " i++;\n" 13072 "}", 13073 format("if (aaaaaaaaaaaaaaa\n" 13074 "|| bbbbbbbbbbbbbbb) { i++; }", 13075 Style)); 13076 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 13077 " i++;\n" 13078 "}", 13079 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 13080 13081 // Don't automatically break all macro definitions (llvm.org/PR17842). 13082 verifyFormat("#define aNumber 10", Style); 13083 // However, generally keep the line breaks that the user authored. 13084 EXPECT_EQ("#define aNumber \\\n" 13085 " 10", 13086 format("#define aNumber \\\n" 13087 " 10", 13088 Style)); 13089 13090 // Keep empty and one-element array literals on a single line. 13091 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 13092 " copyItems:YES];", 13093 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 13094 "copyItems:YES];", 13095 Style)); 13096 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 13097 " copyItems:YES];", 13098 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 13099 " copyItems:YES];", 13100 Style)); 13101 // FIXME: This does not seem right, there should be more indentation before 13102 // the array literal's entries. Nested blocks have the same problem. 13103 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13104 " @\"a\",\n" 13105 " @\"a\"\n" 13106 "]\n" 13107 " copyItems:YES];", 13108 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13109 " @\"a\",\n" 13110 " @\"a\"\n" 13111 " ]\n" 13112 " copyItems:YES];", 13113 Style)); 13114 EXPECT_EQ( 13115 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13116 " copyItems:YES];", 13117 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13118 " copyItems:YES];", 13119 Style)); 13120 13121 verifyFormat("[self.a b:c c:d];", Style); 13122 EXPECT_EQ("[self.a b:c\n" 13123 " c:d];", 13124 format("[self.a b:c\n" 13125 "c:d];", 13126 Style)); 13127 } 13128 13129 TEST_F(FormatTest, FormatsLambdas) { 13130 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 13131 verifyFormat( 13132 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 13133 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 13134 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 13135 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 13136 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 13137 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 13138 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 13139 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 13140 verifyFormat("int x = f(*+[] {});"); 13141 verifyFormat("void f() {\n" 13142 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 13143 "}\n"); 13144 verifyFormat("void f() {\n" 13145 " other(x.begin(), //\n" 13146 " x.end(), //\n" 13147 " [&](int, int) { return 1; });\n" 13148 "}\n"); 13149 verifyFormat("void f() {\n" 13150 " other.other.other.other.other(\n" 13151 " x.begin(), x.end(),\n" 13152 " [something, rather](int, int, int, int, int, int, int) { " 13153 "return 1; });\n" 13154 "}\n"); 13155 verifyFormat( 13156 "void f() {\n" 13157 " other.other.other.other.other(\n" 13158 " x.begin(), x.end(),\n" 13159 " [something, rather](int, int, int, int, int, int, int) {\n" 13160 " //\n" 13161 " });\n" 13162 "}\n"); 13163 verifyFormat("SomeFunction([]() { // A cool function...\n" 13164 " return 43;\n" 13165 "});"); 13166 EXPECT_EQ("SomeFunction([]() {\n" 13167 "#define A a\n" 13168 " return 43;\n" 13169 "});", 13170 format("SomeFunction([](){\n" 13171 "#define A a\n" 13172 "return 43;\n" 13173 "});")); 13174 verifyFormat("void f() {\n" 13175 " SomeFunction([](decltype(x), A *a) {});\n" 13176 "}"); 13177 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13178 " [](const aaaaaaaaaa &a) { return a; });"); 13179 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 13180 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 13181 "});"); 13182 verifyFormat("Constructor()\n" 13183 " : Field([] { // comment\n" 13184 " int i;\n" 13185 " }) {}"); 13186 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 13187 " return some_parameter.size();\n" 13188 "};"); 13189 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 13190 " [](const string &s) { return s; };"); 13191 verifyFormat("int i = aaaaaa ? 1 //\n" 13192 " : [] {\n" 13193 " return 2; //\n" 13194 " }();"); 13195 verifyFormat("llvm::errs() << \"number of twos is \"\n" 13196 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 13197 " return x == 2; // force break\n" 13198 " });"); 13199 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13200 " [=](int iiiiiiiiiiii) {\n" 13201 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 13202 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 13203 " });", 13204 getLLVMStyleWithColumns(60)); 13205 verifyFormat("SomeFunction({[&] {\n" 13206 " // comment\n" 13207 " },\n" 13208 " [&] {\n" 13209 " // comment\n" 13210 " }});"); 13211 verifyFormat("SomeFunction({[&] {\n" 13212 " // comment\n" 13213 "}});"); 13214 verifyFormat( 13215 "virtual aaaaaaaaaaaaaaaa(\n" 13216 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 13217 " aaaaa aaaaaaaaa);"); 13218 13219 // Lambdas with return types. 13220 verifyFormat("int c = []() -> int { return 2; }();\n"); 13221 verifyFormat("int c = []() -> int * { return 2; }();\n"); 13222 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 13223 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 13224 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 13225 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 13226 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 13227 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 13228 verifyFormat("[a, a]() -> a<1> {};"); 13229 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 13230 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 13231 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 13232 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 13233 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 13234 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 13235 verifyFormat("[]() -> foo<!5> { return {}; };"); 13236 verifyFormat("[]() -> foo<~5> { return {}; };"); 13237 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 13238 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 13239 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 13240 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 13241 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 13242 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 13243 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 13244 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 13245 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 13246 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 13247 verifyFormat("namespace bar {\n" 13248 "// broken:\n" 13249 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 13250 "} // namespace bar"); 13251 verifyFormat("namespace bar {\n" 13252 "// broken:\n" 13253 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 13254 "} // namespace bar"); 13255 verifyFormat("namespace bar {\n" 13256 "// broken:\n" 13257 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 13258 "} // namespace bar"); 13259 verifyFormat("namespace bar {\n" 13260 "// broken:\n" 13261 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 13262 "} // namespace bar"); 13263 verifyFormat("namespace bar {\n" 13264 "// broken:\n" 13265 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 13266 "} // namespace bar"); 13267 verifyFormat("namespace bar {\n" 13268 "// broken:\n" 13269 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 13270 "} // namespace bar"); 13271 verifyFormat("namespace bar {\n" 13272 "// broken:\n" 13273 "auto foo{[]() -> foo<!5> { return {}; }};\n" 13274 "} // namespace bar"); 13275 verifyFormat("namespace bar {\n" 13276 "// broken:\n" 13277 "auto foo{[]() -> foo<~5> { return {}; }};\n" 13278 "} // namespace bar"); 13279 verifyFormat("namespace bar {\n" 13280 "// broken:\n" 13281 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 13282 "} // namespace bar"); 13283 verifyFormat("namespace bar {\n" 13284 "// broken:\n" 13285 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 13286 "} // namespace bar"); 13287 verifyFormat("namespace bar {\n" 13288 "// broken:\n" 13289 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 13290 "} // namespace bar"); 13291 verifyFormat("namespace bar {\n" 13292 "// broken:\n" 13293 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 13294 "} // namespace bar"); 13295 verifyFormat("namespace bar {\n" 13296 "// broken:\n" 13297 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 13298 "} // namespace bar"); 13299 verifyFormat("namespace bar {\n" 13300 "// broken:\n" 13301 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 13302 "} // namespace bar"); 13303 verifyFormat("namespace bar {\n" 13304 "// broken:\n" 13305 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 13306 "} // namespace bar"); 13307 verifyFormat("namespace bar {\n" 13308 "// broken:\n" 13309 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 13310 "} // namespace bar"); 13311 verifyFormat("namespace bar {\n" 13312 "// broken:\n" 13313 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 13314 "} // namespace bar"); 13315 verifyFormat("namespace bar {\n" 13316 "// broken:\n" 13317 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 13318 "} // namespace bar"); 13319 verifyFormat("[]() -> a<1> {};"); 13320 verifyFormat("[]() -> a<1> { ; };"); 13321 verifyFormat("[]() -> a<1> { ; }();"); 13322 verifyFormat("[a, a]() -> a<true> {};"); 13323 verifyFormat("[]() -> a<true> {};"); 13324 verifyFormat("[]() -> a<true> { ; };"); 13325 verifyFormat("[]() -> a<true> { ; }();"); 13326 verifyFormat("[a, a]() -> a<false> {};"); 13327 verifyFormat("[]() -> a<false> {};"); 13328 verifyFormat("[]() -> a<false> { ; };"); 13329 verifyFormat("[]() -> a<false> { ; }();"); 13330 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 13331 verifyFormat("namespace bar {\n" 13332 "auto foo{[]() -> foo<false> { ; }};\n" 13333 "} // namespace bar"); 13334 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 13335 " int j) -> int {\n" 13336 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 13337 "};"); 13338 verifyFormat( 13339 "aaaaaaaaaaaaaaaaaaaaaa(\n" 13340 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 13341 " return aaaaaaaaaaaaaaaaa;\n" 13342 " });", 13343 getLLVMStyleWithColumns(70)); 13344 verifyFormat("[]() //\n" 13345 " -> int {\n" 13346 " return 1; //\n" 13347 "};"); 13348 13349 // Lambdas with explicit template argument lists. 13350 verifyFormat( 13351 "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n"); 13352 13353 // Multiple lambdas in the same parentheses change indentation rules. These 13354 // lambdas are forced to start on new lines. 13355 verifyFormat("SomeFunction(\n" 13356 " []() {\n" 13357 " //\n" 13358 " },\n" 13359 " []() {\n" 13360 " //\n" 13361 " });"); 13362 13363 // A lambda passed as arg0 is always pushed to the next line. 13364 verifyFormat("SomeFunction(\n" 13365 " [this] {\n" 13366 " //\n" 13367 " },\n" 13368 " 1);\n"); 13369 13370 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like 13371 // the arg0 case above. 13372 auto Style = getGoogleStyle(); 13373 Style.BinPackArguments = false; 13374 verifyFormat("SomeFunction(\n" 13375 " a,\n" 13376 " [this] {\n" 13377 " //\n" 13378 " },\n" 13379 " b);\n", 13380 Style); 13381 verifyFormat("SomeFunction(\n" 13382 " a,\n" 13383 " [this] {\n" 13384 " //\n" 13385 " },\n" 13386 " b);\n"); 13387 13388 // A lambda with a very long line forces arg0 to be pushed out irrespective of 13389 // the BinPackArguments value (as long as the code is wide enough). 13390 verifyFormat( 13391 "something->SomeFunction(\n" 13392 " a,\n" 13393 " [this] {\n" 13394 " " 13395 "D0000000000000000000000000000000000000000000000000000000000001();\n" 13396 " },\n" 13397 " b);\n"); 13398 13399 // A multi-line lambda is pulled up as long as the introducer fits on the 13400 // previous line and there are no further args. 13401 verifyFormat("function(1, [this, that] {\n" 13402 " //\n" 13403 "});\n"); 13404 verifyFormat("function([this, that] {\n" 13405 " //\n" 13406 "});\n"); 13407 // FIXME: this format is not ideal and we should consider forcing the first 13408 // arg onto its own line. 13409 verifyFormat("function(a, b, c, //\n" 13410 " d, [this, that] {\n" 13411 " //\n" 13412 " });\n"); 13413 13414 // Multiple lambdas are treated correctly even when there is a short arg0. 13415 verifyFormat("SomeFunction(\n" 13416 " 1,\n" 13417 " [this] {\n" 13418 " //\n" 13419 " },\n" 13420 " [this] {\n" 13421 " //\n" 13422 " },\n" 13423 " 1);\n"); 13424 13425 // More complex introducers. 13426 verifyFormat("return [i, args...] {};"); 13427 13428 // Not lambdas. 13429 verifyFormat("constexpr char hello[]{\"hello\"};"); 13430 verifyFormat("double &operator[](int i) { return 0; }\n" 13431 "int i;"); 13432 verifyFormat("std::unique_ptr<int[]> foo() {}"); 13433 verifyFormat("int i = a[a][a]->f();"); 13434 verifyFormat("int i = (*b)[a]->f();"); 13435 13436 // Other corner cases. 13437 verifyFormat("void f() {\n" 13438 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 13439 " );\n" 13440 "}"); 13441 13442 // Lambdas created through weird macros. 13443 verifyFormat("void f() {\n" 13444 " MACRO((const AA &a) { return 1; });\n" 13445 " MACRO((AA &a) { return 1; });\n" 13446 "}"); 13447 13448 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 13449 " doo_dah();\n" 13450 " doo_dah();\n" 13451 " })) {\n" 13452 "}"); 13453 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 13454 " doo_dah();\n" 13455 " doo_dah();\n" 13456 " })) {\n" 13457 "}"); 13458 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n" 13459 " doo_dah();\n" 13460 " doo_dah();\n" 13461 " })) {\n" 13462 "}"); 13463 verifyFormat("auto lambda = []() {\n" 13464 " int a = 2\n" 13465 "#if A\n" 13466 " + 2\n" 13467 "#endif\n" 13468 " ;\n" 13469 "};"); 13470 13471 // Lambdas with complex multiline introducers. 13472 verifyFormat( 13473 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13474 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 13475 " -> ::std::unordered_set<\n" 13476 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 13477 " //\n" 13478 " });"); 13479 13480 FormatStyle DoNotMerge = getLLVMStyle(); 13481 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 13482 verifyFormat("auto c = []() {\n" 13483 " return b;\n" 13484 "};", 13485 "auto c = []() { return b; };", DoNotMerge); 13486 verifyFormat("auto c = []() {\n" 13487 "};", 13488 " auto c = []() {};", DoNotMerge); 13489 13490 FormatStyle MergeEmptyOnly = getLLVMStyle(); 13491 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 13492 verifyFormat("auto c = []() {\n" 13493 " return b;\n" 13494 "};", 13495 "auto c = []() {\n" 13496 " return b;\n" 13497 " };", 13498 MergeEmptyOnly); 13499 verifyFormat("auto c = []() {};", 13500 "auto c = []() {\n" 13501 "};", 13502 MergeEmptyOnly); 13503 13504 FormatStyle MergeInline = getLLVMStyle(); 13505 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 13506 verifyFormat("auto c = []() {\n" 13507 " return b;\n" 13508 "};", 13509 "auto c = []() { return b; };", MergeInline); 13510 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 13511 MergeInline); 13512 verifyFormat("function([]() { return b; }, a)", 13513 "function([]() { return b; }, a)", MergeInline); 13514 verifyFormat("function(a, []() { return b; })", 13515 "function(a, []() { return b; })", MergeInline); 13516 } 13517 13518 TEST_F(FormatTest, EmptyLinesInLambdas) { 13519 verifyFormat("auto lambda = []() {\n" 13520 " x(); //\n" 13521 "};", 13522 "auto lambda = []() {\n" 13523 "\n" 13524 " x(); //\n" 13525 "\n" 13526 "};"); 13527 } 13528 13529 TEST_F(FormatTest, FormatsBlocks) { 13530 FormatStyle ShortBlocks = getLLVMStyle(); 13531 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13532 verifyFormat("int (^Block)(int, int);", ShortBlocks); 13533 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 13534 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 13535 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 13536 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 13537 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 13538 13539 verifyFormat("foo(^{ bar(); });", ShortBlocks); 13540 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 13541 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 13542 13543 verifyFormat("[operation setCompletionBlock:^{\n" 13544 " [self onOperationDone];\n" 13545 "}];"); 13546 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 13547 " [self onOperationDone];\n" 13548 "}]};"); 13549 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 13550 " f();\n" 13551 "}];"); 13552 verifyFormat("int a = [operation block:^int(int *i) {\n" 13553 " return 1;\n" 13554 "}];"); 13555 verifyFormat("[myObject doSomethingWith:arg1\n" 13556 " aaa:^int(int *a) {\n" 13557 " return 1;\n" 13558 " }\n" 13559 " bbb:f(a * bbbbbbbb)];"); 13560 13561 verifyFormat("[operation setCompletionBlock:^{\n" 13562 " [self.delegate newDataAvailable];\n" 13563 "}];", 13564 getLLVMStyleWithColumns(60)); 13565 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 13566 " NSString *path = [self sessionFilePath];\n" 13567 " if (path) {\n" 13568 " // ...\n" 13569 " }\n" 13570 "});"); 13571 verifyFormat("[[SessionService sharedService]\n" 13572 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13573 " if (window) {\n" 13574 " [self windowDidLoad:window];\n" 13575 " } else {\n" 13576 " [self errorLoadingWindow];\n" 13577 " }\n" 13578 " }];"); 13579 verifyFormat("void (^largeBlock)(void) = ^{\n" 13580 " // ...\n" 13581 "};\n", 13582 getLLVMStyleWithColumns(40)); 13583 verifyFormat("[[SessionService sharedService]\n" 13584 " loadWindowWithCompletionBlock: //\n" 13585 " ^(SessionWindow *window) {\n" 13586 " if (window) {\n" 13587 " [self windowDidLoad:window];\n" 13588 " } else {\n" 13589 " [self errorLoadingWindow];\n" 13590 " }\n" 13591 " }];", 13592 getLLVMStyleWithColumns(60)); 13593 verifyFormat("[myObject doSomethingWith:arg1\n" 13594 " firstBlock:^(Foo *a) {\n" 13595 " // ...\n" 13596 " int i;\n" 13597 " }\n" 13598 " secondBlock:^(Bar *b) {\n" 13599 " // ...\n" 13600 " int i;\n" 13601 " }\n" 13602 " thirdBlock:^Foo(Bar *b) {\n" 13603 " // ...\n" 13604 " int i;\n" 13605 " }];"); 13606 verifyFormat("[myObject doSomethingWith:arg1\n" 13607 " firstBlock:-1\n" 13608 " secondBlock:^(Bar *b) {\n" 13609 " // ...\n" 13610 " int i;\n" 13611 " }];"); 13612 13613 verifyFormat("f(^{\n" 13614 " @autoreleasepool {\n" 13615 " if (a) {\n" 13616 " g();\n" 13617 " }\n" 13618 " }\n" 13619 "});"); 13620 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 13621 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 13622 "};"); 13623 13624 FormatStyle FourIndent = getLLVMStyle(); 13625 FourIndent.ObjCBlockIndentWidth = 4; 13626 verifyFormat("[operation setCompletionBlock:^{\n" 13627 " [self onOperationDone];\n" 13628 "}];", 13629 FourIndent); 13630 } 13631 13632 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 13633 FormatStyle ZeroColumn = getLLVMStyle(); 13634 ZeroColumn.ColumnLimit = 0; 13635 13636 verifyFormat("[[SessionService sharedService] " 13637 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13638 " if (window) {\n" 13639 " [self windowDidLoad:window];\n" 13640 " } else {\n" 13641 " [self errorLoadingWindow];\n" 13642 " }\n" 13643 "}];", 13644 ZeroColumn); 13645 EXPECT_EQ("[[SessionService sharedService]\n" 13646 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13647 " if (window) {\n" 13648 " [self windowDidLoad:window];\n" 13649 " } else {\n" 13650 " [self errorLoadingWindow];\n" 13651 " }\n" 13652 " }];", 13653 format("[[SessionService sharedService]\n" 13654 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13655 " if (window) {\n" 13656 " [self windowDidLoad:window];\n" 13657 " } else {\n" 13658 " [self errorLoadingWindow];\n" 13659 " }\n" 13660 "}];", 13661 ZeroColumn)); 13662 verifyFormat("[myObject doSomethingWith:arg1\n" 13663 " firstBlock:^(Foo *a) {\n" 13664 " // ...\n" 13665 " int i;\n" 13666 " }\n" 13667 " secondBlock:^(Bar *b) {\n" 13668 " // ...\n" 13669 " int i;\n" 13670 " }\n" 13671 " thirdBlock:^Foo(Bar *b) {\n" 13672 " // ...\n" 13673 " int i;\n" 13674 " }];", 13675 ZeroColumn); 13676 verifyFormat("f(^{\n" 13677 " @autoreleasepool {\n" 13678 " if (a) {\n" 13679 " g();\n" 13680 " }\n" 13681 " }\n" 13682 "});", 13683 ZeroColumn); 13684 verifyFormat("void (^largeBlock)(void) = ^{\n" 13685 " // ...\n" 13686 "};", 13687 ZeroColumn); 13688 13689 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13690 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 13691 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 13692 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 13693 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 13694 " int i;\n" 13695 "};", 13696 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 13697 } 13698 13699 TEST_F(FormatTest, SupportsCRLF) { 13700 EXPECT_EQ("int a;\r\n" 13701 "int b;\r\n" 13702 "int c;\r\n", 13703 format("int a;\r\n" 13704 " int b;\r\n" 13705 " int c;\r\n", 13706 getLLVMStyle())); 13707 EXPECT_EQ("int a;\r\n" 13708 "int b;\r\n" 13709 "int c;\r\n", 13710 format("int a;\r\n" 13711 " int b;\n" 13712 " int c;\r\n", 13713 getLLVMStyle())); 13714 EXPECT_EQ("int a;\n" 13715 "int b;\n" 13716 "int c;\n", 13717 format("int a;\r\n" 13718 " int b;\n" 13719 " int c;\n", 13720 getLLVMStyle())); 13721 EXPECT_EQ("\"aaaaaaa \"\r\n" 13722 "\"bbbbbbb\";\r\n", 13723 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 13724 EXPECT_EQ("#define A \\\r\n" 13725 " b; \\\r\n" 13726 " c; \\\r\n" 13727 " d;\r\n", 13728 format("#define A \\\r\n" 13729 " b; \\\r\n" 13730 " c; d; \r\n", 13731 getGoogleStyle())); 13732 13733 EXPECT_EQ("/*\r\n" 13734 "multi line block comments\r\n" 13735 "should not introduce\r\n" 13736 "an extra carriage return\r\n" 13737 "*/\r\n", 13738 format("/*\r\n" 13739 "multi line block comments\r\n" 13740 "should not introduce\r\n" 13741 "an extra carriage return\r\n" 13742 "*/\r\n")); 13743 EXPECT_EQ("/*\r\n" 13744 "\r\n" 13745 "*/", 13746 format("/*\r\n" 13747 " \r\r\r\n" 13748 "*/")); 13749 } 13750 13751 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 13752 verifyFormat("MY_CLASS(C) {\n" 13753 " int i;\n" 13754 " int j;\n" 13755 "};"); 13756 } 13757 13758 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 13759 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 13760 TwoIndent.ContinuationIndentWidth = 2; 13761 13762 EXPECT_EQ("int i =\n" 13763 " longFunction(\n" 13764 " arg);", 13765 format("int i = longFunction(arg);", TwoIndent)); 13766 13767 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 13768 SixIndent.ContinuationIndentWidth = 6; 13769 13770 EXPECT_EQ("int i =\n" 13771 " longFunction(\n" 13772 " arg);", 13773 format("int i = longFunction(arg);", SixIndent)); 13774 } 13775 13776 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 13777 FormatStyle Style = getLLVMStyle(); 13778 verifyFormat("int Foo::getter(\n" 13779 " //\n" 13780 ") const {\n" 13781 " return foo;\n" 13782 "}", 13783 Style); 13784 verifyFormat("void Foo::setter(\n" 13785 " //\n" 13786 ") {\n" 13787 " foo = 1;\n" 13788 "}", 13789 Style); 13790 } 13791 13792 TEST_F(FormatTest, SpacesInAngles) { 13793 FormatStyle Spaces = getLLVMStyle(); 13794 Spaces.SpacesInAngles = true; 13795 13796 verifyFormat("static_cast< int >(arg);", Spaces); 13797 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 13798 verifyFormat("f< int, float >();", Spaces); 13799 verifyFormat("template <> g() {}", Spaces); 13800 verifyFormat("template < std::vector< int > > f() {}", Spaces); 13801 verifyFormat("std::function< void(int, int) > fct;", Spaces); 13802 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 13803 Spaces); 13804 13805 Spaces.Standard = FormatStyle::LS_Cpp03; 13806 Spaces.SpacesInAngles = true; 13807 verifyFormat("A< A< int > >();", Spaces); 13808 13809 Spaces.SpacesInAngles = false; 13810 verifyFormat("A<A<int> >();", Spaces); 13811 13812 Spaces.Standard = FormatStyle::LS_Cpp11; 13813 Spaces.SpacesInAngles = true; 13814 verifyFormat("A< A< int > >();", Spaces); 13815 13816 Spaces.SpacesInAngles = false; 13817 verifyFormat("A<A<int>>();", Spaces); 13818 } 13819 13820 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 13821 FormatStyle Style = getLLVMStyle(); 13822 Style.SpaceAfterTemplateKeyword = false; 13823 verifyFormat("template<int> void foo();", Style); 13824 } 13825 13826 TEST_F(FormatTest, TripleAngleBrackets) { 13827 verifyFormat("f<<<1, 1>>>();"); 13828 verifyFormat("f<<<1, 1, 1, s>>>();"); 13829 verifyFormat("f<<<a, b, c, d>>>();"); 13830 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 13831 verifyFormat("f<param><<<1, 1>>>();"); 13832 verifyFormat("f<1><<<1, 1>>>();"); 13833 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 13834 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 13835 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 13836 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 13837 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 13838 } 13839 13840 TEST_F(FormatTest, MergeLessLessAtEnd) { 13841 verifyFormat("<<"); 13842 EXPECT_EQ("< < <", format("\\\n<<<")); 13843 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 13844 "aaallvm::outs() <<"); 13845 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 13846 "aaaallvm::outs()\n <<"); 13847 } 13848 13849 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 13850 std::string code = "#if A\n" 13851 "#if B\n" 13852 "a.\n" 13853 "#endif\n" 13854 " a = 1;\n" 13855 "#else\n" 13856 "#endif\n" 13857 "#if C\n" 13858 "#else\n" 13859 "#endif\n"; 13860 EXPECT_EQ(code, format(code)); 13861 } 13862 13863 TEST_F(FormatTest, HandleConflictMarkers) { 13864 // Git/SVN conflict markers. 13865 EXPECT_EQ("int a;\n" 13866 "void f() {\n" 13867 " callme(some(parameter1,\n" 13868 "<<<<<<< text by the vcs\n" 13869 " parameter2),\n" 13870 "||||||| text by the vcs\n" 13871 " parameter2),\n" 13872 " parameter3,\n" 13873 "======= text by the vcs\n" 13874 " parameter2, parameter3),\n" 13875 ">>>>>>> text by the vcs\n" 13876 " otherparameter);\n", 13877 format("int a;\n" 13878 "void f() {\n" 13879 " callme(some(parameter1,\n" 13880 "<<<<<<< text by the vcs\n" 13881 " parameter2),\n" 13882 "||||||| text by the vcs\n" 13883 " parameter2),\n" 13884 " parameter3,\n" 13885 "======= text by the vcs\n" 13886 " parameter2,\n" 13887 " parameter3),\n" 13888 ">>>>>>> text by the vcs\n" 13889 " otherparameter);\n")); 13890 13891 // Perforce markers. 13892 EXPECT_EQ("void f() {\n" 13893 " function(\n" 13894 ">>>> text by the vcs\n" 13895 " parameter,\n" 13896 "==== text by the vcs\n" 13897 " parameter,\n" 13898 "==== text by the vcs\n" 13899 " parameter,\n" 13900 "<<<< text by the vcs\n" 13901 " parameter);\n", 13902 format("void f() {\n" 13903 " function(\n" 13904 ">>>> text by the vcs\n" 13905 " parameter,\n" 13906 "==== text by the vcs\n" 13907 " parameter,\n" 13908 "==== text by the vcs\n" 13909 " parameter,\n" 13910 "<<<< text by the vcs\n" 13911 " parameter);\n")); 13912 13913 EXPECT_EQ("<<<<<<<\n" 13914 "|||||||\n" 13915 "=======\n" 13916 ">>>>>>>", 13917 format("<<<<<<<\n" 13918 "|||||||\n" 13919 "=======\n" 13920 ">>>>>>>")); 13921 13922 EXPECT_EQ("<<<<<<<\n" 13923 "|||||||\n" 13924 "int i;\n" 13925 "=======\n" 13926 ">>>>>>>", 13927 format("<<<<<<<\n" 13928 "|||||||\n" 13929 "int i;\n" 13930 "=======\n" 13931 ">>>>>>>")); 13932 13933 // FIXME: Handle parsing of macros around conflict markers correctly: 13934 EXPECT_EQ("#define Macro \\\n" 13935 "<<<<<<<\n" 13936 "Something \\\n" 13937 "|||||||\n" 13938 "Else \\\n" 13939 "=======\n" 13940 "Other \\\n" 13941 ">>>>>>>\n" 13942 " End int i;\n", 13943 format("#define Macro \\\n" 13944 "<<<<<<<\n" 13945 " Something \\\n" 13946 "|||||||\n" 13947 " Else \\\n" 13948 "=======\n" 13949 " Other \\\n" 13950 ">>>>>>>\n" 13951 " End\n" 13952 "int i;\n")); 13953 } 13954 13955 TEST_F(FormatTest, DisableRegions) { 13956 EXPECT_EQ("int i;\n" 13957 "// clang-format off\n" 13958 " int j;\n" 13959 "// clang-format on\n" 13960 "int k;", 13961 format(" int i;\n" 13962 " // clang-format off\n" 13963 " int j;\n" 13964 " // clang-format on\n" 13965 " int k;")); 13966 EXPECT_EQ("int i;\n" 13967 "/* clang-format off */\n" 13968 " int j;\n" 13969 "/* clang-format on */\n" 13970 "int k;", 13971 format(" int i;\n" 13972 " /* clang-format off */\n" 13973 " int j;\n" 13974 " /* clang-format on */\n" 13975 " int k;")); 13976 13977 // Don't reflow comments within disabled regions. 13978 EXPECT_EQ("// clang-format off\n" 13979 "// long long long long long long line\n" 13980 "/* clang-format on */\n" 13981 "/* long long long\n" 13982 " * long long long\n" 13983 " * line */\n" 13984 "int i;\n" 13985 "/* clang-format off */\n" 13986 "/* long long long long long long line */\n", 13987 format("// clang-format off\n" 13988 "// long long long long long long line\n" 13989 "/* clang-format on */\n" 13990 "/* long long long long long long line */\n" 13991 "int i;\n" 13992 "/* clang-format off */\n" 13993 "/* long long long long long long line */\n", 13994 getLLVMStyleWithColumns(20))); 13995 } 13996 13997 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 13998 format("? ) ="); 13999 verifyNoCrash("#define a\\\n /**/}"); 14000 } 14001 14002 TEST_F(FormatTest, FormatsTableGenCode) { 14003 FormatStyle Style = getLLVMStyle(); 14004 Style.Language = FormatStyle::LK_TableGen; 14005 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 14006 } 14007 14008 TEST_F(FormatTest, ArrayOfTemplates) { 14009 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 14010 format("auto a = new unique_ptr<int > [ 10];")); 14011 14012 FormatStyle Spaces = getLLVMStyle(); 14013 Spaces.SpacesInSquareBrackets = true; 14014 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 14015 format("auto a = new unique_ptr<int > [10];", Spaces)); 14016 } 14017 14018 TEST_F(FormatTest, ArrayAsTemplateType) { 14019 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 14020 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 14021 14022 FormatStyle Spaces = getLLVMStyle(); 14023 Spaces.SpacesInSquareBrackets = true; 14024 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 14025 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 14026 } 14027 14028 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); } 14029 14030 TEST(FormatStyle, GetStyleWithEmptyFileName) { 14031 llvm::vfs::InMemoryFileSystem FS; 14032 auto Style1 = getStyle("file", "", "Google", "", &FS); 14033 ASSERT_TRUE((bool)Style1); 14034 ASSERT_EQ(*Style1, getGoogleStyle()); 14035 } 14036 14037 TEST(FormatStyle, GetStyleOfFile) { 14038 llvm::vfs::InMemoryFileSystem FS; 14039 // Test 1: format file in the same directory. 14040 ASSERT_TRUE( 14041 FS.addFile("/a/.clang-format", 0, 14042 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 14043 ASSERT_TRUE( 14044 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14045 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 14046 ASSERT_TRUE((bool)Style1); 14047 ASSERT_EQ(*Style1, getLLVMStyle()); 14048 14049 // Test 2.1: fallback to default. 14050 ASSERT_TRUE( 14051 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14052 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 14053 ASSERT_TRUE((bool)Style2); 14054 ASSERT_EQ(*Style2, getMozillaStyle()); 14055 14056 // Test 2.2: no format on 'none' fallback style. 14057 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 14058 ASSERT_TRUE((bool)Style2); 14059 ASSERT_EQ(*Style2, getNoStyle()); 14060 14061 // Test 2.3: format if config is found with no based style while fallback is 14062 // 'none'. 14063 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 14064 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 14065 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 14066 ASSERT_TRUE((bool)Style2); 14067 ASSERT_EQ(*Style2, getLLVMStyle()); 14068 14069 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 14070 Style2 = getStyle("{}", "a.h", "none", "", &FS); 14071 ASSERT_TRUE((bool)Style2); 14072 ASSERT_EQ(*Style2, getLLVMStyle()); 14073 14074 // Test 3: format file in parent directory. 14075 ASSERT_TRUE( 14076 FS.addFile("/c/.clang-format", 0, 14077 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 14078 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 14079 llvm::MemoryBuffer::getMemBuffer("int i;"))); 14080 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 14081 ASSERT_TRUE((bool)Style3); 14082 ASSERT_EQ(*Style3, getGoogleStyle()); 14083 14084 // Test 4: error on invalid fallback style 14085 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 14086 ASSERT_FALSE((bool)Style4); 14087 llvm::consumeError(Style4.takeError()); 14088 14089 // Test 5: error on invalid yaml on command line 14090 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 14091 ASSERT_FALSE((bool)Style5); 14092 llvm::consumeError(Style5.takeError()); 14093 14094 // Test 6: error on invalid style 14095 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 14096 ASSERT_FALSE((bool)Style6); 14097 llvm::consumeError(Style6.takeError()); 14098 14099 // Test 7: found config file, error on parsing it 14100 ASSERT_TRUE( 14101 FS.addFile("/d/.clang-format", 0, 14102 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 14103 "InvalidKey: InvalidValue"))); 14104 ASSERT_TRUE( 14105 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14106 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 14107 ASSERT_FALSE((bool)Style7); 14108 llvm::consumeError(Style7.takeError()); 14109 14110 // Test 8: inferred per-language defaults apply. 14111 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 14112 ASSERT_TRUE((bool)StyleTd); 14113 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 14114 } 14115 14116 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 14117 // Column limit is 20. 14118 std::string Code = "Type *a =\n" 14119 " new Type();\n" 14120 "g(iiiii, 0, jjjjj,\n" 14121 " 0, kkkkk, 0, mm);\n" 14122 "int bad = format ;"; 14123 std::string Expected = "auto a = new Type();\n" 14124 "g(iiiii, nullptr,\n" 14125 " jjjjj, nullptr,\n" 14126 " kkkkk, nullptr,\n" 14127 " mm);\n" 14128 "int bad = format ;"; 14129 FileID ID = Context.createInMemoryFile("format.cpp", Code); 14130 tooling::Replacements Replaces = toReplacements( 14131 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 14132 "auto "), 14133 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 14134 "nullptr"), 14135 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 14136 "nullptr"), 14137 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 14138 "nullptr")}); 14139 14140 format::FormatStyle Style = format::getLLVMStyle(); 14141 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 14142 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 14143 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 14144 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 14145 auto Result = applyAllReplacements(Code, *FormattedReplaces); 14146 EXPECT_TRUE(static_cast<bool>(Result)); 14147 EXPECT_EQ(Expected, *Result); 14148 } 14149 14150 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 14151 std::string Code = "#include \"a.h\"\n" 14152 "#include \"c.h\"\n" 14153 "\n" 14154 "int main() {\n" 14155 " return 0;\n" 14156 "}"; 14157 std::string Expected = "#include \"a.h\"\n" 14158 "#include \"b.h\"\n" 14159 "#include \"c.h\"\n" 14160 "\n" 14161 "int main() {\n" 14162 " return 0;\n" 14163 "}"; 14164 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 14165 tooling::Replacements Replaces = toReplacements( 14166 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 14167 "#include \"b.h\"\n")}); 14168 14169 format::FormatStyle Style = format::getLLVMStyle(); 14170 Style.SortIncludes = true; 14171 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 14172 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 14173 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 14174 auto Result = applyAllReplacements(Code, *FormattedReplaces); 14175 EXPECT_TRUE(static_cast<bool>(Result)); 14176 EXPECT_EQ(Expected, *Result); 14177 } 14178 14179 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 14180 EXPECT_EQ("using std::cin;\n" 14181 "using std::cout;", 14182 format("using std::cout;\n" 14183 "using std::cin;", 14184 getGoogleStyle())); 14185 } 14186 14187 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 14188 format::FormatStyle Style = format::getLLVMStyle(); 14189 Style.Standard = FormatStyle::LS_Cpp03; 14190 // cpp03 recognize this string as identifier u8 and literal character 'a' 14191 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 14192 } 14193 14194 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 14195 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 14196 // all modes, including C++11, C++14 and C++17 14197 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 14198 } 14199 14200 TEST_F(FormatTest, DoNotFormatLikelyXml) { 14201 EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle())); 14202 EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle())); 14203 } 14204 14205 TEST_F(FormatTest, StructuredBindings) { 14206 // Structured bindings is a C++17 feature. 14207 // all modes, including C++11, C++14 and C++17 14208 verifyFormat("auto [a, b] = f();"); 14209 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 14210 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 14211 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 14212 EXPECT_EQ("auto const volatile [a, b] = f();", 14213 format("auto const volatile[a, b] = f();")); 14214 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 14215 EXPECT_EQ("auto &[a, b, c] = f();", 14216 format("auto &[ a , b,c ] = f();")); 14217 EXPECT_EQ("auto &&[a, b, c] = f();", 14218 format("auto &&[ a , b,c ] = f();")); 14219 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 14220 EXPECT_EQ("auto const volatile &&[a, b] = f();", 14221 format("auto const volatile &&[a, b] = f();")); 14222 EXPECT_EQ("auto const &&[a, b] = f();", 14223 format("auto const && [a, b] = f();")); 14224 EXPECT_EQ("const auto &[a, b] = f();", 14225 format("const auto & [a, b] = f();")); 14226 EXPECT_EQ("const auto volatile &&[a, b] = f();", 14227 format("const auto volatile &&[a, b] = f();")); 14228 EXPECT_EQ("volatile const auto &&[a, b] = f();", 14229 format("volatile const auto &&[a, b] = f();")); 14230 EXPECT_EQ("const auto &&[a, b] = f();", 14231 format("const auto && [a, b] = f();")); 14232 14233 // Make sure we don't mistake structured bindings for lambdas. 14234 FormatStyle PointerMiddle = getLLVMStyle(); 14235 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 14236 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 14237 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 14238 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 14239 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 14240 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 14241 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 14242 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 14243 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 14244 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 14245 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 14246 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 14247 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 14248 14249 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 14250 format("for (const auto && [a, b] : some_range) {\n}")); 14251 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 14252 format("for (const auto & [a, b] : some_range) {\n}")); 14253 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 14254 format("for (const auto[a, b] : some_range) {\n}")); 14255 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 14256 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 14257 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 14258 EXPECT_EQ("auto const &[x, y](expr);", 14259 format("auto const & [x,y] (expr);")); 14260 EXPECT_EQ("auto const &&[x, y](expr);", 14261 format("auto const && [x,y] (expr);")); 14262 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 14263 EXPECT_EQ("auto const &[x, y]{expr};", 14264 format("auto const & [x,y] {expr};")); 14265 EXPECT_EQ("auto const &&[x, y]{expr};", 14266 format("auto const && [x,y] {expr};")); 14267 14268 format::FormatStyle Spaces = format::getLLVMStyle(); 14269 Spaces.SpacesInSquareBrackets = true; 14270 verifyFormat("auto [ a, b ] = f();", Spaces); 14271 verifyFormat("auto &&[ a, b ] = f();", Spaces); 14272 verifyFormat("auto &[ a, b ] = f();", Spaces); 14273 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 14274 verifyFormat("auto const &[ a, b ] = f();", Spaces); 14275 } 14276 14277 TEST_F(FormatTest, FileAndCode) { 14278 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 14279 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 14280 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 14281 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 14282 EXPECT_EQ(FormatStyle::LK_ObjC, 14283 guessLanguage("foo.h", "@interface Foo\n@end\n")); 14284 EXPECT_EQ( 14285 FormatStyle::LK_ObjC, 14286 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 14287 EXPECT_EQ(FormatStyle::LK_ObjC, 14288 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 14289 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 14290 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 14291 EXPECT_EQ(FormatStyle::LK_ObjC, 14292 guessLanguage("foo", "@interface Foo\n@end\n")); 14293 EXPECT_EQ(FormatStyle::LK_ObjC, 14294 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 14295 EXPECT_EQ( 14296 FormatStyle::LK_ObjC, 14297 guessLanguage("foo.h", 14298 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 14299 EXPECT_EQ( 14300 FormatStyle::LK_Cpp, 14301 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 14302 } 14303 14304 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 14305 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 14306 EXPECT_EQ(FormatStyle::LK_ObjC, 14307 guessLanguage("foo.h", "array[[calculator getIndex]];")); 14308 EXPECT_EQ(FormatStyle::LK_Cpp, 14309 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 14310 EXPECT_EQ( 14311 FormatStyle::LK_Cpp, 14312 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 14313 EXPECT_EQ(FormatStyle::LK_ObjC, 14314 guessLanguage("foo.h", "[[noreturn foo] bar];")); 14315 EXPECT_EQ(FormatStyle::LK_Cpp, 14316 guessLanguage("foo.h", "[[clang::fallthrough]];")); 14317 EXPECT_EQ(FormatStyle::LK_ObjC, 14318 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 14319 EXPECT_EQ(FormatStyle::LK_Cpp, 14320 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 14321 EXPECT_EQ(FormatStyle::LK_Cpp, 14322 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 14323 EXPECT_EQ(FormatStyle::LK_ObjC, 14324 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 14325 EXPECT_EQ(FormatStyle::LK_Cpp, 14326 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 14327 EXPECT_EQ( 14328 FormatStyle::LK_Cpp, 14329 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 14330 EXPECT_EQ( 14331 FormatStyle::LK_Cpp, 14332 guessLanguage("foo.h", 14333 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 14334 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 14335 } 14336 14337 TEST_F(FormatTest, GuessLanguageWithCaret) { 14338 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 14339 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 14340 EXPECT_EQ(FormatStyle::LK_ObjC, 14341 guessLanguage("foo.h", "int(^)(char, float);")); 14342 EXPECT_EQ(FormatStyle::LK_ObjC, 14343 guessLanguage("foo.h", "int(^foo)(char, float);")); 14344 EXPECT_EQ(FormatStyle::LK_ObjC, 14345 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 14346 EXPECT_EQ(FormatStyle::LK_ObjC, 14347 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 14348 EXPECT_EQ( 14349 FormatStyle::LK_ObjC, 14350 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 14351 } 14352 14353 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 14354 EXPECT_EQ(FormatStyle::LK_Cpp, 14355 guessLanguage("foo.h", "void f() {\n" 14356 " asm (\"mov %[e], %[d]\"\n" 14357 " : [d] \"=rm\" (d)\n" 14358 " [e] \"rm\" (*e));\n" 14359 "}")); 14360 EXPECT_EQ(FormatStyle::LK_Cpp, 14361 guessLanguage("foo.h", "void f() {\n" 14362 " _asm (\"mov %[e], %[d]\"\n" 14363 " : [d] \"=rm\" (d)\n" 14364 " [e] \"rm\" (*e));\n" 14365 "}")); 14366 EXPECT_EQ(FormatStyle::LK_Cpp, 14367 guessLanguage("foo.h", "void f() {\n" 14368 " __asm (\"mov %[e], %[d]\"\n" 14369 " : [d] \"=rm\" (d)\n" 14370 " [e] \"rm\" (*e));\n" 14371 "}")); 14372 EXPECT_EQ(FormatStyle::LK_Cpp, 14373 guessLanguage("foo.h", "void f() {\n" 14374 " __asm__ (\"mov %[e], %[d]\"\n" 14375 " : [d] \"=rm\" (d)\n" 14376 " [e] \"rm\" (*e));\n" 14377 "}")); 14378 EXPECT_EQ(FormatStyle::LK_Cpp, 14379 guessLanguage("foo.h", "void f() {\n" 14380 " asm (\"mov %[e], %[d]\"\n" 14381 " : [d] \"=rm\" (d),\n" 14382 " [e] \"rm\" (*e));\n" 14383 "}")); 14384 EXPECT_EQ(FormatStyle::LK_Cpp, 14385 guessLanguage("foo.h", "void f() {\n" 14386 " asm volatile (\"mov %[e], %[d]\"\n" 14387 " : [d] \"=rm\" (d)\n" 14388 " [e] \"rm\" (*e));\n" 14389 "}")); 14390 } 14391 14392 TEST_F(FormatTest, GuessLanguageWithChildLines) { 14393 EXPECT_EQ(FormatStyle::LK_Cpp, 14394 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 14395 EXPECT_EQ(FormatStyle::LK_ObjC, 14396 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 14397 EXPECT_EQ( 14398 FormatStyle::LK_Cpp, 14399 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 14400 EXPECT_EQ( 14401 FormatStyle::LK_ObjC, 14402 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 14403 } 14404 14405 TEST_F(FormatTest, TypenameMacros) { 14406 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 14407 14408 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 14409 FormatStyle Google = getGoogleStyleWithColumns(0); 14410 Google.TypenameMacros = TypenameMacros; 14411 verifyFormat("struct foo {\n" 14412 " int bar;\n" 14413 " TAILQ_ENTRY(a) bleh;\n" 14414 "};", 14415 Google); 14416 14417 FormatStyle Macros = getLLVMStyle(); 14418 Macros.TypenameMacros = TypenameMacros; 14419 14420 verifyFormat("STACK_OF(int) a;", Macros); 14421 verifyFormat("STACK_OF(int) *a;", Macros); 14422 verifyFormat("STACK_OF(int const *) *a;", Macros); 14423 verifyFormat("STACK_OF(int *const) *a;", Macros); 14424 verifyFormat("STACK_OF(int, string) a;", Macros); 14425 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 14426 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 14427 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 14428 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 14429 14430 Macros.PointerAlignment = FormatStyle::PAS_Left; 14431 verifyFormat("STACK_OF(int)* a;", Macros); 14432 verifyFormat("STACK_OF(int*)* a;", Macros); 14433 } 14434 14435 TEST_F(FormatTest, AmbersandInLamda) { 14436 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899 14437 FormatStyle AlignStyle = getLLVMStyle(); 14438 AlignStyle.PointerAlignment = FormatStyle::PAS_Left; 14439 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 14440 AlignStyle.PointerAlignment = FormatStyle::PAS_Right; 14441 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 14442 } 14443 14444 } // end namespace 14445 } // end namespace format 14446 } // end namespace clang 14447