1 //===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "clang/Format/Format.h" 10 11 #include "../Tooling/ReplacementTest.h" 12 #include "FormatTestUtils.h" 13 14 #include "clang/Frontend/TextDiagnosticPrinter.h" 15 #include "llvm/Support/Debug.h" 16 #include "llvm/Support/MemoryBuffer.h" 17 #include "gtest/gtest.h" 18 19 #define DEBUG_TYPE "format-test" 20 21 using clang::tooling::ReplacementTest; 22 using clang::tooling::toReplacements; 23 24 namespace clang { 25 namespace format { 26 namespace { 27 28 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); } 29 30 class FormatTest : public ::testing::Test { 31 protected: 32 enum StatusCheck { 33 SC_ExpectComplete, 34 SC_ExpectIncomplete, 35 SC_DoNotCheck 36 }; 37 38 std::string format(llvm::StringRef Code, 39 const FormatStyle &Style = getLLVMStyle(), 40 StatusCheck CheckComplete = SC_ExpectComplete) { 41 LLVM_DEBUG(llvm::errs() << "---\n"); 42 LLVM_DEBUG(llvm::errs() << Code << "\n\n"); 43 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size())); 44 FormattingAttemptStatus Status; 45 tooling::Replacements Replaces = 46 reformat(Style, Code, Ranges, "<stdin>", &Status); 47 if (CheckComplete != SC_DoNotCheck) { 48 bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete; 49 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete) 50 << Code << "\n\n"; 51 } 52 ReplacementCount = Replaces.size(); 53 auto Result = applyAllReplacements(Code, Replaces); 54 EXPECT_TRUE(static_cast<bool>(Result)); 55 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); 56 return *Result; 57 } 58 59 FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) { 60 Style.ColumnLimit = ColumnLimit; 61 return Style; 62 } 63 64 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 65 return getStyleWithColumns(getLLVMStyle(), ColumnLimit); 66 } 67 68 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) { 69 return getStyleWithColumns(getGoogleStyle(), ColumnLimit); 70 } 71 72 void verifyFormat(llvm::StringRef Expected, llvm::StringRef Code, 73 const FormatStyle &Style = getLLVMStyle()) { 74 EXPECT_EQ(Expected.str(), format(Expected, Style)) 75 << "Expected code is not stable"; 76 EXPECT_EQ(Expected.str(), format(Code, Style)); 77 if (Style.Language == FormatStyle::LK_Cpp) { 78 // Objective-C++ is a superset of C++, so everything checked for C++ 79 // needs to be checked for Objective-C++ as well. 80 FormatStyle ObjCStyle = Style; 81 ObjCStyle.Language = FormatStyle::LK_ObjC; 82 EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle)); 83 } 84 } 85 86 void verifyFormat(llvm::StringRef Code, 87 const FormatStyle &Style = getLLVMStyle()) { 88 verifyFormat(Code, test::messUp(Code), Style); 89 } 90 91 void verifyIncompleteFormat(llvm::StringRef Code, 92 const FormatStyle &Style = getLLVMStyle()) { 93 EXPECT_EQ(Code.str(), 94 format(test::messUp(Code), Style, SC_ExpectIncomplete)); 95 } 96 97 void verifyGoogleFormat(llvm::StringRef Code) { 98 verifyFormat(Code, getGoogleStyle()); 99 } 100 101 void verifyIndependentOfContext(llvm::StringRef text) { 102 verifyFormat(text); 103 verifyFormat(llvm::Twine("void f() { " + text + " }").str()); 104 } 105 106 /// \brief Verify that clang-format does not crash on the given input. 107 void verifyNoCrash(llvm::StringRef Code, 108 const FormatStyle &Style = getLLVMStyle()) { 109 format(Code, Style, SC_DoNotCheck); 110 } 111 112 int ReplacementCount; 113 }; 114 115 TEST_F(FormatTest, MessUp) { 116 EXPECT_EQ("1 2 3", test::messUp("1 2 3")); 117 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n")); 118 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc")); 119 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc")); 120 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne")); 121 } 122 123 TEST_F(FormatTest, DefaultLLVMStyleIsCpp) { 124 EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language); 125 } 126 127 TEST_F(FormatTest, LLVMStyleOverride) { 128 EXPECT_EQ(FormatStyle::LK_Proto, 129 getLLVMStyle(FormatStyle::LK_Proto).Language); 130 } 131 132 //===----------------------------------------------------------------------===// 133 // Basic function tests. 134 //===----------------------------------------------------------------------===// 135 136 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { 137 EXPECT_EQ(";", format(";")); 138 } 139 140 TEST_F(FormatTest, FormatsGlobalStatementsAt0) { 141 EXPECT_EQ("int i;", format(" int i;")); 142 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;")); 143 EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); 144 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); 145 } 146 147 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { 148 EXPECT_EQ("int i;", format("int\ni;")); 149 } 150 151 TEST_F(FormatTest, FormatsNestedBlockStatements) { 152 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}")); 153 } 154 155 TEST_F(FormatTest, FormatsNestedCall) { 156 verifyFormat("Method(f1, f2(f3));"); 157 verifyFormat("Method(f1(f2, f3()));"); 158 verifyFormat("Method(f1(f2, (f3())));"); 159 } 160 161 TEST_F(FormatTest, NestedNameSpecifiers) { 162 verifyFormat("vector<::Type> v;"); 163 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())"); 164 verifyFormat("static constexpr bool Bar = decltype(bar())::value;"); 165 verifyFormat("bool a = 2 < ::SomeFunction();"); 166 verifyFormat("ALWAYS_INLINE ::std::string getName();"); 167 verifyFormat("some::string getName();"); 168 } 169 170 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { 171 EXPECT_EQ("if (a) {\n" 172 " f();\n" 173 "}", 174 format("if(a){f();}")); 175 EXPECT_EQ(4, ReplacementCount); 176 EXPECT_EQ("if (a) {\n" 177 " f();\n" 178 "}", 179 format("if (a) {\n" 180 " f();\n" 181 "}")); 182 EXPECT_EQ(0, ReplacementCount); 183 EXPECT_EQ("/*\r\n" 184 "\r\n" 185 "*/\r\n", 186 format("/*\r\n" 187 "\r\n" 188 "*/\r\n")); 189 EXPECT_EQ(0, ReplacementCount); 190 } 191 192 TEST_F(FormatTest, RemovesEmptyLines) { 193 EXPECT_EQ("class C {\n" 194 " int i;\n" 195 "};", 196 format("class C {\n" 197 " int i;\n" 198 "\n" 199 "};")); 200 201 // Don't remove empty lines at the start of namespaces or extern "C" blocks. 202 EXPECT_EQ("namespace N {\n" 203 "\n" 204 "int i;\n" 205 "}", 206 format("namespace N {\n" 207 "\n" 208 "int i;\n" 209 "}", 210 getGoogleStyle())); 211 EXPECT_EQ("/* something */ namespace N {\n" 212 "\n" 213 "int i;\n" 214 "}", 215 format("/* something */ namespace N {\n" 216 "\n" 217 "int i;\n" 218 "}", 219 getGoogleStyle())); 220 EXPECT_EQ("inline namespace N {\n" 221 "\n" 222 "int i;\n" 223 "}", 224 format("inline namespace N {\n" 225 "\n" 226 "int i;\n" 227 "}", 228 getGoogleStyle())); 229 EXPECT_EQ("/* something */ inline namespace N {\n" 230 "\n" 231 "int i;\n" 232 "}", 233 format("/* something */ inline namespace N {\n" 234 "\n" 235 "int i;\n" 236 "}", 237 getGoogleStyle())); 238 EXPECT_EQ("export namespace N {\n" 239 "\n" 240 "int i;\n" 241 "}", 242 format("export namespace N {\n" 243 "\n" 244 "int i;\n" 245 "}", 246 getGoogleStyle())); 247 EXPECT_EQ("extern /**/ \"C\" /**/ {\n" 248 "\n" 249 "int i;\n" 250 "}", 251 format("extern /**/ \"C\" /**/ {\n" 252 "\n" 253 "int i;\n" 254 "}", 255 getGoogleStyle())); 256 257 // ...but do keep inlining and removing empty lines for non-block extern "C" 258 // functions. 259 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle()); 260 EXPECT_EQ("extern \"C\" int f() {\n" 261 " int i = 42;\n" 262 " return i;\n" 263 "}", 264 format("extern \"C\" int f() {\n" 265 "\n" 266 " int i = 42;\n" 267 " return i;\n" 268 "}", 269 getGoogleStyle())); 270 271 // Remove empty lines at the beginning and end of blocks. 272 EXPECT_EQ("void f() {\n" 273 "\n" 274 " if (a) {\n" 275 "\n" 276 " f();\n" 277 " }\n" 278 "}", 279 format("void f() {\n" 280 "\n" 281 " if (a) {\n" 282 "\n" 283 " f();\n" 284 "\n" 285 " }\n" 286 "\n" 287 "}", 288 getLLVMStyle())); 289 EXPECT_EQ("void f() {\n" 290 " if (a) {\n" 291 " f();\n" 292 " }\n" 293 "}", 294 format("void f() {\n" 295 "\n" 296 " if (a) {\n" 297 "\n" 298 " f();\n" 299 "\n" 300 " }\n" 301 "\n" 302 "}", 303 getGoogleStyle())); 304 305 // Don't remove empty lines in more complex control statements. 306 EXPECT_EQ("void f() {\n" 307 " if (a) {\n" 308 " f();\n" 309 "\n" 310 " } else if (b) {\n" 311 " f();\n" 312 " }\n" 313 "}", 314 format("void f() {\n" 315 " if (a) {\n" 316 " f();\n" 317 "\n" 318 " } else if (b) {\n" 319 " f();\n" 320 "\n" 321 " }\n" 322 "\n" 323 "}")); 324 325 // Don't remove empty lines before namespace endings. 326 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 327 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 328 EXPECT_EQ("namespace {\n" 329 "int i;\n" 330 "\n" 331 "}", 332 format("namespace {\n" 333 "int i;\n" 334 "\n" 335 "}", LLVMWithNoNamespaceFix)); 336 EXPECT_EQ("namespace {\n" 337 "int i;\n" 338 "}", 339 format("namespace {\n" 340 "int i;\n" 341 "}", LLVMWithNoNamespaceFix)); 342 EXPECT_EQ("namespace {\n" 343 "int i;\n" 344 "\n" 345 "};", 346 format("namespace {\n" 347 "int i;\n" 348 "\n" 349 "};", LLVMWithNoNamespaceFix)); 350 EXPECT_EQ("namespace {\n" 351 "int i;\n" 352 "};", 353 format("namespace {\n" 354 "int i;\n" 355 "};", LLVMWithNoNamespaceFix)); 356 EXPECT_EQ("namespace {\n" 357 "int i;\n" 358 "\n" 359 "}", 360 format("namespace {\n" 361 "int i;\n" 362 "\n" 363 "}")); 364 EXPECT_EQ("namespace {\n" 365 "int i;\n" 366 "\n" 367 "} // namespace", 368 format("namespace {\n" 369 "int i;\n" 370 "\n" 371 "} // namespace")); 372 373 FormatStyle Style = getLLVMStyle(); 374 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 375 Style.MaxEmptyLinesToKeep = 2; 376 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 377 Style.BraceWrapping.AfterClass = true; 378 Style.BraceWrapping.AfterFunction = true; 379 Style.KeepEmptyLinesAtTheStartOfBlocks = false; 380 381 EXPECT_EQ("class Foo\n" 382 "{\n" 383 " Foo() {}\n" 384 "\n" 385 " void funk() {}\n" 386 "};", 387 format("class Foo\n" 388 "{\n" 389 " Foo()\n" 390 " {\n" 391 " }\n" 392 "\n" 393 " void funk() {}\n" 394 "};", 395 Style)); 396 } 397 398 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) { 399 verifyFormat("x = (a) and (b);"); 400 verifyFormat("x = (a) or (b);"); 401 verifyFormat("x = (a) bitand (b);"); 402 verifyFormat("x = (a) bitor (b);"); 403 verifyFormat("x = (a) not_eq (b);"); 404 verifyFormat("x = (a) and_eq (b);"); 405 verifyFormat("x = (a) or_eq (b);"); 406 verifyFormat("x = (a) xor (b);"); 407 } 408 409 TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) { 410 verifyFormat("x = compl(a);"); 411 verifyFormat("x = not(a);"); 412 verifyFormat("x = bitand(a);"); 413 // Unary operator must not be merged with the next identifier 414 verifyFormat("x = compl a;"); 415 verifyFormat("x = not a;"); 416 verifyFormat("x = bitand a;"); 417 } 418 419 //===----------------------------------------------------------------------===// 420 // Tests for control statements. 421 //===----------------------------------------------------------------------===// 422 423 TEST_F(FormatTest, FormatIfWithoutCompoundStatement) { 424 verifyFormat("if (true)\n f();\ng();"); 425 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();"); 426 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();"); 427 verifyFormat("if constexpr (true)\n" 428 " f();\ng();"); 429 verifyFormat("if constexpr (a)\n" 430 " if constexpr (b)\n" 431 " if constexpr (c)\n" 432 " g();\n" 433 "h();"); 434 verifyFormat("if constexpr (a)\n" 435 " if constexpr (b) {\n" 436 " f();\n" 437 " }\n" 438 "g();"); 439 440 FormatStyle AllowsMergedIf = getLLVMStyle(); 441 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 442 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 443 FormatStyle::SIS_WithoutElse; 444 verifyFormat("if (a)\n" 445 " // comment\n" 446 " f();", 447 AllowsMergedIf); 448 verifyFormat("{\n" 449 " if (a)\n" 450 " label:\n" 451 " f();\n" 452 "}", 453 AllowsMergedIf); 454 verifyFormat("#define A \\\n" 455 " if (a) \\\n" 456 " label: \\\n" 457 " f()", 458 AllowsMergedIf); 459 verifyFormat("if (a)\n" 460 " ;", 461 AllowsMergedIf); 462 verifyFormat("if (a)\n" 463 " if (b) return;", 464 AllowsMergedIf); 465 466 verifyFormat("if (a) // Can't merge this\n" 467 " f();\n", 468 AllowsMergedIf); 469 verifyFormat("if (a) /* still don't merge */\n" 470 " f();", 471 AllowsMergedIf); 472 verifyFormat("if (a) { // Never merge this\n" 473 " f();\n" 474 "}", 475 AllowsMergedIf); 476 verifyFormat("if (a) { /* Never merge this */\n" 477 " f();\n" 478 "}", 479 AllowsMergedIf); 480 481 AllowsMergedIf.ColumnLimit = 14; 482 verifyFormat("if (a) return;", AllowsMergedIf); 483 verifyFormat("if (aaaaaaaaa)\n" 484 " return;", 485 AllowsMergedIf); 486 487 AllowsMergedIf.ColumnLimit = 13; 488 verifyFormat("if (a)\n return;", AllowsMergedIf); 489 } 490 491 TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) { 492 FormatStyle AllowsMergedIf = getLLVMStyle(); 493 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 494 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 495 FormatStyle::SIS_WithoutElse; 496 verifyFormat("if (a)\n" 497 " f();\n" 498 "else {\n" 499 " g();\n" 500 "}", 501 AllowsMergedIf); 502 verifyFormat("if (a)\n" 503 " f();\n" 504 "else\n" 505 " g();\n", 506 AllowsMergedIf); 507 508 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 509 510 verifyFormat("if (a) f();\n" 511 "else {\n" 512 " g();\n" 513 "}", 514 AllowsMergedIf); 515 verifyFormat("if (a) f();\n" 516 "else {\n" 517 " if (a) f();\n" 518 " else {\n" 519 " g();\n" 520 " }\n" 521 " g();\n" 522 "}", 523 AllowsMergedIf); 524 } 525 526 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) { 527 FormatStyle AllowsMergedLoops = getLLVMStyle(); 528 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true; 529 verifyFormat("while (true) continue;", AllowsMergedLoops); 530 verifyFormat("for (;;) continue;", AllowsMergedLoops); 531 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops); 532 verifyFormat("while (true)\n" 533 " ;", 534 AllowsMergedLoops); 535 verifyFormat("for (;;)\n" 536 " ;", 537 AllowsMergedLoops); 538 verifyFormat("for (;;)\n" 539 " for (;;) continue;", 540 AllowsMergedLoops); 541 verifyFormat("for (;;) // Can't merge this\n" 542 " continue;", 543 AllowsMergedLoops); 544 verifyFormat("for (;;) /* still don't merge */\n" 545 " continue;", 546 AllowsMergedLoops); 547 } 548 549 TEST_F(FormatTest, FormatShortBracedStatements) { 550 FormatStyle AllowSimpleBracedStatements = getLLVMStyle(); 551 AllowSimpleBracedStatements.ColumnLimit = 40; 552 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = true; 553 554 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 555 FormatStyle::SIS_WithoutElse; 556 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 557 558 AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom; 559 AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true; 560 AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false; 561 562 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 563 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 564 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 565 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 566 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 567 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 568 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 569 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 570 verifyFormat("if (true) {\n" 571 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 572 "}", 573 AllowSimpleBracedStatements); 574 verifyFormat("if (true) { //\n" 575 " f();\n" 576 "}", 577 AllowSimpleBracedStatements); 578 verifyFormat("if (true) {\n" 579 " f();\n" 580 " f();\n" 581 "}", 582 AllowSimpleBracedStatements); 583 verifyFormat("if (true) {\n" 584 " f();\n" 585 "} else {\n" 586 " f();\n" 587 "}", 588 AllowSimpleBracedStatements); 589 590 verifyFormat("struct A2 {\n" 591 " int X;\n" 592 "};", 593 AllowSimpleBracedStatements); 594 verifyFormat("typedef struct A2 {\n" 595 " int X;\n" 596 "} A2_t;", 597 AllowSimpleBracedStatements); 598 verifyFormat("template <int> struct A2 {\n" 599 " struct B {};\n" 600 "};", 601 AllowSimpleBracedStatements); 602 603 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 604 FormatStyle::SIS_Never; 605 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 606 verifyFormat("if (true) {\n" 607 " f();\n" 608 "}", 609 AllowSimpleBracedStatements); 610 verifyFormat("if (true) {\n" 611 " f();\n" 612 "} else {\n" 613 " f();\n" 614 "}", 615 AllowSimpleBracedStatements); 616 617 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 618 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 619 verifyFormat("while (true) {\n" 620 " f();\n" 621 "}", 622 AllowSimpleBracedStatements); 623 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 624 verifyFormat("for (;;) {\n" 625 " f();\n" 626 "}", 627 AllowSimpleBracedStatements); 628 629 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 630 FormatStyle::SIS_WithoutElse; 631 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 632 AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement = true; 633 634 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 635 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 636 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 637 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 638 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 639 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 640 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 641 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 642 verifyFormat("if (true)\n" 643 "{\n" 644 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 645 "}", 646 AllowSimpleBracedStatements); 647 verifyFormat("if (true)\n" 648 "{ //\n" 649 " f();\n" 650 "}", 651 AllowSimpleBracedStatements); 652 verifyFormat("if (true)\n" 653 "{\n" 654 " f();\n" 655 " f();\n" 656 "}", 657 AllowSimpleBracedStatements); 658 verifyFormat("if (true)\n" 659 "{\n" 660 " f();\n" 661 "} else\n" 662 "{\n" 663 " f();\n" 664 "}", 665 AllowSimpleBracedStatements); 666 667 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 668 FormatStyle::SIS_Never; 669 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 670 verifyFormat("if (true)\n" 671 "{\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.AllowShortLoopsOnASingleLine = false; 685 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 686 verifyFormat("while (true)\n" 687 "{\n" 688 " f();\n" 689 "}", 690 AllowSimpleBracedStatements); 691 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 692 verifyFormat("for (;;)\n" 693 "{\n" 694 " f();\n" 695 "}", 696 AllowSimpleBracedStatements); 697 } 698 699 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) { 700 FormatStyle Style = getLLVMStyleWithColumns(60); 701 Style.AllowShortBlocksOnASingleLine = true; 702 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 703 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 704 EXPECT_EQ("#define A \\\n" 705 " if (HANDLEwernufrnuLwrmviferuvnierv) \\\n" 706 " { RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; }\n" 707 "X;", 708 format("#define A \\\n" 709 " if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n" 710 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n" 711 " }\n" 712 "X;", 713 Style)); 714 } 715 716 TEST_F(FormatTest, ParseIfElse) { 717 verifyFormat("if (true)\n" 718 " if (true)\n" 719 " if (true)\n" 720 " f();\n" 721 " else\n" 722 " g();\n" 723 " else\n" 724 " h();\n" 725 "else\n" 726 " i();"); 727 verifyFormat("if (true)\n" 728 " if (true)\n" 729 " if (true) {\n" 730 " if (true)\n" 731 " f();\n" 732 " } else {\n" 733 " g();\n" 734 " }\n" 735 " else\n" 736 " h();\n" 737 "else {\n" 738 " i();\n" 739 "}"); 740 verifyFormat("if (true)\n" 741 " if constexpr (true)\n" 742 " if (true) {\n" 743 " if constexpr (true)\n" 744 " f();\n" 745 " } else {\n" 746 " g();\n" 747 " }\n" 748 " else\n" 749 " h();\n" 750 "else {\n" 751 " i();\n" 752 "}"); 753 verifyFormat("void f() {\n" 754 " if (a) {\n" 755 " } else {\n" 756 " }\n" 757 "}"); 758 } 759 760 TEST_F(FormatTest, ElseIf) { 761 verifyFormat("if (a) {\n} else if (b) {\n}"); 762 verifyFormat("if (a)\n" 763 " f();\n" 764 "else if (b)\n" 765 " g();\n" 766 "else\n" 767 " h();"); 768 verifyFormat("if constexpr (a)\n" 769 " f();\n" 770 "else if constexpr (b)\n" 771 " g();\n" 772 "else\n" 773 " h();"); 774 verifyFormat("if (a) {\n" 775 " f();\n" 776 "}\n" 777 "// or else ..\n" 778 "else {\n" 779 " g()\n" 780 "}"); 781 782 verifyFormat("if (a) {\n" 783 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 784 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 785 "}"); 786 verifyFormat("if (a) {\n" 787 "} else if (\n" 788 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 789 "}", 790 getLLVMStyleWithColumns(62)); 791 verifyFormat("if (a) {\n" 792 "} else if constexpr (\n" 793 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 794 "}", 795 getLLVMStyleWithColumns(62)); 796 } 797 798 TEST_F(FormatTest, FormatsForLoop) { 799 verifyFormat( 800 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 801 " ++VeryVeryLongLoopVariable)\n" 802 " ;"); 803 verifyFormat("for (;;)\n" 804 " f();"); 805 verifyFormat("for (;;) {\n}"); 806 verifyFormat("for (;;) {\n" 807 " f();\n" 808 "}"); 809 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 810 811 verifyFormat( 812 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 813 " E = UnwrappedLines.end();\n" 814 " I != E; ++I) {\n}"); 815 816 verifyFormat( 817 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 818 " ++IIIII) {\n}"); 819 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 820 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 821 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 822 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 823 " I = FD->getDeclsInPrototypeScope().begin(),\n" 824 " E = FD->getDeclsInPrototypeScope().end();\n" 825 " I != E; ++I) {\n}"); 826 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n" 827 " I = Container.begin(),\n" 828 " E = Container.end();\n" 829 " I != E; ++I) {\n}", 830 getLLVMStyleWithColumns(76)); 831 832 verifyFormat( 833 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 834 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 835 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 836 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 837 " ++aaaaaaaaaaa) {\n}"); 838 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 839 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n" 840 " ++i) {\n}"); 841 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 842 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 843 "}"); 844 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 845 " aaaaaaaaaa);\n" 846 " iter; ++iter) {\n" 847 "}"); 848 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 849 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 850 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n" 851 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {"); 852 853 // These should not be formatted as Objective-C for-in loops. 854 verifyFormat("for (Foo *x = 0; x != in; x++) {\n}"); 855 verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}"); 856 verifyFormat("Foo *x;\nfor (x in y) {\n}"); 857 verifyFormat("for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}"); 858 859 FormatStyle NoBinPacking = getLLVMStyle(); 860 NoBinPacking.BinPackParameters = false; 861 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 862 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 863 " aaaaaaaaaaaaaaaa,\n" 864 " aaaaaaaaaaaaaaaa,\n" 865 " aaaaaaaaaaaaaaaa);\n" 866 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 867 "}", 868 NoBinPacking); 869 verifyFormat( 870 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 871 " E = UnwrappedLines.end();\n" 872 " I != E;\n" 873 " ++I) {\n}", 874 NoBinPacking); 875 876 FormatStyle AlignLeft = getLLVMStyle(); 877 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 878 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft); 879 } 880 881 TEST_F(FormatTest, RangeBasedForLoops) { 882 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 883 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 884 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 885 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 886 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 887 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 888 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n" 889 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}"); 890 } 891 892 TEST_F(FormatTest, ForEachLoops) { 893 verifyFormat("void f() {\n" 894 " foreach (Item *item, itemlist) {}\n" 895 " Q_FOREACH (Item *item, itemlist) {}\n" 896 " BOOST_FOREACH (Item *item, itemlist) {}\n" 897 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 898 "}"); 899 900 // As function-like macros. 901 verifyFormat("#define foreach(x, y)\n" 902 "#define Q_FOREACH(x, y)\n" 903 "#define BOOST_FOREACH(x, y)\n" 904 "#define UNKNOWN_FOREACH(x, y)\n"); 905 906 // Not as function-like macros. 907 verifyFormat("#define foreach (x, y)\n" 908 "#define Q_FOREACH (x, y)\n" 909 "#define BOOST_FOREACH (x, y)\n" 910 "#define UNKNOWN_FOREACH (x, y)\n"); 911 } 912 913 TEST_F(FormatTest, FormatsWhileLoop) { 914 verifyFormat("while (true) {\n}"); 915 verifyFormat("while (true)\n" 916 " f();"); 917 verifyFormat("while () {\n}"); 918 verifyFormat("while () {\n" 919 " f();\n" 920 "}"); 921 } 922 923 TEST_F(FormatTest, FormatsDoWhile) { 924 verifyFormat("do {\n" 925 " do_something();\n" 926 "} while (something());"); 927 verifyFormat("do\n" 928 " do_something();\n" 929 "while (something());"); 930 } 931 932 TEST_F(FormatTest, FormatsSwitchStatement) { 933 verifyFormat("switch (x) {\n" 934 "case 1:\n" 935 " f();\n" 936 " break;\n" 937 "case kFoo:\n" 938 "case ns::kBar:\n" 939 "case kBaz:\n" 940 " break;\n" 941 "default:\n" 942 " g();\n" 943 " break;\n" 944 "}"); 945 verifyFormat("switch (x) {\n" 946 "case 1: {\n" 947 " f();\n" 948 " break;\n" 949 "}\n" 950 "case 2: {\n" 951 " break;\n" 952 "}\n" 953 "}"); 954 verifyFormat("switch (x) {\n" 955 "case 1: {\n" 956 " f();\n" 957 " {\n" 958 " g();\n" 959 " h();\n" 960 " }\n" 961 " break;\n" 962 "}\n" 963 "}"); 964 verifyFormat("switch (x) {\n" 965 "case 1: {\n" 966 " f();\n" 967 " if (foo) {\n" 968 " g();\n" 969 " h();\n" 970 " }\n" 971 " break;\n" 972 "}\n" 973 "}"); 974 verifyFormat("switch (x) {\n" 975 "case 1: {\n" 976 " f();\n" 977 " g();\n" 978 "} break;\n" 979 "}"); 980 verifyFormat("switch (test)\n" 981 " ;"); 982 verifyFormat("switch (x) {\n" 983 "default: {\n" 984 " // Do nothing.\n" 985 "}\n" 986 "}"); 987 verifyFormat("switch (x) {\n" 988 "// comment\n" 989 "// if 1, do f()\n" 990 "case 1:\n" 991 " f();\n" 992 "}"); 993 verifyFormat("switch (x) {\n" 994 "case 1:\n" 995 " // Do amazing stuff\n" 996 " {\n" 997 " f();\n" 998 " g();\n" 999 " }\n" 1000 " break;\n" 1001 "}"); 1002 verifyFormat("#define A \\\n" 1003 " switch (x) { \\\n" 1004 " case a: \\\n" 1005 " foo = b; \\\n" 1006 " }", 1007 getLLVMStyleWithColumns(20)); 1008 verifyFormat("#define OPERATION_CASE(name) \\\n" 1009 " case OP_name: \\\n" 1010 " return operations::Operation##name\n", 1011 getLLVMStyleWithColumns(40)); 1012 verifyFormat("switch (x) {\n" 1013 "case 1:;\n" 1014 "default:;\n" 1015 " int i;\n" 1016 "}"); 1017 1018 verifyGoogleFormat("switch (x) {\n" 1019 " case 1:\n" 1020 " f();\n" 1021 " break;\n" 1022 " case kFoo:\n" 1023 " case ns::kBar:\n" 1024 " case kBaz:\n" 1025 " break;\n" 1026 " default:\n" 1027 " g();\n" 1028 " break;\n" 1029 "}"); 1030 verifyGoogleFormat("switch (x) {\n" 1031 " case 1: {\n" 1032 " f();\n" 1033 " break;\n" 1034 " }\n" 1035 "}"); 1036 verifyGoogleFormat("switch (test)\n" 1037 " ;"); 1038 1039 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 1040 " case OP_name: \\\n" 1041 " return operations::Operation##name\n"); 1042 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 1043 " // Get the correction operation class.\n" 1044 " switch (OpCode) {\n" 1045 " CASE(Add);\n" 1046 " CASE(Subtract);\n" 1047 " default:\n" 1048 " return operations::Unknown;\n" 1049 " }\n" 1050 "#undef OPERATION_CASE\n" 1051 "}"); 1052 verifyFormat("DEBUG({\n" 1053 " switch (x) {\n" 1054 " case A:\n" 1055 " f();\n" 1056 " break;\n" 1057 " // fallthrough\n" 1058 " case B:\n" 1059 " g();\n" 1060 " break;\n" 1061 " }\n" 1062 "});"); 1063 EXPECT_EQ("DEBUG({\n" 1064 " switch (x) {\n" 1065 " case A:\n" 1066 " f();\n" 1067 " break;\n" 1068 " // On B:\n" 1069 " case B:\n" 1070 " g();\n" 1071 " break;\n" 1072 " }\n" 1073 "});", 1074 format("DEBUG({\n" 1075 " switch (x) {\n" 1076 " case A:\n" 1077 " f();\n" 1078 " break;\n" 1079 " // On B:\n" 1080 " case B:\n" 1081 " g();\n" 1082 " break;\n" 1083 " }\n" 1084 "});", 1085 getLLVMStyle())); 1086 EXPECT_EQ("switch (n) {\n" 1087 "case 0: {\n" 1088 " return false;\n" 1089 "}\n" 1090 "default: {\n" 1091 " return true;\n" 1092 "}\n" 1093 "}", 1094 format("switch (n)\n" 1095 "{\n" 1096 "case 0: {\n" 1097 " return false;\n" 1098 "}\n" 1099 "default: {\n" 1100 " return true;\n" 1101 "}\n" 1102 "}", 1103 getLLVMStyle())); 1104 verifyFormat("switch (a) {\n" 1105 "case (b):\n" 1106 " return;\n" 1107 "}"); 1108 1109 verifyFormat("switch (a) {\n" 1110 "case some_namespace::\n" 1111 " some_constant:\n" 1112 " return;\n" 1113 "}", 1114 getLLVMStyleWithColumns(34)); 1115 1116 FormatStyle Style = getLLVMStyle(); 1117 Style.IndentCaseLabels = true; 1118 Style.AllowShortBlocksOnASingleLine = false; 1119 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1120 Style.BraceWrapping.AfterCaseLabel = true; 1121 Style.BraceWrapping.AfterControlStatement = true; 1122 EXPECT_EQ("switch (n)\n" 1123 "{\n" 1124 " case 0:\n" 1125 " {\n" 1126 " return false;\n" 1127 " }\n" 1128 " default:\n" 1129 " {\n" 1130 " return true;\n" 1131 " }\n" 1132 "}", 1133 format("switch (n) {\n" 1134 " case 0: {\n" 1135 " return false;\n" 1136 " }\n" 1137 " default: {\n" 1138 " return true;\n" 1139 " }\n" 1140 "}", 1141 Style)); 1142 Style.BraceWrapping.AfterCaseLabel = false; 1143 EXPECT_EQ("switch (n)\n" 1144 "{\n" 1145 " case 0: {\n" 1146 " return false;\n" 1147 " }\n" 1148 " default: {\n" 1149 " return true;\n" 1150 " }\n" 1151 "}", 1152 format("switch (n) {\n" 1153 " case 0:\n" 1154 " {\n" 1155 " return false;\n" 1156 " }\n" 1157 " default:\n" 1158 " {\n" 1159 " return true;\n" 1160 " }\n" 1161 "}", 1162 Style)); 1163 } 1164 1165 TEST_F(FormatTest, CaseRanges) { 1166 verifyFormat("switch (x) {\n" 1167 "case 'A' ... 'Z':\n" 1168 "case 1 ... 5:\n" 1169 "case a ... b:\n" 1170 " break;\n" 1171 "}"); 1172 } 1173 1174 TEST_F(FormatTest, ShortCaseLabels) { 1175 FormatStyle Style = getLLVMStyle(); 1176 Style.AllowShortCaseLabelsOnASingleLine = true; 1177 verifyFormat("switch (a) {\n" 1178 "case 1: x = 1; break;\n" 1179 "case 2: return;\n" 1180 "case 3:\n" 1181 "case 4:\n" 1182 "case 5: return;\n" 1183 "case 6: // comment\n" 1184 " return;\n" 1185 "case 7:\n" 1186 " // comment\n" 1187 " return;\n" 1188 "case 8:\n" 1189 " x = 8; // comment\n" 1190 " break;\n" 1191 "default: y = 1; break;\n" 1192 "}", 1193 Style); 1194 verifyFormat("switch (a) {\n" 1195 "case 0: return; // comment\n" 1196 "case 1: break; // comment\n" 1197 "case 2: return;\n" 1198 "// comment\n" 1199 "case 3: return;\n" 1200 "// comment 1\n" 1201 "// comment 2\n" 1202 "// comment 3\n" 1203 "case 4: break; /* comment */\n" 1204 "case 5:\n" 1205 " // comment\n" 1206 " break;\n" 1207 "case 6: /* comment */ x = 1; break;\n" 1208 "case 7: x = /* comment */ 1; break;\n" 1209 "case 8:\n" 1210 " x = 1; /* comment */\n" 1211 " break;\n" 1212 "case 9:\n" 1213 " break; // comment line 1\n" 1214 " // comment line 2\n" 1215 "}", 1216 Style); 1217 EXPECT_EQ("switch (a) {\n" 1218 "case 1:\n" 1219 " x = 8;\n" 1220 " // fall through\n" 1221 "case 2: x = 8;\n" 1222 "// comment\n" 1223 "case 3:\n" 1224 " return; /* comment line 1\n" 1225 " * comment line 2 */\n" 1226 "case 4: i = 8;\n" 1227 "// something else\n" 1228 "#if FOO\n" 1229 "case 5: break;\n" 1230 "#endif\n" 1231 "}", 1232 format("switch (a) {\n" 1233 "case 1: x = 8;\n" 1234 " // fall through\n" 1235 "case 2:\n" 1236 " x = 8;\n" 1237 "// comment\n" 1238 "case 3:\n" 1239 " return; /* comment line 1\n" 1240 " * comment line 2 */\n" 1241 "case 4:\n" 1242 " i = 8;\n" 1243 "// something else\n" 1244 "#if FOO\n" 1245 "case 5: break;\n" 1246 "#endif\n" 1247 "}", 1248 Style)); 1249 EXPECT_EQ("switch (a) {\n" "case 0:\n" 1250 " return; // long long long long long long long long long long long long comment\n" 1251 " // line\n" "}", 1252 format("switch (a) {\n" 1253 "case 0: return; // long long long long long long long long long long long long comment line\n" 1254 "}", 1255 Style)); 1256 EXPECT_EQ("switch (a) {\n" 1257 "case 0:\n" 1258 " return; /* long long long long long long long long long long long long comment\n" 1259 " line */\n" 1260 "}", 1261 format("switch (a) {\n" 1262 "case 0: return; /* long long long long long long long long long long long long comment line */\n" 1263 "}", 1264 Style)); 1265 verifyFormat("switch (a) {\n" 1266 "#if FOO\n" 1267 "case 0: return 0;\n" 1268 "#endif\n" 1269 "}", 1270 Style); 1271 verifyFormat("switch (a) {\n" 1272 "case 1: {\n" 1273 "}\n" 1274 "case 2: {\n" 1275 " return;\n" 1276 "}\n" 1277 "case 3: {\n" 1278 " x = 1;\n" 1279 " return;\n" 1280 "}\n" 1281 "case 4:\n" 1282 " if (x)\n" 1283 " return;\n" 1284 "}", 1285 Style); 1286 Style.ColumnLimit = 21; 1287 verifyFormat("switch (a) {\n" 1288 "case 1: x = 1; break;\n" 1289 "case 2: return;\n" 1290 "case 3:\n" 1291 "case 4:\n" 1292 "case 5: return;\n" 1293 "default:\n" 1294 " y = 1;\n" 1295 " break;\n" 1296 "}", 1297 Style); 1298 Style.ColumnLimit = 80; 1299 Style.AllowShortCaseLabelsOnASingleLine = false; 1300 Style.IndentCaseLabels = true; 1301 EXPECT_EQ("switch (n) {\n" 1302 " default /*comments*/:\n" 1303 " return true;\n" 1304 " case 0:\n" 1305 " return false;\n" 1306 "}", 1307 format("switch (n) {\n" 1308 "default/*comments*/:\n" 1309 " return true;\n" 1310 "case 0:\n" 1311 " return false;\n" 1312 "}", 1313 Style)); 1314 Style.AllowShortCaseLabelsOnASingleLine = true; 1315 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1316 Style.BraceWrapping.AfterCaseLabel = true; 1317 Style.BraceWrapping.AfterControlStatement = true; 1318 EXPECT_EQ("switch (n)\n" 1319 "{\n" 1320 " case 0:\n" 1321 " {\n" 1322 " return false;\n" 1323 " }\n" 1324 " default:\n" 1325 " {\n" 1326 " return true;\n" 1327 " }\n" 1328 "}", 1329 format("switch (n) {\n" 1330 " case 0: {\n" 1331 " return false;\n" 1332 " }\n" 1333 " default:\n" 1334 " {\n" 1335 " return true;\n" 1336 " }\n" 1337 "}", 1338 Style)); 1339 } 1340 1341 TEST_F(FormatTest, FormatsLabels) { 1342 verifyFormat("void f() {\n" 1343 " some_code();\n" 1344 "test_label:\n" 1345 " some_other_code();\n" 1346 " {\n" 1347 " some_more_code();\n" 1348 " another_label:\n" 1349 " some_more_code();\n" 1350 " }\n" 1351 "}"); 1352 verifyFormat("{\n" 1353 " some_code();\n" 1354 "test_label:\n" 1355 " some_other_code();\n" 1356 "}"); 1357 verifyFormat("{\n" 1358 " some_code();\n" 1359 "test_label:;\n" 1360 " int i = 0;\n" 1361 "}"); 1362 } 1363 1364 //===----------------------------------------------------------------------===// 1365 // Tests for classes, namespaces, etc. 1366 //===----------------------------------------------------------------------===// 1367 1368 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1369 verifyFormat("class A {};"); 1370 } 1371 1372 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1373 verifyFormat("class A {\n" 1374 "public:\n" 1375 "public: // comment\n" 1376 "protected:\n" 1377 "private:\n" 1378 " void f() {}\n" 1379 "};"); 1380 verifyFormat("export class A {\n" 1381 "public:\n" 1382 "public: // comment\n" 1383 "protected:\n" 1384 "private:\n" 1385 " void f() {}\n" 1386 "};"); 1387 verifyGoogleFormat("class A {\n" 1388 " public:\n" 1389 " protected:\n" 1390 " private:\n" 1391 " void f() {}\n" 1392 "};"); 1393 verifyGoogleFormat("export class A {\n" 1394 " public:\n" 1395 " protected:\n" 1396 " private:\n" 1397 " void f() {}\n" 1398 "};"); 1399 verifyFormat("class A {\n" 1400 "public slots:\n" 1401 " void f1() {}\n" 1402 "public Q_SLOTS:\n" 1403 " void f2() {}\n" 1404 "protected slots:\n" 1405 " void f3() {}\n" 1406 "protected Q_SLOTS:\n" 1407 " void f4() {}\n" 1408 "private slots:\n" 1409 " void f5() {}\n" 1410 "private Q_SLOTS:\n" 1411 " void f6() {}\n" 1412 "signals:\n" 1413 " void g1();\n" 1414 "Q_SIGNALS:\n" 1415 " void g2();\n" 1416 "};"); 1417 1418 // Don't interpret 'signals' the wrong way. 1419 verifyFormat("signals.set();"); 1420 verifyFormat("for (Signals signals : f()) {\n}"); 1421 verifyFormat("{\n" 1422 " signals.set(); // This needs indentation.\n" 1423 "}"); 1424 verifyFormat("void f() {\n" 1425 "label:\n" 1426 " signals.baz();\n" 1427 "}"); 1428 } 1429 1430 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1431 EXPECT_EQ("class A {\n" 1432 "public:\n" 1433 " void f();\n" 1434 "\n" 1435 "private:\n" 1436 " void g() {}\n" 1437 " // test\n" 1438 "protected:\n" 1439 " int h;\n" 1440 "};", 1441 format("class A {\n" 1442 "public:\n" 1443 "void f();\n" 1444 "private:\n" 1445 "void g() {}\n" 1446 "// test\n" 1447 "protected:\n" 1448 "int h;\n" 1449 "};")); 1450 EXPECT_EQ("class A {\n" 1451 "protected:\n" 1452 "public:\n" 1453 " void f();\n" 1454 "};", 1455 format("class A {\n" 1456 "protected:\n" 1457 "\n" 1458 "public:\n" 1459 "\n" 1460 " void f();\n" 1461 "};")); 1462 1463 // Even ensure proper spacing inside macros. 1464 EXPECT_EQ("#define B \\\n" 1465 " class A { \\\n" 1466 " protected: \\\n" 1467 " public: \\\n" 1468 " void f(); \\\n" 1469 " };", 1470 format("#define B \\\n" 1471 " class A { \\\n" 1472 " protected: \\\n" 1473 " \\\n" 1474 " public: \\\n" 1475 " \\\n" 1476 " void f(); \\\n" 1477 " };", 1478 getGoogleStyle())); 1479 // But don't remove empty lines after macros ending in access specifiers. 1480 EXPECT_EQ("#define A private:\n" 1481 "\n" 1482 "int i;", 1483 format("#define A private:\n" 1484 "\n" 1485 "int i;")); 1486 } 1487 1488 TEST_F(FormatTest, FormatsClasses) { 1489 verifyFormat("class A : public B {};"); 1490 verifyFormat("class A : public ::B {};"); 1491 1492 verifyFormat( 1493 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1494 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1495 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1496 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1497 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1498 verifyFormat( 1499 "class A : public B, public C, public D, public E, public F {};"); 1500 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1501 " public C,\n" 1502 " public D,\n" 1503 " public E,\n" 1504 " public F,\n" 1505 " public G {};"); 1506 1507 verifyFormat("class\n" 1508 " ReallyReallyLongClassName {\n" 1509 " int i;\n" 1510 "};", 1511 getLLVMStyleWithColumns(32)); 1512 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1513 " aaaaaaaaaaaaaaaa> {};"); 1514 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1515 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1516 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1517 verifyFormat("template <class R, class C>\n" 1518 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1519 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1520 verifyFormat("class ::A::B {};"); 1521 } 1522 1523 TEST_F(FormatTest, BreakInheritanceStyle) { 1524 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1525 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1526 FormatStyle::BILS_BeforeComma; 1527 verifyFormat("class MyClass : public X {};", 1528 StyleWithInheritanceBreakBeforeComma); 1529 verifyFormat("class MyClass\n" 1530 " : public X\n" 1531 " , public Y {};", 1532 StyleWithInheritanceBreakBeforeComma); 1533 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1534 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1535 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1536 StyleWithInheritanceBreakBeforeComma); 1537 verifyFormat("struct aaaaaaaaaaaaa\n" 1538 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1539 " aaaaaaaaaaaaaaaa> {};", 1540 StyleWithInheritanceBreakBeforeComma); 1541 1542 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1543 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1544 FormatStyle::BILS_AfterColon; 1545 verifyFormat("class MyClass : public X {};", 1546 StyleWithInheritanceBreakAfterColon); 1547 verifyFormat("class MyClass : public X, public Y {};", 1548 StyleWithInheritanceBreakAfterColon); 1549 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1550 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1551 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1552 StyleWithInheritanceBreakAfterColon); 1553 verifyFormat("struct aaaaaaaaaaaaa :\n" 1554 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1555 " aaaaaaaaaaaaaaaa> {};", 1556 StyleWithInheritanceBreakAfterColon); 1557 } 1558 1559 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1560 verifyFormat("class A {\n} a, b;"); 1561 verifyFormat("struct A {\n} a, b;"); 1562 verifyFormat("union A {\n} a;"); 1563 } 1564 1565 TEST_F(FormatTest, FormatsEnum) { 1566 verifyFormat("enum {\n" 1567 " Zero,\n" 1568 " One = 1,\n" 1569 " Two = One + 1,\n" 1570 " Three = (One + Two),\n" 1571 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1572 " Five = (One, Two, Three, Four, 5)\n" 1573 "};"); 1574 verifyGoogleFormat("enum {\n" 1575 " Zero,\n" 1576 " One = 1,\n" 1577 " Two = One + 1,\n" 1578 " Three = (One + Two),\n" 1579 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1580 " Five = (One, Two, Three, Four, 5)\n" 1581 "};"); 1582 verifyFormat("enum Enum {};"); 1583 verifyFormat("enum {};"); 1584 verifyFormat("enum X E {} d;"); 1585 verifyFormat("enum __attribute__((...)) E {} d;"); 1586 verifyFormat("enum __declspec__((...)) E {} d;"); 1587 verifyFormat("enum {\n" 1588 " Bar = Foo<int, int>::value\n" 1589 "};", 1590 getLLVMStyleWithColumns(30)); 1591 1592 verifyFormat("enum ShortEnum { A, B, C };"); 1593 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1594 1595 EXPECT_EQ("enum KeepEmptyLines {\n" 1596 " ONE,\n" 1597 "\n" 1598 " TWO,\n" 1599 "\n" 1600 " THREE\n" 1601 "}", 1602 format("enum KeepEmptyLines {\n" 1603 " ONE,\n" 1604 "\n" 1605 " TWO,\n" 1606 "\n" 1607 "\n" 1608 " THREE\n" 1609 "}")); 1610 verifyFormat("enum E { // comment\n" 1611 " ONE,\n" 1612 " TWO\n" 1613 "};\n" 1614 "int i;"); 1615 // Not enums. 1616 verifyFormat("enum X f() {\n" 1617 " a();\n" 1618 " return 42;\n" 1619 "}"); 1620 verifyFormat("enum X Type::f() {\n" 1621 " a();\n" 1622 " return 42;\n" 1623 "}"); 1624 verifyFormat("enum ::X f() {\n" 1625 " a();\n" 1626 " return 42;\n" 1627 "}"); 1628 verifyFormat("enum ns::X f() {\n" 1629 " a();\n" 1630 " return 42;\n" 1631 "}"); 1632 } 1633 1634 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1635 verifyFormat("enum Type {\n" 1636 " One = 0; // These semicolons should be commas.\n" 1637 " Two = 1;\n" 1638 "};"); 1639 verifyFormat("namespace n {\n" 1640 "enum Type {\n" 1641 " One,\n" 1642 " Two, // missing };\n" 1643 " int i;\n" 1644 "}\n" 1645 "void g() {}"); 1646 } 1647 1648 TEST_F(FormatTest, FormatsEnumStruct) { 1649 verifyFormat("enum struct {\n" 1650 " Zero,\n" 1651 " One = 1,\n" 1652 " Two = One + 1,\n" 1653 " Three = (One + Two),\n" 1654 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1655 " Five = (One, Two, Three, Four, 5)\n" 1656 "};"); 1657 verifyFormat("enum struct Enum {};"); 1658 verifyFormat("enum struct {};"); 1659 verifyFormat("enum struct X E {} d;"); 1660 verifyFormat("enum struct __attribute__((...)) E {} d;"); 1661 verifyFormat("enum struct __declspec__((...)) E {} d;"); 1662 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1663 } 1664 1665 TEST_F(FormatTest, FormatsEnumClass) { 1666 verifyFormat("enum class {\n" 1667 " Zero,\n" 1668 " One = 1,\n" 1669 " Two = One + 1,\n" 1670 " Three = (One + Two),\n" 1671 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1672 " Five = (One, Two, Three, Four, 5)\n" 1673 "};"); 1674 verifyFormat("enum class Enum {};"); 1675 verifyFormat("enum class {};"); 1676 verifyFormat("enum class X E {} d;"); 1677 verifyFormat("enum class __attribute__((...)) E {} d;"); 1678 verifyFormat("enum class __declspec__((...)) E {} d;"); 1679 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 1680 } 1681 1682 TEST_F(FormatTest, FormatsEnumTypes) { 1683 verifyFormat("enum X : int {\n" 1684 " A, // Force multiple lines.\n" 1685 " B\n" 1686 "};"); 1687 verifyFormat("enum X : int { A, B };"); 1688 verifyFormat("enum X : std::uint32_t { A, B };"); 1689 } 1690 1691 TEST_F(FormatTest, FormatsTypedefEnum) { 1692 FormatStyle Style = getLLVMStyle(); 1693 Style.ColumnLimit = 40; 1694 verifyFormat("typedef enum {} EmptyEnum;"); 1695 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1696 verifyFormat("typedef enum {\n" 1697 " ZERO = 0,\n" 1698 " ONE = 1,\n" 1699 " TWO = 2,\n" 1700 " THREE = 3\n" 1701 "} LongEnum;", 1702 Style); 1703 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1704 Style.BraceWrapping.AfterEnum = true; 1705 verifyFormat("typedef enum {} EmptyEnum;"); 1706 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1707 verifyFormat("typedef enum\n" 1708 "{\n" 1709 " ZERO = 0,\n" 1710 " ONE = 1,\n" 1711 " TWO = 2,\n" 1712 " THREE = 3\n" 1713 "} LongEnum;", 1714 Style); 1715 } 1716 1717 TEST_F(FormatTest, FormatsNSEnums) { 1718 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1719 verifyGoogleFormat( 1720 "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1721 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 1722 " // Information about someDecentlyLongValue.\n" 1723 " someDecentlyLongValue,\n" 1724 " // Information about anotherDecentlyLongValue.\n" 1725 " anotherDecentlyLongValue,\n" 1726 " // Information about aThirdDecentlyLongValue.\n" 1727 " aThirdDecentlyLongValue\n" 1728 "};"); 1729 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n" 1730 " // Information about someDecentlyLongValue.\n" 1731 " someDecentlyLongValue,\n" 1732 " // Information about anotherDecentlyLongValue.\n" 1733 " anotherDecentlyLongValue,\n" 1734 " // Information about aThirdDecentlyLongValue.\n" 1735 " aThirdDecentlyLongValue\n" 1736 "};"); 1737 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 1738 " a = 1,\n" 1739 " b = 2,\n" 1740 " c = 3,\n" 1741 "};"); 1742 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 1743 " a = 1,\n" 1744 " b = 2,\n" 1745 " c = 3,\n" 1746 "};"); 1747 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n" 1748 " a = 1,\n" 1749 " b = 2,\n" 1750 " c = 3,\n" 1751 "};"); 1752 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 1753 " a = 1,\n" 1754 " b = 2,\n" 1755 " c = 3,\n" 1756 "};"); 1757 } 1758 1759 TEST_F(FormatTest, FormatsBitfields) { 1760 verifyFormat("struct Bitfields {\n" 1761 " unsigned sClass : 8;\n" 1762 " unsigned ValueKind : 2;\n" 1763 "};"); 1764 verifyFormat("struct A {\n" 1765 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 1766 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 1767 "};"); 1768 verifyFormat("struct MyStruct {\n" 1769 " uchar data;\n" 1770 " uchar : 8;\n" 1771 " uchar : 8;\n" 1772 " uchar other;\n" 1773 "};"); 1774 } 1775 1776 TEST_F(FormatTest, FormatsNamespaces) { 1777 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 1778 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 1779 1780 verifyFormat("namespace some_namespace {\n" 1781 "class A {};\n" 1782 "void f() { f(); }\n" 1783 "}", 1784 LLVMWithNoNamespaceFix); 1785 verifyFormat("namespace N::inline D {\n" 1786 "class A {};\n" 1787 "void f() { f(); }\n" 1788 "}", 1789 LLVMWithNoNamespaceFix); 1790 verifyFormat("namespace N::inline D::E {\n" 1791 "class A {};\n" 1792 "void f() { f(); }\n" 1793 "}", 1794 LLVMWithNoNamespaceFix); 1795 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n" 1796 "class A {};\n" 1797 "void f() { f(); }\n" 1798 "}", 1799 LLVMWithNoNamespaceFix); 1800 verifyFormat("/* something */ namespace some_namespace {\n" 1801 "class A {};\n" 1802 "void f() { f(); }\n" 1803 "}", 1804 LLVMWithNoNamespaceFix); 1805 verifyFormat("namespace {\n" 1806 "class A {};\n" 1807 "void f() { f(); }\n" 1808 "}", 1809 LLVMWithNoNamespaceFix); 1810 verifyFormat("/* something */ namespace {\n" 1811 "class A {};\n" 1812 "void f() { f(); }\n" 1813 "}", 1814 LLVMWithNoNamespaceFix); 1815 verifyFormat("inline namespace X {\n" 1816 "class A {};\n" 1817 "void f() { f(); }\n" 1818 "}", 1819 LLVMWithNoNamespaceFix); 1820 verifyFormat("/* something */ inline namespace X {\n" 1821 "class A {};\n" 1822 "void f() { f(); }\n" 1823 "}", 1824 LLVMWithNoNamespaceFix); 1825 verifyFormat("export namespace X {\n" 1826 "class A {};\n" 1827 "void f() { f(); }\n" 1828 "}", 1829 LLVMWithNoNamespaceFix); 1830 verifyFormat("using namespace some_namespace;\n" 1831 "class A {};\n" 1832 "void f() { f(); }", 1833 LLVMWithNoNamespaceFix); 1834 1835 // This code is more common than we thought; if we 1836 // layout this correctly the semicolon will go into 1837 // its own line, which is undesirable. 1838 verifyFormat("namespace {};", 1839 LLVMWithNoNamespaceFix); 1840 verifyFormat("namespace {\n" 1841 "class A {};\n" 1842 "};", 1843 LLVMWithNoNamespaceFix); 1844 1845 verifyFormat("namespace {\n" 1846 "int SomeVariable = 0; // comment\n" 1847 "} // namespace", 1848 LLVMWithNoNamespaceFix); 1849 EXPECT_EQ("#ifndef HEADER_GUARD\n" 1850 "#define HEADER_GUARD\n" 1851 "namespace my_namespace {\n" 1852 "int i;\n" 1853 "} // my_namespace\n" 1854 "#endif // HEADER_GUARD", 1855 format("#ifndef HEADER_GUARD\n" 1856 " #define HEADER_GUARD\n" 1857 " namespace my_namespace {\n" 1858 "int i;\n" 1859 "} // my_namespace\n" 1860 "#endif // HEADER_GUARD", 1861 LLVMWithNoNamespaceFix)); 1862 1863 EXPECT_EQ("namespace A::B {\n" 1864 "class C {};\n" 1865 "}", 1866 format("namespace A::B {\n" 1867 "class C {};\n" 1868 "}", 1869 LLVMWithNoNamespaceFix)); 1870 1871 FormatStyle Style = getLLVMStyle(); 1872 Style.NamespaceIndentation = FormatStyle::NI_All; 1873 EXPECT_EQ("namespace out {\n" 1874 " int i;\n" 1875 " namespace in {\n" 1876 " int i;\n" 1877 " } // namespace in\n" 1878 "} // namespace out", 1879 format("namespace out {\n" 1880 "int i;\n" 1881 "namespace in {\n" 1882 "int i;\n" 1883 "} // namespace in\n" 1884 "} // namespace out", 1885 Style)); 1886 1887 Style.NamespaceIndentation = FormatStyle::NI_Inner; 1888 EXPECT_EQ("namespace out {\n" 1889 "int i;\n" 1890 "namespace in {\n" 1891 " int i;\n" 1892 "} // namespace in\n" 1893 "} // namespace out", 1894 format("namespace out {\n" 1895 "int i;\n" 1896 "namespace in {\n" 1897 "int i;\n" 1898 "} // namespace in\n" 1899 "} // namespace out", 1900 Style)); 1901 } 1902 1903 TEST_F(FormatTest, NamespaceMacros) { 1904 FormatStyle Style = getLLVMStyle(); 1905 Style.NamespaceMacros.push_back("TESTSUITE"); 1906 1907 verifyFormat("TESTSUITE(A) {\n" 1908 "int foo();\n" 1909 "} // TESTSUITE(A)", 1910 Style); 1911 1912 verifyFormat("TESTSUITE(A, B) {\n" 1913 "int foo();\n" 1914 "} // TESTSUITE(A)", 1915 Style); 1916 1917 // Properly indent according to NamespaceIndentation style 1918 Style.NamespaceIndentation = FormatStyle::NI_All; 1919 verifyFormat("TESTSUITE(A) {\n" 1920 " int foo();\n" 1921 "} // TESTSUITE(A)", 1922 Style); 1923 verifyFormat("TESTSUITE(A) {\n" 1924 " namespace B {\n" 1925 " int foo();\n" 1926 " } // namespace B\n" 1927 "} // TESTSUITE(A)", 1928 Style); 1929 verifyFormat("namespace A {\n" 1930 " TESTSUITE(B) {\n" 1931 " int foo();\n" 1932 " } // TESTSUITE(B)\n" 1933 "} // namespace A", 1934 Style); 1935 1936 Style.NamespaceIndentation = FormatStyle::NI_Inner; 1937 verifyFormat("TESTSUITE(A) {\n" 1938 "TESTSUITE(B) {\n" 1939 " int foo();\n" 1940 "} // TESTSUITE(B)\n" 1941 "} // TESTSUITE(A)", 1942 Style); 1943 verifyFormat("TESTSUITE(A) {\n" 1944 "namespace B {\n" 1945 " int foo();\n" 1946 "} // namespace B\n" 1947 "} // TESTSUITE(A)", 1948 Style); 1949 verifyFormat("namespace A {\n" 1950 "TESTSUITE(B) {\n" 1951 " int foo();\n" 1952 "} // TESTSUITE(B)\n" 1953 "} // namespace A", 1954 Style); 1955 1956 // Properly merge namespace-macros blocks in CompactNamespaces mode 1957 Style.NamespaceIndentation = FormatStyle::NI_None; 1958 Style.CompactNamespaces = true; 1959 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n" 1960 "}} // TESTSUITE(A::B)", 1961 Style); 1962 1963 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 1964 "}} // TESTSUITE(out::in)", 1965 format("TESTSUITE(out) {\n" 1966 "TESTSUITE(in) {\n" 1967 "} // TESTSUITE(in)\n" 1968 "} // TESTSUITE(out)", 1969 Style)); 1970 1971 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 1972 "}} // TESTSUITE(out::in)", 1973 format("TESTSUITE(out) {\n" 1974 "TESTSUITE(in) {\n" 1975 "} // TESTSUITE(in)\n" 1976 "} // TESTSUITE(out)", 1977 Style)); 1978 1979 // Do not merge different namespaces/macros 1980 EXPECT_EQ("namespace out {\n" 1981 "TESTSUITE(in) {\n" 1982 "} // TESTSUITE(in)\n" 1983 "} // namespace out", 1984 format("namespace out {\n" 1985 "TESTSUITE(in) {\n" 1986 "} // TESTSUITE(in)\n" 1987 "} // namespace out", 1988 Style)); 1989 EXPECT_EQ("TESTSUITE(out) {\n" 1990 "namespace in {\n" 1991 "} // namespace in\n" 1992 "} // TESTSUITE(out)", 1993 format("TESTSUITE(out) {\n" 1994 "namespace in {\n" 1995 "} // namespace in\n" 1996 "} // TESTSUITE(out)", 1997 Style)); 1998 Style.NamespaceMacros.push_back("FOOBAR"); 1999 EXPECT_EQ("TESTSUITE(out) {\n" 2000 "FOOBAR(in) {\n" 2001 "} // FOOBAR(in)\n" 2002 "} // TESTSUITE(out)", 2003 format("TESTSUITE(out) {\n" 2004 "FOOBAR(in) {\n" 2005 "} // FOOBAR(in)\n" 2006 "} // TESTSUITE(out)", 2007 Style)); 2008 } 2009 2010 TEST_F(FormatTest, FormatsCompactNamespaces) { 2011 FormatStyle Style = getLLVMStyle(); 2012 Style.CompactNamespaces = true; 2013 Style.NamespaceMacros.push_back("TESTSUITE"); 2014 2015 verifyFormat("namespace A { namespace B {\n" 2016 "}} // namespace A::B", 2017 Style); 2018 2019 EXPECT_EQ("namespace out { namespace in {\n" 2020 "}} // namespace out::in", 2021 format("namespace out {\n" 2022 "namespace in {\n" 2023 "} // namespace in\n" 2024 "} // namespace out", 2025 Style)); 2026 2027 // Only namespaces which have both consecutive opening and end get compacted 2028 EXPECT_EQ("namespace out {\n" 2029 "namespace in1 {\n" 2030 "} // namespace in1\n" 2031 "namespace in2 {\n" 2032 "} // namespace in2\n" 2033 "} // namespace out", 2034 format("namespace out {\n" 2035 "namespace in1 {\n" 2036 "} // namespace in1\n" 2037 "namespace in2 {\n" 2038 "} // namespace in2\n" 2039 "} // namespace out", 2040 Style)); 2041 2042 EXPECT_EQ("namespace out {\n" 2043 "int i;\n" 2044 "namespace in {\n" 2045 "int j;\n" 2046 "} // namespace in\n" 2047 "int k;\n" 2048 "} // namespace out", 2049 format("namespace out { int i;\n" 2050 "namespace in { int j; } // namespace in\n" 2051 "int k; } // namespace out", 2052 Style)); 2053 2054 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 2055 "}}} // namespace A::B::C\n", 2056 format("namespace A { namespace B {\n" 2057 "namespace C {\n" 2058 "}} // namespace B::C\n" 2059 "} // namespace A\n", 2060 Style)); 2061 2062 Style.ColumnLimit = 40; 2063 EXPECT_EQ("namespace aaaaaaaaaa {\n" 2064 "namespace bbbbbbbbbb {\n" 2065 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 2066 format("namespace aaaaaaaaaa {\n" 2067 "namespace bbbbbbbbbb {\n" 2068 "} // namespace bbbbbbbbbb\n" 2069 "} // namespace aaaaaaaaaa", 2070 Style)); 2071 2072 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 2073 "namespace cccccc {\n" 2074 "}}} // namespace aaaaaa::bbbbbb::cccccc", 2075 format("namespace aaaaaa {\n" 2076 "namespace bbbbbb {\n" 2077 "namespace cccccc {\n" 2078 "} // namespace cccccc\n" 2079 "} // namespace bbbbbb\n" 2080 "} // namespace aaaaaa", 2081 Style)); 2082 Style.ColumnLimit = 80; 2083 2084 // Extra semicolon after 'inner' closing brace prevents merging 2085 EXPECT_EQ("namespace out { namespace in {\n" 2086 "}; } // namespace out::in", 2087 format("namespace out {\n" 2088 "namespace in {\n" 2089 "}; // namespace in\n" 2090 "} // namespace out", 2091 Style)); 2092 2093 // Extra semicolon after 'outer' closing brace is conserved 2094 EXPECT_EQ("namespace out { namespace in {\n" 2095 "}}; // namespace out::in", 2096 format("namespace out {\n" 2097 "namespace in {\n" 2098 "} // namespace in\n" 2099 "}; // namespace out", 2100 Style)); 2101 2102 Style.NamespaceIndentation = FormatStyle::NI_All; 2103 EXPECT_EQ("namespace out { namespace in {\n" 2104 " int i;\n" 2105 "}} // namespace out::in", 2106 format("namespace out {\n" 2107 "namespace in {\n" 2108 "int i;\n" 2109 "} // namespace in\n" 2110 "} // namespace out", 2111 Style)); 2112 EXPECT_EQ("namespace out { namespace mid {\n" 2113 " namespace in {\n" 2114 " int j;\n" 2115 " } // namespace in\n" 2116 " int k;\n" 2117 "}} // namespace out::mid", 2118 format("namespace out { namespace mid {\n" 2119 "namespace in { int j; } // namespace in\n" 2120 "int k; }} // namespace out::mid", 2121 Style)); 2122 2123 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2124 EXPECT_EQ("namespace out { namespace in {\n" 2125 " int i;\n" 2126 "}} // namespace out::in", 2127 format("namespace out {\n" 2128 "namespace in {\n" 2129 "int i;\n" 2130 "} // namespace in\n" 2131 "} // namespace out", 2132 Style)); 2133 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 2134 " int i;\n" 2135 "}}} // namespace out::mid::in", 2136 format("namespace out {\n" 2137 "namespace mid {\n" 2138 "namespace in {\n" 2139 "int i;\n" 2140 "} // namespace in\n" 2141 "} // namespace mid\n" 2142 "} // namespace out", 2143 Style)); 2144 } 2145 2146 TEST_F(FormatTest, FormatsExternC) { 2147 verifyFormat("extern \"C\" {\nint a;"); 2148 verifyFormat("extern \"C\" {}"); 2149 verifyFormat("extern \"C\" {\n" 2150 "int foo();\n" 2151 "}"); 2152 verifyFormat("extern \"C\" int foo() {}"); 2153 verifyFormat("extern \"C\" int foo();"); 2154 verifyFormat("extern \"C\" int foo() {\n" 2155 " int i = 42;\n" 2156 " return i;\n" 2157 "}"); 2158 2159 FormatStyle Style = getLLVMStyle(); 2160 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2161 Style.BraceWrapping.AfterFunction = true; 2162 verifyFormat("extern \"C\" int foo() {}", Style); 2163 verifyFormat("extern \"C\" int foo();", Style); 2164 verifyFormat("extern \"C\" int foo()\n" 2165 "{\n" 2166 " int i = 42;\n" 2167 " return i;\n" 2168 "}", 2169 Style); 2170 2171 Style.BraceWrapping.AfterExternBlock = true; 2172 Style.BraceWrapping.SplitEmptyRecord = false; 2173 verifyFormat("extern \"C\"\n" 2174 "{}", 2175 Style); 2176 verifyFormat("extern \"C\"\n" 2177 "{\n" 2178 " int foo();\n" 2179 "}", 2180 Style); 2181 } 2182 2183 TEST_F(FormatTest, FormatsInlineASM) { 2184 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2185 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2186 verifyFormat( 2187 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2188 " \"cpuid\\n\\t\"\n" 2189 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2190 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2191 " : \"a\"(value));"); 2192 EXPECT_EQ( 2193 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2194 " __asm {\n" 2195 " mov edx,[that] // vtable in edx\n" 2196 " mov eax,methodIndex\n" 2197 " call [edx][eax*4] // stdcall\n" 2198 " }\n" 2199 "}", 2200 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2201 " __asm {\n" 2202 " mov edx,[that] // vtable in edx\n" 2203 " mov eax,methodIndex\n" 2204 " call [edx][eax*4] // stdcall\n" 2205 " }\n" 2206 "}")); 2207 EXPECT_EQ("_asm {\n" 2208 " xor eax, eax;\n" 2209 " cpuid;\n" 2210 "}", 2211 format("_asm {\n" 2212 " xor eax, eax;\n" 2213 " cpuid;\n" 2214 "}")); 2215 verifyFormat("void function() {\n" 2216 " // comment\n" 2217 " asm(\"\");\n" 2218 "}"); 2219 EXPECT_EQ("__asm {\n" 2220 "}\n" 2221 "int i;", 2222 format("__asm {\n" 2223 "}\n" 2224 "int i;")); 2225 } 2226 2227 TEST_F(FormatTest, FormatTryCatch) { 2228 verifyFormat("try {\n" 2229 " throw a * b;\n" 2230 "} catch (int a) {\n" 2231 " // Do nothing.\n" 2232 "} catch (...) {\n" 2233 " exit(42);\n" 2234 "}"); 2235 2236 // Function-level try statements. 2237 verifyFormat("int f() try { return 4; } catch (...) {\n" 2238 " return 5;\n" 2239 "}"); 2240 verifyFormat("class A {\n" 2241 " int a;\n" 2242 " A() try : a(0) {\n" 2243 " } catch (...) {\n" 2244 " throw;\n" 2245 " }\n" 2246 "};\n"); 2247 2248 // Incomplete try-catch blocks. 2249 verifyIncompleteFormat("try {} catch ("); 2250 } 2251 2252 TEST_F(FormatTest, FormatSEHTryCatch) { 2253 verifyFormat("__try {\n" 2254 " int a = b * c;\n" 2255 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2256 " // Do nothing.\n" 2257 "}"); 2258 2259 verifyFormat("__try {\n" 2260 " int a = b * c;\n" 2261 "} __finally {\n" 2262 " // Do nothing.\n" 2263 "}"); 2264 2265 verifyFormat("DEBUG({\n" 2266 " __try {\n" 2267 " } __finally {\n" 2268 " }\n" 2269 "});\n"); 2270 } 2271 2272 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2273 verifyFormat("try {\n" 2274 " f();\n" 2275 "} catch {\n" 2276 " g();\n" 2277 "}"); 2278 verifyFormat("try {\n" 2279 " f();\n" 2280 "} catch (A a) MACRO(x) {\n" 2281 " g();\n" 2282 "} catch (B b) MACRO(x) {\n" 2283 " g();\n" 2284 "}"); 2285 } 2286 2287 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2288 FormatStyle Style = getLLVMStyle(); 2289 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2290 FormatStyle::BS_WebKit}) { 2291 Style.BreakBeforeBraces = BraceStyle; 2292 verifyFormat("try {\n" 2293 " // something\n" 2294 "} catch (...) {\n" 2295 " // something\n" 2296 "}", 2297 Style); 2298 } 2299 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2300 verifyFormat("try {\n" 2301 " // something\n" 2302 "}\n" 2303 "catch (...) {\n" 2304 " // something\n" 2305 "}", 2306 Style); 2307 verifyFormat("__try {\n" 2308 " // something\n" 2309 "}\n" 2310 "__finally {\n" 2311 " // something\n" 2312 "}", 2313 Style); 2314 verifyFormat("@try {\n" 2315 " // something\n" 2316 "}\n" 2317 "@finally {\n" 2318 " // something\n" 2319 "}", 2320 Style); 2321 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2322 verifyFormat("try\n" 2323 "{\n" 2324 " // something\n" 2325 "}\n" 2326 "catch (...)\n" 2327 "{\n" 2328 " // something\n" 2329 "}", 2330 Style); 2331 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2332 verifyFormat("try\n" 2333 " {\n" 2334 " // something\n" 2335 " }\n" 2336 "catch (...)\n" 2337 " {\n" 2338 " // something\n" 2339 " }", 2340 Style); 2341 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2342 Style.BraceWrapping.BeforeCatch = true; 2343 verifyFormat("try {\n" 2344 " // something\n" 2345 "}\n" 2346 "catch (...) {\n" 2347 " // something\n" 2348 "}", 2349 Style); 2350 } 2351 2352 TEST_F(FormatTest, StaticInitializers) { 2353 verifyFormat("static SomeClass SC = {1, 'a'};"); 2354 2355 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2356 " 100000000, " 2357 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2358 2359 // Here, everything other than the "}" would fit on a line. 2360 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2361 " 10000000000000000000000000};"); 2362 EXPECT_EQ("S s = {a,\n" 2363 "\n" 2364 " b};", 2365 format("S s = {\n" 2366 " a,\n" 2367 "\n" 2368 " b\n" 2369 "};")); 2370 2371 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2372 // line. However, the formatting looks a bit off and this probably doesn't 2373 // happen often in practice. 2374 verifyFormat("static int Variable[1] = {\n" 2375 " {1000000000000000000000000000000000000}};", 2376 getLLVMStyleWithColumns(40)); 2377 } 2378 2379 TEST_F(FormatTest, DesignatedInitializers) { 2380 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2381 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2382 " .bbbbbbbbbb = 2,\n" 2383 " .cccccccccc = 3,\n" 2384 " .dddddddddd = 4,\n" 2385 " .eeeeeeeeee = 5};"); 2386 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2387 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2388 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2389 " .ccccccccccccccccccccccccccc = 3,\n" 2390 " .ddddddddddddddddddddddddddd = 4,\n" 2391 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2392 2393 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2394 2395 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2396 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2397 " [2] = bbbbbbbbbb,\n" 2398 " [3] = cccccccccc,\n" 2399 " [4] = dddddddddd,\n" 2400 " [5] = eeeeeeeeee};"); 2401 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2402 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2403 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2404 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2405 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2406 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2407 } 2408 2409 TEST_F(FormatTest, NestedStaticInitializers) { 2410 verifyFormat("static A x = {{{}}};\n"); 2411 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2412 " {init1, init2, init3, init4}}};", 2413 getLLVMStyleWithColumns(50)); 2414 2415 verifyFormat("somes Status::global_reps[3] = {\n" 2416 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2417 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2418 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2419 getLLVMStyleWithColumns(60)); 2420 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2421 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2422 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2423 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2424 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2425 " {rect.fRight - rect.fLeft, rect.fBottom - " 2426 "rect.fTop}};"); 2427 2428 verifyFormat( 2429 "SomeArrayOfSomeType a = {\n" 2430 " {{1, 2, 3},\n" 2431 " {1, 2, 3},\n" 2432 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2433 " 333333333333333333333333333333},\n" 2434 " {1, 2, 3},\n" 2435 " {1, 2, 3}}};"); 2436 verifyFormat( 2437 "SomeArrayOfSomeType a = {\n" 2438 " {{1, 2, 3}},\n" 2439 " {{1, 2, 3}},\n" 2440 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2441 " 333333333333333333333333333333}},\n" 2442 " {{1, 2, 3}},\n" 2443 " {{1, 2, 3}}};"); 2444 2445 verifyFormat("struct {\n" 2446 " unsigned bit;\n" 2447 " const char *const name;\n" 2448 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2449 " {kOsWin, \"Windows\"},\n" 2450 " {kOsLinux, \"Linux\"},\n" 2451 " {kOsCrOS, \"Chrome OS\"}};"); 2452 verifyFormat("struct {\n" 2453 " unsigned bit;\n" 2454 " const char *const name;\n" 2455 "} kBitsToOs[] = {\n" 2456 " {kOsMac, \"Mac\"},\n" 2457 " {kOsWin, \"Windows\"},\n" 2458 " {kOsLinux, \"Linux\"},\n" 2459 " {kOsCrOS, \"Chrome OS\"},\n" 2460 "};"); 2461 } 2462 2463 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2464 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2465 " \\\n" 2466 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2467 } 2468 2469 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2470 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2471 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2472 2473 // Do break defaulted and deleted functions. 2474 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2475 " default;", 2476 getLLVMStyleWithColumns(40)); 2477 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2478 " delete;", 2479 getLLVMStyleWithColumns(40)); 2480 } 2481 2482 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2483 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2484 getLLVMStyleWithColumns(40)); 2485 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2486 getLLVMStyleWithColumns(40)); 2487 EXPECT_EQ("#define Q \\\n" 2488 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2489 " \"aaaaaaaa.cpp\"", 2490 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2491 getLLVMStyleWithColumns(40))); 2492 } 2493 2494 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2495 EXPECT_EQ("# 123 \"A string literal\"", 2496 format(" # 123 \"A string literal\"")); 2497 } 2498 2499 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2500 EXPECT_EQ("#;", format("#;")); 2501 verifyFormat("#\n;\n;\n;"); 2502 } 2503 2504 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2505 EXPECT_EQ("#line 42 \"test\"\n", 2506 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2507 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2508 getLLVMStyleWithColumns(12))); 2509 } 2510 2511 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2512 EXPECT_EQ("#line 42 \"test\"", 2513 format("# \\\n line \\\n 42 \\\n \"test\"")); 2514 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2515 } 2516 2517 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2518 verifyFormat("#define A \\x20"); 2519 verifyFormat("#define A \\ x20"); 2520 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2521 verifyFormat("#define A ''"); 2522 verifyFormat("#define A ''qqq"); 2523 verifyFormat("#define A `qqq"); 2524 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2525 EXPECT_EQ("const char *c = STRINGIFY(\n" 2526 "\\na : b);", 2527 format("const char * c = STRINGIFY(\n" 2528 "\\na : b);")); 2529 2530 verifyFormat("a\r\\"); 2531 verifyFormat("a\v\\"); 2532 verifyFormat("a\f\\"); 2533 } 2534 2535 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2536 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2537 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2538 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2539 // FIXME: We never break before the macro name. 2540 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2541 2542 verifyFormat("#define A A\n#define A A"); 2543 verifyFormat("#define A(X) A\n#define A A"); 2544 2545 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2546 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2547 } 2548 2549 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2550 EXPECT_EQ("// somecomment\n" 2551 "#include \"a.h\"\n" 2552 "#define A( \\\n" 2553 " A, B)\n" 2554 "#include \"b.h\"\n" 2555 "// somecomment\n", 2556 format(" // somecomment\n" 2557 " #include \"a.h\"\n" 2558 "#define A(A,\\\n" 2559 " B)\n" 2560 " #include \"b.h\"\n" 2561 " // somecomment\n", 2562 getLLVMStyleWithColumns(13))); 2563 } 2564 2565 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2566 2567 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2568 EXPECT_EQ("#define A \\\n" 2569 " c; \\\n" 2570 " e;\n" 2571 "f;", 2572 format("#define A c; e;\n" 2573 "f;", 2574 getLLVMStyleWithColumns(14))); 2575 } 2576 2577 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2578 2579 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2580 EXPECT_EQ("int x,\n" 2581 "#define A\n" 2582 " y;", 2583 format("int x,\n#define A\ny;")); 2584 } 2585 2586 TEST_F(FormatTest, HashInMacroDefinition) { 2587 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2588 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2589 verifyFormat("#define A \\\n" 2590 " { \\\n" 2591 " f(#c); \\\n" 2592 " }", 2593 getLLVMStyleWithColumns(11)); 2594 2595 verifyFormat("#define A(X) \\\n" 2596 " void function##X()", 2597 getLLVMStyleWithColumns(22)); 2598 2599 verifyFormat("#define A(a, b, c) \\\n" 2600 " void a##b##c()", 2601 getLLVMStyleWithColumns(22)); 2602 2603 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2604 } 2605 2606 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2607 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2608 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2609 2610 FormatStyle Style = getLLVMStyle(); 2611 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 2612 verifyFormat("#define true ((foo)1)", Style); 2613 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 2614 verifyFormat("#define false((foo)0)", Style); 2615 } 2616 2617 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2618 EXPECT_EQ("#define A b;", format("#define A \\\n" 2619 " \\\n" 2620 " b;", 2621 getLLVMStyleWithColumns(25))); 2622 EXPECT_EQ("#define A \\\n" 2623 " \\\n" 2624 " a; \\\n" 2625 " b;", 2626 format("#define A \\\n" 2627 " \\\n" 2628 " a; \\\n" 2629 " b;", 2630 getLLVMStyleWithColumns(11))); 2631 EXPECT_EQ("#define A \\\n" 2632 " a; \\\n" 2633 " \\\n" 2634 " b;", 2635 format("#define A \\\n" 2636 " a; \\\n" 2637 " \\\n" 2638 " b;", 2639 getLLVMStyleWithColumns(11))); 2640 } 2641 2642 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 2643 verifyIncompleteFormat("#define A :"); 2644 verifyFormat("#define SOMECASES \\\n" 2645 " case 1: \\\n" 2646 " case 2\n", 2647 getLLVMStyleWithColumns(20)); 2648 verifyFormat("#define MACRO(a) \\\n" 2649 " if (a) \\\n" 2650 " f(); \\\n" 2651 " else \\\n" 2652 " g()", 2653 getLLVMStyleWithColumns(18)); 2654 verifyFormat("#define A template <typename T>"); 2655 verifyIncompleteFormat("#define STR(x) #x\n" 2656 "f(STR(this_is_a_string_literal{));"); 2657 verifyFormat("#pragma omp threadprivate( \\\n" 2658 " y)), // expected-warning", 2659 getLLVMStyleWithColumns(28)); 2660 verifyFormat("#d, = };"); 2661 verifyFormat("#if \"a"); 2662 verifyIncompleteFormat("({\n" 2663 "#define b \\\n" 2664 " } \\\n" 2665 " a\n" 2666 "a", 2667 getLLVMStyleWithColumns(15)); 2668 verifyFormat("#define A \\\n" 2669 " { \\\n" 2670 " {\n" 2671 "#define B \\\n" 2672 " } \\\n" 2673 " }", 2674 getLLVMStyleWithColumns(15)); 2675 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 2676 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 2677 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 2678 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 2679 } 2680 2681 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 2682 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 2683 EXPECT_EQ("class A : public QObject {\n" 2684 " Q_OBJECT\n" 2685 "\n" 2686 " A() {}\n" 2687 "};", 2688 format("class A : public QObject {\n" 2689 " Q_OBJECT\n" 2690 "\n" 2691 " A() {\n}\n" 2692 "} ;")); 2693 EXPECT_EQ("MACRO\n" 2694 "/*static*/ int i;", 2695 format("MACRO\n" 2696 " /*static*/ int i;")); 2697 EXPECT_EQ("SOME_MACRO\n" 2698 "namespace {\n" 2699 "void f();\n" 2700 "} // namespace", 2701 format("SOME_MACRO\n" 2702 " namespace {\n" 2703 "void f( );\n" 2704 "} // namespace")); 2705 // Only if the identifier contains at least 5 characters. 2706 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 2707 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 2708 // Only if everything is upper case. 2709 EXPECT_EQ("class A : public QObject {\n" 2710 " Q_Object A() {}\n" 2711 "};", 2712 format("class A : public QObject {\n" 2713 " Q_Object\n" 2714 " A() {\n}\n" 2715 "} ;")); 2716 2717 // Only if the next line can actually start an unwrapped line. 2718 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 2719 format("SOME_WEIRD_LOG_MACRO\n" 2720 "<< SomeThing;")); 2721 2722 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 2723 "(n, buffers))\n", 2724 getChromiumStyle(FormatStyle::LK_Cpp)); 2725 2726 // See PR41483 2727 EXPECT_EQ("/**/ FOO(a)\n" 2728 "FOO(b)", 2729 format("/**/ FOO(a)\n" 2730 "FOO(b)")); 2731 } 2732 2733 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 2734 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2735 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2736 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2737 "class X {};\n" 2738 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2739 "int *createScopDetectionPass() { return 0; }", 2740 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2741 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2742 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2743 " class X {};\n" 2744 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2745 " int *createScopDetectionPass() { return 0; }")); 2746 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 2747 // braces, so that inner block is indented one level more. 2748 EXPECT_EQ("int q() {\n" 2749 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2750 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2751 " IPC_END_MESSAGE_MAP()\n" 2752 "}", 2753 format("int q() {\n" 2754 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2755 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2756 " IPC_END_MESSAGE_MAP()\n" 2757 "}")); 2758 2759 // Same inside macros. 2760 EXPECT_EQ("#define LIST(L) \\\n" 2761 " L(A) \\\n" 2762 " L(B) \\\n" 2763 " L(C)", 2764 format("#define LIST(L) \\\n" 2765 " L(A) \\\n" 2766 " L(B) \\\n" 2767 " L(C)", 2768 getGoogleStyle())); 2769 2770 // These must not be recognized as macros. 2771 EXPECT_EQ("int q() {\n" 2772 " f(x);\n" 2773 " f(x) {}\n" 2774 " f(x)->g();\n" 2775 " f(x)->*g();\n" 2776 " f(x).g();\n" 2777 " f(x) = x;\n" 2778 " f(x) += x;\n" 2779 " f(x) -= x;\n" 2780 " f(x) *= x;\n" 2781 " f(x) /= x;\n" 2782 " f(x) %= x;\n" 2783 " f(x) &= x;\n" 2784 " f(x) |= x;\n" 2785 " f(x) ^= x;\n" 2786 " f(x) >>= x;\n" 2787 " f(x) <<= x;\n" 2788 " f(x)[y].z();\n" 2789 " LOG(INFO) << x;\n" 2790 " ifstream(x) >> x;\n" 2791 "}\n", 2792 format("int q() {\n" 2793 " f(x)\n;\n" 2794 " f(x)\n {}\n" 2795 " f(x)\n->g();\n" 2796 " f(x)\n->*g();\n" 2797 " f(x)\n.g();\n" 2798 " f(x)\n = x;\n" 2799 " f(x)\n += x;\n" 2800 " f(x)\n -= x;\n" 2801 " f(x)\n *= x;\n" 2802 " f(x)\n /= x;\n" 2803 " f(x)\n %= x;\n" 2804 " f(x)\n &= x;\n" 2805 " f(x)\n |= x;\n" 2806 " f(x)\n ^= x;\n" 2807 " f(x)\n >>= x;\n" 2808 " f(x)\n <<= x;\n" 2809 " f(x)\n[y].z();\n" 2810 " LOG(INFO)\n << x;\n" 2811 " ifstream(x)\n >> x;\n" 2812 "}\n")); 2813 EXPECT_EQ("int q() {\n" 2814 " F(x)\n" 2815 " if (1) {\n" 2816 " }\n" 2817 " F(x)\n" 2818 " while (1) {\n" 2819 " }\n" 2820 " F(x)\n" 2821 " G(x);\n" 2822 " F(x)\n" 2823 " try {\n" 2824 " Q();\n" 2825 " } catch (...) {\n" 2826 " }\n" 2827 "}\n", 2828 format("int q() {\n" 2829 "F(x)\n" 2830 "if (1) {}\n" 2831 "F(x)\n" 2832 "while (1) {}\n" 2833 "F(x)\n" 2834 "G(x);\n" 2835 "F(x)\n" 2836 "try { Q(); } catch (...) {}\n" 2837 "}\n")); 2838 EXPECT_EQ("class A {\n" 2839 " A() : t(0) {}\n" 2840 " A(int i) noexcept() : {}\n" 2841 " A(X x)\n" // FIXME: function-level try blocks are broken. 2842 " try : t(0) {\n" 2843 " } catch (...) {\n" 2844 " }\n" 2845 "};", 2846 format("class A {\n" 2847 " A()\n : t(0) {}\n" 2848 " A(int i)\n noexcept() : {}\n" 2849 " A(X x)\n" 2850 " try : t(0) {} catch (...) {}\n" 2851 "};")); 2852 FormatStyle Style = getLLVMStyle(); 2853 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2854 Style.BraceWrapping.AfterControlStatement = true; 2855 Style.BraceWrapping.AfterFunction = true; 2856 EXPECT_EQ("void f()\n" 2857 "try\n" 2858 "{\n" 2859 "}", 2860 format("void f() try {\n" 2861 "}", Style)); 2862 EXPECT_EQ("class SomeClass {\n" 2863 "public:\n" 2864 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2865 "};", 2866 format("class SomeClass {\n" 2867 "public:\n" 2868 " SomeClass()\n" 2869 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2870 "};")); 2871 EXPECT_EQ("class SomeClass {\n" 2872 "public:\n" 2873 " SomeClass()\n" 2874 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2875 "};", 2876 format("class SomeClass {\n" 2877 "public:\n" 2878 " SomeClass()\n" 2879 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 2880 "};", 2881 getLLVMStyleWithColumns(40))); 2882 2883 verifyFormat("MACRO(>)"); 2884 2885 // Some macros contain an implicit semicolon. 2886 Style = getLLVMStyle(); 2887 Style.StatementMacros.push_back("FOO"); 2888 verifyFormat("FOO(a) int b = 0;"); 2889 verifyFormat("FOO(a)\n" 2890 "int b = 0;", 2891 Style); 2892 verifyFormat("FOO(a);\n" 2893 "int b = 0;", 2894 Style); 2895 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 2896 "int b = 0;", 2897 Style); 2898 verifyFormat("FOO()\n" 2899 "int b = 0;", 2900 Style); 2901 verifyFormat("FOO\n" 2902 "int b = 0;", 2903 Style); 2904 verifyFormat("void f() {\n" 2905 " FOO(a)\n" 2906 " return a;\n" 2907 "}", 2908 Style); 2909 verifyFormat("FOO(a)\n" 2910 "FOO(b)", 2911 Style); 2912 verifyFormat("int a = 0;\n" 2913 "FOO(b)\n" 2914 "int c = 0;", 2915 Style); 2916 verifyFormat("int a = 0;\n" 2917 "int x = FOO(a)\n" 2918 "int b = 0;", 2919 Style); 2920 verifyFormat("void foo(int a) { FOO(a) }\n" 2921 "uint32_t bar() {}", 2922 Style); 2923 } 2924 2925 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 2926 verifyFormat("#define A \\\n" 2927 " f({ \\\n" 2928 " g(); \\\n" 2929 " });", 2930 getLLVMStyleWithColumns(11)); 2931 } 2932 2933 TEST_F(FormatTest, IndentPreprocessorDirectives) { 2934 FormatStyle Style = getLLVMStyle(); 2935 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 2936 Style.ColumnLimit = 40; 2937 verifyFormat("#ifdef _WIN32\n" 2938 "#define A 0\n" 2939 "#ifdef VAR2\n" 2940 "#define B 1\n" 2941 "#include <someheader.h>\n" 2942 "#define MACRO \\\n" 2943 " some_very_long_func_aaaaaaaaaa();\n" 2944 "#endif\n" 2945 "#else\n" 2946 "#define A 1\n" 2947 "#endif", 2948 Style); 2949 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 2950 verifyFormat("#ifdef _WIN32\n" 2951 "# define A 0\n" 2952 "# ifdef VAR2\n" 2953 "# define B 1\n" 2954 "# include <someheader.h>\n" 2955 "# define MACRO \\\n" 2956 " some_very_long_func_aaaaaaaaaa();\n" 2957 "# endif\n" 2958 "#else\n" 2959 "# define A 1\n" 2960 "#endif", 2961 Style); 2962 verifyFormat("#if A\n" 2963 "# define MACRO \\\n" 2964 " void a(int x) { \\\n" 2965 " b(); \\\n" 2966 " c(); \\\n" 2967 " d(); \\\n" 2968 " e(); \\\n" 2969 " f(); \\\n" 2970 " }\n" 2971 "#endif", 2972 Style); 2973 // Comments before include guard. 2974 verifyFormat("// file comment\n" 2975 "// file comment\n" 2976 "#ifndef HEADER_H\n" 2977 "#define HEADER_H\n" 2978 "code();\n" 2979 "#endif", 2980 Style); 2981 // Test with include guards. 2982 verifyFormat("#ifndef HEADER_H\n" 2983 "#define HEADER_H\n" 2984 "code();\n" 2985 "#endif", 2986 Style); 2987 // Include guards must have a #define with the same variable immediately 2988 // after #ifndef. 2989 verifyFormat("#ifndef NOT_GUARD\n" 2990 "# define FOO\n" 2991 "code();\n" 2992 "#endif", 2993 Style); 2994 2995 // Include guards must cover the entire file. 2996 verifyFormat("code();\n" 2997 "code();\n" 2998 "#ifndef NOT_GUARD\n" 2999 "# define NOT_GUARD\n" 3000 "code();\n" 3001 "#endif", 3002 Style); 3003 verifyFormat("#ifndef NOT_GUARD\n" 3004 "# define NOT_GUARD\n" 3005 "code();\n" 3006 "#endif\n" 3007 "code();", 3008 Style); 3009 // Test with trailing blank lines. 3010 verifyFormat("#ifndef HEADER_H\n" 3011 "#define HEADER_H\n" 3012 "code();\n" 3013 "#endif\n", 3014 Style); 3015 // Include guards don't have #else. 3016 verifyFormat("#ifndef NOT_GUARD\n" 3017 "# define NOT_GUARD\n" 3018 "code();\n" 3019 "#else\n" 3020 "#endif", 3021 Style); 3022 verifyFormat("#ifndef NOT_GUARD\n" 3023 "# define NOT_GUARD\n" 3024 "code();\n" 3025 "#elif FOO\n" 3026 "#endif", 3027 Style); 3028 // Non-identifier #define after potential include guard. 3029 verifyFormat("#ifndef FOO\n" 3030 "# define 1\n" 3031 "#endif\n", 3032 Style); 3033 // #if closes past last non-preprocessor line. 3034 verifyFormat("#ifndef FOO\n" 3035 "#define FOO\n" 3036 "#if 1\n" 3037 "int i;\n" 3038 "# define A 0\n" 3039 "#endif\n" 3040 "#endif\n", 3041 Style); 3042 // FIXME: This doesn't handle the case where there's code between the 3043 // #ifndef and #define but all other conditions hold. This is because when 3044 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 3045 // previous code line yet, so we can't detect it. 3046 EXPECT_EQ("#ifndef NOT_GUARD\n" 3047 "code();\n" 3048 "#define NOT_GUARD\n" 3049 "code();\n" 3050 "#endif", 3051 format("#ifndef NOT_GUARD\n" 3052 "code();\n" 3053 "# define NOT_GUARD\n" 3054 "code();\n" 3055 "#endif", 3056 Style)); 3057 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 3058 // be outside an include guard. Examples are #pragma once and 3059 // #pragma GCC diagnostic, or anything else that does not change the meaning 3060 // of the file if it's included multiple times. 3061 EXPECT_EQ("#ifdef WIN32\n" 3062 "# pragma once\n" 3063 "#endif\n" 3064 "#ifndef HEADER_H\n" 3065 "# define HEADER_H\n" 3066 "code();\n" 3067 "#endif", 3068 format("#ifdef WIN32\n" 3069 "# pragma once\n" 3070 "#endif\n" 3071 "#ifndef HEADER_H\n" 3072 "#define HEADER_H\n" 3073 "code();\n" 3074 "#endif", 3075 Style)); 3076 // FIXME: This does not detect when there is a single non-preprocessor line 3077 // in front of an include-guard-like structure where other conditions hold 3078 // because ScopedLineState hides the line. 3079 EXPECT_EQ("code();\n" 3080 "#ifndef HEADER_H\n" 3081 "#define HEADER_H\n" 3082 "code();\n" 3083 "#endif", 3084 format("code();\n" 3085 "#ifndef HEADER_H\n" 3086 "# define HEADER_H\n" 3087 "code();\n" 3088 "#endif", 3089 Style)); 3090 // Keep comments aligned with #, otherwise indent comments normally. These 3091 // tests cannot use verifyFormat because messUp manipulates leading 3092 // whitespace. 3093 { 3094 const char *Expected = "" 3095 "void f() {\n" 3096 "#if 1\n" 3097 "// Preprocessor aligned.\n" 3098 "# define A 0\n" 3099 " // Code. Separated by blank line.\n" 3100 "\n" 3101 "# define B 0\n" 3102 " // Code. Not aligned with #\n" 3103 "# define C 0\n" 3104 "#endif"; 3105 const char *ToFormat = "" 3106 "void f() {\n" 3107 "#if 1\n" 3108 "// Preprocessor aligned.\n" 3109 "# define A 0\n" 3110 "// Code. Separated by blank line.\n" 3111 "\n" 3112 "# define B 0\n" 3113 " // Code. Not aligned with #\n" 3114 "# define C 0\n" 3115 "#endif"; 3116 EXPECT_EQ(Expected, format(ToFormat, Style)); 3117 EXPECT_EQ(Expected, format(Expected, Style)); 3118 } 3119 // Keep block quotes aligned. 3120 { 3121 const char *Expected = "" 3122 "void f() {\n" 3123 "#if 1\n" 3124 "/* Preprocessor aligned. */\n" 3125 "# define A 0\n" 3126 " /* Code. Separated by blank line. */\n" 3127 "\n" 3128 "# define B 0\n" 3129 " /* Code. Not aligned with # */\n" 3130 "# define C 0\n" 3131 "#endif"; 3132 const char *ToFormat = "" 3133 "void f() {\n" 3134 "#if 1\n" 3135 "/* Preprocessor aligned. */\n" 3136 "# define A 0\n" 3137 "/* Code. Separated by blank line. */\n" 3138 "\n" 3139 "# define B 0\n" 3140 " /* Code. Not aligned with # */\n" 3141 "# define C 0\n" 3142 "#endif"; 3143 EXPECT_EQ(Expected, format(ToFormat, Style)); 3144 EXPECT_EQ(Expected, format(Expected, Style)); 3145 } 3146 // Keep comments aligned with un-indented directives. 3147 { 3148 const char *Expected = "" 3149 "void f() {\n" 3150 "// Preprocessor aligned.\n" 3151 "#define A 0\n" 3152 " // Code. Separated by blank line.\n" 3153 "\n" 3154 "#define B 0\n" 3155 " // Code. Not aligned with #\n" 3156 "#define C 0\n"; 3157 const char *ToFormat = "" 3158 "void f() {\n" 3159 "// Preprocessor aligned.\n" 3160 "#define A 0\n" 3161 "// Code. Separated by blank line.\n" 3162 "\n" 3163 "#define B 0\n" 3164 " // Code. Not aligned with #\n" 3165 "#define C 0\n"; 3166 EXPECT_EQ(Expected, format(ToFormat, Style)); 3167 EXPECT_EQ(Expected, format(Expected, Style)); 3168 } 3169 // Test AfterHash with tabs. 3170 { 3171 FormatStyle Tabbed = Style; 3172 Tabbed.UseTab = FormatStyle::UT_Always; 3173 Tabbed.IndentWidth = 8; 3174 Tabbed.TabWidth = 8; 3175 verifyFormat("#ifdef _WIN32\n" 3176 "#\tdefine A 0\n" 3177 "#\tifdef VAR2\n" 3178 "#\t\tdefine B 1\n" 3179 "#\t\tinclude <someheader.h>\n" 3180 "#\t\tdefine MACRO \\\n" 3181 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3182 "#\tendif\n" 3183 "#else\n" 3184 "#\tdefine A 1\n" 3185 "#endif", 3186 Tabbed); 3187 } 3188 3189 // Regression test: Multiline-macro inside include guards. 3190 verifyFormat("#ifndef HEADER_H\n" 3191 "#define HEADER_H\n" 3192 "#define A() \\\n" 3193 " int i; \\\n" 3194 " int j;\n" 3195 "#endif // HEADER_H", 3196 getLLVMStyleWithColumns(20)); 3197 3198 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3199 // Basic before hash indent tests 3200 verifyFormat("#ifdef _WIN32\n" 3201 " #define A 0\n" 3202 " #ifdef VAR2\n" 3203 " #define B 1\n" 3204 " #include <someheader.h>\n" 3205 " #define MACRO \\\n" 3206 " some_very_long_func_aaaaaaaaaa();\n" 3207 " #endif\n" 3208 "#else\n" 3209 " #define A 1\n" 3210 "#endif", 3211 Style); 3212 verifyFormat("#if A\n" 3213 " #define MACRO \\\n" 3214 " void a(int x) { \\\n" 3215 " b(); \\\n" 3216 " c(); \\\n" 3217 " d(); \\\n" 3218 " e(); \\\n" 3219 " f(); \\\n" 3220 " }\n" 3221 "#endif", 3222 Style); 3223 // Keep comments aligned with indented directives. These 3224 // tests cannot use verifyFormat because messUp manipulates leading 3225 // whitespace. 3226 { 3227 const char *Expected = "void f() {\n" 3228 "// Aligned to preprocessor.\n" 3229 "#if 1\n" 3230 " // Aligned to code.\n" 3231 " int a;\n" 3232 " #if 1\n" 3233 " // Aligned to preprocessor.\n" 3234 " #define A 0\n" 3235 " // Aligned to code.\n" 3236 " int b;\n" 3237 " #endif\n" 3238 "#endif\n" 3239 "}"; 3240 const char *ToFormat = "void f() {\n" 3241 "// Aligned to preprocessor.\n" 3242 "#if 1\n" 3243 "// Aligned to code.\n" 3244 "int a;\n" 3245 "#if 1\n" 3246 "// Aligned to preprocessor.\n" 3247 "#define A 0\n" 3248 "// Aligned to code.\n" 3249 "int b;\n" 3250 "#endif\n" 3251 "#endif\n" 3252 "}"; 3253 EXPECT_EQ(Expected, format(ToFormat, Style)); 3254 EXPECT_EQ(Expected, format(Expected, Style)); 3255 } 3256 { 3257 const char *Expected = "void f() {\n" 3258 "/* Aligned to preprocessor. */\n" 3259 "#if 1\n" 3260 " /* Aligned to code. */\n" 3261 " int a;\n" 3262 " #if 1\n" 3263 " /* Aligned to preprocessor. */\n" 3264 " #define A 0\n" 3265 " /* Aligned to code. */\n" 3266 " int b;\n" 3267 " #endif\n" 3268 "#endif\n" 3269 "}"; 3270 const char *ToFormat = "void f() {\n" 3271 "/* Aligned to preprocessor. */\n" 3272 "#if 1\n" 3273 "/* Aligned to code. */\n" 3274 "int a;\n" 3275 "#if 1\n" 3276 "/* Aligned to preprocessor. */\n" 3277 "#define A 0\n" 3278 "/* Aligned to code. */\n" 3279 "int b;\n" 3280 "#endif\n" 3281 "#endif\n" 3282 "}"; 3283 EXPECT_EQ(Expected, format(ToFormat, Style)); 3284 EXPECT_EQ(Expected, format(Expected, Style)); 3285 } 3286 3287 // Test single comment before preprocessor 3288 verifyFormat("// Comment\n" 3289 "\n" 3290 "#if 1\n" 3291 "#endif", 3292 Style); 3293 } 3294 3295 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3296 verifyFormat("{\n { a #c; }\n}"); 3297 } 3298 3299 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3300 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3301 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3302 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3303 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3304 } 3305 3306 TEST_F(FormatTest, EscapedNewlines) { 3307 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3308 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3309 format("#define A \\\nint i;\\\n int j;", Narrow)); 3310 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3311 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3312 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3313 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3314 3315 FormatStyle AlignLeft = getLLVMStyle(); 3316 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3317 EXPECT_EQ("#define MACRO(x) \\\n" 3318 "private: \\\n" 3319 " int x(int a);\n", 3320 format("#define MACRO(x) \\\n" 3321 "private: \\\n" 3322 " int x(int a);\n", 3323 AlignLeft)); 3324 3325 // CRLF line endings 3326 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3327 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3328 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3329 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3330 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3331 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3332 EXPECT_EQ("#define MACRO(x) \\\r\n" 3333 "private: \\\r\n" 3334 " int x(int a);\r\n", 3335 format("#define MACRO(x) \\\r\n" 3336 "private: \\\r\n" 3337 " int x(int a);\r\n", 3338 AlignLeft)); 3339 3340 FormatStyle DontAlign = getLLVMStyle(); 3341 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3342 DontAlign.MaxEmptyLinesToKeep = 3; 3343 // FIXME: can't use verifyFormat here because the newline before 3344 // "public:" is not inserted the first time it's reformatted 3345 EXPECT_EQ("#define A \\\n" 3346 " class Foo { \\\n" 3347 " void bar(); \\\n" 3348 "\\\n" 3349 "\\\n" 3350 "\\\n" 3351 " public: \\\n" 3352 " void baz(); \\\n" 3353 " };", 3354 format("#define A \\\n" 3355 " class Foo { \\\n" 3356 " void bar(); \\\n" 3357 "\\\n" 3358 "\\\n" 3359 "\\\n" 3360 " public: \\\n" 3361 " void baz(); \\\n" 3362 " };", 3363 DontAlign)); 3364 } 3365 3366 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3367 verifyFormat("#define A \\\n" 3368 " int v( \\\n" 3369 " a); \\\n" 3370 " int i;", 3371 getLLVMStyleWithColumns(11)); 3372 } 3373 3374 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3375 EXPECT_EQ( 3376 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3377 " \\\n" 3378 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3379 "\n" 3380 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3381 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3382 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3383 "\\\n" 3384 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3385 " \n" 3386 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3387 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3388 } 3389 3390 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3391 EXPECT_EQ("int\n" 3392 "#define A\n" 3393 " a;", 3394 format("int\n#define A\na;")); 3395 verifyFormat("functionCallTo(\n" 3396 " someOtherFunction(\n" 3397 " withSomeParameters, whichInSequence,\n" 3398 " areLongerThanALine(andAnotherCall,\n" 3399 "#define A B\n" 3400 " withMoreParamters,\n" 3401 " whichStronglyInfluenceTheLayout),\n" 3402 " andMoreParameters),\n" 3403 " trailing);", 3404 getLLVMStyleWithColumns(69)); 3405 verifyFormat("Foo::Foo()\n" 3406 "#ifdef BAR\n" 3407 " : baz(0)\n" 3408 "#endif\n" 3409 "{\n" 3410 "}"); 3411 verifyFormat("void f() {\n" 3412 " if (true)\n" 3413 "#ifdef A\n" 3414 " f(42);\n" 3415 " x();\n" 3416 "#else\n" 3417 " g();\n" 3418 " x();\n" 3419 "#endif\n" 3420 "}"); 3421 verifyFormat("void f(param1, param2,\n" 3422 " param3,\n" 3423 "#ifdef A\n" 3424 " param4(param5,\n" 3425 "#ifdef A1\n" 3426 " param6,\n" 3427 "#ifdef A2\n" 3428 " param7),\n" 3429 "#else\n" 3430 " param8),\n" 3431 " param9,\n" 3432 "#endif\n" 3433 " param10,\n" 3434 "#endif\n" 3435 " param11)\n" 3436 "#else\n" 3437 " param12)\n" 3438 "#endif\n" 3439 "{\n" 3440 " x();\n" 3441 "}", 3442 getLLVMStyleWithColumns(28)); 3443 verifyFormat("#if 1\n" 3444 "int i;"); 3445 verifyFormat("#if 1\n" 3446 "#endif\n" 3447 "#if 1\n" 3448 "#else\n" 3449 "#endif\n"); 3450 verifyFormat("DEBUG({\n" 3451 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3452 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3453 "});\n" 3454 "#if a\n" 3455 "#else\n" 3456 "#endif"); 3457 3458 verifyIncompleteFormat("void f(\n" 3459 "#if A\n" 3460 ");\n" 3461 "#else\n" 3462 "#endif"); 3463 } 3464 3465 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3466 verifyFormat("#endif\n" 3467 "#if B"); 3468 } 3469 3470 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3471 FormatStyle SingleLine = getLLVMStyle(); 3472 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3473 verifyFormat("#if 0\n" 3474 "#elif 1\n" 3475 "#endif\n" 3476 "void foo() {\n" 3477 " if (test) foo2();\n" 3478 "}", 3479 SingleLine); 3480 } 3481 3482 TEST_F(FormatTest, LayoutBlockInsideParens) { 3483 verifyFormat("functionCall({ int i; });"); 3484 verifyFormat("functionCall({\n" 3485 " int i;\n" 3486 " int j;\n" 3487 "});"); 3488 verifyFormat("functionCall(\n" 3489 " {\n" 3490 " int i;\n" 3491 " int j;\n" 3492 " },\n" 3493 " aaaa, bbbb, cccc);"); 3494 verifyFormat("functionA(functionB({\n" 3495 " int i;\n" 3496 " int j;\n" 3497 " }),\n" 3498 " aaaa, bbbb, cccc);"); 3499 verifyFormat("functionCall(\n" 3500 " {\n" 3501 " int i;\n" 3502 " int j;\n" 3503 " },\n" 3504 " aaaa, bbbb, // comment\n" 3505 " cccc);"); 3506 verifyFormat("functionA(functionB({\n" 3507 " int i;\n" 3508 " int j;\n" 3509 " }),\n" 3510 " aaaa, bbbb, // comment\n" 3511 " cccc);"); 3512 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3513 verifyFormat("functionCall(aaaa, bbbb, {\n" 3514 " int i;\n" 3515 " int j;\n" 3516 "});"); 3517 verifyFormat( 3518 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3519 " {\n" 3520 " int i; // break\n" 3521 " },\n" 3522 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3523 " ccccccccccccccccc));"); 3524 verifyFormat("DEBUG({\n" 3525 " if (a)\n" 3526 " f();\n" 3527 "});"); 3528 } 3529 3530 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3531 EXPECT_EQ("SOME_MACRO { int i; }\n" 3532 "int i;", 3533 format(" SOME_MACRO {int i;} int i;")); 3534 } 3535 3536 TEST_F(FormatTest, LayoutNestedBlocks) { 3537 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3538 " struct s {\n" 3539 " int i;\n" 3540 " };\n" 3541 " s kBitsToOs[] = {{10}};\n" 3542 " for (int i = 0; i < 10; ++i)\n" 3543 " return;\n" 3544 "}"); 3545 verifyFormat("call(parameter, {\n" 3546 " something();\n" 3547 " // Comment using all columns.\n" 3548 " somethingelse();\n" 3549 "});", 3550 getLLVMStyleWithColumns(40)); 3551 verifyFormat("DEBUG( //\n" 3552 " { f(); }, a);"); 3553 verifyFormat("DEBUG( //\n" 3554 " {\n" 3555 " f(); //\n" 3556 " },\n" 3557 " a);"); 3558 3559 EXPECT_EQ("call(parameter, {\n" 3560 " something();\n" 3561 " // Comment too\n" 3562 " // looooooooooong.\n" 3563 " somethingElse();\n" 3564 "});", 3565 format("call(parameter, {\n" 3566 " something();\n" 3567 " // Comment too looooooooooong.\n" 3568 " somethingElse();\n" 3569 "});", 3570 getLLVMStyleWithColumns(29))); 3571 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3572 EXPECT_EQ("DEBUG({ // comment\n" 3573 " int i;\n" 3574 "});", 3575 format("DEBUG({ // comment\n" 3576 "int i;\n" 3577 "});")); 3578 EXPECT_EQ("DEBUG({\n" 3579 " int i;\n" 3580 "\n" 3581 " // comment\n" 3582 " int j;\n" 3583 "});", 3584 format("DEBUG({\n" 3585 " int i;\n" 3586 "\n" 3587 " // comment\n" 3588 " int j;\n" 3589 "});")); 3590 3591 verifyFormat("DEBUG({\n" 3592 " if (a)\n" 3593 " return;\n" 3594 "});"); 3595 verifyGoogleFormat("DEBUG({\n" 3596 " if (a) return;\n" 3597 "});"); 3598 FormatStyle Style = getGoogleStyle(); 3599 Style.ColumnLimit = 45; 3600 verifyFormat("Debug(\n" 3601 " aaaaa,\n" 3602 " {\n" 3603 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 3604 " },\n" 3605 " a);", 3606 Style); 3607 3608 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 3609 3610 verifyNoCrash("^{v^{a}}"); 3611 } 3612 3613 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 3614 EXPECT_EQ("#define MACRO() \\\n" 3615 " Debug(aaa, /* force line break */ \\\n" 3616 " { \\\n" 3617 " int i; \\\n" 3618 " int j; \\\n" 3619 " })", 3620 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 3621 " { int i; int j; })", 3622 getGoogleStyle())); 3623 3624 EXPECT_EQ("#define A \\\n" 3625 " [] { \\\n" 3626 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3627 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 3628 " }", 3629 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3630 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 3631 getGoogleStyle())); 3632 } 3633 3634 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 3635 EXPECT_EQ("{}", format("{}")); 3636 verifyFormat("enum E {};"); 3637 verifyFormat("enum E {}"); 3638 } 3639 3640 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 3641 FormatStyle Style = getLLVMStyle(); 3642 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 3643 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 3644 verifyFormat("FOO_BEGIN\n" 3645 " FOO_ENTRY\n" 3646 "FOO_END", Style); 3647 verifyFormat("FOO_BEGIN\n" 3648 " NESTED_FOO_BEGIN\n" 3649 " NESTED_FOO_ENTRY\n" 3650 " NESTED_FOO_END\n" 3651 "FOO_END", Style); 3652 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 3653 " int x;\n" 3654 " x = 1;\n" 3655 "FOO_END(Baz)", Style); 3656 } 3657 3658 //===----------------------------------------------------------------------===// 3659 // Line break tests. 3660 //===----------------------------------------------------------------------===// 3661 3662 TEST_F(FormatTest, PreventConfusingIndents) { 3663 verifyFormat( 3664 "void f() {\n" 3665 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 3666 " parameter, parameter, parameter)),\n" 3667 " SecondLongCall(parameter));\n" 3668 "}"); 3669 verifyFormat( 3670 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3671 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3672 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3673 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 3674 verifyFormat( 3675 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3676 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 3677 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 3678 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 3679 verifyFormat( 3680 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 3681 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 3682 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 3683 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 3684 verifyFormat("int a = bbbb && ccc &&\n" 3685 " fffff(\n" 3686 "#define A Just forcing a new line\n" 3687 " ddd);"); 3688 } 3689 3690 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 3691 verifyFormat( 3692 "bool aaaaaaa =\n" 3693 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 3694 " bbbbbbbb();"); 3695 verifyFormat( 3696 "bool aaaaaaa =\n" 3697 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 3698 " bbbbbbbb();"); 3699 3700 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3701 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 3702 " ccccccccc == ddddddddddd;"); 3703 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3704 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 3705 " ccccccccc == ddddddddddd;"); 3706 verifyFormat( 3707 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 3708 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 3709 " ccccccccc == ddddddddddd;"); 3710 3711 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3712 " aaaaaa) &&\n" 3713 " bbbbbb && cccccc;"); 3714 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3715 " aaaaaa) >>\n" 3716 " bbbbbb;"); 3717 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 3718 " SourceMgr.getSpellingColumnNumber(\n" 3719 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 3720 " 1);"); 3721 3722 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3723 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 3724 " cccccc) {\n}"); 3725 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3726 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3727 " cccccc) {\n}"); 3728 verifyFormat("b = a &&\n" 3729 " // Comment\n" 3730 " b.c && d;"); 3731 3732 // If the LHS of a comparison is not a binary expression itself, the 3733 // additional linebreak confuses many people. 3734 verifyFormat( 3735 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3736 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 3737 "}"); 3738 verifyFormat( 3739 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3740 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3741 "}"); 3742 verifyFormat( 3743 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 3744 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3745 "}"); 3746 verifyFormat( 3747 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3748 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 3749 "}"); 3750 // Even explicit parentheses stress the precedence enough to make the 3751 // additional break unnecessary. 3752 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3753 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3754 "}"); 3755 // This cases is borderline, but with the indentation it is still readable. 3756 verifyFormat( 3757 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3758 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3759 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 3760 "}", 3761 getLLVMStyleWithColumns(75)); 3762 3763 // If the LHS is a binary expression, we should still use the additional break 3764 // as otherwise the formatting hides the operator precedence. 3765 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3766 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3767 " 5) {\n" 3768 "}"); 3769 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3770 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 3771 " 5) {\n" 3772 "}"); 3773 3774 FormatStyle OnePerLine = getLLVMStyle(); 3775 OnePerLine.BinPackParameters = false; 3776 verifyFormat( 3777 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3778 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3779 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 3780 OnePerLine); 3781 3782 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 3783 " .aaa(aaaaaaaaaaaaa) *\n" 3784 " aaaaaaa +\n" 3785 " aaaaaaa;", 3786 getLLVMStyleWithColumns(40)); 3787 } 3788 3789 TEST_F(FormatTest, ExpressionIndentation) { 3790 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3791 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3792 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3793 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3794 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 3795 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 3796 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3797 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 3798 " ccccccccccccccccccccccccccccccccccccccccc;"); 3799 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3800 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3801 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3802 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3803 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3804 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3805 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3806 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3807 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 3808 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 3809 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3810 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 3811 verifyFormat("if () {\n" 3812 "} else if (aaaaa && bbbbb > // break\n" 3813 " ccccc) {\n" 3814 "}"); 3815 verifyFormat("if () {\n" 3816 "} else if (aaaaa &&\n" 3817 " bbbbb > // break\n" 3818 " ccccc &&\n" 3819 " ddddd) {\n" 3820 "}"); 3821 3822 // Presence of a trailing comment used to change indentation of b. 3823 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 3824 " b;\n" 3825 "return aaaaaaaaaaaaaaaaaaa +\n" 3826 " b; //", 3827 getLLVMStyleWithColumns(30)); 3828 } 3829 3830 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 3831 // Not sure what the best system is here. Like this, the LHS can be found 3832 // immediately above an operator (everything with the same or a higher 3833 // indent). The RHS is aligned right of the operator and so compasses 3834 // everything until something with the same indent as the operator is found. 3835 // FIXME: Is this a good system? 3836 FormatStyle Style = getLLVMStyle(); 3837 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 3838 verifyFormat( 3839 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3840 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3841 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3842 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3843 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3844 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3845 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3846 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3847 " > ccccccccccccccccccccccccccccccccccccccccc;", 3848 Style); 3849 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3850 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3851 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3852 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3853 Style); 3854 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3855 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3856 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3857 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3858 Style); 3859 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3860 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3861 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3862 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 3863 Style); 3864 verifyFormat("if () {\n" 3865 "} else if (aaaaa\n" 3866 " && bbbbb // break\n" 3867 " > ccccc) {\n" 3868 "}", 3869 Style); 3870 verifyFormat("return (a)\n" 3871 " // comment\n" 3872 " + b;", 3873 Style); 3874 verifyFormat( 3875 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3876 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3877 " + cc;", 3878 Style); 3879 3880 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3881 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 3882 Style); 3883 3884 // Forced by comments. 3885 verifyFormat( 3886 "unsigned ContentSize =\n" 3887 " sizeof(int16_t) // DWARF ARange version number\n" 3888 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 3889 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 3890 " + sizeof(int8_t); // Segment Size (in bytes)"); 3891 3892 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 3893 " == boost::fusion::at_c<1>(iiii).second;", 3894 Style); 3895 3896 Style.ColumnLimit = 60; 3897 verifyFormat("zzzzzzzzzz\n" 3898 " = bbbbbbbbbbbbbbbbb\n" 3899 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 3900 Style); 3901 3902 Style.ColumnLimit = 80; 3903 Style.IndentWidth = 4; 3904 Style.TabWidth = 4; 3905 Style.UseTab = FormatStyle::UT_Always; 3906 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 3907 Style.AlignOperands = false; 3908 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 3909 "\t&& (someOtherLongishConditionPart1\n" 3910 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 3911 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && (someOtherLongishConditionPart1 || someOtherEvenLongerNestedConditionPart2);", 3912 Style)); 3913 } 3914 3915 TEST_F(FormatTest, EnforcedOperatorWraps) { 3916 // Here we'd like to wrap after the || operators, but a comment is forcing an 3917 // earlier wrap. 3918 verifyFormat("bool x = aaaaa //\n" 3919 " || bbbbb\n" 3920 " //\n" 3921 " || cccc;"); 3922 } 3923 3924 TEST_F(FormatTest, NoOperandAlignment) { 3925 FormatStyle Style = getLLVMStyle(); 3926 Style.AlignOperands = false; 3927 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 3928 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3929 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 3930 Style); 3931 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 3932 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3933 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3934 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3935 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3936 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3937 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3938 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3939 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3940 " > ccccccccccccccccccccccccccccccccccccccccc;", 3941 Style); 3942 3943 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3944 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3945 " + cc;", 3946 Style); 3947 verifyFormat("int a = aa\n" 3948 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 3949 " * cccccccccccccccccccccccccccccccccccc;\n", 3950 Style); 3951 3952 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 3953 verifyFormat("return (a > b\n" 3954 " // comment1\n" 3955 " // comment2\n" 3956 " || c);", 3957 Style); 3958 } 3959 3960 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 3961 FormatStyle Style = getLLVMStyle(); 3962 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 3963 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 3964 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3965 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 3966 Style); 3967 } 3968 3969 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 3970 FormatStyle Style = getLLVMStyle(); 3971 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 3972 Style.BinPackArguments = false; 3973 Style.ColumnLimit = 40; 3974 verifyFormat("void test() {\n" 3975 " someFunction(\n" 3976 " this + argument + is + quite\n" 3977 " + long + so + it + gets + wrapped\n" 3978 " + but + remains + bin - packed);\n" 3979 "}", 3980 Style); 3981 verifyFormat("void test() {\n" 3982 " someFunction(arg1,\n" 3983 " this + argument + is\n" 3984 " + quite + long + so\n" 3985 " + it + gets + wrapped\n" 3986 " + but + remains + bin\n" 3987 " - packed,\n" 3988 " arg3);\n" 3989 "}", 3990 Style); 3991 verifyFormat("void test() {\n" 3992 " someFunction(\n" 3993 " arg1,\n" 3994 " this + argument + has\n" 3995 " + anotherFunc(nested,\n" 3996 " calls + whose\n" 3997 " + arguments\n" 3998 " + are + also\n" 3999 " + wrapped,\n" 4000 " in + addition)\n" 4001 " + to + being + bin - packed,\n" 4002 " arg3);\n" 4003 "}", 4004 Style); 4005 4006 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4007 verifyFormat("void test() {\n" 4008 " someFunction(\n" 4009 " arg1,\n" 4010 " this + argument + has +\n" 4011 " anotherFunc(nested,\n" 4012 " calls + whose +\n" 4013 " arguments +\n" 4014 " are + also +\n" 4015 " wrapped,\n" 4016 " in + addition) +\n" 4017 " to + being + bin - packed,\n" 4018 " arg3);\n" 4019 "}", 4020 Style); 4021 } 4022 4023 TEST_F(FormatTest, ConstructorInitializers) { 4024 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4025 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 4026 getLLVMStyleWithColumns(45)); 4027 verifyFormat("Constructor()\n" 4028 " : Inttializer(FitsOnTheLine) {}", 4029 getLLVMStyleWithColumns(44)); 4030 verifyFormat("Constructor()\n" 4031 " : Inttializer(FitsOnTheLine) {}", 4032 getLLVMStyleWithColumns(43)); 4033 4034 verifyFormat("template <typename T>\n" 4035 "Constructor() : Initializer(FitsOnTheLine) {}", 4036 getLLVMStyleWithColumns(45)); 4037 4038 verifyFormat( 4039 "SomeClass::Constructor()\n" 4040 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4041 4042 verifyFormat( 4043 "SomeClass::Constructor()\n" 4044 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4045 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 4046 verifyFormat( 4047 "SomeClass::Constructor()\n" 4048 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4049 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4050 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4051 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4052 " : aaaaaaaaaa(aaaaaa) {}"); 4053 4054 verifyFormat("Constructor()\n" 4055 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4056 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4057 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4058 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 4059 4060 verifyFormat("Constructor()\n" 4061 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4062 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4063 4064 verifyFormat("Constructor(int Parameter = 0)\n" 4065 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4066 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 4067 verifyFormat("Constructor()\n" 4068 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4069 "}", 4070 getLLVMStyleWithColumns(60)); 4071 verifyFormat("Constructor()\n" 4072 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4073 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 4074 4075 // Here a line could be saved by splitting the second initializer onto two 4076 // lines, but that is not desirable. 4077 verifyFormat("Constructor()\n" 4078 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4079 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4080 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4081 4082 FormatStyle OnePerLine = getLLVMStyle(); 4083 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4084 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 4085 verifyFormat("SomeClass::Constructor()\n" 4086 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4087 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4088 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4089 OnePerLine); 4090 verifyFormat("SomeClass::Constructor()\n" 4091 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4092 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4093 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4094 OnePerLine); 4095 verifyFormat("MyClass::MyClass(int var)\n" 4096 " : some_var_(var), // 4 space indent\n" 4097 " some_other_var_(var + 1) { // lined up\n" 4098 "}", 4099 OnePerLine); 4100 verifyFormat("Constructor()\n" 4101 " : aaaaa(aaaaaa),\n" 4102 " aaaaa(aaaaaa),\n" 4103 " aaaaa(aaaaaa),\n" 4104 " aaaaa(aaaaaa),\n" 4105 " aaaaa(aaaaaa) {}", 4106 OnePerLine); 4107 verifyFormat("Constructor()\n" 4108 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4109 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4110 OnePerLine); 4111 OnePerLine.BinPackParameters = false; 4112 verifyFormat( 4113 "Constructor()\n" 4114 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4115 " aaaaaaaaaaa().aaa(),\n" 4116 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4117 OnePerLine); 4118 OnePerLine.ColumnLimit = 60; 4119 verifyFormat("Constructor()\n" 4120 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4121 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4122 OnePerLine); 4123 4124 EXPECT_EQ("Constructor()\n" 4125 " : // Comment forcing unwanted break.\n" 4126 " aaaa(aaaa) {}", 4127 format("Constructor() :\n" 4128 " // Comment forcing unwanted break.\n" 4129 " aaaa(aaaa) {}")); 4130 } 4131 4132 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 4133 FormatStyle Style = getLLVMStyle(); 4134 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4135 Style.ColumnLimit = 60; 4136 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4137 Style.AllowAllConstructorInitializersOnNextLine = true; 4138 Style.BinPackParameters = false; 4139 4140 for (int i = 0; i < 4; ++i) { 4141 // Test all combinations of parameters that should not have an effect. 4142 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4143 Style.AllowAllArgumentsOnNextLine = i & 2; 4144 4145 Style.AllowAllConstructorInitializersOnNextLine = true; 4146 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4147 verifyFormat("Constructor()\n" 4148 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4149 Style); 4150 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4151 4152 Style.AllowAllConstructorInitializersOnNextLine = false; 4153 verifyFormat("Constructor()\n" 4154 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4155 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4156 Style); 4157 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4158 4159 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4160 Style.AllowAllConstructorInitializersOnNextLine = true; 4161 verifyFormat("Constructor()\n" 4162 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4163 Style); 4164 4165 Style.AllowAllConstructorInitializersOnNextLine = false; 4166 verifyFormat("Constructor()\n" 4167 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4168 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4169 Style); 4170 4171 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4172 Style.AllowAllConstructorInitializersOnNextLine = true; 4173 verifyFormat("Constructor() :\n" 4174 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4175 Style); 4176 4177 Style.AllowAllConstructorInitializersOnNextLine = false; 4178 verifyFormat("Constructor() :\n" 4179 " aaaaaaaaaaaaaaaaaa(a),\n" 4180 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4181 Style); 4182 } 4183 4184 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4185 // AllowAllConstructorInitializersOnNextLine in all 4186 // BreakConstructorInitializers modes 4187 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4188 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4189 Style.AllowAllConstructorInitializersOnNextLine = false; 4190 verifyFormat("SomeClassWithALongName::Constructor(\n" 4191 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4192 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4193 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4194 Style); 4195 4196 Style.AllowAllConstructorInitializersOnNextLine = true; 4197 verifyFormat("SomeClassWithALongName::Constructor(\n" 4198 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4199 " int bbbbbbbbbbbbb,\n" 4200 " int cccccccccccccccc)\n" 4201 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4202 Style); 4203 4204 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4205 Style.AllowAllConstructorInitializersOnNextLine = false; 4206 verifyFormat("SomeClassWithALongName::Constructor(\n" 4207 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4208 " int bbbbbbbbbbbbb)\n" 4209 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4210 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4211 Style); 4212 4213 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4214 4215 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4216 verifyFormat("SomeClassWithALongName::Constructor(\n" 4217 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4218 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4219 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4220 Style); 4221 4222 Style.AllowAllConstructorInitializersOnNextLine = true; 4223 verifyFormat("SomeClassWithALongName::Constructor(\n" 4224 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4225 " int bbbbbbbbbbbbb,\n" 4226 " int cccccccccccccccc)\n" 4227 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4228 Style); 4229 4230 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4231 Style.AllowAllConstructorInitializersOnNextLine = false; 4232 verifyFormat("SomeClassWithALongName::Constructor(\n" 4233 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4234 " int bbbbbbbbbbbbb)\n" 4235 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4236 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4237 Style); 4238 4239 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4240 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4241 verifyFormat("SomeClassWithALongName::Constructor(\n" 4242 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4243 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4244 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4245 Style); 4246 4247 Style.AllowAllConstructorInitializersOnNextLine = true; 4248 verifyFormat("SomeClassWithALongName::Constructor(\n" 4249 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4250 " int bbbbbbbbbbbbb,\n" 4251 " int cccccccccccccccc) :\n" 4252 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4253 Style); 4254 4255 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4256 Style.AllowAllConstructorInitializersOnNextLine = false; 4257 verifyFormat("SomeClassWithALongName::Constructor(\n" 4258 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4259 " int bbbbbbbbbbbbb) :\n" 4260 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4261 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4262 Style); 4263 } 4264 4265 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4266 FormatStyle Style = getLLVMStyle(); 4267 Style.ColumnLimit = 60; 4268 Style.BinPackArguments = false; 4269 for (int i = 0; i < 4; ++i) { 4270 // Test all combinations of parameters that should not have an effect. 4271 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4272 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4273 4274 Style.AllowAllArgumentsOnNextLine = true; 4275 verifyFormat("void foo() {\n" 4276 " FunctionCallWithReallyLongName(\n" 4277 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4278 "}", 4279 Style); 4280 Style.AllowAllArgumentsOnNextLine = false; 4281 verifyFormat("void foo() {\n" 4282 " FunctionCallWithReallyLongName(\n" 4283 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4284 " bbbbbbbbbbbb);\n" 4285 "}", 4286 Style); 4287 4288 Style.AllowAllArgumentsOnNextLine = true; 4289 verifyFormat("void foo() {\n" 4290 " auto VariableWithReallyLongName = {\n" 4291 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4292 "}", 4293 Style); 4294 Style.AllowAllArgumentsOnNextLine = false; 4295 verifyFormat("void foo() {\n" 4296 " auto VariableWithReallyLongName = {\n" 4297 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4298 " bbbbbbbbbbbb};\n" 4299 "}", 4300 Style); 4301 } 4302 4303 // This parameter should not affect declarations. 4304 Style.BinPackParameters = false; 4305 Style.AllowAllArgumentsOnNextLine = false; 4306 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4307 verifyFormat("void FunctionCallWithReallyLongName(\n" 4308 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4309 Style); 4310 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4311 verifyFormat("void FunctionCallWithReallyLongName(\n" 4312 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4313 " int bbbbbbbbbbbb);", 4314 Style); 4315 } 4316 4317 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4318 FormatStyle Style = getLLVMStyle(); 4319 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4320 4321 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4322 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4323 getStyleWithColumns(Style, 45)); 4324 verifyFormat("Constructor() :\n" 4325 " Initializer(FitsOnTheLine) {}", 4326 getStyleWithColumns(Style, 44)); 4327 verifyFormat("Constructor() :\n" 4328 " Initializer(FitsOnTheLine) {}", 4329 getStyleWithColumns(Style, 43)); 4330 4331 verifyFormat("template <typename T>\n" 4332 "Constructor() : Initializer(FitsOnTheLine) {}", 4333 getStyleWithColumns(Style, 50)); 4334 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4335 verifyFormat( 4336 "SomeClass::Constructor() :\n" 4337 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4338 Style); 4339 4340 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4341 verifyFormat( 4342 "SomeClass::Constructor() :\n" 4343 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4344 Style); 4345 4346 verifyFormat( 4347 "SomeClass::Constructor() :\n" 4348 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4349 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4350 Style); 4351 verifyFormat( 4352 "SomeClass::Constructor() :\n" 4353 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4354 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4355 Style); 4356 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4357 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4358 " aaaaaaaaaa(aaaaaa) {}", 4359 Style); 4360 4361 verifyFormat("Constructor() :\n" 4362 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4363 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4364 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4365 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4366 Style); 4367 4368 verifyFormat("Constructor() :\n" 4369 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4370 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4371 Style); 4372 4373 verifyFormat("Constructor(int Parameter = 0) :\n" 4374 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4375 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4376 Style); 4377 verifyFormat("Constructor() :\n" 4378 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4379 "}", 4380 getStyleWithColumns(Style, 60)); 4381 verifyFormat("Constructor() :\n" 4382 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4383 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4384 Style); 4385 4386 // Here a line could be saved by splitting the second initializer onto two 4387 // lines, but that is not desirable. 4388 verifyFormat("Constructor() :\n" 4389 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4390 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4391 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4392 Style); 4393 4394 FormatStyle OnePerLine = Style; 4395 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4396 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4397 verifyFormat("SomeClass::Constructor() :\n" 4398 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4399 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4400 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4401 OnePerLine); 4402 verifyFormat("SomeClass::Constructor() :\n" 4403 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4404 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4405 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4406 OnePerLine); 4407 verifyFormat("MyClass::MyClass(int var) :\n" 4408 " some_var_(var), // 4 space indent\n" 4409 " some_other_var_(var + 1) { // lined up\n" 4410 "}", 4411 OnePerLine); 4412 verifyFormat("Constructor() :\n" 4413 " aaaaa(aaaaaa),\n" 4414 " aaaaa(aaaaaa),\n" 4415 " aaaaa(aaaaaa),\n" 4416 " aaaaa(aaaaaa),\n" 4417 " aaaaa(aaaaaa) {}", 4418 OnePerLine); 4419 verifyFormat("Constructor() :\n" 4420 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4421 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4422 OnePerLine); 4423 OnePerLine.BinPackParameters = false; 4424 verifyFormat( 4425 "Constructor() :\n" 4426 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4427 " aaaaaaaaaaa().aaa(),\n" 4428 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4429 OnePerLine); 4430 OnePerLine.ColumnLimit = 60; 4431 verifyFormat("Constructor() :\n" 4432 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4433 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4434 OnePerLine); 4435 4436 EXPECT_EQ("Constructor() :\n" 4437 " // Comment forcing unwanted break.\n" 4438 " aaaa(aaaa) {}", 4439 format("Constructor() :\n" 4440 " // Comment forcing unwanted break.\n" 4441 " aaaa(aaaa) {}", 4442 Style)); 4443 4444 Style.ColumnLimit = 0; 4445 verifyFormat("SomeClass::Constructor() :\n" 4446 " a(a) {}", 4447 Style); 4448 verifyFormat("SomeClass::Constructor() noexcept :\n" 4449 " a(a) {}", 4450 Style); 4451 verifyFormat("SomeClass::Constructor() :\n" 4452 " a(a), b(b), c(c) {}", 4453 Style); 4454 verifyFormat("SomeClass::Constructor() :\n" 4455 " a(a) {\n" 4456 " foo();\n" 4457 " bar();\n" 4458 "}", 4459 Style); 4460 4461 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4462 verifyFormat("SomeClass::Constructor() :\n" 4463 " a(a), b(b), c(c) {\n" 4464 "}", 4465 Style); 4466 verifyFormat("SomeClass::Constructor() :\n" 4467 " a(a) {\n" 4468 "}", 4469 Style); 4470 4471 Style.ColumnLimit = 80; 4472 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4473 Style.ConstructorInitializerIndentWidth = 2; 4474 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", 4475 Style); 4476 verifyFormat("SomeClass::Constructor() :\n" 4477 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4478 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 4479 Style); 4480 4481 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as well 4482 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 4483 verifyFormat("class SomeClass\n" 4484 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4485 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4486 Style); 4487 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 4488 verifyFormat("class SomeClass\n" 4489 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4490 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4491 Style); 4492 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 4493 verifyFormat("class SomeClass :\n" 4494 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4495 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4496 Style); 4497 } 4498 4499 #ifndef EXPENSIVE_CHECKS 4500 // Expensive checks enables libstdc++ checking which includes validating the 4501 // state of ranges used in std::priority_queue - this blows out the 4502 // runtime/scalability of the function and makes this test unacceptably slow. 4503 TEST_F(FormatTest, MemoizationTests) { 4504 // This breaks if the memoization lookup does not take \c Indent and 4505 // \c LastSpace into account. 4506 verifyFormat( 4507 "extern CFRunLoopTimerRef\n" 4508 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 4509 " CFTimeInterval interval, CFOptionFlags flags,\n" 4510 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 4511 " CFRunLoopTimerContext *context) {}"); 4512 4513 // Deep nesting somewhat works around our memoization. 4514 verifyFormat( 4515 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4516 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4517 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4518 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4519 " aaaaa())))))))))))))))))))))))))))))))))))))));", 4520 getLLVMStyleWithColumns(65)); 4521 verifyFormat( 4522 "aaaaa(\n" 4523 " aaaaa,\n" 4524 " aaaaa(\n" 4525 " aaaaa,\n" 4526 " aaaaa(\n" 4527 " aaaaa,\n" 4528 " aaaaa(\n" 4529 " aaaaa,\n" 4530 " aaaaa(\n" 4531 " aaaaa,\n" 4532 " aaaaa(\n" 4533 " aaaaa,\n" 4534 " aaaaa(\n" 4535 " aaaaa,\n" 4536 " aaaaa(\n" 4537 " aaaaa,\n" 4538 " aaaaa(\n" 4539 " aaaaa,\n" 4540 " aaaaa(\n" 4541 " aaaaa,\n" 4542 " aaaaa(\n" 4543 " aaaaa,\n" 4544 " aaaaa(\n" 4545 " aaaaa,\n" 4546 " aaaaa))))))))))));", 4547 getLLVMStyleWithColumns(65)); 4548 verifyFormat( 4549 "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" 4550 " a),\n" 4551 " a),\n" 4552 " a),\n" 4553 " a),\n" 4554 " a),\n" 4555 " a),\n" 4556 " a),\n" 4557 " a),\n" 4558 " a),\n" 4559 " a),\n" 4560 " a),\n" 4561 " a),\n" 4562 " a),\n" 4563 " a),\n" 4564 " a),\n" 4565 " a),\n" 4566 " a)", 4567 getLLVMStyleWithColumns(65)); 4568 4569 // This test takes VERY long when memoization is broken. 4570 FormatStyle OnePerLine = getLLVMStyle(); 4571 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4572 OnePerLine.BinPackParameters = false; 4573 std::string input = "Constructor()\n" 4574 " : aaaa(a,\n"; 4575 for (unsigned i = 0, e = 80; i != e; ++i) { 4576 input += " a,\n"; 4577 } 4578 input += " a) {}"; 4579 verifyFormat(input, OnePerLine); 4580 } 4581 #endif 4582 4583 TEST_F(FormatTest, BreaksAsHighAsPossible) { 4584 verifyFormat( 4585 "void f() {\n" 4586 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 4587 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 4588 " f();\n" 4589 "}"); 4590 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 4591 " Intervals[i - 1].getRange().getLast()) {\n}"); 4592 } 4593 4594 TEST_F(FormatTest, BreaksFunctionDeclarations) { 4595 // Principially, we break function declarations in a certain order: 4596 // 1) break amongst arguments. 4597 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 4598 " Cccccccccccccc cccccccccccccc);"); 4599 verifyFormat("template <class TemplateIt>\n" 4600 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 4601 " TemplateIt *stop) {}"); 4602 4603 // 2) break after return type. 4604 verifyFormat( 4605 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4606 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 4607 getGoogleStyle()); 4608 4609 // 3) break after (. 4610 verifyFormat( 4611 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 4612 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 4613 getGoogleStyle()); 4614 4615 // 4) break before after nested name specifiers. 4616 verifyFormat( 4617 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4618 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 4619 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 4620 getGoogleStyle()); 4621 4622 // However, there are exceptions, if a sufficient amount of lines can be 4623 // saved. 4624 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 4625 // more adjusting. 4626 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4627 " Cccccccccccccc cccccccccc,\n" 4628 " Cccccccccccccc cccccccccc,\n" 4629 " Cccccccccccccc cccccccccc,\n" 4630 " Cccccccccccccc cccccccccc);"); 4631 verifyFormat( 4632 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4633 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4634 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4635 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 4636 getGoogleStyle()); 4637 verifyFormat( 4638 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4639 " Cccccccccccccc cccccccccc,\n" 4640 " Cccccccccccccc cccccccccc,\n" 4641 " Cccccccccccccc cccccccccc,\n" 4642 " Cccccccccccccc cccccccccc,\n" 4643 " Cccccccccccccc cccccccccc,\n" 4644 " Cccccccccccccc cccccccccc);"); 4645 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4646 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4647 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4648 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4649 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 4650 4651 // Break after multi-line parameters. 4652 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4653 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4654 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4655 " bbbb bbbb);"); 4656 verifyFormat("void SomeLoooooooooooongFunction(\n" 4657 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 4658 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4659 " int bbbbbbbbbbbbb);"); 4660 4661 // Treat overloaded operators like other functions. 4662 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4663 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 4664 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4665 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 4666 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4667 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 4668 verifyGoogleFormat( 4669 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 4670 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4671 verifyGoogleFormat( 4672 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 4673 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4674 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4675 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4676 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 4677 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4678 verifyGoogleFormat( 4679 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 4680 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4681 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 4682 verifyGoogleFormat( 4683 "template <typename T>\n" 4684 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4685 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 4686 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 4687 4688 FormatStyle Style = getLLVMStyle(); 4689 Style.PointerAlignment = FormatStyle::PAS_Left; 4690 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4691 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 4692 Style); 4693 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 4694 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4695 Style); 4696 } 4697 4698 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 4699 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 4700 // Prefer keeping `::` followed by `operator` together. 4701 EXPECT_EQ("const aaaa::bbbbbbb &\n" 4702 "ccccccccc::operator++() {\n" 4703 " stuff();\n" 4704 "}", 4705 format("const aaaa::bbbbbbb\n" 4706 "&ccccccccc::operator++() { stuff(); }", 4707 getLLVMStyleWithColumns(40))); 4708 } 4709 4710 TEST_F(FormatTest, TrailingReturnType) { 4711 verifyFormat("auto foo() -> int;\n"); 4712 verifyFormat("struct S {\n" 4713 " auto bar() const -> int;\n" 4714 "};"); 4715 verifyFormat("template <size_t Order, typename T>\n" 4716 "auto load_img(const std::string &filename)\n" 4717 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 4718 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 4719 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 4720 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 4721 verifyFormat("template <typename T>\n" 4722 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 4723 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 4724 4725 // Not trailing return types. 4726 verifyFormat("void f() { auto a = b->c(); }"); 4727 } 4728 4729 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 4730 // Avoid breaking before trailing 'const' or other trailing annotations, if 4731 // they are not function-like. 4732 FormatStyle Style = getGoogleStyle(); 4733 Style.ColumnLimit = 47; 4734 verifyFormat("void someLongFunction(\n" 4735 " int someLoooooooooooooongParameter) const {\n}", 4736 getLLVMStyleWithColumns(47)); 4737 verifyFormat("LoooooongReturnType\n" 4738 "someLoooooooongFunction() const {}", 4739 getLLVMStyleWithColumns(47)); 4740 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 4741 " const {}", 4742 Style); 4743 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4744 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 4745 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4746 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 4747 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 4748 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 4749 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 4750 " aaaaaaaaaaa aaaaa) const override;"); 4751 verifyGoogleFormat( 4752 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 4753 " const override;"); 4754 4755 // Even if the first parameter has to be wrapped. 4756 verifyFormat("void someLongFunction(\n" 4757 " int someLongParameter) const {}", 4758 getLLVMStyleWithColumns(46)); 4759 verifyFormat("void someLongFunction(\n" 4760 " int someLongParameter) const {}", 4761 Style); 4762 verifyFormat("void someLongFunction(\n" 4763 " int someLongParameter) override {}", 4764 Style); 4765 verifyFormat("void someLongFunction(\n" 4766 " int someLongParameter) OVERRIDE {}", 4767 Style); 4768 verifyFormat("void someLongFunction(\n" 4769 " int someLongParameter) final {}", 4770 Style); 4771 verifyFormat("void someLongFunction(\n" 4772 " int someLongParameter) FINAL {}", 4773 Style); 4774 verifyFormat("void someLongFunction(\n" 4775 " int parameter) const override {}", 4776 Style); 4777 4778 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 4779 verifyFormat("void someLongFunction(\n" 4780 " int someLongParameter) const\n" 4781 "{\n" 4782 "}", 4783 Style); 4784 4785 // Unless these are unknown annotations. 4786 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 4787 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4788 " LONG_AND_UGLY_ANNOTATION;"); 4789 4790 // Breaking before function-like trailing annotations is fine to keep them 4791 // close to their arguments. 4792 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4793 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 4794 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 4795 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 4796 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 4797 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 4798 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 4799 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 4800 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 4801 4802 verifyFormat( 4803 "void aaaaaaaaaaaaaaaaaa()\n" 4804 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 4805 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 4806 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4807 " __attribute__((unused));"); 4808 verifyGoogleFormat( 4809 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4810 " GUARDED_BY(aaaaaaaaaaaa);"); 4811 verifyGoogleFormat( 4812 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4813 " GUARDED_BY(aaaaaaaaaaaa);"); 4814 verifyGoogleFormat( 4815 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 4816 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4817 verifyGoogleFormat( 4818 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 4819 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 4820 } 4821 4822 TEST_F(FormatTest, FunctionAnnotations) { 4823 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4824 "int OldFunction(const string ¶meter) {}"); 4825 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4826 "string OldFunction(const string ¶meter) {}"); 4827 verifyFormat("template <typename T>\n" 4828 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 4829 "string OldFunction(const string ¶meter) {}"); 4830 4831 // Not function annotations. 4832 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4833 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 4834 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 4835 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 4836 verifyFormat("MACRO(abc).function() // wrap\n" 4837 " << abc;"); 4838 verifyFormat("MACRO(abc)->function() // wrap\n" 4839 " << abc;"); 4840 verifyFormat("MACRO(abc)::function() // wrap\n" 4841 " << abc;"); 4842 } 4843 4844 TEST_F(FormatTest, BreaksDesireably) { 4845 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 4846 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 4847 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 4848 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4849 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 4850 "}"); 4851 4852 verifyFormat( 4853 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4854 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4855 4856 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4857 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4858 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4859 4860 verifyFormat( 4861 "aaaaaaaa(aaaaaaaaaaaaa,\n" 4862 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4863 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 4864 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4865 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 4866 4867 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4868 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4869 4870 verifyFormat( 4871 "void f() {\n" 4872 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 4873 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 4874 "}"); 4875 verifyFormat( 4876 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4877 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4878 verifyFormat( 4879 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4880 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 4881 verifyFormat( 4882 "aaaaaa(aaa,\n" 4883 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4884 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4885 " aaaa);"); 4886 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4887 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4888 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4889 4890 // Indent consistently independent of call expression and unary operator. 4891 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4892 " dddddddddddddddddddddddddddddd));"); 4893 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4894 " dddddddddddddddddddddddddddddd));"); 4895 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 4896 " dddddddddddddddddddddddddddddd));"); 4897 4898 // This test case breaks on an incorrect memoization, i.e. an optimization not 4899 // taking into account the StopAt value. 4900 verifyFormat( 4901 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 4902 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 4903 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 4904 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 4905 4906 verifyFormat("{\n {\n {\n" 4907 " Annotation.SpaceRequiredBefore =\n" 4908 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 4909 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 4910 " }\n }\n}"); 4911 4912 // Break on an outer level if there was a break on an inner level. 4913 EXPECT_EQ("f(g(h(a, // comment\n" 4914 " b, c),\n" 4915 " d, e),\n" 4916 " x, y);", 4917 format("f(g(h(a, // comment\n" 4918 " b, c), d, e), x, y);")); 4919 4920 // Prefer breaking similar line breaks. 4921 verifyFormat( 4922 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 4923 " NSTrackingMouseEnteredAndExited |\n" 4924 " NSTrackingActiveAlways;"); 4925 } 4926 4927 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 4928 FormatStyle NoBinPacking = getGoogleStyle(); 4929 NoBinPacking.BinPackParameters = false; 4930 NoBinPacking.BinPackArguments = true; 4931 verifyFormat("void f() {\n" 4932 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 4933 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 4934 "}", 4935 NoBinPacking); 4936 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 4937 " int aaaaaaaaaaaaaaaaaaaa,\n" 4938 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4939 NoBinPacking); 4940 4941 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 4942 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4943 " vector<int> bbbbbbbbbbbbbbb);", 4944 NoBinPacking); 4945 // FIXME: This behavior difference is probably not wanted. However, currently 4946 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 4947 // template arguments from BreakBeforeParameter being set because of the 4948 // one-per-line formatting. 4949 verifyFormat( 4950 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 4951 " aaaaaaaaaa> aaaaaaaaaa);", 4952 NoBinPacking); 4953 verifyFormat( 4954 "void fffffffffff(\n" 4955 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 4956 " aaaaaaaaaa);"); 4957 } 4958 4959 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 4960 FormatStyle NoBinPacking = getGoogleStyle(); 4961 NoBinPacking.BinPackParameters = false; 4962 NoBinPacking.BinPackArguments = false; 4963 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 4964 " aaaaaaaaaaaaaaaaaaaa,\n" 4965 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 4966 NoBinPacking); 4967 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 4968 " aaaaaaaaaaaaa,\n" 4969 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 4970 NoBinPacking); 4971 verifyFormat( 4972 "aaaaaaaa(aaaaaaaaaaaaa,\n" 4973 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4974 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 4975 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4976 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 4977 NoBinPacking); 4978 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 4979 " .aaaaaaaaaaaaaaaaaa();", 4980 NoBinPacking); 4981 verifyFormat("void f() {\n" 4982 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4983 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 4984 "}", 4985 NoBinPacking); 4986 4987 verifyFormat( 4988 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4989 " aaaaaaaaaaaa,\n" 4990 " aaaaaaaaaaaa);", 4991 NoBinPacking); 4992 verifyFormat( 4993 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 4994 " ddddddddddddddddddddddddddddd),\n" 4995 " test);", 4996 NoBinPacking); 4997 4998 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 4999 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 5000 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 5001 " aaaaaaaaaaaaaaaaaa;", 5002 NoBinPacking); 5003 verifyFormat("a(\"a\"\n" 5004 " \"a\",\n" 5005 " a);"); 5006 5007 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5008 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 5009 " aaaaaaaaa,\n" 5010 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5011 NoBinPacking); 5012 verifyFormat( 5013 "void f() {\n" 5014 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5015 " .aaaaaaa();\n" 5016 "}", 5017 NoBinPacking); 5018 verifyFormat( 5019 "template <class SomeType, class SomeOtherType>\n" 5020 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 5021 NoBinPacking); 5022 } 5023 5024 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 5025 FormatStyle Style = getLLVMStyleWithColumns(15); 5026 Style.ExperimentalAutoDetectBinPacking = true; 5027 EXPECT_EQ("aaa(aaaa,\n" 5028 " aaaa,\n" 5029 " aaaa);\n" 5030 "aaa(aaaa,\n" 5031 " aaaa,\n" 5032 " aaaa);", 5033 format("aaa(aaaa,\n" // one-per-line 5034 " aaaa,\n" 5035 " aaaa );\n" 5036 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5037 Style)); 5038 EXPECT_EQ("aaa(aaaa, aaaa,\n" 5039 " aaaa);\n" 5040 "aaa(aaaa, aaaa,\n" 5041 " aaaa);", 5042 format("aaa(aaaa, aaaa,\n" // bin-packed 5043 " aaaa );\n" 5044 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5045 Style)); 5046 } 5047 5048 TEST_F(FormatTest, FormatsBuilderPattern) { 5049 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 5050 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 5051 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 5052 " .StartsWith(\".init\", ORDER_INIT)\n" 5053 " .StartsWith(\".fini\", ORDER_FINI)\n" 5054 " .StartsWith(\".hash\", ORDER_HASH)\n" 5055 " .Default(ORDER_TEXT);\n"); 5056 5057 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 5058 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 5059 verifyFormat( 5060 "aaaaaaa->aaaaaaa\n" 5061 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5062 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5063 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5064 verifyFormat( 5065 "aaaaaaa->aaaaaaa\n" 5066 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5067 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5068 verifyFormat( 5069 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 5070 " aaaaaaaaaaaaaa);"); 5071 verifyFormat( 5072 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 5073 " aaaaaa->aaaaaaaaaaaa()\n" 5074 " ->aaaaaaaaaaaaaaaa(\n" 5075 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5076 " ->aaaaaaaaaaaaaaaaa();"); 5077 verifyGoogleFormat( 5078 "void f() {\n" 5079 " someo->Add((new util::filetools::Handler(dir))\n" 5080 " ->OnEvent1(NewPermanentCallback(\n" 5081 " this, &HandlerHolderClass::EventHandlerCBA))\n" 5082 " ->OnEvent2(NewPermanentCallback(\n" 5083 " this, &HandlerHolderClass::EventHandlerCBB))\n" 5084 " ->OnEvent3(NewPermanentCallback(\n" 5085 " this, &HandlerHolderClass::EventHandlerCBC))\n" 5086 " ->OnEvent5(NewPermanentCallback(\n" 5087 " this, &HandlerHolderClass::EventHandlerCBD))\n" 5088 " ->OnEvent6(NewPermanentCallback(\n" 5089 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 5090 "}"); 5091 5092 verifyFormat( 5093 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 5094 verifyFormat("aaaaaaaaaaaaaaa()\n" 5095 " .aaaaaaaaaaaaaaa()\n" 5096 " .aaaaaaaaaaaaaaa()\n" 5097 " .aaaaaaaaaaaaaaa()\n" 5098 " .aaaaaaaaaaaaaaa();"); 5099 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5100 " .aaaaaaaaaaaaaaa()\n" 5101 " .aaaaaaaaaaaaaaa()\n" 5102 " .aaaaaaaaaaaaaaa();"); 5103 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5104 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5105 " .aaaaaaaaaaaaaaa();"); 5106 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 5107 " ->aaaaaaaaaaaaaae(0)\n" 5108 " ->aaaaaaaaaaaaaaa();"); 5109 5110 // Don't linewrap after very short segments. 5111 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5112 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5113 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5114 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5115 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5116 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5117 verifyFormat("aaa()\n" 5118 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5119 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5120 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5121 5122 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5123 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5124 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 5125 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5126 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 5127 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 5128 5129 // Prefer not to break after empty parentheses. 5130 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 5131 " First->LastNewlineOffset);"); 5132 5133 // Prefer not to create "hanging" indents. 5134 verifyFormat( 5135 "return !soooooooooooooome_map\n" 5136 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5137 " .second;"); 5138 verifyFormat( 5139 "return aaaaaaaaaaaaaaaa\n" 5140 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 5141 " .aaaa(aaaaaaaaaaaaaa);"); 5142 // No hanging indent here. 5143 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5144 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5145 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5146 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5147 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5148 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5149 getLLVMStyleWithColumns(60)); 5150 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5151 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5152 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5153 getLLVMStyleWithColumns(59)); 5154 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5155 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5156 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5157 5158 // Dont break if only closing statements before member call 5159 verifyFormat("test() {\n" 5160 " ([]() -> {\n" 5161 " int b = 32;\n" 5162 " return 3;\n" 5163 " }).foo();\n" 5164 "}"); 5165 verifyFormat("test() {\n" 5166 " (\n" 5167 " []() -> {\n" 5168 " int b = 32;\n" 5169 " return 3;\n" 5170 " },\n" 5171 " foo, bar)\n" 5172 " .foo();\n" 5173 "}"); 5174 verifyFormat("test() {\n" 5175 " ([]() -> {\n" 5176 " int b = 32;\n" 5177 " return 3;\n" 5178 " })\n" 5179 " .foo()\n" 5180 " .bar();\n" 5181 "}"); 5182 verifyFormat("test() {\n" 5183 " ([]() -> {\n" 5184 " int b = 32;\n" 5185 " return 3;\n" 5186 " })\n" 5187 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5188 " \"bbbb\");\n" 5189 "}", 5190 getLLVMStyleWithColumns(30)); 5191 } 5192 5193 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5194 verifyFormat( 5195 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5196 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5197 verifyFormat( 5198 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5199 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5200 5201 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5202 " ccccccccccccccccccccccccc) {\n}"); 5203 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5204 " ccccccccccccccccccccccccc) {\n}"); 5205 5206 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5207 " ccccccccccccccccccccccccc) {\n}"); 5208 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5209 " ccccccccccccccccccccccccc) {\n}"); 5210 5211 verifyFormat( 5212 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5213 " ccccccccccccccccccccccccc) {\n}"); 5214 verifyFormat( 5215 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5216 " ccccccccccccccccccccccccc) {\n}"); 5217 5218 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5219 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5220 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5221 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5222 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5223 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5224 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5225 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5226 5227 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5228 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5229 " aaaaaaaaaaaaaaa != aa) {\n}"); 5230 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5231 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5232 " aaaaaaaaaaaaaaa != aa) {\n}"); 5233 } 5234 5235 TEST_F(FormatTest, BreaksAfterAssignments) { 5236 verifyFormat( 5237 "unsigned Cost =\n" 5238 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5239 " SI->getPointerAddressSpaceee());\n"); 5240 verifyFormat( 5241 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5242 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5243 5244 verifyFormat( 5245 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5246 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5247 verifyFormat("unsigned OriginalStartColumn =\n" 5248 " SourceMgr.getSpellingColumnNumber(\n" 5249 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5250 " 1;"); 5251 } 5252 5253 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5254 FormatStyle Style = getLLVMStyle(); 5255 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5256 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5257 Style); 5258 5259 Style.PenaltyBreakAssignment = 20; 5260 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5261 " cccccccccccccccccccccccccc;", 5262 Style); 5263 } 5264 5265 TEST_F(FormatTest, AlignsAfterAssignments) { 5266 verifyFormat( 5267 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5268 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5269 verifyFormat( 5270 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5271 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5272 verifyFormat( 5273 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5274 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5275 verifyFormat( 5276 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5277 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5278 verifyFormat( 5279 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5280 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5281 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5282 } 5283 5284 TEST_F(FormatTest, AlignsAfterReturn) { 5285 verifyFormat( 5286 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5287 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5288 verifyFormat( 5289 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5290 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5291 verifyFormat( 5292 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5293 " aaaaaaaaaaaaaaaaaaaaaa();"); 5294 verifyFormat( 5295 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5296 " aaaaaaaaaaaaaaaaaaaaaa());"); 5297 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5298 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5299 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5300 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5301 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5302 verifyFormat("return\n" 5303 " // true if code is one of a or b.\n" 5304 " code == a || code == b;"); 5305 } 5306 5307 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5308 verifyFormat( 5309 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5310 " aaaaaaaaa aaaaaaa) {}"); 5311 verifyFormat( 5312 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5313 " aaaaaaaaaaa aaaaaaaaa);"); 5314 verifyFormat( 5315 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5316 " aaaaaaaaaaaaaaaaaaaaa));"); 5317 FormatStyle Style = getLLVMStyle(); 5318 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5319 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5320 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5321 Style); 5322 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5323 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5324 Style); 5325 verifyFormat("SomeLongVariableName->someFunction(\n" 5326 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5327 Style); 5328 verifyFormat( 5329 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5330 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5331 Style); 5332 verifyFormat( 5333 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5334 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5335 Style); 5336 verifyFormat( 5337 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5338 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5339 Style); 5340 5341 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5342 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5343 " b));", 5344 Style); 5345 5346 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5347 Style.BinPackArguments = false; 5348 Style.BinPackParameters = false; 5349 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5350 " aaaaaaaaaaa aaaaaaaa,\n" 5351 " aaaaaaaaa aaaaaaa,\n" 5352 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5353 Style); 5354 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5355 " aaaaaaaaaaa aaaaaaaaa,\n" 5356 " aaaaaaaaaaa aaaaaaaaa,\n" 5357 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5358 Style); 5359 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5360 " aaaaaaaaaaaaaaa,\n" 5361 " aaaaaaaaaaaaaaaaaaaaa,\n" 5362 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5363 Style); 5364 verifyFormat( 5365 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5366 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5367 Style); 5368 verifyFormat( 5369 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5370 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5371 Style); 5372 verifyFormat( 5373 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5374 " aaaaaaaaaaaaaaaaaaaaa(\n" 5375 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5376 " aaaaaaaaaaaaaaaa);", 5377 Style); 5378 verifyFormat( 5379 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5380 " aaaaaaaaaaaaaaaaaaaaa(\n" 5381 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5382 " aaaaaaaaaaaaaaaa);", 5383 Style); 5384 } 5385 5386 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5387 FormatStyle Style = getLLVMStyleWithColumns(40); 5388 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5389 " bbbbbbbbbbbbbbbbbbbbbb);", 5390 Style); 5391 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5392 Style.AlignOperands = false; 5393 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5394 " bbbbbbbbbbbbbbbbbbbbbb);", 5395 Style); 5396 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5397 Style.AlignOperands = true; 5398 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5399 " bbbbbbbbbbbbbbbbbbbbbb);", 5400 Style); 5401 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5402 Style.AlignOperands = false; 5403 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5404 " bbbbbbbbbbbbbbbbbbbbbb);", 5405 Style); 5406 } 5407 5408 TEST_F(FormatTest, BreaksConditionalExpressions) { 5409 verifyFormat( 5410 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5411 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5412 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5413 verifyFormat( 5414 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5415 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5416 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5417 verifyFormat( 5418 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5419 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5420 verifyFormat( 5421 "aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5422 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5423 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5424 verifyFormat( 5425 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5426 " : aaaaaaaaaaaaa);"); 5427 verifyFormat( 5428 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5429 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5430 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5431 " aaaaaaaaaaaaa);"); 5432 verifyFormat( 5433 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5434 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5435 " aaaaaaaaaaaaa);"); 5436 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5437 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5438 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5439 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5440 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5441 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5442 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5443 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5444 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5445 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5446 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5447 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5448 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5449 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5450 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5451 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5452 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5453 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5454 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5455 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5456 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5457 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5458 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5459 " : aaaaaaaaaaaaaaaa;"); 5460 verifyFormat( 5461 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5462 " ? aaaaaaaaaaaaaaa\n" 5463 " : aaaaaaaaaaaaaaa;"); 5464 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5465 " aaaaaaaaa\n" 5466 " ? b\n" 5467 " : c);"); 5468 verifyFormat("return aaaa == bbbb\n" 5469 " // comment\n" 5470 " ? aaaa\n" 5471 " : bbbb;"); 5472 verifyFormat("unsigned Indent =\n" 5473 " format(TheLine.First,\n" 5474 " IndentForLevel[TheLine.Level] >= 0\n" 5475 " ? IndentForLevel[TheLine.Level]\n" 5476 " : TheLine * 2,\n" 5477 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5478 getLLVMStyleWithColumns(60)); 5479 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5480 " ? aaaaaaaaaaaaaaa\n" 5481 " : bbbbbbbbbbbbbbb //\n" 5482 " ? ccccccccccccccc\n" 5483 " : ddddddddddddddd;"); 5484 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5485 " ? aaaaaaaaaaaaaaa\n" 5486 " : (bbbbbbbbbbbbbbb //\n" 5487 " ? ccccccccccccccc\n" 5488 " : ddddddddddddddd);"); 5489 verifyFormat( 5490 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5491 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5492 " aaaaaaaaaaaaaaaaaaaaa +\n" 5493 " aaaaaaaaaaaaaaaaaaaaa\n" 5494 " : aaaaaaaaaa;"); 5495 verifyFormat( 5496 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5497 " : aaaaaaaaaaaaaaaaaaaaaa\n" 5498 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5499 5500 FormatStyle NoBinPacking = getLLVMStyle(); 5501 NoBinPacking.BinPackArguments = false; 5502 verifyFormat( 5503 "void f() {\n" 5504 " g(aaa,\n" 5505 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5506 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5507 " ? aaaaaaaaaaaaaaa\n" 5508 " : aaaaaaaaaaaaaaa);\n" 5509 "}", 5510 NoBinPacking); 5511 verifyFormat( 5512 "void f() {\n" 5513 " g(aaa,\n" 5514 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5515 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5516 " ?: aaaaaaaaaaaaaaa);\n" 5517 "}", 5518 NoBinPacking); 5519 5520 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 5521 " // comment.\n" 5522 " ccccccccccccccccccccccccccccccccccccccc\n" 5523 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5524 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 5525 5526 // Assignments in conditional expressions. Apparently not uncommon :-(. 5527 verifyFormat("return a != b\n" 5528 " // comment\n" 5529 " ? a = b\n" 5530 " : a = b;"); 5531 verifyFormat("return a != b\n" 5532 " // comment\n" 5533 " ? a = a != b\n" 5534 " // comment\n" 5535 " ? a = b\n" 5536 " : a\n" 5537 " : a;\n"); 5538 verifyFormat("return a != b\n" 5539 " // comment\n" 5540 " ? a\n" 5541 " : a = a != b\n" 5542 " // comment\n" 5543 " ? a = b\n" 5544 " : a;"); 5545 } 5546 5547 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 5548 FormatStyle Style = getLLVMStyle(); 5549 Style.BreakBeforeTernaryOperators = false; 5550 Style.ColumnLimit = 70; 5551 verifyFormat( 5552 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5553 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5554 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5555 Style); 5556 verifyFormat( 5557 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5558 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5559 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5560 Style); 5561 verifyFormat( 5562 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5563 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5564 Style); 5565 verifyFormat( 5566 "aaaa(aaaaaaaa, aaaaaaaaaa,\n" 5567 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5568 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5569 Style); 5570 verifyFormat( 5571 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 5572 " aaaaaaaaaaaaa);", 5573 Style); 5574 verifyFormat( 5575 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5576 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5577 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5578 " aaaaaaaaaaaaa);", 5579 Style); 5580 verifyFormat( 5581 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5582 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5583 " aaaaaaaaaaaaa);", 5584 Style); 5585 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5586 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5587 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5588 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5589 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5590 Style); 5591 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5592 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5593 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5594 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5595 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5596 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5597 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5598 Style); 5599 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5600 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 5601 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5602 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5603 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5604 Style); 5605 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5606 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5607 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5608 Style); 5609 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5610 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5611 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5612 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5613 Style); 5614 verifyFormat( 5615 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5616 " aaaaaaaaaaaaaaa :\n" 5617 " aaaaaaaaaaaaaaa;", 5618 Style); 5619 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5620 " aaaaaaaaa ?\n" 5621 " b :\n" 5622 " c);", 5623 Style); 5624 verifyFormat("unsigned Indent =\n" 5625 " format(TheLine.First,\n" 5626 " IndentForLevel[TheLine.Level] >= 0 ?\n" 5627 " IndentForLevel[TheLine.Level] :\n" 5628 " TheLine * 2,\n" 5629 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5630 Style); 5631 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5632 " aaaaaaaaaaaaaaa :\n" 5633 " bbbbbbbbbbbbbbb ? //\n" 5634 " ccccccccccccccc :\n" 5635 " ddddddddddddddd;", 5636 Style); 5637 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5638 " aaaaaaaaaaaaaaa :\n" 5639 " (bbbbbbbbbbbbbbb ? //\n" 5640 " ccccccccccccccc :\n" 5641 " ddddddddddddddd);", 5642 Style); 5643 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5644 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 5645 " ccccccccccccccccccccccccccc;", 5646 Style); 5647 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5648 " aaaaa :\n" 5649 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 5650 Style); 5651 } 5652 5653 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 5654 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 5655 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 5656 verifyFormat("bool a = true, b = false;"); 5657 5658 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5659 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 5660 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 5661 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 5662 verifyFormat( 5663 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 5664 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 5665 " d = e && f;"); 5666 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 5667 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 5668 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5669 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 5670 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 5671 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 5672 5673 FormatStyle Style = getGoogleStyle(); 5674 Style.PointerAlignment = FormatStyle::PAS_Left; 5675 Style.DerivePointerAlignment = false; 5676 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5677 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 5678 " *b = bbbbbbbbbbbbbbbbbbb;", 5679 Style); 5680 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5681 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 5682 Style); 5683 verifyFormat("vector<int*> a, b;", Style); 5684 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 5685 } 5686 5687 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 5688 verifyFormat("arr[foo ? bar : baz];"); 5689 verifyFormat("f()[foo ? bar : baz];"); 5690 verifyFormat("(a + b)[foo ? bar : baz];"); 5691 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 5692 } 5693 5694 TEST_F(FormatTest, AlignsStringLiterals) { 5695 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 5696 " \"short literal\");"); 5697 verifyFormat( 5698 "looooooooooooooooooooooooongFunction(\n" 5699 " \"short literal\"\n" 5700 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 5701 verifyFormat("someFunction(\"Always break between multi-line\"\n" 5702 " \" string literals\",\n" 5703 " and, other, parameters);"); 5704 EXPECT_EQ("fun + \"1243\" /* comment */\n" 5705 " \"5678\";", 5706 format("fun + \"1243\" /* comment */\n" 5707 " \"5678\";", 5708 getLLVMStyleWithColumns(28))); 5709 EXPECT_EQ( 5710 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 5711 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 5712 " \"aaaaaaaaaaaaaaaa\";", 5713 format("aaaaaa =" 5714 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 5715 "aaaaaaaaaaaaaaaaaaaaa\" " 5716 "\"aaaaaaaaaaaaaaaa\";")); 5717 verifyFormat("a = a + \"a\"\n" 5718 " \"a\"\n" 5719 " \"a\";"); 5720 verifyFormat("f(\"a\", \"b\"\n" 5721 " \"c\");"); 5722 5723 verifyFormat( 5724 "#define LL_FORMAT \"ll\"\n" 5725 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 5726 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 5727 5728 verifyFormat("#define A(X) \\\n" 5729 " \"aaaaa\" #X \"bbbbbb\" \\\n" 5730 " \"ccccc\"", 5731 getLLVMStyleWithColumns(23)); 5732 verifyFormat("#define A \"def\"\n" 5733 "f(\"abc\" A \"ghi\"\n" 5734 " \"jkl\");"); 5735 5736 verifyFormat("f(L\"a\"\n" 5737 " L\"b\");"); 5738 verifyFormat("#define A(X) \\\n" 5739 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 5740 " L\"ccccc\"", 5741 getLLVMStyleWithColumns(25)); 5742 5743 verifyFormat("f(@\"a\"\n" 5744 " @\"b\");"); 5745 verifyFormat("NSString s = @\"a\"\n" 5746 " @\"b\"\n" 5747 " @\"c\";"); 5748 verifyFormat("NSString s = @\"a\"\n" 5749 " \"b\"\n" 5750 " \"c\";"); 5751 } 5752 5753 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 5754 FormatStyle Style = getLLVMStyle(); 5755 // No declarations or definitions should be moved to own line. 5756 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 5757 verifyFormat("class A {\n" 5758 " int f() { return 1; }\n" 5759 " int g();\n" 5760 "};\n" 5761 "int f() { return 1; }\n" 5762 "int g();\n", 5763 Style); 5764 5765 // All declarations and definitions should have the return type moved to its 5766 // own 5767 // line. 5768 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 5769 verifyFormat("class E {\n" 5770 " int\n" 5771 " f() {\n" 5772 " return 1;\n" 5773 " }\n" 5774 " int\n" 5775 " g();\n" 5776 "};\n" 5777 "int\n" 5778 "f() {\n" 5779 " return 1;\n" 5780 "}\n" 5781 "int\n" 5782 "g();\n", 5783 Style); 5784 5785 // Top-level definitions, and no kinds of declarations should have the 5786 // return type moved to its own line. 5787 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 5788 verifyFormat("class B {\n" 5789 " int f() { return 1; }\n" 5790 " int g();\n" 5791 "};\n" 5792 "int\n" 5793 "f() {\n" 5794 " return 1;\n" 5795 "}\n" 5796 "int g();\n", 5797 Style); 5798 5799 // Top-level definitions and declarations should have the return type moved 5800 // to its own line. 5801 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 5802 verifyFormat("class C {\n" 5803 " int f() { return 1; }\n" 5804 " int g();\n" 5805 "};\n" 5806 "int\n" 5807 "f() {\n" 5808 " return 1;\n" 5809 "}\n" 5810 "int\n" 5811 "g();\n", 5812 Style); 5813 5814 // All definitions should have the return type moved to its own line, but no 5815 // kinds of declarations. 5816 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 5817 verifyFormat("class D {\n" 5818 " int\n" 5819 " f() {\n" 5820 " return 1;\n" 5821 " }\n" 5822 " int g();\n" 5823 "};\n" 5824 "int\n" 5825 "f() {\n" 5826 " return 1;\n" 5827 "}\n" 5828 "int g();\n", 5829 Style); 5830 verifyFormat("const char *\n" 5831 "f(void) {\n" // Break here. 5832 " return \"\";\n" 5833 "}\n" 5834 "const char *bar(void);\n", // No break here. 5835 Style); 5836 verifyFormat("template <class T>\n" 5837 "T *\n" 5838 "f(T &c) {\n" // Break here. 5839 " return NULL;\n" 5840 "}\n" 5841 "template <class T> T *f(T &c);\n", // No break here. 5842 Style); 5843 verifyFormat("class C {\n" 5844 " int\n" 5845 " operator+() {\n" 5846 " return 1;\n" 5847 " }\n" 5848 " int\n" 5849 " operator()() {\n" 5850 " return 1;\n" 5851 " }\n" 5852 "};\n", 5853 Style); 5854 verifyFormat("void\n" 5855 "A::operator()() {}\n" 5856 "void\n" 5857 "A::operator>>() {}\n" 5858 "void\n" 5859 "A::operator+() {}\n", 5860 Style); 5861 verifyFormat("void *operator new(std::size_t s);", // No break here. 5862 Style); 5863 verifyFormat("void *\n" 5864 "operator new(std::size_t s) {}", 5865 Style); 5866 verifyFormat("void *\n" 5867 "operator delete[](void *ptr) {}", 5868 Style); 5869 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 5870 verifyFormat("const char *\n" 5871 "f(void)\n" // Break here. 5872 "{\n" 5873 " return \"\";\n" 5874 "}\n" 5875 "const char *bar(void);\n", // No break here. 5876 Style); 5877 verifyFormat("template <class T>\n" 5878 "T *\n" // Problem here: no line break 5879 "f(T &c)\n" // Break here. 5880 "{\n" 5881 " return NULL;\n" 5882 "}\n" 5883 "template <class T> T *f(T &c);\n", // No break here. 5884 Style); 5885 verifyFormat("int\n" 5886 "foo(A<bool> a)\n" 5887 "{\n" 5888 " return a;\n" 5889 "}\n", 5890 Style); 5891 verifyFormat("int\n" 5892 "foo(A<8> a)\n" 5893 "{\n" 5894 " return a;\n" 5895 "}\n", 5896 Style); 5897 verifyFormat("int\n" 5898 "foo(A<B<bool>, 8> a)\n" 5899 "{\n" 5900 " return a;\n" 5901 "}\n", 5902 Style); 5903 verifyFormat("int\n" 5904 "foo(A<B<8>, bool> a)\n" 5905 "{\n" 5906 " return a;\n" 5907 "}\n", 5908 Style); 5909 verifyFormat("int\n" 5910 "foo(A<B<bool>, bool> a)\n" 5911 "{\n" 5912 " return a;\n" 5913 "}\n", 5914 Style); 5915 verifyFormat("int\n" 5916 "foo(A<B<8>, 8> a)\n" 5917 "{\n" 5918 " return a;\n" 5919 "}\n", 5920 Style); 5921 5922 Style = getGNUStyle(); 5923 5924 // Test for comments at the end of function declarations. 5925 verifyFormat("void\n" 5926 "foo (int a, /*abc*/ int b) // def\n" 5927 "{\n" 5928 "}\n", 5929 Style); 5930 5931 verifyFormat("void\n" 5932 "foo (int a, /* abc */ int b) /* def */\n" 5933 "{\n" 5934 "}\n", 5935 Style); 5936 5937 // Definitions that should not break after return type 5938 verifyFormat("void foo (int a, int b); // def\n", Style); 5939 verifyFormat("void foo (int a, int b); /* def */\n", Style); 5940 verifyFormat("void foo (int a, int b);\n", Style); 5941 } 5942 5943 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 5944 FormatStyle NoBreak = getLLVMStyle(); 5945 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 5946 FormatStyle Break = getLLVMStyle(); 5947 Break.AlwaysBreakBeforeMultilineStrings = true; 5948 verifyFormat("aaaa = \"bbbb\"\n" 5949 " \"cccc\";", 5950 NoBreak); 5951 verifyFormat("aaaa =\n" 5952 " \"bbbb\"\n" 5953 " \"cccc\";", 5954 Break); 5955 verifyFormat("aaaa(\"bbbb\"\n" 5956 " \"cccc\");", 5957 NoBreak); 5958 verifyFormat("aaaa(\n" 5959 " \"bbbb\"\n" 5960 " \"cccc\");", 5961 Break); 5962 verifyFormat("aaaa(qqq, \"bbbb\"\n" 5963 " \"cccc\");", 5964 NoBreak); 5965 verifyFormat("aaaa(qqq,\n" 5966 " \"bbbb\"\n" 5967 " \"cccc\");", 5968 Break); 5969 verifyFormat("aaaa(qqq,\n" 5970 " L\"bbbb\"\n" 5971 " L\"cccc\");", 5972 Break); 5973 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 5974 " \"bbbb\"));", 5975 Break); 5976 verifyFormat("string s = someFunction(\n" 5977 " \"abc\"\n" 5978 " \"abc\");", 5979 Break); 5980 5981 // As we break before unary operators, breaking right after them is bad. 5982 verifyFormat("string foo = abc ? \"x\"\n" 5983 " \"blah blah blah blah blah blah\"\n" 5984 " : \"y\";", 5985 Break); 5986 5987 // Don't break if there is no column gain. 5988 verifyFormat("f(\"aaaa\"\n" 5989 " \"bbbb\");", 5990 Break); 5991 5992 // Treat literals with escaped newlines like multi-line string literals. 5993 EXPECT_EQ("x = \"a\\\n" 5994 "b\\\n" 5995 "c\";", 5996 format("x = \"a\\\n" 5997 "b\\\n" 5998 "c\";", 5999 NoBreak)); 6000 EXPECT_EQ("xxxx =\n" 6001 " \"a\\\n" 6002 "b\\\n" 6003 "c\";", 6004 format("xxxx = \"a\\\n" 6005 "b\\\n" 6006 "c\";", 6007 Break)); 6008 6009 EXPECT_EQ("NSString *const kString =\n" 6010 " @\"aaaa\"\n" 6011 " @\"bbbb\";", 6012 format("NSString *const kString = @\"aaaa\"\n" 6013 "@\"bbbb\";", 6014 Break)); 6015 6016 Break.ColumnLimit = 0; 6017 verifyFormat("const char *hello = \"hello llvm\";", Break); 6018 } 6019 6020 TEST_F(FormatTest, AlignsPipes) { 6021 verifyFormat( 6022 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6023 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6024 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6025 verifyFormat( 6026 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 6027 " << aaaaaaaaaaaaaaaaaaaa;"); 6028 verifyFormat( 6029 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6030 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6031 verifyFormat( 6032 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 6033 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6034 verifyFormat( 6035 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 6036 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 6037 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 6038 verifyFormat( 6039 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6040 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6041 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6042 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6043 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6044 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6045 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6046 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 6047 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 6048 verifyFormat( 6049 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6050 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6051 verifyFormat( 6052 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 6053 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6054 6055 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 6056 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 6057 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6058 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6059 " aaaaaaaaaaaaaaaaaaaaa)\n" 6060 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6061 verifyFormat("LOG_IF(aaa == //\n" 6062 " bbb)\n" 6063 " << a << b;"); 6064 6065 // But sometimes, breaking before the first "<<" is desirable. 6066 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6067 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 6068 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 6069 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6070 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6071 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 6072 " << BEF << IsTemplate << Description << E->getType();"); 6073 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6074 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6075 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6076 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6077 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6078 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6079 " << aaa;"); 6080 6081 verifyFormat( 6082 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6083 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6084 6085 // Incomplete string literal. 6086 EXPECT_EQ("llvm::errs() << \"\n" 6087 " << a;", 6088 format("llvm::errs() << \"\n<<a;")); 6089 6090 verifyFormat("void f() {\n" 6091 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 6092 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 6093 "}"); 6094 6095 // Handle 'endl'. 6096 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 6097 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6098 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6099 6100 // Handle '\n'. 6101 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 6102 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6103 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 6104 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 6105 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 6106 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 6107 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6108 } 6109 6110 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 6111 verifyFormat("return out << \"somepacket = {\\n\"\n" 6112 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 6113 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 6114 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 6115 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 6116 " << \"}\";"); 6117 6118 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6119 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6120 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 6121 verifyFormat( 6122 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 6123 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 6124 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 6125 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 6126 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 6127 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 6128 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6129 verifyFormat( 6130 "void f() {\n" 6131 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 6132 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 6133 "}"); 6134 6135 // Breaking before the first "<<" is generally not desirable. 6136 verifyFormat( 6137 "llvm::errs()\n" 6138 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6139 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6140 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6141 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6142 getLLVMStyleWithColumns(70)); 6143 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6144 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6145 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6146 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6147 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6148 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6149 getLLVMStyleWithColumns(70)); 6150 6151 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6152 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6153 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6154 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6155 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6156 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 6157 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 6158 " (aaaa + aaaa);", 6159 getLLVMStyleWithColumns(40)); 6160 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 6161 " (aaaaaaa + aaaaa));", 6162 getLLVMStyleWithColumns(40)); 6163 verifyFormat( 6164 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 6165 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 6166 " bbbbbbbbbbbbbbbbbbbbbbb);"); 6167 } 6168 6169 TEST_F(FormatTest, UnderstandsEquals) { 6170 verifyFormat( 6171 "aaaaaaaaaaaaaaaaa =\n" 6172 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6173 verifyFormat( 6174 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6175 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6176 verifyFormat( 6177 "if (a) {\n" 6178 " f();\n" 6179 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6180 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 6181 "}"); 6182 6183 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6184 " 100000000 + 10000000) {\n}"); 6185 } 6186 6187 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 6188 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6189 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 6190 6191 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6192 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 6193 6194 verifyFormat( 6195 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 6196 " Parameter2);"); 6197 6198 verifyFormat( 6199 "ShortObject->shortFunction(\n" 6200 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 6201 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 6202 6203 verifyFormat("loooooooooooooongFunction(\n" 6204 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 6205 6206 verifyFormat( 6207 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 6208 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 6209 6210 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6211 " .WillRepeatedly(Return(SomeValue));"); 6212 verifyFormat("void f() {\n" 6213 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6214 " .Times(2)\n" 6215 " .WillRepeatedly(Return(SomeValue));\n" 6216 "}"); 6217 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 6218 " ccccccccccccccccccccccc);"); 6219 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6220 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6221 " .aaaaa(aaaaa),\n" 6222 " aaaaaaaaaaaaaaaaaaaaa);"); 6223 verifyFormat("void f() {\n" 6224 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6225 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 6226 "}"); 6227 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6228 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6229 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6230 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6231 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6232 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6233 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6234 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6235 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 6236 "}"); 6237 6238 // Here, it is not necessary to wrap at "." or "->". 6239 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 6240 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6241 verifyFormat( 6242 "aaaaaaaaaaa->aaaaaaaaa(\n" 6243 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6244 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 6245 6246 verifyFormat( 6247 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6248 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 6249 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 6250 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6251 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 6252 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6253 6254 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6255 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6256 " .a();"); 6257 6258 FormatStyle NoBinPacking = getLLVMStyle(); 6259 NoBinPacking.BinPackParameters = false; 6260 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6261 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6262 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 6263 " aaaaaaaaaaaaaaaaaaa,\n" 6264 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6265 NoBinPacking); 6266 6267 // If there is a subsequent call, change to hanging indentation. 6268 verifyFormat( 6269 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6270 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 6271 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6272 verifyFormat( 6273 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6274 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 6275 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6276 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6277 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6278 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6279 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6280 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6281 } 6282 6283 TEST_F(FormatTest, WrapsTemplateDeclarations) { 6284 verifyFormat("template <typename T>\n" 6285 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6286 verifyFormat("template <typename T>\n" 6287 "// T should be one of {A, B}.\n" 6288 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6289 verifyFormat( 6290 "template <typename T>\n" 6291 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 6292 verifyFormat("template <typename T>\n" 6293 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 6294 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 6295 verifyFormat( 6296 "template <typename T>\n" 6297 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 6298 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 6299 verifyFormat( 6300 "template <typename T>\n" 6301 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 6302 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 6303 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6304 verifyFormat("template <typename T>\n" 6305 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6306 " int aaaaaaaaaaaaaaaaaaaaaa);"); 6307 verifyFormat( 6308 "template <typename T1, typename T2 = char, typename T3 = char,\n" 6309 " typename T4 = char>\n" 6310 "void f();"); 6311 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 6312 " template <typename> class cccccccccccccccccccccc,\n" 6313 " typename ddddddddddddd>\n" 6314 "class C {};"); 6315 verifyFormat( 6316 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 6317 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6318 6319 verifyFormat("void f() {\n" 6320 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 6321 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 6322 "}"); 6323 6324 verifyFormat("template <typename T> class C {};"); 6325 verifyFormat("template <typename T> void f();"); 6326 verifyFormat("template <typename T> void f() {}"); 6327 verifyFormat( 6328 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6329 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6330 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 6331 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6332 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6333 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 6334 " bbbbbbbbbbbbbbbbbbbbbbbb);", 6335 getLLVMStyleWithColumns(72)); 6336 EXPECT_EQ("static_cast<A< //\n" 6337 " B> *>(\n" 6338 "\n" 6339 ");", 6340 format("static_cast<A<//\n" 6341 " B>*>(\n" 6342 "\n" 6343 " );")); 6344 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6345 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 6346 6347 FormatStyle AlwaysBreak = getLLVMStyle(); 6348 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 6349 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 6350 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 6351 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 6352 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6353 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6354 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 6355 verifyFormat("template <template <typename> class Fooooooo,\n" 6356 " template <typename> class Baaaaaaar>\n" 6357 "struct C {};", 6358 AlwaysBreak); 6359 verifyFormat("template <typename T> // T can be A, B or C.\n" 6360 "struct C {};", 6361 AlwaysBreak); 6362 verifyFormat("template <enum E> class A {\n" 6363 "public:\n" 6364 " E *f();\n" 6365 "};"); 6366 6367 FormatStyle NeverBreak = getLLVMStyle(); 6368 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 6369 verifyFormat("template <typename T> class C {};", NeverBreak); 6370 verifyFormat("template <typename T> void f();", NeverBreak); 6371 verifyFormat("template <typename T> void f() {}", NeverBreak); 6372 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbb) {}", 6373 NeverBreak); 6374 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6375 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6376 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 6377 NeverBreak); 6378 verifyFormat("template <template <typename> class Fooooooo,\n" 6379 " template <typename> class Baaaaaaar>\n" 6380 "struct C {};", 6381 NeverBreak); 6382 verifyFormat("template <typename T> // T can be A, B or C.\n" 6383 "struct C {};", 6384 NeverBreak); 6385 verifyFormat("template <enum E> class A {\n" 6386 "public:\n" 6387 " E *f();\n" 6388 "};", NeverBreak); 6389 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 6390 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbb) {}", 6391 NeverBreak); 6392 } 6393 6394 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 6395 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 6396 Style.ColumnLimit = 60; 6397 EXPECT_EQ("// Baseline - no comments.\n" 6398 "template <\n" 6399 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6400 "void f() {}", 6401 format("// Baseline - no comments.\n" 6402 "template <\n" 6403 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6404 "void f() {}", 6405 Style)); 6406 6407 EXPECT_EQ("template <\n" 6408 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6409 "void f() {}", 6410 format("template <\n" 6411 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6412 "void f() {}", 6413 Style)); 6414 6415 EXPECT_EQ( 6416 "template <\n" 6417 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6418 "void f() {}", 6419 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6420 "void f() {}", 6421 Style)); 6422 6423 EXPECT_EQ( 6424 "template <\n" 6425 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6426 " // multiline\n" 6427 "void f() {}", 6428 format("template <\n" 6429 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6430 " // multiline\n" 6431 "void f() {}", 6432 Style)); 6433 6434 EXPECT_EQ( 6435 "template <typename aaaaaaaaaa<\n" 6436 " bbbbbbbbbbbb>::value> // trailing loooong\n" 6437 "void f() {}", 6438 format( 6439 "template <\n" 6440 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 6441 "void f() {}", 6442 Style)); 6443 } 6444 6445 TEST_F(FormatTest, WrapsTemplateParameters) { 6446 FormatStyle Style = getLLVMStyle(); 6447 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6448 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6449 verifyFormat( 6450 "template <typename... a> struct q {};\n" 6451 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6452 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6453 " y;", 6454 Style); 6455 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6456 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6457 verifyFormat( 6458 "template <typename... a> struct r {};\n" 6459 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6460 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6461 " y;", 6462 Style); 6463 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6464 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6465 verifyFormat( 6466 "template <typename... a> struct s {};\n" 6467 "extern s<\n" 6468 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 6469 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n" 6470 " y;", 6471 Style); 6472 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6473 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6474 verifyFormat( 6475 "template <typename... a> struct t {};\n" 6476 "extern t<\n" 6477 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 6478 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n" 6479 " y;", 6480 Style); 6481 } 6482 6483 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 6484 verifyFormat( 6485 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6486 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6487 verifyFormat( 6488 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6489 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6490 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6491 6492 // FIXME: Should we have the extra indent after the second break? 6493 verifyFormat( 6494 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6495 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6496 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6497 6498 verifyFormat( 6499 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 6500 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 6501 6502 // Breaking at nested name specifiers is generally not desirable. 6503 verifyFormat( 6504 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6505 " aaaaaaaaaaaaaaaaaaaaaaa);"); 6506 6507 verifyFormat( 6508 "aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 6509 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6510 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6511 " aaaaaaaaaaaaaaaaaaaaa);", 6512 getLLVMStyleWithColumns(74)); 6513 6514 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6515 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6516 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6517 } 6518 6519 TEST_F(FormatTest, UnderstandsTemplateParameters) { 6520 verifyFormat("A<int> a;"); 6521 verifyFormat("A<A<A<int>>> a;"); 6522 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 6523 verifyFormat("bool x = a < 1 || 2 > a;"); 6524 verifyFormat("bool x = 5 < f<int>();"); 6525 verifyFormat("bool x = f<int>() > 5;"); 6526 verifyFormat("bool x = 5 < a<int>::x;"); 6527 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 6528 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 6529 6530 verifyGoogleFormat("A<A<int>> a;"); 6531 verifyGoogleFormat("A<A<A<int>>> a;"); 6532 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 6533 verifyGoogleFormat("A<A<int> > a;"); 6534 verifyGoogleFormat("A<A<A<int> > > a;"); 6535 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 6536 verifyGoogleFormat("A<::A<int>> a;"); 6537 verifyGoogleFormat("A<::A> a;"); 6538 verifyGoogleFormat("A< ::A> a;"); 6539 verifyGoogleFormat("A< ::A<int> > a;"); 6540 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 6541 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 6542 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 6543 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 6544 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 6545 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 6546 6547 verifyFormat("A<A>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 6548 6549 verifyFormat("test >> a >> b;"); 6550 verifyFormat("test << a >> b;"); 6551 6552 verifyFormat("f<int>();"); 6553 verifyFormat("template <typename T> void f() {}"); 6554 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 6555 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 6556 "sizeof(char)>::type>;"); 6557 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 6558 verifyFormat("f(a.operator()<A>());"); 6559 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6560 " .template operator()<A>());", 6561 getLLVMStyleWithColumns(35)); 6562 6563 // Not template parameters. 6564 verifyFormat("return a < b && c > d;"); 6565 verifyFormat("void f() {\n" 6566 " while (a < b && c > d) {\n" 6567 " }\n" 6568 "}"); 6569 verifyFormat("template <typename... Types>\n" 6570 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 6571 6572 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6573 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 6574 getLLVMStyleWithColumns(60)); 6575 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 6576 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 6577 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 6578 } 6579 6580 TEST_F(FormatTest, BitshiftOperatorWidth) { 6581 EXPECT_EQ("int a = 1 << 2; /* foo\n" 6582 " bar */", 6583 format("int a=1<<2; /* foo\n" 6584 " bar */")); 6585 6586 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 6587 " bar */", 6588 format("int b =256>>1 ; /* foo\n" 6589 " bar */")); 6590 } 6591 6592 TEST_F(FormatTest, UnderstandsBinaryOperators) { 6593 verifyFormat("COMPARE(a, ==, b);"); 6594 verifyFormat("auto s = sizeof...(Ts) - 1;"); 6595 } 6596 6597 TEST_F(FormatTest, UnderstandsPointersToMembers) { 6598 verifyFormat("int A::*x;"); 6599 verifyFormat("int (S::*func)(void *);"); 6600 verifyFormat("void f() { int (S::*func)(void *); }"); 6601 verifyFormat("typedef bool *(Class::*Member)() const;"); 6602 verifyFormat("void f() {\n" 6603 " (a->*f)();\n" 6604 " a->*x;\n" 6605 " (a.*f)();\n" 6606 " ((*a).*f)();\n" 6607 " a.*x;\n" 6608 "}"); 6609 verifyFormat("void f() {\n" 6610 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 6611 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 6612 "}"); 6613 verifyFormat( 6614 "(aaaaaaaaaa->*bbbbbbb)(\n" 6615 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6616 FormatStyle Style = getLLVMStyle(); 6617 Style.PointerAlignment = FormatStyle::PAS_Left; 6618 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 6619 } 6620 6621 TEST_F(FormatTest, UnderstandsUnaryOperators) { 6622 verifyFormat("int a = -2;"); 6623 verifyFormat("f(-1, -2, -3);"); 6624 verifyFormat("a[-1] = 5;"); 6625 verifyFormat("int a = 5 + -2;"); 6626 verifyFormat("if (i == -1) {\n}"); 6627 verifyFormat("if (i != -1) {\n}"); 6628 verifyFormat("if (i > -1) {\n}"); 6629 verifyFormat("if (i < -1) {\n}"); 6630 verifyFormat("++(a->f());"); 6631 verifyFormat("--(a->f());"); 6632 verifyFormat("(a->f())++;"); 6633 verifyFormat("a[42]++;"); 6634 verifyFormat("if (!(a->f())) {\n}"); 6635 verifyFormat("if (!+i) {\n}"); 6636 verifyFormat("~&a;"); 6637 6638 verifyFormat("a-- > b;"); 6639 verifyFormat("b ? -a : c;"); 6640 verifyFormat("n * sizeof char16;"); 6641 verifyFormat("n * alignof char16;", getGoogleStyle()); 6642 verifyFormat("sizeof(char);"); 6643 verifyFormat("alignof(char);", getGoogleStyle()); 6644 6645 verifyFormat("return -1;"); 6646 verifyFormat("switch (a) {\n" 6647 "case -1:\n" 6648 " break;\n" 6649 "}"); 6650 verifyFormat("#define X -1"); 6651 verifyFormat("#define X -kConstant"); 6652 6653 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 6654 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 6655 6656 verifyFormat("int a = /* confusing comment */ -1;"); 6657 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 6658 verifyFormat("int a = i /* confusing comment */++;"); 6659 } 6660 6661 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 6662 verifyFormat("if (!aaaaaaaaaa( // break\n" 6663 " aaaaa)) {\n" 6664 "}"); 6665 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 6666 " aaaaa));"); 6667 verifyFormat("*aaa = aaaaaaa( // break\n" 6668 " bbbbbb);"); 6669 } 6670 6671 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 6672 verifyFormat("bool operator<();"); 6673 verifyFormat("bool operator>();"); 6674 verifyFormat("bool operator=();"); 6675 verifyFormat("bool operator==();"); 6676 verifyFormat("bool operator!=();"); 6677 verifyFormat("int operator+();"); 6678 verifyFormat("int operator++();"); 6679 verifyFormat("int operator++(int) volatile noexcept;"); 6680 verifyFormat("bool operator,();"); 6681 verifyFormat("bool operator();"); 6682 verifyFormat("bool operator()();"); 6683 verifyFormat("bool operator[]();"); 6684 verifyFormat("operator bool();"); 6685 verifyFormat("operator int();"); 6686 verifyFormat("operator void *();"); 6687 verifyFormat("operator SomeType<int>();"); 6688 verifyFormat("operator SomeType<int, int>();"); 6689 verifyFormat("operator SomeType<SomeType<int>>();"); 6690 verifyFormat("void *operator new(std::size_t size);"); 6691 verifyFormat("void *operator new[](std::size_t size);"); 6692 verifyFormat("void operator delete(void *ptr);"); 6693 verifyFormat("void operator delete[](void *ptr);"); 6694 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 6695 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 6696 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 6697 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 6698 6699 verifyFormat( 6700 "ostream &operator<<(ostream &OutputStream,\n" 6701 " SomeReallyLongType WithSomeReallyLongValue);"); 6702 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 6703 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 6704 " return left.group < right.group;\n" 6705 "}"); 6706 verifyFormat("SomeType &operator=(const SomeType &S);"); 6707 verifyFormat("f.template operator()<int>();"); 6708 6709 verifyGoogleFormat("operator void*();"); 6710 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 6711 verifyGoogleFormat("operator ::A();"); 6712 6713 verifyFormat("using A::operator+;"); 6714 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 6715 "int i;"); 6716 } 6717 6718 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 6719 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 6720 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 6721 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 6722 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 6723 verifyFormat("Deleted &operator=(const Deleted &) &;"); 6724 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 6725 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 6726 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 6727 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 6728 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 6729 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 6730 verifyFormat("void Fn(T const &) const &;"); 6731 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 6732 verifyFormat("template <typename T>\n" 6733 "void F(T) && = delete;", 6734 getGoogleStyle()); 6735 6736 FormatStyle AlignLeft = getLLVMStyle(); 6737 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 6738 verifyFormat("void A::b() && {}", AlignLeft); 6739 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 6740 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 6741 AlignLeft); 6742 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 6743 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 6744 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 6745 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 6746 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 6747 verifyFormat("auto Function(T) & -> void;", AlignLeft); 6748 verifyFormat("void Fn(T const&) const&;", AlignLeft); 6749 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 6750 6751 FormatStyle Spaces = getLLVMStyle(); 6752 Spaces.SpacesInCStyleCastParentheses = true; 6753 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 6754 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 6755 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 6756 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 6757 6758 Spaces.SpacesInCStyleCastParentheses = false; 6759 Spaces.SpacesInParentheses = true; 6760 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 6761 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", Spaces); 6762 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 6763 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 6764 } 6765 6766 TEST_F(FormatTest, UnderstandsNewAndDelete) { 6767 verifyFormat("void f() {\n" 6768 " A *a = new A;\n" 6769 " A *a = new (placement) A;\n" 6770 " delete a;\n" 6771 " delete (A *)a;\n" 6772 "}"); 6773 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 6774 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 6775 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6776 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 6777 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 6778 verifyFormat("delete[] h->p;"); 6779 } 6780 6781 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 6782 verifyFormat("int *f(int *a) {}"); 6783 verifyFormat("int main(int argc, char **argv) {}"); 6784 verifyFormat("Test::Test(int b) : a(b * b) {}"); 6785 verifyIndependentOfContext("f(a, *a);"); 6786 verifyFormat("void g() { f(*a); }"); 6787 verifyIndependentOfContext("int a = b * 10;"); 6788 verifyIndependentOfContext("int a = 10 * b;"); 6789 verifyIndependentOfContext("int a = b * c;"); 6790 verifyIndependentOfContext("int a += b * c;"); 6791 verifyIndependentOfContext("int a -= b * c;"); 6792 verifyIndependentOfContext("int a *= b * c;"); 6793 verifyIndependentOfContext("int a /= b * c;"); 6794 verifyIndependentOfContext("int a = *b;"); 6795 verifyIndependentOfContext("int a = *b * c;"); 6796 verifyIndependentOfContext("int a = b * *c;"); 6797 verifyIndependentOfContext("int a = b * (10);"); 6798 verifyIndependentOfContext("S << b * (10);"); 6799 verifyIndependentOfContext("return 10 * b;"); 6800 verifyIndependentOfContext("return *b * *c;"); 6801 verifyIndependentOfContext("return a & ~b;"); 6802 verifyIndependentOfContext("f(b ? *c : *d);"); 6803 verifyIndependentOfContext("int a = b ? *c : *d;"); 6804 verifyIndependentOfContext("*b = a;"); 6805 verifyIndependentOfContext("a * ~b;"); 6806 verifyIndependentOfContext("a * !b;"); 6807 verifyIndependentOfContext("a * +b;"); 6808 verifyIndependentOfContext("a * -b;"); 6809 verifyIndependentOfContext("a * ++b;"); 6810 verifyIndependentOfContext("a * --b;"); 6811 verifyIndependentOfContext("a[4] * b;"); 6812 verifyIndependentOfContext("a[a * a] = 1;"); 6813 verifyIndependentOfContext("f() * b;"); 6814 verifyIndependentOfContext("a * [self dostuff];"); 6815 verifyIndependentOfContext("int x = a * (a + b);"); 6816 verifyIndependentOfContext("(a *)(a + b);"); 6817 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 6818 verifyIndependentOfContext("int *pa = (int *)&a;"); 6819 verifyIndependentOfContext("return sizeof(int **);"); 6820 verifyIndependentOfContext("return sizeof(int ******);"); 6821 verifyIndependentOfContext("return (int **&)a;"); 6822 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 6823 verifyFormat("void f(Type (*parameter)[10]) {}"); 6824 verifyFormat("void f(Type (¶meter)[10]) {}"); 6825 verifyGoogleFormat("return sizeof(int**);"); 6826 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 6827 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 6828 verifyFormat("auto a = [](int **&, int ***) {};"); 6829 verifyFormat("auto PointerBinding = [](const char *S) {};"); 6830 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 6831 verifyFormat("[](const decltype(*a) &value) {}"); 6832 verifyFormat("decltype(a * b) F();"); 6833 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 6834 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 6835 verifyIndependentOfContext("typedef void (*f)(int *a);"); 6836 verifyIndependentOfContext("int i{a * b};"); 6837 verifyIndependentOfContext("aaa && aaa->f();"); 6838 verifyIndependentOfContext("int x = ~*p;"); 6839 verifyFormat("Constructor() : a(a), area(width * height) {}"); 6840 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 6841 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 6842 verifyFormat("void f() { f(a, c * d); }"); 6843 verifyFormat("void f() { f(new a(), c * d); }"); 6844 verifyFormat("void f(const MyOverride &override);"); 6845 verifyFormat("void f(const MyFinal &final);"); 6846 verifyIndependentOfContext("bool a = f() && override.f();"); 6847 verifyIndependentOfContext("bool a = f() && final.f();"); 6848 6849 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 6850 6851 verifyIndependentOfContext("A<int *> a;"); 6852 verifyIndependentOfContext("A<int **> a;"); 6853 verifyIndependentOfContext("A<int *, int *> a;"); 6854 verifyIndependentOfContext("A<int *[]> a;"); 6855 verifyIndependentOfContext( 6856 "const char *const p = reinterpret_cast<const char *const>(q);"); 6857 verifyIndependentOfContext("A<int **, int **> a;"); 6858 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 6859 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 6860 verifyFormat("for (; a && b;) {\n}"); 6861 verifyFormat("bool foo = true && [] { return false; }();"); 6862 6863 verifyFormat( 6864 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6865 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6866 6867 verifyGoogleFormat("int const* a = &b;"); 6868 verifyGoogleFormat("**outparam = 1;"); 6869 verifyGoogleFormat("*outparam = a * b;"); 6870 verifyGoogleFormat("int main(int argc, char** argv) {}"); 6871 verifyGoogleFormat("A<int*> a;"); 6872 verifyGoogleFormat("A<int**> a;"); 6873 verifyGoogleFormat("A<int*, int*> a;"); 6874 verifyGoogleFormat("A<int**, int**> a;"); 6875 verifyGoogleFormat("f(b ? *c : *d);"); 6876 verifyGoogleFormat("int a = b ? *c : *d;"); 6877 verifyGoogleFormat("Type* t = **x;"); 6878 verifyGoogleFormat("Type* t = *++*x;"); 6879 verifyGoogleFormat("*++*x;"); 6880 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 6881 verifyGoogleFormat("Type* t = x++ * y;"); 6882 verifyGoogleFormat( 6883 "const char* const p = reinterpret_cast<const char* const>(q);"); 6884 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 6885 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 6886 verifyGoogleFormat("template <typename T>\n" 6887 "void f(int i = 0, SomeType** temps = NULL);"); 6888 6889 FormatStyle Left = getLLVMStyle(); 6890 Left.PointerAlignment = FormatStyle::PAS_Left; 6891 verifyFormat("x = *a(x) = *a(y);", Left); 6892 verifyFormat("for (;; *a = b) {\n}", Left); 6893 verifyFormat("return *this += 1;", Left); 6894 verifyFormat("throw *x;", Left); 6895 verifyFormat("delete *x;", Left); 6896 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 6897 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 6898 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 6899 6900 verifyIndependentOfContext("a = *(x + y);"); 6901 verifyIndependentOfContext("a = &(x + y);"); 6902 verifyIndependentOfContext("*(x + y).call();"); 6903 verifyIndependentOfContext("&(x + y)->call();"); 6904 verifyFormat("void f() { &(*I).first; }"); 6905 6906 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 6907 verifyFormat( 6908 "int *MyValues = {\n" 6909 " *A, // Operator detection might be confused by the '{'\n" 6910 " *BB // Operator detection might be confused by previous comment\n" 6911 "};"); 6912 6913 verifyIndependentOfContext("if (int *a = &b)"); 6914 verifyIndependentOfContext("if (int &a = *b)"); 6915 verifyIndependentOfContext("if (a & b[i])"); 6916 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 6917 verifyIndependentOfContext("if (*b[i])"); 6918 verifyIndependentOfContext("if (int *a = (&b))"); 6919 verifyIndependentOfContext("while (int *a = &b)"); 6920 verifyIndependentOfContext("size = sizeof *a;"); 6921 verifyIndependentOfContext("if (a && (b = c))"); 6922 verifyFormat("void f() {\n" 6923 " for (const int &v : Values) {\n" 6924 " }\n" 6925 "}"); 6926 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 6927 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 6928 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 6929 6930 verifyFormat("#define A (!a * b)"); 6931 verifyFormat("#define MACRO \\\n" 6932 " int *i = a * b; \\\n" 6933 " void f(a *b);", 6934 getLLVMStyleWithColumns(19)); 6935 6936 verifyIndependentOfContext("A = new SomeType *[Length];"); 6937 verifyIndependentOfContext("A = new SomeType *[Length]();"); 6938 verifyIndependentOfContext("T **t = new T *;"); 6939 verifyIndependentOfContext("T **t = new T *();"); 6940 verifyGoogleFormat("A = new SomeType*[Length]();"); 6941 verifyGoogleFormat("A = new SomeType*[Length];"); 6942 verifyGoogleFormat("T** t = new T*;"); 6943 verifyGoogleFormat("T** t = new T*();"); 6944 6945 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 6946 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 6947 verifyFormat("template <bool a, bool b> " 6948 "typename t::if<x && y>::type f() {}"); 6949 verifyFormat("template <int *y> f() {}"); 6950 verifyFormat("vector<int *> v;"); 6951 verifyFormat("vector<int *const> v;"); 6952 verifyFormat("vector<int *const **const *> v;"); 6953 verifyFormat("vector<int *volatile> v;"); 6954 verifyFormat("vector<a * b> v;"); 6955 verifyFormat("foo<b && false>();"); 6956 verifyFormat("foo<b & 1>();"); 6957 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 6958 verifyFormat( 6959 "template <class T, class = typename std::enable_if<\n" 6960 " std::is_integral<T>::value &&\n" 6961 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 6962 "void F();", 6963 getLLVMStyleWithColumns(70)); 6964 verifyFormat( 6965 "template <class T,\n" 6966 " class = typename std::enable_if<\n" 6967 " std::is_integral<T>::value &&\n" 6968 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 6969 " class U>\n" 6970 "void F();", 6971 getLLVMStyleWithColumns(70)); 6972 verifyFormat( 6973 "template <class T,\n" 6974 " class = typename ::std::enable_if<\n" 6975 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 6976 "void F();", 6977 getGoogleStyleWithColumns(68)); 6978 6979 verifyIndependentOfContext("MACRO(int *i);"); 6980 verifyIndependentOfContext("MACRO(auto *a);"); 6981 verifyIndependentOfContext("MACRO(const A *a);"); 6982 verifyIndependentOfContext("MACRO(A *const a);"); 6983 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 6984 verifyFormat("void f() { f(float{1}, a * a); }"); 6985 // FIXME: Is there a way to make this work? 6986 // verifyIndependentOfContext("MACRO(A *a);"); 6987 6988 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 6989 verifyFormat("return options != nullptr && operator==(*options);"); 6990 6991 EXPECT_EQ("#define OP(x) \\\n" 6992 " ostream &operator<<(ostream &s, const A &a) { \\\n" 6993 " return s << a.DebugString(); \\\n" 6994 " }", 6995 format("#define OP(x) \\\n" 6996 " ostream &operator<<(ostream &s, const A &a) { \\\n" 6997 " return s << a.DebugString(); \\\n" 6998 " }", 6999 getLLVMStyleWithColumns(50))); 7000 7001 // FIXME: We cannot handle this case yet; we might be able to figure out that 7002 // foo<x> d > v; doesn't make sense. 7003 verifyFormat("foo<a<b && c> d> v;"); 7004 7005 FormatStyle PointerMiddle = getLLVMStyle(); 7006 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7007 verifyFormat("delete *x;", PointerMiddle); 7008 verifyFormat("int * x;", PointerMiddle); 7009 verifyFormat("int *[] x;", PointerMiddle); 7010 verifyFormat("template <int * y> f() {}", PointerMiddle); 7011 verifyFormat("int * f(int * a) {}", PointerMiddle); 7012 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7013 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7014 verifyFormat("A<int *> a;", PointerMiddle); 7015 verifyFormat("A<int **> a;", PointerMiddle); 7016 verifyFormat("A<int *, int *> a;", PointerMiddle); 7017 verifyFormat("A<int *[]> a;", PointerMiddle); 7018 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7019 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7020 verifyFormat("T ** t = new T *;", PointerMiddle); 7021 7022 // Member function reference qualifiers aren't binary operators. 7023 verifyFormat("string // break\n" 7024 "operator()() & {}"); 7025 verifyFormat("string // break\n" 7026 "operator()() && {}"); 7027 verifyGoogleFormat("template <typename T>\n" 7028 "auto x() & -> int {}"); 7029 } 7030 7031 TEST_F(FormatTest, UnderstandsAttributes) { 7032 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7033 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7034 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7035 FormatStyle AfterType = getLLVMStyle(); 7036 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7037 verifyFormat("__attribute__((nodebug)) void\n" 7038 "foo() {}\n", 7039 AfterType); 7040 } 7041 7042 TEST_F(FormatTest, UnderstandsSquareAttributes) { 7043 verifyFormat("SomeType s [[unused]] (InitValue);"); 7044 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 7045 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 7046 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 7047 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 7048 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7049 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7050 7051 // Make sure we do not mistake attributes for array subscripts. 7052 verifyFormat("int a() {}\n" 7053 "[[unused]] int b() {}\n"); 7054 verifyFormat("NSArray *arr;\n" 7055 "arr[[Foo() bar]];"); 7056 7057 // On the other hand, we still need to correctly find array subscripts. 7058 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 7059 7060 // Make sure that we do not mistake Objective-C method inside array literals 7061 // as attributes, even if those method names are also keywords. 7062 verifyFormat("@[ [foo bar] ];"); 7063 verifyFormat("@[ [NSArray class] ];"); 7064 verifyFormat("@[ [foo enum] ];"); 7065 7066 // Make sure we do not parse attributes as lambda introducers. 7067 FormatStyle MultiLineFunctions = getLLVMStyle(); 7068 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7069 verifyFormat("[[unused]] int b() {\n" 7070 " return 42;\n" 7071 "}\n", 7072 MultiLineFunctions); 7073 } 7074 7075 TEST_F(FormatTest, UnderstandsEllipsis) { 7076 verifyFormat("int printf(const char *fmt, ...);"); 7077 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 7078 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 7079 7080 FormatStyle PointersLeft = getLLVMStyle(); 7081 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 7082 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 7083 } 7084 7085 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 7086 EXPECT_EQ("int *a;\n" 7087 "int *a;\n" 7088 "int *a;", 7089 format("int *a;\n" 7090 "int* a;\n" 7091 "int *a;", 7092 getGoogleStyle())); 7093 EXPECT_EQ("int* a;\n" 7094 "int* a;\n" 7095 "int* a;", 7096 format("int* a;\n" 7097 "int* a;\n" 7098 "int *a;", 7099 getGoogleStyle())); 7100 EXPECT_EQ("int *a;\n" 7101 "int *a;\n" 7102 "int *a;", 7103 format("int *a;\n" 7104 "int * a;\n" 7105 "int * a;", 7106 getGoogleStyle())); 7107 EXPECT_EQ("auto x = [] {\n" 7108 " int *a;\n" 7109 " int *a;\n" 7110 " int *a;\n" 7111 "};", 7112 format("auto x=[]{int *a;\n" 7113 "int * a;\n" 7114 "int * a;};", 7115 getGoogleStyle())); 7116 } 7117 7118 TEST_F(FormatTest, UnderstandsRvalueReferences) { 7119 verifyFormat("int f(int &&a) {}"); 7120 verifyFormat("int f(int a, char &&b) {}"); 7121 verifyFormat("void f() { int &&a = b; }"); 7122 verifyGoogleFormat("int f(int a, char&& b) {}"); 7123 verifyGoogleFormat("void f() { int&& a = b; }"); 7124 7125 verifyIndependentOfContext("A<int &&> a;"); 7126 verifyIndependentOfContext("A<int &&, int &&> a;"); 7127 verifyGoogleFormat("A<int&&> a;"); 7128 verifyGoogleFormat("A<int&&, int&&> a;"); 7129 7130 // Not rvalue references: 7131 verifyFormat("template <bool B, bool C> class A {\n" 7132 " static_assert(B && C, \"Something is wrong\");\n" 7133 "};"); 7134 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 7135 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 7136 verifyFormat("#define A(a, b) (a && b)"); 7137 } 7138 7139 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 7140 verifyFormat("void f() {\n" 7141 " x[aaaaaaaaa -\n" 7142 " b] = 23;\n" 7143 "}", 7144 getLLVMStyleWithColumns(15)); 7145 } 7146 7147 TEST_F(FormatTest, FormatsCasts) { 7148 verifyFormat("Type *A = static_cast<Type *>(P);"); 7149 verifyFormat("Type *A = (Type *)P;"); 7150 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7151 verifyFormat("int a = (int)(2.0f);"); 7152 verifyFormat("int a = (int)2.0f;"); 7153 verifyFormat("x[(int32)y];"); 7154 verifyFormat("x = (int32)y;"); 7155 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7156 verifyFormat("int a = (int)*b;"); 7157 verifyFormat("int a = (int)2.0f;"); 7158 verifyFormat("int a = (int)~0;"); 7159 verifyFormat("int a = (int)++a;"); 7160 verifyFormat("int a = (int)sizeof(int);"); 7161 verifyFormat("int a = (int)+2;"); 7162 verifyFormat("my_int a = (my_int)2.0f;"); 7163 verifyFormat("my_int a = (my_int)sizeof(int);"); 7164 verifyFormat("return (my_int)aaa;"); 7165 verifyFormat("#define x ((int)-1)"); 7166 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7167 verifyFormat("#define p(q) ((int *)&q)"); 7168 verifyFormat("fn(a)(b) + 1;"); 7169 7170 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7171 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7172 verifyFormat("my_int a = (my_int)~0;"); 7173 verifyFormat("my_int a = (my_int)++a;"); 7174 verifyFormat("my_int a = (my_int)-2;"); 7175 verifyFormat("my_int a = (my_int)1;"); 7176 verifyFormat("my_int a = (my_int *)1;"); 7177 verifyFormat("my_int a = (const my_int)-1;"); 7178 verifyFormat("my_int a = (const my_int *)-1;"); 7179 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7180 verifyFormat("my_int a = (ns::my_int)-2;"); 7181 verifyFormat("case (my_int)ONE:"); 7182 verifyFormat("auto x = (X)this;"); 7183 7184 // FIXME: single value wrapped with paren will be treated as cast. 7185 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7186 7187 verifyFormat("{ (void)F; }"); 7188 7189 // Don't break after a cast's 7190 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7191 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7192 " bbbbbbbbbbbbbbbbbbbbbb);"); 7193 7194 // These are not casts. 7195 verifyFormat("void f(int *) {}"); 7196 verifyFormat("f(foo)->b;"); 7197 verifyFormat("f(foo).b;"); 7198 verifyFormat("f(foo)(b);"); 7199 verifyFormat("f(foo)[b];"); 7200 verifyFormat("[](foo) { return 4; }(bar);"); 7201 verifyFormat("(*funptr)(foo)[4];"); 7202 verifyFormat("funptrs[4](foo)[4];"); 7203 verifyFormat("void f(int *);"); 7204 verifyFormat("void f(int *) = 0;"); 7205 verifyFormat("void f(SmallVector<int>) {}"); 7206 verifyFormat("void f(SmallVector<int>);"); 7207 verifyFormat("void f(SmallVector<int>) = 0;"); 7208 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7209 verifyFormat("int a = sizeof(int) * b;"); 7210 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7211 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7212 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7213 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7214 7215 // These are not casts, but at some point were confused with casts. 7216 verifyFormat("virtual void foo(int *) override;"); 7217 verifyFormat("virtual void foo(char &) const;"); 7218 verifyFormat("virtual void foo(int *a, char *) const;"); 7219 verifyFormat("int a = sizeof(int *) + b;"); 7220 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7221 verifyFormat("bool b = f(g<int>) && c;"); 7222 verifyFormat("typedef void (*f)(int i) func;"); 7223 7224 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7225 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7226 // FIXME: The indentation here is not ideal. 7227 verifyFormat( 7228 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7229 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7230 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7231 } 7232 7233 TEST_F(FormatTest, FormatsFunctionTypes) { 7234 verifyFormat("A<bool()> a;"); 7235 verifyFormat("A<SomeType()> a;"); 7236 verifyFormat("A<void (*)(int, std::string)> a;"); 7237 verifyFormat("A<void *(int)>;"); 7238 verifyFormat("void *(*a)(int *, SomeType *);"); 7239 verifyFormat("int (*func)(void *);"); 7240 verifyFormat("void f() { int (*func)(void *); }"); 7241 verifyFormat("template <class CallbackClass>\n" 7242 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7243 7244 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7245 verifyGoogleFormat("void* (*a)(int);"); 7246 verifyGoogleFormat( 7247 "template <class CallbackClass>\n" 7248 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7249 7250 // Other constructs can look somewhat like function types: 7251 verifyFormat("A<sizeof(*x)> a;"); 7252 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7253 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7254 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7255 verifyFormat("int x = f(&h)();"); 7256 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7257 verifyFormat("std::function<\n" 7258 " LooooooooooongTemplatedType<\n" 7259 " SomeType>*(\n" 7260 " LooooooooooooooooongType type)>\n" 7261 " function;", 7262 getGoogleStyleWithColumns(40)); 7263 } 7264 7265 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7266 verifyFormat("A (*foo_)[6];"); 7267 verifyFormat("vector<int> (*foo_)[6];"); 7268 } 7269 7270 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7271 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7272 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7273 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7274 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7275 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7276 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7277 7278 // Different ways of ()-initializiation. 7279 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7280 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7281 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7282 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7283 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7284 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7285 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7286 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7287 7288 // Lambdas should not confuse the variable declaration heuristic. 7289 verifyFormat("LooooooooooooooooongType\n" 7290 " variable(nullptr, [](A *a) {});", 7291 getLLVMStyleWithColumns(40)); 7292 } 7293 7294 TEST_F(FormatTest, BreaksLongDeclarations) { 7295 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7296 " AnotherNameForTheLongType;"); 7297 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7298 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7299 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7300 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7301 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7302 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7303 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7304 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7305 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7306 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7307 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7308 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7309 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7310 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7311 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7312 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7313 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7314 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7315 FormatStyle Indented = getLLVMStyle(); 7316 Indented.IndentWrappedFunctionNames = true; 7317 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7318 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7319 Indented); 7320 verifyFormat( 7321 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7322 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7323 Indented); 7324 verifyFormat( 7325 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7326 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7327 Indented); 7328 verifyFormat( 7329 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7330 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7331 Indented); 7332 7333 // FIXME: Without the comment, this breaks after "(". 7334 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7335 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7336 getGoogleStyle()); 7337 7338 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7339 " int LoooooooooooooooooooongParam2) {}"); 7340 verifyFormat( 7341 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7342 " SourceLocation L, IdentifierIn *II,\n" 7343 " Type *T) {}"); 7344 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7345 "ReallyReaaallyLongFunctionName(\n" 7346 " const std::string &SomeParameter,\n" 7347 " const SomeType<string, SomeOtherTemplateParameter>\n" 7348 " &ReallyReallyLongParameterName,\n" 7349 " const SomeType<string, SomeOtherTemplateParameter>\n" 7350 " &AnotherLongParameterName) {}"); 7351 verifyFormat("template <typename A>\n" 7352 "SomeLoooooooooooooooooooooongType<\n" 7353 " typename some_namespace::SomeOtherType<A>::Type>\n" 7354 "Function() {}"); 7355 7356 verifyGoogleFormat( 7357 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7358 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7359 verifyGoogleFormat( 7360 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7361 " SourceLocation L) {}"); 7362 verifyGoogleFormat( 7363 "some_namespace::LongReturnType\n" 7364 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7365 " int first_long_parameter, int second_parameter) {}"); 7366 7367 verifyGoogleFormat("template <typename T>\n" 7368 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7369 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7370 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7371 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7372 7373 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7374 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7375 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7376 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7377 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7378 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 7379 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7380 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 7381 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 7382 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7383 7384 verifyFormat("template <typename T> // Templates on own line.\n" 7385 "static int // Some comment.\n" 7386 "MyFunction(int a);", 7387 getLLVMStyle()); 7388 } 7389 7390 TEST_F(FormatTest, FormatsArrays) { 7391 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7392 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 7393 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 7394 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 7395 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 7396 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 7397 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7398 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7399 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7400 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 7401 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7402 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7403 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7404 verifyFormat( 7405 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 7406 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7407 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 7408 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 7409 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7410 7411 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 7412 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 7413 verifyFormat( 7414 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 7415 " .aaaaaaa[0]\n" 7416 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7417 verifyFormat("a[::b::c];"); 7418 7419 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 7420 7421 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 7422 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 7423 } 7424 7425 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 7426 verifyFormat("(a)->b();"); 7427 verifyFormat("--a;"); 7428 } 7429 7430 TEST_F(FormatTest, HandlesIncludeDirectives) { 7431 verifyFormat("#include <string>\n" 7432 "#include <a/b/c.h>\n" 7433 "#include \"a/b/string\"\n" 7434 "#include \"string.h\"\n" 7435 "#include \"string.h\"\n" 7436 "#include <a-a>\n" 7437 "#include < path with space >\n" 7438 "#include_next <test.h>" 7439 "#include \"abc.h\" // this is included for ABC\n" 7440 "#include \"some long include\" // with a comment\n" 7441 "#include \"some very long include path\"\n" 7442 "#include <some/very/long/include/path>\n", 7443 getLLVMStyleWithColumns(35)); 7444 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 7445 EXPECT_EQ("#include <a>", format("#include<a>")); 7446 7447 verifyFormat("#import <string>"); 7448 verifyFormat("#import <a/b/c.h>"); 7449 verifyFormat("#import \"a/b/string\""); 7450 verifyFormat("#import \"string.h\""); 7451 verifyFormat("#import \"string.h\""); 7452 verifyFormat("#if __has_include(<strstream>)\n" 7453 "#include <strstream>\n" 7454 "#endif"); 7455 7456 verifyFormat("#define MY_IMPORT <a/b>"); 7457 7458 verifyFormat("#if __has_include(<a/b>)"); 7459 verifyFormat("#if __has_include_next(<a/b>)"); 7460 verifyFormat("#define F __has_include(<a/b>)"); 7461 verifyFormat("#define F __has_include_next(<a/b>)"); 7462 7463 // Protocol buffer definition or missing "#". 7464 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 7465 getLLVMStyleWithColumns(30)); 7466 7467 FormatStyle Style = getLLVMStyle(); 7468 Style.AlwaysBreakBeforeMultilineStrings = true; 7469 Style.ColumnLimit = 0; 7470 verifyFormat("#import \"abc.h\"", Style); 7471 7472 // But 'import' might also be a regular C++ namespace. 7473 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7474 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7475 } 7476 7477 //===----------------------------------------------------------------------===// 7478 // Error recovery tests. 7479 //===----------------------------------------------------------------------===// 7480 7481 TEST_F(FormatTest, IncompleteParameterLists) { 7482 FormatStyle NoBinPacking = getLLVMStyle(); 7483 NoBinPacking.BinPackParameters = false; 7484 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 7485 " double *min_x,\n" 7486 " double *max_x,\n" 7487 " double *min_y,\n" 7488 " double *max_y,\n" 7489 " double *min_z,\n" 7490 " double *max_z, ) {}", 7491 NoBinPacking); 7492 } 7493 7494 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 7495 verifyFormat("void f() { return; }\n42"); 7496 verifyFormat("void f() {\n" 7497 " if (0)\n" 7498 " return;\n" 7499 "}\n" 7500 "42"); 7501 verifyFormat("void f() { return }\n42"); 7502 verifyFormat("void f() {\n" 7503 " if (0)\n" 7504 " return\n" 7505 "}\n" 7506 "42"); 7507 } 7508 7509 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 7510 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 7511 EXPECT_EQ("void f() {\n" 7512 " if (a)\n" 7513 " return\n" 7514 "}", 7515 format("void f ( ) { if ( a ) return }")); 7516 EXPECT_EQ("namespace N {\n" 7517 "void f()\n" 7518 "}", 7519 format("namespace N { void f() }")); 7520 EXPECT_EQ("namespace N {\n" 7521 "void f() {}\n" 7522 "void g()\n" 7523 "} // namespace N", 7524 format("namespace N { void f( ) { } void g( ) }")); 7525 } 7526 7527 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 7528 verifyFormat("int aaaaaaaa =\n" 7529 " // Overlylongcomment\n" 7530 " b;", 7531 getLLVMStyleWithColumns(20)); 7532 verifyFormat("function(\n" 7533 " ShortArgument,\n" 7534 " LoooooooooooongArgument);\n", 7535 getLLVMStyleWithColumns(20)); 7536 } 7537 7538 TEST_F(FormatTest, IncorrectAccessSpecifier) { 7539 verifyFormat("public:"); 7540 verifyFormat("class A {\n" 7541 "public\n" 7542 " void f() {}\n" 7543 "};"); 7544 verifyFormat("public\n" 7545 "int qwerty;"); 7546 verifyFormat("public\n" 7547 "B {}"); 7548 verifyFormat("public\n" 7549 "{}"); 7550 verifyFormat("public\n" 7551 "B { int x; }"); 7552 } 7553 7554 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 7555 verifyFormat("{"); 7556 verifyFormat("#})"); 7557 verifyNoCrash("(/**/[:!] ?[)."); 7558 } 7559 7560 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 7561 // Found by oss-fuzz: 7562 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 7563 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 7564 Style.ColumnLimit = 60; 7565 verifyNoCrash( 7566 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 7567 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 7568 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 7569 Style); 7570 } 7571 7572 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 7573 verifyFormat("do {\n}"); 7574 verifyFormat("do {\n}\n" 7575 "f();"); 7576 verifyFormat("do {\n}\n" 7577 "wheeee(fun);"); 7578 verifyFormat("do {\n" 7579 " f();\n" 7580 "}"); 7581 } 7582 7583 TEST_F(FormatTest, IncorrectCodeMissingParens) { 7584 verifyFormat("if {\n foo;\n foo();\n}"); 7585 verifyFormat("switch {\n foo;\n foo();\n}"); 7586 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 7587 verifyFormat("while {\n foo;\n foo();\n}"); 7588 verifyFormat("do {\n foo;\n foo();\n} while;"); 7589 } 7590 7591 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 7592 verifyIncompleteFormat("namespace {\n" 7593 "class Foo { Foo (\n" 7594 "};\n" 7595 "} // namespace"); 7596 } 7597 7598 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 7599 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 7600 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 7601 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 7602 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 7603 7604 EXPECT_EQ("{\n" 7605 " {\n" 7606 " breakme(\n" 7607 " qwe);\n" 7608 " }\n", 7609 format("{\n" 7610 " {\n" 7611 " breakme(qwe);\n" 7612 "}\n", 7613 getLLVMStyleWithColumns(10))); 7614 } 7615 7616 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 7617 verifyFormat("int x = {\n" 7618 " avariable,\n" 7619 " b(alongervariable)};", 7620 getLLVMStyleWithColumns(25)); 7621 } 7622 7623 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 7624 verifyFormat("return (a)(b){1, 2, 3};"); 7625 } 7626 7627 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 7628 verifyFormat("vector<int> x{1, 2, 3, 4};"); 7629 verifyFormat("vector<int> x{\n" 7630 " 1,\n" 7631 " 2,\n" 7632 " 3,\n" 7633 " 4,\n" 7634 "};"); 7635 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 7636 verifyFormat("f({1, 2});"); 7637 verifyFormat("auto v = Foo{-1};"); 7638 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 7639 verifyFormat("Class::Class : member{1, 2, 3} {}"); 7640 verifyFormat("new vector<int>{1, 2, 3};"); 7641 verifyFormat("new int[3]{1, 2, 3};"); 7642 verifyFormat("new int{1};"); 7643 verifyFormat("return {arg1, arg2};"); 7644 verifyFormat("return {arg1, SomeType{parameter}};"); 7645 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 7646 verifyFormat("new T{arg1, arg2};"); 7647 verifyFormat("f(MyMap[{composite, key}]);"); 7648 verifyFormat("class Class {\n" 7649 " T member = {arg1, arg2};\n" 7650 "};"); 7651 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 7652 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 7653 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 7654 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 7655 verifyFormat("int a = std::is_integral<int>{} + 0;"); 7656 7657 verifyFormat("int foo(int i) { return fo1{}(i); }"); 7658 verifyFormat("int foo(int i) { return fo1{}(i); }"); 7659 verifyFormat("auto i = decltype(x){};"); 7660 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 7661 verifyFormat("Node n{1, Node{1000}, //\n" 7662 " 2};"); 7663 verifyFormat("Aaaa aaaaaaa{\n" 7664 " {\n" 7665 " aaaa,\n" 7666 " },\n" 7667 "};"); 7668 verifyFormat("class C : public D {\n" 7669 " SomeClass SC{2};\n" 7670 "};"); 7671 verifyFormat("class C : public A {\n" 7672 " class D : public B {\n" 7673 " void f() { int i{2}; }\n" 7674 " };\n" 7675 "};"); 7676 verifyFormat("#define A {a, a},"); 7677 7678 // Avoid breaking between equal sign and opening brace 7679 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 7680 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 7681 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 7682 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 7683 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 7684 " {\"ccccccccccccccccccccc\", 2}};", 7685 AvoidBreakingFirstArgument); 7686 7687 // Binpacking only if there is no trailing comma 7688 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 7689 " cccccccccc, dddddddddd};", 7690 getLLVMStyleWithColumns(50)); 7691 verifyFormat("const Aaaaaa aaaaa = {\n" 7692 " aaaaaaaaaaa,\n" 7693 " bbbbbbbbbbb,\n" 7694 " ccccccccccc,\n" 7695 " ddddddddddd,\n" 7696 "};", getLLVMStyleWithColumns(50)); 7697 7698 // Cases where distinguising braced lists and blocks is hard. 7699 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 7700 verifyFormat("void f() {\n" 7701 " return; // comment\n" 7702 "}\n" 7703 "SomeType t;"); 7704 verifyFormat("void f() {\n" 7705 " if (a) {\n" 7706 " f();\n" 7707 " }\n" 7708 "}\n" 7709 "SomeType t;"); 7710 7711 // In combination with BinPackArguments = false. 7712 FormatStyle NoBinPacking = getLLVMStyle(); 7713 NoBinPacking.BinPackArguments = false; 7714 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 7715 " bbbbb,\n" 7716 " ccccc,\n" 7717 " ddddd,\n" 7718 " eeeee,\n" 7719 " ffffff,\n" 7720 " ggggg,\n" 7721 " hhhhhh,\n" 7722 " iiiiii,\n" 7723 " jjjjjj,\n" 7724 " kkkkkk};", 7725 NoBinPacking); 7726 verifyFormat("const Aaaaaa aaaaa = {\n" 7727 " aaaaa,\n" 7728 " bbbbb,\n" 7729 " ccccc,\n" 7730 " ddddd,\n" 7731 " eeeee,\n" 7732 " ffffff,\n" 7733 " ggggg,\n" 7734 " hhhhhh,\n" 7735 " iiiiii,\n" 7736 " jjjjjj,\n" 7737 " kkkkkk,\n" 7738 "};", 7739 NoBinPacking); 7740 verifyFormat( 7741 "const Aaaaaa aaaaa = {\n" 7742 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 7743 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 7744 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 7745 "};", 7746 NoBinPacking); 7747 7748 // FIXME: The alignment of these trailing comments might be bad. Then again, 7749 // this might be utterly useless in real code. 7750 verifyFormat("Constructor::Constructor()\n" 7751 " : some_value{ //\n" 7752 " aaaaaaa, //\n" 7753 " bbbbbbb} {}"); 7754 7755 // In braced lists, the first comment is always assumed to belong to the 7756 // first element. Thus, it can be moved to the next or previous line as 7757 // appropriate. 7758 EXPECT_EQ("function({// First element:\n" 7759 " 1,\n" 7760 " // Second element:\n" 7761 " 2});", 7762 format("function({\n" 7763 " // First element:\n" 7764 " 1,\n" 7765 " // Second element:\n" 7766 " 2});")); 7767 EXPECT_EQ("std::vector<int> MyNumbers{\n" 7768 " // First element:\n" 7769 " 1,\n" 7770 " // Second element:\n" 7771 " 2};", 7772 format("std::vector<int> MyNumbers{// First element:\n" 7773 " 1,\n" 7774 " // Second element:\n" 7775 " 2};", 7776 getLLVMStyleWithColumns(30))); 7777 // A trailing comma should still lead to an enforced line break and no 7778 // binpacking. 7779 EXPECT_EQ("vector<int> SomeVector = {\n" 7780 " // aaa\n" 7781 " 1,\n" 7782 " 2,\n" 7783 "};", 7784 format("vector<int> SomeVector = { // aaa\n" 7785 " 1, 2, };")); 7786 7787 FormatStyle ExtraSpaces = getLLVMStyle(); 7788 ExtraSpaces.Cpp11BracedListStyle = false; 7789 ExtraSpaces.ColumnLimit = 75; 7790 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 7791 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 7792 verifyFormat("f({ 1, 2 });", ExtraSpaces); 7793 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 7794 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 7795 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 7796 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 7797 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 7798 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 7799 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 7800 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 7801 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 7802 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 7803 verifyFormat("class Class {\n" 7804 " T member = { arg1, arg2 };\n" 7805 "};", 7806 ExtraSpaces); 7807 verifyFormat( 7808 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7809 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 7810 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 7811 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 7812 ExtraSpaces); 7813 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 7814 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 7815 ExtraSpaces); 7816 verifyFormat( 7817 "someFunction(OtherParam,\n" 7818 " BracedList{ // comment 1 (Forcing interesting break)\n" 7819 " param1, param2,\n" 7820 " // comment 2\n" 7821 " param3, param4 });", 7822 ExtraSpaces); 7823 verifyFormat( 7824 "std::this_thread::sleep_for(\n" 7825 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 7826 ExtraSpaces); 7827 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 7828 " aaaaaaa,\n" 7829 " aaaaaaaaaa,\n" 7830 " aaaaa,\n" 7831 " aaaaaaaaaaaaaaa,\n" 7832 " aaa,\n" 7833 " aaaaaaaaaa,\n" 7834 " a,\n" 7835 " aaaaaaaaaaaaaaaaaaaaa,\n" 7836 " aaaaaaaaaaaa,\n" 7837 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 7838 " aaaaaaa,\n" 7839 " a};"); 7840 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 7841 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 7842 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 7843 7844 // Avoid breaking between initializer/equal sign and opening brace 7845 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 7846 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 7847 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 7848 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 7849 " { \"ccccccccccccccccccccc\", 2 }\n" 7850 "};", 7851 ExtraSpaces); 7852 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 7853 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 7854 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 7855 " { \"ccccccccccccccccccccc\", 2 }\n" 7856 "};", 7857 ExtraSpaces); 7858 7859 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 7860 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 7861 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 7862 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 7863 } 7864 7865 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 7866 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7867 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7868 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7869 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7870 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7871 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 7872 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 7873 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7874 " 1, 22, 333, 4444, 55555, //\n" 7875 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7876 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 7877 verifyFormat( 7878 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7879 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7880 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 7881 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 7882 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 7883 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 7884 " 7777777};"); 7885 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 7886 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 7887 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 7888 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 7889 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 7890 " // Separating comment.\n" 7891 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 7892 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 7893 " // Leading comment\n" 7894 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 7895 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 7896 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 7897 " 1, 1, 1, 1};", 7898 getLLVMStyleWithColumns(39)); 7899 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 7900 " 1, 1, 1, 1};", 7901 getLLVMStyleWithColumns(38)); 7902 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 7903 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 7904 getLLVMStyleWithColumns(43)); 7905 verifyFormat( 7906 "static unsigned SomeValues[10][3] = {\n" 7907 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 7908 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 7909 verifyFormat("static auto fields = new vector<string>{\n" 7910 " \"aaaaaaaaaaaaa\",\n" 7911 " \"aaaaaaaaaaaaa\",\n" 7912 " \"aaaaaaaaaaaa\",\n" 7913 " \"aaaaaaaaaaaaaa\",\n" 7914 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 7915 " \"aaaaaaaaaaaa\",\n" 7916 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 7917 "};"); 7918 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 7919 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 7920 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 7921 " 3, cccccccccccccccccccccc};", 7922 getLLVMStyleWithColumns(60)); 7923 7924 // Trailing commas. 7925 verifyFormat("vector<int> x = {\n" 7926 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 7927 "};", 7928 getLLVMStyleWithColumns(39)); 7929 verifyFormat("vector<int> x = {\n" 7930 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 7931 "};", 7932 getLLVMStyleWithColumns(39)); 7933 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 7934 " 1, 1, 1, 1,\n" 7935 " /**/ /**/};", 7936 getLLVMStyleWithColumns(39)); 7937 7938 // Trailing comment in the first line. 7939 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 7940 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 7941 " 111111111, 222222222, 3333333333, 444444444, //\n" 7942 " 11111111, 22222222, 333333333, 44444444};"); 7943 // Trailing comment in the last line. 7944 verifyFormat("int aaaaa[] = {\n" 7945 " 1, 2, 3, // comment\n" 7946 " 4, 5, 6 // comment\n" 7947 "};"); 7948 7949 // With nested lists, we should either format one item per line or all nested 7950 // lists one on line. 7951 // FIXME: For some nested lists, we can do better. 7952 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 7953 " {aaaaaaaaaaaaaaaaaaa},\n" 7954 " {aaaaaaaaaaaaaaaaaaaaa},\n" 7955 " {aaaaaaaaaaaaaaaaa}};", 7956 getLLVMStyleWithColumns(60)); 7957 verifyFormat( 7958 "SomeStruct my_struct_array = {\n" 7959 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 7960 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 7961 " {aaa, aaa},\n" 7962 " {aaa, aaa},\n" 7963 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 7964 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 7965 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 7966 7967 // No column layout should be used here. 7968 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 7969 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 7970 7971 verifyNoCrash("a<,"); 7972 7973 // No braced initializer here. 7974 verifyFormat("void f() {\n" 7975 " struct Dummy {};\n" 7976 " f(v);\n" 7977 "}"); 7978 7979 // Long lists should be formatted in columns even if they are nested. 7980 verifyFormat( 7981 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7982 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7983 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7984 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7985 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 7986 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 7987 7988 // Allow "single-column" layout even if that violates the column limit. There 7989 // isn't going to be a better way. 7990 verifyFormat("std::vector<int> a = {\n" 7991 " aaaaaaaa,\n" 7992 " aaaaaaaa,\n" 7993 " aaaaaaaa,\n" 7994 " aaaaaaaa,\n" 7995 " aaaaaaaaaa,\n" 7996 " aaaaaaaa,\n" 7997 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 7998 getLLVMStyleWithColumns(30)); 7999 verifyFormat("vector<int> aaaa = {\n" 8000 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8001 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8002 " aaaaaa.aaaaaaa,\n" 8003 " aaaaaa.aaaaaaa,\n" 8004 " aaaaaa.aaaaaaa,\n" 8005 " aaaaaa.aaaaaaa,\n" 8006 "};"); 8007 8008 // Don't create hanging lists. 8009 verifyFormat("someFunction(Param, {List1, List2,\n" 8010 " List3});", 8011 getLLVMStyleWithColumns(35)); 8012 verifyFormat("someFunction(Param, Param,\n" 8013 " {List1, List2,\n" 8014 " List3});", 8015 getLLVMStyleWithColumns(35)); 8016 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 8017 " aaaaaaaaaaaaaaaaaaaaaaa);"); 8018 } 8019 8020 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 8021 FormatStyle DoNotMerge = getLLVMStyle(); 8022 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8023 8024 verifyFormat("void f() { return 42; }"); 8025 verifyFormat("void f() {\n" 8026 " return 42;\n" 8027 "}", 8028 DoNotMerge); 8029 verifyFormat("void f() {\n" 8030 " // Comment\n" 8031 "}"); 8032 verifyFormat("{\n" 8033 "#error {\n" 8034 " int a;\n" 8035 "}"); 8036 verifyFormat("{\n" 8037 " int a;\n" 8038 "#error {\n" 8039 "}"); 8040 verifyFormat("void f() {} // comment"); 8041 verifyFormat("void f() { int a; } // comment"); 8042 verifyFormat("void f() {\n" 8043 "} // comment", 8044 DoNotMerge); 8045 verifyFormat("void f() {\n" 8046 " int a;\n" 8047 "} // comment", 8048 DoNotMerge); 8049 verifyFormat("void f() {\n" 8050 "} // comment", 8051 getLLVMStyleWithColumns(15)); 8052 8053 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 8054 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 8055 8056 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 8057 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 8058 verifyFormat("class C {\n" 8059 " C()\n" 8060 " : iiiiiiii(nullptr),\n" 8061 " kkkkkkk(nullptr),\n" 8062 " mmmmmmm(nullptr),\n" 8063 " nnnnnnn(nullptr) {}\n" 8064 "};", 8065 getGoogleStyle()); 8066 8067 FormatStyle NoColumnLimit = getLLVMStyle(); 8068 NoColumnLimit.ColumnLimit = 0; 8069 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 8070 EXPECT_EQ("class C {\n" 8071 " A() : b(0) {}\n" 8072 "};", 8073 format("class C{A():b(0){}};", NoColumnLimit)); 8074 EXPECT_EQ("A()\n" 8075 " : b(0) {\n" 8076 "}", 8077 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 8078 8079 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 8080 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 8081 FormatStyle::SFS_None; 8082 EXPECT_EQ("A()\n" 8083 " : b(0) {\n" 8084 "}", 8085 format("A():b(0){}", DoNotMergeNoColumnLimit)); 8086 EXPECT_EQ("A()\n" 8087 " : b(0) {\n" 8088 "}", 8089 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 8090 8091 verifyFormat("#define A \\\n" 8092 " void f() { \\\n" 8093 " int i; \\\n" 8094 " }", 8095 getLLVMStyleWithColumns(20)); 8096 verifyFormat("#define A \\\n" 8097 " void f() { int i; }", 8098 getLLVMStyleWithColumns(21)); 8099 verifyFormat("#define A \\\n" 8100 " void f() { \\\n" 8101 " int i; \\\n" 8102 " } \\\n" 8103 " int j;", 8104 getLLVMStyleWithColumns(22)); 8105 verifyFormat("#define A \\\n" 8106 " void f() { int i; } \\\n" 8107 " int j;", 8108 getLLVMStyleWithColumns(23)); 8109 } 8110 8111 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 8112 FormatStyle MergeEmptyOnly = getLLVMStyle(); 8113 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8114 verifyFormat("class C {\n" 8115 " int f() {}\n" 8116 "};", 8117 MergeEmptyOnly); 8118 verifyFormat("class C {\n" 8119 " int f() {\n" 8120 " return 42;\n" 8121 " }\n" 8122 "};", 8123 MergeEmptyOnly); 8124 verifyFormat("int f() {}", MergeEmptyOnly); 8125 verifyFormat("int f() {\n" 8126 " return 42;\n" 8127 "}", 8128 MergeEmptyOnly); 8129 8130 // Also verify behavior when BraceWrapping.AfterFunction = true 8131 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8132 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 8133 verifyFormat("int f() {}", MergeEmptyOnly); 8134 verifyFormat("class C {\n" 8135 " int f() {}\n" 8136 "};", 8137 MergeEmptyOnly); 8138 } 8139 8140 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 8141 FormatStyle MergeInlineOnly = getLLVMStyle(); 8142 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8143 verifyFormat("class C {\n" 8144 " int f() { return 42; }\n" 8145 "};", 8146 MergeInlineOnly); 8147 verifyFormat("int f() {\n" 8148 " return 42;\n" 8149 "}", 8150 MergeInlineOnly); 8151 8152 // SFS_Inline implies SFS_Empty 8153 verifyFormat("class C {\n" 8154 " int f() {}\n" 8155 "};", 8156 MergeInlineOnly); 8157 verifyFormat("int f() {}", MergeInlineOnly); 8158 8159 // Also verify behavior when BraceWrapping.AfterFunction = true 8160 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8161 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8162 verifyFormat("class C {\n" 8163 " int f() { return 42; }\n" 8164 "};", 8165 MergeInlineOnly); 8166 verifyFormat("int f()\n" 8167 "{\n" 8168 " return 42;\n" 8169 "}", 8170 MergeInlineOnly); 8171 8172 // SFS_Inline implies SFS_Empty 8173 verifyFormat("int f() {}", MergeInlineOnly); 8174 verifyFormat("class C {\n" 8175 " int f() {}\n" 8176 "};", 8177 MergeInlineOnly); 8178 } 8179 8180 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8181 FormatStyle MergeInlineOnly = getLLVMStyle(); 8182 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8183 FormatStyle::SFS_InlineOnly; 8184 verifyFormat("class C {\n" 8185 " int f() { return 42; }\n" 8186 "};", 8187 MergeInlineOnly); 8188 verifyFormat("int f() {\n" 8189 " return 42;\n" 8190 "}", 8191 MergeInlineOnly); 8192 8193 // SFS_InlineOnly does not imply SFS_Empty 8194 verifyFormat("class C {\n" 8195 " int f() {}\n" 8196 "};", 8197 MergeInlineOnly); 8198 verifyFormat("int f() {\n" 8199 "}", 8200 MergeInlineOnly); 8201 8202 // Also verify behavior when BraceWrapping.AfterFunction = true 8203 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8204 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8205 verifyFormat("class C {\n" 8206 " int f() { return 42; }\n" 8207 "};", 8208 MergeInlineOnly); 8209 verifyFormat("int f()\n" 8210 "{\n" 8211 " return 42;\n" 8212 "}", 8213 MergeInlineOnly); 8214 8215 // SFS_InlineOnly does not imply SFS_Empty 8216 verifyFormat("int f()\n" 8217 "{\n" 8218 "}", 8219 MergeInlineOnly); 8220 verifyFormat("class C {\n" 8221 " int f() {}\n" 8222 "};", 8223 MergeInlineOnly); 8224 } 8225 8226 TEST_F(FormatTest, SplitEmptyFunction) { 8227 FormatStyle Style = getLLVMStyle(); 8228 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8229 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8230 Style.BraceWrapping.AfterFunction = true; 8231 Style.BraceWrapping.SplitEmptyFunction = false; 8232 Style.ColumnLimit = 40; 8233 8234 verifyFormat("int f()\n" 8235 "{}", 8236 Style); 8237 verifyFormat("int f()\n" 8238 "{\n" 8239 " return 42;\n" 8240 "}", 8241 Style); 8242 verifyFormat("int f()\n" 8243 "{\n" 8244 " // some comment\n" 8245 "}", 8246 Style); 8247 8248 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8249 verifyFormat("int f() {}", Style); 8250 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8251 "{}", 8252 Style); 8253 verifyFormat("int f()\n" 8254 "{\n" 8255 " return 0;\n" 8256 "}", 8257 Style); 8258 8259 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8260 verifyFormat("class Foo {\n" 8261 " int f() {}\n" 8262 "};\n", 8263 Style); 8264 verifyFormat("class Foo {\n" 8265 " int f() { return 0; }\n" 8266 "};\n", 8267 Style); 8268 verifyFormat("class Foo {\n" 8269 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8270 " {}\n" 8271 "};\n", 8272 Style); 8273 verifyFormat("class Foo {\n" 8274 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8275 " {\n" 8276 " return 0;\n" 8277 " }\n" 8278 "};\n", 8279 Style); 8280 8281 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8282 verifyFormat("int f() {}", Style); 8283 verifyFormat("int f() { return 0; }", Style); 8284 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8285 "{}", 8286 Style); 8287 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8288 "{\n" 8289 " return 0;\n" 8290 "}", 8291 Style); 8292 } 8293 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8294 FormatStyle Style = getLLVMStyle(); 8295 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8296 verifyFormat("#ifdef A\n" 8297 "int f() {}\n" 8298 "#else\n" 8299 "int g() {}\n" 8300 "#endif", 8301 Style); 8302 } 8303 8304 TEST_F(FormatTest, SplitEmptyClass) { 8305 FormatStyle Style = getLLVMStyle(); 8306 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8307 Style.BraceWrapping.AfterClass = true; 8308 Style.BraceWrapping.SplitEmptyRecord = false; 8309 8310 verifyFormat("class Foo\n" 8311 "{};", 8312 Style); 8313 verifyFormat("/* something */ class Foo\n" 8314 "{};", 8315 Style); 8316 verifyFormat("template <typename X> class Foo\n" 8317 "{};", 8318 Style); 8319 verifyFormat("class Foo\n" 8320 "{\n" 8321 " Foo();\n" 8322 "};", 8323 Style); 8324 verifyFormat("typedef class Foo\n" 8325 "{\n" 8326 "} Foo_t;", 8327 Style); 8328 } 8329 8330 TEST_F(FormatTest, SplitEmptyStruct) { 8331 FormatStyle Style = getLLVMStyle(); 8332 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8333 Style.BraceWrapping.AfterStruct = true; 8334 Style.BraceWrapping.SplitEmptyRecord = false; 8335 8336 verifyFormat("struct Foo\n" 8337 "{};", 8338 Style); 8339 verifyFormat("/* something */ struct Foo\n" 8340 "{};", 8341 Style); 8342 verifyFormat("template <typename X> struct Foo\n" 8343 "{};", 8344 Style); 8345 verifyFormat("struct Foo\n" 8346 "{\n" 8347 " Foo();\n" 8348 "};", 8349 Style); 8350 verifyFormat("typedef struct Foo\n" 8351 "{\n" 8352 "} Foo_t;", 8353 Style); 8354 //typedef struct Bar {} Bar_t; 8355 } 8356 8357 TEST_F(FormatTest, SplitEmptyUnion) { 8358 FormatStyle Style = getLLVMStyle(); 8359 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8360 Style.BraceWrapping.AfterUnion = true; 8361 Style.BraceWrapping.SplitEmptyRecord = false; 8362 8363 verifyFormat("union Foo\n" 8364 "{};", 8365 Style); 8366 verifyFormat("/* something */ union Foo\n" 8367 "{};", 8368 Style); 8369 verifyFormat("union Foo\n" 8370 "{\n" 8371 " A,\n" 8372 "};", 8373 Style); 8374 verifyFormat("typedef union Foo\n" 8375 "{\n" 8376 "} Foo_t;", 8377 Style); 8378 } 8379 8380 TEST_F(FormatTest, SplitEmptyNamespace) { 8381 FormatStyle Style = getLLVMStyle(); 8382 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8383 Style.BraceWrapping.AfterNamespace = true; 8384 Style.BraceWrapping.SplitEmptyNamespace = false; 8385 8386 verifyFormat("namespace Foo\n" 8387 "{};", 8388 Style); 8389 verifyFormat("/* something */ namespace Foo\n" 8390 "{};", 8391 Style); 8392 verifyFormat("inline namespace Foo\n" 8393 "{};", 8394 Style); 8395 verifyFormat("/* something */ inline namespace Foo\n" 8396 "{};", 8397 Style); 8398 verifyFormat("export namespace Foo\n" 8399 "{};", 8400 Style); 8401 verifyFormat("namespace Foo\n" 8402 "{\n" 8403 "void Bar();\n" 8404 "};", 8405 Style); 8406 } 8407 8408 TEST_F(FormatTest, NeverMergeShortRecords) { 8409 FormatStyle Style = getLLVMStyle(); 8410 8411 verifyFormat("class Foo {\n" 8412 " Foo();\n" 8413 "};", 8414 Style); 8415 verifyFormat("typedef class Foo {\n" 8416 " Foo();\n" 8417 "} Foo_t;", 8418 Style); 8419 verifyFormat("struct Foo {\n" 8420 " Foo();\n" 8421 "};", 8422 Style); 8423 verifyFormat("typedef struct Foo {\n" 8424 " Foo();\n" 8425 "} Foo_t;", 8426 Style); 8427 verifyFormat("union Foo {\n" 8428 " A,\n" 8429 "};", 8430 Style); 8431 verifyFormat("typedef union Foo {\n" 8432 " A,\n" 8433 "} Foo_t;", 8434 Style); 8435 verifyFormat("namespace Foo {\n" 8436 "void Bar();\n" 8437 "};", 8438 Style); 8439 8440 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8441 Style.BraceWrapping.AfterClass = true; 8442 Style.BraceWrapping.AfterStruct = true; 8443 Style.BraceWrapping.AfterUnion = true; 8444 Style.BraceWrapping.AfterNamespace = true; 8445 verifyFormat("class Foo\n" 8446 "{\n" 8447 " Foo();\n" 8448 "};", 8449 Style); 8450 verifyFormat("typedef class Foo\n" 8451 "{\n" 8452 " Foo();\n" 8453 "} Foo_t;", 8454 Style); 8455 verifyFormat("struct Foo\n" 8456 "{\n" 8457 " Foo();\n" 8458 "};", 8459 Style); 8460 verifyFormat("typedef struct Foo\n" 8461 "{\n" 8462 " Foo();\n" 8463 "} Foo_t;", 8464 Style); 8465 verifyFormat("union Foo\n" 8466 "{\n" 8467 " A,\n" 8468 "};", 8469 Style); 8470 verifyFormat("typedef union Foo\n" 8471 "{\n" 8472 " A,\n" 8473 "} Foo_t;", 8474 Style); 8475 verifyFormat("namespace Foo\n" 8476 "{\n" 8477 "void Bar();\n" 8478 "};", 8479 Style); 8480 } 8481 8482 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 8483 // Elaborate type variable declarations. 8484 verifyFormat("struct foo a = {bar};\nint n;"); 8485 verifyFormat("class foo a = {bar};\nint n;"); 8486 verifyFormat("union foo a = {bar};\nint n;"); 8487 8488 // Elaborate types inside function definitions. 8489 verifyFormat("struct foo f() {}\nint n;"); 8490 verifyFormat("class foo f() {}\nint n;"); 8491 verifyFormat("union foo f() {}\nint n;"); 8492 8493 // Templates. 8494 verifyFormat("template <class X> void f() {}\nint n;"); 8495 verifyFormat("template <struct X> void f() {}\nint n;"); 8496 verifyFormat("template <union X> void f() {}\nint n;"); 8497 8498 // Actual definitions... 8499 verifyFormat("struct {\n} n;"); 8500 verifyFormat( 8501 "template <template <class T, class Y>, class Z> class X {\n} n;"); 8502 verifyFormat("union Z {\n int n;\n} x;"); 8503 verifyFormat("class MACRO Z {\n} n;"); 8504 verifyFormat("class MACRO(X) Z {\n} n;"); 8505 verifyFormat("class __attribute__(X) Z {\n} n;"); 8506 verifyFormat("class __declspec(X) Z {\n} n;"); 8507 verifyFormat("class A##B##C {\n} n;"); 8508 verifyFormat("class alignas(16) Z {\n} n;"); 8509 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 8510 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 8511 8512 // Redefinition from nested context: 8513 verifyFormat("class A::B::C {\n} n;"); 8514 8515 // Template definitions. 8516 verifyFormat( 8517 "template <typename F>\n" 8518 "Matcher(const Matcher<F> &Other,\n" 8519 " typename enable_if_c<is_base_of<F, T>::value &&\n" 8520 " !is_same<F, T>::value>::type * = 0)\n" 8521 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 8522 8523 // FIXME: This is still incorrectly handled at the formatter side. 8524 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 8525 verifyFormat("int i = SomeFunction(a<b, a> b);"); 8526 8527 // FIXME: 8528 // This now gets parsed incorrectly as class definition. 8529 // verifyFormat("class A<int> f() {\n}\nint n;"); 8530 8531 // Elaborate types where incorrectly parsing the structural element would 8532 // break the indent. 8533 verifyFormat("if (true)\n" 8534 " class X x;\n" 8535 "else\n" 8536 " f();\n"); 8537 8538 // This is simply incomplete. Formatting is not important, but must not crash. 8539 verifyFormat("class A:"); 8540 } 8541 8542 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 8543 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 8544 format("#error Leave all white!!!!! space* alone!\n")); 8545 EXPECT_EQ( 8546 "#warning Leave all white!!!!! space* alone!\n", 8547 format("#warning Leave all white!!!!! space* alone!\n")); 8548 EXPECT_EQ("#error 1", format(" # error 1")); 8549 EXPECT_EQ("#warning 1", format(" # warning 1")); 8550 } 8551 8552 TEST_F(FormatTest, FormatHashIfExpressions) { 8553 verifyFormat("#if AAAA && BBBB"); 8554 verifyFormat("#if (AAAA && BBBB)"); 8555 verifyFormat("#elif (AAAA && BBBB)"); 8556 // FIXME: Come up with a better indentation for #elif. 8557 verifyFormat( 8558 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 8559 " defined(BBBBBBBB)\n" 8560 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 8561 " defined(BBBBBBBB)\n" 8562 "#endif", 8563 getLLVMStyleWithColumns(65)); 8564 } 8565 8566 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 8567 FormatStyle AllowsMergedIf = getGoogleStyle(); 8568 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 8569 FormatStyle::SIS_WithoutElse; 8570 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 8571 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 8572 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 8573 EXPECT_EQ("if (true) return 42;", 8574 format("if (true)\nreturn 42;", AllowsMergedIf)); 8575 FormatStyle ShortMergedIf = AllowsMergedIf; 8576 ShortMergedIf.ColumnLimit = 25; 8577 verifyFormat("#define A \\\n" 8578 " if (true) return 42;", 8579 ShortMergedIf); 8580 verifyFormat("#define A \\\n" 8581 " f(); \\\n" 8582 " if (true)\n" 8583 "#define B", 8584 ShortMergedIf); 8585 verifyFormat("#define A \\\n" 8586 " f(); \\\n" 8587 " if (true)\n" 8588 "g();", 8589 ShortMergedIf); 8590 verifyFormat("{\n" 8591 "#ifdef A\n" 8592 " // Comment\n" 8593 " if (true) continue;\n" 8594 "#endif\n" 8595 " // Comment\n" 8596 " if (true) continue;\n" 8597 "}", 8598 ShortMergedIf); 8599 ShortMergedIf.ColumnLimit = 33; 8600 verifyFormat("#define A \\\n" 8601 " if constexpr (true) return 42;", 8602 ShortMergedIf); 8603 ShortMergedIf.ColumnLimit = 29; 8604 verifyFormat("#define A \\\n" 8605 " if (aaaaaaaaaa) return 1; \\\n" 8606 " return 2;", 8607 ShortMergedIf); 8608 ShortMergedIf.ColumnLimit = 28; 8609 verifyFormat("#define A \\\n" 8610 " if (aaaaaaaaaa) \\\n" 8611 " return 1; \\\n" 8612 " return 2;", 8613 ShortMergedIf); 8614 verifyFormat("#define A \\\n" 8615 " if constexpr (aaaaaaa) \\\n" 8616 " return 1; \\\n" 8617 " return 2;", 8618 ShortMergedIf); 8619 } 8620 8621 TEST_F(FormatTest, FormatStarDependingOnContext) { 8622 verifyFormat("void f(int *a);"); 8623 verifyFormat("void f() { f(fint * b); }"); 8624 verifyFormat("class A {\n void f(int *a);\n};"); 8625 verifyFormat("class A {\n int *a;\n};"); 8626 verifyFormat("namespace a {\n" 8627 "namespace b {\n" 8628 "class A {\n" 8629 " void f() {}\n" 8630 " int *a;\n" 8631 "};\n" 8632 "} // namespace b\n" 8633 "} // namespace a"); 8634 } 8635 8636 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 8637 verifyFormat("while"); 8638 verifyFormat("operator"); 8639 } 8640 8641 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 8642 // This code would be painfully slow to format if we didn't skip it. 8643 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 8644 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8645 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8646 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8647 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 8648 "A(1, 1)\n" 8649 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 8650 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8651 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8652 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8653 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8654 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8655 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8656 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8657 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 8658 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 8659 // Deeply nested part is untouched, rest is formatted. 8660 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 8661 format(std::string("int i;\n") + Code + "int j;\n", 8662 getLLVMStyle(), SC_ExpectIncomplete)); 8663 } 8664 8665 //===----------------------------------------------------------------------===// 8666 // Objective-C tests. 8667 //===----------------------------------------------------------------------===// 8668 8669 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 8670 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 8671 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 8672 format("-(NSUInteger)indexOfObject:(id)anObject;")); 8673 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 8674 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 8675 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 8676 format("-(NSInteger)Method3:(id)anObject;")); 8677 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 8678 format("-(NSInteger)Method4:(id)anObject;")); 8679 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 8680 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 8681 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 8682 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 8683 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 8684 "forAllCells:(BOOL)flag;", 8685 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 8686 "forAllCells:(BOOL)flag;")); 8687 8688 // Very long objectiveC method declaration. 8689 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 8690 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 8691 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 8692 " inRange:(NSRange)range\n" 8693 " outRange:(NSRange)out_range\n" 8694 " outRange1:(NSRange)out_range1\n" 8695 " outRange2:(NSRange)out_range2\n" 8696 " outRange3:(NSRange)out_range3\n" 8697 " outRange4:(NSRange)out_range4\n" 8698 " outRange5:(NSRange)out_range5\n" 8699 " outRange6:(NSRange)out_range6\n" 8700 " outRange7:(NSRange)out_range7\n" 8701 " outRange8:(NSRange)out_range8\n" 8702 " outRange9:(NSRange)out_range9;"); 8703 8704 // When the function name has to be wrapped. 8705 FormatStyle Style = getLLVMStyle(); 8706 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 8707 // and always indents instead. 8708 Style.IndentWrappedFunctionNames = false; 8709 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 8710 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 8711 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 8712 "}", 8713 Style); 8714 Style.IndentWrappedFunctionNames = true; 8715 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 8716 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 8717 " anotherName:(NSString)dddddddddddddd {\n" 8718 "}", 8719 Style); 8720 8721 verifyFormat("- (int)sum:(vector<int>)numbers;"); 8722 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 8723 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 8724 // protocol lists (but not for template classes): 8725 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 8726 8727 verifyFormat("- (int (*)())foo:(int (*)())f;"); 8728 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 8729 8730 // If there's no return type (very rare in practice!), LLVM and Google style 8731 // agree. 8732 verifyFormat("- foo;"); 8733 verifyFormat("- foo:(int)f;"); 8734 verifyGoogleFormat("- foo:(int)foo;"); 8735 } 8736 8737 8738 TEST_F(FormatTest, BreaksStringLiterals) { 8739 EXPECT_EQ("\"some text \"\n" 8740 "\"other\";", 8741 format("\"some text other\";", getLLVMStyleWithColumns(12))); 8742 EXPECT_EQ("\"some text \"\n" 8743 "\"other\";", 8744 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 8745 EXPECT_EQ( 8746 "#define A \\\n" 8747 " \"some \" \\\n" 8748 " \"text \" \\\n" 8749 " \"other\";", 8750 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 8751 EXPECT_EQ( 8752 "#define A \\\n" 8753 " \"so \" \\\n" 8754 " \"text \" \\\n" 8755 " \"other\";", 8756 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 8757 8758 EXPECT_EQ("\"some text\"", 8759 format("\"some text\"", getLLVMStyleWithColumns(1))); 8760 EXPECT_EQ("\"some text\"", 8761 format("\"some text\"", getLLVMStyleWithColumns(11))); 8762 EXPECT_EQ("\"some \"\n" 8763 "\"text\"", 8764 format("\"some text\"", getLLVMStyleWithColumns(10))); 8765 EXPECT_EQ("\"some \"\n" 8766 "\"text\"", 8767 format("\"some text\"", getLLVMStyleWithColumns(7))); 8768 EXPECT_EQ("\"some\"\n" 8769 "\" tex\"\n" 8770 "\"t\"", 8771 format("\"some text\"", getLLVMStyleWithColumns(6))); 8772 EXPECT_EQ("\"some\"\n" 8773 "\" tex\"\n" 8774 "\" and\"", 8775 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 8776 EXPECT_EQ("\"some\"\n" 8777 "\"/tex\"\n" 8778 "\"/and\"", 8779 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 8780 8781 EXPECT_EQ("variable =\n" 8782 " \"long string \"\n" 8783 " \"literal\";", 8784 format("variable = \"long string literal\";", 8785 getLLVMStyleWithColumns(20))); 8786 8787 EXPECT_EQ("variable = f(\n" 8788 " \"long string \"\n" 8789 " \"literal\",\n" 8790 " short,\n" 8791 " loooooooooooooooooooong);", 8792 format("variable = f(\"long string literal\", short, " 8793 "loooooooooooooooooooong);", 8794 getLLVMStyleWithColumns(20))); 8795 8796 EXPECT_EQ( 8797 "f(g(\"long string \"\n" 8798 " \"literal\"),\n" 8799 " b);", 8800 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 8801 EXPECT_EQ("f(g(\"long string \"\n" 8802 " \"literal\",\n" 8803 " a),\n" 8804 " b);", 8805 format("f(g(\"long string literal\", a), b);", 8806 getLLVMStyleWithColumns(20))); 8807 EXPECT_EQ( 8808 "f(\"one two\".split(\n" 8809 " variable));", 8810 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 8811 EXPECT_EQ("f(\"one two three four five six \"\n" 8812 " \"seven\".split(\n" 8813 " really_looooong_variable));", 8814 format("f(\"one two three four five six seven\"." 8815 "split(really_looooong_variable));", 8816 getLLVMStyleWithColumns(33))); 8817 8818 EXPECT_EQ("f(\"some \"\n" 8819 " \"text\",\n" 8820 " other);", 8821 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 8822 8823 // Only break as a last resort. 8824 verifyFormat( 8825 "aaaaaaaaaaaaaaaaaaaa(\n" 8826 " aaaaaaaaaaaaaaaaaaaa,\n" 8827 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 8828 8829 EXPECT_EQ("\"splitmea\"\n" 8830 "\"trandomp\"\n" 8831 "\"oint\"", 8832 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 8833 8834 EXPECT_EQ("\"split/\"\n" 8835 "\"pathat/\"\n" 8836 "\"slashes\"", 8837 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 8838 8839 EXPECT_EQ("\"split/\"\n" 8840 "\"pathat/\"\n" 8841 "\"slashes\"", 8842 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 8843 EXPECT_EQ("\"split at \"\n" 8844 "\"spaces/at/\"\n" 8845 "\"slashes.at.any$\"\n" 8846 "\"non-alphanumeric%\"\n" 8847 "\"1111111111characte\"\n" 8848 "\"rs\"", 8849 format("\"split at " 8850 "spaces/at/" 8851 "slashes.at." 8852 "any$non-" 8853 "alphanumeric%" 8854 "1111111111characte" 8855 "rs\"", 8856 getLLVMStyleWithColumns(20))); 8857 8858 // Verify that splitting the strings understands 8859 // Style::AlwaysBreakBeforeMultilineStrings. 8860 EXPECT_EQ( 8861 "aaaaaaaaaaaa(\n" 8862 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 8863 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 8864 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 8865 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 8866 "aaaaaaaaaaaaaaaaaaaaaa\");", 8867 getGoogleStyle())); 8868 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 8869 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 8870 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 8871 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 8872 "aaaaaaaaaaaaaaaaaaaaaa\";", 8873 getGoogleStyle())); 8874 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 8875 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 8876 format("llvm::outs() << " 8877 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 8878 "aaaaaaaaaaaaaaaaaaa\";")); 8879 EXPECT_EQ("ffff(\n" 8880 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 8881 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 8882 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 8883 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 8884 getGoogleStyle())); 8885 8886 FormatStyle Style = getLLVMStyleWithColumns(12); 8887 Style.BreakStringLiterals = false; 8888 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 8889 8890 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 8891 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 8892 EXPECT_EQ("#define A \\\n" 8893 " \"some \" \\\n" 8894 " \"text \" \\\n" 8895 " \"other\";", 8896 format("#define A \"some text other\";", AlignLeft)); 8897 } 8898 8899 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 8900 EXPECT_EQ("C a = \"some more \"\n" 8901 " \"text\";", 8902 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 8903 } 8904 8905 TEST_F(FormatTest, FullyRemoveEmptyLines) { 8906 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 8907 NoEmptyLines.MaxEmptyLinesToKeep = 0; 8908 EXPECT_EQ("int i = a(b());", 8909 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 8910 } 8911 8912 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 8913 EXPECT_EQ( 8914 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 8915 "(\n" 8916 " \"x\t\");", 8917 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 8918 "aaaaaaa(" 8919 "\"x\t\");")); 8920 } 8921 8922 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 8923 EXPECT_EQ( 8924 "u8\"utf8 string \"\n" 8925 "u8\"literal\";", 8926 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 8927 EXPECT_EQ( 8928 "u\"utf16 string \"\n" 8929 "u\"literal\";", 8930 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 8931 EXPECT_EQ( 8932 "U\"utf32 string \"\n" 8933 "U\"literal\";", 8934 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 8935 EXPECT_EQ("L\"wide string \"\n" 8936 "L\"literal\";", 8937 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 8938 EXPECT_EQ("@\"NSString \"\n" 8939 "@\"literal\";", 8940 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 8941 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 8942 8943 // This input makes clang-format try to split the incomplete unicode escape 8944 // sequence, which used to lead to a crasher. 8945 verifyNoCrash( 8946 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 8947 getLLVMStyleWithColumns(60)); 8948 } 8949 8950 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 8951 FormatStyle Style = getGoogleStyleWithColumns(15); 8952 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 8953 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 8954 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 8955 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 8956 EXPECT_EQ("u8R\"x(raw literal)x\";", 8957 format("u8R\"x(raw literal)x\";", Style)); 8958 } 8959 8960 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 8961 FormatStyle Style = getLLVMStyleWithColumns(20); 8962 EXPECT_EQ( 8963 "_T(\"aaaaaaaaaaaaaa\")\n" 8964 "_T(\"aaaaaaaaaaaaaa\")\n" 8965 "_T(\"aaaaaaaaaaaa\")", 8966 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 8967 EXPECT_EQ("f(x,\n" 8968 " _T(\"aaaaaaaaaaaa\")\n" 8969 " _T(\"aaa\"),\n" 8970 " z);", 8971 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 8972 8973 // FIXME: Handle embedded spaces in one iteration. 8974 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 8975 // "_T(\"aaaaaaaaaaaaa\")\n" 8976 // "_T(\"aaaaaaaaaaaaa\")\n" 8977 // "_T(\"a\")", 8978 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 8979 // getLLVMStyleWithColumns(20))); 8980 EXPECT_EQ( 8981 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 8982 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 8983 EXPECT_EQ("f(\n" 8984 "#if !TEST\n" 8985 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 8986 "#endif\n" 8987 ");", 8988 format("f(\n" 8989 "#if !TEST\n" 8990 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 8991 "#endif\n" 8992 ");")); 8993 EXPECT_EQ("f(\n" 8994 "\n" 8995 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 8996 format("f(\n" 8997 "\n" 8998 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 8999 } 9000 9001 TEST_F(FormatTest, BreaksStringLiteralOperands) { 9002 // In a function call with two operands, the second can be broken with no line 9003 // break before it. 9004 EXPECT_EQ("func(a, \"long long \"\n" 9005 " \"long long\");", 9006 format("func(a, \"long long long long\");", 9007 getLLVMStyleWithColumns(24))); 9008 // In a function call with three operands, the second must be broken with a 9009 // line break before it. 9010 EXPECT_EQ("func(a,\n" 9011 " \"long long long \"\n" 9012 " \"long\",\n" 9013 " c);", 9014 format("func(a, \"long long long long\", c);", 9015 getLLVMStyleWithColumns(24))); 9016 // In a function call with three operands, the third must be broken with a 9017 // line break before it. 9018 EXPECT_EQ("func(a, b,\n" 9019 " \"long long long \"\n" 9020 " \"long\");", 9021 format("func(a, b, \"long long long long\");", 9022 getLLVMStyleWithColumns(24))); 9023 // In a function call with three operands, both the second and the third must 9024 // be broken with a line break before them. 9025 EXPECT_EQ("func(a,\n" 9026 " \"long long long \"\n" 9027 " \"long\",\n" 9028 " \"long long long \"\n" 9029 " \"long\");", 9030 format("func(a, \"long long long long\", \"long long long long\");", 9031 getLLVMStyleWithColumns(24))); 9032 // In a chain of << with two operands, the second can be broken with no line 9033 // break before it. 9034 EXPECT_EQ("a << \"line line \"\n" 9035 " \"line\";", 9036 format("a << \"line line line\";", 9037 getLLVMStyleWithColumns(20))); 9038 // In a chain of << with three operands, the second can be broken with no line 9039 // break before it. 9040 EXPECT_EQ("abcde << \"line \"\n" 9041 " \"line line\"\n" 9042 " << c;", 9043 format("abcde << \"line line line\" << c;", 9044 getLLVMStyleWithColumns(20))); 9045 // In a chain of << with three operands, the third must be broken with a line 9046 // break before it. 9047 EXPECT_EQ("a << b\n" 9048 " << \"line line \"\n" 9049 " \"line\";", 9050 format("a << b << \"line line line\";", 9051 getLLVMStyleWithColumns(20))); 9052 // In a chain of << with three operands, the second can be broken with no line 9053 // break before it and the third must be broken with a line break before it. 9054 EXPECT_EQ("abcd << \"line line \"\n" 9055 " \"line\"\n" 9056 " << \"line line \"\n" 9057 " \"line\";", 9058 format("abcd << \"line line line\" << \"line line line\";", 9059 getLLVMStyleWithColumns(20))); 9060 // In a chain of binary operators with two operands, the second can be broken 9061 // with no line break before it. 9062 EXPECT_EQ("abcd + \"line line \"\n" 9063 " \"line line\";", 9064 format("abcd + \"line line line line\";", 9065 getLLVMStyleWithColumns(20))); 9066 // In a chain of binary operators with three operands, the second must be 9067 // broken with a line break before it. 9068 EXPECT_EQ("abcd +\n" 9069 " \"line line \"\n" 9070 " \"line line\" +\n" 9071 " e;", 9072 format("abcd + \"line line line line\" + e;", 9073 getLLVMStyleWithColumns(20))); 9074 // In a function call with two operands, with AlignAfterOpenBracket enabled, 9075 // the first must be broken with a line break before it. 9076 FormatStyle Style = getLLVMStyleWithColumns(25); 9077 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 9078 EXPECT_EQ("someFunction(\n" 9079 " \"long long long \"\n" 9080 " \"long\",\n" 9081 " a);", 9082 format("someFunction(\"long long long long\", a);", Style)); 9083 } 9084 9085 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 9086 EXPECT_EQ( 9087 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9088 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9089 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9090 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9091 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9092 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 9093 } 9094 9095 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 9096 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 9097 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 9098 EXPECT_EQ("fffffffffff(g(R\"x(\n" 9099 "multiline raw string literal xxxxxxxxxxxxxx\n" 9100 ")x\",\n" 9101 " a),\n" 9102 " b);", 9103 format("fffffffffff(g(R\"x(\n" 9104 "multiline raw string literal xxxxxxxxxxxxxx\n" 9105 ")x\", a), b);", 9106 getGoogleStyleWithColumns(20))); 9107 EXPECT_EQ("fffffffffff(\n" 9108 " g(R\"x(qqq\n" 9109 "multiline raw string literal xxxxxxxxxxxxxx\n" 9110 ")x\",\n" 9111 " a),\n" 9112 " b);", 9113 format("fffffffffff(g(R\"x(qqq\n" 9114 "multiline raw string literal xxxxxxxxxxxxxx\n" 9115 ")x\", a), b);", 9116 getGoogleStyleWithColumns(20))); 9117 9118 EXPECT_EQ("fffffffffff(R\"x(\n" 9119 "multiline raw string literal xxxxxxxxxxxxxx\n" 9120 ")x\");", 9121 format("fffffffffff(R\"x(\n" 9122 "multiline raw string literal xxxxxxxxxxxxxx\n" 9123 ")x\");", 9124 getGoogleStyleWithColumns(20))); 9125 EXPECT_EQ("fffffffffff(R\"x(\n" 9126 "multiline raw string literal xxxxxxxxxxxxxx\n" 9127 ")x\" + bbbbbb);", 9128 format("fffffffffff(R\"x(\n" 9129 "multiline raw string literal xxxxxxxxxxxxxx\n" 9130 ")x\" + bbbbbb);", 9131 getGoogleStyleWithColumns(20))); 9132 EXPECT_EQ("fffffffffff(\n" 9133 " R\"x(\n" 9134 "multiline raw string literal xxxxxxxxxxxxxx\n" 9135 ")x\" +\n" 9136 " bbbbbb);", 9137 format("fffffffffff(\n" 9138 " R\"x(\n" 9139 "multiline raw string literal xxxxxxxxxxxxxx\n" 9140 ")x\" + bbbbbb);", 9141 getGoogleStyleWithColumns(20))); 9142 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 9143 format("fffffffffff(\n" 9144 " R\"(single line raw string)\" + bbbbbb);")); 9145 } 9146 9147 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 9148 verifyFormat("string a = \"unterminated;"); 9149 EXPECT_EQ("function(\"unterminated,\n" 9150 " OtherParameter);", 9151 format("function( \"unterminated,\n" 9152 " OtherParameter);")); 9153 } 9154 9155 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9156 FormatStyle Style = getLLVMStyle(); 9157 Style.Standard = FormatStyle::LS_Cpp03; 9158 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9159 format("#define x(_a) printf(\"foo\"_a);", Style)); 9160 } 9161 9162 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9163 9164 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9165 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9166 " \"ddeeefff\");", 9167 format("someFunction(\"aaabbbcccdddeeefff\");", 9168 getLLVMStyleWithColumns(25))); 9169 EXPECT_EQ("someFunction1234567890(\n" 9170 " \"aaabbbcccdddeeefff\");", 9171 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9172 getLLVMStyleWithColumns(26))); 9173 EXPECT_EQ("someFunction1234567890(\n" 9174 " \"aaabbbcccdddeeeff\"\n" 9175 " \"f\");", 9176 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9177 getLLVMStyleWithColumns(25))); 9178 EXPECT_EQ("someFunction1234567890(\n" 9179 " \"aaabbbcccdddeeeff\"\n" 9180 " \"f\");", 9181 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9182 getLLVMStyleWithColumns(24))); 9183 EXPECT_EQ("someFunction(\n" 9184 " \"aaabbbcc ddde \"\n" 9185 " \"efff\");", 9186 format("someFunction(\"aaabbbcc ddde efff\");", 9187 getLLVMStyleWithColumns(25))); 9188 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9189 " \"ddeeefff\");", 9190 format("someFunction(\"aaabbbccc ddeeefff\");", 9191 getLLVMStyleWithColumns(25))); 9192 EXPECT_EQ("someFunction1234567890(\n" 9193 " \"aaabb \"\n" 9194 " \"cccdddeeefff\");", 9195 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9196 getLLVMStyleWithColumns(25))); 9197 EXPECT_EQ("#define A \\\n" 9198 " string s = \\\n" 9199 " \"123456789\" \\\n" 9200 " \"0\"; \\\n" 9201 " int i;", 9202 format("#define A string s = \"1234567890\"; int i;", 9203 getLLVMStyleWithColumns(20))); 9204 EXPECT_EQ("someFunction(\n" 9205 " \"aaabbbcc \"\n" 9206 " \"dddeeefff\");", 9207 format("someFunction(\"aaabbbcc dddeeefff\");", 9208 getLLVMStyleWithColumns(25))); 9209 } 9210 9211 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9212 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9213 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9214 EXPECT_EQ("\"test\"\n" 9215 "\"\\n\"", 9216 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9217 EXPECT_EQ("\"tes\\\\\"\n" 9218 "\"n\"", 9219 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9220 EXPECT_EQ("\"\\\\\\\\\"\n" 9221 "\"\\n\"", 9222 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9223 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9224 EXPECT_EQ("\"\\uff01\"\n" 9225 "\"test\"", 9226 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9227 EXPECT_EQ("\"\\Uff01ff02\"", 9228 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9229 EXPECT_EQ("\"\\x000000000001\"\n" 9230 "\"next\"", 9231 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9232 EXPECT_EQ("\"\\x000000000001next\"", 9233 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9234 EXPECT_EQ("\"\\x000000000001\"", 9235 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9236 EXPECT_EQ("\"test\"\n" 9237 "\"\\000000\"\n" 9238 "\"000001\"", 9239 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9240 EXPECT_EQ("\"test\\000\"\n" 9241 "\"00000000\"\n" 9242 "\"1\"", 9243 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9244 } 9245 9246 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9247 verifyFormat("void f() {\n" 9248 " return g() {}\n" 9249 " void h() {}"); 9250 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9251 "g();\n" 9252 "}"); 9253 } 9254 9255 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9256 verifyFormat( 9257 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9258 } 9259 9260 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9261 verifyFormat("class X {\n" 9262 " void f() {\n" 9263 " }\n" 9264 "};", 9265 getLLVMStyleWithColumns(12)); 9266 } 9267 9268 TEST_F(FormatTest, ConfigurableIndentWidth) { 9269 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9270 EightIndent.IndentWidth = 8; 9271 EightIndent.ContinuationIndentWidth = 8; 9272 verifyFormat("void f() {\n" 9273 " someFunction();\n" 9274 " if (true) {\n" 9275 " f();\n" 9276 " }\n" 9277 "}", 9278 EightIndent); 9279 verifyFormat("class X {\n" 9280 " void f() {\n" 9281 " }\n" 9282 "};", 9283 EightIndent); 9284 verifyFormat("int x[] = {\n" 9285 " call(),\n" 9286 " call()};", 9287 EightIndent); 9288 } 9289 9290 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9291 verifyFormat("double\n" 9292 "f();", 9293 getLLVMStyleWithColumns(8)); 9294 } 9295 9296 TEST_F(FormatTest, ConfigurableUseOfTab) { 9297 FormatStyle Tab = getLLVMStyleWithColumns(42); 9298 Tab.IndentWidth = 8; 9299 Tab.UseTab = FormatStyle::UT_Always; 9300 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9301 9302 EXPECT_EQ("if (aaaaaaaa && // q\n" 9303 " bb)\t\t// w\n" 9304 "\t;", 9305 format("if (aaaaaaaa &&// q\n" 9306 "bb)// w\n" 9307 ";", 9308 Tab)); 9309 EXPECT_EQ("if (aaa && bbb) // w\n" 9310 "\t;", 9311 format("if(aaa&&bbb)// w\n" 9312 ";", 9313 Tab)); 9314 9315 verifyFormat("class X {\n" 9316 "\tvoid f() {\n" 9317 "\t\tsomeFunction(parameter1,\n" 9318 "\t\t\t parameter2);\n" 9319 "\t}\n" 9320 "};", 9321 Tab); 9322 verifyFormat("#define A \\\n" 9323 "\tvoid f() { \\\n" 9324 "\t\tsomeFunction( \\\n" 9325 "\t\t parameter1, \\\n" 9326 "\t\t parameter2); \\\n" 9327 "\t}", 9328 Tab); 9329 verifyFormat("int a;\t // x\n" 9330 "int bbbbbbbb; // x\n", 9331 Tab); 9332 9333 Tab.TabWidth = 4; 9334 Tab.IndentWidth = 8; 9335 verifyFormat("class TabWidth4Indent8 {\n" 9336 "\t\tvoid f() {\n" 9337 "\t\t\t\tsomeFunction(parameter1,\n" 9338 "\t\t\t\t\t\t\t parameter2);\n" 9339 "\t\t}\n" 9340 "};", 9341 Tab); 9342 9343 Tab.TabWidth = 4; 9344 Tab.IndentWidth = 4; 9345 verifyFormat("class TabWidth4Indent4 {\n" 9346 "\tvoid f() {\n" 9347 "\t\tsomeFunction(parameter1,\n" 9348 "\t\t\t\t\t parameter2);\n" 9349 "\t}\n" 9350 "};", 9351 Tab); 9352 9353 Tab.TabWidth = 8; 9354 Tab.IndentWidth = 4; 9355 verifyFormat("class TabWidth8Indent4 {\n" 9356 " void f() {\n" 9357 "\tsomeFunction(parameter1,\n" 9358 "\t\t parameter2);\n" 9359 " }\n" 9360 "};", 9361 Tab); 9362 9363 Tab.TabWidth = 8; 9364 Tab.IndentWidth = 8; 9365 EXPECT_EQ("/*\n" 9366 "\t a\t\tcomment\n" 9367 "\t in multiple lines\n" 9368 " */", 9369 format(" /*\t \t \n" 9370 " \t \t a\t\tcomment\t \t\n" 9371 " \t \t in multiple lines\t\n" 9372 " \t */", 9373 Tab)); 9374 9375 Tab.UseTab = FormatStyle::UT_ForIndentation; 9376 verifyFormat("{\n" 9377 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9378 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9379 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9380 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9381 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9382 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9383 "};", 9384 Tab); 9385 verifyFormat("enum AA {\n" 9386 "\ta1, // Force multiple lines\n" 9387 "\ta2,\n" 9388 "\ta3\n" 9389 "};", 9390 Tab); 9391 EXPECT_EQ("if (aaaaaaaa && // q\n" 9392 " bb) // w\n" 9393 "\t;", 9394 format("if (aaaaaaaa &&// q\n" 9395 "bb)// w\n" 9396 ";", 9397 Tab)); 9398 verifyFormat("class X {\n" 9399 "\tvoid f() {\n" 9400 "\t\tsomeFunction(parameter1,\n" 9401 "\t\t parameter2);\n" 9402 "\t}\n" 9403 "};", 9404 Tab); 9405 verifyFormat("{\n" 9406 "\tQ(\n" 9407 "\t {\n" 9408 "\t\t int a;\n" 9409 "\t\t someFunction(aaaaaaaa,\n" 9410 "\t\t bbbbbbb);\n" 9411 "\t },\n" 9412 "\t p);\n" 9413 "}", 9414 Tab); 9415 EXPECT_EQ("{\n" 9416 "\t/* aaaa\n" 9417 "\t bbbb */\n" 9418 "}", 9419 format("{\n" 9420 "/* aaaa\n" 9421 " bbbb */\n" 9422 "}", 9423 Tab)); 9424 EXPECT_EQ("{\n" 9425 "\t/*\n" 9426 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9427 "\t bbbbbbbbbbbbb\n" 9428 "\t*/\n" 9429 "}", 9430 format("{\n" 9431 "/*\n" 9432 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9433 "*/\n" 9434 "}", 9435 Tab)); 9436 EXPECT_EQ("{\n" 9437 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9438 "\t// bbbbbbbbbbbbb\n" 9439 "}", 9440 format("{\n" 9441 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9442 "}", 9443 Tab)); 9444 EXPECT_EQ("{\n" 9445 "\t/*\n" 9446 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9447 "\t bbbbbbbbbbbbb\n" 9448 "\t*/\n" 9449 "}", 9450 format("{\n" 9451 "\t/*\n" 9452 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9453 "\t*/\n" 9454 "}", 9455 Tab)); 9456 EXPECT_EQ("{\n" 9457 "\t/*\n" 9458 "\n" 9459 "\t*/\n" 9460 "}", 9461 format("{\n" 9462 "\t/*\n" 9463 "\n" 9464 "\t*/\n" 9465 "}", 9466 Tab)); 9467 EXPECT_EQ("{\n" 9468 "\t/*\n" 9469 " asdf\n" 9470 "\t*/\n" 9471 "}", 9472 format("{\n" 9473 "\t/*\n" 9474 " asdf\n" 9475 "\t*/\n" 9476 "}", 9477 Tab)); 9478 9479 Tab.UseTab = FormatStyle::UT_Never; 9480 EXPECT_EQ("/*\n" 9481 " a\t\tcomment\n" 9482 " in multiple lines\n" 9483 " */", 9484 format(" /*\t \t \n" 9485 " \t \t a\t\tcomment\t \t\n" 9486 " \t \t in multiple lines\t\n" 9487 " \t */", 9488 Tab)); 9489 EXPECT_EQ("/* some\n" 9490 " comment */", 9491 format(" \t \t /* some\n" 9492 " \t \t comment */", 9493 Tab)); 9494 EXPECT_EQ("int a; /* some\n" 9495 " comment */", 9496 format(" \t \t int a; /* some\n" 9497 " \t \t comment */", 9498 Tab)); 9499 9500 EXPECT_EQ("int a; /* some\n" 9501 "comment */", 9502 format(" \t \t int\ta; /* some\n" 9503 " \t \t comment */", 9504 Tab)); 9505 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9506 " comment */", 9507 format(" \t \t f(\"\t\t\"); /* some\n" 9508 " \t \t comment */", 9509 Tab)); 9510 EXPECT_EQ("{\n" 9511 " /*\n" 9512 " * Comment\n" 9513 " */\n" 9514 " int i;\n" 9515 "}", 9516 format("{\n" 9517 "\t/*\n" 9518 "\t * Comment\n" 9519 "\t */\n" 9520 "\t int i;\n" 9521 "}")); 9522 9523 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 9524 Tab.TabWidth = 8; 9525 Tab.IndentWidth = 8; 9526 EXPECT_EQ("if (aaaaaaaa && // q\n" 9527 " bb) // w\n" 9528 "\t;", 9529 format("if (aaaaaaaa &&// q\n" 9530 "bb)// w\n" 9531 ";", 9532 Tab)); 9533 EXPECT_EQ("if (aaa && bbb) // w\n" 9534 "\t;", 9535 format("if(aaa&&bbb)// w\n" 9536 ";", 9537 Tab)); 9538 verifyFormat("class X {\n" 9539 "\tvoid f() {\n" 9540 "\t\tsomeFunction(parameter1,\n" 9541 "\t\t\t parameter2);\n" 9542 "\t}\n" 9543 "};", 9544 Tab); 9545 verifyFormat("#define A \\\n" 9546 "\tvoid f() { \\\n" 9547 "\t\tsomeFunction( \\\n" 9548 "\t\t parameter1, \\\n" 9549 "\t\t parameter2); \\\n" 9550 "\t}", 9551 Tab); 9552 Tab.TabWidth = 4; 9553 Tab.IndentWidth = 8; 9554 verifyFormat("class TabWidth4Indent8 {\n" 9555 "\t\tvoid f() {\n" 9556 "\t\t\t\tsomeFunction(parameter1,\n" 9557 "\t\t\t\t\t\t\t parameter2);\n" 9558 "\t\t}\n" 9559 "};", 9560 Tab); 9561 Tab.TabWidth = 4; 9562 Tab.IndentWidth = 4; 9563 verifyFormat("class TabWidth4Indent4 {\n" 9564 "\tvoid f() {\n" 9565 "\t\tsomeFunction(parameter1,\n" 9566 "\t\t\t\t\t parameter2);\n" 9567 "\t}\n" 9568 "};", 9569 Tab); 9570 Tab.TabWidth = 8; 9571 Tab.IndentWidth = 4; 9572 verifyFormat("class TabWidth8Indent4 {\n" 9573 " void f() {\n" 9574 "\tsomeFunction(parameter1,\n" 9575 "\t\t parameter2);\n" 9576 " }\n" 9577 "};", 9578 Tab); 9579 Tab.TabWidth = 8; 9580 Tab.IndentWidth = 8; 9581 EXPECT_EQ("/*\n" 9582 "\t a\t\tcomment\n" 9583 "\t in multiple lines\n" 9584 " */", 9585 format(" /*\t \t \n" 9586 " \t \t a\t\tcomment\t \t\n" 9587 " \t \t in multiple lines\t\n" 9588 " \t */", 9589 Tab)); 9590 verifyFormat("{\n" 9591 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9592 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9593 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9594 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9595 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9596 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9597 "};", 9598 Tab); 9599 verifyFormat("enum AA {\n" 9600 "\ta1, // Force multiple lines\n" 9601 "\ta2,\n" 9602 "\ta3\n" 9603 "};", 9604 Tab); 9605 EXPECT_EQ("if (aaaaaaaa && // q\n" 9606 " bb) // w\n" 9607 "\t;", 9608 format("if (aaaaaaaa &&// q\n" 9609 "bb)// w\n" 9610 ";", 9611 Tab)); 9612 verifyFormat("class X {\n" 9613 "\tvoid f() {\n" 9614 "\t\tsomeFunction(parameter1,\n" 9615 "\t\t\t parameter2);\n" 9616 "\t}\n" 9617 "};", 9618 Tab); 9619 verifyFormat("{\n" 9620 "\tQ(\n" 9621 "\t {\n" 9622 "\t\t int a;\n" 9623 "\t\t someFunction(aaaaaaaa,\n" 9624 "\t\t\t\t bbbbbbb);\n" 9625 "\t },\n" 9626 "\t p);\n" 9627 "}", 9628 Tab); 9629 EXPECT_EQ("{\n" 9630 "\t/* aaaa\n" 9631 "\t bbbb */\n" 9632 "}", 9633 format("{\n" 9634 "/* aaaa\n" 9635 " bbbb */\n" 9636 "}", 9637 Tab)); 9638 EXPECT_EQ("{\n" 9639 "\t/*\n" 9640 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9641 "\t bbbbbbbbbbbbb\n" 9642 "\t*/\n" 9643 "}", 9644 format("{\n" 9645 "/*\n" 9646 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9647 "*/\n" 9648 "}", 9649 Tab)); 9650 EXPECT_EQ("{\n" 9651 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9652 "\t// bbbbbbbbbbbbb\n" 9653 "}", 9654 format("{\n" 9655 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9656 "}", 9657 Tab)); 9658 EXPECT_EQ("{\n" 9659 "\t/*\n" 9660 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9661 "\t bbbbbbbbbbbbb\n" 9662 "\t*/\n" 9663 "}", 9664 format("{\n" 9665 "\t/*\n" 9666 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9667 "\t*/\n" 9668 "}", 9669 Tab)); 9670 EXPECT_EQ("{\n" 9671 "\t/*\n" 9672 "\n" 9673 "\t*/\n" 9674 "}", 9675 format("{\n" 9676 "\t/*\n" 9677 "\n" 9678 "\t*/\n" 9679 "}", 9680 Tab)); 9681 EXPECT_EQ("{\n" 9682 "\t/*\n" 9683 " asdf\n" 9684 "\t*/\n" 9685 "}", 9686 format("{\n" 9687 "\t/*\n" 9688 " asdf\n" 9689 "\t*/\n" 9690 "}", 9691 Tab)); 9692 EXPECT_EQ("/*\n" 9693 "\t a\t\tcomment\n" 9694 "\t in multiple lines\n" 9695 " */", 9696 format(" /*\t \t \n" 9697 " \t \t a\t\tcomment\t \t\n" 9698 " \t \t in multiple lines\t\n" 9699 " \t */", 9700 Tab)); 9701 EXPECT_EQ("/* some\n" 9702 " comment */", 9703 format(" \t \t /* some\n" 9704 " \t \t comment */", 9705 Tab)); 9706 EXPECT_EQ("int a; /* some\n" 9707 " comment */", 9708 format(" \t \t int a; /* some\n" 9709 " \t \t comment */", 9710 Tab)); 9711 EXPECT_EQ("int a; /* some\n" 9712 "comment */", 9713 format(" \t \t int\ta; /* some\n" 9714 " \t \t comment */", 9715 Tab)); 9716 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9717 " comment */", 9718 format(" \t \t f(\"\t\t\"); /* some\n" 9719 " \t \t comment */", 9720 Tab)); 9721 EXPECT_EQ("{\n" 9722 " /*\n" 9723 " * Comment\n" 9724 " */\n" 9725 " int i;\n" 9726 "}", 9727 format("{\n" 9728 "\t/*\n" 9729 "\t * Comment\n" 9730 "\t */\n" 9731 "\t int i;\n" 9732 "}")); 9733 Tab.AlignConsecutiveAssignments = true; 9734 Tab.AlignConsecutiveDeclarations = true; 9735 Tab.TabWidth = 4; 9736 Tab.IndentWidth = 4; 9737 verifyFormat("class Assign {\n" 9738 "\tvoid f() {\n" 9739 "\t\tint x = 123;\n" 9740 "\t\tint random = 4;\n" 9741 "\t\tstd::string alphabet =\n" 9742 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 9743 "\t}\n" 9744 "};", 9745 Tab); 9746 } 9747 9748 TEST_F(FormatTest, CalculatesOriginalColumn) { 9749 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9750 "q\"; /* some\n" 9751 " comment */", 9752 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9753 "q\"; /* some\n" 9754 " comment */", 9755 getLLVMStyle())); 9756 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 9757 "/* some\n" 9758 " comment */", 9759 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 9760 " /* some\n" 9761 " comment */", 9762 getLLVMStyle())); 9763 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9764 "qqq\n" 9765 "/* some\n" 9766 " comment */", 9767 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9768 "qqq\n" 9769 " /* some\n" 9770 " comment */", 9771 getLLVMStyle())); 9772 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9773 "wwww; /* some\n" 9774 " comment */", 9775 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 9776 "wwww; /* some\n" 9777 " comment */", 9778 getLLVMStyle())); 9779 } 9780 9781 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 9782 FormatStyle NoSpace = getLLVMStyle(); 9783 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 9784 9785 verifyFormat("while(true)\n" 9786 " continue;", 9787 NoSpace); 9788 verifyFormat("for(;;)\n" 9789 " continue;", 9790 NoSpace); 9791 verifyFormat("if(true)\n" 9792 " f();\n" 9793 "else if(true)\n" 9794 " f();", 9795 NoSpace); 9796 verifyFormat("do {\n" 9797 " do_something();\n" 9798 "} while(something());", 9799 NoSpace); 9800 verifyFormat("switch(x) {\n" 9801 "default:\n" 9802 " break;\n" 9803 "}", 9804 NoSpace); 9805 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 9806 verifyFormat("size_t x = sizeof(x);", NoSpace); 9807 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 9808 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 9809 verifyFormat("alignas(128) char a[128];", NoSpace); 9810 verifyFormat("size_t x = alignof(MyType);", NoSpace); 9811 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 9812 verifyFormat("int f() throw(Deprecated);", NoSpace); 9813 verifyFormat("typedef void (*cb)(int);", NoSpace); 9814 verifyFormat("T A::operator()();", NoSpace); 9815 verifyFormat("X A::operator++(T);", NoSpace); 9816 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 9817 9818 FormatStyle Space = getLLVMStyle(); 9819 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 9820 9821 verifyFormat("int f ();", Space); 9822 verifyFormat("void f (int a, T b) {\n" 9823 " while (true)\n" 9824 " continue;\n" 9825 "}", 9826 Space); 9827 verifyFormat("if (true)\n" 9828 " f ();\n" 9829 "else if (true)\n" 9830 " f ();", 9831 Space); 9832 verifyFormat("do {\n" 9833 " do_something ();\n" 9834 "} while (something ());", 9835 Space); 9836 verifyFormat("switch (x) {\n" 9837 "default:\n" 9838 " break;\n" 9839 "}", 9840 Space); 9841 verifyFormat("A::A () : a (1) {}", Space); 9842 verifyFormat("void f () __attribute__ ((asdf));", Space); 9843 verifyFormat("*(&a + 1);\n" 9844 "&((&a)[1]);\n" 9845 "a[(b + c) * d];\n" 9846 "(((a + 1) * 2) + 3) * 4;", 9847 Space); 9848 verifyFormat("#define A(x) x", Space); 9849 verifyFormat("#define A (x) x", Space); 9850 verifyFormat("#if defined(x)\n" 9851 "#endif", 9852 Space); 9853 verifyFormat("auto i = std::make_unique<int> (5);", Space); 9854 verifyFormat("size_t x = sizeof (x);", Space); 9855 verifyFormat("auto f (int x) -> decltype (x);", Space); 9856 verifyFormat("int f (T x) noexcept (x.create ());", Space); 9857 verifyFormat("alignas (128) char a[128];", Space); 9858 verifyFormat("size_t x = alignof (MyType);", Space); 9859 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 9860 verifyFormat("int f () throw (Deprecated);", Space); 9861 verifyFormat("typedef void (*cb) (int);", Space); 9862 verifyFormat("T A::operator() ();", Space); 9863 verifyFormat("X A::operator++ (T);", Space); 9864 verifyFormat("auto lambda = [] () { return 0; };", Space); 9865 verifyFormat("int x = int (y);", Space); 9866 9867 FormatStyle SomeSpace = getLLVMStyle(); 9868 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 9869 9870 verifyFormat("[]() -> float {}", SomeSpace); 9871 verifyFormat("[] (auto foo) {}", SomeSpace); 9872 verifyFormat("[foo]() -> int {}", SomeSpace); 9873 verifyFormat("int f();", SomeSpace); 9874 verifyFormat("void f (int a, T b) {\n" 9875 " while (true)\n" 9876 " continue;\n" 9877 "}", 9878 SomeSpace); 9879 verifyFormat("if (true)\n" 9880 " f();\n" 9881 "else if (true)\n" 9882 " f();", 9883 SomeSpace); 9884 verifyFormat("do {\n" 9885 " do_something();\n" 9886 "} while (something());", 9887 SomeSpace); 9888 verifyFormat("switch (x) {\n" 9889 "default:\n" 9890 " break;\n" 9891 "}", 9892 SomeSpace); 9893 verifyFormat("A::A() : a (1) {}", SomeSpace); 9894 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 9895 verifyFormat("*(&a + 1);\n" 9896 "&((&a)[1]);\n" 9897 "a[(b + c) * d];\n" 9898 "(((a + 1) * 2) + 3) * 4;", 9899 SomeSpace); 9900 verifyFormat("#define A(x) x", SomeSpace); 9901 verifyFormat("#define A (x) x", SomeSpace); 9902 verifyFormat("#if defined(x)\n" 9903 "#endif", 9904 SomeSpace); 9905 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 9906 verifyFormat("size_t x = sizeof (x);", SomeSpace); 9907 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 9908 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 9909 verifyFormat("alignas (128) char a[128];", SomeSpace); 9910 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 9911 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 9912 SomeSpace); 9913 verifyFormat("int f() throw (Deprecated);", SomeSpace); 9914 verifyFormat("typedef void (*cb) (int);", SomeSpace); 9915 verifyFormat("T A::operator()();", SomeSpace); 9916 verifyFormat("X A::operator++ (T);", SomeSpace); 9917 verifyFormat("int x = int (y);", SomeSpace); 9918 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 9919 } 9920 9921 TEST_F(FormatTest, SpaceAfterLogicalNot) { 9922 FormatStyle Spaces = getLLVMStyle(); 9923 Spaces.SpaceAfterLogicalNot = true; 9924 9925 verifyFormat("bool x = ! y", Spaces); 9926 verifyFormat("if (! isFailure())", Spaces); 9927 verifyFormat("if (! (a && b))", Spaces); 9928 verifyFormat("\"Error!\"", Spaces); 9929 verifyFormat("! ! x", Spaces); 9930 } 9931 9932 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 9933 FormatStyle Spaces = getLLVMStyle(); 9934 9935 Spaces.SpacesInParentheses = true; 9936 verifyFormat("do_something( ::globalVar );", Spaces); 9937 verifyFormat("call( x, y, z );", Spaces); 9938 verifyFormat("call();", Spaces); 9939 verifyFormat("std::function<void( int, int )> callback;", Spaces); 9940 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 9941 Spaces); 9942 verifyFormat("while ( (bool)1 )\n" 9943 " continue;", 9944 Spaces); 9945 verifyFormat("for ( ;; )\n" 9946 " continue;", 9947 Spaces); 9948 verifyFormat("if ( true )\n" 9949 " f();\n" 9950 "else if ( true )\n" 9951 " f();", 9952 Spaces); 9953 verifyFormat("do {\n" 9954 " do_something( (int)i );\n" 9955 "} while ( something() );", 9956 Spaces); 9957 verifyFormat("switch ( x ) {\n" 9958 "default:\n" 9959 " break;\n" 9960 "}", 9961 Spaces); 9962 9963 Spaces.SpacesInParentheses = false; 9964 Spaces.SpacesInCStyleCastParentheses = true; 9965 verifyFormat("Type *A = ( Type * )P;", Spaces); 9966 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 9967 verifyFormat("x = ( int32 )y;", Spaces); 9968 verifyFormat("int a = ( int )(2.0f);", Spaces); 9969 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 9970 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 9971 verifyFormat("#define x (( int )-1)", Spaces); 9972 9973 // Run the first set of tests again with: 9974 Spaces.SpacesInParentheses = false; 9975 Spaces.SpaceInEmptyParentheses = true; 9976 Spaces.SpacesInCStyleCastParentheses = true; 9977 verifyFormat("call(x, y, z);", Spaces); 9978 verifyFormat("call( );", Spaces); 9979 verifyFormat("std::function<void(int, int)> callback;", Spaces); 9980 verifyFormat("while (( bool )1)\n" 9981 " continue;", 9982 Spaces); 9983 verifyFormat("for (;;)\n" 9984 " continue;", 9985 Spaces); 9986 verifyFormat("if (true)\n" 9987 " f( );\n" 9988 "else if (true)\n" 9989 " f( );", 9990 Spaces); 9991 verifyFormat("do {\n" 9992 " do_something(( int )i);\n" 9993 "} while (something( ));", 9994 Spaces); 9995 verifyFormat("switch (x) {\n" 9996 "default:\n" 9997 " break;\n" 9998 "}", 9999 Spaces); 10000 10001 // Run the first set of tests again with: 10002 Spaces.SpaceAfterCStyleCast = true; 10003 verifyFormat("call(x, y, z);", Spaces); 10004 verifyFormat("call( );", Spaces); 10005 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10006 verifyFormat("while (( bool ) 1)\n" 10007 " continue;", 10008 Spaces); 10009 verifyFormat("for (;;)\n" 10010 " continue;", 10011 Spaces); 10012 verifyFormat("if (true)\n" 10013 " f( );\n" 10014 "else if (true)\n" 10015 " f( );", 10016 Spaces); 10017 verifyFormat("do {\n" 10018 " do_something(( int ) i);\n" 10019 "} while (something( ));", 10020 Spaces); 10021 verifyFormat("switch (x) {\n" 10022 "default:\n" 10023 " break;\n" 10024 "}", 10025 Spaces); 10026 10027 // Run subset of tests again with: 10028 Spaces.SpacesInCStyleCastParentheses = false; 10029 Spaces.SpaceAfterCStyleCast = true; 10030 verifyFormat("while ((bool) 1)\n" 10031 " continue;", 10032 Spaces); 10033 verifyFormat("do {\n" 10034 " do_something((int) i);\n" 10035 "} while (something( ));", 10036 Spaces); 10037 } 10038 10039 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 10040 verifyFormat("int a[5];"); 10041 verifyFormat("a[3] += 42;"); 10042 10043 FormatStyle Spaces = getLLVMStyle(); 10044 Spaces.SpacesInSquareBrackets = true; 10045 // Lambdas unchanged. 10046 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 10047 verifyFormat("return [i, args...] {};", Spaces); 10048 10049 // Not lambdas. 10050 verifyFormat("int a[ 5 ];", Spaces); 10051 verifyFormat("a[ 3 ] += 42;", Spaces); 10052 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 10053 verifyFormat("double &operator[](int i) { return 0; }\n" 10054 "int i;", 10055 Spaces); 10056 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 10057 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 10058 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 10059 } 10060 10061 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 10062 verifyFormat("int a = 5;"); 10063 verifyFormat("a += 42;"); 10064 verifyFormat("a or_eq 8;"); 10065 10066 FormatStyle Spaces = getLLVMStyle(); 10067 Spaces.SpaceBeforeAssignmentOperators = false; 10068 verifyFormat("int a= 5;", Spaces); 10069 verifyFormat("a+= 42;", Spaces); 10070 verifyFormat("a or_eq 8;", Spaces); 10071 } 10072 10073 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 10074 verifyFormat("class Foo : public Bar {};"); 10075 verifyFormat("Foo::Foo() : foo(1) {}"); 10076 verifyFormat("for (auto a : b) {\n}"); 10077 verifyFormat("int x = a ? b : c;"); 10078 verifyFormat("{\n" 10079 "label0:\n" 10080 " int x = 0;\n" 10081 "}"); 10082 verifyFormat("switch (x) {\n" 10083 "case 1:\n" 10084 "default:\n" 10085 "}"); 10086 10087 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 10088 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 10089 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 10090 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 10091 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 10092 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 10093 verifyFormat("{\n" 10094 "label1:\n" 10095 " int x = 0;\n" 10096 "}", 10097 CtorInitializerStyle); 10098 verifyFormat("switch (x) {\n" 10099 "case 1:\n" 10100 "default:\n" 10101 "}", 10102 CtorInitializerStyle); 10103 CtorInitializerStyle.BreakConstructorInitializers = 10104 FormatStyle::BCIS_AfterColon; 10105 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 10106 " aaaaaaaaaaaaaaaa(1),\n" 10107 " bbbbbbbbbbbbbbbb(2) {}", 10108 CtorInitializerStyle); 10109 CtorInitializerStyle.BreakConstructorInitializers = 10110 FormatStyle::BCIS_BeforeComma; 10111 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10112 " : aaaaaaaaaaaaaaaa(1)\n" 10113 " , bbbbbbbbbbbbbbbb(2) {}", 10114 CtorInitializerStyle); 10115 CtorInitializerStyle.BreakConstructorInitializers = 10116 FormatStyle::BCIS_BeforeColon; 10117 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10118 " : aaaaaaaaaaaaaaaa(1),\n" 10119 " bbbbbbbbbbbbbbbb(2) {}", 10120 CtorInitializerStyle); 10121 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 10122 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10123 ": aaaaaaaaaaaaaaaa(1),\n" 10124 " bbbbbbbbbbbbbbbb(2) {}", 10125 CtorInitializerStyle); 10126 10127 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 10128 InheritanceStyle.SpaceBeforeInheritanceColon = false; 10129 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 10130 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 10131 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 10132 verifyFormat("int x = a ? b : c;", InheritanceStyle); 10133 verifyFormat("{\n" 10134 "label2:\n" 10135 " int x = 0;\n" 10136 "}", 10137 InheritanceStyle); 10138 verifyFormat("switch (x) {\n" 10139 "case 1:\n" 10140 "default:\n" 10141 "}", 10142 InheritanceStyle); 10143 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 10144 verifyFormat("class Foooooooooooooooooooooo:\n" 10145 " public aaaaaaaaaaaaaaaaaa,\n" 10146 " public bbbbbbbbbbbbbbbbbb {\n" 10147 "}", 10148 InheritanceStyle); 10149 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 10150 verifyFormat("class Foooooooooooooooooooooo\n" 10151 " : public aaaaaaaaaaaaaaaaaa\n" 10152 " , public bbbbbbbbbbbbbbbbbb {\n" 10153 "}", 10154 InheritanceStyle); 10155 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 10156 verifyFormat("class Foooooooooooooooooooooo\n" 10157 " : public aaaaaaaaaaaaaaaaaa,\n" 10158 " public bbbbbbbbbbbbbbbbbb {\n" 10159 "}", 10160 InheritanceStyle); 10161 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 10162 verifyFormat("class Foooooooooooooooooooooo\n" 10163 ": public aaaaaaaaaaaaaaaaaa,\n" 10164 " public bbbbbbbbbbbbbbbbbb {}", 10165 InheritanceStyle); 10166 10167 FormatStyle ForLoopStyle = getLLVMStyle(); 10168 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 10169 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 10170 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 10171 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 10172 verifyFormat("int x = a ? b : c;", ForLoopStyle); 10173 verifyFormat("{\n" 10174 "label2:\n" 10175 " int x = 0;\n" 10176 "}", 10177 ForLoopStyle); 10178 verifyFormat("switch (x) {\n" 10179 "case 1:\n" 10180 "default:\n" 10181 "}", 10182 ForLoopStyle); 10183 10184 FormatStyle NoSpaceStyle = getLLVMStyle(); 10185 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 10186 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 10187 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 10188 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 10189 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 10190 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 10191 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 10192 verifyFormat("{\n" 10193 "label3:\n" 10194 " int x = 0;\n" 10195 "}", 10196 NoSpaceStyle); 10197 verifyFormat("switch (x) {\n" 10198 "case 1:\n" 10199 "default:\n" 10200 "}", 10201 NoSpaceStyle); 10202 } 10203 10204 TEST_F(FormatTest, AlignConsecutiveMacros) { 10205 FormatStyle Style = getLLVMStyle(); 10206 Style.AlignConsecutiveAssignments = true; 10207 Style.AlignConsecutiveDeclarations = true; 10208 Style.AlignConsecutiveMacros = false; 10209 10210 verifyFormat("#define a 3\n" 10211 "#define bbbb 4\n" 10212 "#define ccc (5)", 10213 Style); 10214 10215 verifyFormat("#define f(x) (x * x)\n" 10216 "#define fff(x, y, z) (x * y + z)\n" 10217 "#define ffff(x, y) (x - y)", 10218 Style); 10219 10220 verifyFormat("#define foo(x, y) (x + y)\n" 10221 "#define bar (5, 6)(2 + 2)", 10222 Style); 10223 10224 verifyFormat("#define a 3\n" 10225 "#define bbbb 4\n" 10226 "#define ccc (5)\n" 10227 "#define f(x) (x * x)\n" 10228 "#define fff(x, y, z) (x * y + z)\n" 10229 "#define ffff(x, y) (x - y)", 10230 Style); 10231 10232 Style.AlignConsecutiveMacros = true; 10233 verifyFormat("#define a 3\n" 10234 "#define bbbb 4\n" 10235 "#define ccc (5)", 10236 Style); 10237 10238 verifyFormat("#define f(x) (x * x)\n" 10239 "#define fff(x, y, z) (x * y + z)\n" 10240 "#define ffff(x, y) (x - y)", 10241 Style); 10242 10243 verifyFormat("#define foo(x, y) (x + y)\n" 10244 "#define bar (5, 6)(2 + 2)", 10245 Style); 10246 10247 verifyFormat("#define a 3\n" 10248 "#define bbbb 4\n" 10249 "#define ccc (5)\n" 10250 "#define f(x) (x * x)\n" 10251 "#define fff(x, y, z) (x * y + z)\n" 10252 "#define ffff(x, y) (x - y)", 10253 Style); 10254 10255 verifyFormat("#define a 5\n" 10256 "#define foo(x, y) (x + y)\n" 10257 "#define CCC (6)\n" 10258 "auto lambda = []() {\n" 10259 " auto ii = 0;\n" 10260 " float j = 0;\n" 10261 " return 0;\n" 10262 "};\n" 10263 "int i = 0;\n" 10264 "float i2 = 0;\n" 10265 "auto v = type{\n" 10266 " i = 1, //\n" 10267 " (i = 2), //\n" 10268 " i = 3 //\n" 10269 "};", 10270 Style); 10271 10272 Style.AlignConsecutiveMacros = false; 10273 Style.ColumnLimit = 20; 10274 10275 verifyFormat("#define a \\\n" 10276 " \"aabbbbbbbbbbbb\"\n" 10277 "#define D \\\n" 10278 " \"aabbbbbbbbbbbb\" \\\n" 10279 " \"ccddeeeeeeeee\"\n" 10280 "#define B \\\n" 10281 " \"QQQQQQQQQQQQQ\" \\\n" 10282 " \"FFFFFFFFFFFFF\" \\\n" 10283 " \"LLLLLLLL\"\n", 10284 Style); 10285 10286 Style.AlignConsecutiveMacros = true; 10287 verifyFormat("#define a \\\n" 10288 " \"aabbbbbbbbbbbb\"\n" 10289 "#define D \\\n" 10290 " \"aabbbbbbbbbbbb\" \\\n" 10291 " \"ccddeeeeeeeee\"\n" 10292 "#define B \\\n" 10293 " \"QQQQQQQQQQQQQ\" \\\n" 10294 " \"FFFFFFFFFFFFF\" \\\n" 10295 " \"LLLLLLLL\"\n", 10296 Style); 10297 } 10298 10299 TEST_F(FormatTest, AlignConsecutiveAssignments) { 10300 FormatStyle Alignment = getLLVMStyle(); 10301 Alignment.AlignConsecutiveMacros = true; 10302 Alignment.AlignConsecutiveAssignments = false; 10303 verifyFormat("int a = 5;\n" 10304 "int oneTwoThree = 123;", 10305 Alignment); 10306 verifyFormat("int a = 5;\n" 10307 "int oneTwoThree = 123;", 10308 Alignment); 10309 10310 Alignment.AlignConsecutiveAssignments = true; 10311 verifyFormat("int a = 5;\n" 10312 "int oneTwoThree = 123;", 10313 Alignment); 10314 verifyFormat("int a = method();\n" 10315 "int oneTwoThree = 133;", 10316 Alignment); 10317 verifyFormat("a &= 5;\n" 10318 "bcd *= 5;\n" 10319 "ghtyf += 5;\n" 10320 "dvfvdb -= 5;\n" 10321 "a /= 5;\n" 10322 "vdsvsv %= 5;\n" 10323 "sfdbddfbdfbb ^= 5;\n" 10324 "dvsdsv |= 5;\n" 10325 "int dsvvdvsdvvv = 123;", 10326 Alignment); 10327 verifyFormat("int i = 1, j = 10;\n" 10328 "something = 2000;", 10329 Alignment); 10330 verifyFormat("something = 2000;\n" 10331 "int i = 1, j = 10;\n", 10332 Alignment); 10333 verifyFormat("something = 2000;\n" 10334 "another = 911;\n" 10335 "int i = 1, j = 10;\n" 10336 "oneMore = 1;\n" 10337 "i = 2;", 10338 Alignment); 10339 verifyFormat("int a = 5;\n" 10340 "int one = 1;\n" 10341 "method();\n" 10342 "int oneTwoThree = 123;\n" 10343 "int oneTwo = 12;", 10344 Alignment); 10345 verifyFormat("int oneTwoThree = 123;\n" 10346 "int oneTwo = 12;\n" 10347 "method();\n", 10348 Alignment); 10349 verifyFormat("int oneTwoThree = 123; // comment\n" 10350 "int oneTwo = 12; // comment", 10351 Alignment); 10352 EXPECT_EQ("int a = 5;\n" 10353 "\n" 10354 "int oneTwoThree = 123;", 10355 format("int a = 5;\n" 10356 "\n" 10357 "int oneTwoThree= 123;", 10358 Alignment)); 10359 EXPECT_EQ("int a = 5;\n" 10360 "int one = 1;\n" 10361 "\n" 10362 "int oneTwoThree = 123;", 10363 format("int a = 5;\n" 10364 "int one = 1;\n" 10365 "\n" 10366 "int oneTwoThree = 123;", 10367 Alignment)); 10368 EXPECT_EQ("int a = 5;\n" 10369 "int one = 1;\n" 10370 "\n" 10371 "int oneTwoThree = 123;\n" 10372 "int oneTwo = 12;", 10373 format("int a = 5;\n" 10374 "int one = 1;\n" 10375 "\n" 10376 "int oneTwoThree = 123;\n" 10377 "int oneTwo = 12;", 10378 Alignment)); 10379 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10380 verifyFormat("#define A \\\n" 10381 " int aaaa = 12; \\\n" 10382 " int b = 23; \\\n" 10383 " int ccc = 234; \\\n" 10384 " int dddddddddd = 2345;", 10385 Alignment); 10386 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10387 verifyFormat("#define A \\\n" 10388 " int aaaa = 12; \\\n" 10389 " int b = 23; \\\n" 10390 " int ccc = 234; \\\n" 10391 " int dddddddddd = 2345;", 10392 Alignment); 10393 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10394 verifyFormat("#define A " 10395 " \\\n" 10396 " int aaaa = 12; " 10397 " \\\n" 10398 " int b = 23; " 10399 " \\\n" 10400 " int ccc = 234; " 10401 " \\\n" 10402 " int dddddddddd = 2345;", 10403 Alignment); 10404 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10405 "k = 4, int l = 5,\n" 10406 " int m = 6) {\n" 10407 " int j = 10;\n" 10408 " otherThing = 1;\n" 10409 "}", 10410 Alignment); 10411 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10412 " int i = 1;\n" 10413 " int j = 2;\n" 10414 " int big = 10000;\n" 10415 "}", 10416 Alignment); 10417 verifyFormat("class C {\n" 10418 "public:\n" 10419 " int i = 1;\n" 10420 " virtual void f() = 0;\n" 10421 "};", 10422 Alignment); 10423 verifyFormat("int i = 1;\n" 10424 "if (SomeType t = getSomething()) {\n" 10425 "}\n" 10426 "int j = 2;\n" 10427 "int big = 10000;", 10428 Alignment); 10429 verifyFormat("int j = 7;\n" 10430 "for (int k = 0; k < N; ++k) {\n" 10431 "}\n" 10432 "int j = 2;\n" 10433 "int big = 10000;\n" 10434 "}", 10435 Alignment); 10436 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10437 verifyFormat("int i = 1;\n" 10438 "LooooooooooongType loooooooooooooooooooooongVariable\n" 10439 " = someLooooooooooooooooongFunction();\n" 10440 "int j = 2;", 10441 Alignment); 10442 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 10443 verifyFormat("int i = 1;\n" 10444 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 10445 " someLooooooooooooooooongFunction();\n" 10446 "int j = 2;", 10447 Alignment); 10448 10449 verifyFormat("auto lambda = []() {\n" 10450 " auto i = 0;\n" 10451 " return 0;\n" 10452 "};\n" 10453 "int i = 0;\n" 10454 "auto v = type{\n" 10455 " i = 1, //\n" 10456 " (i = 2), //\n" 10457 " i = 3 //\n" 10458 "};", 10459 Alignment); 10460 10461 verifyFormat( 10462 "int i = 1;\n" 10463 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 10464 " loooooooooooooooooooooongParameterB);\n" 10465 "int j = 2;", 10466 Alignment); 10467 10468 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 10469 " typename B = very_long_type_name_1,\n" 10470 " typename T_2 = very_long_type_name_2>\n" 10471 "auto foo() {}\n", 10472 Alignment); 10473 verifyFormat("int a, b = 1;\n" 10474 "int c = 2;\n" 10475 "int dd = 3;\n", 10476 Alignment); 10477 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10478 "float b[1][] = {{3.f}};\n", 10479 Alignment); 10480 verifyFormat("for (int i = 0; i < 1; i++)\n" 10481 " int x = 1;\n", 10482 Alignment); 10483 verifyFormat("for (i = 0; i < 1; i++)\n" 10484 " x = 1;\n" 10485 "y = 1;\n", 10486 Alignment); 10487 } 10488 10489 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 10490 FormatStyle Alignment = getLLVMStyle(); 10491 Alignment.AlignConsecutiveMacros = true; 10492 Alignment.AlignConsecutiveDeclarations = false; 10493 verifyFormat("float const a = 5;\n" 10494 "int oneTwoThree = 123;", 10495 Alignment); 10496 verifyFormat("int a = 5;\n" 10497 "float const oneTwoThree = 123;", 10498 Alignment); 10499 10500 Alignment.AlignConsecutiveDeclarations = true; 10501 verifyFormat("float const a = 5;\n" 10502 "int oneTwoThree = 123;", 10503 Alignment); 10504 verifyFormat("int a = method();\n" 10505 "float const oneTwoThree = 133;", 10506 Alignment); 10507 verifyFormat("int i = 1, j = 10;\n" 10508 "something = 2000;", 10509 Alignment); 10510 verifyFormat("something = 2000;\n" 10511 "int i = 1, j = 10;\n", 10512 Alignment); 10513 verifyFormat("float something = 2000;\n" 10514 "double another = 911;\n" 10515 "int i = 1, j = 10;\n" 10516 "const int *oneMore = 1;\n" 10517 "unsigned i = 2;", 10518 Alignment); 10519 verifyFormat("float a = 5;\n" 10520 "int one = 1;\n" 10521 "method();\n" 10522 "const double oneTwoThree = 123;\n" 10523 "const unsigned int oneTwo = 12;", 10524 Alignment); 10525 verifyFormat("int oneTwoThree{0}; // comment\n" 10526 "unsigned oneTwo; // comment", 10527 Alignment); 10528 EXPECT_EQ("float const a = 5;\n" 10529 "\n" 10530 "int oneTwoThree = 123;", 10531 format("float const a = 5;\n" 10532 "\n" 10533 "int oneTwoThree= 123;", 10534 Alignment)); 10535 EXPECT_EQ("float a = 5;\n" 10536 "int one = 1;\n" 10537 "\n" 10538 "unsigned oneTwoThree = 123;", 10539 format("float a = 5;\n" 10540 "int one = 1;\n" 10541 "\n" 10542 "unsigned oneTwoThree = 123;", 10543 Alignment)); 10544 EXPECT_EQ("float a = 5;\n" 10545 "int one = 1;\n" 10546 "\n" 10547 "unsigned oneTwoThree = 123;\n" 10548 "int oneTwo = 12;", 10549 format("float a = 5;\n" 10550 "int one = 1;\n" 10551 "\n" 10552 "unsigned oneTwoThree = 123;\n" 10553 "int oneTwo = 12;", 10554 Alignment)); 10555 // Function prototype alignment 10556 verifyFormat("int a();\n" 10557 "double b();", 10558 Alignment); 10559 verifyFormat("int a(int x);\n" 10560 "double b();", 10561 Alignment); 10562 unsigned OldColumnLimit = Alignment.ColumnLimit; 10563 // We need to set ColumnLimit to zero, in order to stress nested alignments, 10564 // otherwise the function parameters will be re-flowed onto a single line. 10565 Alignment.ColumnLimit = 0; 10566 EXPECT_EQ("int a(int x,\n" 10567 " float y);\n" 10568 "double b(int x,\n" 10569 " double y);", 10570 format("int a(int x,\n" 10571 " float y);\n" 10572 "double b(int x,\n" 10573 " double y);", 10574 Alignment)); 10575 // This ensures that function parameters of function declarations are 10576 // correctly indented when their owning functions are indented. 10577 // The failure case here is for 'double y' to not be indented enough. 10578 EXPECT_EQ("double a(int x);\n" 10579 "int b(int y,\n" 10580 " double z);", 10581 format("double a(int x);\n" 10582 "int b(int y,\n" 10583 " double z);", 10584 Alignment)); 10585 // Set ColumnLimit low so that we induce wrapping immediately after 10586 // the function name and opening paren. 10587 Alignment.ColumnLimit = 13; 10588 verifyFormat("int function(\n" 10589 " int x,\n" 10590 " bool y);", 10591 Alignment); 10592 Alignment.ColumnLimit = OldColumnLimit; 10593 // Ensure function pointers don't screw up recursive alignment 10594 verifyFormat("int a(int x, void (*fp)(int y));\n" 10595 "double b();", 10596 Alignment); 10597 Alignment.AlignConsecutiveAssignments = true; 10598 // Ensure recursive alignment is broken by function braces, so that the 10599 // "a = 1" does not align with subsequent assignments inside the function 10600 // body. 10601 verifyFormat("int func(int a = 1) {\n" 10602 " int b = 2;\n" 10603 " int cc = 3;\n" 10604 "}", 10605 Alignment); 10606 verifyFormat("float something = 2000;\n" 10607 "double another = 911;\n" 10608 "int i = 1, j = 10;\n" 10609 "const int *oneMore = 1;\n" 10610 "unsigned i = 2;", 10611 Alignment); 10612 verifyFormat("int oneTwoThree = {0}; // comment\n" 10613 "unsigned oneTwo = 0; // comment", 10614 Alignment); 10615 // Make sure that scope is correctly tracked, in the absence of braces 10616 verifyFormat("for (int i = 0; i < n; i++)\n" 10617 " j = i;\n" 10618 "double x = 1;\n", 10619 Alignment); 10620 verifyFormat("if (int i = 0)\n" 10621 " j = i;\n" 10622 "double x = 1;\n", 10623 Alignment); 10624 // Ensure operator[] and operator() are comprehended 10625 verifyFormat("struct test {\n" 10626 " long long int foo();\n" 10627 " int operator[](int a);\n" 10628 " double bar();\n" 10629 "};\n", 10630 Alignment); 10631 verifyFormat("struct test {\n" 10632 " long long int foo();\n" 10633 " int operator()(int a);\n" 10634 " double bar();\n" 10635 "};\n", 10636 Alignment); 10637 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 10638 " int const i = 1;\n" 10639 " int * j = 2;\n" 10640 " int big = 10000;\n" 10641 "\n" 10642 " unsigned oneTwoThree = 123;\n" 10643 " int oneTwo = 12;\n" 10644 " method();\n" 10645 " float k = 2;\n" 10646 " int ll = 10000;\n" 10647 "}", 10648 format("void SomeFunction(int parameter= 0) {\n" 10649 " int const i= 1;\n" 10650 " int *j=2;\n" 10651 " int big = 10000;\n" 10652 "\n" 10653 "unsigned oneTwoThree =123;\n" 10654 "int oneTwo = 12;\n" 10655 " method();\n" 10656 "float k= 2;\n" 10657 "int ll=10000;\n" 10658 "}", 10659 Alignment)); 10660 Alignment.AlignConsecutiveAssignments = false; 10661 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10662 verifyFormat("#define A \\\n" 10663 " int aaaa = 12; \\\n" 10664 " float b = 23; \\\n" 10665 " const int ccc = 234; \\\n" 10666 " unsigned dddddddddd = 2345;", 10667 Alignment); 10668 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10669 verifyFormat("#define A \\\n" 10670 " int aaaa = 12; \\\n" 10671 " float b = 23; \\\n" 10672 " const int ccc = 234; \\\n" 10673 " unsigned dddddddddd = 2345;", 10674 Alignment); 10675 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10676 Alignment.ColumnLimit = 30; 10677 verifyFormat("#define A \\\n" 10678 " int aaaa = 12; \\\n" 10679 " float b = 23; \\\n" 10680 " const int ccc = 234; \\\n" 10681 " int dddddddddd = 2345;", 10682 Alignment); 10683 Alignment.ColumnLimit = 80; 10684 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10685 "k = 4, int l = 5,\n" 10686 " int m = 6) {\n" 10687 " const int j = 10;\n" 10688 " otherThing = 1;\n" 10689 "}", 10690 Alignment); 10691 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10692 " int const i = 1;\n" 10693 " int * j = 2;\n" 10694 " int big = 10000;\n" 10695 "}", 10696 Alignment); 10697 verifyFormat("class C {\n" 10698 "public:\n" 10699 " int i = 1;\n" 10700 " virtual void f() = 0;\n" 10701 "};", 10702 Alignment); 10703 verifyFormat("float i = 1;\n" 10704 "if (SomeType t = getSomething()) {\n" 10705 "}\n" 10706 "const unsigned j = 2;\n" 10707 "int big = 10000;", 10708 Alignment); 10709 verifyFormat("float j = 7;\n" 10710 "for (int k = 0; k < N; ++k) {\n" 10711 "}\n" 10712 "unsigned j = 2;\n" 10713 "int big = 10000;\n" 10714 "}", 10715 Alignment); 10716 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10717 verifyFormat("float i = 1;\n" 10718 "LooooooooooongType loooooooooooooooooooooongVariable\n" 10719 " = someLooooooooooooooooongFunction();\n" 10720 "int j = 2;", 10721 Alignment); 10722 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 10723 verifyFormat("int i = 1;\n" 10724 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 10725 " someLooooooooooooooooongFunction();\n" 10726 "int j = 2;", 10727 Alignment); 10728 10729 Alignment.AlignConsecutiveAssignments = true; 10730 verifyFormat("auto lambda = []() {\n" 10731 " auto ii = 0;\n" 10732 " float j = 0;\n" 10733 " return 0;\n" 10734 "};\n" 10735 "int i = 0;\n" 10736 "float i2 = 0;\n" 10737 "auto v = type{\n" 10738 " i = 1, //\n" 10739 " (i = 2), //\n" 10740 " i = 3 //\n" 10741 "};", 10742 Alignment); 10743 Alignment.AlignConsecutiveAssignments = false; 10744 10745 verifyFormat( 10746 "int i = 1;\n" 10747 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 10748 " loooooooooooooooooooooongParameterB);\n" 10749 "int j = 2;", 10750 Alignment); 10751 10752 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 10753 // We expect declarations and assignments to align, as long as it doesn't 10754 // exceed the column limit, starting a new alignment sequence whenever it 10755 // happens. 10756 Alignment.AlignConsecutiveAssignments = true; 10757 Alignment.ColumnLimit = 30; 10758 verifyFormat("float ii = 1;\n" 10759 "unsigned j = 2;\n" 10760 "int someVerylongVariable = 1;\n" 10761 "AnotherLongType ll = 123456;\n" 10762 "VeryVeryLongType k = 2;\n" 10763 "int myvar = 1;", 10764 Alignment); 10765 Alignment.ColumnLimit = 80; 10766 Alignment.AlignConsecutiveAssignments = false; 10767 10768 verifyFormat( 10769 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 10770 " typename LongType, typename B>\n" 10771 "auto foo() {}\n", 10772 Alignment); 10773 verifyFormat("float a, b = 1;\n" 10774 "int c = 2;\n" 10775 "int dd = 3;\n", 10776 Alignment); 10777 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10778 "float b[1][] = {{3.f}};\n", 10779 Alignment); 10780 Alignment.AlignConsecutiveAssignments = true; 10781 verifyFormat("float a, b = 1;\n" 10782 "int c = 2;\n" 10783 "int dd = 3;\n", 10784 Alignment); 10785 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 10786 "float b[1][] = {{3.f}};\n", 10787 Alignment); 10788 Alignment.AlignConsecutiveAssignments = false; 10789 10790 Alignment.ColumnLimit = 30; 10791 Alignment.BinPackParameters = false; 10792 verifyFormat("void foo(float a,\n" 10793 " float b,\n" 10794 " int c,\n" 10795 " uint32_t *d) {\n" 10796 " int * e = 0;\n" 10797 " float f = 0;\n" 10798 " double g = 0;\n" 10799 "}\n" 10800 "void bar(ino_t a,\n" 10801 " int b,\n" 10802 " uint32_t *c,\n" 10803 " bool d) {}\n", 10804 Alignment); 10805 Alignment.BinPackParameters = true; 10806 Alignment.ColumnLimit = 80; 10807 10808 // Bug 33507 10809 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 10810 verifyFormat( 10811 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 10812 " static const Version verVs2017;\n" 10813 " return true;\n" 10814 "});\n", 10815 Alignment); 10816 Alignment.PointerAlignment = FormatStyle::PAS_Right; 10817 10818 // See llvm.org/PR35641 10819 Alignment.AlignConsecutiveDeclarations = true; 10820 verifyFormat("int func() { //\n" 10821 " int b;\n" 10822 " unsigned c;\n" 10823 "}", 10824 Alignment); 10825 10826 // See PR37175 10827 FormatStyle Style = getMozillaStyle(); 10828 Style.AlignConsecutiveDeclarations = true; 10829 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 10830 "foo(int a);", 10831 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 10832 } 10833 10834 TEST_F(FormatTest, LinuxBraceBreaking) { 10835 FormatStyle LinuxBraceStyle = getLLVMStyle(); 10836 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 10837 verifyFormat("namespace a\n" 10838 "{\n" 10839 "class A\n" 10840 "{\n" 10841 " void f()\n" 10842 " {\n" 10843 " if (true) {\n" 10844 " a();\n" 10845 " b();\n" 10846 " } else {\n" 10847 " a();\n" 10848 " }\n" 10849 " }\n" 10850 " void g() { return; }\n" 10851 "};\n" 10852 "struct B {\n" 10853 " int x;\n" 10854 "};\n" 10855 "} // namespace a\n", 10856 LinuxBraceStyle); 10857 verifyFormat("enum X {\n" 10858 " Y = 0,\n" 10859 "}\n", 10860 LinuxBraceStyle); 10861 verifyFormat("struct S {\n" 10862 " int Type;\n" 10863 " union {\n" 10864 " int x;\n" 10865 " double y;\n" 10866 " } Value;\n" 10867 " class C\n" 10868 " {\n" 10869 " MyFavoriteType Value;\n" 10870 " } Class;\n" 10871 "}\n", 10872 LinuxBraceStyle); 10873 } 10874 10875 TEST_F(FormatTest, MozillaBraceBreaking) { 10876 FormatStyle MozillaBraceStyle = getLLVMStyle(); 10877 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 10878 MozillaBraceStyle.FixNamespaceComments = false; 10879 verifyFormat("namespace a {\n" 10880 "class A\n" 10881 "{\n" 10882 " void f()\n" 10883 " {\n" 10884 " if (true) {\n" 10885 " a();\n" 10886 " b();\n" 10887 " }\n" 10888 " }\n" 10889 " void g() { return; }\n" 10890 "};\n" 10891 "enum E\n" 10892 "{\n" 10893 " A,\n" 10894 " // foo\n" 10895 " B,\n" 10896 " C\n" 10897 "};\n" 10898 "struct B\n" 10899 "{\n" 10900 " int x;\n" 10901 "};\n" 10902 "}\n", 10903 MozillaBraceStyle); 10904 verifyFormat("struct S\n" 10905 "{\n" 10906 " int Type;\n" 10907 " union\n" 10908 " {\n" 10909 " int x;\n" 10910 " double y;\n" 10911 " } Value;\n" 10912 " class C\n" 10913 " {\n" 10914 " MyFavoriteType Value;\n" 10915 " } Class;\n" 10916 "}\n", 10917 MozillaBraceStyle); 10918 } 10919 10920 TEST_F(FormatTest, StroustrupBraceBreaking) { 10921 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 10922 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 10923 verifyFormat("namespace a {\n" 10924 "class A {\n" 10925 " void f()\n" 10926 " {\n" 10927 " if (true) {\n" 10928 " a();\n" 10929 " b();\n" 10930 " }\n" 10931 " }\n" 10932 " void g() { return; }\n" 10933 "};\n" 10934 "struct B {\n" 10935 " int x;\n" 10936 "};\n" 10937 "} // namespace a\n", 10938 StroustrupBraceStyle); 10939 10940 verifyFormat("void foo()\n" 10941 "{\n" 10942 " if (a) {\n" 10943 " a();\n" 10944 " }\n" 10945 " else {\n" 10946 " b();\n" 10947 " }\n" 10948 "}\n", 10949 StroustrupBraceStyle); 10950 10951 verifyFormat("#ifdef _DEBUG\n" 10952 "int foo(int i = 0)\n" 10953 "#else\n" 10954 "int foo(int i = 5)\n" 10955 "#endif\n" 10956 "{\n" 10957 " return i;\n" 10958 "}", 10959 StroustrupBraceStyle); 10960 10961 verifyFormat("void foo() {}\n" 10962 "void bar()\n" 10963 "#ifdef _DEBUG\n" 10964 "{\n" 10965 " foo();\n" 10966 "}\n" 10967 "#else\n" 10968 "{\n" 10969 "}\n" 10970 "#endif", 10971 StroustrupBraceStyle); 10972 10973 verifyFormat("void foobar() { int i = 5; }\n" 10974 "#ifdef _DEBUG\n" 10975 "void bar() {}\n" 10976 "#else\n" 10977 "void bar() { foobar(); }\n" 10978 "#endif", 10979 StroustrupBraceStyle); 10980 } 10981 10982 TEST_F(FormatTest, AllmanBraceBreaking) { 10983 FormatStyle AllmanBraceStyle = getLLVMStyle(); 10984 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 10985 10986 EXPECT_EQ("namespace a\n" 10987 "{\n" 10988 "void f();\n" 10989 "void g();\n" 10990 "} // namespace a\n", 10991 format("namespace a\n" 10992 "{\n" 10993 "void f();\n" 10994 "void g();\n" 10995 "}\n", 10996 AllmanBraceStyle)); 10997 10998 verifyFormat("namespace a\n" 10999 "{\n" 11000 "class A\n" 11001 "{\n" 11002 " void f()\n" 11003 " {\n" 11004 " if (true)\n" 11005 " {\n" 11006 " a();\n" 11007 " b();\n" 11008 " }\n" 11009 " }\n" 11010 " void g() { return; }\n" 11011 "};\n" 11012 "struct B\n" 11013 "{\n" 11014 " int x;\n" 11015 "};\n" 11016 "} // namespace a", 11017 AllmanBraceStyle); 11018 11019 verifyFormat("void f()\n" 11020 "{\n" 11021 " if (true)\n" 11022 " {\n" 11023 " a();\n" 11024 " }\n" 11025 " else if (false)\n" 11026 " {\n" 11027 " b();\n" 11028 " }\n" 11029 " else\n" 11030 " {\n" 11031 " c();\n" 11032 " }\n" 11033 "}\n", 11034 AllmanBraceStyle); 11035 11036 verifyFormat("void f()\n" 11037 "{\n" 11038 " for (int i = 0; i < 10; ++i)\n" 11039 " {\n" 11040 " a();\n" 11041 " }\n" 11042 " while (false)\n" 11043 " {\n" 11044 " b();\n" 11045 " }\n" 11046 " do\n" 11047 " {\n" 11048 " c();\n" 11049 " } while (false)\n" 11050 "}\n", 11051 AllmanBraceStyle); 11052 11053 verifyFormat("void f(int a)\n" 11054 "{\n" 11055 " switch (a)\n" 11056 " {\n" 11057 " case 0:\n" 11058 " break;\n" 11059 " case 1:\n" 11060 " {\n" 11061 " break;\n" 11062 " }\n" 11063 " case 2:\n" 11064 " {\n" 11065 " }\n" 11066 " break;\n" 11067 " default:\n" 11068 " break;\n" 11069 " }\n" 11070 "}\n", 11071 AllmanBraceStyle); 11072 11073 verifyFormat("enum X\n" 11074 "{\n" 11075 " Y = 0,\n" 11076 "}\n", 11077 AllmanBraceStyle); 11078 verifyFormat("enum X\n" 11079 "{\n" 11080 " Y = 0\n" 11081 "}\n", 11082 AllmanBraceStyle); 11083 11084 verifyFormat("@interface BSApplicationController ()\n" 11085 "{\n" 11086 "@private\n" 11087 " id _extraIvar;\n" 11088 "}\n" 11089 "@end\n", 11090 AllmanBraceStyle); 11091 11092 verifyFormat("#ifdef _DEBUG\n" 11093 "int foo(int i = 0)\n" 11094 "#else\n" 11095 "int foo(int i = 5)\n" 11096 "#endif\n" 11097 "{\n" 11098 " return i;\n" 11099 "}", 11100 AllmanBraceStyle); 11101 11102 verifyFormat("void foo() {}\n" 11103 "void bar()\n" 11104 "#ifdef _DEBUG\n" 11105 "{\n" 11106 " foo();\n" 11107 "}\n" 11108 "#else\n" 11109 "{\n" 11110 "}\n" 11111 "#endif", 11112 AllmanBraceStyle); 11113 11114 verifyFormat("void foobar() { int i = 5; }\n" 11115 "#ifdef _DEBUG\n" 11116 "void bar() {}\n" 11117 "#else\n" 11118 "void bar() { foobar(); }\n" 11119 "#endif", 11120 AllmanBraceStyle); 11121 11122 // This shouldn't affect ObjC blocks.. 11123 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 11124 " // ...\n" 11125 " int i;\n" 11126 "}];", 11127 AllmanBraceStyle); 11128 verifyFormat("void (^block)(void) = ^{\n" 11129 " // ...\n" 11130 " int i;\n" 11131 "};", 11132 AllmanBraceStyle); 11133 // .. or dict literals. 11134 verifyFormat("void f()\n" 11135 "{\n" 11136 " // ...\n" 11137 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 11138 "}", 11139 AllmanBraceStyle); 11140 verifyFormat("void f()\n" 11141 "{\n" 11142 " // ...\n" 11143 " [object someMethod:@{a : @\"b\"}];\n" 11144 "}", 11145 AllmanBraceStyle); 11146 verifyFormat("int f()\n" 11147 "{ // comment\n" 11148 " return 42;\n" 11149 "}", 11150 AllmanBraceStyle); 11151 11152 AllmanBraceStyle.ColumnLimit = 19; 11153 verifyFormat("void f() { int i; }", AllmanBraceStyle); 11154 AllmanBraceStyle.ColumnLimit = 18; 11155 verifyFormat("void f()\n" 11156 "{\n" 11157 " int i;\n" 11158 "}", 11159 AllmanBraceStyle); 11160 AllmanBraceStyle.ColumnLimit = 80; 11161 11162 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 11163 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 11164 FormatStyle::SIS_WithoutElse; 11165 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 11166 verifyFormat("void f(bool b)\n" 11167 "{\n" 11168 " if (b)\n" 11169 " {\n" 11170 " return;\n" 11171 " }\n" 11172 "}\n", 11173 BreakBeforeBraceShortIfs); 11174 verifyFormat("void f(bool b)\n" 11175 "{\n" 11176 " if constexpr (b)\n" 11177 " {\n" 11178 " return;\n" 11179 " }\n" 11180 "}\n", 11181 BreakBeforeBraceShortIfs); 11182 verifyFormat("void f(bool b)\n" 11183 "{\n" 11184 " if (b) return;\n" 11185 "}\n", 11186 BreakBeforeBraceShortIfs); 11187 verifyFormat("void f(bool b)\n" 11188 "{\n" 11189 " if constexpr (b) return;\n" 11190 "}\n", 11191 BreakBeforeBraceShortIfs); 11192 verifyFormat("void f(bool b)\n" 11193 "{\n" 11194 " while (b)\n" 11195 " {\n" 11196 " return;\n" 11197 " }\n" 11198 "}\n", 11199 BreakBeforeBraceShortIfs); 11200 } 11201 11202 TEST_F(FormatTest, GNUBraceBreaking) { 11203 FormatStyle GNUBraceStyle = getLLVMStyle(); 11204 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 11205 verifyFormat("namespace a\n" 11206 "{\n" 11207 "class A\n" 11208 "{\n" 11209 " void f()\n" 11210 " {\n" 11211 " int a;\n" 11212 " {\n" 11213 " int b;\n" 11214 " }\n" 11215 " if (true)\n" 11216 " {\n" 11217 " a();\n" 11218 " b();\n" 11219 " }\n" 11220 " }\n" 11221 " void g() { return; }\n" 11222 "}\n" 11223 "} // namespace a", 11224 GNUBraceStyle); 11225 11226 verifyFormat("void f()\n" 11227 "{\n" 11228 " if (true)\n" 11229 " {\n" 11230 " a();\n" 11231 " }\n" 11232 " else if (false)\n" 11233 " {\n" 11234 " b();\n" 11235 " }\n" 11236 " else\n" 11237 " {\n" 11238 " c();\n" 11239 " }\n" 11240 "}\n", 11241 GNUBraceStyle); 11242 11243 verifyFormat("void f()\n" 11244 "{\n" 11245 " for (int i = 0; i < 10; ++i)\n" 11246 " {\n" 11247 " a();\n" 11248 " }\n" 11249 " while (false)\n" 11250 " {\n" 11251 " b();\n" 11252 " }\n" 11253 " do\n" 11254 " {\n" 11255 " c();\n" 11256 " }\n" 11257 " while (false);\n" 11258 "}\n", 11259 GNUBraceStyle); 11260 11261 verifyFormat("void f(int a)\n" 11262 "{\n" 11263 " switch (a)\n" 11264 " {\n" 11265 " case 0:\n" 11266 " break;\n" 11267 " case 1:\n" 11268 " {\n" 11269 " break;\n" 11270 " }\n" 11271 " case 2:\n" 11272 " {\n" 11273 " }\n" 11274 " break;\n" 11275 " default:\n" 11276 " break;\n" 11277 " }\n" 11278 "}\n", 11279 GNUBraceStyle); 11280 11281 verifyFormat("enum X\n" 11282 "{\n" 11283 " Y = 0,\n" 11284 "}\n", 11285 GNUBraceStyle); 11286 11287 verifyFormat("@interface BSApplicationController ()\n" 11288 "{\n" 11289 "@private\n" 11290 " id _extraIvar;\n" 11291 "}\n" 11292 "@end\n", 11293 GNUBraceStyle); 11294 11295 verifyFormat("#ifdef _DEBUG\n" 11296 "int foo(int i = 0)\n" 11297 "#else\n" 11298 "int foo(int i = 5)\n" 11299 "#endif\n" 11300 "{\n" 11301 " return i;\n" 11302 "}", 11303 GNUBraceStyle); 11304 11305 verifyFormat("void foo() {}\n" 11306 "void bar()\n" 11307 "#ifdef _DEBUG\n" 11308 "{\n" 11309 " foo();\n" 11310 "}\n" 11311 "#else\n" 11312 "{\n" 11313 "}\n" 11314 "#endif", 11315 GNUBraceStyle); 11316 11317 verifyFormat("void foobar() { int i = 5; }\n" 11318 "#ifdef _DEBUG\n" 11319 "void bar() {}\n" 11320 "#else\n" 11321 "void bar() { foobar(); }\n" 11322 "#endif", 11323 GNUBraceStyle); 11324 } 11325 11326 TEST_F(FormatTest, WebKitBraceBreaking) { 11327 FormatStyle WebKitBraceStyle = getLLVMStyle(); 11328 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 11329 WebKitBraceStyle.FixNamespaceComments = false; 11330 verifyFormat("namespace a {\n" 11331 "class A {\n" 11332 " void f()\n" 11333 " {\n" 11334 " if (true) {\n" 11335 " a();\n" 11336 " b();\n" 11337 " }\n" 11338 " }\n" 11339 " void g() { return; }\n" 11340 "};\n" 11341 "enum E {\n" 11342 " A,\n" 11343 " // foo\n" 11344 " B,\n" 11345 " C\n" 11346 "};\n" 11347 "struct B {\n" 11348 " int x;\n" 11349 "};\n" 11350 "}\n", 11351 WebKitBraceStyle); 11352 verifyFormat("struct S {\n" 11353 " int Type;\n" 11354 " union {\n" 11355 " int x;\n" 11356 " double y;\n" 11357 " } Value;\n" 11358 " class C {\n" 11359 " MyFavoriteType Value;\n" 11360 " } Class;\n" 11361 "};\n", 11362 WebKitBraceStyle); 11363 } 11364 11365 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 11366 verifyFormat("void f() {\n" 11367 " try {\n" 11368 " } catch (const Exception &e) {\n" 11369 " }\n" 11370 "}\n", 11371 getLLVMStyle()); 11372 } 11373 11374 TEST_F(FormatTest, UnderstandsPragmas) { 11375 verifyFormat("#pragma omp reduction(| : var)"); 11376 verifyFormat("#pragma omp reduction(+ : var)"); 11377 11378 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 11379 "(including parentheses).", 11380 format("#pragma mark Any non-hyphenated or hyphenated string " 11381 "(including parentheses).")); 11382 } 11383 11384 TEST_F(FormatTest, UnderstandPragmaOption) { 11385 verifyFormat("#pragma option -C -A"); 11386 11387 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 11388 } 11389 11390 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 11391 FormatStyle Style = getLLVMStyle(); 11392 Style.ColumnLimit = 20; 11393 11394 // See PR41213 11395 EXPECT_EQ("/*\n" 11396 " *\t9012345\n" 11397 " * /8901\n" 11398 " */", 11399 format("/*\n" 11400 " *\t9012345 /8901\n" 11401 " */", 11402 Style)); 11403 EXPECT_EQ("/*\n" 11404 " *345678\n" 11405 " *\t/8901\n" 11406 " */", 11407 format("/*\n" 11408 " *345678\t/8901\n" 11409 " */", 11410 Style)); 11411 11412 verifyFormat("int a; // the\n" 11413 " // comment", Style); 11414 EXPECT_EQ("int a; /* first line\n" 11415 " * second\n" 11416 " * line third\n" 11417 " * line\n" 11418 " */", 11419 format("int a; /* first line\n" 11420 " * second\n" 11421 " * line third\n" 11422 " * line\n" 11423 " */", 11424 Style)); 11425 EXPECT_EQ("int a; // first line\n" 11426 " // second\n" 11427 " // line third\n" 11428 " // line", 11429 format("int a; // first line\n" 11430 " // second line\n" 11431 " // third line", 11432 Style)); 11433 11434 Style.PenaltyExcessCharacter = 90; 11435 verifyFormat("int a; // the comment", Style); 11436 EXPECT_EQ("int a; // the comment\n" 11437 " // aaa", 11438 format("int a; // the comment aaa", Style)); 11439 EXPECT_EQ("int a; /* first line\n" 11440 " * second line\n" 11441 " * third line\n" 11442 " */", 11443 format("int a; /* first line\n" 11444 " * second line\n" 11445 " * third line\n" 11446 " */", 11447 Style)); 11448 EXPECT_EQ("int a; // first line\n" 11449 " // second line\n" 11450 " // third line", 11451 format("int a; // first line\n" 11452 " // second line\n" 11453 " // third line", 11454 Style)); 11455 // FIXME: Investigate why this is not getting the same layout as the test 11456 // above. 11457 EXPECT_EQ("int a; /* first line\n" 11458 " * second line\n" 11459 " * third line\n" 11460 " */", 11461 format("int a; /* first line second line third line" 11462 "\n*/", 11463 Style)); 11464 11465 EXPECT_EQ("// foo bar baz bazfoo\n" 11466 "// foo bar foo bar\n", 11467 format("// foo bar baz bazfoo\n" 11468 "// foo bar foo bar\n", 11469 Style)); 11470 EXPECT_EQ("// foo bar baz bazfoo\n" 11471 "// foo bar foo bar\n", 11472 format("// foo bar baz bazfoo\n" 11473 "// foo bar foo bar\n", 11474 Style)); 11475 11476 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 11477 // next one. 11478 EXPECT_EQ("// foo bar baz bazfoo\n" 11479 "// bar foo bar\n", 11480 format("// foo bar baz bazfoo bar\n" 11481 "// foo bar\n", 11482 Style)); 11483 11484 EXPECT_EQ("// foo bar baz bazfoo\n" 11485 "// foo bar baz bazfoo\n" 11486 "// bar foo bar\n", 11487 format("// foo bar baz bazfoo\n" 11488 "// foo bar baz bazfoo bar\n" 11489 "// foo bar\n", 11490 Style)); 11491 11492 EXPECT_EQ("// foo bar baz bazfoo\n" 11493 "// foo bar baz bazfoo\n" 11494 "// bar foo bar\n", 11495 format("// foo bar baz bazfoo\n" 11496 "// foo bar baz bazfoo bar\n" 11497 "// foo bar\n", 11498 Style)); 11499 11500 // Make sure we do not keep protruding characters if strict mode reflow is 11501 // cheaper than keeping protruding characters. 11502 Style.ColumnLimit = 21; 11503 EXPECT_EQ("// foo foo foo foo\n" 11504 "// foo foo foo foo\n" 11505 "// foo foo foo foo\n", 11506 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", 11507 Style)); 11508 11509 EXPECT_EQ("int a = /* long block\n" 11510 " comment */\n" 11511 " 42;", 11512 format("int a = /* long block comment */ 42;", Style)); 11513 } 11514 11515 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 11516 for (size_t i = 1; i < Styles.size(); ++i) \ 11517 EXPECT_EQ(Styles[0], Styles[i]) << "Style #" << i << " of " << Styles.size() \ 11518 << " differs from Style #0" 11519 11520 TEST_F(FormatTest, GetsPredefinedStyleByName) { 11521 SmallVector<FormatStyle, 3> Styles; 11522 Styles.resize(3); 11523 11524 Styles[0] = getLLVMStyle(); 11525 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 11526 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 11527 EXPECT_ALL_STYLES_EQUAL(Styles); 11528 11529 Styles[0] = getGoogleStyle(); 11530 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 11531 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 11532 EXPECT_ALL_STYLES_EQUAL(Styles); 11533 11534 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 11535 EXPECT_TRUE( 11536 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 11537 EXPECT_TRUE( 11538 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 11539 EXPECT_ALL_STYLES_EQUAL(Styles); 11540 11541 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 11542 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 11543 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 11544 EXPECT_ALL_STYLES_EQUAL(Styles); 11545 11546 Styles[0] = getMozillaStyle(); 11547 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 11548 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 11549 EXPECT_ALL_STYLES_EQUAL(Styles); 11550 11551 Styles[0] = getWebKitStyle(); 11552 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 11553 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 11554 EXPECT_ALL_STYLES_EQUAL(Styles); 11555 11556 Styles[0] = getGNUStyle(); 11557 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 11558 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 11559 EXPECT_ALL_STYLES_EQUAL(Styles); 11560 11561 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 11562 } 11563 11564 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 11565 SmallVector<FormatStyle, 8> Styles; 11566 Styles.resize(2); 11567 11568 Styles[0] = getGoogleStyle(); 11569 Styles[1] = getLLVMStyle(); 11570 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 11571 EXPECT_ALL_STYLES_EQUAL(Styles); 11572 11573 Styles.resize(5); 11574 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 11575 Styles[1] = getLLVMStyle(); 11576 Styles[1].Language = FormatStyle::LK_JavaScript; 11577 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 11578 11579 Styles[2] = getLLVMStyle(); 11580 Styles[2].Language = FormatStyle::LK_JavaScript; 11581 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 11582 "BasedOnStyle: Google", 11583 &Styles[2]) 11584 .value()); 11585 11586 Styles[3] = getLLVMStyle(); 11587 Styles[3].Language = FormatStyle::LK_JavaScript; 11588 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 11589 "Language: JavaScript", 11590 &Styles[3]) 11591 .value()); 11592 11593 Styles[4] = getLLVMStyle(); 11594 Styles[4].Language = FormatStyle::LK_JavaScript; 11595 EXPECT_EQ(0, parseConfiguration("---\n" 11596 "BasedOnStyle: LLVM\n" 11597 "IndentWidth: 123\n" 11598 "---\n" 11599 "BasedOnStyle: Google\n" 11600 "Language: JavaScript", 11601 &Styles[4]) 11602 .value()); 11603 EXPECT_ALL_STYLES_EQUAL(Styles); 11604 } 11605 11606 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 11607 Style.FIELD = false; \ 11608 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 11609 EXPECT_TRUE(Style.FIELD); \ 11610 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 11611 EXPECT_FALSE(Style.FIELD); 11612 11613 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 11614 11615 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 11616 Style.STRUCT.FIELD = false; \ 11617 EXPECT_EQ(0, \ 11618 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 11619 .value()); \ 11620 EXPECT_TRUE(Style.STRUCT.FIELD); \ 11621 EXPECT_EQ(0, \ 11622 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 11623 .value()); \ 11624 EXPECT_FALSE(Style.STRUCT.FIELD); 11625 11626 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 11627 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 11628 11629 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 11630 EXPECT_NE(VALUE, Style.FIELD); \ 11631 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 11632 EXPECT_EQ(VALUE, Style.FIELD) 11633 11634 TEST_F(FormatTest, ParsesConfigurationBools) { 11635 FormatStyle Style = {}; 11636 Style.Language = FormatStyle::LK_Cpp; 11637 CHECK_PARSE_BOOL(AlignOperands); 11638 CHECK_PARSE_BOOL(AlignTrailingComments); 11639 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 11640 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 11641 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 11642 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 11643 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 11644 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 11645 CHECK_PARSE_BOOL(AllowShortBlocksOnASingleLine); 11646 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 11647 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 11648 CHECK_PARSE_BOOL(BinPackArguments); 11649 CHECK_PARSE_BOOL(BinPackParameters); 11650 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 11651 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 11652 CHECK_PARSE_BOOL(BreakStringLiterals); 11653 CHECK_PARSE_BOOL(CompactNamespaces); 11654 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 11655 CHECK_PARSE_BOOL(DerivePointerAlignment); 11656 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 11657 CHECK_PARSE_BOOL(DisableFormat); 11658 CHECK_PARSE_BOOL(IndentCaseLabels); 11659 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 11660 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 11661 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 11662 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 11663 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 11664 CHECK_PARSE_BOOL(ReflowComments); 11665 CHECK_PARSE_BOOL(SortIncludes); 11666 CHECK_PARSE_BOOL(SortUsingDeclarations); 11667 CHECK_PARSE_BOOL(SpacesInParentheses); 11668 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 11669 CHECK_PARSE_BOOL(SpacesInAngles); 11670 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 11671 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 11672 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 11673 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 11674 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 11675 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 11676 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 11677 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 11678 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 11679 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 11680 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 11681 11682 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 11683 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 11684 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterControlStatement); 11685 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 11686 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 11687 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 11688 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 11689 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 11690 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 11691 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 11692 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 11693 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 11694 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 11695 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 11696 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 11697 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 11698 } 11699 11700 #undef CHECK_PARSE_BOOL 11701 11702 TEST_F(FormatTest, ParsesConfiguration) { 11703 FormatStyle Style = {}; 11704 Style.Language = FormatStyle::LK_Cpp; 11705 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 11706 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 11707 ConstructorInitializerIndentWidth, 1234u); 11708 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 11709 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 11710 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 11711 CHECK_PARSE("PenaltyBreakAssignment: 1234", 11712 PenaltyBreakAssignment, 1234u); 11713 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 11714 PenaltyBreakBeforeFirstCallParameter, 1234u); 11715 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 11716 PenaltyBreakTemplateDeclaration, 1234u); 11717 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 11718 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 11719 PenaltyReturnTypeOnItsOwnLine, 1234u); 11720 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 11721 SpacesBeforeTrailingComments, 1234u); 11722 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 11723 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 11724 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 11725 11726 Style.PointerAlignment = FormatStyle::PAS_Middle; 11727 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 11728 FormatStyle::PAS_Left); 11729 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 11730 FormatStyle::PAS_Right); 11731 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 11732 FormatStyle::PAS_Middle); 11733 // For backward compatibility: 11734 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 11735 FormatStyle::PAS_Left); 11736 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 11737 FormatStyle::PAS_Right); 11738 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 11739 FormatStyle::PAS_Middle); 11740 11741 Style.Standard = FormatStyle::LS_Auto; 11742 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 11743 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11); 11744 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 11745 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 11746 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 11747 11748 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11749 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 11750 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 11751 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 11752 FormatStyle::BOS_None); 11753 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 11754 FormatStyle::BOS_All); 11755 // For backward compatibility: 11756 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 11757 FormatStyle::BOS_None); 11758 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 11759 FormatStyle::BOS_All); 11760 11761 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 11762 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 11763 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 11764 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 11765 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 11766 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 11767 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 11768 // For backward compatibility: 11769 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 11770 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 11771 11772 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 11773 CHECK_PARSE("BreakInheritanceList: BeforeComma", 11774 BreakInheritanceList, FormatStyle::BILS_BeforeComma); 11775 CHECK_PARSE("BreakInheritanceList: AfterColon", 11776 BreakInheritanceList, FormatStyle::BILS_AfterColon); 11777 CHECK_PARSE("BreakInheritanceList: BeforeColon", 11778 BreakInheritanceList, FormatStyle::BILS_BeforeColon); 11779 // For backward compatibility: 11780 CHECK_PARSE("BreakBeforeInheritanceComma: true", 11781 BreakInheritanceList, FormatStyle::BILS_BeforeComma); 11782 11783 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 11784 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 11785 FormatStyle::BAS_Align); 11786 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 11787 FormatStyle::BAS_DontAlign); 11788 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 11789 FormatStyle::BAS_AlwaysBreak); 11790 // For backward compatibility: 11791 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 11792 FormatStyle::BAS_DontAlign); 11793 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 11794 FormatStyle::BAS_Align); 11795 11796 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11797 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 11798 FormatStyle::ENAS_DontAlign); 11799 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 11800 FormatStyle::ENAS_Left); 11801 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 11802 FormatStyle::ENAS_Right); 11803 // For backward compatibility: 11804 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 11805 FormatStyle::ENAS_Left); 11806 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 11807 FormatStyle::ENAS_Right); 11808 11809 Style.UseTab = FormatStyle::UT_ForIndentation; 11810 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 11811 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 11812 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 11813 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 11814 FormatStyle::UT_ForContinuationAndIndentation); 11815 // For backward compatibility: 11816 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 11817 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 11818 11819 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 11820 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 11821 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 11822 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 11823 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 11824 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 11825 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 11826 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 11827 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 11828 // For backward compatibility: 11829 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 11830 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 11831 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 11832 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 11833 11834 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 11835 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 11836 FormatStyle::SBPO_Never); 11837 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 11838 FormatStyle::SBPO_Always); 11839 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 11840 FormatStyle::SBPO_ControlStatements); 11841 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 11842 FormatStyle::SBPO_NonEmptyParentheses); 11843 // For backward compatibility: 11844 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 11845 FormatStyle::SBPO_Never); 11846 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 11847 FormatStyle::SBPO_ControlStatements); 11848 11849 Style.ColumnLimit = 123; 11850 FormatStyle BaseStyle = getLLVMStyle(); 11851 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 11852 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 11853 11854 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11855 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 11856 FormatStyle::BS_Attach); 11857 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 11858 FormatStyle::BS_Linux); 11859 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 11860 FormatStyle::BS_Mozilla); 11861 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 11862 FormatStyle::BS_Stroustrup); 11863 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 11864 FormatStyle::BS_Allman); 11865 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 11866 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 11867 FormatStyle::BS_WebKit); 11868 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 11869 FormatStyle::BS_Custom); 11870 11871 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 11872 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 11873 FormatStyle::RTBS_None); 11874 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 11875 FormatStyle::RTBS_All); 11876 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 11877 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 11878 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 11879 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 11880 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 11881 AlwaysBreakAfterReturnType, 11882 FormatStyle::RTBS_TopLevelDefinitions); 11883 11884 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 11885 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", AlwaysBreakTemplateDeclarations, 11886 FormatStyle::BTDS_No); 11887 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", AlwaysBreakTemplateDeclarations, 11888 FormatStyle::BTDS_MultiLine); 11889 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", AlwaysBreakTemplateDeclarations, 11890 FormatStyle::BTDS_Yes); 11891 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", AlwaysBreakTemplateDeclarations, 11892 FormatStyle::BTDS_MultiLine); 11893 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", AlwaysBreakTemplateDeclarations, 11894 FormatStyle::BTDS_Yes); 11895 11896 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 11897 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 11898 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 11899 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 11900 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 11901 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 11902 AlwaysBreakAfterDefinitionReturnType, 11903 FormatStyle::DRTBS_TopLevel); 11904 11905 Style.NamespaceIndentation = FormatStyle::NI_All; 11906 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 11907 FormatStyle::NI_None); 11908 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 11909 FormatStyle::NI_Inner); 11910 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 11911 FormatStyle::NI_All); 11912 11913 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 11914 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 11915 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 11916 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 11917 AllowShortIfStatementsOnASingleLine, 11918 FormatStyle::SIS_WithoutElse); 11919 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 11920 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 11921 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 11922 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 11923 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 11924 AllowShortIfStatementsOnASingleLine, 11925 FormatStyle::SIS_WithoutElse); 11926 11927 // FIXME: This is required because parsing a configuration simply overwrites 11928 // the first N elements of the list instead of resetting it. 11929 Style.ForEachMacros.clear(); 11930 std::vector<std::string> BoostForeach; 11931 BoostForeach.push_back("BOOST_FOREACH"); 11932 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 11933 std::vector<std::string> BoostAndQForeach; 11934 BoostAndQForeach.push_back("BOOST_FOREACH"); 11935 BoostAndQForeach.push_back("Q_FOREACH"); 11936 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 11937 BoostAndQForeach); 11938 11939 Style.StatementMacros.clear(); 11940 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 11941 std::vector<std::string>{"QUNUSED"}); 11942 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 11943 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 11944 11945 Style.NamespaceMacros.clear(); 11946 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 11947 std::vector<std::string>{"TESTSUITE"}); 11948 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 11949 std::vector<std::string>({"TESTSUITE", "SUITE"})); 11950 11951 Style.IncludeStyle.IncludeCategories.clear(); 11952 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 11953 {"abc/.*", 2}, {".*", 1}}; 11954 CHECK_PARSE("IncludeCategories:\n" 11955 " - Regex: abc/.*\n" 11956 " Priority: 2\n" 11957 " - Regex: .*\n" 11958 " Priority: 1", 11959 IncludeStyle.IncludeCategories, ExpectedCategories); 11960 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 11961 "abc$"); 11962 11963 Style.RawStringFormats.clear(); 11964 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 11965 { 11966 FormatStyle::LK_TextProto, 11967 {"pb", "proto"}, 11968 {"PARSE_TEXT_PROTO"}, 11969 /*CanonicalDelimiter=*/"", 11970 "llvm", 11971 }, 11972 { 11973 FormatStyle::LK_Cpp, 11974 {"cc", "cpp"}, 11975 {"C_CODEBLOCK", "CPPEVAL"}, 11976 /*CanonicalDelimiter=*/"cc", 11977 /*BasedOnStyle=*/"", 11978 }, 11979 }; 11980 11981 CHECK_PARSE("RawStringFormats:\n" 11982 " - Language: TextProto\n" 11983 " Delimiters:\n" 11984 " - 'pb'\n" 11985 " - 'proto'\n" 11986 " EnclosingFunctions:\n" 11987 " - 'PARSE_TEXT_PROTO'\n" 11988 " BasedOnStyle: llvm\n" 11989 " - Language: Cpp\n" 11990 " Delimiters:\n" 11991 " - 'cc'\n" 11992 " - 'cpp'\n" 11993 " EnclosingFunctions:\n" 11994 " - 'C_CODEBLOCK'\n" 11995 " - 'CPPEVAL'\n" 11996 " CanonicalDelimiter: 'cc'", 11997 RawStringFormats, ExpectedRawStringFormats); 11998 } 11999 12000 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 12001 FormatStyle Style = {}; 12002 Style.Language = FormatStyle::LK_Cpp; 12003 CHECK_PARSE("Language: Cpp\n" 12004 "IndentWidth: 12", 12005 IndentWidth, 12u); 12006 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 12007 "IndentWidth: 34", 12008 &Style), 12009 ParseError::Unsuitable); 12010 EXPECT_EQ(12u, Style.IndentWidth); 12011 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12012 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12013 12014 Style.Language = FormatStyle::LK_JavaScript; 12015 CHECK_PARSE("Language: JavaScript\n" 12016 "IndentWidth: 12", 12017 IndentWidth, 12u); 12018 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 12019 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 12020 "IndentWidth: 34", 12021 &Style), 12022 ParseError::Unsuitable); 12023 EXPECT_EQ(23u, Style.IndentWidth); 12024 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12025 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12026 12027 CHECK_PARSE("BasedOnStyle: LLVM\n" 12028 "IndentWidth: 67", 12029 IndentWidth, 67u); 12030 12031 CHECK_PARSE("---\n" 12032 "Language: JavaScript\n" 12033 "IndentWidth: 12\n" 12034 "---\n" 12035 "Language: Cpp\n" 12036 "IndentWidth: 34\n" 12037 "...\n", 12038 IndentWidth, 12u); 12039 12040 Style.Language = FormatStyle::LK_Cpp; 12041 CHECK_PARSE("---\n" 12042 "Language: JavaScript\n" 12043 "IndentWidth: 12\n" 12044 "---\n" 12045 "Language: Cpp\n" 12046 "IndentWidth: 34\n" 12047 "...\n", 12048 IndentWidth, 34u); 12049 CHECK_PARSE("---\n" 12050 "IndentWidth: 78\n" 12051 "---\n" 12052 "Language: JavaScript\n" 12053 "IndentWidth: 56\n" 12054 "...\n", 12055 IndentWidth, 78u); 12056 12057 Style.ColumnLimit = 123; 12058 Style.IndentWidth = 234; 12059 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 12060 Style.TabWidth = 345; 12061 EXPECT_FALSE(parseConfiguration("---\n" 12062 "IndentWidth: 456\n" 12063 "BreakBeforeBraces: Allman\n" 12064 "---\n" 12065 "Language: JavaScript\n" 12066 "IndentWidth: 111\n" 12067 "TabWidth: 111\n" 12068 "---\n" 12069 "Language: Cpp\n" 12070 "BreakBeforeBraces: Stroustrup\n" 12071 "TabWidth: 789\n" 12072 "...\n", 12073 &Style)); 12074 EXPECT_EQ(123u, Style.ColumnLimit); 12075 EXPECT_EQ(456u, Style.IndentWidth); 12076 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 12077 EXPECT_EQ(789u, Style.TabWidth); 12078 12079 EXPECT_EQ(parseConfiguration("---\n" 12080 "Language: JavaScript\n" 12081 "IndentWidth: 56\n" 12082 "---\n" 12083 "IndentWidth: 78\n" 12084 "...\n", 12085 &Style), 12086 ParseError::Error); 12087 EXPECT_EQ(parseConfiguration("---\n" 12088 "Language: JavaScript\n" 12089 "IndentWidth: 56\n" 12090 "---\n" 12091 "Language: JavaScript\n" 12092 "IndentWidth: 78\n" 12093 "...\n", 12094 &Style), 12095 ParseError::Error); 12096 12097 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12098 } 12099 12100 #undef CHECK_PARSE 12101 12102 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 12103 FormatStyle Style = {}; 12104 Style.Language = FormatStyle::LK_JavaScript; 12105 Style.BreakBeforeTernaryOperators = true; 12106 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 12107 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 12108 12109 Style.BreakBeforeTernaryOperators = true; 12110 EXPECT_EQ(0, parseConfiguration("---\n" 12111 "BasedOnStyle: Google\n" 12112 "---\n" 12113 "Language: JavaScript\n" 12114 "IndentWidth: 76\n" 12115 "...\n", 12116 &Style) 12117 .value()); 12118 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 12119 EXPECT_EQ(76u, Style.IndentWidth); 12120 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12121 } 12122 12123 TEST_F(FormatTest, ConfigurationRoundTripTest) { 12124 FormatStyle Style = getLLVMStyle(); 12125 std::string YAML = configurationAsText(Style); 12126 FormatStyle ParsedStyle = {}; 12127 ParsedStyle.Language = FormatStyle::LK_Cpp; 12128 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 12129 EXPECT_EQ(Style, ParsedStyle); 12130 } 12131 12132 TEST_F(FormatTest, WorksFor8bitEncodings) { 12133 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 12134 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 12135 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 12136 "\"\xef\xee\xf0\xf3...\"", 12137 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 12138 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 12139 "\xef\xee\xf0\xf3...\"", 12140 getLLVMStyleWithColumns(12))); 12141 } 12142 12143 TEST_F(FormatTest, HandlesUTF8BOM) { 12144 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 12145 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 12146 format("\xef\xbb\xbf#include <iostream>")); 12147 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 12148 format("\xef\xbb\xbf\n#include <iostream>")); 12149 } 12150 12151 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 12152 #if !defined(_MSC_VER) 12153 12154 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 12155 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 12156 getLLVMStyleWithColumns(35)); 12157 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 12158 getLLVMStyleWithColumns(31)); 12159 verifyFormat("// Однажды в студёную зимнюю пору...", 12160 getLLVMStyleWithColumns(36)); 12161 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 12162 verifyFormat("/* Однажды в студёную зимнюю пору... */", 12163 getLLVMStyleWithColumns(39)); 12164 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 12165 getLLVMStyleWithColumns(35)); 12166 } 12167 12168 TEST_F(FormatTest, SplitsUTF8Strings) { 12169 // Non-printable characters' width is currently considered to be the length in 12170 // bytes in UTF8. The characters can be displayed in very different manner 12171 // (zero-width, single width with a substitution glyph, expanded to their code 12172 // (e.g. "<8d>"), so there's no single correct way to handle them. 12173 EXPECT_EQ("\"aaaaÄ\"\n" 12174 "\"\xc2\x8d\";", 12175 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 12176 EXPECT_EQ("\"aaaaaaaÄ\"\n" 12177 "\"\xc2\x8d\";", 12178 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 12179 EXPECT_EQ("\"Однажды, в \"\n" 12180 "\"студёную \"\n" 12181 "\"зимнюю \"\n" 12182 "\"пору,\"", 12183 format("\"Однажды, в студёную зимнюю пору,\"", 12184 getLLVMStyleWithColumns(13))); 12185 EXPECT_EQ( 12186 "\"一 二 三 \"\n" 12187 "\"四 五六 \"\n" 12188 "\"七 八 九 \"\n" 12189 "\"十\"", 12190 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 12191 EXPECT_EQ("\"一\t\"\n" 12192 "\"二 \t\"\n" 12193 "\"三 四 \"\n" 12194 "\"五\t\"\n" 12195 "\"六 \t\"\n" 12196 "\"七 \"\n" 12197 "\"八九十\tqq\"", 12198 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 12199 getLLVMStyleWithColumns(11))); 12200 12201 // UTF8 character in an escape sequence. 12202 EXPECT_EQ("\"aaaaaa\"\n" 12203 "\"\\\xC2\x8D\"", 12204 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 12205 } 12206 12207 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 12208 EXPECT_EQ("const char *sssss =\n" 12209 " \"一二三四五六七八\\\n" 12210 " 九 十\";", 12211 format("const char *sssss = \"一二三四五六七八\\\n" 12212 " 九 十\";", 12213 getLLVMStyleWithColumns(30))); 12214 } 12215 12216 TEST_F(FormatTest, SplitsUTF8LineComments) { 12217 EXPECT_EQ("// aaaaÄ\xc2\x8d", 12218 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 12219 EXPECT_EQ("// Я из лесу\n" 12220 "// вышел; был\n" 12221 "// сильный\n" 12222 "// мороз.", 12223 format("// Я из лесу вышел; был сильный мороз.", 12224 getLLVMStyleWithColumns(13))); 12225 EXPECT_EQ("// 一二三\n" 12226 "// 四五六七\n" 12227 "// 八 九\n" 12228 "// 十", 12229 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 12230 } 12231 12232 TEST_F(FormatTest, SplitsUTF8BlockComments) { 12233 EXPECT_EQ("/* Гляжу,\n" 12234 " * поднимается\n" 12235 " * медленно в\n" 12236 " * гору\n" 12237 " * Лошадка,\n" 12238 " * везущая\n" 12239 " * хворосту\n" 12240 " * воз. */", 12241 format("/* Гляжу, поднимается медленно в гору\n" 12242 " * Лошадка, везущая хворосту воз. */", 12243 getLLVMStyleWithColumns(13))); 12244 EXPECT_EQ( 12245 "/* 一二三\n" 12246 " * 四五六七\n" 12247 " * 八 九\n" 12248 " * 十 */", 12249 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 12250 EXPECT_EQ("/* �������� ��������\n" 12251 " * ��������\n" 12252 " * ������-�� */", 12253 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 12254 } 12255 12256 #endif // _MSC_VER 12257 12258 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 12259 FormatStyle Style = getLLVMStyle(); 12260 12261 Style.ConstructorInitializerIndentWidth = 4; 12262 verifyFormat( 12263 "SomeClass::Constructor()\n" 12264 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12265 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12266 Style); 12267 12268 Style.ConstructorInitializerIndentWidth = 2; 12269 verifyFormat( 12270 "SomeClass::Constructor()\n" 12271 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12272 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12273 Style); 12274 12275 Style.ConstructorInitializerIndentWidth = 0; 12276 verifyFormat( 12277 "SomeClass::Constructor()\n" 12278 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 12279 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 12280 Style); 12281 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 12282 verifyFormat( 12283 "SomeLongTemplateVariableName<\n" 12284 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 12285 Style); 12286 verifyFormat( 12287 "bool smaller = 1 < bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 12288 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 12289 Style); 12290 12291 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 12292 verifyFormat( 12293 "SomeClass::Constructor() :\n" 12294 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 12295 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 12296 Style); 12297 } 12298 12299 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 12300 FormatStyle Style = getLLVMStyle(); 12301 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 12302 Style.ConstructorInitializerIndentWidth = 4; 12303 verifyFormat("SomeClass::Constructor()\n" 12304 " : a(a)\n" 12305 " , b(b)\n" 12306 " , c(c) {}", 12307 Style); 12308 verifyFormat("SomeClass::Constructor()\n" 12309 " : a(a) {}", 12310 Style); 12311 12312 Style.ColumnLimit = 0; 12313 verifyFormat("SomeClass::Constructor()\n" 12314 " : a(a) {}", 12315 Style); 12316 verifyFormat("SomeClass::Constructor() noexcept\n" 12317 " : a(a) {}", 12318 Style); 12319 verifyFormat("SomeClass::Constructor()\n" 12320 " : a(a)\n" 12321 " , b(b)\n" 12322 " , c(c) {}", 12323 Style); 12324 verifyFormat("SomeClass::Constructor()\n" 12325 " : a(a) {\n" 12326 " foo();\n" 12327 " bar();\n" 12328 "}", 12329 Style); 12330 12331 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 12332 verifyFormat("SomeClass::Constructor()\n" 12333 " : a(a)\n" 12334 " , b(b)\n" 12335 " , c(c) {\n}", 12336 Style); 12337 verifyFormat("SomeClass::Constructor()\n" 12338 " : a(a) {\n}", 12339 Style); 12340 12341 Style.ColumnLimit = 80; 12342 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 12343 Style.ConstructorInitializerIndentWidth = 2; 12344 verifyFormat("SomeClass::Constructor()\n" 12345 " : a(a)\n" 12346 " , b(b)\n" 12347 " , c(c) {}", 12348 Style); 12349 12350 Style.ConstructorInitializerIndentWidth = 0; 12351 verifyFormat("SomeClass::Constructor()\n" 12352 ": a(a)\n" 12353 ", b(b)\n" 12354 ", c(c) {}", 12355 Style); 12356 12357 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 12358 Style.ConstructorInitializerIndentWidth = 4; 12359 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 12360 verifyFormat( 12361 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 12362 Style); 12363 verifyFormat( 12364 "SomeClass::Constructor()\n" 12365 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 12366 Style); 12367 Style.ConstructorInitializerIndentWidth = 4; 12368 Style.ColumnLimit = 60; 12369 verifyFormat("SomeClass::Constructor()\n" 12370 " : aaaaaaaa(aaaaaaaa)\n" 12371 " , aaaaaaaa(aaaaaaaa)\n" 12372 " , aaaaaaaa(aaaaaaaa) {}", 12373 Style); 12374 } 12375 12376 TEST_F(FormatTest, Destructors) { 12377 verifyFormat("void F(int &i) { i.~int(); }"); 12378 verifyFormat("void F(int &i) { i->~int(); }"); 12379 } 12380 12381 TEST_F(FormatTest, FormatsWithWebKitStyle) { 12382 FormatStyle Style = getWebKitStyle(); 12383 12384 // Don't indent in outer namespaces. 12385 verifyFormat("namespace outer {\n" 12386 "int i;\n" 12387 "namespace inner {\n" 12388 " int i;\n" 12389 "} // namespace inner\n" 12390 "} // namespace outer\n" 12391 "namespace other_outer {\n" 12392 "int i;\n" 12393 "}", 12394 Style); 12395 12396 // Don't indent case labels. 12397 verifyFormat("switch (variable) {\n" 12398 "case 1:\n" 12399 "case 2:\n" 12400 " doSomething();\n" 12401 " break;\n" 12402 "default:\n" 12403 " ++variable;\n" 12404 "}", 12405 Style); 12406 12407 // Wrap before binary operators. 12408 EXPECT_EQ("void f()\n" 12409 "{\n" 12410 " if (aaaaaaaaaaaaaaaa\n" 12411 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 12412 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 12413 " return;\n" 12414 "}", 12415 format("void f() {\n" 12416 "if (aaaaaaaaaaaaaaaa\n" 12417 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 12418 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 12419 "return;\n" 12420 "}", 12421 Style)); 12422 12423 // Allow functions on a single line. 12424 verifyFormat("void f() { return; }", Style); 12425 12426 // Constructor initializers are formatted one per line with the "," on the 12427 // new line. 12428 verifyFormat("Constructor()\n" 12429 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 12430 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 12431 " aaaaaaaaaaaaaa)\n" 12432 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 12433 "{\n" 12434 "}", 12435 Style); 12436 verifyFormat("SomeClass::Constructor()\n" 12437 " : a(a)\n" 12438 "{\n" 12439 "}", 12440 Style); 12441 EXPECT_EQ("SomeClass::Constructor()\n" 12442 " : a(a)\n" 12443 "{\n" 12444 "}", 12445 format("SomeClass::Constructor():a(a){}", Style)); 12446 verifyFormat("SomeClass::Constructor()\n" 12447 " : a(a)\n" 12448 " , b(b)\n" 12449 " , c(c)\n" 12450 "{\n" 12451 "}", 12452 Style); 12453 verifyFormat("SomeClass::Constructor()\n" 12454 " : a(a)\n" 12455 "{\n" 12456 " foo();\n" 12457 " bar();\n" 12458 "}", 12459 Style); 12460 12461 // Access specifiers should be aligned left. 12462 verifyFormat("class C {\n" 12463 "public:\n" 12464 " int i;\n" 12465 "};", 12466 Style); 12467 12468 // Do not align comments. 12469 verifyFormat("int a; // Do not\n" 12470 "double b; // align comments.", 12471 Style); 12472 12473 // Do not align operands. 12474 EXPECT_EQ("ASSERT(aaaa\n" 12475 " || bbbb);", 12476 format("ASSERT ( aaaa\n||bbbb);", Style)); 12477 12478 // Accept input's line breaks. 12479 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 12480 " || bbbbbbbbbbbbbbb) {\n" 12481 " i++;\n" 12482 "}", 12483 format("if (aaaaaaaaaaaaaaa\n" 12484 "|| bbbbbbbbbbbbbbb) { i++; }", 12485 Style)); 12486 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 12487 " i++;\n" 12488 "}", 12489 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 12490 12491 // Don't automatically break all macro definitions (llvm.org/PR17842). 12492 verifyFormat("#define aNumber 10", Style); 12493 // However, generally keep the line breaks that the user authored. 12494 EXPECT_EQ("#define aNumber \\\n" 12495 " 10", 12496 format("#define aNumber \\\n" 12497 " 10", 12498 Style)); 12499 12500 // Keep empty and one-element array literals on a single line. 12501 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 12502 " copyItems:YES];", 12503 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 12504 "copyItems:YES];", 12505 Style)); 12506 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 12507 " copyItems:YES];", 12508 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 12509 " copyItems:YES];", 12510 Style)); 12511 // FIXME: This does not seem right, there should be more indentation before 12512 // the array literal's entries. Nested blocks have the same problem. 12513 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 12514 " @\"a\",\n" 12515 " @\"a\"\n" 12516 "]\n" 12517 " copyItems:YES];", 12518 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 12519 " @\"a\",\n" 12520 " @\"a\"\n" 12521 " ]\n" 12522 " copyItems:YES];", 12523 Style)); 12524 EXPECT_EQ( 12525 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 12526 " copyItems:YES];", 12527 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 12528 " copyItems:YES];", 12529 Style)); 12530 12531 verifyFormat("[self.a b:c c:d];", Style); 12532 EXPECT_EQ("[self.a b:c\n" 12533 " c:d];", 12534 format("[self.a b:c\n" 12535 "c:d];", 12536 Style)); 12537 } 12538 12539 TEST_F(FormatTest, FormatsLambdas) { 12540 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 12541 verifyFormat( 12542 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 12543 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 12544 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 12545 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 12546 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 12547 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 12548 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 12549 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 12550 verifyFormat("int x = f(*+[] {});"); 12551 verifyFormat("void f() {\n" 12552 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 12553 "}\n"); 12554 verifyFormat("void f() {\n" 12555 " other(x.begin(), //\n" 12556 " x.end(), //\n" 12557 " [&](int, int) { return 1; });\n" 12558 "}\n"); 12559 verifyFormat("void f() {\n" 12560 " other.other.other.other.other(\n" 12561 " x.begin(), x.end(),\n" 12562 " [something, rather](int, int, int, int, int, int, int) { return 1; });\n" 12563 "}\n"); 12564 verifyFormat("void f() {\n" 12565 " other.other.other.other.other(\n" 12566 " x.begin(), x.end(),\n" 12567 " [something, rather](int, int, int, int, int, int, int) {\n" 12568 " //\n" 12569 " });\n" 12570 "}\n"); 12571 verifyFormat("SomeFunction([]() { // A cool function...\n" 12572 " return 43;\n" 12573 "});"); 12574 EXPECT_EQ("SomeFunction([]() {\n" 12575 "#define A a\n" 12576 " return 43;\n" 12577 "});", 12578 format("SomeFunction([](){\n" 12579 "#define A a\n" 12580 "return 43;\n" 12581 "});")); 12582 verifyFormat("void f() {\n" 12583 " SomeFunction([](decltype(x), A *a) {});\n" 12584 "}"); 12585 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 12586 " [](const aaaaaaaaaa &a) { return a; });"); 12587 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 12588 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 12589 "});"); 12590 verifyFormat("Constructor()\n" 12591 " : Field([] { // comment\n" 12592 " int i;\n" 12593 " }) {}"); 12594 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 12595 " return some_parameter.size();\n" 12596 "};"); 12597 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 12598 " [](const string &s) { return s; };"); 12599 verifyFormat("int i = aaaaaa ? 1 //\n" 12600 " : [] {\n" 12601 " return 2; //\n" 12602 " }();"); 12603 verifyFormat("llvm::errs() << \"number of twos is \"\n" 12604 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 12605 " return x == 2; // force break\n" 12606 " });"); 12607 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 12608 " [=](int iiiiiiiiiiii) {\n" 12609 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 12610 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 12611 " });", 12612 getLLVMStyleWithColumns(60)); 12613 verifyFormat("SomeFunction({[&] {\n" 12614 " // comment\n" 12615 " },\n" 12616 " [&] {\n" 12617 " // comment\n" 12618 " }});"); 12619 verifyFormat("SomeFunction({[&] {\n" 12620 " // comment\n" 12621 "}});"); 12622 verifyFormat("virtual aaaaaaaaaaaaaaaa(\n" 12623 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 12624 " aaaaa aaaaaaaaa);"); 12625 12626 // Lambdas with return types. 12627 verifyFormat("int c = []() -> int { return 2; }();\n"); 12628 verifyFormat("int c = []() -> int * { return 2; }();\n"); 12629 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 12630 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 12631 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 12632 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 12633 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 12634 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 12635 verifyFormat("[a, a]() -> a<1> {};"); 12636 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 12637 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 12638 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 12639 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 12640 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 12641 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 12642 verifyFormat("[]() -> foo<!5> { return {}; };"); 12643 verifyFormat("[]() -> foo<~5> { return {}; };"); 12644 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 12645 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 12646 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 12647 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 12648 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 12649 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 12650 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 12651 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 12652 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 12653 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 12654 verifyFormat("namespace bar {\n" 12655 "// broken:\n" 12656 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 12657 "} // namespace bar"); 12658 verifyFormat("namespace bar {\n" 12659 "// broken:\n" 12660 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 12661 "} // namespace bar"); 12662 verifyFormat("namespace bar {\n" 12663 "// broken:\n" 12664 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 12665 "} // namespace bar"); 12666 verifyFormat("namespace bar {\n" 12667 "// broken:\n" 12668 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 12669 "} // namespace bar"); 12670 verifyFormat("namespace bar {\n" 12671 "// broken:\n" 12672 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 12673 "} // namespace bar"); 12674 verifyFormat("namespace bar {\n" 12675 "// broken:\n" 12676 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 12677 "} // namespace bar"); 12678 verifyFormat("namespace bar {\n" 12679 "// broken:\n" 12680 "auto foo{[]() -> foo<!5> { return {}; }};\n" 12681 "} // namespace bar"); 12682 verifyFormat("namespace bar {\n" 12683 "// broken:\n" 12684 "auto foo{[]() -> foo<~5> { return {}; }};\n" 12685 "} // namespace bar"); 12686 verifyFormat("namespace bar {\n" 12687 "// broken:\n" 12688 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 12689 "} // namespace bar"); 12690 verifyFormat("namespace bar {\n" 12691 "// broken:\n" 12692 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 12693 "} // namespace bar"); 12694 verifyFormat("namespace bar {\n" 12695 "// broken:\n" 12696 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 12697 "} // namespace bar"); 12698 verifyFormat("namespace bar {\n" 12699 "// broken:\n" 12700 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 12701 "} // namespace bar"); 12702 verifyFormat("namespace bar {\n" 12703 "// broken:\n" 12704 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 12705 "} // namespace bar"); 12706 verifyFormat("namespace bar {\n" 12707 "// broken:\n" 12708 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 12709 "} // namespace bar"); 12710 verifyFormat("namespace bar {\n" 12711 "// broken:\n" 12712 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 12713 "} // namespace bar"); 12714 verifyFormat("namespace bar {\n" 12715 "// broken:\n" 12716 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 12717 "} // namespace bar"); 12718 verifyFormat("namespace bar {\n" 12719 "// broken:\n" 12720 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 12721 "} // namespace bar"); 12722 verifyFormat("namespace bar {\n" 12723 "// broken:\n" 12724 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 12725 "} // namespace bar"); 12726 verifyFormat("[]() -> a<1> {};"); 12727 verifyFormat("[]() -> a<1> { ; };"); 12728 verifyFormat("[]() -> a<1> { ; }();"); 12729 verifyFormat("[a, a]() -> a<true> {};"); 12730 verifyFormat("[]() -> a<true> {};"); 12731 verifyFormat("[]() -> a<true> { ; };"); 12732 verifyFormat("[]() -> a<true> { ; }();"); 12733 verifyFormat("[a, a]() -> a<false> {};"); 12734 verifyFormat("[]() -> a<false> {};"); 12735 verifyFormat("[]() -> a<false> { ; };"); 12736 verifyFormat("[]() -> a<false> { ; }();"); 12737 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 12738 verifyFormat("namespace bar {\n" 12739 "auto foo{[]() -> foo<false> { ; }};\n" 12740 "} // namespace bar"); 12741 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 12742 " int j) -> int {\n" 12743 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 12744 "};"); 12745 verifyFormat( 12746 "aaaaaaaaaaaaaaaaaaaaaa(\n" 12747 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 12748 " return aaaaaaaaaaaaaaaaa;\n" 12749 " });", 12750 getLLVMStyleWithColumns(70)); 12751 verifyFormat("[]() //\n" 12752 " -> int {\n" 12753 " return 1; //\n" 12754 "};"); 12755 12756 // Multiple lambdas in the same parentheses change indentation rules. These 12757 // lambdas are forced to start on new lines. 12758 verifyFormat("SomeFunction(\n" 12759 " []() {\n" 12760 " //\n" 12761 " },\n" 12762 " []() {\n" 12763 " //\n" 12764 " });"); 12765 12766 // A lambda passed as arg0 is always pushed to the next line. 12767 verifyFormat("SomeFunction(\n" 12768 " [this] {\n" 12769 " //\n" 12770 " },\n" 12771 " 1);\n"); 12772 12773 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like the arg0 12774 // case above. 12775 auto Style = getGoogleStyle(); 12776 Style.BinPackArguments = false; 12777 verifyFormat("SomeFunction(\n" 12778 " a,\n" 12779 " [this] {\n" 12780 " //\n" 12781 " },\n" 12782 " b);\n", 12783 Style); 12784 verifyFormat("SomeFunction(\n" 12785 " a,\n" 12786 " [this] {\n" 12787 " //\n" 12788 " },\n" 12789 " b);\n"); 12790 12791 // A lambda with a very long line forces arg0 to be pushed out irrespective of 12792 // the BinPackArguments value (as long as the code is wide enough). 12793 verifyFormat("something->SomeFunction(\n" 12794 " a,\n" 12795 " [this] {\n" 12796 " D0000000000000000000000000000000000000000000000000000000000001();\n" 12797 " },\n" 12798 " b);\n"); 12799 12800 // A multi-line lambda is pulled up as long as the introducer fits on the previous 12801 // line and there are no further args. 12802 verifyFormat("function(1, [this, that] {\n" 12803 " //\n" 12804 "});\n"); 12805 verifyFormat("function([this, that] {\n" 12806 " //\n" 12807 "});\n"); 12808 // FIXME: this format is not ideal and we should consider forcing the first arg 12809 // onto its own line. 12810 verifyFormat("function(a, b, c, //\n" 12811 " d, [this, that] {\n" 12812 " //\n" 12813 " });\n"); 12814 12815 // Multiple lambdas are treated correctly even when there is a short arg0. 12816 verifyFormat("SomeFunction(\n" 12817 " 1,\n" 12818 " [this] {\n" 12819 " //\n" 12820 " },\n" 12821 " [this] {\n" 12822 " //\n" 12823 " },\n" 12824 " 1);\n"); 12825 12826 // More complex introducers. 12827 verifyFormat("return [i, args...] {};"); 12828 12829 // Not lambdas. 12830 verifyFormat("constexpr char hello[]{\"hello\"};"); 12831 verifyFormat("double &operator[](int i) { return 0; }\n" 12832 "int i;"); 12833 verifyFormat("std::unique_ptr<int[]> foo() {}"); 12834 verifyFormat("int i = a[a][a]->f();"); 12835 verifyFormat("int i = (*b)[a]->f();"); 12836 12837 // Other corner cases. 12838 verifyFormat("void f() {\n" 12839 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 12840 " );\n" 12841 "}"); 12842 12843 // Lambdas created through weird macros. 12844 verifyFormat("void f() {\n" 12845 " MACRO((const AA &a) { return 1; });\n" 12846 " MACRO((AA &a) { return 1; });\n" 12847 "}"); 12848 12849 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 12850 " doo_dah();\n" 12851 " doo_dah();\n" 12852 " })) {\n" 12853 "}"); 12854 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 12855 " doo_dah();\n" 12856 " doo_dah();\n" 12857 " })) {\n" 12858 "}"); 12859 verifyFormat("auto lambda = []() {\n" 12860 " int a = 2\n" 12861 "#if A\n" 12862 " + 2\n" 12863 "#endif\n" 12864 " ;\n" 12865 "};"); 12866 12867 // Lambdas with complex multiline introducers. 12868 verifyFormat( 12869 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 12870 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 12871 " -> ::std::unordered_set<\n" 12872 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 12873 " //\n" 12874 " });"); 12875 12876 FormatStyle DoNotMerge = getLLVMStyle(); 12877 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 12878 verifyFormat("auto c = []() {\n" 12879 " return b;\n" 12880 "};", 12881 "auto c = []() { return b; };", DoNotMerge); 12882 verifyFormat("auto c = []() {\n" 12883 "};", 12884 " auto c = []() {};", DoNotMerge); 12885 12886 FormatStyle MergeEmptyOnly = getLLVMStyle(); 12887 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 12888 verifyFormat("auto c = []() {\n" 12889 " return b;\n" 12890 "};", 12891 "auto c = []() {\n" 12892 " return b;\n" 12893 " };", 12894 MergeEmptyOnly); 12895 verifyFormat("auto c = []() {};", 12896 "auto c = []() {\n" 12897 "};", 12898 MergeEmptyOnly); 12899 12900 FormatStyle MergeInline = getLLVMStyle(); 12901 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 12902 verifyFormat("auto c = []() {\n" 12903 " return b;\n" 12904 "};", 12905 "auto c = []() { return b; };", MergeInline); 12906 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 12907 MergeInline); 12908 verifyFormat("function([]() { return b; }, a)", 12909 "function([]() { return b; }, a)", MergeInline); 12910 verifyFormat("function(a, []() { return b; })", 12911 "function(a, []() { return b; })", MergeInline); 12912 } 12913 12914 TEST_F(FormatTest, EmptyLinesInLambdas) { 12915 verifyFormat("auto lambda = []() {\n" 12916 " x(); //\n" 12917 "};", 12918 "auto lambda = []() {\n" 12919 "\n" 12920 " x(); //\n" 12921 "\n" 12922 "};"); 12923 } 12924 12925 TEST_F(FormatTest, FormatsBlocks) { 12926 FormatStyle ShortBlocks = getLLVMStyle(); 12927 ShortBlocks.AllowShortBlocksOnASingleLine = true; 12928 verifyFormat("int (^Block)(int, int);", ShortBlocks); 12929 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 12930 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 12931 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 12932 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 12933 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 12934 12935 verifyFormat("foo(^{ bar(); });", ShortBlocks); 12936 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 12937 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 12938 12939 verifyFormat("[operation setCompletionBlock:^{\n" 12940 " [self onOperationDone];\n" 12941 "}];"); 12942 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 12943 " [self onOperationDone];\n" 12944 "}]};"); 12945 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 12946 " f();\n" 12947 "}];"); 12948 verifyFormat("int a = [operation block:^int(int *i) {\n" 12949 " return 1;\n" 12950 "}];"); 12951 verifyFormat("[myObject doSomethingWith:arg1\n" 12952 " aaa:^int(int *a) {\n" 12953 " return 1;\n" 12954 " }\n" 12955 " bbb:f(a * bbbbbbbb)];"); 12956 12957 verifyFormat("[operation setCompletionBlock:^{\n" 12958 " [self.delegate newDataAvailable];\n" 12959 "}];", 12960 getLLVMStyleWithColumns(60)); 12961 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 12962 " NSString *path = [self sessionFilePath];\n" 12963 " if (path) {\n" 12964 " // ...\n" 12965 " }\n" 12966 "});"); 12967 verifyFormat("[[SessionService sharedService]\n" 12968 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 12969 " if (window) {\n" 12970 " [self windowDidLoad:window];\n" 12971 " } else {\n" 12972 " [self errorLoadingWindow];\n" 12973 " }\n" 12974 " }];"); 12975 verifyFormat("void (^largeBlock)(void) = ^{\n" 12976 " // ...\n" 12977 "};\n", 12978 getLLVMStyleWithColumns(40)); 12979 verifyFormat("[[SessionService sharedService]\n" 12980 " loadWindowWithCompletionBlock: //\n" 12981 " ^(SessionWindow *window) {\n" 12982 " if (window) {\n" 12983 " [self windowDidLoad:window];\n" 12984 " } else {\n" 12985 " [self errorLoadingWindow];\n" 12986 " }\n" 12987 " }];", 12988 getLLVMStyleWithColumns(60)); 12989 verifyFormat("[myObject doSomethingWith:arg1\n" 12990 " firstBlock:^(Foo *a) {\n" 12991 " // ...\n" 12992 " int i;\n" 12993 " }\n" 12994 " secondBlock:^(Bar *b) {\n" 12995 " // ...\n" 12996 " int i;\n" 12997 " }\n" 12998 " thirdBlock:^Foo(Bar *b) {\n" 12999 " // ...\n" 13000 " int i;\n" 13001 " }];"); 13002 verifyFormat("[myObject doSomethingWith:arg1\n" 13003 " firstBlock:-1\n" 13004 " secondBlock:^(Bar *b) {\n" 13005 " // ...\n" 13006 " int i;\n" 13007 " }];"); 13008 13009 verifyFormat("f(^{\n" 13010 " @autoreleasepool {\n" 13011 " if (a) {\n" 13012 " g();\n" 13013 " }\n" 13014 " }\n" 13015 "});"); 13016 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 13017 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 13018 "};"); 13019 13020 FormatStyle FourIndent = getLLVMStyle(); 13021 FourIndent.ObjCBlockIndentWidth = 4; 13022 verifyFormat("[operation setCompletionBlock:^{\n" 13023 " [self onOperationDone];\n" 13024 "}];", 13025 FourIndent); 13026 } 13027 13028 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 13029 FormatStyle ZeroColumn = getLLVMStyle(); 13030 ZeroColumn.ColumnLimit = 0; 13031 13032 verifyFormat("[[SessionService sharedService] " 13033 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13034 " if (window) {\n" 13035 " [self windowDidLoad:window];\n" 13036 " } else {\n" 13037 " [self errorLoadingWindow];\n" 13038 " }\n" 13039 "}];", 13040 ZeroColumn); 13041 EXPECT_EQ("[[SessionService sharedService]\n" 13042 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13043 " if (window) {\n" 13044 " [self windowDidLoad:window];\n" 13045 " } else {\n" 13046 " [self errorLoadingWindow];\n" 13047 " }\n" 13048 " }];", 13049 format("[[SessionService sharedService]\n" 13050 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13051 " if (window) {\n" 13052 " [self windowDidLoad:window];\n" 13053 " } else {\n" 13054 " [self errorLoadingWindow];\n" 13055 " }\n" 13056 "}];", 13057 ZeroColumn)); 13058 verifyFormat("[myObject doSomethingWith:arg1\n" 13059 " firstBlock:^(Foo *a) {\n" 13060 " // ...\n" 13061 " int i;\n" 13062 " }\n" 13063 " secondBlock:^(Bar *b) {\n" 13064 " // ...\n" 13065 " int i;\n" 13066 " }\n" 13067 " thirdBlock:^Foo(Bar *b) {\n" 13068 " // ...\n" 13069 " int i;\n" 13070 " }];", 13071 ZeroColumn); 13072 verifyFormat("f(^{\n" 13073 " @autoreleasepool {\n" 13074 " if (a) {\n" 13075 " g();\n" 13076 " }\n" 13077 " }\n" 13078 "});", 13079 ZeroColumn); 13080 verifyFormat("void (^largeBlock)(void) = ^{\n" 13081 " // ...\n" 13082 "};", 13083 ZeroColumn); 13084 13085 ZeroColumn.AllowShortBlocksOnASingleLine = true; 13086 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 13087 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 13088 ZeroColumn.AllowShortBlocksOnASingleLine = false; 13089 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 13090 " int i;\n" 13091 "};", 13092 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 13093 } 13094 13095 TEST_F(FormatTest, SupportsCRLF) { 13096 EXPECT_EQ("int a;\r\n" 13097 "int b;\r\n" 13098 "int c;\r\n", 13099 format("int a;\r\n" 13100 " int b;\r\n" 13101 " int c;\r\n", 13102 getLLVMStyle())); 13103 EXPECT_EQ("int a;\r\n" 13104 "int b;\r\n" 13105 "int c;\r\n", 13106 format("int a;\r\n" 13107 " int b;\n" 13108 " int c;\r\n", 13109 getLLVMStyle())); 13110 EXPECT_EQ("int a;\n" 13111 "int b;\n" 13112 "int c;\n", 13113 format("int a;\r\n" 13114 " int b;\n" 13115 " int c;\n", 13116 getLLVMStyle())); 13117 EXPECT_EQ("\"aaaaaaa \"\r\n" 13118 "\"bbbbbbb\";\r\n", 13119 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 13120 EXPECT_EQ("#define A \\\r\n" 13121 " b; \\\r\n" 13122 " c; \\\r\n" 13123 " d;\r\n", 13124 format("#define A \\\r\n" 13125 " b; \\\r\n" 13126 " c; d; \r\n", 13127 getGoogleStyle())); 13128 13129 EXPECT_EQ("/*\r\n" 13130 "multi line block comments\r\n" 13131 "should not introduce\r\n" 13132 "an extra carriage return\r\n" 13133 "*/\r\n", 13134 format("/*\r\n" 13135 "multi line block comments\r\n" 13136 "should not introduce\r\n" 13137 "an extra carriage return\r\n" 13138 "*/\r\n")); 13139 EXPECT_EQ("/*\r\n" 13140 "\r\n" 13141 "*/", 13142 format("/*\r\n" 13143 " \r\r\r\n" 13144 "*/")); 13145 } 13146 13147 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 13148 verifyFormat("MY_CLASS(C) {\n" 13149 " int i;\n" 13150 " int j;\n" 13151 "};"); 13152 } 13153 13154 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 13155 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 13156 TwoIndent.ContinuationIndentWidth = 2; 13157 13158 EXPECT_EQ("int i =\n" 13159 " longFunction(\n" 13160 " arg);", 13161 format("int i = longFunction(arg);", TwoIndent)); 13162 13163 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 13164 SixIndent.ContinuationIndentWidth = 6; 13165 13166 EXPECT_EQ("int i =\n" 13167 " longFunction(\n" 13168 " arg);", 13169 format("int i = longFunction(arg);", SixIndent)); 13170 } 13171 13172 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 13173 FormatStyle Style = getLLVMStyle(); 13174 verifyFormat("int Foo::getter(\n" 13175 " //\n" 13176 ") const {\n" 13177 " return foo;\n" 13178 "}", 13179 Style); 13180 verifyFormat("void Foo::setter(\n" 13181 " //\n" 13182 ") {\n" 13183 " foo = 1;\n" 13184 "}", 13185 Style); 13186 } 13187 13188 TEST_F(FormatTest, SpacesInAngles) { 13189 FormatStyle Spaces = getLLVMStyle(); 13190 Spaces.SpacesInAngles = true; 13191 13192 verifyFormat("static_cast< int >(arg);", Spaces); 13193 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 13194 verifyFormat("f< int, float >();", Spaces); 13195 verifyFormat("template <> g() {}", Spaces); 13196 verifyFormat("template < std::vector< int > > f() {}", Spaces); 13197 verifyFormat("std::function< void(int, int) > fct;", Spaces); 13198 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 13199 Spaces); 13200 13201 Spaces.Standard = FormatStyle::LS_Cpp03; 13202 Spaces.SpacesInAngles = true; 13203 verifyFormat("A< A< int > >();", Spaces); 13204 13205 Spaces.SpacesInAngles = false; 13206 verifyFormat("A<A<int> >();", Spaces); 13207 13208 Spaces.Standard = FormatStyle::LS_Cpp11; 13209 Spaces.SpacesInAngles = true; 13210 verifyFormat("A< A< int > >();", Spaces); 13211 13212 Spaces.SpacesInAngles = false; 13213 verifyFormat("A<A<int>>();", Spaces); 13214 } 13215 13216 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 13217 FormatStyle Style = getLLVMStyle(); 13218 Style.SpaceAfterTemplateKeyword = false; 13219 verifyFormat("template<int> void foo();", Style); 13220 } 13221 13222 TEST_F(FormatTest, TripleAngleBrackets) { 13223 verifyFormat("f<<<1, 1>>>();"); 13224 verifyFormat("f<<<1, 1, 1, s>>>();"); 13225 verifyFormat("f<<<a, b, c, d>>>();"); 13226 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 13227 verifyFormat("f<param><<<1, 1>>>();"); 13228 verifyFormat("f<1><<<1, 1>>>();"); 13229 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 13230 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 13231 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 13232 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 13233 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 13234 } 13235 13236 TEST_F(FormatTest, MergeLessLessAtEnd) { 13237 verifyFormat("<<"); 13238 EXPECT_EQ("< < <", format("\\\n<<<")); 13239 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 13240 "aaallvm::outs() <<"); 13241 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 13242 "aaaallvm::outs()\n <<"); 13243 } 13244 13245 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 13246 std::string code = "#if A\n" 13247 "#if B\n" 13248 "a.\n" 13249 "#endif\n" 13250 " a = 1;\n" 13251 "#else\n" 13252 "#endif\n" 13253 "#if C\n" 13254 "#else\n" 13255 "#endif\n"; 13256 EXPECT_EQ(code, format(code)); 13257 } 13258 13259 TEST_F(FormatTest, HandleConflictMarkers) { 13260 // Git/SVN conflict markers. 13261 EXPECT_EQ("int a;\n" 13262 "void f() {\n" 13263 " callme(some(parameter1,\n" 13264 "<<<<<<< text by the vcs\n" 13265 " parameter2),\n" 13266 "||||||| text by the vcs\n" 13267 " parameter2),\n" 13268 " parameter3,\n" 13269 "======= text by the vcs\n" 13270 " parameter2, parameter3),\n" 13271 ">>>>>>> text by the vcs\n" 13272 " otherparameter);\n", 13273 format("int a;\n" 13274 "void f() {\n" 13275 " callme(some(parameter1,\n" 13276 "<<<<<<< text by the vcs\n" 13277 " parameter2),\n" 13278 "||||||| text by the vcs\n" 13279 " parameter2),\n" 13280 " parameter3,\n" 13281 "======= text by the vcs\n" 13282 " parameter2,\n" 13283 " parameter3),\n" 13284 ">>>>>>> text by the vcs\n" 13285 " otherparameter);\n")); 13286 13287 // Perforce markers. 13288 EXPECT_EQ("void f() {\n" 13289 " function(\n" 13290 ">>>> text by the vcs\n" 13291 " parameter,\n" 13292 "==== text by the vcs\n" 13293 " parameter,\n" 13294 "==== text by the vcs\n" 13295 " parameter,\n" 13296 "<<<< text by the vcs\n" 13297 " parameter);\n", 13298 format("void f() {\n" 13299 " function(\n" 13300 ">>>> text by the vcs\n" 13301 " parameter,\n" 13302 "==== text by the vcs\n" 13303 " parameter,\n" 13304 "==== text by the vcs\n" 13305 " parameter,\n" 13306 "<<<< text by the vcs\n" 13307 " parameter);\n")); 13308 13309 EXPECT_EQ("<<<<<<<\n" 13310 "|||||||\n" 13311 "=======\n" 13312 ">>>>>>>", 13313 format("<<<<<<<\n" 13314 "|||||||\n" 13315 "=======\n" 13316 ">>>>>>>")); 13317 13318 EXPECT_EQ("<<<<<<<\n" 13319 "|||||||\n" 13320 "int i;\n" 13321 "=======\n" 13322 ">>>>>>>", 13323 format("<<<<<<<\n" 13324 "|||||||\n" 13325 "int i;\n" 13326 "=======\n" 13327 ">>>>>>>")); 13328 13329 // FIXME: Handle parsing of macros around conflict markers correctly: 13330 EXPECT_EQ("#define Macro \\\n" 13331 "<<<<<<<\n" 13332 "Something \\\n" 13333 "|||||||\n" 13334 "Else \\\n" 13335 "=======\n" 13336 "Other \\\n" 13337 ">>>>>>>\n" 13338 " End int i;\n", 13339 format("#define Macro \\\n" 13340 "<<<<<<<\n" 13341 " Something \\\n" 13342 "|||||||\n" 13343 " Else \\\n" 13344 "=======\n" 13345 " Other \\\n" 13346 ">>>>>>>\n" 13347 " End\n" 13348 "int i;\n")); 13349 } 13350 13351 TEST_F(FormatTest, DisableRegions) { 13352 EXPECT_EQ("int i;\n" 13353 "// clang-format off\n" 13354 " int j;\n" 13355 "// clang-format on\n" 13356 "int k;", 13357 format(" int i;\n" 13358 " // clang-format off\n" 13359 " int j;\n" 13360 " // clang-format on\n" 13361 " int k;")); 13362 EXPECT_EQ("int i;\n" 13363 "/* clang-format off */\n" 13364 " int j;\n" 13365 "/* clang-format on */\n" 13366 "int k;", 13367 format(" int i;\n" 13368 " /* clang-format off */\n" 13369 " int j;\n" 13370 " /* clang-format on */\n" 13371 " int k;")); 13372 13373 // Don't reflow comments within disabled regions. 13374 EXPECT_EQ( 13375 "// clang-format off\n" 13376 "// long long long long long long line\n" 13377 "/* clang-format on */\n" 13378 "/* long long long\n" 13379 " * long long long\n" 13380 " * line */\n" 13381 "int i;\n" 13382 "/* clang-format off */\n" 13383 "/* long long long long long long line */\n", 13384 format("// clang-format off\n" 13385 "// long long long long long long line\n" 13386 "/* clang-format on */\n" 13387 "/* long long long long long long line */\n" 13388 "int i;\n" 13389 "/* clang-format off */\n" 13390 "/* long long long long long long line */\n", 13391 getLLVMStyleWithColumns(20))); 13392 } 13393 13394 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 13395 format("? ) ="); 13396 verifyNoCrash("#define a\\\n /**/}"); 13397 } 13398 13399 TEST_F(FormatTest, FormatsTableGenCode) { 13400 FormatStyle Style = getLLVMStyle(); 13401 Style.Language = FormatStyle::LK_TableGen; 13402 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 13403 } 13404 13405 TEST_F(FormatTest, ArrayOfTemplates) { 13406 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 13407 format("auto a = new unique_ptr<int > [ 10];")); 13408 13409 FormatStyle Spaces = getLLVMStyle(); 13410 Spaces.SpacesInSquareBrackets = true; 13411 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 13412 format("auto a = new unique_ptr<int > [10];", Spaces)); 13413 } 13414 13415 TEST_F(FormatTest, ArrayAsTemplateType) { 13416 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 13417 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 13418 13419 FormatStyle Spaces = getLLVMStyle(); 13420 Spaces.SpacesInSquareBrackets = true; 13421 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 13422 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 13423 } 13424 13425 TEST_F(FormatTest, NoSpaceAfterSuper) { 13426 verifyFormat("__super::FooBar();"); 13427 } 13428 13429 TEST(FormatStyle, GetStyleWithEmptyFileName) { 13430 llvm::vfs::InMemoryFileSystem FS; 13431 auto Style1 = getStyle("file", "", "Google", "", &FS); 13432 ASSERT_TRUE((bool)Style1); 13433 ASSERT_EQ(*Style1, getGoogleStyle()); 13434 } 13435 13436 TEST(FormatStyle, GetStyleOfFile) { 13437 llvm::vfs::InMemoryFileSystem FS; 13438 // Test 1: format file in the same directory. 13439 ASSERT_TRUE( 13440 FS.addFile("/a/.clang-format", 0, 13441 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 13442 ASSERT_TRUE( 13443 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13444 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 13445 ASSERT_TRUE((bool)Style1); 13446 ASSERT_EQ(*Style1, getLLVMStyle()); 13447 13448 // Test 2.1: fallback to default. 13449 ASSERT_TRUE( 13450 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13451 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 13452 ASSERT_TRUE((bool)Style2); 13453 ASSERT_EQ(*Style2, getMozillaStyle()); 13454 13455 // Test 2.2: no format on 'none' fallback style. 13456 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 13457 ASSERT_TRUE((bool)Style2); 13458 ASSERT_EQ(*Style2, getNoStyle()); 13459 13460 // Test 2.3: format if config is found with no based style while fallback is 13461 // 'none'. 13462 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 13463 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 13464 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 13465 ASSERT_TRUE((bool)Style2); 13466 ASSERT_EQ(*Style2, getLLVMStyle()); 13467 13468 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 13469 Style2 = getStyle("{}", "a.h", "none", "", &FS); 13470 ASSERT_TRUE((bool)Style2); 13471 ASSERT_EQ(*Style2, getLLVMStyle()); 13472 13473 // Test 3: format file in parent directory. 13474 ASSERT_TRUE( 13475 FS.addFile("/c/.clang-format", 0, 13476 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 13477 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 13478 llvm::MemoryBuffer::getMemBuffer("int i;"))); 13479 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 13480 ASSERT_TRUE((bool)Style3); 13481 ASSERT_EQ(*Style3, getGoogleStyle()); 13482 13483 // Test 4: error on invalid fallback style 13484 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 13485 ASSERT_FALSE((bool)Style4); 13486 llvm::consumeError(Style4.takeError()); 13487 13488 // Test 5: error on invalid yaml on command line 13489 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 13490 ASSERT_FALSE((bool)Style5); 13491 llvm::consumeError(Style5.takeError()); 13492 13493 // Test 6: error on invalid style 13494 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 13495 ASSERT_FALSE((bool)Style6); 13496 llvm::consumeError(Style6.takeError()); 13497 13498 // Test 7: found config file, error on parsing it 13499 ASSERT_TRUE( 13500 FS.addFile("/d/.clang-format", 0, 13501 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 13502 "InvalidKey: InvalidValue"))); 13503 ASSERT_TRUE( 13504 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 13505 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 13506 ASSERT_FALSE((bool)Style7); 13507 llvm::consumeError(Style7.takeError()); 13508 13509 // Test 8: inferred per-language defaults apply. 13510 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 13511 ASSERT_TRUE((bool)StyleTd); 13512 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 13513 } 13514 13515 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 13516 // Column limit is 20. 13517 std::string Code = "Type *a =\n" 13518 " new Type();\n" 13519 "g(iiiii, 0, jjjjj,\n" 13520 " 0, kkkkk, 0, mm);\n" 13521 "int bad = format ;"; 13522 std::string Expected = "auto a = new Type();\n" 13523 "g(iiiii, nullptr,\n" 13524 " jjjjj, nullptr,\n" 13525 " kkkkk, nullptr,\n" 13526 " mm);\n" 13527 "int bad = format ;"; 13528 FileID ID = Context.createInMemoryFile("format.cpp", Code); 13529 tooling::Replacements Replaces = toReplacements( 13530 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 13531 "auto "), 13532 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 13533 "nullptr"), 13534 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 13535 "nullptr"), 13536 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 13537 "nullptr")}); 13538 13539 format::FormatStyle Style = format::getLLVMStyle(); 13540 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 13541 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 13542 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 13543 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 13544 auto Result = applyAllReplacements(Code, *FormattedReplaces); 13545 EXPECT_TRUE(static_cast<bool>(Result)); 13546 EXPECT_EQ(Expected, *Result); 13547 } 13548 13549 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 13550 std::string Code = "#include \"a.h\"\n" 13551 "#include \"c.h\"\n" 13552 "\n" 13553 "int main() {\n" 13554 " return 0;\n" 13555 "}"; 13556 std::string Expected = "#include \"a.h\"\n" 13557 "#include \"b.h\"\n" 13558 "#include \"c.h\"\n" 13559 "\n" 13560 "int main() {\n" 13561 " return 0;\n" 13562 "}"; 13563 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 13564 tooling::Replacements Replaces = toReplacements( 13565 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 13566 "#include \"b.h\"\n")}); 13567 13568 format::FormatStyle Style = format::getLLVMStyle(); 13569 Style.SortIncludes = true; 13570 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 13571 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 13572 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 13573 auto Result = applyAllReplacements(Code, *FormattedReplaces); 13574 EXPECT_TRUE(static_cast<bool>(Result)); 13575 EXPECT_EQ(Expected, *Result); 13576 } 13577 13578 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 13579 EXPECT_EQ("using std::cin;\n" 13580 "using std::cout;", 13581 format("using std::cout;\n" 13582 "using std::cin;", getGoogleStyle())); 13583 } 13584 13585 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 13586 format::FormatStyle Style = format::getLLVMStyle(); 13587 Style.Standard = FormatStyle::LS_Cpp03; 13588 // cpp03 recognize this string as identifier u8 and literal character 'a' 13589 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 13590 } 13591 13592 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 13593 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 13594 // all modes, including C++11, C++14 and C++17 13595 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 13596 } 13597 13598 TEST_F(FormatTest, DoNotFormatLikelyXml) { 13599 EXPECT_EQ("<!-- ;> -->", 13600 format("<!-- ;> -->", getGoogleStyle())); 13601 EXPECT_EQ(" <!-- >; -->", 13602 format(" <!-- >; -->", getGoogleStyle())); 13603 } 13604 13605 TEST_F(FormatTest, StructuredBindings) { 13606 // Structured bindings is a C++17 feature. 13607 // all modes, including C++11, C++14 and C++17 13608 verifyFormat("auto [a, b] = f();"); 13609 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 13610 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 13611 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 13612 EXPECT_EQ("auto const volatile [a, b] = f();", 13613 format("auto const volatile[a, b] = f();")); 13614 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 13615 EXPECT_EQ("auto &[a, b, c] = f();", 13616 format("auto &[ a , b,c ] = f();")); 13617 EXPECT_EQ("auto &&[a, b, c] = f();", 13618 format("auto &&[ a , b,c ] = f();")); 13619 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 13620 EXPECT_EQ("auto const volatile &&[a, b] = f();", 13621 format("auto const volatile &&[a, b] = f();")); 13622 EXPECT_EQ("auto const &&[a, b] = f();", format("auto const && [a, b] = f();")); 13623 EXPECT_EQ("const auto &[a, b] = f();", format("const auto & [a, b] = f();")); 13624 EXPECT_EQ("const auto volatile &&[a, b] = f();", 13625 format("const auto volatile &&[a, b] = f();")); 13626 EXPECT_EQ("volatile const auto &&[a, b] = f();", 13627 format("volatile const auto &&[a, b] = f();")); 13628 EXPECT_EQ("const auto &&[a, b] = f();", format("const auto && [a, b] = f();")); 13629 13630 // Make sure we don't mistake structured bindings for lambdas. 13631 FormatStyle PointerMiddle = getLLVMStyle(); 13632 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 13633 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 13634 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 13635 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 13636 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 13637 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 13638 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 13639 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 13640 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 13641 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 13642 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 13643 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 13644 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 13645 13646 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 13647 format("for (const auto && [a, b] : some_range) {\n}")); 13648 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 13649 format("for (const auto & [a, b] : some_range) {\n}")); 13650 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 13651 format("for (const auto[a, b] : some_range) {\n}")); 13652 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 13653 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 13654 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 13655 EXPECT_EQ("auto const &[x, y](expr);", format("auto const & [x,y] (expr);")); 13656 EXPECT_EQ("auto const &&[x, y](expr);", format("auto const && [x,y] (expr);")); 13657 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 13658 EXPECT_EQ("auto const &[x, y]{expr};", format("auto const & [x,y] {expr};")); 13659 EXPECT_EQ("auto const &&[x, y]{expr};", format("auto const && [x,y] {expr};")); 13660 13661 format::FormatStyle Spaces = format::getLLVMStyle(); 13662 Spaces.SpacesInSquareBrackets = true; 13663 verifyFormat("auto [ a, b ] = f();", Spaces); 13664 verifyFormat("auto &&[ a, b ] = f();", Spaces); 13665 verifyFormat("auto &[ a, b ] = f();", Spaces); 13666 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 13667 verifyFormat("auto const &[ a, b ] = f();", Spaces); 13668 } 13669 13670 TEST_F(FormatTest, FileAndCode) { 13671 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 13672 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 13673 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 13674 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 13675 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@interface Foo\n@end\n")); 13676 EXPECT_EQ( 13677 FormatStyle::LK_ObjC, 13678 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 13679 EXPECT_EQ(FormatStyle::LK_ObjC, 13680 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 13681 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 13682 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 13683 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo", "@interface Foo\n@end\n")); 13684 EXPECT_EQ(FormatStyle::LK_ObjC, 13685 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 13686 EXPECT_EQ( 13687 FormatStyle::LK_ObjC, 13688 guessLanguage("foo.h", 13689 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 13690 EXPECT_EQ( 13691 FormatStyle::LK_Cpp, 13692 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 13693 } 13694 13695 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 13696 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 13697 EXPECT_EQ(FormatStyle::LK_ObjC, 13698 guessLanguage("foo.h", "array[[calculator getIndex]];")); 13699 EXPECT_EQ(FormatStyle::LK_Cpp, 13700 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 13701 EXPECT_EQ( 13702 FormatStyle::LK_Cpp, 13703 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 13704 EXPECT_EQ(FormatStyle::LK_ObjC, 13705 guessLanguage("foo.h", "[[noreturn foo] bar];")); 13706 EXPECT_EQ(FormatStyle::LK_Cpp, 13707 guessLanguage("foo.h", "[[clang::fallthrough]];")); 13708 EXPECT_EQ(FormatStyle::LK_ObjC, 13709 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 13710 EXPECT_EQ(FormatStyle::LK_Cpp, 13711 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 13712 EXPECT_EQ(FormatStyle::LK_Cpp, 13713 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 13714 EXPECT_EQ(FormatStyle::LK_ObjC, 13715 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 13716 EXPECT_EQ(FormatStyle::LK_Cpp, 13717 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 13718 EXPECT_EQ( 13719 FormatStyle::LK_Cpp, 13720 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 13721 EXPECT_EQ( 13722 FormatStyle::LK_Cpp, 13723 guessLanguage("foo.h", 13724 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 13725 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 13726 } 13727 13728 TEST_F(FormatTest, GuessLanguageWithCaret) { 13729 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 13730 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 13731 EXPECT_EQ(FormatStyle::LK_ObjC, 13732 guessLanguage("foo.h", "int(^)(char, float);")); 13733 EXPECT_EQ(FormatStyle::LK_ObjC, 13734 guessLanguage("foo.h", "int(^foo)(char, float);")); 13735 EXPECT_EQ(FormatStyle::LK_ObjC, 13736 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 13737 EXPECT_EQ(FormatStyle::LK_ObjC, 13738 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 13739 EXPECT_EQ( 13740 FormatStyle::LK_ObjC, 13741 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 13742 } 13743 13744 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 13745 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13746 "void f() {\n" 13747 " asm (\"mov %[e], %[d]\"\n" 13748 " : [d] \"=rm\" (d)\n" 13749 " [e] \"rm\" (*e));\n" 13750 "}")); 13751 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13752 "void f() {\n" 13753 " _asm (\"mov %[e], %[d]\"\n" 13754 " : [d] \"=rm\" (d)\n" 13755 " [e] \"rm\" (*e));\n" 13756 "}")); 13757 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13758 "void f() {\n" 13759 " __asm (\"mov %[e], %[d]\"\n" 13760 " : [d] \"=rm\" (d)\n" 13761 " [e] \"rm\" (*e));\n" 13762 "}")); 13763 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13764 "void f() {\n" 13765 " __asm__ (\"mov %[e], %[d]\"\n" 13766 " : [d] \"=rm\" (d)\n" 13767 " [e] \"rm\" (*e));\n" 13768 "}")); 13769 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", 13770 "void f() {\n" 13771 " asm (\"mov %[e], %[d]\"\n" 13772 " : [d] \"=rm\" (d),\n" 13773 " [e] \"rm\" (*e));\n" 13774 "}")); 13775 EXPECT_EQ(FormatStyle::LK_Cpp, 13776 guessLanguage("foo.h", "void f() {\n" 13777 " asm volatile (\"mov %[e], %[d]\"\n" 13778 " : [d] \"=rm\" (d)\n" 13779 " [e] \"rm\" (*e));\n" 13780 "}")); 13781 } 13782 13783 TEST_F(FormatTest, GuessLanguageWithChildLines) { 13784 EXPECT_EQ(FormatStyle::LK_Cpp, 13785 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 13786 EXPECT_EQ(FormatStyle::LK_ObjC, 13787 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 13788 EXPECT_EQ( 13789 FormatStyle::LK_Cpp, 13790 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 13791 EXPECT_EQ( 13792 FormatStyle::LK_ObjC, 13793 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 13794 } 13795 13796 TEST_F(FormatTest, TypenameMacros) { 13797 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 13798 13799 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 13800 FormatStyle Google = getGoogleStyleWithColumns(0); 13801 Google.TypenameMacros = TypenameMacros; 13802 verifyFormat("struct foo {\n" 13803 " int bar;\n" 13804 " TAILQ_ENTRY(a) bleh;\n" 13805 "};", Google); 13806 13807 FormatStyle Macros = getLLVMStyle(); 13808 Macros.TypenameMacros = TypenameMacros; 13809 13810 verifyFormat("STACK_OF(int) a;", Macros); 13811 verifyFormat("STACK_OF(int) *a;", Macros); 13812 verifyFormat("STACK_OF(int const *) *a;", Macros); 13813 verifyFormat("STACK_OF(int *const) *a;", Macros); 13814 verifyFormat("STACK_OF(int, string) a;", Macros); 13815 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 13816 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 13817 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 13818 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 13819 13820 Macros.PointerAlignment = FormatStyle::PAS_Left; 13821 verifyFormat("STACK_OF(int)* a;", Macros); 13822 verifyFormat("STACK_OF(int*)* a;", Macros); 13823 } 13824 13825 } // end namespace 13826 } // end namespace format 13827 } // end namespace clang 13828