1 //===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "clang/Format/Format.h" 10 11 #include "../Tooling/ReplacementTest.h" 12 #include "FormatTestUtils.h" 13 14 #include "clang/Frontend/TextDiagnosticPrinter.h" 15 #include "llvm/Support/Debug.h" 16 #include "llvm/Support/MemoryBuffer.h" 17 #include "gtest/gtest.h" 18 19 #define DEBUG_TYPE "format-test" 20 21 using clang::tooling::ReplacementTest; 22 using clang::tooling::toReplacements; 23 24 namespace clang { 25 namespace format { 26 namespace { 27 28 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); } 29 30 class FormatTest : public ::testing::Test { 31 protected: 32 enum StatusCheck { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck }; 33 34 std::string format(llvm::StringRef Code, 35 const FormatStyle &Style = getLLVMStyle(), 36 StatusCheck CheckComplete = SC_ExpectComplete) { 37 LLVM_DEBUG(llvm::errs() << "---\n"); 38 LLVM_DEBUG(llvm::errs() << Code << "\n\n"); 39 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size())); 40 FormattingAttemptStatus Status; 41 tooling::Replacements Replaces = 42 reformat(Style, Code, Ranges, "<stdin>", &Status); 43 if (CheckComplete != SC_DoNotCheck) { 44 bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete; 45 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete) 46 << Code << "\n\n"; 47 } 48 ReplacementCount = Replaces.size(); 49 auto Result = applyAllReplacements(Code, Replaces); 50 EXPECT_TRUE(static_cast<bool>(Result)); 51 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); 52 return *Result; 53 } 54 55 FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) { 56 Style.ColumnLimit = ColumnLimit; 57 return Style; 58 } 59 60 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 61 return getStyleWithColumns(getLLVMStyle(), ColumnLimit); 62 } 63 64 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) { 65 return getStyleWithColumns(getGoogleStyle(), ColumnLimit); 66 } 67 68 void verifyFormat(llvm::StringRef Expected, llvm::StringRef Code, 69 const FormatStyle &Style = getLLVMStyle()) { 70 EXPECT_EQ(Expected.str(), format(Expected, Style)) 71 << "Expected code is not stable"; 72 EXPECT_EQ(Expected.str(), format(Code, Style)); 73 if (Style.Language == FormatStyle::LK_Cpp) { 74 // Objective-C++ is a superset of C++, so everything checked for C++ 75 // needs to be checked for Objective-C++ as well. 76 FormatStyle ObjCStyle = Style; 77 ObjCStyle.Language = FormatStyle::LK_ObjC; 78 EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle)); 79 } 80 } 81 82 void verifyFormat(llvm::StringRef Code, 83 const FormatStyle &Style = getLLVMStyle()) { 84 verifyFormat(Code, test::messUp(Code), Style); 85 } 86 87 void verifyIncompleteFormat(llvm::StringRef Code, 88 const FormatStyle &Style = getLLVMStyle()) { 89 EXPECT_EQ(Code.str(), 90 format(test::messUp(Code), Style, SC_ExpectIncomplete)); 91 } 92 93 void verifyGoogleFormat(llvm::StringRef Code) { 94 verifyFormat(Code, getGoogleStyle()); 95 } 96 97 void verifyIndependentOfContext(llvm::StringRef text) { 98 verifyFormat(text); 99 verifyFormat(llvm::Twine("void f() { " + text + " }").str()); 100 } 101 102 /// \brief Verify that clang-format does not crash on the given input. 103 void verifyNoCrash(llvm::StringRef Code, 104 const FormatStyle &Style = getLLVMStyle()) { 105 format(Code, Style, SC_DoNotCheck); 106 } 107 108 int ReplacementCount; 109 }; 110 111 TEST_F(FormatTest, MessUp) { 112 EXPECT_EQ("1 2 3", test::messUp("1 2 3")); 113 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n")); 114 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc")); 115 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc")); 116 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne")); 117 } 118 119 TEST_F(FormatTest, DefaultLLVMStyleIsCpp) { 120 EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language); 121 } 122 123 TEST_F(FormatTest, LLVMStyleOverride) { 124 EXPECT_EQ(FormatStyle::LK_Proto, 125 getLLVMStyle(FormatStyle::LK_Proto).Language); 126 } 127 128 //===----------------------------------------------------------------------===// 129 // Basic function tests. 130 //===----------------------------------------------------------------------===// 131 132 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { 133 EXPECT_EQ(";", format(";")); 134 } 135 136 TEST_F(FormatTest, FormatsGlobalStatementsAt0) { 137 EXPECT_EQ("int i;", format(" int i;")); 138 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;")); 139 EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); 140 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); 141 } 142 143 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { 144 EXPECT_EQ("int i;", format("int\ni;")); 145 } 146 147 TEST_F(FormatTest, FormatsNestedBlockStatements) { 148 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}")); 149 } 150 151 TEST_F(FormatTest, FormatsNestedCall) { 152 verifyFormat("Method(f1, f2(f3));"); 153 verifyFormat("Method(f1(f2, f3()));"); 154 verifyFormat("Method(f1(f2, (f3())));"); 155 } 156 157 TEST_F(FormatTest, NestedNameSpecifiers) { 158 verifyFormat("vector<::Type> v;"); 159 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())"); 160 verifyFormat("static constexpr bool Bar = decltype(bar())::value;"); 161 verifyFormat("bool a = 2 < ::SomeFunction();"); 162 verifyFormat("ALWAYS_INLINE ::std::string getName();"); 163 verifyFormat("some::string getName();"); 164 } 165 166 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { 167 EXPECT_EQ("if (a) {\n" 168 " f();\n" 169 "}", 170 format("if(a){f();}")); 171 EXPECT_EQ(4, ReplacementCount); 172 EXPECT_EQ("if (a) {\n" 173 " f();\n" 174 "}", 175 format("if (a) {\n" 176 " f();\n" 177 "}")); 178 EXPECT_EQ(0, ReplacementCount); 179 EXPECT_EQ("/*\r\n" 180 "\r\n" 181 "*/\r\n", 182 format("/*\r\n" 183 "\r\n" 184 "*/\r\n")); 185 EXPECT_EQ(0, ReplacementCount); 186 } 187 188 TEST_F(FormatTest, RemovesEmptyLines) { 189 EXPECT_EQ("class C {\n" 190 " int i;\n" 191 "};", 192 format("class C {\n" 193 " int i;\n" 194 "\n" 195 "};")); 196 197 // Don't remove empty lines at the start of namespaces or extern "C" blocks. 198 EXPECT_EQ("namespace N {\n" 199 "\n" 200 "int i;\n" 201 "}", 202 format("namespace N {\n" 203 "\n" 204 "int i;\n" 205 "}", 206 getGoogleStyle())); 207 EXPECT_EQ("/* something */ namespace N {\n" 208 "\n" 209 "int i;\n" 210 "}", 211 format("/* something */ namespace N {\n" 212 "\n" 213 "int i;\n" 214 "}", 215 getGoogleStyle())); 216 EXPECT_EQ("inline namespace N {\n" 217 "\n" 218 "int i;\n" 219 "}", 220 format("inline namespace N {\n" 221 "\n" 222 "int i;\n" 223 "}", 224 getGoogleStyle())); 225 EXPECT_EQ("/* something */ inline namespace N {\n" 226 "\n" 227 "int i;\n" 228 "}", 229 format("/* something */ inline namespace N {\n" 230 "\n" 231 "int i;\n" 232 "}", 233 getGoogleStyle())); 234 EXPECT_EQ("export namespace N {\n" 235 "\n" 236 "int i;\n" 237 "}", 238 format("export namespace N {\n" 239 "\n" 240 "int i;\n" 241 "}", 242 getGoogleStyle())); 243 EXPECT_EQ("extern /**/ \"C\" /**/ {\n" 244 "\n" 245 "int i;\n" 246 "}", 247 format("extern /**/ \"C\" /**/ {\n" 248 "\n" 249 "int i;\n" 250 "}", 251 getGoogleStyle())); 252 253 // ...but do keep inlining and removing empty lines for non-block extern "C" 254 // functions. 255 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle()); 256 EXPECT_EQ("extern \"C\" int f() {\n" 257 " int i = 42;\n" 258 " return i;\n" 259 "}", 260 format("extern \"C\" int f() {\n" 261 "\n" 262 " int i = 42;\n" 263 " return i;\n" 264 "}", 265 getGoogleStyle())); 266 267 // Remove empty lines at the beginning and end of blocks. 268 EXPECT_EQ("void f() {\n" 269 "\n" 270 " if (a) {\n" 271 "\n" 272 " f();\n" 273 " }\n" 274 "}", 275 format("void f() {\n" 276 "\n" 277 " if (a) {\n" 278 "\n" 279 " f();\n" 280 "\n" 281 " }\n" 282 "\n" 283 "}", 284 getLLVMStyle())); 285 EXPECT_EQ("void f() {\n" 286 " if (a) {\n" 287 " f();\n" 288 " }\n" 289 "}", 290 format("void f() {\n" 291 "\n" 292 " if (a) {\n" 293 "\n" 294 " f();\n" 295 "\n" 296 " }\n" 297 "\n" 298 "}", 299 getGoogleStyle())); 300 301 // Don't remove empty lines in more complex control statements. 302 EXPECT_EQ("void f() {\n" 303 " if (a) {\n" 304 " f();\n" 305 "\n" 306 " } else if (b) {\n" 307 " f();\n" 308 " }\n" 309 "}", 310 format("void f() {\n" 311 " if (a) {\n" 312 " f();\n" 313 "\n" 314 " } else if (b) {\n" 315 " f();\n" 316 "\n" 317 " }\n" 318 "\n" 319 "}")); 320 321 // Don't remove empty lines before namespace endings. 322 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 323 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 324 EXPECT_EQ("namespace {\n" 325 "int i;\n" 326 "\n" 327 "}", 328 format("namespace {\n" 329 "int i;\n" 330 "\n" 331 "}", 332 LLVMWithNoNamespaceFix)); 333 EXPECT_EQ("namespace {\n" 334 "int i;\n" 335 "}", 336 format("namespace {\n" 337 "int i;\n" 338 "}", 339 LLVMWithNoNamespaceFix)); 340 EXPECT_EQ("namespace {\n" 341 "int i;\n" 342 "\n" 343 "};", 344 format("namespace {\n" 345 "int i;\n" 346 "\n" 347 "};", 348 LLVMWithNoNamespaceFix)); 349 EXPECT_EQ("namespace {\n" 350 "int i;\n" 351 "};", 352 format("namespace {\n" 353 "int i;\n" 354 "};", 355 LLVMWithNoNamespaceFix)); 356 EXPECT_EQ("namespace {\n" 357 "int i;\n" 358 "\n" 359 "}", 360 format("namespace {\n" 361 "int i;\n" 362 "\n" 363 "}")); 364 EXPECT_EQ("namespace {\n" 365 "int i;\n" 366 "\n" 367 "} // namespace", 368 format("namespace {\n" 369 "int i;\n" 370 "\n" 371 "} // namespace")); 372 373 FormatStyle Style = getLLVMStyle(); 374 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 375 Style.MaxEmptyLinesToKeep = 2; 376 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 377 Style.BraceWrapping.AfterClass = true; 378 Style.BraceWrapping.AfterFunction = true; 379 Style.KeepEmptyLinesAtTheStartOfBlocks = false; 380 381 EXPECT_EQ("class Foo\n" 382 "{\n" 383 " Foo() {}\n" 384 "\n" 385 " void funk() {}\n" 386 "};", 387 format("class Foo\n" 388 "{\n" 389 " Foo()\n" 390 " {\n" 391 " }\n" 392 "\n" 393 " void funk() {}\n" 394 "};", 395 Style)); 396 } 397 398 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) { 399 verifyFormat("x = (a) and (b);"); 400 verifyFormat("x = (a) or (b);"); 401 verifyFormat("x = (a) bitand (b);"); 402 verifyFormat("x = (a) bitor (b);"); 403 verifyFormat("x = (a) not_eq (b);"); 404 verifyFormat("x = (a) and_eq (b);"); 405 verifyFormat("x = (a) or_eq (b);"); 406 verifyFormat("x = (a) xor (b);"); 407 } 408 409 TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) { 410 verifyFormat("x = compl(a);"); 411 verifyFormat("x = not(a);"); 412 verifyFormat("x = bitand(a);"); 413 // Unary operator must not be merged with the next identifier 414 verifyFormat("x = compl a;"); 415 verifyFormat("x = not a;"); 416 verifyFormat("x = bitand a;"); 417 } 418 419 //===----------------------------------------------------------------------===// 420 // Tests for control statements. 421 //===----------------------------------------------------------------------===// 422 423 TEST_F(FormatTest, FormatIfWithoutCompoundStatement) { 424 verifyFormat("if (true)\n f();\ng();"); 425 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();"); 426 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();"); 427 verifyFormat("if constexpr (true)\n" 428 " f();\ng();"); 429 verifyFormat("if CONSTEXPR (true)\n" 430 " f();\ng();"); 431 verifyFormat("if constexpr (a)\n" 432 " if constexpr (b)\n" 433 " if constexpr (c)\n" 434 " g();\n" 435 "h();"); 436 verifyFormat("if CONSTEXPR (a)\n" 437 " if CONSTEXPR (b)\n" 438 " if CONSTEXPR (c)\n" 439 " g();\n" 440 "h();"); 441 verifyFormat("if constexpr (a)\n" 442 " if constexpr (b) {\n" 443 " f();\n" 444 " }\n" 445 "g();"); 446 verifyFormat("if CONSTEXPR (a)\n" 447 " if CONSTEXPR (b) {\n" 448 " f();\n" 449 " }\n" 450 "g();"); 451 452 FormatStyle AllowsMergedIf = getLLVMStyle(); 453 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 454 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 455 FormatStyle::SIS_WithoutElse; 456 verifyFormat("if (a)\n" 457 " // comment\n" 458 " f();", 459 AllowsMergedIf); 460 verifyFormat("{\n" 461 " if (a)\n" 462 " label:\n" 463 " f();\n" 464 "}", 465 AllowsMergedIf); 466 verifyFormat("#define A \\\n" 467 " if (a) \\\n" 468 " label: \\\n" 469 " f()", 470 AllowsMergedIf); 471 verifyFormat("if (a)\n" 472 " ;", 473 AllowsMergedIf); 474 verifyFormat("if (a)\n" 475 " if (b) return;", 476 AllowsMergedIf); 477 478 verifyFormat("if (a) // Can't merge this\n" 479 " f();\n", 480 AllowsMergedIf); 481 verifyFormat("if (a) /* still don't merge */\n" 482 " f();", 483 AllowsMergedIf); 484 verifyFormat("if (a) { // Never merge this\n" 485 " f();\n" 486 "}", 487 AllowsMergedIf); 488 verifyFormat("if (a) { /* Never merge this */\n" 489 " f();\n" 490 "}", 491 AllowsMergedIf); 492 493 AllowsMergedIf.ColumnLimit = 14; 494 verifyFormat("if (a) return;", AllowsMergedIf); 495 verifyFormat("if (aaaaaaaaa)\n" 496 " return;", 497 AllowsMergedIf); 498 499 AllowsMergedIf.ColumnLimit = 13; 500 verifyFormat("if (a)\n return;", AllowsMergedIf); 501 } 502 503 TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) { 504 FormatStyle AllowsMergedIf = getLLVMStyle(); 505 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 506 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 507 FormatStyle::SIS_WithoutElse; 508 verifyFormat("if (a)\n" 509 " f();\n" 510 "else {\n" 511 " g();\n" 512 "}", 513 AllowsMergedIf); 514 verifyFormat("if (a)\n" 515 " f();\n" 516 "else\n" 517 " g();\n", 518 AllowsMergedIf); 519 520 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 521 522 verifyFormat("if (a) f();\n" 523 "else {\n" 524 " g();\n" 525 "}", 526 AllowsMergedIf); 527 verifyFormat("if (a) f();\n" 528 "else {\n" 529 " if (a) f();\n" 530 " else {\n" 531 " g();\n" 532 " }\n" 533 " g();\n" 534 "}", 535 AllowsMergedIf); 536 } 537 538 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) { 539 FormatStyle AllowsMergedLoops = getLLVMStyle(); 540 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true; 541 verifyFormat("while (true) continue;", AllowsMergedLoops); 542 verifyFormat("for (;;) continue;", AllowsMergedLoops); 543 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops); 544 verifyFormat("while (true)\n" 545 " ;", 546 AllowsMergedLoops); 547 verifyFormat("for (;;)\n" 548 " ;", 549 AllowsMergedLoops); 550 verifyFormat("for (;;)\n" 551 " for (;;) continue;", 552 AllowsMergedLoops); 553 verifyFormat("for (;;) // Can't merge this\n" 554 " continue;", 555 AllowsMergedLoops); 556 verifyFormat("for (;;) /* still don't merge */\n" 557 " continue;", 558 AllowsMergedLoops); 559 verifyFormat("do a++;\n" 560 "while (true);", 561 AllowsMergedLoops); 562 verifyFormat("do /* Don't merge */\n" 563 " a++;\n" 564 "while (true);", 565 AllowsMergedLoops); 566 verifyFormat("do // Don't merge\n" 567 " a++;\n" 568 "while (true);", 569 AllowsMergedLoops); 570 verifyFormat("do\n" 571 " // Don't merge\n" 572 " a++;\n" 573 "while (true);", 574 AllowsMergedLoops); 575 // Without braces labels are interpreted differently. 576 verifyFormat("{\n" 577 " do\n" 578 " label:\n" 579 " a++;\n" 580 " while (true);\n" 581 "}", 582 AllowsMergedLoops); 583 } 584 585 TEST_F(FormatTest, FormatShortBracedStatements) { 586 FormatStyle AllowSimpleBracedStatements = getLLVMStyle(); 587 AllowSimpleBracedStatements.ColumnLimit = 40; 588 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = 589 FormatStyle::SBS_Always; 590 591 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 592 FormatStyle::SIS_WithoutElse; 593 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 594 595 AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom; 596 AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true; 597 AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false; 598 599 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 600 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 601 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 602 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 603 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 604 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 605 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 606 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 607 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 608 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 609 verifyFormat("if (true) {\n" 610 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 611 "}", 612 AllowSimpleBracedStatements); 613 verifyFormat("if (true) { //\n" 614 " f();\n" 615 "}", 616 AllowSimpleBracedStatements); 617 verifyFormat("if (true) {\n" 618 " f();\n" 619 " f();\n" 620 "}", 621 AllowSimpleBracedStatements); 622 verifyFormat("if (true) {\n" 623 " f();\n" 624 "} else {\n" 625 " f();\n" 626 "}", 627 AllowSimpleBracedStatements); 628 629 verifyFormat("struct A2 {\n" 630 " int X;\n" 631 "};", 632 AllowSimpleBracedStatements); 633 verifyFormat("typedef struct A2 {\n" 634 " int X;\n" 635 "} A2_t;", 636 AllowSimpleBracedStatements); 637 verifyFormat("template <int> struct A2 {\n" 638 " struct B {};\n" 639 "};", 640 AllowSimpleBracedStatements); 641 642 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 643 FormatStyle::SIS_Never; 644 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 645 verifyFormat("if (true) {\n" 646 " f();\n" 647 "}", 648 AllowSimpleBracedStatements); 649 verifyFormat("if (true) {\n" 650 " f();\n" 651 "} else {\n" 652 " f();\n" 653 "}", 654 AllowSimpleBracedStatements); 655 656 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 657 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 658 verifyFormat("while (true) {\n" 659 " f();\n" 660 "}", 661 AllowSimpleBracedStatements); 662 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 663 verifyFormat("for (;;) {\n" 664 " f();\n" 665 "}", 666 AllowSimpleBracedStatements); 667 668 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 669 FormatStyle::SIS_WithoutElse; 670 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 671 AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement = 672 FormatStyle::BWACS_Always; 673 674 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 675 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 676 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 677 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 678 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 679 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 680 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 681 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 682 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 683 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 684 verifyFormat("if (true)\n" 685 "{\n" 686 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 687 "}", 688 AllowSimpleBracedStatements); 689 verifyFormat("if (true)\n" 690 "{ //\n" 691 " f();\n" 692 "}", 693 AllowSimpleBracedStatements); 694 verifyFormat("if (true)\n" 695 "{\n" 696 " f();\n" 697 " f();\n" 698 "}", 699 AllowSimpleBracedStatements); 700 verifyFormat("if (true)\n" 701 "{\n" 702 " f();\n" 703 "} else\n" 704 "{\n" 705 " f();\n" 706 "}", 707 AllowSimpleBracedStatements); 708 709 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 710 FormatStyle::SIS_Never; 711 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 712 verifyFormat("if (true)\n" 713 "{\n" 714 " f();\n" 715 "}", 716 AllowSimpleBracedStatements); 717 verifyFormat("if (true)\n" 718 "{\n" 719 " f();\n" 720 "} else\n" 721 "{\n" 722 " f();\n" 723 "}", 724 AllowSimpleBracedStatements); 725 726 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 727 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 728 verifyFormat("while (true)\n" 729 "{\n" 730 " f();\n" 731 "}", 732 AllowSimpleBracedStatements); 733 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 734 verifyFormat("for (;;)\n" 735 "{\n" 736 " f();\n" 737 "}", 738 AllowSimpleBracedStatements); 739 } 740 741 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) { 742 FormatStyle Style = getLLVMStyleWithColumns(60); 743 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 744 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 745 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 746 EXPECT_EQ("#define A \\\n" 747 " if (HANDLEwernufrnuLwrmviferuvnierv) \\\n" 748 " { RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; }\n" 749 "X;", 750 format("#define A \\\n" 751 " if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n" 752 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n" 753 " }\n" 754 "X;", 755 Style)); 756 } 757 758 TEST_F(FormatTest, ParseIfElse) { 759 verifyFormat("if (true)\n" 760 " if (true)\n" 761 " if (true)\n" 762 " f();\n" 763 " else\n" 764 " g();\n" 765 " else\n" 766 " h();\n" 767 "else\n" 768 " i();"); 769 verifyFormat("if (true)\n" 770 " if (true)\n" 771 " if (true) {\n" 772 " if (true)\n" 773 " f();\n" 774 " } else {\n" 775 " g();\n" 776 " }\n" 777 " else\n" 778 " h();\n" 779 "else {\n" 780 " i();\n" 781 "}"); 782 verifyFormat("if (true)\n" 783 " if constexpr (true)\n" 784 " if (true) {\n" 785 " if constexpr (true)\n" 786 " f();\n" 787 " } else {\n" 788 " g();\n" 789 " }\n" 790 " else\n" 791 " h();\n" 792 "else {\n" 793 " i();\n" 794 "}"); 795 verifyFormat("if (true)\n" 796 " if CONSTEXPR (true)\n" 797 " if (true) {\n" 798 " if CONSTEXPR (true)\n" 799 " f();\n" 800 " } else {\n" 801 " g();\n" 802 " }\n" 803 " else\n" 804 " h();\n" 805 "else {\n" 806 " i();\n" 807 "}"); 808 verifyFormat("void f() {\n" 809 " if (a) {\n" 810 " } else {\n" 811 " }\n" 812 "}"); 813 } 814 815 TEST_F(FormatTest, ElseIf) { 816 verifyFormat("if (a) {\n} else if (b) {\n}"); 817 verifyFormat("if (a)\n" 818 " f();\n" 819 "else if (b)\n" 820 " g();\n" 821 "else\n" 822 " h();"); 823 verifyFormat("if constexpr (a)\n" 824 " f();\n" 825 "else if constexpr (b)\n" 826 " g();\n" 827 "else\n" 828 " h();"); 829 verifyFormat("if CONSTEXPR (a)\n" 830 " f();\n" 831 "else if CONSTEXPR (b)\n" 832 " g();\n" 833 "else\n" 834 " h();"); 835 verifyFormat("if (a) {\n" 836 " f();\n" 837 "}\n" 838 "// or else ..\n" 839 "else {\n" 840 " g()\n" 841 "}"); 842 843 verifyFormat("if (a) {\n" 844 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 845 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 846 "}"); 847 verifyFormat("if (a) {\n" 848 "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 849 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 850 "}"); 851 verifyFormat("if (a) {\n" 852 "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 853 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 854 "}"); 855 verifyFormat("if (a) {\n" 856 "} else if (\n" 857 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 858 "}", 859 getLLVMStyleWithColumns(62)); 860 verifyFormat("if (a) {\n" 861 "} else if constexpr (\n" 862 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 863 "}", 864 getLLVMStyleWithColumns(62)); 865 verifyFormat("if (a) {\n" 866 "} else if CONSTEXPR (\n" 867 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 868 "}", 869 getLLVMStyleWithColumns(62)); 870 } 871 872 TEST_F(FormatTest, FormatsForLoop) { 873 verifyFormat( 874 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 875 " ++VeryVeryLongLoopVariable)\n" 876 " ;"); 877 verifyFormat("for (;;)\n" 878 " f();"); 879 verifyFormat("for (;;) {\n}"); 880 verifyFormat("for (;;) {\n" 881 " f();\n" 882 "}"); 883 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 884 885 verifyFormat( 886 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 887 " E = UnwrappedLines.end();\n" 888 " I != E; ++I) {\n}"); 889 890 verifyFormat( 891 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 892 " ++IIIII) {\n}"); 893 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 894 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 895 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 896 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 897 " I = FD->getDeclsInPrototypeScope().begin(),\n" 898 " E = FD->getDeclsInPrototypeScope().end();\n" 899 " I != E; ++I) {\n}"); 900 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n" 901 " I = Container.begin(),\n" 902 " E = Container.end();\n" 903 " I != E; ++I) {\n}", 904 getLLVMStyleWithColumns(76)); 905 906 verifyFormat( 907 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 908 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 909 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 910 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 911 " ++aaaaaaaaaaa) {\n}"); 912 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 913 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n" 914 " ++i) {\n}"); 915 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 916 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 917 "}"); 918 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 919 " aaaaaaaaaa);\n" 920 " iter; ++iter) {\n" 921 "}"); 922 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 923 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 924 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n" 925 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {"); 926 927 // These should not be formatted as Objective-C for-in loops. 928 verifyFormat("for (Foo *x = 0; x != in; x++) {\n}"); 929 verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}"); 930 verifyFormat("Foo *x;\nfor (x in y) {\n}"); 931 verifyFormat( 932 "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}"); 933 934 FormatStyle NoBinPacking = getLLVMStyle(); 935 NoBinPacking.BinPackParameters = false; 936 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 937 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 938 " aaaaaaaaaaaaaaaa,\n" 939 " aaaaaaaaaaaaaaaa,\n" 940 " aaaaaaaaaaaaaaaa);\n" 941 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 942 "}", 943 NoBinPacking); 944 verifyFormat( 945 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 946 " E = UnwrappedLines.end();\n" 947 " I != E;\n" 948 " ++I) {\n}", 949 NoBinPacking); 950 951 FormatStyle AlignLeft = getLLVMStyle(); 952 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 953 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft); 954 } 955 956 TEST_F(FormatTest, RangeBasedForLoops) { 957 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 958 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 959 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 960 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 961 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 962 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 963 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n" 964 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}"); 965 } 966 967 TEST_F(FormatTest, ForEachLoops) { 968 verifyFormat("void f() {\n" 969 " foreach (Item *item, itemlist) {}\n" 970 " Q_FOREACH (Item *item, itemlist) {}\n" 971 " BOOST_FOREACH (Item *item, itemlist) {}\n" 972 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 973 "}"); 974 975 FormatStyle Style = getLLVMStyle(); 976 Style.SpaceBeforeParens = 977 FormatStyle::SBPO_ControlStatementsExceptForEachMacros; 978 verifyFormat("void f() {\n" 979 " foreach(Item *item, itemlist) {}\n" 980 " Q_FOREACH(Item *item, itemlist) {}\n" 981 " BOOST_FOREACH(Item *item, itemlist) {}\n" 982 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 983 "}", 984 Style); 985 986 // As function-like macros. 987 verifyFormat("#define foreach(x, y)\n" 988 "#define Q_FOREACH(x, y)\n" 989 "#define BOOST_FOREACH(x, y)\n" 990 "#define UNKNOWN_FOREACH(x, y)\n"); 991 992 // Not as function-like macros. 993 verifyFormat("#define foreach (x, y)\n" 994 "#define Q_FOREACH (x, y)\n" 995 "#define BOOST_FOREACH (x, y)\n" 996 "#define UNKNOWN_FOREACH (x, y)\n"); 997 } 998 999 TEST_F(FormatTest, FormatsWhileLoop) { 1000 verifyFormat("while (true) {\n}"); 1001 verifyFormat("while (true)\n" 1002 " f();"); 1003 verifyFormat("while () {\n}"); 1004 verifyFormat("while () {\n" 1005 " f();\n" 1006 "}"); 1007 } 1008 1009 TEST_F(FormatTest, FormatsDoWhile) { 1010 verifyFormat("do {\n" 1011 " do_something();\n" 1012 "} while (something());"); 1013 verifyFormat("do\n" 1014 " do_something();\n" 1015 "while (something());"); 1016 } 1017 1018 TEST_F(FormatTest, FormatsSwitchStatement) { 1019 verifyFormat("switch (x) {\n" 1020 "case 1:\n" 1021 " f();\n" 1022 " break;\n" 1023 "case kFoo:\n" 1024 "case ns::kBar:\n" 1025 "case kBaz:\n" 1026 " break;\n" 1027 "default:\n" 1028 " g();\n" 1029 " break;\n" 1030 "}"); 1031 verifyFormat("switch (x) {\n" 1032 "case 1: {\n" 1033 " f();\n" 1034 " break;\n" 1035 "}\n" 1036 "case 2: {\n" 1037 " break;\n" 1038 "}\n" 1039 "}"); 1040 verifyFormat("switch (x) {\n" 1041 "case 1: {\n" 1042 " f();\n" 1043 " {\n" 1044 " g();\n" 1045 " h();\n" 1046 " }\n" 1047 " break;\n" 1048 "}\n" 1049 "}"); 1050 verifyFormat("switch (x) {\n" 1051 "case 1: {\n" 1052 " f();\n" 1053 " if (foo) {\n" 1054 " g();\n" 1055 " h();\n" 1056 " }\n" 1057 " break;\n" 1058 "}\n" 1059 "}"); 1060 verifyFormat("switch (x) {\n" 1061 "case 1: {\n" 1062 " f();\n" 1063 " g();\n" 1064 "} break;\n" 1065 "}"); 1066 verifyFormat("switch (test)\n" 1067 " ;"); 1068 verifyFormat("switch (x) {\n" 1069 "default: {\n" 1070 " // Do nothing.\n" 1071 "}\n" 1072 "}"); 1073 verifyFormat("switch (x) {\n" 1074 "// comment\n" 1075 "// if 1, do f()\n" 1076 "case 1:\n" 1077 " f();\n" 1078 "}"); 1079 verifyFormat("switch (x) {\n" 1080 "case 1:\n" 1081 " // Do amazing stuff\n" 1082 " {\n" 1083 " f();\n" 1084 " g();\n" 1085 " }\n" 1086 " break;\n" 1087 "}"); 1088 verifyFormat("#define A \\\n" 1089 " switch (x) { \\\n" 1090 " case a: \\\n" 1091 " foo = b; \\\n" 1092 " }", 1093 getLLVMStyleWithColumns(20)); 1094 verifyFormat("#define OPERATION_CASE(name) \\\n" 1095 " case OP_name: \\\n" 1096 " return operations::Operation##name\n", 1097 getLLVMStyleWithColumns(40)); 1098 verifyFormat("switch (x) {\n" 1099 "case 1:;\n" 1100 "default:;\n" 1101 " int i;\n" 1102 "}"); 1103 1104 verifyGoogleFormat("switch (x) {\n" 1105 " case 1:\n" 1106 " f();\n" 1107 " break;\n" 1108 " case kFoo:\n" 1109 " case ns::kBar:\n" 1110 " case kBaz:\n" 1111 " break;\n" 1112 " default:\n" 1113 " g();\n" 1114 " break;\n" 1115 "}"); 1116 verifyGoogleFormat("switch (x) {\n" 1117 " case 1: {\n" 1118 " f();\n" 1119 " break;\n" 1120 " }\n" 1121 "}"); 1122 verifyGoogleFormat("switch (test)\n" 1123 " ;"); 1124 1125 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 1126 " case OP_name: \\\n" 1127 " return operations::Operation##name\n"); 1128 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 1129 " // Get the correction operation class.\n" 1130 " switch (OpCode) {\n" 1131 " CASE(Add);\n" 1132 " CASE(Subtract);\n" 1133 " default:\n" 1134 " return operations::Unknown;\n" 1135 " }\n" 1136 "#undef OPERATION_CASE\n" 1137 "}"); 1138 verifyFormat("DEBUG({\n" 1139 " switch (x) {\n" 1140 " case A:\n" 1141 " f();\n" 1142 " break;\n" 1143 " // fallthrough\n" 1144 " case B:\n" 1145 " g();\n" 1146 " break;\n" 1147 " }\n" 1148 "});"); 1149 EXPECT_EQ("DEBUG({\n" 1150 " switch (x) {\n" 1151 " case A:\n" 1152 " f();\n" 1153 " break;\n" 1154 " // On B:\n" 1155 " case B:\n" 1156 " g();\n" 1157 " break;\n" 1158 " }\n" 1159 "});", 1160 format("DEBUG({\n" 1161 " switch (x) {\n" 1162 " case A:\n" 1163 " f();\n" 1164 " break;\n" 1165 " // On B:\n" 1166 " case B:\n" 1167 " g();\n" 1168 " break;\n" 1169 " }\n" 1170 "});", 1171 getLLVMStyle())); 1172 EXPECT_EQ("switch (n) {\n" 1173 "case 0: {\n" 1174 " return false;\n" 1175 "}\n" 1176 "default: {\n" 1177 " return true;\n" 1178 "}\n" 1179 "}", 1180 format("switch (n)\n" 1181 "{\n" 1182 "case 0: {\n" 1183 " return false;\n" 1184 "}\n" 1185 "default: {\n" 1186 " return true;\n" 1187 "}\n" 1188 "}", 1189 getLLVMStyle())); 1190 verifyFormat("switch (a) {\n" 1191 "case (b):\n" 1192 " return;\n" 1193 "}"); 1194 1195 verifyFormat("switch (a) {\n" 1196 "case some_namespace::\n" 1197 " some_constant:\n" 1198 " return;\n" 1199 "}", 1200 getLLVMStyleWithColumns(34)); 1201 1202 FormatStyle Style = getLLVMStyle(); 1203 Style.IndentCaseLabels = true; 1204 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 1205 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1206 Style.BraceWrapping.AfterCaseLabel = true; 1207 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1208 EXPECT_EQ("switch (n)\n" 1209 "{\n" 1210 " case 0:\n" 1211 " {\n" 1212 " return false;\n" 1213 " }\n" 1214 " default:\n" 1215 " {\n" 1216 " return true;\n" 1217 " }\n" 1218 "}", 1219 format("switch (n) {\n" 1220 " case 0: {\n" 1221 " return false;\n" 1222 " }\n" 1223 " default: {\n" 1224 " return true;\n" 1225 " }\n" 1226 "}", 1227 Style)); 1228 Style.BraceWrapping.AfterCaseLabel = false; 1229 EXPECT_EQ("switch (n)\n" 1230 "{\n" 1231 " case 0: {\n" 1232 " return false;\n" 1233 " }\n" 1234 " default: {\n" 1235 " return true;\n" 1236 " }\n" 1237 "}", 1238 format("switch (n) {\n" 1239 " case 0:\n" 1240 " {\n" 1241 " return false;\n" 1242 " }\n" 1243 " default:\n" 1244 " {\n" 1245 " return true;\n" 1246 " }\n" 1247 "}", 1248 Style)); 1249 Style.IndentCaseLabels = false; 1250 Style.IndentCaseBlocks = true; 1251 EXPECT_EQ("switch (n)\n" 1252 "{\n" 1253 "case 0:\n" 1254 " {\n" 1255 " return false;\n" 1256 " }\n" 1257 "case 1:\n" 1258 " break;\n" 1259 "default:\n" 1260 " {\n" 1261 " return true;\n" 1262 " }\n" 1263 "}", 1264 format("switch (n) {\n" 1265 "case 0: {\n" 1266 " return false;\n" 1267 "}\n" 1268 "case 1:\n" 1269 " break;\n" 1270 "default: {\n" 1271 " return true;\n" 1272 "}\n" 1273 "}", 1274 Style)); 1275 Style.IndentCaseLabels = true; 1276 Style.IndentCaseBlocks = true; 1277 EXPECT_EQ("switch (n)\n" 1278 "{\n" 1279 " case 0:\n" 1280 " {\n" 1281 " return false;\n" 1282 " }\n" 1283 " case 1:\n" 1284 " break;\n" 1285 " default:\n" 1286 " {\n" 1287 " return true;\n" 1288 " }\n" 1289 "}", 1290 format("switch (n) {\n" 1291 "case 0: {\n" 1292 " return false;\n" 1293 "}\n" 1294 "case 1:\n" 1295 " break;\n" 1296 "default: {\n" 1297 " return true;\n" 1298 "}\n" 1299 "}", 1300 Style)); 1301 } 1302 1303 TEST_F(FormatTest, CaseRanges) { 1304 verifyFormat("switch (x) {\n" 1305 "case 'A' ... 'Z':\n" 1306 "case 1 ... 5:\n" 1307 "case a ... b:\n" 1308 " break;\n" 1309 "}"); 1310 } 1311 1312 TEST_F(FormatTest, ShortEnums) { 1313 FormatStyle Style = getLLVMStyle(); 1314 Style.AllowShortEnumsOnASingleLine = true; 1315 verifyFormat("enum { A, B, C } ShortEnum1, ShortEnum2;", Style); 1316 Style.AllowShortEnumsOnASingleLine = false; 1317 verifyFormat("enum\n" 1318 "{\n" 1319 " A,\n" 1320 " B,\n" 1321 " C\n" 1322 "} ShortEnum1, ShortEnum2;", 1323 Style); 1324 } 1325 1326 TEST_F(FormatTest, ShortCaseLabels) { 1327 FormatStyle Style = getLLVMStyle(); 1328 Style.AllowShortCaseLabelsOnASingleLine = true; 1329 verifyFormat("switch (a) {\n" 1330 "case 1: x = 1; break;\n" 1331 "case 2: return;\n" 1332 "case 3:\n" 1333 "case 4:\n" 1334 "case 5: return;\n" 1335 "case 6: // comment\n" 1336 " return;\n" 1337 "case 7:\n" 1338 " // comment\n" 1339 " return;\n" 1340 "case 8:\n" 1341 " x = 8; // comment\n" 1342 " break;\n" 1343 "default: y = 1; break;\n" 1344 "}", 1345 Style); 1346 verifyFormat("switch (a) {\n" 1347 "case 0: return; // comment\n" 1348 "case 1: break; // comment\n" 1349 "case 2: return;\n" 1350 "// comment\n" 1351 "case 3: return;\n" 1352 "// comment 1\n" 1353 "// comment 2\n" 1354 "// comment 3\n" 1355 "case 4: break; /* comment */\n" 1356 "case 5:\n" 1357 " // comment\n" 1358 " break;\n" 1359 "case 6: /* comment */ x = 1; break;\n" 1360 "case 7: x = /* comment */ 1; break;\n" 1361 "case 8:\n" 1362 " x = 1; /* comment */\n" 1363 " break;\n" 1364 "case 9:\n" 1365 " break; // comment line 1\n" 1366 " // comment line 2\n" 1367 "}", 1368 Style); 1369 EXPECT_EQ("switch (a) {\n" 1370 "case 1:\n" 1371 " x = 8;\n" 1372 " // fall through\n" 1373 "case 2: x = 8;\n" 1374 "// comment\n" 1375 "case 3:\n" 1376 " return; /* comment line 1\n" 1377 " * comment line 2 */\n" 1378 "case 4: i = 8;\n" 1379 "// something else\n" 1380 "#if FOO\n" 1381 "case 5: break;\n" 1382 "#endif\n" 1383 "}", 1384 format("switch (a) {\n" 1385 "case 1: x = 8;\n" 1386 " // fall through\n" 1387 "case 2:\n" 1388 " x = 8;\n" 1389 "// comment\n" 1390 "case 3:\n" 1391 " return; /* comment line 1\n" 1392 " * comment line 2 */\n" 1393 "case 4:\n" 1394 " i = 8;\n" 1395 "// something else\n" 1396 "#if FOO\n" 1397 "case 5: break;\n" 1398 "#endif\n" 1399 "}", 1400 Style)); 1401 EXPECT_EQ("switch (a) {\n" 1402 "case 0:\n" 1403 " return; // long long long long long long long long long long " 1404 "long long comment\n" 1405 " // line\n" 1406 "}", 1407 format("switch (a) {\n" 1408 "case 0: return; // long long long long long long long long " 1409 "long long long long comment line\n" 1410 "}", 1411 Style)); 1412 EXPECT_EQ("switch (a) {\n" 1413 "case 0:\n" 1414 " return; /* long long long long long long long long long long " 1415 "long long comment\n" 1416 " line */\n" 1417 "}", 1418 format("switch (a) {\n" 1419 "case 0: return; /* long long long long long long long long " 1420 "long long long long comment line */\n" 1421 "}", 1422 Style)); 1423 verifyFormat("switch (a) {\n" 1424 "#if FOO\n" 1425 "case 0: return 0;\n" 1426 "#endif\n" 1427 "}", 1428 Style); 1429 verifyFormat("switch (a) {\n" 1430 "case 1: {\n" 1431 "}\n" 1432 "case 2: {\n" 1433 " return;\n" 1434 "}\n" 1435 "case 3: {\n" 1436 " x = 1;\n" 1437 " return;\n" 1438 "}\n" 1439 "case 4:\n" 1440 " if (x)\n" 1441 " return;\n" 1442 "}", 1443 Style); 1444 Style.ColumnLimit = 21; 1445 verifyFormat("switch (a) {\n" 1446 "case 1: x = 1; break;\n" 1447 "case 2: return;\n" 1448 "case 3:\n" 1449 "case 4:\n" 1450 "case 5: return;\n" 1451 "default:\n" 1452 " y = 1;\n" 1453 " break;\n" 1454 "}", 1455 Style); 1456 Style.ColumnLimit = 80; 1457 Style.AllowShortCaseLabelsOnASingleLine = false; 1458 Style.IndentCaseLabels = true; 1459 EXPECT_EQ("switch (n) {\n" 1460 " default /*comments*/:\n" 1461 " return true;\n" 1462 " case 0:\n" 1463 " return false;\n" 1464 "}", 1465 format("switch (n) {\n" 1466 "default/*comments*/:\n" 1467 " return true;\n" 1468 "case 0:\n" 1469 " return false;\n" 1470 "}", 1471 Style)); 1472 Style.AllowShortCaseLabelsOnASingleLine = true; 1473 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1474 Style.BraceWrapping.AfterCaseLabel = true; 1475 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1476 EXPECT_EQ("switch (n)\n" 1477 "{\n" 1478 " case 0:\n" 1479 " {\n" 1480 " return false;\n" 1481 " }\n" 1482 " default:\n" 1483 " {\n" 1484 " return true;\n" 1485 " }\n" 1486 "}", 1487 format("switch (n) {\n" 1488 " case 0: {\n" 1489 " return false;\n" 1490 " }\n" 1491 " default:\n" 1492 " {\n" 1493 " return true;\n" 1494 " }\n" 1495 "}", 1496 Style)); 1497 } 1498 1499 TEST_F(FormatTest, FormatsLabels) { 1500 verifyFormat("void f() {\n" 1501 " some_code();\n" 1502 "test_label:\n" 1503 " some_other_code();\n" 1504 " {\n" 1505 " some_more_code();\n" 1506 " another_label:\n" 1507 " some_more_code();\n" 1508 " }\n" 1509 "}"); 1510 verifyFormat("{\n" 1511 " some_code();\n" 1512 "test_label:\n" 1513 " some_other_code();\n" 1514 "}"); 1515 verifyFormat("{\n" 1516 " some_code();\n" 1517 "test_label:;\n" 1518 " int i = 0;\n" 1519 "}"); 1520 FormatStyle Style = getLLVMStyle(); 1521 Style.IndentGotoLabels = false; 1522 verifyFormat("void f() {\n" 1523 " some_code();\n" 1524 "test_label:\n" 1525 " some_other_code();\n" 1526 " {\n" 1527 " some_more_code();\n" 1528 "another_label:\n" 1529 " some_more_code();\n" 1530 " }\n" 1531 "}", 1532 Style); 1533 verifyFormat("{\n" 1534 " some_code();\n" 1535 "test_label:\n" 1536 " some_other_code();\n" 1537 "}", 1538 Style); 1539 verifyFormat("{\n" 1540 " some_code();\n" 1541 "test_label:;\n" 1542 " int i = 0;\n" 1543 "}"); 1544 } 1545 1546 TEST_F(FormatTest, MultiLineControlStatements) { 1547 FormatStyle Style = getLLVMStyle(); 1548 Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom; 1549 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine; 1550 Style.ColumnLimit = 20; 1551 // Short lines should keep opening brace on same line. 1552 EXPECT_EQ("if (foo) {\n" 1553 " bar();\n" 1554 "}", 1555 format("if(foo){bar();}", Style)); 1556 EXPECT_EQ("if (foo) {\n" 1557 " bar();\n" 1558 "} else {\n" 1559 " baz();\n" 1560 "}", 1561 format("if(foo){bar();}else{baz();}", Style)); 1562 EXPECT_EQ("if (foo && bar) {\n" 1563 " baz();\n" 1564 "}", 1565 format("if(foo&&bar){baz();}", Style)); 1566 EXPECT_EQ("if (foo) {\n" 1567 " bar();\n" 1568 "} else if (baz) {\n" 1569 " quux();\n" 1570 "}", 1571 format("if(foo){bar();}else if(baz){quux();}", Style)); 1572 EXPECT_EQ( 1573 "if (foo) {\n" 1574 " bar();\n" 1575 "} else if (baz) {\n" 1576 " quux();\n" 1577 "} else {\n" 1578 " foobar();\n" 1579 "}", 1580 format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style)); 1581 EXPECT_EQ("for (;;) {\n" 1582 " foo();\n" 1583 "}", 1584 format("for(;;){foo();}")); 1585 EXPECT_EQ("while (1) {\n" 1586 " foo();\n" 1587 "}", 1588 format("while(1){foo();}", Style)); 1589 EXPECT_EQ("switch (foo) {\n" 1590 "case bar:\n" 1591 " return;\n" 1592 "}", 1593 format("switch(foo){case bar:return;}", Style)); 1594 EXPECT_EQ("try {\n" 1595 " foo();\n" 1596 "} catch (...) {\n" 1597 " bar();\n" 1598 "}", 1599 format("try{foo();}catch(...){bar();}", Style)); 1600 EXPECT_EQ("do {\n" 1601 " foo();\n" 1602 "} while (bar &&\n" 1603 " baz);", 1604 format("do{foo();}while(bar&&baz);", Style)); 1605 // Long lines should put opening brace on new line. 1606 EXPECT_EQ("if (foo && bar &&\n" 1607 " baz)\n" 1608 "{\n" 1609 " quux();\n" 1610 "}", 1611 format("if(foo&&bar&&baz){quux();}", Style)); 1612 EXPECT_EQ("if (foo && bar &&\n" 1613 " baz)\n" 1614 "{\n" 1615 " quux();\n" 1616 "}", 1617 format("if (foo && bar &&\n" 1618 " baz) {\n" 1619 " quux();\n" 1620 "}", 1621 Style)); 1622 EXPECT_EQ("if (foo) {\n" 1623 " bar();\n" 1624 "} else if (baz ||\n" 1625 " quux)\n" 1626 "{\n" 1627 " foobar();\n" 1628 "}", 1629 format("if(foo){bar();}else if(baz||quux){foobar();}", Style)); 1630 EXPECT_EQ( 1631 "if (foo) {\n" 1632 " bar();\n" 1633 "} else if (baz ||\n" 1634 " quux)\n" 1635 "{\n" 1636 " foobar();\n" 1637 "} else {\n" 1638 " barbaz();\n" 1639 "}", 1640 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1641 Style)); 1642 EXPECT_EQ("for (int i = 0;\n" 1643 " i < 10; ++i)\n" 1644 "{\n" 1645 " foo();\n" 1646 "}", 1647 format("for(int i=0;i<10;++i){foo();}", Style)); 1648 EXPECT_EQ("while (foo || bar ||\n" 1649 " baz)\n" 1650 "{\n" 1651 " quux();\n" 1652 "}", 1653 format("while(foo||bar||baz){quux();}", Style)); 1654 EXPECT_EQ("switch (\n" 1655 " foo = barbaz)\n" 1656 "{\n" 1657 "case quux:\n" 1658 " return;\n" 1659 "}", 1660 format("switch(foo=barbaz){case quux:return;}", Style)); 1661 EXPECT_EQ("try {\n" 1662 " foo();\n" 1663 "} catch (\n" 1664 " Exception &bar)\n" 1665 "{\n" 1666 " baz();\n" 1667 "}", 1668 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1669 Style.ColumnLimit = 1670 40; // to concentrate at brace wrapping, not line wrap due to column limit 1671 EXPECT_EQ("try {\n" 1672 " foo();\n" 1673 "} catch (Exception &bar) {\n" 1674 " baz();\n" 1675 "}", 1676 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1677 Style.ColumnLimit = 1678 20; // to concentrate at brace wrapping, not line wrap due to column limit 1679 1680 Style.BraceWrapping.BeforeElse = true; 1681 EXPECT_EQ( 1682 "if (foo) {\n" 1683 " bar();\n" 1684 "}\n" 1685 "else if (baz ||\n" 1686 " quux)\n" 1687 "{\n" 1688 " foobar();\n" 1689 "}\n" 1690 "else {\n" 1691 " barbaz();\n" 1692 "}", 1693 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1694 Style)); 1695 1696 Style.BraceWrapping.BeforeCatch = true; 1697 EXPECT_EQ("try {\n" 1698 " foo();\n" 1699 "}\n" 1700 "catch (...) {\n" 1701 " baz();\n" 1702 "}", 1703 format("try{foo();}catch(...){baz();}", Style)); 1704 } 1705 1706 //===----------------------------------------------------------------------===// 1707 // Tests for classes, namespaces, etc. 1708 //===----------------------------------------------------------------------===// 1709 1710 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1711 verifyFormat("class A {};"); 1712 } 1713 1714 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1715 verifyFormat("class A {\n" 1716 "public:\n" 1717 "public: // comment\n" 1718 "protected:\n" 1719 "private:\n" 1720 " void f() {}\n" 1721 "};"); 1722 verifyFormat("export class A {\n" 1723 "public:\n" 1724 "public: // comment\n" 1725 "protected:\n" 1726 "private:\n" 1727 " void f() {}\n" 1728 "};"); 1729 verifyGoogleFormat("class A {\n" 1730 " public:\n" 1731 " protected:\n" 1732 " private:\n" 1733 " void f() {}\n" 1734 "};"); 1735 verifyGoogleFormat("export class A {\n" 1736 " public:\n" 1737 " protected:\n" 1738 " private:\n" 1739 " void f() {}\n" 1740 "};"); 1741 verifyFormat("class A {\n" 1742 "public slots:\n" 1743 " void f1() {}\n" 1744 "public Q_SLOTS:\n" 1745 " void f2() {}\n" 1746 "protected slots:\n" 1747 " void f3() {}\n" 1748 "protected Q_SLOTS:\n" 1749 " void f4() {}\n" 1750 "private slots:\n" 1751 " void f5() {}\n" 1752 "private Q_SLOTS:\n" 1753 " void f6() {}\n" 1754 "signals:\n" 1755 " void g1();\n" 1756 "Q_SIGNALS:\n" 1757 " void g2();\n" 1758 "};"); 1759 1760 // Don't interpret 'signals' the wrong way. 1761 verifyFormat("signals.set();"); 1762 verifyFormat("for (Signals signals : f()) {\n}"); 1763 verifyFormat("{\n" 1764 " signals.set(); // This needs indentation.\n" 1765 "}"); 1766 verifyFormat("void f() {\n" 1767 "label:\n" 1768 " signals.baz();\n" 1769 "}"); 1770 } 1771 1772 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1773 EXPECT_EQ("class A {\n" 1774 "public:\n" 1775 " void f();\n" 1776 "\n" 1777 "private:\n" 1778 " void g() {}\n" 1779 " // test\n" 1780 "protected:\n" 1781 " int h;\n" 1782 "};", 1783 format("class A {\n" 1784 "public:\n" 1785 "void f();\n" 1786 "private:\n" 1787 "void g() {}\n" 1788 "// test\n" 1789 "protected:\n" 1790 "int h;\n" 1791 "};")); 1792 EXPECT_EQ("class A {\n" 1793 "protected:\n" 1794 "public:\n" 1795 " void f();\n" 1796 "};", 1797 format("class A {\n" 1798 "protected:\n" 1799 "\n" 1800 "public:\n" 1801 "\n" 1802 " void f();\n" 1803 "};")); 1804 1805 // Even ensure proper spacing inside macros. 1806 EXPECT_EQ("#define B \\\n" 1807 " class A { \\\n" 1808 " protected: \\\n" 1809 " public: \\\n" 1810 " void f(); \\\n" 1811 " };", 1812 format("#define B \\\n" 1813 " class A { \\\n" 1814 " protected: \\\n" 1815 " \\\n" 1816 " public: \\\n" 1817 " \\\n" 1818 " void f(); \\\n" 1819 " };", 1820 getGoogleStyle())); 1821 // But don't remove empty lines after macros ending in access specifiers. 1822 EXPECT_EQ("#define A private:\n" 1823 "\n" 1824 "int i;", 1825 format("#define A private:\n" 1826 "\n" 1827 "int i;")); 1828 } 1829 1830 TEST_F(FormatTest, FormatsClasses) { 1831 verifyFormat("class A : public B {};"); 1832 verifyFormat("class A : public ::B {};"); 1833 1834 verifyFormat( 1835 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1836 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1837 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1838 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1839 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1840 verifyFormat( 1841 "class A : public B, public C, public D, public E, public F {};"); 1842 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1843 " public C,\n" 1844 " public D,\n" 1845 " public E,\n" 1846 " public F,\n" 1847 " public G {};"); 1848 1849 verifyFormat("class\n" 1850 " ReallyReallyLongClassName {\n" 1851 " int i;\n" 1852 "};", 1853 getLLVMStyleWithColumns(32)); 1854 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1855 " aaaaaaaaaaaaaaaa> {};"); 1856 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1857 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1858 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1859 verifyFormat("template <class R, class C>\n" 1860 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1861 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1862 verifyFormat("class ::A::B {};"); 1863 } 1864 1865 TEST_F(FormatTest, BreakInheritanceStyle) { 1866 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1867 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1868 FormatStyle::BILS_BeforeComma; 1869 verifyFormat("class MyClass : public X {};", 1870 StyleWithInheritanceBreakBeforeComma); 1871 verifyFormat("class MyClass\n" 1872 " : public X\n" 1873 " , public Y {};", 1874 StyleWithInheritanceBreakBeforeComma); 1875 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1876 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1877 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1878 StyleWithInheritanceBreakBeforeComma); 1879 verifyFormat("struct aaaaaaaaaaaaa\n" 1880 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1881 " aaaaaaaaaaaaaaaa> {};", 1882 StyleWithInheritanceBreakBeforeComma); 1883 1884 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1885 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1886 FormatStyle::BILS_AfterColon; 1887 verifyFormat("class MyClass : public X {};", 1888 StyleWithInheritanceBreakAfterColon); 1889 verifyFormat("class MyClass : public X, public Y {};", 1890 StyleWithInheritanceBreakAfterColon); 1891 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1892 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1893 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1894 StyleWithInheritanceBreakAfterColon); 1895 verifyFormat("struct aaaaaaaaaaaaa :\n" 1896 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1897 " aaaaaaaaaaaaaaaa> {};", 1898 StyleWithInheritanceBreakAfterColon); 1899 } 1900 1901 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1902 verifyFormat("class A {\n} a, b;"); 1903 verifyFormat("struct A {\n} a, b;"); 1904 verifyFormat("union A {\n} a;"); 1905 } 1906 1907 TEST_F(FormatTest, FormatsEnum) { 1908 verifyFormat("enum {\n" 1909 " Zero,\n" 1910 " One = 1,\n" 1911 " Two = One + 1,\n" 1912 " Three = (One + Two),\n" 1913 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1914 " Five = (One, Two, Three, Four, 5)\n" 1915 "};"); 1916 verifyGoogleFormat("enum {\n" 1917 " Zero,\n" 1918 " One = 1,\n" 1919 " Two = One + 1,\n" 1920 " Three = (One + Two),\n" 1921 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1922 " Five = (One, Two, Three, Four, 5)\n" 1923 "};"); 1924 verifyFormat("enum Enum {};"); 1925 verifyFormat("enum {};"); 1926 verifyFormat("enum X E {} d;"); 1927 verifyFormat("enum __attribute__((...)) E {} d;"); 1928 verifyFormat("enum __declspec__((...)) E {} d;"); 1929 verifyFormat("enum {\n" 1930 " Bar = Foo<int, int>::value\n" 1931 "};", 1932 getLLVMStyleWithColumns(30)); 1933 1934 verifyFormat("enum ShortEnum { A, B, C };"); 1935 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1936 1937 EXPECT_EQ("enum KeepEmptyLines {\n" 1938 " ONE,\n" 1939 "\n" 1940 " TWO,\n" 1941 "\n" 1942 " THREE\n" 1943 "}", 1944 format("enum KeepEmptyLines {\n" 1945 " ONE,\n" 1946 "\n" 1947 " TWO,\n" 1948 "\n" 1949 "\n" 1950 " THREE\n" 1951 "}")); 1952 verifyFormat("enum E { // comment\n" 1953 " ONE,\n" 1954 " TWO\n" 1955 "};\n" 1956 "int i;"); 1957 1958 FormatStyle EightIndent = getLLVMStyle(); 1959 EightIndent.IndentWidth = 8; 1960 verifyFormat("enum {\n" 1961 " VOID,\n" 1962 " CHAR,\n" 1963 " SHORT,\n" 1964 " INT,\n" 1965 " LONG,\n" 1966 " SIGNED,\n" 1967 " UNSIGNED,\n" 1968 " BOOL,\n" 1969 " FLOAT,\n" 1970 " DOUBLE,\n" 1971 " COMPLEX\n" 1972 "};", 1973 EightIndent); 1974 1975 // Not enums. 1976 verifyFormat("enum X f() {\n" 1977 " a();\n" 1978 " return 42;\n" 1979 "}"); 1980 verifyFormat("enum X Type::f() {\n" 1981 " a();\n" 1982 " return 42;\n" 1983 "}"); 1984 verifyFormat("enum ::X f() {\n" 1985 " a();\n" 1986 " return 42;\n" 1987 "}"); 1988 verifyFormat("enum ns::X f() {\n" 1989 " a();\n" 1990 " return 42;\n" 1991 "}"); 1992 } 1993 1994 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1995 verifyFormat("enum Type {\n" 1996 " One = 0; // These semicolons should be commas.\n" 1997 " Two = 1;\n" 1998 "};"); 1999 verifyFormat("namespace n {\n" 2000 "enum Type {\n" 2001 " One,\n" 2002 " Two, // missing };\n" 2003 " int i;\n" 2004 "}\n" 2005 "void g() {}"); 2006 } 2007 2008 TEST_F(FormatTest, FormatsEnumStruct) { 2009 verifyFormat("enum struct {\n" 2010 " Zero,\n" 2011 " One = 1,\n" 2012 " Two = One + 1,\n" 2013 " Three = (One + Two),\n" 2014 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 2015 " Five = (One, Two, Three, Four, 5)\n" 2016 "};"); 2017 verifyFormat("enum struct Enum {};"); 2018 verifyFormat("enum struct {};"); 2019 verifyFormat("enum struct X E {} d;"); 2020 verifyFormat("enum struct __attribute__((...)) E {} d;"); 2021 verifyFormat("enum struct __declspec__((...)) E {} d;"); 2022 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 2023 } 2024 2025 TEST_F(FormatTest, FormatsEnumClass) { 2026 verifyFormat("enum class {\n" 2027 " Zero,\n" 2028 " One = 1,\n" 2029 " Two = One + 1,\n" 2030 " Three = (One + Two),\n" 2031 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 2032 " Five = (One, Two, Three, Four, 5)\n" 2033 "};"); 2034 verifyFormat("enum class Enum {};"); 2035 verifyFormat("enum class {};"); 2036 verifyFormat("enum class X E {} d;"); 2037 verifyFormat("enum class __attribute__((...)) E {} d;"); 2038 verifyFormat("enum class __declspec__((...)) E {} d;"); 2039 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 2040 } 2041 2042 TEST_F(FormatTest, FormatsEnumTypes) { 2043 verifyFormat("enum X : int {\n" 2044 " A, // Force multiple lines.\n" 2045 " B\n" 2046 "};"); 2047 verifyFormat("enum X : int { A, B };"); 2048 verifyFormat("enum X : std::uint32_t { A, B };"); 2049 } 2050 2051 TEST_F(FormatTest, FormatsTypedefEnum) { 2052 FormatStyle Style = getLLVMStyle(); 2053 Style.ColumnLimit = 40; 2054 verifyFormat("typedef enum {} EmptyEnum;"); 2055 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 2056 verifyFormat("typedef enum {\n" 2057 " ZERO = 0,\n" 2058 " ONE = 1,\n" 2059 " TWO = 2,\n" 2060 " THREE = 3\n" 2061 "} LongEnum;", 2062 Style); 2063 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2064 Style.BraceWrapping.AfterEnum = true; 2065 verifyFormat("typedef enum {} EmptyEnum;"); 2066 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 2067 verifyFormat("typedef enum\n" 2068 "{\n" 2069 " ZERO = 0,\n" 2070 " ONE = 1,\n" 2071 " TWO = 2,\n" 2072 " THREE = 3\n" 2073 "} LongEnum;", 2074 Style); 2075 } 2076 2077 TEST_F(FormatTest, FormatsNSEnums) { 2078 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 2079 verifyGoogleFormat( 2080 "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }"); 2081 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 2082 " // Information about someDecentlyLongValue.\n" 2083 " someDecentlyLongValue,\n" 2084 " // Information about anotherDecentlyLongValue.\n" 2085 " anotherDecentlyLongValue,\n" 2086 " // Information about aThirdDecentlyLongValue.\n" 2087 " aThirdDecentlyLongValue\n" 2088 "};"); 2089 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n" 2090 " // Information about someDecentlyLongValue.\n" 2091 " someDecentlyLongValue,\n" 2092 " // Information about anotherDecentlyLongValue.\n" 2093 " anotherDecentlyLongValue,\n" 2094 " // Information about aThirdDecentlyLongValue.\n" 2095 " aThirdDecentlyLongValue\n" 2096 "};"); 2097 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 2098 " a = 1,\n" 2099 " b = 2,\n" 2100 " c = 3,\n" 2101 "};"); 2102 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 2103 " a = 1,\n" 2104 " b = 2,\n" 2105 " c = 3,\n" 2106 "};"); 2107 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n" 2108 " a = 1,\n" 2109 " b = 2,\n" 2110 " c = 3,\n" 2111 "};"); 2112 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 2113 " a = 1,\n" 2114 " b = 2,\n" 2115 " c = 3,\n" 2116 "};"); 2117 } 2118 2119 TEST_F(FormatTest, FormatsBitfields) { 2120 verifyFormat("struct Bitfields {\n" 2121 " unsigned sClass : 8;\n" 2122 " unsigned ValueKind : 2;\n" 2123 "};"); 2124 verifyFormat("struct A {\n" 2125 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 2126 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 2127 "};"); 2128 verifyFormat("struct MyStruct {\n" 2129 " uchar data;\n" 2130 " uchar : 8;\n" 2131 " uchar : 8;\n" 2132 " uchar other;\n" 2133 "};"); 2134 } 2135 2136 TEST_F(FormatTest, FormatsNamespaces) { 2137 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 2138 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 2139 2140 verifyFormat("namespace some_namespace {\n" 2141 "class A {};\n" 2142 "void f() { f(); }\n" 2143 "}", 2144 LLVMWithNoNamespaceFix); 2145 verifyFormat("namespace N::inline D {\n" 2146 "class A {};\n" 2147 "void f() { f(); }\n" 2148 "}", 2149 LLVMWithNoNamespaceFix); 2150 verifyFormat("namespace N::inline D::E {\n" 2151 "class A {};\n" 2152 "void f() { f(); }\n" 2153 "}", 2154 LLVMWithNoNamespaceFix); 2155 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n" 2156 "class A {};\n" 2157 "void f() { f(); }\n" 2158 "}", 2159 LLVMWithNoNamespaceFix); 2160 verifyFormat("/* something */ namespace some_namespace {\n" 2161 "class A {};\n" 2162 "void f() { f(); }\n" 2163 "}", 2164 LLVMWithNoNamespaceFix); 2165 verifyFormat("namespace {\n" 2166 "class A {};\n" 2167 "void f() { f(); }\n" 2168 "}", 2169 LLVMWithNoNamespaceFix); 2170 verifyFormat("/* something */ namespace {\n" 2171 "class A {};\n" 2172 "void f() { f(); }\n" 2173 "}", 2174 LLVMWithNoNamespaceFix); 2175 verifyFormat("inline namespace X {\n" 2176 "class A {};\n" 2177 "void f() { f(); }\n" 2178 "}", 2179 LLVMWithNoNamespaceFix); 2180 verifyFormat("/* something */ inline namespace X {\n" 2181 "class A {};\n" 2182 "void f() { f(); }\n" 2183 "}", 2184 LLVMWithNoNamespaceFix); 2185 verifyFormat("export namespace X {\n" 2186 "class A {};\n" 2187 "void f() { f(); }\n" 2188 "}", 2189 LLVMWithNoNamespaceFix); 2190 verifyFormat("using namespace some_namespace;\n" 2191 "class A {};\n" 2192 "void f() { f(); }", 2193 LLVMWithNoNamespaceFix); 2194 2195 // This code is more common than we thought; if we 2196 // layout this correctly the semicolon will go into 2197 // its own line, which is undesirable. 2198 verifyFormat("namespace {};", LLVMWithNoNamespaceFix); 2199 verifyFormat("namespace {\n" 2200 "class A {};\n" 2201 "};", 2202 LLVMWithNoNamespaceFix); 2203 2204 verifyFormat("namespace {\n" 2205 "int SomeVariable = 0; // comment\n" 2206 "} // namespace", 2207 LLVMWithNoNamespaceFix); 2208 EXPECT_EQ("#ifndef HEADER_GUARD\n" 2209 "#define HEADER_GUARD\n" 2210 "namespace my_namespace {\n" 2211 "int i;\n" 2212 "} // my_namespace\n" 2213 "#endif // HEADER_GUARD", 2214 format("#ifndef HEADER_GUARD\n" 2215 " #define HEADER_GUARD\n" 2216 " namespace my_namespace {\n" 2217 "int i;\n" 2218 "} // my_namespace\n" 2219 "#endif // HEADER_GUARD", 2220 LLVMWithNoNamespaceFix)); 2221 2222 EXPECT_EQ("namespace A::B {\n" 2223 "class C {};\n" 2224 "}", 2225 format("namespace A::B {\n" 2226 "class C {};\n" 2227 "}", 2228 LLVMWithNoNamespaceFix)); 2229 2230 FormatStyle Style = getLLVMStyle(); 2231 Style.NamespaceIndentation = FormatStyle::NI_All; 2232 EXPECT_EQ("namespace out {\n" 2233 " int i;\n" 2234 " namespace in {\n" 2235 " int i;\n" 2236 " } // namespace in\n" 2237 "} // namespace out", 2238 format("namespace out {\n" 2239 "int i;\n" 2240 "namespace in {\n" 2241 "int i;\n" 2242 "} // namespace in\n" 2243 "} // namespace out", 2244 Style)); 2245 2246 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2247 EXPECT_EQ("namespace out {\n" 2248 "int i;\n" 2249 "namespace in {\n" 2250 " int i;\n" 2251 "} // namespace in\n" 2252 "} // namespace out", 2253 format("namespace out {\n" 2254 "int i;\n" 2255 "namespace in {\n" 2256 "int i;\n" 2257 "} // namespace in\n" 2258 "} // namespace out", 2259 Style)); 2260 } 2261 2262 TEST_F(FormatTest, NamespaceMacros) { 2263 FormatStyle Style = getLLVMStyle(); 2264 Style.NamespaceMacros.push_back("TESTSUITE"); 2265 2266 verifyFormat("TESTSUITE(A) {\n" 2267 "int foo();\n" 2268 "} // TESTSUITE(A)", 2269 Style); 2270 2271 verifyFormat("TESTSUITE(A, B) {\n" 2272 "int foo();\n" 2273 "} // TESTSUITE(A)", 2274 Style); 2275 2276 // Properly indent according to NamespaceIndentation style 2277 Style.NamespaceIndentation = FormatStyle::NI_All; 2278 verifyFormat("TESTSUITE(A) {\n" 2279 " int foo();\n" 2280 "} // TESTSUITE(A)", 2281 Style); 2282 verifyFormat("TESTSUITE(A) {\n" 2283 " namespace B {\n" 2284 " int foo();\n" 2285 " } // namespace B\n" 2286 "} // TESTSUITE(A)", 2287 Style); 2288 verifyFormat("namespace A {\n" 2289 " TESTSUITE(B) {\n" 2290 " int foo();\n" 2291 " } // TESTSUITE(B)\n" 2292 "} // namespace A", 2293 Style); 2294 2295 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2296 verifyFormat("TESTSUITE(A) {\n" 2297 "TESTSUITE(B) {\n" 2298 " int foo();\n" 2299 "} // TESTSUITE(B)\n" 2300 "} // TESTSUITE(A)", 2301 Style); 2302 verifyFormat("TESTSUITE(A) {\n" 2303 "namespace B {\n" 2304 " int foo();\n" 2305 "} // namespace B\n" 2306 "} // TESTSUITE(A)", 2307 Style); 2308 verifyFormat("namespace A {\n" 2309 "TESTSUITE(B) {\n" 2310 " int foo();\n" 2311 "} // TESTSUITE(B)\n" 2312 "} // namespace A", 2313 Style); 2314 2315 // Properly merge namespace-macros blocks in CompactNamespaces mode 2316 Style.NamespaceIndentation = FormatStyle::NI_None; 2317 Style.CompactNamespaces = true; 2318 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n" 2319 "}} // TESTSUITE(A::B)", 2320 Style); 2321 2322 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2323 "}} // TESTSUITE(out::in)", 2324 format("TESTSUITE(out) {\n" 2325 "TESTSUITE(in) {\n" 2326 "} // TESTSUITE(in)\n" 2327 "} // TESTSUITE(out)", 2328 Style)); 2329 2330 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2331 "}} // TESTSUITE(out::in)", 2332 format("TESTSUITE(out) {\n" 2333 "TESTSUITE(in) {\n" 2334 "} // TESTSUITE(in)\n" 2335 "} // TESTSUITE(out)", 2336 Style)); 2337 2338 // Do not merge different namespaces/macros 2339 EXPECT_EQ("namespace out {\n" 2340 "TESTSUITE(in) {\n" 2341 "} // TESTSUITE(in)\n" 2342 "} // namespace out", 2343 format("namespace out {\n" 2344 "TESTSUITE(in) {\n" 2345 "} // TESTSUITE(in)\n" 2346 "} // namespace out", 2347 Style)); 2348 EXPECT_EQ("TESTSUITE(out) {\n" 2349 "namespace in {\n" 2350 "} // namespace in\n" 2351 "} // TESTSUITE(out)", 2352 format("TESTSUITE(out) {\n" 2353 "namespace in {\n" 2354 "} // namespace in\n" 2355 "} // TESTSUITE(out)", 2356 Style)); 2357 Style.NamespaceMacros.push_back("FOOBAR"); 2358 EXPECT_EQ("TESTSUITE(out) {\n" 2359 "FOOBAR(in) {\n" 2360 "} // FOOBAR(in)\n" 2361 "} // TESTSUITE(out)", 2362 format("TESTSUITE(out) {\n" 2363 "FOOBAR(in) {\n" 2364 "} // FOOBAR(in)\n" 2365 "} // TESTSUITE(out)", 2366 Style)); 2367 } 2368 2369 TEST_F(FormatTest, FormatsCompactNamespaces) { 2370 FormatStyle Style = getLLVMStyle(); 2371 Style.CompactNamespaces = true; 2372 Style.NamespaceMacros.push_back("TESTSUITE"); 2373 2374 verifyFormat("namespace A { namespace B {\n" 2375 "}} // namespace A::B", 2376 Style); 2377 2378 EXPECT_EQ("namespace out { namespace in {\n" 2379 "}} // namespace out::in", 2380 format("namespace out {\n" 2381 "namespace in {\n" 2382 "} // namespace in\n" 2383 "} // namespace out", 2384 Style)); 2385 2386 // Only namespaces which have both consecutive opening and end get compacted 2387 EXPECT_EQ("namespace out {\n" 2388 "namespace in1 {\n" 2389 "} // namespace in1\n" 2390 "namespace in2 {\n" 2391 "} // namespace in2\n" 2392 "} // namespace out", 2393 format("namespace out {\n" 2394 "namespace in1 {\n" 2395 "} // namespace in1\n" 2396 "namespace in2 {\n" 2397 "} // namespace in2\n" 2398 "} // namespace out", 2399 Style)); 2400 2401 EXPECT_EQ("namespace out {\n" 2402 "int i;\n" 2403 "namespace in {\n" 2404 "int j;\n" 2405 "} // namespace in\n" 2406 "int k;\n" 2407 "} // namespace out", 2408 format("namespace out { int i;\n" 2409 "namespace in { int j; } // namespace in\n" 2410 "int k; } // namespace out", 2411 Style)); 2412 2413 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 2414 "}}} // namespace A::B::C\n", 2415 format("namespace A { namespace B {\n" 2416 "namespace C {\n" 2417 "}} // namespace B::C\n" 2418 "} // namespace A\n", 2419 Style)); 2420 2421 Style.ColumnLimit = 40; 2422 EXPECT_EQ("namespace aaaaaaaaaa {\n" 2423 "namespace bbbbbbbbbb {\n" 2424 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 2425 format("namespace aaaaaaaaaa {\n" 2426 "namespace bbbbbbbbbb {\n" 2427 "} // namespace bbbbbbbbbb\n" 2428 "} // namespace aaaaaaaaaa", 2429 Style)); 2430 2431 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 2432 "namespace cccccc {\n" 2433 "}}} // namespace aaaaaa::bbbbbb::cccccc", 2434 format("namespace aaaaaa {\n" 2435 "namespace bbbbbb {\n" 2436 "namespace cccccc {\n" 2437 "} // namespace cccccc\n" 2438 "} // namespace bbbbbb\n" 2439 "} // namespace aaaaaa", 2440 Style)); 2441 Style.ColumnLimit = 80; 2442 2443 // Extra semicolon after 'inner' closing brace prevents merging 2444 EXPECT_EQ("namespace out { namespace in {\n" 2445 "}; } // namespace out::in", 2446 format("namespace out {\n" 2447 "namespace in {\n" 2448 "}; // namespace in\n" 2449 "} // namespace out", 2450 Style)); 2451 2452 // Extra semicolon after 'outer' closing brace is conserved 2453 EXPECT_EQ("namespace out { namespace in {\n" 2454 "}}; // namespace out::in", 2455 format("namespace out {\n" 2456 "namespace in {\n" 2457 "} // namespace in\n" 2458 "}; // namespace out", 2459 Style)); 2460 2461 Style.NamespaceIndentation = FormatStyle::NI_All; 2462 EXPECT_EQ("namespace out { namespace in {\n" 2463 " int i;\n" 2464 "}} // namespace out::in", 2465 format("namespace out {\n" 2466 "namespace in {\n" 2467 "int i;\n" 2468 "} // namespace in\n" 2469 "} // namespace out", 2470 Style)); 2471 EXPECT_EQ("namespace out { namespace mid {\n" 2472 " namespace in {\n" 2473 " int j;\n" 2474 " } // namespace in\n" 2475 " int k;\n" 2476 "}} // namespace out::mid", 2477 format("namespace out { namespace mid {\n" 2478 "namespace in { int j; } // namespace in\n" 2479 "int k; }} // namespace out::mid", 2480 Style)); 2481 2482 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2483 EXPECT_EQ("namespace out { namespace in {\n" 2484 " int i;\n" 2485 "}} // namespace out::in", 2486 format("namespace out {\n" 2487 "namespace in {\n" 2488 "int i;\n" 2489 "} // namespace in\n" 2490 "} // namespace out", 2491 Style)); 2492 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 2493 " int i;\n" 2494 "}}} // namespace out::mid::in", 2495 format("namespace out {\n" 2496 "namespace mid {\n" 2497 "namespace in {\n" 2498 "int i;\n" 2499 "} // namespace in\n" 2500 "} // namespace mid\n" 2501 "} // namespace out", 2502 Style)); 2503 } 2504 2505 TEST_F(FormatTest, FormatsExternC) { 2506 verifyFormat("extern \"C\" {\nint a;"); 2507 verifyFormat("extern \"C\" {}"); 2508 verifyFormat("extern \"C\" {\n" 2509 "int foo();\n" 2510 "}"); 2511 verifyFormat("extern \"C\" int foo() {}"); 2512 verifyFormat("extern \"C\" int foo();"); 2513 verifyFormat("extern \"C\" int foo() {\n" 2514 " int i = 42;\n" 2515 " return i;\n" 2516 "}"); 2517 2518 FormatStyle Style = getLLVMStyle(); 2519 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2520 Style.BraceWrapping.AfterFunction = true; 2521 verifyFormat("extern \"C\" int foo() {}", Style); 2522 verifyFormat("extern \"C\" int foo();", Style); 2523 verifyFormat("extern \"C\" int foo()\n" 2524 "{\n" 2525 " int i = 42;\n" 2526 " return i;\n" 2527 "}", 2528 Style); 2529 2530 Style.BraceWrapping.AfterExternBlock = true; 2531 Style.BraceWrapping.SplitEmptyRecord = false; 2532 verifyFormat("extern \"C\"\n" 2533 "{}", 2534 Style); 2535 verifyFormat("extern \"C\"\n" 2536 "{\n" 2537 " int foo();\n" 2538 "}", 2539 Style); 2540 } 2541 2542 TEST_F(FormatTest, FormatsInlineASM) { 2543 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2544 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2545 verifyFormat( 2546 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2547 " \"cpuid\\n\\t\"\n" 2548 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2549 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2550 " : \"a\"(value));"); 2551 EXPECT_EQ( 2552 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2553 " __asm {\n" 2554 " mov edx,[that] // vtable in edx\n" 2555 " mov eax,methodIndex\n" 2556 " call [edx][eax*4] // stdcall\n" 2557 " }\n" 2558 "}", 2559 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2560 " __asm {\n" 2561 " mov edx,[that] // vtable in edx\n" 2562 " mov eax,methodIndex\n" 2563 " call [edx][eax*4] // stdcall\n" 2564 " }\n" 2565 "}")); 2566 EXPECT_EQ("_asm {\n" 2567 " xor eax, eax;\n" 2568 " cpuid;\n" 2569 "}", 2570 format("_asm {\n" 2571 " xor eax, eax;\n" 2572 " cpuid;\n" 2573 "}")); 2574 verifyFormat("void function() {\n" 2575 " // comment\n" 2576 " asm(\"\");\n" 2577 "}"); 2578 EXPECT_EQ("__asm {\n" 2579 "}\n" 2580 "int i;", 2581 format("__asm {\n" 2582 "}\n" 2583 "int i;")); 2584 } 2585 2586 TEST_F(FormatTest, FormatTryCatch) { 2587 verifyFormat("try {\n" 2588 " throw a * b;\n" 2589 "} catch (int a) {\n" 2590 " // Do nothing.\n" 2591 "} catch (...) {\n" 2592 " exit(42);\n" 2593 "}"); 2594 2595 // Function-level try statements. 2596 verifyFormat("int f() try { return 4; } catch (...) {\n" 2597 " return 5;\n" 2598 "}"); 2599 verifyFormat("class A {\n" 2600 " int a;\n" 2601 " A() try : a(0) {\n" 2602 " } catch (...) {\n" 2603 " throw;\n" 2604 " }\n" 2605 "};\n"); 2606 2607 // Incomplete try-catch blocks. 2608 verifyIncompleteFormat("try {} catch ("); 2609 } 2610 2611 TEST_F(FormatTest, FormatSEHTryCatch) { 2612 verifyFormat("__try {\n" 2613 " int a = b * c;\n" 2614 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2615 " // Do nothing.\n" 2616 "}"); 2617 2618 verifyFormat("__try {\n" 2619 " int a = b * c;\n" 2620 "} __finally {\n" 2621 " // Do nothing.\n" 2622 "}"); 2623 2624 verifyFormat("DEBUG({\n" 2625 " __try {\n" 2626 " } __finally {\n" 2627 " }\n" 2628 "});\n"); 2629 } 2630 2631 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2632 verifyFormat("try {\n" 2633 " f();\n" 2634 "} catch {\n" 2635 " g();\n" 2636 "}"); 2637 verifyFormat("try {\n" 2638 " f();\n" 2639 "} catch (A a) MACRO(x) {\n" 2640 " g();\n" 2641 "} catch (B b) MACRO(x) {\n" 2642 " g();\n" 2643 "}"); 2644 } 2645 2646 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2647 FormatStyle Style = getLLVMStyle(); 2648 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2649 FormatStyle::BS_WebKit}) { 2650 Style.BreakBeforeBraces = BraceStyle; 2651 verifyFormat("try {\n" 2652 " // something\n" 2653 "} catch (...) {\n" 2654 " // something\n" 2655 "}", 2656 Style); 2657 } 2658 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2659 verifyFormat("try {\n" 2660 " // something\n" 2661 "}\n" 2662 "catch (...) {\n" 2663 " // something\n" 2664 "}", 2665 Style); 2666 verifyFormat("__try {\n" 2667 " // something\n" 2668 "}\n" 2669 "__finally {\n" 2670 " // something\n" 2671 "}", 2672 Style); 2673 verifyFormat("@try {\n" 2674 " // something\n" 2675 "}\n" 2676 "@finally {\n" 2677 " // something\n" 2678 "}", 2679 Style); 2680 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2681 verifyFormat("try\n" 2682 "{\n" 2683 " // something\n" 2684 "}\n" 2685 "catch (...)\n" 2686 "{\n" 2687 " // something\n" 2688 "}", 2689 Style); 2690 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 2691 verifyFormat("try\n" 2692 " {\n" 2693 " // something white\n" 2694 " }\n" 2695 "catch (...)\n" 2696 " {\n" 2697 " // something white\n" 2698 " }", 2699 Style); 2700 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2701 verifyFormat("try\n" 2702 " {\n" 2703 " // something\n" 2704 " }\n" 2705 "catch (...)\n" 2706 " {\n" 2707 " // something\n" 2708 " }", 2709 Style); 2710 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2711 Style.BraceWrapping.BeforeCatch = true; 2712 verifyFormat("try {\n" 2713 " // something\n" 2714 "}\n" 2715 "catch (...) {\n" 2716 " // something\n" 2717 "}", 2718 Style); 2719 } 2720 2721 TEST_F(FormatTest, StaticInitializers) { 2722 verifyFormat("static SomeClass SC = {1, 'a'};"); 2723 2724 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2725 " 100000000, " 2726 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2727 2728 // Here, everything other than the "}" would fit on a line. 2729 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2730 " 10000000000000000000000000};"); 2731 EXPECT_EQ("S s = {a,\n" 2732 "\n" 2733 " b};", 2734 format("S s = {\n" 2735 " a,\n" 2736 "\n" 2737 " b\n" 2738 "};")); 2739 2740 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2741 // line. However, the formatting looks a bit off and this probably doesn't 2742 // happen often in practice. 2743 verifyFormat("static int Variable[1] = {\n" 2744 " {1000000000000000000000000000000000000}};", 2745 getLLVMStyleWithColumns(40)); 2746 } 2747 2748 TEST_F(FormatTest, DesignatedInitializers) { 2749 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2750 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2751 " .bbbbbbbbbb = 2,\n" 2752 " .cccccccccc = 3,\n" 2753 " .dddddddddd = 4,\n" 2754 " .eeeeeeeeee = 5};"); 2755 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2756 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2757 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2758 " .ccccccccccccccccccccccccccc = 3,\n" 2759 " .ddddddddddddddddddddddddddd = 4,\n" 2760 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2761 2762 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2763 2764 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2765 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2766 " [2] = bbbbbbbbbb,\n" 2767 " [3] = cccccccccc,\n" 2768 " [4] = dddddddddd,\n" 2769 " [5] = eeeeeeeeee};"); 2770 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2771 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2772 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2773 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2774 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2775 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2776 } 2777 2778 TEST_F(FormatTest, NestedStaticInitializers) { 2779 verifyFormat("static A x = {{{}}};\n"); 2780 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2781 " {init1, init2, init3, init4}}};", 2782 getLLVMStyleWithColumns(50)); 2783 2784 verifyFormat("somes Status::global_reps[3] = {\n" 2785 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2786 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2787 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2788 getLLVMStyleWithColumns(60)); 2789 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2790 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2791 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2792 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2793 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2794 " {rect.fRight - rect.fLeft, rect.fBottom - " 2795 "rect.fTop}};"); 2796 2797 verifyFormat( 2798 "SomeArrayOfSomeType a = {\n" 2799 " {{1, 2, 3},\n" 2800 " {1, 2, 3},\n" 2801 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2802 " 333333333333333333333333333333},\n" 2803 " {1, 2, 3},\n" 2804 " {1, 2, 3}}};"); 2805 verifyFormat( 2806 "SomeArrayOfSomeType a = {\n" 2807 " {{1, 2, 3}},\n" 2808 " {{1, 2, 3}},\n" 2809 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2810 " 333333333333333333333333333333}},\n" 2811 " {{1, 2, 3}},\n" 2812 " {{1, 2, 3}}};"); 2813 2814 verifyFormat("struct {\n" 2815 " unsigned bit;\n" 2816 " const char *const name;\n" 2817 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2818 " {kOsWin, \"Windows\"},\n" 2819 " {kOsLinux, \"Linux\"},\n" 2820 " {kOsCrOS, \"Chrome OS\"}};"); 2821 verifyFormat("struct {\n" 2822 " unsigned bit;\n" 2823 " const char *const name;\n" 2824 "} kBitsToOs[] = {\n" 2825 " {kOsMac, \"Mac\"},\n" 2826 " {kOsWin, \"Windows\"},\n" 2827 " {kOsLinux, \"Linux\"},\n" 2828 " {kOsCrOS, \"Chrome OS\"},\n" 2829 "};"); 2830 } 2831 2832 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2833 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2834 " \\\n" 2835 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2836 } 2837 2838 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2839 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2840 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2841 2842 // Do break defaulted and deleted functions. 2843 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2844 " default;", 2845 getLLVMStyleWithColumns(40)); 2846 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2847 " delete;", 2848 getLLVMStyleWithColumns(40)); 2849 } 2850 2851 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2852 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2853 getLLVMStyleWithColumns(40)); 2854 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2855 getLLVMStyleWithColumns(40)); 2856 EXPECT_EQ("#define Q \\\n" 2857 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2858 " \"aaaaaaaa.cpp\"", 2859 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2860 getLLVMStyleWithColumns(40))); 2861 } 2862 2863 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2864 EXPECT_EQ("# 123 \"A string literal\"", 2865 format(" # 123 \"A string literal\"")); 2866 } 2867 2868 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2869 EXPECT_EQ("#;", format("#;")); 2870 verifyFormat("#\n;\n;\n;"); 2871 } 2872 2873 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2874 EXPECT_EQ("#line 42 \"test\"\n", 2875 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2876 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2877 getLLVMStyleWithColumns(12))); 2878 } 2879 2880 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2881 EXPECT_EQ("#line 42 \"test\"", 2882 format("# \\\n line \\\n 42 \\\n \"test\"")); 2883 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2884 } 2885 2886 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2887 verifyFormat("#define A \\x20"); 2888 verifyFormat("#define A \\ x20"); 2889 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2890 verifyFormat("#define A ''"); 2891 verifyFormat("#define A ''qqq"); 2892 verifyFormat("#define A `qqq"); 2893 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2894 EXPECT_EQ("const char *c = STRINGIFY(\n" 2895 "\\na : b);", 2896 format("const char * c = STRINGIFY(\n" 2897 "\\na : b);")); 2898 2899 verifyFormat("a\r\\"); 2900 verifyFormat("a\v\\"); 2901 verifyFormat("a\f\\"); 2902 } 2903 2904 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2905 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2906 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2907 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2908 // FIXME: We never break before the macro name. 2909 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2910 2911 verifyFormat("#define A A\n#define A A"); 2912 verifyFormat("#define A(X) A\n#define A A"); 2913 2914 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2915 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2916 } 2917 2918 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2919 EXPECT_EQ("// somecomment\n" 2920 "#include \"a.h\"\n" 2921 "#define A( \\\n" 2922 " A, B)\n" 2923 "#include \"b.h\"\n" 2924 "// somecomment\n", 2925 format(" // somecomment\n" 2926 " #include \"a.h\"\n" 2927 "#define A(A,\\\n" 2928 " B)\n" 2929 " #include \"b.h\"\n" 2930 " // somecomment\n", 2931 getLLVMStyleWithColumns(13))); 2932 } 2933 2934 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2935 2936 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2937 EXPECT_EQ("#define A \\\n" 2938 " c; \\\n" 2939 " e;\n" 2940 "f;", 2941 format("#define A c; e;\n" 2942 "f;", 2943 getLLVMStyleWithColumns(14))); 2944 } 2945 2946 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2947 2948 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2949 EXPECT_EQ("int x,\n" 2950 "#define A\n" 2951 " y;", 2952 format("int x,\n#define A\ny;")); 2953 } 2954 2955 TEST_F(FormatTest, HashInMacroDefinition) { 2956 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2957 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2958 verifyFormat("#define A \\\n" 2959 " { \\\n" 2960 " f(#c); \\\n" 2961 " }", 2962 getLLVMStyleWithColumns(11)); 2963 2964 verifyFormat("#define A(X) \\\n" 2965 " void function##X()", 2966 getLLVMStyleWithColumns(22)); 2967 2968 verifyFormat("#define A(a, b, c) \\\n" 2969 " void a##b##c()", 2970 getLLVMStyleWithColumns(22)); 2971 2972 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2973 } 2974 2975 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2976 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2977 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2978 2979 FormatStyle Style = getLLVMStyle(); 2980 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 2981 verifyFormat("#define true ((foo)1)", Style); 2982 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 2983 verifyFormat("#define false((foo)0)", Style); 2984 } 2985 2986 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2987 EXPECT_EQ("#define A b;", format("#define A \\\n" 2988 " \\\n" 2989 " b;", 2990 getLLVMStyleWithColumns(25))); 2991 EXPECT_EQ("#define A \\\n" 2992 " \\\n" 2993 " a; \\\n" 2994 " b;", 2995 format("#define A \\\n" 2996 " \\\n" 2997 " a; \\\n" 2998 " b;", 2999 getLLVMStyleWithColumns(11))); 3000 EXPECT_EQ("#define A \\\n" 3001 " a; \\\n" 3002 " \\\n" 3003 " b;", 3004 format("#define A \\\n" 3005 " a; \\\n" 3006 " \\\n" 3007 " b;", 3008 getLLVMStyleWithColumns(11))); 3009 } 3010 3011 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 3012 verifyIncompleteFormat("#define A :"); 3013 verifyFormat("#define SOMECASES \\\n" 3014 " case 1: \\\n" 3015 " case 2\n", 3016 getLLVMStyleWithColumns(20)); 3017 verifyFormat("#define MACRO(a) \\\n" 3018 " if (a) \\\n" 3019 " f(); \\\n" 3020 " else \\\n" 3021 " g()", 3022 getLLVMStyleWithColumns(18)); 3023 verifyFormat("#define A template <typename T>"); 3024 verifyIncompleteFormat("#define STR(x) #x\n" 3025 "f(STR(this_is_a_string_literal{));"); 3026 verifyFormat("#pragma omp threadprivate( \\\n" 3027 " y)), // expected-warning", 3028 getLLVMStyleWithColumns(28)); 3029 verifyFormat("#d, = };"); 3030 verifyFormat("#if \"a"); 3031 verifyIncompleteFormat("({\n" 3032 "#define b \\\n" 3033 " } \\\n" 3034 " a\n" 3035 "a", 3036 getLLVMStyleWithColumns(15)); 3037 verifyFormat("#define A \\\n" 3038 " { \\\n" 3039 " {\n" 3040 "#define B \\\n" 3041 " } \\\n" 3042 " }", 3043 getLLVMStyleWithColumns(15)); 3044 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 3045 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 3046 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 3047 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 3048 } 3049 3050 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 3051 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 3052 EXPECT_EQ("class A : public QObject {\n" 3053 " Q_OBJECT\n" 3054 "\n" 3055 " A() {}\n" 3056 "};", 3057 format("class A : public QObject {\n" 3058 " Q_OBJECT\n" 3059 "\n" 3060 " A() {\n}\n" 3061 "} ;")); 3062 EXPECT_EQ("MACRO\n" 3063 "/*static*/ int i;", 3064 format("MACRO\n" 3065 " /*static*/ int i;")); 3066 EXPECT_EQ("SOME_MACRO\n" 3067 "namespace {\n" 3068 "void f();\n" 3069 "} // namespace", 3070 format("SOME_MACRO\n" 3071 " namespace {\n" 3072 "void f( );\n" 3073 "} // namespace")); 3074 // Only if the identifier contains at least 5 characters. 3075 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 3076 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 3077 // Only if everything is upper case. 3078 EXPECT_EQ("class A : public QObject {\n" 3079 " Q_Object A() {}\n" 3080 "};", 3081 format("class A : public QObject {\n" 3082 " Q_Object\n" 3083 " A() {\n}\n" 3084 "} ;")); 3085 3086 // Only if the next line can actually start an unwrapped line. 3087 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 3088 format("SOME_WEIRD_LOG_MACRO\n" 3089 "<< SomeThing;")); 3090 3091 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 3092 "(n, buffers))\n", 3093 getChromiumStyle(FormatStyle::LK_Cpp)); 3094 3095 // See PR41483 3096 EXPECT_EQ("/**/ FOO(a)\n" 3097 "FOO(b)", 3098 format("/**/ FOO(a)\n" 3099 "FOO(b)")); 3100 } 3101 3102 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 3103 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 3104 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 3105 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 3106 "class X {};\n" 3107 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 3108 "int *createScopDetectionPass() { return 0; }", 3109 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 3110 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 3111 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 3112 " class X {};\n" 3113 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 3114 " int *createScopDetectionPass() { return 0; }")); 3115 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 3116 // braces, so that inner block is indented one level more. 3117 EXPECT_EQ("int q() {\n" 3118 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 3119 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 3120 " IPC_END_MESSAGE_MAP()\n" 3121 "}", 3122 format("int q() {\n" 3123 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 3124 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 3125 " IPC_END_MESSAGE_MAP()\n" 3126 "}")); 3127 3128 // Same inside macros. 3129 EXPECT_EQ("#define LIST(L) \\\n" 3130 " L(A) \\\n" 3131 " L(B) \\\n" 3132 " L(C)", 3133 format("#define LIST(L) \\\n" 3134 " L(A) \\\n" 3135 " L(B) \\\n" 3136 " L(C)", 3137 getGoogleStyle())); 3138 3139 // These must not be recognized as macros. 3140 EXPECT_EQ("int q() {\n" 3141 " f(x);\n" 3142 " f(x) {}\n" 3143 " f(x)->g();\n" 3144 " f(x)->*g();\n" 3145 " f(x).g();\n" 3146 " f(x) = x;\n" 3147 " f(x) += x;\n" 3148 " f(x) -= x;\n" 3149 " f(x) *= x;\n" 3150 " f(x) /= x;\n" 3151 " f(x) %= x;\n" 3152 " f(x) &= x;\n" 3153 " f(x) |= x;\n" 3154 " f(x) ^= x;\n" 3155 " f(x) >>= x;\n" 3156 " f(x) <<= x;\n" 3157 " f(x)[y].z();\n" 3158 " LOG(INFO) << x;\n" 3159 " ifstream(x) >> x;\n" 3160 "}\n", 3161 format("int q() {\n" 3162 " f(x)\n;\n" 3163 " f(x)\n {}\n" 3164 " f(x)\n->g();\n" 3165 " f(x)\n->*g();\n" 3166 " f(x)\n.g();\n" 3167 " f(x)\n = x;\n" 3168 " f(x)\n += x;\n" 3169 " f(x)\n -= x;\n" 3170 " f(x)\n *= x;\n" 3171 " f(x)\n /= x;\n" 3172 " f(x)\n %= x;\n" 3173 " f(x)\n &= x;\n" 3174 " f(x)\n |= x;\n" 3175 " f(x)\n ^= x;\n" 3176 " f(x)\n >>= x;\n" 3177 " f(x)\n <<= x;\n" 3178 " f(x)\n[y].z();\n" 3179 " LOG(INFO)\n << x;\n" 3180 " ifstream(x)\n >> x;\n" 3181 "}\n")); 3182 EXPECT_EQ("int q() {\n" 3183 " F(x)\n" 3184 " if (1) {\n" 3185 " }\n" 3186 " F(x)\n" 3187 " while (1) {\n" 3188 " }\n" 3189 " F(x)\n" 3190 " G(x);\n" 3191 " F(x)\n" 3192 " try {\n" 3193 " Q();\n" 3194 " } catch (...) {\n" 3195 " }\n" 3196 "}\n", 3197 format("int q() {\n" 3198 "F(x)\n" 3199 "if (1) {}\n" 3200 "F(x)\n" 3201 "while (1) {}\n" 3202 "F(x)\n" 3203 "G(x);\n" 3204 "F(x)\n" 3205 "try { Q(); } catch (...) {}\n" 3206 "}\n")); 3207 EXPECT_EQ("class A {\n" 3208 " A() : t(0) {}\n" 3209 " A(int i) noexcept() : {}\n" 3210 " A(X x)\n" // FIXME: function-level try blocks are broken. 3211 " try : t(0) {\n" 3212 " } catch (...) {\n" 3213 " }\n" 3214 "};", 3215 format("class A {\n" 3216 " A()\n : t(0) {}\n" 3217 " A(int i)\n noexcept() : {}\n" 3218 " A(X x)\n" 3219 " try : t(0) {} catch (...) {}\n" 3220 "};")); 3221 FormatStyle Style = getLLVMStyle(); 3222 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 3223 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 3224 Style.BraceWrapping.AfterFunction = true; 3225 EXPECT_EQ("void f()\n" 3226 "try\n" 3227 "{\n" 3228 "}", 3229 format("void f() try {\n" 3230 "}", 3231 Style)); 3232 EXPECT_EQ("class SomeClass {\n" 3233 "public:\n" 3234 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3235 "};", 3236 format("class SomeClass {\n" 3237 "public:\n" 3238 " SomeClass()\n" 3239 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3240 "};")); 3241 EXPECT_EQ("class SomeClass {\n" 3242 "public:\n" 3243 " SomeClass()\n" 3244 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3245 "};", 3246 format("class SomeClass {\n" 3247 "public:\n" 3248 " SomeClass()\n" 3249 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3250 "};", 3251 getLLVMStyleWithColumns(40))); 3252 3253 verifyFormat("MACRO(>)"); 3254 3255 // Some macros contain an implicit semicolon. 3256 Style = getLLVMStyle(); 3257 Style.StatementMacros.push_back("FOO"); 3258 verifyFormat("FOO(a) int b = 0;"); 3259 verifyFormat("FOO(a)\n" 3260 "int b = 0;", 3261 Style); 3262 verifyFormat("FOO(a);\n" 3263 "int b = 0;", 3264 Style); 3265 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 3266 "int b = 0;", 3267 Style); 3268 verifyFormat("FOO()\n" 3269 "int b = 0;", 3270 Style); 3271 verifyFormat("FOO\n" 3272 "int b = 0;", 3273 Style); 3274 verifyFormat("void f() {\n" 3275 " FOO(a)\n" 3276 " return a;\n" 3277 "}", 3278 Style); 3279 verifyFormat("FOO(a)\n" 3280 "FOO(b)", 3281 Style); 3282 verifyFormat("int a = 0;\n" 3283 "FOO(b)\n" 3284 "int c = 0;", 3285 Style); 3286 verifyFormat("int a = 0;\n" 3287 "int x = FOO(a)\n" 3288 "int b = 0;", 3289 Style); 3290 verifyFormat("void foo(int a) { FOO(a) }\n" 3291 "uint32_t bar() {}", 3292 Style); 3293 } 3294 3295 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 3296 verifyFormat("#define A \\\n" 3297 " f({ \\\n" 3298 " g(); \\\n" 3299 " });", 3300 getLLVMStyleWithColumns(11)); 3301 } 3302 3303 TEST_F(FormatTest, IndentPreprocessorDirectives) { 3304 FormatStyle Style = getLLVMStyle(); 3305 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 3306 Style.ColumnLimit = 40; 3307 verifyFormat("#ifdef _WIN32\n" 3308 "#define A 0\n" 3309 "#ifdef VAR2\n" 3310 "#define B 1\n" 3311 "#include <someheader.h>\n" 3312 "#define MACRO \\\n" 3313 " some_very_long_func_aaaaaaaaaa();\n" 3314 "#endif\n" 3315 "#else\n" 3316 "#define A 1\n" 3317 "#endif", 3318 Style); 3319 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 3320 verifyFormat("#ifdef _WIN32\n" 3321 "# define A 0\n" 3322 "# ifdef VAR2\n" 3323 "# define B 1\n" 3324 "# include <someheader.h>\n" 3325 "# define MACRO \\\n" 3326 " some_very_long_func_aaaaaaaaaa();\n" 3327 "# endif\n" 3328 "#else\n" 3329 "# define A 1\n" 3330 "#endif", 3331 Style); 3332 verifyFormat("#if A\n" 3333 "# define MACRO \\\n" 3334 " void a(int x) { \\\n" 3335 " b(); \\\n" 3336 " c(); \\\n" 3337 " d(); \\\n" 3338 " e(); \\\n" 3339 " f(); \\\n" 3340 " }\n" 3341 "#endif", 3342 Style); 3343 // Comments before include guard. 3344 verifyFormat("// file comment\n" 3345 "// file comment\n" 3346 "#ifndef HEADER_H\n" 3347 "#define HEADER_H\n" 3348 "code();\n" 3349 "#endif", 3350 Style); 3351 // Test with include guards. 3352 verifyFormat("#ifndef HEADER_H\n" 3353 "#define HEADER_H\n" 3354 "code();\n" 3355 "#endif", 3356 Style); 3357 // Include guards must have a #define with the same variable immediately 3358 // after #ifndef. 3359 verifyFormat("#ifndef NOT_GUARD\n" 3360 "# define FOO\n" 3361 "code();\n" 3362 "#endif", 3363 Style); 3364 3365 // Include guards must cover the entire file. 3366 verifyFormat("code();\n" 3367 "code();\n" 3368 "#ifndef NOT_GUARD\n" 3369 "# define NOT_GUARD\n" 3370 "code();\n" 3371 "#endif", 3372 Style); 3373 verifyFormat("#ifndef NOT_GUARD\n" 3374 "# define NOT_GUARD\n" 3375 "code();\n" 3376 "#endif\n" 3377 "code();", 3378 Style); 3379 // Test with trailing blank lines. 3380 verifyFormat("#ifndef HEADER_H\n" 3381 "#define HEADER_H\n" 3382 "code();\n" 3383 "#endif\n", 3384 Style); 3385 // Include guards don't have #else. 3386 verifyFormat("#ifndef NOT_GUARD\n" 3387 "# define NOT_GUARD\n" 3388 "code();\n" 3389 "#else\n" 3390 "#endif", 3391 Style); 3392 verifyFormat("#ifndef NOT_GUARD\n" 3393 "# define NOT_GUARD\n" 3394 "code();\n" 3395 "#elif FOO\n" 3396 "#endif", 3397 Style); 3398 // Non-identifier #define after potential include guard. 3399 verifyFormat("#ifndef FOO\n" 3400 "# define 1\n" 3401 "#endif\n", 3402 Style); 3403 // #if closes past last non-preprocessor line. 3404 verifyFormat("#ifndef FOO\n" 3405 "#define FOO\n" 3406 "#if 1\n" 3407 "int i;\n" 3408 "# define A 0\n" 3409 "#endif\n" 3410 "#endif\n", 3411 Style); 3412 // Don't crash if there is an #elif directive without a condition. 3413 verifyFormat("#if 1\n" 3414 "int x;\n" 3415 "#elif\n" 3416 "int y;\n" 3417 "#else\n" 3418 "int z;\n" 3419 "#endif", 3420 Style); 3421 // FIXME: This doesn't handle the case where there's code between the 3422 // #ifndef and #define but all other conditions hold. This is because when 3423 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 3424 // previous code line yet, so we can't detect it. 3425 EXPECT_EQ("#ifndef NOT_GUARD\n" 3426 "code();\n" 3427 "#define NOT_GUARD\n" 3428 "code();\n" 3429 "#endif", 3430 format("#ifndef NOT_GUARD\n" 3431 "code();\n" 3432 "# define NOT_GUARD\n" 3433 "code();\n" 3434 "#endif", 3435 Style)); 3436 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 3437 // be outside an include guard. Examples are #pragma once and 3438 // #pragma GCC diagnostic, or anything else that does not change the meaning 3439 // of the file if it's included multiple times. 3440 EXPECT_EQ("#ifdef WIN32\n" 3441 "# pragma once\n" 3442 "#endif\n" 3443 "#ifndef HEADER_H\n" 3444 "# define HEADER_H\n" 3445 "code();\n" 3446 "#endif", 3447 format("#ifdef WIN32\n" 3448 "# pragma once\n" 3449 "#endif\n" 3450 "#ifndef HEADER_H\n" 3451 "#define HEADER_H\n" 3452 "code();\n" 3453 "#endif", 3454 Style)); 3455 // FIXME: This does not detect when there is a single non-preprocessor line 3456 // in front of an include-guard-like structure where other conditions hold 3457 // because ScopedLineState hides the line. 3458 EXPECT_EQ("code();\n" 3459 "#ifndef HEADER_H\n" 3460 "#define HEADER_H\n" 3461 "code();\n" 3462 "#endif", 3463 format("code();\n" 3464 "#ifndef HEADER_H\n" 3465 "# define HEADER_H\n" 3466 "code();\n" 3467 "#endif", 3468 Style)); 3469 // Keep comments aligned with #, otherwise indent comments normally. These 3470 // tests cannot use verifyFormat because messUp manipulates leading 3471 // whitespace. 3472 { 3473 const char *Expected = "" 3474 "void f() {\n" 3475 "#if 1\n" 3476 "// Preprocessor aligned.\n" 3477 "# define A 0\n" 3478 " // Code. Separated by blank line.\n" 3479 "\n" 3480 "# define B 0\n" 3481 " // Code. Not aligned with #\n" 3482 "# define C 0\n" 3483 "#endif"; 3484 const char *ToFormat = "" 3485 "void f() {\n" 3486 "#if 1\n" 3487 "// Preprocessor aligned.\n" 3488 "# define A 0\n" 3489 "// Code. Separated by blank line.\n" 3490 "\n" 3491 "# define B 0\n" 3492 " // Code. Not aligned with #\n" 3493 "# define C 0\n" 3494 "#endif"; 3495 EXPECT_EQ(Expected, format(ToFormat, Style)); 3496 EXPECT_EQ(Expected, format(Expected, Style)); 3497 } 3498 // Keep block quotes aligned. 3499 { 3500 const char *Expected = "" 3501 "void f() {\n" 3502 "#if 1\n" 3503 "/* Preprocessor aligned. */\n" 3504 "# define A 0\n" 3505 " /* Code. Separated by blank line. */\n" 3506 "\n" 3507 "# define B 0\n" 3508 " /* Code. Not aligned with # */\n" 3509 "# define C 0\n" 3510 "#endif"; 3511 const char *ToFormat = "" 3512 "void f() {\n" 3513 "#if 1\n" 3514 "/* Preprocessor aligned. */\n" 3515 "# define A 0\n" 3516 "/* Code. Separated by blank line. */\n" 3517 "\n" 3518 "# define B 0\n" 3519 " /* Code. Not aligned with # */\n" 3520 "# define C 0\n" 3521 "#endif"; 3522 EXPECT_EQ(Expected, format(ToFormat, Style)); 3523 EXPECT_EQ(Expected, format(Expected, Style)); 3524 } 3525 // Keep comments aligned with un-indented directives. 3526 { 3527 const char *Expected = "" 3528 "void f() {\n" 3529 "// Preprocessor aligned.\n" 3530 "#define A 0\n" 3531 " // Code. Separated by blank line.\n" 3532 "\n" 3533 "#define B 0\n" 3534 " // Code. Not aligned with #\n" 3535 "#define C 0\n"; 3536 const char *ToFormat = "" 3537 "void f() {\n" 3538 "// Preprocessor aligned.\n" 3539 "#define A 0\n" 3540 "// Code. Separated by blank line.\n" 3541 "\n" 3542 "#define B 0\n" 3543 " // Code. Not aligned with #\n" 3544 "#define C 0\n"; 3545 EXPECT_EQ(Expected, format(ToFormat, Style)); 3546 EXPECT_EQ(Expected, format(Expected, Style)); 3547 } 3548 // Test AfterHash with tabs. 3549 { 3550 FormatStyle Tabbed = Style; 3551 Tabbed.UseTab = FormatStyle::UT_Always; 3552 Tabbed.IndentWidth = 8; 3553 Tabbed.TabWidth = 8; 3554 verifyFormat("#ifdef _WIN32\n" 3555 "#\tdefine A 0\n" 3556 "#\tifdef VAR2\n" 3557 "#\t\tdefine B 1\n" 3558 "#\t\tinclude <someheader.h>\n" 3559 "#\t\tdefine MACRO \\\n" 3560 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3561 "#\tendif\n" 3562 "#else\n" 3563 "#\tdefine A 1\n" 3564 "#endif", 3565 Tabbed); 3566 } 3567 3568 // Regression test: Multiline-macro inside include guards. 3569 verifyFormat("#ifndef HEADER_H\n" 3570 "#define HEADER_H\n" 3571 "#define A() \\\n" 3572 " int i; \\\n" 3573 " int j;\n" 3574 "#endif // HEADER_H", 3575 getLLVMStyleWithColumns(20)); 3576 3577 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3578 // Basic before hash indent tests 3579 verifyFormat("#ifdef _WIN32\n" 3580 " #define A 0\n" 3581 " #ifdef VAR2\n" 3582 " #define B 1\n" 3583 " #include <someheader.h>\n" 3584 " #define MACRO \\\n" 3585 " some_very_long_func_aaaaaaaaaa();\n" 3586 " #endif\n" 3587 "#else\n" 3588 " #define A 1\n" 3589 "#endif", 3590 Style); 3591 verifyFormat("#if A\n" 3592 " #define MACRO \\\n" 3593 " void a(int x) { \\\n" 3594 " b(); \\\n" 3595 " c(); \\\n" 3596 " d(); \\\n" 3597 " e(); \\\n" 3598 " f(); \\\n" 3599 " }\n" 3600 "#endif", 3601 Style); 3602 // Keep comments aligned with indented directives. These 3603 // tests cannot use verifyFormat because messUp manipulates leading 3604 // whitespace. 3605 { 3606 const char *Expected = "void f() {\n" 3607 "// Aligned to preprocessor.\n" 3608 "#if 1\n" 3609 " // Aligned to code.\n" 3610 " int a;\n" 3611 " #if 1\n" 3612 " // Aligned to preprocessor.\n" 3613 " #define A 0\n" 3614 " // Aligned to code.\n" 3615 " int b;\n" 3616 " #endif\n" 3617 "#endif\n" 3618 "}"; 3619 const char *ToFormat = "void f() {\n" 3620 "// Aligned to preprocessor.\n" 3621 "#if 1\n" 3622 "// Aligned to code.\n" 3623 "int a;\n" 3624 "#if 1\n" 3625 "// Aligned to preprocessor.\n" 3626 "#define A 0\n" 3627 "// Aligned to code.\n" 3628 "int b;\n" 3629 "#endif\n" 3630 "#endif\n" 3631 "}"; 3632 EXPECT_EQ(Expected, format(ToFormat, Style)); 3633 EXPECT_EQ(Expected, format(Expected, Style)); 3634 } 3635 { 3636 const char *Expected = "void f() {\n" 3637 "/* Aligned to preprocessor. */\n" 3638 "#if 1\n" 3639 " /* Aligned to code. */\n" 3640 " int a;\n" 3641 " #if 1\n" 3642 " /* Aligned to preprocessor. */\n" 3643 " #define A 0\n" 3644 " /* Aligned to code. */\n" 3645 " int b;\n" 3646 " #endif\n" 3647 "#endif\n" 3648 "}"; 3649 const char *ToFormat = "void f() {\n" 3650 "/* Aligned to preprocessor. */\n" 3651 "#if 1\n" 3652 "/* Aligned to code. */\n" 3653 "int a;\n" 3654 "#if 1\n" 3655 "/* Aligned to preprocessor. */\n" 3656 "#define A 0\n" 3657 "/* Aligned to code. */\n" 3658 "int b;\n" 3659 "#endif\n" 3660 "#endif\n" 3661 "}"; 3662 EXPECT_EQ(Expected, format(ToFormat, Style)); 3663 EXPECT_EQ(Expected, format(Expected, Style)); 3664 } 3665 3666 // Test single comment before preprocessor 3667 verifyFormat("// Comment\n" 3668 "\n" 3669 "#if 1\n" 3670 "#endif", 3671 Style); 3672 } 3673 3674 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3675 verifyFormat("{\n { a #c; }\n}"); 3676 } 3677 3678 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3679 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3680 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3681 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3682 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3683 } 3684 3685 TEST_F(FormatTest, EscapedNewlines) { 3686 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3687 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3688 format("#define A \\\nint i;\\\n int j;", Narrow)); 3689 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3690 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3691 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3692 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3693 3694 FormatStyle AlignLeft = getLLVMStyle(); 3695 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3696 EXPECT_EQ("#define MACRO(x) \\\n" 3697 "private: \\\n" 3698 " int x(int a);\n", 3699 format("#define MACRO(x) \\\n" 3700 "private: \\\n" 3701 " int x(int a);\n", 3702 AlignLeft)); 3703 3704 // CRLF line endings 3705 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3706 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3707 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3708 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3709 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3710 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3711 EXPECT_EQ("#define MACRO(x) \\\r\n" 3712 "private: \\\r\n" 3713 " int x(int a);\r\n", 3714 format("#define MACRO(x) \\\r\n" 3715 "private: \\\r\n" 3716 " int x(int a);\r\n", 3717 AlignLeft)); 3718 3719 FormatStyle DontAlign = getLLVMStyle(); 3720 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3721 DontAlign.MaxEmptyLinesToKeep = 3; 3722 // FIXME: can't use verifyFormat here because the newline before 3723 // "public:" is not inserted the first time it's reformatted 3724 EXPECT_EQ("#define A \\\n" 3725 " class Foo { \\\n" 3726 " void bar(); \\\n" 3727 "\\\n" 3728 "\\\n" 3729 "\\\n" 3730 " public: \\\n" 3731 " void baz(); \\\n" 3732 " };", 3733 format("#define A \\\n" 3734 " class Foo { \\\n" 3735 " void bar(); \\\n" 3736 "\\\n" 3737 "\\\n" 3738 "\\\n" 3739 " public: \\\n" 3740 " void baz(); \\\n" 3741 " };", 3742 DontAlign)); 3743 } 3744 3745 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3746 verifyFormat("#define A \\\n" 3747 " int v( \\\n" 3748 " a); \\\n" 3749 " int i;", 3750 getLLVMStyleWithColumns(11)); 3751 } 3752 3753 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3754 EXPECT_EQ( 3755 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3756 " \\\n" 3757 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3758 "\n" 3759 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3760 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3761 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3762 "\\\n" 3763 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3764 " \n" 3765 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3766 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3767 } 3768 3769 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3770 EXPECT_EQ("int\n" 3771 "#define A\n" 3772 " a;", 3773 format("int\n#define A\na;")); 3774 verifyFormat("functionCallTo(\n" 3775 " someOtherFunction(\n" 3776 " withSomeParameters, whichInSequence,\n" 3777 " areLongerThanALine(andAnotherCall,\n" 3778 "#define A B\n" 3779 " withMoreParamters,\n" 3780 " whichStronglyInfluenceTheLayout),\n" 3781 " andMoreParameters),\n" 3782 " trailing);", 3783 getLLVMStyleWithColumns(69)); 3784 verifyFormat("Foo::Foo()\n" 3785 "#ifdef BAR\n" 3786 " : baz(0)\n" 3787 "#endif\n" 3788 "{\n" 3789 "}"); 3790 verifyFormat("void f() {\n" 3791 " if (true)\n" 3792 "#ifdef A\n" 3793 " f(42);\n" 3794 " x();\n" 3795 "#else\n" 3796 " g();\n" 3797 " x();\n" 3798 "#endif\n" 3799 "}"); 3800 verifyFormat("void f(param1, param2,\n" 3801 " param3,\n" 3802 "#ifdef A\n" 3803 " param4(param5,\n" 3804 "#ifdef A1\n" 3805 " param6,\n" 3806 "#ifdef A2\n" 3807 " param7),\n" 3808 "#else\n" 3809 " param8),\n" 3810 " param9,\n" 3811 "#endif\n" 3812 " param10,\n" 3813 "#endif\n" 3814 " param11)\n" 3815 "#else\n" 3816 " param12)\n" 3817 "#endif\n" 3818 "{\n" 3819 " x();\n" 3820 "}", 3821 getLLVMStyleWithColumns(28)); 3822 verifyFormat("#if 1\n" 3823 "int i;"); 3824 verifyFormat("#if 1\n" 3825 "#endif\n" 3826 "#if 1\n" 3827 "#else\n" 3828 "#endif\n"); 3829 verifyFormat("DEBUG({\n" 3830 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3831 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3832 "});\n" 3833 "#if a\n" 3834 "#else\n" 3835 "#endif"); 3836 3837 verifyIncompleteFormat("void f(\n" 3838 "#if A\n" 3839 ");\n" 3840 "#else\n" 3841 "#endif"); 3842 } 3843 3844 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3845 verifyFormat("#endif\n" 3846 "#if B"); 3847 } 3848 3849 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3850 FormatStyle SingleLine = getLLVMStyle(); 3851 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3852 verifyFormat("#if 0\n" 3853 "#elif 1\n" 3854 "#endif\n" 3855 "void foo() {\n" 3856 " if (test) foo2();\n" 3857 "}", 3858 SingleLine); 3859 } 3860 3861 TEST_F(FormatTest, LayoutBlockInsideParens) { 3862 verifyFormat("functionCall({ int i; });"); 3863 verifyFormat("functionCall({\n" 3864 " int i;\n" 3865 " int j;\n" 3866 "});"); 3867 verifyFormat("functionCall(\n" 3868 " {\n" 3869 " int i;\n" 3870 " int j;\n" 3871 " },\n" 3872 " aaaa, bbbb, cccc);"); 3873 verifyFormat("functionA(functionB({\n" 3874 " int i;\n" 3875 " int j;\n" 3876 " }),\n" 3877 " aaaa, bbbb, cccc);"); 3878 verifyFormat("functionCall(\n" 3879 " {\n" 3880 " int i;\n" 3881 " int j;\n" 3882 " },\n" 3883 " aaaa, bbbb, // comment\n" 3884 " cccc);"); 3885 verifyFormat("functionA(functionB({\n" 3886 " int i;\n" 3887 " int j;\n" 3888 " }),\n" 3889 " aaaa, bbbb, // comment\n" 3890 " cccc);"); 3891 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3892 verifyFormat("functionCall(aaaa, bbbb, {\n" 3893 " int i;\n" 3894 " int j;\n" 3895 "});"); 3896 verifyFormat( 3897 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3898 " {\n" 3899 " int i; // break\n" 3900 " },\n" 3901 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3902 " ccccccccccccccccc));"); 3903 verifyFormat("DEBUG({\n" 3904 " if (a)\n" 3905 " f();\n" 3906 "});"); 3907 } 3908 3909 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3910 EXPECT_EQ("SOME_MACRO { int i; }\n" 3911 "int i;", 3912 format(" SOME_MACRO {int i;} int i;")); 3913 } 3914 3915 TEST_F(FormatTest, LayoutNestedBlocks) { 3916 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3917 " struct s {\n" 3918 " int i;\n" 3919 " };\n" 3920 " s kBitsToOs[] = {{10}};\n" 3921 " for (int i = 0; i < 10; ++i)\n" 3922 " return;\n" 3923 "}"); 3924 verifyFormat("call(parameter, {\n" 3925 " something();\n" 3926 " // Comment using all columns.\n" 3927 " somethingelse();\n" 3928 "});", 3929 getLLVMStyleWithColumns(40)); 3930 verifyFormat("DEBUG( //\n" 3931 " { f(); }, a);"); 3932 verifyFormat("DEBUG( //\n" 3933 " {\n" 3934 " f(); //\n" 3935 " },\n" 3936 " a);"); 3937 3938 EXPECT_EQ("call(parameter, {\n" 3939 " something();\n" 3940 " // Comment too\n" 3941 " // looooooooooong.\n" 3942 " somethingElse();\n" 3943 "});", 3944 format("call(parameter, {\n" 3945 " something();\n" 3946 " // Comment too looooooooooong.\n" 3947 " somethingElse();\n" 3948 "});", 3949 getLLVMStyleWithColumns(29))); 3950 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3951 EXPECT_EQ("DEBUG({ // comment\n" 3952 " int i;\n" 3953 "});", 3954 format("DEBUG({ // comment\n" 3955 "int i;\n" 3956 "});")); 3957 EXPECT_EQ("DEBUG({\n" 3958 " int i;\n" 3959 "\n" 3960 " // comment\n" 3961 " int j;\n" 3962 "});", 3963 format("DEBUG({\n" 3964 " int i;\n" 3965 "\n" 3966 " // comment\n" 3967 " int j;\n" 3968 "});")); 3969 3970 verifyFormat("DEBUG({\n" 3971 " if (a)\n" 3972 " return;\n" 3973 "});"); 3974 verifyGoogleFormat("DEBUG({\n" 3975 " if (a) return;\n" 3976 "});"); 3977 FormatStyle Style = getGoogleStyle(); 3978 Style.ColumnLimit = 45; 3979 verifyFormat("Debug(\n" 3980 " aaaaa,\n" 3981 " {\n" 3982 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 3983 " },\n" 3984 " a);", 3985 Style); 3986 3987 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 3988 3989 verifyNoCrash("^{v^{a}}"); 3990 } 3991 3992 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 3993 EXPECT_EQ("#define MACRO() \\\n" 3994 " Debug(aaa, /* force line break */ \\\n" 3995 " { \\\n" 3996 " int i; \\\n" 3997 " int j; \\\n" 3998 " })", 3999 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 4000 " { int i; int j; })", 4001 getGoogleStyle())); 4002 4003 EXPECT_EQ("#define A \\\n" 4004 " [] { \\\n" 4005 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 4006 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 4007 " }", 4008 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 4009 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 4010 getGoogleStyle())); 4011 } 4012 4013 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 4014 EXPECT_EQ("{}", format("{}")); 4015 verifyFormat("enum E {};"); 4016 verifyFormat("enum E {}"); 4017 FormatStyle Style = getLLVMStyle(); 4018 Style.SpaceInEmptyBlock = true; 4019 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 4020 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 4021 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 4022 } 4023 4024 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 4025 FormatStyle Style = getLLVMStyle(); 4026 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 4027 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 4028 verifyFormat("FOO_BEGIN\n" 4029 " FOO_ENTRY\n" 4030 "FOO_END", 4031 Style); 4032 verifyFormat("FOO_BEGIN\n" 4033 " NESTED_FOO_BEGIN\n" 4034 " NESTED_FOO_ENTRY\n" 4035 " NESTED_FOO_END\n" 4036 "FOO_END", 4037 Style); 4038 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 4039 " int x;\n" 4040 " x = 1;\n" 4041 "FOO_END(Baz)", 4042 Style); 4043 } 4044 4045 //===----------------------------------------------------------------------===// 4046 // Line break tests. 4047 //===----------------------------------------------------------------------===// 4048 4049 TEST_F(FormatTest, PreventConfusingIndents) { 4050 verifyFormat( 4051 "void f() {\n" 4052 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 4053 " parameter, parameter, parameter)),\n" 4054 " SecondLongCall(parameter));\n" 4055 "}"); 4056 verifyFormat( 4057 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4058 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4059 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4060 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 4061 verifyFormat( 4062 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4063 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 4064 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 4065 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 4066 verifyFormat( 4067 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 4068 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 4069 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 4070 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 4071 verifyFormat("int a = bbbb && ccc &&\n" 4072 " fffff(\n" 4073 "#define A Just forcing a new line\n" 4074 " ddd);"); 4075 } 4076 4077 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 4078 verifyFormat( 4079 "bool aaaaaaa =\n" 4080 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 4081 " bbbbbbbb();"); 4082 verifyFormat( 4083 "bool aaaaaaa =\n" 4084 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 4085 " bbbbbbbb();"); 4086 4087 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 4088 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 4089 " ccccccccc == ddddddddddd;"); 4090 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 4091 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 4092 " ccccccccc == ddddddddddd;"); 4093 verifyFormat( 4094 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 4095 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 4096 " ccccccccc == ddddddddddd;"); 4097 4098 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 4099 " aaaaaa) &&\n" 4100 " bbbbbb && cccccc;"); 4101 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 4102 " aaaaaa) >>\n" 4103 " bbbbbb;"); 4104 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 4105 " SourceMgr.getSpellingColumnNumber(\n" 4106 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 4107 " 1);"); 4108 4109 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4110 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 4111 " cccccc) {\n}"); 4112 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4113 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 4114 " cccccc) {\n}"); 4115 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4116 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 4117 " cccccc) {\n}"); 4118 verifyFormat("b = a &&\n" 4119 " // Comment\n" 4120 " b.c && d;"); 4121 4122 // If the LHS of a comparison is not a binary expression itself, the 4123 // additional linebreak confuses many people. 4124 verifyFormat( 4125 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4126 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 4127 "}"); 4128 verifyFormat( 4129 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4130 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4131 "}"); 4132 verifyFormat( 4133 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 4134 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4135 "}"); 4136 verifyFormat( 4137 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4138 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 4139 "}"); 4140 // Even explicit parentheses stress the precedence enough to make the 4141 // additional break unnecessary. 4142 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4143 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4144 "}"); 4145 // This cases is borderline, but with the indentation it is still readable. 4146 verifyFormat( 4147 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4148 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4149 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 4150 "}", 4151 getLLVMStyleWithColumns(75)); 4152 4153 // If the LHS is a binary expression, we should still use the additional break 4154 // as otherwise the formatting hides the operator precedence. 4155 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4156 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4157 " 5) {\n" 4158 "}"); 4159 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4160 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 4161 " 5) {\n" 4162 "}"); 4163 4164 FormatStyle OnePerLine = getLLVMStyle(); 4165 OnePerLine.BinPackParameters = false; 4166 verifyFormat( 4167 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4168 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4169 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 4170 OnePerLine); 4171 4172 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 4173 " .aaa(aaaaaaaaaaaaa) *\n" 4174 " aaaaaaa +\n" 4175 " aaaaaaa;", 4176 getLLVMStyleWithColumns(40)); 4177 } 4178 4179 TEST_F(FormatTest, ExpressionIndentation) { 4180 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4181 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4182 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4183 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4184 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 4185 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 4186 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4187 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 4188 " ccccccccccccccccccccccccccccccccccccccccc;"); 4189 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4190 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4191 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4192 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4193 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4194 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4195 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4196 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4197 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4198 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4199 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4200 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4201 verifyFormat("if () {\n" 4202 "} else if (aaaaa && bbbbb > // break\n" 4203 " ccccc) {\n" 4204 "}"); 4205 verifyFormat("if () {\n" 4206 "} else if constexpr (aaaaa && bbbbb > // break\n" 4207 " ccccc) {\n" 4208 "}"); 4209 verifyFormat("if () {\n" 4210 "} else if CONSTEXPR (aaaaa && bbbbb > // break\n" 4211 " ccccc) {\n" 4212 "}"); 4213 verifyFormat("if () {\n" 4214 "} else if (aaaaa &&\n" 4215 " bbbbb > // break\n" 4216 " ccccc &&\n" 4217 " ddddd) {\n" 4218 "}"); 4219 4220 // Presence of a trailing comment used to change indentation of b. 4221 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 4222 " b;\n" 4223 "return aaaaaaaaaaaaaaaaaaa +\n" 4224 " b; //", 4225 getLLVMStyleWithColumns(30)); 4226 } 4227 4228 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 4229 // Not sure what the best system is here. Like this, the LHS can be found 4230 // immediately above an operator (everything with the same or a higher 4231 // indent). The RHS is aligned right of the operator and so compasses 4232 // everything until something with the same indent as the operator is found. 4233 // FIXME: Is this a good system? 4234 FormatStyle Style = getLLVMStyle(); 4235 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 4236 verifyFormat( 4237 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4238 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4239 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4240 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4241 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4242 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4243 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4244 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4245 " > ccccccccccccccccccccccccccccccccccccccccc;", 4246 Style); 4247 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4248 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4249 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4250 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4251 Style); 4252 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4253 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4254 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4255 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4256 Style); 4257 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4258 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4259 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4260 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4261 Style); 4262 verifyFormat("if () {\n" 4263 "} else if (aaaaa\n" 4264 " && bbbbb // break\n" 4265 " > ccccc) {\n" 4266 "}", 4267 Style); 4268 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4269 " && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4270 Style); 4271 verifyFormat("return (a)\n" 4272 " // comment\n" 4273 " + b;", 4274 Style); 4275 verifyFormat( 4276 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4277 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4278 " + cc;", 4279 Style); 4280 4281 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4282 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4283 Style); 4284 4285 // Forced by comments. 4286 verifyFormat( 4287 "unsigned ContentSize =\n" 4288 " sizeof(int16_t) // DWARF ARange version number\n" 4289 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4290 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4291 " + sizeof(int8_t); // Segment Size (in bytes)"); 4292 4293 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 4294 " == boost::fusion::at_c<1>(iiii).second;", 4295 Style); 4296 4297 Style.ColumnLimit = 60; 4298 verifyFormat("zzzzzzzzzz\n" 4299 " = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4300 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 4301 Style); 4302 4303 Style.ColumnLimit = 80; 4304 Style.IndentWidth = 4; 4305 Style.TabWidth = 4; 4306 Style.UseTab = FormatStyle::UT_Always; 4307 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4308 Style.AlignOperands = FormatStyle::OAS_DontAlign; 4309 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 4310 "\t&& (someOtherLongishConditionPart1\n" 4311 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 4312 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && " 4313 "(someOtherLongishConditionPart1 || " 4314 "someOtherEvenLongerNestedConditionPart2);", 4315 Style)); 4316 } 4317 4318 TEST_F(FormatTest, ExpressionIndentationStrictAlign) { 4319 FormatStyle Style = getLLVMStyle(); 4320 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 4321 Style.AlignOperands = FormatStyle::OAS_AlignAfterOperator; 4322 4323 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4324 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4325 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4326 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4327 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4328 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4329 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4330 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4331 " > ccccccccccccccccccccccccccccccccccccccccc;", 4332 Style); 4333 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4334 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4335 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4336 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4337 Style); 4338 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4339 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4340 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4341 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4342 Style); 4343 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4344 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4345 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4346 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4347 Style); 4348 verifyFormat("if () {\n" 4349 "} else if (aaaaa\n" 4350 " && bbbbb // break\n" 4351 " > ccccc) {\n" 4352 "}", 4353 Style); 4354 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4355 " && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4356 Style); 4357 verifyFormat("return (a)\n" 4358 " // comment\n" 4359 " + b;", 4360 Style); 4361 verifyFormat( 4362 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4363 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4364 " + cc;", 4365 Style); 4366 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n" 4367 " : bbbbbbbbbbbbbbbb ? 2222222222222222\n" 4368 " : 3333333333333333;", 4369 Style); 4370 verifyFormat( 4371 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 4372 " : ccccccccccccccc ? dddddddddddddddddd\n" 4373 " : eeeeeeeeeeeeeeeeee)\n" 4374 " : bbbbbbbbbbbbbbbb ? 2222222222222222\n" 4375 " : 3333333333333333;", 4376 Style); 4377 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4378 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4379 Style); 4380 4381 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 4382 " == boost::fusion::at_c<1>(iiii).second;", 4383 Style); 4384 4385 Style.ColumnLimit = 60; 4386 verifyFormat("zzzzzzzzzzzzz\n" 4387 " = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4388 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 4389 Style); 4390 4391 // Forced by comments. 4392 Style.ColumnLimit = 80; 4393 verifyFormat( 4394 "unsigned ContentSize\n" 4395 " = sizeof(int16_t) // DWARF ARange version number\n" 4396 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4397 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4398 " + sizeof(int8_t); // Segment Size (in bytes)", 4399 Style); 4400 4401 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4402 verifyFormat( 4403 "unsigned ContentSize =\n" 4404 " sizeof(int16_t) // DWARF ARange version number\n" 4405 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4406 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4407 " + sizeof(int8_t); // Segment Size (in bytes)", 4408 Style); 4409 4410 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4411 verifyFormat( 4412 "unsigned ContentSize =\n" 4413 " sizeof(int16_t) // DWARF ARange version number\n" 4414 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4415 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4416 " + sizeof(int8_t); // Segment Size (in bytes)", 4417 Style); 4418 } 4419 4420 TEST_F(FormatTest, EnforcedOperatorWraps) { 4421 // Here we'd like to wrap after the || operators, but a comment is forcing an 4422 // earlier wrap. 4423 verifyFormat("bool x = aaaaa //\n" 4424 " || bbbbb\n" 4425 " //\n" 4426 " || cccc;"); 4427 } 4428 4429 TEST_F(FormatTest, NoOperandAlignment) { 4430 FormatStyle Style = getLLVMStyle(); 4431 Style.AlignOperands = FormatStyle::OAS_DontAlign; 4432 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 4433 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4434 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4435 Style); 4436 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4437 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4438 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4439 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4440 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4441 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4442 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4443 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4444 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4445 " > ccccccccccccccccccccccccccccccccccccccccc;", 4446 Style); 4447 4448 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4449 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4450 " + cc;", 4451 Style); 4452 verifyFormat("int a = aa\n" 4453 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4454 " * cccccccccccccccccccccccccccccccccccc;\n", 4455 Style); 4456 4457 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4458 verifyFormat("return (a > b\n" 4459 " // comment1\n" 4460 " // comment2\n" 4461 " || c);", 4462 Style); 4463 } 4464 4465 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 4466 FormatStyle Style = getLLVMStyle(); 4467 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4468 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4469 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4470 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4471 Style); 4472 } 4473 4474 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 4475 FormatStyle Style = getLLVMStyle(); 4476 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4477 Style.BinPackArguments = false; 4478 Style.ColumnLimit = 40; 4479 verifyFormat("void test() {\n" 4480 " someFunction(\n" 4481 " this + argument + is + quite\n" 4482 " + long + so + it + gets + wrapped\n" 4483 " + but + remains + bin - packed);\n" 4484 "}", 4485 Style); 4486 verifyFormat("void test() {\n" 4487 " someFunction(arg1,\n" 4488 " this + argument + is\n" 4489 " + quite + long + so\n" 4490 " + it + gets + wrapped\n" 4491 " + but + remains + bin\n" 4492 " - packed,\n" 4493 " arg3);\n" 4494 "}", 4495 Style); 4496 verifyFormat("void test() {\n" 4497 " someFunction(\n" 4498 " arg1,\n" 4499 " this + argument + has\n" 4500 " + anotherFunc(nested,\n" 4501 " calls + whose\n" 4502 " + arguments\n" 4503 " + are + also\n" 4504 " + wrapped,\n" 4505 " in + addition)\n" 4506 " + to + being + bin - packed,\n" 4507 " arg3);\n" 4508 "}", 4509 Style); 4510 4511 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4512 verifyFormat("void test() {\n" 4513 " someFunction(\n" 4514 " arg1,\n" 4515 " this + argument + has +\n" 4516 " anotherFunc(nested,\n" 4517 " calls + whose +\n" 4518 " arguments +\n" 4519 " are + also +\n" 4520 " wrapped,\n" 4521 " in + addition) +\n" 4522 " to + being + bin - packed,\n" 4523 " arg3);\n" 4524 "}", 4525 Style); 4526 } 4527 4528 TEST_F(FormatTest, ConstructorInitializers) { 4529 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4530 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 4531 getLLVMStyleWithColumns(45)); 4532 verifyFormat("Constructor()\n" 4533 " : Inttializer(FitsOnTheLine) {}", 4534 getLLVMStyleWithColumns(44)); 4535 verifyFormat("Constructor()\n" 4536 " : Inttializer(FitsOnTheLine) {}", 4537 getLLVMStyleWithColumns(43)); 4538 4539 verifyFormat("template <typename T>\n" 4540 "Constructor() : Initializer(FitsOnTheLine) {}", 4541 getLLVMStyleWithColumns(45)); 4542 4543 verifyFormat( 4544 "SomeClass::Constructor()\n" 4545 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4546 4547 verifyFormat( 4548 "SomeClass::Constructor()\n" 4549 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4550 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 4551 verifyFormat( 4552 "SomeClass::Constructor()\n" 4553 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4554 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4555 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4556 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4557 " : aaaaaaaaaa(aaaaaa) {}"); 4558 4559 verifyFormat("Constructor()\n" 4560 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4561 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4562 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4563 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 4564 4565 verifyFormat("Constructor()\n" 4566 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4567 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4568 4569 verifyFormat("Constructor(int Parameter = 0)\n" 4570 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4571 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 4572 verifyFormat("Constructor()\n" 4573 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4574 "}", 4575 getLLVMStyleWithColumns(60)); 4576 verifyFormat("Constructor()\n" 4577 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4578 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 4579 4580 // Here a line could be saved by splitting the second initializer onto two 4581 // lines, but that is not desirable. 4582 verifyFormat("Constructor()\n" 4583 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4584 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4585 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4586 4587 FormatStyle OnePerLine = getLLVMStyle(); 4588 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4589 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 4590 verifyFormat("SomeClass::Constructor()\n" 4591 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4592 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4593 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4594 OnePerLine); 4595 verifyFormat("SomeClass::Constructor()\n" 4596 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4597 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4598 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4599 OnePerLine); 4600 verifyFormat("MyClass::MyClass(int var)\n" 4601 " : some_var_(var), // 4 space indent\n" 4602 " some_other_var_(var + 1) { // lined up\n" 4603 "}", 4604 OnePerLine); 4605 verifyFormat("Constructor()\n" 4606 " : aaaaa(aaaaaa),\n" 4607 " aaaaa(aaaaaa),\n" 4608 " aaaaa(aaaaaa),\n" 4609 " aaaaa(aaaaaa),\n" 4610 " aaaaa(aaaaaa) {}", 4611 OnePerLine); 4612 verifyFormat("Constructor()\n" 4613 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4614 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4615 OnePerLine); 4616 OnePerLine.BinPackParameters = false; 4617 verifyFormat( 4618 "Constructor()\n" 4619 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4620 " aaaaaaaaaaa().aaa(),\n" 4621 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4622 OnePerLine); 4623 OnePerLine.ColumnLimit = 60; 4624 verifyFormat("Constructor()\n" 4625 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4626 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4627 OnePerLine); 4628 4629 EXPECT_EQ("Constructor()\n" 4630 " : // Comment forcing unwanted break.\n" 4631 " aaaa(aaaa) {}", 4632 format("Constructor() :\n" 4633 " // Comment forcing unwanted break.\n" 4634 " aaaa(aaaa) {}")); 4635 } 4636 4637 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 4638 FormatStyle Style = getLLVMStyle(); 4639 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4640 Style.ColumnLimit = 60; 4641 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4642 Style.AllowAllConstructorInitializersOnNextLine = true; 4643 Style.BinPackParameters = false; 4644 4645 for (int i = 0; i < 4; ++i) { 4646 // Test all combinations of parameters that should not have an effect. 4647 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4648 Style.AllowAllArgumentsOnNextLine = i & 2; 4649 4650 Style.AllowAllConstructorInitializersOnNextLine = true; 4651 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4652 verifyFormat("Constructor()\n" 4653 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4654 Style); 4655 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4656 4657 Style.AllowAllConstructorInitializersOnNextLine = false; 4658 verifyFormat("Constructor()\n" 4659 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4660 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4661 Style); 4662 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4663 4664 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4665 Style.AllowAllConstructorInitializersOnNextLine = true; 4666 verifyFormat("Constructor()\n" 4667 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4668 Style); 4669 4670 Style.AllowAllConstructorInitializersOnNextLine = false; 4671 verifyFormat("Constructor()\n" 4672 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4673 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4674 Style); 4675 4676 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4677 Style.AllowAllConstructorInitializersOnNextLine = true; 4678 verifyFormat("Constructor() :\n" 4679 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4680 Style); 4681 4682 Style.AllowAllConstructorInitializersOnNextLine = false; 4683 verifyFormat("Constructor() :\n" 4684 " aaaaaaaaaaaaaaaaaa(a),\n" 4685 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4686 Style); 4687 } 4688 4689 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4690 // AllowAllConstructorInitializersOnNextLine in all 4691 // BreakConstructorInitializers modes 4692 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4693 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4694 Style.AllowAllConstructorInitializersOnNextLine = false; 4695 verifyFormat("SomeClassWithALongName::Constructor(\n" 4696 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4697 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4698 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4699 Style); 4700 4701 Style.AllowAllConstructorInitializersOnNextLine = true; 4702 verifyFormat("SomeClassWithALongName::Constructor(\n" 4703 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4704 " int bbbbbbbbbbbbb,\n" 4705 " int cccccccccccccccc)\n" 4706 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4707 Style); 4708 4709 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4710 Style.AllowAllConstructorInitializersOnNextLine = false; 4711 verifyFormat("SomeClassWithALongName::Constructor(\n" 4712 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4713 " int bbbbbbbbbbbbb)\n" 4714 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4715 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4716 Style); 4717 4718 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4719 4720 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4721 verifyFormat("SomeClassWithALongName::Constructor(\n" 4722 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4723 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4724 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4725 Style); 4726 4727 Style.AllowAllConstructorInitializersOnNextLine = true; 4728 verifyFormat("SomeClassWithALongName::Constructor(\n" 4729 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4730 " int bbbbbbbbbbbbb,\n" 4731 " int cccccccccccccccc)\n" 4732 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4733 Style); 4734 4735 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4736 Style.AllowAllConstructorInitializersOnNextLine = false; 4737 verifyFormat("SomeClassWithALongName::Constructor(\n" 4738 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4739 " int bbbbbbbbbbbbb)\n" 4740 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4741 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4742 Style); 4743 4744 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4745 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4746 verifyFormat("SomeClassWithALongName::Constructor(\n" 4747 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4748 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4749 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4750 Style); 4751 4752 Style.AllowAllConstructorInitializersOnNextLine = true; 4753 verifyFormat("SomeClassWithALongName::Constructor(\n" 4754 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4755 " int bbbbbbbbbbbbb,\n" 4756 " int cccccccccccccccc) :\n" 4757 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4758 Style); 4759 4760 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4761 Style.AllowAllConstructorInitializersOnNextLine = false; 4762 verifyFormat("SomeClassWithALongName::Constructor(\n" 4763 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4764 " int bbbbbbbbbbbbb) :\n" 4765 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4766 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4767 Style); 4768 } 4769 4770 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4771 FormatStyle Style = getLLVMStyle(); 4772 Style.ColumnLimit = 60; 4773 Style.BinPackArguments = false; 4774 for (int i = 0; i < 4; ++i) { 4775 // Test all combinations of parameters that should not have an effect. 4776 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4777 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4778 4779 Style.AllowAllArgumentsOnNextLine = true; 4780 verifyFormat("void foo() {\n" 4781 " FunctionCallWithReallyLongName(\n" 4782 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4783 "}", 4784 Style); 4785 Style.AllowAllArgumentsOnNextLine = false; 4786 verifyFormat("void foo() {\n" 4787 " FunctionCallWithReallyLongName(\n" 4788 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4789 " bbbbbbbbbbbb);\n" 4790 "}", 4791 Style); 4792 4793 Style.AllowAllArgumentsOnNextLine = true; 4794 verifyFormat("void foo() {\n" 4795 " auto VariableWithReallyLongName = {\n" 4796 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4797 "}", 4798 Style); 4799 Style.AllowAllArgumentsOnNextLine = false; 4800 verifyFormat("void foo() {\n" 4801 " auto VariableWithReallyLongName = {\n" 4802 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4803 " bbbbbbbbbbbb};\n" 4804 "}", 4805 Style); 4806 } 4807 4808 // This parameter should not affect declarations. 4809 Style.BinPackParameters = false; 4810 Style.AllowAllArgumentsOnNextLine = false; 4811 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4812 verifyFormat("void FunctionCallWithReallyLongName(\n" 4813 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4814 Style); 4815 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4816 verifyFormat("void FunctionCallWithReallyLongName(\n" 4817 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4818 " int bbbbbbbbbbbb);", 4819 Style); 4820 } 4821 4822 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4823 FormatStyle Style = getLLVMStyle(); 4824 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4825 4826 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4827 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4828 getStyleWithColumns(Style, 45)); 4829 verifyFormat("Constructor() :\n" 4830 " Initializer(FitsOnTheLine) {}", 4831 getStyleWithColumns(Style, 44)); 4832 verifyFormat("Constructor() :\n" 4833 " Initializer(FitsOnTheLine) {}", 4834 getStyleWithColumns(Style, 43)); 4835 4836 verifyFormat("template <typename T>\n" 4837 "Constructor() : Initializer(FitsOnTheLine) {}", 4838 getStyleWithColumns(Style, 50)); 4839 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4840 verifyFormat( 4841 "SomeClass::Constructor() :\n" 4842 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4843 Style); 4844 4845 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4846 verifyFormat( 4847 "SomeClass::Constructor() :\n" 4848 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4849 Style); 4850 4851 verifyFormat( 4852 "SomeClass::Constructor() :\n" 4853 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4854 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4855 Style); 4856 verifyFormat( 4857 "SomeClass::Constructor() :\n" 4858 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4859 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4860 Style); 4861 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4862 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4863 " aaaaaaaaaa(aaaaaa) {}", 4864 Style); 4865 4866 verifyFormat("Constructor() :\n" 4867 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4868 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4869 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4870 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4871 Style); 4872 4873 verifyFormat("Constructor() :\n" 4874 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4875 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4876 Style); 4877 4878 verifyFormat("Constructor(int Parameter = 0) :\n" 4879 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4880 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4881 Style); 4882 verifyFormat("Constructor() :\n" 4883 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4884 "}", 4885 getStyleWithColumns(Style, 60)); 4886 verifyFormat("Constructor() :\n" 4887 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4888 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4889 Style); 4890 4891 // Here a line could be saved by splitting the second initializer onto two 4892 // lines, but that is not desirable. 4893 verifyFormat("Constructor() :\n" 4894 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4895 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4896 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4897 Style); 4898 4899 FormatStyle OnePerLine = Style; 4900 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4901 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4902 verifyFormat("SomeClass::Constructor() :\n" 4903 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4904 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4905 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4906 OnePerLine); 4907 verifyFormat("SomeClass::Constructor() :\n" 4908 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4909 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4910 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4911 OnePerLine); 4912 verifyFormat("MyClass::MyClass(int var) :\n" 4913 " some_var_(var), // 4 space indent\n" 4914 " some_other_var_(var + 1) { // lined up\n" 4915 "}", 4916 OnePerLine); 4917 verifyFormat("Constructor() :\n" 4918 " aaaaa(aaaaaa),\n" 4919 " aaaaa(aaaaaa),\n" 4920 " aaaaa(aaaaaa),\n" 4921 " aaaaa(aaaaaa),\n" 4922 " aaaaa(aaaaaa) {}", 4923 OnePerLine); 4924 verifyFormat("Constructor() :\n" 4925 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4926 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4927 OnePerLine); 4928 OnePerLine.BinPackParameters = false; 4929 verifyFormat("Constructor() :\n" 4930 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4931 " aaaaaaaaaaa().aaa(),\n" 4932 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4933 OnePerLine); 4934 OnePerLine.ColumnLimit = 60; 4935 verifyFormat("Constructor() :\n" 4936 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4937 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4938 OnePerLine); 4939 4940 EXPECT_EQ("Constructor() :\n" 4941 " // Comment forcing unwanted break.\n" 4942 " aaaa(aaaa) {}", 4943 format("Constructor() :\n" 4944 " // Comment forcing unwanted break.\n" 4945 " aaaa(aaaa) {}", 4946 Style)); 4947 4948 Style.ColumnLimit = 0; 4949 verifyFormat("SomeClass::Constructor() :\n" 4950 " a(a) {}", 4951 Style); 4952 verifyFormat("SomeClass::Constructor() noexcept :\n" 4953 " a(a) {}", 4954 Style); 4955 verifyFormat("SomeClass::Constructor() :\n" 4956 " a(a), b(b), c(c) {}", 4957 Style); 4958 verifyFormat("SomeClass::Constructor() :\n" 4959 " a(a) {\n" 4960 " foo();\n" 4961 " bar();\n" 4962 "}", 4963 Style); 4964 4965 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4966 verifyFormat("SomeClass::Constructor() :\n" 4967 " a(a), b(b), c(c) {\n" 4968 "}", 4969 Style); 4970 verifyFormat("SomeClass::Constructor() :\n" 4971 " a(a) {\n" 4972 "}", 4973 Style); 4974 4975 Style.ColumnLimit = 80; 4976 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4977 Style.ConstructorInitializerIndentWidth = 2; 4978 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style); 4979 verifyFormat("SomeClass::Constructor() :\n" 4980 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4981 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 4982 Style); 4983 4984 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as 4985 // well 4986 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 4987 verifyFormat( 4988 "class SomeClass\n" 4989 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4990 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4991 Style); 4992 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 4993 verifyFormat( 4994 "class SomeClass\n" 4995 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4996 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4997 Style); 4998 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 4999 verifyFormat( 5000 "class SomeClass :\n" 5001 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5002 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 5003 Style); 5004 } 5005 5006 #ifndef EXPENSIVE_CHECKS 5007 // Expensive checks enables libstdc++ checking which includes validating the 5008 // state of ranges used in std::priority_queue - this blows out the 5009 // runtime/scalability of the function and makes this test unacceptably slow. 5010 TEST_F(FormatTest, MemoizationTests) { 5011 // This breaks if the memoization lookup does not take \c Indent and 5012 // \c LastSpace into account. 5013 verifyFormat( 5014 "extern CFRunLoopTimerRef\n" 5015 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 5016 " CFTimeInterval interval, CFOptionFlags flags,\n" 5017 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 5018 " CFRunLoopTimerContext *context) {}"); 5019 5020 // Deep nesting somewhat works around our memoization. 5021 verifyFormat( 5022 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 5023 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 5024 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 5025 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 5026 " aaaaa())))))))))))))))))))))))))))))))))))))));", 5027 getLLVMStyleWithColumns(65)); 5028 verifyFormat( 5029 "aaaaa(\n" 5030 " aaaaa,\n" 5031 " aaaaa(\n" 5032 " aaaaa,\n" 5033 " aaaaa(\n" 5034 " aaaaa,\n" 5035 " aaaaa(\n" 5036 " aaaaa,\n" 5037 " aaaaa(\n" 5038 " aaaaa,\n" 5039 " aaaaa(\n" 5040 " aaaaa,\n" 5041 " aaaaa(\n" 5042 " aaaaa,\n" 5043 " aaaaa(\n" 5044 " aaaaa,\n" 5045 " aaaaa(\n" 5046 " aaaaa,\n" 5047 " aaaaa(\n" 5048 " aaaaa,\n" 5049 " aaaaa(\n" 5050 " aaaaa,\n" 5051 " aaaaa(\n" 5052 " aaaaa,\n" 5053 " aaaaa))))))))))));", 5054 getLLVMStyleWithColumns(65)); 5055 verifyFormat( 5056 "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" 5057 " a),\n" 5058 " a),\n" 5059 " a),\n" 5060 " a),\n" 5061 " a),\n" 5062 " a),\n" 5063 " a),\n" 5064 " a),\n" 5065 " a),\n" 5066 " a),\n" 5067 " a),\n" 5068 " a),\n" 5069 " a),\n" 5070 " a),\n" 5071 " a),\n" 5072 " a),\n" 5073 " a)", 5074 getLLVMStyleWithColumns(65)); 5075 5076 // This test takes VERY long when memoization is broken. 5077 FormatStyle OnePerLine = getLLVMStyle(); 5078 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 5079 OnePerLine.BinPackParameters = false; 5080 std::string input = "Constructor()\n" 5081 " : aaaa(a,\n"; 5082 for (unsigned i = 0, e = 80; i != e; ++i) { 5083 input += " a,\n"; 5084 } 5085 input += " a) {}"; 5086 verifyFormat(input, OnePerLine); 5087 } 5088 #endif 5089 5090 TEST_F(FormatTest, BreaksAsHighAsPossible) { 5091 verifyFormat( 5092 "void f() {\n" 5093 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 5094 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 5095 " f();\n" 5096 "}"); 5097 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 5098 " Intervals[i - 1].getRange().getLast()) {\n}"); 5099 } 5100 5101 TEST_F(FormatTest, BreaksFunctionDeclarations) { 5102 // Principially, we break function declarations in a certain order: 5103 // 1) break amongst arguments. 5104 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 5105 " Cccccccccccccc cccccccccccccc);"); 5106 verifyFormat("template <class TemplateIt>\n" 5107 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 5108 " TemplateIt *stop) {}"); 5109 5110 // 2) break after return type. 5111 verifyFormat( 5112 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5113 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 5114 getGoogleStyle()); 5115 5116 // 3) break after (. 5117 verifyFormat( 5118 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 5119 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 5120 getGoogleStyle()); 5121 5122 // 4) break before after nested name specifiers. 5123 verifyFormat( 5124 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5125 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 5126 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 5127 getGoogleStyle()); 5128 5129 // However, there are exceptions, if a sufficient amount of lines can be 5130 // saved. 5131 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 5132 // more adjusting. 5133 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 5134 " Cccccccccccccc cccccccccc,\n" 5135 " Cccccccccccccc cccccccccc,\n" 5136 " Cccccccccccccc cccccccccc,\n" 5137 " Cccccccccccccc cccccccccc);"); 5138 verifyFormat( 5139 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5140 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5141 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5142 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 5143 getGoogleStyle()); 5144 verifyFormat( 5145 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 5146 " Cccccccccccccc cccccccccc,\n" 5147 " Cccccccccccccc cccccccccc,\n" 5148 " Cccccccccccccc cccccccccc,\n" 5149 " Cccccccccccccc cccccccccc,\n" 5150 " Cccccccccccccc cccccccccc,\n" 5151 " Cccccccccccccc cccccccccc);"); 5152 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5153 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5154 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5155 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5156 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 5157 5158 // Break after multi-line parameters. 5159 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5160 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5161 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5162 " bbbb bbbb);"); 5163 verifyFormat("void SomeLoooooooooooongFunction(\n" 5164 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 5165 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5166 " int bbbbbbbbbbbbb);"); 5167 5168 // Treat overloaded operators like other functions. 5169 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5170 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 5171 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5172 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 5173 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5174 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 5175 verifyGoogleFormat( 5176 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 5177 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 5178 verifyGoogleFormat( 5179 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 5180 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 5181 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5182 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 5183 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 5184 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 5185 verifyGoogleFormat( 5186 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 5187 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5188 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 5189 verifyGoogleFormat("template <typename T>\n" 5190 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5191 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 5192 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 5193 5194 FormatStyle Style = getLLVMStyle(); 5195 Style.PointerAlignment = FormatStyle::PAS_Left; 5196 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5197 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 5198 Style); 5199 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 5200 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5201 Style); 5202 } 5203 5204 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 5205 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 5206 // Prefer keeping `::` followed by `operator` together. 5207 EXPECT_EQ("const aaaa::bbbbbbb &\n" 5208 "ccccccccc::operator++() {\n" 5209 " stuff();\n" 5210 "}", 5211 format("const aaaa::bbbbbbb\n" 5212 "&ccccccccc::operator++() { stuff(); }", 5213 getLLVMStyleWithColumns(40))); 5214 } 5215 5216 TEST_F(FormatTest, TrailingReturnType) { 5217 verifyFormat("auto foo() -> int;\n"); 5218 // correct trailing return type spacing 5219 verifyFormat("auto operator->() -> int;\n"); 5220 verifyFormat("auto operator++(int) -> int;\n"); 5221 5222 verifyFormat("struct S {\n" 5223 " auto bar() const -> int;\n" 5224 "};"); 5225 verifyFormat("template <size_t Order, typename T>\n" 5226 "auto load_img(const std::string &filename)\n" 5227 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 5228 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 5229 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 5230 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 5231 verifyFormat("template <typename T>\n" 5232 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 5233 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 5234 5235 // Not trailing return types. 5236 verifyFormat("void f() { auto a = b->c(); }"); 5237 } 5238 5239 TEST_F(FormatTest, DeductionGuides) { 5240 verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;"); 5241 verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;"); 5242 verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;"); 5243 verifyFormat( 5244 "template <class... T>\n" 5245 "array(T &&... t) -> array<std::common_type_t<T...>, sizeof...(T)>;"); 5246 verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;"); 5247 verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;"); 5248 verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;"); 5249 verifyFormat("template <class T> A() -> A<(3 < 2)>;"); 5250 verifyFormat("template <class T> A() -> A<((3) < (2))>;"); 5251 verifyFormat("template <class T> x() -> x<1>;"); 5252 verifyFormat("template <class T> explicit x(T &) -> x<1>;"); 5253 5254 // Ensure not deduction guides. 5255 verifyFormat("c()->f<int>();"); 5256 verifyFormat("x()->foo<1>;"); 5257 verifyFormat("x = p->foo<3>();"); 5258 verifyFormat("x()->x<1>();"); 5259 verifyFormat("x()->x<1>;"); 5260 } 5261 5262 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 5263 // Avoid breaking before trailing 'const' or other trailing annotations, if 5264 // they are not function-like. 5265 FormatStyle Style = getGoogleStyle(); 5266 Style.ColumnLimit = 47; 5267 verifyFormat("void someLongFunction(\n" 5268 " int someLoooooooooooooongParameter) const {\n}", 5269 getLLVMStyleWithColumns(47)); 5270 verifyFormat("LoooooongReturnType\n" 5271 "someLoooooooongFunction() const {}", 5272 getLLVMStyleWithColumns(47)); 5273 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 5274 " const {}", 5275 Style); 5276 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5277 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 5278 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5279 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 5280 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5281 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 5282 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 5283 " aaaaaaaaaaa aaaaa) const override;"); 5284 verifyGoogleFormat( 5285 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5286 " const override;"); 5287 5288 // Even if the first parameter has to be wrapped. 5289 verifyFormat("void someLongFunction(\n" 5290 " int someLongParameter) const {}", 5291 getLLVMStyleWithColumns(46)); 5292 verifyFormat("void someLongFunction(\n" 5293 " int someLongParameter) const {}", 5294 Style); 5295 verifyFormat("void someLongFunction(\n" 5296 " int someLongParameter) override {}", 5297 Style); 5298 verifyFormat("void someLongFunction(\n" 5299 " int someLongParameter) OVERRIDE {}", 5300 Style); 5301 verifyFormat("void someLongFunction(\n" 5302 " int someLongParameter) final {}", 5303 Style); 5304 verifyFormat("void someLongFunction(\n" 5305 " int someLongParameter) FINAL {}", 5306 Style); 5307 verifyFormat("void someLongFunction(\n" 5308 " int parameter) const override {}", 5309 Style); 5310 5311 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 5312 verifyFormat("void someLongFunction(\n" 5313 " int someLongParameter) const\n" 5314 "{\n" 5315 "}", 5316 Style); 5317 5318 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 5319 verifyFormat("void someLongFunction(\n" 5320 " int someLongParameter) const\n" 5321 " {\n" 5322 " }", 5323 Style); 5324 5325 // Unless these are unknown annotations. 5326 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 5327 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5328 " LONG_AND_UGLY_ANNOTATION;"); 5329 5330 // Breaking before function-like trailing annotations is fine to keep them 5331 // close to their arguments. 5332 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5333 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5334 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5335 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5336 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5337 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 5338 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 5339 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 5340 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 5341 5342 verifyFormat( 5343 "void aaaaaaaaaaaaaaaaaa()\n" 5344 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 5345 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 5346 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5347 " __attribute__((unused));"); 5348 verifyGoogleFormat( 5349 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5350 " GUARDED_BY(aaaaaaaaaaaa);"); 5351 verifyGoogleFormat( 5352 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5353 " GUARDED_BY(aaaaaaaaaaaa);"); 5354 verifyGoogleFormat( 5355 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5356 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5357 verifyGoogleFormat( 5358 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5359 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5360 } 5361 5362 TEST_F(FormatTest, FunctionAnnotations) { 5363 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5364 "int OldFunction(const string ¶meter) {}"); 5365 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5366 "string OldFunction(const string ¶meter) {}"); 5367 verifyFormat("template <typename T>\n" 5368 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5369 "string OldFunction(const string ¶meter) {}"); 5370 5371 // Not function annotations. 5372 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5373 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 5374 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 5375 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 5376 verifyFormat("MACRO(abc).function() // wrap\n" 5377 " << abc;"); 5378 verifyFormat("MACRO(abc)->function() // wrap\n" 5379 " << abc;"); 5380 verifyFormat("MACRO(abc)::function() // wrap\n" 5381 " << abc;"); 5382 } 5383 5384 TEST_F(FormatTest, BreaksDesireably) { 5385 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5386 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5387 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 5388 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5389 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 5390 "}"); 5391 5392 verifyFormat( 5393 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5394 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 5395 5396 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5397 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5398 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5399 5400 verifyFormat( 5401 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5402 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5403 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5404 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5405 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 5406 5407 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5408 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5409 5410 verifyFormat( 5411 "void f() {\n" 5412 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 5413 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5414 "}"); 5415 verifyFormat( 5416 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5417 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5418 verifyFormat( 5419 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5420 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5421 verifyFormat( 5422 "aaaaaa(aaa,\n" 5423 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5424 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5425 " aaaa);"); 5426 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5427 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5428 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5429 5430 // Indent consistently independent of call expression and unary operator. 5431 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5432 " dddddddddddddddddddddddddddddd));"); 5433 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5434 " dddddddddddddddddddddddddddddd));"); 5435 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 5436 " dddddddddddddddddddddddddddddd));"); 5437 5438 // This test case breaks on an incorrect memoization, i.e. an optimization not 5439 // taking into account the StopAt value. 5440 verifyFormat( 5441 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5442 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5443 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5444 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5445 5446 verifyFormat("{\n {\n {\n" 5447 " Annotation.SpaceRequiredBefore =\n" 5448 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 5449 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 5450 " }\n }\n}"); 5451 5452 // Break on an outer level if there was a break on an inner level. 5453 EXPECT_EQ("f(g(h(a, // comment\n" 5454 " b, c),\n" 5455 " d, e),\n" 5456 " x, y);", 5457 format("f(g(h(a, // comment\n" 5458 " b, c), d, e), x, y);")); 5459 5460 // Prefer breaking similar line breaks. 5461 verifyFormat( 5462 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 5463 " NSTrackingMouseEnteredAndExited |\n" 5464 " NSTrackingActiveAlways;"); 5465 } 5466 5467 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 5468 FormatStyle NoBinPacking = getGoogleStyle(); 5469 NoBinPacking.BinPackParameters = false; 5470 NoBinPacking.BinPackArguments = true; 5471 verifyFormat("void f() {\n" 5472 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 5473 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5474 "}", 5475 NoBinPacking); 5476 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 5477 " int aaaaaaaaaaaaaaaaaaaa,\n" 5478 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5479 NoBinPacking); 5480 5481 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5482 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5483 " vector<int> bbbbbbbbbbbbbbb);", 5484 NoBinPacking); 5485 // FIXME: This behavior difference is probably not wanted. However, currently 5486 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 5487 // template arguments from BreakBeforeParameter being set because of the 5488 // one-per-line formatting. 5489 verifyFormat( 5490 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5491 " aaaaaaaaaa> aaaaaaaaaa);", 5492 NoBinPacking); 5493 verifyFormat( 5494 "void fffffffffff(\n" 5495 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 5496 " aaaaaaaaaa);"); 5497 } 5498 5499 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 5500 FormatStyle NoBinPacking = getGoogleStyle(); 5501 NoBinPacking.BinPackParameters = false; 5502 NoBinPacking.BinPackArguments = false; 5503 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 5504 " aaaaaaaaaaaaaaaaaaaa,\n" 5505 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 5506 NoBinPacking); 5507 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 5508 " aaaaaaaaaaaaa,\n" 5509 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 5510 NoBinPacking); 5511 verifyFormat( 5512 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5513 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5514 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5515 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5516 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 5517 NoBinPacking); 5518 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5519 " .aaaaaaaaaaaaaaaaaa();", 5520 NoBinPacking); 5521 verifyFormat("void f() {\n" 5522 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5523 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 5524 "}", 5525 NoBinPacking); 5526 5527 verifyFormat( 5528 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5529 " aaaaaaaaaaaa,\n" 5530 " aaaaaaaaaaaa);", 5531 NoBinPacking); 5532 verifyFormat( 5533 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 5534 " ddddddddddddddddddddddddddddd),\n" 5535 " test);", 5536 NoBinPacking); 5537 5538 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5539 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 5540 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 5541 " aaaaaaaaaaaaaaaaaa;", 5542 NoBinPacking); 5543 verifyFormat("a(\"a\"\n" 5544 " \"a\",\n" 5545 " a);"); 5546 5547 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5548 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 5549 " aaaaaaaaa,\n" 5550 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5551 NoBinPacking); 5552 verifyFormat( 5553 "void f() {\n" 5554 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5555 " .aaaaaaa();\n" 5556 "}", 5557 NoBinPacking); 5558 verifyFormat( 5559 "template <class SomeType, class SomeOtherType>\n" 5560 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 5561 NoBinPacking); 5562 } 5563 5564 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 5565 FormatStyle Style = getLLVMStyleWithColumns(15); 5566 Style.ExperimentalAutoDetectBinPacking = true; 5567 EXPECT_EQ("aaa(aaaa,\n" 5568 " aaaa,\n" 5569 " aaaa);\n" 5570 "aaa(aaaa,\n" 5571 " aaaa,\n" 5572 " aaaa);", 5573 format("aaa(aaaa,\n" // one-per-line 5574 " aaaa,\n" 5575 " aaaa );\n" 5576 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5577 Style)); 5578 EXPECT_EQ("aaa(aaaa, aaaa,\n" 5579 " aaaa);\n" 5580 "aaa(aaaa, aaaa,\n" 5581 " aaaa);", 5582 format("aaa(aaaa, aaaa,\n" // bin-packed 5583 " aaaa );\n" 5584 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5585 Style)); 5586 } 5587 5588 TEST_F(FormatTest, FormatsBuilderPattern) { 5589 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 5590 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 5591 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 5592 " .StartsWith(\".init\", ORDER_INIT)\n" 5593 " .StartsWith(\".fini\", ORDER_FINI)\n" 5594 " .StartsWith(\".hash\", ORDER_HASH)\n" 5595 " .Default(ORDER_TEXT);\n"); 5596 5597 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 5598 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 5599 verifyFormat("aaaaaaa->aaaaaaa\n" 5600 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5601 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5602 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5603 verifyFormat( 5604 "aaaaaaa->aaaaaaa\n" 5605 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5606 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5607 verifyFormat( 5608 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 5609 " aaaaaaaaaaaaaa);"); 5610 verifyFormat( 5611 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 5612 " aaaaaa->aaaaaaaaaaaa()\n" 5613 " ->aaaaaaaaaaaaaaaa(\n" 5614 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5615 " ->aaaaaaaaaaaaaaaaa();"); 5616 verifyGoogleFormat( 5617 "void f() {\n" 5618 " someo->Add((new util::filetools::Handler(dir))\n" 5619 " ->OnEvent1(NewPermanentCallback(\n" 5620 " this, &HandlerHolderClass::EventHandlerCBA))\n" 5621 " ->OnEvent2(NewPermanentCallback(\n" 5622 " this, &HandlerHolderClass::EventHandlerCBB))\n" 5623 " ->OnEvent3(NewPermanentCallback(\n" 5624 " this, &HandlerHolderClass::EventHandlerCBC))\n" 5625 " ->OnEvent5(NewPermanentCallback(\n" 5626 " this, &HandlerHolderClass::EventHandlerCBD))\n" 5627 " ->OnEvent6(NewPermanentCallback(\n" 5628 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 5629 "}"); 5630 5631 verifyFormat( 5632 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 5633 verifyFormat("aaaaaaaaaaaaaaa()\n" 5634 " .aaaaaaaaaaaaaaa()\n" 5635 " .aaaaaaaaaaaaaaa()\n" 5636 " .aaaaaaaaaaaaaaa()\n" 5637 " .aaaaaaaaaaaaaaa();"); 5638 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5639 " .aaaaaaaaaaaaaaa()\n" 5640 " .aaaaaaaaaaaaaaa()\n" 5641 " .aaaaaaaaaaaaaaa();"); 5642 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5643 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5644 " .aaaaaaaaaaaaaaa();"); 5645 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 5646 " ->aaaaaaaaaaaaaae(0)\n" 5647 " ->aaaaaaaaaaaaaaa();"); 5648 5649 // Don't linewrap after very short segments. 5650 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5651 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5652 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5653 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5654 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5655 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5656 verifyFormat("aaa()\n" 5657 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5658 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5659 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5660 5661 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5662 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5663 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 5664 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5665 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 5666 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 5667 5668 // Prefer not to break after empty parentheses. 5669 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 5670 " First->LastNewlineOffset);"); 5671 5672 // Prefer not to create "hanging" indents. 5673 verifyFormat( 5674 "return !soooooooooooooome_map\n" 5675 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5676 " .second;"); 5677 verifyFormat( 5678 "return aaaaaaaaaaaaaaaa\n" 5679 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 5680 " .aaaa(aaaaaaaaaaaaaa);"); 5681 // No hanging indent here. 5682 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5683 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5684 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5685 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5686 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5687 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5688 getLLVMStyleWithColumns(60)); 5689 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5690 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5691 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5692 getLLVMStyleWithColumns(59)); 5693 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5694 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5695 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5696 5697 // Dont break if only closing statements before member call 5698 verifyFormat("test() {\n" 5699 " ([]() -> {\n" 5700 " int b = 32;\n" 5701 " return 3;\n" 5702 " }).foo();\n" 5703 "}"); 5704 verifyFormat("test() {\n" 5705 " (\n" 5706 " []() -> {\n" 5707 " int b = 32;\n" 5708 " return 3;\n" 5709 " },\n" 5710 " foo, bar)\n" 5711 " .foo();\n" 5712 "}"); 5713 verifyFormat("test() {\n" 5714 " ([]() -> {\n" 5715 " int b = 32;\n" 5716 " return 3;\n" 5717 " })\n" 5718 " .foo()\n" 5719 " .bar();\n" 5720 "}"); 5721 verifyFormat("test() {\n" 5722 " ([]() -> {\n" 5723 " int b = 32;\n" 5724 " return 3;\n" 5725 " })\n" 5726 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5727 " \"bbbb\");\n" 5728 "}", 5729 getLLVMStyleWithColumns(30)); 5730 } 5731 5732 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5733 verifyFormat( 5734 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5735 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5736 verifyFormat( 5737 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5738 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5739 5740 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5741 " ccccccccccccccccccccccccc) {\n}"); 5742 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5743 " ccccccccccccccccccccccccc) {\n}"); 5744 5745 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5746 " ccccccccccccccccccccccccc) {\n}"); 5747 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5748 " ccccccccccccccccccccccccc) {\n}"); 5749 5750 verifyFormat( 5751 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5752 " ccccccccccccccccccccccccc) {\n}"); 5753 verifyFormat( 5754 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5755 " ccccccccccccccccccccccccc) {\n}"); 5756 5757 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5758 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5759 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5760 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5761 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5762 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5763 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5764 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5765 5766 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5767 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5768 " aaaaaaaaaaaaaaa != aa) {\n}"); 5769 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5770 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5771 " aaaaaaaaaaaaaaa != aa) {\n}"); 5772 } 5773 5774 TEST_F(FormatTest, BreaksAfterAssignments) { 5775 verifyFormat( 5776 "unsigned Cost =\n" 5777 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5778 " SI->getPointerAddressSpaceee());\n"); 5779 verifyFormat( 5780 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5781 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5782 5783 verifyFormat( 5784 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5785 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5786 verifyFormat("unsigned OriginalStartColumn =\n" 5787 " SourceMgr.getSpellingColumnNumber(\n" 5788 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5789 " 1;"); 5790 } 5791 5792 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5793 FormatStyle Style = getLLVMStyle(); 5794 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5795 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5796 Style); 5797 5798 Style.PenaltyBreakAssignment = 20; 5799 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5800 " cccccccccccccccccccccccccc;", 5801 Style); 5802 } 5803 5804 TEST_F(FormatTest, AlignsAfterAssignments) { 5805 verifyFormat( 5806 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5807 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5808 verifyFormat( 5809 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5810 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5811 verifyFormat( 5812 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5813 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5814 verifyFormat( 5815 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5816 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5817 verifyFormat( 5818 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5819 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5820 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5821 } 5822 5823 TEST_F(FormatTest, AlignsAfterReturn) { 5824 verifyFormat( 5825 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5826 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5827 verifyFormat( 5828 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5829 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5830 verifyFormat( 5831 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5832 " aaaaaaaaaaaaaaaaaaaaaa();"); 5833 verifyFormat( 5834 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5835 " aaaaaaaaaaaaaaaaaaaaaa());"); 5836 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5837 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5838 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5839 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5840 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5841 verifyFormat("return\n" 5842 " // true if code is one of a or b.\n" 5843 " code == a || code == b;"); 5844 } 5845 5846 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5847 verifyFormat( 5848 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5849 " aaaaaaaaa aaaaaaa) {}"); 5850 verifyFormat( 5851 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5852 " aaaaaaaaaaa aaaaaaaaa);"); 5853 verifyFormat( 5854 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5855 " aaaaaaaaaaaaaaaaaaaaa));"); 5856 FormatStyle Style = getLLVMStyle(); 5857 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5858 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5859 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5860 Style); 5861 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5862 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5863 Style); 5864 verifyFormat("SomeLongVariableName->someFunction(\n" 5865 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5866 Style); 5867 verifyFormat( 5868 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5869 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5870 Style); 5871 verifyFormat( 5872 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5873 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5874 Style); 5875 verifyFormat( 5876 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5877 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5878 Style); 5879 5880 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5881 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5882 " b));", 5883 Style); 5884 5885 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5886 Style.BinPackArguments = false; 5887 Style.BinPackParameters = false; 5888 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5889 " aaaaaaaaaaa aaaaaaaa,\n" 5890 " aaaaaaaaa aaaaaaa,\n" 5891 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5892 Style); 5893 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5894 " aaaaaaaaaaa aaaaaaaaa,\n" 5895 " aaaaaaaaaaa aaaaaaaaa,\n" 5896 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5897 Style); 5898 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5899 " aaaaaaaaaaaaaaa,\n" 5900 " aaaaaaaaaaaaaaaaaaaaa,\n" 5901 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5902 Style); 5903 verifyFormat( 5904 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5905 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5906 Style); 5907 verifyFormat( 5908 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5909 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5910 Style); 5911 verifyFormat( 5912 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5913 " aaaaaaaaaaaaaaaaaaaaa(\n" 5914 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5915 " aaaaaaaaaaaaaaaa);", 5916 Style); 5917 verifyFormat( 5918 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5919 " aaaaaaaaaaaaaaaaaaaaa(\n" 5920 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5921 " aaaaaaaaaaaaaaaa);", 5922 Style); 5923 } 5924 5925 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5926 FormatStyle Style = getLLVMStyleWithColumns(40); 5927 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5928 " bbbbbbbbbbbbbbbbbbbbbb);", 5929 Style); 5930 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5931 Style.AlignOperands = FormatStyle::OAS_DontAlign; 5932 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5933 " bbbbbbbbbbbbbbbbbbbbbb);", 5934 Style); 5935 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5936 Style.AlignOperands = FormatStyle::OAS_Align; 5937 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5938 " bbbbbbbbbbbbbbbbbbbbbb);", 5939 Style); 5940 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5941 Style.AlignOperands = FormatStyle::OAS_DontAlign; 5942 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5943 " bbbbbbbbbbbbbbbbbbbbbb);", 5944 Style); 5945 } 5946 5947 TEST_F(FormatTest, BreaksConditionalExpressions) { 5948 verifyFormat( 5949 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5950 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5951 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5952 verifyFormat( 5953 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5954 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5955 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5956 verifyFormat( 5957 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5958 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5959 verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5960 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5961 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5962 verifyFormat( 5963 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5964 " : aaaaaaaaaaaaa);"); 5965 verifyFormat( 5966 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5967 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5968 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5969 " aaaaaaaaaaaaa);"); 5970 verifyFormat( 5971 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5972 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5973 " aaaaaaaaaaaaa);"); 5974 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5975 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5976 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5977 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5978 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5979 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5980 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5981 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5982 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5983 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5984 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5985 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5986 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5987 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5988 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5989 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5990 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5991 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5992 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5993 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5994 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5995 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5996 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5997 " : aaaaaaaaaaaaaaaa;"); 5998 verifyFormat( 5999 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6000 " ? aaaaaaaaaaaaaaa\n" 6001 " : aaaaaaaaaaaaaaa;"); 6002 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 6003 " aaaaaaaaa\n" 6004 " ? b\n" 6005 " : c);"); 6006 verifyFormat("return aaaa == bbbb\n" 6007 " // comment\n" 6008 " ? aaaa\n" 6009 " : bbbb;"); 6010 verifyFormat("unsigned Indent =\n" 6011 " format(TheLine.First,\n" 6012 " IndentForLevel[TheLine.Level] >= 0\n" 6013 " ? IndentForLevel[TheLine.Level]\n" 6014 " : TheLine * 2,\n" 6015 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 6016 getLLVMStyleWithColumns(60)); 6017 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 6018 " ? aaaaaaaaaaaaaaa\n" 6019 " : bbbbbbbbbbbbbbb //\n" 6020 " ? ccccccccccccccc\n" 6021 " : ddddddddddddddd;"); 6022 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 6023 " ? aaaaaaaaaaaaaaa\n" 6024 " : (bbbbbbbbbbbbbbb //\n" 6025 " ? ccccccccccccccc\n" 6026 " : ddddddddddddddd);"); 6027 verifyFormat( 6028 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6029 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 6030 " aaaaaaaaaaaaaaaaaaaaa +\n" 6031 " aaaaaaaaaaaaaaaaaaaaa\n" 6032 " : aaaaaaaaaa;"); 6033 verifyFormat( 6034 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6035 " : aaaaaaaaaaaaaaaaaaaaaa\n" 6036 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6037 6038 FormatStyle NoBinPacking = getLLVMStyle(); 6039 NoBinPacking.BinPackArguments = false; 6040 verifyFormat( 6041 "void f() {\n" 6042 " g(aaa,\n" 6043 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 6044 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6045 " ? aaaaaaaaaaaaaaa\n" 6046 " : aaaaaaaaaaaaaaa);\n" 6047 "}", 6048 NoBinPacking); 6049 verifyFormat( 6050 "void f() {\n" 6051 " g(aaa,\n" 6052 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 6053 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6054 " ?: aaaaaaaaaaaaaaa);\n" 6055 "}", 6056 NoBinPacking); 6057 6058 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 6059 " // comment.\n" 6060 " ccccccccccccccccccccccccccccccccccccccc\n" 6061 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6062 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 6063 6064 // Assignments in conditional expressions. Apparently not uncommon :-(. 6065 verifyFormat("return a != b\n" 6066 " // comment\n" 6067 " ? a = b\n" 6068 " : a = b;"); 6069 verifyFormat("return a != b\n" 6070 " // comment\n" 6071 " ? a = a != b\n" 6072 " // comment\n" 6073 " ? a = b\n" 6074 " : a\n" 6075 " : a;\n"); 6076 verifyFormat("return a != b\n" 6077 " // comment\n" 6078 " ? a\n" 6079 " : a = a != b\n" 6080 " // comment\n" 6081 " ? a = b\n" 6082 " : a;"); 6083 6084 // Chained conditionals 6085 FormatStyle Style = getLLVMStyle(); 6086 Style.ColumnLimit = 70; 6087 Style.AlignOperands = FormatStyle::OAS_Align; 6088 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n" 6089 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6090 " : 3333333333333333;", 6091 Style); 6092 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n" 6093 " : bbbbbbbbbb ? 2222222222222222\n" 6094 " : 3333333333333333;", 6095 Style); 6096 verifyFormat("return aaaaaaaaaa ? 1111111111111111\n" 6097 " : bbbbbbbbbbbbbbbb ? 2222222222222222\n" 6098 " : 3333333333333333;", 6099 Style); 6100 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n" 6101 " : bbbbbbbbbbbbbb ? 222222\n" 6102 " : 333333;", 6103 Style); 6104 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n" 6105 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6106 " : cccccccccccccc ? 3333333333333333\n" 6107 " : 4444444444444444;", 6108 Style); 6109 verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc)\n" 6110 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6111 " : 3333333333333333;", 6112 Style); 6113 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n" 6114 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6115 " : (aaa ? bbb : ccc);", 6116 Style); 6117 verifyFormat( 6118 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6119 " : cccccccccccccccccc)\n" 6120 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6121 " : 3333333333333333;", 6122 Style); 6123 verifyFormat( 6124 "return aaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6125 " : cccccccccccccccccc)\n" 6126 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6127 " : 3333333333333333;", 6128 Style); 6129 verifyFormat( 6130 "return aaaaaaaaa ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6131 " : dddddddddddddddddd)\n" 6132 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6133 " : 3333333333333333;", 6134 Style); 6135 verifyFormat( 6136 "return aaaaaaaaa ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6137 " : dddddddddddddddddd)\n" 6138 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6139 " : 3333333333333333;", 6140 Style); 6141 verifyFormat( 6142 "return aaaaaaaaa ? 1111111111111111\n" 6143 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6144 " : a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6145 " : dddddddddddddddddd)\n", 6146 Style); 6147 verifyFormat( 6148 "return aaaaaaaaaaaaaaaa ? 1111111111111111\n" 6149 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6150 " : (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6151 " : cccccccccccccccccc);", 6152 Style); 6153 verifyFormat( 6154 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6155 " : ccccccccccccccc ? dddddddddddddddddd\n" 6156 " : eeeeeeeeeeeeeeeeee)\n" 6157 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6158 " : 3333333333333333;", 6159 Style); 6160 verifyFormat( 6161 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6162 " : ccccccccccccccc ? dddddddddddddddddd\n" 6163 " : eeeeeeeeeeeeeeeeee)\n" 6164 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6165 " : 3333333333333333;", 6166 Style); 6167 verifyFormat( 6168 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6169 " : cccccccccccc ? dddddddddddddddddd\n" 6170 " : eeeeeeeeeeeeeeeeee)\n" 6171 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6172 " : 3333333333333333;", 6173 Style); 6174 verifyFormat( 6175 "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6176 " : cccccccccccccccccc\n" 6177 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6178 " : 3333333333333333;", 6179 Style); 6180 verifyFormat( 6181 "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6182 " : cccccccccccccccc ? dddddddddddddddddd\n" 6183 " : eeeeeeeeeeeeeeeeee\n" 6184 " : bbbbbbbbbbbbbb ? 2222222222222222\n" 6185 " : 3333333333333333;", 6186 Style); 6187 verifyFormat("return aaaaaaaaaaaaaaaaaaaaa\n" 6188 " ? (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6189 " : cccccccccccccccccc ? dddddddddddddddddd\n" 6190 " : eeeeeeeeeeeeeeeeee)\n" 6191 " : bbbbbbbbbbbbbbbbbbb ? 2222222222222222\n" 6192 " : 3333333333333333;", 6193 Style); 6194 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaa\n" 6195 " ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" 6196 " : cccccccccccccccc ? dddddddddddddddddd\n" 6197 " : eeeeeeeeeeeeeeeeee\n" 6198 " : bbbbbbbbbbbbbbbbbbbbbbb ? 2222222222222222\n" 6199 " : 3333333333333333;", 6200 Style); 6201 } 6202 6203 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 6204 FormatStyle Style = getLLVMStyle(); 6205 Style.BreakBeforeTernaryOperators = false; 6206 Style.ColumnLimit = 70; 6207 verifyFormat( 6208 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6209 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6210 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6211 Style); 6212 verifyFormat( 6213 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 6214 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6215 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6216 Style); 6217 verifyFormat( 6218 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6219 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6220 Style); 6221 verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n" 6222 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6223 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6224 Style); 6225 verifyFormat( 6226 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 6227 " aaaaaaaaaaaaa);", 6228 Style); 6229 verifyFormat( 6230 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6231 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6232 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6233 " aaaaaaaaaaaaa);", 6234 Style); 6235 verifyFormat( 6236 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6237 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6238 " aaaaaaaaaaaaa);", 6239 Style); 6240 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6241 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6242 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 6243 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6244 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6245 Style); 6246 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6247 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6248 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6249 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 6250 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6251 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 6252 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6253 Style); 6254 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6255 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 6256 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6257 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 6258 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6259 Style); 6260 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6261 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6262 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6263 Style); 6264 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 6265 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6266 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6267 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6268 Style); 6269 verifyFormat( 6270 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6271 " aaaaaaaaaaaaaaa :\n" 6272 " aaaaaaaaaaaaaaa;", 6273 Style); 6274 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 6275 " aaaaaaaaa ?\n" 6276 " b :\n" 6277 " c);", 6278 Style); 6279 verifyFormat("unsigned Indent =\n" 6280 " format(TheLine.First,\n" 6281 " IndentForLevel[TheLine.Level] >= 0 ?\n" 6282 " IndentForLevel[TheLine.Level] :\n" 6283 " TheLine * 2,\n" 6284 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 6285 Style); 6286 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 6287 " aaaaaaaaaaaaaaa :\n" 6288 " bbbbbbbbbbbbbbb ? //\n" 6289 " ccccccccccccccc :\n" 6290 " ddddddddddddddd;", 6291 Style); 6292 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 6293 " aaaaaaaaaaaaaaa :\n" 6294 " (bbbbbbbbbbbbbbb ? //\n" 6295 " ccccccccccccccc :\n" 6296 " ddddddddddddddd);", 6297 Style); 6298 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6299 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 6300 " ccccccccccccccccccccccccccc;", 6301 Style); 6302 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6303 " aaaaa :\n" 6304 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 6305 Style); 6306 6307 // Chained conditionals 6308 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n" 6309 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6310 " 3333333333333333;", 6311 Style); 6312 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n" 6313 " bbbbbbbbbb ? 2222222222222222 :\n" 6314 " 3333333333333333;", 6315 Style); 6316 verifyFormat("return aaaaaaaaaa ? 1111111111111111 :\n" 6317 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6318 " 3333333333333333;", 6319 Style); 6320 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n" 6321 " bbbbbbbbbbbbbbbb ? 222222 :\n" 6322 " 333333;", 6323 Style); 6324 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n" 6325 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6326 " cccccccccccccccc ? 3333333333333333 :\n" 6327 " 4444444444444444;", 6328 Style); 6329 verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc) :\n" 6330 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6331 " 3333333333333333;", 6332 Style); 6333 verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n" 6334 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6335 " (aaa ? bbb : ccc);", 6336 Style); 6337 verifyFormat( 6338 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6339 " cccccccccccccccccc) :\n" 6340 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6341 " 3333333333333333;", 6342 Style); 6343 verifyFormat( 6344 "return aaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6345 " cccccccccccccccccc) :\n" 6346 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6347 " 3333333333333333;", 6348 Style); 6349 verifyFormat( 6350 "return aaaaaaaaa ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6351 " dddddddddddddddddd) :\n" 6352 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6353 " 3333333333333333;", 6354 Style); 6355 verifyFormat( 6356 "return aaaaaaaaa ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6357 " dddddddddddddddddd) :\n" 6358 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6359 " 3333333333333333;", 6360 Style); 6361 verifyFormat( 6362 "return aaaaaaaaa ? 1111111111111111 :\n" 6363 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6364 " a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6365 " dddddddddddddddddd)\n", 6366 Style); 6367 verifyFormat( 6368 "return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n" 6369 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6370 " (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6371 " cccccccccccccccccc);", 6372 Style); 6373 verifyFormat( 6374 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6375 " ccccccccccccccccc ? dddddddddddddddddd :\n" 6376 " eeeeeeeeeeeeeeeeee) :\n" 6377 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6378 " 3333333333333333;", 6379 Style); 6380 verifyFormat( 6381 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6382 " ccccccccccccc ? dddddddddddddddddd :\n" 6383 " eeeeeeeeeeeeeeeeee) :\n" 6384 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6385 " 3333333333333333;", 6386 Style); 6387 verifyFormat( 6388 "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6389 " ccccccccccccccccc ? dddddddddddddddddd :\n" 6390 " eeeeeeeeeeeeeeeeee) :\n" 6391 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6392 " 3333333333333333;", 6393 Style); 6394 verifyFormat( 6395 "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6396 " cccccccccccccccccc :\n" 6397 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6398 " 3333333333333333;", 6399 Style); 6400 verifyFormat( 6401 "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6402 " cccccccccccccccccc ? dddddddddddddddddd :\n" 6403 " eeeeeeeeeeeeeeeeee :\n" 6404 " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6405 " 3333333333333333;", 6406 Style); 6407 verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n" 6408 " (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6409 " cccccccccccccccccc ? dddddddddddddddddd :\n" 6410 " eeeeeeeeeeeeeeeeee) :\n" 6411 " bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6412 " 3333333333333333;", 6413 Style); 6414 verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n" 6415 " aaaaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" 6416 " cccccccccccccccccccc ? dddddddddddddddddd :\n" 6417 " eeeeeeeeeeeeeeeeee :\n" 6418 " bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n" 6419 " 3333333333333333;", 6420 Style); 6421 } 6422 6423 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 6424 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 6425 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 6426 verifyFormat("bool a = true, b = false;"); 6427 6428 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6429 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 6430 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 6431 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 6432 verifyFormat( 6433 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 6434 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 6435 " d = e && f;"); 6436 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 6437 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 6438 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 6439 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 6440 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 6441 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 6442 6443 FormatStyle Style = getGoogleStyle(); 6444 Style.PointerAlignment = FormatStyle::PAS_Left; 6445 Style.DerivePointerAlignment = false; 6446 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6447 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 6448 " *b = bbbbbbbbbbbbbbbbbbb;", 6449 Style); 6450 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 6451 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 6452 Style); 6453 verifyFormat("vector<int*> a, b;", Style); 6454 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 6455 } 6456 6457 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 6458 verifyFormat("arr[foo ? bar : baz];"); 6459 verifyFormat("f()[foo ? bar : baz];"); 6460 verifyFormat("(a + b)[foo ? bar : baz];"); 6461 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 6462 } 6463 6464 TEST_F(FormatTest, AlignsStringLiterals) { 6465 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 6466 " \"short literal\");"); 6467 verifyFormat( 6468 "looooooooooooooooooooooooongFunction(\n" 6469 " \"short literal\"\n" 6470 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 6471 verifyFormat("someFunction(\"Always break between multi-line\"\n" 6472 " \" string literals\",\n" 6473 " and, other, parameters);"); 6474 EXPECT_EQ("fun + \"1243\" /* comment */\n" 6475 " \"5678\";", 6476 format("fun + \"1243\" /* comment */\n" 6477 " \"5678\";", 6478 getLLVMStyleWithColumns(28))); 6479 EXPECT_EQ( 6480 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 6481 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 6482 " \"aaaaaaaaaaaaaaaa\";", 6483 format("aaaaaa =" 6484 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 6485 "aaaaaaaaaaaaaaaaaaaaa\" " 6486 "\"aaaaaaaaaaaaaaaa\";")); 6487 verifyFormat("a = a + \"a\"\n" 6488 " \"a\"\n" 6489 " \"a\";"); 6490 verifyFormat("f(\"a\", \"b\"\n" 6491 " \"c\");"); 6492 6493 verifyFormat( 6494 "#define LL_FORMAT \"ll\"\n" 6495 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 6496 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 6497 6498 verifyFormat("#define A(X) \\\n" 6499 " \"aaaaa\" #X \"bbbbbb\" \\\n" 6500 " \"ccccc\"", 6501 getLLVMStyleWithColumns(23)); 6502 verifyFormat("#define A \"def\"\n" 6503 "f(\"abc\" A \"ghi\"\n" 6504 " \"jkl\");"); 6505 6506 verifyFormat("f(L\"a\"\n" 6507 " L\"b\");"); 6508 verifyFormat("#define A(X) \\\n" 6509 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 6510 " L\"ccccc\"", 6511 getLLVMStyleWithColumns(25)); 6512 6513 verifyFormat("f(@\"a\"\n" 6514 " @\"b\");"); 6515 verifyFormat("NSString s = @\"a\"\n" 6516 " @\"b\"\n" 6517 " @\"c\";"); 6518 verifyFormat("NSString s = @\"a\"\n" 6519 " \"b\"\n" 6520 " \"c\";"); 6521 } 6522 6523 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 6524 FormatStyle Style = getLLVMStyle(); 6525 // No declarations or definitions should be moved to own line. 6526 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 6527 verifyFormat("class A {\n" 6528 " int f() { return 1; }\n" 6529 " int g();\n" 6530 "};\n" 6531 "int f() { return 1; }\n" 6532 "int g();\n", 6533 Style); 6534 6535 // All declarations and definitions should have the return type moved to its 6536 // own 6537 // line. 6538 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 6539 verifyFormat("class E {\n" 6540 " int\n" 6541 " f() {\n" 6542 " return 1;\n" 6543 " }\n" 6544 " int\n" 6545 " g();\n" 6546 "};\n" 6547 "int\n" 6548 "f() {\n" 6549 " return 1;\n" 6550 "}\n" 6551 "int\n" 6552 "g();\n", 6553 Style); 6554 6555 // Top-level definitions, and no kinds of declarations should have the 6556 // return type moved to its own line. 6557 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 6558 verifyFormat("class B {\n" 6559 " int f() { return 1; }\n" 6560 " int g();\n" 6561 "};\n" 6562 "int\n" 6563 "f() {\n" 6564 " return 1;\n" 6565 "}\n" 6566 "int g();\n", 6567 Style); 6568 6569 // Top-level definitions and declarations should have the return type moved 6570 // to its own line. 6571 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 6572 verifyFormat("class C {\n" 6573 " int f() { return 1; }\n" 6574 " int g();\n" 6575 "};\n" 6576 "int\n" 6577 "f() {\n" 6578 " return 1;\n" 6579 "}\n" 6580 "int\n" 6581 "g();\n", 6582 Style); 6583 6584 // All definitions should have the return type moved to its own line, but no 6585 // kinds of declarations. 6586 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 6587 verifyFormat("class D {\n" 6588 " int\n" 6589 " f() {\n" 6590 " return 1;\n" 6591 " }\n" 6592 " int g();\n" 6593 "};\n" 6594 "int\n" 6595 "f() {\n" 6596 " return 1;\n" 6597 "}\n" 6598 "int g();\n", 6599 Style); 6600 verifyFormat("const char *\n" 6601 "f(void) {\n" // Break here. 6602 " return \"\";\n" 6603 "}\n" 6604 "const char *bar(void);\n", // No break here. 6605 Style); 6606 verifyFormat("template <class T>\n" 6607 "T *\n" 6608 "f(T &c) {\n" // Break here. 6609 " return NULL;\n" 6610 "}\n" 6611 "template <class T> T *f(T &c);\n", // No break here. 6612 Style); 6613 verifyFormat("class C {\n" 6614 " int\n" 6615 " operator+() {\n" 6616 " return 1;\n" 6617 " }\n" 6618 " int\n" 6619 " operator()() {\n" 6620 " return 1;\n" 6621 " }\n" 6622 "};\n", 6623 Style); 6624 verifyFormat("void\n" 6625 "A::operator()() {}\n" 6626 "void\n" 6627 "A::operator>>() {}\n" 6628 "void\n" 6629 "A::operator+() {}\n" 6630 "void\n" 6631 "A::operator*() {}\n" 6632 "void\n" 6633 "A::operator->() {}\n" 6634 "void\n" 6635 "A::operator void *() {}\n" 6636 "void\n" 6637 "A::operator void &() {}\n" 6638 "void\n" 6639 "A::operator void &&() {}\n" 6640 "void\n" 6641 "A::operator char *() {}\n" 6642 "void\n" 6643 "A::operator[]() {}\n" 6644 "void\n" 6645 "A::operator!() {}\n" 6646 "void\n" 6647 "A::operator**() {}\n" 6648 "void\n" 6649 "A::operator<Foo> *() {}\n" 6650 "void\n" 6651 "A::operator<Foo> **() {}\n" 6652 "void\n" 6653 "A::operator<Foo> &() {}\n" 6654 "void\n" 6655 "A::operator void **() {}\n", 6656 Style); 6657 verifyFormat("constexpr auto\n" 6658 "operator()() const -> reference {}\n" 6659 "constexpr auto\n" 6660 "operator>>() const -> reference {}\n" 6661 "constexpr auto\n" 6662 "operator+() const -> reference {}\n" 6663 "constexpr auto\n" 6664 "operator*() const -> reference {}\n" 6665 "constexpr auto\n" 6666 "operator->() const -> reference {}\n" 6667 "constexpr auto\n" 6668 "operator++() const -> reference {}\n" 6669 "constexpr auto\n" 6670 "operator void *() const -> reference {}\n" 6671 "constexpr auto\n" 6672 "operator void **() const -> reference {}\n" 6673 "constexpr auto\n" 6674 "operator void *() const -> reference {}\n" 6675 "constexpr auto\n" 6676 "operator void &() const -> reference {}\n" 6677 "constexpr auto\n" 6678 "operator void &&() const -> reference {}\n" 6679 "constexpr auto\n" 6680 "operator char *() const -> reference {}\n" 6681 "constexpr auto\n" 6682 "operator!() const -> reference {}\n" 6683 "constexpr auto\n" 6684 "operator[]() const -> reference {}\n", 6685 Style); 6686 verifyFormat("void *operator new(std::size_t s);", // No break here. 6687 Style); 6688 verifyFormat("void *\n" 6689 "operator new(std::size_t s) {}", 6690 Style); 6691 verifyFormat("void *\n" 6692 "operator delete[](void *ptr) {}", 6693 Style); 6694 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 6695 verifyFormat("const char *\n" 6696 "f(void)\n" // Break here. 6697 "{\n" 6698 " return \"\";\n" 6699 "}\n" 6700 "const char *bar(void);\n", // No break here. 6701 Style); 6702 verifyFormat("template <class T>\n" 6703 "T *\n" // Problem here: no line break 6704 "f(T &c)\n" // Break here. 6705 "{\n" 6706 " return NULL;\n" 6707 "}\n" 6708 "template <class T> T *f(T &c);\n", // No break here. 6709 Style); 6710 verifyFormat("int\n" 6711 "foo(A<bool> a)\n" 6712 "{\n" 6713 " return a;\n" 6714 "}\n", 6715 Style); 6716 verifyFormat("int\n" 6717 "foo(A<8> a)\n" 6718 "{\n" 6719 " return a;\n" 6720 "}\n", 6721 Style); 6722 verifyFormat("int\n" 6723 "foo(A<B<bool>, 8> a)\n" 6724 "{\n" 6725 " return a;\n" 6726 "}\n", 6727 Style); 6728 verifyFormat("int\n" 6729 "foo(A<B<8>, bool> a)\n" 6730 "{\n" 6731 " return a;\n" 6732 "}\n", 6733 Style); 6734 verifyFormat("int\n" 6735 "foo(A<B<bool>, bool> a)\n" 6736 "{\n" 6737 " return a;\n" 6738 "}\n", 6739 Style); 6740 verifyFormat("int\n" 6741 "foo(A<B<8>, 8> a)\n" 6742 "{\n" 6743 " return a;\n" 6744 "}\n", 6745 Style); 6746 6747 Style = getGNUStyle(); 6748 6749 // Test for comments at the end of function declarations. 6750 verifyFormat("void\n" 6751 "foo (int a, /*abc*/ int b) // def\n" 6752 "{\n" 6753 "}\n", 6754 Style); 6755 6756 verifyFormat("void\n" 6757 "foo (int a, /* abc */ int b) /* def */\n" 6758 "{\n" 6759 "}\n", 6760 Style); 6761 6762 // Definitions that should not break after return type 6763 verifyFormat("void foo (int a, int b); // def\n", Style); 6764 verifyFormat("void foo (int a, int b); /* def */\n", Style); 6765 verifyFormat("void foo (int a, int b);\n", Style); 6766 } 6767 6768 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 6769 FormatStyle NoBreak = getLLVMStyle(); 6770 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 6771 FormatStyle Break = getLLVMStyle(); 6772 Break.AlwaysBreakBeforeMultilineStrings = true; 6773 verifyFormat("aaaa = \"bbbb\"\n" 6774 " \"cccc\";", 6775 NoBreak); 6776 verifyFormat("aaaa =\n" 6777 " \"bbbb\"\n" 6778 " \"cccc\";", 6779 Break); 6780 verifyFormat("aaaa(\"bbbb\"\n" 6781 " \"cccc\");", 6782 NoBreak); 6783 verifyFormat("aaaa(\n" 6784 " \"bbbb\"\n" 6785 " \"cccc\");", 6786 Break); 6787 verifyFormat("aaaa(qqq, \"bbbb\"\n" 6788 " \"cccc\");", 6789 NoBreak); 6790 verifyFormat("aaaa(qqq,\n" 6791 " \"bbbb\"\n" 6792 " \"cccc\");", 6793 Break); 6794 verifyFormat("aaaa(qqq,\n" 6795 " L\"bbbb\"\n" 6796 " L\"cccc\");", 6797 Break); 6798 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 6799 " \"bbbb\"));", 6800 Break); 6801 verifyFormat("string s = someFunction(\n" 6802 " \"abc\"\n" 6803 " \"abc\");", 6804 Break); 6805 6806 // As we break before unary operators, breaking right after them is bad. 6807 verifyFormat("string foo = abc ? \"x\"\n" 6808 " \"blah blah blah blah blah blah\"\n" 6809 " : \"y\";", 6810 Break); 6811 6812 // Don't break if there is no column gain. 6813 verifyFormat("f(\"aaaa\"\n" 6814 " \"bbbb\");", 6815 Break); 6816 6817 // Treat literals with escaped newlines like multi-line string literals. 6818 EXPECT_EQ("x = \"a\\\n" 6819 "b\\\n" 6820 "c\";", 6821 format("x = \"a\\\n" 6822 "b\\\n" 6823 "c\";", 6824 NoBreak)); 6825 EXPECT_EQ("xxxx =\n" 6826 " \"a\\\n" 6827 "b\\\n" 6828 "c\";", 6829 format("xxxx = \"a\\\n" 6830 "b\\\n" 6831 "c\";", 6832 Break)); 6833 6834 EXPECT_EQ("NSString *const kString =\n" 6835 " @\"aaaa\"\n" 6836 " @\"bbbb\";", 6837 format("NSString *const kString = @\"aaaa\"\n" 6838 "@\"bbbb\";", 6839 Break)); 6840 6841 Break.ColumnLimit = 0; 6842 verifyFormat("const char *hello = \"hello llvm\";", Break); 6843 } 6844 6845 TEST_F(FormatTest, AlignsPipes) { 6846 verifyFormat( 6847 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6848 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6849 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6850 verifyFormat( 6851 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 6852 " << aaaaaaaaaaaaaaaaaaaa;"); 6853 verifyFormat( 6854 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6855 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6856 verifyFormat( 6857 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 6858 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6859 verifyFormat( 6860 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 6861 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 6862 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 6863 verifyFormat( 6864 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6865 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6866 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6867 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6868 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6869 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6870 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6871 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 6872 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 6873 verifyFormat( 6874 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6875 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6876 verifyFormat( 6877 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 6878 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6879 6880 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 6881 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 6882 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6883 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6884 " aaaaaaaaaaaaaaaaaaaaa)\n" 6885 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6886 verifyFormat("LOG_IF(aaa == //\n" 6887 " bbb)\n" 6888 " << a << b;"); 6889 6890 // But sometimes, breaking before the first "<<" is desirable. 6891 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6892 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 6893 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 6894 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6895 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6896 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 6897 " << BEF << IsTemplate << Description << E->getType();"); 6898 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6899 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6900 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6901 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6902 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6903 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6904 " << aaa;"); 6905 6906 verifyFormat( 6907 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6908 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6909 6910 // Incomplete string literal. 6911 EXPECT_EQ("llvm::errs() << \"\n" 6912 " << a;", 6913 format("llvm::errs() << \"\n<<a;")); 6914 6915 verifyFormat("void f() {\n" 6916 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 6917 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 6918 "}"); 6919 6920 // Handle 'endl'. 6921 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 6922 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6923 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6924 6925 // Handle '\n'. 6926 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 6927 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6928 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 6929 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 6930 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 6931 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 6932 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6933 } 6934 6935 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 6936 verifyFormat("return out << \"somepacket = {\\n\"\n" 6937 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 6938 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 6939 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 6940 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 6941 " << \"}\";"); 6942 6943 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6944 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6945 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 6946 verifyFormat( 6947 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 6948 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 6949 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 6950 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 6951 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 6952 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 6953 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6954 verifyFormat( 6955 "void f() {\n" 6956 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 6957 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 6958 "}"); 6959 6960 // Breaking before the first "<<" is generally not desirable. 6961 verifyFormat( 6962 "llvm::errs()\n" 6963 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6964 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6965 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6966 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6967 getLLVMStyleWithColumns(70)); 6968 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6969 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6970 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6971 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6972 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6973 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6974 getLLVMStyleWithColumns(70)); 6975 6976 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6977 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6978 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6979 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6980 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6981 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 6982 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 6983 " (aaaa + aaaa);", 6984 getLLVMStyleWithColumns(40)); 6985 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 6986 " (aaaaaaa + aaaaa));", 6987 getLLVMStyleWithColumns(40)); 6988 verifyFormat( 6989 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 6990 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 6991 " bbbbbbbbbbbbbbbbbbbbbbb);"); 6992 } 6993 6994 TEST_F(FormatTest, UnderstandsEquals) { 6995 verifyFormat( 6996 "aaaaaaaaaaaaaaaaa =\n" 6997 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6998 verifyFormat( 6999 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7000 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 7001 verifyFormat( 7002 "if (a) {\n" 7003 " f();\n" 7004 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7005 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 7006 "}"); 7007 7008 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7009 " 100000000 + 10000000) {\n}"); 7010 } 7011 7012 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 7013 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 7014 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 7015 7016 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 7017 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 7018 7019 verifyFormat( 7020 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 7021 " Parameter2);"); 7022 7023 verifyFormat( 7024 "ShortObject->shortFunction(\n" 7025 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 7026 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 7027 7028 verifyFormat("loooooooooooooongFunction(\n" 7029 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 7030 7031 verifyFormat( 7032 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 7033 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 7034 7035 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 7036 " .WillRepeatedly(Return(SomeValue));"); 7037 verifyFormat("void f() {\n" 7038 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 7039 " .Times(2)\n" 7040 " .WillRepeatedly(Return(SomeValue));\n" 7041 "}"); 7042 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 7043 " ccccccccccccccccccccccc);"); 7044 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7045 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 7046 " .aaaaa(aaaaa),\n" 7047 " aaaaaaaaaaaaaaaaaaaaa);"); 7048 verifyFormat("void f() {\n" 7049 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7050 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 7051 "}"); 7052 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7053 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 7054 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7055 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7056 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 7057 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7058 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7059 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7060 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 7061 "}"); 7062 7063 // Here, it is not necessary to wrap at "." or "->". 7064 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 7065 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 7066 verifyFormat( 7067 "aaaaaaaaaaa->aaaaaaaaa(\n" 7068 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7069 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 7070 7071 verifyFormat( 7072 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7073 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 7074 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 7075 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 7076 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 7077 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 7078 7079 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7080 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 7081 " .a();"); 7082 7083 FormatStyle NoBinPacking = getLLVMStyle(); 7084 NoBinPacking.BinPackParameters = false; 7085 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 7086 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 7087 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 7088 " aaaaaaaaaaaaaaaaaaa,\n" 7089 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 7090 NoBinPacking); 7091 7092 // If there is a subsequent call, change to hanging indentation. 7093 verifyFormat( 7094 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7095 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 7096 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 7097 verifyFormat( 7098 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7099 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 7100 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7101 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 7102 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 7103 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7104 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 7105 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 7106 } 7107 7108 TEST_F(FormatTest, WrapsTemplateDeclarations) { 7109 verifyFormat("template <typename T>\n" 7110 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 7111 verifyFormat("template <typename T>\n" 7112 "// T should be one of {A, B}.\n" 7113 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 7114 verifyFormat( 7115 "template <typename T>\n" 7116 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 7117 verifyFormat("template <typename T>\n" 7118 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 7119 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 7120 verifyFormat( 7121 "template <typename T>\n" 7122 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 7123 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 7124 verifyFormat( 7125 "template <typename T>\n" 7126 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 7127 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 7128 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7129 verifyFormat("template <typename T>\n" 7130 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7131 " int aaaaaaaaaaaaaaaaaaaaaa);"); 7132 verifyFormat( 7133 "template <typename T1, typename T2 = char, typename T3 = char,\n" 7134 " typename T4 = char>\n" 7135 "void f();"); 7136 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 7137 " template <typename> class cccccccccccccccccccccc,\n" 7138 " typename ddddddddddddd>\n" 7139 "class C {};"); 7140 verifyFormat( 7141 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 7142 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7143 7144 verifyFormat("void f() {\n" 7145 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 7146 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 7147 "}"); 7148 7149 verifyFormat("template <typename T> class C {};"); 7150 verifyFormat("template <typename T> void f();"); 7151 verifyFormat("template <typename T> void f() {}"); 7152 verifyFormat( 7153 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 7154 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7155 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 7156 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 7157 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7158 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 7159 " bbbbbbbbbbbbbbbbbbbbbbbb);", 7160 getLLVMStyleWithColumns(72)); 7161 EXPECT_EQ("static_cast<A< //\n" 7162 " B> *>(\n" 7163 "\n" 7164 ");", 7165 format("static_cast<A<//\n" 7166 " B>*>(\n" 7167 "\n" 7168 " );")); 7169 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7170 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 7171 7172 FormatStyle AlwaysBreak = getLLVMStyle(); 7173 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 7174 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 7175 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 7176 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 7177 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7178 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 7179 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 7180 verifyFormat("template <template <typename> class Fooooooo,\n" 7181 " template <typename> class Baaaaaaar>\n" 7182 "struct C {};", 7183 AlwaysBreak); 7184 verifyFormat("template <typename T> // T can be A, B or C.\n" 7185 "struct C {};", 7186 AlwaysBreak); 7187 verifyFormat("template <enum E> class A {\n" 7188 "public:\n" 7189 " E *f();\n" 7190 "};"); 7191 7192 FormatStyle NeverBreak = getLLVMStyle(); 7193 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 7194 verifyFormat("template <typename T> class C {};", NeverBreak); 7195 verifyFormat("template <typename T> void f();", NeverBreak); 7196 verifyFormat("template <typename T> void f() {}", NeverBreak); 7197 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 7198 "bbbbbbbbbbbbbbbbbbbb) {}", 7199 NeverBreak); 7200 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7201 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 7202 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 7203 NeverBreak); 7204 verifyFormat("template <template <typename> class Fooooooo,\n" 7205 " template <typename> class Baaaaaaar>\n" 7206 "struct C {};", 7207 NeverBreak); 7208 verifyFormat("template <typename T> // T can be A, B or C.\n" 7209 "struct C {};", 7210 NeverBreak); 7211 verifyFormat("template <enum E> class A {\n" 7212 "public:\n" 7213 " E *f();\n" 7214 "};", 7215 NeverBreak); 7216 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 7217 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 7218 "bbbbbbbbbbbbbbbbbbbb) {}", 7219 NeverBreak); 7220 } 7221 7222 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 7223 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 7224 Style.ColumnLimit = 60; 7225 EXPECT_EQ("// Baseline - no comments.\n" 7226 "template <\n" 7227 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 7228 "void f() {}", 7229 format("// Baseline - no comments.\n" 7230 "template <\n" 7231 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 7232 "void f() {}", 7233 Style)); 7234 7235 EXPECT_EQ("template <\n" 7236 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 7237 "void f() {}", 7238 format("template <\n" 7239 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 7240 "void f() {}", 7241 Style)); 7242 7243 EXPECT_EQ( 7244 "template <\n" 7245 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 7246 "void f() {}", 7247 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 7248 "void f() {}", 7249 Style)); 7250 7251 EXPECT_EQ( 7252 "template <\n" 7253 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 7254 " // multiline\n" 7255 "void f() {}", 7256 format("template <\n" 7257 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 7258 " // multiline\n" 7259 "void f() {}", 7260 Style)); 7261 7262 EXPECT_EQ( 7263 "template <typename aaaaaaaaaa<\n" 7264 " bbbbbbbbbbbb>::value> // trailing loooong\n" 7265 "void f() {}", 7266 format( 7267 "template <\n" 7268 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 7269 "void f() {}", 7270 Style)); 7271 } 7272 7273 TEST_F(FormatTest, WrapsTemplateParameters) { 7274 FormatStyle Style = getLLVMStyle(); 7275 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 7276 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 7277 verifyFormat( 7278 "template <typename... a> struct q {};\n" 7279 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 7280 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 7281 " y;", 7282 Style); 7283 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 7284 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 7285 verifyFormat( 7286 "template <typename... a> struct r {};\n" 7287 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 7288 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 7289 " y;", 7290 Style); 7291 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 7292 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 7293 verifyFormat("template <typename... a> struct s {};\n" 7294 "extern s<\n" 7295 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 7296 "aaaaaaaaaaaaaaaaaaaaaa,\n" 7297 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 7298 "aaaaaaaaaaaaaaaaaaaaaa>\n" 7299 " y;", 7300 Style); 7301 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 7302 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 7303 verifyFormat("template <typename... a> struct t {};\n" 7304 "extern t<\n" 7305 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 7306 "aaaaaaaaaaaaaaaaaaaaaa,\n" 7307 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 7308 "aaaaaaaaaaaaaaaaaaaaaa>\n" 7309 " y;", 7310 Style); 7311 } 7312 7313 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 7314 verifyFormat( 7315 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 7316 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 7317 verifyFormat( 7318 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 7319 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7320 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 7321 7322 // FIXME: Should we have the extra indent after the second break? 7323 verifyFormat( 7324 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 7325 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 7326 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 7327 7328 verifyFormat( 7329 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 7330 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 7331 7332 // Breaking at nested name specifiers is generally not desirable. 7333 verifyFormat( 7334 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7335 " aaaaaaaaaaaaaaaaaaaaaaa);"); 7336 7337 verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 7338 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 7339 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7340 " aaaaaaaaaaaaaaaaaaaaa);", 7341 getLLVMStyleWithColumns(74)); 7342 7343 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 7344 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7345 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 7346 } 7347 7348 TEST_F(FormatTest, UnderstandsTemplateParameters) { 7349 verifyFormat("A<int> a;"); 7350 verifyFormat("A<A<A<int>>> a;"); 7351 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 7352 verifyFormat("bool x = a < 1 || 2 > a;"); 7353 verifyFormat("bool x = 5 < f<int>();"); 7354 verifyFormat("bool x = f<int>() > 5;"); 7355 verifyFormat("bool x = 5 < a<int>::x;"); 7356 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 7357 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 7358 7359 verifyGoogleFormat("A<A<int>> a;"); 7360 verifyGoogleFormat("A<A<A<int>>> a;"); 7361 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 7362 verifyGoogleFormat("A<A<int> > a;"); 7363 verifyGoogleFormat("A<A<A<int> > > a;"); 7364 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 7365 verifyGoogleFormat("A<::A<int>> a;"); 7366 verifyGoogleFormat("A<::A> a;"); 7367 verifyGoogleFormat("A< ::A> a;"); 7368 verifyGoogleFormat("A< ::A<int> > a;"); 7369 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 7370 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 7371 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 7372 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 7373 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 7374 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 7375 7376 verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 7377 7378 // template closer followed by a token that starts with > or = 7379 verifyFormat("bool b = a<1> > 1;"); 7380 verifyFormat("bool b = a<1> >= 1;"); 7381 verifyFormat("int i = a<1> >> 1;"); 7382 FormatStyle Style = getLLVMStyle(); 7383 Style.SpaceBeforeAssignmentOperators = false; 7384 verifyFormat("bool b= a<1> == 1;", Style); 7385 verifyFormat("a<int> = 1;", Style); 7386 verifyFormat("a<int> >>= 1;", Style); 7387 7388 verifyFormat("test >> a >> b;"); 7389 verifyFormat("test << a >> b;"); 7390 7391 verifyFormat("f<int>();"); 7392 verifyFormat("template <typename T> void f() {}"); 7393 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 7394 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 7395 "sizeof(char)>::type>;"); 7396 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 7397 verifyFormat("f(a.operator()<A>());"); 7398 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7399 " .template operator()<A>());", 7400 getLLVMStyleWithColumns(35)); 7401 7402 // Not template parameters. 7403 verifyFormat("return a < b && c > d;"); 7404 verifyFormat("void f() {\n" 7405 " while (a < b && c > d) {\n" 7406 " }\n" 7407 "}"); 7408 verifyFormat("template <typename... Types>\n" 7409 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 7410 7411 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7412 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 7413 getLLVMStyleWithColumns(60)); 7414 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 7415 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 7416 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 7417 } 7418 7419 TEST_F(FormatTest, BitshiftOperatorWidth) { 7420 EXPECT_EQ("int a = 1 << 2; /* foo\n" 7421 " bar */", 7422 format("int a=1<<2; /* foo\n" 7423 " bar */")); 7424 7425 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 7426 " bar */", 7427 format("int b =256>>1 ; /* foo\n" 7428 " bar */")); 7429 } 7430 7431 TEST_F(FormatTest, UnderstandsBinaryOperators) { 7432 verifyFormat("COMPARE(a, ==, b);"); 7433 verifyFormat("auto s = sizeof...(Ts) - 1;"); 7434 } 7435 7436 TEST_F(FormatTest, UnderstandsPointersToMembers) { 7437 verifyFormat("int A::*x;"); 7438 verifyFormat("int (S::*func)(void *);"); 7439 verifyFormat("void f() { int (S::*func)(void *); }"); 7440 verifyFormat("typedef bool *(Class::*Member)() const;"); 7441 verifyFormat("void f() {\n" 7442 " (a->*f)();\n" 7443 " a->*x;\n" 7444 " (a.*f)();\n" 7445 " ((*a).*f)();\n" 7446 " a.*x;\n" 7447 "}"); 7448 verifyFormat("void f() {\n" 7449 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7450 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 7451 "}"); 7452 verifyFormat( 7453 "(aaaaaaaaaa->*bbbbbbb)(\n" 7454 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 7455 FormatStyle Style = getLLVMStyle(); 7456 Style.PointerAlignment = FormatStyle::PAS_Left; 7457 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 7458 } 7459 7460 TEST_F(FormatTest, UnderstandsUnaryOperators) { 7461 verifyFormat("int a = -2;"); 7462 verifyFormat("f(-1, -2, -3);"); 7463 verifyFormat("a[-1] = 5;"); 7464 verifyFormat("int a = 5 + -2;"); 7465 verifyFormat("if (i == -1) {\n}"); 7466 verifyFormat("if (i != -1) {\n}"); 7467 verifyFormat("if (i > -1) {\n}"); 7468 verifyFormat("if (i < -1) {\n}"); 7469 verifyFormat("++(a->f());"); 7470 verifyFormat("--(a->f());"); 7471 verifyFormat("(a->f())++;"); 7472 verifyFormat("a[42]++;"); 7473 verifyFormat("if (!(a->f())) {\n}"); 7474 verifyFormat("if (!+i) {\n}"); 7475 verifyFormat("~&a;"); 7476 7477 verifyFormat("a-- > b;"); 7478 verifyFormat("b ? -a : c;"); 7479 verifyFormat("n * sizeof char16;"); 7480 verifyFormat("n * alignof char16;", getGoogleStyle()); 7481 verifyFormat("sizeof(char);"); 7482 verifyFormat("alignof(char);", getGoogleStyle()); 7483 7484 verifyFormat("return -1;"); 7485 verifyFormat("throw -1;"); 7486 verifyFormat("switch (a) {\n" 7487 "case -1:\n" 7488 " break;\n" 7489 "}"); 7490 verifyFormat("#define X -1"); 7491 verifyFormat("#define X -kConstant"); 7492 7493 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 7494 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 7495 7496 verifyFormat("int a = /* confusing comment */ -1;"); 7497 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 7498 verifyFormat("int a = i /* confusing comment */++;"); 7499 7500 verifyFormat("co_yield -1;"); 7501 verifyFormat("co_return -1;"); 7502 } 7503 7504 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 7505 verifyFormat("if (!aaaaaaaaaa( // break\n" 7506 " aaaaa)) {\n" 7507 "}"); 7508 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 7509 " aaaaa));"); 7510 verifyFormat("*aaa = aaaaaaa( // break\n" 7511 " bbbbbb);"); 7512 } 7513 7514 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 7515 verifyFormat("bool operator<();"); 7516 verifyFormat("bool operator>();"); 7517 verifyFormat("bool operator=();"); 7518 verifyFormat("bool operator==();"); 7519 verifyFormat("bool operator!=();"); 7520 verifyFormat("int operator+();"); 7521 verifyFormat("int operator++();"); 7522 verifyFormat("int operator++(int) volatile noexcept;"); 7523 verifyFormat("bool operator,();"); 7524 verifyFormat("bool operator();"); 7525 verifyFormat("bool operator()();"); 7526 verifyFormat("bool operator[]();"); 7527 verifyFormat("operator bool();"); 7528 verifyFormat("operator int();"); 7529 verifyFormat("operator void *();"); 7530 verifyFormat("operator SomeType<int>();"); 7531 verifyFormat("operator SomeType<int, int>();"); 7532 verifyFormat("operator SomeType<SomeType<int>>();"); 7533 verifyFormat("void *operator new(std::size_t size);"); 7534 verifyFormat("void *operator new[](std::size_t size);"); 7535 verifyFormat("void operator delete(void *ptr);"); 7536 verifyFormat("void operator delete[](void *ptr);"); 7537 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 7538 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 7539 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 7540 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 7541 7542 verifyFormat( 7543 "ostream &operator<<(ostream &OutputStream,\n" 7544 " SomeReallyLongType WithSomeReallyLongValue);"); 7545 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 7546 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 7547 " return left.group < right.group;\n" 7548 "}"); 7549 verifyFormat("SomeType &operator=(const SomeType &S);"); 7550 verifyFormat("f.template operator()<int>();"); 7551 7552 verifyGoogleFormat("operator void*();"); 7553 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 7554 verifyGoogleFormat("operator ::A();"); 7555 7556 verifyFormat("using A::operator+;"); 7557 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 7558 "int i;"); 7559 } 7560 7561 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 7562 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 7563 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 7564 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 7565 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 7566 verifyFormat("Deleted &operator=(const Deleted &) &;"); 7567 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 7568 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 7569 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 7570 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 7571 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 7572 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 7573 verifyFormat("void Fn(T const &) const &;"); 7574 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 7575 verifyFormat("template <typename T>\n" 7576 "void F(T) && = delete;", 7577 getGoogleStyle()); 7578 7579 FormatStyle AlignLeft = getLLVMStyle(); 7580 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 7581 verifyFormat("void A::b() && {}", AlignLeft); 7582 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 7583 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 7584 AlignLeft); 7585 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 7586 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 7587 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 7588 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 7589 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 7590 verifyFormat("auto Function(T) & -> void;", AlignLeft); 7591 verifyFormat("void Fn(T const&) const&;", AlignLeft); 7592 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 7593 7594 FormatStyle Spaces = getLLVMStyle(); 7595 Spaces.SpacesInCStyleCastParentheses = true; 7596 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 7597 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 7598 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 7599 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 7600 7601 Spaces.SpacesInCStyleCastParentheses = false; 7602 Spaces.SpacesInParentheses = true; 7603 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 7604 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", 7605 Spaces); 7606 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 7607 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 7608 7609 FormatStyle BreakTemplate = getLLVMStyle(); 7610 BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 7611 7612 verifyFormat("struct f {\n" 7613 " template <class T>\n" 7614 " int &foo(const std::string &str) &noexcept {}\n" 7615 "};", 7616 BreakTemplate); 7617 7618 verifyFormat("struct f {\n" 7619 " template <class T>\n" 7620 " int &foo(const std::string &str) &&noexcept {}\n" 7621 "};", 7622 BreakTemplate); 7623 7624 verifyFormat("struct f {\n" 7625 " template <class T>\n" 7626 " int &foo(const std::string &str) const &noexcept {}\n" 7627 "};", 7628 BreakTemplate); 7629 7630 verifyFormat("struct f {\n" 7631 " template <class T>\n" 7632 " int &foo(const std::string &str) const &noexcept {}\n" 7633 "};", 7634 BreakTemplate); 7635 7636 verifyFormat("struct f {\n" 7637 " template <class T>\n" 7638 " auto foo(const std::string &str) &&noexcept -> int & {}\n" 7639 "};", 7640 BreakTemplate); 7641 7642 FormatStyle AlignLeftBreakTemplate = getLLVMStyle(); 7643 AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations = 7644 FormatStyle::BTDS_Yes; 7645 AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left; 7646 7647 verifyFormat("struct f {\n" 7648 " template <class T>\n" 7649 " int& foo(const std::string& str) & noexcept {}\n" 7650 "};", 7651 AlignLeftBreakTemplate); 7652 7653 verifyFormat("struct f {\n" 7654 " template <class T>\n" 7655 " int& foo(const std::string& str) && noexcept {}\n" 7656 "};", 7657 AlignLeftBreakTemplate); 7658 7659 verifyFormat("struct f {\n" 7660 " template <class T>\n" 7661 " int& foo(const std::string& str) const& noexcept {}\n" 7662 "};", 7663 AlignLeftBreakTemplate); 7664 7665 verifyFormat("struct f {\n" 7666 " template <class T>\n" 7667 " int& foo(const std::string& str) const&& noexcept {}\n" 7668 "};", 7669 AlignLeftBreakTemplate); 7670 7671 verifyFormat("struct f {\n" 7672 " template <class T>\n" 7673 " auto foo(const std::string& str) && noexcept -> int& {}\n" 7674 "};", 7675 AlignLeftBreakTemplate); 7676 7677 // The `&` in `Type&` should not be confused with a trailing `&` of 7678 // DEPRECATED(reason) member function. 7679 verifyFormat("struct f {\n" 7680 " template <class T>\n" 7681 " DEPRECATED(reason)\n" 7682 " Type &foo(arguments) {}\n" 7683 "};", 7684 BreakTemplate); 7685 7686 verifyFormat("struct f {\n" 7687 " template <class T>\n" 7688 " DEPRECATED(reason)\n" 7689 " Type& foo(arguments) {}\n" 7690 "};", 7691 AlignLeftBreakTemplate); 7692 7693 verifyFormat("void (*foopt)(int) = &func;"); 7694 } 7695 7696 TEST_F(FormatTest, UnderstandsNewAndDelete) { 7697 verifyFormat("void f() {\n" 7698 " A *a = new A;\n" 7699 " A *a = new (placement) A;\n" 7700 " delete a;\n" 7701 " delete (A *)a;\n" 7702 "}"); 7703 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7704 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7705 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7706 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7707 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7708 verifyFormat("delete[] h->p;"); 7709 } 7710 7711 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 7712 verifyFormat("int *f(int *a) {}"); 7713 verifyFormat("int main(int argc, char **argv) {}"); 7714 verifyFormat("Test::Test(int b) : a(b * b) {}"); 7715 verifyIndependentOfContext("f(a, *a);"); 7716 verifyFormat("void g() { f(*a); }"); 7717 verifyIndependentOfContext("int a = b * 10;"); 7718 verifyIndependentOfContext("int a = 10 * b;"); 7719 verifyIndependentOfContext("int a = b * c;"); 7720 verifyIndependentOfContext("int a += b * c;"); 7721 verifyIndependentOfContext("int a -= b * c;"); 7722 verifyIndependentOfContext("int a *= b * c;"); 7723 verifyIndependentOfContext("int a /= b * c;"); 7724 verifyIndependentOfContext("int a = *b;"); 7725 verifyIndependentOfContext("int a = *b * c;"); 7726 verifyIndependentOfContext("int a = b * *c;"); 7727 verifyIndependentOfContext("int a = b * (10);"); 7728 verifyIndependentOfContext("S << b * (10);"); 7729 verifyIndependentOfContext("return 10 * b;"); 7730 verifyIndependentOfContext("return *b * *c;"); 7731 verifyIndependentOfContext("return a & ~b;"); 7732 verifyIndependentOfContext("f(b ? *c : *d);"); 7733 verifyIndependentOfContext("int a = b ? *c : *d;"); 7734 verifyIndependentOfContext("*b = a;"); 7735 verifyIndependentOfContext("a * ~b;"); 7736 verifyIndependentOfContext("a * !b;"); 7737 verifyIndependentOfContext("a * +b;"); 7738 verifyIndependentOfContext("a * -b;"); 7739 verifyIndependentOfContext("a * ++b;"); 7740 verifyIndependentOfContext("a * --b;"); 7741 verifyIndependentOfContext("a[4] * b;"); 7742 verifyIndependentOfContext("a[a * a] = 1;"); 7743 verifyIndependentOfContext("f() * b;"); 7744 verifyIndependentOfContext("a * [self dostuff];"); 7745 verifyIndependentOfContext("int x = a * (a + b);"); 7746 verifyIndependentOfContext("(a *)(a + b);"); 7747 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 7748 verifyIndependentOfContext("int *pa = (int *)&a;"); 7749 verifyIndependentOfContext("return sizeof(int **);"); 7750 verifyIndependentOfContext("return sizeof(int ******);"); 7751 verifyIndependentOfContext("return (int **&)a;"); 7752 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 7753 verifyFormat("void f(Type (*parameter)[10]) {}"); 7754 verifyFormat("void f(Type (¶meter)[10]) {}"); 7755 verifyGoogleFormat("return sizeof(int**);"); 7756 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 7757 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 7758 verifyFormat("auto a = [](int **&, int ***) {};"); 7759 verifyFormat("auto PointerBinding = [](const char *S) {};"); 7760 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 7761 verifyFormat("[](const decltype(*a) &value) {}"); 7762 verifyFormat("decltype(a * b) F();"); 7763 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 7764 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 7765 verifyIndependentOfContext("typedef void (*f)(int *a);"); 7766 verifyIndependentOfContext("int i{a * b};"); 7767 verifyIndependentOfContext("aaa && aaa->f();"); 7768 verifyIndependentOfContext("int x = ~*p;"); 7769 verifyFormat("Constructor() : a(a), area(width * height) {}"); 7770 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 7771 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 7772 verifyFormat("void f() { f(a, c * d); }"); 7773 verifyFormat("void f() { f(new a(), c * d); }"); 7774 verifyFormat("void f(const MyOverride &override);"); 7775 verifyFormat("void f(const MyFinal &final);"); 7776 verifyIndependentOfContext("bool a = f() && override.f();"); 7777 verifyIndependentOfContext("bool a = f() && final.f();"); 7778 7779 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 7780 7781 verifyIndependentOfContext("A<int *> a;"); 7782 verifyIndependentOfContext("A<int **> a;"); 7783 verifyIndependentOfContext("A<int *, int *> a;"); 7784 verifyIndependentOfContext("A<int *[]> a;"); 7785 verifyIndependentOfContext( 7786 "const char *const p = reinterpret_cast<const char *const>(q);"); 7787 verifyIndependentOfContext("A<int **, int **> a;"); 7788 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 7789 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 7790 verifyFormat("for (; a && b;) {\n}"); 7791 verifyFormat("bool foo = true && [] { return false; }();"); 7792 7793 verifyFormat( 7794 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7795 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7796 7797 verifyGoogleFormat("int const* a = &b;"); 7798 verifyGoogleFormat("**outparam = 1;"); 7799 verifyGoogleFormat("*outparam = a * b;"); 7800 verifyGoogleFormat("int main(int argc, char** argv) {}"); 7801 verifyGoogleFormat("A<int*> a;"); 7802 verifyGoogleFormat("A<int**> a;"); 7803 verifyGoogleFormat("A<int*, int*> a;"); 7804 verifyGoogleFormat("A<int**, int**> a;"); 7805 verifyGoogleFormat("f(b ? *c : *d);"); 7806 verifyGoogleFormat("int a = b ? *c : *d;"); 7807 verifyGoogleFormat("Type* t = **x;"); 7808 verifyGoogleFormat("Type* t = *++*x;"); 7809 verifyGoogleFormat("*++*x;"); 7810 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 7811 verifyGoogleFormat("Type* t = x++ * y;"); 7812 verifyGoogleFormat( 7813 "const char* const p = reinterpret_cast<const char* const>(q);"); 7814 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 7815 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 7816 verifyGoogleFormat("template <typename T>\n" 7817 "void f(int i = 0, SomeType** temps = NULL);"); 7818 7819 FormatStyle Left = getLLVMStyle(); 7820 Left.PointerAlignment = FormatStyle::PAS_Left; 7821 verifyFormat("x = *a(x) = *a(y);", Left); 7822 verifyFormat("for (;; *a = b) {\n}", Left); 7823 verifyFormat("return *this += 1;", Left); 7824 verifyFormat("throw *x;", Left); 7825 verifyFormat("delete *x;", Left); 7826 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 7827 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 7828 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 7829 verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left); 7830 verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left); 7831 verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left); 7832 7833 verifyIndependentOfContext("a = *(x + y);"); 7834 verifyIndependentOfContext("a = &(x + y);"); 7835 verifyIndependentOfContext("*(x + y).call();"); 7836 verifyIndependentOfContext("&(x + y)->call();"); 7837 verifyFormat("void f() { &(*I).first; }"); 7838 7839 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 7840 verifyFormat( 7841 "int *MyValues = {\n" 7842 " *A, // Operator detection might be confused by the '{'\n" 7843 " *BB // Operator detection might be confused by previous comment\n" 7844 "};"); 7845 7846 verifyIndependentOfContext("if (int *a = &b)"); 7847 verifyIndependentOfContext("if (int &a = *b)"); 7848 verifyIndependentOfContext("if (a & b[i])"); 7849 verifyIndependentOfContext("if constexpr (a & b[i])"); 7850 verifyIndependentOfContext("if CONSTEXPR (a & b[i])"); 7851 verifyIndependentOfContext("if (a * (b * c))"); 7852 verifyIndependentOfContext("if constexpr (a * (b * c))"); 7853 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))"); 7854 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 7855 verifyIndependentOfContext("if (*b[i])"); 7856 verifyIndependentOfContext("if (int *a = (&b))"); 7857 verifyIndependentOfContext("while (int *a = &b)"); 7858 verifyIndependentOfContext("while (a * (b * c))"); 7859 verifyIndependentOfContext("size = sizeof *a;"); 7860 verifyIndependentOfContext("if (a && (b = c))"); 7861 verifyFormat("void f() {\n" 7862 " for (const int &v : Values) {\n" 7863 " }\n" 7864 "}"); 7865 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 7866 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 7867 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 7868 7869 verifyFormat("#define A (!a * b)"); 7870 verifyFormat("#define MACRO \\\n" 7871 " int *i = a * b; \\\n" 7872 " void f(a *b);", 7873 getLLVMStyleWithColumns(19)); 7874 7875 verifyIndependentOfContext("A = new SomeType *[Length];"); 7876 verifyIndependentOfContext("A = new SomeType *[Length]();"); 7877 verifyIndependentOfContext("T **t = new T *;"); 7878 verifyIndependentOfContext("T **t = new T *();"); 7879 verifyGoogleFormat("A = new SomeType*[Length]();"); 7880 verifyGoogleFormat("A = new SomeType*[Length];"); 7881 verifyGoogleFormat("T** t = new T*;"); 7882 verifyGoogleFormat("T** t = new T*();"); 7883 7884 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 7885 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 7886 verifyFormat("template <bool a, bool b> " 7887 "typename t::if<x && y>::type f() {}"); 7888 verifyFormat("template <int *y> f() {}"); 7889 verifyFormat("vector<int *> v;"); 7890 verifyFormat("vector<int *const> v;"); 7891 verifyFormat("vector<int *const **const *> v;"); 7892 verifyFormat("vector<int *volatile> v;"); 7893 verifyFormat("vector<a * b> v;"); 7894 verifyFormat("foo<b && false>();"); 7895 verifyFormat("foo<b & 1>();"); 7896 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 7897 verifyFormat( 7898 "template <class T, class = typename std::enable_if<\n" 7899 " std::is_integral<T>::value &&\n" 7900 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 7901 "void F();", 7902 getLLVMStyleWithColumns(70)); 7903 verifyFormat("template <class T,\n" 7904 " class = typename std::enable_if<\n" 7905 " std::is_integral<T>::value &&\n" 7906 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 7907 " class U>\n" 7908 "void F();", 7909 getLLVMStyleWithColumns(70)); 7910 verifyFormat( 7911 "template <class T,\n" 7912 " class = typename ::std::enable_if<\n" 7913 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 7914 "void F();", 7915 getGoogleStyleWithColumns(68)); 7916 7917 verifyIndependentOfContext("MACRO(int *i);"); 7918 verifyIndependentOfContext("MACRO(auto *a);"); 7919 verifyIndependentOfContext("MACRO(const A *a);"); 7920 verifyIndependentOfContext("MACRO(A *const a);"); 7921 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 7922 verifyFormat("void f() { f(float{1}, a * a); }"); 7923 // FIXME: Is there a way to make this work? 7924 // verifyIndependentOfContext("MACRO(A *a);"); 7925 7926 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 7927 verifyFormat("return options != nullptr && operator==(*options);"); 7928 7929 EXPECT_EQ("#define OP(x) \\\n" 7930 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7931 " return s << a.DebugString(); \\\n" 7932 " }", 7933 format("#define OP(x) \\\n" 7934 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7935 " return s << a.DebugString(); \\\n" 7936 " }", 7937 getLLVMStyleWithColumns(50))); 7938 7939 // FIXME: We cannot handle this case yet; we might be able to figure out that 7940 // foo<x> d > v; doesn't make sense. 7941 verifyFormat("foo<a<b && c> d> v;"); 7942 7943 FormatStyle PointerMiddle = getLLVMStyle(); 7944 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7945 verifyFormat("delete *x;", PointerMiddle); 7946 verifyFormat("int * x;", PointerMiddle); 7947 verifyFormat("int *[] x;", PointerMiddle); 7948 verifyFormat("template <int * y> f() {}", PointerMiddle); 7949 verifyFormat("int * f(int * a) {}", PointerMiddle); 7950 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7951 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7952 verifyFormat("A<int *> a;", PointerMiddle); 7953 verifyFormat("A<int **> a;", PointerMiddle); 7954 verifyFormat("A<int *, int *> a;", PointerMiddle); 7955 verifyFormat("A<int *[]> a;", PointerMiddle); 7956 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7957 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7958 verifyFormat("T ** t = new T *;", PointerMiddle); 7959 7960 // Member function reference qualifiers aren't binary operators. 7961 verifyFormat("string // break\n" 7962 "operator()() & {}"); 7963 verifyFormat("string // break\n" 7964 "operator()() && {}"); 7965 verifyGoogleFormat("template <typename T>\n" 7966 "auto x() & -> int {}"); 7967 } 7968 7969 TEST_F(FormatTest, UnderstandsAttributes) { 7970 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7971 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7972 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7973 FormatStyle AfterType = getLLVMStyle(); 7974 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7975 verifyFormat("__attribute__((nodebug)) void\n" 7976 "foo() {}\n", 7977 AfterType); 7978 } 7979 7980 TEST_F(FormatTest, UnderstandsSquareAttributes) { 7981 verifyFormat("SomeType s [[unused]] (InitValue);"); 7982 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 7983 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 7984 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 7985 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 7986 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7987 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7988 verifyFormat("[[nodiscard]] bool f() { return false; }"); 7989 verifyFormat("class [[nodiscard]] f {\npublic:\n f() {}\n}"); 7990 verifyFormat("class [[deprecated(\"so sorry\")]] f {\npublic:\n f() {}\n}"); 7991 verifyFormat("class [[gnu::unused]] f {\npublic:\n f() {}\n}"); 7992 7993 // Make sure we do not mistake attributes for array subscripts. 7994 verifyFormat("int a() {}\n" 7995 "[[unused]] int b() {}\n"); 7996 verifyFormat("NSArray *arr;\n" 7997 "arr[[Foo() bar]];"); 7998 7999 // On the other hand, we still need to correctly find array subscripts. 8000 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 8001 8002 // Make sure that we do not mistake Objective-C method inside array literals 8003 // as attributes, even if those method names are also keywords. 8004 verifyFormat("@[ [foo bar] ];"); 8005 verifyFormat("@[ [NSArray class] ];"); 8006 verifyFormat("@[ [foo enum] ];"); 8007 8008 // Make sure we do not parse attributes as lambda introducers. 8009 FormatStyle MultiLineFunctions = getLLVMStyle(); 8010 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8011 verifyFormat("[[unused]] int b() {\n" 8012 " return 42;\n" 8013 "}\n", 8014 MultiLineFunctions); 8015 } 8016 8017 TEST_F(FormatTest, AttributePenaltyBreaking) { 8018 FormatStyle Style = getLLVMStyle(); 8019 verifyFormat("void ABCDEFGH::ABCDEFGHIJKLMN(\n" 8020 " [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}", 8021 Style); 8022 verifyFormat("void ABCDEFGH::ABCDEFGHIJK(\n" 8023 " [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}", 8024 Style); 8025 verifyFormat("void ABCDEFGH::ABCDEFGH([[maybe_unused]] const " 8026 "shared_ptr<ALongTypeName> &C d) {\n}", 8027 Style); 8028 } 8029 8030 TEST_F(FormatTest, UnderstandsEllipsis) { 8031 verifyFormat("int printf(const char *fmt, ...);"); 8032 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 8033 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 8034 8035 FormatStyle PointersLeft = getLLVMStyle(); 8036 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 8037 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 8038 } 8039 8040 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 8041 EXPECT_EQ("int *a;\n" 8042 "int *a;\n" 8043 "int *a;", 8044 format("int *a;\n" 8045 "int* a;\n" 8046 "int *a;", 8047 getGoogleStyle())); 8048 EXPECT_EQ("int* a;\n" 8049 "int* a;\n" 8050 "int* a;", 8051 format("int* a;\n" 8052 "int* a;\n" 8053 "int *a;", 8054 getGoogleStyle())); 8055 EXPECT_EQ("int *a;\n" 8056 "int *a;\n" 8057 "int *a;", 8058 format("int *a;\n" 8059 "int * a;\n" 8060 "int * a;", 8061 getGoogleStyle())); 8062 EXPECT_EQ("auto x = [] {\n" 8063 " int *a;\n" 8064 " int *a;\n" 8065 " int *a;\n" 8066 "};", 8067 format("auto x=[]{int *a;\n" 8068 "int * a;\n" 8069 "int * a;};", 8070 getGoogleStyle())); 8071 } 8072 8073 TEST_F(FormatTest, UnderstandsRvalueReferences) { 8074 verifyFormat("int f(int &&a) {}"); 8075 verifyFormat("int f(int a, char &&b) {}"); 8076 verifyFormat("void f() { int &&a = b; }"); 8077 verifyGoogleFormat("int f(int a, char&& b) {}"); 8078 verifyGoogleFormat("void f() { int&& a = b; }"); 8079 8080 verifyIndependentOfContext("A<int &&> a;"); 8081 verifyIndependentOfContext("A<int &&, int &&> a;"); 8082 verifyGoogleFormat("A<int&&> a;"); 8083 verifyGoogleFormat("A<int&&, int&&> a;"); 8084 8085 // Not rvalue references: 8086 verifyFormat("template <bool B, bool C> class A {\n" 8087 " static_assert(B && C, \"Something is wrong\");\n" 8088 "};"); 8089 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 8090 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 8091 verifyFormat("#define A(a, b) (a && b)"); 8092 } 8093 8094 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 8095 verifyFormat("void f() {\n" 8096 " x[aaaaaaaaa -\n" 8097 " b] = 23;\n" 8098 "}", 8099 getLLVMStyleWithColumns(15)); 8100 } 8101 8102 TEST_F(FormatTest, FormatsCasts) { 8103 verifyFormat("Type *A = static_cast<Type *>(P);"); 8104 verifyFormat("Type *A = (Type *)P;"); 8105 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 8106 verifyFormat("int a = (int)(2.0f);"); 8107 verifyFormat("int a = (int)2.0f;"); 8108 verifyFormat("x[(int32)y];"); 8109 verifyFormat("x = (int32)y;"); 8110 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 8111 verifyFormat("int a = (int)*b;"); 8112 verifyFormat("int a = (int)2.0f;"); 8113 verifyFormat("int a = (int)~0;"); 8114 verifyFormat("int a = (int)++a;"); 8115 verifyFormat("int a = (int)sizeof(int);"); 8116 verifyFormat("int a = (int)+2;"); 8117 verifyFormat("my_int a = (my_int)2.0f;"); 8118 verifyFormat("my_int a = (my_int)sizeof(int);"); 8119 verifyFormat("return (my_int)aaa;"); 8120 verifyFormat("#define x ((int)-1)"); 8121 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 8122 verifyFormat("#define p(q) ((int *)&q)"); 8123 verifyFormat("fn(a)(b) + 1;"); 8124 8125 verifyFormat("void f() { my_int a = (my_int)*b; }"); 8126 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 8127 verifyFormat("my_int a = (my_int)~0;"); 8128 verifyFormat("my_int a = (my_int)++a;"); 8129 verifyFormat("my_int a = (my_int)-2;"); 8130 verifyFormat("my_int a = (my_int)1;"); 8131 verifyFormat("my_int a = (my_int *)1;"); 8132 verifyFormat("my_int a = (const my_int)-1;"); 8133 verifyFormat("my_int a = (const my_int *)-1;"); 8134 verifyFormat("my_int a = (my_int)(my_int)-1;"); 8135 verifyFormat("my_int a = (ns::my_int)-2;"); 8136 verifyFormat("case (my_int)ONE:"); 8137 verifyFormat("auto x = (X)this;"); 8138 // Casts in Obj-C style calls used to not be recognized as such. 8139 verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle()); 8140 8141 // FIXME: single value wrapped with paren will be treated as cast. 8142 verifyFormat("void f(int i = (kValue)*kMask) {}"); 8143 8144 verifyFormat("{ (void)F; }"); 8145 8146 // Don't break after a cast's 8147 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 8148 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 8149 " bbbbbbbbbbbbbbbbbbbbbb);"); 8150 8151 // These are not casts. 8152 verifyFormat("void f(int *) {}"); 8153 verifyFormat("f(foo)->b;"); 8154 verifyFormat("f(foo).b;"); 8155 verifyFormat("f(foo)(b);"); 8156 verifyFormat("f(foo)[b];"); 8157 verifyFormat("[](foo) { return 4; }(bar);"); 8158 verifyFormat("(*funptr)(foo)[4];"); 8159 verifyFormat("funptrs[4](foo)[4];"); 8160 verifyFormat("void f(int *);"); 8161 verifyFormat("void f(int *) = 0;"); 8162 verifyFormat("void f(SmallVector<int>) {}"); 8163 verifyFormat("void f(SmallVector<int>);"); 8164 verifyFormat("void f(SmallVector<int>) = 0;"); 8165 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 8166 verifyFormat("int a = sizeof(int) * b;"); 8167 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 8168 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 8169 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 8170 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 8171 8172 // These are not casts, but at some point were confused with casts. 8173 verifyFormat("virtual void foo(int *) override;"); 8174 verifyFormat("virtual void foo(char &) const;"); 8175 verifyFormat("virtual void foo(int *a, char *) const;"); 8176 verifyFormat("int a = sizeof(int *) + b;"); 8177 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 8178 verifyFormat("bool b = f(g<int>) && c;"); 8179 verifyFormat("typedef void (*f)(int i) func;"); 8180 verifyFormat("void operator++(int) noexcept;"); 8181 verifyFormat("void operator++(int &) noexcept;"); 8182 verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t " 8183 "&) noexcept;"); 8184 verifyFormat( 8185 "void operator delete(std::size_t, const std::nothrow_t &) noexcept;"); 8186 verifyFormat("void operator delete(const std::nothrow_t &) noexcept;"); 8187 verifyFormat("void operator delete(std::nothrow_t &) noexcept;"); 8188 verifyFormat("void operator delete(nothrow_t &) noexcept;"); 8189 verifyFormat("void operator delete(foo &) noexcept;"); 8190 verifyFormat("void operator delete(foo) noexcept;"); 8191 verifyFormat("void operator delete(int) noexcept;"); 8192 verifyFormat("void operator delete(int &) noexcept;"); 8193 verifyFormat("void operator delete(int &) volatile noexcept;"); 8194 verifyFormat("void operator delete(int &) const"); 8195 verifyFormat("void operator delete(int &) = default"); 8196 verifyFormat("void operator delete(int &) = delete"); 8197 verifyFormat("void operator delete(int &) [[noreturn]]"); 8198 verifyFormat("void operator delete(int &) throw();"); 8199 verifyFormat("void operator delete(int &) throw(int);"); 8200 verifyFormat("auto operator delete(int &) -> int;"); 8201 verifyFormat("auto operator delete(int &) override"); 8202 verifyFormat("auto operator delete(int &) final"); 8203 8204 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 8205 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 8206 // FIXME: The indentation here is not ideal. 8207 verifyFormat( 8208 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8209 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 8210 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 8211 } 8212 8213 TEST_F(FormatTest, FormatsFunctionTypes) { 8214 verifyFormat("A<bool()> a;"); 8215 verifyFormat("A<SomeType()> a;"); 8216 verifyFormat("A<void (*)(int, std::string)> a;"); 8217 verifyFormat("A<void *(int)>;"); 8218 verifyFormat("void *(*a)(int *, SomeType *);"); 8219 verifyFormat("int (*func)(void *);"); 8220 verifyFormat("void f() { int (*func)(void *); }"); 8221 verifyFormat("template <class CallbackClass>\n" 8222 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 8223 8224 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 8225 verifyGoogleFormat("void* (*a)(int);"); 8226 verifyGoogleFormat( 8227 "template <class CallbackClass>\n" 8228 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 8229 8230 // Other constructs can look somewhat like function types: 8231 verifyFormat("A<sizeof(*x)> a;"); 8232 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 8233 verifyFormat("some_var = function(*some_pointer_var)[0];"); 8234 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 8235 verifyFormat("int x = f(&h)();"); 8236 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 8237 verifyFormat("std::function<\n" 8238 " LooooooooooongTemplatedType<\n" 8239 " SomeType>*(\n" 8240 " LooooooooooooooooongType type)>\n" 8241 " function;", 8242 getGoogleStyleWithColumns(40)); 8243 } 8244 8245 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 8246 verifyFormat("A (*foo_)[6];"); 8247 verifyFormat("vector<int> (*foo_)[6];"); 8248 } 8249 8250 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 8251 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 8252 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 8253 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 8254 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 8255 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 8256 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 8257 8258 // Different ways of ()-initializiation. 8259 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 8260 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 8261 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 8262 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 8263 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 8264 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 8265 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 8266 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 8267 8268 // Lambdas should not confuse the variable declaration heuristic. 8269 verifyFormat("LooooooooooooooooongType\n" 8270 " variable(nullptr, [](A *a) {});", 8271 getLLVMStyleWithColumns(40)); 8272 } 8273 8274 TEST_F(FormatTest, BreaksLongDeclarations) { 8275 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 8276 " AnotherNameForTheLongType;"); 8277 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 8278 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 8279 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 8280 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 8281 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 8282 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 8283 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 8284 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 8285 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 8286 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 8287 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 8288 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 8289 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 8290 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 8291 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 8292 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 8293 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 8294 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 8295 FormatStyle Indented = getLLVMStyle(); 8296 Indented.IndentWrappedFunctionNames = true; 8297 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 8298 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 8299 Indented); 8300 verifyFormat( 8301 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 8302 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 8303 Indented); 8304 verifyFormat( 8305 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 8306 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 8307 Indented); 8308 verifyFormat( 8309 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 8310 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 8311 Indented); 8312 8313 // FIXME: Without the comment, this breaks after "(". 8314 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 8315 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 8316 getGoogleStyle()); 8317 8318 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 8319 " int LoooooooooooooooooooongParam2) {}"); 8320 verifyFormat( 8321 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 8322 " SourceLocation L, IdentifierIn *II,\n" 8323 " Type *T) {}"); 8324 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 8325 "ReallyReaaallyLongFunctionName(\n" 8326 " const std::string &SomeParameter,\n" 8327 " const SomeType<string, SomeOtherTemplateParameter>\n" 8328 " &ReallyReallyLongParameterName,\n" 8329 " const SomeType<string, SomeOtherTemplateParameter>\n" 8330 " &AnotherLongParameterName) {}"); 8331 verifyFormat("template <typename A>\n" 8332 "SomeLoooooooooooooooooooooongType<\n" 8333 " typename some_namespace::SomeOtherType<A>::Type>\n" 8334 "Function() {}"); 8335 8336 verifyGoogleFormat( 8337 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 8338 " aaaaaaaaaaaaaaaaaaaaaaa;"); 8339 verifyGoogleFormat( 8340 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 8341 " SourceLocation L) {}"); 8342 verifyGoogleFormat( 8343 "some_namespace::LongReturnType\n" 8344 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 8345 " int first_long_parameter, int second_parameter) {}"); 8346 8347 verifyGoogleFormat("template <typename T>\n" 8348 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 8349 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 8350 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8351 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 8352 8353 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 8354 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8355 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 8356 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 8357 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 8358 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 8359 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 8360 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 8361 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 8362 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 8363 8364 verifyFormat("template <typename T> // Templates on own line.\n" 8365 "static int // Some comment.\n" 8366 "MyFunction(int a);", 8367 getLLVMStyle()); 8368 } 8369 8370 TEST_F(FormatTest, FormatsArrays) { 8371 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 8372 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 8373 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 8374 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 8375 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 8376 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 8377 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8378 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 8379 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8380 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 8381 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 8382 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 8383 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 8384 verifyFormat( 8385 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 8386 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 8387 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 8388 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 8389 " .aaaaaaaaaaaaaaaaaaaaaa();"); 8390 8391 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 8392 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 8393 verifyFormat( 8394 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 8395 " .aaaaaaa[0]\n" 8396 " .aaaaaaaaaaaaaaaaaaaaaa();"); 8397 verifyFormat("a[::b::c];"); 8398 8399 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 8400 8401 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 8402 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 8403 } 8404 8405 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 8406 verifyFormat("(a)->b();"); 8407 verifyFormat("--a;"); 8408 } 8409 8410 TEST_F(FormatTest, HandlesIncludeDirectives) { 8411 verifyFormat("#include <string>\n" 8412 "#include <a/b/c.h>\n" 8413 "#include \"a/b/string\"\n" 8414 "#include \"string.h\"\n" 8415 "#include \"string.h\"\n" 8416 "#include <a-a>\n" 8417 "#include < path with space >\n" 8418 "#include_next <test.h>" 8419 "#include \"abc.h\" // this is included for ABC\n" 8420 "#include \"some long include\" // with a comment\n" 8421 "#include \"some very long include path\"\n" 8422 "#include <some/very/long/include/path>\n", 8423 getLLVMStyleWithColumns(35)); 8424 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 8425 EXPECT_EQ("#include <a>", format("#include<a>")); 8426 8427 verifyFormat("#import <string>"); 8428 verifyFormat("#import <a/b/c.h>"); 8429 verifyFormat("#import \"a/b/string\""); 8430 verifyFormat("#import \"string.h\""); 8431 verifyFormat("#import \"string.h\""); 8432 verifyFormat("#if __has_include(<strstream>)\n" 8433 "#include <strstream>\n" 8434 "#endif"); 8435 8436 verifyFormat("#define MY_IMPORT <a/b>"); 8437 8438 verifyFormat("#if __has_include(<a/b>)"); 8439 verifyFormat("#if __has_include_next(<a/b>)"); 8440 verifyFormat("#define F __has_include(<a/b>)"); 8441 verifyFormat("#define F __has_include_next(<a/b>)"); 8442 8443 // Protocol buffer definition or missing "#". 8444 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 8445 getLLVMStyleWithColumns(30)); 8446 8447 FormatStyle Style = getLLVMStyle(); 8448 Style.AlwaysBreakBeforeMultilineStrings = true; 8449 Style.ColumnLimit = 0; 8450 verifyFormat("#import \"abc.h\"", Style); 8451 8452 // But 'import' might also be a regular C++ namespace. 8453 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8454 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 8455 } 8456 8457 //===----------------------------------------------------------------------===// 8458 // Error recovery tests. 8459 //===----------------------------------------------------------------------===// 8460 8461 TEST_F(FormatTest, IncompleteParameterLists) { 8462 FormatStyle NoBinPacking = getLLVMStyle(); 8463 NoBinPacking.BinPackParameters = false; 8464 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 8465 " double *min_x,\n" 8466 " double *max_x,\n" 8467 " double *min_y,\n" 8468 " double *max_y,\n" 8469 " double *min_z,\n" 8470 " double *max_z, ) {}", 8471 NoBinPacking); 8472 } 8473 8474 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 8475 verifyFormat("void f() { return; }\n42"); 8476 verifyFormat("void f() {\n" 8477 " if (0)\n" 8478 " return;\n" 8479 "}\n" 8480 "42"); 8481 verifyFormat("void f() { return }\n42"); 8482 verifyFormat("void f() {\n" 8483 " if (0)\n" 8484 " return\n" 8485 "}\n" 8486 "42"); 8487 } 8488 8489 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 8490 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 8491 EXPECT_EQ("void f() {\n" 8492 " if (a)\n" 8493 " return\n" 8494 "}", 8495 format("void f ( ) { if ( a ) return }")); 8496 EXPECT_EQ("namespace N {\n" 8497 "void f()\n" 8498 "}", 8499 format("namespace N { void f() }")); 8500 EXPECT_EQ("namespace N {\n" 8501 "void f() {}\n" 8502 "void g()\n" 8503 "} // namespace N", 8504 format("namespace N { void f( ) { } void g( ) }")); 8505 } 8506 8507 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 8508 verifyFormat("int aaaaaaaa =\n" 8509 " // Overlylongcomment\n" 8510 " b;", 8511 getLLVMStyleWithColumns(20)); 8512 verifyFormat("function(\n" 8513 " ShortArgument,\n" 8514 " LoooooooooooongArgument);\n", 8515 getLLVMStyleWithColumns(20)); 8516 } 8517 8518 TEST_F(FormatTest, IncorrectAccessSpecifier) { 8519 verifyFormat("public:"); 8520 verifyFormat("class A {\n" 8521 "public\n" 8522 " void f() {}\n" 8523 "};"); 8524 verifyFormat("public\n" 8525 "int qwerty;"); 8526 verifyFormat("public\n" 8527 "B {}"); 8528 verifyFormat("public\n" 8529 "{}"); 8530 verifyFormat("public\n" 8531 "B { int x; }"); 8532 } 8533 8534 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 8535 verifyFormat("{"); 8536 verifyFormat("#})"); 8537 verifyNoCrash("(/**/[:!] ?[)."); 8538 } 8539 8540 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 8541 // Found by oss-fuzz: 8542 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 8543 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 8544 Style.ColumnLimit = 60; 8545 verifyNoCrash( 8546 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 8547 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 8548 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 8549 Style); 8550 } 8551 8552 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 8553 verifyFormat("do {\n}"); 8554 verifyFormat("do {\n}\n" 8555 "f();"); 8556 verifyFormat("do {\n}\n" 8557 "wheeee(fun);"); 8558 verifyFormat("do {\n" 8559 " f();\n" 8560 "}"); 8561 } 8562 8563 TEST_F(FormatTest, IncorrectCodeMissingParens) { 8564 verifyFormat("if {\n foo;\n foo();\n}"); 8565 verifyFormat("switch {\n foo;\n foo();\n}"); 8566 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 8567 verifyFormat("while {\n foo;\n foo();\n}"); 8568 verifyFormat("do {\n foo;\n foo();\n} while;"); 8569 } 8570 8571 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 8572 verifyIncompleteFormat("namespace {\n" 8573 "class Foo { Foo (\n" 8574 "};\n" 8575 "} // namespace"); 8576 } 8577 8578 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 8579 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 8580 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 8581 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 8582 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 8583 8584 EXPECT_EQ("{\n" 8585 " {\n" 8586 " breakme(\n" 8587 " qwe);\n" 8588 " }\n", 8589 format("{\n" 8590 " {\n" 8591 " breakme(qwe);\n" 8592 "}\n", 8593 getLLVMStyleWithColumns(10))); 8594 } 8595 8596 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 8597 verifyFormat("int x = {\n" 8598 " avariable,\n" 8599 " b(alongervariable)};", 8600 getLLVMStyleWithColumns(25)); 8601 } 8602 8603 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 8604 verifyFormat("return (a)(b){1, 2, 3};"); 8605 } 8606 8607 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 8608 verifyFormat("vector<int> x{1, 2, 3, 4};"); 8609 verifyFormat("vector<int> x{\n" 8610 " 1,\n" 8611 " 2,\n" 8612 " 3,\n" 8613 " 4,\n" 8614 "};"); 8615 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 8616 verifyFormat("f({1, 2});"); 8617 verifyFormat("auto v = Foo{-1};"); 8618 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 8619 verifyFormat("Class::Class : member{1, 2, 3} {}"); 8620 verifyFormat("new vector<int>{1, 2, 3};"); 8621 verifyFormat("new int[3]{1, 2, 3};"); 8622 verifyFormat("new int{1};"); 8623 verifyFormat("return {arg1, arg2};"); 8624 verifyFormat("return {arg1, SomeType{parameter}};"); 8625 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 8626 verifyFormat("new T{arg1, arg2};"); 8627 verifyFormat("f(MyMap[{composite, key}]);"); 8628 verifyFormat("class Class {\n" 8629 " T member = {arg1, arg2};\n" 8630 "};"); 8631 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 8632 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 8633 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 8634 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 8635 verifyFormat("int a = std::is_integral<int>{} + 0;"); 8636 8637 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8638 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8639 verifyFormat("auto i = decltype(x){};"); 8640 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 8641 verifyFormat("Node n{1, Node{1000}, //\n" 8642 " 2};"); 8643 verifyFormat("Aaaa aaaaaaa{\n" 8644 " {\n" 8645 " aaaa,\n" 8646 " },\n" 8647 "};"); 8648 verifyFormat("class C : public D {\n" 8649 " SomeClass SC{2};\n" 8650 "};"); 8651 verifyFormat("class C : public A {\n" 8652 " class D : public B {\n" 8653 " void f() { int i{2}; }\n" 8654 " };\n" 8655 "};"); 8656 verifyFormat("#define A {a, a},"); 8657 8658 // Avoid breaking between equal sign and opening brace 8659 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 8660 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 8661 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 8662 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 8663 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 8664 " {\"ccccccccccccccccccccc\", 2}};", 8665 AvoidBreakingFirstArgument); 8666 8667 // Binpacking only if there is no trailing comma 8668 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 8669 " cccccccccc, dddddddddd};", 8670 getLLVMStyleWithColumns(50)); 8671 verifyFormat("const Aaaaaa aaaaa = {\n" 8672 " aaaaaaaaaaa,\n" 8673 " bbbbbbbbbbb,\n" 8674 " ccccccccccc,\n" 8675 " ddddddddddd,\n" 8676 "};", 8677 getLLVMStyleWithColumns(50)); 8678 8679 // Cases where distinguising braced lists and blocks is hard. 8680 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 8681 verifyFormat("void f() {\n" 8682 " return; // comment\n" 8683 "}\n" 8684 "SomeType t;"); 8685 verifyFormat("void f() {\n" 8686 " if (a) {\n" 8687 " f();\n" 8688 " }\n" 8689 "}\n" 8690 "SomeType t;"); 8691 8692 // In combination with BinPackArguments = false. 8693 FormatStyle NoBinPacking = getLLVMStyle(); 8694 NoBinPacking.BinPackArguments = false; 8695 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 8696 " bbbbb,\n" 8697 " ccccc,\n" 8698 " ddddd,\n" 8699 " eeeee,\n" 8700 " ffffff,\n" 8701 " ggggg,\n" 8702 " hhhhhh,\n" 8703 " iiiiii,\n" 8704 " jjjjjj,\n" 8705 " kkkkkk};", 8706 NoBinPacking); 8707 verifyFormat("const Aaaaaa aaaaa = {\n" 8708 " aaaaa,\n" 8709 " bbbbb,\n" 8710 " ccccc,\n" 8711 " ddddd,\n" 8712 " eeeee,\n" 8713 " ffffff,\n" 8714 " ggggg,\n" 8715 " hhhhhh,\n" 8716 " iiiiii,\n" 8717 " jjjjjj,\n" 8718 " kkkkkk,\n" 8719 "};", 8720 NoBinPacking); 8721 verifyFormat( 8722 "const Aaaaaa aaaaa = {\n" 8723 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 8724 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 8725 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 8726 "};", 8727 NoBinPacking); 8728 8729 NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 8730 EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n" 8731 " CDDDP83848_BMCR_REGISTER,\n" 8732 " CDDDP83848_BMSR_REGISTER,\n" 8733 " CDDDP83848_RBR_REGISTER};", 8734 format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n" 8735 " CDDDP83848_BMSR_REGISTER,\n" 8736 " CDDDP83848_RBR_REGISTER};", 8737 NoBinPacking)); 8738 8739 // FIXME: The alignment of these trailing comments might be bad. Then again, 8740 // this might be utterly useless in real code. 8741 verifyFormat("Constructor::Constructor()\n" 8742 " : some_value{ //\n" 8743 " aaaaaaa, //\n" 8744 " bbbbbbb} {}"); 8745 8746 // In braced lists, the first comment is always assumed to belong to the 8747 // first element. Thus, it can be moved to the next or previous line as 8748 // appropriate. 8749 EXPECT_EQ("function({// First element:\n" 8750 " 1,\n" 8751 " // Second element:\n" 8752 " 2});", 8753 format("function({\n" 8754 " // First element:\n" 8755 " 1,\n" 8756 " // Second element:\n" 8757 " 2});")); 8758 EXPECT_EQ("std::vector<int> MyNumbers{\n" 8759 " // First element:\n" 8760 " 1,\n" 8761 " // Second element:\n" 8762 " 2};", 8763 format("std::vector<int> MyNumbers{// First element:\n" 8764 " 1,\n" 8765 " // Second element:\n" 8766 " 2};", 8767 getLLVMStyleWithColumns(30))); 8768 // A trailing comma should still lead to an enforced line break and no 8769 // binpacking. 8770 EXPECT_EQ("vector<int> SomeVector = {\n" 8771 " // aaa\n" 8772 " 1,\n" 8773 " 2,\n" 8774 "};", 8775 format("vector<int> SomeVector = { // aaa\n" 8776 " 1, 2, };")); 8777 8778 // C++11 brace initializer list l-braces should not be treated any differently 8779 // when breaking before lambda bodies is enabled 8780 FormatStyle BreakBeforeLambdaBody = getLLVMStyle(); 8781 BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom; 8782 BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true; 8783 BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true; 8784 verifyFormat( 8785 "std::runtime_error{\n" 8786 " \"Long string which will force a break onto the next line...\"};", 8787 BreakBeforeLambdaBody); 8788 8789 FormatStyle ExtraSpaces = getLLVMStyle(); 8790 ExtraSpaces.Cpp11BracedListStyle = false; 8791 ExtraSpaces.ColumnLimit = 75; 8792 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 8793 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 8794 verifyFormat("f({ 1, 2 });", ExtraSpaces); 8795 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 8796 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 8797 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 8798 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 8799 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 8800 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 8801 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 8802 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 8803 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 8804 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 8805 verifyFormat("class Class {\n" 8806 " T member = { arg1, arg2 };\n" 8807 "};", 8808 ExtraSpaces); 8809 verifyFormat( 8810 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8811 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 8812 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 8813 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 8814 ExtraSpaces); 8815 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 8816 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 8817 ExtraSpaces); 8818 verifyFormat( 8819 "someFunction(OtherParam,\n" 8820 " BracedList{ // comment 1 (Forcing interesting break)\n" 8821 " param1, param2,\n" 8822 " // comment 2\n" 8823 " param3, param4 });", 8824 ExtraSpaces); 8825 verifyFormat( 8826 "std::this_thread::sleep_for(\n" 8827 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 8828 ExtraSpaces); 8829 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 8830 " aaaaaaa,\n" 8831 " aaaaaaaaaa,\n" 8832 " aaaaa,\n" 8833 " aaaaaaaaaaaaaaa,\n" 8834 " aaa,\n" 8835 " aaaaaaaaaa,\n" 8836 " a,\n" 8837 " aaaaaaaaaaaaaaaaaaaaa,\n" 8838 " aaaaaaaaaaaa,\n" 8839 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 8840 " aaaaaaa,\n" 8841 " a};"); 8842 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 8843 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 8844 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 8845 8846 // Avoid breaking between initializer/equal sign and opening brace 8847 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 8848 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 8849 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8850 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8851 " { \"ccccccccccccccccccccc\", 2 }\n" 8852 "};", 8853 ExtraSpaces); 8854 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 8855 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8856 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8857 " { \"ccccccccccccccccccccc\", 2 }\n" 8858 "};", 8859 ExtraSpaces); 8860 8861 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 8862 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 8863 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 8864 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 8865 8866 FormatStyle SpaceBetweenBraces = getLLVMStyle(); 8867 SpaceBetweenBraces.SpacesInAngles = true; 8868 SpaceBetweenBraces.SpacesInParentheses = true; 8869 SpaceBetweenBraces.SpacesInSquareBrackets = true; 8870 verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces); 8871 verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces); 8872 verifyFormat("vector< int > x{ // comment 1\n" 8873 " 1, 2, 3, 4 };", 8874 SpaceBetweenBraces); 8875 SpaceBetweenBraces.ColumnLimit = 20; 8876 EXPECT_EQ("vector< int > x{\n" 8877 " 1, 2, 3, 4 };", 8878 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8879 SpaceBetweenBraces.ColumnLimit = 24; 8880 EXPECT_EQ("vector< int > x{ 1, 2,\n" 8881 " 3, 4 };", 8882 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8883 EXPECT_EQ("vector< int > x{\n" 8884 " 1,\n" 8885 " 2,\n" 8886 " 3,\n" 8887 " 4,\n" 8888 "};", 8889 format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces)); 8890 verifyFormat("vector< int > x{};", SpaceBetweenBraces); 8891 SpaceBetweenBraces.SpaceInEmptyParentheses = true; 8892 verifyFormat("vector< int > x{ };", SpaceBetweenBraces); 8893 } 8894 8895 TEST_F(FormatTest, FormatSpacesInAngles) { 8896 FormatStyle SpaceInAngles = getLLVMStyle(); 8897 SpaceInAngles.SpacesInAngles = true; 8898 verifyFormat("vector< ::std::string > x1;", SpaceInAngles); 8899 verifyFormat("Foo< int, Bar > x2;", SpaceInAngles); 8900 verifyFormat("Foo< ::int, ::Bar > x3;", SpaceInAngles); 8901 8902 SpaceInAngles.SpacesInAngles = false; 8903 verifyFormat("vector<::std::string> x4;", SpaceInAngles); 8904 verifyFormat("vector<int> x5;", SpaceInAngles); 8905 verifyFormat("Foo<int, Bar> x6;", SpaceInAngles); 8906 verifyFormat("Foo<::int, ::Bar> x7;", SpaceInAngles); 8907 } 8908 8909 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 8910 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8911 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8912 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8913 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8914 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8915 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8916 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 8917 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8918 " 1, 22, 333, 4444, 55555, //\n" 8919 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8920 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8921 verifyFormat( 8922 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8923 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8924 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 8925 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8926 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8927 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8928 " 7777777};"); 8929 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8930 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8931 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8932 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8933 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8934 " // Separating comment.\n" 8935 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8936 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8937 " // Leading comment\n" 8938 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8939 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8940 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8941 " 1, 1, 1, 1};", 8942 getLLVMStyleWithColumns(39)); 8943 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8944 " 1, 1, 1, 1};", 8945 getLLVMStyleWithColumns(38)); 8946 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 8947 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 8948 getLLVMStyleWithColumns(43)); 8949 verifyFormat( 8950 "static unsigned SomeValues[10][3] = {\n" 8951 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 8952 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 8953 verifyFormat("static auto fields = new vector<string>{\n" 8954 " \"aaaaaaaaaaaaa\",\n" 8955 " \"aaaaaaaaaaaaa\",\n" 8956 " \"aaaaaaaaaaaa\",\n" 8957 " \"aaaaaaaaaaaaaa\",\n" 8958 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8959 " \"aaaaaaaaaaaa\",\n" 8960 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8961 "};"); 8962 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 8963 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 8964 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 8965 " 3, cccccccccccccccccccccc};", 8966 getLLVMStyleWithColumns(60)); 8967 8968 // Trailing commas. 8969 verifyFormat("vector<int> x = {\n" 8970 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 8971 "};", 8972 getLLVMStyleWithColumns(39)); 8973 verifyFormat("vector<int> x = {\n" 8974 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 8975 "};", 8976 getLLVMStyleWithColumns(39)); 8977 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8978 " 1, 1, 1, 1,\n" 8979 " /**/ /**/};", 8980 getLLVMStyleWithColumns(39)); 8981 8982 // Trailing comment in the first line. 8983 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 8984 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 8985 " 111111111, 222222222, 3333333333, 444444444, //\n" 8986 " 11111111, 22222222, 333333333, 44444444};"); 8987 // Trailing comment in the last line. 8988 verifyFormat("int aaaaa[] = {\n" 8989 " 1, 2, 3, // comment\n" 8990 " 4, 5, 6 // comment\n" 8991 "};"); 8992 8993 // With nested lists, we should either format one item per line or all nested 8994 // lists one on line. 8995 // FIXME: For some nested lists, we can do better. 8996 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 8997 " {aaaaaaaaaaaaaaaaaaa},\n" 8998 " {aaaaaaaaaaaaaaaaaaaaa},\n" 8999 " {aaaaaaaaaaaaaaaaa}};", 9000 getLLVMStyleWithColumns(60)); 9001 verifyFormat( 9002 "SomeStruct my_struct_array = {\n" 9003 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 9004 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 9005 " {aaa, aaa},\n" 9006 " {aaa, aaa},\n" 9007 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 9008 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 9009 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 9010 9011 // No column layout should be used here. 9012 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 9013 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 9014 9015 verifyNoCrash("a<,"); 9016 9017 // No braced initializer here. 9018 verifyFormat("void f() {\n" 9019 " struct Dummy {};\n" 9020 " f(v);\n" 9021 "}"); 9022 9023 // Long lists should be formatted in columns even if they are nested. 9024 verifyFormat( 9025 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 9026 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 9027 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 9028 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 9029 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 9030 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 9031 9032 // Allow "single-column" layout even if that violates the column limit. There 9033 // isn't going to be a better way. 9034 verifyFormat("std::vector<int> a = {\n" 9035 " aaaaaaaa,\n" 9036 " aaaaaaaa,\n" 9037 " aaaaaaaa,\n" 9038 " aaaaaaaa,\n" 9039 " aaaaaaaaaa,\n" 9040 " aaaaaaaa,\n" 9041 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 9042 getLLVMStyleWithColumns(30)); 9043 verifyFormat("vector<int> aaaa = {\n" 9044 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 9045 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 9046 " aaaaaa.aaaaaaa,\n" 9047 " aaaaaa.aaaaaaa,\n" 9048 " aaaaaa.aaaaaaa,\n" 9049 " aaaaaa.aaaaaaa,\n" 9050 "};"); 9051 9052 // Don't create hanging lists. 9053 verifyFormat("someFunction(Param, {List1, List2,\n" 9054 " List3});", 9055 getLLVMStyleWithColumns(35)); 9056 verifyFormat("someFunction(Param, Param,\n" 9057 " {List1, List2,\n" 9058 " List3});", 9059 getLLVMStyleWithColumns(35)); 9060 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 9061 " aaaaaaaaaaaaaaaaaaaaaaa);"); 9062 } 9063 9064 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 9065 FormatStyle DoNotMerge = getLLVMStyle(); 9066 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 9067 9068 verifyFormat("void f() { return 42; }"); 9069 verifyFormat("void f() {\n" 9070 " return 42;\n" 9071 "}", 9072 DoNotMerge); 9073 verifyFormat("void f() {\n" 9074 " // Comment\n" 9075 "}"); 9076 verifyFormat("{\n" 9077 "#error {\n" 9078 " int a;\n" 9079 "}"); 9080 verifyFormat("{\n" 9081 " int a;\n" 9082 "#error {\n" 9083 "}"); 9084 verifyFormat("void f() {} // comment"); 9085 verifyFormat("void f() { int a; } // comment"); 9086 verifyFormat("void f() {\n" 9087 "} // comment", 9088 DoNotMerge); 9089 verifyFormat("void f() {\n" 9090 " int a;\n" 9091 "} // comment", 9092 DoNotMerge); 9093 verifyFormat("void f() {\n" 9094 "} // comment", 9095 getLLVMStyleWithColumns(15)); 9096 9097 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 9098 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 9099 9100 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 9101 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 9102 verifyFormat("class C {\n" 9103 " C()\n" 9104 " : iiiiiiii(nullptr),\n" 9105 " kkkkkkk(nullptr),\n" 9106 " mmmmmmm(nullptr),\n" 9107 " nnnnnnn(nullptr) {}\n" 9108 "};", 9109 getGoogleStyle()); 9110 9111 FormatStyle NoColumnLimit = getLLVMStyle(); 9112 NoColumnLimit.ColumnLimit = 0; 9113 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 9114 EXPECT_EQ("class C {\n" 9115 " A() : b(0) {}\n" 9116 "};", 9117 format("class C{A():b(0){}};", NoColumnLimit)); 9118 EXPECT_EQ("A()\n" 9119 " : b(0) {\n" 9120 "}", 9121 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 9122 9123 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 9124 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 9125 FormatStyle::SFS_None; 9126 EXPECT_EQ("A()\n" 9127 " : b(0) {\n" 9128 "}", 9129 format("A():b(0){}", DoNotMergeNoColumnLimit)); 9130 EXPECT_EQ("A()\n" 9131 " : b(0) {\n" 9132 "}", 9133 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 9134 9135 verifyFormat("#define A \\\n" 9136 " void f() { \\\n" 9137 " int i; \\\n" 9138 " }", 9139 getLLVMStyleWithColumns(20)); 9140 verifyFormat("#define A \\\n" 9141 " void f() { int i; }", 9142 getLLVMStyleWithColumns(21)); 9143 verifyFormat("#define A \\\n" 9144 " void f() { \\\n" 9145 " int i; \\\n" 9146 " } \\\n" 9147 " int j;", 9148 getLLVMStyleWithColumns(22)); 9149 verifyFormat("#define A \\\n" 9150 " void f() { int i; } \\\n" 9151 " int j;", 9152 getLLVMStyleWithColumns(23)); 9153 } 9154 9155 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 9156 FormatStyle MergeEmptyOnly = getLLVMStyle(); 9157 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 9158 verifyFormat("class C {\n" 9159 " int f() {}\n" 9160 "};", 9161 MergeEmptyOnly); 9162 verifyFormat("class C {\n" 9163 " int f() {\n" 9164 " return 42;\n" 9165 " }\n" 9166 "};", 9167 MergeEmptyOnly); 9168 verifyFormat("int f() {}", MergeEmptyOnly); 9169 verifyFormat("int f() {\n" 9170 " return 42;\n" 9171 "}", 9172 MergeEmptyOnly); 9173 9174 // Also verify behavior when BraceWrapping.AfterFunction = true 9175 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 9176 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 9177 verifyFormat("int f() {}", MergeEmptyOnly); 9178 verifyFormat("class C {\n" 9179 " int f() {}\n" 9180 "};", 9181 MergeEmptyOnly); 9182 } 9183 9184 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 9185 FormatStyle MergeInlineOnly = getLLVMStyle(); 9186 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 9187 verifyFormat("class C {\n" 9188 " int f() { return 42; }\n" 9189 "};", 9190 MergeInlineOnly); 9191 verifyFormat("int f() {\n" 9192 " return 42;\n" 9193 "}", 9194 MergeInlineOnly); 9195 9196 // SFS_Inline implies SFS_Empty 9197 verifyFormat("class C {\n" 9198 " int f() {}\n" 9199 "};", 9200 MergeInlineOnly); 9201 verifyFormat("int f() {}", MergeInlineOnly); 9202 9203 // Also verify behavior when BraceWrapping.AfterFunction = true 9204 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 9205 MergeInlineOnly.BraceWrapping.AfterFunction = true; 9206 verifyFormat("class C {\n" 9207 " int f() { return 42; }\n" 9208 "};", 9209 MergeInlineOnly); 9210 verifyFormat("int f()\n" 9211 "{\n" 9212 " return 42;\n" 9213 "}", 9214 MergeInlineOnly); 9215 9216 // SFS_Inline implies SFS_Empty 9217 verifyFormat("int f() {}", MergeInlineOnly); 9218 verifyFormat("class C {\n" 9219 " int f() {}\n" 9220 "};", 9221 MergeInlineOnly); 9222 } 9223 9224 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 9225 FormatStyle MergeInlineOnly = getLLVMStyle(); 9226 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 9227 FormatStyle::SFS_InlineOnly; 9228 verifyFormat("class C {\n" 9229 " int f() { return 42; }\n" 9230 "};", 9231 MergeInlineOnly); 9232 verifyFormat("int f() {\n" 9233 " return 42;\n" 9234 "}", 9235 MergeInlineOnly); 9236 9237 // SFS_InlineOnly does not imply SFS_Empty 9238 verifyFormat("class C {\n" 9239 " int f() {}\n" 9240 "};", 9241 MergeInlineOnly); 9242 verifyFormat("int f() {\n" 9243 "}", 9244 MergeInlineOnly); 9245 9246 // Also verify behavior when BraceWrapping.AfterFunction = true 9247 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 9248 MergeInlineOnly.BraceWrapping.AfterFunction = true; 9249 verifyFormat("class C {\n" 9250 " int f() { return 42; }\n" 9251 "};", 9252 MergeInlineOnly); 9253 verifyFormat("int f()\n" 9254 "{\n" 9255 " return 42;\n" 9256 "}", 9257 MergeInlineOnly); 9258 9259 // SFS_InlineOnly does not imply SFS_Empty 9260 verifyFormat("int f()\n" 9261 "{\n" 9262 "}", 9263 MergeInlineOnly); 9264 verifyFormat("class C {\n" 9265 " int f() {}\n" 9266 "};", 9267 MergeInlineOnly); 9268 } 9269 9270 TEST_F(FormatTest, SplitEmptyFunction) { 9271 FormatStyle Style = getLLVMStyle(); 9272 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 9273 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9274 Style.BraceWrapping.AfterFunction = true; 9275 Style.BraceWrapping.SplitEmptyFunction = false; 9276 Style.ColumnLimit = 40; 9277 9278 verifyFormat("int f()\n" 9279 "{}", 9280 Style); 9281 verifyFormat("int f()\n" 9282 "{\n" 9283 " return 42;\n" 9284 "}", 9285 Style); 9286 verifyFormat("int f()\n" 9287 "{\n" 9288 " // some comment\n" 9289 "}", 9290 Style); 9291 9292 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 9293 verifyFormat("int f() {}", Style); 9294 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 9295 "{}", 9296 Style); 9297 verifyFormat("int f()\n" 9298 "{\n" 9299 " return 0;\n" 9300 "}", 9301 Style); 9302 9303 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 9304 verifyFormat("class Foo {\n" 9305 " int f() {}\n" 9306 "};\n", 9307 Style); 9308 verifyFormat("class Foo {\n" 9309 " int f() { return 0; }\n" 9310 "};\n", 9311 Style); 9312 verifyFormat("class Foo {\n" 9313 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 9314 " {}\n" 9315 "};\n", 9316 Style); 9317 verifyFormat("class Foo {\n" 9318 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 9319 " {\n" 9320 " return 0;\n" 9321 " }\n" 9322 "};\n", 9323 Style); 9324 9325 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 9326 verifyFormat("int f() {}", Style); 9327 verifyFormat("int f() { return 0; }", Style); 9328 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 9329 "{}", 9330 Style); 9331 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 9332 "{\n" 9333 " return 0;\n" 9334 "}", 9335 Style); 9336 } 9337 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 9338 FormatStyle Style = getLLVMStyle(); 9339 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 9340 verifyFormat("#ifdef A\n" 9341 "int f() {}\n" 9342 "#else\n" 9343 "int g() {}\n" 9344 "#endif", 9345 Style); 9346 } 9347 9348 TEST_F(FormatTest, SplitEmptyClass) { 9349 FormatStyle Style = getLLVMStyle(); 9350 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9351 Style.BraceWrapping.AfterClass = true; 9352 Style.BraceWrapping.SplitEmptyRecord = false; 9353 9354 verifyFormat("class Foo\n" 9355 "{};", 9356 Style); 9357 verifyFormat("/* something */ class Foo\n" 9358 "{};", 9359 Style); 9360 verifyFormat("template <typename X> class Foo\n" 9361 "{};", 9362 Style); 9363 verifyFormat("class Foo\n" 9364 "{\n" 9365 " Foo();\n" 9366 "};", 9367 Style); 9368 verifyFormat("typedef class Foo\n" 9369 "{\n" 9370 "} Foo_t;", 9371 Style); 9372 } 9373 9374 TEST_F(FormatTest, SplitEmptyStruct) { 9375 FormatStyle Style = getLLVMStyle(); 9376 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9377 Style.BraceWrapping.AfterStruct = true; 9378 Style.BraceWrapping.SplitEmptyRecord = false; 9379 9380 verifyFormat("struct Foo\n" 9381 "{};", 9382 Style); 9383 verifyFormat("/* something */ struct Foo\n" 9384 "{};", 9385 Style); 9386 verifyFormat("template <typename X> struct Foo\n" 9387 "{};", 9388 Style); 9389 verifyFormat("struct Foo\n" 9390 "{\n" 9391 " Foo();\n" 9392 "};", 9393 Style); 9394 verifyFormat("typedef struct Foo\n" 9395 "{\n" 9396 "} Foo_t;", 9397 Style); 9398 // typedef struct Bar {} Bar_t; 9399 } 9400 9401 TEST_F(FormatTest, SplitEmptyUnion) { 9402 FormatStyle Style = getLLVMStyle(); 9403 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9404 Style.BraceWrapping.AfterUnion = true; 9405 Style.BraceWrapping.SplitEmptyRecord = false; 9406 9407 verifyFormat("union Foo\n" 9408 "{};", 9409 Style); 9410 verifyFormat("/* something */ union Foo\n" 9411 "{};", 9412 Style); 9413 verifyFormat("union Foo\n" 9414 "{\n" 9415 " A,\n" 9416 "};", 9417 Style); 9418 verifyFormat("typedef union Foo\n" 9419 "{\n" 9420 "} Foo_t;", 9421 Style); 9422 } 9423 9424 TEST_F(FormatTest, SplitEmptyNamespace) { 9425 FormatStyle Style = getLLVMStyle(); 9426 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9427 Style.BraceWrapping.AfterNamespace = true; 9428 Style.BraceWrapping.SplitEmptyNamespace = false; 9429 9430 verifyFormat("namespace Foo\n" 9431 "{};", 9432 Style); 9433 verifyFormat("/* something */ namespace Foo\n" 9434 "{};", 9435 Style); 9436 verifyFormat("inline namespace Foo\n" 9437 "{};", 9438 Style); 9439 verifyFormat("/* something */ inline namespace Foo\n" 9440 "{};", 9441 Style); 9442 verifyFormat("export namespace Foo\n" 9443 "{};", 9444 Style); 9445 verifyFormat("namespace Foo\n" 9446 "{\n" 9447 "void Bar();\n" 9448 "};", 9449 Style); 9450 } 9451 9452 TEST_F(FormatTest, NeverMergeShortRecords) { 9453 FormatStyle Style = getLLVMStyle(); 9454 9455 verifyFormat("class Foo {\n" 9456 " Foo();\n" 9457 "};", 9458 Style); 9459 verifyFormat("typedef class Foo {\n" 9460 " Foo();\n" 9461 "} Foo_t;", 9462 Style); 9463 verifyFormat("struct Foo {\n" 9464 " Foo();\n" 9465 "};", 9466 Style); 9467 verifyFormat("typedef struct Foo {\n" 9468 " Foo();\n" 9469 "} Foo_t;", 9470 Style); 9471 verifyFormat("union Foo {\n" 9472 " A,\n" 9473 "};", 9474 Style); 9475 verifyFormat("typedef union Foo {\n" 9476 " A,\n" 9477 "} Foo_t;", 9478 Style); 9479 verifyFormat("namespace Foo {\n" 9480 "void Bar();\n" 9481 "};", 9482 Style); 9483 9484 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9485 Style.BraceWrapping.AfterClass = true; 9486 Style.BraceWrapping.AfterStruct = true; 9487 Style.BraceWrapping.AfterUnion = true; 9488 Style.BraceWrapping.AfterNamespace = true; 9489 verifyFormat("class Foo\n" 9490 "{\n" 9491 " Foo();\n" 9492 "};", 9493 Style); 9494 verifyFormat("typedef class Foo\n" 9495 "{\n" 9496 " Foo();\n" 9497 "} Foo_t;", 9498 Style); 9499 verifyFormat("struct Foo\n" 9500 "{\n" 9501 " Foo();\n" 9502 "};", 9503 Style); 9504 verifyFormat("typedef struct Foo\n" 9505 "{\n" 9506 " Foo();\n" 9507 "} Foo_t;", 9508 Style); 9509 verifyFormat("union Foo\n" 9510 "{\n" 9511 " A,\n" 9512 "};", 9513 Style); 9514 verifyFormat("typedef union Foo\n" 9515 "{\n" 9516 " A,\n" 9517 "} Foo_t;", 9518 Style); 9519 verifyFormat("namespace Foo\n" 9520 "{\n" 9521 "void Bar();\n" 9522 "};", 9523 Style); 9524 } 9525 9526 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 9527 // Elaborate type variable declarations. 9528 verifyFormat("struct foo a = {bar};\nint n;"); 9529 verifyFormat("class foo a = {bar};\nint n;"); 9530 verifyFormat("union foo a = {bar};\nint n;"); 9531 9532 // Elaborate types inside function definitions. 9533 verifyFormat("struct foo f() {}\nint n;"); 9534 verifyFormat("class foo f() {}\nint n;"); 9535 verifyFormat("union foo f() {}\nint n;"); 9536 9537 // Templates. 9538 verifyFormat("template <class X> void f() {}\nint n;"); 9539 verifyFormat("template <struct X> void f() {}\nint n;"); 9540 verifyFormat("template <union X> void f() {}\nint n;"); 9541 9542 // Actual definitions... 9543 verifyFormat("struct {\n} n;"); 9544 verifyFormat( 9545 "template <template <class T, class Y>, class Z> class X {\n} n;"); 9546 verifyFormat("union Z {\n int n;\n} x;"); 9547 verifyFormat("class MACRO Z {\n} n;"); 9548 verifyFormat("class MACRO(X) Z {\n} n;"); 9549 verifyFormat("class __attribute__(X) Z {\n} n;"); 9550 verifyFormat("class __declspec(X) Z {\n} n;"); 9551 verifyFormat("class A##B##C {\n} n;"); 9552 verifyFormat("class alignas(16) Z {\n} n;"); 9553 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 9554 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 9555 9556 // Redefinition from nested context: 9557 verifyFormat("class A::B::C {\n} n;"); 9558 9559 // Template definitions. 9560 verifyFormat( 9561 "template <typename F>\n" 9562 "Matcher(const Matcher<F> &Other,\n" 9563 " typename enable_if_c<is_base_of<F, T>::value &&\n" 9564 " !is_same<F, T>::value>::type * = 0)\n" 9565 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 9566 9567 // FIXME: This is still incorrectly handled at the formatter side. 9568 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 9569 verifyFormat("int i = SomeFunction(a<b, a> b);"); 9570 9571 // FIXME: 9572 // This now gets parsed incorrectly as class definition. 9573 // verifyFormat("class A<int> f() {\n}\nint n;"); 9574 9575 // Elaborate types where incorrectly parsing the structural element would 9576 // break the indent. 9577 verifyFormat("if (true)\n" 9578 " class X x;\n" 9579 "else\n" 9580 " f();\n"); 9581 9582 // This is simply incomplete. Formatting is not important, but must not crash. 9583 verifyFormat("class A:"); 9584 } 9585 9586 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 9587 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 9588 format("#error Leave all white!!!!! space* alone!\n")); 9589 EXPECT_EQ( 9590 "#warning Leave all white!!!!! space* alone!\n", 9591 format("#warning Leave all white!!!!! space* alone!\n")); 9592 EXPECT_EQ("#error 1", format(" # error 1")); 9593 EXPECT_EQ("#warning 1", format(" # warning 1")); 9594 } 9595 9596 TEST_F(FormatTest, FormatHashIfExpressions) { 9597 verifyFormat("#if AAAA && BBBB"); 9598 verifyFormat("#if (AAAA && BBBB)"); 9599 verifyFormat("#elif (AAAA && BBBB)"); 9600 // FIXME: Come up with a better indentation for #elif. 9601 verifyFormat( 9602 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 9603 " defined(BBBBBBBB)\n" 9604 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 9605 " defined(BBBBBBBB)\n" 9606 "#endif", 9607 getLLVMStyleWithColumns(65)); 9608 } 9609 9610 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 9611 FormatStyle AllowsMergedIf = getGoogleStyle(); 9612 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 9613 FormatStyle::SIS_WithoutElse; 9614 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 9615 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 9616 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 9617 EXPECT_EQ("if (true) return 42;", 9618 format("if (true)\nreturn 42;", AllowsMergedIf)); 9619 FormatStyle ShortMergedIf = AllowsMergedIf; 9620 ShortMergedIf.ColumnLimit = 25; 9621 verifyFormat("#define A \\\n" 9622 " if (true) return 42;", 9623 ShortMergedIf); 9624 verifyFormat("#define A \\\n" 9625 " f(); \\\n" 9626 " if (true)\n" 9627 "#define B", 9628 ShortMergedIf); 9629 verifyFormat("#define A \\\n" 9630 " f(); \\\n" 9631 " if (true)\n" 9632 "g();", 9633 ShortMergedIf); 9634 verifyFormat("{\n" 9635 "#ifdef A\n" 9636 " // Comment\n" 9637 " if (true) continue;\n" 9638 "#endif\n" 9639 " // Comment\n" 9640 " if (true) continue;\n" 9641 "}", 9642 ShortMergedIf); 9643 ShortMergedIf.ColumnLimit = 33; 9644 verifyFormat("#define A \\\n" 9645 " if constexpr (true) return 42;", 9646 ShortMergedIf); 9647 verifyFormat("#define A \\\n" 9648 " if CONSTEXPR (true) return 42;", 9649 ShortMergedIf); 9650 ShortMergedIf.ColumnLimit = 29; 9651 verifyFormat("#define A \\\n" 9652 " if (aaaaaaaaaa) return 1; \\\n" 9653 " return 2;", 9654 ShortMergedIf); 9655 ShortMergedIf.ColumnLimit = 28; 9656 verifyFormat("#define A \\\n" 9657 " if (aaaaaaaaaa) \\\n" 9658 " return 1; \\\n" 9659 " return 2;", 9660 ShortMergedIf); 9661 verifyFormat("#define A \\\n" 9662 " if constexpr (aaaaaaa) \\\n" 9663 " return 1; \\\n" 9664 " return 2;", 9665 ShortMergedIf); 9666 verifyFormat("#define A \\\n" 9667 " if CONSTEXPR (aaaaaaa) \\\n" 9668 " return 1; \\\n" 9669 " return 2;", 9670 ShortMergedIf); 9671 } 9672 9673 TEST_F(FormatTest, FormatStarDependingOnContext) { 9674 verifyFormat("void f(int *a);"); 9675 verifyFormat("void f() { f(fint * b); }"); 9676 verifyFormat("class A {\n void f(int *a);\n};"); 9677 verifyFormat("class A {\n int *a;\n};"); 9678 verifyFormat("namespace a {\n" 9679 "namespace b {\n" 9680 "class A {\n" 9681 " void f() {}\n" 9682 " int *a;\n" 9683 "};\n" 9684 "} // namespace b\n" 9685 "} // namespace a"); 9686 } 9687 9688 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 9689 verifyFormat("while"); 9690 verifyFormat("operator"); 9691 } 9692 9693 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 9694 // This code would be painfully slow to format if we didn't skip it. 9695 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 9696 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9697 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9698 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9699 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9700 "A(1, 1)\n" 9701 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 9702 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9703 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9704 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9705 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9706 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9707 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9708 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9709 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9710 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 9711 // Deeply nested part is untouched, rest is formatted. 9712 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 9713 format(std::string("int i;\n") + Code + "int j;\n", 9714 getLLVMStyle(), SC_ExpectIncomplete)); 9715 } 9716 9717 //===----------------------------------------------------------------------===// 9718 // Objective-C tests. 9719 //===----------------------------------------------------------------------===// 9720 9721 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 9722 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 9723 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 9724 format("-(NSUInteger)indexOfObject:(id)anObject;")); 9725 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 9726 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 9727 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 9728 format("-(NSInteger)Method3:(id)anObject;")); 9729 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 9730 format("-(NSInteger)Method4:(id)anObject;")); 9731 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 9732 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 9733 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 9734 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 9735 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9736 "forAllCells:(BOOL)flag;", 9737 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9738 "forAllCells:(BOOL)flag;")); 9739 9740 // Very long objectiveC method declaration. 9741 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 9742 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 9743 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 9744 " inRange:(NSRange)range\n" 9745 " outRange:(NSRange)out_range\n" 9746 " outRange1:(NSRange)out_range1\n" 9747 " outRange2:(NSRange)out_range2\n" 9748 " outRange3:(NSRange)out_range3\n" 9749 " outRange4:(NSRange)out_range4\n" 9750 " outRange5:(NSRange)out_range5\n" 9751 " outRange6:(NSRange)out_range6\n" 9752 " outRange7:(NSRange)out_range7\n" 9753 " outRange8:(NSRange)out_range8\n" 9754 " outRange9:(NSRange)out_range9;"); 9755 9756 // When the function name has to be wrapped. 9757 FormatStyle Style = getLLVMStyle(); 9758 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 9759 // and always indents instead. 9760 Style.IndentWrappedFunctionNames = false; 9761 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9762 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 9763 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 9764 "}", 9765 Style); 9766 Style.IndentWrappedFunctionNames = true; 9767 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9768 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 9769 " anotherName:(NSString)dddddddddddddd {\n" 9770 "}", 9771 Style); 9772 9773 verifyFormat("- (int)sum:(vector<int>)numbers;"); 9774 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 9775 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 9776 // protocol lists (but not for template classes): 9777 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 9778 9779 verifyFormat("- (int (*)())foo:(int (*)())f;"); 9780 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 9781 9782 // If there's no return type (very rare in practice!), LLVM and Google style 9783 // agree. 9784 verifyFormat("- foo;"); 9785 verifyFormat("- foo:(int)f;"); 9786 verifyGoogleFormat("- foo:(int)foo;"); 9787 } 9788 9789 TEST_F(FormatTest, BreaksStringLiterals) { 9790 EXPECT_EQ("\"some text \"\n" 9791 "\"other\";", 9792 format("\"some text other\";", getLLVMStyleWithColumns(12))); 9793 EXPECT_EQ("\"some text \"\n" 9794 "\"other\";", 9795 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 9796 EXPECT_EQ( 9797 "#define A \\\n" 9798 " \"some \" \\\n" 9799 " \"text \" \\\n" 9800 " \"other\";", 9801 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 9802 EXPECT_EQ( 9803 "#define A \\\n" 9804 " \"so \" \\\n" 9805 " \"text \" \\\n" 9806 " \"other\";", 9807 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 9808 9809 EXPECT_EQ("\"some text\"", 9810 format("\"some text\"", getLLVMStyleWithColumns(1))); 9811 EXPECT_EQ("\"some text\"", 9812 format("\"some text\"", getLLVMStyleWithColumns(11))); 9813 EXPECT_EQ("\"some \"\n" 9814 "\"text\"", 9815 format("\"some text\"", getLLVMStyleWithColumns(10))); 9816 EXPECT_EQ("\"some \"\n" 9817 "\"text\"", 9818 format("\"some text\"", getLLVMStyleWithColumns(7))); 9819 EXPECT_EQ("\"some\"\n" 9820 "\" tex\"\n" 9821 "\"t\"", 9822 format("\"some text\"", getLLVMStyleWithColumns(6))); 9823 EXPECT_EQ("\"some\"\n" 9824 "\" tex\"\n" 9825 "\" and\"", 9826 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 9827 EXPECT_EQ("\"some\"\n" 9828 "\"/tex\"\n" 9829 "\"/and\"", 9830 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 9831 9832 EXPECT_EQ("variable =\n" 9833 " \"long string \"\n" 9834 " \"literal\";", 9835 format("variable = \"long string literal\";", 9836 getLLVMStyleWithColumns(20))); 9837 9838 EXPECT_EQ("variable = f(\n" 9839 " \"long string \"\n" 9840 " \"literal\",\n" 9841 " short,\n" 9842 " loooooooooooooooooooong);", 9843 format("variable = f(\"long string literal\", short, " 9844 "loooooooooooooooooooong);", 9845 getLLVMStyleWithColumns(20))); 9846 9847 EXPECT_EQ( 9848 "f(g(\"long string \"\n" 9849 " \"literal\"),\n" 9850 " b);", 9851 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 9852 EXPECT_EQ("f(g(\"long string \"\n" 9853 " \"literal\",\n" 9854 " a),\n" 9855 " b);", 9856 format("f(g(\"long string literal\", a), b);", 9857 getLLVMStyleWithColumns(20))); 9858 EXPECT_EQ( 9859 "f(\"one two\".split(\n" 9860 " variable));", 9861 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 9862 EXPECT_EQ("f(\"one two three four five six \"\n" 9863 " \"seven\".split(\n" 9864 " really_looooong_variable));", 9865 format("f(\"one two three four five six seven\"." 9866 "split(really_looooong_variable));", 9867 getLLVMStyleWithColumns(33))); 9868 9869 EXPECT_EQ("f(\"some \"\n" 9870 " \"text\",\n" 9871 " other);", 9872 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 9873 9874 // Only break as a last resort. 9875 verifyFormat( 9876 "aaaaaaaaaaaaaaaaaaaa(\n" 9877 " aaaaaaaaaaaaaaaaaaaa,\n" 9878 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 9879 9880 EXPECT_EQ("\"splitmea\"\n" 9881 "\"trandomp\"\n" 9882 "\"oint\"", 9883 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 9884 9885 EXPECT_EQ("\"split/\"\n" 9886 "\"pathat/\"\n" 9887 "\"slashes\"", 9888 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9889 9890 EXPECT_EQ("\"split/\"\n" 9891 "\"pathat/\"\n" 9892 "\"slashes\"", 9893 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9894 EXPECT_EQ("\"split at \"\n" 9895 "\"spaces/at/\"\n" 9896 "\"slashes.at.any$\"\n" 9897 "\"non-alphanumeric%\"\n" 9898 "\"1111111111characte\"\n" 9899 "\"rs\"", 9900 format("\"split at " 9901 "spaces/at/" 9902 "slashes.at." 9903 "any$non-" 9904 "alphanumeric%" 9905 "1111111111characte" 9906 "rs\"", 9907 getLLVMStyleWithColumns(20))); 9908 9909 // Verify that splitting the strings understands 9910 // Style::AlwaysBreakBeforeMultilineStrings. 9911 EXPECT_EQ("aaaaaaaaaaaa(\n" 9912 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 9913 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 9914 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 9915 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9916 "aaaaaaaaaaaaaaaaaaaaaa\");", 9917 getGoogleStyle())); 9918 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9919 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 9920 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 9921 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9922 "aaaaaaaaaaaaaaaaaaaaaa\";", 9923 getGoogleStyle())); 9924 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9925 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9926 format("llvm::outs() << " 9927 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 9928 "aaaaaaaaaaaaaaaaaaa\";")); 9929 EXPECT_EQ("ffff(\n" 9930 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9931 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9932 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 9933 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9934 getGoogleStyle())); 9935 9936 FormatStyle Style = getLLVMStyleWithColumns(12); 9937 Style.BreakStringLiterals = false; 9938 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 9939 9940 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 9941 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9942 EXPECT_EQ("#define A \\\n" 9943 " \"some \" \\\n" 9944 " \"text \" \\\n" 9945 " \"other\";", 9946 format("#define A \"some text other\";", AlignLeft)); 9947 } 9948 9949 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 9950 EXPECT_EQ("C a = \"some more \"\n" 9951 " \"text\";", 9952 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 9953 } 9954 9955 TEST_F(FormatTest, FullyRemoveEmptyLines) { 9956 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 9957 NoEmptyLines.MaxEmptyLinesToKeep = 0; 9958 EXPECT_EQ("int i = a(b());", 9959 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 9960 } 9961 9962 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 9963 EXPECT_EQ( 9964 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9965 "(\n" 9966 " \"x\t\");", 9967 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9968 "aaaaaaa(" 9969 "\"x\t\");")); 9970 } 9971 9972 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 9973 EXPECT_EQ( 9974 "u8\"utf8 string \"\n" 9975 "u8\"literal\";", 9976 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 9977 EXPECT_EQ( 9978 "u\"utf16 string \"\n" 9979 "u\"literal\";", 9980 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 9981 EXPECT_EQ( 9982 "U\"utf32 string \"\n" 9983 "U\"literal\";", 9984 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 9985 EXPECT_EQ("L\"wide string \"\n" 9986 "L\"literal\";", 9987 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 9988 EXPECT_EQ("@\"NSString \"\n" 9989 "@\"literal\";", 9990 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 9991 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 9992 9993 // This input makes clang-format try to split the incomplete unicode escape 9994 // sequence, which used to lead to a crasher. 9995 verifyNoCrash( 9996 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 9997 getLLVMStyleWithColumns(60)); 9998 } 9999 10000 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 10001 FormatStyle Style = getGoogleStyleWithColumns(15); 10002 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 10003 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 10004 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 10005 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 10006 EXPECT_EQ("u8R\"x(raw literal)x\";", 10007 format("u8R\"x(raw literal)x\";", Style)); 10008 } 10009 10010 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 10011 FormatStyle Style = getLLVMStyleWithColumns(20); 10012 EXPECT_EQ( 10013 "_T(\"aaaaaaaaaaaaaa\")\n" 10014 "_T(\"aaaaaaaaaaaaaa\")\n" 10015 "_T(\"aaaaaaaaaaaa\")", 10016 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 10017 EXPECT_EQ("f(x,\n" 10018 " _T(\"aaaaaaaaaaaa\")\n" 10019 " _T(\"aaa\"),\n" 10020 " z);", 10021 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 10022 10023 // FIXME: Handle embedded spaces in one iteration. 10024 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 10025 // "_T(\"aaaaaaaaaaaaa\")\n" 10026 // "_T(\"aaaaaaaaaaaaa\")\n" 10027 // "_T(\"a\")", 10028 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 10029 // getLLVMStyleWithColumns(20))); 10030 EXPECT_EQ( 10031 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 10032 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 10033 EXPECT_EQ("f(\n" 10034 "#if !TEST\n" 10035 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 10036 "#endif\n" 10037 ");", 10038 format("f(\n" 10039 "#if !TEST\n" 10040 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 10041 "#endif\n" 10042 ");")); 10043 EXPECT_EQ("f(\n" 10044 "\n" 10045 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 10046 format("f(\n" 10047 "\n" 10048 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 10049 } 10050 10051 TEST_F(FormatTest, BreaksStringLiteralOperands) { 10052 // In a function call with two operands, the second can be broken with no line 10053 // break before it. 10054 EXPECT_EQ( 10055 "func(a, \"long long \"\n" 10056 " \"long long\");", 10057 format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24))); 10058 // In a function call with three operands, the second must be broken with a 10059 // line break before it. 10060 EXPECT_EQ("func(a,\n" 10061 " \"long long long \"\n" 10062 " \"long\",\n" 10063 " c);", 10064 format("func(a, \"long long long long\", c);", 10065 getLLVMStyleWithColumns(24))); 10066 // In a function call with three operands, the third must be broken with a 10067 // line break before it. 10068 EXPECT_EQ("func(a, b,\n" 10069 " \"long long long \"\n" 10070 " \"long\");", 10071 format("func(a, b, \"long long long long\");", 10072 getLLVMStyleWithColumns(24))); 10073 // In a function call with three operands, both the second and the third must 10074 // be broken with a line break before them. 10075 EXPECT_EQ("func(a,\n" 10076 " \"long long long \"\n" 10077 " \"long\",\n" 10078 " \"long long long \"\n" 10079 " \"long\");", 10080 format("func(a, \"long long long long\", \"long long long long\");", 10081 getLLVMStyleWithColumns(24))); 10082 // In a chain of << with two operands, the second can be broken with no line 10083 // break before it. 10084 EXPECT_EQ("a << \"line line \"\n" 10085 " \"line\";", 10086 format("a << \"line line line\";", getLLVMStyleWithColumns(20))); 10087 // In a chain of << with three operands, the second can be broken with no line 10088 // break before it. 10089 EXPECT_EQ( 10090 "abcde << \"line \"\n" 10091 " \"line line\"\n" 10092 " << c;", 10093 format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20))); 10094 // In a chain of << with three operands, the third must be broken with a line 10095 // break before it. 10096 EXPECT_EQ( 10097 "a << b\n" 10098 " << \"line line \"\n" 10099 " \"line\";", 10100 format("a << b << \"line line line\";", getLLVMStyleWithColumns(20))); 10101 // In a chain of << with three operands, the second can be broken with no line 10102 // break before it and the third must be broken with a line break before it. 10103 EXPECT_EQ("abcd << \"line line \"\n" 10104 " \"line\"\n" 10105 " << \"line line \"\n" 10106 " \"line\";", 10107 format("abcd << \"line line line\" << \"line line line\";", 10108 getLLVMStyleWithColumns(20))); 10109 // In a chain of binary operators with two operands, the second can be broken 10110 // with no line break before it. 10111 EXPECT_EQ( 10112 "abcd + \"line line \"\n" 10113 " \"line line\";", 10114 format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20))); 10115 // In a chain of binary operators with three operands, the second must be 10116 // broken with a line break before it. 10117 EXPECT_EQ("abcd +\n" 10118 " \"line line \"\n" 10119 " \"line line\" +\n" 10120 " e;", 10121 format("abcd + \"line line line line\" + e;", 10122 getLLVMStyleWithColumns(20))); 10123 // In a function call with two operands, with AlignAfterOpenBracket enabled, 10124 // the first must be broken with a line break before it. 10125 FormatStyle Style = getLLVMStyleWithColumns(25); 10126 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 10127 EXPECT_EQ("someFunction(\n" 10128 " \"long long long \"\n" 10129 " \"long\",\n" 10130 " a);", 10131 format("someFunction(\"long long long long\", a);", Style)); 10132 } 10133 10134 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 10135 EXPECT_EQ( 10136 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 10137 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 10138 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 10139 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 10140 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 10141 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 10142 } 10143 10144 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 10145 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 10146 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 10147 EXPECT_EQ("fffffffffff(g(R\"x(\n" 10148 "multiline raw string literal xxxxxxxxxxxxxx\n" 10149 ")x\",\n" 10150 " a),\n" 10151 " b);", 10152 format("fffffffffff(g(R\"x(\n" 10153 "multiline raw string literal xxxxxxxxxxxxxx\n" 10154 ")x\", a), b);", 10155 getGoogleStyleWithColumns(20))); 10156 EXPECT_EQ("fffffffffff(\n" 10157 " g(R\"x(qqq\n" 10158 "multiline raw string literal xxxxxxxxxxxxxx\n" 10159 ")x\",\n" 10160 " a),\n" 10161 " b);", 10162 format("fffffffffff(g(R\"x(qqq\n" 10163 "multiline raw string literal xxxxxxxxxxxxxx\n" 10164 ")x\", a), b);", 10165 getGoogleStyleWithColumns(20))); 10166 10167 EXPECT_EQ("fffffffffff(R\"x(\n" 10168 "multiline raw string literal xxxxxxxxxxxxxx\n" 10169 ")x\");", 10170 format("fffffffffff(R\"x(\n" 10171 "multiline raw string literal xxxxxxxxxxxxxx\n" 10172 ")x\");", 10173 getGoogleStyleWithColumns(20))); 10174 EXPECT_EQ("fffffffffff(R\"x(\n" 10175 "multiline raw string literal xxxxxxxxxxxxxx\n" 10176 ")x\" + bbbbbb);", 10177 format("fffffffffff(R\"x(\n" 10178 "multiline raw string literal xxxxxxxxxxxxxx\n" 10179 ")x\" + bbbbbb);", 10180 getGoogleStyleWithColumns(20))); 10181 EXPECT_EQ("fffffffffff(\n" 10182 " R\"x(\n" 10183 "multiline raw string literal xxxxxxxxxxxxxx\n" 10184 ")x\" +\n" 10185 " bbbbbb);", 10186 format("fffffffffff(\n" 10187 " R\"x(\n" 10188 "multiline raw string literal xxxxxxxxxxxxxx\n" 10189 ")x\" + bbbbbb);", 10190 getGoogleStyleWithColumns(20))); 10191 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 10192 format("fffffffffff(\n" 10193 " R\"(single line raw string)\" + bbbbbb);")); 10194 } 10195 10196 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 10197 verifyFormat("string a = \"unterminated;"); 10198 EXPECT_EQ("function(\"unterminated,\n" 10199 " OtherParameter);", 10200 format("function( \"unterminated,\n" 10201 " OtherParameter);")); 10202 } 10203 10204 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 10205 FormatStyle Style = getLLVMStyle(); 10206 Style.Standard = FormatStyle::LS_Cpp03; 10207 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 10208 format("#define x(_a) printf(\"foo\"_a);", Style)); 10209 } 10210 10211 TEST_F(FormatTest, CppLexVersion) { 10212 FormatStyle Style = getLLVMStyle(); 10213 // Formatting of x * y differs if x is a type. 10214 verifyFormat("void foo() { MACRO(a * b); }", Style); 10215 verifyFormat("void foo() { MACRO(int *b); }", Style); 10216 10217 // LLVM style uses latest lexer. 10218 verifyFormat("void foo() { MACRO(char8_t *b); }", Style); 10219 Style.Standard = FormatStyle::LS_Cpp17; 10220 // But in c++17, char8_t isn't a keyword. 10221 verifyFormat("void foo() { MACRO(char8_t * b); }", Style); 10222 } 10223 10224 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 10225 10226 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 10227 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 10228 " \"ddeeefff\");", 10229 format("someFunction(\"aaabbbcccdddeeefff\");", 10230 getLLVMStyleWithColumns(25))); 10231 EXPECT_EQ("someFunction1234567890(\n" 10232 " \"aaabbbcccdddeeefff\");", 10233 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 10234 getLLVMStyleWithColumns(26))); 10235 EXPECT_EQ("someFunction1234567890(\n" 10236 " \"aaabbbcccdddeeeff\"\n" 10237 " \"f\");", 10238 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 10239 getLLVMStyleWithColumns(25))); 10240 EXPECT_EQ("someFunction1234567890(\n" 10241 " \"aaabbbcccdddeeeff\"\n" 10242 " \"f\");", 10243 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 10244 getLLVMStyleWithColumns(24))); 10245 EXPECT_EQ("someFunction(\n" 10246 " \"aaabbbcc ddde \"\n" 10247 " \"efff\");", 10248 format("someFunction(\"aaabbbcc ddde efff\");", 10249 getLLVMStyleWithColumns(25))); 10250 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 10251 " \"ddeeefff\");", 10252 format("someFunction(\"aaabbbccc ddeeefff\");", 10253 getLLVMStyleWithColumns(25))); 10254 EXPECT_EQ("someFunction1234567890(\n" 10255 " \"aaabb \"\n" 10256 " \"cccdddeeefff\");", 10257 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 10258 getLLVMStyleWithColumns(25))); 10259 EXPECT_EQ("#define A \\\n" 10260 " string s = \\\n" 10261 " \"123456789\" \\\n" 10262 " \"0\"; \\\n" 10263 " int i;", 10264 format("#define A string s = \"1234567890\"; int i;", 10265 getLLVMStyleWithColumns(20))); 10266 EXPECT_EQ("someFunction(\n" 10267 " \"aaabbbcc \"\n" 10268 " \"dddeeefff\");", 10269 format("someFunction(\"aaabbbcc dddeeefff\");", 10270 getLLVMStyleWithColumns(25))); 10271 } 10272 10273 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 10274 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 10275 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 10276 EXPECT_EQ("\"test\"\n" 10277 "\"\\n\"", 10278 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 10279 EXPECT_EQ("\"tes\\\\\"\n" 10280 "\"n\"", 10281 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 10282 EXPECT_EQ("\"\\\\\\\\\"\n" 10283 "\"\\n\"", 10284 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 10285 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 10286 EXPECT_EQ("\"\\uff01\"\n" 10287 "\"test\"", 10288 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 10289 EXPECT_EQ("\"\\Uff01ff02\"", 10290 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 10291 EXPECT_EQ("\"\\x000000000001\"\n" 10292 "\"next\"", 10293 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 10294 EXPECT_EQ("\"\\x000000000001next\"", 10295 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 10296 EXPECT_EQ("\"\\x000000000001\"", 10297 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 10298 EXPECT_EQ("\"test\"\n" 10299 "\"\\000000\"\n" 10300 "\"000001\"", 10301 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 10302 EXPECT_EQ("\"test\\000\"\n" 10303 "\"00000000\"\n" 10304 "\"1\"", 10305 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 10306 } 10307 10308 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 10309 verifyFormat("void f() {\n" 10310 " return g() {}\n" 10311 " void h() {}"); 10312 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 10313 "g();\n" 10314 "}"); 10315 } 10316 10317 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 10318 verifyFormat( 10319 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 10320 } 10321 10322 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 10323 verifyFormat("class X {\n" 10324 " void f() {\n" 10325 " }\n" 10326 "};", 10327 getLLVMStyleWithColumns(12)); 10328 } 10329 10330 TEST_F(FormatTest, ConfigurableIndentWidth) { 10331 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 10332 EightIndent.IndentWidth = 8; 10333 EightIndent.ContinuationIndentWidth = 8; 10334 verifyFormat("void f() {\n" 10335 " someFunction();\n" 10336 " if (true) {\n" 10337 " f();\n" 10338 " }\n" 10339 "}", 10340 EightIndent); 10341 verifyFormat("class X {\n" 10342 " void f() {\n" 10343 " }\n" 10344 "};", 10345 EightIndent); 10346 verifyFormat("int x[] = {\n" 10347 " call(),\n" 10348 " call()};", 10349 EightIndent); 10350 } 10351 10352 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 10353 verifyFormat("double\n" 10354 "f();", 10355 getLLVMStyleWithColumns(8)); 10356 } 10357 10358 TEST_F(FormatTest, ConfigurableUseOfTab) { 10359 FormatStyle Tab = getLLVMStyleWithColumns(42); 10360 Tab.IndentWidth = 8; 10361 Tab.UseTab = FormatStyle::UT_Always; 10362 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10363 10364 EXPECT_EQ("if (aaaaaaaa && // q\n" 10365 " bb)\t\t// w\n" 10366 "\t;", 10367 format("if (aaaaaaaa &&// q\n" 10368 "bb)// w\n" 10369 ";", 10370 Tab)); 10371 EXPECT_EQ("if (aaa && bbb) // w\n" 10372 "\t;", 10373 format("if(aaa&&bbb)// w\n" 10374 ";", 10375 Tab)); 10376 10377 verifyFormat("class X {\n" 10378 "\tvoid f() {\n" 10379 "\t\tsomeFunction(parameter1,\n" 10380 "\t\t\t parameter2);\n" 10381 "\t}\n" 10382 "};", 10383 Tab); 10384 verifyFormat("#define A \\\n" 10385 "\tvoid f() { \\\n" 10386 "\t\tsomeFunction( \\\n" 10387 "\t\t parameter1, \\\n" 10388 "\t\t parameter2); \\\n" 10389 "\t}", 10390 Tab); 10391 verifyFormat("int a;\t // x\n" 10392 "int bbbbbbbb; // x\n", 10393 Tab); 10394 10395 Tab.TabWidth = 4; 10396 Tab.IndentWidth = 8; 10397 verifyFormat("class TabWidth4Indent8 {\n" 10398 "\t\tvoid f() {\n" 10399 "\t\t\t\tsomeFunction(parameter1,\n" 10400 "\t\t\t\t\t\t\t parameter2);\n" 10401 "\t\t}\n" 10402 "};", 10403 Tab); 10404 10405 Tab.TabWidth = 4; 10406 Tab.IndentWidth = 4; 10407 verifyFormat("class TabWidth4Indent4 {\n" 10408 "\tvoid f() {\n" 10409 "\t\tsomeFunction(parameter1,\n" 10410 "\t\t\t\t\t parameter2);\n" 10411 "\t}\n" 10412 "};", 10413 Tab); 10414 10415 Tab.TabWidth = 8; 10416 Tab.IndentWidth = 4; 10417 verifyFormat("class TabWidth8Indent4 {\n" 10418 " void f() {\n" 10419 "\tsomeFunction(parameter1,\n" 10420 "\t\t parameter2);\n" 10421 " }\n" 10422 "};", 10423 Tab); 10424 10425 Tab.TabWidth = 8; 10426 Tab.IndentWidth = 8; 10427 EXPECT_EQ("/*\n" 10428 "\t a\t\tcomment\n" 10429 "\t in multiple lines\n" 10430 " */", 10431 format(" /*\t \t \n" 10432 " \t \t a\t\tcomment\t \t\n" 10433 " \t \t in multiple lines\t\n" 10434 " \t */", 10435 Tab)); 10436 10437 Tab.UseTab = FormatStyle::UT_ForIndentation; 10438 verifyFormat("{\n" 10439 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10440 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10441 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10442 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10443 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10444 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10445 "};", 10446 Tab); 10447 verifyFormat("enum AA {\n" 10448 "\ta1, // Force multiple lines\n" 10449 "\ta2,\n" 10450 "\ta3\n" 10451 "};", 10452 Tab); 10453 EXPECT_EQ("if (aaaaaaaa && // q\n" 10454 " bb) // w\n" 10455 "\t;", 10456 format("if (aaaaaaaa &&// q\n" 10457 "bb)// w\n" 10458 ";", 10459 Tab)); 10460 verifyFormat("class X {\n" 10461 "\tvoid f() {\n" 10462 "\t\tsomeFunction(parameter1,\n" 10463 "\t\t parameter2);\n" 10464 "\t}\n" 10465 "};", 10466 Tab); 10467 verifyFormat("{\n" 10468 "\tQ(\n" 10469 "\t {\n" 10470 "\t\t int a;\n" 10471 "\t\t someFunction(aaaaaaaa,\n" 10472 "\t\t bbbbbbb);\n" 10473 "\t },\n" 10474 "\t p);\n" 10475 "}", 10476 Tab); 10477 EXPECT_EQ("{\n" 10478 "\t/* aaaa\n" 10479 "\t bbbb */\n" 10480 "}", 10481 format("{\n" 10482 "/* aaaa\n" 10483 " bbbb */\n" 10484 "}", 10485 Tab)); 10486 EXPECT_EQ("{\n" 10487 "\t/*\n" 10488 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10489 "\t bbbbbbbbbbbbb\n" 10490 "\t*/\n" 10491 "}", 10492 format("{\n" 10493 "/*\n" 10494 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10495 "*/\n" 10496 "}", 10497 Tab)); 10498 EXPECT_EQ("{\n" 10499 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10500 "\t// bbbbbbbbbbbbb\n" 10501 "}", 10502 format("{\n" 10503 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10504 "}", 10505 Tab)); 10506 EXPECT_EQ("{\n" 10507 "\t/*\n" 10508 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10509 "\t bbbbbbbbbbbbb\n" 10510 "\t*/\n" 10511 "}", 10512 format("{\n" 10513 "\t/*\n" 10514 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10515 "\t*/\n" 10516 "}", 10517 Tab)); 10518 EXPECT_EQ("{\n" 10519 "\t/*\n" 10520 "\n" 10521 "\t*/\n" 10522 "}", 10523 format("{\n" 10524 "\t/*\n" 10525 "\n" 10526 "\t*/\n" 10527 "}", 10528 Tab)); 10529 EXPECT_EQ("{\n" 10530 "\t/*\n" 10531 " asdf\n" 10532 "\t*/\n" 10533 "}", 10534 format("{\n" 10535 "\t/*\n" 10536 " asdf\n" 10537 "\t*/\n" 10538 "}", 10539 Tab)); 10540 10541 Tab.UseTab = FormatStyle::UT_Never; 10542 EXPECT_EQ("/*\n" 10543 " a\t\tcomment\n" 10544 " in multiple lines\n" 10545 " */", 10546 format(" /*\t \t \n" 10547 " \t \t a\t\tcomment\t \t\n" 10548 " \t \t in multiple lines\t\n" 10549 " \t */", 10550 Tab)); 10551 EXPECT_EQ("/* some\n" 10552 " comment */", 10553 format(" \t \t /* some\n" 10554 " \t \t comment */", 10555 Tab)); 10556 EXPECT_EQ("int a; /* some\n" 10557 " comment */", 10558 format(" \t \t int a; /* some\n" 10559 " \t \t comment */", 10560 Tab)); 10561 10562 EXPECT_EQ("int a; /* some\n" 10563 "comment */", 10564 format(" \t \t int\ta; /* some\n" 10565 " \t \t comment */", 10566 Tab)); 10567 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10568 " comment */", 10569 format(" \t \t f(\"\t\t\"); /* some\n" 10570 " \t \t comment */", 10571 Tab)); 10572 EXPECT_EQ("{\n" 10573 " /*\n" 10574 " * Comment\n" 10575 " */\n" 10576 " int i;\n" 10577 "}", 10578 format("{\n" 10579 "\t/*\n" 10580 "\t * Comment\n" 10581 "\t */\n" 10582 "\t int i;\n" 10583 "}", 10584 Tab)); 10585 10586 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10587 Tab.TabWidth = 8; 10588 Tab.IndentWidth = 8; 10589 EXPECT_EQ("if (aaaaaaaa && // q\n" 10590 " bb) // w\n" 10591 "\t;", 10592 format("if (aaaaaaaa &&// q\n" 10593 "bb)// w\n" 10594 ";", 10595 Tab)); 10596 EXPECT_EQ("if (aaa && bbb) // w\n" 10597 "\t;", 10598 format("if(aaa&&bbb)// w\n" 10599 ";", 10600 Tab)); 10601 verifyFormat("class X {\n" 10602 "\tvoid f() {\n" 10603 "\t\tsomeFunction(parameter1,\n" 10604 "\t\t\t parameter2);\n" 10605 "\t}\n" 10606 "};", 10607 Tab); 10608 verifyFormat("#define A \\\n" 10609 "\tvoid f() { \\\n" 10610 "\t\tsomeFunction( \\\n" 10611 "\t\t parameter1, \\\n" 10612 "\t\t parameter2); \\\n" 10613 "\t}", 10614 Tab); 10615 Tab.TabWidth = 4; 10616 Tab.IndentWidth = 8; 10617 verifyFormat("class TabWidth4Indent8 {\n" 10618 "\t\tvoid f() {\n" 10619 "\t\t\t\tsomeFunction(parameter1,\n" 10620 "\t\t\t\t\t\t\t parameter2);\n" 10621 "\t\t}\n" 10622 "};", 10623 Tab); 10624 Tab.TabWidth = 4; 10625 Tab.IndentWidth = 4; 10626 verifyFormat("class TabWidth4Indent4 {\n" 10627 "\tvoid f() {\n" 10628 "\t\tsomeFunction(parameter1,\n" 10629 "\t\t\t\t\t parameter2);\n" 10630 "\t}\n" 10631 "};", 10632 Tab); 10633 Tab.TabWidth = 8; 10634 Tab.IndentWidth = 4; 10635 verifyFormat("class TabWidth8Indent4 {\n" 10636 " void f() {\n" 10637 "\tsomeFunction(parameter1,\n" 10638 "\t\t parameter2);\n" 10639 " }\n" 10640 "};", 10641 Tab); 10642 Tab.TabWidth = 8; 10643 Tab.IndentWidth = 8; 10644 EXPECT_EQ("/*\n" 10645 "\t a\t\tcomment\n" 10646 "\t in multiple lines\n" 10647 " */", 10648 format(" /*\t \t \n" 10649 " \t \t a\t\tcomment\t \t\n" 10650 " \t \t in multiple lines\t\n" 10651 " \t */", 10652 Tab)); 10653 verifyFormat("{\n" 10654 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10655 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10656 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10657 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10658 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10659 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10660 "};", 10661 Tab); 10662 verifyFormat("enum AA {\n" 10663 "\ta1, // Force multiple lines\n" 10664 "\ta2,\n" 10665 "\ta3\n" 10666 "};", 10667 Tab); 10668 EXPECT_EQ("if (aaaaaaaa && // q\n" 10669 " bb) // w\n" 10670 "\t;", 10671 format("if (aaaaaaaa &&// q\n" 10672 "bb)// w\n" 10673 ";", 10674 Tab)); 10675 verifyFormat("class X {\n" 10676 "\tvoid f() {\n" 10677 "\t\tsomeFunction(parameter1,\n" 10678 "\t\t\t parameter2);\n" 10679 "\t}\n" 10680 "};", 10681 Tab); 10682 verifyFormat("{\n" 10683 "\tQ(\n" 10684 "\t {\n" 10685 "\t\t int a;\n" 10686 "\t\t someFunction(aaaaaaaa,\n" 10687 "\t\t\t\t bbbbbbb);\n" 10688 "\t },\n" 10689 "\t p);\n" 10690 "}", 10691 Tab); 10692 EXPECT_EQ("{\n" 10693 "\t/* aaaa\n" 10694 "\t bbbb */\n" 10695 "}", 10696 format("{\n" 10697 "/* aaaa\n" 10698 " bbbb */\n" 10699 "}", 10700 Tab)); 10701 EXPECT_EQ("{\n" 10702 "\t/*\n" 10703 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10704 "\t bbbbbbbbbbbbb\n" 10705 "\t*/\n" 10706 "}", 10707 format("{\n" 10708 "/*\n" 10709 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10710 "*/\n" 10711 "}", 10712 Tab)); 10713 EXPECT_EQ("{\n" 10714 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10715 "\t// bbbbbbbbbbbbb\n" 10716 "}", 10717 format("{\n" 10718 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10719 "}", 10720 Tab)); 10721 EXPECT_EQ("{\n" 10722 "\t/*\n" 10723 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10724 "\t bbbbbbbbbbbbb\n" 10725 "\t*/\n" 10726 "}", 10727 format("{\n" 10728 "\t/*\n" 10729 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10730 "\t*/\n" 10731 "}", 10732 Tab)); 10733 EXPECT_EQ("{\n" 10734 "\t/*\n" 10735 "\n" 10736 "\t*/\n" 10737 "}", 10738 format("{\n" 10739 "\t/*\n" 10740 "\n" 10741 "\t*/\n" 10742 "}", 10743 Tab)); 10744 EXPECT_EQ("{\n" 10745 "\t/*\n" 10746 " asdf\n" 10747 "\t*/\n" 10748 "}", 10749 format("{\n" 10750 "\t/*\n" 10751 " asdf\n" 10752 "\t*/\n" 10753 "}", 10754 Tab)); 10755 EXPECT_EQ("/* some\n" 10756 " comment */", 10757 format(" \t \t /* some\n" 10758 " \t \t comment */", 10759 Tab)); 10760 EXPECT_EQ("int a; /* some\n" 10761 " comment */", 10762 format(" \t \t int a; /* some\n" 10763 " \t \t comment */", 10764 Tab)); 10765 EXPECT_EQ("int a; /* some\n" 10766 "comment */", 10767 format(" \t \t int\ta; /* some\n" 10768 " \t \t comment */", 10769 Tab)); 10770 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10771 " comment */", 10772 format(" \t \t f(\"\t\t\"); /* some\n" 10773 " \t \t comment */", 10774 Tab)); 10775 EXPECT_EQ("{\n" 10776 "\t/*\n" 10777 "\t * Comment\n" 10778 "\t */\n" 10779 "\tint i;\n" 10780 "}", 10781 format("{\n" 10782 "\t/*\n" 10783 "\t * Comment\n" 10784 "\t */\n" 10785 "\t int i;\n" 10786 "}", 10787 Tab)); 10788 Tab.TabWidth = 2; 10789 Tab.IndentWidth = 2; 10790 EXPECT_EQ("{\n" 10791 "\t/* aaaa\n" 10792 "\t\t bbbb */\n" 10793 "}", 10794 format("{\n" 10795 "/* aaaa\n" 10796 "\t bbbb */\n" 10797 "}", 10798 Tab)); 10799 EXPECT_EQ("{\n" 10800 "\t/*\n" 10801 "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10802 "\t\tbbbbbbbbbbbbb\n" 10803 "\t*/\n" 10804 "}", 10805 format("{\n" 10806 "/*\n" 10807 "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10808 "*/\n" 10809 "}", 10810 Tab)); 10811 Tab.AlignConsecutiveAssignments = true; 10812 Tab.AlignConsecutiveDeclarations = true; 10813 Tab.TabWidth = 4; 10814 Tab.IndentWidth = 4; 10815 verifyFormat("class Assign {\n" 10816 "\tvoid f() {\n" 10817 "\t\tint x = 123;\n" 10818 "\t\tint random = 4;\n" 10819 "\t\tstd::string alphabet =\n" 10820 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 10821 "\t}\n" 10822 "};", 10823 Tab); 10824 10825 Tab.UseTab = FormatStyle::UT_AlignWithSpaces; 10826 Tab.TabWidth = 8; 10827 Tab.IndentWidth = 8; 10828 EXPECT_EQ("if (aaaaaaaa && // q\n" 10829 " bb) // w\n" 10830 "\t;", 10831 format("if (aaaaaaaa &&// q\n" 10832 "bb)// w\n" 10833 ";", 10834 Tab)); 10835 EXPECT_EQ("if (aaa && bbb) // w\n" 10836 "\t;", 10837 format("if(aaa&&bbb)// w\n" 10838 ";", 10839 Tab)); 10840 verifyFormat("class X {\n" 10841 "\tvoid f() {\n" 10842 "\t\tsomeFunction(parameter1,\n" 10843 "\t\t parameter2);\n" 10844 "\t}\n" 10845 "};", 10846 Tab); 10847 verifyFormat("#define A \\\n" 10848 "\tvoid f() { \\\n" 10849 "\t\tsomeFunction( \\\n" 10850 "\t\t parameter1, \\\n" 10851 "\t\t parameter2); \\\n" 10852 "\t}", 10853 Tab); 10854 Tab.TabWidth = 4; 10855 Tab.IndentWidth = 8; 10856 verifyFormat("class TabWidth4Indent8 {\n" 10857 "\t\tvoid f() {\n" 10858 "\t\t\t\tsomeFunction(parameter1,\n" 10859 "\t\t\t\t parameter2);\n" 10860 "\t\t}\n" 10861 "};", 10862 Tab); 10863 Tab.TabWidth = 4; 10864 Tab.IndentWidth = 4; 10865 verifyFormat("class TabWidth4Indent4 {\n" 10866 "\tvoid f() {\n" 10867 "\t\tsomeFunction(parameter1,\n" 10868 "\t\t parameter2);\n" 10869 "\t}\n" 10870 "};", 10871 Tab); 10872 Tab.TabWidth = 8; 10873 Tab.IndentWidth = 4; 10874 verifyFormat("class TabWidth8Indent4 {\n" 10875 " void f() {\n" 10876 "\tsomeFunction(parameter1,\n" 10877 "\t parameter2);\n" 10878 " }\n" 10879 "};", 10880 Tab); 10881 Tab.TabWidth = 8; 10882 Tab.IndentWidth = 8; 10883 EXPECT_EQ("/*\n" 10884 " a\t\tcomment\n" 10885 " in multiple lines\n" 10886 " */", 10887 format(" /*\t \t \n" 10888 " \t \t a\t\tcomment\t \t\n" 10889 " \t \t in multiple lines\t\n" 10890 " \t */", 10891 Tab)); 10892 verifyFormat("{\n" 10893 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10894 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10895 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10896 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10897 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10898 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10899 "};", 10900 Tab); 10901 verifyFormat("enum AA {\n" 10902 "\ta1, // Force multiple lines\n" 10903 "\ta2,\n" 10904 "\ta3\n" 10905 "};", 10906 Tab); 10907 EXPECT_EQ("if (aaaaaaaa && // q\n" 10908 " bb) // w\n" 10909 "\t;", 10910 format("if (aaaaaaaa &&// q\n" 10911 "bb)// w\n" 10912 ";", 10913 Tab)); 10914 verifyFormat("class X {\n" 10915 "\tvoid f() {\n" 10916 "\t\tsomeFunction(parameter1,\n" 10917 "\t\t parameter2);\n" 10918 "\t}\n" 10919 "};", 10920 Tab); 10921 verifyFormat("{\n" 10922 "\tQ(\n" 10923 "\t {\n" 10924 "\t\t int a;\n" 10925 "\t\t someFunction(aaaaaaaa,\n" 10926 "\t\t bbbbbbb);\n" 10927 "\t },\n" 10928 "\t p);\n" 10929 "}", 10930 Tab); 10931 EXPECT_EQ("{\n" 10932 "\t/* aaaa\n" 10933 "\t bbbb */\n" 10934 "}", 10935 format("{\n" 10936 "/* aaaa\n" 10937 " bbbb */\n" 10938 "}", 10939 Tab)); 10940 EXPECT_EQ("{\n" 10941 "\t/*\n" 10942 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10943 "\t bbbbbbbbbbbbb\n" 10944 "\t*/\n" 10945 "}", 10946 format("{\n" 10947 "/*\n" 10948 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10949 "*/\n" 10950 "}", 10951 Tab)); 10952 EXPECT_EQ("{\n" 10953 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10954 "\t// bbbbbbbbbbbbb\n" 10955 "}", 10956 format("{\n" 10957 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10958 "}", 10959 Tab)); 10960 EXPECT_EQ("{\n" 10961 "\t/*\n" 10962 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10963 "\t bbbbbbbbbbbbb\n" 10964 "\t*/\n" 10965 "}", 10966 format("{\n" 10967 "\t/*\n" 10968 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10969 "\t*/\n" 10970 "}", 10971 Tab)); 10972 EXPECT_EQ("{\n" 10973 "\t/*\n" 10974 "\n" 10975 "\t*/\n" 10976 "}", 10977 format("{\n" 10978 "\t/*\n" 10979 "\n" 10980 "\t*/\n" 10981 "}", 10982 Tab)); 10983 EXPECT_EQ("{\n" 10984 "\t/*\n" 10985 " asdf\n" 10986 "\t*/\n" 10987 "}", 10988 format("{\n" 10989 "\t/*\n" 10990 " asdf\n" 10991 "\t*/\n" 10992 "}", 10993 Tab)); 10994 EXPECT_EQ("/* some\n" 10995 " comment */", 10996 format(" \t \t /* some\n" 10997 " \t \t comment */", 10998 Tab)); 10999 EXPECT_EQ("int a; /* some\n" 11000 " comment */", 11001 format(" \t \t int a; /* some\n" 11002 " \t \t comment */", 11003 Tab)); 11004 EXPECT_EQ("int a; /* some\n" 11005 "comment */", 11006 format(" \t \t int\ta; /* some\n" 11007 " \t \t comment */", 11008 Tab)); 11009 EXPECT_EQ("f(\"\t\t\"); /* some\n" 11010 " comment */", 11011 format(" \t \t f(\"\t\t\"); /* some\n" 11012 " \t \t comment */", 11013 Tab)); 11014 EXPECT_EQ("{\n" 11015 "\t/*\n" 11016 "\t * Comment\n" 11017 "\t */\n" 11018 "\tint i;\n" 11019 "}", 11020 format("{\n" 11021 "\t/*\n" 11022 "\t * Comment\n" 11023 "\t */\n" 11024 "\t int i;\n" 11025 "}", 11026 Tab)); 11027 Tab.TabWidth = 2; 11028 Tab.IndentWidth = 2; 11029 EXPECT_EQ("{\n" 11030 "\t/* aaaa\n" 11031 "\t bbbb */\n" 11032 "}", 11033 format("{\n" 11034 "/* aaaa\n" 11035 " bbbb */\n" 11036 "}", 11037 Tab)); 11038 EXPECT_EQ("{\n" 11039 "\t/*\n" 11040 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 11041 "\t bbbbbbbbbbbbb\n" 11042 "\t*/\n" 11043 "}", 11044 format("{\n" 11045 "/*\n" 11046 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 11047 "*/\n" 11048 "}", 11049 Tab)); 11050 Tab.AlignConsecutiveAssignments = true; 11051 Tab.AlignConsecutiveDeclarations = true; 11052 Tab.TabWidth = 4; 11053 Tab.IndentWidth = 4; 11054 verifyFormat("class Assign {\n" 11055 "\tvoid f() {\n" 11056 "\t\tint x = 123;\n" 11057 "\t\tint random = 4;\n" 11058 "\t\tstd::string alphabet =\n" 11059 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 11060 "\t}\n" 11061 "};", 11062 Tab); 11063 } 11064 11065 TEST_F(FormatTest, ZeroTabWidth) { 11066 FormatStyle Tab = getLLVMStyleWithColumns(42); 11067 Tab.IndentWidth = 8; 11068 Tab.UseTab = FormatStyle::UT_Never; 11069 Tab.TabWidth = 0; 11070 EXPECT_EQ("void a(){\n" 11071 " // line starts with '\t'\n" 11072 "};", 11073 format("void a(){\n" 11074 "\t// line starts with '\t'\n" 11075 "};", 11076 Tab)); 11077 11078 EXPECT_EQ("void a(){\n" 11079 " // line starts with '\t'\n" 11080 "};", 11081 format("void a(){\n" 11082 "\t\t// line starts with '\t'\n" 11083 "};", 11084 Tab)); 11085 11086 Tab.UseTab = FormatStyle::UT_ForIndentation; 11087 EXPECT_EQ("void a(){\n" 11088 " // line starts with '\t'\n" 11089 "};", 11090 format("void a(){\n" 11091 "\t// line starts with '\t'\n" 11092 "};", 11093 Tab)); 11094 11095 EXPECT_EQ("void a(){\n" 11096 " // line starts with '\t'\n" 11097 "};", 11098 format("void a(){\n" 11099 "\t\t// line starts with '\t'\n" 11100 "};", 11101 Tab)); 11102 11103 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 11104 EXPECT_EQ("void a(){\n" 11105 " // line starts with '\t'\n" 11106 "};", 11107 format("void a(){\n" 11108 "\t// line starts with '\t'\n" 11109 "};", 11110 Tab)); 11111 11112 EXPECT_EQ("void a(){\n" 11113 " // line starts with '\t'\n" 11114 "};", 11115 format("void a(){\n" 11116 "\t\t// line starts with '\t'\n" 11117 "};", 11118 Tab)); 11119 11120 Tab.UseTab = FormatStyle::UT_AlignWithSpaces; 11121 EXPECT_EQ("void a(){\n" 11122 " // line starts with '\t'\n" 11123 "};", 11124 format("void a(){\n" 11125 "\t// line starts with '\t'\n" 11126 "};", 11127 Tab)); 11128 11129 EXPECT_EQ("void a(){\n" 11130 " // line starts with '\t'\n" 11131 "};", 11132 format("void a(){\n" 11133 "\t\t// line starts with '\t'\n" 11134 "};", 11135 Tab)); 11136 11137 Tab.UseTab = FormatStyle::UT_Always; 11138 EXPECT_EQ("void a(){\n" 11139 "// line starts with '\t'\n" 11140 "};", 11141 format("void a(){\n" 11142 "\t// line starts with '\t'\n" 11143 "};", 11144 Tab)); 11145 11146 EXPECT_EQ("void a(){\n" 11147 "// line starts with '\t'\n" 11148 "};", 11149 format("void a(){\n" 11150 "\t\t// line starts with '\t'\n" 11151 "};", 11152 Tab)); 11153 } 11154 11155 TEST_F(FormatTest, CalculatesOriginalColumn) { 11156 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 11157 "q\"; /* some\n" 11158 " comment */", 11159 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 11160 "q\"; /* some\n" 11161 " comment */", 11162 getLLVMStyle())); 11163 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 11164 "/* some\n" 11165 " comment */", 11166 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 11167 " /* some\n" 11168 " comment */", 11169 getLLVMStyle())); 11170 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 11171 "qqq\n" 11172 "/* some\n" 11173 " comment */", 11174 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 11175 "qqq\n" 11176 " /* some\n" 11177 " comment */", 11178 getLLVMStyle())); 11179 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 11180 "wwww; /* some\n" 11181 " comment */", 11182 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 11183 "wwww; /* some\n" 11184 " comment */", 11185 getLLVMStyle())); 11186 } 11187 11188 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 11189 FormatStyle NoSpace = getLLVMStyle(); 11190 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 11191 11192 verifyFormat("while(true)\n" 11193 " continue;", 11194 NoSpace); 11195 verifyFormat("for(;;)\n" 11196 " continue;", 11197 NoSpace); 11198 verifyFormat("if(true)\n" 11199 " f();\n" 11200 "else if(true)\n" 11201 " f();", 11202 NoSpace); 11203 verifyFormat("do {\n" 11204 " do_something();\n" 11205 "} while(something());", 11206 NoSpace); 11207 verifyFormat("switch(x) {\n" 11208 "default:\n" 11209 " break;\n" 11210 "}", 11211 NoSpace); 11212 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 11213 verifyFormat("size_t x = sizeof(x);", NoSpace); 11214 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 11215 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 11216 verifyFormat("alignas(128) char a[128];", NoSpace); 11217 verifyFormat("size_t x = alignof(MyType);", NoSpace); 11218 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 11219 verifyFormat("int f() throw(Deprecated);", NoSpace); 11220 verifyFormat("typedef void (*cb)(int);", NoSpace); 11221 verifyFormat("T A::operator()();", NoSpace); 11222 verifyFormat("X A::operator++(T);", NoSpace); 11223 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 11224 11225 FormatStyle Space = getLLVMStyle(); 11226 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 11227 11228 verifyFormat("int f ();", Space); 11229 verifyFormat("void f (int a, T b) {\n" 11230 " while (true)\n" 11231 " continue;\n" 11232 "}", 11233 Space); 11234 verifyFormat("if (true)\n" 11235 " f ();\n" 11236 "else if (true)\n" 11237 " f ();", 11238 Space); 11239 verifyFormat("do {\n" 11240 " do_something ();\n" 11241 "} while (something ());", 11242 Space); 11243 verifyFormat("switch (x) {\n" 11244 "default:\n" 11245 " break;\n" 11246 "}", 11247 Space); 11248 verifyFormat("A::A () : a (1) {}", Space); 11249 verifyFormat("void f () __attribute__ ((asdf));", Space); 11250 verifyFormat("*(&a + 1);\n" 11251 "&((&a)[1]);\n" 11252 "a[(b + c) * d];\n" 11253 "(((a + 1) * 2) + 3) * 4;", 11254 Space); 11255 verifyFormat("#define A(x) x", Space); 11256 verifyFormat("#define A (x) x", Space); 11257 verifyFormat("#if defined(x)\n" 11258 "#endif", 11259 Space); 11260 verifyFormat("auto i = std::make_unique<int> (5);", Space); 11261 verifyFormat("size_t x = sizeof (x);", Space); 11262 verifyFormat("auto f (int x) -> decltype (x);", Space); 11263 verifyFormat("int f (T x) noexcept (x.create ());", Space); 11264 verifyFormat("alignas (128) char a[128];", Space); 11265 verifyFormat("size_t x = alignof (MyType);", Space); 11266 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 11267 verifyFormat("int f () throw (Deprecated);", Space); 11268 verifyFormat("typedef void (*cb) (int);", Space); 11269 verifyFormat("T A::operator() ();", Space); 11270 verifyFormat("X A::operator++ (T);", Space); 11271 verifyFormat("auto lambda = [] () { return 0; };", Space); 11272 verifyFormat("int x = int (y);", Space); 11273 11274 FormatStyle SomeSpace = getLLVMStyle(); 11275 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 11276 11277 verifyFormat("[]() -> float {}", SomeSpace); 11278 verifyFormat("[] (auto foo) {}", SomeSpace); 11279 verifyFormat("[foo]() -> int {}", SomeSpace); 11280 verifyFormat("int f();", SomeSpace); 11281 verifyFormat("void f (int a, T b) {\n" 11282 " while (true)\n" 11283 " continue;\n" 11284 "}", 11285 SomeSpace); 11286 verifyFormat("if (true)\n" 11287 " f();\n" 11288 "else if (true)\n" 11289 " f();", 11290 SomeSpace); 11291 verifyFormat("do {\n" 11292 " do_something();\n" 11293 "} while (something());", 11294 SomeSpace); 11295 verifyFormat("switch (x) {\n" 11296 "default:\n" 11297 " break;\n" 11298 "}", 11299 SomeSpace); 11300 verifyFormat("A::A() : a (1) {}", SomeSpace); 11301 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 11302 verifyFormat("*(&a + 1);\n" 11303 "&((&a)[1]);\n" 11304 "a[(b + c) * d];\n" 11305 "(((a + 1) * 2) + 3) * 4;", 11306 SomeSpace); 11307 verifyFormat("#define A(x) x", SomeSpace); 11308 verifyFormat("#define A (x) x", SomeSpace); 11309 verifyFormat("#if defined(x)\n" 11310 "#endif", 11311 SomeSpace); 11312 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 11313 verifyFormat("size_t x = sizeof (x);", SomeSpace); 11314 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 11315 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 11316 verifyFormat("alignas (128) char a[128];", SomeSpace); 11317 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 11318 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 11319 SomeSpace); 11320 verifyFormat("int f() throw (Deprecated);", SomeSpace); 11321 verifyFormat("typedef void (*cb) (int);", SomeSpace); 11322 verifyFormat("T A::operator()();", SomeSpace); 11323 verifyFormat("X A::operator++ (T);", SomeSpace); 11324 verifyFormat("int x = int (y);", SomeSpace); 11325 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 11326 } 11327 11328 TEST_F(FormatTest, SpaceAfterLogicalNot) { 11329 FormatStyle Spaces = getLLVMStyle(); 11330 Spaces.SpaceAfterLogicalNot = true; 11331 11332 verifyFormat("bool x = ! y", Spaces); 11333 verifyFormat("if (! isFailure())", Spaces); 11334 verifyFormat("if (! (a && b))", Spaces); 11335 verifyFormat("\"Error!\"", Spaces); 11336 verifyFormat("! ! x", Spaces); 11337 } 11338 11339 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 11340 FormatStyle Spaces = getLLVMStyle(); 11341 11342 Spaces.SpacesInParentheses = true; 11343 verifyFormat("do_something( ::globalVar );", Spaces); 11344 verifyFormat("call( x, y, z );", Spaces); 11345 verifyFormat("call();", Spaces); 11346 verifyFormat("std::function<void( int, int )> callback;", Spaces); 11347 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 11348 Spaces); 11349 verifyFormat("while ( (bool)1 )\n" 11350 " continue;", 11351 Spaces); 11352 verifyFormat("for ( ;; )\n" 11353 " continue;", 11354 Spaces); 11355 verifyFormat("if ( true )\n" 11356 " f();\n" 11357 "else if ( true )\n" 11358 " f();", 11359 Spaces); 11360 verifyFormat("do {\n" 11361 " do_something( (int)i );\n" 11362 "} while ( something() );", 11363 Spaces); 11364 verifyFormat("switch ( x ) {\n" 11365 "default:\n" 11366 " break;\n" 11367 "}", 11368 Spaces); 11369 11370 Spaces.SpacesInParentheses = false; 11371 Spaces.SpacesInCStyleCastParentheses = true; 11372 verifyFormat("Type *A = ( Type * )P;", Spaces); 11373 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 11374 verifyFormat("x = ( int32 )y;", Spaces); 11375 verifyFormat("int a = ( int )(2.0f);", Spaces); 11376 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 11377 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 11378 verifyFormat("#define x (( int )-1)", Spaces); 11379 11380 // Run the first set of tests again with: 11381 Spaces.SpacesInParentheses = false; 11382 Spaces.SpaceInEmptyParentheses = true; 11383 Spaces.SpacesInCStyleCastParentheses = true; 11384 verifyFormat("call(x, y, z);", Spaces); 11385 verifyFormat("call( );", Spaces); 11386 verifyFormat("std::function<void(int, int)> callback;", Spaces); 11387 verifyFormat("while (( bool )1)\n" 11388 " continue;", 11389 Spaces); 11390 verifyFormat("for (;;)\n" 11391 " continue;", 11392 Spaces); 11393 verifyFormat("if (true)\n" 11394 " f( );\n" 11395 "else if (true)\n" 11396 " f( );", 11397 Spaces); 11398 verifyFormat("do {\n" 11399 " do_something(( int )i);\n" 11400 "} while (something( ));", 11401 Spaces); 11402 verifyFormat("switch (x) {\n" 11403 "default:\n" 11404 " break;\n" 11405 "}", 11406 Spaces); 11407 11408 // Run the first set of tests again with: 11409 Spaces.SpaceAfterCStyleCast = true; 11410 verifyFormat("call(x, y, z);", Spaces); 11411 verifyFormat("call( );", Spaces); 11412 verifyFormat("std::function<void(int, int)> callback;", Spaces); 11413 verifyFormat("while (( bool ) 1)\n" 11414 " continue;", 11415 Spaces); 11416 verifyFormat("for (;;)\n" 11417 " continue;", 11418 Spaces); 11419 verifyFormat("if (true)\n" 11420 " f( );\n" 11421 "else if (true)\n" 11422 " f( );", 11423 Spaces); 11424 verifyFormat("do {\n" 11425 " do_something(( int ) i);\n" 11426 "} while (something( ));", 11427 Spaces); 11428 verifyFormat("switch (x) {\n" 11429 "default:\n" 11430 " break;\n" 11431 "}", 11432 Spaces); 11433 11434 // Run subset of tests again with: 11435 Spaces.SpacesInCStyleCastParentheses = false; 11436 Spaces.SpaceAfterCStyleCast = true; 11437 verifyFormat("while ((bool) 1)\n" 11438 " continue;", 11439 Spaces); 11440 verifyFormat("do {\n" 11441 " do_something((int) i);\n" 11442 "} while (something( ));", 11443 Spaces); 11444 } 11445 11446 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 11447 verifyFormat("int a[5];"); 11448 verifyFormat("a[3] += 42;"); 11449 11450 FormatStyle Spaces = getLLVMStyle(); 11451 Spaces.SpacesInSquareBrackets = true; 11452 // Not lambdas. 11453 verifyFormat("int a[ 5 ];", Spaces); 11454 verifyFormat("a[ 3 ] += 42;", Spaces); 11455 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 11456 verifyFormat("double &operator[](int i) { return 0; }\n" 11457 "int i;", 11458 Spaces); 11459 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 11460 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 11461 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 11462 // Lambdas. 11463 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 11464 verifyFormat("return [ i, args... ] {};", Spaces); 11465 verifyFormat("int foo = [ &bar ]() {};", Spaces); 11466 verifyFormat("int foo = [ = ]() {};", Spaces); 11467 verifyFormat("int foo = [ & ]() {};", Spaces); 11468 verifyFormat("int foo = [ =, &bar ]() {};", Spaces); 11469 verifyFormat("int foo = [ &bar, = ]() {};", Spaces); 11470 } 11471 11472 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) { 11473 FormatStyle NoSpaceStyle = getLLVMStyle(); 11474 verifyFormat("int a[5];", NoSpaceStyle); 11475 verifyFormat("a[3] += 42;", NoSpaceStyle); 11476 11477 verifyFormat("int a[1];", NoSpaceStyle); 11478 verifyFormat("int 1 [a];", NoSpaceStyle); 11479 verifyFormat("int a[1][2];", NoSpaceStyle); 11480 verifyFormat("a[7] = 5;", NoSpaceStyle); 11481 verifyFormat("int a = (f())[23];", NoSpaceStyle); 11482 verifyFormat("f([] {})", NoSpaceStyle); 11483 11484 FormatStyle Space = getLLVMStyle(); 11485 Space.SpaceBeforeSquareBrackets = true; 11486 verifyFormat("int c = []() -> int { return 2; }();\n", Space); 11487 verifyFormat("return [i, args...] {};", Space); 11488 11489 verifyFormat("int a [5];", Space); 11490 verifyFormat("a [3] += 42;", Space); 11491 verifyFormat("constexpr char hello []{\"hello\"};", Space); 11492 verifyFormat("double &operator[](int i) { return 0; }\n" 11493 "int i;", 11494 Space); 11495 verifyFormat("std::unique_ptr<int []> foo() {}", Space); 11496 verifyFormat("int i = a [a][a]->f();", Space); 11497 verifyFormat("int i = (*b) [a]->f();", Space); 11498 11499 verifyFormat("int a [1];", Space); 11500 verifyFormat("int 1 [a];", Space); 11501 verifyFormat("int a [1][2];", Space); 11502 verifyFormat("a [7] = 5;", Space); 11503 verifyFormat("int a = (f()) [23];", Space); 11504 verifyFormat("f([] {})", Space); 11505 } 11506 11507 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 11508 verifyFormat("int a = 5;"); 11509 verifyFormat("a += 42;"); 11510 verifyFormat("a or_eq 8;"); 11511 11512 FormatStyle Spaces = getLLVMStyle(); 11513 Spaces.SpaceBeforeAssignmentOperators = false; 11514 verifyFormat("int a= 5;", Spaces); 11515 verifyFormat("a+= 42;", Spaces); 11516 verifyFormat("a or_eq 8;", Spaces); 11517 } 11518 11519 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 11520 verifyFormat("class Foo : public Bar {};"); 11521 verifyFormat("Foo::Foo() : foo(1) {}"); 11522 verifyFormat("for (auto a : b) {\n}"); 11523 verifyFormat("int x = a ? b : c;"); 11524 verifyFormat("{\n" 11525 "label0:\n" 11526 " int x = 0;\n" 11527 "}"); 11528 verifyFormat("switch (x) {\n" 11529 "case 1:\n" 11530 "default:\n" 11531 "}"); 11532 11533 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 11534 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 11535 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 11536 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 11537 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 11538 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 11539 verifyFormat("{\n" 11540 "label1:\n" 11541 " int x = 0;\n" 11542 "}", 11543 CtorInitializerStyle); 11544 verifyFormat("switch (x) {\n" 11545 "case 1:\n" 11546 "default:\n" 11547 "}", 11548 CtorInitializerStyle); 11549 CtorInitializerStyle.BreakConstructorInitializers = 11550 FormatStyle::BCIS_AfterColon; 11551 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 11552 " aaaaaaaaaaaaaaaa(1),\n" 11553 " bbbbbbbbbbbbbbbb(2) {}", 11554 CtorInitializerStyle); 11555 CtorInitializerStyle.BreakConstructorInitializers = 11556 FormatStyle::BCIS_BeforeComma; 11557 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 11558 " : aaaaaaaaaaaaaaaa(1)\n" 11559 " , bbbbbbbbbbbbbbbb(2) {}", 11560 CtorInitializerStyle); 11561 CtorInitializerStyle.BreakConstructorInitializers = 11562 FormatStyle::BCIS_BeforeColon; 11563 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 11564 " : aaaaaaaaaaaaaaaa(1),\n" 11565 " bbbbbbbbbbbbbbbb(2) {}", 11566 CtorInitializerStyle); 11567 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 11568 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 11569 ": aaaaaaaaaaaaaaaa(1),\n" 11570 " bbbbbbbbbbbbbbbb(2) {}", 11571 CtorInitializerStyle); 11572 11573 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 11574 InheritanceStyle.SpaceBeforeInheritanceColon = false; 11575 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 11576 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 11577 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 11578 verifyFormat("int x = a ? b : c;", InheritanceStyle); 11579 verifyFormat("{\n" 11580 "label2:\n" 11581 " int x = 0;\n" 11582 "}", 11583 InheritanceStyle); 11584 verifyFormat("switch (x) {\n" 11585 "case 1:\n" 11586 "default:\n" 11587 "}", 11588 InheritanceStyle); 11589 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 11590 verifyFormat("class Foooooooooooooooooooooo:\n" 11591 " public aaaaaaaaaaaaaaaaaa,\n" 11592 " public bbbbbbbbbbbbbbbbbb {\n" 11593 "}", 11594 InheritanceStyle); 11595 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 11596 verifyFormat("class Foooooooooooooooooooooo\n" 11597 " : public aaaaaaaaaaaaaaaaaa\n" 11598 " , public bbbbbbbbbbbbbbbbbb {\n" 11599 "}", 11600 InheritanceStyle); 11601 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 11602 verifyFormat("class Foooooooooooooooooooooo\n" 11603 " : public aaaaaaaaaaaaaaaaaa,\n" 11604 " public bbbbbbbbbbbbbbbbbb {\n" 11605 "}", 11606 InheritanceStyle); 11607 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 11608 verifyFormat("class Foooooooooooooooooooooo\n" 11609 ": public aaaaaaaaaaaaaaaaaa,\n" 11610 " public bbbbbbbbbbbbbbbbbb {}", 11611 InheritanceStyle); 11612 11613 FormatStyle ForLoopStyle = getLLVMStyle(); 11614 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 11615 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 11616 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 11617 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 11618 verifyFormat("int x = a ? b : c;", ForLoopStyle); 11619 verifyFormat("{\n" 11620 "label2:\n" 11621 " int x = 0;\n" 11622 "}", 11623 ForLoopStyle); 11624 verifyFormat("switch (x) {\n" 11625 "case 1:\n" 11626 "default:\n" 11627 "}", 11628 ForLoopStyle); 11629 11630 FormatStyle NoSpaceStyle = getLLVMStyle(); 11631 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 11632 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 11633 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 11634 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 11635 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 11636 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 11637 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 11638 verifyFormat("{\n" 11639 "label3:\n" 11640 " int x = 0;\n" 11641 "}", 11642 NoSpaceStyle); 11643 verifyFormat("switch (x) {\n" 11644 "case 1:\n" 11645 "default:\n" 11646 "}", 11647 NoSpaceStyle); 11648 } 11649 11650 TEST_F(FormatTest, AlignConsecutiveMacros) { 11651 FormatStyle Style = getLLVMStyle(); 11652 Style.AlignConsecutiveAssignments = true; 11653 Style.AlignConsecutiveDeclarations = true; 11654 Style.AlignConsecutiveMacros = false; 11655 11656 verifyFormat("#define a 3\n" 11657 "#define bbbb 4\n" 11658 "#define ccc (5)", 11659 Style); 11660 11661 verifyFormat("#define f(x) (x * x)\n" 11662 "#define fff(x, y, z) (x * y + z)\n" 11663 "#define ffff(x, y) (x - y)", 11664 Style); 11665 11666 verifyFormat("#define foo(x, y) (x + y)\n" 11667 "#define bar (5, 6)(2 + 2)", 11668 Style); 11669 11670 verifyFormat("#define a 3\n" 11671 "#define bbbb 4\n" 11672 "#define ccc (5)\n" 11673 "#define f(x) (x * x)\n" 11674 "#define fff(x, y, z) (x * y + z)\n" 11675 "#define ffff(x, y) (x - y)", 11676 Style); 11677 11678 Style.AlignConsecutiveMacros = true; 11679 verifyFormat("#define a 3\n" 11680 "#define bbbb 4\n" 11681 "#define ccc (5)", 11682 Style); 11683 11684 verifyFormat("#define f(x) (x * x)\n" 11685 "#define fff(x, y, z) (x * y + z)\n" 11686 "#define ffff(x, y) (x - y)", 11687 Style); 11688 11689 verifyFormat("#define foo(x, y) (x + y)\n" 11690 "#define bar (5, 6)(2 + 2)", 11691 Style); 11692 11693 verifyFormat("#define a 3\n" 11694 "#define bbbb 4\n" 11695 "#define ccc (5)\n" 11696 "#define f(x) (x * x)\n" 11697 "#define fff(x, y, z) (x * y + z)\n" 11698 "#define ffff(x, y) (x - y)", 11699 Style); 11700 11701 verifyFormat("#define a 5\n" 11702 "#define foo(x, y) (x + y)\n" 11703 "#define CCC (6)\n" 11704 "auto lambda = []() {\n" 11705 " auto ii = 0;\n" 11706 " float j = 0;\n" 11707 " return 0;\n" 11708 "};\n" 11709 "int i = 0;\n" 11710 "float i2 = 0;\n" 11711 "auto v = type{\n" 11712 " i = 1, //\n" 11713 " (i = 2), //\n" 11714 " i = 3 //\n" 11715 "};", 11716 Style); 11717 11718 Style.AlignConsecutiveMacros = false; 11719 Style.ColumnLimit = 20; 11720 11721 verifyFormat("#define a \\\n" 11722 " \"aabbbbbbbbbbbb\"\n" 11723 "#define D \\\n" 11724 " \"aabbbbbbbbbbbb\" \\\n" 11725 " \"ccddeeeeeeeee\"\n" 11726 "#define B \\\n" 11727 " \"QQQQQQQQQQQQQ\" \\\n" 11728 " \"FFFFFFFFFFFFF\" \\\n" 11729 " \"LLLLLLLL\"\n", 11730 Style); 11731 11732 Style.AlignConsecutiveMacros = true; 11733 verifyFormat("#define a \\\n" 11734 " \"aabbbbbbbbbbbb\"\n" 11735 "#define D \\\n" 11736 " \"aabbbbbbbbbbbb\" \\\n" 11737 " \"ccddeeeeeeeee\"\n" 11738 "#define B \\\n" 11739 " \"QQQQQQQQQQQQQ\" \\\n" 11740 " \"FFFFFFFFFFFFF\" \\\n" 11741 " \"LLLLLLLL\"\n", 11742 Style); 11743 } 11744 11745 TEST_F(FormatTest, AlignConsecutiveAssignments) { 11746 FormatStyle Alignment = getLLVMStyle(); 11747 Alignment.AlignConsecutiveMacros = true; 11748 Alignment.AlignConsecutiveAssignments = false; 11749 verifyFormat("int a = 5;\n" 11750 "int oneTwoThree = 123;", 11751 Alignment); 11752 verifyFormat("int a = 5;\n" 11753 "int oneTwoThree = 123;", 11754 Alignment); 11755 11756 Alignment.AlignConsecutiveAssignments = true; 11757 verifyFormat("int a = 5;\n" 11758 "int oneTwoThree = 123;", 11759 Alignment); 11760 verifyFormat("int a = method();\n" 11761 "int oneTwoThree = 133;", 11762 Alignment); 11763 verifyFormat("a &= 5;\n" 11764 "bcd *= 5;\n" 11765 "ghtyf += 5;\n" 11766 "dvfvdb -= 5;\n" 11767 "a /= 5;\n" 11768 "vdsvsv %= 5;\n" 11769 "sfdbddfbdfbb ^= 5;\n" 11770 "dvsdsv |= 5;\n" 11771 "int dsvvdvsdvvv = 123;", 11772 Alignment); 11773 verifyFormat("int i = 1, j = 10;\n" 11774 "something = 2000;", 11775 Alignment); 11776 verifyFormat("something = 2000;\n" 11777 "int i = 1, j = 10;\n", 11778 Alignment); 11779 verifyFormat("something = 2000;\n" 11780 "another = 911;\n" 11781 "int i = 1, j = 10;\n" 11782 "oneMore = 1;\n" 11783 "i = 2;", 11784 Alignment); 11785 verifyFormat("int a = 5;\n" 11786 "int one = 1;\n" 11787 "method();\n" 11788 "int oneTwoThree = 123;\n" 11789 "int oneTwo = 12;", 11790 Alignment); 11791 verifyFormat("int oneTwoThree = 123;\n" 11792 "int oneTwo = 12;\n" 11793 "method();\n", 11794 Alignment); 11795 verifyFormat("int oneTwoThree = 123; // comment\n" 11796 "int oneTwo = 12; // comment", 11797 Alignment); 11798 11799 // Bug 25167 11800 verifyFormat("#if A\n" 11801 "#else\n" 11802 "int aaaaaaaa = 12;\n" 11803 "#endif\n" 11804 "#if B\n" 11805 "#else\n" 11806 "int a = 12;\n" 11807 "#endif\n", 11808 Alignment); 11809 verifyFormat("enum foo {\n" 11810 "#if A\n" 11811 "#else\n" 11812 " aaaaaaaa = 12;\n" 11813 "#endif\n" 11814 "#if B\n" 11815 "#else\n" 11816 " a = 12;\n" 11817 "#endif\n" 11818 "};\n", 11819 Alignment); 11820 11821 EXPECT_EQ("int a = 5;\n" 11822 "\n" 11823 "int oneTwoThree = 123;", 11824 format("int a = 5;\n" 11825 "\n" 11826 "int oneTwoThree= 123;", 11827 Alignment)); 11828 EXPECT_EQ("int a = 5;\n" 11829 "int one = 1;\n" 11830 "\n" 11831 "int oneTwoThree = 123;", 11832 format("int a = 5;\n" 11833 "int one = 1;\n" 11834 "\n" 11835 "int oneTwoThree = 123;", 11836 Alignment)); 11837 EXPECT_EQ("int a = 5;\n" 11838 "int one = 1;\n" 11839 "\n" 11840 "int oneTwoThree = 123;\n" 11841 "int oneTwo = 12;", 11842 format("int a = 5;\n" 11843 "int one = 1;\n" 11844 "\n" 11845 "int oneTwoThree = 123;\n" 11846 "int oneTwo = 12;", 11847 Alignment)); 11848 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11849 verifyFormat("#define A \\\n" 11850 " int aaaa = 12; \\\n" 11851 " int b = 23; \\\n" 11852 " int ccc = 234; \\\n" 11853 " int dddddddddd = 2345;", 11854 Alignment); 11855 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11856 verifyFormat("#define A \\\n" 11857 " int aaaa = 12; \\\n" 11858 " int b = 23; \\\n" 11859 " int ccc = 234; \\\n" 11860 " int dddddddddd = 2345;", 11861 Alignment); 11862 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11863 verifyFormat("#define A " 11864 " \\\n" 11865 " int aaaa = 12; " 11866 " \\\n" 11867 " int b = 23; " 11868 " \\\n" 11869 " int ccc = 234; " 11870 " \\\n" 11871 " int dddddddddd = 2345;", 11872 Alignment); 11873 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11874 "k = 4, int l = 5,\n" 11875 " int m = 6) {\n" 11876 " int j = 10;\n" 11877 " otherThing = 1;\n" 11878 "}", 11879 Alignment); 11880 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11881 " int i = 1;\n" 11882 " int j = 2;\n" 11883 " int big = 10000;\n" 11884 "}", 11885 Alignment); 11886 verifyFormat("class C {\n" 11887 "public:\n" 11888 " int i = 1;\n" 11889 " virtual void f() = 0;\n" 11890 "};", 11891 Alignment); 11892 verifyFormat("int i = 1;\n" 11893 "if (SomeType t = getSomething()) {\n" 11894 "}\n" 11895 "int j = 2;\n" 11896 "int big = 10000;", 11897 Alignment); 11898 verifyFormat("int j = 7;\n" 11899 "for (int k = 0; k < N; ++k) {\n" 11900 "}\n" 11901 "int j = 2;\n" 11902 "int big = 10000;\n" 11903 "}", 11904 Alignment); 11905 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11906 verifyFormat("int i = 1;\n" 11907 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11908 " = someLooooooooooooooooongFunction();\n" 11909 "int j = 2;", 11910 Alignment); 11911 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11912 verifyFormat("int i = 1;\n" 11913 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11914 " someLooooooooooooooooongFunction();\n" 11915 "int j = 2;", 11916 Alignment); 11917 11918 verifyFormat("auto lambda = []() {\n" 11919 " auto i = 0;\n" 11920 " return 0;\n" 11921 "};\n" 11922 "int i = 0;\n" 11923 "auto v = type{\n" 11924 " i = 1, //\n" 11925 " (i = 2), //\n" 11926 " i = 3 //\n" 11927 "};", 11928 Alignment); 11929 11930 verifyFormat( 11931 "int i = 1;\n" 11932 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11933 " loooooooooooooooooooooongParameterB);\n" 11934 "int j = 2;", 11935 Alignment); 11936 11937 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 11938 " typename B = very_long_type_name_1,\n" 11939 " typename T_2 = very_long_type_name_2>\n" 11940 "auto foo() {}\n", 11941 Alignment); 11942 verifyFormat("int a, b = 1;\n" 11943 "int c = 2;\n" 11944 "int dd = 3;\n", 11945 Alignment); 11946 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11947 "float b[1][] = {{3.f}};\n", 11948 Alignment); 11949 verifyFormat("for (int i = 0; i < 1; i++)\n" 11950 " int x = 1;\n", 11951 Alignment); 11952 verifyFormat("for (i = 0; i < 1; i++)\n" 11953 " x = 1;\n" 11954 "y = 1;\n", 11955 Alignment); 11956 } 11957 11958 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 11959 FormatStyle Alignment = getLLVMStyle(); 11960 Alignment.AlignConsecutiveMacros = true; 11961 Alignment.AlignConsecutiveDeclarations = false; 11962 verifyFormat("float const a = 5;\n" 11963 "int oneTwoThree = 123;", 11964 Alignment); 11965 verifyFormat("int a = 5;\n" 11966 "float const oneTwoThree = 123;", 11967 Alignment); 11968 11969 Alignment.AlignConsecutiveDeclarations = true; 11970 verifyFormat("float const a = 5;\n" 11971 "int oneTwoThree = 123;", 11972 Alignment); 11973 verifyFormat("int a = method();\n" 11974 "float const oneTwoThree = 133;", 11975 Alignment); 11976 verifyFormat("int i = 1, j = 10;\n" 11977 "something = 2000;", 11978 Alignment); 11979 verifyFormat("something = 2000;\n" 11980 "int i = 1, j = 10;\n", 11981 Alignment); 11982 verifyFormat("float something = 2000;\n" 11983 "double another = 911;\n" 11984 "int i = 1, j = 10;\n" 11985 "const int *oneMore = 1;\n" 11986 "unsigned i = 2;", 11987 Alignment); 11988 verifyFormat("float a = 5;\n" 11989 "int one = 1;\n" 11990 "method();\n" 11991 "const double oneTwoThree = 123;\n" 11992 "const unsigned int oneTwo = 12;", 11993 Alignment); 11994 verifyFormat("int oneTwoThree{0}; // comment\n" 11995 "unsigned oneTwo; // comment", 11996 Alignment); 11997 EXPECT_EQ("float const a = 5;\n" 11998 "\n" 11999 "int oneTwoThree = 123;", 12000 format("float const a = 5;\n" 12001 "\n" 12002 "int oneTwoThree= 123;", 12003 Alignment)); 12004 EXPECT_EQ("float a = 5;\n" 12005 "int one = 1;\n" 12006 "\n" 12007 "unsigned oneTwoThree = 123;", 12008 format("float a = 5;\n" 12009 "int one = 1;\n" 12010 "\n" 12011 "unsigned oneTwoThree = 123;", 12012 Alignment)); 12013 EXPECT_EQ("float a = 5;\n" 12014 "int one = 1;\n" 12015 "\n" 12016 "unsigned oneTwoThree = 123;\n" 12017 "int oneTwo = 12;", 12018 format("float a = 5;\n" 12019 "int one = 1;\n" 12020 "\n" 12021 "unsigned oneTwoThree = 123;\n" 12022 "int oneTwo = 12;", 12023 Alignment)); 12024 // Function prototype alignment 12025 verifyFormat("int a();\n" 12026 "double b();", 12027 Alignment); 12028 verifyFormat("int a(int x);\n" 12029 "double b();", 12030 Alignment); 12031 unsigned OldColumnLimit = Alignment.ColumnLimit; 12032 // We need to set ColumnLimit to zero, in order to stress nested alignments, 12033 // otherwise the function parameters will be re-flowed onto a single line. 12034 Alignment.ColumnLimit = 0; 12035 EXPECT_EQ("int a(int x,\n" 12036 " float y);\n" 12037 "double b(int x,\n" 12038 " double y);", 12039 format("int a(int x,\n" 12040 " float y);\n" 12041 "double b(int x,\n" 12042 " double y);", 12043 Alignment)); 12044 // This ensures that function parameters of function declarations are 12045 // correctly indented when their owning functions are indented. 12046 // The failure case here is for 'double y' to not be indented enough. 12047 EXPECT_EQ("double a(int x);\n" 12048 "int b(int y,\n" 12049 " double z);", 12050 format("double a(int x);\n" 12051 "int b(int y,\n" 12052 " double z);", 12053 Alignment)); 12054 // Set ColumnLimit low so that we induce wrapping immediately after 12055 // the function name and opening paren. 12056 Alignment.ColumnLimit = 13; 12057 verifyFormat("int function(\n" 12058 " int x,\n" 12059 " bool y);", 12060 Alignment); 12061 Alignment.ColumnLimit = OldColumnLimit; 12062 // Ensure function pointers don't screw up recursive alignment 12063 verifyFormat("int a(int x, void (*fp)(int y));\n" 12064 "double b();", 12065 Alignment); 12066 Alignment.AlignConsecutiveAssignments = true; 12067 // Ensure recursive alignment is broken by function braces, so that the 12068 // "a = 1" does not align with subsequent assignments inside the function 12069 // body. 12070 verifyFormat("int func(int a = 1) {\n" 12071 " int b = 2;\n" 12072 " int cc = 3;\n" 12073 "}", 12074 Alignment); 12075 verifyFormat("float something = 2000;\n" 12076 "double another = 911;\n" 12077 "int i = 1, j = 10;\n" 12078 "const int *oneMore = 1;\n" 12079 "unsigned i = 2;", 12080 Alignment); 12081 verifyFormat("int oneTwoThree = {0}; // comment\n" 12082 "unsigned oneTwo = 0; // comment", 12083 Alignment); 12084 // Make sure that scope is correctly tracked, in the absence of braces 12085 verifyFormat("for (int i = 0; i < n; i++)\n" 12086 " j = i;\n" 12087 "double x = 1;\n", 12088 Alignment); 12089 verifyFormat("if (int i = 0)\n" 12090 " j = i;\n" 12091 "double x = 1;\n", 12092 Alignment); 12093 // Ensure operator[] and operator() are comprehended 12094 verifyFormat("struct test {\n" 12095 " long long int foo();\n" 12096 " int operator[](int a);\n" 12097 " double bar();\n" 12098 "};\n", 12099 Alignment); 12100 verifyFormat("struct test {\n" 12101 " long long int foo();\n" 12102 " int operator()(int a);\n" 12103 " double bar();\n" 12104 "};\n", 12105 Alignment); 12106 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 12107 " int const i = 1;\n" 12108 " int * j = 2;\n" 12109 " int big = 10000;\n" 12110 "\n" 12111 " unsigned oneTwoThree = 123;\n" 12112 " int oneTwo = 12;\n" 12113 " method();\n" 12114 " float k = 2;\n" 12115 " int ll = 10000;\n" 12116 "}", 12117 format("void SomeFunction(int parameter= 0) {\n" 12118 " int const i= 1;\n" 12119 " int *j=2;\n" 12120 " int big = 10000;\n" 12121 "\n" 12122 "unsigned oneTwoThree =123;\n" 12123 "int oneTwo = 12;\n" 12124 " method();\n" 12125 "float k= 2;\n" 12126 "int ll=10000;\n" 12127 "}", 12128 Alignment)); 12129 Alignment.AlignConsecutiveAssignments = false; 12130 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 12131 verifyFormat("#define A \\\n" 12132 " int aaaa = 12; \\\n" 12133 " float b = 23; \\\n" 12134 " const int ccc = 234; \\\n" 12135 " unsigned dddddddddd = 2345;", 12136 Alignment); 12137 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 12138 verifyFormat("#define A \\\n" 12139 " int aaaa = 12; \\\n" 12140 " float b = 23; \\\n" 12141 " const int ccc = 234; \\\n" 12142 " unsigned dddddddddd = 2345;", 12143 Alignment); 12144 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 12145 Alignment.ColumnLimit = 30; 12146 verifyFormat("#define A \\\n" 12147 " int aaaa = 12; \\\n" 12148 " float b = 23; \\\n" 12149 " const int ccc = 234; \\\n" 12150 " int dddddddddd = 2345;", 12151 Alignment); 12152 Alignment.ColumnLimit = 80; 12153 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 12154 "k = 4, int l = 5,\n" 12155 " int m = 6) {\n" 12156 " const int j = 10;\n" 12157 " otherThing = 1;\n" 12158 "}", 12159 Alignment); 12160 verifyFormat("void SomeFunction(int parameter = 0) {\n" 12161 " int const i = 1;\n" 12162 " int * j = 2;\n" 12163 " int big = 10000;\n" 12164 "}", 12165 Alignment); 12166 verifyFormat("class C {\n" 12167 "public:\n" 12168 " int i = 1;\n" 12169 " virtual void f() = 0;\n" 12170 "};", 12171 Alignment); 12172 verifyFormat("float i = 1;\n" 12173 "if (SomeType t = getSomething()) {\n" 12174 "}\n" 12175 "const unsigned j = 2;\n" 12176 "int big = 10000;", 12177 Alignment); 12178 verifyFormat("float j = 7;\n" 12179 "for (int k = 0; k < N; ++k) {\n" 12180 "}\n" 12181 "unsigned j = 2;\n" 12182 "int big = 10000;\n" 12183 "}", 12184 Alignment); 12185 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 12186 verifyFormat("float i = 1;\n" 12187 "LooooooooooongType loooooooooooooooooooooongVariable\n" 12188 " = someLooooooooooooooooongFunction();\n" 12189 "int j = 2;", 12190 Alignment); 12191 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 12192 verifyFormat("int i = 1;\n" 12193 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 12194 " someLooooooooooooooooongFunction();\n" 12195 "int j = 2;", 12196 Alignment); 12197 12198 Alignment.AlignConsecutiveAssignments = true; 12199 verifyFormat("auto lambda = []() {\n" 12200 " auto ii = 0;\n" 12201 " float j = 0;\n" 12202 " return 0;\n" 12203 "};\n" 12204 "int i = 0;\n" 12205 "float i2 = 0;\n" 12206 "auto v = type{\n" 12207 " i = 1, //\n" 12208 " (i = 2), //\n" 12209 " i = 3 //\n" 12210 "};", 12211 Alignment); 12212 Alignment.AlignConsecutiveAssignments = false; 12213 12214 verifyFormat( 12215 "int i = 1;\n" 12216 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 12217 " loooooooooooooooooooooongParameterB);\n" 12218 "int j = 2;", 12219 Alignment); 12220 12221 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 12222 // We expect declarations and assignments to align, as long as it doesn't 12223 // exceed the column limit, starting a new alignment sequence whenever it 12224 // happens. 12225 Alignment.AlignConsecutiveAssignments = true; 12226 Alignment.ColumnLimit = 30; 12227 verifyFormat("float ii = 1;\n" 12228 "unsigned j = 2;\n" 12229 "int someVerylongVariable = 1;\n" 12230 "AnotherLongType ll = 123456;\n" 12231 "VeryVeryLongType k = 2;\n" 12232 "int myvar = 1;", 12233 Alignment); 12234 Alignment.ColumnLimit = 80; 12235 Alignment.AlignConsecutiveAssignments = false; 12236 12237 verifyFormat( 12238 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 12239 " typename LongType, typename B>\n" 12240 "auto foo() {}\n", 12241 Alignment); 12242 verifyFormat("float a, b = 1;\n" 12243 "int c = 2;\n" 12244 "int dd = 3;\n", 12245 Alignment); 12246 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 12247 "float b[1][] = {{3.f}};\n", 12248 Alignment); 12249 Alignment.AlignConsecutiveAssignments = true; 12250 verifyFormat("float a, b = 1;\n" 12251 "int c = 2;\n" 12252 "int dd = 3;\n", 12253 Alignment); 12254 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 12255 "float b[1][] = {{3.f}};\n", 12256 Alignment); 12257 Alignment.AlignConsecutiveAssignments = false; 12258 12259 Alignment.ColumnLimit = 30; 12260 Alignment.BinPackParameters = false; 12261 verifyFormat("void foo(float a,\n" 12262 " float b,\n" 12263 " int c,\n" 12264 " uint32_t *d) {\n" 12265 " int * e = 0;\n" 12266 " float f = 0;\n" 12267 " double g = 0;\n" 12268 "}\n" 12269 "void bar(ino_t a,\n" 12270 " int b,\n" 12271 " uint32_t *c,\n" 12272 " bool d) {}\n", 12273 Alignment); 12274 Alignment.BinPackParameters = true; 12275 Alignment.ColumnLimit = 80; 12276 12277 // Bug 33507 12278 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 12279 verifyFormat( 12280 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 12281 " static const Version verVs2017;\n" 12282 " return true;\n" 12283 "});\n", 12284 Alignment); 12285 Alignment.PointerAlignment = FormatStyle::PAS_Right; 12286 12287 // See llvm.org/PR35641 12288 Alignment.AlignConsecutiveDeclarations = true; 12289 verifyFormat("int func() { //\n" 12290 " int b;\n" 12291 " unsigned c;\n" 12292 "}", 12293 Alignment); 12294 12295 // See PR37175 12296 FormatStyle Style = getMozillaStyle(); 12297 Style.AlignConsecutiveDeclarations = true; 12298 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 12299 "foo(int a);", 12300 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 12301 } 12302 12303 TEST_F(FormatTest, LinuxBraceBreaking) { 12304 FormatStyle LinuxBraceStyle = getLLVMStyle(); 12305 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 12306 verifyFormat("namespace a\n" 12307 "{\n" 12308 "class A\n" 12309 "{\n" 12310 " void f()\n" 12311 " {\n" 12312 " if (true) {\n" 12313 " a();\n" 12314 " b();\n" 12315 " } else {\n" 12316 " a();\n" 12317 " }\n" 12318 " }\n" 12319 " void g() { return; }\n" 12320 "};\n" 12321 "struct B {\n" 12322 " int x;\n" 12323 "};\n" 12324 "} // namespace a\n", 12325 LinuxBraceStyle); 12326 verifyFormat("enum X {\n" 12327 " Y = 0,\n" 12328 "}\n", 12329 LinuxBraceStyle); 12330 verifyFormat("struct S {\n" 12331 " int Type;\n" 12332 " union {\n" 12333 " int x;\n" 12334 " double y;\n" 12335 " } Value;\n" 12336 " class C\n" 12337 " {\n" 12338 " MyFavoriteType Value;\n" 12339 " } Class;\n" 12340 "}\n", 12341 LinuxBraceStyle); 12342 } 12343 12344 TEST_F(FormatTest, MozillaBraceBreaking) { 12345 FormatStyle MozillaBraceStyle = getLLVMStyle(); 12346 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 12347 MozillaBraceStyle.FixNamespaceComments = false; 12348 verifyFormat("namespace a {\n" 12349 "class A\n" 12350 "{\n" 12351 " void f()\n" 12352 " {\n" 12353 " if (true) {\n" 12354 " a();\n" 12355 " b();\n" 12356 " }\n" 12357 " }\n" 12358 " void g() { return; }\n" 12359 "};\n" 12360 "enum E\n" 12361 "{\n" 12362 " A,\n" 12363 " // foo\n" 12364 " B,\n" 12365 " C\n" 12366 "};\n" 12367 "struct B\n" 12368 "{\n" 12369 " int x;\n" 12370 "};\n" 12371 "}\n", 12372 MozillaBraceStyle); 12373 verifyFormat("struct S\n" 12374 "{\n" 12375 " int Type;\n" 12376 " union\n" 12377 " {\n" 12378 " int x;\n" 12379 " double y;\n" 12380 " } Value;\n" 12381 " class C\n" 12382 " {\n" 12383 " MyFavoriteType Value;\n" 12384 " } Class;\n" 12385 "}\n", 12386 MozillaBraceStyle); 12387 } 12388 12389 TEST_F(FormatTest, StroustrupBraceBreaking) { 12390 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 12391 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 12392 verifyFormat("namespace a {\n" 12393 "class A {\n" 12394 " void f()\n" 12395 " {\n" 12396 " if (true) {\n" 12397 " a();\n" 12398 " b();\n" 12399 " }\n" 12400 " }\n" 12401 " void g() { return; }\n" 12402 "};\n" 12403 "struct B {\n" 12404 " int x;\n" 12405 "};\n" 12406 "} // namespace a\n", 12407 StroustrupBraceStyle); 12408 12409 verifyFormat("void foo()\n" 12410 "{\n" 12411 " if (a) {\n" 12412 " a();\n" 12413 " }\n" 12414 " else {\n" 12415 " b();\n" 12416 " }\n" 12417 "}\n", 12418 StroustrupBraceStyle); 12419 12420 verifyFormat("#ifdef _DEBUG\n" 12421 "int foo(int i = 0)\n" 12422 "#else\n" 12423 "int foo(int i = 5)\n" 12424 "#endif\n" 12425 "{\n" 12426 " return i;\n" 12427 "}", 12428 StroustrupBraceStyle); 12429 12430 verifyFormat("void foo() {}\n" 12431 "void bar()\n" 12432 "#ifdef _DEBUG\n" 12433 "{\n" 12434 " foo();\n" 12435 "}\n" 12436 "#else\n" 12437 "{\n" 12438 "}\n" 12439 "#endif", 12440 StroustrupBraceStyle); 12441 12442 verifyFormat("void foobar() { int i = 5; }\n" 12443 "#ifdef _DEBUG\n" 12444 "void bar() {}\n" 12445 "#else\n" 12446 "void bar() { foobar(); }\n" 12447 "#endif", 12448 StroustrupBraceStyle); 12449 } 12450 12451 TEST_F(FormatTest, AllmanBraceBreaking) { 12452 FormatStyle AllmanBraceStyle = getLLVMStyle(); 12453 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 12454 12455 EXPECT_EQ("namespace a\n" 12456 "{\n" 12457 "void f();\n" 12458 "void g();\n" 12459 "} // namespace a\n", 12460 format("namespace a\n" 12461 "{\n" 12462 "void f();\n" 12463 "void g();\n" 12464 "}\n", 12465 AllmanBraceStyle)); 12466 12467 verifyFormat("namespace a\n" 12468 "{\n" 12469 "class A\n" 12470 "{\n" 12471 " void f()\n" 12472 " {\n" 12473 " if (true)\n" 12474 " {\n" 12475 " a();\n" 12476 " b();\n" 12477 " }\n" 12478 " }\n" 12479 " void g() { return; }\n" 12480 "};\n" 12481 "struct B\n" 12482 "{\n" 12483 " int x;\n" 12484 "};\n" 12485 "union C\n" 12486 "{\n" 12487 "};\n" 12488 "} // namespace a", 12489 AllmanBraceStyle); 12490 12491 verifyFormat("void f()\n" 12492 "{\n" 12493 " if (true)\n" 12494 " {\n" 12495 " a();\n" 12496 " }\n" 12497 " else if (false)\n" 12498 " {\n" 12499 " b();\n" 12500 " }\n" 12501 " else\n" 12502 " {\n" 12503 " c();\n" 12504 " }\n" 12505 "}\n", 12506 AllmanBraceStyle); 12507 12508 verifyFormat("void f()\n" 12509 "{\n" 12510 " for (int i = 0; i < 10; ++i)\n" 12511 " {\n" 12512 " a();\n" 12513 " }\n" 12514 " while (false)\n" 12515 " {\n" 12516 " b();\n" 12517 " }\n" 12518 " do\n" 12519 " {\n" 12520 " c();\n" 12521 " } while (false)\n" 12522 "}\n", 12523 AllmanBraceStyle); 12524 12525 verifyFormat("void f(int a)\n" 12526 "{\n" 12527 " switch (a)\n" 12528 " {\n" 12529 " case 0:\n" 12530 " break;\n" 12531 " case 1:\n" 12532 " {\n" 12533 " break;\n" 12534 " }\n" 12535 " case 2:\n" 12536 " {\n" 12537 " }\n" 12538 " break;\n" 12539 " default:\n" 12540 " break;\n" 12541 " }\n" 12542 "}\n", 12543 AllmanBraceStyle); 12544 12545 verifyFormat("enum X\n" 12546 "{\n" 12547 " Y = 0,\n" 12548 "}\n", 12549 AllmanBraceStyle); 12550 verifyFormat("enum X\n" 12551 "{\n" 12552 " Y = 0\n" 12553 "}\n", 12554 AllmanBraceStyle); 12555 12556 verifyFormat("@interface BSApplicationController ()\n" 12557 "{\n" 12558 "@private\n" 12559 " id _extraIvar;\n" 12560 "}\n" 12561 "@end\n", 12562 AllmanBraceStyle); 12563 12564 verifyFormat("#ifdef _DEBUG\n" 12565 "int foo(int i = 0)\n" 12566 "#else\n" 12567 "int foo(int i = 5)\n" 12568 "#endif\n" 12569 "{\n" 12570 " return i;\n" 12571 "}", 12572 AllmanBraceStyle); 12573 12574 verifyFormat("void foo() {}\n" 12575 "void bar()\n" 12576 "#ifdef _DEBUG\n" 12577 "{\n" 12578 " foo();\n" 12579 "}\n" 12580 "#else\n" 12581 "{\n" 12582 "}\n" 12583 "#endif", 12584 AllmanBraceStyle); 12585 12586 verifyFormat("void foobar() { int i = 5; }\n" 12587 "#ifdef _DEBUG\n" 12588 "void bar() {}\n" 12589 "#else\n" 12590 "void bar() { foobar(); }\n" 12591 "#endif", 12592 AllmanBraceStyle); 12593 12594 // This shouldn't affect ObjC blocks.. 12595 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 12596 " // ...\n" 12597 " int i;\n" 12598 "}];", 12599 AllmanBraceStyle); 12600 verifyFormat("void (^block)(void) = ^{\n" 12601 " // ...\n" 12602 " int i;\n" 12603 "};", 12604 AllmanBraceStyle); 12605 // .. or dict literals. 12606 verifyFormat("void f()\n" 12607 "{\n" 12608 " // ...\n" 12609 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 12610 "}", 12611 AllmanBraceStyle); 12612 verifyFormat("void f()\n" 12613 "{\n" 12614 " // ...\n" 12615 " [object someMethod:@{a : @\"b\"}];\n" 12616 "}", 12617 AllmanBraceStyle); 12618 verifyFormat("int f()\n" 12619 "{ // comment\n" 12620 " return 42;\n" 12621 "}", 12622 AllmanBraceStyle); 12623 12624 AllmanBraceStyle.ColumnLimit = 19; 12625 verifyFormat("void f() { int i; }", AllmanBraceStyle); 12626 AllmanBraceStyle.ColumnLimit = 18; 12627 verifyFormat("void f()\n" 12628 "{\n" 12629 " int i;\n" 12630 "}", 12631 AllmanBraceStyle); 12632 AllmanBraceStyle.ColumnLimit = 80; 12633 12634 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 12635 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 12636 FormatStyle::SIS_WithoutElse; 12637 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 12638 verifyFormat("void f(bool b)\n" 12639 "{\n" 12640 " if (b)\n" 12641 " {\n" 12642 " return;\n" 12643 " }\n" 12644 "}\n", 12645 BreakBeforeBraceShortIfs); 12646 verifyFormat("void f(bool b)\n" 12647 "{\n" 12648 " if constexpr (b)\n" 12649 " {\n" 12650 " return;\n" 12651 " }\n" 12652 "}\n", 12653 BreakBeforeBraceShortIfs); 12654 verifyFormat("void f(bool b)\n" 12655 "{\n" 12656 " if CONSTEXPR (b)\n" 12657 " {\n" 12658 " return;\n" 12659 " }\n" 12660 "}\n", 12661 BreakBeforeBraceShortIfs); 12662 verifyFormat("void f(bool b)\n" 12663 "{\n" 12664 " if (b) return;\n" 12665 "}\n", 12666 BreakBeforeBraceShortIfs); 12667 verifyFormat("void f(bool b)\n" 12668 "{\n" 12669 " if constexpr (b) return;\n" 12670 "}\n", 12671 BreakBeforeBraceShortIfs); 12672 verifyFormat("void f(bool b)\n" 12673 "{\n" 12674 " if CONSTEXPR (b) return;\n" 12675 "}\n", 12676 BreakBeforeBraceShortIfs); 12677 verifyFormat("void f(bool b)\n" 12678 "{\n" 12679 " while (b)\n" 12680 " {\n" 12681 " return;\n" 12682 " }\n" 12683 "}\n", 12684 BreakBeforeBraceShortIfs); 12685 } 12686 12687 TEST_F(FormatTest, WhitesmithsBraceBreaking) { 12688 FormatStyle WhitesmithsBraceStyle = getLLVMStyle(); 12689 WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 12690 12691 // Make a few changes to the style for testing purposes 12692 WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine = 12693 FormatStyle::SFS_Empty; 12694 WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 12695 WhitesmithsBraceStyle.ColumnLimit = 0; 12696 12697 // FIXME: this test case can't decide whether there should be a blank line 12698 // after the ~D() line or not. It adds one if one doesn't exist in the test 12699 // and it removes the line if one exists. 12700 /* 12701 verifyFormat("class A;\n" 12702 "namespace B\n" 12703 " {\n" 12704 "class C;\n" 12705 "// Comment\n" 12706 "class D\n" 12707 " {\n" 12708 "public:\n" 12709 " D();\n" 12710 " ~D() {}\n" 12711 "private:\n" 12712 " enum E\n" 12713 " {\n" 12714 " F\n" 12715 " }\n" 12716 " };\n" 12717 " } // namespace B\n", 12718 WhitesmithsBraceStyle); 12719 */ 12720 12721 verifyFormat("namespace a\n" 12722 " {\n" 12723 "class A\n" 12724 " {\n" 12725 " void f()\n" 12726 " {\n" 12727 " if (true)\n" 12728 " {\n" 12729 " a();\n" 12730 " b();\n" 12731 " }\n" 12732 " }\n" 12733 " void g()\n" 12734 " {\n" 12735 " return;\n" 12736 " }\n" 12737 " };\n" 12738 "struct B\n" 12739 " {\n" 12740 " int x;\n" 12741 " };\n" 12742 " } // namespace a", 12743 WhitesmithsBraceStyle); 12744 12745 verifyFormat("void f()\n" 12746 " {\n" 12747 " if (true)\n" 12748 " {\n" 12749 " a();\n" 12750 " }\n" 12751 " else if (false)\n" 12752 " {\n" 12753 " b();\n" 12754 " }\n" 12755 " else\n" 12756 " {\n" 12757 " c();\n" 12758 " }\n" 12759 " }\n", 12760 WhitesmithsBraceStyle); 12761 12762 verifyFormat("void f()\n" 12763 " {\n" 12764 " for (int i = 0; i < 10; ++i)\n" 12765 " {\n" 12766 " a();\n" 12767 " }\n" 12768 " while (false)\n" 12769 " {\n" 12770 " b();\n" 12771 " }\n" 12772 " do\n" 12773 " {\n" 12774 " c();\n" 12775 " } while (false)\n" 12776 " }\n", 12777 WhitesmithsBraceStyle); 12778 12779 // FIXME: the block and the break under case 2 in this test don't get indented 12780 // correctly 12781 /* 12782 verifyFormat("void switchTest1(int a)\n" 12783 " {\n" 12784 " switch (a)\n" 12785 " {\n" 12786 " case 2:\n" 12787 " {\n" 12788 " }\n" 12789 " break;\n" 12790 " }\n" 12791 " }\n", 12792 WhitesmithsBraceStyle); 12793 */ 12794 12795 // FIXME: the block and the break under case 2 in this test don't get indented 12796 // correctly 12797 /* 12798 verifyFormat("void switchTest2(int a)\n" 12799 " {\n" 12800 " switch (a)\n" 12801 " {\n" 12802 " case 0:\n" 12803 " break;\n" 12804 " case 1:\n" 12805 " {\n" 12806 " break;\n" 12807 " }\n" 12808 " case 2:\n" 12809 " {\n" 12810 " }\n" 12811 " break;\n" 12812 " default:\n" 12813 " break;\n" 12814 " }\n" 12815 " }\n", 12816 WhitesmithsBraceStyle); 12817 */ 12818 12819 verifyFormat("enum X\n" 12820 " {\n" 12821 " Y = 0, // testing\n" 12822 " }\n", 12823 WhitesmithsBraceStyle); 12824 12825 verifyFormat("enum X\n" 12826 " {\n" 12827 " Y = 0\n" 12828 " }\n", 12829 WhitesmithsBraceStyle); 12830 verifyFormat("enum X\n" 12831 " {\n" 12832 " Y = 0,\n" 12833 " Z = 1\n" 12834 " };\n", 12835 WhitesmithsBraceStyle); 12836 12837 verifyFormat("@interface BSApplicationController ()\n" 12838 " {\n" 12839 "@private\n" 12840 " id _extraIvar;\n" 12841 " }\n" 12842 "@end\n", 12843 WhitesmithsBraceStyle); 12844 12845 verifyFormat("#ifdef _DEBUG\n" 12846 "int foo(int i = 0)\n" 12847 "#else\n" 12848 "int foo(int i = 5)\n" 12849 "#endif\n" 12850 " {\n" 12851 " return i;\n" 12852 " }", 12853 WhitesmithsBraceStyle); 12854 12855 verifyFormat("void foo() {}\n" 12856 "void bar()\n" 12857 "#ifdef _DEBUG\n" 12858 " {\n" 12859 " foo();\n" 12860 " }\n" 12861 "#else\n" 12862 " {\n" 12863 " }\n" 12864 "#endif", 12865 WhitesmithsBraceStyle); 12866 12867 verifyFormat("void foobar()\n" 12868 " {\n" 12869 " int i = 5;\n" 12870 " }\n" 12871 "#ifdef _DEBUG\n" 12872 "void bar()\n" 12873 " {\n" 12874 " }\n" 12875 "#else\n" 12876 "void bar()\n" 12877 " {\n" 12878 " foobar();\n" 12879 " }\n" 12880 "#endif", 12881 WhitesmithsBraceStyle); 12882 12883 // This shouldn't affect ObjC blocks.. 12884 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 12885 " // ...\n" 12886 " int i;\n" 12887 "}];", 12888 WhitesmithsBraceStyle); 12889 verifyFormat("void (^block)(void) = ^{\n" 12890 " // ...\n" 12891 " int i;\n" 12892 "};", 12893 WhitesmithsBraceStyle); 12894 // .. or dict literals. 12895 verifyFormat("void f()\n" 12896 " {\n" 12897 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 12898 " }", 12899 WhitesmithsBraceStyle); 12900 12901 verifyFormat("int f()\n" 12902 " { // comment\n" 12903 " return 42;\n" 12904 " }", 12905 WhitesmithsBraceStyle); 12906 12907 FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle; 12908 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 12909 FormatStyle::SIS_Always; 12910 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 12911 verifyFormat("void f(bool b)\n" 12912 " {\n" 12913 " if (b)\n" 12914 " {\n" 12915 " return;\n" 12916 " }\n" 12917 " }\n", 12918 BreakBeforeBraceShortIfs); 12919 verifyFormat("void f(bool b)\n" 12920 " {\n" 12921 " if (b) return;\n" 12922 " }\n", 12923 BreakBeforeBraceShortIfs); 12924 verifyFormat("void f(bool b)\n" 12925 " {\n" 12926 " while (b)\n" 12927 " {\n" 12928 " return;\n" 12929 " }\n" 12930 " }\n", 12931 BreakBeforeBraceShortIfs); 12932 } 12933 12934 TEST_F(FormatTest, GNUBraceBreaking) { 12935 FormatStyle GNUBraceStyle = getLLVMStyle(); 12936 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 12937 verifyFormat("namespace a\n" 12938 "{\n" 12939 "class A\n" 12940 "{\n" 12941 " void f()\n" 12942 " {\n" 12943 " int a;\n" 12944 " {\n" 12945 " int b;\n" 12946 " }\n" 12947 " if (true)\n" 12948 " {\n" 12949 " a();\n" 12950 " b();\n" 12951 " }\n" 12952 " }\n" 12953 " void g() { return; }\n" 12954 "}\n" 12955 "} // namespace a", 12956 GNUBraceStyle); 12957 12958 verifyFormat("void f()\n" 12959 "{\n" 12960 " if (true)\n" 12961 " {\n" 12962 " a();\n" 12963 " }\n" 12964 " else if (false)\n" 12965 " {\n" 12966 " b();\n" 12967 " }\n" 12968 " else\n" 12969 " {\n" 12970 " c();\n" 12971 " }\n" 12972 "}\n", 12973 GNUBraceStyle); 12974 12975 verifyFormat("void f()\n" 12976 "{\n" 12977 " for (int i = 0; i < 10; ++i)\n" 12978 " {\n" 12979 " a();\n" 12980 " }\n" 12981 " while (false)\n" 12982 " {\n" 12983 " b();\n" 12984 " }\n" 12985 " do\n" 12986 " {\n" 12987 " c();\n" 12988 " }\n" 12989 " while (false);\n" 12990 "}\n", 12991 GNUBraceStyle); 12992 12993 verifyFormat("void f(int a)\n" 12994 "{\n" 12995 " switch (a)\n" 12996 " {\n" 12997 " case 0:\n" 12998 " break;\n" 12999 " case 1:\n" 13000 " {\n" 13001 " break;\n" 13002 " }\n" 13003 " case 2:\n" 13004 " {\n" 13005 " }\n" 13006 " break;\n" 13007 " default:\n" 13008 " break;\n" 13009 " }\n" 13010 "}\n", 13011 GNUBraceStyle); 13012 13013 verifyFormat("enum X\n" 13014 "{\n" 13015 " Y = 0,\n" 13016 "}\n", 13017 GNUBraceStyle); 13018 13019 verifyFormat("@interface BSApplicationController ()\n" 13020 "{\n" 13021 "@private\n" 13022 " id _extraIvar;\n" 13023 "}\n" 13024 "@end\n", 13025 GNUBraceStyle); 13026 13027 verifyFormat("#ifdef _DEBUG\n" 13028 "int foo(int i = 0)\n" 13029 "#else\n" 13030 "int foo(int i = 5)\n" 13031 "#endif\n" 13032 "{\n" 13033 " return i;\n" 13034 "}", 13035 GNUBraceStyle); 13036 13037 verifyFormat("void foo() {}\n" 13038 "void bar()\n" 13039 "#ifdef _DEBUG\n" 13040 "{\n" 13041 " foo();\n" 13042 "}\n" 13043 "#else\n" 13044 "{\n" 13045 "}\n" 13046 "#endif", 13047 GNUBraceStyle); 13048 13049 verifyFormat("void foobar() { int i = 5; }\n" 13050 "#ifdef _DEBUG\n" 13051 "void bar() {}\n" 13052 "#else\n" 13053 "void bar() { foobar(); }\n" 13054 "#endif", 13055 GNUBraceStyle); 13056 } 13057 13058 TEST_F(FormatTest, WebKitBraceBreaking) { 13059 FormatStyle WebKitBraceStyle = getLLVMStyle(); 13060 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 13061 WebKitBraceStyle.FixNamespaceComments = false; 13062 verifyFormat("namespace a {\n" 13063 "class A {\n" 13064 " void f()\n" 13065 " {\n" 13066 " if (true) {\n" 13067 " a();\n" 13068 " b();\n" 13069 " }\n" 13070 " }\n" 13071 " void g() { return; }\n" 13072 "};\n" 13073 "enum E {\n" 13074 " A,\n" 13075 " // foo\n" 13076 " B,\n" 13077 " C\n" 13078 "};\n" 13079 "struct B {\n" 13080 " int x;\n" 13081 "};\n" 13082 "}\n", 13083 WebKitBraceStyle); 13084 verifyFormat("struct S {\n" 13085 " int Type;\n" 13086 " union {\n" 13087 " int x;\n" 13088 " double y;\n" 13089 " } Value;\n" 13090 " class C {\n" 13091 " MyFavoriteType Value;\n" 13092 " } Class;\n" 13093 "};\n", 13094 WebKitBraceStyle); 13095 } 13096 13097 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 13098 verifyFormat("void f() {\n" 13099 " try {\n" 13100 " } catch (const Exception &e) {\n" 13101 " }\n" 13102 "}\n", 13103 getLLVMStyle()); 13104 } 13105 13106 TEST_F(FormatTest, UnderstandsPragmas) { 13107 verifyFormat("#pragma omp reduction(| : var)"); 13108 verifyFormat("#pragma omp reduction(+ : var)"); 13109 13110 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 13111 "(including parentheses).", 13112 format("#pragma mark Any non-hyphenated or hyphenated string " 13113 "(including parentheses).")); 13114 } 13115 13116 TEST_F(FormatTest, UnderstandPragmaOption) { 13117 verifyFormat("#pragma option -C -A"); 13118 13119 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 13120 } 13121 13122 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 13123 FormatStyle Style = getLLVMStyle(); 13124 Style.ColumnLimit = 20; 13125 13126 // See PR41213 13127 EXPECT_EQ("/*\n" 13128 " *\t9012345\n" 13129 " * /8901\n" 13130 " */", 13131 format("/*\n" 13132 " *\t9012345 /8901\n" 13133 " */", 13134 Style)); 13135 EXPECT_EQ("/*\n" 13136 " *345678\n" 13137 " *\t/8901\n" 13138 " */", 13139 format("/*\n" 13140 " *345678\t/8901\n" 13141 " */", 13142 Style)); 13143 13144 verifyFormat("int a; // the\n" 13145 " // comment", 13146 Style); 13147 EXPECT_EQ("int a; /* first line\n" 13148 " * second\n" 13149 " * line third\n" 13150 " * line\n" 13151 " */", 13152 format("int a; /* first line\n" 13153 " * second\n" 13154 " * line third\n" 13155 " * line\n" 13156 " */", 13157 Style)); 13158 EXPECT_EQ("int a; // first line\n" 13159 " // second\n" 13160 " // line third\n" 13161 " // line", 13162 format("int a; // first line\n" 13163 " // second line\n" 13164 " // third line", 13165 Style)); 13166 13167 Style.PenaltyExcessCharacter = 90; 13168 verifyFormat("int a; // the comment", Style); 13169 EXPECT_EQ("int a; // the comment\n" 13170 " // aaa", 13171 format("int a; // the comment aaa", Style)); 13172 EXPECT_EQ("int a; /* first line\n" 13173 " * second line\n" 13174 " * third line\n" 13175 " */", 13176 format("int a; /* first line\n" 13177 " * second line\n" 13178 " * third line\n" 13179 " */", 13180 Style)); 13181 EXPECT_EQ("int a; // first line\n" 13182 " // second line\n" 13183 " // third line", 13184 format("int a; // first line\n" 13185 " // second line\n" 13186 " // third line", 13187 Style)); 13188 // FIXME: Investigate why this is not getting the same layout as the test 13189 // above. 13190 EXPECT_EQ("int a; /* first line\n" 13191 " * second line\n" 13192 " * third line\n" 13193 " */", 13194 format("int a; /* first line second line third line" 13195 "\n*/", 13196 Style)); 13197 13198 EXPECT_EQ("// foo bar baz bazfoo\n" 13199 "// foo bar foo bar\n", 13200 format("// foo bar baz bazfoo\n" 13201 "// foo bar foo bar\n", 13202 Style)); 13203 EXPECT_EQ("// foo bar baz bazfoo\n" 13204 "// foo bar foo bar\n", 13205 format("// foo bar baz bazfoo\n" 13206 "// foo bar foo bar\n", 13207 Style)); 13208 13209 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 13210 // next one. 13211 EXPECT_EQ("// foo bar baz bazfoo\n" 13212 "// bar foo bar\n", 13213 format("// foo bar baz bazfoo bar\n" 13214 "// foo bar\n", 13215 Style)); 13216 13217 EXPECT_EQ("// foo bar baz bazfoo\n" 13218 "// foo bar baz bazfoo\n" 13219 "// bar foo bar\n", 13220 format("// foo bar baz bazfoo\n" 13221 "// foo bar baz bazfoo bar\n" 13222 "// foo bar\n", 13223 Style)); 13224 13225 EXPECT_EQ("// foo bar baz bazfoo\n" 13226 "// foo bar baz bazfoo\n" 13227 "// bar foo bar\n", 13228 format("// foo bar baz bazfoo\n" 13229 "// foo bar baz bazfoo bar\n" 13230 "// foo bar\n", 13231 Style)); 13232 13233 // Make sure we do not keep protruding characters if strict mode reflow is 13234 // cheaper than keeping protruding characters. 13235 Style.ColumnLimit = 21; 13236 EXPECT_EQ( 13237 "// foo foo foo foo\n" 13238 "// foo foo foo foo\n" 13239 "// foo foo foo foo\n", 13240 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style)); 13241 13242 EXPECT_EQ("int a = /* long block\n" 13243 " comment */\n" 13244 " 42;", 13245 format("int a = /* long block comment */ 42;", Style)); 13246 } 13247 13248 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 13249 for (size_t i = 1; i < Styles.size(); ++i) \ 13250 EXPECT_EQ(Styles[0], Styles[i]) \ 13251 << "Style #" << i << " of " << Styles.size() << " differs from Style #0" 13252 13253 TEST_F(FormatTest, GetsPredefinedStyleByName) { 13254 SmallVector<FormatStyle, 3> Styles; 13255 Styles.resize(3); 13256 13257 Styles[0] = getLLVMStyle(); 13258 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 13259 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 13260 EXPECT_ALL_STYLES_EQUAL(Styles); 13261 13262 Styles[0] = getGoogleStyle(); 13263 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 13264 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 13265 EXPECT_ALL_STYLES_EQUAL(Styles); 13266 13267 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 13268 EXPECT_TRUE( 13269 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 13270 EXPECT_TRUE( 13271 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 13272 EXPECT_ALL_STYLES_EQUAL(Styles); 13273 13274 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 13275 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 13276 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 13277 EXPECT_ALL_STYLES_EQUAL(Styles); 13278 13279 Styles[0] = getMozillaStyle(); 13280 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 13281 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 13282 EXPECT_ALL_STYLES_EQUAL(Styles); 13283 13284 Styles[0] = getWebKitStyle(); 13285 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 13286 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 13287 EXPECT_ALL_STYLES_EQUAL(Styles); 13288 13289 Styles[0] = getGNUStyle(); 13290 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 13291 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 13292 EXPECT_ALL_STYLES_EQUAL(Styles); 13293 13294 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 13295 } 13296 13297 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 13298 SmallVector<FormatStyle, 8> Styles; 13299 Styles.resize(2); 13300 13301 Styles[0] = getGoogleStyle(); 13302 Styles[1] = getLLVMStyle(); 13303 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 13304 EXPECT_ALL_STYLES_EQUAL(Styles); 13305 13306 Styles.resize(5); 13307 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 13308 Styles[1] = getLLVMStyle(); 13309 Styles[1].Language = FormatStyle::LK_JavaScript; 13310 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 13311 13312 Styles[2] = getLLVMStyle(); 13313 Styles[2].Language = FormatStyle::LK_JavaScript; 13314 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 13315 "BasedOnStyle: Google", 13316 &Styles[2]) 13317 .value()); 13318 13319 Styles[3] = getLLVMStyle(); 13320 Styles[3].Language = FormatStyle::LK_JavaScript; 13321 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 13322 "Language: JavaScript", 13323 &Styles[3]) 13324 .value()); 13325 13326 Styles[4] = getLLVMStyle(); 13327 Styles[4].Language = FormatStyle::LK_JavaScript; 13328 EXPECT_EQ(0, parseConfiguration("---\n" 13329 "BasedOnStyle: LLVM\n" 13330 "IndentWidth: 123\n" 13331 "---\n" 13332 "BasedOnStyle: Google\n" 13333 "Language: JavaScript", 13334 &Styles[4]) 13335 .value()); 13336 EXPECT_ALL_STYLES_EQUAL(Styles); 13337 } 13338 13339 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 13340 Style.FIELD = false; \ 13341 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 13342 EXPECT_TRUE(Style.FIELD); \ 13343 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 13344 EXPECT_FALSE(Style.FIELD); 13345 13346 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 13347 13348 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 13349 Style.STRUCT.FIELD = false; \ 13350 EXPECT_EQ(0, \ 13351 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 13352 .value()); \ 13353 EXPECT_TRUE(Style.STRUCT.FIELD); \ 13354 EXPECT_EQ(0, \ 13355 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 13356 .value()); \ 13357 EXPECT_FALSE(Style.STRUCT.FIELD); 13358 13359 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 13360 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 13361 13362 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 13363 EXPECT_NE(VALUE, Style.FIELD); \ 13364 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 13365 EXPECT_EQ(VALUE, Style.FIELD) 13366 13367 TEST_F(FormatTest, ParsesConfigurationBools) { 13368 FormatStyle Style = {}; 13369 Style.Language = FormatStyle::LK_Cpp; 13370 CHECK_PARSE_BOOL(AlignTrailingComments); 13371 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 13372 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 13373 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 13374 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 13375 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 13376 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 13377 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 13378 CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine); 13379 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 13380 CHECK_PARSE_BOOL(BinPackArguments); 13381 CHECK_PARSE_BOOL(BinPackParameters); 13382 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 13383 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 13384 CHECK_PARSE_BOOL(BreakStringLiterals); 13385 CHECK_PARSE_BOOL(CompactNamespaces); 13386 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 13387 CHECK_PARSE_BOOL(DeriveLineEnding); 13388 CHECK_PARSE_BOOL(DerivePointerAlignment); 13389 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 13390 CHECK_PARSE_BOOL(DisableFormat); 13391 CHECK_PARSE_BOOL(IndentCaseLabels); 13392 CHECK_PARSE_BOOL(IndentCaseBlocks); 13393 CHECK_PARSE_BOOL(IndentGotoLabels); 13394 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 13395 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 13396 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 13397 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 13398 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 13399 CHECK_PARSE_BOOL(ReflowComments); 13400 CHECK_PARSE_BOOL(SortIncludes); 13401 CHECK_PARSE_BOOL(SortUsingDeclarations); 13402 CHECK_PARSE_BOOL(SpacesInParentheses); 13403 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 13404 CHECK_PARSE_BOOL(SpacesInAngles); 13405 CHECK_PARSE_BOOL(SpacesInConditionalStatement); 13406 CHECK_PARSE_BOOL(SpaceInEmptyBlock); 13407 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 13408 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 13409 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 13410 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 13411 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 13412 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 13413 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 13414 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 13415 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 13416 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 13417 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 13418 CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets); 13419 CHECK_PARSE_BOOL(UseCRLF); 13420 13421 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 13422 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 13423 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 13424 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 13425 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 13426 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 13427 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 13428 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 13429 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 13430 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 13431 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 13432 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody); 13433 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 13434 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 13435 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 13436 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 13437 } 13438 13439 #undef CHECK_PARSE_BOOL 13440 13441 TEST_F(FormatTest, ParsesConfiguration) { 13442 FormatStyle Style = {}; 13443 Style.Language = FormatStyle::LK_Cpp; 13444 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 13445 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 13446 ConstructorInitializerIndentWidth, 1234u); 13447 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 13448 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 13449 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 13450 CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u); 13451 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 13452 PenaltyBreakBeforeFirstCallParameter, 1234u); 13453 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 13454 PenaltyBreakTemplateDeclaration, 1234u); 13455 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 13456 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 13457 PenaltyReturnTypeOnItsOwnLine, 1234u); 13458 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 13459 SpacesBeforeTrailingComments, 1234u); 13460 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 13461 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 13462 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 13463 13464 Style.PointerAlignment = FormatStyle::PAS_Middle; 13465 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 13466 FormatStyle::PAS_Left); 13467 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 13468 FormatStyle::PAS_Right); 13469 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 13470 FormatStyle::PAS_Middle); 13471 // For backward compatibility: 13472 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 13473 FormatStyle::PAS_Left); 13474 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 13475 FormatStyle::PAS_Right); 13476 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 13477 FormatStyle::PAS_Middle); 13478 13479 Style.Standard = FormatStyle::LS_Auto; 13480 CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03); 13481 CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11); 13482 CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14); 13483 CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17); 13484 CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20); 13485 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 13486 CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest); 13487 // Legacy aliases: 13488 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 13489 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest); 13490 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 13491 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 13492 13493 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 13494 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 13495 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 13496 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 13497 FormatStyle::BOS_None); 13498 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 13499 FormatStyle::BOS_All); 13500 // For backward compatibility: 13501 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 13502 FormatStyle::BOS_None); 13503 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 13504 FormatStyle::BOS_All); 13505 13506 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 13507 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 13508 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 13509 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 13510 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 13511 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 13512 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 13513 // For backward compatibility: 13514 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 13515 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 13516 13517 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 13518 CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList, 13519 FormatStyle::BILS_BeforeComma); 13520 CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList, 13521 FormatStyle::BILS_AfterColon); 13522 CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList, 13523 FormatStyle::BILS_BeforeColon); 13524 // For backward compatibility: 13525 CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList, 13526 FormatStyle::BILS_BeforeComma); 13527 13528 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 13529 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 13530 FormatStyle::BAS_Align); 13531 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 13532 FormatStyle::BAS_DontAlign); 13533 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 13534 FormatStyle::BAS_AlwaysBreak); 13535 // For backward compatibility: 13536 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 13537 FormatStyle::BAS_DontAlign); 13538 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 13539 FormatStyle::BAS_Align); 13540 13541 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 13542 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 13543 FormatStyle::ENAS_DontAlign); 13544 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 13545 FormatStyle::ENAS_Left); 13546 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 13547 FormatStyle::ENAS_Right); 13548 // For backward compatibility: 13549 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 13550 FormatStyle::ENAS_Left); 13551 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 13552 FormatStyle::ENAS_Right); 13553 13554 Style.AlignOperands = FormatStyle::OAS_Align; 13555 CHECK_PARSE("AlignOperands: DontAlign", AlignOperands, 13556 FormatStyle::OAS_DontAlign); 13557 CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align); 13558 CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands, 13559 FormatStyle::OAS_AlignAfterOperator); 13560 // For backward compatibility: 13561 CHECK_PARSE("AlignOperands: false", AlignOperands, 13562 FormatStyle::OAS_DontAlign); 13563 CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align); 13564 13565 Style.UseTab = FormatStyle::UT_ForIndentation; 13566 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 13567 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 13568 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 13569 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 13570 FormatStyle::UT_ForContinuationAndIndentation); 13571 CHECK_PARSE("UseTab: AlignWithSpaces", UseTab, 13572 FormatStyle::UT_AlignWithSpaces); 13573 // For backward compatibility: 13574 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 13575 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 13576 13577 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 13578 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never", 13579 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 13580 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty", 13581 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty); 13582 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always", 13583 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 13584 // For backward compatibility: 13585 CHECK_PARSE("AllowShortBlocksOnASingleLine: false", 13586 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 13587 CHECK_PARSE("AllowShortBlocksOnASingleLine: true", 13588 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 13589 13590 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 13591 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 13592 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 13593 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 13594 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 13595 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 13596 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 13597 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 13598 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 13599 // For backward compatibility: 13600 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 13601 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 13602 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 13603 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 13604 13605 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 13606 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 13607 FormatStyle::SBPO_Never); 13608 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 13609 FormatStyle::SBPO_Always); 13610 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 13611 FormatStyle::SBPO_ControlStatements); 13612 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 13613 FormatStyle::SBPO_NonEmptyParentheses); 13614 // For backward compatibility: 13615 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 13616 FormatStyle::SBPO_Never); 13617 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 13618 FormatStyle::SBPO_ControlStatements); 13619 13620 Style.ColumnLimit = 123; 13621 FormatStyle BaseStyle = getLLVMStyle(); 13622 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 13623 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 13624 13625 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 13626 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 13627 FormatStyle::BS_Attach); 13628 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 13629 FormatStyle::BS_Linux); 13630 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 13631 FormatStyle::BS_Mozilla); 13632 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 13633 FormatStyle::BS_Stroustrup); 13634 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 13635 FormatStyle::BS_Allman); 13636 CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces, 13637 FormatStyle::BS_Whitesmiths); 13638 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 13639 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 13640 FormatStyle::BS_WebKit); 13641 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 13642 FormatStyle::BS_Custom); 13643 13644 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never; 13645 CHECK_PARSE("BraceWrapping:\n" 13646 " AfterControlStatement: MultiLine", 13647 BraceWrapping.AfterControlStatement, 13648 FormatStyle::BWACS_MultiLine); 13649 CHECK_PARSE("BraceWrapping:\n" 13650 " AfterControlStatement: Always", 13651 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 13652 CHECK_PARSE("BraceWrapping:\n" 13653 " AfterControlStatement: Never", 13654 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 13655 // For backward compatibility: 13656 CHECK_PARSE("BraceWrapping:\n" 13657 " AfterControlStatement: true", 13658 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 13659 CHECK_PARSE("BraceWrapping:\n" 13660 " AfterControlStatement: false", 13661 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 13662 13663 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 13664 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 13665 FormatStyle::RTBS_None); 13666 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 13667 FormatStyle::RTBS_All); 13668 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 13669 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 13670 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 13671 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 13672 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 13673 AlwaysBreakAfterReturnType, 13674 FormatStyle::RTBS_TopLevelDefinitions); 13675 13676 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 13677 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", 13678 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No); 13679 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", 13680 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 13681 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", 13682 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 13683 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", 13684 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 13685 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", 13686 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 13687 13688 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 13689 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 13690 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 13691 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 13692 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 13693 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 13694 AlwaysBreakAfterDefinitionReturnType, 13695 FormatStyle::DRTBS_TopLevel); 13696 13697 Style.NamespaceIndentation = FormatStyle::NI_All; 13698 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 13699 FormatStyle::NI_None); 13700 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 13701 FormatStyle::NI_Inner); 13702 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 13703 FormatStyle::NI_All); 13704 13705 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 13706 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 13707 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 13708 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 13709 AllowShortIfStatementsOnASingleLine, 13710 FormatStyle::SIS_WithoutElse); 13711 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 13712 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 13713 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 13714 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 13715 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 13716 AllowShortIfStatementsOnASingleLine, 13717 FormatStyle::SIS_WithoutElse); 13718 13719 // FIXME: This is required because parsing a configuration simply overwrites 13720 // the first N elements of the list instead of resetting it. 13721 Style.ForEachMacros.clear(); 13722 std::vector<std::string> BoostForeach; 13723 BoostForeach.push_back("BOOST_FOREACH"); 13724 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 13725 std::vector<std::string> BoostAndQForeach; 13726 BoostAndQForeach.push_back("BOOST_FOREACH"); 13727 BoostAndQForeach.push_back("Q_FOREACH"); 13728 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 13729 BoostAndQForeach); 13730 13731 Style.StatementMacros.clear(); 13732 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 13733 std::vector<std::string>{"QUNUSED"}); 13734 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 13735 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 13736 13737 Style.NamespaceMacros.clear(); 13738 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 13739 std::vector<std::string>{"TESTSUITE"}); 13740 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 13741 std::vector<std::string>({"TESTSUITE", "SUITE"})); 13742 13743 Style.IncludeStyle.IncludeCategories.clear(); 13744 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 13745 {"abc/.*", 2, 0}, {".*", 1, 0}}; 13746 CHECK_PARSE("IncludeCategories:\n" 13747 " - Regex: abc/.*\n" 13748 " Priority: 2\n" 13749 " - Regex: .*\n" 13750 " Priority: 1", 13751 IncludeStyle.IncludeCategories, ExpectedCategories); 13752 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 13753 "abc$"); 13754 CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'", 13755 IncludeStyle.IncludeIsMainSourceRegex, "abc$"); 13756 13757 Style.RawStringFormats.clear(); 13758 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 13759 { 13760 FormatStyle::LK_TextProto, 13761 {"pb", "proto"}, 13762 {"PARSE_TEXT_PROTO"}, 13763 /*CanonicalDelimiter=*/"", 13764 "llvm", 13765 }, 13766 { 13767 FormatStyle::LK_Cpp, 13768 {"cc", "cpp"}, 13769 {"C_CODEBLOCK", "CPPEVAL"}, 13770 /*CanonicalDelimiter=*/"cc", 13771 /*BasedOnStyle=*/"", 13772 }, 13773 }; 13774 13775 CHECK_PARSE("RawStringFormats:\n" 13776 " - Language: TextProto\n" 13777 " Delimiters:\n" 13778 " - 'pb'\n" 13779 " - 'proto'\n" 13780 " EnclosingFunctions:\n" 13781 " - 'PARSE_TEXT_PROTO'\n" 13782 " BasedOnStyle: llvm\n" 13783 " - Language: Cpp\n" 13784 " Delimiters:\n" 13785 " - 'cc'\n" 13786 " - 'cpp'\n" 13787 " EnclosingFunctions:\n" 13788 " - 'C_CODEBLOCK'\n" 13789 " - 'CPPEVAL'\n" 13790 " CanonicalDelimiter: 'cc'", 13791 RawStringFormats, ExpectedRawStringFormats); 13792 } 13793 13794 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 13795 FormatStyle Style = {}; 13796 Style.Language = FormatStyle::LK_Cpp; 13797 CHECK_PARSE("Language: Cpp\n" 13798 "IndentWidth: 12", 13799 IndentWidth, 12u); 13800 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 13801 "IndentWidth: 34", 13802 &Style), 13803 ParseError::Unsuitable); 13804 FormatStyle BinPackedTCS = {}; 13805 BinPackedTCS.Language = FormatStyle::LK_JavaScript; 13806 EXPECT_EQ(parseConfiguration("BinPackArguments: true\n" 13807 "InsertTrailingCommas: Wrapped", 13808 &BinPackedTCS), 13809 ParseError::BinPackTrailingCommaConflict); 13810 EXPECT_EQ(12u, Style.IndentWidth); 13811 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 13812 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 13813 13814 Style.Language = FormatStyle::LK_JavaScript; 13815 CHECK_PARSE("Language: JavaScript\n" 13816 "IndentWidth: 12", 13817 IndentWidth, 12u); 13818 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 13819 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 13820 "IndentWidth: 34", 13821 &Style), 13822 ParseError::Unsuitable); 13823 EXPECT_EQ(23u, Style.IndentWidth); 13824 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 13825 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 13826 13827 CHECK_PARSE("BasedOnStyle: LLVM\n" 13828 "IndentWidth: 67", 13829 IndentWidth, 67u); 13830 13831 CHECK_PARSE("---\n" 13832 "Language: JavaScript\n" 13833 "IndentWidth: 12\n" 13834 "---\n" 13835 "Language: Cpp\n" 13836 "IndentWidth: 34\n" 13837 "...\n", 13838 IndentWidth, 12u); 13839 13840 Style.Language = FormatStyle::LK_Cpp; 13841 CHECK_PARSE("---\n" 13842 "Language: JavaScript\n" 13843 "IndentWidth: 12\n" 13844 "---\n" 13845 "Language: Cpp\n" 13846 "IndentWidth: 34\n" 13847 "...\n", 13848 IndentWidth, 34u); 13849 CHECK_PARSE("---\n" 13850 "IndentWidth: 78\n" 13851 "---\n" 13852 "Language: JavaScript\n" 13853 "IndentWidth: 56\n" 13854 "...\n", 13855 IndentWidth, 78u); 13856 13857 Style.ColumnLimit = 123; 13858 Style.IndentWidth = 234; 13859 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 13860 Style.TabWidth = 345; 13861 EXPECT_FALSE(parseConfiguration("---\n" 13862 "IndentWidth: 456\n" 13863 "BreakBeforeBraces: Allman\n" 13864 "---\n" 13865 "Language: JavaScript\n" 13866 "IndentWidth: 111\n" 13867 "TabWidth: 111\n" 13868 "---\n" 13869 "Language: Cpp\n" 13870 "BreakBeforeBraces: Stroustrup\n" 13871 "TabWidth: 789\n" 13872 "...\n", 13873 &Style)); 13874 EXPECT_EQ(123u, Style.ColumnLimit); 13875 EXPECT_EQ(456u, Style.IndentWidth); 13876 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 13877 EXPECT_EQ(789u, Style.TabWidth); 13878 13879 EXPECT_EQ(parseConfiguration("---\n" 13880 "Language: JavaScript\n" 13881 "IndentWidth: 56\n" 13882 "---\n" 13883 "IndentWidth: 78\n" 13884 "...\n", 13885 &Style), 13886 ParseError::Error); 13887 EXPECT_EQ(parseConfiguration("---\n" 13888 "Language: JavaScript\n" 13889 "IndentWidth: 56\n" 13890 "---\n" 13891 "Language: JavaScript\n" 13892 "IndentWidth: 78\n" 13893 "...\n", 13894 &Style), 13895 ParseError::Error); 13896 13897 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 13898 } 13899 13900 #undef CHECK_PARSE 13901 13902 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 13903 FormatStyle Style = {}; 13904 Style.Language = FormatStyle::LK_JavaScript; 13905 Style.BreakBeforeTernaryOperators = true; 13906 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 13907 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 13908 13909 Style.BreakBeforeTernaryOperators = true; 13910 EXPECT_EQ(0, parseConfiguration("---\n" 13911 "BasedOnStyle: Google\n" 13912 "---\n" 13913 "Language: JavaScript\n" 13914 "IndentWidth: 76\n" 13915 "...\n", 13916 &Style) 13917 .value()); 13918 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 13919 EXPECT_EQ(76u, Style.IndentWidth); 13920 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 13921 } 13922 13923 TEST_F(FormatTest, ConfigurationRoundTripTest) { 13924 FormatStyle Style = getLLVMStyle(); 13925 std::string YAML = configurationAsText(Style); 13926 FormatStyle ParsedStyle = {}; 13927 ParsedStyle.Language = FormatStyle::LK_Cpp; 13928 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 13929 EXPECT_EQ(Style, ParsedStyle); 13930 } 13931 13932 TEST_F(FormatTest, WorksFor8bitEncodings) { 13933 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 13934 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 13935 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 13936 "\"\xef\xee\xf0\xf3...\"", 13937 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 13938 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 13939 "\xef\xee\xf0\xf3...\"", 13940 getLLVMStyleWithColumns(12))); 13941 } 13942 13943 TEST_F(FormatTest, HandlesUTF8BOM) { 13944 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 13945 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 13946 format("\xef\xbb\xbf#include <iostream>")); 13947 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 13948 format("\xef\xbb\xbf\n#include <iostream>")); 13949 } 13950 13951 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 13952 #if !defined(_MSC_VER) 13953 13954 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 13955 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 13956 getLLVMStyleWithColumns(35)); 13957 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 13958 getLLVMStyleWithColumns(31)); 13959 verifyFormat("// Однажды в студёную зимнюю пору...", 13960 getLLVMStyleWithColumns(36)); 13961 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 13962 verifyFormat("/* Однажды в студёную зимнюю пору... */", 13963 getLLVMStyleWithColumns(39)); 13964 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 13965 getLLVMStyleWithColumns(35)); 13966 } 13967 13968 TEST_F(FormatTest, SplitsUTF8Strings) { 13969 // Non-printable characters' width is currently considered to be the length in 13970 // bytes in UTF8. The characters can be displayed in very different manner 13971 // (zero-width, single width with a substitution glyph, expanded to their code 13972 // (e.g. "<8d>"), so there's no single correct way to handle them. 13973 EXPECT_EQ("\"aaaaÄ\"\n" 13974 "\"\xc2\x8d\";", 13975 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13976 EXPECT_EQ("\"aaaaaaaÄ\"\n" 13977 "\"\xc2\x8d\";", 13978 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13979 EXPECT_EQ("\"Однажды, в \"\n" 13980 "\"студёную \"\n" 13981 "\"зимнюю \"\n" 13982 "\"пору,\"", 13983 format("\"Однажды, в студёную зимнюю пору,\"", 13984 getLLVMStyleWithColumns(13))); 13985 EXPECT_EQ( 13986 "\"一 二 三 \"\n" 13987 "\"四 五六 \"\n" 13988 "\"七 八 九 \"\n" 13989 "\"十\"", 13990 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 13991 EXPECT_EQ("\"一\t\"\n" 13992 "\"二 \t\"\n" 13993 "\"三 四 \"\n" 13994 "\"五\t\"\n" 13995 "\"六 \t\"\n" 13996 "\"七 \"\n" 13997 "\"八九十\tqq\"", 13998 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 13999 getLLVMStyleWithColumns(11))); 14000 14001 // UTF8 character in an escape sequence. 14002 EXPECT_EQ("\"aaaaaa\"\n" 14003 "\"\\\xC2\x8D\"", 14004 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 14005 } 14006 14007 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 14008 EXPECT_EQ("const char *sssss =\n" 14009 " \"一二三四五六七八\\\n" 14010 " 九 十\";", 14011 format("const char *sssss = \"一二三四五六七八\\\n" 14012 " 九 十\";", 14013 getLLVMStyleWithColumns(30))); 14014 } 14015 14016 TEST_F(FormatTest, SplitsUTF8LineComments) { 14017 EXPECT_EQ("// aaaaÄ\xc2\x8d", 14018 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 14019 EXPECT_EQ("// Я из лесу\n" 14020 "// вышел; был\n" 14021 "// сильный\n" 14022 "// мороз.", 14023 format("// Я из лесу вышел; был сильный мороз.", 14024 getLLVMStyleWithColumns(13))); 14025 EXPECT_EQ("// 一二三\n" 14026 "// 四五六七\n" 14027 "// 八 九\n" 14028 "// 十", 14029 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 14030 } 14031 14032 TEST_F(FormatTest, SplitsUTF8BlockComments) { 14033 EXPECT_EQ("/* Гляжу,\n" 14034 " * поднимается\n" 14035 " * медленно в\n" 14036 " * гору\n" 14037 " * Лошадка,\n" 14038 " * везущая\n" 14039 " * хворосту\n" 14040 " * воз. */", 14041 format("/* Гляжу, поднимается медленно в гору\n" 14042 " * Лошадка, везущая хворосту воз. */", 14043 getLLVMStyleWithColumns(13))); 14044 EXPECT_EQ( 14045 "/* 一二三\n" 14046 " * 四五六七\n" 14047 " * 八 九\n" 14048 " * 十 */", 14049 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 14050 EXPECT_EQ("/* �������� ��������\n" 14051 " * ��������\n" 14052 " * ������-�� */", 14053 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 14054 } 14055 14056 #endif // _MSC_VER 14057 14058 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 14059 FormatStyle Style = getLLVMStyle(); 14060 14061 Style.ConstructorInitializerIndentWidth = 4; 14062 verifyFormat( 14063 "SomeClass::Constructor()\n" 14064 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 14065 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 14066 Style); 14067 14068 Style.ConstructorInitializerIndentWidth = 2; 14069 verifyFormat( 14070 "SomeClass::Constructor()\n" 14071 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 14072 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 14073 Style); 14074 14075 Style.ConstructorInitializerIndentWidth = 0; 14076 verifyFormat( 14077 "SomeClass::Constructor()\n" 14078 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 14079 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 14080 Style); 14081 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 14082 verifyFormat( 14083 "SomeLongTemplateVariableName<\n" 14084 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 14085 Style); 14086 verifyFormat("bool smaller = 1 < " 14087 "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 14088 " " 14089 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 14090 Style); 14091 14092 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 14093 verifyFormat("SomeClass::Constructor() :\n" 14094 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 14095 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 14096 Style); 14097 } 14098 14099 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 14100 FormatStyle Style = getLLVMStyle(); 14101 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 14102 Style.ConstructorInitializerIndentWidth = 4; 14103 verifyFormat("SomeClass::Constructor()\n" 14104 " : a(a)\n" 14105 " , b(b)\n" 14106 " , c(c) {}", 14107 Style); 14108 verifyFormat("SomeClass::Constructor()\n" 14109 " : a(a) {}", 14110 Style); 14111 14112 Style.ColumnLimit = 0; 14113 verifyFormat("SomeClass::Constructor()\n" 14114 " : a(a) {}", 14115 Style); 14116 verifyFormat("SomeClass::Constructor() noexcept\n" 14117 " : a(a) {}", 14118 Style); 14119 verifyFormat("SomeClass::Constructor()\n" 14120 " : a(a)\n" 14121 " , b(b)\n" 14122 " , c(c) {}", 14123 Style); 14124 verifyFormat("SomeClass::Constructor()\n" 14125 " : a(a) {\n" 14126 " foo();\n" 14127 " bar();\n" 14128 "}", 14129 Style); 14130 14131 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 14132 verifyFormat("SomeClass::Constructor()\n" 14133 " : a(a)\n" 14134 " , b(b)\n" 14135 " , c(c) {\n}", 14136 Style); 14137 verifyFormat("SomeClass::Constructor()\n" 14138 " : a(a) {\n}", 14139 Style); 14140 14141 Style.ColumnLimit = 80; 14142 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 14143 Style.ConstructorInitializerIndentWidth = 2; 14144 verifyFormat("SomeClass::Constructor()\n" 14145 " : a(a)\n" 14146 " , b(b)\n" 14147 " , c(c) {}", 14148 Style); 14149 14150 Style.ConstructorInitializerIndentWidth = 0; 14151 verifyFormat("SomeClass::Constructor()\n" 14152 ": a(a)\n" 14153 ", b(b)\n" 14154 ", c(c) {}", 14155 Style); 14156 14157 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 14158 Style.ConstructorInitializerIndentWidth = 4; 14159 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 14160 verifyFormat( 14161 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 14162 Style); 14163 verifyFormat( 14164 "SomeClass::Constructor()\n" 14165 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 14166 Style); 14167 Style.ConstructorInitializerIndentWidth = 4; 14168 Style.ColumnLimit = 60; 14169 verifyFormat("SomeClass::Constructor()\n" 14170 " : aaaaaaaa(aaaaaaaa)\n" 14171 " , aaaaaaaa(aaaaaaaa)\n" 14172 " , aaaaaaaa(aaaaaaaa) {}", 14173 Style); 14174 } 14175 14176 TEST_F(FormatTest, Destructors) { 14177 verifyFormat("void F(int &i) { i.~int(); }"); 14178 verifyFormat("void F(int &i) { i->~int(); }"); 14179 } 14180 14181 TEST_F(FormatTest, FormatsWithWebKitStyle) { 14182 FormatStyle Style = getWebKitStyle(); 14183 14184 // Don't indent in outer namespaces. 14185 verifyFormat("namespace outer {\n" 14186 "int i;\n" 14187 "namespace inner {\n" 14188 " int i;\n" 14189 "} // namespace inner\n" 14190 "} // namespace outer\n" 14191 "namespace other_outer {\n" 14192 "int i;\n" 14193 "}", 14194 Style); 14195 14196 // Don't indent case labels. 14197 verifyFormat("switch (variable) {\n" 14198 "case 1:\n" 14199 "case 2:\n" 14200 " doSomething();\n" 14201 " break;\n" 14202 "default:\n" 14203 " ++variable;\n" 14204 "}", 14205 Style); 14206 14207 // Wrap before binary operators. 14208 EXPECT_EQ("void f()\n" 14209 "{\n" 14210 " if (aaaaaaaaaaaaaaaa\n" 14211 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 14212 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 14213 " return;\n" 14214 "}", 14215 format("void f() {\n" 14216 "if (aaaaaaaaaaaaaaaa\n" 14217 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 14218 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 14219 "return;\n" 14220 "}", 14221 Style)); 14222 14223 // Allow functions on a single line. 14224 verifyFormat("void f() { return; }", Style); 14225 14226 // Allow empty blocks on a single line and insert a space in empty blocks. 14227 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 14228 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 14229 // However, don't merge non-empty short loops. 14230 EXPECT_EQ("while (true) {\n" 14231 " continue;\n" 14232 "}", 14233 format("while (true) { continue; }", Style)); 14234 14235 // Constructor initializers are formatted one per line with the "," on the 14236 // new line. 14237 verifyFormat("Constructor()\n" 14238 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 14239 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 14240 " aaaaaaaaaaaaaa)\n" 14241 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 14242 "{\n" 14243 "}", 14244 Style); 14245 verifyFormat("SomeClass::Constructor()\n" 14246 " : a(a)\n" 14247 "{\n" 14248 "}", 14249 Style); 14250 EXPECT_EQ("SomeClass::Constructor()\n" 14251 " : a(a)\n" 14252 "{\n" 14253 "}", 14254 format("SomeClass::Constructor():a(a){}", Style)); 14255 verifyFormat("SomeClass::Constructor()\n" 14256 " : a(a)\n" 14257 " , b(b)\n" 14258 " , c(c)\n" 14259 "{\n" 14260 "}", 14261 Style); 14262 verifyFormat("SomeClass::Constructor()\n" 14263 " : a(a)\n" 14264 "{\n" 14265 " foo();\n" 14266 " bar();\n" 14267 "}", 14268 Style); 14269 14270 // Access specifiers should be aligned left. 14271 verifyFormat("class C {\n" 14272 "public:\n" 14273 " int i;\n" 14274 "};", 14275 Style); 14276 14277 // Do not align comments. 14278 verifyFormat("int a; // Do not\n" 14279 "double b; // align comments.", 14280 Style); 14281 14282 // Do not align operands. 14283 EXPECT_EQ("ASSERT(aaaa\n" 14284 " || bbbb);", 14285 format("ASSERT ( aaaa\n||bbbb);", Style)); 14286 14287 // Accept input's line breaks. 14288 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 14289 " || bbbbbbbbbbbbbbb) {\n" 14290 " i++;\n" 14291 "}", 14292 format("if (aaaaaaaaaaaaaaa\n" 14293 "|| bbbbbbbbbbbbbbb) { i++; }", 14294 Style)); 14295 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 14296 " i++;\n" 14297 "}", 14298 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 14299 14300 // Don't automatically break all macro definitions (llvm.org/PR17842). 14301 verifyFormat("#define aNumber 10", Style); 14302 // However, generally keep the line breaks that the user authored. 14303 EXPECT_EQ("#define aNumber \\\n" 14304 " 10", 14305 format("#define aNumber \\\n" 14306 " 10", 14307 Style)); 14308 14309 // Keep empty and one-element array literals on a single line. 14310 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 14311 " copyItems:YES];", 14312 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 14313 "copyItems:YES];", 14314 Style)); 14315 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 14316 " copyItems:YES];", 14317 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 14318 " copyItems:YES];", 14319 Style)); 14320 // FIXME: This does not seem right, there should be more indentation before 14321 // the array literal's entries. Nested blocks have the same problem. 14322 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 14323 " @\"a\",\n" 14324 " @\"a\"\n" 14325 "]\n" 14326 " copyItems:YES];", 14327 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 14328 " @\"a\",\n" 14329 " @\"a\"\n" 14330 " ]\n" 14331 " copyItems:YES];", 14332 Style)); 14333 EXPECT_EQ( 14334 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 14335 " copyItems:YES];", 14336 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 14337 " copyItems:YES];", 14338 Style)); 14339 14340 verifyFormat("[self.a b:c c:d];", Style); 14341 EXPECT_EQ("[self.a b:c\n" 14342 " c:d];", 14343 format("[self.a b:c\n" 14344 "c:d];", 14345 Style)); 14346 } 14347 14348 TEST_F(FormatTest, FormatsLambdas) { 14349 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 14350 verifyFormat( 14351 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 14352 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 14353 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 14354 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 14355 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 14356 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 14357 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 14358 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 14359 verifyFormat("int x = f(*+[] {});"); 14360 verifyFormat("void f() {\n" 14361 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 14362 "}\n"); 14363 verifyFormat("void f() {\n" 14364 " other(x.begin(), //\n" 14365 " x.end(), //\n" 14366 " [&](int, int) { return 1; });\n" 14367 "}\n"); 14368 verifyFormat("void f() {\n" 14369 " other.other.other.other.other(\n" 14370 " x.begin(), x.end(),\n" 14371 " [something, rather](int, int, int, int, int, int, int) { " 14372 "return 1; });\n" 14373 "}\n"); 14374 verifyFormat( 14375 "void f() {\n" 14376 " other.other.other.other.other(\n" 14377 " x.begin(), x.end(),\n" 14378 " [something, rather](int, int, int, int, int, int, int) {\n" 14379 " //\n" 14380 " });\n" 14381 "}\n"); 14382 verifyFormat("SomeFunction([]() { // A cool function...\n" 14383 " return 43;\n" 14384 "});"); 14385 EXPECT_EQ("SomeFunction([]() {\n" 14386 "#define A a\n" 14387 " return 43;\n" 14388 "});", 14389 format("SomeFunction([](){\n" 14390 "#define A a\n" 14391 "return 43;\n" 14392 "});")); 14393 verifyFormat("void f() {\n" 14394 " SomeFunction([](decltype(x), A *a) {});\n" 14395 "}"); 14396 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 14397 " [](const aaaaaaaaaa &a) { return a; });"); 14398 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 14399 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 14400 "});"); 14401 verifyFormat("Constructor()\n" 14402 " : Field([] { // comment\n" 14403 " int i;\n" 14404 " }) {}"); 14405 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 14406 " return some_parameter.size();\n" 14407 "};"); 14408 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 14409 " [](const string &s) { return s; };"); 14410 verifyFormat("int i = aaaaaa ? 1 //\n" 14411 " : [] {\n" 14412 " return 2; //\n" 14413 " }();"); 14414 verifyFormat("llvm::errs() << \"number of twos is \"\n" 14415 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 14416 " return x == 2; // force break\n" 14417 " });"); 14418 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 14419 " [=](int iiiiiiiiiiii) {\n" 14420 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 14421 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 14422 " });", 14423 getLLVMStyleWithColumns(60)); 14424 verifyFormat("SomeFunction({[&] {\n" 14425 " // comment\n" 14426 " },\n" 14427 " [&] {\n" 14428 " // comment\n" 14429 " }});"); 14430 verifyFormat("SomeFunction({[&] {\n" 14431 " // comment\n" 14432 "}});"); 14433 verifyFormat( 14434 "virtual aaaaaaaaaaaaaaaa(\n" 14435 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 14436 " aaaaa aaaaaaaaa);"); 14437 14438 // Lambdas with return types. 14439 verifyFormat("int c = []() -> int { return 2; }();\n"); 14440 verifyFormat("int c = []() -> int * { return 2; }();\n"); 14441 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 14442 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 14443 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 14444 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 14445 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 14446 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 14447 verifyFormat("[a, a]() -> a<1> {};"); 14448 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 14449 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 14450 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 14451 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 14452 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 14453 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 14454 verifyFormat("[]() -> foo<!5> { return {}; };"); 14455 verifyFormat("[]() -> foo<~5> { return {}; };"); 14456 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 14457 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 14458 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 14459 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 14460 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 14461 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 14462 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 14463 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 14464 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 14465 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 14466 verifyFormat("namespace bar {\n" 14467 "// broken:\n" 14468 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 14469 "} // namespace bar"); 14470 verifyFormat("namespace bar {\n" 14471 "// broken:\n" 14472 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 14473 "} // namespace bar"); 14474 verifyFormat("namespace bar {\n" 14475 "// broken:\n" 14476 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 14477 "} // namespace bar"); 14478 verifyFormat("namespace bar {\n" 14479 "// broken:\n" 14480 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 14481 "} // namespace bar"); 14482 verifyFormat("namespace bar {\n" 14483 "// broken:\n" 14484 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 14485 "} // namespace bar"); 14486 verifyFormat("namespace bar {\n" 14487 "// broken:\n" 14488 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 14489 "} // namespace bar"); 14490 verifyFormat("namespace bar {\n" 14491 "// broken:\n" 14492 "auto foo{[]() -> foo<!5> { return {}; }};\n" 14493 "} // namespace bar"); 14494 verifyFormat("namespace bar {\n" 14495 "// broken:\n" 14496 "auto foo{[]() -> foo<~5> { return {}; }};\n" 14497 "} // namespace bar"); 14498 verifyFormat("namespace bar {\n" 14499 "// broken:\n" 14500 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 14501 "} // namespace bar"); 14502 verifyFormat("namespace bar {\n" 14503 "// broken:\n" 14504 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 14505 "} // namespace bar"); 14506 verifyFormat("namespace bar {\n" 14507 "// broken:\n" 14508 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 14509 "} // namespace bar"); 14510 verifyFormat("namespace bar {\n" 14511 "// broken:\n" 14512 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 14513 "} // namespace bar"); 14514 verifyFormat("namespace bar {\n" 14515 "// broken:\n" 14516 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 14517 "} // namespace bar"); 14518 verifyFormat("namespace bar {\n" 14519 "// broken:\n" 14520 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 14521 "} // namespace bar"); 14522 verifyFormat("namespace bar {\n" 14523 "// broken:\n" 14524 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 14525 "} // namespace bar"); 14526 verifyFormat("namespace bar {\n" 14527 "// broken:\n" 14528 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 14529 "} // namespace bar"); 14530 verifyFormat("namespace bar {\n" 14531 "// broken:\n" 14532 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 14533 "} // namespace bar"); 14534 verifyFormat("namespace bar {\n" 14535 "// broken:\n" 14536 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 14537 "} // namespace bar"); 14538 verifyFormat("[]() -> a<1> {};"); 14539 verifyFormat("[]() -> a<1> { ; };"); 14540 verifyFormat("[]() -> a<1> { ; }();"); 14541 verifyFormat("[a, a]() -> a<true> {};"); 14542 verifyFormat("[]() -> a<true> {};"); 14543 verifyFormat("[]() -> a<true> { ; };"); 14544 verifyFormat("[]() -> a<true> { ; }();"); 14545 verifyFormat("[a, a]() -> a<false> {};"); 14546 verifyFormat("[]() -> a<false> {};"); 14547 verifyFormat("[]() -> a<false> { ; };"); 14548 verifyFormat("[]() -> a<false> { ; }();"); 14549 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 14550 verifyFormat("namespace bar {\n" 14551 "auto foo{[]() -> foo<false> { ; }};\n" 14552 "} // namespace bar"); 14553 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 14554 " int j) -> int {\n" 14555 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 14556 "};"); 14557 verifyFormat( 14558 "aaaaaaaaaaaaaaaaaaaaaa(\n" 14559 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 14560 " return aaaaaaaaaaaaaaaaa;\n" 14561 " });", 14562 getLLVMStyleWithColumns(70)); 14563 verifyFormat("[]() //\n" 14564 " -> int {\n" 14565 " return 1; //\n" 14566 "};"); 14567 verifyFormat("[]() -> Void<T...> {};"); 14568 verifyFormat("[a, b]() -> Tuple<T...> { return {}; };"); 14569 14570 // Lambdas with explicit template argument lists. 14571 verifyFormat( 14572 "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n"); 14573 14574 // Multiple lambdas in the same parentheses change indentation rules. These 14575 // lambdas are forced to start on new lines. 14576 verifyFormat("SomeFunction(\n" 14577 " []() {\n" 14578 " //\n" 14579 " },\n" 14580 " []() {\n" 14581 " //\n" 14582 " });"); 14583 14584 // A lambda passed as arg0 is always pushed to the next line. 14585 verifyFormat("SomeFunction(\n" 14586 " [this] {\n" 14587 " //\n" 14588 " },\n" 14589 " 1);\n"); 14590 14591 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like 14592 // the arg0 case above. 14593 auto Style = getGoogleStyle(); 14594 Style.BinPackArguments = false; 14595 verifyFormat("SomeFunction(\n" 14596 " a,\n" 14597 " [this] {\n" 14598 " //\n" 14599 " },\n" 14600 " b);\n", 14601 Style); 14602 verifyFormat("SomeFunction(\n" 14603 " a,\n" 14604 " [this] {\n" 14605 " //\n" 14606 " },\n" 14607 " b);\n"); 14608 14609 // A lambda with a very long line forces arg0 to be pushed out irrespective of 14610 // the BinPackArguments value (as long as the code is wide enough). 14611 verifyFormat( 14612 "something->SomeFunction(\n" 14613 " a,\n" 14614 " [this] {\n" 14615 " " 14616 "D0000000000000000000000000000000000000000000000000000000000001();\n" 14617 " },\n" 14618 " b);\n"); 14619 14620 // A multi-line lambda is pulled up as long as the introducer fits on the 14621 // previous line and there are no further args. 14622 verifyFormat("function(1, [this, that] {\n" 14623 " //\n" 14624 "});\n"); 14625 verifyFormat("function([this, that] {\n" 14626 " //\n" 14627 "});\n"); 14628 // FIXME: this format is not ideal and we should consider forcing the first 14629 // arg onto its own line. 14630 verifyFormat("function(a, b, c, //\n" 14631 " d, [this, that] {\n" 14632 " //\n" 14633 " });\n"); 14634 14635 // Multiple lambdas are treated correctly even when there is a short arg0. 14636 verifyFormat("SomeFunction(\n" 14637 " 1,\n" 14638 " [this] {\n" 14639 " //\n" 14640 " },\n" 14641 " [this] {\n" 14642 " //\n" 14643 " },\n" 14644 " 1);\n"); 14645 14646 // More complex introducers. 14647 verifyFormat("return [i, args...] {};"); 14648 14649 // Not lambdas. 14650 verifyFormat("constexpr char hello[]{\"hello\"};"); 14651 verifyFormat("double &operator[](int i) { return 0; }\n" 14652 "int i;"); 14653 verifyFormat("std::unique_ptr<int[]> foo() {}"); 14654 verifyFormat("int i = a[a][a]->f();"); 14655 verifyFormat("int i = (*b)[a]->f();"); 14656 14657 // Other corner cases. 14658 verifyFormat("void f() {\n" 14659 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 14660 " );\n" 14661 "}"); 14662 14663 // Lambdas created through weird macros. 14664 verifyFormat("void f() {\n" 14665 " MACRO((const AA &a) { return 1; });\n" 14666 " MACRO((AA &a) { return 1; });\n" 14667 "}"); 14668 14669 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 14670 " doo_dah();\n" 14671 " doo_dah();\n" 14672 " })) {\n" 14673 "}"); 14674 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 14675 " doo_dah();\n" 14676 " doo_dah();\n" 14677 " })) {\n" 14678 "}"); 14679 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n" 14680 " doo_dah();\n" 14681 " doo_dah();\n" 14682 " })) {\n" 14683 "}"); 14684 verifyFormat("auto lambda = []() {\n" 14685 " int a = 2\n" 14686 "#if A\n" 14687 " + 2\n" 14688 "#endif\n" 14689 " ;\n" 14690 "};"); 14691 14692 // Lambdas with complex multiline introducers. 14693 verifyFormat( 14694 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 14695 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 14696 " -> ::std::unordered_set<\n" 14697 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 14698 " //\n" 14699 " });"); 14700 14701 FormatStyle DoNotMerge = getLLVMStyle(); 14702 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 14703 verifyFormat("auto c = []() {\n" 14704 " return b;\n" 14705 "};", 14706 "auto c = []() { return b; };", DoNotMerge); 14707 verifyFormat("auto c = []() {\n" 14708 "};", 14709 " auto c = []() {};", DoNotMerge); 14710 14711 FormatStyle MergeEmptyOnly = getLLVMStyle(); 14712 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 14713 verifyFormat("auto c = []() {\n" 14714 " return b;\n" 14715 "};", 14716 "auto c = []() {\n" 14717 " return b;\n" 14718 " };", 14719 MergeEmptyOnly); 14720 verifyFormat("auto c = []() {};", 14721 "auto c = []() {\n" 14722 "};", 14723 MergeEmptyOnly); 14724 14725 FormatStyle MergeInline = getLLVMStyle(); 14726 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 14727 verifyFormat("auto c = []() {\n" 14728 " return b;\n" 14729 "};", 14730 "auto c = []() { return b; };", MergeInline); 14731 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 14732 MergeInline); 14733 verifyFormat("function([]() { return b; }, a)", 14734 "function([]() { return b; }, a)", MergeInline); 14735 verifyFormat("function(a, []() { return b; })", 14736 "function(a, []() { return b; })", MergeInline); 14737 14738 // Check option "BraceWrapping.BeforeLambdaBody" and different state of 14739 // AllowShortLambdasOnASingleLine 14740 FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle(); 14741 LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom; 14742 LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true; 14743 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14744 FormatStyle::ShortLambdaStyle::SLS_None; 14745 verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n" 14746 " []()\n" 14747 " {\n" 14748 " return 17;\n" 14749 " });", 14750 LLVMWithBeforeLambdaBody); 14751 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n" 14752 " []()\n" 14753 " {\n" 14754 " });", 14755 LLVMWithBeforeLambdaBody); 14756 verifyFormat("auto fct_SLS_None = []()\n" 14757 "{\n" 14758 " return 17;\n" 14759 "};", 14760 LLVMWithBeforeLambdaBody); 14761 verifyFormat("TwoNestedLambdas_SLS_None(\n" 14762 " []()\n" 14763 " {\n" 14764 " return Call(\n" 14765 " []()\n" 14766 " {\n" 14767 " return 17;\n" 14768 " });\n" 14769 " });", 14770 LLVMWithBeforeLambdaBody); 14771 verifyFormat("void Fct()\n" 14772 "{\n" 14773 " return {[]()\n" 14774 " {\n" 14775 " return 17;\n" 14776 " }};\n" 14777 "}", 14778 LLVMWithBeforeLambdaBody); 14779 14780 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14781 FormatStyle::ShortLambdaStyle::SLS_Empty; 14782 verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n" 14783 " []()\n" 14784 " {\n" 14785 " return 17;\n" 14786 " });", 14787 LLVMWithBeforeLambdaBody); 14788 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});", 14789 LLVMWithBeforeLambdaBody); 14790 verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL" 14791 "ongFunctionName_SLS_Empty(\n" 14792 " []() {});", 14793 LLVMWithBeforeLambdaBody); 14794 verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n" 14795 " []()\n" 14796 " {\n" 14797 " return 17;\n" 14798 " });", 14799 LLVMWithBeforeLambdaBody); 14800 verifyFormat("auto fct_SLS_Empty = []()\n" 14801 "{\n" 14802 " return 17;\n" 14803 "};", 14804 LLVMWithBeforeLambdaBody); 14805 verifyFormat("TwoNestedLambdas_SLS_Empty(\n" 14806 " []()\n" 14807 " {\n" 14808 " return Call([]() {});\n" 14809 " });", 14810 LLVMWithBeforeLambdaBody); 14811 verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n" 14812 " []()\n" 14813 " {\n" 14814 " return Call([]() {});\n" 14815 " });", 14816 LLVMWithBeforeLambdaBody); 14817 verifyFormat( 14818 "FctWithLongLineInLambda_SLS_Empty(\n" 14819 " []()\n" 14820 " {\n" 14821 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14822 " AndShouldNotBeConsiderAsInline,\n" 14823 " LambdaBodyMustBeBreak);\n" 14824 " });", 14825 LLVMWithBeforeLambdaBody); 14826 14827 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14828 FormatStyle::ShortLambdaStyle::SLS_Inline; 14829 verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });", 14830 LLVMWithBeforeLambdaBody); 14831 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});", 14832 LLVMWithBeforeLambdaBody); 14833 verifyFormat("auto fct_SLS_Inline = []()\n" 14834 "{\n" 14835 " return 17;\n" 14836 "};", 14837 LLVMWithBeforeLambdaBody); 14838 verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return " 14839 "17; }); });", 14840 LLVMWithBeforeLambdaBody); 14841 verifyFormat( 14842 "FctWithLongLineInLambda_SLS_Inline(\n" 14843 " []()\n" 14844 " {\n" 14845 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14846 " AndShouldNotBeConsiderAsInline,\n" 14847 " LambdaBodyMustBeBreak);\n" 14848 " });", 14849 LLVMWithBeforeLambdaBody); 14850 verifyFormat("FctWithMultipleParams_SLS_Inline(" 14851 "VeryLongParameterThatShouldAskToBeOnMultiLine,\n" 14852 " []() { return 17; });", 14853 LLVMWithBeforeLambdaBody); 14854 verifyFormat( 14855 "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });", 14856 LLVMWithBeforeLambdaBody); 14857 14858 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14859 FormatStyle::ShortLambdaStyle::SLS_All; 14860 verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });", 14861 LLVMWithBeforeLambdaBody); 14862 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});", 14863 LLVMWithBeforeLambdaBody); 14864 verifyFormat("auto fct_SLS_All = []() { return 17; };", 14865 LLVMWithBeforeLambdaBody); 14866 verifyFormat("FctWithOneParam_SLS_All(\n" 14867 " []()\n" 14868 " {\n" 14869 " // A cool function...\n" 14870 " return 43;\n" 14871 " });", 14872 LLVMWithBeforeLambdaBody); 14873 verifyFormat("FctWithMultipleParams_SLS_All(" 14874 "VeryLongParameterThatShouldAskToBeOnMultiLine,\n" 14875 " []() { return 17; });", 14876 LLVMWithBeforeLambdaBody); 14877 verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });", 14878 LLVMWithBeforeLambdaBody); 14879 verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });", 14880 LLVMWithBeforeLambdaBody); 14881 verifyFormat( 14882 "FctWithLongLineInLambda_SLS_All(\n" 14883 " []()\n" 14884 " {\n" 14885 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14886 " AndShouldNotBeConsiderAsInline,\n" 14887 " LambdaBodyMustBeBreak);\n" 14888 " });", 14889 LLVMWithBeforeLambdaBody); 14890 verifyFormat( 14891 "auto fct_SLS_All = []()\n" 14892 "{\n" 14893 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14894 " AndShouldNotBeConsiderAsInline,\n" 14895 " LambdaBodyMustBeBreak);\n" 14896 "};", 14897 LLVMWithBeforeLambdaBody); 14898 LLVMWithBeforeLambdaBody.BinPackParameters = false; 14899 verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);", 14900 LLVMWithBeforeLambdaBody); 14901 verifyFormat( 14902 "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n" 14903 " FirstParam,\n" 14904 " SecondParam,\n" 14905 " ThirdParam,\n" 14906 " FourthParam);", 14907 LLVMWithBeforeLambdaBody); 14908 verifyFormat("FctWithLongLineInLambda_SLS_All(\n" 14909 " []() { return " 14910 "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n" 14911 " FirstParam,\n" 14912 " SecondParam,\n" 14913 " ThirdParam,\n" 14914 " FourthParam);", 14915 LLVMWithBeforeLambdaBody); 14916 verifyFormat( 14917 "FctWithLongLineInLambda_SLS_All(FirstParam,\n" 14918 " SecondParam,\n" 14919 " ThirdParam,\n" 14920 " FourthParam,\n" 14921 " []() { return SomeValueNotSoLong; });", 14922 LLVMWithBeforeLambdaBody); 14923 verifyFormat("FctWithLongLineInLambda_SLS_All(\n" 14924 " []()\n" 14925 " {\n" 14926 " return " 14927 "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB" 14928 "eConsiderAsInline;\n" 14929 " });", 14930 LLVMWithBeforeLambdaBody); 14931 verifyFormat( 14932 "FctWithLongLineInLambda_SLS_All(\n" 14933 " []()\n" 14934 " {\n" 14935 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14936 " AndShouldNotBeConsiderAsInline,\n" 14937 " LambdaBodyMustBeBreak);\n" 14938 " });", 14939 LLVMWithBeforeLambdaBody); 14940 verifyFormat("FctWithTwoParams_SLS_All(\n" 14941 " []()\n" 14942 " {\n" 14943 " // A cool function...\n" 14944 " return 43;\n" 14945 " },\n" 14946 " 87);", 14947 LLVMWithBeforeLambdaBody); 14948 verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);", 14949 LLVMWithBeforeLambdaBody); 14950 verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });", 14951 LLVMWithBeforeLambdaBody); 14952 verifyFormat( 14953 "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });", 14954 LLVMWithBeforeLambdaBody); 14955 verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; " 14956 "}); }, x);", 14957 LLVMWithBeforeLambdaBody); 14958 verifyFormat("TwoNestedLambdas_SLS_All(\n" 14959 " []()\n" 14960 " {\n" 14961 " // A cool function...\n" 14962 " return Call([]() { return 17; });\n" 14963 " });", 14964 LLVMWithBeforeLambdaBody); 14965 verifyFormat("TwoNestedLambdas_SLS_All(\n" 14966 " []()\n" 14967 " {\n" 14968 " return Call(\n" 14969 " []()\n" 14970 " {\n" 14971 " // A cool function...\n" 14972 " return 17;\n" 14973 " });\n" 14974 " });", 14975 LLVMWithBeforeLambdaBody); 14976 } 14977 14978 TEST_F(FormatTest, LambdaWithLineComments) { 14979 FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle(); 14980 LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom; 14981 LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true; 14982 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14983 FormatStyle::ShortLambdaStyle::SLS_All; 14984 14985 verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody); 14986 verifyFormat("auto k = []() // comment\n" 14987 "{ return; }", 14988 LLVMWithBeforeLambdaBody); 14989 verifyFormat("auto k = []() /* comment */ { return; }", 14990 LLVMWithBeforeLambdaBody); 14991 verifyFormat("auto k = []() /* comment */ /* comment */ { return; }", 14992 LLVMWithBeforeLambdaBody); 14993 verifyFormat("auto k = []() // X\n" 14994 "{ return; }", 14995 LLVMWithBeforeLambdaBody); 14996 verifyFormat( 14997 "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n" 14998 "{ return; }", 14999 LLVMWithBeforeLambdaBody); 15000 } 15001 15002 TEST_F(FormatTest, EmptyLinesInLambdas) { 15003 verifyFormat("auto lambda = []() {\n" 15004 " x(); //\n" 15005 "};", 15006 "auto lambda = []() {\n" 15007 "\n" 15008 " x(); //\n" 15009 "\n" 15010 "};"); 15011 } 15012 15013 TEST_F(FormatTest, FormatsBlocks) { 15014 FormatStyle ShortBlocks = getLLVMStyle(); 15015 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 15016 verifyFormat("int (^Block)(int, int);", ShortBlocks); 15017 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 15018 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 15019 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 15020 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 15021 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 15022 15023 verifyFormat("foo(^{ bar(); });", ShortBlocks); 15024 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 15025 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 15026 15027 verifyFormat("[operation setCompletionBlock:^{\n" 15028 " [self onOperationDone];\n" 15029 "}];"); 15030 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 15031 " [self onOperationDone];\n" 15032 "}]};"); 15033 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 15034 " f();\n" 15035 "}];"); 15036 verifyFormat("int a = [operation block:^int(int *i) {\n" 15037 " return 1;\n" 15038 "}];"); 15039 verifyFormat("[myObject doSomethingWith:arg1\n" 15040 " aaa:^int(int *a) {\n" 15041 " return 1;\n" 15042 " }\n" 15043 " bbb:f(a * bbbbbbbb)];"); 15044 15045 verifyFormat("[operation setCompletionBlock:^{\n" 15046 " [self.delegate newDataAvailable];\n" 15047 "}];", 15048 getLLVMStyleWithColumns(60)); 15049 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 15050 " NSString *path = [self sessionFilePath];\n" 15051 " if (path) {\n" 15052 " // ...\n" 15053 " }\n" 15054 "});"); 15055 verifyFormat("[[SessionService sharedService]\n" 15056 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 15057 " if (window) {\n" 15058 " [self windowDidLoad:window];\n" 15059 " } else {\n" 15060 " [self errorLoadingWindow];\n" 15061 " }\n" 15062 " }];"); 15063 verifyFormat("void (^largeBlock)(void) = ^{\n" 15064 " // ...\n" 15065 "};\n", 15066 getLLVMStyleWithColumns(40)); 15067 verifyFormat("[[SessionService sharedService]\n" 15068 " loadWindowWithCompletionBlock: //\n" 15069 " ^(SessionWindow *window) {\n" 15070 " if (window) {\n" 15071 " [self windowDidLoad:window];\n" 15072 " } else {\n" 15073 " [self errorLoadingWindow];\n" 15074 " }\n" 15075 " }];", 15076 getLLVMStyleWithColumns(60)); 15077 verifyFormat("[myObject doSomethingWith:arg1\n" 15078 " firstBlock:^(Foo *a) {\n" 15079 " // ...\n" 15080 " int i;\n" 15081 " }\n" 15082 " secondBlock:^(Bar *b) {\n" 15083 " // ...\n" 15084 " int i;\n" 15085 " }\n" 15086 " thirdBlock:^Foo(Bar *b) {\n" 15087 " // ...\n" 15088 " int i;\n" 15089 " }];"); 15090 verifyFormat("[myObject doSomethingWith:arg1\n" 15091 " firstBlock:-1\n" 15092 " secondBlock:^(Bar *b) {\n" 15093 " // ...\n" 15094 " int i;\n" 15095 " }];"); 15096 15097 verifyFormat("f(^{\n" 15098 " @autoreleasepool {\n" 15099 " if (a) {\n" 15100 " g();\n" 15101 " }\n" 15102 " }\n" 15103 "});"); 15104 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 15105 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 15106 "};"); 15107 15108 FormatStyle FourIndent = getLLVMStyle(); 15109 FourIndent.ObjCBlockIndentWidth = 4; 15110 verifyFormat("[operation setCompletionBlock:^{\n" 15111 " [self onOperationDone];\n" 15112 "}];", 15113 FourIndent); 15114 } 15115 15116 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 15117 FormatStyle ZeroColumn = getLLVMStyle(); 15118 ZeroColumn.ColumnLimit = 0; 15119 15120 verifyFormat("[[SessionService sharedService] " 15121 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 15122 " if (window) {\n" 15123 " [self windowDidLoad:window];\n" 15124 " } else {\n" 15125 " [self errorLoadingWindow];\n" 15126 " }\n" 15127 "}];", 15128 ZeroColumn); 15129 EXPECT_EQ("[[SessionService sharedService]\n" 15130 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 15131 " if (window) {\n" 15132 " [self windowDidLoad:window];\n" 15133 " } else {\n" 15134 " [self errorLoadingWindow];\n" 15135 " }\n" 15136 " }];", 15137 format("[[SessionService sharedService]\n" 15138 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 15139 " if (window) {\n" 15140 " [self windowDidLoad:window];\n" 15141 " } else {\n" 15142 " [self errorLoadingWindow];\n" 15143 " }\n" 15144 "}];", 15145 ZeroColumn)); 15146 verifyFormat("[myObject doSomethingWith:arg1\n" 15147 " firstBlock:^(Foo *a) {\n" 15148 " // ...\n" 15149 " int i;\n" 15150 " }\n" 15151 " secondBlock:^(Bar *b) {\n" 15152 " // ...\n" 15153 " int i;\n" 15154 " }\n" 15155 " thirdBlock:^Foo(Bar *b) {\n" 15156 " // ...\n" 15157 " int i;\n" 15158 " }];", 15159 ZeroColumn); 15160 verifyFormat("f(^{\n" 15161 " @autoreleasepool {\n" 15162 " if (a) {\n" 15163 " g();\n" 15164 " }\n" 15165 " }\n" 15166 "});", 15167 ZeroColumn); 15168 verifyFormat("void (^largeBlock)(void) = ^{\n" 15169 " // ...\n" 15170 "};", 15171 ZeroColumn); 15172 15173 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 15174 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 15175 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 15176 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 15177 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 15178 " int i;\n" 15179 "};", 15180 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 15181 } 15182 15183 TEST_F(FormatTest, SupportsCRLF) { 15184 EXPECT_EQ("int a;\r\n" 15185 "int b;\r\n" 15186 "int c;\r\n", 15187 format("int a;\r\n" 15188 " int b;\r\n" 15189 " int c;\r\n", 15190 getLLVMStyle())); 15191 EXPECT_EQ("int a;\r\n" 15192 "int b;\r\n" 15193 "int c;\r\n", 15194 format("int a;\r\n" 15195 " int b;\n" 15196 " int c;\r\n", 15197 getLLVMStyle())); 15198 EXPECT_EQ("int a;\n" 15199 "int b;\n" 15200 "int c;\n", 15201 format("int a;\r\n" 15202 " int b;\n" 15203 " int c;\n", 15204 getLLVMStyle())); 15205 EXPECT_EQ("\"aaaaaaa \"\r\n" 15206 "\"bbbbbbb\";\r\n", 15207 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 15208 EXPECT_EQ("#define A \\\r\n" 15209 " b; \\\r\n" 15210 " c; \\\r\n" 15211 " d;\r\n", 15212 format("#define A \\\r\n" 15213 " b; \\\r\n" 15214 " c; d; \r\n", 15215 getGoogleStyle())); 15216 15217 EXPECT_EQ("/*\r\n" 15218 "multi line block comments\r\n" 15219 "should not introduce\r\n" 15220 "an extra carriage return\r\n" 15221 "*/\r\n", 15222 format("/*\r\n" 15223 "multi line block comments\r\n" 15224 "should not introduce\r\n" 15225 "an extra carriage return\r\n" 15226 "*/\r\n")); 15227 EXPECT_EQ("/*\r\n" 15228 "\r\n" 15229 "*/", 15230 format("/*\r\n" 15231 " \r\r\r\n" 15232 "*/")); 15233 15234 FormatStyle style = getLLVMStyle(); 15235 15236 style.DeriveLineEnding = true; 15237 style.UseCRLF = false; 15238 EXPECT_EQ("union FooBarBazQux {\n" 15239 " int foo;\n" 15240 " int bar;\n" 15241 " int baz;\n" 15242 "};", 15243 format("union FooBarBazQux {\r\n" 15244 " int foo;\n" 15245 " int bar;\r\n" 15246 " int baz;\n" 15247 "};", 15248 style)); 15249 style.UseCRLF = true; 15250 EXPECT_EQ("union FooBarBazQux {\r\n" 15251 " int foo;\r\n" 15252 " int bar;\r\n" 15253 " int baz;\r\n" 15254 "};", 15255 format("union FooBarBazQux {\r\n" 15256 " int foo;\n" 15257 " int bar;\r\n" 15258 " int baz;\n" 15259 "};", 15260 style)); 15261 15262 style.DeriveLineEnding = false; 15263 style.UseCRLF = false; 15264 EXPECT_EQ("union FooBarBazQux {\n" 15265 " int foo;\n" 15266 " int bar;\n" 15267 " int baz;\n" 15268 " int qux;\n" 15269 "};", 15270 format("union FooBarBazQux {\r\n" 15271 " int foo;\n" 15272 " int bar;\r\n" 15273 " int baz;\n" 15274 " int qux;\r\n" 15275 "};", 15276 style)); 15277 style.UseCRLF = true; 15278 EXPECT_EQ("union FooBarBazQux {\r\n" 15279 " int foo;\r\n" 15280 " int bar;\r\n" 15281 " int baz;\r\n" 15282 " int qux;\r\n" 15283 "};", 15284 format("union FooBarBazQux {\r\n" 15285 " int foo;\n" 15286 " int bar;\r\n" 15287 " int baz;\n" 15288 " int qux;\n" 15289 "};", 15290 style)); 15291 15292 style.DeriveLineEnding = true; 15293 style.UseCRLF = false; 15294 EXPECT_EQ("union FooBarBazQux {\r\n" 15295 " int foo;\r\n" 15296 " int bar;\r\n" 15297 " int baz;\r\n" 15298 " int qux;\r\n" 15299 "};", 15300 format("union FooBarBazQux {\r\n" 15301 " int foo;\n" 15302 " int bar;\r\n" 15303 " int baz;\n" 15304 " int qux;\r\n" 15305 "};", 15306 style)); 15307 style.UseCRLF = true; 15308 EXPECT_EQ("union FooBarBazQux {\n" 15309 " int foo;\n" 15310 " int bar;\n" 15311 " int baz;\n" 15312 " int qux;\n" 15313 "};", 15314 format("union FooBarBazQux {\r\n" 15315 " int foo;\n" 15316 " int bar;\r\n" 15317 " int baz;\n" 15318 " int qux;\n" 15319 "};", 15320 style)); 15321 } 15322 15323 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 15324 verifyFormat("MY_CLASS(C) {\n" 15325 " int i;\n" 15326 " int j;\n" 15327 "};"); 15328 } 15329 15330 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 15331 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 15332 TwoIndent.ContinuationIndentWidth = 2; 15333 15334 EXPECT_EQ("int i =\n" 15335 " longFunction(\n" 15336 " arg);", 15337 format("int i = longFunction(arg);", TwoIndent)); 15338 15339 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 15340 SixIndent.ContinuationIndentWidth = 6; 15341 15342 EXPECT_EQ("int i =\n" 15343 " longFunction(\n" 15344 " arg);", 15345 format("int i = longFunction(arg);", SixIndent)); 15346 } 15347 15348 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 15349 FormatStyle Style = getLLVMStyle(); 15350 verifyFormat("int Foo::getter(\n" 15351 " //\n" 15352 ") const {\n" 15353 " return foo;\n" 15354 "}", 15355 Style); 15356 verifyFormat("void Foo::setter(\n" 15357 " //\n" 15358 ") {\n" 15359 " foo = 1;\n" 15360 "}", 15361 Style); 15362 } 15363 15364 TEST_F(FormatTest, SpacesInAngles) { 15365 FormatStyle Spaces = getLLVMStyle(); 15366 Spaces.SpacesInAngles = true; 15367 15368 verifyFormat("static_cast< int >(arg);", Spaces); 15369 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 15370 verifyFormat("f< int, float >();", Spaces); 15371 verifyFormat("template <> g() {}", Spaces); 15372 verifyFormat("template < std::vector< int > > f() {}", Spaces); 15373 verifyFormat("std::function< void(int, int) > fct;", Spaces); 15374 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 15375 Spaces); 15376 15377 Spaces.Standard = FormatStyle::LS_Cpp03; 15378 Spaces.SpacesInAngles = true; 15379 verifyFormat("A< A< int > >();", Spaces); 15380 15381 Spaces.SpacesInAngles = false; 15382 verifyFormat("A<A<int> >();", Spaces); 15383 15384 Spaces.Standard = FormatStyle::LS_Cpp11; 15385 Spaces.SpacesInAngles = true; 15386 verifyFormat("A< A< int > >();", Spaces); 15387 15388 Spaces.SpacesInAngles = false; 15389 verifyFormat("A<A<int>>();", Spaces); 15390 } 15391 15392 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 15393 FormatStyle Style = getLLVMStyle(); 15394 Style.SpaceAfterTemplateKeyword = false; 15395 verifyFormat("template<int> void foo();", Style); 15396 } 15397 15398 TEST_F(FormatTest, TripleAngleBrackets) { 15399 verifyFormat("f<<<1, 1>>>();"); 15400 verifyFormat("f<<<1, 1, 1, s>>>();"); 15401 verifyFormat("f<<<a, b, c, d>>>();"); 15402 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 15403 verifyFormat("f<param><<<1, 1>>>();"); 15404 verifyFormat("f<1><<<1, 1>>>();"); 15405 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 15406 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 15407 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 15408 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 15409 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 15410 } 15411 15412 TEST_F(FormatTest, MergeLessLessAtEnd) { 15413 verifyFormat("<<"); 15414 EXPECT_EQ("< < <", format("\\\n<<<")); 15415 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 15416 "aaallvm::outs() <<"); 15417 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 15418 "aaaallvm::outs()\n <<"); 15419 } 15420 15421 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 15422 std::string code = "#if A\n" 15423 "#if B\n" 15424 "a.\n" 15425 "#endif\n" 15426 " a = 1;\n" 15427 "#else\n" 15428 "#endif\n" 15429 "#if C\n" 15430 "#else\n" 15431 "#endif\n"; 15432 EXPECT_EQ(code, format(code)); 15433 } 15434 15435 TEST_F(FormatTest, HandleConflictMarkers) { 15436 // Git/SVN conflict markers. 15437 EXPECT_EQ("int a;\n" 15438 "void f() {\n" 15439 " callme(some(parameter1,\n" 15440 "<<<<<<< text by the vcs\n" 15441 " parameter2),\n" 15442 "||||||| text by the vcs\n" 15443 " parameter2),\n" 15444 " parameter3,\n" 15445 "======= text by the vcs\n" 15446 " parameter2, parameter3),\n" 15447 ">>>>>>> text by the vcs\n" 15448 " otherparameter);\n", 15449 format("int a;\n" 15450 "void f() {\n" 15451 " callme(some(parameter1,\n" 15452 "<<<<<<< text by the vcs\n" 15453 " parameter2),\n" 15454 "||||||| text by the vcs\n" 15455 " parameter2),\n" 15456 " parameter3,\n" 15457 "======= text by the vcs\n" 15458 " parameter2,\n" 15459 " parameter3),\n" 15460 ">>>>>>> text by the vcs\n" 15461 " otherparameter);\n")); 15462 15463 // Perforce markers. 15464 EXPECT_EQ("void f() {\n" 15465 " function(\n" 15466 ">>>> text by the vcs\n" 15467 " parameter,\n" 15468 "==== text by the vcs\n" 15469 " parameter,\n" 15470 "==== text by the vcs\n" 15471 " parameter,\n" 15472 "<<<< text by the vcs\n" 15473 " parameter);\n", 15474 format("void f() {\n" 15475 " function(\n" 15476 ">>>> text by the vcs\n" 15477 " parameter,\n" 15478 "==== text by the vcs\n" 15479 " parameter,\n" 15480 "==== text by the vcs\n" 15481 " parameter,\n" 15482 "<<<< text by the vcs\n" 15483 " parameter);\n")); 15484 15485 EXPECT_EQ("<<<<<<<\n" 15486 "|||||||\n" 15487 "=======\n" 15488 ">>>>>>>", 15489 format("<<<<<<<\n" 15490 "|||||||\n" 15491 "=======\n" 15492 ">>>>>>>")); 15493 15494 EXPECT_EQ("<<<<<<<\n" 15495 "|||||||\n" 15496 "int i;\n" 15497 "=======\n" 15498 ">>>>>>>", 15499 format("<<<<<<<\n" 15500 "|||||||\n" 15501 "int i;\n" 15502 "=======\n" 15503 ">>>>>>>")); 15504 15505 // FIXME: Handle parsing of macros around conflict markers correctly: 15506 EXPECT_EQ("#define Macro \\\n" 15507 "<<<<<<<\n" 15508 "Something \\\n" 15509 "|||||||\n" 15510 "Else \\\n" 15511 "=======\n" 15512 "Other \\\n" 15513 ">>>>>>>\n" 15514 " End int i;\n", 15515 format("#define Macro \\\n" 15516 "<<<<<<<\n" 15517 " Something \\\n" 15518 "|||||||\n" 15519 " Else \\\n" 15520 "=======\n" 15521 " Other \\\n" 15522 ">>>>>>>\n" 15523 " End\n" 15524 "int i;\n")); 15525 } 15526 15527 TEST_F(FormatTest, DisableRegions) { 15528 EXPECT_EQ("int i;\n" 15529 "// clang-format off\n" 15530 " int j;\n" 15531 "// clang-format on\n" 15532 "int k;", 15533 format(" int i;\n" 15534 " // clang-format off\n" 15535 " int j;\n" 15536 " // clang-format on\n" 15537 " int k;")); 15538 EXPECT_EQ("int i;\n" 15539 "/* clang-format off */\n" 15540 " int j;\n" 15541 "/* clang-format on */\n" 15542 "int k;", 15543 format(" int i;\n" 15544 " /* clang-format off */\n" 15545 " int j;\n" 15546 " /* clang-format on */\n" 15547 " int k;")); 15548 15549 // Don't reflow comments within disabled regions. 15550 EXPECT_EQ("// clang-format off\n" 15551 "// long long long long long long line\n" 15552 "/* clang-format on */\n" 15553 "/* long long long\n" 15554 " * long long long\n" 15555 " * line */\n" 15556 "int i;\n" 15557 "/* clang-format off */\n" 15558 "/* long long long long long long line */\n", 15559 format("// clang-format off\n" 15560 "// long long long long long long line\n" 15561 "/* clang-format on */\n" 15562 "/* long long long long long long line */\n" 15563 "int i;\n" 15564 "/* clang-format off */\n" 15565 "/* long long long long long long line */\n", 15566 getLLVMStyleWithColumns(20))); 15567 } 15568 15569 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 15570 format("? ) ="); 15571 verifyNoCrash("#define a\\\n /**/}"); 15572 } 15573 15574 TEST_F(FormatTest, FormatsTableGenCode) { 15575 FormatStyle Style = getLLVMStyle(); 15576 Style.Language = FormatStyle::LK_TableGen; 15577 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 15578 } 15579 15580 TEST_F(FormatTest, ArrayOfTemplates) { 15581 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 15582 format("auto a = new unique_ptr<int > [ 10];")); 15583 15584 FormatStyle Spaces = getLLVMStyle(); 15585 Spaces.SpacesInSquareBrackets = true; 15586 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 15587 format("auto a = new unique_ptr<int > [10];", Spaces)); 15588 } 15589 15590 TEST_F(FormatTest, ArrayAsTemplateType) { 15591 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 15592 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 15593 15594 FormatStyle Spaces = getLLVMStyle(); 15595 Spaces.SpacesInSquareBrackets = true; 15596 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 15597 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 15598 } 15599 15600 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); } 15601 15602 TEST(FormatStyle, GetStyleWithEmptyFileName) { 15603 llvm::vfs::InMemoryFileSystem FS; 15604 auto Style1 = getStyle("file", "", "Google", "", &FS); 15605 ASSERT_TRUE((bool)Style1); 15606 ASSERT_EQ(*Style1, getGoogleStyle()); 15607 } 15608 15609 TEST(FormatStyle, GetStyleOfFile) { 15610 llvm::vfs::InMemoryFileSystem FS; 15611 // Test 1: format file in the same directory. 15612 ASSERT_TRUE( 15613 FS.addFile("/a/.clang-format", 0, 15614 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 15615 ASSERT_TRUE( 15616 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 15617 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 15618 ASSERT_TRUE((bool)Style1); 15619 ASSERT_EQ(*Style1, getLLVMStyle()); 15620 15621 // Test 2.1: fallback to default. 15622 ASSERT_TRUE( 15623 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 15624 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 15625 ASSERT_TRUE((bool)Style2); 15626 ASSERT_EQ(*Style2, getMozillaStyle()); 15627 15628 // Test 2.2: no format on 'none' fallback style. 15629 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 15630 ASSERT_TRUE((bool)Style2); 15631 ASSERT_EQ(*Style2, getNoStyle()); 15632 15633 // Test 2.3: format if config is found with no based style while fallback is 15634 // 'none'. 15635 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 15636 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 15637 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 15638 ASSERT_TRUE((bool)Style2); 15639 ASSERT_EQ(*Style2, getLLVMStyle()); 15640 15641 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 15642 Style2 = getStyle("{}", "a.h", "none", "", &FS); 15643 ASSERT_TRUE((bool)Style2); 15644 ASSERT_EQ(*Style2, getLLVMStyle()); 15645 15646 // Test 3: format file in parent directory. 15647 ASSERT_TRUE( 15648 FS.addFile("/c/.clang-format", 0, 15649 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 15650 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 15651 llvm::MemoryBuffer::getMemBuffer("int i;"))); 15652 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 15653 ASSERT_TRUE((bool)Style3); 15654 ASSERT_EQ(*Style3, getGoogleStyle()); 15655 15656 // Test 4: error on invalid fallback style 15657 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 15658 ASSERT_FALSE((bool)Style4); 15659 llvm::consumeError(Style4.takeError()); 15660 15661 // Test 5: error on invalid yaml on command line 15662 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 15663 ASSERT_FALSE((bool)Style5); 15664 llvm::consumeError(Style5.takeError()); 15665 15666 // Test 6: error on invalid style 15667 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 15668 ASSERT_FALSE((bool)Style6); 15669 llvm::consumeError(Style6.takeError()); 15670 15671 // Test 7: found config file, error on parsing it 15672 ASSERT_TRUE( 15673 FS.addFile("/d/.clang-format", 0, 15674 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 15675 "InvalidKey: InvalidValue"))); 15676 ASSERT_TRUE( 15677 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 15678 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 15679 ASSERT_FALSE((bool)Style7); 15680 llvm::consumeError(Style7.takeError()); 15681 15682 // Test 8: inferred per-language defaults apply. 15683 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 15684 ASSERT_TRUE((bool)StyleTd); 15685 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 15686 } 15687 15688 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 15689 // Column limit is 20. 15690 std::string Code = "Type *a =\n" 15691 " new Type();\n" 15692 "g(iiiii, 0, jjjjj,\n" 15693 " 0, kkkkk, 0, mm);\n" 15694 "int bad = format ;"; 15695 std::string Expected = "auto a = new Type();\n" 15696 "g(iiiii, nullptr,\n" 15697 " jjjjj, nullptr,\n" 15698 " kkkkk, nullptr,\n" 15699 " mm);\n" 15700 "int bad = format ;"; 15701 FileID ID = Context.createInMemoryFile("format.cpp", Code); 15702 tooling::Replacements Replaces = toReplacements( 15703 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 15704 "auto "), 15705 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 15706 "nullptr"), 15707 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 15708 "nullptr"), 15709 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 15710 "nullptr")}); 15711 15712 format::FormatStyle Style = format::getLLVMStyle(); 15713 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 15714 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 15715 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 15716 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 15717 auto Result = applyAllReplacements(Code, *FormattedReplaces); 15718 EXPECT_TRUE(static_cast<bool>(Result)); 15719 EXPECT_EQ(Expected, *Result); 15720 } 15721 15722 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 15723 std::string Code = "#include \"a.h\"\n" 15724 "#include \"c.h\"\n" 15725 "\n" 15726 "int main() {\n" 15727 " return 0;\n" 15728 "}"; 15729 std::string Expected = "#include \"a.h\"\n" 15730 "#include \"b.h\"\n" 15731 "#include \"c.h\"\n" 15732 "\n" 15733 "int main() {\n" 15734 " return 0;\n" 15735 "}"; 15736 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 15737 tooling::Replacements Replaces = toReplacements( 15738 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 15739 "#include \"b.h\"\n")}); 15740 15741 format::FormatStyle Style = format::getLLVMStyle(); 15742 Style.SortIncludes = true; 15743 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 15744 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 15745 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 15746 auto Result = applyAllReplacements(Code, *FormattedReplaces); 15747 EXPECT_TRUE(static_cast<bool>(Result)); 15748 EXPECT_EQ(Expected, *Result); 15749 } 15750 15751 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 15752 EXPECT_EQ("using std::cin;\n" 15753 "using std::cout;", 15754 format("using std::cout;\n" 15755 "using std::cin;", 15756 getGoogleStyle())); 15757 } 15758 15759 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 15760 format::FormatStyle Style = format::getLLVMStyle(); 15761 Style.Standard = FormatStyle::LS_Cpp03; 15762 // cpp03 recognize this string as identifier u8 and literal character 'a' 15763 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 15764 } 15765 15766 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 15767 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 15768 // all modes, including C++11, C++14 and C++17 15769 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 15770 } 15771 15772 TEST_F(FormatTest, DoNotFormatLikelyXml) { 15773 EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle())); 15774 EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle())); 15775 } 15776 15777 TEST_F(FormatTest, StructuredBindings) { 15778 // Structured bindings is a C++17 feature. 15779 // all modes, including C++11, C++14 and C++17 15780 verifyFormat("auto [a, b] = f();"); 15781 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 15782 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 15783 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 15784 EXPECT_EQ("auto const volatile [a, b] = f();", 15785 format("auto const volatile[a, b] = f();")); 15786 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 15787 EXPECT_EQ("auto &[a, b, c] = f();", 15788 format("auto &[ a , b,c ] = f();")); 15789 EXPECT_EQ("auto &&[a, b, c] = f();", 15790 format("auto &&[ a , b,c ] = f();")); 15791 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 15792 EXPECT_EQ("auto const volatile &&[a, b] = f();", 15793 format("auto const volatile &&[a, b] = f();")); 15794 EXPECT_EQ("auto const &&[a, b] = f();", 15795 format("auto const && [a, b] = f();")); 15796 EXPECT_EQ("const auto &[a, b] = f();", 15797 format("const auto & [a, b] = f();")); 15798 EXPECT_EQ("const auto volatile &&[a, b] = f();", 15799 format("const auto volatile &&[a, b] = f();")); 15800 EXPECT_EQ("volatile const auto &&[a, b] = f();", 15801 format("volatile const auto &&[a, b] = f();")); 15802 EXPECT_EQ("const auto &&[a, b] = f();", 15803 format("const auto && [a, b] = f();")); 15804 15805 // Make sure we don't mistake structured bindings for lambdas. 15806 FormatStyle PointerMiddle = getLLVMStyle(); 15807 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 15808 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 15809 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 15810 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 15811 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 15812 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 15813 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 15814 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 15815 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 15816 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 15817 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 15818 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 15819 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 15820 15821 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 15822 format("for (const auto && [a, b] : some_range) {\n}")); 15823 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 15824 format("for (const auto & [a, b] : some_range) {\n}")); 15825 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 15826 format("for (const auto[a, b] : some_range) {\n}")); 15827 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 15828 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 15829 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 15830 EXPECT_EQ("auto const &[x, y](expr);", 15831 format("auto const & [x,y] (expr);")); 15832 EXPECT_EQ("auto const &&[x, y](expr);", 15833 format("auto const && [x,y] (expr);")); 15834 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 15835 EXPECT_EQ("auto const &[x, y]{expr};", 15836 format("auto const & [x,y] {expr};")); 15837 EXPECT_EQ("auto const &&[x, y]{expr};", 15838 format("auto const && [x,y] {expr};")); 15839 15840 format::FormatStyle Spaces = format::getLLVMStyle(); 15841 Spaces.SpacesInSquareBrackets = true; 15842 verifyFormat("auto [ a, b ] = f();", Spaces); 15843 verifyFormat("auto &&[ a, b ] = f();", Spaces); 15844 verifyFormat("auto &[ a, b ] = f();", Spaces); 15845 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 15846 verifyFormat("auto const &[ a, b ] = f();", Spaces); 15847 } 15848 15849 TEST_F(FormatTest, FileAndCode) { 15850 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 15851 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 15852 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 15853 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 15854 EXPECT_EQ(FormatStyle::LK_ObjC, 15855 guessLanguage("foo.h", "@interface Foo\n@end\n")); 15856 EXPECT_EQ( 15857 FormatStyle::LK_ObjC, 15858 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 15859 EXPECT_EQ(FormatStyle::LK_ObjC, 15860 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 15861 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 15862 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 15863 EXPECT_EQ(FormatStyle::LK_ObjC, 15864 guessLanguage("foo", "@interface Foo\n@end\n")); 15865 EXPECT_EQ(FormatStyle::LK_ObjC, 15866 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 15867 EXPECT_EQ( 15868 FormatStyle::LK_ObjC, 15869 guessLanguage("foo.h", 15870 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 15871 EXPECT_EQ( 15872 FormatStyle::LK_Cpp, 15873 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 15874 } 15875 15876 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 15877 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 15878 EXPECT_EQ(FormatStyle::LK_ObjC, 15879 guessLanguage("foo.h", "array[[calculator getIndex]];")); 15880 EXPECT_EQ(FormatStyle::LK_Cpp, 15881 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 15882 EXPECT_EQ( 15883 FormatStyle::LK_Cpp, 15884 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 15885 EXPECT_EQ(FormatStyle::LK_ObjC, 15886 guessLanguage("foo.h", "[[noreturn foo] bar];")); 15887 EXPECT_EQ(FormatStyle::LK_Cpp, 15888 guessLanguage("foo.h", "[[clang::fallthrough]];")); 15889 EXPECT_EQ(FormatStyle::LK_ObjC, 15890 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 15891 EXPECT_EQ(FormatStyle::LK_Cpp, 15892 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 15893 EXPECT_EQ(FormatStyle::LK_Cpp, 15894 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 15895 EXPECT_EQ(FormatStyle::LK_ObjC, 15896 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 15897 EXPECT_EQ(FormatStyle::LK_Cpp, 15898 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 15899 EXPECT_EQ( 15900 FormatStyle::LK_Cpp, 15901 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 15902 EXPECT_EQ( 15903 FormatStyle::LK_Cpp, 15904 guessLanguage("foo.h", 15905 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 15906 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 15907 } 15908 15909 TEST_F(FormatTest, GuessLanguageWithCaret) { 15910 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 15911 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 15912 EXPECT_EQ(FormatStyle::LK_ObjC, 15913 guessLanguage("foo.h", "int(^)(char, float);")); 15914 EXPECT_EQ(FormatStyle::LK_ObjC, 15915 guessLanguage("foo.h", "int(^foo)(char, float);")); 15916 EXPECT_EQ(FormatStyle::LK_ObjC, 15917 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 15918 EXPECT_EQ(FormatStyle::LK_ObjC, 15919 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 15920 EXPECT_EQ( 15921 FormatStyle::LK_ObjC, 15922 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 15923 } 15924 15925 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) { 15926 // ASM symbolic names are identifiers that must be surrounded by [] without 15927 // space in between: 15928 // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands 15929 15930 // Example from https://bugs.llvm.org/show_bug.cgi?id=45108. 15931 verifyFormat(R"(// 15932 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result)); 15933 )"); 15934 15935 // A list of several ASM symbolic names. 15936 verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)"); 15937 15938 // ASM symbolic names in inline ASM with inputs and outputs. 15939 verifyFormat(R"(// 15940 asm("cmoveq %1, %2, %[result]" 15941 : [result] "=r"(result) 15942 : "r"(test), "r"(new), "[result]"(old)); 15943 )"); 15944 15945 // ASM symbolic names in inline ASM with no outputs. 15946 verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)"); 15947 } 15948 15949 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 15950 EXPECT_EQ(FormatStyle::LK_Cpp, 15951 guessLanguage("foo.h", "void f() {\n" 15952 " asm (\"mov %[e], %[d]\"\n" 15953 " : [d] \"=rm\" (d)\n" 15954 " [e] \"rm\" (*e));\n" 15955 "}")); 15956 EXPECT_EQ(FormatStyle::LK_Cpp, 15957 guessLanguage("foo.h", "void f() {\n" 15958 " _asm (\"mov %[e], %[d]\"\n" 15959 " : [d] \"=rm\" (d)\n" 15960 " [e] \"rm\" (*e));\n" 15961 "}")); 15962 EXPECT_EQ(FormatStyle::LK_Cpp, 15963 guessLanguage("foo.h", "void f() {\n" 15964 " __asm (\"mov %[e], %[d]\"\n" 15965 " : [d] \"=rm\" (d)\n" 15966 " [e] \"rm\" (*e));\n" 15967 "}")); 15968 EXPECT_EQ(FormatStyle::LK_Cpp, 15969 guessLanguage("foo.h", "void f() {\n" 15970 " __asm__ (\"mov %[e], %[d]\"\n" 15971 " : [d] \"=rm\" (d)\n" 15972 " [e] \"rm\" (*e));\n" 15973 "}")); 15974 EXPECT_EQ(FormatStyle::LK_Cpp, 15975 guessLanguage("foo.h", "void f() {\n" 15976 " asm (\"mov %[e], %[d]\"\n" 15977 " : [d] \"=rm\" (d),\n" 15978 " [e] \"rm\" (*e));\n" 15979 "}")); 15980 EXPECT_EQ(FormatStyle::LK_Cpp, 15981 guessLanguage("foo.h", "void f() {\n" 15982 " asm volatile (\"mov %[e], %[d]\"\n" 15983 " : [d] \"=rm\" (d)\n" 15984 " [e] \"rm\" (*e));\n" 15985 "}")); 15986 } 15987 15988 TEST_F(FormatTest, GuessLanguageWithChildLines) { 15989 EXPECT_EQ(FormatStyle::LK_Cpp, 15990 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 15991 EXPECT_EQ(FormatStyle::LK_ObjC, 15992 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 15993 EXPECT_EQ( 15994 FormatStyle::LK_Cpp, 15995 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 15996 EXPECT_EQ( 15997 FormatStyle::LK_ObjC, 15998 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 15999 } 16000 16001 TEST_F(FormatTest, TypenameMacros) { 16002 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 16003 16004 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 16005 FormatStyle Google = getGoogleStyleWithColumns(0); 16006 Google.TypenameMacros = TypenameMacros; 16007 verifyFormat("struct foo {\n" 16008 " int bar;\n" 16009 " TAILQ_ENTRY(a) bleh;\n" 16010 "};", 16011 Google); 16012 16013 FormatStyle Macros = getLLVMStyle(); 16014 Macros.TypenameMacros = TypenameMacros; 16015 16016 verifyFormat("STACK_OF(int) a;", Macros); 16017 verifyFormat("STACK_OF(int) *a;", Macros); 16018 verifyFormat("STACK_OF(int const *) *a;", Macros); 16019 verifyFormat("STACK_OF(int *const) *a;", Macros); 16020 verifyFormat("STACK_OF(int, string) a;", Macros); 16021 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 16022 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 16023 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 16024 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 16025 16026 Macros.PointerAlignment = FormatStyle::PAS_Left; 16027 verifyFormat("STACK_OF(int)* a;", Macros); 16028 verifyFormat("STACK_OF(int*)* a;", Macros); 16029 } 16030 16031 TEST_F(FormatTest, AmbersandInLamda) { 16032 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899 16033 FormatStyle AlignStyle = getLLVMStyle(); 16034 AlignStyle.PointerAlignment = FormatStyle::PAS_Left; 16035 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 16036 AlignStyle.PointerAlignment = FormatStyle::PAS_Right; 16037 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 16038 } 16039 16040 TEST_F(FormatTest, SpacesInConditionalStatement) { 16041 FormatStyle Spaces = getLLVMStyle(); 16042 Spaces.SpacesInConditionalStatement = true; 16043 verifyFormat("for ( int i = 0; i; i++ )\n continue;", Spaces); 16044 verifyFormat("if ( !a )\n return;", Spaces); 16045 verifyFormat("if ( a )\n return;", Spaces); 16046 verifyFormat("if constexpr ( a )\n return;", Spaces); 16047 verifyFormat("switch ( a )\ncase 1:\n return;", Spaces); 16048 verifyFormat("while ( a )\n return;", Spaces); 16049 verifyFormat("while ( (a && b) )\n return;", Spaces); 16050 verifyFormat("do {\n} while ( 1 != 0 );", Spaces); 16051 verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces); 16052 // Check that space on the left of "::" is inserted as expected at beginning 16053 // of condition. 16054 verifyFormat("while ( ::func() )\n return;", Spaces); 16055 } 16056 16057 TEST_F(FormatTest, AlternativeOperators) { 16058 // Test case for ensuring alternate operators are not 16059 // combined with their right most neighbour. 16060 verifyFormat("int a and b;"); 16061 verifyFormat("int a and_eq b;"); 16062 verifyFormat("int a bitand b;"); 16063 verifyFormat("int a bitor b;"); 16064 verifyFormat("int a compl b;"); 16065 verifyFormat("int a not b;"); 16066 verifyFormat("int a not_eq b;"); 16067 verifyFormat("int a or b;"); 16068 verifyFormat("int a xor b;"); 16069 verifyFormat("int a xor_eq b;"); 16070 verifyFormat("return this not_eq bitand other;"); 16071 verifyFormat("bool operator not_eq(const X bitand other)"); 16072 16073 verifyFormat("int a and 5;"); 16074 verifyFormat("int a and_eq 5;"); 16075 verifyFormat("int a bitand 5;"); 16076 verifyFormat("int a bitor 5;"); 16077 verifyFormat("int a compl 5;"); 16078 verifyFormat("int a not 5;"); 16079 verifyFormat("int a not_eq 5;"); 16080 verifyFormat("int a or 5;"); 16081 verifyFormat("int a xor 5;"); 16082 verifyFormat("int a xor_eq 5;"); 16083 16084 verifyFormat("int a compl(5);"); 16085 verifyFormat("int a not(5);"); 16086 16087 /* FIXME handle alternate tokens 16088 * https://en.cppreference.com/w/cpp/language/operator_alternative 16089 // alternative tokens 16090 verifyFormat("compl foo();"); // ~foo(); 16091 verifyFormat("foo() <%%>;"); // foo(); 16092 verifyFormat("void foo() <%%>;"); // void foo(){} 16093 verifyFormat("int a <:1:>;"); // int a[1];[ 16094 verifyFormat("%:define ABC abc"); // #define ABC abc 16095 verifyFormat("%:%:"); // ## 16096 */ 16097 } 16098 16099 TEST_F(FormatTest, STLWhileNotDefineChed) { 16100 verifyFormat("#if defined(while)\n" 16101 "#define while EMIT WARNING C4005\n" 16102 "#endif // while"); 16103 } 16104 16105 TEST_F(FormatTest, OperatorSpacing) { 16106 FormatStyle Style = getLLVMStyle(); 16107 Style.PointerAlignment = FormatStyle::PAS_Right; 16108 verifyFormat("Foo::operator*();", Style); 16109 verifyFormat("Foo::operator void *();", Style); 16110 verifyFormat("Foo::operator void **();", Style); 16111 verifyFormat("Foo::operator void *&();", Style); 16112 verifyFormat("Foo::operator void *&&();", Style); 16113 verifyFormat("Foo::operator()(void *);", Style); 16114 verifyFormat("Foo::operator*(void *);", Style); 16115 verifyFormat("Foo::operator*();", Style); 16116 verifyFormat("Foo::operator**();", Style); 16117 verifyFormat("Foo::operator&();", Style); 16118 verifyFormat("Foo::operator<int> *();", Style); 16119 verifyFormat("Foo::operator<Foo> *();", Style); 16120 verifyFormat("Foo::operator<int> **();", Style); 16121 verifyFormat("Foo::operator<Foo> **();", Style); 16122 verifyFormat("Foo::operator<int> &();", Style); 16123 verifyFormat("Foo::operator<Foo> &();", Style); 16124 verifyFormat("Foo::operator<int> &&();", Style); 16125 verifyFormat("Foo::operator<Foo> &&();", Style); 16126 verifyFormat("Foo::operator<int> *&();", Style); 16127 verifyFormat("Foo::operator<Foo> *&();", Style); 16128 verifyFormat("Foo::operator<int> *&&();", Style); 16129 verifyFormat("Foo::operator<Foo> *&&();", Style); 16130 verifyFormat("operator*(int (*)(), class Foo);", Style); 16131 16132 verifyFormat("Foo::operator&();", Style); 16133 verifyFormat("Foo::operator void &();", Style); 16134 verifyFormat("Foo::operator()(void &);", Style); 16135 verifyFormat("Foo::operator&(void &);", Style); 16136 verifyFormat("Foo::operator&();", Style); 16137 verifyFormat("operator&(int (&)(), class Foo);", Style); 16138 16139 verifyFormat("Foo::operator&&();", Style); 16140 verifyFormat("Foo::operator**();", Style); 16141 verifyFormat("Foo::operator void &&();", Style); 16142 verifyFormat("Foo::operator()(void &&);", Style); 16143 verifyFormat("Foo::operator&&(void &&);", Style); 16144 verifyFormat("Foo::operator&&();", Style); 16145 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 16146 verifyFormat("operator const nsTArrayRight<E> &()", Style); 16147 verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()", 16148 Style); 16149 verifyFormat("operator void **()", Style); 16150 verifyFormat("operator const FooRight<Object> &()", Style); 16151 verifyFormat("operator const FooRight<Object> *()", Style); 16152 verifyFormat("operator const FooRight<Object> **()", Style); 16153 verifyFormat("operator const FooRight<Object> *&()", Style); 16154 verifyFormat("operator const FooRight<Object> *&&()", Style); 16155 16156 Style.PointerAlignment = FormatStyle::PAS_Left; 16157 verifyFormat("Foo::operator*();", Style); 16158 verifyFormat("Foo::operator**();", Style); 16159 verifyFormat("Foo::operator void*();", Style); 16160 verifyFormat("Foo::operator void**();", Style); 16161 verifyFormat("Foo::operator void*&();", Style); 16162 verifyFormat("Foo::operator/*comment*/ void*();", Style); 16163 verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style); 16164 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style); 16165 verifyFormat("Foo::operator()(void*);", Style); 16166 verifyFormat("Foo::operator*(void*);", Style); 16167 verifyFormat("Foo::operator*();", Style); 16168 verifyFormat("Foo::operator<int>*();", Style); 16169 verifyFormat("Foo::operator<Foo>*();", Style); 16170 verifyFormat("Foo::operator<int>**();", Style); 16171 verifyFormat("Foo::operator<Foo>**();", Style); 16172 verifyFormat("Foo::operator<Foo>*&();", Style); 16173 verifyFormat("Foo::operator<int>&();", Style); 16174 verifyFormat("Foo::operator<Foo>&();", Style); 16175 verifyFormat("Foo::operator<int>&&();", Style); 16176 verifyFormat("Foo::operator<Foo>&&();", Style); 16177 verifyFormat("Foo::operator<int>*&();", Style); 16178 verifyFormat("Foo::operator<Foo>*&();", Style); 16179 verifyFormat("operator*(int (*)(), class Foo);", Style); 16180 16181 verifyFormat("Foo::operator&();", Style); 16182 verifyFormat("Foo::operator void&();", Style); 16183 verifyFormat("Foo::operator/*comment*/ void&();", Style); 16184 verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style); 16185 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style); 16186 verifyFormat("Foo::operator()(void&);", Style); 16187 verifyFormat("Foo::operator&(void&);", Style); 16188 verifyFormat("Foo::operator&();", Style); 16189 verifyFormat("operator&(int (&)(), class Foo);", Style); 16190 16191 verifyFormat("Foo::operator&&();", Style); 16192 verifyFormat("Foo::operator void&&();", Style); 16193 verifyFormat("Foo::operator/*comment*/ void&&();", Style); 16194 verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style); 16195 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style); 16196 verifyFormat("Foo::operator()(void&&);", Style); 16197 verifyFormat("Foo::operator&&(void&&);", Style); 16198 verifyFormat("Foo::operator&&();", Style); 16199 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 16200 verifyFormat("operator const nsTArrayLeft<E>&()", Style); 16201 verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()", 16202 Style); 16203 verifyFormat("operator void**()", Style); 16204 verifyFormat("operator const FooLeft<Object>&()", Style); 16205 verifyFormat("operator const FooLeft<Object>*()", Style); 16206 verifyFormat("operator const FooLeft<Object>**()", Style); 16207 verifyFormat("operator const FooLeft<Object>*&()", Style); 16208 verifyFormat("operator const FooLeft<Object>*&&()", Style); 16209 16210 // PR45107 16211 verifyFormat("operator Vector<String>&();", Style); 16212 verifyFormat("operator const Vector<String>&();", Style); 16213 verifyFormat("operator foo::Bar*();", Style); 16214 verifyFormat("operator const Foo<X>::Bar<Y>*();", Style); 16215 verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();", 16216 Style); 16217 16218 Style.PointerAlignment = FormatStyle::PAS_Middle; 16219 verifyFormat("Foo::operator*();", Style); 16220 verifyFormat("Foo::operator void *();", Style); 16221 verifyFormat("Foo::operator()(void *);", Style); 16222 verifyFormat("Foo::operator*(void *);", Style); 16223 verifyFormat("Foo::operator*();", Style); 16224 verifyFormat("operator*(int (*)(), class Foo);", Style); 16225 16226 verifyFormat("Foo::operator&();", Style); 16227 verifyFormat("Foo::operator void &();", Style); 16228 verifyFormat("Foo::operator()(void &);", Style); 16229 verifyFormat("Foo::operator&(void &);", Style); 16230 verifyFormat("Foo::operator&();", Style); 16231 verifyFormat("operator&(int (&)(), class Foo);", Style); 16232 16233 verifyFormat("Foo::operator&&();", Style); 16234 verifyFormat("Foo::operator void &&();", Style); 16235 verifyFormat("Foo::operator()(void &&);", Style); 16236 verifyFormat("Foo::operator&&(void &&);", Style); 16237 verifyFormat("Foo::operator&&();", Style); 16238 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 16239 } 16240 16241 TEST_F(FormatTest, VeryLongNamespaceCommentSplit) { 16242 // These tests are not in NamespaceFixer because that doesn't 16243 // test its interaction with line wrapping 16244 FormatStyle Style = getLLVMStyle(); 16245 Style.ColumnLimit = 80; 16246 verifyFormat("namespace {\n" 16247 "int i;\n" 16248 "int j;\n" 16249 "} // namespace", 16250 Style); 16251 16252 verifyFormat("namespace AAA {\n" 16253 "int i;\n" 16254 "int j;\n" 16255 "} // namespace AAA", 16256 Style); 16257 16258 EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n" 16259 "int i;\n" 16260 "int j;\n" 16261 "} // namespace Averyveryveryverylongnamespace", 16262 format("namespace Averyveryveryverylongnamespace {\n" 16263 "int i;\n" 16264 "int j;\n" 16265 "}", 16266 Style)); 16267 16268 EXPECT_EQ( 16269 "namespace " 16270 "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n" 16271 " went::mad::now {\n" 16272 "int i;\n" 16273 "int j;\n" 16274 "} // namespace\n" 16275 " // " 16276 "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::" 16277 "went::mad::now", 16278 format("namespace " 16279 "would::it::save::you::a::lot::of::time::if_::i::" 16280 "just::gave::up::and_::went::mad::now {\n" 16281 "int i;\n" 16282 "int j;\n" 16283 "}", 16284 Style)); 16285 16286 // This used to duplicate the comment again and again on subsequent runs 16287 EXPECT_EQ( 16288 "namespace " 16289 "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n" 16290 " went::mad::now {\n" 16291 "int i;\n" 16292 "int j;\n" 16293 "} // namespace\n" 16294 " // " 16295 "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::" 16296 "went::mad::now", 16297 format("namespace " 16298 "would::it::save::you::a::lot::of::time::if_::i::" 16299 "just::gave::up::and_::went::mad::now {\n" 16300 "int i;\n" 16301 "int j;\n" 16302 "} // namespace\n" 16303 " // " 16304 "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::" 16305 "and_::went::mad::now", 16306 Style)); 16307 } 16308 16309 } // namespace 16310 } // namespace format 16311 } // namespace clang 16312