1 //===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "clang/Format/Format.h" 10 11 #include "../Tooling/ReplacementTest.h" 12 #include "FormatTestUtils.h" 13 14 #include "clang/Frontend/TextDiagnosticPrinter.h" 15 #include "llvm/Support/Debug.h" 16 #include "llvm/Support/MemoryBuffer.h" 17 #include "gtest/gtest.h" 18 19 #define DEBUG_TYPE "format-test" 20 21 using clang::tooling::ReplacementTest; 22 using clang::tooling::toReplacements; 23 24 namespace clang { 25 namespace format { 26 namespace { 27 28 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); } 29 30 class FormatTest : public ::testing::Test { 31 protected: 32 enum StatusCheck { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck }; 33 34 std::string format(llvm::StringRef Code, 35 const FormatStyle &Style = getLLVMStyle(), 36 StatusCheck CheckComplete = SC_ExpectComplete) { 37 LLVM_DEBUG(llvm::errs() << "---\n"); 38 LLVM_DEBUG(llvm::errs() << Code << "\n\n"); 39 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size())); 40 FormattingAttemptStatus Status; 41 tooling::Replacements Replaces = 42 reformat(Style, Code, Ranges, "<stdin>", &Status); 43 if (CheckComplete != SC_DoNotCheck) { 44 bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete; 45 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete) 46 << Code << "\n\n"; 47 } 48 ReplacementCount = Replaces.size(); 49 auto Result = applyAllReplacements(Code, Replaces); 50 EXPECT_TRUE(static_cast<bool>(Result)); 51 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); 52 return *Result; 53 } 54 55 FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) { 56 Style.ColumnLimit = ColumnLimit; 57 return Style; 58 } 59 60 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 61 return getStyleWithColumns(getLLVMStyle(), ColumnLimit); 62 } 63 64 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) { 65 return getStyleWithColumns(getGoogleStyle(), ColumnLimit); 66 } 67 68 void verifyFormat(llvm::StringRef Expected, llvm::StringRef Code, 69 const FormatStyle &Style = getLLVMStyle()) { 70 EXPECT_EQ(Expected.str(), format(Expected, Style)) 71 << "Expected code is not stable"; 72 EXPECT_EQ(Expected.str(), format(Code, Style)); 73 if (Style.Language == FormatStyle::LK_Cpp) { 74 // Objective-C++ is a superset of C++, so everything checked for C++ 75 // needs to be checked for Objective-C++ as well. 76 FormatStyle ObjCStyle = Style; 77 ObjCStyle.Language = FormatStyle::LK_ObjC; 78 EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle)); 79 } 80 } 81 82 void verifyFormat(llvm::StringRef Code, 83 const FormatStyle &Style = getLLVMStyle()) { 84 verifyFormat(Code, test::messUp(Code), Style); 85 } 86 87 void verifyIncompleteFormat(llvm::StringRef Code, 88 const FormatStyle &Style = getLLVMStyle()) { 89 EXPECT_EQ(Code.str(), 90 format(test::messUp(Code), Style, SC_ExpectIncomplete)); 91 } 92 93 void verifyGoogleFormat(llvm::StringRef Code) { 94 verifyFormat(Code, getGoogleStyle()); 95 } 96 97 void verifyIndependentOfContext(llvm::StringRef text) { 98 verifyFormat(text); 99 verifyFormat(llvm::Twine("void f() { " + text + " }").str()); 100 } 101 102 /// \brief Verify that clang-format does not crash on the given input. 103 void verifyNoCrash(llvm::StringRef Code, 104 const FormatStyle &Style = getLLVMStyle()) { 105 format(Code, Style, SC_DoNotCheck); 106 } 107 108 int ReplacementCount; 109 }; 110 111 TEST_F(FormatTest, MessUp) { 112 EXPECT_EQ("1 2 3", test::messUp("1 2 3")); 113 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n")); 114 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc")); 115 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc")); 116 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne")); 117 } 118 119 TEST_F(FormatTest, DefaultLLVMStyleIsCpp) { 120 EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language); 121 } 122 123 TEST_F(FormatTest, LLVMStyleOverride) { 124 EXPECT_EQ(FormatStyle::LK_Proto, 125 getLLVMStyle(FormatStyle::LK_Proto).Language); 126 } 127 128 //===----------------------------------------------------------------------===// 129 // Basic function tests. 130 //===----------------------------------------------------------------------===// 131 132 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { 133 EXPECT_EQ(";", format(";")); 134 } 135 136 TEST_F(FormatTest, FormatsGlobalStatementsAt0) { 137 EXPECT_EQ("int i;", format(" int i;")); 138 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;")); 139 EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); 140 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); 141 } 142 143 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { 144 EXPECT_EQ("int i;", format("int\ni;")); 145 } 146 147 TEST_F(FormatTest, FormatsNestedBlockStatements) { 148 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}")); 149 } 150 151 TEST_F(FormatTest, FormatsNestedCall) { 152 verifyFormat("Method(f1, f2(f3));"); 153 verifyFormat("Method(f1(f2, f3()));"); 154 verifyFormat("Method(f1(f2, (f3())));"); 155 } 156 157 TEST_F(FormatTest, NestedNameSpecifiers) { 158 verifyFormat("vector<::Type> v;"); 159 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())"); 160 verifyFormat("static constexpr bool Bar = decltype(bar())::value;"); 161 verifyFormat("bool a = 2 < ::SomeFunction();"); 162 verifyFormat("ALWAYS_INLINE ::std::string getName();"); 163 verifyFormat("some::string getName();"); 164 } 165 166 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { 167 EXPECT_EQ("if (a) {\n" 168 " f();\n" 169 "}", 170 format("if(a){f();}")); 171 EXPECT_EQ(4, ReplacementCount); 172 EXPECT_EQ("if (a) {\n" 173 " f();\n" 174 "}", 175 format("if (a) {\n" 176 " f();\n" 177 "}")); 178 EXPECT_EQ(0, ReplacementCount); 179 EXPECT_EQ("/*\r\n" 180 "\r\n" 181 "*/\r\n", 182 format("/*\r\n" 183 "\r\n" 184 "*/\r\n")); 185 EXPECT_EQ(0, ReplacementCount); 186 } 187 188 TEST_F(FormatTest, RemovesEmptyLines) { 189 EXPECT_EQ("class C {\n" 190 " int i;\n" 191 "};", 192 format("class C {\n" 193 " int i;\n" 194 "\n" 195 "};")); 196 197 // Don't remove empty lines at the start of namespaces or extern "C" blocks. 198 EXPECT_EQ("namespace N {\n" 199 "\n" 200 "int i;\n" 201 "}", 202 format("namespace N {\n" 203 "\n" 204 "int i;\n" 205 "}", 206 getGoogleStyle())); 207 EXPECT_EQ("/* something */ namespace N {\n" 208 "\n" 209 "int i;\n" 210 "}", 211 format("/* something */ namespace N {\n" 212 "\n" 213 "int i;\n" 214 "}", 215 getGoogleStyle())); 216 EXPECT_EQ("inline namespace N {\n" 217 "\n" 218 "int i;\n" 219 "}", 220 format("inline namespace N {\n" 221 "\n" 222 "int i;\n" 223 "}", 224 getGoogleStyle())); 225 EXPECT_EQ("/* something */ inline namespace N {\n" 226 "\n" 227 "int i;\n" 228 "}", 229 format("/* something */ inline namespace N {\n" 230 "\n" 231 "int i;\n" 232 "}", 233 getGoogleStyle())); 234 EXPECT_EQ("export namespace N {\n" 235 "\n" 236 "int i;\n" 237 "}", 238 format("export namespace N {\n" 239 "\n" 240 "int i;\n" 241 "}", 242 getGoogleStyle())); 243 EXPECT_EQ("extern /**/ \"C\" /**/ {\n" 244 "\n" 245 "int i;\n" 246 "}", 247 format("extern /**/ \"C\" /**/ {\n" 248 "\n" 249 "int i;\n" 250 "}", 251 getGoogleStyle())); 252 253 // ...but do keep inlining and removing empty lines for non-block extern "C" 254 // functions. 255 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle()); 256 EXPECT_EQ("extern \"C\" int f() {\n" 257 " int i = 42;\n" 258 " return i;\n" 259 "}", 260 format("extern \"C\" int f() {\n" 261 "\n" 262 " int i = 42;\n" 263 " return i;\n" 264 "}", 265 getGoogleStyle())); 266 267 // Remove empty lines at the beginning and end of blocks. 268 EXPECT_EQ("void f() {\n" 269 "\n" 270 " if (a) {\n" 271 "\n" 272 " f();\n" 273 " }\n" 274 "}", 275 format("void f() {\n" 276 "\n" 277 " if (a) {\n" 278 "\n" 279 " f();\n" 280 "\n" 281 " }\n" 282 "\n" 283 "}", 284 getLLVMStyle())); 285 EXPECT_EQ("void f() {\n" 286 " if (a) {\n" 287 " f();\n" 288 " }\n" 289 "}", 290 format("void f() {\n" 291 "\n" 292 " if (a) {\n" 293 "\n" 294 " f();\n" 295 "\n" 296 " }\n" 297 "\n" 298 "}", 299 getGoogleStyle())); 300 301 // Don't remove empty lines in more complex control statements. 302 EXPECT_EQ("void f() {\n" 303 " if (a) {\n" 304 " f();\n" 305 "\n" 306 " } else if (b) {\n" 307 " f();\n" 308 " }\n" 309 "}", 310 format("void f() {\n" 311 " if (a) {\n" 312 " f();\n" 313 "\n" 314 " } else if (b) {\n" 315 " f();\n" 316 "\n" 317 " }\n" 318 "\n" 319 "}")); 320 321 // Don't remove empty lines before namespace endings. 322 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 323 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 324 EXPECT_EQ("namespace {\n" 325 "int i;\n" 326 "\n" 327 "}", 328 format("namespace {\n" 329 "int i;\n" 330 "\n" 331 "}", 332 LLVMWithNoNamespaceFix)); 333 EXPECT_EQ("namespace {\n" 334 "int i;\n" 335 "}", 336 format("namespace {\n" 337 "int i;\n" 338 "}", 339 LLVMWithNoNamespaceFix)); 340 EXPECT_EQ("namespace {\n" 341 "int i;\n" 342 "\n" 343 "};", 344 format("namespace {\n" 345 "int i;\n" 346 "\n" 347 "};", 348 LLVMWithNoNamespaceFix)); 349 EXPECT_EQ("namespace {\n" 350 "int i;\n" 351 "};", 352 format("namespace {\n" 353 "int i;\n" 354 "};", 355 LLVMWithNoNamespaceFix)); 356 EXPECT_EQ("namespace {\n" 357 "int i;\n" 358 "\n" 359 "}", 360 format("namespace {\n" 361 "int i;\n" 362 "\n" 363 "}")); 364 EXPECT_EQ("namespace {\n" 365 "int i;\n" 366 "\n" 367 "} // namespace", 368 format("namespace {\n" 369 "int i;\n" 370 "\n" 371 "} // namespace")); 372 373 FormatStyle Style = getLLVMStyle(); 374 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 375 Style.MaxEmptyLinesToKeep = 2; 376 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 377 Style.BraceWrapping.AfterClass = true; 378 Style.BraceWrapping.AfterFunction = true; 379 Style.KeepEmptyLinesAtTheStartOfBlocks = false; 380 381 EXPECT_EQ("class Foo\n" 382 "{\n" 383 " Foo() {}\n" 384 "\n" 385 " void funk() {}\n" 386 "};", 387 format("class Foo\n" 388 "{\n" 389 " Foo()\n" 390 " {\n" 391 " }\n" 392 "\n" 393 " void funk() {}\n" 394 "};", 395 Style)); 396 } 397 398 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) { 399 verifyFormat("x = (a) and (b);"); 400 verifyFormat("x = (a) or (b);"); 401 verifyFormat("x = (a) bitand (b);"); 402 verifyFormat("x = (a) bitor (b);"); 403 verifyFormat("x = (a) not_eq (b);"); 404 verifyFormat("x = (a) and_eq (b);"); 405 verifyFormat("x = (a) or_eq (b);"); 406 verifyFormat("x = (a) xor (b);"); 407 } 408 409 TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) { 410 verifyFormat("x = compl(a);"); 411 verifyFormat("x = not(a);"); 412 verifyFormat("x = bitand(a);"); 413 // Unary operator must not be merged with the next identifier 414 verifyFormat("x = compl a;"); 415 verifyFormat("x = not a;"); 416 verifyFormat("x = bitand a;"); 417 } 418 419 //===----------------------------------------------------------------------===// 420 // Tests for control statements. 421 //===----------------------------------------------------------------------===// 422 423 TEST_F(FormatTest, FormatIfWithoutCompoundStatement) { 424 verifyFormat("if (true)\n f();\ng();"); 425 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();"); 426 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();"); 427 verifyFormat("if constexpr (true)\n" 428 " f();\ng();"); 429 verifyFormat("if CONSTEXPR (true)\n" 430 " f();\ng();"); 431 verifyFormat("if constexpr (a)\n" 432 " if constexpr (b)\n" 433 " if constexpr (c)\n" 434 " g();\n" 435 "h();"); 436 verifyFormat("if CONSTEXPR (a)\n" 437 " if CONSTEXPR (b)\n" 438 " if CONSTEXPR (c)\n" 439 " g();\n" 440 "h();"); 441 verifyFormat("if constexpr (a)\n" 442 " if constexpr (b) {\n" 443 " f();\n" 444 " }\n" 445 "g();"); 446 verifyFormat("if CONSTEXPR (a)\n" 447 " if CONSTEXPR (b) {\n" 448 " f();\n" 449 " }\n" 450 "g();"); 451 452 FormatStyle AllowsMergedIf = getLLVMStyle(); 453 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 454 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 455 FormatStyle::SIS_WithoutElse; 456 verifyFormat("if (a)\n" 457 " // comment\n" 458 " f();", 459 AllowsMergedIf); 460 verifyFormat("{\n" 461 " if (a)\n" 462 " label:\n" 463 " f();\n" 464 "}", 465 AllowsMergedIf); 466 verifyFormat("#define A \\\n" 467 " if (a) \\\n" 468 " label: \\\n" 469 " f()", 470 AllowsMergedIf); 471 verifyFormat("if (a)\n" 472 " ;", 473 AllowsMergedIf); 474 verifyFormat("if (a)\n" 475 " if (b) return;", 476 AllowsMergedIf); 477 478 verifyFormat("if (a) // Can't merge this\n" 479 " f();\n", 480 AllowsMergedIf); 481 verifyFormat("if (a) /* still don't merge */\n" 482 " f();", 483 AllowsMergedIf); 484 verifyFormat("if (a) { // Never merge this\n" 485 " f();\n" 486 "}", 487 AllowsMergedIf); 488 verifyFormat("if (a) { /* Never merge this */\n" 489 " f();\n" 490 "}", 491 AllowsMergedIf); 492 493 AllowsMergedIf.ColumnLimit = 14; 494 verifyFormat("if (a) return;", AllowsMergedIf); 495 verifyFormat("if (aaaaaaaaa)\n" 496 " return;", 497 AllowsMergedIf); 498 499 AllowsMergedIf.ColumnLimit = 13; 500 verifyFormat("if (a)\n return;", AllowsMergedIf); 501 } 502 503 TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) { 504 FormatStyle AllowsMergedIf = getLLVMStyle(); 505 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 506 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 507 FormatStyle::SIS_WithoutElse; 508 verifyFormat("if (a)\n" 509 " f();\n" 510 "else {\n" 511 " g();\n" 512 "}", 513 AllowsMergedIf); 514 verifyFormat("if (a)\n" 515 " f();\n" 516 "else\n" 517 " g();\n", 518 AllowsMergedIf); 519 520 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 521 522 verifyFormat("if (a) f();\n" 523 "else {\n" 524 " g();\n" 525 "}", 526 AllowsMergedIf); 527 verifyFormat("if (a) f();\n" 528 "else {\n" 529 " if (a) f();\n" 530 " else {\n" 531 " g();\n" 532 " }\n" 533 " g();\n" 534 "}", 535 AllowsMergedIf); 536 } 537 538 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) { 539 FormatStyle AllowsMergedLoops = getLLVMStyle(); 540 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true; 541 verifyFormat("while (true) continue;", AllowsMergedLoops); 542 verifyFormat("for (;;) continue;", AllowsMergedLoops); 543 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops); 544 verifyFormat("while (true)\n" 545 " ;", 546 AllowsMergedLoops); 547 verifyFormat("for (;;)\n" 548 " ;", 549 AllowsMergedLoops); 550 verifyFormat("for (;;)\n" 551 " for (;;) continue;", 552 AllowsMergedLoops); 553 verifyFormat("for (;;) // Can't merge this\n" 554 " continue;", 555 AllowsMergedLoops); 556 verifyFormat("for (;;) /* still don't merge */\n" 557 " continue;", 558 AllowsMergedLoops); 559 } 560 561 TEST_F(FormatTest, FormatShortBracedStatements) { 562 FormatStyle AllowSimpleBracedStatements = getLLVMStyle(); 563 AllowSimpleBracedStatements.ColumnLimit = 40; 564 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = 565 FormatStyle::SBS_Always; 566 567 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 568 FormatStyle::SIS_WithoutElse; 569 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 570 571 AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom; 572 AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true; 573 AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false; 574 575 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 576 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 577 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 578 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 579 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 580 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 581 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 582 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 583 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 584 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 585 verifyFormat("if (true) {\n" 586 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 587 "}", 588 AllowSimpleBracedStatements); 589 verifyFormat("if (true) { //\n" 590 " f();\n" 591 "}", 592 AllowSimpleBracedStatements); 593 verifyFormat("if (true) {\n" 594 " f();\n" 595 " f();\n" 596 "}", 597 AllowSimpleBracedStatements); 598 verifyFormat("if (true) {\n" 599 " f();\n" 600 "} else {\n" 601 " f();\n" 602 "}", 603 AllowSimpleBracedStatements); 604 605 verifyFormat("struct A2 {\n" 606 " int X;\n" 607 "};", 608 AllowSimpleBracedStatements); 609 verifyFormat("typedef struct A2 {\n" 610 " int X;\n" 611 "} A2_t;", 612 AllowSimpleBracedStatements); 613 verifyFormat("template <int> struct A2 {\n" 614 " struct B {};\n" 615 "};", 616 AllowSimpleBracedStatements); 617 618 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 619 FormatStyle::SIS_Never; 620 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 621 verifyFormat("if (true) {\n" 622 " f();\n" 623 "}", 624 AllowSimpleBracedStatements); 625 verifyFormat("if (true) {\n" 626 " f();\n" 627 "} else {\n" 628 " f();\n" 629 "}", 630 AllowSimpleBracedStatements); 631 632 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 633 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 634 verifyFormat("while (true) {\n" 635 " f();\n" 636 "}", 637 AllowSimpleBracedStatements); 638 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 639 verifyFormat("for (;;) {\n" 640 " f();\n" 641 "}", 642 AllowSimpleBracedStatements); 643 644 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 645 FormatStyle::SIS_WithoutElse; 646 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 647 AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement = 648 FormatStyle::BWACS_Always; 649 650 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 651 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 652 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 653 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 654 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 655 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 656 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 657 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 658 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 659 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 660 verifyFormat("if (true)\n" 661 "{\n" 662 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 663 "}", 664 AllowSimpleBracedStatements); 665 verifyFormat("if (true)\n" 666 "{ //\n" 667 " f();\n" 668 "}", 669 AllowSimpleBracedStatements); 670 verifyFormat("if (true)\n" 671 "{\n" 672 " f();\n" 673 " f();\n" 674 "}", 675 AllowSimpleBracedStatements); 676 verifyFormat("if (true)\n" 677 "{\n" 678 " f();\n" 679 "} else\n" 680 "{\n" 681 " f();\n" 682 "}", 683 AllowSimpleBracedStatements); 684 685 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 686 FormatStyle::SIS_Never; 687 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 688 verifyFormat("if (true)\n" 689 "{\n" 690 " f();\n" 691 "}", 692 AllowSimpleBracedStatements); 693 verifyFormat("if (true)\n" 694 "{\n" 695 " f();\n" 696 "} else\n" 697 "{\n" 698 " f();\n" 699 "}", 700 AllowSimpleBracedStatements); 701 702 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 703 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 704 verifyFormat("while (true)\n" 705 "{\n" 706 " f();\n" 707 "}", 708 AllowSimpleBracedStatements); 709 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 710 verifyFormat("for (;;)\n" 711 "{\n" 712 " f();\n" 713 "}", 714 AllowSimpleBracedStatements); 715 } 716 717 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) { 718 FormatStyle Style = getLLVMStyleWithColumns(60); 719 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 720 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 721 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 722 EXPECT_EQ("#define A \\\n" 723 " if (HANDLEwernufrnuLwrmviferuvnierv) \\\n" 724 " { RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; }\n" 725 "X;", 726 format("#define A \\\n" 727 " if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n" 728 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n" 729 " }\n" 730 "X;", 731 Style)); 732 } 733 734 TEST_F(FormatTest, ParseIfElse) { 735 verifyFormat("if (true)\n" 736 " if (true)\n" 737 " if (true)\n" 738 " f();\n" 739 " else\n" 740 " g();\n" 741 " else\n" 742 " h();\n" 743 "else\n" 744 " i();"); 745 verifyFormat("if (true)\n" 746 " if (true)\n" 747 " if (true) {\n" 748 " if (true)\n" 749 " f();\n" 750 " } else {\n" 751 " g();\n" 752 " }\n" 753 " else\n" 754 " h();\n" 755 "else {\n" 756 " i();\n" 757 "}"); 758 verifyFormat("if (true)\n" 759 " if constexpr (true)\n" 760 " if (true) {\n" 761 " if constexpr (true)\n" 762 " f();\n" 763 " } else {\n" 764 " g();\n" 765 " }\n" 766 " else\n" 767 " h();\n" 768 "else {\n" 769 " i();\n" 770 "}"); 771 verifyFormat("if (true)\n" 772 " if CONSTEXPR (true)\n" 773 " if (true) {\n" 774 " if CONSTEXPR (true)\n" 775 " f();\n" 776 " } else {\n" 777 " g();\n" 778 " }\n" 779 " else\n" 780 " h();\n" 781 "else {\n" 782 " i();\n" 783 "}"); 784 verifyFormat("void f() {\n" 785 " if (a) {\n" 786 " } else {\n" 787 " }\n" 788 "}"); 789 } 790 791 TEST_F(FormatTest, ElseIf) { 792 verifyFormat("if (a) {\n} else if (b) {\n}"); 793 verifyFormat("if (a)\n" 794 " f();\n" 795 "else if (b)\n" 796 " g();\n" 797 "else\n" 798 " h();"); 799 verifyFormat("if constexpr (a)\n" 800 " f();\n" 801 "else if constexpr (b)\n" 802 " g();\n" 803 "else\n" 804 " h();"); 805 verifyFormat("if CONSTEXPR (a)\n" 806 " f();\n" 807 "else if CONSTEXPR (b)\n" 808 " g();\n" 809 "else\n" 810 " h();"); 811 verifyFormat("if (a) {\n" 812 " f();\n" 813 "}\n" 814 "// or else ..\n" 815 "else {\n" 816 " g()\n" 817 "}"); 818 819 verifyFormat("if (a) {\n" 820 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 821 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 822 "}"); 823 verifyFormat("if (a) {\n" 824 "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 825 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 826 "}"); 827 verifyFormat("if (a) {\n" 828 "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 829 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 830 "}"); 831 verifyFormat("if (a) {\n" 832 "} else if (\n" 833 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 834 "}", 835 getLLVMStyleWithColumns(62)); 836 verifyFormat("if (a) {\n" 837 "} else if constexpr (\n" 838 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 839 "}", 840 getLLVMStyleWithColumns(62)); 841 verifyFormat("if (a) {\n" 842 "} else if CONSTEXPR (\n" 843 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 844 "}", 845 getLLVMStyleWithColumns(62)); 846 } 847 848 TEST_F(FormatTest, FormatsForLoop) { 849 verifyFormat( 850 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 851 " ++VeryVeryLongLoopVariable)\n" 852 " ;"); 853 verifyFormat("for (;;)\n" 854 " f();"); 855 verifyFormat("for (;;) {\n}"); 856 verifyFormat("for (;;) {\n" 857 " f();\n" 858 "}"); 859 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 860 861 verifyFormat( 862 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 863 " E = UnwrappedLines.end();\n" 864 " I != E; ++I) {\n}"); 865 866 verifyFormat( 867 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 868 " ++IIIII) {\n}"); 869 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 870 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 871 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 872 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 873 " I = FD->getDeclsInPrototypeScope().begin(),\n" 874 " E = FD->getDeclsInPrototypeScope().end();\n" 875 " I != E; ++I) {\n}"); 876 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n" 877 " I = Container.begin(),\n" 878 " E = Container.end();\n" 879 " I != E; ++I) {\n}", 880 getLLVMStyleWithColumns(76)); 881 882 verifyFormat( 883 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 884 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 885 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 886 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 887 " ++aaaaaaaaaaa) {\n}"); 888 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 889 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n" 890 " ++i) {\n}"); 891 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 892 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 893 "}"); 894 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 895 " aaaaaaaaaa);\n" 896 " iter; ++iter) {\n" 897 "}"); 898 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 899 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 900 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n" 901 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {"); 902 903 // These should not be formatted as Objective-C for-in loops. 904 verifyFormat("for (Foo *x = 0; x != in; x++) {\n}"); 905 verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}"); 906 verifyFormat("Foo *x;\nfor (x in y) {\n}"); 907 verifyFormat( 908 "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}"); 909 910 FormatStyle NoBinPacking = getLLVMStyle(); 911 NoBinPacking.BinPackParameters = false; 912 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 913 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 914 " aaaaaaaaaaaaaaaa,\n" 915 " aaaaaaaaaaaaaaaa,\n" 916 " aaaaaaaaaaaaaaaa);\n" 917 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 918 "}", 919 NoBinPacking); 920 verifyFormat( 921 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 922 " E = UnwrappedLines.end();\n" 923 " I != E;\n" 924 " ++I) {\n}", 925 NoBinPacking); 926 927 FormatStyle AlignLeft = getLLVMStyle(); 928 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 929 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft); 930 } 931 932 TEST_F(FormatTest, RangeBasedForLoops) { 933 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 934 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 935 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 936 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 937 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 938 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 939 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n" 940 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}"); 941 } 942 943 TEST_F(FormatTest, ForEachLoops) { 944 verifyFormat("void f() {\n" 945 " foreach (Item *item, itemlist) {}\n" 946 " Q_FOREACH (Item *item, itemlist) {}\n" 947 " BOOST_FOREACH (Item *item, itemlist) {}\n" 948 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 949 "}"); 950 951 // As function-like macros. 952 verifyFormat("#define foreach(x, y)\n" 953 "#define Q_FOREACH(x, y)\n" 954 "#define BOOST_FOREACH(x, y)\n" 955 "#define UNKNOWN_FOREACH(x, y)\n"); 956 957 // Not as function-like macros. 958 verifyFormat("#define foreach (x, y)\n" 959 "#define Q_FOREACH (x, y)\n" 960 "#define BOOST_FOREACH (x, y)\n" 961 "#define UNKNOWN_FOREACH (x, y)\n"); 962 } 963 964 TEST_F(FormatTest, FormatsWhileLoop) { 965 verifyFormat("while (true) {\n}"); 966 verifyFormat("while (true)\n" 967 " f();"); 968 verifyFormat("while () {\n}"); 969 verifyFormat("while () {\n" 970 " f();\n" 971 "}"); 972 } 973 974 TEST_F(FormatTest, FormatsDoWhile) { 975 verifyFormat("do {\n" 976 " do_something();\n" 977 "} while (something());"); 978 verifyFormat("do\n" 979 " do_something();\n" 980 "while (something());"); 981 } 982 983 TEST_F(FormatTest, FormatsSwitchStatement) { 984 verifyFormat("switch (x) {\n" 985 "case 1:\n" 986 " f();\n" 987 " break;\n" 988 "case kFoo:\n" 989 "case ns::kBar:\n" 990 "case kBaz:\n" 991 " break;\n" 992 "default:\n" 993 " g();\n" 994 " break;\n" 995 "}"); 996 verifyFormat("switch (x) {\n" 997 "case 1: {\n" 998 " f();\n" 999 " break;\n" 1000 "}\n" 1001 "case 2: {\n" 1002 " break;\n" 1003 "}\n" 1004 "}"); 1005 verifyFormat("switch (x) {\n" 1006 "case 1: {\n" 1007 " f();\n" 1008 " {\n" 1009 " g();\n" 1010 " h();\n" 1011 " }\n" 1012 " break;\n" 1013 "}\n" 1014 "}"); 1015 verifyFormat("switch (x) {\n" 1016 "case 1: {\n" 1017 " f();\n" 1018 " if (foo) {\n" 1019 " g();\n" 1020 " h();\n" 1021 " }\n" 1022 " break;\n" 1023 "}\n" 1024 "}"); 1025 verifyFormat("switch (x) {\n" 1026 "case 1: {\n" 1027 " f();\n" 1028 " g();\n" 1029 "} break;\n" 1030 "}"); 1031 verifyFormat("switch (test)\n" 1032 " ;"); 1033 verifyFormat("switch (x) {\n" 1034 "default: {\n" 1035 " // Do nothing.\n" 1036 "}\n" 1037 "}"); 1038 verifyFormat("switch (x) {\n" 1039 "// comment\n" 1040 "// if 1, do f()\n" 1041 "case 1:\n" 1042 " f();\n" 1043 "}"); 1044 verifyFormat("switch (x) {\n" 1045 "case 1:\n" 1046 " // Do amazing stuff\n" 1047 " {\n" 1048 " f();\n" 1049 " g();\n" 1050 " }\n" 1051 " break;\n" 1052 "}"); 1053 verifyFormat("#define A \\\n" 1054 " switch (x) { \\\n" 1055 " case a: \\\n" 1056 " foo = b; \\\n" 1057 " }", 1058 getLLVMStyleWithColumns(20)); 1059 verifyFormat("#define OPERATION_CASE(name) \\\n" 1060 " case OP_name: \\\n" 1061 " return operations::Operation##name\n", 1062 getLLVMStyleWithColumns(40)); 1063 verifyFormat("switch (x) {\n" 1064 "case 1:;\n" 1065 "default:;\n" 1066 " int i;\n" 1067 "}"); 1068 1069 verifyGoogleFormat("switch (x) {\n" 1070 " case 1:\n" 1071 " f();\n" 1072 " break;\n" 1073 " case kFoo:\n" 1074 " case ns::kBar:\n" 1075 " case kBaz:\n" 1076 " break;\n" 1077 " default:\n" 1078 " g();\n" 1079 " break;\n" 1080 "}"); 1081 verifyGoogleFormat("switch (x) {\n" 1082 " case 1: {\n" 1083 " f();\n" 1084 " break;\n" 1085 " }\n" 1086 "}"); 1087 verifyGoogleFormat("switch (test)\n" 1088 " ;"); 1089 1090 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 1091 " case OP_name: \\\n" 1092 " return operations::Operation##name\n"); 1093 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 1094 " // Get the correction operation class.\n" 1095 " switch (OpCode) {\n" 1096 " CASE(Add);\n" 1097 " CASE(Subtract);\n" 1098 " default:\n" 1099 " return operations::Unknown;\n" 1100 " }\n" 1101 "#undef OPERATION_CASE\n" 1102 "}"); 1103 verifyFormat("DEBUG({\n" 1104 " switch (x) {\n" 1105 " case A:\n" 1106 " f();\n" 1107 " break;\n" 1108 " // fallthrough\n" 1109 " case B:\n" 1110 " g();\n" 1111 " break;\n" 1112 " }\n" 1113 "});"); 1114 EXPECT_EQ("DEBUG({\n" 1115 " switch (x) {\n" 1116 " case A:\n" 1117 " f();\n" 1118 " break;\n" 1119 " // On B:\n" 1120 " case B:\n" 1121 " g();\n" 1122 " break;\n" 1123 " }\n" 1124 "});", 1125 format("DEBUG({\n" 1126 " switch (x) {\n" 1127 " case A:\n" 1128 " f();\n" 1129 " break;\n" 1130 " // On B:\n" 1131 " case B:\n" 1132 " g();\n" 1133 " break;\n" 1134 " }\n" 1135 "});", 1136 getLLVMStyle())); 1137 EXPECT_EQ("switch (n) {\n" 1138 "case 0: {\n" 1139 " return false;\n" 1140 "}\n" 1141 "default: {\n" 1142 " return true;\n" 1143 "}\n" 1144 "}", 1145 format("switch (n)\n" 1146 "{\n" 1147 "case 0: {\n" 1148 " return false;\n" 1149 "}\n" 1150 "default: {\n" 1151 " return true;\n" 1152 "}\n" 1153 "}", 1154 getLLVMStyle())); 1155 verifyFormat("switch (a) {\n" 1156 "case (b):\n" 1157 " return;\n" 1158 "}"); 1159 1160 verifyFormat("switch (a) {\n" 1161 "case some_namespace::\n" 1162 " some_constant:\n" 1163 " return;\n" 1164 "}", 1165 getLLVMStyleWithColumns(34)); 1166 1167 FormatStyle Style = getLLVMStyle(); 1168 Style.IndentCaseLabels = true; 1169 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 1170 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1171 Style.BraceWrapping.AfterCaseLabel = true; 1172 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1173 EXPECT_EQ("switch (n)\n" 1174 "{\n" 1175 " case 0:\n" 1176 " {\n" 1177 " return false;\n" 1178 " }\n" 1179 " default:\n" 1180 " {\n" 1181 " return true;\n" 1182 " }\n" 1183 "}", 1184 format("switch (n) {\n" 1185 " case 0: {\n" 1186 " return false;\n" 1187 " }\n" 1188 " default: {\n" 1189 " return true;\n" 1190 " }\n" 1191 "}", 1192 Style)); 1193 Style.BraceWrapping.AfterCaseLabel = false; 1194 EXPECT_EQ("switch (n)\n" 1195 "{\n" 1196 " case 0: {\n" 1197 " return false;\n" 1198 " }\n" 1199 " default: {\n" 1200 " return true;\n" 1201 " }\n" 1202 "}", 1203 format("switch (n) {\n" 1204 " case 0:\n" 1205 " {\n" 1206 " return false;\n" 1207 " }\n" 1208 " default:\n" 1209 " {\n" 1210 " return true;\n" 1211 " }\n" 1212 "}", 1213 Style)); 1214 } 1215 1216 TEST_F(FormatTest, CaseRanges) { 1217 verifyFormat("switch (x) {\n" 1218 "case 'A' ... 'Z':\n" 1219 "case 1 ... 5:\n" 1220 "case a ... b:\n" 1221 " break;\n" 1222 "}"); 1223 } 1224 1225 TEST_F(FormatTest, ShortCaseLabels) { 1226 FormatStyle Style = getLLVMStyle(); 1227 Style.AllowShortCaseLabelsOnASingleLine = true; 1228 verifyFormat("switch (a) {\n" 1229 "case 1: x = 1; break;\n" 1230 "case 2: return;\n" 1231 "case 3:\n" 1232 "case 4:\n" 1233 "case 5: return;\n" 1234 "case 6: // comment\n" 1235 " return;\n" 1236 "case 7:\n" 1237 " // comment\n" 1238 " return;\n" 1239 "case 8:\n" 1240 " x = 8; // comment\n" 1241 " break;\n" 1242 "default: y = 1; break;\n" 1243 "}", 1244 Style); 1245 verifyFormat("switch (a) {\n" 1246 "case 0: return; // comment\n" 1247 "case 1: break; // comment\n" 1248 "case 2: return;\n" 1249 "// comment\n" 1250 "case 3: return;\n" 1251 "// comment 1\n" 1252 "// comment 2\n" 1253 "// comment 3\n" 1254 "case 4: break; /* comment */\n" 1255 "case 5:\n" 1256 " // comment\n" 1257 " break;\n" 1258 "case 6: /* comment */ x = 1; break;\n" 1259 "case 7: x = /* comment */ 1; break;\n" 1260 "case 8:\n" 1261 " x = 1; /* comment */\n" 1262 " break;\n" 1263 "case 9:\n" 1264 " break; // comment line 1\n" 1265 " // comment line 2\n" 1266 "}", 1267 Style); 1268 EXPECT_EQ("switch (a) {\n" 1269 "case 1:\n" 1270 " x = 8;\n" 1271 " // fall through\n" 1272 "case 2: x = 8;\n" 1273 "// comment\n" 1274 "case 3:\n" 1275 " return; /* comment line 1\n" 1276 " * comment line 2 */\n" 1277 "case 4: i = 8;\n" 1278 "// something else\n" 1279 "#if FOO\n" 1280 "case 5: break;\n" 1281 "#endif\n" 1282 "}", 1283 format("switch (a) {\n" 1284 "case 1: x = 8;\n" 1285 " // fall through\n" 1286 "case 2:\n" 1287 " x = 8;\n" 1288 "// comment\n" 1289 "case 3:\n" 1290 " return; /* comment line 1\n" 1291 " * comment line 2 */\n" 1292 "case 4:\n" 1293 " i = 8;\n" 1294 "// something else\n" 1295 "#if FOO\n" 1296 "case 5: break;\n" 1297 "#endif\n" 1298 "}", 1299 Style)); 1300 EXPECT_EQ("switch (a) {\n" 1301 "case 0:\n" 1302 " return; // long long long long long long long long long long " 1303 "long long comment\n" 1304 " // line\n" 1305 "}", 1306 format("switch (a) {\n" 1307 "case 0: return; // long long long long long long long long " 1308 "long long long long comment line\n" 1309 "}", 1310 Style)); 1311 EXPECT_EQ("switch (a) {\n" 1312 "case 0:\n" 1313 " return; /* long long long long long long long long long long " 1314 "long long comment\n" 1315 " line */\n" 1316 "}", 1317 format("switch (a) {\n" 1318 "case 0: return; /* long long long long long long long long " 1319 "long long long long comment line */\n" 1320 "}", 1321 Style)); 1322 verifyFormat("switch (a) {\n" 1323 "#if FOO\n" 1324 "case 0: return 0;\n" 1325 "#endif\n" 1326 "}", 1327 Style); 1328 verifyFormat("switch (a) {\n" 1329 "case 1: {\n" 1330 "}\n" 1331 "case 2: {\n" 1332 " return;\n" 1333 "}\n" 1334 "case 3: {\n" 1335 " x = 1;\n" 1336 " return;\n" 1337 "}\n" 1338 "case 4:\n" 1339 " if (x)\n" 1340 " return;\n" 1341 "}", 1342 Style); 1343 Style.ColumnLimit = 21; 1344 verifyFormat("switch (a) {\n" 1345 "case 1: x = 1; break;\n" 1346 "case 2: return;\n" 1347 "case 3:\n" 1348 "case 4:\n" 1349 "case 5: return;\n" 1350 "default:\n" 1351 " y = 1;\n" 1352 " break;\n" 1353 "}", 1354 Style); 1355 Style.ColumnLimit = 80; 1356 Style.AllowShortCaseLabelsOnASingleLine = false; 1357 Style.IndentCaseLabels = true; 1358 EXPECT_EQ("switch (n) {\n" 1359 " default /*comments*/:\n" 1360 " return true;\n" 1361 " case 0:\n" 1362 " return false;\n" 1363 "}", 1364 format("switch (n) {\n" 1365 "default/*comments*/:\n" 1366 " return true;\n" 1367 "case 0:\n" 1368 " return false;\n" 1369 "}", 1370 Style)); 1371 Style.AllowShortCaseLabelsOnASingleLine = true; 1372 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1373 Style.BraceWrapping.AfterCaseLabel = true; 1374 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1375 EXPECT_EQ("switch (n)\n" 1376 "{\n" 1377 " case 0:\n" 1378 " {\n" 1379 " return false;\n" 1380 " }\n" 1381 " default:\n" 1382 " {\n" 1383 " return true;\n" 1384 " }\n" 1385 "}", 1386 format("switch (n) {\n" 1387 " case 0: {\n" 1388 " return false;\n" 1389 " }\n" 1390 " default:\n" 1391 " {\n" 1392 " return true;\n" 1393 " }\n" 1394 "}", 1395 Style)); 1396 } 1397 1398 TEST_F(FormatTest, FormatsLabels) { 1399 verifyFormat("void f() {\n" 1400 " some_code();\n" 1401 "test_label:\n" 1402 " some_other_code();\n" 1403 " {\n" 1404 " some_more_code();\n" 1405 " another_label:\n" 1406 " some_more_code();\n" 1407 " }\n" 1408 "}"); 1409 verifyFormat("{\n" 1410 " some_code();\n" 1411 "test_label:\n" 1412 " some_other_code();\n" 1413 "}"); 1414 verifyFormat("{\n" 1415 " some_code();\n" 1416 "test_label:;\n" 1417 " int i = 0;\n" 1418 "}"); 1419 FormatStyle Style = getLLVMStyle(); 1420 Style.IndentGotoLabels = false; 1421 verifyFormat("void f() {\n" 1422 " some_code();\n" 1423 "test_label:\n" 1424 " some_other_code();\n" 1425 " {\n" 1426 " some_more_code();\n" 1427 "another_label:\n" 1428 " some_more_code();\n" 1429 " }\n" 1430 "}", 1431 Style); 1432 verifyFormat("{\n" 1433 " some_code();\n" 1434 "test_label:\n" 1435 " some_other_code();\n" 1436 "}", 1437 Style); 1438 verifyFormat("{\n" 1439 " some_code();\n" 1440 "test_label:;\n" 1441 " int i = 0;\n" 1442 "}"); 1443 } 1444 1445 TEST_F(FormatTest, MultiLineControlStatements) { 1446 FormatStyle Style = getLLVMStyle(); 1447 Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom; 1448 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine; 1449 Style.ColumnLimit = 20; 1450 // Short lines should keep opening brace on same line. 1451 EXPECT_EQ("if (foo) {\n" 1452 " bar();\n" 1453 "}", 1454 format("if(foo){bar();}", Style)); 1455 EXPECT_EQ("if (foo) {\n" 1456 " bar();\n" 1457 "} else {\n" 1458 " baz();\n" 1459 "}", 1460 format("if(foo){bar();}else{baz();}", Style)); 1461 EXPECT_EQ("if (foo && bar) {\n" 1462 " baz();\n" 1463 "}", 1464 format("if(foo&&bar){baz();}", Style)); 1465 EXPECT_EQ("if (foo) {\n" 1466 " bar();\n" 1467 "} else if (baz) {\n" 1468 " quux();\n" 1469 "}", 1470 format("if(foo){bar();}else if(baz){quux();}", Style)); 1471 EXPECT_EQ( 1472 "if (foo) {\n" 1473 " bar();\n" 1474 "} else if (baz) {\n" 1475 " quux();\n" 1476 "} else {\n" 1477 " foobar();\n" 1478 "}", 1479 format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style)); 1480 EXPECT_EQ("for (;;) {\n" 1481 " foo();\n" 1482 "}", 1483 format("for(;;){foo();}")); 1484 EXPECT_EQ("while (1) {\n" 1485 " foo();\n" 1486 "}", 1487 format("while(1){foo();}", Style)); 1488 EXPECT_EQ("switch (foo) {\n" 1489 "case bar:\n" 1490 " return;\n" 1491 "}", 1492 format("switch(foo){case bar:return;}", Style)); 1493 EXPECT_EQ("try {\n" 1494 " foo();\n" 1495 "} catch (...) {\n" 1496 " bar();\n" 1497 "}", 1498 format("try{foo();}catch(...){bar();}", Style)); 1499 EXPECT_EQ("do {\n" 1500 " foo();\n" 1501 "} while (bar &&\n" 1502 " baz);", 1503 format("do{foo();}while(bar&&baz);", Style)); 1504 // Long lines should put opening brace on new line. 1505 EXPECT_EQ("if (foo && bar &&\n" 1506 " baz)\n" 1507 "{\n" 1508 " quux();\n" 1509 "}", 1510 format("if(foo&&bar&&baz){quux();}", Style)); 1511 EXPECT_EQ("if (foo && bar &&\n" 1512 " baz)\n" 1513 "{\n" 1514 " quux();\n" 1515 "}", 1516 format("if (foo && bar &&\n" 1517 " baz) {\n" 1518 " quux();\n" 1519 "}", 1520 Style)); 1521 EXPECT_EQ("if (foo) {\n" 1522 " bar();\n" 1523 "} else if (baz ||\n" 1524 " quux)\n" 1525 "{\n" 1526 " foobar();\n" 1527 "}", 1528 format("if(foo){bar();}else if(baz||quux){foobar();}", Style)); 1529 EXPECT_EQ( 1530 "if (foo) {\n" 1531 " bar();\n" 1532 "} else if (baz ||\n" 1533 " quux)\n" 1534 "{\n" 1535 " foobar();\n" 1536 "} else {\n" 1537 " barbaz();\n" 1538 "}", 1539 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1540 Style)); 1541 EXPECT_EQ("for (int i = 0;\n" 1542 " i < 10; ++i)\n" 1543 "{\n" 1544 " foo();\n" 1545 "}", 1546 format("for(int i=0;i<10;++i){foo();}", Style)); 1547 EXPECT_EQ("while (foo || bar ||\n" 1548 " baz)\n" 1549 "{\n" 1550 " quux();\n" 1551 "}", 1552 format("while(foo||bar||baz){quux();}", Style)); 1553 EXPECT_EQ("switch (\n" 1554 " foo = barbaz)\n" 1555 "{\n" 1556 "case quux:\n" 1557 " return;\n" 1558 "}", 1559 format("switch(foo=barbaz){case quux:return;}", Style)); 1560 EXPECT_EQ("try {\n" 1561 " foo();\n" 1562 "} catch (\n" 1563 " Exception &bar)\n" 1564 "{\n" 1565 " baz();\n" 1566 "}", 1567 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1568 } 1569 1570 //===----------------------------------------------------------------------===// 1571 // Tests for classes, namespaces, etc. 1572 //===----------------------------------------------------------------------===// 1573 1574 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1575 verifyFormat("class A {};"); 1576 } 1577 1578 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1579 verifyFormat("class A {\n" 1580 "public:\n" 1581 "public: // comment\n" 1582 "protected:\n" 1583 "private:\n" 1584 " void f() {}\n" 1585 "};"); 1586 verifyFormat("export class A {\n" 1587 "public:\n" 1588 "public: // comment\n" 1589 "protected:\n" 1590 "private:\n" 1591 " void f() {}\n" 1592 "};"); 1593 verifyGoogleFormat("class A {\n" 1594 " public:\n" 1595 " protected:\n" 1596 " private:\n" 1597 " void f() {}\n" 1598 "};"); 1599 verifyGoogleFormat("export class A {\n" 1600 " public:\n" 1601 " protected:\n" 1602 " private:\n" 1603 " void f() {}\n" 1604 "};"); 1605 verifyFormat("class A {\n" 1606 "public slots:\n" 1607 " void f1() {}\n" 1608 "public Q_SLOTS:\n" 1609 " void f2() {}\n" 1610 "protected slots:\n" 1611 " void f3() {}\n" 1612 "protected Q_SLOTS:\n" 1613 " void f4() {}\n" 1614 "private slots:\n" 1615 " void f5() {}\n" 1616 "private Q_SLOTS:\n" 1617 " void f6() {}\n" 1618 "signals:\n" 1619 " void g1();\n" 1620 "Q_SIGNALS:\n" 1621 " void g2();\n" 1622 "};"); 1623 1624 // Don't interpret 'signals' the wrong way. 1625 verifyFormat("signals.set();"); 1626 verifyFormat("for (Signals signals : f()) {\n}"); 1627 verifyFormat("{\n" 1628 " signals.set(); // This needs indentation.\n" 1629 "}"); 1630 verifyFormat("void f() {\n" 1631 "label:\n" 1632 " signals.baz();\n" 1633 "}"); 1634 } 1635 1636 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1637 EXPECT_EQ("class A {\n" 1638 "public:\n" 1639 " void f();\n" 1640 "\n" 1641 "private:\n" 1642 " void g() {}\n" 1643 " // test\n" 1644 "protected:\n" 1645 " int h;\n" 1646 "};", 1647 format("class A {\n" 1648 "public:\n" 1649 "void f();\n" 1650 "private:\n" 1651 "void g() {}\n" 1652 "// test\n" 1653 "protected:\n" 1654 "int h;\n" 1655 "};")); 1656 EXPECT_EQ("class A {\n" 1657 "protected:\n" 1658 "public:\n" 1659 " void f();\n" 1660 "};", 1661 format("class A {\n" 1662 "protected:\n" 1663 "\n" 1664 "public:\n" 1665 "\n" 1666 " void f();\n" 1667 "};")); 1668 1669 // Even ensure proper spacing inside macros. 1670 EXPECT_EQ("#define B \\\n" 1671 " class A { \\\n" 1672 " protected: \\\n" 1673 " public: \\\n" 1674 " void f(); \\\n" 1675 " };", 1676 format("#define B \\\n" 1677 " class A { \\\n" 1678 " protected: \\\n" 1679 " \\\n" 1680 " public: \\\n" 1681 " \\\n" 1682 " void f(); \\\n" 1683 " };", 1684 getGoogleStyle())); 1685 // But don't remove empty lines after macros ending in access specifiers. 1686 EXPECT_EQ("#define A private:\n" 1687 "\n" 1688 "int i;", 1689 format("#define A private:\n" 1690 "\n" 1691 "int i;")); 1692 } 1693 1694 TEST_F(FormatTest, FormatsClasses) { 1695 verifyFormat("class A : public B {};"); 1696 verifyFormat("class A : public ::B {};"); 1697 1698 verifyFormat( 1699 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1700 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1701 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1702 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1703 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1704 verifyFormat( 1705 "class A : public B, public C, public D, public E, public F {};"); 1706 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1707 " public C,\n" 1708 " public D,\n" 1709 " public E,\n" 1710 " public F,\n" 1711 " public G {};"); 1712 1713 verifyFormat("class\n" 1714 " ReallyReallyLongClassName {\n" 1715 " int i;\n" 1716 "};", 1717 getLLVMStyleWithColumns(32)); 1718 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1719 " aaaaaaaaaaaaaaaa> {};"); 1720 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1721 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1722 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1723 verifyFormat("template <class R, class C>\n" 1724 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1725 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1726 verifyFormat("class ::A::B {};"); 1727 } 1728 1729 TEST_F(FormatTest, BreakInheritanceStyle) { 1730 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1731 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1732 FormatStyle::BILS_BeforeComma; 1733 verifyFormat("class MyClass : public X {};", 1734 StyleWithInheritanceBreakBeforeComma); 1735 verifyFormat("class MyClass\n" 1736 " : public X\n" 1737 " , public Y {};", 1738 StyleWithInheritanceBreakBeforeComma); 1739 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1740 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1741 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1742 StyleWithInheritanceBreakBeforeComma); 1743 verifyFormat("struct aaaaaaaaaaaaa\n" 1744 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1745 " aaaaaaaaaaaaaaaa> {};", 1746 StyleWithInheritanceBreakBeforeComma); 1747 1748 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1749 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1750 FormatStyle::BILS_AfterColon; 1751 verifyFormat("class MyClass : public X {};", 1752 StyleWithInheritanceBreakAfterColon); 1753 verifyFormat("class MyClass : public X, public Y {};", 1754 StyleWithInheritanceBreakAfterColon); 1755 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1756 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1757 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1758 StyleWithInheritanceBreakAfterColon); 1759 verifyFormat("struct aaaaaaaaaaaaa :\n" 1760 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1761 " aaaaaaaaaaaaaaaa> {};", 1762 StyleWithInheritanceBreakAfterColon); 1763 } 1764 1765 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1766 verifyFormat("class A {\n} a, b;"); 1767 verifyFormat("struct A {\n} a, b;"); 1768 verifyFormat("union A {\n} a;"); 1769 } 1770 1771 TEST_F(FormatTest, FormatsEnum) { 1772 verifyFormat("enum {\n" 1773 " Zero,\n" 1774 " One = 1,\n" 1775 " Two = One + 1,\n" 1776 " Three = (One + Two),\n" 1777 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1778 " Five = (One, Two, Three, Four, 5)\n" 1779 "};"); 1780 verifyGoogleFormat("enum {\n" 1781 " Zero,\n" 1782 " One = 1,\n" 1783 " Two = One + 1,\n" 1784 " Three = (One + Two),\n" 1785 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1786 " Five = (One, Two, Three, Four, 5)\n" 1787 "};"); 1788 verifyFormat("enum Enum {};"); 1789 verifyFormat("enum {};"); 1790 verifyFormat("enum X E {} d;"); 1791 verifyFormat("enum __attribute__((...)) E {} d;"); 1792 verifyFormat("enum __declspec__((...)) E {} d;"); 1793 verifyFormat("enum {\n" 1794 " Bar = Foo<int, int>::value\n" 1795 "};", 1796 getLLVMStyleWithColumns(30)); 1797 1798 verifyFormat("enum ShortEnum { A, B, C };"); 1799 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1800 1801 EXPECT_EQ("enum KeepEmptyLines {\n" 1802 " ONE,\n" 1803 "\n" 1804 " TWO,\n" 1805 "\n" 1806 " THREE\n" 1807 "}", 1808 format("enum KeepEmptyLines {\n" 1809 " ONE,\n" 1810 "\n" 1811 " TWO,\n" 1812 "\n" 1813 "\n" 1814 " THREE\n" 1815 "}")); 1816 verifyFormat("enum E { // comment\n" 1817 " ONE,\n" 1818 " TWO\n" 1819 "};\n" 1820 "int i;"); 1821 // Not enums. 1822 verifyFormat("enum X f() {\n" 1823 " a();\n" 1824 " return 42;\n" 1825 "}"); 1826 verifyFormat("enum X Type::f() {\n" 1827 " a();\n" 1828 " return 42;\n" 1829 "}"); 1830 verifyFormat("enum ::X f() {\n" 1831 " a();\n" 1832 " return 42;\n" 1833 "}"); 1834 verifyFormat("enum ns::X f() {\n" 1835 " a();\n" 1836 " return 42;\n" 1837 "}"); 1838 } 1839 1840 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1841 verifyFormat("enum Type {\n" 1842 " One = 0; // These semicolons should be commas.\n" 1843 " Two = 1;\n" 1844 "};"); 1845 verifyFormat("namespace n {\n" 1846 "enum Type {\n" 1847 " One,\n" 1848 " Two, // missing };\n" 1849 " int i;\n" 1850 "}\n" 1851 "void g() {}"); 1852 } 1853 1854 TEST_F(FormatTest, FormatsEnumStruct) { 1855 verifyFormat("enum struct {\n" 1856 " Zero,\n" 1857 " One = 1,\n" 1858 " Two = One + 1,\n" 1859 " Three = (One + Two),\n" 1860 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1861 " Five = (One, Two, Three, Four, 5)\n" 1862 "};"); 1863 verifyFormat("enum struct Enum {};"); 1864 verifyFormat("enum struct {};"); 1865 verifyFormat("enum struct X E {} d;"); 1866 verifyFormat("enum struct __attribute__((...)) E {} d;"); 1867 verifyFormat("enum struct __declspec__((...)) E {} d;"); 1868 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1869 } 1870 1871 TEST_F(FormatTest, FormatsEnumClass) { 1872 verifyFormat("enum class {\n" 1873 " Zero,\n" 1874 " One = 1,\n" 1875 " Two = One + 1,\n" 1876 " Three = (One + Two),\n" 1877 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1878 " Five = (One, Two, Three, Four, 5)\n" 1879 "};"); 1880 verifyFormat("enum class Enum {};"); 1881 verifyFormat("enum class {};"); 1882 verifyFormat("enum class X E {} d;"); 1883 verifyFormat("enum class __attribute__((...)) E {} d;"); 1884 verifyFormat("enum class __declspec__((...)) E {} d;"); 1885 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 1886 } 1887 1888 TEST_F(FormatTest, FormatsEnumTypes) { 1889 verifyFormat("enum X : int {\n" 1890 " A, // Force multiple lines.\n" 1891 " B\n" 1892 "};"); 1893 verifyFormat("enum X : int { A, B };"); 1894 verifyFormat("enum X : std::uint32_t { A, B };"); 1895 } 1896 1897 TEST_F(FormatTest, FormatsTypedefEnum) { 1898 FormatStyle Style = getLLVMStyle(); 1899 Style.ColumnLimit = 40; 1900 verifyFormat("typedef enum {} EmptyEnum;"); 1901 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1902 verifyFormat("typedef enum {\n" 1903 " ZERO = 0,\n" 1904 " ONE = 1,\n" 1905 " TWO = 2,\n" 1906 " THREE = 3\n" 1907 "} LongEnum;", 1908 Style); 1909 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1910 Style.BraceWrapping.AfterEnum = true; 1911 verifyFormat("typedef enum {} EmptyEnum;"); 1912 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1913 verifyFormat("typedef enum\n" 1914 "{\n" 1915 " ZERO = 0,\n" 1916 " ONE = 1,\n" 1917 " TWO = 2,\n" 1918 " THREE = 3\n" 1919 "} LongEnum;", 1920 Style); 1921 } 1922 1923 TEST_F(FormatTest, FormatsNSEnums) { 1924 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1925 verifyGoogleFormat( 1926 "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1927 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 1928 " // Information about someDecentlyLongValue.\n" 1929 " someDecentlyLongValue,\n" 1930 " // Information about anotherDecentlyLongValue.\n" 1931 " anotherDecentlyLongValue,\n" 1932 " // Information about aThirdDecentlyLongValue.\n" 1933 " aThirdDecentlyLongValue\n" 1934 "};"); 1935 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n" 1936 " // Information about someDecentlyLongValue.\n" 1937 " someDecentlyLongValue,\n" 1938 " // Information about anotherDecentlyLongValue.\n" 1939 " anotherDecentlyLongValue,\n" 1940 " // Information about aThirdDecentlyLongValue.\n" 1941 " aThirdDecentlyLongValue\n" 1942 "};"); 1943 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 1944 " a = 1,\n" 1945 " b = 2,\n" 1946 " c = 3,\n" 1947 "};"); 1948 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 1949 " a = 1,\n" 1950 " b = 2,\n" 1951 " c = 3,\n" 1952 "};"); 1953 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n" 1954 " a = 1,\n" 1955 " b = 2,\n" 1956 " c = 3,\n" 1957 "};"); 1958 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 1959 " a = 1,\n" 1960 " b = 2,\n" 1961 " c = 3,\n" 1962 "};"); 1963 } 1964 1965 TEST_F(FormatTest, FormatsBitfields) { 1966 verifyFormat("struct Bitfields {\n" 1967 " unsigned sClass : 8;\n" 1968 " unsigned ValueKind : 2;\n" 1969 "};"); 1970 verifyFormat("struct A {\n" 1971 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 1972 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 1973 "};"); 1974 verifyFormat("struct MyStruct {\n" 1975 " uchar data;\n" 1976 " uchar : 8;\n" 1977 " uchar : 8;\n" 1978 " uchar other;\n" 1979 "};"); 1980 } 1981 1982 TEST_F(FormatTest, FormatsNamespaces) { 1983 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 1984 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 1985 1986 verifyFormat("namespace some_namespace {\n" 1987 "class A {};\n" 1988 "void f() { f(); }\n" 1989 "}", 1990 LLVMWithNoNamespaceFix); 1991 verifyFormat("namespace N::inline D {\n" 1992 "class A {};\n" 1993 "void f() { f(); }\n" 1994 "}", 1995 LLVMWithNoNamespaceFix); 1996 verifyFormat("namespace N::inline D::E {\n" 1997 "class A {};\n" 1998 "void f() { f(); }\n" 1999 "}", 2000 LLVMWithNoNamespaceFix); 2001 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n" 2002 "class A {};\n" 2003 "void f() { f(); }\n" 2004 "}", 2005 LLVMWithNoNamespaceFix); 2006 verifyFormat("/* something */ namespace some_namespace {\n" 2007 "class A {};\n" 2008 "void f() { f(); }\n" 2009 "}", 2010 LLVMWithNoNamespaceFix); 2011 verifyFormat("namespace {\n" 2012 "class A {};\n" 2013 "void f() { f(); }\n" 2014 "}", 2015 LLVMWithNoNamespaceFix); 2016 verifyFormat("/* something */ namespace {\n" 2017 "class A {};\n" 2018 "void f() { f(); }\n" 2019 "}", 2020 LLVMWithNoNamespaceFix); 2021 verifyFormat("inline namespace X {\n" 2022 "class A {};\n" 2023 "void f() { f(); }\n" 2024 "}", 2025 LLVMWithNoNamespaceFix); 2026 verifyFormat("/* something */ inline namespace X {\n" 2027 "class A {};\n" 2028 "void f() { f(); }\n" 2029 "}", 2030 LLVMWithNoNamespaceFix); 2031 verifyFormat("export namespace X {\n" 2032 "class A {};\n" 2033 "void f() { f(); }\n" 2034 "}", 2035 LLVMWithNoNamespaceFix); 2036 verifyFormat("using namespace some_namespace;\n" 2037 "class A {};\n" 2038 "void f() { f(); }", 2039 LLVMWithNoNamespaceFix); 2040 2041 // This code is more common than we thought; if we 2042 // layout this correctly the semicolon will go into 2043 // its own line, which is undesirable. 2044 verifyFormat("namespace {};", LLVMWithNoNamespaceFix); 2045 verifyFormat("namespace {\n" 2046 "class A {};\n" 2047 "};", 2048 LLVMWithNoNamespaceFix); 2049 2050 verifyFormat("namespace {\n" 2051 "int SomeVariable = 0; // comment\n" 2052 "} // namespace", 2053 LLVMWithNoNamespaceFix); 2054 EXPECT_EQ("#ifndef HEADER_GUARD\n" 2055 "#define HEADER_GUARD\n" 2056 "namespace my_namespace {\n" 2057 "int i;\n" 2058 "} // my_namespace\n" 2059 "#endif // HEADER_GUARD", 2060 format("#ifndef HEADER_GUARD\n" 2061 " #define HEADER_GUARD\n" 2062 " namespace my_namespace {\n" 2063 "int i;\n" 2064 "} // my_namespace\n" 2065 "#endif // HEADER_GUARD", 2066 LLVMWithNoNamespaceFix)); 2067 2068 EXPECT_EQ("namespace A::B {\n" 2069 "class C {};\n" 2070 "}", 2071 format("namespace A::B {\n" 2072 "class C {};\n" 2073 "}", 2074 LLVMWithNoNamespaceFix)); 2075 2076 FormatStyle Style = getLLVMStyle(); 2077 Style.NamespaceIndentation = FormatStyle::NI_All; 2078 EXPECT_EQ("namespace out {\n" 2079 " int i;\n" 2080 " namespace in {\n" 2081 " int i;\n" 2082 " } // namespace in\n" 2083 "} // namespace out", 2084 format("namespace out {\n" 2085 "int i;\n" 2086 "namespace in {\n" 2087 "int i;\n" 2088 "} // namespace in\n" 2089 "} // namespace out", 2090 Style)); 2091 2092 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2093 EXPECT_EQ("namespace out {\n" 2094 "int i;\n" 2095 "namespace in {\n" 2096 " int i;\n" 2097 "} // namespace in\n" 2098 "} // namespace out", 2099 format("namespace out {\n" 2100 "int i;\n" 2101 "namespace in {\n" 2102 "int i;\n" 2103 "} // namespace in\n" 2104 "} // namespace out", 2105 Style)); 2106 } 2107 2108 TEST_F(FormatTest, NamespaceMacros) { 2109 FormatStyle Style = getLLVMStyle(); 2110 Style.NamespaceMacros.push_back("TESTSUITE"); 2111 2112 verifyFormat("TESTSUITE(A) {\n" 2113 "int foo();\n" 2114 "} // TESTSUITE(A)", 2115 Style); 2116 2117 verifyFormat("TESTSUITE(A, B) {\n" 2118 "int foo();\n" 2119 "} // TESTSUITE(A)", 2120 Style); 2121 2122 // Properly indent according to NamespaceIndentation style 2123 Style.NamespaceIndentation = FormatStyle::NI_All; 2124 verifyFormat("TESTSUITE(A) {\n" 2125 " int foo();\n" 2126 "} // TESTSUITE(A)", 2127 Style); 2128 verifyFormat("TESTSUITE(A) {\n" 2129 " namespace B {\n" 2130 " int foo();\n" 2131 " } // namespace B\n" 2132 "} // TESTSUITE(A)", 2133 Style); 2134 verifyFormat("namespace A {\n" 2135 " TESTSUITE(B) {\n" 2136 " int foo();\n" 2137 " } // TESTSUITE(B)\n" 2138 "} // namespace A", 2139 Style); 2140 2141 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2142 verifyFormat("TESTSUITE(A) {\n" 2143 "TESTSUITE(B) {\n" 2144 " int foo();\n" 2145 "} // TESTSUITE(B)\n" 2146 "} // TESTSUITE(A)", 2147 Style); 2148 verifyFormat("TESTSUITE(A) {\n" 2149 "namespace B {\n" 2150 " int foo();\n" 2151 "} // namespace B\n" 2152 "} // TESTSUITE(A)", 2153 Style); 2154 verifyFormat("namespace A {\n" 2155 "TESTSUITE(B) {\n" 2156 " int foo();\n" 2157 "} // TESTSUITE(B)\n" 2158 "} // namespace A", 2159 Style); 2160 2161 // Properly merge namespace-macros blocks in CompactNamespaces mode 2162 Style.NamespaceIndentation = FormatStyle::NI_None; 2163 Style.CompactNamespaces = true; 2164 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n" 2165 "}} // TESTSUITE(A::B)", 2166 Style); 2167 2168 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2169 "}} // TESTSUITE(out::in)", 2170 format("TESTSUITE(out) {\n" 2171 "TESTSUITE(in) {\n" 2172 "} // TESTSUITE(in)\n" 2173 "} // TESTSUITE(out)", 2174 Style)); 2175 2176 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2177 "}} // TESTSUITE(out::in)", 2178 format("TESTSUITE(out) {\n" 2179 "TESTSUITE(in) {\n" 2180 "} // TESTSUITE(in)\n" 2181 "} // TESTSUITE(out)", 2182 Style)); 2183 2184 // Do not merge different namespaces/macros 2185 EXPECT_EQ("namespace out {\n" 2186 "TESTSUITE(in) {\n" 2187 "} // TESTSUITE(in)\n" 2188 "} // namespace out", 2189 format("namespace out {\n" 2190 "TESTSUITE(in) {\n" 2191 "} // TESTSUITE(in)\n" 2192 "} // namespace out", 2193 Style)); 2194 EXPECT_EQ("TESTSUITE(out) {\n" 2195 "namespace in {\n" 2196 "} // namespace in\n" 2197 "} // TESTSUITE(out)", 2198 format("TESTSUITE(out) {\n" 2199 "namespace in {\n" 2200 "} // namespace in\n" 2201 "} // TESTSUITE(out)", 2202 Style)); 2203 Style.NamespaceMacros.push_back("FOOBAR"); 2204 EXPECT_EQ("TESTSUITE(out) {\n" 2205 "FOOBAR(in) {\n" 2206 "} // FOOBAR(in)\n" 2207 "} // TESTSUITE(out)", 2208 format("TESTSUITE(out) {\n" 2209 "FOOBAR(in) {\n" 2210 "} // FOOBAR(in)\n" 2211 "} // TESTSUITE(out)", 2212 Style)); 2213 } 2214 2215 TEST_F(FormatTest, FormatsCompactNamespaces) { 2216 FormatStyle Style = getLLVMStyle(); 2217 Style.CompactNamespaces = true; 2218 Style.NamespaceMacros.push_back("TESTSUITE"); 2219 2220 verifyFormat("namespace A { namespace B {\n" 2221 "}} // namespace A::B", 2222 Style); 2223 2224 EXPECT_EQ("namespace out { namespace in {\n" 2225 "}} // namespace out::in", 2226 format("namespace out {\n" 2227 "namespace in {\n" 2228 "} // namespace in\n" 2229 "} // namespace out", 2230 Style)); 2231 2232 // Only namespaces which have both consecutive opening and end get compacted 2233 EXPECT_EQ("namespace out {\n" 2234 "namespace in1 {\n" 2235 "} // namespace in1\n" 2236 "namespace in2 {\n" 2237 "} // namespace in2\n" 2238 "} // namespace out", 2239 format("namespace out {\n" 2240 "namespace in1 {\n" 2241 "} // namespace in1\n" 2242 "namespace in2 {\n" 2243 "} // namespace in2\n" 2244 "} // namespace out", 2245 Style)); 2246 2247 EXPECT_EQ("namespace out {\n" 2248 "int i;\n" 2249 "namespace in {\n" 2250 "int j;\n" 2251 "} // namespace in\n" 2252 "int k;\n" 2253 "} // namespace out", 2254 format("namespace out { int i;\n" 2255 "namespace in { int j; } // namespace in\n" 2256 "int k; } // namespace out", 2257 Style)); 2258 2259 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 2260 "}}} // namespace A::B::C\n", 2261 format("namespace A { namespace B {\n" 2262 "namespace C {\n" 2263 "}} // namespace B::C\n" 2264 "} // namespace A\n", 2265 Style)); 2266 2267 Style.ColumnLimit = 40; 2268 EXPECT_EQ("namespace aaaaaaaaaa {\n" 2269 "namespace bbbbbbbbbb {\n" 2270 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 2271 format("namespace aaaaaaaaaa {\n" 2272 "namespace bbbbbbbbbb {\n" 2273 "} // namespace bbbbbbbbbb\n" 2274 "} // namespace aaaaaaaaaa", 2275 Style)); 2276 2277 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 2278 "namespace cccccc {\n" 2279 "}}} // namespace aaaaaa::bbbbbb::cccccc", 2280 format("namespace aaaaaa {\n" 2281 "namespace bbbbbb {\n" 2282 "namespace cccccc {\n" 2283 "} // namespace cccccc\n" 2284 "} // namespace bbbbbb\n" 2285 "} // namespace aaaaaa", 2286 Style)); 2287 Style.ColumnLimit = 80; 2288 2289 // Extra semicolon after 'inner' closing brace prevents merging 2290 EXPECT_EQ("namespace out { namespace in {\n" 2291 "}; } // namespace out::in", 2292 format("namespace out {\n" 2293 "namespace in {\n" 2294 "}; // namespace in\n" 2295 "} // namespace out", 2296 Style)); 2297 2298 // Extra semicolon after 'outer' closing brace is conserved 2299 EXPECT_EQ("namespace out { namespace in {\n" 2300 "}}; // namespace out::in", 2301 format("namespace out {\n" 2302 "namespace in {\n" 2303 "} // namespace in\n" 2304 "}; // namespace out", 2305 Style)); 2306 2307 Style.NamespaceIndentation = FormatStyle::NI_All; 2308 EXPECT_EQ("namespace out { namespace in {\n" 2309 " int i;\n" 2310 "}} // namespace out::in", 2311 format("namespace out {\n" 2312 "namespace in {\n" 2313 "int i;\n" 2314 "} // namespace in\n" 2315 "} // namespace out", 2316 Style)); 2317 EXPECT_EQ("namespace out { namespace mid {\n" 2318 " namespace in {\n" 2319 " int j;\n" 2320 " } // namespace in\n" 2321 " int k;\n" 2322 "}} // namespace out::mid", 2323 format("namespace out { namespace mid {\n" 2324 "namespace in { int j; } // namespace in\n" 2325 "int k; }} // namespace out::mid", 2326 Style)); 2327 2328 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2329 EXPECT_EQ("namespace out { namespace in {\n" 2330 " int i;\n" 2331 "}} // namespace out::in", 2332 format("namespace out {\n" 2333 "namespace in {\n" 2334 "int i;\n" 2335 "} // namespace in\n" 2336 "} // namespace out", 2337 Style)); 2338 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 2339 " int i;\n" 2340 "}}} // namespace out::mid::in", 2341 format("namespace out {\n" 2342 "namespace mid {\n" 2343 "namespace in {\n" 2344 "int i;\n" 2345 "} // namespace in\n" 2346 "} // namespace mid\n" 2347 "} // namespace out", 2348 Style)); 2349 } 2350 2351 TEST_F(FormatTest, FormatsExternC) { 2352 verifyFormat("extern \"C\" {\nint a;"); 2353 verifyFormat("extern \"C\" {}"); 2354 verifyFormat("extern \"C\" {\n" 2355 "int foo();\n" 2356 "}"); 2357 verifyFormat("extern \"C\" int foo() {}"); 2358 verifyFormat("extern \"C\" int foo();"); 2359 verifyFormat("extern \"C\" int foo() {\n" 2360 " int i = 42;\n" 2361 " return i;\n" 2362 "}"); 2363 2364 FormatStyle Style = getLLVMStyle(); 2365 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2366 Style.BraceWrapping.AfterFunction = true; 2367 verifyFormat("extern \"C\" int foo() {}", Style); 2368 verifyFormat("extern \"C\" int foo();", Style); 2369 verifyFormat("extern \"C\" int foo()\n" 2370 "{\n" 2371 " int i = 42;\n" 2372 " return i;\n" 2373 "}", 2374 Style); 2375 2376 Style.BraceWrapping.AfterExternBlock = true; 2377 Style.BraceWrapping.SplitEmptyRecord = false; 2378 verifyFormat("extern \"C\"\n" 2379 "{}", 2380 Style); 2381 verifyFormat("extern \"C\"\n" 2382 "{\n" 2383 " int foo();\n" 2384 "}", 2385 Style); 2386 } 2387 2388 TEST_F(FormatTest, FormatsInlineASM) { 2389 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2390 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2391 verifyFormat( 2392 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2393 " \"cpuid\\n\\t\"\n" 2394 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2395 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2396 " : \"a\"(value));"); 2397 EXPECT_EQ( 2398 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2399 " __asm {\n" 2400 " mov edx,[that] // vtable in edx\n" 2401 " mov eax,methodIndex\n" 2402 " call [edx][eax*4] // stdcall\n" 2403 " }\n" 2404 "}", 2405 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2406 " __asm {\n" 2407 " mov edx,[that] // vtable in edx\n" 2408 " mov eax,methodIndex\n" 2409 " call [edx][eax*4] // stdcall\n" 2410 " }\n" 2411 "}")); 2412 EXPECT_EQ("_asm {\n" 2413 " xor eax, eax;\n" 2414 " cpuid;\n" 2415 "}", 2416 format("_asm {\n" 2417 " xor eax, eax;\n" 2418 " cpuid;\n" 2419 "}")); 2420 verifyFormat("void function() {\n" 2421 " // comment\n" 2422 " asm(\"\");\n" 2423 "}"); 2424 EXPECT_EQ("__asm {\n" 2425 "}\n" 2426 "int i;", 2427 format("__asm {\n" 2428 "}\n" 2429 "int i;")); 2430 } 2431 2432 TEST_F(FormatTest, FormatTryCatch) { 2433 verifyFormat("try {\n" 2434 " throw a * b;\n" 2435 "} catch (int a) {\n" 2436 " // Do nothing.\n" 2437 "} catch (...) {\n" 2438 " exit(42);\n" 2439 "}"); 2440 2441 // Function-level try statements. 2442 verifyFormat("int f() try { return 4; } catch (...) {\n" 2443 " return 5;\n" 2444 "}"); 2445 verifyFormat("class A {\n" 2446 " int a;\n" 2447 " A() try : a(0) {\n" 2448 " } catch (...) {\n" 2449 " throw;\n" 2450 " }\n" 2451 "};\n"); 2452 2453 // Incomplete try-catch blocks. 2454 verifyIncompleteFormat("try {} catch ("); 2455 } 2456 2457 TEST_F(FormatTest, FormatSEHTryCatch) { 2458 verifyFormat("__try {\n" 2459 " int a = b * c;\n" 2460 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2461 " // Do nothing.\n" 2462 "}"); 2463 2464 verifyFormat("__try {\n" 2465 " int a = b * c;\n" 2466 "} __finally {\n" 2467 " // Do nothing.\n" 2468 "}"); 2469 2470 verifyFormat("DEBUG({\n" 2471 " __try {\n" 2472 " } __finally {\n" 2473 " }\n" 2474 "});\n"); 2475 } 2476 2477 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2478 verifyFormat("try {\n" 2479 " f();\n" 2480 "} catch {\n" 2481 " g();\n" 2482 "}"); 2483 verifyFormat("try {\n" 2484 " f();\n" 2485 "} catch (A a) MACRO(x) {\n" 2486 " g();\n" 2487 "} catch (B b) MACRO(x) {\n" 2488 " g();\n" 2489 "}"); 2490 } 2491 2492 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2493 FormatStyle Style = getLLVMStyle(); 2494 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2495 FormatStyle::BS_WebKit}) { 2496 Style.BreakBeforeBraces = BraceStyle; 2497 verifyFormat("try {\n" 2498 " // something\n" 2499 "} catch (...) {\n" 2500 " // something\n" 2501 "}", 2502 Style); 2503 } 2504 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2505 verifyFormat("try {\n" 2506 " // something\n" 2507 "}\n" 2508 "catch (...) {\n" 2509 " // something\n" 2510 "}", 2511 Style); 2512 verifyFormat("__try {\n" 2513 " // something\n" 2514 "}\n" 2515 "__finally {\n" 2516 " // something\n" 2517 "}", 2518 Style); 2519 verifyFormat("@try {\n" 2520 " // something\n" 2521 "}\n" 2522 "@finally {\n" 2523 " // something\n" 2524 "}", 2525 Style); 2526 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2527 verifyFormat("try\n" 2528 "{\n" 2529 " // something\n" 2530 "}\n" 2531 "catch (...)\n" 2532 "{\n" 2533 " // something\n" 2534 "}", 2535 Style); 2536 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 2537 verifyFormat("try\n" 2538 " {\n" 2539 " // something white\n" 2540 " }\n" 2541 "catch (...)\n" 2542 " {\n" 2543 " // something white\n" 2544 " }", 2545 Style); 2546 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2547 verifyFormat("try\n" 2548 " {\n" 2549 " // something\n" 2550 " }\n" 2551 "catch (...)\n" 2552 " {\n" 2553 " // something\n" 2554 " }", 2555 Style); 2556 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2557 Style.BraceWrapping.BeforeCatch = true; 2558 verifyFormat("try {\n" 2559 " // something\n" 2560 "}\n" 2561 "catch (...) {\n" 2562 " // something\n" 2563 "}", 2564 Style); 2565 } 2566 2567 TEST_F(FormatTest, StaticInitializers) { 2568 verifyFormat("static SomeClass SC = {1, 'a'};"); 2569 2570 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2571 " 100000000, " 2572 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2573 2574 // Here, everything other than the "}" would fit on a line. 2575 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2576 " 10000000000000000000000000};"); 2577 EXPECT_EQ("S s = {a,\n" 2578 "\n" 2579 " b};", 2580 format("S s = {\n" 2581 " a,\n" 2582 "\n" 2583 " b\n" 2584 "};")); 2585 2586 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2587 // line. However, the formatting looks a bit off and this probably doesn't 2588 // happen often in practice. 2589 verifyFormat("static int Variable[1] = {\n" 2590 " {1000000000000000000000000000000000000}};", 2591 getLLVMStyleWithColumns(40)); 2592 } 2593 2594 TEST_F(FormatTest, DesignatedInitializers) { 2595 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2596 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2597 " .bbbbbbbbbb = 2,\n" 2598 " .cccccccccc = 3,\n" 2599 " .dddddddddd = 4,\n" 2600 " .eeeeeeeeee = 5};"); 2601 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2602 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2603 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2604 " .ccccccccccccccccccccccccccc = 3,\n" 2605 " .ddddddddddddddddddddddddddd = 4,\n" 2606 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2607 2608 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2609 2610 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2611 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2612 " [2] = bbbbbbbbbb,\n" 2613 " [3] = cccccccccc,\n" 2614 " [4] = dddddddddd,\n" 2615 " [5] = eeeeeeeeee};"); 2616 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2617 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2618 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2619 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2620 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2621 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2622 } 2623 2624 TEST_F(FormatTest, NestedStaticInitializers) { 2625 verifyFormat("static A x = {{{}}};\n"); 2626 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2627 " {init1, init2, init3, init4}}};", 2628 getLLVMStyleWithColumns(50)); 2629 2630 verifyFormat("somes Status::global_reps[3] = {\n" 2631 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2632 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2633 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2634 getLLVMStyleWithColumns(60)); 2635 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2636 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2637 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2638 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2639 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2640 " {rect.fRight - rect.fLeft, rect.fBottom - " 2641 "rect.fTop}};"); 2642 2643 verifyFormat( 2644 "SomeArrayOfSomeType a = {\n" 2645 " {{1, 2, 3},\n" 2646 " {1, 2, 3},\n" 2647 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2648 " 333333333333333333333333333333},\n" 2649 " {1, 2, 3},\n" 2650 " {1, 2, 3}}};"); 2651 verifyFormat( 2652 "SomeArrayOfSomeType a = {\n" 2653 " {{1, 2, 3}},\n" 2654 " {{1, 2, 3}},\n" 2655 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2656 " 333333333333333333333333333333}},\n" 2657 " {{1, 2, 3}},\n" 2658 " {{1, 2, 3}}};"); 2659 2660 verifyFormat("struct {\n" 2661 " unsigned bit;\n" 2662 " const char *const name;\n" 2663 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2664 " {kOsWin, \"Windows\"},\n" 2665 " {kOsLinux, \"Linux\"},\n" 2666 " {kOsCrOS, \"Chrome OS\"}};"); 2667 verifyFormat("struct {\n" 2668 " unsigned bit;\n" 2669 " const char *const name;\n" 2670 "} kBitsToOs[] = {\n" 2671 " {kOsMac, \"Mac\"},\n" 2672 " {kOsWin, \"Windows\"},\n" 2673 " {kOsLinux, \"Linux\"},\n" 2674 " {kOsCrOS, \"Chrome OS\"},\n" 2675 "};"); 2676 } 2677 2678 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2679 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2680 " \\\n" 2681 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2682 } 2683 2684 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2685 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2686 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2687 2688 // Do break defaulted and deleted functions. 2689 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2690 " default;", 2691 getLLVMStyleWithColumns(40)); 2692 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2693 " delete;", 2694 getLLVMStyleWithColumns(40)); 2695 } 2696 2697 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2698 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2699 getLLVMStyleWithColumns(40)); 2700 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2701 getLLVMStyleWithColumns(40)); 2702 EXPECT_EQ("#define Q \\\n" 2703 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2704 " \"aaaaaaaa.cpp\"", 2705 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2706 getLLVMStyleWithColumns(40))); 2707 } 2708 2709 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2710 EXPECT_EQ("# 123 \"A string literal\"", 2711 format(" # 123 \"A string literal\"")); 2712 } 2713 2714 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2715 EXPECT_EQ("#;", format("#;")); 2716 verifyFormat("#\n;\n;\n;"); 2717 } 2718 2719 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2720 EXPECT_EQ("#line 42 \"test\"\n", 2721 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2722 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2723 getLLVMStyleWithColumns(12))); 2724 } 2725 2726 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2727 EXPECT_EQ("#line 42 \"test\"", 2728 format("# \\\n line \\\n 42 \\\n \"test\"")); 2729 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2730 } 2731 2732 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2733 verifyFormat("#define A \\x20"); 2734 verifyFormat("#define A \\ x20"); 2735 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2736 verifyFormat("#define A ''"); 2737 verifyFormat("#define A ''qqq"); 2738 verifyFormat("#define A `qqq"); 2739 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2740 EXPECT_EQ("const char *c = STRINGIFY(\n" 2741 "\\na : b);", 2742 format("const char * c = STRINGIFY(\n" 2743 "\\na : b);")); 2744 2745 verifyFormat("a\r\\"); 2746 verifyFormat("a\v\\"); 2747 verifyFormat("a\f\\"); 2748 } 2749 2750 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2751 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2752 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2753 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2754 // FIXME: We never break before the macro name. 2755 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2756 2757 verifyFormat("#define A A\n#define A A"); 2758 verifyFormat("#define A(X) A\n#define A A"); 2759 2760 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2761 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2762 } 2763 2764 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2765 EXPECT_EQ("// somecomment\n" 2766 "#include \"a.h\"\n" 2767 "#define A( \\\n" 2768 " A, B)\n" 2769 "#include \"b.h\"\n" 2770 "// somecomment\n", 2771 format(" // somecomment\n" 2772 " #include \"a.h\"\n" 2773 "#define A(A,\\\n" 2774 " B)\n" 2775 " #include \"b.h\"\n" 2776 " // somecomment\n", 2777 getLLVMStyleWithColumns(13))); 2778 } 2779 2780 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2781 2782 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2783 EXPECT_EQ("#define A \\\n" 2784 " c; \\\n" 2785 " e;\n" 2786 "f;", 2787 format("#define A c; e;\n" 2788 "f;", 2789 getLLVMStyleWithColumns(14))); 2790 } 2791 2792 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2793 2794 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2795 EXPECT_EQ("int x,\n" 2796 "#define A\n" 2797 " y;", 2798 format("int x,\n#define A\ny;")); 2799 } 2800 2801 TEST_F(FormatTest, HashInMacroDefinition) { 2802 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2803 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2804 verifyFormat("#define A \\\n" 2805 " { \\\n" 2806 " f(#c); \\\n" 2807 " }", 2808 getLLVMStyleWithColumns(11)); 2809 2810 verifyFormat("#define A(X) \\\n" 2811 " void function##X()", 2812 getLLVMStyleWithColumns(22)); 2813 2814 verifyFormat("#define A(a, b, c) \\\n" 2815 " void a##b##c()", 2816 getLLVMStyleWithColumns(22)); 2817 2818 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2819 } 2820 2821 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2822 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2823 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2824 2825 FormatStyle Style = getLLVMStyle(); 2826 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 2827 verifyFormat("#define true ((foo)1)", Style); 2828 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 2829 verifyFormat("#define false((foo)0)", Style); 2830 } 2831 2832 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2833 EXPECT_EQ("#define A b;", format("#define A \\\n" 2834 " \\\n" 2835 " b;", 2836 getLLVMStyleWithColumns(25))); 2837 EXPECT_EQ("#define A \\\n" 2838 " \\\n" 2839 " a; \\\n" 2840 " b;", 2841 format("#define A \\\n" 2842 " \\\n" 2843 " a; \\\n" 2844 " b;", 2845 getLLVMStyleWithColumns(11))); 2846 EXPECT_EQ("#define A \\\n" 2847 " a; \\\n" 2848 " \\\n" 2849 " b;", 2850 format("#define A \\\n" 2851 " a; \\\n" 2852 " \\\n" 2853 " b;", 2854 getLLVMStyleWithColumns(11))); 2855 } 2856 2857 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 2858 verifyIncompleteFormat("#define A :"); 2859 verifyFormat("#define SOMECASES \\\n" 2860 " case 1: \\\n" 2861 " case 2\n", 2862 getLLVMStyleWithColumns(20)); 2863 verifyFormat("#define MACRO(a) \\\n" 2864 " if (a) \\\n" 2865 " f(); \\\n" 2866 " else \\\n" 2867 " g()", 2868 getLLVMStyleWithColumns(18)); 2869 verifyFormat("#define A template <typename T>"); 2870 verifyIncompleteFormat("#define STR(x) #x\n" 2871 "f(STR(this_is_a_string_literal{));"); 2872 verifyFormat("#pragma omp threadprivate( \\\n" 2873 " y)), // expected-warning", 2874 getLLVMStyleWithColumns(28)); 2875 verifyFormat("#d, = };"); 2876 verifyFormat("#if \"a"); 2877 verifyIncompleteFormat("({\n" 2878 "#define b \\\n" 2879 " } \\\n" 2880 " a\n" 2881 "a", 2882 getLLVMStyleWithColumns(15)); 2883 verifyFormat("#define A \\\n" 2884 " { \\\n" 2885 " {\n" 2886 "#define B \\\n" 2887 " } \\\n" 2888 " }", 2889 getLLVMStyleWithColumns(15)); 2890 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 2891 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 2892 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 2893 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 2894 } 2895 2896 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 2897 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 2898 EXPECT_EQ("class A : public QObject {\n" 2899 " Q_OBJECT\n" 2900 "\n" 2901 " A() {}\n" 2902 "};", 2903 format("class A : public QObject {\n" 2904 " Q_OBJECT\n" 2905 "\n" 2906 " A() {\n}\n" 2907 "} ;")); 2908 EXPECT_EQ("MACRO\n" 2909 "/*static*/ int i;", 2910 format("MACRO\n" 2911 " /*static*/ int i;")); 2912 EXPECT_EQ("SOME_MACRO\n" 2913 "namespace {\n" 2914 "void f();\n" 2915 "} // namespace", 2916 format("SOME_MACRO\n" 2917 " namespace {\n" 2918 "void f( );\n" 2919 "} // namespace")); 2920 // Only if the identifier contains at least 5 characters. 2921 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 2922 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 2923 // Only if everything is upper case. 2924 EXPECT_EQ("class A : public QObject {\n" 2925 " Q_Object A() {}\n" 2926 "};", 2927 format("class A : public QObject {\n" 2928 " Q_Object\n" 2929 " A() {\n}\n" 2930 "} ;")); 2931 2932 // Only if the next line can actually start an unwrapped line. 2933 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 2934 format("SOME_WEIRD_LOG_MACRO\n" 2935 "<< SomeThing;")); 2936 2937 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 2938 "(n, buffers))\n", 2939 getChromiumStyle(FormatStyle::LK_Cpp)); 2940 2941 // See PR41483 2942 EXPECT_EQ("/**/ FOO(a)\n" 2943 "FOO(b)", 2944 format("/**/ FOO(a)\n" 2945 "FOO(b)")); 2946 } 2947 2948 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 2949 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2950 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2951 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2952 "class X {};\n" 2953 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2954 "int *createScopDetectionPass() { return 0; }", 2955 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2956 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2957 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2958 " class X {};\n" 2959 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2960 " int *createScopDetectionPass() { return 0; }")); 2961 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 2962 // braces, so that inner block is indented one level more. 2963 EXPECT_EQ("int q() {\n" 2964 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2965 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2966 " IPC_END_MESSAGE_MAP()\n" 2967 "}", 2968 format("int q() {\n" 2969 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2970 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2971 " IPC_END_MESSAGE_MAP()\n" 2972 "}")); 2973 2974 // Same inside macros. 2975 EXPECT_EQ("#define LIST(L) \\\n" 2976 " L(A) \\\n" 2977 " L(B) \\\n" 2978 " L(C)", 2979 format("#define LIST(L) \\\n" 2980 " L(A) \\\n" 2981 " L(B) \\\n" 2982 " L(C)", 2983 getGoogleStyle())); 2984 2985 // These must not be recognized as macros. 2986 EXPECT_EQ("int q() {\n" 2987 " f(x);\n" 2988 " f(x) {}\n" 2989 " f(x)->g();\n" 2990 " f(x)->*g();\n" 2991 " f(x).g();\n" 2992 " f(x) = x;\n" 2993 " f(x) += x;\n" 2994 " f(x) -= x;\n" 2995 " f(x) *= x;\n" 2996 " f(x) /= x;\n" 2997 " f(x) %= x;\n" 2998 " f(x) &= x;\n" 2999 " f(x) |= x;\n" 3000 " f(x) ^= x;\n" 3001 " f(x) >>= x;\n" 3002 " f(x) <<= x;\n" 3003 " f(x)[y].z();\n" 3004 " LOG(INFO) << x;\n" 3005 " ifstream(x) >> x;\n" 3006 "}\n", 3007 format("int q() {\n" 3008 " f(x)\n;\n" 3009 " f(x)\n {}\n" 3010 " f(x)\n->g();\n" 3011 " f(x)\n->*g();\n" 3012 " f(x)\n.g();\n" 3013 " f(x)\n = x;\n" 3014 " f(x)\n += x;\n" 3015 " f(x)\n -= x;\n" 3016 " f(x)\n *= x;\n" 3017 " f(x)\n /= x;\n" 3018 " f(x)\n %= x;\n" 3019 " f(x)\n &= x;\n" 3020 " f(x)\n |= x;\n" 3021 " f(x)\n ^= x;\n" 3022 " f(x)\n >>= x;\n" 3023 " f(x)\n <<= x;\n" 3024 " f(x)\n[y].z();\n" 3025 " LOG(INFO)\n << x;\n" 3026 " ifstream(x)\n >> x;\n" 3027 "}\n")); 3028 EXPECT_EQ("int q() {\n" 3029 " F(x)\n" 3030 " if (1) {\n" 3031 " }\n" 3032 " F(x)\n" 3033 " while (1) {\n" 3034 " }\n" 3035 " F(x)\n" 3036 " G(x);\n" 3037 " F(x)\n" 3038 " try {\n" 3039 " Q();\n" 3040 " } catch (...) {\n" 3041 " }\n" 3042 "}\n", 3043 format("int q() {\n" 3044 "F(x)\n" 3045 "if (1) {}\n" 3046 "F(x)\n" 3047 "while (1) {}\n" 3048 "F(x)\n" 3049 "G(x);\n" 3050 "F(x)\n" 3051 "try { Q(); } catch (...) {}\n" 3052 "}\n")); 3053 EXPECT_EQ("class A {\n" 3054 " A() : t(0) {}\n" 3055 " A(int i) noexcept() : {}\n" 3056 " A(X x)\n" // FIXME: function-level try blocks are broken. 3057 " try : t(0) {\n" 3058 " } catch (...) {\n" 3059 " }\n" 3060 "};", 3061 format("class A {\n" 3062 " A()\n : t(0) {}\n" 3063 " A(int i)\n noexcept() : {}\n" 3064 " A(X x)\n" 3065 " try : t(0) {} catch (...) {}\n" 3066 "};")); 3067 FormatStyle Style = getLLVMStyle(); 3068 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 3069 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 3070 Style.BraceWrapping.AfterFunction = true; 3071 EXPECT_EQ("void f()\n" 3072 "try\n" 3073 "{\n" 3074 "}", 3075 format("void f() try {\n" 3076 "}", 3077 Style)); 3078 EXPECT_EQ("class SomeClass {\n" 3079 "public:\n" 3080 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3081 "};", 3082 format("class SomeClass {\n" 3083 "public:\n" 3084 " SomeClass()\n" 3085 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3086 "};")); 3087 EXPECT_EQ("class SomeClass {\n" 3088 "public:\n" 3089 " SomeClass()\n" 3090 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3091 "};", 3092 format("class SomeClass {\n" 3093 "public:\n" 3094 " SomeClass()\n" 3095 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3096 "};", 3097 getLLVMStyleWithColumns(40))); 3098 3099 verifyFormat("MACRO(>)"); 3100 3101 // Some macros contain an implicit semicolon. 3102 Style = getLLVMStyle(); 3103 Style.StatementMacros.push_back("FOO"); 3104 verifyFormat("FOO(a) int b = 0;"); 3105 verifyFormat("FOO(a)\n" 3106 "int b = 0;", 3107 Style); 3108 verifyFormat("FOO(a);\n" 3109 "int b = 0;", 3110 Style); 3111 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 3112 "int b = 0;", 3113 Style); 3114 verifyFormat("FOO()\n" 3115 "int b = 0;", 3116 Style); 3117 verifyFormat("FOO\n" 3118 "int b = 0;", 3119 Style); 3120 verifyFormat("void f() {\n" 3121 " FOO(a)\n" 3122 " return a;\n" 3123 "}", 3124 Style); 3125 verifyFormat("FOO(a)\n" 3126 "FOO(b)", 3127 Style); 3128 verifyFormat("int a = 0;\n" 3129 "FOO(b)\n" 3130 "int c = 0;", 3131 Style); 3132 verifyFormat("int a = 0;\n" 3133 "int x = FOO(a)\n" 3134 "int b = 0;", 3135 Style); 3136 verifyFormat("void foo(int a) { FOO(a) }\n" 3137 "uint32_t bar() {}", 3138 Style); 3139 } 3140 3141 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 3142 verifyFormat("#define A \\\n" 3143 " f({ \\\n" 3144 " g(); \\\n" 3145 " });", 3146 getLLVMStyleWithColumns(11)); 3147 } 3148 3149 TEST_F(FormatTest, IndentPreprocessorDirectives) { 3150 FormatStyle Style = getLLVMStyle(); 3151 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 3152 Style.ColumnLimit = 40; 3153 verifyFormat("#ifdef _WIN32\n" 3154 "#define A 0\n" 3155 "#ifdef VAR2\n" 3156 "#define B 1\n" 3157 "#include <someheader.h>\n" 3158 "#define MACRO \\\n" 3159 " some_very_long_func_aaaaaaaaaa();\n" 3160 "#endif\n" 3161 "#else\n" 3162 "#define A 1\n" 3163 "#endif", 3164 Style); 3165 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 3166 verifyFormat("#ifdef _WIN32\n" 3167 "# define A 0\n" 3168 "# ifdef VAR2\n" 3169 "# define B 1\n" 3170 "# include <someheader.h>\n" 3171 "# define MACRO \\\n" 3172 " some_very_long_func_aaaaaaaaaa();\n" 3173 "# endif\n" 3174 "#else\n" 3175 "# define A 1\n" 3176 "#endif", 3177 Style); 3178 verifyFormat("#if A\n" 3179 "# define MACRO \\\n" 3180 " void a(int x) { \\\n" 3181 " b(); \\\n" 3182 " c(); \\\n" 3183 " d(); \\\n" 3184 " e(); \\\n" 3185 " f(); \\\n" 3186 " }\n" 3187 "#endif", 3188 Style); 3189 // Comments before include guard. 3190 verifyFormat("// file comment\n" 3191 "// file comment\n" 3192 "#ifndef HEADER_H\n" 3193 "#define HEADER_H\n" 3194 "code();\n" 3195 "#endif", 3196 Style); 3197 // Test with include guards. 3198 verifyFormat("#ifndef HEADER_H\n" 3199 "#define HEADER_H\n" 3200 "code();\n" 3201 "#endif", 3202 Style); 3203 // Include guards must have a #define with the same variable immediately 3204 // after #ifndef. 3205 verifyFormat("#ifndef NOT_GUARD\n" 3206 "# define FOO\n" 3207 "code();\n" 3208 "#endif", 3209 Style); 3210 3211 // Include guards must cover the entire file. 3212 verifyFormat("code();\n" 3213 "code();\n" 3214 "#ifndef NOT_GUARD\n" 3215 "# define NOT_GUARD\n" 3216 "code();\n" 3217 "#endif", 3218 Style); 3219 verifyFormat("#ifndef NOT_GUARD\n" 3220 "# define NOT_GUARD\n" 3221 "code();\n" 3222 "#endif\n" 3223 "code();", 3224 Style); 3225 // Test with trailing blank lines. 3226 verifyFormat("#ifndef HEADER_H\n" 3227 "#define HEADER_H\n" 3228 "code();\n" 3229 "#endif\n", 3230 Style); 3231 // Include guards don't have #else. 3232 verifyFormat("#ifndef NOT_GUARD\n" 3233 "# define NOT_GUARD\n" 3234 "code();\n" 3235 "#else\n" 3236 "#endif", 3237 Style); 3238 verifyFormat("#ifndef NOT_GUARD\n" 3239 "# define NOT_GUARD\n" 3240 "code();\n" 3241 "#elif FOO\n" 3242 "#endif", 3243 Style); 3244 // Non-identifier #define after potential include guard. 3245 verifyFormat("#ifndef FOO\n" 3246 "# define 1\n" 3247 "#endif\n", 3248 Style); 3249 // #if closes past last non-preprocessor line. 3250 verifyFormat("#ifndef FOO\n" 3251 "#define FOO\n" 3252 "#if 1\n" 3253 "int i;\n" 3254 "# define A 0\n" 3255 "#endif\n" 3256 "#endif\n", 3257 Style); 3258 // Don't crash if there is an #elif directive without a condition. 3259 verifyFormat("#if 1\n" 3260 "int x;\n" 3261 "#elif\n" 3262 "int y;\n" 3263 "#else\n" 3264 "int z;\n" 3265 "#endif", 3266 Style); 3267 // FIXME: This doesn't handle the case where there's code between the 3268 // #ifndef and #define but all other conditions hold. This is because when 3269 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 3270 // previous code line yet, so we can't detect it. 3271 EXPECT_EQ("#ifndef NOT_GUARD\n" 3272 "code();\n" 3273 "#define NOT_GUARD\n" 3274 "code();\n" 3275 "#endif", 3276 format("#ifndef NOT_GUARD\n" 3277 "code();\n" 3278 "# define NOT_GUARD\n" 3279 "code();\n" 3280 "#endif", 3281 Style)); 3282 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 3283 // be outside an include guard. Examples are #pragma once and 3284 // #pragma GCC diagnostic, or anything else that does not change the meaning 3285 // of the file if it's included multiple times. 3286 EXPECT_EQ("#ifdef WIN32\n" 3287 "# pragma once\n" 3288 "#endif\n" 3289 "#ifndef HEADER_H\n" 3290 "# define HEADER_H\n" 3291 "code();\n" 3292 "#endif", 3293 format("#ifdef WIN32\n" 3294 "# pragma once\n" 3295 "#endif\n" 3296 "#ifndef HEADER_H\n" 3297 "#define HEADER_H\n" 3298 "code();\n" 3299 "#endif", 3300 Style)); 3301 // FIXME: This does not detect when there is a single non-preprocessor line 3302 // in front of an include-guard-like structure where other conditions hold 3303 // because ScopedLineState hides the line. 3304 EXPECT_EQ("code();\n" 3305 "#ifndef HEADER_H\n" 3306 "#define HEADER_H\n" 3307 "code();\n" 3308 "#endif", 3309 format("code();\n" 3310 "#ifndef HEADER_H\n" 3311 "# define HEADER_H\n" 3312 "code();\n" 3313 "#endif", 3314 Style)); 3315 // Keep comments aligned with #, otherwise indent comments normally. These 3316 // tests cannot use verifyFormat because messUp manipulates leading 3317 // whitespace. 3318 { 3319 const char *Expected = "" 3320 "void f() {\n" 3321 "#if 1\n" 3322 "// Preprocessor aligned.\n" 3323 "# define A 0\n" 3324 " // Code. Separated by blank line.\n" 3325 "\n" 3326 "# define B 0\n" 3327 " // Code. Not aligned with #\n" 3328 "# define C 0\n" 3329 "#endif"; 3330 const char *ToFormat = "" 3331 "void f() {\n" 3332 "#if 1\n" 3333 "// Preprocessor aligned.\n" 3334 "# define A 0\n" 3335 "// Code. Separated by blank line.\n" 3336 "\n" 3337 "# define B 0\n" 3338 " // Code. Not aligned with #\n" 3339 "# define C 0\n" 3340 "#endif"; 3341 EXPECT_EQ(Expected, format(ToFormat, Style)); 3342 EXPECT_EQ(Expected, format(Expected, Style)); 3343 } 3344 // Keep block quotes aligned. 3345 { 3346 const char *Expected = "" 3347 "void f() {\n" 3348 "#if 1\n" 3349 "/* Preprocessor aligned. */\n" 3350 "# define A 0\n" 3351 " /* Code. Separated by blank line. */\n" 3352 "\n" 3353 "# define B 0\n" 3354 " /* Code. Not aligned with # */\n" 3355 "# define C 0\n" 3356 "#endif"; 3357 const char *ToFormat = "" 3358 "void f() {\n" 3359 "#if 1\n" 3360 "/* Preprocessor aligned. */\n" 3361 "# define A 0\n" 3362 "/* Code. Separated by blank line. */\n" 3363 "\n" 3364 "# define B 0\n" 3365 " /* Code. Not aligned with # */\n" 3366 "# define C 0\n" 3367 "#endif"; 3368 EXPECT_EQ(Expected, format(ToFormat, Style)); 3369 EXPECT_EQ(Expected, format(Expected, Style)); 3370 } 3371 // Keep comments aligned with un-indented directives. 3372 { 3373 const char *Expected = "" 3374 "void f() {\n" 3375 "// Preprocessor aligned.\n" 3376 "#define A 0\n" 3377 " // Code. Separated by blank line.\n" 3378 "\n" 3379 "#define B 0\n" 3380 " // Code. Not aligned with #\n" 3381 "#define C 0\n"; 3382 const char *ToFormat = "" 3383 "void f() {\n" 3384 "// Preprocessor aligned.\n" 3385 "#define A 0\n" 3386 "// Code. Separated by blank line.\n" 3387 "\n" 3388 "#define B 0\n" 3389 " // Code. Not aligned with #\n" 3390 "#define C 0\n"; 3391 EXPECT_EQ(Expected, format(ToFormat, Style)); 3392 EXPECT_EQ(Expected, format(Expected, Style)); 3393 } 3394 // Test AfterHash with tabs. 3395 { 3396 FormatStyle Tabbed = Style; 3397 Tabbed.UseTab = FormatStyle::UT_Always; 3398 Tabbed.IndentWidth = 8; 3399 Tabbed.TabWidth = 8; 3400 verifyFormat("#ifdef _WIN32\n" 3401 "#\tdefine A 0\n" 3402 "#\tifdef VAR2\n" 3403 "#\t\tdefine B 1\n" 3404 "#\t\tinclude <someheader.h>\n" 3405 "#\t\tdefine MACRO \\\n" 3406 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3407 "#\tendif\n" 3408 "#else\n" 3409 "#\tdefine A 1\n" 3410 "#endif", 3411 Tabbed); 3412 } 3413 3414 // Regression test: Multiline-macro inside include guards. 3415 verifyFormat("#ifndef HEADER_H\n" 3416 "#define HEADER_H\n" 3417 "#define A() \\\n" 3418 " int i; \\\n" 3419 " int j;\n" 3420 "#endif // HEADER_H", 3421 getLLVMStyleWithColumns(20)); 3422 3423 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3424 // Basic before hash indent tests 3425 verifyFormat("#ifdef _WIN32\n" 3426 " #define A 0\n" 3427 " #ifdef VAR2\n" 3428 " #define B 1\n" 3429 " #include <someheader.h>\n" 3430 " #define MACRO \\\n" 3431 " some_very_long_func_aaaaaaaaaa();\n" 3432 " #endif\n" 3433 "#else\n" 3434 " #define A 1\n" 3435 "#endif", 3436 Style); 3437 verifyFormat("#if A\n" 3438 " #define MACRO \\\n" 3439 " void a(int x) { \\\n" 3440 " b(); \\\n" 3441 " c(); \\\n" 3442 " d(); \\\n" 3443 " e(); \\\n" 3444 " f(); \\\n" 3445 " }\n" 3446 "#endif", 3447 Style); 3448 // Keep comments aligned with indented directives. These 3449 // tests cannot use verifyFormat because messUp manipulates leading 3450 // whitespace. 3451 { 3452 const char *Expected = "void f() {\n" 3453 "// Aligned to preprocessor.\n" 3454 "#if 1\n" 3455 " // Aligned to code.\n" 3456 " int a;\n" 3457 " #if 1\n" 3458 " // Aligned to preprocessor.\n" 3459 " #define A 0\n" 3460 " // Aligned to code.\n" 3461 " int b;\n" 3462 " #endif\n" 3463 "#endif\n" 3464 "}"; 3465 const char *ToFormat = "void f() {\n" 3466 "// Aligned to preprocessor.\n" 3467 "#if 1\n" 3468 "// Aligned to code.\n" 3469 "int a;\n" 3470 "#if 1\n" 3471 "// Aligned to preprocessor.\n" 3472 "#define A 0\n" 3473 "// Aligned to code.\n" 3474 "int b;\n" 3475 "#endif\n" 3476 "#endif\n" 3477 "}"; 3478 EXPECT_EQ(Expected, format(ToFormat, Style)); 3479 EXPECT_EQ(Expected, format(Expected, Style)); 3480 } 3481 { 3482 const char *Expected = "void f() {\n" 3483 "/* Aligned to preprocessor. */\n" 3484 "#if 1\n" 3485 " /* Aligned to code. */\n" 3486 " int a;\n" 3487 " #if 1\n" 3488 " /* Aligned to preprocessor. */\n" 3489 " #define A 0\n" 3490 " /* Aligned to code. */\n" 3491 " int b;\n" 3492 " #endif\n" 3493 "#endif\n" 3494 "}"; 3495 const char *ToFormat = "void f() {\n" 3496 "/* Aligned to preprocessor. */\n" 3497 "#if 1\n" 3498 "/* Aligned to code. */\n" 3499 "int a;\n" 3500 "#if 1\n" 3501 "/* Aligned to preprocessor. */\n" 3502 "#define A 0\n" 3503 "/* Aligned to code. */\n" 3504 "int b;\n" 3505 "#endif\n" 3506 "#endif\n" 3507 "}"; 3508 EXPECT_EQ(Expected, format(ToFormat, Style)); 3509 EXPECT_EQ(Expected, format(Expected, Style)); 3510 } 3511 3512 // Test single comment before preprocessor 3513 verifyFormat("// Comment\n" 3514 "\n" 3515 "#if 1\n" 3516 "#endif", 3517 Style); 3518 } 3519 3520 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3521 verifyFormat("{\n { a #c; }\n}"); 3522 } 3523 3524 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3525 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3526 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3527 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3528 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3529 } 3530 3531 TEST_F(FormatTest, EscapedNewlines) { 3532 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3533 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3534 format("#define A \\\nint i;\\\n int j;", Narrow)); 3535 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3536 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3537 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3538 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3539 3540 FormatStyle AlignLeft = getLLVMStyle(); 3541 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3542 EXPECT_EQ("#define MACRO(x) \\\n" 3543 "private: \\\n" 3544 " int x(int a);\n", 3545 format("#define MACRO(x) \\\n" 3546 "private: \\\n" 3547 " int x(int a);\n", 3548 AlignLeft)); 3549 3550 // CRLF line endings 3551 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3552 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3553 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3554 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3555 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3556 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3557 EXPECT_EQ("#define MACRO(x) \\\r\n" 3558 "private: \\\r\n" 3559 " int x(int a);\r\n", 3560 format("#define MACRO(x) \\\r\n" 3561 "private: \\\r\n" 3562 " int x(int a);\r\n", 3563 AlignLeft)); 3564 3565 FormatStyle DontAlign = getLLVMStyle(); 3566 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3567 DontAlign.MaxEmptyLinesToKeep = 3; 3568 // FIXME: can't use verifyFormat here because the newline before 3569 // "public:" is not inserted the first time it's reformatted 3570 EXPECT_EQ("#define A \\\n" 3571 " class Foo { \\\n" 3572 " void bar(); \\\n" 3573 "\\\n" 3574 "\\\n" 3575 "\\\n" 3576 " public: \\\n" 3577 " void baz(); \\\n" 3578 " };", 3579 format("#define A \\\n" 3580 " class Foo { \\\n" 3581 " void bar(); \\\n" 3582 "\\\n" 3583 "\\\n" 3584 "\\\n" 3585 " public: \\\n" 3586 " void baz(); \\\n" 3587 " };", 3588 DontAlign)); 3589 } 3590 3591 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3592 verifyFormat("#define A \\\n" 3593 " int v( \\\n" 3594 " a); \\\n" 3595 " int i;", 3596 getLLVMStyleWithColumns(11)); 3597 } 3598 3599 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3600 EXPECT_EQ( 3601 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3602 " \\\n" 3603 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3604 "\n" 3605 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3606 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3607 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3608 "\\\n" 3609 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3610 " \n" 3611 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3612 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3613 } 3614 3615 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3616 EXPECT_EQ("int\n" 3617 "#define A\n" 3618 " a;", 3619 format("int\n#define A\na;")); 3620 verifyFormat("functionCallTo(\n" 3621 " someOtherFunction(\n" 3622 " withSomeParameters, whichInSequence,\n" 3623 " areLongerThanALine(andAnotherCall,\n" 3624 "#define A B\n" 3625 " withMoreParamters,\n" 3626 " whichStronglyInfluenceTheLayout),\n" 3627 " andMoreParameters),\n" 3628 " trailing);", 3629 getLLVMStyleWithColumns(69)); 3630 verifyFormat("Foo::Foo()\n" 3631 "#ifdef BAR\n" 3632 " : baz(0)\n" 3633 "#endif\n" 3634 "{\n" 3635 "}"); 3636 verifyFormat("void f() {\n" 3637 " if (true)\n" 3638 "#ifdef A\n" 3639 " f(42);\n" 3640 " x();\n" 3641 "#else\n" 3642 " g();\n" 3643 " x();\n" 3644 "#endif\n" 3645 "}"); 3646 verifyFormat("void f(param1, param2,\n" 3647 " param3,\n" 3648 "#ifdef A\n" 3649 " param4(param5,\n" 3650 "#ifdef A1\n" 3651 " param6,\n" 3652 "#ifdef A2\n" 3653 " param7),\n" 3654 "#else\n" 3655 " param8),\n" 3656 " param9,\n" 3657 "#endif\n" 3658 " param10,\n" 3659 "#endif\n" 3660 " param11)\n" 3661 "#else\n" 3662 " param12)\n" 3663 "#endif\n" 3664 "{\n" 3665 " x();\n" 3666 "}", 3667 getLLVMStyleWithColumns(28)); 3668 verifyFormat("#if 1\n" 3669 "int i;"); 3670 verifyFormat("#if 1\n" 3671 "#endif\n" 3672 "#if 1\n" 3673 "#else\n" 3674 "#endif\n"); 3675 verifyFormat("DEBUG({\n" 3676 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3677 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3678 "});\n" 3679 "#if a\n" 3680 "#else\n" 3681 "#endif"); 3682 3683 verifyIncompleteFormat("void f(\n" 3684 "#if A\n" 3685 ");\n" 3686 "#else\n" 3687 "#endif"); 3688 } 3689 3690 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3691 verifyFormat("#endif\n" 3692 "#if B"); 3693 } 3694 3695 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3696 FormatStyle SingleLine = getLLVMStyle(); 3697 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3698 verifyFormat("#if 0\n" 3699 "#elif 1\n" 3700 "#endif\n" 3701 "void foo() {\n" 3702 " if (test) foo2();\n" 3703 "}", 3704 SingleLine); 3705 } 3706 3707 TEST_F(FormatTest, LayoutBlockInsideParens) { 3708 verifyFormat("functionCall({ int i; });"); 3709 verifyFormat("functionCall({\n" 3710 " int i;\n" 3711 " int j;\n" 3712 "});"); 3713 verifyFormat("functionCall(\n" 3714 " {\n" 3715 " int i;\n" 3716 " int j;\n" 3717 " },\n" 3718 " aaaa, bbbb, cccc);"); 3719 verifyFormat("functionA(functionB({\n" 3720 " int i;\n" 3721 " int j;\n" 3722 " }),\n" 3723 " aaaa, bbbb, cccc);"); 3724 verifyFormat("functionCall(\n" 3725 " {\n" 3726 " int i;\n" 3727 " int j;\n" 3728 " },\n" 3729 " aaaa, bbbb, // comment\n" 3730 " cccc);"); 3731 verifyFormat("functionA(functionB({\n" 3732 " int i;\n" 3733 " int j;\n" 3734 " }),\n" 3735 " aaaa, bbbb, // comment\n" 3736 " cccc);"); 3737 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3738 verifyFormat("functionCall(aaaa, bbbb, {\n" 3739 " int i;\n" 3740 " int j;\n" 3741 "});"); 3742 verifyFormat( 3743 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3744 " {\n" 3745 " int i; // break\n" 3746 " },\n" 3747 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3748 " ccccccccccccccccc));"); 3749 verifyFormat("DEBUG({\n" 3750 " if (a)\n" 3751 " f();\n" 3752 "});"); 3753 } 3754 3755 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3756 EXPECT_EQ("SOME_MACRO { int i; }\n" 3757 "int i;", 3758 format(" SOME_MACRO {int i;} int i;")); 3759 } 3760 3761 TEST_F(FormatTest, LayoutNestedBlocks) { 3762 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3763 " struct s {\n" 3764 " int i;\n" 3765 " };\n" 3766 " s kBitsToOs[] = {{10}};\n" 3767 " for (int i = 0; i < 10; ++i)\n" 3768 " return;\n" 3769 "}"); 3770 verifyFormat("call(parameter, {\n" 3771 " something();\n" 3772 " // Comment using all columns.\n" 3773 " somethingelse();\n" 3774 "});", 3775 getLLVMStyleWithColumns(40)); 3776 verifyFormat("DEBUG( //\n" 3777 " { f(); }, a);"); 3778 verifyFormat("DEBUG( //\n" 3779 " {\n" 3780 " f(); //\n" 3781 " },\n" 3782 " a);"); 3783 3784 EXPECT_EQ("call(parameter, {\n" 3785 " something();\n" 3786 " // Comment too\n" 3787 " // looooooooooong.\n" 3788 " somethingElse();\n" 3789 "});", 3790 format("call(parameter, {\n" 3791 " something();\n" 3792 " // Comment too looooooooooong.\n" 3793 " somethingElse();\n" 3794 "});", 3795 getLLVMStyleWithColumns(29))); 3796 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3797 EXPECT_EQ("DEBUG({ // comment\n" 3798 " int i;\n" 3799 "});", 3800 format("DEBUG({ // comment\n" 3801 "int i;\n" 3802 "});")); 3803 EXPECT_EQ("DEBUG({\n" 3804 " int i;\n" 3805 "\n" 3806 " // comment\n" 3807 " int j;\n" 3808 "});", 3809 format("DEBUG({\n" 3810 " int i;\n" 3811 "\n" 3812 " // comment\n" 3813 " int j;\n" 3814 "});")); 3815 3816 verifyFormat("DEBUG({\n" 3817 " if (a)\n" 3818 " return;\n" 3819 "});"); 3820 verifyGoogleFormat("DEBUG({\n" 3821 " if (a) return;\n" 3822 "});"); 3823 FormatStyle Style = getGoogleStyle(); 3824 Style.ColumnLimit = 45; 3825 verifyFormat("Debug(\n" 3826 " aaaaa,\n" 3827 " {\n" 3828 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 3829 " },\n" 3830 " a);", 3831 Style); 3832 3833 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 3834 3835 verifyNoCrash("^{v^{a}}"); 3836 } 3837 3838 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 3839 EXPECT_EQ("#define MACRO() \\\n" 3840 " Debug(aaa, /* force line break */ \\\n" 3841 " { \\\n" 3842 " int i; \\\n" 3843 " int j; \\\n" 3844 " })", 3845 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 3846 " { int i; int j; })", 3847 getGoogleStyle())); 3848 3849 EXPECT_EQ("#define A \\\n" 3850 " [] { \\\n" 3851 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3852 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 3853 " }", 3854 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3855 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 3856 getGoogleStyle())); 3857 } 3858 3859 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 3860 EXPECT_EQ("{}", format("{}")); 3861 verifyFormat("enum E {};"); 3862 verifyFormat("enum E {}"); 3863 FormatStyle Style = getLLVMStyle(); 3864 Style.SpaceInEmptyBlock = true; 3865 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 3866 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 3867 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 3868 } 3869 3870 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 3871 FormatStyle Style = getLLVMStyle(); 3872 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 3873 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 3874 verifyFormat("FOO_BEGIN\n" 3875 " FOO_ENTRY\n" 3876 "FOO_END", 3877 Style); 3878 verifyFormat("FOO_BEGIN\n" 3879 " NESTED_FOO_BEGIN\n" 3880 " NESTED_FOO_ENTRY\n" 3881 " NESTED_FOO_END\n" 3882 "FOO_END", 3883 Style); 3884 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 3885 " int x;\n" 3886 " x = 1;\n" 3887 "FOO_END(Baz)", 3888 Style); 3889 } 3890 3891 //===----------------------------------------------------------------------===// 3892 // Line break tests. 3893 //===----------------------------------------------------------------------===// 3894 3895 TEST_F(FormatTest, PreventConfusingIndents) { 3896 verifyFormat( 3897 "void f() {\n" 3898 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 3899 " parameter, parameter, parameter)),\n" 3900 " SecondLongCall(parameter));\n" 3901 "}"); 3902 verifyFormat( 3903 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3904 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3905 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3906 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 3907 verifyFormat( 3908 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3909 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 3910 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 3911 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 3912 verifyFormat( 3913 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 3914 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 3915 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 3916 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 3917 verifyFormat("int a = bbbb && ccc &&\n" 3918 " fffff(\n" 3919 "#define A Just forcing a new line\n" 3920 " ddd);"); 3921 } 3922 3923 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 3924 verifyFormat( 3925 "bool aaaaaaa =\n" 3926 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 3927 " bbbbbbbb();"); 3928 verifyFormat( 3929 "bool aaaaaaa =\n" 3930 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 3931 " bbbbbbbb();"); 3932 3933 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3934 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 3935 " ccccccccc == ddddddddddd;"); 3936 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3937 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 3938 " ccccccccc == ddddddddddd;"); 3939 verifyFormat( 3940 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 3941 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 3942 " ccccccccc == ddddddddddd;"); 3943 3944 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3945 " aaaaaa) &&\n" 3946 " bbbbbb && cccccc;"); 3947 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3948 " aaaaaa) >>\n" 3949 " bbbbbb;"); 3950 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 3951 " SourceMgr.getSpellingColumnNumber(\n" 3952 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 3953 " 1);"); 3954 3955 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3956 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 3957 " cccccc) {\n}"); 3958 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3959 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3960 " cccccc) {\n}"); 3961 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3962 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3963 " cccccc) {\n}"); 3964 verifyFormat("b = a &&\n" 3965 " // Comment\n" 3966 " b.c && d;"); 3967 3968 // If the LHS of a comparison is not a binary expression itself, the 3969 // additional linebreak confuses many people. 3970 verifyFormat( 3971 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3972 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 3973 "}"); 3974 verifyFormat( 3975 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3976 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3977 "}"); 3978 verifyFormat( 3979 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 3980 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3981 "}"); 3982 verifyFormat( 3983 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3984 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 3985 "}"); 3986 // Even explicit parentheses stress the precedence enough to make the 3987 // additional break unnecessary. 3988 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3989 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3990 "}"); 3991 // This cases is borderline, but with the indentation it is still readable. 3992 verifyFormat( 3993 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3994 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3995 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 3996 "}", 3997 getLLVMStyleWithColumns(75)); 3998 3999 // If the LHS is a binary expression, we should still use the additional break 4000 // as otherwise the formatting hides the operator precedence. 4001 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4002 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4003 " 5) {\n" 4004 "}"); 4005 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4006 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 4007 " 5) {\n" 4008 "}"); 4009 4010 FormatStyle OnePerLine = getLLVMStyle(); 4011 OnePerLine.BinPackParameters = false; 4012 verifyFormat( 4013 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4014 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4015 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 4016 OnePerLine); 4017 4018 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 4019 " .aaa(aaaaaaaaaaaaa) *\n" 4020 " aaaaaaa +\n" 4021 " aaaaaaa;", 4022 getLLVMStyleWithColumns(40)); 4023 } 4024 4025 TEST_F(FormatTest, ExpressionIndentation) { 4026 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4027 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4028 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4029 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4030 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 4031 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 4032 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4033 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 4034 " ccccccccccccccccccccccccccccccccccccccccc;"); 4035 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4036 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4037 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4038 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4039 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4040 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4041 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4042 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4043 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4044 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4045 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4046 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4047 verifyFormat("if () {\n" 4048 "} else if (aaaaa && bbbbb > // break\n" 4049 " ccccc) {\n" 4050 "}"); 4051 verifyFormat("if () {\n" 4052 "} else if constexpr (aaaaa && bbbbb > // break\n" 4053 " ccccc) {\n" 4054 "}"); 4055 verifyFormat("if () {\n" 4056 "} else if CONSTEXPR (aaaaa && bbbbb > // break\n" 4057 " ccccc) {\n" 4058 "}"); 4059 verifyFormat("if () {\n" 4060 "} else if (aaaaa &&\n" 4061 " bbbbb > // break\n" 4062 " ccccc &&\n" 4063 " ddddd) {\n" 4064 "}"); 4065 4066 // Presence of a trailing comment used to change indentation of b. 4067 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 4068 " b;\n" 4069 "return aaaaaaaaaaaaaaaaaaa +\n" 4070 " b; //", 4071 getLLVMStyleWithColumns(30)); 4072 } 4073 4074 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 4075 // Not sure what the best system is here. Like this, the LHS can be found 4076 // immediately above an operator (everything with the same or a higher 4077 // indent). The RHS is aligned right of the operator and so compasses 4078 // everything until something with the same indent as the operator is found. 4079 // FIXME: Is this a good system? 4080 FormatStyle Style = getLLVMStyle(); 4081 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 4082 verifyFormat( 4083 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4084 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4085 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4086 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4087 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4088 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4089 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4090 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4091 " > ccccccccccccccccccccccccccccccccccccccccc;", 4092 Style); 4093 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4094 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4095 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4096 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4097 Style); 4098 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4099 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4100 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4101 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4102 Style); 4103 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4104 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4105 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4106 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4107 Style); 4108 verifyFormat("if () {\n" 4109 "} else if (aaaaa\n" 4110 " && bbbbb // break\n" 4111 " > ccccc) {\n" 4112 "}", 4113 Style); 4114 verifyFormat("return (a)\n" 4115 " // comment\n" 4116 " + b;", 4117 Style); 4118 verifyFormat( 4119 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4120 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4121 " + cc;", 4122 Style); 4123 4124 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4125 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4126 Style); 4127 4128 // Forced by comments. 4129 verifyFormat( 4130 "unsigned ContentSize =\n" 4131 " sizeof(int16_t) // DWARF ARange version number\n" 4132 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4133 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4134 " + sizeof(int8_t); // Segment Size (in bytes)"); 4135 4136 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 4137 " == boost::fusion::at_c<1>(iiii).second;", 4138 Style); 4139 4140 Style.ColumnLimit = 60; 4141 verifyFormat("zzzzzzzzzz\n" 4142 " = bbbbbbbbbbbbbbbbb\n" 4143 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 4144 Style); 4145 4146 Style.ColumnLimit = 80; 4147 Style.IndentWidth = 4; 4148 Style.TabWidth = 4; 4149 Style.UseTab = FormatStyle::UT_Always; 4150 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4151 Style.AlignOperands = false; 4152 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 4153 "\t&& (someOtherLongishConditionPart1\n" 4154 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 4155 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && " 4156 "(someOtherLongishConditionPart1 || " 4157 "someOtherEvenLongerNestedConditionPart2);", 4158 Style)); 4159 } 4160 4161 TEST_F(FormatTest, EnforcedOperatorWraps) { 4162 // Here we'd like to wrap after the || operators, but a comment is forcing an 4163 // earlier wrap. 4164 verifyFormat("bool x = aaaaa //\n" 4165 " || bbbbb\n" 4166 " //\n" 4167 " || cccc;"); 4168 } 4169 4170 TEST_F(FormatTest, NoOperandAlignment) { 4171 FormatStyle Style = getLLVMStyle(); 4172 Style.AlignOperands = false; 4173 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 4174 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4175 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4176 Style); 4177 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4178 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4179 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4180 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4181 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4182 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4183 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4184 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4185 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4186 " > ccccccccccccccccccccccccccccccccccccccccc;", 4187 Style); 4188 4189 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4190 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4191 " + cc;", 4192 Style); 4193 verifyFormat("int a = aa\n" 4194 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4195 " * cccccccccccccccccccccccccccccccccccc;\n", 4196 Style); 4197 4198 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4199 verifyFormat("return (a > b\n" 4200 " // comment1\n" 4201 " // comment2\n" 4202 " || c);", 4203 Style); 4204 } 4205 4206 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 4207 FormatStyle Style = getLLVMStyle(); 4208 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4209 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4210 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4211 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4212 Style); 4213 } 4214 4215 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 4216 FormatStyle Style = getLLVMStyle(); 4217 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4218 Style.BinPackArguments = false; 4219 Style.ColumnLimit = 40; 4220 verifyFormat("void test() {\n" 4221 " someFunction(\n" 4222 " this + argument + is + quite\n" 4223 " + long + so + it + gets + wrapped\n" 4224 " + but + remains + bin - packed);\n" 4225 "}", 4226 Style); 4227 verifyFormat("void test() {\n" 4228 " someFunction(arg1,\n" 4229 " this + argument + is\n" 4230 " + quite + long + so\n" 4231 " + it + gets + wrapped\n" 4232 " + but + remains + bin\n" 4233 " - packed,\n" 4234 " arg3);\n" 4235 "}", 4236 Style); 4237 verifyFormat("void test() {\n" 4238 " someFunction(\n" 4239 " arg1,\n" 4240 " this + argument + has\n" 4241 " + anotherFunc(nested,\n" 4242 " calls + whose\n" 4243 " + arguments\n" 4244 " + are + also\n" 4245 " + wrapped,\n" 4246 " in + addition)\n" 4247 " + to + being + bin - packed,\n" 4248 " arg3);\n" 4249 "}", 4250 Style); 4251 4252 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4253 verifyFormat("void test() {\n" 4254 " someFunction(\n" 4255 " arg1,\n" 4256 " this + argument + has +\n" 4257 " anotherFunc(nested,\n" 4258 " calls + whose +\n" 4259 " arguments +\n" 4260 " are + also +\n" 4261 " wrapped,\n" 4262 " in + addition) +\n" 4263 " to + being + bin - packed,\n" 4264 " arg3);\n" 4265 "}", 4266 Style); 4267 } 4268 4269 TEST_F(FormatTest, ConstructorInitializers) { 4270 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4271 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 4272 getLLVMStyleWithColumns(45)); 4273 verifyFormat("Constructor()\n" 4274 " : Inttializer(FitsOnTheLine) {}", 4275 getLLVMStyleWithColumns(44)); 4276 verifyFormat("Constructor()\n" 4277 " : Inttializer(FitsOnTheLine) {}", 4278 getLLVMStyleWithColumns(43)); 4279 4280 verifyFormat("template <typename T>\n" 4281 "Constructor() : Initializer(FitsOnTheLine) {}", 4282 getLLVMStyleWithColumns(45)); 4283 4284 verifyFormat( 4285 "SomeClass::Constructor()\n" 4286 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4287 4288 verifyFormat( 4289 "SomeClass::Constructor()\n" 4290 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4291 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 4292 verifyFormat( 4293 "SomeClass::Constructor()\n" 4294 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4295 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4296 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4297 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4298 " : aaaaaaaaaa(aaaaaa) {}"); 4299 4300 verifyFormat("Constructor()\n" 4301 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4302 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4303 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4304 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 4305 4306 verifyFormat("Constructor()\n" 4307 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4308 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4309 4310 verifyFormat("Constructor(int Parameter = 0)\n" 4311 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4312 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 4313 verifyFormat("Constructor()\n" 4314 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4315 "}", 4316 getLLVMStyleWithColumns(60)); 4317 verifyFormat("Constructor()\n" 4318 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4319 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 4320 4321 // Here a line could be saved by splitting the second initializer onto two 4322 // lines, but that is not desirable. 4323 verifyFormat("Constructor()\n" 4324 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4325 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4326 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4327 4328 FormatStyle OnePerLine = getLLVMStyle(); 4329 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4330 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 4331 verifyFormat("SomeClass::Constructor()\n" 4332 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4333 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4334 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4335 OnePerLine); 4336 verifyFormat("SomeClass::Constructor()\n" 4337 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4338 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4339 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4340 OnePerLine); 4341 verifyFormat("MyClass::MyClass(int var)\n" 4342 " : some_var_(var), // 4 space indent\n" 4343 " some_other_var_(var + 1) { // lined up\n" 4344 "}", 4345 OnePerLine); 4346 verifyFormat("Constructor()\n" 4347 " : aaaaa(aaaaaa),\n" 4348 " aaaaa(aaaaaa),\n" 4349 " aaaaa(aaaaaa),\n" 4350 " aaaaa(aaaaaa),\n" 4351 " aaaaa(aaaaaa) {}", 4352 OnePerLine); 4353 verifyFormat("Constructor()\n" 4354 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4355 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4356 OnePerLine); 4357 OnePerLine.BinPackParameters = false; 4358 verifyFormat( 4359 "Constructor()\n" 4360 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4361 " aaaaaaaaaaa().aaa(),\n" 4362 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4363 OnePerLine); 4364 OnePerLine.ColumnLimit = 60; 4365 verifyFormat("Constructor()\n" 4366 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4367 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4368 OnePerLine); 4369 4370 EXPECT_EQ("Constructor()\n" 4371 " : // Comment forcing unwanted break.\n" 4372 " aaaa(aaaa) {}", 4373 format("Constructor() :\n" 4374 " // Comment forcing unwanted break.\n" 4375 " aaaa(aaaa) {}")); 4376 } 4377 4378 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 4379 FormatStyle Style = getLLVMStyle(); 4380 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4381 Style.ColumnLimit = 60; 4382 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4383 Style.AllowAllConstructorInitializersOnNextLine = true; 4384 Style.BinPackParameters = false; 4385 4386 for (int i = 0; i < 4; ++i) { 4387 // Test all combinations of parameters that should not have an effect. 4388 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4389 Style.AllowAllArgumentsOnNextLine = i & 2; 4390 4391 Style.AllowAllConstructorInitializersOnNextLine = true; 4392 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4393 verifyFormat("Constructor()\n" 4394 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4395 Style); 4396 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4397 4398 Style.AllowAllConstructorInitializersOnNextLine = false; 4399 verifyFormat("Constructor()\n" 4400 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4401 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4402 Style); 4403 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4404 4405 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4406 Style.AllowAllConstructorInitializersOnNextLine = true; 4407 verifyFormat("Constructor()\n" 4408 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4409 Style); 4410 4411 Style.AllowAllConstructorInitializersOnNextLine = false; 4412 verifyFormat("Constructor()\n" 4413 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4414 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4415 Style); 4416 4417 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4418 Style.AllowAllConstructorInitializersOnNextLine = true; 4419 verifyFormat("Constructor() :\n" 4420 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4421 Style); 4422 4423 Style.AllowAllConstructorInitializersOnNextLine = false; 4424 verifyFormat("Constructor() :\n" 4425 " aaaaaaaaaaaaaaaaaa(a),\n" 4426 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4427 Style); 4428 } 4429 4430 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4431 // AllowAllConstructorInitializersOnNextLine in all 4432 // BreakConstructorInitializers modes 4433 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4434 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4435 Style.AllowAllConstructorInitializersOnNextLine = false; 4436 verifyFormat("SomeClassWithALongName::Constructor(\n" 4437 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4438 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4439 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4440 Style); 4441 4442 Style.AllowAllConstructorInitializersOnNextLine = true; 4443 verifyFormat("SomeClassWithALongName::Constructor(\n" 4444 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4445 " int bbbbbbbbbbbbb,\n" 4446 " int cccccccccccccccc)\n" 4447 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4448 Style); 4449 4450 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4451 Style.AllowAllConstructorInitializersOnNextLine = false; 4452 verifyFormat("SomeClassWithALongName::Constructor(\n" 4453 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4454 " int bbbbbbbbbbbbb)\n" 4455 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4456 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4457 Style); 4458 4459 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4460 4461 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4462 verifyFormat("SomeClassWithALongName::Constructor(\n" 4463 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4464 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4465 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4466 Style); 4467 4468 Style.AllowAllConstructorInitializersOnNextLine = true; 4469 verifyFormat("SomeClassWithALongName::Constructor(\n" 4470 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4471 " int bbbbbbbbbbbbb,\n" 4472 " int cccccccccccccccc)\n" 4473 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4474 Style); 4475 4476 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4477 Style.AllowAllConstructorInitializersOnNextLine = false; 4478 verifyFormat("SomeClassWithALongName::Constructor(\n" 4479 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4480 " int bbbbbbbbbbbbb)\n" 4481 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4482 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4483 Style); 4484 4485 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4486 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4487 verifyFormat("SomeClassWithALongName::Constructor(\n" 4488 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4489 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4490 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4491 Style); 4492 4493 Style.AllowAllConstructorInitializersOnNextLine = true; 4494 verifyFormat("SomeClassWithALongName::Constructor(\n" 4495 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4496 " int bbbbbbbbbbbbb,\n" 4497 " int cccccccccccccccc) :\n" 4498 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4499 Style); 4500 4501 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4502 Style.AllowAllConstructorInitializersOnNextLine = false; 4503 verifyFormat("SomeClassWithALongName::Constructor(\n" 4504 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4505 " int bbbbbbbbbbbbb) :\n" 4506 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4507 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4508 Style); 4509 } 4510 4511 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4512 FormatStyle Style = getLLVMStyle(); 4513 Style.ColumnLimit = 60; 4514 Style.BinPackArguments = false; 4515 for (int i = 0; i < 4; ++i) { 4516 // Test all combinations of parameters that should not have an effect. 4517 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4518 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4519 4520 Style.AllowAllArgumentsOnNextLine = true; 4521 verifyFormat("void foo() {\n" 4522 " FunctionCallWithReallyLongName(\n" 4523 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4524 "}", 4525 Style); 4526 Style.AllowAllArgumentsOnNextLine = false; 4527 verifyFormat("void foo() {\n" 4528 " FunctionCallWithReallyLongName(\n" 4529 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4530 " bbbbbbbbbbbb);\n" 4531 "}", 4532 Style); 4533 4534 Style.AllowAllArgumentsOnNextLine = true; 4535 verifyFormat("void foo() {\n" 4536 " auto VariableWithReallyLongName = {\n" 4537 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4538 "}", 4539 Style); 4540 Style.AllowAllArgumentsOnNextLine = false; 4541 verifyFormat("void foo() {\n" 4542 " auto VariableWithReallyLongName = {\n" 4543 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4544 " bbbbbbbbbbbb};\n" 4545 "}", 4546 Style); 4547 } 4548 4549 // This parameter should not affect declarations. 4550 Style.BinPackParameters = false; 4551 Style.AllowAllArgumentsOnNextLine = false; 4552 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4553 verifyFormat("void FunctionCallWithReallyLongName(\n" 4554 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4555 Style); 4556 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4557 verifyFormat("void FunctionCallWithReallyLongName(\n" 4558 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4559 " int bbbbbbbbbbbb);", 4560 Style); 4561 } 4562 4563 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4564 FormatStyle Style = getLLVMStyle(); 4565 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4566 4567 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4568 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4569 getStyleWithColumns(Style, 45)); 4570 verifyFormat("Constructor() :\n" 4571 " Initializer(FitsOnTheLine) {}", 4572 getStyleWithColumns(Style, 44)); 4573 verifyFormat("Constructor() :\n" 4574 " Initializer(FitsOnTheLine) {}", 4575 getStyleWithColumns(Style, 43)); 4576 4577 verifyFormat("template <typename T>\n" 4578 "Constructor() : Initializer(FitsOnTheLine) {}", 4579 getStyleWithColumns(Style, 50)); 4580 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4581 verifyFormat( 4582 "SomeClass::Constructor() :\n" 4583 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4584 Style); 4585 4586 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4587 verifyFormat( 4588 "SomeClass::Constructor() :\n" 4589 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4590 Style); 4591 4592 verifyFormat( 4593 "SomeClass::Constructor() :\n" 4594 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4595 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4596 Style); 4597 verifyFormat( 4598 "SomeClass::Constructor() :\n" 4599 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4600 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4601 Style); 4602 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4603 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4604 " aaaaaaaaaa(aaaaaa) {}", 4605 Style); 4606 4607 verifyFormat("Constructor() :\n" 4608 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4609 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4610 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4611 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4612 Style); 4613 4614 verifyFormat("Constructor() :\n" 4615 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4616 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4617 Style); 4618 4619 verifyFormat("Constructor(int Parameter = 0) :\n" 4620 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4621 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4622 Style); 4623 verifyFormat("Constructor() :\n" 4624 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4625 "}", 4626 getStyleWithColumns(Style, 60)); 4627 verifyFormat("Constructor() :\n" 4628 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4629 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4630 Style); 4631 4632 // Here a line could be saved by splitting the second initializer onto two 4633 // lines, but that is not desirable. 4634 verifyFormat("Constructor() :\n" 4635 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4636 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4637 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4638 Style); 4639 4640 FormatStyle OnePerLine = Style; 4641 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4642 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4643 verifyFormat("SomeClass::Constructor() :\n" 4644 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4645 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4646 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4647 OnePerLine); 4648 verifyFormat("SomeClass::Constructor() :\n" 4649 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4650 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4651 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4652 OnePerLine); 4653 verifyFormat("MyClass::MyClass(int var) :\n" 4654 " some_var_(var), // 4 space indent\n" 4655 " some_other_var_(var + 1) { // lined up\n" 4656 "}", 4657 OnePerLine); 4658 verifyFormat("Constructor() :\n" 4659 " aaaaa(aaaaaa),\n" 4660 " aaaaa(aaaaaa),\n" 4661 " aaaaa(aaaaaa),\n" 4662 " aaaaa(aaaaaa),\n" 4663 " aaaaa(aaaaaa) {}", 4664 OnePerLine); 4665 verifyFormat("Constructor() :\n" 4666 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4667 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4668 OnePerLine); 4669 OnePerLine.BinPackParameters = false; 4670 verifyFormat("Constructor() :\n" 4671 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4672 " aaaaaaaaaaa().aaa(),\n" 4673 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4674 OnePerLine); 4675 OnePerLine.ColumnLimit = 60; 4676 verifyFormat("Constructor() :\n" 4677 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4678 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4679 OnePerLine); 4680 4681 EXPECT_EQ("Constructor() :\n" 4682 " // Comment forcing unwanted break.\n" 4683 " aaaa(aaaa) {}", 4684 format("Constructor() :\n" 4685 " // Comment forcing unwanted break.\n" 4686 " aaaa(aaaa) {}", 4687 Style)); 4688 4689 Style.ColumnLimit = 0; 4690 verifyFormat("SomeClass::Constructor() :\n" 4691 " a(a) {}", 4692 Style); 4693 verifyFormat("SomeClass::Constructor() noexcept :\n" 4694 " a(a) {}", 4695 Style); 4696 verifyFormat("SomeClass::Constructor() :\n" 4697 " a(a), b(b), c(c) {}", 4698 Style); 4699 verifyFormat("SomeClass::Constructor() :\n" 4700 " a(a) {\n" 4701 " foo();\n" 4702 " bar();\n" 4703 "}", 4704 Style); 4705 4706 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4707 verifyFormat("SomeClass::Constructor() :\n" 4708 " a(a), b(b), c(c) {\n" 4709 "}", 4710 Style); 4711 verifyFormat("SomeClass::Constructor() :\n" 4712 " a(a) {\n" 4713 "}", 4714 Style); 4715 4716 Style.ColumnLimit = 80; 4717 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4718 Style.ConstructorInitializerIndentWidth = 2; 4719 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style); 4720 verifyFormat("SomeClass::Constructor() :\n" 4721 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4722 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 4723 Style); 4724 4725 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as 4726 // well 4727 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 4728 verifyFormat( 4729 "class SomeClass\n" 4730 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4731 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4732 Style); 4733 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 4734 verifyFormat( 4735 "class SomeClass\n" 4736 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4737 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4738 Style); 4739 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 4740 verifyFormat( 4741 "class SomeClass :\n" 4742 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4743 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4744 Style); 4745 } 4746 4747 #ifndef EXPENSIVE_CHECKS 4748 // Expensive checks enables libstdc++ checking which includes validating the 4749 // state of ranges used in std::priority_queue - this blows out the 4750 // runtime/scalability of the function and makes this test unacceptably slow. 4751 TEST_F(FormatTest, MemoizationTests) { 4752 // This breaks if the memoization lookup does not take \c Indent and 4753 // \c LastSpace into account. 4754 verifyFormat( 4755 "extern CFRunLoopTimerRef\n" 4756 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 4757 " CFTimeInterval interval, CFOptionFlags flags,\n" 4758 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 4759 " CFRunLoopTimerContext *context) {}"); 4760 4761 // Deep nesting somewhat works around our memoization. 4762 verifyFormat( 4763 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4764 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4765 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4766 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4767 " aaaaa())))))))))))))))))))))))))))))))))))))));", 4768 getLLVMStyleWithColumns(65)); 4769 verifyFormat( 4770 "aaaaa(\n" 4771 " aaaaa,\n" 4772 " aaaaa(\n" 4773 " aaaaa,\n" 4774 " aaaaa(\n" 4775 " aaaaa,\n" 4776 " aaaaa(\n" 4777 " aaaaa,\n" 4778 " aaaaa(\n" 4779 " aaaaa,\n" 4780 " aaaaa(\n" 4781 " aaaaa,\n" 4782 " aaaaa(\n" 4783 " aaaaa,\n" 4784 " aaaaa(\n" 4785 " aaaaa,\n" 4786 " aaaaa(\n" 4787 " aaaaa,\n" 4788 " aaaaa(\n" 4789 " aaaaa,\n" 4790 " aaaaa(\n" 4791 " aaaaa,\n" 4792 " aaaaa(\n" 4793 " aaaaa,\n" 4794 " aaaaa))))))))))));", 4795 getLLVMStyleWithColumns(65)); 4796 verifyFormat( 4797 "a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(), a), a), a), a),\n" 4798 " a),\n" 4799 " a),\n" 4800 " a),\n" 4801 " a),\n" 4802 " a),\n" 4803 " a),\n" 4804 " a),\n" 4805 " a),\n" 4806 " a),\n" 4807 " a),\n" 4808 " a),\n" 4809 " a),\n" 4810 " a),\n" 4811 " a),\n" 4812 " a),\n" 4813 " a),\n" 4814 " a)", 4815 getLLVMStyleWithColumns(65)); 4816 4817 // This test takes VERY long when memoization is broken. 4818 FormatStyle OnePerLine = getLLVMStyle(); 4819 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4820 OnePerLine.BinPackParameters = false; 4821 std::string input = "Constructor()\n" 4822 " : aaaa(a,\n"; 4823 for (unsigned i = 0, e = 80; i != e; ++i) { 4824 input += " a,\n"; 4825 } 4826 input += " a) {}"; 4827 verifyFormat(input, OnePerLine); 4828 } 4829 #endif 4830 4831 TEST_F(FormatTest, BreaksAsHighAsPossible) { 4832 verifyFormat( 4833 "void f() {\n" 4834 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 4835 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 4836 " f();\n" 4837 "}"); 4838 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 4839 " Intervals[i - 1].getRange().getLast()) {\n}"); 4840 } 4841 4842 TEST_F(FormatTest, BreaksFunctionDeclarations) { 4843 // Principially, we break function declarations in a certain order: 4844 // 1) break amongst arguments. 4845 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 4846 " Cccccccccccccc cccccccccccccc);"); 4847 verifyFormat("template <class TemplateIt>\n" 4848 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 4849 " TemplateIt *stop) {}"); 4850 4851 // 2) break after return type. 4852 verifyFormat( 4853 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4854 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 4855 getGoogleStyle()); 4856 4857 // 3) break after (. 4858 verifyFormat( 4859 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 4860 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 4861 getGoogleStyle()); 4862 4863 // 4) break before after nested name specifiers. 4864 verifyFormat( 4865 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4866 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 4867 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 4868 getGoogleStyle()); 4869 4870 // However, there are exceptions, if a sufficient amount of lines can be 4871 // saved. 4872 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 4873 // more adjusting. 4874 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4875 " Cccccccccccccc cccccccccc,\n" 4876 " Cccccccccccccc cccccccccc,\n" 4877 " Cccccccccccccc cccccccccc,\n" 4878 " Cccccccccccccc cccccccccc);"); 4879 verifyFormat( 4880 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4881 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4882 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4883 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 4884 getGoogleStyle()); 4885 verifyFormat( 4886 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4887 " Cccccccccccccc cccccccccc,\n" 4888 " Cccccccccccccc cccccccccc,\n" 4889 " Cccccccccccccc cccccccccc,\n" 4890 " Cccccccccccccc cccccccccc,\n" 4891 " Cccccccccccccc cccccccccc,\n" 4892 " Cccccccccccccc cccccccccc);"); 4893 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4894 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4895 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4896 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4897 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 4898 4899 // Break after multi-line parameters. 4900 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4901 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4902 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4903 " bbbb bbbb);"); 4904 verifyFormat("void SomeLoooooooooooongFunction(\n" 4905 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 4906 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4907 " int bbbbbbbbbbbbb);"); 4908 4909 // Treat overloaded operators like other functions. 4910 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4911 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 4912 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4913 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 4914 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4915 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 4916 verifyGoogleFormat( 4917 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 4918 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4919 verifyGoogleFormat( 4920 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 4921 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4922 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4923 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4924 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 4925 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4926 verifyGoogleFormat( 4927 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 4928 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4929 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 4930 verifyGoogleFormat("template <typename T>\n" 4931 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4932 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 4933 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 4934 4935 FormatStyle Style = getLLVMStyle(); 4936 Style.PointerAlignment = FormatStyle::PAS_Left; 4937 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4938 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 4939 Style); 4940 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 4941 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4942 Style); 4943 } 4944 4945 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 4946 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 4947 // Prefer keeping `::` followed by `operator` together. 4948 EXPECT_EQ("const aaaa::bbbbbbb &\n" 4949 "ccccccccc::operator++() {\n" 4950 " stuff();\n" 4951 "}", 4952 format("const aaaa::bbbbbbb\n" 4953 "&ccccccccc::operator++() { stuff(); }", 4954 getLLVMStyleWithColumns(40))); 4955 } 4956 4957 TEST_F(FormatTest, TrailingReturnType) { 4958 verifyFormat("auto foo() -> int;\n"); 4959 // correct trailing return type spacing 4960 verifyFormat("auto operator->() -> int;\n"); 4961 verifyFormat("auto operator++(int) -> int;\n"); 4962 4963 verifyFormat("struct S {\n" 4964 " auto bar() const -> int;\n" 4965 "};"); 4966 verifyFormat("template <size_t Order, typename T>\n" 4967 "auto load_img(const std::string &filename)\n" 4968 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 4969 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 4970 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 4971 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 4972 verifyFormat("template <typename T>\n" 4973 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 4974 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 4975 4976 // Not trailing return types. 4977 verifyFormat("void f() { auto a = b->c(); }"); 4978 } 4979 4980 TEST_F(FormatTest, DeductionGuides) { 4981 verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;"); 4982 verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;"); 4983 verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;"); 4984 verifyFormat( 4985 "template <class... T>\n" 4986 "array(T &&... t) -> array<std::common_type_t<T...>, sizeof...(T)>;"); 4987 verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;"); 4988 verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;"); 4989 verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;"); 4990 verifyFormat("template <class T> A() -> A<(3 < 2)>;"); 4991 verifyFormat("template <class T> A() -> A<((3) < (2))>;"); 4992 verifyFormat("template <class T> x() -> x<1>;"); 4993 verifyFormat("template <class T> explicit x(T &) -> x<1>;"); 4994 4995 // Ensure not deduction guides. 4996 verifyFormat("c()->f<int>();"); 4997 verifyFormat("x()->foo<1>;"); 4998 verifyFormat("x = p->foo<3>();"); 4999 verifyFormat("x()->x<1>();"); 5000 verifyFormat("x()->x<1>;"); 5001 } 5002 5003 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 5004 // Avoid breaking before trailing 'const' or other trailing annotations, if 5005 // they are not function-like. 5006 FormatStyle Style = getGoogleStyle(); 5007 Style.ColumnLimit = 47; 5008 verifyFormat("void someLongFunction(\n" 5009 " int someLoooooooooooooongParameter) const {\n}", 5010 getLLVMStyleWithColumns(47)); 5011 verifyFormat("LoooooongReturnType\n" 5012 "someLoooooooongFunction() const {}", 5013 getLLVMStyleWithColumns(47)); 5014 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 5015 " const {}", 5016 Style); 5017 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5018 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 5019 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5020 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 5021 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5022 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 5023 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 5024 " aaaaaaaaaaa aaaaa) const override;"); 5025 verifyGoogleFormat( 5026 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5027 " const override;"); 5028 5029 // Even if the first parameter has to be wrapped. 5030 verifyFormat("void someLongFunction(\n" 5031 " int someLongParameter) const {}", 5032 getLLVMStyleWithColumns(46)); 5033 verifyFormat("void someLongFunction(\n" 5034 " int someLongParameter) const {}", 5035 Style); 5036 verifyFormat("void someLongFunction(\n" 5037 " int someLongParameter) override {}", 5038 Style); 5039 verifyFormat("void someLongFunction(\n" 5040 " int someLongParameter) OVERRIDE {}", 5041 Style); 5042 verifyFormat("void someLongFunction(\n" 5043 " int someLongParameter) final {}", 5044 Style); 5045 verifyFormat("void someLongFunction(\n" 5046 " int someLongParameter) FINAL {}", 5047 Style); 5048 verifyFormat("void someLongFunction(\n" 5049 " int parameter) const override {}", 5050 Style); 5051 5052 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 5053 verifyFormat("void someLongFunction(\n" 5054 " int someLongParameter) const\n" 5055 "{\n" 5056 "}", 5057 Style); 5058 5059 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 5060 verifyFormat("void someLongFunction(\n" 5061 " int someLongParameter) const\n" 5062 " {\n" 5063 " }", 5064 Style); 5065 5066 // Unless these are unknown annotations. 5067 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 5068 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5069 " LONG_AND_UGLY_ANNOTATION;"); 5070 5071 // Breaking before function-like trailing annotations is fine to keep them 5072 // close to their arguments. 5073 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5074 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5075 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5076 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5077 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5078 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 5079 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 5080 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 5081 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 5082 5083 verifyFormat( 5084 "void aaaaaaaaaaaaaaaaaa()\n" 5085 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 5086 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 5087 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5088 " __attribute__((unused));"); 5089 verifyGoogleFormat( 5090 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5091 " GUARDED_BY(aaaaaaaaaaaa);"); 5092 verifyGoogleFormat( 5093 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5094 " GUARDED_BY(aaaaaaaaaaaa);"); 5095 verifyGoogleFormat( 5096 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5097 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5098 verifyGoogleFormat( 5099 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5100 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5101 } 5102 5103 TEST_F(FormatTest, FunctionAnnotations) { 5104 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5105 "int OldFunction(const string ¶meter) {}"); 5106 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5107 "string OldFunction(const string ¶meter) {}"); 5108 verifyFormat("template <typename T>\n" 5109 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5110 "string OldFunction(const string ¶meter) {}"); 5111 5112 // Not function annotations. 5113 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5114 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 5115 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 5116 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 5117 verifyFormat("MACRO(abc).function() // wrap\n" 5118 " << abc;"); 5119 verifyFormat("MACRO(abc)->function() // wrap\n" 5120 " << abc;"); 5121 verifyFormat("MACRO(abc)::function() // wrap\n" 5122 " << abc;"); 5123 } 5124 5125 TEST_F(FormatTest, BreaksDesireably) { 5126 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5127 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5128 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 5129 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5130 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 5131 "}"); 5132 5133 verifyFormat( 5134 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5135 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 5136 5137 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5138 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5139 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5140 5141 verifyFormat( 5142 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5143 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5144 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5145 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5146 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 5147 5148 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5149 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5150 5151 verifyFormat( 5152 "void f() {\n" 5153 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 5154 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5155 "}"); 5156 verifyFormat( 5157 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5158 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5159 verifyFormat( 5160 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5161 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5162 verifyFormat( 5163 "aaaaaa(aaa,\n" 5164 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5165 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5166 " aaaa);"); 5167 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5168 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5169 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5170 5171 // Indent consistently independent of call expression and unary operator. 5172 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5173 " dddddddddddddddddddddddddddddd));"); 5174 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5175 " dddddddddddddddddddddddddddddd));"); 5176 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 5177 " dddddddddddddddddddddddddddddd));"); 5178 5179 // This test case breaks on an incorrect memoization, i.e. an optimization not 5180 // taking into account the StopAt value. 5181 verifyFormat( 5182 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5183 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5184 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5185 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5186 5187 verifyFormat("{\n {\n {\n" 5188 " Annotation.SpaceRequiredBefore =\n" 5189 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 5190 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 5191 " }\n }\n}"); 5192 5193 // Break on an outer level if there was a break on an inner level. 5194 EXPECT_EQ("f(g(h(a, // comment\n" 5195 " b, c),\n" 5196 " d, e),\n" 5197 " x, y);", 5198 format("f(g(h(a, // comment\n" 5199 " b, c), d, e), x, y);")); 5200 5201 // Prefer breaking similar line breaks. 5202 verifyFormat( 5203 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 5204 " NSTrackingMouseEnteredAndExited |\n" 5205 " NSTrackingActiveAlways;"); 5206 } 5207 5208 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 5209 FormatStyle NoBinPacking = getGoogleStyle(); 5210 NoBinPacking.BinPackParameters = false; 5211 NoBinPacking.BinPackArguments = true; 5212 verifyFormat("void f() {\n" 5213 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 5214 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5215 "}", 5216 NoBinPacking); 5217 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 5218 " int aaaaaaaaaaaaaaaaaaaa,\n" 5219 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5220 NoBinPacking); 5221 5222 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5223 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5224 " vector<int> bbbbbbbbbbbbbbb);", 5225 NoBinPacking); 5226 // FIXME: This behavior difference is probably not wanted. However, currently 5227 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 5228 // template arguments from BreakBeforeParameter being set because of the 5229 // one-per-line formatting. 5230 verifyFormat( 5231 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5232 " aaaaaaaaaa> aaaaaaaaaa);", 5233 NoBinPacking); 5234 verifyFormat( 5235 "void fffffffffff(\n" 5236 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 5237 " aaaaaaaaaa);"); 5238 } 5239 5240 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 5241 FormatStyle NoBinPacking = getGoogleStyle(); 5242 NoBinPacking.BinPackParameters = false; 5243 NoBinPacking.BinPackArguments = false; 5244 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 5245 " aaaaaaaaaaaaaaaaaaaa,\n" 5246 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 5247 NoBinPacking); 5248 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 5249 " aaaaaaaaaaaaa,\n" 5250 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 5251 NoBinPacking); 5252 verifyFormat( 5253 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5254 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5255 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5256 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5257 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 5258 NoBinPacking); 5259 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5260 " .aaaaaaaaaaaaaaaaaa();", 5261 NoBinPacking); 5262 verifyFormat("void f() {\n" 5263 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5264 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 5265 "}", 5266 NoBinPacking); 5267 5268 verifyFormat( 5269 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5270 " aaaaaaaaaaaa,\n" 5271 " aaaaaaaaaaaa);", 5272 NoBinPacking); 5273 verifyFormat( 5274 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 5275 " ddddddddddddddddddddddddddddd),\n" 5276 " test);", 5277 NoBinPacking); 5278 5279 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5280 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 5281 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 5282 " aaaaaaaaaaaaaaaaaa;", 5283 NoBinPacking); 5284 verifyFormat("a(\"a\"\n" 5285 " \"a\",\n" 5286 " a);"); 5287 5288 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5289 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 5290 " aaaaaaaaa,\n" 5291 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5292 NoBinPacking); 5293 verifyFormat( 5294 "void f() {\n" 5295 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5296 " .aaaaaaa();\n" 5297 "}", 5298 NoBinPacking); 5299 verifyFormat( 5300 "template <class SomeType, class SomeOtherType>\n" 5301 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 5302 NoBinPacking); 5303 } 5304 5305 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 5306 FormatStyle Style = getLLVMStyleWithColumns(15); 5307 Style.ExperimentalAutoDetectBinPacking = true; 5308 EXPECT_EQ("aaa(aaaa,\n" 5309 " aaaa,\n" 5310 " aaaa);\n" 5311 "aaa(aaaa,\n" 5312 " aaaa,\n" 5313 " aaaa);", 5314 format("aaa(aaaa,\n" // one-per-line 5315 " aaaa,\n" 5316 " aaaa );\n" 5317 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5318 Style)); 5319 EXPECT_EQ("aaa(aaaa, aaaa,\n" 5320 " aaaa);\n" 5321 "aaa(aaaa, aaaa,\n" 5322 " aaaa);", 5323 format("aaa(aaaa, aaaa,\n" // bin-packed 5324 " aaaa );\n" 5325 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5326 Style)); 5327 } 5328 5329 TEST_F(FormatTest, FormatsBuilderPattern) { 5330 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 5331 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 5332 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 5333 " .StartsWith(\".init\", ORDER_INIT)\n" 5334 " .StartsWith(\".fini\", ORDER_FINI)\n" 5335 " .StartsWith(\".hash\", ORDER_HASH)\n" 5336 " .Default(ORDER_TEXT);\n"); 5337 5338 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 5339 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 5340 verifyFormat("aaaaaaa->aaaaaaa\n" 5341 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5342 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5343 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5344 verifyFormat( 5345 "aaaaaaa->aaaaaaa\n" 5346 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5347 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5348 verifyFormat( 5349 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 5350 " aaaaaaaaaaaaaa);"); 5351 verifyFormat( 5352 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 5353 " aaaaaa->aaaaaaaaaaaa()\n" 5354 " ->aaaaaaaaaaaaaaaa(\n" 5355 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5356 " ->aaaaaaaaaaaaaaaaa();"); 5357 verifyGoogleFormat( 5358 "void f() {\n" 5359 " someo->Add((new util::filetools::Handler(dir))\n" 5360 " ->OnEvent1(NewPermanentCallback(\n" 5361 " this, &HandlerHolderClass::EventHandlerCBA))\n" 5362 " ->OnEvent2(NewPermanentCallback(\n" 5363 " this, &HandlerHolderClass::EventHandlerCBB))\n" 5364 " ->OnEvent3(NewPermanentCallback(\n" 5365 " this, &HandlerHolderClass::EventHandlerCBC))\n" 5366 " ->OnEvent5(NewPermanentCallback(\n" 5367 " this, &HandlerHolderClass::EventHandlerCBD))\n" 5368 " ->OnEvent6(NewPermanentCallback(\n" 5369 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 5370 "}"); 5371 5372 verifyFormat( 5373 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 5374 verifyFormat("aaaaaaaaaaaaaaa()\n" 5375 " .aaaaaaaaaaaaaaa()\n" 5376 " .aaaaaaaaaaaaaaa()\n" 5377 " .aaaaaaaaaaaaaaa()\n" 5378 " .aaaaaaaaaaaaaaa();"); 5379 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5380 " .aaaaaaaaaaaaaaa()\n" 5381 " .aaaaaaaaaaaaaaa()\n" 5382 " .aaaaaaaaaaaaaaa();"); 5383 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5384 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5385 " .aaaaaaaaaaaaaaa();"); 5386 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 5387 " ->aaaaaaaaaaaaaae(0)\n" 5388 " ->aaaaaaaaaaaaaaa();"); 5389 5390 // Don't linewrap after very short segments. 5391 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5392 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5393 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5394 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5395 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5396 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5397 verifyFormat("aaa()\n" 5398 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5399 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5400 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5401 5402 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5403 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5404 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 5405 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5406 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 5407 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 5408 5409 // Prefer not to break after empty parentheses. 5410 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 5411 " First->LastNewlineOffset);"); 5412 5413 // Prefer not to create "hanging" indents. 5414 verifyFormat( 5415 "return !soooooooooooooome_map\n" 5416 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5417 " .second;"); 5418 verifyFormat( 5419 "return aaaaaaaaaaaaaaaa\n" 5420 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 5421 " .aaaa(aaaaaaaaaaaaaa);"); 5422 // No hanging indent here. 5423 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5424 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5425 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5426 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5427 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5428 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5429 getLLVMStyleWithColumns(60)); 5430 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5431 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5432 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5433 getLLVMStyleWithColumns(59)); 5434 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5435 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5436 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5437 5438 // Dont break if only closing statements before member call 5439 verifyFormat("test() {\n" 5440 " ([]() -> {\n" 5441 " int b = 32;\n" 5442 " return 3;\n" 5443 " }).foo();\n" 5444 "}"); 5445 verifyFormat("test() {\n" 5446 " (\n" 5447 " []() -> {\n" 5448 " int b = 32;\n" 5449 " return 3;\n" 5450 " },\n" 5451 " foo, bar)\n" 5452 " .foo();\n" 5453 "}"); 5454 verifyFormat("test() {\n" 5455 " ([]() -> {\n" 5456 " int b = 32;\n" 5457 " return 3;\n" 5458 " })\n" 5459 " .foo()\n" 5460 " .bar();\n" 5461 "}"); 5462 verifyFormat("test() {\n" 5463 " ([]() -> {\n" 5464 " int b = 32;\n" 5465 " return 3;\n" 5466 " })\n" 5467 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5468 " \"bbbb\");\n" 5469 "}", 5470 getLLVMStyleWithColumns(30)); 5471 } 5472 5473 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5474 verifyFormat( 5475 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5476 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5477 verifyFormat( 5478 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5479 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5480 5481 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5482 " ccccccccccccccccccccccccc) {\n}"); 5483 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5484 " ccccccccccccccccccccccccc) {\n}"); 5485 5486 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5487 " ccccccccccccccccccccccccc) {\n}"); 5488 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5489 " ccccccccccccccccccccccccc) {\n}"); 5490 5491 verifyFormat( 5492 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5493 " ccccccccccccccccccccccccc) {\n}"); 5494 verifyFormat( 5495 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5496 " ccccccccccccccccccccccccc) {\n}"); 5497 5498 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5499 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5500 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5501 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5502 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5503 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5504 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5505 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5506 5507 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5508 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5509 " aaaaaaaaaaaaaaa != aa) {\n}"); 5510 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5511 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5512 " aaaaaaaaaaaaaaa != aa) {\n}"); 5513 } 5514 5515 TEST_F(FormatTest, BreaksAfterAssignments) { 5516 verifyFormat( 5517 "unsigned Cost =\n" 5518 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5519 " SI->getPointerAddressSpaceee());\n"); 5520 verifyFormat( 5521 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5522 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5523 5524 verifyFormat( 5525 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5526 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5527 verifyFormat("unsigned OriginalStartColumn =\n" 5528 " SourceMgr.getSpellingColumnNumber(\n" 5529 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5530 " 1;"); 5531 } 5532 5533 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5534 FormatStyle Style = getLLVMStyle(); 5535 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5536 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5537 Style); 5538 5539 Style.PenaltyBreakAssignment = 20; 5540 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5541 " cccccccccccccccccccccccccc;", 5542 Style); 5543 } 5544 5545 TEST_F(FormatTest, AlignsAfterAssignments) { 5546 verifyFormat( 5547 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5548 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5549 verifyFormat( 5550 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5551 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5552 verifyFormat( 5553 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5554 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5555 verifyFormat( 5556 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5557 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5558 verifyFormat( 5559 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5560 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5561 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5562 } 5563 5564 TEST_F(FormatTest, AlignsAfterReturn) { 5565 verifyFormat( 5566 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5567 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5568 verifyFormat( 5569 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5570 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5571 verifyFormat( 5572 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5573 " aaaaaaaaaaaaaaaaaaaaaa();"); 5574 verifyFormat( 5575 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5576 " aaaaaaaaaaaaaaaaaaaaaa());"); 5577 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5578 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5579 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5580 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5581 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5582 verifyFormat("return\n" 5583 " // true if code is one of a or b.\n" 5584 " code == a || code == b;"); 5585 } 5586 5587 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5588 verifyFormat( 5589 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5590 " aaaaaaaaa aaaaaaa) {}"); 5591 verifyFormat( 5592 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5593 " aaaaaaaaaaa aaaaaaaaa);"); 5594 verifyFormat( 5595 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5596 " aaaaaaaaaaaaaaaaaaaaa));"); 5597 FormatStyle Style = getLLVMStyle(); 5598 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5599 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5600 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5601 Style); 5602 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5603 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5604 Style); 5605 verifyFormat("SomeLongVariableName->someFunction(\n" 5606 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5607 Style); 5608 verifyFormat( 5609 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5610 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5611 Style); 5612 verifyFormat( 5613 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5614 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5615 Style); 5616 verifyFormat( 5617 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5618 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5619 Style); 5620 5621 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5622 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5623 " b));", 5624 Style); 5625 5626 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5627 Style.BinPackArguments = false; 5628 Style.BinPackParameters = false; 5629 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5630 " aaaaaaaaaaa aaaaaaaa,\n" 5631 " aaaaaaaaa aaaaaaa,\n" 5632 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5633 Style); 5634 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5635 " aaaaaaaaaaa aaaaaaaaa,\n" 5636 " aaaaaaaaaaa aaaaaaaaa,\n" 5637 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5638 Style); 5639 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5640 " aaaaaaaaaaaaaaa,\n" 5641 " aaaaaaaaaaaaaaaaaaaaa,\n" 5642 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5643 Style); 5644 verifyFormat( 5645 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5646 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5647 Style); 5648 verifyFormat( 5649 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5650 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5651 Style); 5652 verifyFormat( 5653 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5654 " aaaaaaaaaaaaaaaaaaaaa(\n" 5655 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5656 " aaaaaaaaaaaaaaaa);", 5657 Style); 5658 verifyFormat( 5659 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5660 " aaaaaaaaaaaaaaaaaaaaa(\n" 5661 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5662 " aaaaaaaaaaaaaaaa);", 5663 Style); 5664 } 5665 5666 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5667 FormatStyle Style = getLLVMStyleWithColumns(40); 5668 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5669 " bbbbbbbbbbbbbbbbbbbbbb);", 5670 Style); 5671 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5672 Style.AlignOperands = false; 5673 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5674 " bbbbbbbbbbbbbbbbbbbbbb);", 5675 Style); 5676 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5677 Style.AlignOperands = true; 5678 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5679 " bbbbbbbbbbbbbbbbbbbbbb);", 5680 Style); 5681 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5682 Style.AlignOperands = false; 5683 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5684 " bbbbbbbbbbbbbbbbbbbbbb);", 5685 Style); 5686 } 5687 5688 TEST_F(FormatTest, BreaksConditionalExpressions) { 5689 verifyFormat( 5690 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5691 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5692 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5693 verifyFormat( 5694 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5695 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5696 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5697 verifyFormat( 5698 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5699 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5700 verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5701 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5702 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5703 verifyFormat( 5704 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5705 " : aaaaaaaaaaaaa);"); 5706 verifyFormat( 5707 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5708 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5709 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5710 " aaaaaaaaaaaaa);"); 5711 verifyFormat( 5712 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5713 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5714 " aaaaaaaaaaaaa);"); 5715 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5716 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5717 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5718 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5719 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5720 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5721 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5722 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5723 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5724 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5725 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5726 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5727 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5728 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5729 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5730 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5731 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5732 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5733 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5734 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5735 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5736 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5737 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5738 " : aaaaaaaaaaaaaaaa;"); 5739 verifyFormat( 5740 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5741 " ? aaaaaaaaaaaaaaa\n" 5742 " : aaaaaaaaaaaaaaa;"); 5743 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5744 " aaaaaaaaa\n" 5745 " ? b\n" 5746 " : c);"); 5747 verifyFormat("return aaaa == bbbb\n" 5748 " // comment\n" 5749 " ? aaaa\n" 5750 " : bbbb;"); 5751 verifyFormat("unsigned Indent =\n" 5752 " format(TheLine.First,\n" 5753 " IndentForLevel[TheLine.Level] >= 0\n" 5754 " ? IndentForLevel[TheLine.Level]\n" 5755 " : TheLine * 2,\n" 5756 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5757 getLLVMStyleWithColumns(60)); 5758 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5759 " ? aaaaaaaaaaaaaaa\n" 5760 " : bbbbbbbbbbbbbbb //\n" 5761 " ? ccccccccccccccc\n" 5762 " : ddddddddddddddd;"); 5763 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5764 " ? aaaaaaaaaaaaaaa\n" 5765 " : (bbbbbbbbbbbbbbb //\n" 5766 " ? ccccccccccccccc\n" 5767 " : ddddddddddddddd);"); 5768 verifyFormat( 5769 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5770 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5771 " aaaaaaaaaaaaaaaaaaaaa +\n" 5772 " aaaaaaaaaaaaaaaaaaaaa\n" 5773 " : aaaaaaaaaa;"); 5774 verifyFormat( 5775 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5776 " : aaaaaaaaaaaaaaaaaaaaaa\n" 5777 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5778 5779 FormatStyle NoBinPacking = getLLVMStyle(); 5780 NoBinPacking.BinPackArguments = false; 5781 verifyFormat( 5782 "void f() {\n" 5783 " g(aaa,\n" 5784 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5785 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5786 " ? aaaaaaaaaaaaaaa\n" 5787 " : aaaaaaaaaaaaaaa);\n" 5788 "}", 5789 NoBinPacking); 5790 verifyFormat( 5791 "void f() {\n" 5792 " g(aaa,\n" 5793 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5794 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5795 " ?: aaaaaaaaaaaaaaa);\n" 5796 "}", 5797 NoBinPacking); 5798 5799 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 5800 " // comment.\n" 5801 " ccccccccccccccccccccccccccccccccccccccc\n" 5802 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5803 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 5804 5805 // Assignments in conditional expressions. Apparently not uncommon :-(. 5806 verifyFormat("return a != b\n" 5807 " // comment\n" 5808 " ? a = b\n" 5809 " : a = b;"); 5810 verifyFormat("return a != b\n" 5811 " // comment\n" 5812 " ? a = a != b\n" 5813 " // comment\n" 5814 " ? a = b\n" 5815 " : a\n" 5816 " : a;\n"); 5817 verifyFormat("return a != b\n" 5818 " // comment\n" 5819 " ? a\n" 5820 " : a = a != b\n" 5821 " // comment\n" 5822 " ? a = b\n" 5823 " : a;"); 5824 } 5825 5826 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 5827 FormatStyle Style = getLLVMStyle(); 5828 Style.BreakBeforeTernaryOperators = false; 5829 Style.ColumnLimit = 70; 5830 verifyFormat( 5831 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5832 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5833 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5834 Style); 5835 verifyFormat( 5836 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5837 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5838 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5839 Style); 5840 verifyFormat( 5841 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5842 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5843 Style); 5844 verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n" 5845 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5846 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5847 Style); 5848 verifyFormat( 5849 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 5850 " aaaaaaaaaaaaa);", 5851 Style); 5852 verifyFormat( 5853 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5854 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5855 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5856 " aaaaaaaaaaaaa);", 5857 Style); 5858 verifyFormat( 5859 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5860 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5861 " aaaaaaaaaaaaa);", 5862 Style); 5863 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5864 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5865 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5866 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5867 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5868 Style); 5869 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5870 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5871 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5872 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5873 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5874 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5875 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5876 Style); 5877 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5878 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 5879 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5880 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5881 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5882 Style); 5883 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5884 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5885 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5886 Style); 5887 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5888 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5889 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5890 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5891 Style); 5892 verifyFormat( 5893 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5894 " aaaaaaaaaaaaaaa :\n" 5895 " aaaaaaaaaaaaaaa;", 5896 Style); 5897 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5898 " aaaaaaaaa ?\n" 5899 " b :\n" 5900 " c);", 5901 Style); 5902 verifyFormat("unsigned Indent =\n" 5903 " format(TheLine.First,\n" 5904 " IndentForLevel[TheLine.Level] >= 0 ?\n" 5905 " IndentForLevel[TheLine.Level] :\n" 5906 " TheLine * 2,\n" 5907 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5908 Style); 5909 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5910 " aaaaaaaaaaaaaaa :\n" 5911 " bbbbbbbbbbbbbbb ? //\n" 5912 " ccccccccccccccc :\n" 5913 " ddddddddddddddd;", 5914 Style); 5915 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5916 " aaaaaaaaaaaaaaa :\n" 5917 " (bbbbbbbbbbbbbbb ? //\n" 5918 " ccccccccccccccc :\n" 5919 " ddddddddddddddd);", 5920 Style); 5921 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5922 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 5923 " ccccccccccccccccccccccccccc;", 5924 Style); 5925 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5926 " aaaaa :\n" 5927 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 5928 Style); 5929 } 5930 5931 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 5932 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 5933 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 5934 verifyFormat("bool a = true, b = false;"); 5935 5936 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5937 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 5938 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 5939 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 5940 verifyFormat( 5941 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 5942 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 5943 " d = e && f;"); 5944 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 5945 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 5946 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5947 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 5948 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 5949 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 5950 5951 FormatStyle Style = getGoogleStyle(); 5952 Style.PointerAlignment = FormatStyle::PAS_Left; 5953 Style.DerivePointerAlignment = false; 5954 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5955 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 5956 " *b = bbbbbbbbbbbbbbbbbbb;", 5957 Style); 5958 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5959 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 5960 Style); 5961 verifyFormat("vector<int*> a, b;", Style); 5962 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 5963 } 5964 5965 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 5966 verifyFormat("arr[foo ? bar : baz];"); 5967 verifyFormat("f()[foo ? bar : baz];"); 5968 verifyFormat("(a + b)[foo ? bar : baz];"); 5969 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 5970 } 5971 5972 TEST_F(FormatTest, AlignsStringLiterals) { 5973 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 5974 " \"short literal\");"); 5975 verifyFormat( 5976 "looooooooooooooooooooooooongFunction(\n" 5977 " \"short literal\"\n" 5978 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 5979 verifyFormat("someFunction(\"Always break between multi-line\"\n" 5980 " \" string literals\",\n" 5981 " and, other, parameters);"); 5982 EXPECT_EQ("fun + \"1243\" /* comment */\n" 5983 " \"5678\";", 5984 format("fun + \"1243\" /* comment */\n" 5985 " \"5678\";", 5986 getLLVMStyleWithColumns(28))); 5987 EXPECT_EQ( 5988 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 5989 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 5990 " \"aaaaaaaaaaaaaaaa\";", 5991 format("aaaaaa =" 5992 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 5993 "aaaaaaaaaaaaaaaaaaaaa\" " 5994 "\"aaaaaaaaaaaaaaaa\";")); 5995 verifyFormat("a = a + \"a\"\n" 5996 " \"a\"\n" 5997 " \"a\";"); 5998 verifyFormat("f(\"a\", \"b\"\n" 5999 " \"c\");"); 6000 6001 verifyFormat( 6002 "#define LL_FORMAT \"ll\"\n" 6003 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 6004 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 6005 6006 verifyFormat("#define A(X) \\\n" 6007 " \"aaaaa\" #X \"bbbbbb\" \\\n" 6008 " \"ccccc\"", 6009 getLLVMStyleWithColumns(23)); 6010 verifyFormat("#define A \"def\"\n" 6011 "f(\"abc\" A \"ghi\"\n" 6012 " \"jkl\");"); 6013 6014 verifyFormat("f(L\"a\"\n" 6015 " L\"b\");"); 6016 verifyFormat("#define A(X) \\\n" 6017 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 6018 " L\"ccccc\"", 6019 getLLVMStyleWithColumns(25)); 6020 6021 verifyFormat("f(@\"a\"\n" 6022 " @\"b\");"); 6023 verifyFormat("NSString s = @\"a\"\n" 6024 " @\"b\"\n" 6025 " @\"c\";"); 6026 verifyFormat("NSString s = @\"a\"\n" 6027 " \"b\"\n" 6028 " \"c\";"); 6029 } 6030 6031 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 6032 FormatStyle Style = getLLVMStyle(); 6033 // No declarations or definitions should be moved to own line. 6034 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 6035 verifyFormat("class A {\n" 6036 " int f() { return 1; }\n" 6037 " int g();\n" 6038 "};\n" 6039 "int f() { return 1; }\n" 6040 "int g();\n", 6041 Style); 6042 6043 // All declarations and definitions should have the return type moved to its 6044 // own 6045 // line. 6046 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 6047 verifyFormat("class E {\n" 6048 " int\n" 6049 " f() {\n" 6050 " return 1;\n" 6051 " }\n" 6052 " int\n" 6053 " g();\n" 6054 "};\n" 6055 "int\n" 6056 "f() {\n" 6057 " return 1;\n" 6058 "}\n" 6059 "int\n" 6060 "g();\n", 6061 Style); 6062 6063 // Top-level definitions, and no kinds of declarations should have the 6064 // return type moved to its own line. 6065 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 6066 verifyFormat("class B {\n" 6067 " int f() { return 1; }\n" 6068 " int g();\n" 6069 "};\n" 6070 "int\n" 6071 "f() {\n" 6072 " return 1;\n" 6073 "}\n" 6074 "int g();\n", 6075 Style); 6076 6077 // Top-level definitions and declarations should have the return type moved 6078 // to its own line. 6079 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 6080 verifyFormat("class C {\n" 6081 " int f() { return 1; }\n" 6082 " int g();\n" 6083 "};\n" 6084 "int\n" 6085 "f() {\n" 6086 " return 1;\n" 6087 "}\n" 6088 "int\n" 6089 "g();\n", 6090 Style); 6091 6092 // All definitions should have the return type moved to its own line, but no 6093 // kinds of declarations. 6094 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 6095 verifyFormat("class D {\n" 6096 " int\n" 6097 " f() {\n" 6098 " return 1;\n" 6099 " }\n" 6100 " int g();\n" 6101 "};\n" 6102 "int\n" 6103 "f() {\n" 6104 " return 1;\n" 6105 "}\n" 6106 "int g();\n", 6107 Style); 6108 verifyFormat("const char *\n" 6109 "f(void) {\n" // Break here. 6110 " return \"\";\n" 6111 "}\n" 6112 "const char *bar(void);\n", // No break here. 6113 Style); 6114 verifyFormat("template <class T>\n" 6115 "T *\n" 6116 "f(T &c) {\n" // Break here. 6117 " return NULL;\n" 6118 "}\n" 6119 "template <class T> T *f(T &c);\n", // No break here. 6120 Style); 6121 verifyFormat("class C {\n" 6122 " int\n" 6123 " operator+() {\n" 6124 " return 1;\n" 6125 " }\n" 6126 " int\n" 6127 " operator()() {\n" 6128 " return 1;\n" 6129 " }\n" 6130 "};\n", 6131 Style); 6132 verifyFormat("void\n" 6133 "A::operator()() {}\n" 6134 "void\n" 6135 "A::operator>>() {}\n" 6136 "void\n" 6137 "A::operator+() {}\n", 6138 Style); 6139 verifyFormat("void *operator new(std::size_t s);", // No break here. 6140 Style); 6141 verifyFormat("void *\n" 6142 "operator new(std::size_t s) {}", 6143 Style); 6144 verifyFormat("void *\n" 6145 "operator delete[](void *ptr) {}", 6146 Style); 6147 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 6148 verifyFormat("const char *\n" 6149 "f(void)\n" // Break here. 6150 "{\n" 6151 " return \"\";\n" 6152 "}\n" 6153 "const char *bar(void);\n", // No break here. 6154 Style); 6155 verifyFormat("template <class T>\n" 6156 "T *\n" // Problem here: no line break 6157 "f(T &c)\n" // Break here. 6158 "{\n" 6159 " return NULL;\n" 6160 "}\n" 6161 "template <class T> T *f(T &c);\n", // No break here. 6162 Style); 6163 verifyFormat("int\n" 6164 "foo(A<bool> a)\n" 6165 "{\n" 6166 " return a;\n" 6167 "}\n", 6168 Style); 6169 verifyFormat("int\n" 6170 "foo(A<8> a)\n" 6171 "{\n" 6172 " return a;\n" 6173 "}\n", 6174 Style); 6175 verifyFormat("int\n" 6176 "foo(A<B<bool>, 8> a)\n" 6177 "{\n" 6178 " return a;\n" 6179 "}\n", 6180 Style); 6181 verifyFormat("int\n" 6182 "foo(A<B<8>, bool> a)\n" 6183 "{\n" 6184 " return a;\n" 6185 "}\n", 6186 Style); 6187 verifyFormat("int\n" 6188 "foo(A<B<bool>, bool> a)\n" 6189 "{\n" 6190 " return a;\n" 6191 "}\n", 6192 Style); 6193 verifyFormat("int\n" 6194 "foo(A<B<8>, 8> a)\n" 6195 "{\n" 6196 " return a;\n" 6197 "}\n", 6198 Style); 6199 6200 Style = getGNUStyle(); 6201 6202 // Test for comments at the end of function declarations. 6203 verifyFormat("void\n" 6204 "foo (int a, /*abc*/ int b) // def\n" 6205 "{\n" 6206 "}\n", 6207 Style); 6208 6209 verifyFormat("void\n" 6210 "foo (int a, /* abc */ int b) /* def */\n" 6211 "{\n" 6212 "}\n", 6213 Style); 6214 6215 // Definitions that should not break after return type 6216 verifyFormat("void foo (int a, int b); // def\n", Style); 6217 verifyFormat("void foo (int a, int b); /* def */\n", Style); 6218 verifyFormat("void foo (int a, int b);\n", Style); 6219 } 6220 6221 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 6222 FormatStyle NoBreak = getLLVMStyle(); 6223 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 6224 FormatStyle Break = getLLVMStyle(); 6225 Break.AlwaysBreakBeforeMultilineStrings = true; 6226 verifyFormat("aaaa = \"bbbb\"\n" 6227 " \"cccc\";", 6228 NoBreak); 6229 verifyFormat("aaaa =\n" 6230 " \"bbbb\"\n" 6231 " \"cccc\";", 6232 Break); 6233 verifyFormat("aaaa(\"bbbb\"\n" 6234 " \"cccc\");", 6235 NoBreak); 6236 verifyFormat("aaaa(\n" 6237 " \"bbbb\"\n" 6238 " \"cccc\");", 6239 Break); 6240 verifyFormat("aaaa(qqq, \"bbbb\"\n" 6241 " \"cccc\");", 6242 NoBreak); 6243 verifyFormat("aaaa(qqq,\n" 6244 " \"bbbb\"\n" 6245 " \"cccc\");", 6246 Break); 6247 verifyFormat("aaaa(qqq,\n" 6248 " L\"bbbb\"\n" 6249 " L\"cccc\");", 6250 Break); 6251 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 6252 " \"bbbb\"));", 6253 Break); 6254 verifyFormat("string s = someFunction(\n" 6255 " \"abc\"\n" 6256 " \"abc\");", 6257 Break); 6258 6259 // As we break before unary operators, breaking right after them is bad. 6260 verifyFormat("string foo = abc ? \"x\"\n" 6261 " \"blah blah blah blah blah blah\"\n" 6262 " : \"y\";", 6263 Break); 6264 6265 // Don't break if there is no column gain. 6266 verifyFormat("f(\"aaaa\"\n" 6267 " \"bbbb\");", 6268 Break); 6269 6270 // Treat literals with escaped newlines like multi-line string literals. 6271 EXPECT_EQ("x = \"a\\\n" 6272 "b\\\n" 6273 "c\";", 6274 format("x = \"a\\\n" 6275 "b\\\n" 6276 "c\";", 6277 NoBreak)); 6278 EXPECT_EQ("xxxx =\n" 6279 " \"a\\\n" 6280 "b\\\n" 6281 "c\";", 6282 format("xxxx = \"a\\\n" 6283 "b\\\n" 6284 "c\";", 6285 Break)); 6286 6287 EXPECT_EQ("NSString *const kString =\n" 6288 " @\"aaaa\"\n" 6289 " @\"bbbb\";", 6290 format("NSString *const kString = @\"aaaa\"\n" 6291 "@\"bbbb\";", 6292 Break)); 6293 6294 Break.ColumnLimit = 0; 6295 verifyFormat("const char *hello = \"hello llvm\";", Break); 6296 } 6297 6298 TEST_F(FormatTest, AlignsPipes) { 6299 verifyFormat( 6300 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6301 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6302 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6303 verifyFormat( 6304 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 6305 " << aaaaaaaaaaaaaaaaaaaa;"); 6306 verifyFormat( 6307 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6308 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6309 verifyFormat( 6310 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 6311 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6312 verifyFormat( 6313 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 6314 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 6315 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 6316 verifyFormat( 6317 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6318 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6319 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6320 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6321 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6322 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6323 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6324 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 6325 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 6326 verifyFormat( 6327 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6328 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6329 verifyFormat( 6330 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 6331 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6332 6333 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 6334 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 6335 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6336 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6337 " aaaaaaaaaaaaaaaaaaaaa)\n" 6338 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6339 verifyFormat("LOG_IF(aaa == //\n" 6340 " bbb)\n" 6341 " << a << b;"); 6342 6343 // But sometimes, breaking before the first "<<" is desirable. 6344 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6345 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 6346 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 6347 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6348 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6349 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 6350 " << BEF << IsTemplate << Description << E->getType();"); 6351 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6352 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6353 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6354 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6355 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6356 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6357 " << aaa;"); 6358 6359 verifyFormat( 6360 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6361 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6362 6363 // Incomplete string literal. 6364 EXPECT_EQ("llvm::errs() << \"\n" 6365 " << a;", 6366 format("llvm::errs() << \"\n<<a;")); 6367 6368 verifyFormat("void f() {\n" 6369 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 6370 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 6371 "}"); 6372 6373 // Handle 'endl'. 6374 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 6375 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6376 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6377 6378 // Handle '\n'. 6379 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 6380 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6381 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 6382 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 6383 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 6384 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 6385 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6386 } 6387 6388 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 6389 verifyFormat("return out << \"somepacket = {\\n\"\n" 6390 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 6391 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 6392 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 6393 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 6394 " << \"}\";"); 6395 6396 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6397 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6398 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 6399 verifyFormat( 6400 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 6401 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 6402 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 6403 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 6404 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 6405 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 6406 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6407 verifyFormat( 6408 "void f() {\n" 6409 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 6410 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 6411 "}"); 6412 6413 // Breaking before the first "<<" is generally not desirable. 6414 verifyFormat( 6415 "llvm::errs()\n" 6416 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6417 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6418 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6419 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6420 getLLVMStyleWithColumns(70)); 6421 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6422 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6423 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6424 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6425 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6426 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6427 getLLVMStyleWithColumns(70)); 6428 6429 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6430 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6431 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6432 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6433 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6434 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 6435 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 6436 " (aaaa + aaaa);", 6437 getLLVMStyleWithColumns(40)); 6438 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 6439 " (aaaaaaa + aaaaa));", 6440 getLLVMStyleWithColumns(40)); 6441 verifyFormat( 6442 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 6443 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 6444 " bbbbbbbbbbbbbbbbbbbbbbb);"); 6445 } 6446 6447 TEST_F(FormatTest, UnderstandsEquals) { 6448 verifyFormat( 6449 "aaaaaaaaaaaaaaaaa =\n" 6450 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6451 verifyFormat( 6452 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6453 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6454 verifyFormat( 6455 "if (a) {\n" 6456 " f();\n" 6457 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6458 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 6459 "}"); 6460 6461 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6462 " 100000000 + 10000000) {\n}"); 6463 } 6464 6465 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 6466 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6467 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 6468 6469 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6470 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 6471 6472 verifyFormat( 6473 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 6474 " Parameter2);"); 6475 6476 verifyFormat( 6477 "ShortObject->shortFunction(\n" 6478 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 6479 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 6480 6481 verifyFormat("loooooooooooooongFunction(\n" 6482 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 6483 6484 verifyFormat( 6485 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 6486 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 6487 6488 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6489 " .WillRepeatedly(Return(SomeValue));"); 6490 verifyFormat("void f() {\n" 6491 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6492 " .Times(2)\n" 6493 " .WillRepeatedly(Return(SomeValue));\n" 6494 "}"); 6495 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 6496 " ccccccccccccccccccccccc);"); 6497 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6498 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6499 " .aaaaa(aaaaa),\n" 6500 " aaaaaaaaaaaaaaaaaaaaa);"); 6501 verifyFormat("void f() {\n" 6502 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6503 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 6504 "}"); 6505 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6506 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6507 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6508 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6509 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6510 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6511 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6512 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6513 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 6514 "}"); 6515 6516 // Here, it is not necessary to wrap at "." or "->". 6517 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 6518 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6519 verifyFormat( 6520 "aaaaaaaaaaa->aaaaaaaaa(\n" 6521 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6522 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 6523 6524 verifyFormat( 6525 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6526 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 6527 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 6528 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6529 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 6530 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6531 6532 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6533 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6534 " .a();"); 6535 6536 FormatStyle NoBinPacking = getLLVMStyle(); 6537 NoBinPacking.BinPackParameters = false; 6538 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6539 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6540 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 6541 " aaaaaaaaaaaaaaaaaaa,\n" 6542 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6543 NoBinPacking); 6544 6545 // If there is a subsequent call, change to hanging indentation. 6546 verifyFormat( 6547 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6548 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 6549 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6550 verifyFormat( 6551 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6552 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 6553 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6554 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6555 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6556 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6557 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6558 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6559 } 6560 6561 TEST_F(FormatTest, WrapsTemplateDeclarations) { 6562 verifyFormat("template <typename T>\n" 6563 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6564 verifyFormat("template <typename T>\n" 6565 "// T should be one of {A, B}.\n" 6566 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6567 verifyFormat( 6568 "template <typename T>\n" 6569 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 6570 verifyFormat("template <typename T>\n" 6571 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 6572 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 6573 verifyFormat( 6574 "template <typename T>\n" 6575 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 6576 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 6577 verifyFormat( 6578 "template <typename T>\n" 6579 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 6580 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 6581 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6582 verifyFormat("template <typename T>\n" 6583 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6584 " int aaaaaaaaaaaaaaaaaaaaaa);"); 6585 verifyFormat( 6586 "template <typename T1, typename T2 = char, typename T3 = char,\n" 6587 " typename T4 = char>\n" 6588 "void f();"); 6589 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 6590 " template <typename> class cccccccccccccccccccccc,\n" 6591 " typename ddddddddddddd>\n" 6592 "class C {};"); 6593 verifyFormat( 6594 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 6595 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6596 6597 verifyFormat("void f() {\n" 6598 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 6599 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 6600 "}"); 6601 6602 verifyFormat("template <typename T> class C {};"); 6603 verifyFormat("template <typename T> void f();"); 6604 verifyFormat("template <typename T> void f() {}"); 6605 verifyFormat( 6606 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6607 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6608 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 6609 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6610 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6611 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 6612 " bbbbbbbbbbbbbbbbbbbbbbbb);", 6613 getLLVMStyleWithColumns(72)); 6614 EXPECT_EQ("static_cast<A< //\n" 6615 " B> *>(\n" 6616 "\n" 6617 ");", 6618 format("static_cast<A<//\n" 6619 " B>*>(\n" 6620 "\n" 6621 " );")); 6622 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6623 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 6624 6625 FormatStyle AlwaysBreak = getLLVMStyle(); 6626 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 6627 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 6628 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 6629 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 6630 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6631 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6632 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 6633 verifyFormat("template <template <typename> class Fooooooo,\n" 6634 " template <typename> class Baaaaaaar>\n" 6635 "struct C {};", 6636 AlwaysBreak); 6637 verifyFormat("template <typename T> // T can be A, B or C.\n" 6638 "struct C {};", 6639 AlwaysBreak); 6640 verifyFormat("template <enum E> class A {\n" 6641 "public:\n" 6642 " E *f();\n" 6643 "};"); 6644 6645 FormatStyle NeverBreak = getLLVMStyle(); 6646 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 6647 verifyFormat("template <typename T> class C {};", NeverBreak); 6648 verifyFormat("template <typename T> void f();", NeverBreak); 6649 verifyFormat("template <typename T> void f() {}", NeverBreak); 6650 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6651 "bbbbbbbbbbbbbbbbbbbb) {}", 6652 NeverBreak); 6653 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6654 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6655 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 6656 NeverBreak); 6657 verifyFormat("template <template <typename> class Fooooooo,\n" 6658 " template <typename> class Baaaaaaar>\n" 6659 "struct C {};", 6660 NeverBreak); 6661 verifyFormat("template <typename T> // T can be A, B or C.\n" 6662 "struct C {};", 6663 NeverBreak); 6664 verifyFormat("template <enum E> class A {\n" 6665 "public:\n" 6666 " E *f();\n" 6667 "};", 6668 NeverBreak); 6669 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 6670 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6671 "bbbbbbbbbbbbbbbbbbbb) {}", 6672 NeverBreak); 6673 } 6674 6675 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 6676 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 6677 Style.ColumnLimit = 60; 6678 EXPECT_EQ("// Baseline - no comments.\n" 6679 "template <\n" 6680 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6681 "void f() {}", 6682 format("// Baseline - no comments.\n" 6683 "template <\n" 6684 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6685 "void f() {}", 6686 Style)); 6687 6688 EXPECT_EQ("template <\n" 6689 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6690 "void f() {}", 6691 format("template <\n" 6692 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6693 "void f() {}", 6694 Style)); 6695 6696 EXPECT_EQ( 6697 "template <\n" 6698 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6699 "void f() {}", 6700 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6701 "void f() {}", 6702 Style)); 6703 6704 EXPECT_EQ( 6705 "template <\n" 6706 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6707 " // multiline\n" 6708 "void f() {}", 6709 format("template <\n" 6710 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6711 " // multiline\n" 6712 "void f() {}", 6713 Style)); 6714 6715 EXPECT_EQ( 6716 "template <typename aaaaaaaaaa<\n" 6717 " bbbbbbbbbbbb>::value> // trailing loooong\n" 6718 "void f() {}", 6719 format( 6720 "template <\n" 6721 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 6722 "void f() {}", 6723 Style)); 6724 } 6725 6726 TEST_F(FormatTest, WrapsTemplateParameters) { 6727 FormatStyle Style = getLLVMStyle(); 6728 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6729 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6730 verifyFormat( 6731 "template <typename... a> struct q {};\n" 6732 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6733 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6734 " y;", 6735 Style); 6736 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6737 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6738 verifyFormat( 6739 "template <typename... a> struct r {};\n" 6740 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6741 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6742 " y;", 6743 Style); 6744 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6745 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6746 verifyFormat("template <typename... a> struct s {};\n" 6747 "extern s<\n" 6748 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6749 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6750 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6751 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6752 " y;", 6753 Style); 6754 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6755 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6756 verifyFormat("template <typename... a> struct t {};\n" 6757 "extern t<\n" 6758 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6759 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6760 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6761 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6762 " y;", 6763 Style); 6764 } 6765 6766 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 6767 verifyFormat( 6768 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6769 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6770 verifyFormat( 6771 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6772 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6773 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6774 6775 // FIXME: Should we have the extra indent after the second break? 6776 verifyFormat( 6777 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6778 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6779 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6780 6781 verifyFormat( 6782 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 6783 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 6784 6785 // Breaking at nested name specifiers is generally not desirable. 6786 verifyFormat( 6787 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6788 " aaaaaaaaaaaaaaaaaaaaaaa);"); 6789 6790 verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 6791 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6792 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6793 " aaaaaaaaaaaaaaaaaaaaa);", 6794 getLLVMStyleWithColumns(74)); 6795 6796 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6797 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6798 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6799 } 6800 6801 TEST_F(FormatTest, UnderstandsTemplateParameters) { 6802 verifyFormat("A<int> a;"); 6803 verifyFormat("A<A<A<int>>> a;"); 6804 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 6805 verifyFormat("bool x = a < 1 || 2 > a;"); 6806 verifyFormat("bool x = 5 < f<int>();"); 6807 verifyFormat("bool x = f<int>() > 5;"); 6808 verifyFormat("bool x = 5 < a<int>::x;"); 6809 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 6810 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 6811 6812 verifyGoogleFormat("A<A<int>> a;"); 6813 verifyGoogleFormat("A<A<A<int>>> a;"); 6814 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 6815 verifyGoogleFormat("A<A<int> > a;"); 6816 verifyGoogleFormat("A<A<A<int> > > a;"); 6817 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 6818 verifyGoogleFormat("A<::A<int>> a;"); 6819 verifyGoogleFormat("A<::A> a;"); 6820 verifyGoogleFormat("A< ::A> a;"); 6821 verifyGoogleFormat("A< ::A<int> > a;"); 6822 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 6823 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 6824 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 6825 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 6826 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 6827 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 6828 6829 verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 6830 6831 // template closer followed by a token that starts with > or = 6832 verifyFormat("bool b = a<1> > 1;"); 6833 verifyFormat("bool b = a<1> >= 1;"); 6834 verifyFormat("int i = a<1> >> 1;"); 6835 FormatStyle Style = getLLVMStyle(); 6836 Style.SpaceBeforeAssignmentOperators = false; 6837 verifyFormat("bool b= a<1> == 1;", Style); 6838 verifyFormat("a<int> = 1;", Style); 6839 verifyFormat("a<int> >>= 1;", Style); 6840 6841 verifyFormat("test >> a >> b;"); 6842 verifyFormat("test << a >> b;"); 6843 6844 verifyFormat("f<int>();"); 6845 verifyFormat("template <typename T> void f() {}"); 6846 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 6847 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 6848 "sizeof(char)>::type>;"); 6849 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 6850 verifyFormat("f(a.operator()<A>());"); 6851 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6852 " .template operator()<A>());", 6853 getLLVMStyleWithColumns(35)); 6854 6855 // Not template parameters. 6856 verifyFormat("return a < b && c > d;"); 6857 verifyFormat("void f() {\n" 6858 " while (a < b && c > d) {\n" 6859 " }\n" 6860 "}"); 6861 verifyFormat("template <typename... Types>\n" 6862 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 6863 6864 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6865 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 6866 getLLVMStyleWithColumns(60)); 6867 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 6868 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 6869 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 6870 } 6871 6872 TEST_F(FormatTest, BitshiftOperatorWidth) { 6873 EXPECT_EQ("int a = 1 << 2; /* foo\n" 6874 " bar */", 6875 format("int a=1<<2; /* foo\n" 6876 " bar */")); 6877 6878 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 6879 " bar */", 6880 format("int b =256>>1 ; /* foo\n" 6881 " bar */")); 6882 } 6883 6884 TEST_F(FormatTest, UnderstandsBinaryOperators) { 6885 verifyFormat("COMPARE(a, ==, b);"); 6886 verifyFormat("auto s = sizeof...(Ts) - 1;"); 6887 } 6888 6889 TEST_F(FormatTest, UnderstandsPointersToMembers) { 6890 verifyFormat("int A::*x;"); 6891 verifyFormat("int (S::*func)(void *);"); 6892 verifyFormat("void f() { int (S::*func)(void *); }"); 6893 verifyFormat("typedef bool *(Class::*Member)() const;"); 6894 verifyFormat("void f() {\n" 6895 " (a->*f)();\n" 6896 " a->*x;\n" 6897 " (a.*f)();\n" 6898 " ((*a).*f)();\n" 6899 " a.*x;\n" 6900 "}"); 6901 verifyFormat("void f() {\n" 6902 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 6903 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 6904 "}"); 6905 verifyFormat( 6906 "(aaaaaaaaaa->*bbbbbbb)(\n" 6907 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6908 FormatStyle Style = getLLVMStyle(); 6909 Style.PointerAlignment = FormatStyle::PAS_Left; 6910 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 6911 } 6912 6913 TEST_F(FormatTest, UnderstandsUnaryOperators) { 6914 verifyFormat("int a = -2;"); 6915 verifyFormat("f(-1, -2, -3);"); 6916 verifyFormat("a[-1] = 5;"); 6917 verifyFormat("int a = 5 + -2;"); 6918 verifyFormat("if (i == -1) {\n}"); 6919 verifyFormat("if (i != -1) {\n}"); 6920 verifyFormat("if (i > -1) {\n}"); 6921 verifyFormat("if (i < -1) {\n}"); 6922 verifyFormat("++(a->f());"); 6923 verifyFormat("--(a->f());"); 6924 verifyFormat("(a->f())++;"); 6925 verifyFormat("a[42]++;"); 6926 verifyFormat("if (!(a->f())) {\n}"); 6927 verifyFormat("if (!+i) {\n}"); 6928 verifyFormat("~&a;"); 6929 6930 verifyFormat("a-- > b;"); 6931 verifyFormat("b ? -a : c;"); 6932 verifyFormat("n * sizeof char16;"); 6933 verifyFormat("n * alignof char16;", getGoogleStyle()); 6934 verifyFormat("sizeof(char);"); 6935 verifyFormat("alignof(char);", getGoogleStyle()); 6936 6937 verifyFormat("return -1;"); 6938 verifyFormat("throw -1;"); 6939 verifyFormat("switch (a) {\n" 6940 "case -1:\n" 6941 " break;\n" 6942 "}"); 6943 verifyFormat("#define X -1"); 6944 verifyFormat("#define X -kConstant"); 6945 6946 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 6947 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 6948 6949 verifyFormat("int a = /* confusing comment */ -1;"); 6950 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 6951 verifyFormat("int a = i /* confusing comment */++;"); 6952 } 6953 6954 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 6955 verifyFormat("if (!aaaaaaaaaa( // break\n" 6956 " aaaaa)) {\n" 6957 "}"); 6958 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 6959 " aaaaa));"); 6960 verifyFormat("*aaa = aaaaaaa( // break\n" 6961 " bbbbbb);"); 6962 } 6963 6964 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 6965 verifyFormat("bool operator<();"); 6966 verifyFormat("bool operator>();"); 6967 verifyFormat("bool operator=();"); 6968 verifyFormat("bool operator==();"); 6969 verifyFormat("bool operator!=();"); 6970 verifyFormat("int operator+();"); 6971 verifyFormat("int operator++();"); 6972 verifyFormat("int operator++(int) volatile noexcept;"); 6973 verifyFormat("bool operator,();"); 6974 verifyFormat("bool operator();"); 6975 verifyFormat("bool operator()();"); 6976 verifyFormat("bool operator[]();"); 6977 verifyFormat("operator bool();"); 6978 verifyFormat("operator int();"); 6979 verifyFormat("operator void *();"); 6980 verifyFormat("operator SomeType<int>();"); 6981 verifyFormat("operator SomeType<int, int>();"); 6982 verifyFormat("operator SomeType<SomeType<int>>();"); 6983 verifyFormat("void *operator new(std::size_t size);"); 6984 verifyFormat("void *operator new[](std::size_t size);"); 6985 verifyFormat("void operator delete(void *ptr);"); 6986 verifyFormat("void operator delete[](void *ptr);"); 6987 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 6988 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 6989 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 6990 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 6991 6992 verifyFormat( 6993 "ostream &operator<<(ostream &OutputStream,\n" 6994 " SomeReallyLongType WithSomeReallyLongValue);"); 6995 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 6996 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 6997 " return left.group < right.group;\n" 6998 "}"); 6999 verifyFormat("SomeType &operator=(const SomeType &S);"); 7000 verifyFormat("f.template operator()<int>();"); 7001 7002 verifyGoogleFormat("operator void*();"); 7003 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 7004 verifyGoogleFormat("operator ::A();"); 7005 7006 verifyFormat("using A::operator+;"); 7007 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 7008 "int i;"); 7009 } 7010 7011 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 7012 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 7013 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 7014 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 7015 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 7016 verifyFormat("Deleted &operator=(const Deleted &) &;"); 7017 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 7018 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 7019 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 7020 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 7021 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 7022 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 7023 verifyFormat("void Fn(T const &) const &;"); 7024 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 7025 verifyFormat("template <typename T>\n" 7026 "void F(T) && = delete;", 7027 getGoogleStyle()); 7028 7029 FormatStyle AlignLeft = getLLVMStyle(); 7030 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 7031 verifyFormat("void A::b() && {}", AlignLeft); 7032 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 7033 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 7034 AlignLeft); 7035 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 7036 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 7037 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 7038 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 7039 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 7040 verifyFormat("auto Function(T) & -> void;", AlignLeft); 7041 verifyFormat("void Fn(T const&) const&;", AlignLeft); 7042 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 7043 7044 FormatStyle Spaces = getLLVMStyle(); 7045 Spaces.SpacesInCStyleCastParentheses = true; 7046 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 7047 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 7048 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 7049 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 7050 7051 Spaces.SpacesInCStyleCastParentheses = false; 7052 Spaces.SpacesInParentheses = true; 7053 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 7054 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", 7055 Spaces); 7056 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 7057 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 7058 7059 FormatStyle BreakTemplate = getLLVMStyle(); 7060 BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 7061 7062 verifyFormat("struct f {\n" 7063 " template <class T>\n" 7064 " int &foo(const std::string &str) &noexcept {}\n" 7065 "};", 7066 BreakTemplate); 7067 7068 verifyFormat("struct f {\n" 7069 " template <class T>\n" 7070 " int &foo(const std::string &str) &&noexcept {}\n" 7071 "};", 7072 BreakTemplate); 7073 7074 verifyFormat("struct f {\n" 7075 " template <class T>\n" 7076 " int &foo(const std::string &str) const &noexcept {}\n" 7077 "};", 7078 BreakTemplate); 7079 7080 verifyFormat("struct f {\n" 7081 " template <class T>\n" 7082 " int &foo(const std::string &str) const &noexcept {}\n" 7083 "};", 7084 BreakTemplate); 7085 7086 verifyFormat("struct f {\n" 7087 " template <class T>\n" 7088 " auto foo(const std::string &str) &&noexcept -> int & {}\n" 7089 "};", 7090 BreakTemplate); 7091 7092 FormatStyle AlignLeftBreakTemplate = getLLVMStyle(); 7093 AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations = 7094 FormatStyle::BTDS_Yes; 7095 AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left; 7096 7097 verifyFormat("struct f {\n" 7098 " template <class T>\n" 7099 " int& foo(const std::string& str) & noexcept {}\n" 7100 "};", 7101 AlignLeftBreakTemplate); 7102 7103 verifyFormat("struct f {\n" 7104 " template <class T>\n" 7105 " int& foo(const std::string& str) && noexcept {}\n" 7106 "};", 7107 AlignLeftBreakTemplate); 7108 7109 verifyFormat("struct f {\n" 7110 " template <class T>\n" 7111 " int& foo(const std::string& str) const& noexcept {}\n" 7112 "};", 7113 AlignLeftBreakTemplate); 7114 7115 verifyFormat("struct f {\n" 7116 " template <class T>\n" 7117 " int& foo(const std::string& str) const&& noexcept {}\n" 7118 "};", 7119 AlignLeftBreakTemplate); 7120 7121 verifyFormat("struct f {\n" 7122 " template <class T>\n" 7123 " auto foo(const std::string& str) && noexcept -> int& {}\n" 7124 "};", 7125 AlignLeftBreakTemplate); 7126 7127 // The `&` in `Type&` should not be confused with a trailing `&` of 7128 // DEPRECATED(reason) member function. 7129 verifyFormat("struct f {\n" 7130 " template <class T>\n" 7131 " DEPRECATED(reason)\n" 7132 " Type &foo(arguments) {}\n" 7133 "};", 7134 BreakTemplate); 7135 7136 verifyFormat("struct f {\n" 7137 " template <class T>\n" 7138 " DEPRECATED(reason)\n" 7139 " Type& foo(arguments) {}\n" 7140 "};", 7141 AlignLeftBreakTemplate); 7142 7143 verifyFormat("void (*foopt)(int) = &func;"); 7144 } 7145 7146 TEST_F(FormatTest, UnderstandsNewAndDelete) { 7147 verifyFormat("void f() {\n" 7148 " A *a = new A;\n" 7149 " A *a = new (placement) A;\n" 7150 " delete a;\n" 7151 " delete (A *)a;\n" 7152 "}"); 7153 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7154 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7155 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7156 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7157 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7158 verifyFormat("delete[] h->p;"); 7159 } 7160 7161 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 7162 verifyFormat("int *f(int *a) {}"); 7163 verifyFormat("int main(int argc, char **argv) {}"); 7164 verifyFormat("Test::Test(int b) : a(b * b) {}"); 7165 verifyIndependentOfContext("f(a, *a);"); 7166 verifyFormat("void g() { f(*a); }"); 7167 verifyIndependentOfContext("int a = b * 10;"); 7168 verifyIndependentOfContext("int a = 10 * b;"); 7169 verifyIndependentOfContext("int a = b * c;"); 7170 verifyIndependentOfContext("int a += b * c;"); 7171 verifyIndependentOfContext("int a -= b * c;"); 7172 verifyIndependentOfContext("int a *= b * c;"); 7173 verifyIndependentOfContext("int a /= b * c;"); 7174 verifyIndependentOfContext("int a = *b;"); 7175 verifyIndependentOfContext("int a = *b * c;"); 7176 verifyIndependentOfContext("int a = b * *c;"); 7177 verifyIndependentOfContext("int a = b * (10);"); 7178 verifyIndependentOfContext("S << b * (10);"); 7179 verifyIndependentOfContext("return 10 * b;"); 7180 verifyIndependentOfContext("return *b * *c;"); 7181 verifyIndependentOfContext("return a & ~b;"); 7182 verifyIndependentOfContext("f(b ? *c : *d);"); 7183 verifyIndependentOfContext("int a = b ? *c : *d;"); 7184 verifyIndependentOfContext("*b = a;"); 7185 verifyIndependentOfContext("a * ~b;"); 7186 verifyIndependentOfContext("a * !b;"); 7187 verifyIndependentOfContext("a * +b;"); 7188 verifyIndependentOfContext("a * -b;"); 7189 verifyIndependentOfContext("a * ++b;"); 7190 verifyIndependentOfContext("a * --b;"); 7191 verifyIndependentOfContext("a[4] * b;"); 7192 verifyIndependentOfContext("a[a * a] = 1;"); 7193 verifyIndependentOfContext("f() * b;"); 7194 verifyIndependentOfContext("a * [self dostuff];"); 7195 verifyIndependentOfContext("int x = a * (a + b);"); 7196 verifyIndependentOfContext("(a *)(a + b);"); 7197 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 7198 verifyIndependentOfContext("int *pa = (int *)&a;"); 7199 verifyIndependentOfContext("return sizeof(int **);"); 7200 verifyIndependentOfContext("return sizeof(int ******);"); 7201 verifyIndependentOfContext("return (int **&)a;"); 7202 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 7203 verifyFormat("void f(Type (*parameter)[10]) {}"); 7204 verifyFormat("void f(Type (¶meter)[10]) {}"); 7205 verifyGoogleFormat("return sizeof(int**);"); 7206 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 7207 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 7208 verifyFormat("auto a = [](int **&, int ***) {};"); 7209 verifyFormat("auto PointerBinding = [](const char *S) {};"); 7210 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 7211 verifyFormat("[](const decltype(*a) &value) {}"); 7212 verifyFormat("decltype(a * b) F();"); 7213 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 7214 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 7215 verifyIndependentOfContext("typedef void (*f)(int *a);"); 7216 verifyIndependentOfContext("int i{a * b};"); 7217 verifyIndependentOfContext("aaa && aaa->f();"); 7218 verifyIndependentOfContext("int x = ~*p;"); 7219 verifyFormat("Constructor() : a(a), area(width * height) {}"); 7220 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 7221 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 7222 verifyFormat("void f() { f(a, c * d); }"); 7223 verifyFormat("void f() { f(new a(), c * d); }"); 7224 verifyFormat("void f(const MyOverride &override);"); 7225 verifyFormat("void f(const MyFinal &final);"); 7226 verifyIndependentOfContext("bool a = f() && override.f();"); 7227 verifyIndependentOfContext("bool a = f() && final.f();"); 7228 7229 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 7230 7231 verifyIndependentOfContext("A<int *> a;"); 7232 verifyIndependentOfContext("A<int **> a;"); 7233 verifyIndependentOfContext("A<int *, int *> a;"); 7234 verifyIndependentOfContext("A<int *[]> a;"); 7235 verifyIndependentOfContext( 7236 "const char *const p = reinterpret_cast<const char *const>(q);"); 7237 verifyIndependentOfContext("A<int **, int **> a;"); 7238 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 7239 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 7240 verifyFormat("for (; a && b;) {\n}"); 7241 verifyFormat("bool foo = true && [] { return false; }();"); 7242 7243 verifyFormat( 7244 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7245 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7246 7247 verifyGoogleFormat("int const* a = &b;"); 7248 verifyGoogleFormat("**outparam = 1;"); 7249 verifyGoogleFormat("*outparam = a * b;"); 7250 verifyGoogleFormat("int main(int argc, char** argv) {}"); 7251 verifyGoogleFormat("A<int*> a;"); 7252 verifyGoogleFormat("A<int**> a;"); 7253 verifyGoogleFormat("A<int*, int*> a;"); 7254 verifyGoogleFormat("A<int**, int**> a;"); 7255 verifyGoogleFormat("f(b ? *c : *d);"); 7256 verifyGoogleFormat("int a = b ? *c : *d;"); 7257 verifyGoogleFormat("Type* t = **x;"); 7258 verifyGoogleFormat("Type* t = *++*x;"); 7259 verifyGoogleFormat("*++*x;"); 7260 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 7261 verifyGoogleFormat("Type* t = x++ * y;"); 7262 verifyGoogleFormat( 7263 "const char* const p = reinterpret_cast<const char* const>(q);"); 7264 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 7265 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 7266 verifyGoogleFormat("template <typename T>\n" 7267 "void f(int i = 0, SomeType** temps = NULL);"); 7268 7269 FormatStyle Left = getLLVMStyle(); 7270 Left.PointerAlignment = FormatStyle::PAS_Left; 7271 verifyFormat("x = *a(x) = *a(y);", Left); 7272 verifyFormat("for (;; *a = b) {\n}", Left); 7273 verifyFormat("return *this += 1;", Left); 7274 verifyFormat("throw *x;", Left); 7275 verifyFormat("delete *x;", Left); 7276 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 7277 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 7278 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 7279 7280 verifyIndependentOfContext("a = *(x + y);"); 7281 verifyIndependentOfContext("a = &(x + y);"); 7282 verifyIndependentOfContext("*(x + y).call();"); 7283 verifyIndependentOfContext("&(x + y)->call();"); 7284 verifyFormat("void f() { &(*I).first; }"); 7285 7286 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 7287 verifyFormat( 7288 "int *MyValues = {\n" 7289 " *A, // Operator detection might be confused by the '{'\n" 7290 " *BB // Operator detection might be confused by previous comment\n" 7291 "};"); 7292 7293 verifyIndependentOfContext("if (int *a = &b)"); 7294 verifyIndependentOfContext("if (int &a = *b)"); 7295 verifyIndependentOfContext("if (a & b[i])"); 7296 verifyIndependentOfContext("if constexpr (a & b[i])"); 7297 verifyIndependentOfContext("if CONSTEXPR (a & b[i])"); 7298 verifyIndependentOfContext("if (a * (b * c))"); 7299 verifyIndependentOfContext("if constexpr (a * (b * c))"); 7300 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))"); 7301 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 7302 verifyIndependentOfContext("if (*b[i])"); 7303 verifyIndependentOfContext("if (int *a = (&b))"); 7304 verifyIndependentOfContext("while (int *a = &b)"); 7305 verifyIndependentOfContext("while (a * (b * c))"); 7306 verifyIndependentOfContext("size = sizeof *a;"); 7307 verifyIndependentOfContext("if (a && (b = c))"); 7308 verifyFormat("void f() {\n" 7309 " for (const int &v : Values) {\n" 7310 " }\n" 7311 "}"); 7312 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 7313 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 7314 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 7315 7316 verifyFormat("#define A (!a * b)"); 7317 verifyFormat("#define MACRO \\\n" 7318 " int *i = a * b; \\\n" 7319 " void f(a *b);", 7320 getLLVMStyleWithColumns(19)); 7321 7322 verifyIndependentOfContext("A = new SomeType *[Length];"); 7323 verifyIndependentOfContext("A = new SomeType *[Length]();"); 7324 verifyIndependentOfContext("T **t = new T *;"); 7325 verifyIndependentOfContext("T **t = new T *();"); 7326 verifyGoogleFormat("A = new SomeType*[Length]();"); 7327 verifyGoogleFormat("A = new SomeType*[Length];"); 7328 verifyGoogleFormat("T** t = new T*;"); 7329 verifyGoogleFormat("T** t = new T*();"); 7330 7331 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 7332 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 7333 verifyFormat("template <bool a, bool b> " 7334 "typename t::if<x && y>::type f() {}"); 7335 verifyFormat("template <int *y> f() {}"); 7336 verifyFormat("vector<int *> v;"); 7337 verifyFormat("vector<int *const> v;"); 7338 verifyFormat("vector<int *const **const *> v;"); 7339 verifyFormat("vector<int *volatile> v;"); 7340 verifyFormat("vector<a * b> v;"); 7341 verifyFormat("foo<b && false>();"); 7342 verifyFormat("foo<b & 1>();"); 7343 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 7344 verifyFormat( 7345 "template <class T, class = typename std::enable_if<\n" 7346 " std::is_integral<T>::value &&\n" 7347 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 7348 "void F();", 7349 getLLVMStyleWithColumns(70)); 7350 verifyFormat("template <class T,\n" 7351 " class = typename std::enable_if<\n" 7352 " std::is_integral<T>::value &&\n" 7353 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 7354 " class U>\n" 7355 "void F();", 7356 getLLVMStyleWithColumns(70)); 7357 verifyFormat( 7358 "template <class T,\n" 7359 " class = typename ::std::enable_if<\n" 7360 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 7361 "void F();", 7362 getGoogleStyleWithColumns(68)); 7363 7364 verifyIndependentOfContext("MACRO(int *i);"); 7365 verifyIndependentOfContext("MACRO(auto *a);"); 7366 verifyIndependentOfContext("MACRO(const A *a);"); 7367 verifyIndependentOfContext("MACRO(A *const a);"); 7368 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 7369 verifyFormat("void f() { f(float{1}, a * a); }"); 7370 // FIXME: Is there a way to make this work? 7371 // verifyIndependentOfContext("MACRO(A *a);"); 7372 7373 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 7374 verifyFormat("return options != nullptr && operator==(*options);"); 7375 7376 EXPECT_EQ("#define OP(x) \\\n" 7377 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7378 " return s << a.DebugString(); \\\n" 7379 " }", 7380 format("#define OP(x) \\\n" 7381 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7382 " return s << a.DebugString(); \\\n" 7383 " }", 7384 getLLVMStyleWithColumns(50))); 7385 7386 // FIXME: We cannot handle this case yet; we might be able to figure out that 7387 // foo<x> d > v; doesn't make sense. 7388 verifyFormat("foo<a<b && c> d> v;"); 7389 7390 FormatStyle PointerMiddle = getLLVMStyle(); 7391 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7392 verifyFormat("delete *x;", PointerMiddle); 7393 verifyFormat("int * x;", PointerMiddle); 7394 verifyFormat("int *[] x;", PointerMiddle); 7395 verifyFormat("template <int * y> f() {}", PointerMiddle); 7396 verifyFormat("int * f(int * a) {}", PointerMiddle); 7397 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7398 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7399 verifyFormat("A<int *> a;", PointerMiddle); 7400 verifyFormat("A<int **> a;", PointerMiddle); 7401 verifyFormat("A<int *, int *> a;", PointerMiddle); 7402 verifyFormat("A<int *[]> a;", PointerMiddle); 7403 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7404 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7405 verifyFormat("T ** t = new T *;", PointerMiddle); 7406 7407 // Member function reference qualifiers aren't binary operators. 7408 verifyFormat("string // break\n" 7409 "operator()() & {}"); 7410 verifyFormat("string // break\n" 7411 "operator()() && {}"); 7412 verifyGoogleFormat("template <typename T>\n" 7413 "auto x() & -> int {}"); 7414 } 7415 7416 TEST_F(FormatTest, UnderstandsAttributes) { 7417 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7418 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7419 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7420 FormatStyle AfterType = getLLVMStyle(); 7421 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7422 verifyFormat("__attribute__((nodebug)) void\n" 7423 "foo() {}\n", 7424 AfterType); 7425 } 7426 7427 TEST_F(FormatTest, UnderstandsSquareAttributes) { 7428 verifyFormat("SomeType s [[unused]] (InitValue);"); 7429 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 7430 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 7431 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 7432 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 7433 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7434 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7435 7436 // Make sure we do not mistake attributes for array subscripts. 7437 verifyFormat("int a() {}\n" 7438 "[[unused]] int b() {}\n"); 7439 verifyFormat("NSArray *arr;\n" 7440 "arr[[Foo() bar]];"); 7441 7442 // On the other hand, we still need to correctly find array subscripts. 7443 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 7444 7445 // Make sure that we do not mistake Objective-C method inside array literals 7446 // as attributes, even if those method names are also keywords. 7447 verifyFormat("@[ [foo bar] ];"); 7448 verifyFormat("@[ [NSArray class] ];"); 7449 verifyFormat("@[ [foo enum] ];"); 7450 7451 // Make sure we do not parse attributes as lambda introducers. 7452 FormatStyle MultiLineFunctions = getLLVMStyle(); 7453 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7454 verifyFormat("[[unused]] int b() {\n" 7455 " return 42;\n" 7456 "}\n", 7457 MultiLineFunctions); 7458 } 7459 7460 TEST_F(FormatTest, UnderstandsEllipsis) { 7461 verifyFormat("int printf(const char *fmt, ...);"); 7462 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 7463 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 7464 7465 FormatStyle PointersLeft = getLLVMStyle(); 7466 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 7467 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 7468 } 7469 7470 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 7471 EXPECT_EQ("int *a;\n" 7472 "int *a;\n" 7473 "int *a;", 7474 format("int *a;\n" 7475 "int* a;\n" 7476 "int *a;", 7477 getGoogleStyle())); 7478 EXPECT_EQ("int* a;\n" 7479 "int* a;\n" 7480 "int* a;", 7481 format("int* a;\n" 7482 "int* a;\n" 7483 "int *a;", 7484 getGoogleStyle())); 7485 EXPECT_EQ("int *a;\n" 7486 "int *a;\n" 7487 "int *a;", 7488 format("int *a;\n" 7489 "int * a;\n" 7490 "int * a;", 7491 getGoogleStyle())); 7492 EXPECT_EQ("auto x = [] {\n" 7493 " int *a;\n" 7494 " int *a;\n" 7495 " int *a;\n" 7496 "};", 7497 format("auto x=[]{int *a;\n" 7498 "int * a;\n" 7499 "int * a;};", 7500 getGoogleStyle())); 7501 } 7502 7503 TEST_F(FormatTest, UnderstandsRvalueReferences) { 7504 verifyFormat("int f(int &&a) {}"); 7505 verifyFormat("int f(int a, char &&b) {}"); 7506 verifyFormat("void f() { int &&a = b; }"); 7507 verifyGoogleFormat("int f(int a, char&& b) {}"); 7508 verifyGoogleFormat("void f() { int&& a = b; }"); 7509 7510 verifyIndependentOfContext("A<int &&> a;"); 7511 verifyIndependentOfContext("A<int &&, int &&> a;"); 7512 verifyGoogleFormat("A<int&&> a;"); 7513 verifyGoogleFormat("A<int&&, int&&> a;"); 7514 7515 // Not rvalue references: 7516 verifyFormat("template <bool B, bool C> class A {\n" 7517 " static_assert(B && C, \"Something is wrong\");\n" 7518 "};"); 7519 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 7520 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 7521 verifyFormat("#define A(a, b) (a && b)"); 7522 } 7523 7524 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 7525 verifyFormat("void f() {\n" 7526 " x[aaaaaaaaa -\n" 7527 " b] = 23;\n" 7528 "}", 7529 getLLVMStyleWithColumns(15)); 7530 } 7531 7532 TEST_F(FormatTest, FormatsCasts) { 7533 verifyFormat("Type *A = static_cast<Type *>(P);"); 7534 verifyFormat("Type *A = (Type *)P;"); 7535 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7536 verifyFormat("int a = (int)(2.0f);"); 7537 verifyFormat("int a = (int)2.0f;"); 7538 verifyFormat("x[(int32)y];"); 7539 verifyFormat("x = (int32)y;"); 7540 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7541 verifyFormat("int a = (int)*b;"); 7542 verifyFormat("int a = (int)2.0f;"); 7543 verifyFormat("int a = (int)~0;"); 7544 verifyFormat("int a = (int)++a;"); 7545 verifyFormat("int a = (int)sizeof(int);"); 7546 verifyFormat("int a = (int)+2;"); 7547 verifyFormat("my_int a = (my_int)2.0f;"); 7548 verifyFormat("my_int a = (my_int)sizeof(int);"); 7549 verifyFormat("return (my_int)aaa;"); 7550 verifyFormat("#define x ((int)-1)"); 7551 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7552 verifyFormat("#define p(q) ((int *)&q)"); 7553 verifyFormat("fn(a)(b) + 1;"); 7554 7555 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7556 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7557 verifyFormat("my_int a = (my_int)~0;"); 7558 verifyFormat("my_int a = (my_int)++a;"); 7559 verifyFormat("my_int a = (my_int)-2;"); 7560 verifyFormat("my_int a = (my_int)1;"); 7561 verifyFormat("my_int a = (my_int *)1;"); 7562 verifyFormat("my_int a = (const my_int)-1;"); 7563 verifyFormat("my_int a = (const my_int *)-1;"); 7564 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7565 verifyFormat("my_int a = (ns::my_int)-2;"); 7566 verifyFormat("case (my_int)ONE:"); 7567 verifyFormat("auto x = (X)this;"); 7568 // Casts in Obj-C style calls used to not be recognized as such. 7569 verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle()); 7570 7571 // FIXME: single value wrapped with paren will be treated as cast. 7572 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7573 7574 verifyFormat("{ (void)F; }"); 7575 7576 // Don't break after a cast's 7577 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7578 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7579 " bbbbbbbbbbbbbbbbbbbbbb);"); 7580 7581 // These are not casts. 7582 verifyFormat("void f(int *) {}"); 7583 verifyFormat("f(foo)->b;"); 7584 verifyFormat("f(foo).b;"); 7585 verifyFormat("f(foo)(b);"); 7586 verifyFormat("f(foo)[b];"); 7587 verifyFormat("[](foo) { return 4; }(bar);"); 7588 verifyFormat("(*funptr)(foo)[4];"); 7589 verifyFormat("funptrs[4](foo)[4];"); 7590 verifyFormat("void f(int *);"); 7591 verifyFormat("void f(int *) = 0;"); 7592 verifyFormat("void f(SmallVector<int>) {}"); 7593 verifyFormat("void f(SmallVector<int>);"); 7594 verifyFormat("void f(SmallVector<int>) = 0;"); 7595 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7596 verifyFormat("int a = sizeof(int) * b;"); 7597 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7598 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7599 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7600 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7601 7602 // These are not casts, but at some point were confused with casts. 7603 verifyFormat("virtual void foo(int *) override;"); 7604 verifyFormat("virtual void foo(char &) const;"); 7605 verifyFormat("virtual void foo(int *a, char *) const;"); 7606 verifyFormat("int a = sizeof(int *) + b;"); 7607 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7608 verifyFormat("bool b = f(g<int>) && c;"); 7609 verifyFormat("typedef void (*f)(int i) func;"); 7610 verifyFormat("void operator++(int) noexcept;"); 7611 verifyFormat("void operator++(int &) noexcept;"); 7612 verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t " 7613 "&) noexcept;"); 7614 verifyFormat( 7615 "void operator delete(std::size_t, const std::nothrow_t &) noexcept;"); 7616 verifyFormat("void operator delete(const std::nothrow_t &) noexcept;"); 7617 verifyFormat("void operator delete(std::nothrow_t &) noexcept;"); 7618 verifyFormat("void operator delete(nothrow_t &) noexcept;"); 7619 verifyFormat("void operator delete(foo &) noexcept;"); 7620 verifyFormat("void operator delete(foo) noexcept;"); 7621 verifyFormat("void operator delete(int) noexcept;"); 7622 verifyFormat("void operator delete(int &) noexcept;"); 7623 verifyFormat("void operator delete(int &) volatile noexcept;"); 7624 verifyFormat("void operator delete(int &) const"); 7625 verifyFormat("void operator delete(int &) = default"); 7626 verifyFormat("void operator delete(int &) = delete"); 7627 verifyFormat("void operator delete(int &) [[noreturn]]"); 7628 verifyFormat("void operator delete(int &) throw();"); 7629 verifyFormat("void operator delete(int &) throw(int);"); 7630 verifyFormat("auto operator delete(int &) -> int;"); 7631 verifyFormat("auto operator delete(int &) override"); 7632 verifyFormat("auto operator delete(int &) final"); 7633 7634 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7635 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7636 // FIXME: The indentation here is not ideal. 7637 verifyFormat( 7638 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7639 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7640 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7641 } 7642 7643 TEST_F(FormatTest, FormatsFunctionTypes) { 7644 verifyFormat("A<bool()> a;"); 7645 verifyFormat("A<SomeType()> a;"); 7646 verifyFormat("A<void (*)(int, std::string)> a;"); 7647 verifyFormat("A<void *(int)>;"); 7648 verifyFormat("void *(*a)(int *, SomeType *);"); 7649 verifyFormat("int (*func)(void *);"); 7650 verifyFormat("void f() { int (*func)(void *); }"); 7651 verifyFormat("template <class CallbackClass>\n" 7652 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7653 7654 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7655 verifyGoogleFormat("void* (*a)(int);"); 7656 verifyGoogleFormat( 7657 "template <class CallbackClass>\n" 7658 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7659 7660 // Other constructs can look somewhat like function types: 7661 verifyFormat("A<sizeof(*x)> a;"); 7662 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7663 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7664 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7665 verifyFormat("int x = f(&h)();"); 7666 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7667 verifyFormat("std::function<\n" 7668 " LooooooooooongTemplatedType<\n" 7669 " SomeType>*(\n" 7670 " LooooooooooooooooongType type)>\n" 7671 " function;", 7672 getGoogleStyleWithColumns(40)); 7673 } 7674 7675 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7676 verifyFormat("A (*foo_)[6];"); 7677 verifyFormat("vector<int> (*foo_)[6];"); 7678 } 7679 7680 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7681 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7682 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7683 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7684 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7685 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7686 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7687 7688 // Different ways of ()-initializiation. 7689 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7690 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7691 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7692 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7693 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7694 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7695 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7696 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7697 7698 // Lambdas should not confuse the variable declaration heuristic. 7699 verifyFormat("LooooooooooooooooongType\n" 7700 " variable(nullptr, [](A *a) {});", 7701 getLLVMStyleWithColumns(40)); 7702 } 7703 7704 TEST_F(FormatTest, BreaksLongDeclarations) { 7705 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7706 " AnotherNameForTheLongType;"); 7707 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7708 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7709 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7710 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7711 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7712 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7713 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7714 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7715 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7716 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7717 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7718 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7719 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7720 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7721 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7722 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7723 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7724 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7725 FormatStyle Indented = getLLVMStyle(); 7726 Indented.IndentWrappedFunctionNames = true; 7727 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7728 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7729 Indented); 7730 verifyFormat( 7731 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7732 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7733 Indented); 7734 verifyFormat( 7735 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7736 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7737 Indented); 7738 verifyFormat( 7739 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7740 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7741 Indented); 7742 7743 // FIXME: Without the comment, this breaks after "(". 7744 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7745 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7746 getGoogleStyle()); 7747 7748 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7749 " int LoooooooooooooooooooongParam2) {}"); 7750 verifyFormat( 7751 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7752 " SourceLocation L, IdentifierIn *II,\n" 7753 " Type *T) {}"); 7754 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7755 "ReallyReaaallyLongFunctionName(\n" 7756 " const std::string &SomeParameter,\n" 7757 " const SomeType<string, SomeOtherTemplateParameter>\n" 7758 " &ReallyReallyLongParameterName,\n" 7759 " const SomeType<string, SomeOtherTemplateParameter>\n" 7760 " &AnotherLongParameterName) {}"); 7761 verifyFormat("template <typename A>\n" 7762 "SomeLoooooooooooooooooooooongType<\n" 7763 " typename some_namespace::SomeOtherType<A>::Type>\n" 7764 "Function() {}"); 7765 7766 verifyGoogleFormat( 7767 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7768 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7769 verifyGoogleFormat( 7770 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7771 " SourceLocation L) {}"); 7772 verifyGoogleFormat( 7773 "some_namespace::LongReturnType\n" 7774 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7775 " int first_long_parameter, int second_parameter) {}"); 7776 7777 verifyGoogleFormat("template <typename T>\n" 7778 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7779 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7780 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7781 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7782 7783 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7784 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7785 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7786 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7787 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7788 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 7789 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7790 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 7791 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 7792 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7793 7794 verifyFormat("template <typename T> // Templates on own line.\n" 7795 "static int // Some comment.\n" 7796 "MyFunction(int a);", 7797 getLLVMStyle()); 7798 } 7799 7800 TEST_F(FormatTest, FormatsArrays) { 7801 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7802 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 7803 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 7804 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 7805 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 7806 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 7807 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7808 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7809 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7810 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 7811 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7812 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7813 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7814 verifyFormat( 7815 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 7816 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7817 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 7818 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 7819 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7820 7821 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 7822 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 7823 verifyFormat( 7824 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 7825 " .aaaaaaa[0]\n" 7826 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7827 verifyFormat("a[::b::c];"); 7828 7829 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 7830 7831 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 7832 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 7833 } 7834 7835 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 7836 verifyFormat("(a)->b();"); 7837 verifyFormat("--a;"); 7838 } 7839 7840 TEST_F(FormatTest, HandlesIncludeDirectives) { 7841 verifyFormat("#include <string>\n" 7842 "#include <a/b/c.h>\n" 7843 "#include \"a/b/string\"\n" 7844 "#include \"string.h\"\n" 7845 "#include \"string.h\"\n" 7846 "#include <a-a>\n" 7847 "#include < path with space >\n" 7848 "#include_next <test.h>" 7849 "#include \"abc.h\" // this is included for ABC\n" 7850 "#include \"some long include\" // with a comment\n" 7851 "#include \"some very long include path\"\n" 7852 "#include <some/very/long/include/path>\n", 7853 getLLVMStyleWithColumns(35)); 7854 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 7855 EXPECT_EQ("#include <a>", format("#include<a>")); 7856 7857 verifyFormat("#import <string>"); 7858 verifyFormat("#import <a/b/c.h>"); 7859 verifyFormat("#import \"a/b/string\""); 7860 verifyFormat("#import \"string.h\""); 7861 verifyFormat("#import \"string.h\""); 7862 verifyFormat("#if __has_include(<strstream>)\n" 7863 "#include <strstream>\n" 7864 "#endif"); 7865 7866 verifyFormat("#define MY_IMPORT <a/b>"); 7867 7868 verifyFormat("#if __has_include(<a/b>)"); 7869 verifyFormat("#if __has_include_next(<a/b>)"); 7870 verifyFormat("#define F __has_include(<a/b>)"); 7871 verifyFormat("#define F __has_include_next(<a/b>)"); 7872 7873 // Protocol buffer definition or missing "#". 7874 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 7875 getLLVMStyleWithColumns(30)); 7876 7877 FormatStyle Style = getLLVMStyle(); 7878 Style.AlwaysBreakBeforeMultilineStrings = true; 7879 Style.ColumnLimit = 0; 7880 verifyFormat("#import \"abc.h\"", Style); 7881 7882 // But 'import' might also be a regular C++ namespace. 7883 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7884 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7885 } 7886 7887 //===----------------------------------------------------------------------===// 7888 // Error recovery tests. 7889 //===----------------------------------------------------------------------===// 7890 7891 TEST_F(FormatTest, IncompleteParameterLists) { 7892 FormatStyle NoBinPacking = getLLVMStyle(); 7893 NoBinPacking.BinPackParameters = false; 7894 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 7895 " double *min_x,\n" 7896 " double *max_x,\n" 7897 " double *min_y,\n" 7898 " double *max_y,\n" 7899 " double *min_z,\n" 7900 " double *max_z, ) {}", 7901 NoBinPacking); 7902 } 7903 7904 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 7905 verifyFormat("void f() { return; }\n42"); 7906 verifyFormat("void f() {\n" 7907 " if (0)\n" 7908 " return;\n" 7909 "}\n" 7910 "42"); 7911 verifyFormat("void f() { return }\n42"); 7912 verifyFormat("void f() {\n" 7913 " if (0)\n" 7914 " return\n" 7915 "}\n" 7916 "42"); 7917 } 7918 7919 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 7920 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 7921 EXPECT_EQ("void f() {\n" 7922 " if (a)\n" 7923 " return\n" 7924 "}", 7925 format("void f ( ) { if ( a ) return }")); 7926 EXPECT_EQ("namespace N {\n" 7927 "void f()\n" 7928 "}", 7929 format("namespace N { void f() }")); 7930 EXPECT_EQ("namespace N {\n" 7931 "void f() {}\n" 7932 "void g()\n" 7933 "} // namespace N", 7934 format("namespace N { void f( ) { } void g( ) }")); 7935 } 7936 7937 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 7938 verifyFormat("int aaaaaaaa =\n" 7939 " // Overlylongcomment\n" 7940 " b;", 7941 getLLVMStyleWithColumns(20)); 7942 verifyFormat("function(\n" 7943 " ShortArgument,\n" 7944 " LoooooooooooongArgument);\n", 7945 getLLVMStyleWithColumns(20)); 7946 } 7947 7948 TEST_F(FormatTest, IncorrectAccessSpecifier) { 7949 verifyFormat("public:"); 7950 verifyFormat("class A {\n" 7951 "public\n" 7952 " void f() {}\n" 7953 "};"); 7954 verifyFormat("public\n" 7955 "int qwerty;"); 7956 verifyFormat("public\n" 7957 "B {}"); 7958 verifyFormat("public\n" 7959 "{}"); 7960 verifyFormat("public\n" 7961 "B { int x; }"); 7962 } 7963 7964 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 7965 verifyFormat("{"); 7966 verifyFormat("#})"); 7967 verifyNoCrash("(/**/[:!] ?[)."); 7968 } 7969 7970 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 7971 // Found by oss-fuzz: 7972 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 7973 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 7974 Style.ColumnLimit = 60; 7975 verifyNoCrash( 7976 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 7977 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 7978 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 7979 Style); 7980 } 7981 7982 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 7983 verifyFormat("do {\n}"); 7984 verifyFormat("do {\n}\n" 7985 "f();"); 7986 verifyFormat("do {\n}\n" 7987 "wheeee(fun);"); 7988 verifyFormat("do {\n" 7989 " f();\n" 7990 "}"); 7991 } 7992 7993 TEST_F(FormatTest, IncorrectCodeMissingParens) { 7994 verifyFormat("if {\n foo;\n foo();\n}"); 7995 verifyFormat("switch {\n foo;\n foo();\n}"); 7996 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 7997 verifyFormat("while {\n foo;\n foo();\n}"); 7998 verifyFormat("do {\n foo;\n foo();\n} while;"); 7999 } 8000 8001 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 8002 verifyIncompleteFormat("namespace {\n" 8003 "class Foo { Foo (\n" 8004 "};\n" 8005 "} // namespace"); 8006 } 8007 8008 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 8009 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 8010 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 8011 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 8012 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 8013 8014 EXPECT_EQ("{\n" 8015 " {\n" 8016 " breakme(\n" 8017 " qwe);\n" 8018 " }\n", 8019 format("{\n" 8020 " {\n" 8021 " breakme(qwe);\n" 8022 "}\n", 8023 getLLVMStyleWithColumns(10))); 8024 } 8025 8026 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 8027 verifyFormat("int x = {\n" 8028 " avariable,\n" 8029 " b(alongervariable)};", 8030 getLLVMStyleWithColumns(25)); 8031 } 8032 8033 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 8034 verifyFormat("return (a)(b){1, 2, 3};"); 8035 } 8036 8037 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 8038 verifyFormat("vector<int> x{1, 2, 3, 4};"); 8039 verifyFormat("vector<int> x{\n" 8040 " 1,\n" 8041 " 2,\n" 8042 " 3,\n" 8043 " 4,\n" 8044 "};"); 8045 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 8046 verifyFormat("f({1, 2});"); 8047 verifyFormat("auto v = Foo{-1};"); 8048 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 8049 verifyFormat("Class::Class : member{1, 2, 3} {}"); 8050 verifyFormat("new vector<int>{1, 2, 3};"); 8051 verifyFormat("new int[3]{1, 2, 3};"); 8052 verifyFormat("new int{1};"); 8053 verifyFormat("return {arg1, arg2};"); 8054 verifyFormat("return {arg1, SomeType{parameter}};"); 8055 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 8056 verifyFormat("new T{arg1, arg2};"); 8057 verifyFormat("f(MyMap[{composite, key}]);"); 8058 verifyFormat("class Class {\n" 8059 " T member = {arg1, arg2};\n" 8060 "};"); 8061 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 8062 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 8063 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 8064 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 8065 verifyFormat("int a = std::is_integral<int>{} + 0;"); 8066 8067 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8068 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8069 verifyFormat("auto i = decltype(x){};"); 8070 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 8071 verifyFormat("Node n{1, Node{1000}, //\n" 8072 " 2};"); 8073 verifyFormat("Aaaa aaaaaaa{\n" 8074 " {\n" 8075 " aaaa,\n" 8076 " },\n" 8077 "};"); 8078 verifyFormat("class C : public D {\n" 8079 " SomeClass SC{2};\n" 8080 "};"); 8081 verifyFormat("class C : public A {\n" 8082 " class D : public B {\n" 8083 " void f() { int i{2}; }\n" 8084 " };\n" 8085 "};"); 8086 verifyFormat("#define A {a, a},"); 8087 8088 // Avoid breaking between equal sign and opening brace 8089 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 8090 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 8091 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 8092 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 8093 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 8094 " {\"ccccccccccccccccccccc\", 2}};", 8095 AvoidBreakingFirstArgument); 8096 8097 // Binpacking only if there is no trailing comma 8098 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 8099 " cccccccccc, dddddddddd};", 8100 getLLVMStyleWithColumns(50)); 8101 verifyFormat("const Aaaaaa aaaaa = {\n" 8102 " aaaaaaaaaaa,\n" 8103 " bbbbbbbbbbb,\n" 8104 " ccccccccccc,\n" 8105 " ddddddddddd,\n" 8106 "};", 8107 getLLVMStyleWithColumns(50)); 8108 8109 // Cases where distinguising braced lists and blocks is hard. 8110 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 8111 verifyFormat("void f() {\n" 8112 " return; // comment\n" 8113 "}\n" 8114 "SomeType t;"); 8115 verifyFormat("void f() {\n" 8116 " if (a) {\n" 8117 " f();\n" 8118 " }\n" 8119 "}\n" 8120 "SomeType t;"); 8121 8122 // In combination with BinPackArguments = false. 8123 FormatStyle NoBinPacking = getLLVMStyle(); 8124 NoBinPacking.BinPackArguments = false; 8125 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 8126 " bbbbb,\n" 8127 " ccccc,\n" 8128 " ddddd,\n" 8129 " eeeee,\n" 8130 " ffffff,\n" 8131 " ggggg,\n" 8132 " hhhhhh,\n" 8133 " iiiiii,\n" 8134 " jjjjjj,\n" 8135 " kkkkkk};", 8136 NoBinPacking); 8137 verifyFormat("const Aaaaaa aaaaa = {\n" 8138 " aaaaa,\n" 8139 " bbbbb,\n" 8140 " ccccc,\n" 8141 " ddddd,\n" 8142 " eeeee,\n" 8143 " ffffff,\n" 8144 " ggggg,\n" 8145 " hhhhhh,\n" 8146 " iiiiii,\n" 8147 " jjjjjj,\n" 8148 " kkkkkk,\n" 8149 "};", 8150 NoBinPacking); 8151 verifyFormat( 8152 "const Aaaaaa aaaaa = {\n" 8153 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 8154 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 8155 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 8156 "};", 8157 NoBinPacking); 8158 8159 NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 8160 EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n" 8161 " CDDDP83848_BMCR_REGISTER,\n" 8162 " CDDDP83848_BMSR_REGISTER,\n" 8163 " CDDDP83848_RBR_REGISTER};", 8164 format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n" 8165 " CDDDP83848_BMSR_REGISTER,\n" 8166 " CDDDP83848_RBR_REGISTER};", 8167 NoBinPacking)); 8168 8169 // FIXME: The alignment of these trailing comments might be bad. Then again, 8170 // this might be utterly useless in real code. 8171 verifyFormat("Constructor::Constructor()\n" 8172 " : some_value{ //\n" 8173 " aaaaaaa, //\n" 8174 " bbbbbbb} {}"); 8175 8176 // In braced lists, the first comment is always assumed to belong to the 8177 // first element. Thus, it can be moved to the next or previous line as 8178 // appropriate. 8179 EXPECT_EQ("function({// First element:\n" 8180 " 1,\n" 8181 " // Second element:\n" 8182 " 2});", 8183 format("function({\n" 8184 " // First element:\n" 8185 " 1,\n" 8186 " // Second element:\n" 8187 " 2});")); 8188 EXPECT_EQ("std::vector<int> MyNumbers{\n" 8189 " // First element:\n" 8190 " 1,\n" 8191 " // Second element:\n" 8192 " 2};", 8193 format("std::vector<int> MyNumbers{// First element:\n" 8194 " 1,\n" 8195 " // Second element:\n" 8196 " 2};", 8197 getLLVMStyleWithColumns(30))); 8198 // A trailing comma should still lead to an enforced line break and no 8199 // binpacking. 8200 EXPECT_EQ("vector<int> SomeVector = {\n" 8201 " // aaa\n" 8202 " 1,\n" 8203 " 2,\n" 8204 "};", 8205 format("vector<int> SomeVector = { // aaa\n" 8206 " 1, 2, };")); 8207 8208 FormatStyle ExtraSpaces = getLLVMStyle(); 8209 ExtraSpaces.Cpp11BracedListStyle = false; 8210 ExtraSpaces.ColumnLimit = 75; 8211 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 8212 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 8213 verifyFormat("f({ 1, 2 });", ExtraSpaces); 8214 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 8215 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 8216 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 8217 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 8218 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 8219 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 8220 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 8221 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 8222 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 8223 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 8224 verifyFormat("class Class {\n" 8225 " T member = { arg1, arg2 };\n" 8226 "};", 8227 ExtraSpaces); 8228 verifyFormat( 8229 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8230 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 8231 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 8232 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 8233 ExtraSpaces); 8234 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 8235 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 8236 ExtraSpaces); 8237 verifyFormat( 8238 "someFunction(OtherParam,\n" 8239 " BracedList{ // comment 1 (Forcing interesting break)\n" 8240 " param1, param2,\n" 8241 " // comment 2\n" 8242 " param3, param4 });", 8243 ExtraSpaces); 8244 verifyFormat( 8245 "std::this_thread::sleep_for(\n" 8246 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 8247 ExtraSpaces); 8248 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 8249 " aaaaaaa,\n" 8250 " aaaaaaaaaa,\n" 8251 " aaaaa,\n" 8252 " aaaaaaaaaaaaaaa,\n" 8253 " aaa,\n" 8254 " aaaaaaaaaa,\n" 8255 " a,\n" 8256 " aaaaaaaaaaaaaaaaaaaaa,\n" 8257 " aaaaaaaaaaaa,\n" 8258 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 8259 " aaaaaaa,\n" 8260 " a};"); 8261 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 8262 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 8263 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 8264 8265 // Avoid breaking between initializer/equal sign and opening brace 8266 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 8267 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 8268 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8269 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8270 " { \"ccccccccccccccccccccc\", 2 }\n" 8271 "};", 8272 ExtraSpaces); 8273 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 8274 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8275 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8276 " { \"ccccccccccccccccccccc\", 2 }\n" 8277 "};", 8278 ExtraSpaces); 8279 8280 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 8281 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 8282 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 8283 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 8284 8285 FormatStyle SpaceBetweenBraces = getLLVMStyle(); 8286 SpaceBetweenBraces.SpacesInAngles = true; 8287 SpaceBetweenBraces.SpacesInParentheses = true; 8288 SpaceBetweenBraces.SpacesInSquareBrackets = true; 8289 verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces); 8290 verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces); 8291 verifyFormat("vector< int > x{ // comment 1\n" 8292 " 1, 2, 3, 4 };", 8293 SpaceBetweenBraces); 8294 SpaceBetweenBraces.ColumnLimit = 20; 8295 EXPECT_EQ("vector< int > x{\n" 8296 " 1, 2, 3, 4 };", 8297 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8298 SpaceBetweenBraces.ColumnLimit = 24; 8299 EXPECT_EQ("vector< int > x{ 1, 2,\n" 8300 " 3, 4 };", 8301 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8302 EXPECT_EQ("vector< int > x{\n" 8303 " 1,\n" 8304 " 2,\n" 8305 " 3,\n" 8306 " 4,\n" 8307 "};", 8308 format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces)); 8309 verifyFormat("vector< int > x{};", SpaceBetweenBraces); 8310 SpaceBetweenBraces.SpaceInEmptyParentheses = true; 8311 verifyFormat("vector< int > x{ };", SpaceBetweenBraces); 8312 } 8313 8314 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 8315 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8316 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8317 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8318 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8319 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8320 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8321 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 8322 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8323 " 1, 22, 333, 4444, 55555, //\n" 8324 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8325 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8326 verifyFormat( 8327 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8328 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8329 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 8330 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8331 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8332 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8333 " 7777777};"); 8334 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8335 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8336 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8337 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8338 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8339 " // Separating comment.\n" 8340 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8341 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8342 " // Leading comment\n" 8343 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8344 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8345 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8346 " 1, 1, 1, 1};", 8347 getLLVMStyleWithColumns(39)); 8348 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8349 " 1, 1, 1, 1};", 8350 getLLVMStyleWithColumns(38)); 8351 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 8352 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 8353 getLLVMStyleWithColumns(43)); 8354 verifyFormat( 8355 "static unsigned SomeValues[10][3] = {\n" 8356 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 8357 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 8358 verifyFormat("static auto fields = new vector<string>{\n" 8359 " \"aaaaaaaaaaaaa\",\n" 8360 " \"aaaaaaaaaaaaa\",\n" 8361 " \"aaaaaaaaaaaa\",\n" 8362 " \"aaaaaaaaaaaaaa\",\n" 8363 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8364 " \"aaaaaaaaaaaa\",\n" 8365 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8366 "};"); 8367 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 8368 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 8369 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 8370 " 3, cccccccccccccccccccccc};", 8371 getLLVMStyleWithColumns(60)); 8372 8373 // Trailing commas. 8374 verifyFormat("vector<int> x = {\n" 8375 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 8376 "};", 8377 getLLVMStyleWithColumns(39)); 8378 verifyFormat("vector<int> x = {\n" 8379 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 8380 "};", 8381 getLLVMStyleWithColumns(39)); 8382 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8383 " 1, 1, 1, 1,\n" 8384 " /**/ /**/};", 8385 getLLVMStyleWithColumns(39)); 8386 8387 // Trailing comment in the first line. 8388 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 8389 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 8390 " 111111111, 222222222, 3333333333, 444444444, //\n" 8391 " 11111111, 22222222, 333333333, 44444444};"); 8392 // Trailing comment in the last line. 8393 verifyFormat("int aaaaa[] = {\n" 8394 " 1, 2, 3, // comment\n" 8395 " 4, 5, 6 // comment\n" 8396 "};"); 8397 8398 // With nested lists, we should either format one item per line or all nested 8399 // lists one on line. 8400 // FIXME: For some nested lists, we can do better. 8401 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 8402 " {aaaaaaaaaaaaaaaaaaa},\n" 8403 " {aaaaaaaaaaaaaaaaaaaaa},\n" 8404 " {aaaaaaaaaaaaaaaaa}};", 8405 getLLVMStyleWithColumns(60)); 8406 verifyFormat( 8407 "SomeStruct my_struct_array = {\n" 8408 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 8409 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 8410 " {aaa, aaa},\n" 8411 " {aaa, aaa},\n" 8412 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 8413 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 8414 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 8415 8416 // No column layout should be used here. 8417 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 8418 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 8419 8420 verifyNoCrash("a<,"); 8421 8422 // No braced initializer here. 8423 verifyFormat("void f() {\n" 8424 " struct Dummy {};\n" 8425 " f(v);\n" 8426 "}"); 8427 8428 // Long lists should be formatted in columns even if they are nested. 8429 verifyFormat( 8430 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8431 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8432 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8433 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8434 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8435 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 8436 8437 // Allow "single-column" layout even if that violates the column limit. There 8438 // isn't going to be a better way. 8439 verifyFormat("std::vector<int> a = {\n" 8440 " aaaaaaaa,\n" 8441 " aaaaaaaa,\n" 8442 " aaaaaaaa,\n" 8443 " aaaaaaaa,\n" 8444 " aaaaaaaaaa,\n" 8445 " aaaaaaaa,\n" 8446 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 8447 getLLVMStyleWithColumns(30)); 8448 verifyFormat("vector<int> aaaa = {\n" 8449 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8450 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8451 " aaaaaa.aaaaaaa,\n" 8452 " aaaaaa.aaaaaaa,\n" 8453 " aaaaaa.aaaaaaa,\n" 8454 " aaaaaa.aaaaaaa,\n" 8455 "};"); 8456 8457 // Don't create hanging lists. 8458 verifyFormat("someFunction(Param, {List1, List2,\n" 8459 " List3});", 8460 getLLVMStyleWithColumns(35)); 8461 verifyFormat("someFunction(Param, Param,\n" 8462 " {List1, List2,\n" 8463 " List3});", 8464 getLLVMStyleWithColumns(35)); 8465 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 8466 " aaaaaaaaaaaaaaaaaaaaaaa);"); 8467 } 8468 8469 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 8470 FormatStyle DoNotMerge = getLLVMStyle(); 8471 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8472 8473 verifyFormat("void f() { return 42; }"); 8474 verifyFormat("void f() {\n" 8475 " return 42;\n" 8476 "}", 8477 DoNotMerge); 8478 verifyFormat("void f() {\n" 8479 " // Comment\n" 8480 "}"); 8481 verifyFormat("{\n" 8482 "#error {\n" 8483 " int a;\n" 8484 "}"); 8485 verifyFormat("{\n" 8486 " int a;\n" 8487 "#error {\n" 8488 "}"); 8489 verifyFormat("void f() {} // comment"); 8490 verifyFormat("void f() { int a; } // comment"); 8491 verifyFormat("void f() {\n" 8492 "} // comment", 8493 DoNotMerge); 8494 verifyFormat("void f() {\n" 8495 " int a;\n" 8496 "} // comment", 8497 DoNotMerge); 8498 verifyFormat("void f() {\n" 8499 "} // comment", 8500 getLLVMStyleWithColumns(15)); 8501 8502 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 8503 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 8504 8505 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 8506 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 8507 verifyFormat("class C {\n" 8508 " C()\n" 8509 " : iiiiiiii(nullptr),\n" 8510 " kkkkkkk(nullptr),\n" 8511 " mmmmmmm(nullptr),\n" 8512 " nnnnnnn(nullptr) {}\n" 8513 "};", 8514 getGoogleStyle()); 8515 8516 FormatStyle NoColumnLimit = getLLVMStyle(); 8517 NoColumnLimit.ColumnLimit = 0; 8518 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 8519 EXPECT_EQ("class C {\n" 8520 " A() : b(0) {}\n" 8521 "};", 8522 format("class C{A():b(0){}};", NoColumnLimit)); 8523 EXPECT_EQ("A()\n" 8524 " : b(0) {\n" 8525 "}", 8526 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 8527 8528 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 8529 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 8530 FormatStyle::SFS_None; 8531 EXPECT_EQ("A()\n" 8532 " : b(0) {\n" 8533 "}", 8534 format("A():b(0){}", DoNotMergeNoColumnLimit)); 8535 EXPECT_EQ("A()\n" 8536 " : b(0) {\n" 8537 "}", 8538 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 8539 8540 verifyFormat("#define A \\\n" 8541 " void f() { \\\n" 8542 " int i; \\\n" 8543 " }", 8544 getLLVMStyleWithColumns(20)); 8545 verifyFormat("#define A \\\n" 8546 " void f() { int i; }", 8547 getLLVMStyleWithColumns(21)); 8548 verifyFormat("#define A \\\n" 8549 " void f() { \\\n" 8550 " int i; \\\n" 8551 " } \\\n" 8552 " int j;", 8553 getLLVMStyleWithColumns(22)); 8554 verifyFormat("#define A \\\n" 8555 " void f() { int i; } \\\n" 8556 " int j;", 8557 getLLVMStyleWithColumns(23)); 8558 } 8559 8560 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 8561 FormatStyle MergeEmptyOnly = getLLVMStyle(); 8562 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8563 verifyFormat("class C {\n" 8564 " int f() {}\n" 8565 "};", 8566 MergeEmptyOnly); 8567 verifyFormat("class C {\n" 8568 " int f() {\n" 8569 " return 42;\n" 8570 " }\n" 8571 "};", 8572 MergeEmptyOnly); 8573 verifyFormat("int f() {}", MergeEmptyOnly); 8574 verifyFormat("int f() {\n" 8575 " return 42;\n" 8576 "}", 8577 MergeEmptyOnly); 8578 8579 // Also verify behavior when BraceWrapping.AfterFunction = true 8580 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8581 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 8582 verifyFormat("int f() {}", MergeEmptyOnly); 8583 verifyFormat("class C {\n" 8584 " int f() {}\n" 8585 "};", 8586 MergeEmptyOnly); 8587 } 8588 8589 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 8590 FormatStyle MergeInlineOnly = getLLVMStyle(); 8591 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8592 verifyFormat("class C {\n" 8593 " int f() { return 42; }\n" 8594 "};", 8595 MergeInlineOnly); 8596 verifyFormat("int f() {\n" 8597 " return 42;\n" 8598 "}", 8599 MergeInlineOnly); 8600 8601 // SFS_Inline implies SFS_Empty 8602 verifyFormat("class C {\n" 8603 " int f() {}\n" 8604 "};", 8605 MergeInlineOnly); 8606 verifyFormat("int f() {}", MergeInlineOnly); 8607 8608 // Also verify behavior when BraceWrapping.AfterFunction = true 8609 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8610 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8611 verifyFormat("class C {\n" 8612 " int f() { return 42; }\n" 8613 "};", 8614 MergeInlineOnly); 8615 verifyFormat("int f()\n" 8616 "{\n" 8617 " return 42;\n" 8618 "}", 8619 MergeInlineOnly); 8620 8621 // SFS_Inline implies SFS_Empty 8622 verifyFormat("int f() {}", MergeInlineOnly); 8623 verifyFormat("class C {\n" 8624 " int f() {}\n" 8625 "};", 8626 MergeInlineOnly); 8627 } 8628 8629 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8630 FormatStyle MergeInlineOnly = getLLVMStyle(); 8631 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8632 FormatStyle::SFS_InlineOnly; 8633 verifyFormat("class C {\n" 8634 " int f() { return 42; }\n" 8635 "};", 8636 MergeInlineOnly); 8637 verifyFormat("int f() {\n" 8638 " return 42;\n" 8639 "}", 8640 MergeInlineOnly); 8641 8642 // SFS_InlineOnly does not imply SFS_Empty 8643 verifyFormat("class C {\n" 8644 " int f() {}\n" 8645 "};", 8646 MergeInlineOnly); 8647 verifyFormat("int f() {\n" 8648 "}", 8649 MergeInlineOnly); 8650 8651 // Also verify behavior when BraceWrapping.AfterFunction = true 8652 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8653 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8654 verifyFormat("class C {\n" 8655 " int f() { return 42; }\n" 8656 "};", 8657 MergeInlineOnly); 8658 verifyFormat("int f()\n" 8659 "{\n" 8660 " return 42;\n" 8661 "}", 8662 MergeInlineOnly); 8663 8664 // SFS_InlineOnly does not imply SFS_Empty 8665 verifyFormat("int f()\n" 8666 "{\n" 8667 "}", 8668 MergeInlineOnly); 8669 verifyFormat("class C {\n" 8670 " int f() {}\n" 8671 "};", 8672 MergeInlineOnly); 8673 } 8674 8675 TEST_F(FormatTest, SplitEmptyFunction) { 8676 FormatStyle Style = getLLVMStyle(); 8677 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8678 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8679 Style.BraceWrapping.AfterFunction = true; 8680 Style.BraceWrapping.SplitEmptyFunction = false; 8681 Style.ColumnLimit = 40; 8682 8683 verifyFormat("int f()\n" 8684 "{}", 8685 Style); 8686 verifyFormat("int f()\n" 8687 "{\n" 8688 " return 42;\n" 8689 "}", 8690 Style); 8691 verifyFormat("int f()\n" 8692 "{\n" 8693 " // some comment\n" 8694 "}", 8695 Style); 8696 8697 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8698 verifyFormat("int f() {}", Style); 8699 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8700 "{}", 8701 Style); 8702 verifyFormat("int f()\n" 8703 "{\n" 8704 " return 0;\n" 8705 "}", 8706 Style); 8707 8708 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8709 verifyFormat("class Foo {\n" 8710 " int f() {}\n" 8711 "};\n", 8712 Style); 8713 verifyFormat("class Foo {\n" 8714 " int f() { return 0; }\n" 8715 "};\n", 8716 Style); 8717 verifyFormat("class Foo {\n" 8718 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8719 " {}\n" 8720 "};\n", 8721 Style); 8722 verifyFormat("class Foo {\n" 8723 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8724 " {\n" 8725 " return 0;\n" 8726 " }\n" 8727 "};\n", 8728 Style); 8729 8730 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8731 verifyFormat("int f() {}", Style); 8732 verifyFormat("int f() { return 0; }", Style); 8733 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8734 "{}", 8735 Style); 8736 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8737 "{\n" 8738 " return 0;\n" 8739 "}", 8740 Style); 8741 } 8742 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8743 FormatStyle Style = getLLVMStyle(); 8744 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8745 verifyFormat("#ifdef A\n" 8746 "int f() {}\n" 8747 "#else\n" 8748 "int g() {}\n" 8749 "#endif", 8750 Style); 8751 } 8752 8753 TEST_F(FormatTest, SplitEmptyClass) { 8754 FormatStyle Style = getLLVMStyle(); 8755 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8756 Style.BraceWrapping.AfterClass = true; 8757 Style.BraceWrapping.SplitEmptyRecord = false; 8758 8759 verifyFormat("class Foo\n" 8760 "{};", 8761 Style); 8762 verifyFormat("/* something */ class Foo\n" 8763 "{};", 8764 Style); 8765 verifyFormat("template <typename X> class Foo\n" 8766 "{};", 8767 Style); 8768 verifyFormat("class Foo\n" 8769 "{\n" 8770 " Foo();\n" 8771 "};", 8772 Style); 8773 verifyFormat("typedef class Foo\n" 8774 "{\n" 8775 "} Foo_t;", 8776 Style); 8777 } 8778 8779 TEST_F(FormatTest, SplitEmptyStruct) { 8780 FormatStyle Style = getLLVMStyle(); 8781 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8782 Style.BraceWrapping.AfterStruct = true; 8783 Style.BraceWrapping.SplitEmptyRecord = false; 8784 8785 verifyFormat("struct Foo\n" 8786 "{};", 8787 Style); 8788 verifyFormat("/* something */ struct Foo\n" 8789 "{};", 8790 Style); 8791 verifyFormat("template <typename X> struct Foo\n" 8792 "{};", 8793 Style); 8794 verifyFormat("struct Foo\n" 8795 "{\n" 8796 " Foo();\n" 8797 "};", 8798 Style); 8799 verifyFormat("typedef struct Foo\n" 8800 "{\n" 8801 "} Foo_t;", 8802 Style); 8803 // typedef struct Bar {} Bar_t; 8804 } 8805 8806 TEST_F(FormatTest, SplitEmptyUnion) { 8807 FormatStyle Style = getLLVMStyle(); 8808 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8809 Style.BraceWrapping.AfterUnion = true; 8810 Style.BraceWrapping.SplitEmptyRecord = false; 8811 8812 verifyFormat("union Foo\n" 8813 "{};", 8814 Style); 8815 verifyFormat("/* something */ union Foo\n" 8816 "{};", 8817 Style); 8818 verifyFormat("union Foo\n" 8819 "{\n" 8820 " A,\n" 8821 "};", 8822 Style); 8823 verifyFormat("typedef union Foo\n" 8824 "{\n" 8825 "} Foo_t;", 8826 Style); 8827 } 8828 8829 TEST_F(FormatTest, SplitEmptyNamespace) { 8830 FormatStyle Style = getLLVMStyle(); 8831 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8832 Style.BraceWrapping.AfterNamespace = true; 8833 Style.BraceWrapping.SplitEmptyNamespace = false; 8834 8835 verifyFormat("namespace Foo\n" 8836 "{};", 8837 Style); 8838 verifyFormat("/* something */ namespace Foo\n" 8839 "{};", 8840 Style); 8841 verifyFormat("inline namespace Foo\n" 8842 "{};", 8843 Style); 8844 verifyFormat("/* something */ inline namespace Foo\n" 8845 "{};", 8846 Style); 8847 verifyFormat("export namespace Foo\n" 8848 "{};", 8849 Style); 8850 verifyFormat("namespace Foo\n" 8851 "{\n" 8852 "void Bar();\n" 8853 "};", 8854 Style); 8855 } 8856 8857 TEST_F(FormatTest, NeverMergeShortRecords) { 8858 FormatStyle Style = getLLVMStyle(); 8859 8860 verifyFormat("class Foo {\n" 8861 " Foo();\n" 8862 "};", 8863 Style); 8864 verifyFormat("typedef class Foo {\n" 8865 " Foo();\n" 8866 "} Foo_t;", 8867 Style); 8868 verifyFormat("struct Foo {\n" 8869 " Foo();\n" 8870 "};", 8871 Style); 8872 verifyFormat("typedef struct Foo {\n" 8873 " Foo();\n" 8874 "} Foo_t;", 8875 Style); 8876 verifyFormat("union Foo {\n" 8877 " A,\n" 8878 "};", 8879 Style); 8880 verifyFormat("typedef union Foo {\n" 8881 " A,\n" 8882 "} Foo_t;", 8883 Style); 8884 verifyFormat("namespace Foo {\n" 8885 "void Bar();\n" 8886 "};", 8887 Style); 8888 8889 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8890 Style.BraceWrapping.AfterClass = true; 8891 Style.BraceWrapping.AfterStruct = true; 8892 Style.BraceWrapping.AfterUnion = true; 8893 Style.BraceWrapping.AfterNamespace = true; 8894 verifyFormat("class Foo\n" 8895 "{\n" 8896 " Foo();\n" 8897 "};", 8898 Style); 8899 verifyFormat("typedef class Foo\n" 8900 "{\n" 8901 " Foo();\n" 8902 "} Foo_t;", 8903 Style); 8904 verifyFormat("struct Foo\n" 8905 "{\n" 8906 " Foo();\n" 8907 "};", 8908 Style); 8909 verifyFormat("typedef struct Foo\n" 8910 "{\n" 8911 " Foo();\n" 8912 "} Foo_t;", 8913 Style); 8914 verifyFormat("union Foo\n" 8915 "{\n" 8916 " A,\n" 8917 "};", 8918 Style); 8919 verifyFormat("typedef union Foo\n" 8920 "{\n" 8921 " A,\n" 8922 "} Foo_t;", 8923 Style); 8924 verifyFormat("namespace Foo\n" 8925 "{\n" 8926 "void Bar();\n" 8927 "};", 8928 Style); 8929 } 8930 8931 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 8932 // Elaborate type variable declarations. 8933 verifyFormat("struct foo a = {bar};\nint n;"); 8934 verifyFormat("class foo a = {bar};\nint n;"); 8935 verifyFormat("union foo a = {bar};\nint n;"); 8936 8937 // Elaborate types inside function definitions. 8938 verifyFormat("struct foo f() {}\nint n;"); 8939 verifyFormat("class foo f() {}\nint n;"); 8940 verifyFormat("union foo f() {}\nint n;"); 8941 8942 // Templates. 8943 verifyFormat("template <class X> void f() {}\nint n;"); 8944 verifyFormat("template <struct X> void f() {}\nint n;"); 8945 verifyFormat("template <union X> void f() {}\nint n;"); 8946 8947 // Actual definitions... 8948 verifyFormat("struct {\n} n;"); 8949 verifyFormat( 8950 "template <template <class T, class Y>, class Z> class X {\n} n;"); 8951 verifyFormat("union Z {\n int n;\n} x;"); 8952 verifyFormat("class MACRO Z {\n} n;"); 8953 verifyFormat("class MACRO(X) Z {\n} n;"); 8954 verifyFormat("class __attribute__(X) Z {\n} n;"); 8955 verifyFormat("class __declspec(X) Z {\n} n;"); 8956 verifyFormat("class A##B##C {\n} n;"); 8957 verifyFormat("class alignas(16) Z {\n} n;"); 8958 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 8959 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 8960 8961 // Redefinition from nested context: 8962 verifyFormat("class A::B::C {\n} n;"); 8963 8964 // Template definitions. 8965 verifyFormat( 8966 "template <typename F>\n" 8967 "Matcher(const Matcher<F> &Other,\n" 8968 " typename enable_if_c<is_base_of<F, T>::value &&\n" 8969 " !is_same<F, T>::value>::type * = 0)\n" 8970 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 8971 8972 // FIXME: This is still incorrectly handled at the formatter side. 8973 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 8974 verifyFormat("int i = SomeFunction(a<b, a> b);"); 8975 8976 // FIXME: 8977 // This now gets parsed incorrectly as class definition. 8978 // verifyFormat("class A<int> f() {\n}\nint n;"); 8979 8980 // Elaborate types where incorrectly parsing the structural element would 8981 // break the indent. 8982 verifyFormat("if (true)\n" 8983 " class X x;\n" 8984 "else\n" 8985 " f();\n"); 8986 8987 // This is simply incomplete. Formatting is not important, but must not crash. 8988 verifyFormat("class A:"); 8989 } 8990 8991 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 8992 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 8993 format("#error Leave all white!!!!! space* alone!\n")); 8994 EXPECT_EQ( 8995 "#warning Leave all white!!!!! space* alone!\n", 8996 format("#warning Leave all white!!!!! space* alone!\n")); 8997 EXPECT_EQ("#error 1", format(" # error 1")); 8998 EXPECT_EQ("#warning 1", format(" # warning 1")); 8999 } 9000 9001 TEST_F(FormatTest, FormatHashIfExpressions) { 9002 verifyFormat("#if AAAA && BBBB"); 9003 verifyFormat("#if (AAAA && BBBB)"); 9004 verifyFormat("#elif (AAAA && BBBB)"); 9005 // FIXME: Come up with a better indentation for #elif. 9006 verifyFormat( 9007 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 9008 " defined(BBBBBBBB)\n" 9009 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 9010 " defined(BBBBBBBB)\n" 9011 "#endif", 9012 getLLVMStyleWithColumns(65)); 9013 } 9014 9015 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 9016 FormatStyle AllowsMergedIf = getGoogleStyle(); 9017 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 9018 FormatStyle::SIS_WithoutElse; 9019 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 9020 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 9021 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 9022 EXPECT_EQ("if (true) return 42;", 9023 format("if (true)\nreturn 42;", AllowsMergedIf)); 9024 FormatStyle ShortMergedIf = AllowsMergedIf; 9025 ShortMergedIf.ColumnLimit = 25; 9026 verifyFormat("#define A \\\n" 9027 " if (true) return 42;", 9028 ShortMergedIf); 9029 verifyFormat("#define A \\\n" 9030 " f(); \\\n" 9031 " if (true)\n" 9032 "#define B", 9033 ShortMergedIf); 9034 verifyFormat("#define A \\\n" 9035 " f(); \\\n" 9036 " if (true)\n" 9037 "g();", 9038 ShortMergedIf); 9039 verifyFormat("{\n" 9040 "#ifdef A\n" 9041 " // Comment\n" 9042 " if (true) continue;\n" 9043 "#endif\n" 9044 " // Comment\n" 9045 " if (true) continue;\n" 9046 "}", 9047 ShortMergedIf); 9048 ShortMergedIf.ColumnLimit = 33; 9049 verifyFormat("#define A \\\n" 9050 " if constexpr (true) return 42;", 9051 ShortMergedIf); 9052 verifyFormat("#define A \\\n" 9053 " if CONSTEXPR (true) return 42;", 9054 ShortMergedIf); 9055 ShortMergedIf.ColumnLimit = 29; 9056 verifyFormat("#define A \\\n" 9057 " if (aaaaaaaaaa) return 1; \\\n" 9058 " return 2;", 9059 ShortMergedIf); 9060 ShortMergedIf.ColumnLimit = 28; 9061 verifyFormat("#define A \\\n" 9062 " if (aaaaaaaaaa) \\\n" 9063 " return 1; \\\n" 9064 " return 2;", 9065 ShortMergedIf); 9066 verifyFormat("#define A \\\n" 9067 " if constexpr (aaaaaaa) \\\n" 9068 " return 1; \\\n" 9069 " return 2;", 9070 ShortMergedIf); 9071 verifyFormat("#define A \\\n" 9072 " if CONSTEXPR (aaaaaaa) \\\n" 9073 " return 1; \\\n" 9074 " return 2;", 9075 ShortMergedIf); 9076 } 9077 9078 TEST_F(FormatTest, FormatStarDependingOnContext) { 9079 verifyFormat("void f(int *a);"); 9080 verifyFormat("void f() { f(fint * b); }"); 9081 verifyFormat("class A {\n void f(int *a);\n};"); 9082 verifyFormat("class A {\n int *a;\n};"); 9083 verifyFormat("namespace a {\n" 9084 "namespace b {\n" 9085 "class A {\n" 9086 " void f() {}\n" 9087 " int *a;\n" 9088 "};\n" 9089 "} // namespace b\n" 9090 "} // namespace a"); 9091 } 9092 9093 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 9094 verifyFormat("while"); 9095 verifyFormat("operator"); 9096 } 9097 9098 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 9099 // This code would be painfully slow to format if we didn't skip it. 9100 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 9101 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9102 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9103 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9104 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9105 "A(1, 1)\n" 9106 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 9107 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9108 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9109 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9110 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9111 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9112 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9113 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9114 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9115 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 9116 // Deeply nested part is untouched, rest is formatted. 9117 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 9118 format(std::string("int i;\n") + Code + "int j;\n", 9119 getLLVMStyle(), SC_ExpectIncomplete)); 9120 } 9121 9122 //===----------------------------------------------------------------------===// 9123 // Objective-C tests. 9124 //===----------------------------------------------------------------------===// 9125 9126 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 9127 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 9128 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 9129 format("-(NSUInteger)indexOfObject:(id)anObject;")); 9130 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 9131 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 9132 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 9133 format("-(NSInteger)Method3:(id)anObject;")); 9134 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 9135 format("-(NSInteger)Method4:(id)anObject;")); 9136 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 9137 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 9138 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 9139 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 9140 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9141 "forAllCells:(BOOL)flag;", 9142 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9143 "forAllCells:(BOOL)flag;")); 9144 9145 // Very long objectiveC method declaration. 9146 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 9147 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 9148 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 9149 " inRange:(NSRange)range\n" 9150 " outRange:(NSRange)out_range\n" 9151 " outRange1:(NSRange)out_range1\n" 9152 " outRange2:(NSRange)out_range2\n" 9153 " outRange3:(NSRange)out_range3\n" 9154 " outRange4:(NSRange)out_range4\n" 9155 " outRange5:(NSRange)out_range5\n" 9156 " outRange6:(NSRange)out_range6\n" 9157 " outRange7:(NSRange)out_range7\n" 9158 " outRange8:(NSRange)out_range8\n" 9159 " outRange9:(NSRange)out_range9;"); 9160 9161 // When the function name has to be wrapped. 9162 FormatStyle Style = getLLVMStyle(); 9163 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 9164 // and always indents instead. 9165 Style.IndentWrappedFunctionNames = false; 9166 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9167 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 9168 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 9169 "}", 9170 Style); 9171 Style.IndentWrappedFunctionNames = true; 9172 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9173 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 9174 " anotherName:(NSString)dddddddddddddd {\n" 9175 "}", 9176 Style); 9177 9178 verifyFormat("- (int)sum:(vector<int>)numbers;"); 9179 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 9180 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 9181 // protocol lists (but not for template classes): 9182 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 9183 9184 verifyFormat("- (int (*)())foo:(int (*)())f;"); 9185 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 9186 9187 // If there's no return type (very rare in practice!), LLVM and Google style 9188 // agree. 9189 verifyFormat("- foo;"); 9190 verifyFormat("- foo:(int)f;"); 9191 verifyGoogleFormat("- foo:(int)foo;"); 9192 } 9193 9194 TEST_F(FormatTest, BreaksStringLiterals) { 9195 EXPECT_EQ("\"some text \"\n" 9196 "\"other\";", 9197 format("\"some text other\";", getLLVMStyleWithColumns(12))); 9198 EXPECT_EQ("\"some text \"\n" 9199 "\"other\";", 9200 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 9201 EXPECT_EQ( 9202 "#define A \\\n" 9203 " \"some \" \\\n" 9204 " \"text \" \\\n" 9205 " \"other\";", 9206 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 9207 EXPECT_EQ( 9208 "#define A \\\n" 9209 " \"so \" \\\n" 9210 " \"text \" \\\n" 9211 " \"other\";", 9212 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 9213 9214 EXPECT_EQ("\"some text\"", 9215 format("\"some text\"", getLLVMStyleWithColumns(1))); 9216 EXPECT_EQ("\"some text\"", 9217 format("\"some text\"", getLLVMStyleWithColumns(11))); 9218 EXPECT_EQ("\"some \"\n" 9219 "\"text\"", 9220 format("\"some text\"", getLLVMStyleWithColumns(10))); 9221 EXPECT_EQ("\"some \"\n" 9222 "\"text\"", 9223 format("\"some text\"", getLLVMStyleWithColumns(7))); 9224 EXPECT_EQ("\"some\"\n" 9225 "\" tex\"\n" 9226 "\"t\"", 9227 format("\"some text\"", getLLVMStyleWithColumns(6))); 9228 EXPECT_EQ("\"some\"\n" 9229 "\" tex\"\n" 9230 "\" and\"", 9231 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 9232 EXPECT_EQ("\"some\"\n" 9233 "\"/tex\"\n" 9234 "\"/and\"", 9235 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 9236 9237 EXPECT_EQ("variable =\n" 9238 " \"long string \"\n" 9239 " \"literal\";", 9240 format("variable = \"long string literal\";", 9241 getLLVMStyleWithColumns(20))); 9242 9243 EXPECT_EQ("variable = f(\n" 9244 " \"long string \"\n" 9245 " \"literal\",\n" 9246 " short,\n" 9247 " loooooooooooooooooooong);", 9248 format("variable = f(\"long string literal\", short, " 9249 "loooooooooooooooooooong);", 9250 getLLVMStyleWithColumns(20))); 9251 9252 EXPECT_EQ( 9253 "f(g(\"long string \"\n" 9254 " \"literal\"),\n" 9255 " b);", 9256 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 9257 EXPECT_EQ("f(g(\"long string \"\n" 9258 " \"literal\",\n" 9259 " a),\n" 9260 " b);", 9261 format("f(g(\"long string literal\", a), b);", 9262 getLLVMStyleWithColumns(20))); 9263 EXPECT_EQ( 9264 "f(\"one two\".split(\n" 9265 " variable));", 9266 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 9267 EXPECT_EQ("f(\"one two three four five six \"\n" 9268 " \"seven\".split(\n" 9269 " really_looooong_variable));", 9270 format("f(\"one two three four five six seven\"." 9271 "split(really_looooong_variable));", 9272 getLLVMStyleWithColumns(33))); 9273 9274 EXPECT_EQ("f(\"some \"\n" 9275 " \"text\",\n" 9276 " other);", 9277 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 9278 9279 // Only break as a last resort. 9280 verifyFormat( 9281 "aaaaaaaaaaaaaaaaaaaa(\n" 9282 " aaaaaaaaaaaaaaaaaaaa,\n" 9283 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 9284 9285 EXPECT_EQ("\"splitmea\"\n" 9286 "\"trandomp\"\n" 9287 "\"oint\"", 9288 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 9289 9290 EXPECT_EQ("\"split/\"\n" 9291 "\"pathat/\"\n" 9292 "\"slashes\"", 9293 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9294 9295 EXPECT_EQ("\"split/\"\n" 9296 "\"pathat/\"\n" 9297 "\"slashes\"", 9298 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9299 EXPECT_EQ("\"split at \"\n" 9300 "\"spaces/at/\"\n" 9301 "\"slashes.at.any$\"\n" 9302 "\"non-alphanumeric%\"\n" 9303 "\"1111111111characte\"\n" 9304 "\"rs\"", 9305 format("\"split at " 9306 "spaces/at/" 9307 "slashes.at." 9308 "any$non-" 9309 "alphanumeric%" 9310 "1111111111characte" 9311 "rs\"", 9312 getLLVMStyleWithColumns(20))); 9313 9314 // Verify that splitting the strings understands 9315 // Style::AlwaysBreakBeforeMultilineStrings. 9316 EXPECT_EQ("aaaaaaaaaaaa(\n" 9317 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 9318 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 9319 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 9320 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9321 "aaaaaaaaaaaaaaaaaaaaaa\");", 9322 getGoogleStyle())); 9323 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9324 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 9325 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 9326 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9327 "aaaaaaaaaaaaaaaaaaaaaa\";", 9328 getGoogleStyle())); 9329 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9330 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9331 format("llvm::outs() << " 9332 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 9333 "aaaaaaaaaaaaaaaaaaa\";")); 9334 EXPECT_EQ("ffff(\n" 9335 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9336 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9337 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 9338 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9339 getGoogleStyle())); 9340 9341 FormatStyle Style = getLLVMStyleWithColumns(12); 9342 Style.BreakStringLiterals = false; 9343 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 9344 9345 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 9346 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9347 EXPECT_EQ("#define A \\\n" 9348 " \"some \" \\\n" 9349 " \"text \" \\\n" 9350 " \"other\";", 9351 format("#define A \"some text other\";", AlignLeft)); 9352 } 9353 9354 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 9355 EXPECT_EQ("C a = \"some more \"\n" 9356 " \"text\";", 9357 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 9358 } 9359 9360 TEST_F(FormatTest, FullyRemoveEmptyLines) { 9361 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 9362 NoEmptyLines.MaxEmptyLinesToKeep = 0; 9363 EXPECT_EQ("int i = a(b());", 9364 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 9365 } 9366 9367 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 9368 EXPECT_EQ( 9369 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9370 "(\n" 9371 " \"x\t\");", 9372 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9373 "aaaaaaa(" 9374 "\"x\t\");")); 9375 } 9376 9377 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 9378 EXPECT_EQ( 9379 "u8\"utf8 string \"\n" 9380 "u8\"literal\";", 9381 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 9382 EXPECT_EQ( 9383 "u\"utf16 string \"\n" 9384 "u\"literal\";", 9385 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 9386 EXPECT_EQ( 9387 "U\"utf32 string \"\n" 9388 "U\"literal\";", 9389 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 9390 EXPECT_EQ("L\"wide string \"\n" 9391 "L\"literal\";", 9392 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 9393 EXPECT_EQ("@\"NSString \"\n" 9394 "@\"literal\";", 9395 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 9396 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 9397 9398 // This input makes clang-format try to split the incomplete unicode escape 9399 // sequence, which used to lead to a crasher. 9400 verifyNoCrash( 9401 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 9402 getLLVMStyleWithColumns(60)); 9403 } 9404 9405 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 9406 FormatStyle Style = getGoogleStyleWithColumns(15); 9407 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 9408 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 9409 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 9410 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 9411 EXPECT_EQ("u8R\"x(raw literal)x\";", 9412 format("u8R\"x(raw literal)x\";", Style)); 9413 } 9414 9415 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 9416 FormatStyle Style = getLLVMStyleWithColumns(20); 9417 EXPECT_EQ( 9418 "_T(\"aaaaaaaaaaaaaa\")\n" 9419 "_T(\"aaaaaaaaaaaaaa\")\n" 9420 "_T(\"aaaaaaaaaaaa\")", 9421 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 9422 EXPECT_EQ("f(x,\n" 9423 " _T(\"aaaaaaaaaaaa\")\n" 9424 " _T(\"aaa\"),\n" 9425 " z);", 9426 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 9427 9428 // FIXME: Handle embedded spaces in one iteration. 9429 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 9430 // "_T(\"aaaaaaaaaaaaa\")\n" 9431 // "_T(\"aaaaaaaaaaaaa\")\n" 9432 // "_T(\"a\")", 9433 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9434 // getLLVMStyleWithColumns(20))); 9435 EXPECT_EQ( 9436 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9437 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 9438 EXPECT_EQ("f(\n" 9439 "#if !TEST\n" 9440 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9441 "#endif\n" 9442 ");", 9443 format("f(\n" 9444 "#if !TEST\n" 9445 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9446 "#endif\n" 9447 ");")); 9448 EXPECT_EQ("f(\n" 9449 "\n" 9450 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 9451 format("f(\n" 9452 "\n" 9453 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 9454 } 9455 9456 TEST_F(FormatTest, BreaksStringLiteralOperands) { 9457 // In a function call with two operands, the second can be broken with no line 9458 // break before it. 9459 EXPECT_EQ( 9460 "func(a, \"long long \"\n" 9461 " \"long long\");", 9462 format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24))); 9463 // In a function call with three operands, the second must be broken with a 9464 // line break before it. 9465 EXPECT_EQ("func(a,\n" 9466 " \"long long long \"\n" 9467 " \"long\",\n" 9468 " c);", 9469 format("func(a, \"long long long long\", c);", 9470 getLLVMStyleWithColumns(24))); 9471 // In a function call with three operands, the third must be broken with a 9472 // line break before it. 9473 EXPECT_EQ("func(a, b,\n" 9474 " \"long long long \"\n" 9475 " \"long\");", 9476 format("func(a, b, \"long long long long\");", 9477 getLLVMStyleWithColumns(24))); 9478 // In a function call with three operands, both the second and the third must 9479 // be broken with a line break before them. 9480 EXPECT_EQ("func(a,\n" 9481 " \"long long long \"\n" 9482 " \"long\",\n" 9483 " \"long long long \"\n" 9484 " \"long\");", 9485 format("func(a, \"long long long long\", \"long long long long\");", 9486 getLLVMStyleWithColumns(24))); 9487 // In a chain of << with two operands, the second can be broken with no line 9488 // break before it. 9489 EXPECT_EQ("a << \"line line \"\n" 9490 " \"line\";", 9491 format("a << \"line line line\";", getLLVMStyleWithColumns(20))); 9492 // In a chain of << with three operands, the second can be broken with no line 9493 // break before it. 9494 EXPECT_EQ( 9495 "abcde << \"line \"\n" 9496 " \"line line\"\n" 9497 " << c;", 9498 format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20))); 9499 // In a chain of << with three operands, the third must be broken with a line 9500 // break before it. 9501 EXPECT_EQ( 9502 "a << b\n" 9503 " << \"line line \"\n" 9504 " \"line\";", 9505 format("a << b << \"line line line\";", getLLVMStyleWithColumns(20))); 9506 // In a chain of << with three operands, the second can be broken with no line 9507 // break before it and the third must be broken with a line break before it. 9508 EXPECT_EQ("abcd << \"line line \"\n" 9509 " \"line\"\n" 9510 " << \"line line \"\n" 9511 " \"line\";", 9512 format("abcd << \"line line line\" << \"line line line\";", 9513 getLLVMStyleWithColumns(20))); 9514 // In a chain of binary operators with two operands, the second can be broken 9515 // with no line break before it. 9516 EXPECT_EQ( 9517 "abcd + \"line line \"\n" 9518 " \"line line\";", 9519 format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20))); 9520 // In a chain of binary operators with three operands, the second must be 9521 // broken with a line break before it. 9522 EXPECT_EQ("abcd +\n" 9523 " \"line line \"\n" 9524 " \"line line\" +\n" 9525 " e;", 9526 format("abcd + \"line line line line\" + e;", 9527 getLLVMStyleWithColumns(20))); 9528 // In a function call with two operands, with AlignAfterOpenBracket enabled, 9529 // the first must be broken with a line break before it. 9530 FormatStyle Style = getLLVMStyleWithColumns(25); 9531 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 9532 EXPECT_EQ("someFunction(\n" 9533 " \"long long long \"\n" 9534 " \"long\",\n" 9535 " a);", 9536 format("someFunction(\"long long long long\", a);", Style)); 9537 } 9538 9539 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 9540 EXPECT_EQ( 9541 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9542 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9543 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9544 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9545 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9546 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 9547 } 9548 9549 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 9550 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 9551 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 9552 EXPECT_EQ("fffffffffff(g(R\"x(\n" 9553 "multiline raw string literal xxxxxxxxxxxxxx\n" 9554 ")x\",\n" 9555 " a),\n" 9556 " b);", 9557 format("fffffffffff(g(R\"x(\n" 9558 "multiline raw string literal xxxxxxxxxxxxxx\n" 9559 ")x\", a), b);", 9560 getGoogleStyleWithColumns(20))); 9561 EXPECT_EQ("fffffffffff(\n" 9562 " g(R\"x(qqq\n" 9563 "multiline raw string literal xxxxxxxxxxxxxx\n" 9564 ")x\",\n" 9565 " a),\n" 9566 " b);", 9567 format("fffffffffff(g(R\"x(qqq\n" 9568 "multiline raw string literal xxxxxxxxxxxxxx\n" 9569 ")x\", a), b);", 9570 getGoogleStyleWithColumns(20))); 9571 9572 EXPECT_EQ("fffffffffff(R\"x(\n" 9573 "multiline raw string literal xxxxxxxxxxxxxx\n" 9574 ")x\");", 9575 format("fffffffffff(R\"x(\n" 9576 "multiline raw string literal xxxxxxxxxxxxxx\n" 9577 ")x\");", 9578 getGoogleStyleWithColumns(20))); 9579 EXPECT_EQ("fffffffffff(R\"x(\n" 9580 "multiline raw string literal xxxxxxxxxxxxxx\n" 9581 ")x\" + bbbbbb);", 9582 format("fffffffffff(R\"x(\n" 9583 "multiline raw string literal xxxxxxxxxxxxxx\n" 9584 ")x\" + bbbbbb);", 9585 getGoogleStyleWithColumns(20))); 9586 EXPECT_EQ("fffffffffff(\n" 9587 " R\"x(\n" 9588 "multiline raw string literal xxxxxxxxxxxxxx\n" 9589 ")x\" +\n" 9590 " bbbbbb);", 9591 format("fffffffffff(\n" 9592 " R\"x(\n" 9593 "multiline raw string literal xxxxxxxxxxxxxx\n" 9594 ")x\" + bbbbbb);", 9595 getGoogleStyleWithColumns(20))); 9596 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 9597 format("fffffffffff(\n" 9598 " R\"(single line raw string)\" + bbbbbb);")); 9599 } 9600 9601 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 9602 verifyFormat("string a = \"unterminated;"); 9603 EXPECT_EQ("function(\"unterminated,\n" 9604 " OtherParameter);", 9605 format("function( \"unterminated,\n" 9606 " OtherParameter);")); 9607 } 9608 9609 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9610 FormatStyle Style = getLLVMStyle(); 9611 Style.Standard = FormatStyle::LS_Cpp03; 9612 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9613 format("#define x(_a) printf(\"foo\"_a);", Style)); 9614 } 9615 9616 TEST_F(FormatTest, CppLexVersion) { 9617 FormatStyle Style = getLLVMStyle(); 9618 // Formatting of x * y differs if x is a type. 9619 verifyFormat("void foo() { MACRO(a * b); }", Style); 9620 verifyFormat("void foo() { MACRO(int *b); }", Style); 9621 9622 // LLVM style uses latest lexer. 9623 verifyFormat("void foo() { MACRO(char8_t *b); }", Style); 9624 Style.Standard = FormatStyle::LS_Cpp17; 9625 // But in c++17, char8_t isn't a keyword. 9626 verifyFormat("void foo() { MACRO(char8_t * b); }", Style); 9627 } 9628 9629 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9630 9631 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9632 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9633 " \"ddeeefff\");", 9634 format("someFunction(\"aaabbbcccdddeeefff\");", 9635 getLLVMStyleWithColumns(25))); 9636 EXPECT_EQ("someFunction1234567890(\n" 9637 " \"aaabbbcccdddeeefff\");", 9638 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9639 getLLVMStyleWithColumns(26))); 9640 EXPECT_EQ("someFunction1234567890(\n" 9641 " \"aaabbbcccdddeeeff\"\n" 9642 " \"f\");", 9643 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9644 getLLVMStyleWithColumns(25))); 9645 EXPECT_EQ("someFunction1234567890(\n" 9646 " \"aaabbbcccdddeeeff\"\n" 9647 " \"f\");", 9648 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9649 getLLVMStyleWithColumns(24))); 9650 EXPECT_EQ("someFunction(\n" 9651 " \"aaabbbcc ddde \"\n" 9652 " \"efff\");", 9653 format("someFunction(\"aaabbbcc ddde efff\");", 9654 getLLVMStyleWithColumns(25))); 9655 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9656 " \"ddeeefff\");", 9657 format("someFunction(\"aaabbbccc ddeeefff\");", 9658 getLLVMStyleWithColumns(25))); 9659 EXPECT_EQ("someFunction1234567890(\n" 9660 " \"aaabb \"\n" 9661 " \"cccdddeeefff\");", 9662 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9663 getLLVMStyleWithColumns(25))); 9664 EXPECT_EQ("#define A \\\n" 9665 " string s = \\\n" 9666 " \"123456789\" \\\n" 9667 " \"0\"; \\\n" 9668 " int i;", 9669 format("#define A string s = \"1234567890\"; int i;", 9670 getLLVMStyleWithColumns(20))); 9671 EXPECT_EQ("someFunction(\n" 9672 " \"aaabbbcc \"\n" 9673 " \"dddeeefff\");", 9674 format("someFunction(\"aaabbbcc dddeeefff\");", 9675 getLLVMStyleWithColumns(25))); 9676 } 9677 9678 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9679 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9680 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9681 EXPECT_EQ("\"test\"\n" 9682 "\"\\n\"", 9683 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9684 EXPECT_EQ("\"tes\\\\\"\n" 9685 "\"n\"", 9686 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9687 EXPECT_EQ("\"\\\\\\\\\"\n" 9688 "\"\\n\"", 9689 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9690 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9691 EXPECT_EQ("\"\\uff01\"\n" 9692 "\"test\"", 9693 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9694 EXPECT_EQ("\"\\Uff01ff02\"", 9695 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9696 EXPECT_EQ("\"\\x000000000001\"\n" 9697 "\"next\"", 9698 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9699 EXPECT_EQ("\"\\x000000000001next\"", 9700 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9701 EXPECT_EQ("\"\\x000000000001\"", 9702 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9703 EXPECT_EQ("\"test\"\n" 9704 "\"\\000000\"\n" 9705 "\"000001\"", 9706 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9707 EXPECT_EQ("\"test\\000\"\n" 9708 "\"00000000\"\n" 9709 "\"1\"", 9710 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9711 } 9712 9713 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9714 verifyFormat("void f() {\n" 9715 " return g() {}\n" 9716 " void h() {}"); 9717 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9718 "g();\n" 9719 "}"); 9720 } 9721 9722 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9723 verifyFormat( 9724 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9725 } 9726 9727 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9728 verifyFormat("class X {\n" 9729 " void f() {\n" 9730 " }\n" 9731 "};", 9732 getLLVMStyleWithColumns(12)); 9733 } 9734 9735 TEST_F(FormatTest, ConfigurableIndentWidth) { 9736 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9737 EightIndent.IndentWidth = 8; 9738 EightIndent.ContinuationIndentWidth = 8; 9739 verifyFormat("void f() {\n" 9740 " someFunction();\n" 9741 " if (true) {\n" 9742 " f();\n" 9743 " }\n" 9744 "}", 9745 EightIndent); 9746 verifyFormat("class X {\n" 9747 " void f() {\n" 9748 " }\n" 9749 "};", 9750 EightIndent); 9751 verifyFormat("int x[] = {\n" 9752 " call(),\n" 9753 " call()};", 9754 EightIndent); 9755 } 9756 9757 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9758 verifyFormat("double\n" 9759 "f();", 9760 getLLVMStyleWithColumns(8)); 9761 } 9762 9763 TEST_F(FormatTest, ConfigurableUseOfTab) { 9764 FormatStyle Tab = getLLVMStyleWithColumns(42); 9765 Tab.IndentWidth = 8; 9766 Tab.UseTab = FormatStyle::UT_Always; 9767 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9768 9769 EXPECT_EQ("if (aaaaaaaa && // q\n" 9770 " bb)\t\t// w\n" 9771 "\t;", 9772 format("if (aaaaaaaa &&// q\n" 9773 "bb)// w\n" 9774 ";", 9775 Tab)); 9776 EXPECT_EQ("if (aaa && bbb) // w\n" 9777 "\t;", 9778 format("if(aaa&&bbb)// w\n" 9779 ";", 9780 Tab)); 9781 9782 verifyFormat("class X {\n" 9783 "\tvoid f() {\n" 9784 "\t\tsomeFunction(parameter1,\n" 9785 "\t\t\t parameter2);\n" 9786 "\t}\n" 9787 "};", 9788 Tab); 9789 verifyFormat("#define A \\\n" 9790 "\tvoid f() { \\\n" 9791 "\t\tsomeFunction( \\\n" 9792 "\t\t parameter1, \\\n" 9793 "\t\t parameter2); \\\n" 9794 "\t}", 9795 Tab); 9796 verifyFormat("int a;\t // x\n" 9797 "int bbbbbbbb; // x\n", 9798 Tab); 9799 9800 Tab.TabWidth = 4; 9801 Tab.IndentWidth = 8; 9802 verifyFormat("class TabWidth4Indent8 {\n" 9803 "\t\tvoid f() {\n" 9804 "\t\t\t\tsomeFunction(parameter1,\n" 9805 "\t\t\t\t\t\t\t parameter2);\n" 9806 "\t\t}\n" 9807 "};", 9808 Tab); 9809 9810 Tab.TabWidth = 4; 9811 Tab.IndentWidth = 4; 9812 verifyFormat("class TabWidth4Indent4 {\n" 9813 "\tvoid f() {\n" 9814 "\t\tsomeFunction(parameter1,\n" 9815 "\t\t\t\t\t parameter2);\n" 9816 "\t}\n" 9817 "};", 9818 Tab); 9819 9820 Tab.TabWidth = 8; 9821 Tab.IndentWidth = 4; 9822 verifyFormat("class TabWidth8Indent4 {\n" 9823 " void f() {\n" 9824 "\tsomeFunction(parameter1,\n" 9825 "\t\t parameter2);\n" 9826 " }\n" 9827 "};", 9828 Tab); 9829 9830 Tab.TabWidth = 8; 9831 Tab.IndentWidth = 8; 9832 EXPECT_EQ("/*\n" 9833 "\t a\t\tcomment\n" 9834 "\t in multiple lines\n" 9835 " */", 9836 format(" /*\t \t \n" 9837 " \t \t a\t\tcomment\t \t\n" 9838 " \t \t in multiple lines\t\n" 9839 " \t */", 9840 Tab)); 9841 9842 Tab.UseTab = FormatStyle::UT_ForIndentation; 9843 verifyFormat("{\n" 9844 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9845 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9846 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9847 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9848 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9849 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9850 "};", 9851 Tab); 9852 verifyFormat("enum AA {\n" 9853 "\ta1, // Force multiple lines\n" 9854 "\ta2,\n" 9855 "\ta3\n" 9856 "};", 9857 Tab); 9858 EXPECT_EQ("if (aaaaaaaa && // q\n" 9859 " bb) // w\n" 9860 "\t;", 9861 format("if (aaaaaaaa &&// q\n" 9862 "bb)// w\n" 9863 ";", 9864 Tab)); 9865 verifyFormat("class X {\n" 9866 "\tvoid f() {\n" 9867 "\t\tsomeFunction(parameter1,\n" 9868 "\t\t parameter2);\n" 9869 "\t}\n" 9870 "};", 9871 Tab); 9872 verifyFormat("{\n" 9873 "\tQ(\n" 9874 "\t {\n" 9875 "\t\t int a;\n" 9876 "\t\t someFunction(aaaaaaaa,\n" 9877 "\t\t bbbbbbb);\n" 9878 "\t },\n" 9879 "\t p);\n" 9880 "}", 9881 Tab); 9882 EXPECT_EQ("{\n" 9883 "\t/* aaaa\n" 9884 "\t bbbb */\n" 9885 "}", 9886 format("{\n" 9887 "/* aaaa\n" 9888 " bbbb */\n" 9889 "}", 9890 Tab)); 9891 EXPECT_EQ("{\n" 9892 "\t/*\n" 9893 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9894 "\t bbbbbbbbbbbbb\n" 9895 "\t*/\n" 9896 "}", 9897 format("{\n" 9898 "/*\n" 9899 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9900 "*/\n" 9901 "}", 9902 Tab)); 9903 EXPECT_EQ("{\n" 9904 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9905 "\t// bbbbbbbbbbbbb\n" 9906 "}", 9907 format("{\n" 9908 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9909 "}", 9910 Tab)); 9911 EXPECT_EQ("{\n" 9912 "\t/*\n" 9913 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9914 "\t bbbbbbbbbbbbb\n" 9915 "\t*/\n" 9916 "}", 9917 format("{\n" 9918 "\t/*\n" 9919 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9920 "\t*/\n" 9921 "}", 9922 Tab)); 9923 EXPECT_EQ("{\n" 9924 "\t/*\n" 9925 "\n" 9926 "\t*/\n" 9927 "}", 9928 format("{\n" 9929 "\t/*\n" 9930 "\n" 9931 "\t*/\n" 9932 "}", 9933 Tab)); 9934 EXPECT_EQ("{\n" 9935 "\t/*\n" 9936 " asdf\n" 9937 "\t*/\n" 9938 "}", 9939 format("{\n" 9940 "\t/*\n" 9941 " asdf\n" 9942 "\t*/\n" 9943 "}", 9944 Tab)); 9945 9946 Tab.UseTab = FormatStyle::UT_Never; 9947 EXPECT_EQ("/*\n" 9948 " a\t\tcomment\n" 9949 " in multiple lines\n" 9950 " */", 9951 format(" /*\t \t \n" 9952 " \t \t a\t\tcomment\t \t\n" 9953 " \t \t in multiple lines\t\n" 9954 " \t */", 9955 Tab)); 9956 EXPECT_EQ("/* some\n" 9957 " comment */", 9958 format(" \t \t /* some\n" 9959 " \t \t comment */", 9960 Tab)); 9961 EXPECT_EQ("int a; /* some\n" 9962 " comment */", 9963 format(" \t \t int a; /* some\n" 9964 " \t \t comment */", 9965 Tab)); 9966 9967 EXPECT_EQ("int a; /* some\n" 9968 "comment */", 9969 format(" \t \t int\ta; /* some\n" 9970 " \t \t comment */", 9971 Tab)); 9972 EXPECT_EQ("f(\"\t\t\"); /* some\n" 9973 " comment */", 9974 format(" \t \t f(\"\t\t\"); /* some\n" 9975 " \t \t comment */", 9976 Tab)); 9977 EXPECT_EQ("{\n" 9978 " /*\n" 9979 " * Comment\n" 9980 " */\n" 9981 " int i;\n" 9982 "}", 9983 format("{\n" 9984 "\t/*\n" 9985 "\t * Comment\n" 9986 "\t */\n" 9987 "\t int i;\n" 9988 "}")); 9989 9990 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 9991 Tab.TabWidth = 8; 9992 Tab.IndentWidth = 8; 9993 EXPECT_EQ("if (aaaaaaaa && // q\n" 9994 " bb) // w\n" 9995 "\t;", 9996 format("if (aaaaaaaa &&// q\n" 9997 "bb)// w\n" 9998 ";", 9999 Tab)); 10000 EXPECT_EQ("if (aaa && bbb) // w\n" 10001 "\t;", 10002 format("if(aaa&&bbb)// w\n" 10003 ";", 10004 Tab)); 10005 verifyFormat("class X {\n" 10006 "\tvoid f() {\n" 10007 "\t\tsomeFunction(parameter1,\n" 10008 "\t\t\t parameter2);\n" 10009 "\t}\n" 10010 "};", 10011 Tab); 10012 verifyFormat("#define A \\\n" 10013 "\tvoid f() { \\\n" 10014 "\t\tsomeFunction( \\\n" 10015 "\t\t parameter1, \\\n" 10016 "\t\t parameter2); \\\n" 10017 "\t}", 10018 Tab); 10019 Tab.TabWidth = 4; 10020 Tab.IndentWidth = 8; 10021 verifyFormat("class TabWidth4Indent8 {\n" 10022 "\t\tvoid f() {\n" 10023 "\t\t\t\tsomeFunction(parameter1,\n" 10024 "\t\t\t\t\t\t\t parameter2);\n" 10025 "\t\t}\n" 10026 "};", 10027 Tab); 10028 Tab.TabWidth = 4; 10029 Tab.IndentWidth = 4; 10030 verifyFormat("class TabWidth4Indent4 {\n" 10031 "\tvoid f() {\n" 10032 "\t\tsomeFunction(parameter1,\n" 10033 "\t\t\t\t\t parameter2);\n" 10034 "\t}\n" 10035 "};", 10036 Tab); 10037 Tab.TabWidth = 8; 10038 Tab.IndentWidth = 4; 10039 verifyFormat("class TabWidth8Indent4 {\n" 10040 " void f() {\n" 10041 "\tsomeFunction(parameter1,\n" 10042 "\t\t parameter2);\n" 10043 " }\n" 10044 "};", 10045 Tab); 10046 Tab.TabWidth = 8; 10047 Tab.IndentWidth = 8; 10048 EXPECT_EQ("/*\n" 10049 "\t a\t\tcomment\n" 10050 "\t in multiple lines\n" 10051 " */", 10052 format(" /*\t \t \n" 10053 " \t \t a\t\tcomment\t \t\n" 10054 " \t \t in multiple lines\t\n" 10055 " \t */", 10056 Tab)); 10057 verifyFormat("{\n" 10058 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10059 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10060 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10061 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10062 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10063 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10064 "};", 10065 Tab); 10066 verifyFormat("enum AA {\n" 10067 "\ta1, // Force multiple lines\n" 10068 "\ta2,\n" 10069 "\ta3\n" 10070 "};", 10071 Tab); 10072 EXPECT_EQ("if (aaaaaaaa && // q\n" 10073 " bb) // w\n" 10074 "\t;", 10075 format("if (aaaaaaaa &&// q\n" 10076 "bb)// w\n" 10077 ";", 10078 Tab)); 10079 verifyFormat("class X {\n" 10080 "\tvoid f() {\n" 10081 "\t\tsomeFunction(parameter1,\n" 10082 "\t\t\t parameter2);\n" 10083 "\t}\n" 10084 "};", 10085 Tab); 10086 verifyFormat("{\n" 10087 "\tQ(\n" 10088 "\t {\n" 10089 "\t\t int a;\n" 10090 "\t\t someFunction(aaaaaaaa,\n" 10091 "\t\t\t\t bbbbbbb);\n" 10092 "\t },\n" 10093 "\t p);\n" 10094 "}", 10095 Tab); 10096 EXPECT_EQ("{\n" 10097 "\t/* aaaa\n" 10098 "\t bbbb */\n" 10099 "}", 10100 format("{\n" 10101 "/* aaaa\n" 10102 " bbbb */\n" 10103 "}", 10104 Tab)); 10105 EXPECT_EQ("{\n" 10106 "\t/*\n" 10107 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10108 "\t bbbbbbbbbbbbb\n" 10109 "\t*/\n" 10110 "}", 10111 format("{\n" 10112 "/*\n" 10113 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10114 "*/\n" 10115 "}", 10116 Tab)); 10117 EXPECT_EQ("{\n" 10118 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10119 "\t// bbbbbbbbbbbbb\n" 10120 "}", 10121 format("{\n" 10122 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10123 "}", 10124 Tab)); 10125 EXPECT_EQ("{\n" 10126 "\t/*\n" 10127 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10128 "\t bbbbbbbbbbbbb\n" 10129 "\t*/\n" 10130 "}", 10131 format("{\n" 10132 "\t/*\n" 10133 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10134 "\t*/\n" 10135 "}", 10136 Tab)); 10137 EXPECT_EQ("{\n" 10138 "\t/*\n" 10139 "\n" 10140 "\t*/\n" 10141 "}", 10142 format("{\n" 10143 "\t/*\n" 10144 "\n" 10145 "\t*/\n" 10146 "}", 10147 Tab)); 10148 EXPECT_EQ("{\n" 10149 "\t/*\n" 10150 " asdf\n" 10151 "\t*/\n" 10152 "}", 10153 format("{\n" 10154 "\t/*\n" 10155 " asdf\n" 10156 "\t*/\n" 10157 "}", 10158 Tab)); 10159 EXPECT_EQ("/*\n" 10160 "\t a\t\tcomment\n" 10161 "\t in multiple lines\n" 10162 " */", 10163 format(" /*\t \t \n" 10164 " \t \t a\t\tcomment\t \t\n" 10165 " \t \t in multiple lines\t\n" 10166 " \t */", 10167 Tab)); 10168 EXPECT_EQ("/* some\n" 10169 " comment */", 10170 format(" \t \t /* some\n" 10171 " \t \t comment */", 10172 Tab)); 10173 EXPECT_EQ("int a; /* some\n" 10174 " comment */", 10175 format(" \t \t int a; /* some\n" 10176 " \t \t comment */", 10177 Tab)); 10178 EXPECT_EQ("int a; /* some\n" 10179 "comment */", 10180 format(" \t \t int\ta; /* some\n" 10181 " \t \t comment */", 10182 Tab)); 10183 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10184 " comment */", 10185 format(" \t \t f(\"\t\t\"); /* some\n" 10186 " \t \t comment */", 10187 Tab)); 10188 EXPECT_EQ("{\n" 10189 " /*\n" 10190 " * Comment\n" 10191 " */\n" 10192 " int i;\n" 10193 "}", 10194 format("{\n" 10195 "\t/*\n" 10196 "\t * Comment\n" 10197 "\t */\n" 10198 "\t int i;\n" 10199 "}")); 10200 Tab.AlignConsecutiveAssignments = true; 10201 Tab.AlignConsecutiveDeclarations = true; 10202 Tab.TabWidth = 4; 10203 Tab.IndentWidth = 4; 10204 verifyFormat("class Assign {\n" 10205 "\tvoid f() {\n" 10206 "\t\tint x = 123;\n" 10207 "\t\tint random = 4;\n" 10208 "\t\tstd::string alphabet =\n" 10209 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 10210 "\t}\n" 10211 "};", 10212 Tab); 10213 } 10214 10215 TEST_F(FormatTest, ZeroTabWidth) { 10216 FormatStyle Tab = getLLVMStyleWithColumns(42); 10217 Tab.IndentWidth = 8; 10218 Tab.UseTab = FormatStyle::UT_Never; 10219 Tab.TabWidth = 0; 10220 EXPECT_EQ("void a(){\n" 10221 " // line starts with '\t'\n" 10222 "};", 10223 format("void a(){\n" 10224 "\t// line starts with '\t'\n" 10225 "};", 10226 Tab)); 10227 10228 EXPECT_EQ("void a(){\n" 10229 " // line starts with '\t'\n" 10230 "};", 10231 format("void a(){\n" 10232 "\t\t// line starts with '\t'\n" 10233 "};", 10234 Tab)); 10235 10236 Tab.UseTab = FormatStyle::UT_ForIndentation; 10237 EXPECT_EQ("void a(){\n" 10238 " // line starts with '\t'\n" 10239 "};", 10240 format("void a(){\n" 10241 "\t// line starts with '\t'\n" 10242 "};", 10243 Tab)); 10244 10245 EXPECT_EQ("void a(){\n" 10246 " // line starts with '\t'\n" 10247 "};", 10248 format("void a(){\n" 10249 "\t\t// line starts with '\t'\n" 10250 "};", 10251 Tab)); 10252 10253 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10254 EXPECT_EQ("void a(){\n" 10255 " // line starts with '\t'\n" 10256 "};", 10257 format("void a(){\n" 10258 "\t// line starts with '\t'\n" 10259 "};", 10260 Tab)); 10261 10262 EXPECT_EQ("void a(){\n" 10263 " // line starts with '\t'\n" 10264 "};", 10265 format("void a(){\n" 10266 "\t\t// line starts with '\t'\n" 10267 "};", 10268 Tab)); 10269 10270 Tab.UseTab = FormatStyle::UT_Always; 10271 EXPECT_EQ("void a(){\n" 10272 "// line starts with '\t'\n" 10273 "};", 10274 format("void a(){\n" 10275 "\t// line starts with '\t'\n" 10276 "};", 10277 Tab)); 10278 10279 EXPECT_EQ("void a(){\n" 10280 "// line starts with '\t'\n" 10281 "};", 10282 format("void a(){\n" 10283 "\t\t// line starts with '\t'\n" 10284 "};", 10285 Tab)); 10286 } 10287 10288 TEST_F(FormatTest, CalculatesOriginalColumn) { 10289 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10290 "q\"; /* some\n" 10291 " comment */", 10292 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10293 "q\"; /* some\n" 10294 " comment */", 10295 getLLVMStyle())); 10296 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10297 "/* some\n" 10298 " comment */", 10299 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10300 " /* some\n" 10301 " comment */", 10302 getLLVMStyle())); 10303 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10304 "qqq\n" 10305 "/* some\n" 10306 " comment */", 10307 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10308 "qqq\n" 10309 " /* some\n" 10310 " comment */", 10311 getLLVMStyle())); 10312 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10313 "wwww; /* some\n" 10314 " comment */", 10315 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10316 "wwww; /* some\n" 10317 " comment */", 10318 getLLVMStyle())); 10319 } 10320 10321 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 10322 FormatStyle NoSpace = getLLVMStyle(); 10323 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 10324 10325 verifyFormat("while(true)\n" 10326 " continue;", 10327 NoSpace); 10328 verifyFormat("for(;;)\n" 10329 " continue;", 10330 NoSpace); 10331 verifyFormat("if(true)\n" 10332 " f();\n" 10333 "else if(true)\n" 10334 " f();", 10335 NoSpace); 10336 verifyFormat("do {\n" 10337 " do_something();\n" 10338 "} while(something());", 10339 NoSpace); 10340 verifyFormat("switch(x) {\n" 10341 "default:\n" 10342 " break;\n" 10343 "}", 10344 NoSpace); 10345 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 10346 verifyFormat("size_t x = sizeof(x);", NoSpace); 10347 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 10348 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 10349 verifyFormat("alignas(128) char a[128];", NoSpace); 10350 verifyFormat("size_t x = alignof(MyType);", NoSpace); 10351 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 10352 verifyFormat("int f() throw(Deprecated);", NoSpace); 10353 verifyFormat("typedef void (*cb)(int);", NoSpace); 10354 verifyFormat("T A::operator()();", NoSpace); 10355 verifyFormat("X A::operator++(T);", NoSpace); 10356 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 10357 10358 FormatStyle Space = getLLVMStyle(); 10359 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 10360 10361 verifyFormat("int f ();", Space); 10362 verifyFormat("void f (int a, T b) {\n" 10363 " while (true)\n" 10364 " continue;\n" 10365 "}", 10366 Space); 10367 verifyFormat("if (true)\n" 10368 " f ();\n" 10369 "else if (true)\n" 10370 " f ();", 10371 Space); 10372 verifyFormat("do {\n" 10373 " do_something ();\n" 10374 "} while (something ());", 10375 Space); 10376 verifyFormat("switch (x) {\n" 10377 "default:\n" 10378 " break;\n" 10379 "}", 10380 Space); 10381 verifyFormat("A::A () : a (1) {}", Space); 10382 verifyFormat("void f () __attribute__ ((asdf));", Space); 10383 verifyFormat("*(&a + 1);\n" 10384 "&((&a)[1]);\n" 10385 "a[(b + c) * d];\n" 10386 "(((a + 1) * 2) + 3) * 4;", 10387 Space); 10388 verifyFormat("#define A(x) x", Space); 10389 verifyFormat("#define A (x) x", Space); 10390 verifyFormat("#if defined(x)\n" 10391 "#endif", 10392 Space); 10393 verifyFormat("auto i = std::make_unique<int> (5);", Space); 10394 verifyFormat("size_t x = sizeof (x);", Space); 10395 verifyFormat("auto f (int x) -> decltype (x);", Space); 10396 verifyFormat("int f (T x) noexcept (x.create ());", Space); 10397 verifyFormat("alignas (128) char a[128];", Space); 10398 verifyFormat("size_t x = alignof (MyType);", Space); 10399 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 10400 verifyFormat("int f () throw (Deprecated);", Space); 10401 verifyFormat("typedef void (*cb) (int);", Space); 10402 verifyFormat("T A::operator() ();", Space); 10403 verifyFormat("X A::operator++ (T);", Space); 10404 verifyFormat("auto lambda = [] () { return 0; };", Space); 10405 verifyFormat("int x = int (y);", Space); 10406 10407 FormatStyle SomeSpace = getLLVMStyle(); 10408 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 10409 10410 verifyFormat("[]() -> float {}", SomeSpace); 10411 verifyFormat("[] (auto foo) {}", SomeSpace); 10412 verifyFormat("[foo]() -> int {}", SomeSpace); 10413 verifyFormat("int f();", SomeSpace); 10414 verifyFormat("void f (int a, T b) {\n" 10415 " while (true)\n" 10416 " continue;\n" 10417 "}", 10418 SomeSpace); 10419 verifyFormat("if (true)\n" 10420 " f();\n" 10421 "else if (true)\n" 10422 " f();", 10423 SomeSpace); 10424 verifyFormat("do {\n" 10425 " do_something();\n" 10426 "} while (something());", 10427 SomeSpace); 10428 verifyFormat("switch (x) {\n" 10429 "default:\n" 10430 " break;\n" 10431 "}", 10432 SomeSpace); 10433 verifyFormat("A::A() : a (1) {}", SomeSpace); 10434 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 10435 verifyFormat("*(&a + 1);\n" 10436 "&((&a)[1]);\n" 10437 "a[(b + c) * d];\n" 10438 "(((a + 1) * 2) + 3) * 4;", 10439 SomeSpace); 10440 verifyFormat("#define A(x) x", SomeSpace); 10441 verifyFormat("#define A (x) x", SomeSpace); 10442 verifyFormat("#if defined(x)\n" 10443 "#endif", 10444 SomeSpace); 10445 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 10446 verifyFormat("size_t x = sizeof (x);", SomeSpace); 10447 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 10448 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 10449 verifyFormat("alignas (128) char a[128];", SomeSpace); 10450 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 10451 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 10452 SomeSpace); 10453 verifyFormat("int f() throw (Deprecated);", SomeSpace); 10454 verifyFormat("typedef void (*cb) (int);", SomeSpace); 10455 verifyFormat("T A::operator()();", SomeSpace); 10456 verifyFormat("X A::operator++ (T);", SomeSpace); 10457 verifyFormat("int x = int (y);", SomeSpace); 10458 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 10459 } 10460 10461 TEST_F(FormatTest, SpaceAfterLogicalNot) { 10462 FormatStyle Spaces = getLLVMStyle(); 10463 Spaces.SpaceAfterLogicalNot = true; 10464 10465 verifyFormat("bool x = ! y", Spaces); 10466 verifyFormat("if (! isFailure())", Spaces); 10467 verifyFormat("if (! (a && b))", Spaces); 10468 verifyFormat("\"Error!\"", Spaces); 10469 verifyFormat("! ! x", Spaces); 10470 } 10471 10472 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 10473 FormatStyle Spaces = getLLVMStyle(); 10474 10475 Spaces.SpacesInParentheses = true; 10476 verifyFormat("do_something( ::globalVar );", Spaces); 10477 verifyFormat("call( x, y, z );", Spaces); 10478 verifyFormat("call();", Spaces); 10479 verifyFormat("std::function<void( int, int )> callback;", Spaces); 10480 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 10481 Spaces); 10482 verifyFormat("while ( (bool)1 )\n" 10483 " continue;", 10484 Spaces); 10485 verifyFormat("for ( ;; )\n" 10486 " continue;", 10487 Spaces); 10488 verifyFormat("if ( true )\n" 10489 " f();\n" 10490 "else if ( true )\n" 10491 " f();", 10492 Spaces); 10493 verifyFormat("do {\n" 10494 " do_something( (int)i );\n" 10495 "} while ( something() );", 10496 Spaces); 10497 verifyFormat("switch ( x ) {\n" 10498 "default:\n" 10499 " break;\n" 10500 "}", 10501 Spaces); 10502 10503 Spaces.SpacesInParentheses = false; 10504 Spaces.SpacesInCStyleCastParentheses = true; 10505 verifyFormat("Type *A = ( Type * )P;", Spaces); 10506 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 10507 verifyFormat("x = ( int32 )y;", Spaces); 10508 verifyFormat("int a = ( int )(2.0f);", Spaces); 10509 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 10510 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 10511 verifyFormat("#define x (( int )-1)", Spaces); 10512 10513 // Run the first set of tests again with: 10514 Spaces.SpacesInParentheses = false; 10515 Spaces.SpaceInEmptyParentheses = true; 10516 Spaces.SpacesInCStyleCastParentheses = true; 10517 verifyFormat("call(x, y, z);", Spaces); 10518 verifyFormat("call( );", Spaces); 10519 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10520 verifyFormat("while (( bool )1)\n" 10521 " continue;", 10522 Spaces); 10523 verifyFormat("for (;;)\n" 10524 " continue;", 10525 Spaces); 10526 verifyFormat("if (true)\n" 10527 " f( );\n" 10528 "else if (true)\n" 10529 " f( );", 10530 Spaces); 10531 verifyFormat("do {\n" 10532 " do_something(( int )i);\n" 10533 "} while (something( ));", 10534 Spaces); 10535 verifyFormat("switch (x) {\n" 10536 "default:\n" 10537 " break;\n" 10538 "}", 10539 Spaces); 10540 10541 // Run the first set of tests again with: 10542 Spaces.SpaceAfterCStyleCast = true; 10543 verifyFormat("call(x, y, z);", Spaces); 10544 verifyFormat("call( );", Spaces); 10545 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10546 verifyFormat("while (( bool ) 1)\n" 10547 " continue;", 10548 Spaces); 10549 verifyFormat("for (;;)\n" 10550 " continue;", 10551 Spaces); 10552 verifyFormat("if (true)\n" 10553 " f( );\n" 10554 "else if (true)\n" 10555 " f( );", 10556 Spaces); 10557 verifyFormat("do {\n" 10558 " do_something(( int ) i);\n" 10559 "} while (something( ));", 10560 Spaces); 10561 verifyFormat("switch (x) {\n" 10562 "default:\n" 10563 " break;\n" 10564 "}", 10565 Spaces); 10566 10567 // Run subset of tests again with: 10568 Spaces.SpacesInCStyleCastParentheses = false; 10569 Spaces.SpaceAfterCStyleCast = true; 10570 verifyFormat("while ((bool) 1)\n" 10571 " continue;", 10572 Spaces); 10573 verifyFormat("do {\n" 10574 " do_something((int) i);\n" 10575 "} while (something( ));", 10576 Spaces); 10577 } 10578 10579 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 10580 verifyFormat("int a[5];"); 10581 verifyFormat("a[3] += 42;"); 10582 10583 FormatStyle Spaces = getLLVMStyle(); 10584 Spaces.SpacesInSquareBrackets = true; 10585 // Not lambdas. 10586 verifyFormat("int a[ 5 ];", Spaces); 10587 verifyFormat("a[ 3 ] += 42;", Spaces); 10588 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 10589 verifyFormat("double &operator[](int i) { return 0; }\n" 10590 "int i;", 10591 Spaces); 10592 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 10593 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 10594 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 10595 // Lambdas. 10596 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 10597 verifyFormat("return [ i, args... ] {};", Spaces); 10598 verifyFormat("int foo = [ &bar ]() {};", Spaces); 10599 verifyFormat("int foo = [ = ]() {};", Spaces); 10600 verifyFormat("int foo = [ =, &bar ]() {};", Spaces); 10601 verifyFormat("int foo = [ &bar, = ]() {};", Spaces); 10602 } 10603 10604 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 10605 verifyFormat("int a = 5;"); 10606 verifyFormat("a += 42;"); 10607 verifyFormat("a or_eq 8;"); 10608 10609 FormatStyle Spaces = getLLVMStyle(); 10610 Spaces.SpaceBeforeAssignmentOperators = false; 10611 verifyFormat("int a= 5;", Spaces); 10612 verifyFormat("a+= 42;", Spaces); 10613 verifyFormat("a or_eq 8;", Spaces); 10614 } 10615 10616 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 10617 verifyFormat("class Foo : public Bar {};"); 10618 verifyFormat("Foo::Foo() : foo(1) {}"); 10619 verifyFormat("for (auto a : b) {\n}"); 10620 verifyFormat("int x = a ? b : c;"); 10621 verifyFormat("{\n" 10622 "label0:\n" 10623 " int x = 0;\n" 10624 "}"); 10625 verifyFormat("switch (x) {\n" 10626 "case 1:\n" 10627 "default:\n" 10628 "}"); 10629 10630 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 10631 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 10632 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 10633 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 10634 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 10635 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 10636 verifyFormat("{\n" 10637 "label1:\n" 10638 " int x = 0;\n" 10639 "}", 10640 CtorInitializerStyle); 10641 verifyFormat("switch (x) {\n" 10642 "case 1:\n" 10643 "default:\n" 10644 "}", 10645 CtorInitializerStyle); 10646 CtorInitializerStyle.BreakConstructorInitializers = 10647 FormatStyle::BCIS_AfterColon; 10648 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 10649 " aaaaaaaaaaaaaaaa(1),\n" 10650 " bbbbbbbbbbbbbbbb(2) {}", 10651 CtorInitializerStyle); 10652 CtorInitializerStyle.BreakConstructorInitializers = 10653 FormatStyle::BCIS_BeforeComma; 10654 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10655 " : aaaaaaaaaaaaaaaa(1)\n" 10656 " , bbbbbbbbbbbbbbbb(2) {}", 10657 CtorInitializerStyle); 10658 CtorInitializerStyle.BreakConstructorInitializers = 10659 FormatStyle::BCIS_BeforeColon; 10660 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10661 " : aaaaaaaaaaaaaaaa(1),\n" 10662 " bbbbbbbbbbbbbbbb(2) {}", 10663 CtorInitializerStyle); 10664 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 10665 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10666 ": aaaaaaaaaaaaaaaa(1),\n" 10667 " bbbbbbbbbbbbbbbb(2) {}", 10668 CtorInitializerStyle); 10669 10670 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 10671 InheritanceStyle.SpaceBeforeInheritanceColon = false; 10672 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 10673 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 10674 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 10675 verifyFormat("int x = a ? b : c;", InheritanceStyle); 10676 verifyFormat("{\n" 10677 "label2:\n" 10678 " int x = 0;\n" 10679 "}", 10680 InheritanceStyle); 10681 verifyFormat("switch (x) {\n" 10682 "case 1:\n" 10683 "default:\n" 10684 "}", 10685 InheritanceStyle); 10686 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 10687 verifyFormat("class Foooooooooooooooooooooo:\n" 10688 " public aaaaaaaaaaaaaaaaaa,\n" 10689 " public bbbbbbbbbbbbbbbbbb {\n" 10690 "}", 10691 InheritanceStyle); 10692 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 10693 verifyFormat("class Foooooooooooooooooooooo\n" 10694 " : public aaaaaaaaaaaaaaaaaa\n" 10695 " , public bbbbbbbbbbbbbbbbbb {\n" 10696 "}", 10697 InheritanceStyle); 10698 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 10699 verifyFormat("class Foooooooooooooooooooooo\n" 10700 " : public aaaaaaaaaaaaaaaaaa,\n" 10701 " public bbbbbbbbbbbbbbbbbb {\n" 10702 "}", 10703 InheritanceStyle); 10704 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 10705 verifyFormat("class Foooooooooooooooooooooo\n" 10706 ": public aaaaaaaaaaaaaaaaaa,\n" 10707 " public bbbbbbbbbbbbbbbbbb {}", 10708 InheritanceStyle); 10709 10710 FormatStyle ForLoopStyle = getLLVMStyle(); 10711 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 10712 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 10713 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 10714 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 10715 verifyFormat("int x = a ? b : c;", ForLoopStyle); 10716 verifyFormat("{\n" 10717 "label2:\n" 10718 " int x = 0;\n" 10719 "}", 10720 ForLoopStyle); 10721 verifyFormat("switch (x) {\n" 10722 "case 1:\n" 10723 "default:\n" 10724 "}", 10725 ForLoopStyle); 10726 10727 FormatStyle NoSpaceStyle = getLLVMStyle(); 10728 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 10729 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 10730 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 10731 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 10732 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 10733 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 10734 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 10735 verifyFormat("{\n" 10736 "label3:\n" 10737 " int x = 0;\n" 10738 "}", 10739 NoSpaceStyle); 10740 verifyFormat("switch (x) {\n" 10741 "case 1:\n" 10742 "default:\n" 10743 "}", 10744 NoSpaceStyle); 10745 } 10746 10747 TEST_F(FormatTest, AlignConsecutiveMacros) { 10748 FormatStyle Style = getLLVMStyle(); 10749 Style.AlignConsecutiveAssignments = true; 10750 Style.AlignConsecutiveDeclarations = true; 10751 Style.AlignConsecutiveMacros = false; 10752 10753 verifyFormat("#define a 3\n" 10754 "#define bbbb 4\n" 10755 "#define ccc (5)", 10756 Style); 10757 10758 verifyFormat("#define f(x) (x * x)\n" 10759 "#define fff(x, y, z) (x * y + z)\n" 10760 "#define ffff(x, y) (x - y)", 10761 Style); 10762 10763 verifyFormat("#define foo(x, y) (x + y)\n" 10764 "#define bar (5, 6)(2 + 2)", 10765 Style); 10766 10767 verifyFormat("#define a 3\n" 10768 "#define bbbb 4\n" 10769 "#define ccc (5)\n" 10770 "#define f(x) (x * x)\n" 10771 "#define fff(x, y, z) (x * y + z)\n" 10772 "#define ffff(x, y) (x - y)", 10773 Style); 10774 10775 Style.AlignConsecutiveMacros = true; 10776 verifyFormat("#define a 3\n" 10777 "#define bbbb 4\n" 10778 "#define ccc (5)", 10779 Style); 10780 10781 verifyFormat("#define f(x) (x * x)\n" 10782 "#define fff(x, y, z) (x * y + z)\n" 10783 "#define ffff(x, y) (x - y)", 10784 Style); 10785 10786 verifyFormat("#define foo(x, y) (x + y)\n" 10787 "#define bar (5, 6)(2 + 2)", 10788 Style); 10789 10790 verifyFormat("#define a 3\n" 10791 "#define bbbb 4\n" 10792 "#define ccc (5)\n" 10793 "#define f(x) (x * x)\n" 10794 "#define fff(x, y, z) (x * y + z)\n" 10795 "#define ffff(x, y) (x - y)", 10796 Style); 10797 10798 verifyFormat("#define a 5\n" 10799 "#define foo(x, y) (x + y)\n" 10800 "#define CCC (6)\n" 10801 "auto lambda = []() {\n" 10802 " auto ii = 0;\n" 10803 " float j = 0;\n" 10804 " return 0;\n" 10805 "};\n" 10806 "int i = 0;\n" 10807 "float i2 = 0;\n" 10808 "auto v = type{\n" 10809 " i = 1, //\n" 10810 " (i = 2), //\n" 10811 " i = 3 //\n" 10812 "};", 10813 Style); 10814 10815 Style.AlignConsecutiveMacros = false; 10816 Style.ColumnLimit = 20; 10817 10818 verifyFormat("#define a \\\n" 10819 " \"aabbbbbbbbbbbb\"\n" 10820 "#define D \\\n" 10821 " \"aabbbbbbbbbbbb\" \\\n" 10822 " \"ccddeeeeeeeee\"\n" 10823 "#define B \\\n" 10824 " \"QQQQQQQQQQQQQ\" \\\n" 10825 " \"FFFFFFFFFFFFF\" \\\n" 10826 " \"LLLLLLLL\"\n", 10827 Style); 10828 10829 Style.AlignConsecutiveMacros = true; 10830 verifyFormat("#define a \\\n" 10831 " \"aabbbbbbbbbbbb\"\n" 10832 "#define D \\\n" 10833 " \"aabbbbbbbbbbbb\" \\\n" 10834 " \"ccddeeeeeeeee\"\n" 10835 "#define B \\\n" 10836 " \"QQQQQQQQQQQQQ\" \\\n" 10837 " \"FFFFFFFFFFFFF\" \\\n" 10838 " \"LLLLLLLL\"\n", 10839 Style); 10840 } 10841 10842 TEST_F(FormatTest, AlignConsecutiveAssignments) { 10843 FormatStyle Alignment = getLLVMStyle(); 10844 Alignment.AlignConsecutiveMacros = true; 10845 Alignment.AlignConsecutiveAssignments = false; 10846 verifyFormat("int a = 5;\n" 10847 "int oneTwoThree = 123;", 10848 Alignment); 10849 verifyFormat("int a = 5;\n" 10850 "int oneTwoThree = 123;", 10851 Alignment); 10852 10853 Alignment.AlignConsecutiveAssignments = true; 10854 verifyFormat("int a = 5;\n" 10855 "int oneTwoThree = 123;", 10856 Alignment); 10857 verifyFormat("int a = method();\n" 10858 "int oneTwoThree = 133;", 10859 Alignment); 10860 verifyFormat("a &= 5;\n" 10861 "bcd *= 5;\n" 10862 "ghtyf += 5;\n" 10863 "dvfvdb -= 5;\n" 10864 "a /= 5;\n" 10865 "vdsvsv %= 5;\n" 10866 "sfdbddfbdfbb ^= 5;\n" 10867 "dvsdsv |= 5;\n" 10868 "int dsvvdvsdvvv = 123;", 10869 Alignment); 10870 verifyFormat("int i = 1, j = 10;\n" 10871 "something = 2000;", 10872 Alignment); 10873 verifyFormat("something = 2000;\n" 10874 "int i = 1, j = 10;\n", 10875 Alignment); 10876 verifyFormat("something = 2000;\n" 10877 "another = 911;\n" 10878 "int i = 1, j = 10;\n" 10879 "oneMore = 1;\n" 10880 "i = 2;", 10881 Alignment); 10882 verifyFormat("int a = 5;\n" 10883 "int one = 1;\n" 10884 "method();\n" 10885 "int oneTwoThree = 123;\n" 10886 "int oneTwo = 12;", 10887 Alignment); 10888 verifyFormat("int oneTwoThree = 123;\n" 10889 "int oneTwo = 12;\n" 10890 "method();\n", 10891 Alignment); 10892 verifyFormat("int oneTwoThree = 123; // comment\n" 10893 "int oneTwo = 12; // comment", 10894 Alignment); 10895 EXPECT_EQ("int a = 5;\n" 10896 "\n" 10897 "int oneTwoThree = 123;", 10898 format("int a = 5;\n" 10899 "\n" 10900 "int oneTwoThree= 123;", 10901 Alignment)); 10902 EXPECT_EQ("int a = 5;\n" 10903 "int one = 1;\n" 10904 "\n" 10905 "int oneTwoThree = 123;", 10906 format("int a = 5;\n" 10907 "int one = 1;\n" 10908 "\n" 10909 "int oneTwoThree = 123;", 10910 Alignment)); 10911 EXPECT_EQ("int a = 5;\n" 10912 "int one = 1;\n" 10913 "\n" 10914 "int oneTwoThree = 123;\n" 10915 "int oneTwo = 12;", 10916 format("int a = 5;\n" 10917 "int one = 1;\n" 10918 "\n" 10919 "int oneTwoThree = 123;\n" 10920 "int oneTwo = 12;", 10921 Alignment)); 10922 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 10923 verifyFormat("#define A \\\n" 10924 " int aaaa = 12; \\\n" 10925 " int b = 23; \\\n" 10926 " int ccc = 234; \\\n" 10927 " int dddddddddd = 2345;", 10928 Alignment); 10929 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 10930 verifyFormat("#define A \\\n" 10931 " int aaaa = 12; \\\n" 10932 " int b = 23; \\\n" 10933 " int ccc = 234; \\\n" 10934 " int dddddddddd = 2345;", 10935 Alignment); 10936 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 10937 verifyFormat("#define A " 10938 " \\\n" 10939 " int aaaa = 12; " 10940 " \\\n" 10941 " int b = 23; " 10942 " \\\n" 10943 " int ccc = 234; " 10944 " \\\n" 10945 " int dddddddddd = 2345;", 10946 Alignment); 10947 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 10948 "k = 4, int l = 5,\n" 10949 " int m = 6) {\n" 10950 " int j = 10;\n" 10951 " otherThing = 1;\n" 10952 "}", 10953 Alignment); 10954 verifyFormat("void SomeFunction(int parameter = 0) {\n" 10955 " int i = 1;\n" 10956 " int j = 2;\n" 10957 " int big = 10000;\n" 10958 "}", 10959 Alignment); 10960 verifyFormat("class C {\n" 10961 "public:\n" 10962 " int i = 1;\n" 10963 " virtual void f() = 0;\n" 10964 "};", 10965 Alignment); 10966 verifyFormat("int i = 1;\n" 10967 "if (SomeType t = getSomething()) {\n" 10968 "}\n" 10969 "int j = 2;\n" 10970 "int big = 10000;", 10971 Alignment); 10972 verifyFormat("int j = 7;\n" 10973 "for (int k = 0; k < N; ++k) {\n" 10974 "}\n" 10975 "int j = 2;\n" 10976 "int big = 10000;\n" 10977 "}", 10978 Alignment); 10979 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 10980 verifyFormat("int i = 1;\n" 10981 "LooooooooooongType loooooooooooooooooooooongVariable\n" 10982 " = someLooooooooooooooooongFunction();\n" 10983 "int j = 2;", 10984 Alignment); 10985 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 10986 verifyFormat("int i = 1;\n" 10987 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 10988 " someLooooooooooooooooongFunction();\n" 10989 "int j = 2;", 10990 Alignment); 10991 10992 verifyFormat("auto lambda = []() {\n" 10993 " auto i = 0;\n" 10994 " return 0;\n" 10995 "};\n" 10996 "int i = 0;\n" 10997 "auto v = type{\n" 10998 " i = 1, //\n" 10999 " (i = 2), //\n" 11000 " i = 3 //\n" 11001 "};", 11002 Alignment); 11003 11004 verifyFormat( 11005 "int i = 1;\n" 11006 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11007 " loooooooooooooooooooooongParameterB);\n" 11008 "int j = 2;", 11009 Alignment); 11010 11011 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 11012 " typename B = very_long_type_name_1,\n" 11013 " typename T_2 = very_long_type_name_2>\n" 11014 "auto foo() {}\n", 11015 Alignment); 11016 verifyFormat("int a, b = 1;\n" 11017 "int c = 2;\n" 11018 "int dd = 3;\n", 11019 Alignment); 11020 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11021 "float b[1][] = {{3.f}};\n", 11022 Alignment); 11023 verifyFormat("for (int i = 0; i < 1; i++)\n" 11024 " int x = 1;\n", 11025 Alignment); 11026 verifyFormat("for (i = 0; i < 1; i++)\n" 11027 " x = 1;\n" 11028 "y = 1;\n", 11029 Alignment); 11030 } 11031 11032 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 11033 FormatStyle Alignment = getLLVMStyle(); 11034 Alignment.AlignConsecutiveMacros = true; 11035 Alignment.AlignConsecutiveDeclarations = false; 11036 verifyFormat("float const a = 5;\n" 11037 "int oneTwoThree = 123;", 11038 Alignment); 11039 verifyFormat("int a = 5;\n" 11040 "float const oneTwoThree = 123;", 11041 Alignment); 11042 11043 Alignment.AlignConsecutiveDeclarations = true; 11044 verifyFormat("float const a = 5;\n" 11045 "int oneTwoThree = 123;", 11046 Alignment); 11047 verifyFormat("int a = method();\n" 11048 "float const oneTwoThree = 133;", 11049 Alignment); 11050 verifyFormat("int i = 1, j = 10;\n" 11051 "something = 2000;", 11052 Alignment); 11053 verifyFormat("something = 2000;\n" 11054 "int i = 1, j = 10;\n", 11055 Alignment); 11056 verifyFormat("float something = 2000;\n" 11057 "double another = 911;\n" 11058 "int i = 1, j = 10;\n" 11059 "const int *oneMore = 1;\n" 11060 "unsigned i = 2;", 11061 Alignment); 11062 verifyFormat("float a = 5;\n" 11063 "int one = 1;\n" 11064 "method();\n" 11065 "const double oneTwoThree = 123;\n" 11066 "const unsigned int oneTwo = 12;", 11067 Alignment); 11068 verifyFormat("int oneTwoThree{0}; // comment\n" 11069 "unsigned oneTwo; // comment", 11070 Alignment); 11071 EXPECT_EQ("float const a = 5;\n" 11072 "\n" 11073 "int oneTwoThree = 123;", 11074 format("float const a = 5;\n" 11075 "\n" 11076 "int oneTwoThree= 123;", 11077 Alignment)); 11078 EXPECT_EQ("float a = 5;\n" 11079 "int one = 1;\n" 11080 "\n" 11081 "unsigned oneTwoThree = 123;", 11082 format("float a = 5;\n" 11083 "int one = 1;\n" 11084 "\n" 11085 "unsigned oneTwoThree = 123;", 11086 Alignment)); 11087 EXPECT_EQ("float a = 5;\n" 11088 "int one = 1;\n" 11089 "\n" 11090 "unsigned oneTwoThree = 123;\n" 11091 "int oneTwo = 12;", 11092 format("float a = 5;\n" 11093 "int one = 1;\n" 11094 "\n" 11095 "unsigned oneTwoThree = 123;\n" 11096 "int oneTwo = 12;", 11097 Alignment)); 11098 // Function prototype alignment 11099 verifyFormat("int a();\n" 11100 "double b();", 11101 Alignment); 11102 verifyFormat("int a(int x);\n" 11103 "double b();", 11104 Alignment); 11105 unsigned OldColumnLimit = Alignment.ColumnLimit; 11106 // We need to set ColumnLimit to zero, in order to stress nested alignments, 11107 // otherwise the function parameters will be re-flowed onto a single line. 11108 Alignment.ColumnLimit = 0; 11109 EXPECT_EQ("int a(int x,\n" 11110 " float y);\n" 11111 "double b(int x,\n" 11112 " double y);", 11113 format("int a(int x,\n" 11114 " float y);\n" 11115 "double b(int x,\n" 11116 " double y);", 11117 Alignment)); 11118 // This ensures that function parameters of function declarations are 11119 // correctly indented when their owning functions are indented. 11120 // The failure case here is for 'double y' to not be indented enough. 11121 EXPECT_EQ("double a(int x);\n" 11122 "int b(int y,\n" 11123 " double z);", 11124 format("double a(int x);\n" 11125 "int b(int y,\n" 11126 " double z);", 11127 Alignment)); 11128 // Set ColumnLimit low so that we induce wrapping immediately after 11129 // the function name and opening paren. 11130 Alignment.ColumnLimit = 13; 11131 verifyFormat("int function(\n" 11132 " int x,\n" 11133 " bool y);", 11134 Alignment); 11135 Alignment.ColumnLimit = OldColumnLimit; 11136 // Ensure function pointers don't screw up recursive alignment 11137 verifyFormat("int a(int x, void (*fp)(int y));\n" 11138 "double b();", 11139 Alignment); 11140 Alignment.AlignConsecutiveAssignments = true; 11141 // Ensure recursive alignment is broken by function braces, so that the 11142 // "a = 1" does not align with subsequent assignments inside the function 11143 // body. 11144 verifyFormat("int func(int a = 1) {\n" 11145 " int b = 2;\n" 11146 " int cc = 3;\n" 11147 "}", 11148 Alignment); 11149 verifyFormat("float something = 2000;\n" 11150 "double another = 911;\n" 11151 "int i = 1, j = 10;\n" 11152 "const int *oneMore = 1;\n" 11153 "unsigned i = 2;", 11154 Alignment); 11155 verifyFormat("int oneTwoThree = {0}; // comment\n" 11156 "unsigned oneTwo = 0; // comment", 11157 Alignment); 11158 // Make sure that scope is correctly tracked, in the absence of braces 11159 verifyFormat("for (int i = 0; i < n; i++)\n" 11160 " j = i;\n" 11161 "double x = 1;\n", 11162 Alignment); 11163 verifyFormat("if (int i = 0)\n" 11164 " j = i;\n" 11165 "double x = 1;\n", 11166 Alignment); 11167 // Ensure operator[] and operator() are comprehended 11168 verifyFormat("struct test {\n" 11169 " long long int foo();\n" 11170 " int operator[](int a);\n" 11171 " double bar();\n" 11172 "};\n", 11173 Alignment); 11174 verifyFormat("struct test {\n" 11175 " long long int foo();\n" 11176 " int operator()(int a);\n" 11177 " double bar();\n" 11178 "};\n", 11179 Alignment); 11180 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 11181 " int const i = 1;\n" 11182 " int * j = 2;\n" 11183 " int big = 10000;\n" 11184 "\n" 11185 " unsigned oneTwoThree = 123;\n" 11186 " int oneTwo = 12;\n" 11187 " method();\n" 11188 " float k = 2;\n" 11189 " int ll = 10000;\n" 11190 "}", 11191 format("void SomeFunction(int parameter= 0) {\n" 11192 " int const i= 1;\n" 11193 " int *j=2;\n" 11194 " int big = 10000;\n" 11195 "\n" 11196 "unsigned oneTwoThree =123;\n" 11197 "int oneTwo = 12;\n" 11198 " method();\n" 11199 "float k= 2;\n" 11200 "int ll=10000;\n" 11201 "}", 11202 Alignment)); 11203 Alignment.AlignConsecutiveAssignments = false; 11204 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11205 verifyFormat("#define A \\\n" 11206 " int aaaa = 12; \\\n" 11207 " float b = 23; \\\n" 11208 " const int ccc = 234; \\\n" 11209 " unsigned dddddddddd = 2345;", 11210 Alignment); 11211 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11212 verifyFormat("#define A \\\n" 11213 " int aaaa = 12; \\\n" 11214 " float b = 23; \\\n" 11215 " const int ccc = 234; \\\n" 11216 " unsigned dddddddddd = 2345;", 11217 Alignment); 11218 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11219 Alignment.ColumnLimit = 30; 11220 verifyFormat("#define A \\\n" 11221 " int aaaa = 12; \\\n" 11222 " float b = 23; \\\n" 11223 " const int ccc = 234; \\\n" 11224 " int dddddddddd = 2345;", 11225 Alignment); 11226 Alignment.ColumnLimit = 80; 11227 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11228 "k = 4, int l = 5,\n" 11229 " int m = 6) {\n" 11230 " const int j = 10;\n" 11231 " otherThing = 1;\n" 11232 "}", 11233 Alignment); 11234 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11235 " int const i = 1;\n" 11236 " int * j = 2;\n" 11237 " int big = 10000;\n" 11238 "}", 11239 Alignment); 11240 verifyFormat("class C {\n" 11241 "public:\n" 11242 " int i = 1;\n" 11243 " virtual void f() = 0;\n" 11244 "};", 11245 Alignment); 11246 verifyFormat("float i = 1;\n" 11247 "if (SomeType t = getSomething()) {\n" 11248 "}\n" 11249 "const unsigned j = 2;\n" 11250 "int big = 10000;", 11251 Alignment); 11252 verifyFormat("float j = 7;\n" 11253 "for (int k = 0; k < N; ++k) {\n" 11254 "}\n" 11255 "unsigned j = 2;\n" 11256 "int big = 10000;\n" 11257 "}", 11258 Alignment); 11259 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11260 verifyFormat("float i = 1;\n" 11261 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11262 " = someLooooooooooooooooongFunction();\n" 11263 "int j = 2;", 11264 Alignment); 11265 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11266 verifyFormat("int i = 1;\n" 11267 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11268 " someLooooooooooooooooongFunction();\n" 11269 "int j = 2;", 11270 Alignment); 11271 11272 Alignment.AlignConsecutiveAssignments = true; 11273 verifyFormat("auto lambda = []() {\n" 11274 " auto ii = 0;\n" 11275 " float j = 0;\n" 11276 " return 0;\n" 11277 "};\n" 11278 "int i = 0;\n" 11279 "float i2 = 0;\n" 11280 "auto v = type{\n" 11281 " i = 1, //\n" 11282 " (i = 2), //\n" 11283 " i = 3 //\n" 11284 "};", 11285 Alignment); 11286 Alignment.AlignConsecutiveAssignments = false; 11287 11288 verifyFormat( 11289 "int i = 1;\n" 11290 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11291 " loooooooooooooooooooooongParameterB);\n" 11292 "int j = 2;", 11293 Alignment); 11294 11295 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 11296 // We expect declarations and assignments to align, as long as it doesn't 11297 // exceed the column limit, starting a new alignment sequence whenever it 11298 // happens. 11299 Alignment.AlignConsecutiveAssignments = true; 11300 Alignment.ColumnLimit = 30; 11301 verifyFormat("float ii = 1;\n" 11302 "unsigned j = 2;\n" 11303 "int someVerylongVariable = 1;\n" 11304 "AnotherLongType ll = 123456;\n" 11305 "VeryVeryLongType k = 2;\n" 11306 "int myvar = 1;", 11307 Alignment); 11308 Alignment.ColumnLimit = 80; 11309 Alignment.AlignConsecutiveAssignments = false; 11310 11311 verifyFormat( 11312 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 11313 " typename LongType, typename B>\n" 11314 "auto foo() {}\n", 11315 Alignment); 11316 verifyFormat("float a, b = 1;\n" 11317 "int c = 2;\n" 11318 "int dd = 3;\n", 11319 Alignment); 11320 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11321 "float b[1][] = {{3.f}};\n", 11322 Alignment); 11323 Alignment.AlignConsecutiveAssignments = true; 11324 verifyFormat("float a, b = 1;\n" 11325 "int c = 2;\n" 11326 "int dd = 3;\n", 11327 Alignment); 11328 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11329 "float b[1][] = {{3.f}};\n", 11330 Alignment); 11331 Alignment.AlignConsecutiveAssignments = false; 11332 11333 Alignment.ColumnLimit = 30; 11334 Alignment.BinPackParameters = false; 11335 verifyFormat("void foo(float a,\n" 11336 " float b,\n" 11337 " int c,\n" 11338 " uint32_t *d) {\n" 11339 " int * e = 0;\n" 11340 " float f = 0;\n" 11341 " double g = 0;\n" 11342 "}\n" 11343 "void bar(ino_t a,\n" 11344 " int b,\n" 11345 " uint32_t *c,\n" 11346 " bool d) {}\n", 11347 Alignment); 11348 Alignment.BinPackParameters = true; 11349 Alignment.ColumnLimit = 80; 11350 11351 // Bug 33507 11352 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 11353 verifyFormat( 11354 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 11355 " static const Version verVs2017;\n" 11356 " return true;\n" 11357 "});\n", 11358 Alignment); 11359 Alignment.PointerAlignment = FormatStyle::PAS_Right; 11360 11361 // See llvm.org/PR35641 11362 Alignment.AlignConsecutiveDeclarations = true; 11363 verifyFormat("int func() { //\n" 11364 " int b;\n" 11365 " unsigned c;\n" 11366 "}", 11367 Alignment); 11368 11369 // See PR37175 11370 FormatStyle Style = getMozillaStyle(); 11371 Style.AlignConsecutiveDeclarations = true; 11372 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 11373 "foo(int a);", 11374 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 11375 } 11376 11377 TEST_F(FormatTest, LinuxBraceBreaking) { 11378 FormatStyle LinuxBraceStyle = getLLVMStyle(); 11379 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 11380 verifyFormat("namespace a\n" 11381 "{\n" 11382 "class A\n" 11383 "{\n" 11384 " void f()\n" 11385 " {\n" 11386 " if (true) {\n" 11387 " a();\n" 11388 " b();\n" 11389 " } else {\n" 11390 " a();\n" 11391 " }\n" 11392 " }\n" 11393 " void g() { return; }\n" 11394 "};\n" 11395 "struct B {\n" 11396 " int x;\n" 11397 "};\n" 11398 "} // namespace a\n", 11399 LinuxBraceStyle); 11400 verifyFormat("enum X {\n" 11401 " Y = 0,\n" 11402 "}\n", 11403 LinuxBraceStyle); 11404 verifyFormat("struct S {\n" 11405 " int Type;\n" 11406 " union {\n" 11407 " int x;\n" 11408 " double y;\n" 11409 " } Value;\n" 11410 " class C\n" 11411 " {\n" 11412 " MyFavoriteType Value;\n" 11413 " } Class;\n" 11414 "}\n", 11415 LinuxBraceStyle); 11416 } 11417 11418 TEST_F(FormatTest, MozillaBraceBreaking) { 11419 FormatStyle MozillaBraceStyle = getLLVMStyle(); 11420 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 11421 MozillaBraceStyle.FixNamespaceComments = false; 11422 verifyFormat("namespace a {\n" 11423 "class A\n" 11424 "{\n" 11425 " void f()\n" 11426 " {\n" 11427 " if (true) {\n" 11428 " a();\n" 11429 " b();\n" 11430 " }\n" 11431 " }\n" 11432 " void g() { return; }\n" 11433 "};\n" 11434 "enum E\n" 11435 "{\n" 11436 " A,\n" 11437 " // foo\n" 11438 " B,\n" 11439 " C\n" 11440 "};\n" 11441 "struct B\n" 11442 "{\n" 11443 " int x;\n" 11444 "};\n" 11445 "}\n", 11446 MozillaBraceStyle); 11447 verifyFormat("struct S\n" 11448 "{\n" 11449 " int Type;\n" 11450 " union\n" 11451 " {\n" 11452 " int x;\n" 11453 " double y;\n" 11454 " } Value;\n" 11455 " class C\n" 11456 " {\n" 11457 " MyFavoriteType Value;\n" 11458 " } Class;\n" 11459 "}\n", 11460 MozillaBraceStyle); 11461 } 11462 11463 TEST_F(FormatTest, StroustrupBraceBreaking) { 11464 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 11465 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11466 verifyFormat("namespace a {\n" 11467 "class A {\n" 11468 " void f()\n" 11469 " {\n" 11470 " if (true) {\n" 11471 " a();\n" 11472 " b();\n" 11473 " }\n" 11474 " }\n" 11475 " void g() { return; }\n" 11476 "};\n" 11477 "struct B {\n" 11478 " int x;\n" 11479 "};\n" 11480 "} // namespace a\n", 11481 StroustrupBraceStyle); 11482 11483 verifyFormat("void foo()\n" 11484 "{\n" 11485 " if (a) {\n" 11486 " a();\n" 11487 " }\n" 11488 " else {\n" 11489 " b();\n" 11490 " }\n" 11491 "}\n", 11492 StroustrupBraceStyle); 11493 11494 verifyFormat("#ifdef _DEBUG\n" 11495 "int foo(int i = 0)\n" 11496 "#else\n" 11497 "int foo(int i = 5)\n" 11498 "#endif\n" 11499 "{\n" 11500 " return i;\n" 11501 "}", 11502 StroustrupBraceStyle); 11503 11504 verifyFormat("void foo() {}\n" 11505 "void bar()\n" 11506 "#ifdef _DEBUG\n" 11507 "{\n" 11508 " foo();\n" 11509 "}\n" 11510 "#else\n" 11511 "{\n" 11512 "}\n" 11513 "#endif", 11514 StroustrupBraceStyle); 11515 11516 verifyFormat("void foobar() { int i = 5; }\n" 11517 "#ifdef _DEBUG\n" 11518 "void bar() {}\n" 11519 "#else\n" 11520 "void bar() { foobar(); }\n" 11521 "#endif", 11522 StroustrupBraceStyle); 11523 } 11524 11525 TEST_F(FormatTest, AllmanBraceBreaking) { 11526 FormatStyle AllmanBraceStyle = getLLVMStyle(); 11527 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 11528 11529 EXPECT_EQ("namespace a\n" 11530 "{\n" 11531 "void f();\n" 11532 "void g();\n" 11533 "} // namespace a\n", 11534 format("namespace a\n" 11535 "{\n" 11536 "void f();\n" 11537 "void g();\n" 11538 "}\n", 11539 AllmanBraceStyle)); 11540 11541 verifyFormat("namespace a\n" 11542 "{\n" 11543 "class A\n" 11544 "{\n" 11545 " void f()\n" 11546 " {\n" 11547 " if (true)\n" 11548 " {\n" 11549 " a();\n" 11550 " b();\n" 11551 " }\n" 11552 " }\n" 11553 " void g() { return; }\n" 11554 "};\n" 11555 "struct B\n" 11556 "{\n" 11557 " int x;\n" 11558 "};\n" 11559 "union C\n" 11560 "{\n" 11561 "};\n" 11562 "} // namespace a", 11563 AllmanBraceStyle); 11564 11565 verifyFormat("void f()\n" 11566 "{\n" 11567 " if (true)\n" 11568 " {\n" 11569 " a();\n" 11570 " }\n" 11571 " else if (false)\n" 11572 " {\n" 11573 " b();\n" 11574 " }\n" 11575 " else\n" 11576 " {\n" 11577 " c();\n" 11578 " }\n" 11579 "}\n", 11580 AllmanBraceStyle); 11581 11582 verifyFormat("void f()\n" 11583 "{\n" 11584 " for (int i = 0; i < 10; ++i)\n" 11585 " {\n" 11586 " a();\n" 11587 " }\n" 11588 " while (false)\n" 11589 " {\n" 11590 " b();\n" 11591 " }\n" 11592 " do\n" 11593 " {\n" 11594 " c();\n" 11595 " } while (false)\n" 11596 "}\n", 11597 AllmanBraceStyle); 11598 11599 verifyFormat("void f(int a)\n" 11600 "{\n" 11601 " switch (a)\n" 11602 " {\n" 11603 " case 0:\n" 11604 " break;\n" 11605 " case 1:\n" 11606 " {\n" 11607 " break;\n" 11608 " }\n" 11609 " case 2:\n" 11610 " {\n" 11611 " }\n" 11612 " break;\n" 11613 " default:\n" 11614 " break;\n" 11615 " }\n" 11616 "}\n", 11617 AllmanBraceStyle); 11618 11619 verifyFormat("enum X\n" 11620 "{\n" 11621 " Y = 0,\n" 11622 "}\n", 11623 AllmanBraceStyle); 11624 verifyFormat("enum X\n" 11625 "{\n" 11626 " Y = 0\n" 11627 "}\n", 11628 AllmanBraceStyle); 11629 11630 verifyFormat("@interface BSApplicationController ()\n" 11631 "{\n" 11632 "@private\n" 11633 " id _extraIvar;\n" 11634 "}\n" 11635 "@end\n", 11636 AllmanBraceStyle); 11637 11638 verifyFormat("#ifdef _DEBUG\n" 11639 "int foo(int i = 0)\n" 11640 "#else\n" 11641 "int foo(int i = 5)\n" 11642 "#endif\n" 11643 "{\n" 11644 " return i;\n" 11645 "}", 11646 AllmanBraceStyle); 11647 11648 verifyFormat("void foo() {}\n" 11649 "void bar()\n" 11650 "#ifdef _DEBUG\n" 11651 "{\n" 11652 " foo();\n" 11653 "}\n" 11654 "#else\n" 11655 "{\n" 11656 "}\n" 11657 "#endif", 11658 AllmanBraceStyle); 11659 11660 verifyFormat("void foobar() { int i = 5; }\n" 11661 "#ifdef _DEBUG\n" 11662 "void bar() {}\n" 11663 "#else\n" 11664 "void bar() { foobar(); }\n" 11665 "#endif", 11666 AllmanBraceStyle); 11667 11668 // This shouldn't affect ObjC blocks.. 11669 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 11670 " // ...\n" 11671 " int i;\n" 11672 "}];", 11673 AllmanBraceStyle); 11674 verifyFormat("void (^block)(void) = ^{\n" 11675 " // ...\n" 11676 " int i;\n" 11677 "};", 11678 AllmanBraceStyle); 11679 // .. or dict literals. 11680 verifyFormat("void f()\n" 11681 "{\n" 11682 " // ...\n" 11683 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 11684 "}", 11685 AllmanBraceStyle); 11686 verifyFormat("void f()\n" 11687 "{\n" 11688 " // ...\n" 11689 " [object someMethod:@{a : @\"b\"}];\n" 11690 "}", 11691 AllmanBraceStyle); 11692 verifyFormat("int f()\n" 11693 "{ // comment\n" 11694 " return 42;\n" 11695 "}", 11696 AllmanBraceStyle); 11697 11698 AllmanBraceStyle.ColumnLimit = 19; 11699 verifyFormat("void f() { int i; }", AllmanBraceStyle); 11700 AllmanBraceStyle.ColumnLimit = 18; 11701 verifyFormat("void f()\n" 11702 "{\n" 11703 " int i;\n" 11704 "}", 11705 AllmanBraceStyle); 11706 AllmanBraceStyle.ColumnLimit = 80; 11707 11708 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 11709 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 11710 FormatStyle::SIS_WithoutElse; 11711 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 11712 verifyFormat("void f(bool b)\n" 11713 "{\n" 11714 " if (b)\n" 11715 " {\n" 11716 " return;\n" 11717 " }\n" 11718 "}\n", 11719 BreakBeforeBraceShortIfs); 11720 verifyFormat("void f(bool b)\n" 11721 "{\n" 11722 " if constexpr (b)\n" 11723 " {\n" 11724 " return;\n" 11725 " }\n" 11726 "}\n", 11727 BreakBeforeBraceShortIfs); 11728 verifyFormat("void f(bool b)\n" 11729 "{\n" 11730 " if CONSTEXPR (b)\n" 11731 " {\n" 11732 " return;\n" 11733 " }\n" 11734 "}\n", 11735 BreakBeforeBraceShortIfs); 11736 verifyFormat("void f(bool b)\n" 11737 "{\n" 11738 " if (b) return;\n" 11739 "}\n", 11740 BreakBeforeBraceShortIfs); 11741 verifyFormat("void f(bool b)\n" 11742 "{\n" 11743 " if constexpr (b) return;\n" 11744 "}\n", 11745 BreakBeforeBraceShortIfs); 11746 verifyFormat("void f(bool b)\n" 11747 "{\n" 11748 " if CONSTEXPR (b) return;\n" 11749 "}\n", 11750 BreakBeforeBraceShortIfs); 11751 verifyFormat("void f(bool b)\n" 11752 "{\n" 11753 " while (b)\n" 11754 " {\n" 11755 " return;\n" 11756 " }\n" 11757 "}\n", 11758 BreakBeforeBraceShortIfs); 11759 } 11760 11761 TEST_F(FormatTest, WhitesmithsBraceBreaking) { 11762 FormatStyle WhitesmithsBraceStyle = getLLVMStyle(); 11763 WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 11764 11765 // Make a few changes to the style for testing purposes 11766 WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine = 11767 FormatStyle::SFS_Empty; 11768 WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 11769 WhitesmithsBraceStyle.ColumnLimit = 0; 11770 11771 // FIXME: this test case can't decide whether there should be a blank line 11772 // after the ~D() line or not. It adds one if one doesn't exist in the test 11773 // and it removes the line if one exists. 11774 /* 11775 verifyFormat("class A;\n" 11776 "namespace B\n" 11777 " {\n" 11778 "class C;\n" 11779 "// Comment\n" 11780 "class D\n" 11781 " {\n" 11782 "public:\n" 11783 " D();\n" 11784 " ~D() {}\n" 11785 "private:\n" 11786 " enum E\n" 11787 " {\n" 11788 " F\n" 11789 " }\n" 11790 " };\n" 11791 " } // namespace B\n", 11792 WhitesmithsBraceStyle); 11793 */ 11794 11795 verifyFormat("namespace a\n" 11796 " {\n" 11797 "class A\n" 11798 " {\n" 11799 " void f()\n" 11800 " {\n" 11801 " if (true)\n" 11802 " {\n" 11803 " a();\n" 11804 " b();\n" 11805 " }\n" 11806 " }\n" 11807 " void g()\n" 11808 " {\n" 11809 " return;\n" 11810 " }\n" 11811 " };\n" 11812 "struct B\n" 11813 " {\n" 11814 " int x;\n" 11815 " };\n" 11816 " } // namespace a", 11817 WhitesmithsBraceStyle); 11818 11819 verifyFormat("void f()\n" 11820 " {\n" 11821 " if (true)\n" 11822 " {\n" 11823 " a();\n" 11824 " }\n" 11825 " else if (false)\n" 11826 " {\n" 11827 " b();\n" 11828 " }\n" 11829 " else\n" 11830 " {\n" 11831 " c();\n" 11832 " }\n" 11833 " }\n", 11834 WhitesmithsBraceStyle); 11835 11836 verifyFormat("void f()\n" 11837 " {\n" 11838 " for (int i = 0; i < 10; ++i)\n" 11839 " {\n" 11840 " a();\n" 11841 " }\n" 11842 " while (false)\n" 11843 " {\n" 11844 " b();\n" 11845 " }\n" 11846 " do\n" 11847 " {\n" 11848 " c();\n" 11849 " } while (false)\n" 11850 " }\n", 11851 WhitesmithsBraceStyle); 11852 11853 // FIXME: the block and the break under case 2 in this test don't get indented 11854 // correctly 11855 /* 11856 verifyFormat("void switchTest1(int a)\n" 11857 " {\n" 11858 " switch (a)\n" 11859 " {\n" 11860 " case 2:\n" 11861 " {\n" 11862 " }\n" 11863 " break;\n" 11864 " }\n" 11865 " }\n", 11866 WhitesmithsBraceStyle); 11867 */ 11868 11869 // FIXME: the block and the break under case 2 in this test don't get indented 11870 // correctly 11871 /* 11872 verifyFormat("void switchTest2(int a)\n" 11873 " {\n" 11874 " switch (a)\n" 11875 " {\n" 11876 " case 0:\n" 11877 " break;\n" 11878 " case 1:\n" 11879 " {\n" 11880 " break;\n" 11881 " }\n" 11882 " case 2:\n" 11883 " {\n" 11884 " }\n" 11885 " break;\n" 11886 " default:\n" 11887 " break;\n" 11888 " }\n" 11889 " }\n", 11890 WhitesmithsBraceStyle); 11891 */ 11892 11893 verifyFormat("enum X\n" 11894 " {\n" 11895 " Y = 0, // testing\n" 11896 " }\n", 11897 WhitesmithsBraceStyle); 11898 11899 verifyFormat("enum X\n" 11900 " {\n" 11901 " Y = 0\n" 11902 " }\n", 11903 WhitesmithsBraceStyle); 11904 verifyFormat("enum X\n" 11905 " {\n" 11906 " Y = 0,\n" 11907 " Z = 1\n" 11908 " };\n", 11909 WhitesmithsBraceStyle); 11910 11911 verifyFormat("@interface BSApplicationController ()\n" 11912 " {\n" 11913 "@private\n" 11914 " id _extraIvar;\n" 11915 " }\n" 11916 "@end\n", 11917 WhitesmithsBraceStyle); 11918 11919 verifyFormat("#ifdef _DEBUG\n" 11920 "int foo(int i = 0)\n" 11921 "#else\n" 11922 "int foo(int i = 5)\n" 11923 "#endif\n" 11924 " {\n" 11925 " return i;\n" 11926 " }", 11927 WhitesmithsBraceStyle); 11928 11929 verifyFormat("void foo() {}\n" 11930 "void bar()\n" 11931 "#ifdef _DEBUG\n" 11932 " {\n" 11933 " foo();\n" 11934 " }\n" 11935 "#else\n" 11936 " {\n" 11937 " }\n" 11938 "#endif", 11939 WhitesmithsBraceStyle); 11940 11941 verifyFormat("void foobar()\n" 11942 " {\n" 11943 " int i = 5;\n" 11944 " }\n" 11945 "#ifdef _DEBUG\n" 11946 "void bar()\n" 11947 " {\n" 11948 " }\n" 11949 "#else\n" 11950 "void bar()\n" 11951 " {\n" 11952 " foobar();\n" 11953 " }\n" 11954 "#endif", 11955 WhitesmithsBraceStyle); 11956 11957 // This shouldn't affect ObjC blocks.. 11958 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 11959 " // ...\n" 11960 " int i;\n" 11961 "}];", 11962 WhitesmithsBraceStyle); 11963 verifyFormat("void (^block)(void) = ^{\n" 11964 " // ...\n" 11965 " int i;\n" 11966 "};", 11967 WhitesmithsBraceStyle); 11968 // .. or dict literals. 11969 verifyFormat("void f()\n" 11970 " {\n" 11971 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 11972 " }", 11973 WhitesmithsBraceStyle); 11974 11975 verifyFormat("int f()\n" 11976 " { // comment\n" 11977 " return 42;\n" 11978 " }", 11979 WhitesmithsBraceStyle); 11980 11981 FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle; 11982 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 11983 FormatStyle::SIS_Always; 11984 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 11985 verifyFormat("void f(bool b)\n" 11986 " {\n" 11987 " if (b)\n" 11988 " {\n" 11989 " return;\n" 11990 " }\n" 11991 " }\n", 11992 BreakBeforeBraceShortIfs); 11993 verifyFormat("void f(bool b)\n" 11994 " {\n" 11995 " if (b) return;\n" 11996 " }\n", 11997 BreakBeforeBraceShortIfs); 11998 verifyFormat("void f(bool b)\n" 11999 " {\n" 12000 " while (b)\n" 12001 " {\n" 12002 " return;\n" 12003 " }\n" 12004 " }\n", 12005 BreakBeforeBraceShortIfs); 12006 } 12007 12008 TEST_F(FormatTest, GNUBraceBreaking) { 12009 FormatStyle GNUBraceStyle = getLLVMStyle(); 12010 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 12011 verifyFormat("namespace a\n" 12012 "{\n" 12013 "class A\n" 12014 "{\n" 12015 " void f()\n" 12016 " {\n" 12017 " int a;\n" 12018 " {\n" 12019 " int b;\n" 12020 " }\n" 12021 " if (true)\n" 12022 " {\n" 12023 " a();\n" 12024 " b();\n" 12025 " }\n" 12026 " }\n" 12027 " void g() { return; }\n" 12028 "}\n" 12029 "} // namespace a", 12030 GNUBraceStyle); 12031 12032 verifyFormat("void f()\n" 12033 "{\n" 12034 " if (true)\n" 12035 " {\n" 12036 " a();\n" 12037 " }\n" 12038 " else if (false)\n" 12039 " {\n" 12040 " b();\n" 12041 " }\n" 12042 " else\n" 12043 " {\n" 12044 " c();\n" 12045 " }\n" 12046 "}\n", 12047 GNUBraceStyle); 12048 12049 verifyFormat("void f()\n" 12050 "{\n" 12051 " for (int i = 0; i < 10; ++i)\n" 12052 " {\n" 12053 " a();\n" 12054 " }\n" 12055 " while (false)\n" 12056 " {\n" 12057 " b();\n" 12058 " }\n" 12059 " do\n" 12060 " {\n" 12061 " c();\n" 12062 " }\n" 12063 " while (false);\n" 12064 "}\n", 12065 GNUBraceStyle); 12066 12067 verifyFormat("void f(int a)\n" 12068 "{\n" 12069 " switch (a)\n" 12070 " {\n" 12071 " case 0:\n" 12072 " break;\n" 12073 " case 1:\n" 12074 " {\n" 12075 " break;\n" 12076 " }\n" 12077 " case 2:\n" 12078 " {\n" 12079 " }\n" 12080 " break;\n" 12081 " default:\n" 12082 " break;\n" 12083 " }\n" 12084 "}\n", 12085 GNUBraceStyle); 12086 12087 verifyFormat("enum X\n" 12088 "{\n" 12089 " Y = 0,\n" 12090 "}\n", 12091 GNUBraceStyle); 12092 12093 verifyFormat("@interface BSApplicationController ()\n" 12094 "{\n" 12095 "@private\n" 12096 " id _extraIvar;\n" 12097 "}\n" 12098 "@end\n", 12099 GNUBraceStyle); 12100 12101 verifyFormat("#ifdef _DEBUG\n" 12102 "int foo(int i = 0)\n" 12103 "#else\n" 12104 "int foo(int i = 5)\n" 12105 "#endif\n" 12106 "{\n" 12107 " return i;\n" 12108 "}", 12109 GNUBraceStyle); 12110 12111 verifyFormat("void foo() {}\n" 12112 "void bar()\n" 12113 "#ifdef _DEBUG\n" 12114 "{\n" 12115 " foo();\n" 12116 "}\n" 12117 "#else\n" 12118 "{\n" 12119 "}\n" 12120 "#endif", 12121 GNUBraceStyle); 12122 12123 verifyFormat("void foobar() { int i = 5; }\n" 12124 "#ifdef _DEBUG\n" 12125 "void bar() {}\n" 12126 "#else\n" 12127 "void bar() { foobar(); }\n" 12128 "#endif", 12129 GNUBraceStyle); 12130 } 12131 12132 TEST_F(FormatTest, WebKitBraceBreaking) { 12133 FormatStyle WebKitBraceStyle = getLLVMStyle(); 12134 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 12135 WebKitBraceStyle.FixNamespaceComments = false; 12136 verifyFormat("namespace a {\n" 12137 "class A {\n" 12138 " void f()\n" 12139 " {\n" 12140 " if (true) {\n" 12141 " a();\n" 12142 " b();\n" 12143 " }\n" 12144 " }\n" 12145 " void g() { return; }\n" 12146 "};\n" 12147 "enum E {\n" 12148 " A,\n" 12149 " // foo\n" 12150 " B,\n" 12151 " C\n" 12152 "};\n" 12153 "struct B {\n" 12154 " int x;\n" 12155 "};\n" 12156 "}\n", 12157 WebKitBraceStyle); 12158 verifyFormat("struct S {\n" 12159 " int Type;\n" 12160 " union {\n" 12161 " int x;\n" 12162 " double y;\n" 12163 " } Value;\n" 12164 " class C {\n" 12165 " MyFavoriteType Value;\n" 12166 " } Class;\n" 12167 "};\n", 12168 WebKitBraceStyle); 12169 } 12170 12171 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 12172 verifyFormat("void f() {\n" 12173 " try {\n" 12174 " } catch (const Exception &e) {\n" 12175 " }\n" 12176 "}\n", 12177 getLLVMStyle()); 12178 } 12179 12180 TEST_F(FormatTest, UnderstandsPragmas) { 12181 verifyFormat("#pragma omp reduction(| : var)"); 12182 verifyFormat("#pragma omp reduction(+ : var)"); 12183 12184 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 12185 "(including parentheses).", 12186 format("#pragma mark Any non-hyphenated or hyphenated string " 12187 "(including parentheses).")); 12188 } 12189 12190 TEST_F(FormatTest, UnderstandPragmaOption) { 12191 verifyFormat("#pragma option -C -A"); 12192 12193 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 12194 } 12195 12196 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 12197 FormatStyle Style = getLLVMStyle(); 12198 Style.ColumnLimit = 20; 12199 12200 // See PR41213 12201 EXPECT_EQ("/*\n" 12202 " *\t9012345\n" 12203 " * /8901\n" 12204 " */", 12205 format("/*\n" 12206 " *\t9012345 /8901\n" 12207 " */", 12208 Style)); 12209 EXPECT_EQ("/*\n" 12210 " *345678\n" 12211 " *\t/8901\n" 12212 " */", 12213 format("/*\n" 12214 " *345678\t/8901\n" 12215 " */", 12216 Style)); 12217 12218 verifyFormat("int a; // the\n" 12219 " // comment", 12220 Style); 12221 EXPECT_EQ("int a; /* first line\n" 12222 " * second\n" 12223 " * line third\n" 12224 " * line\n" 12225 " */", 12226 format("int a; /* first line\n" 12227 " * second\n" 12228 " * line third\n" 12229 " * line\n" 12230 " */", 12231 Style)); 12232 EXPECT_EQ("int a; // first line\n" 12233 " // second\n" 12234 " // line third\n" 12235 " // line", 12236 format("int a; // first line\n" 12237 " // second line\n" 12238 " // third line", 12239 Style)); 12240 12241 Style.PenaltyExcessCharacter = 90; 12242 verifyFormat("int a; // the comment", Style); 12243 EXPECT_EQ("int a; // the comment\n" 12244 " // aaa", 12245 format("int a; // the comment aaa", Style)); 12246 EXPECT_EQ("int a; /* first line\n" 12247 " * second line\n" 12248 " * third line\n" 12249 " */", 12250 format("int a; /* first line\n" 12251 " * second line\n" 12252 " * third line\n" 12253 " */", 12254 Style)); 12255 EXPECT_EQ("int a; // first line\n" 12256 " // second line\n" 12257 " // third line", 12258 format("int a; // first line\n" 12259 " // second line\n" 12260 " // third line", 12261 Style)); 12262 // FIXME: Investigate why this is not getting the same layout as the test 12263 // above. 12264 EXPECT_EQ("int a; /* first line\n" 12265 " * second line\n" 12266 " * third line\n" 12267 " */", 12268 format("int a; /* first line second line third line" 12269 "\n*/", 12270 Style)); 12271 12272 EXPECT_EQ("// foo bar baz bazfoo\n" 12273 "// foo bar foo bar\n", 12274 format("// foo bar baz bazfoo\n" 12275 "// foo bar foo bar\n", 12276 Style)); 12277 EXPECT_EQ("// foo bar baz bazfoo\n" 12278 "// foo bar foo bar\n", 12279 format("// foo bar baz bazfoo\n" 12280 "// foo bar foo bar\n", 12281 Style)); 12282 12283 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 12284 // next one. 12285 EXPECT_EQ("// foo bar baz bazfoo\n" 12286 "// bar foo bar\n", 12287 format("// foo bar baz bazfoo bar\n" 12288 "// foo bar\n", 12289 Style)); 12290 12291 EXPECT_EQ("// foo bar baz bazfoo\n" 12292 "// foo bar baz bazfoo\n" 12293 "// bar foo bar\n", 12294 format("// foo bar baz bazfoo\n" 12295 "// foo bar baz bazfoo bar\n" 12296 "// foo bar\n", 12297 Style)); 12298 12299 EXPECT_EQ("// foo bar baz bazfoo\n" 12300 "// foo bar baz bazfoo\n" 12301 "// bar foo bar\n", 12302 format("// foo bar baz bazfoo\n" 12303 "// foo bar baz bazfoo bar\n" 12304 "// foo bar\n", 12305 Style)); 12306 12307 // Make sure we do not keep protruding characters if strict mode reflow is 12308 // cheaper than keeping protruding characters. 12309 Style.ColumnLimit = 21; 12310 EXPECT_EQ( 12311 "// foo foo foo foo\n" 12312 "// foo foo foo foo\n" 12313 "// foo foo foo foo\n", 12314 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style)); 12315 12316 EXPECT_EQ("int a = /* long block\n" 12317 " comment */\n" 12318 " 42;", 12319 format("int a = /* long block comment */ 42;", Style)); 12320 } 12321 12322 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 12323 for (size_t i = 1; i < Styles.size(); ++i) \ 12324 EXPECT_EQ(Styles[0], Styles[i]) \ 12325 << "Style #" << i << " of " << Styles.size() << " differs from Style #0" 12326 12327 TEST_F(FormatTest, GetsPredefinedStyleByName) { 12328 SmallVector<FormatStyle, 3> Styles; 12329 Styles.resize(3); 12330 12331 Styles[0] = getLLVMStyle(); 12332 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 12333 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 12334 EXPECT_ALL_STYLES_EQUAL(Styles); 12335 12336 Styles[0] = getGoogleStyle(); 12337 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 12338 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 12339 EXPECT_ALL_STYLES_EQUAL(Styles); 12340 12341 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12342 EXPECT_TRUE( 12343 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 12344 EXPECT_TRUE( 12345 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 12346 EXPECT_ALL_STYLES_EQUAL(Styles); 12347 12348 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 12349 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 12350 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 12351 EXPECT_ALL_STYLES_EQUAL(Styles); 12352 12353 Styles[0] = getMozillaStyle(); 12354 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 12355 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 12356 EXPECT_ALL_STYLES_EQUAL(Styles); 12357 12358 Styles[0] = getWebKitStyle(); 12359 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 12360 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 12361 EXPECT_ALL_STYLES_EQUAL(Styles); 12362 12363 Styles[0] = getGNUStyle(); 12364 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 12365 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 12366 EXPECT_ALL_STYLES_EQUAL(Styles); 12367 12368 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 12369 } 12370 12371 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 12372 SmallVector<FormatStyle, 8> Styles; 12373 Styles.resize(2); 12374 12375 Styles[0] = getGoogleStyle(); 12376 Styles[1] = getLLVMStyle(); 12377 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12378 EXPECT_ALL_STYLES_EQUAL(Styles); 12379 12380 Styles.resize(5); 12381 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12382 Styles[1] = getLLVMStyle(); 12383 Styles[1].Language = FormatStyle::LK_JavaScript; 12384 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12385 12386 Styles[2] = getLLVMStyle(); 12387 Styles[2].Language = FormatStyle::LK_JavaScript; 12388 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 12389 "BasedOnStyle: Google", 12390 &Styles[2]) 12391 .value()); 12392 12393 Styles[3] = getLLVMStyle(); 12394 Styles[3].Language = FormatStyle::LK_JavaScript; 12395 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 12396 "Language: JavaScript", 12397 &Styles[3]) 12398 .value()); 12399 12400 Styles[4] = getLLVMStyle(); 12401 Styles[4].Language = FormatStyle::LK_JavaScript; 12402 EXPECT_EQ(0, parseConfiguration("---\n" 12403 "BasedOnStyle: LLVM\n" 12404 "IndentWidth: 123\n" 12405 "---\n" 12406 "BasedOnStyle: Google\n" 12407 "Language: JavaScript", 12408 &Styles[4]) 12409 .value()); 12410 EXPECT_ALL_STYLES_EQUAL(Styles); 12411 } 12412 12413 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 12414 Style.FIELD = false; \ 12415 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 12416 EXPECT_TRUE(Style.FIELD); \ 12417 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 12418 EXPECT_FALSE(Style.FIELD); 12419 12420 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 12421 12422 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 12423 Style.STRUCT.FIELD = false; \ 12424 EXPECT_EQ(0, \ 12425 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 12426 .value()); \ 12427 EXPECT_TRUE(Style.STRUCT.FIELD); \ 12428 EXPECT_EQ(0, \ 12429 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 12430 .value()); \ 12431 EXPECT_FALSE(Style.STRUCT.FIELD); 12432 12433 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 12434 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 12435 12436 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 12437 EXPECT_NE(VALUE, Style.FIELD); \ 12438 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 12439 EXPECT_EQ(VALUE, Style.FIELD) 12440 12441 TEST_F(FormatTest, ParsesConfigurationBools) { 12442 FormatStyle Style = {}; 12443 Style.Language = FormatStyle::LK_Cpp; 12444 CHECK_PARSE_BOOL(AlignOperands); 12445 CHECK_PARSE_BOOL(AlignTrailingComments); 12446 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 12447 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 12448 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 12449 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 12450 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 12451 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 12452 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 12453 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 12454 CHECK_PARSE_BOOL(BinPackArguments); 12455 CHECK_PARSE_BOOL(BinPackParameters); 12456 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 12457 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 12458 CHECK_PARSE_BOOL(BreakStringLiterals); 12459 CHECK_PARSE_BOOL(CompactNamespaces); 12460 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 12461 CHECK_PARSE_BOOL(DerivePointerAlignment); 12462 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 12463 CHECK_PARSE_BOOL(DisableFormat); 12464 CHECK_PARSE_BOOL(IndentCaseLabels); 12465 CHECK_PARSE_BOOL(IndentGotoLabels); 12466 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 12467 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 12468 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 12469 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 12470 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 12471 CHECK_PARSE_BOOL(ReflowComments); 12472 CHECK_PARSE_BOOL(SortIncludes); 12473 CHECK_PARSE_BOOL(SortUsingDeclarations); 12474 CHECK_PARSE_BOOL(SpacesInParentheses); 12475 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 12476 CHECK_PARSE_BOOL(SpacesInAngles); 12477 CHECK_PARSE_BOOL(SpaceInEmptyBlock); 12478 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 12479 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 12480 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 12481 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 12482 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 12483 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 12484 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 12485 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 12486 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 12487 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 12488 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 12489 12490 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 12491 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 12492 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 12493 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 12494 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 12495 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 12496 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 12497 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 12498 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 12499 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 12500 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 12501 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 12502 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 12503 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 12504 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 12505 } 12506 12507 #undef CHECK_PARSE_BOOL 12508 12509 TEST_F(FormatTest, ParsesConfiguration) { 12510 FormatStyle Style = {}; 12511 Style.Language = FormatStyle::LK_Cpp; 12512 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 12513 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 12514 ConstructorInitializerIndentWidth, 1234u); 12515 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 12516 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 12517 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 12518 CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u); 12519 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 12520 PenaltyBreakBeforeFirstCallParameter, 1234u); 12521 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 12522 PenaltyBreakTemplateDeclaration, 1234u); 12523 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 12524 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 12525 PenaltyReturnTypeOnItsOwnLine, 1234u); 12526 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 12527 SpacesBeforeTrailingComments, 1234u); 12528 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 12529 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 12530 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 12531 12532 Style.PointerAlignment = FormatStyle::PAS_Middle; 12533 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 12534 FormatStyle::PAS_Left); 12535 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 12536 FormatStyle::PAS_Right); 12537 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 12538 FormatStyle::PAS_Middle); 12539 // For backward compatibility: 12540 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 12541 FormatStyle::PAS_Left); 12542 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 12543 FormatStyle::PAS_Right); 12544 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 12545 FormatStyle::PAS_Middle); 12546 12547 Style.Standard = FormatStyle::LS_Auto; 12548 CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03); 12549 CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11); 12550 CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14); 12551 CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17); 12552 CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20); 12553 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 12554 CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest); 12555 // Legacy aliases: 12556 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 12557 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest); 12558 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 12559 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 12560 12561 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 12562 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 12563 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 12564 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 12565 FormatStyle::BOS_None); 12566 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 12567 FormatStyle::BOS_All); 12568 // For backward compatibility: 12569 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 12570 FormatStyle::BOS_None); 12571 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 12572 FormatStyle::BOS_All); 12573 12574 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 12575 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 12576 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 12577 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 12578 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 12579 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 12580 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 12581 // For backward compatibility: 12582 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 12583 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 12584 12585 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 12586 CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList, 12587 FormatStyle::BILS_BeforeComma); 12588 CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList, 12589 FormatStyle::BILS_AfterColon); 12590 CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList, 12591 FormatStyle::BILS_BeforeColon); 12592 // For backward compatibility: 12593 CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList, 12594 FormatStyle::BILS_BeforeComma); 12595 12596 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 12597 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 12598 FormatStyle::BAS_Align); 12599 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 12600 FormatStyle::BAS_DontAlign); 12601 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 12602 FormatStyle::BAS_AlwaysBreak); 12603 // For backward compatibility: 12604 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 12605 FormatStyle::BAS_DontAlign); 12606 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 12607 FormatStyle::BAS_Align); 12608 12609 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 12610 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 12611 FormatStyle::ENAS_DontAlign); 12612 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 12613 FormatStyle::ENAS_Left); 12614 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 12615 FormatStyle::ENAS_Right); 12616 // For backward compatibility: 12617 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 12618 FormatStyle::ENAS_Left); 12619 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 12620 FormatStyle::ENAS_Right); 12621 12622 Style.UseTab = FormatStyle::UT_ForIndentation; 12623 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 12624 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 12625 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 12626 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 12627 FormatStyle::UT_ForContinuationAndIndentation); 12628 // For backward compatibility: 12629 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 12630 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 12631 12632 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 12633 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never", 12634 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12635 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty", 12636 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty); 12637 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always", 12638 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12639 // For backward compatibility: 12640 CHECK_PARSE("AllowShortBlocksOnASingleLine: false", 12641 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12642 CHECK_PARSE("AllowShortBlocksOnASingleLine: true", 12643 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12644 12645 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 12646 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 12647 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12648 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 12649 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 12650 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 12651 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 12652 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 12653 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12654 // For backward compatibility: 12655 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 12656 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12657 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 12658 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12659 12660 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 12661 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 12662 FormatStyle::SBPO_Never); 12663 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 12664 FormatStyle::SBPO_Always); 12665 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 12666 FormatStyle::SBPO_ControlStatements); 12667 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 12668 FormatStyle::SBPO_NonEmptyParentheses); 12669 // For backward compatibility: 12670 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 12671 FormatStyle::SBPO_Never); 12672 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 12673 FormatStyle::SBPO_ControlStatements); 12674 12675 Style.ColumnLimit = 123; 12676 FormatStyle BaseStyle = getLLVMStyle(); 12677 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 12678 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 12679 12680 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 12681 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 12682 FormatStyle::BS_Attach); 12683 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 12684 FormatStyle::BS_Linux); 12685 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 12686 FormatStyle::BS_Mozilla); 12687 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 12688 FormatStyle::BS_Stroustrup); 12689 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 12690 FormatStyle::BS_Allman); 12691 CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces, 12692 FormatStyle::BS_Whitesmiths); 12693 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 12694 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 12695 FormatStyle::BS_WebKit); 12696 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 12697 FormatStyle::BS_Custom); 12698 12699 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never; 12700 CHECK_PARSE("BraceWrapping:\n" 12701 " AfterControlStatement: MultiLine", 12702 BraceWrapping.AfterControlStatement, 12703 FormatStyle::BWACS_MultiLine); 12704 CHECK_PARSE("BraceWrapping:\n" 12705 " AfterControlStatement: Always", 12706 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 12707 CHECK_PARSE("BraceWrapping:\n" 12708 " AfterControlStatement: Never", 12709 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 12710 // For backward compatibility: 12711 CHECK_PARSE("BraceWrapping:\n" 12712 " AfterControlStatement: true", 12713 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 12714 CHECK_PARSE("BraceWrapping:\n" 12715 " AfterControlStatement: false", 12716 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 12717 12718 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 12719 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 12720 FormatStyle::RTBS_None); 12721 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 12722 FormatStyle::RTBS_All); 12723 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 12724 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 12725 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 12726 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 12727 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 12728 AlwaysBreakAfterReturnType, 12729 FormatStyle::RTBS_TopLevelDefinitions); 12730 12731 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 12732 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", 12733 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No); 12734 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", 12735 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 12736 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", 12737 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 12738 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", 12739 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 12740 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", 12741 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 12742 12743 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 12744 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 12745 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 12746 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 12747 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 12748 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 12749 AlwaysBreakAfterDefinitionReturnType, 12750 FormatStyle::DRTBS_TopLevel); 12751 12752 Style.NamespaceIndentation = FormatStyle::NI_All; 12753 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 12754 FormatStyle::NI_None); 12755 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 12756 FormatStyle::NI_Inner); 12757 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 12758 FormatStyle::NI_All); 12759 12760 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 12761 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 12762 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12763 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 12764 AllowShortIfStatementsOnASingleLine, 12765 FormatStyle::SIS_WithoutElse); 12766 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 12767 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 12768 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 12769 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12770 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 12771 AllowShortIfStatementsOnASingleLine, 12772 FormatStyle::SIS_WithoutElse); 12773 12774 // FIXME: This is required because parsing a configuration simply overwrites 12775 // the first N elements of the list instead of resetting it. 12776 Style.ForEachMacros.clear(); 12777 std::vector<std::string> BoostForeach; 12778 BoostForeach.push_back("BOOST_FOREACH"); 12779 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 12780 std::vector<std::string> BoostAndQForeach; 12781 BoostAndQForeach.push_back("BOOST_FOREACH"); 12782 BoostAndQForeach.push_back("Q_FOREACH"); 12783 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 12784 BoostAndQForeach); 12785 12786 Style.StatementMacros.clear(); 12787 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 12788 std::vector<std::string>{"QUNUSED"}); 12789 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 12790 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 12791 12792 Style.NamespaceMacros.clear(); 12793 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 12794 std::vector<std::string>{"TESTSUITE"}); 12795 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 12796 std::vector<std::string>({"TESTSUITE", "SUITE"})); 12797 12798 Style.IncludeStyle.IncludeCategories.clear(); 12799 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 12800 {"abc/.*", 2, 0}, {".*", 1, 0}}; 12801 CHECK_PARSE("IncludeCategories:\n" 12802 " - Regex: abc/.*\n" 12803 " Priority: 2\n" 12804 " - Regex: .*\n" 12805 " Priority: 1", 12806 IncludeStyle.IncludeCategories, ExpectedCategories); 12807 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 12808 "abc$"); 12809 12810 Style.RawStringFormats.clear(); 12811 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 12812 { 12813 FormatStyle::LK_TextProto, 12814 {"pb", "proto"}, 12815 {"PARSE_TEXT_PROTO"}, 12816 /*CanonicalDelimiter=*/"", 12817 "llvm", 12818 }, 12819 { 12820 FormatStyle::LK_Cpp, 12821 {"cc", "cpp"}, 12822 {"C_CODEBLOCK", "CPPEVAL"}, 12823 /*CanonicalDelimiter=*/"cc", 12824 /*BasedOnStyle=*/"", 12825 }, 12826 }; 12827 12828 CHECK_PARSE("RawStringFormats:\n" 12829 " - Language: TextProto\n" 12830 " Delimiters:\n" 12831 " - 'pb'\n" 12832 " - 'proto'\n" 12833 " EnclosingFunctions:\n" 12834 " - 'PARSE_TEXT_PROTO'\n" 12835 " BasedOnStyle: llvm\n" 12836 " - Language: Cpp\n" 12837 " Delimiters:\n" 12838 " - 'cc'\n" 12839 " - 'cpp'\n" 12840 " EnclosingFunctions:\n" 12841 " - 'C_CODEBLOCK'\n" 12842 " - 'CPPEVAL'\n" 12843 " CanonicalDelimiter: 'cc'", 12844 RawStringFormats, ExpectedRawStringFormats); 12845 } 12846 12847 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 12848 FormatStyle Style = {}; 12849 Style.Language = FormatStyle::LK_Cpp; 12850 CHECK_PARSE("Language: Cpp\n" 12851 "IndentWidth: 12", 12852 IndentWidth, 12u); 12853 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 12854 "IndentWidth: 34", 12855 &Style), 12856 ParseError::Unsuitable); 12857 EXPECT_EQ(12u, Style.IndentWidth); 12858 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12859 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12860 12861 Style.Language = FormatStyle::LK_JavaScript; 12862 CHECK_PARSE("Language: JavaScript\n" 12863 "IndentWidth: 12", 12864 IndentWidth, 12u); 12865 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 12866 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 12867 "IndentWidth: 34", 12868 &Style), 12869 ParseError::Unsuitable); 12870 EXPECT_EQ(23u, Style.IndentWidth); 12871 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12872 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12873 12874 CHECK_PARSE("BasedOnStyle: LLVM\n" 12875 "IndentWidth: 67", 12876 IndentWidth, 67u); 12877 12878 CHECK_PARSE("---\n" 12879 "Language: JavaScript\n" 12880 "IndentWidth: 12\n" 12881 "---\n" 12882 "Language: Cpp\n" 12883 "IndentWidth: 34\n" 12884 "...\n", 12885 IndentWidth, 12u); 12886 12887 Style.Language = FormatStyle::LK_Cpp; 12888 CHECK_PARSE("---\n" 12889 "Language: JavaScript\n" 12890 "IndentWidth: 12\n" 12891 "---\n" 12892 "Language: Cpp\n" 12893 "IndentWidth: 34\n" 12894 "...\n", 12895 IndentWidth, 34u); 12896 CHECK_PARSE("---\n" 12897 "IndentWidth: 78\n" 12898 "---\n" 12899 "Language: JavaScript\n" 12900 "IndentWidth: 56\n" 12901 "...\n", 12902 IndentWidth, 78u); 12903 12904 Style.ColumnLimit = 123; 12905 Style.IndentWidth = 234; 12906 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 12907 Style.TabWidth = 345; 12908 EXPECT_FALSE(parseConfiguration("---\n" 12909 "IndentWidth: 456\n" 12910 "BreakBeforeBraces: Allman\n" 12911 "---\n" 12912 "Language: JavaScript\n" 12913 "IndentWidth: 111\n" 12914 "TabWidth: 111\n" 12915 "---\n" 12916 "Language: Cpp\n" 12917 "BreakBeforeBraces: Stroustrup\n" 12918 "TabWidth: 789\n" 12919 "...\n", 12920 &Style)); 12921 EXPECT_EQ(123u, Style.ColumnLimit); 12922 EXPECT_EQ(456u, Style.IndentWidth); 12923 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 12924 EXPECT_EQ(789u, Style.TabWidth); 12925 12926 EXPECT_EQ(parseConfiguration("---\n" 12927 "Language: JavaScript\n" 12928 "IndentWidth: 56\n" 12929 "---\n" 12930 "IndentWidth: 78\n" 12931 "...\n", 12932 &Style), 12933 ParseError::Error); 12934 EXPECT_EQ(parseConfiguration("---\n" 12935 "Language: JavaScript\n" 12936 "IndentWidth: 56\n" 12937 "---\n" 12938 "Language: JavaScript\n" 12939 "IndentWidth: 78\n" 12940 "...\n", 12941 &Style), 12942 ParseError::Error); 12943 12944 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12945 } 12946 12947 #undef CHECK_PARSE 12948 12949 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 12950 FormatStyle Style = {}; 12951 Style.Language = FormatStyle::LK_JavaScript; 12952 Style.BreakBeforeTernaryOperators = true; 12953 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 12954 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 12955 12956 Style.BreakBeforeTernaryOperators = true; 12957 EXPECT_EQ(0, parseConfiguration("---\n" 12958 "BasedOnStyle: Google\n" 12959 "---\n" 12960 "Language: JavaScript\n" 12961 "IndentWidth: 76\n" 12962 "...\n", 12963 &Style) 12964 .value()); 12965 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 12966 EXPECT_EQ(76u, Style.IndentWidth); 12967 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12968 } 12969 12970 TEST_F(FormatTest, ConfigurationRoundTripTest) { 12971 FormatStyle Style = getLLVMStyle(); 12972 std::string YAML = configurationAsText(Style); 12973 FormatStyle ParsedStyle = {}; 12974 ParsedStyle.Language = FormatStyle::LK_Cpp; 12975 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 12976 EXPECT_EQ(Style, ParsedStyle); 12977 } 12978 12979 TEST_F(FormatTest, WorksFor8bitEncodings) { 12980 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 12981 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 12982 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 12983 "\"\xef\xee\xf0\xf3...\"", 12984 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 12985 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 12986 "\xef\xee\xf0\xf3...\"", 12987 getLLVMStyleWithColumns(12))); 12988 } 12989 12990 TEST_F(FormatTest, HandlesUTF8BOM) { 12991 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 12992 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 12993 format("\xef\xbb\xbf#include <iostream>")); 12994 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 12995 format("\xef\xbb\xbf\n#include <iostream>")); 12996 } 12997 12998 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 12999 #if !defined(_MSC_VER) 13000 13001 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 13002 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 13003 getLLVMStyleWithColumns(35)); 13004 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 13005 getLLVMStyleWithColumns(31)); 13006 verifyFormat("// Однажды в студёную зимнюю пору...", 13007 getLLVMStyleWithColumns(36)); 13008 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 13009 verifyFormat("/* Однажды в студёную зимнюю пору... */", 13010 getLLVMStyleWithColumns(39)); 13011 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 13012 getLLVMStyleWithColumns(35)); 13013 } 13014 13015 TEST_F(FormatTest, SplitsUTF8Strings) { 13016 // Non-printable characters' width is currently considered to be the length in 13017 // bytes in UTF8. The characters can be displayed in very different manner 13018 // (zero-width, single width with a substitution glyph, expanded to their code 13019 // (e.g. "<8d>"), so there's no single correct way to handle them. 13020 EXPECT_EQ("\"aaaaÄ\"\n" 13021 "\"\xc2\x8d\";", 13022 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13023 EXPECT_EQ("\"aaaaaaaÄ\"\n" 13024 "\"\xc2\x8d\";", 13025 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13026 EXPECT_EQ("\"Однажды, в \"\n" 13027 "\"студёную \"\n" 13028 "\"зимнюю \"\n" 13029 "\"пору,\"", 13030 format("\"Однажды, в студёную зимнюю пору,\"", 13031 getLLVMStyleWithColumns(13))); 13032 EXPECT_EQ( 13033 "\"一 二 三 \"\n" 13034 "\"四 五六 \"\n" 13035 "\"七 八 九 \"\n" 13036 "\"十\"", 13037 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 13038 EXPECT_EQ("\"一\t\"\n" 13039 "\"二 \t\"\n" 13040 "\"三 四 \"\n" 13041 "\"五\t\"\n" 13042 "\"六 \t\"\n" 13043 "\"七 \"\n" 13044 "\"八九十\tqq\"", 13045 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 13046 getLLVMStyleWithColumns(11))); 13047 13048 // UTF8 character in an escape sequence. 13049 EXPECT_EQ("\"aaaaaa\"\n" 13050 "\"\\\xC2\x8D\"", 13051 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 13052 } 13053 13054 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 13055 EXPECT_EQ("const char *sssss =\n" 13056 " \"一二三四五六七八\\\n" 13057 " 九 十\";", 13058 format("const char *sssss = \"一二三四五六七八\\\n" 13059 " 九 十\";", 13060 getLLVMStyleWithColumns(30))); 13061 } 13062 13063 TEST_F(FormatTest, SplitsUTF8LineComments) { 13064 EXPECT_EQ("// aaaaÄ\xc2\x8d", 13065 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 13066 EXPECT_EQ("// Я из лесу\n" 13067 "// вышел; был\n" 13068 "// сильный\n" 13069 "// мороз.", 13070 format("// Я из лесу вышел; был сильный мороз.", 13071 getLLVMStyleWithColumns(13))); 13072 EXPECT_EQ("// 一二三\n" 13073 "// 四五六七\n" 13074 "// 八 九\n" 13075 "// 十", 13076 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 13077 } 13078 13079 TEST_F(FormatTest, SplitsUTF8BlockComments) { 13080 EXPECT_EQ("/* Гляжу,\n" 13081 " * поднимается\n" 13082 " * медленно в\n" 13083 " * гору\n" 13084 " * Лошадка,\n" 13085 " * везущая\n" 13086 " * хворосту\n" 13087 " * воз. */", 13088 format("/* Гляжу, поднимается медленно в гору\n" 13089 " * Лошадка, везущая хворосту воз. */", 13090 getLLVMStyleWithColumns(13))); 13091 EXPECT_EQ( 13092 "/* 一二三\n" 13093 " * 四五六七\n" 13094 " * 八 九\n" 13095 " * 十 */", 13096 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 13097 EXPECT_EQ("/* �������� ��������\n" 13098 " * ��������\n" 13099 " * ������-�� */", 13100 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 13101 } 13102 13103 #endif // _MSC_VER 13104 13105 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 13106 FormatStyle Style = getLLVMStyle(); 13107 13108 Style.ConstructorInitializerIndentWidth = 4; 13109 verifyFormat( 13110 "SomeClass::Constructor()\n" 13111 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13112 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13113 Style); 13114 13115 Style.ConstructorInitializerIndentWidth = 2; 13116 verifyFormat( 13117 "SomeClass::Constructor()\n" 13118 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13119 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13120 Style); 13121 13122 Style.ConstructorInitializerIndentWidth = 0; 13123 verifyFormat( 13124 "SomeClass::Constructor()\n" 13125 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13126 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13127 Style); 13128 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 13129 verifyFormat( 13130 "SomeLongTemplateVariableName<\n" 13131 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 13132 Style); 13133 verifyFormat("bool smaller = 1 < " 13134 "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 13135 " " 13136 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 13137 Style); 13138 13139 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 13140 verifyFormat("SomeClass::Constructor() :\n" 13141 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 13142 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 13143 Style); 13144 } 13145 13146 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 13147 FormatStyle Style = getLLVMStyle(); 13148 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 13149 Style.ConstructorInitializerIndentWidth = 4; 13150 verifyFormat("SomeClass::Constructor()\n" 13151 " : a(a)\n" 13152 " , b(b)\n" 13153 " , c(c) {}", 13154 Style); 13155 verifyFormat("SomeClass::Constructor()\n" 13156 " : a(a) {}", 13157 Style); 13158 13159 Style.ColumnLimit = 0; 13160 verifyFormat("SomeClass::Constructor()\n" 13161 " : a(a) {}", 13162 Style); 13163 verifyFormat("SomeClass::Constructor() noexcept\n" 13164 " : a(a) {}", 13165 Style); 13166 verifyFormat("SomeClass::Constructor()\n" 13167 " : a(a)\n" 13168 " , b(b)\n" 13169 " , c(c) {}", 13170 Style); 13171 verifyFormat("SomeClass::Constructor()\n" 13172 " : a(a) {\n" 13173 " foo();\n" 13174 " bar();\n" 13175 "}", 13176 Style); 13177 13178 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 13179 verifyFormat("SomeClass::Constructor()\n" 13180 " : a(a)\n" 13181 " , b(b)\n" 13182 " , c(c) {\n}", 13183 Style); 13184 verifyFormat("SomeClass::Constructor()\n" 13185 " : a(a) {\n}", 13186 Style); 13187 13188 Style.ColumnLimit = 80; 13189 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 13190 Style.ConstructorInitializerIndentWidth = 2; 13191 verifyFormat("SomeClass::Constructor()\n" 13192 " : a(a)\n" 13193 " , b(b)\n" 13194 " , c(c) {}", 13195 Style); 13196 13197 Style.ConstructorInitializerIndentWidth = 0; 13198 verifyFormat("SomeClass::Constructor()\n" 13199 ": a(a)\n" 13200 ", b(b)\n" 13201 ", c(c) {}", 13202 Style); 13203 13204 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 13205 Style.ConstructorInitializerIndentWidth = 4; 13206 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 13207 verifyFormat( 13208 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 13209 Style); 13210 verifyFormat( 13211 "SomeClass::Constructor()\n" 13212 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 13213 Style); 13214 Style.ConstructorInitializerIndentWidth = 4; 13215 Style.ColumnLimit = 60; 13216 verifyFormat("SomeClass::Constructor()\n" 13217 " : aaaaaaaa(aaaaaaaa)\n" 13218 " , aaaaaaaa(aaaaaaaa)\n" 13219 " , aaaaaaaa(aaaaaaaa) {}", 13220 Style); 13221 } 13222 13223 TEST_F(FormatTest, Destructors) { 13224 verifyFormat("void F(int &i) { i.~int(); }"); 13225 verifyFormat("void F(int &i) { i->~int(); }"); 13226 } 13227 13228 TEST_F(FormatTest, FormatsWithWebKitStyle) { 13229 FormatStyle Style = getWebKitStyle(); 13230 13231 // Don't indent in outer namespaces. 13232 verifyFormat("namespace outer {\n" 13233 "int i;\n" 13234 "namespace inner {\n" 13235 " int i;\n" 13236 "} // namespace inner\n" 13237 "} // namespace outer\n" 13238 "namespace other_outer {\n" 13239 "int i;\n" 13240 "}", 13241 Style); 13242 13243 // Don't indent case labels. 13244 verifyFormat("switch (variable) {\n" 13245 "case 1:\n" 13246 "case 2:\n" 13247 " doSomething();\n" 13248 " break;\n" 13249 "default:\n" 13250 " ++variable;\n" 13251 "}", 13252 Style); 13253 13254 // Wrap before binary operators. 13255 EXPECT_EQ("void f()\n" 13256 "{\n" 13257 " if (aaaaaaaaaaaaaaaa\n" 13258 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 13259 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13260 " return;\n" 13261 "}", 13262 format("void f() {\n" 13263 "if (aaaaaaaaaaaaaaaa\n" 13264 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 13265 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13266 "return;\n" 13267 "}", 13268 Style)); 13269 13270 // Allow functions on a single line. 13271 verifyFormat("void f() { return; }", Style); 13272 13273 // Allow empty blocks on a single line and insert a space in empty blocks. 13274 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 13275 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 13276 // However, don't merge non-empty short loops. 13277 EXPECT_EQ("while (true) {\n" 13278 " continue;\n" 13279 "}", 13280 format("while (true) { continue; }", Style)); 13281 13282 // Constructor initializers are formatted one per line with the "," on the 13283 // new line. 13284 verifyFormat("Constructor()\n" 13285 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 13286 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 13287 " aaaaaaaaaaaaaa)\n" 13288 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 13289 "{\n" 13290 "}", 13291 Style); 13292 verifyFormat("SomeClass::Constructor()\n" 13293 " : a(a)\n" 13294 "{\n" 13295 "}", 13296 Style); 13297 EXPECT_EQ("SomeClass::Constructor()\n" 13298 " : a(a)\n" 13299 "{\n" 13300 "}", 13301 format("SomeClass::Constructor():a(a){}", Style)); 13302 verifyFormat("SomeClass::Constructor()\n" 13303 " : a(a)\n" 13304 " , b(b)\n" 13305 " , c(c)\n" 13306 "{\n" 13307 "}", 13308 Style); 13309 verifyFormat("SomeClass::Constructor()\n" 13310 " : a(a)\n" 13311 "{\n" 13312 " foo();\n" 13313 " bar();\n" 13314 "}", 13315 Style); 13316 13317 // Access specifiers should be aligned left. 13318 verifyFormat("class C {\n" 13319 "public:\n" 13320 " int i;\n" 13321 "};", 13322 Style); 13323 13324 // Do not align comments. 13325 verifyFormat("int a; // Do not\n" 13326 "double b; // align comments.", 13327 Style); 13328 13329 // Do not align operands. 13330 EXPECT_EQ("ASSERT(aaaa\n" 13331 " || bbbb);", 13332 format("ASSERT ( aaaa\n||bbbb);", Style)); 13333 13334 // Accept input's line breaks. 13335 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 13336 " || bbbbbbbbbbbbbbb) {\n" 13337 " i++;\n" 13338 "}", 13339 format("if (aaaaaaaaaaaaaaa\n" 13340 "|| bbbbbbbbbbbbbbb) { i++; }", 13341 Style)); 13342 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 13343 " i++;\n" 13344 "}", 13345 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 13346 13347 // Don't automatically break all macro definitions (llvm.org/PR17842). 13348 verifyFormat("#define aNumber 10", Style); 13349 // However, generally keep the line breaks that the user authored. 13350 EXPECT_EQ("#define aNumber \\\n" 13351 " 10", 13352 format("#define aNumber \\\n" 13353 " 10", 13354 Style)); 13355 13356 // Keep empty and one-element array literals on a single line. 13357 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 13358 " copyItems:YES];", 13359 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 13360 "copyItems:YES];", 13361 Style)); 13362 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 13363 " copyItems:YES];", 13364 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 13365 " copyItems:YES];", 13366 Style)); 13367 // FIXME: This does not seem right, there should be more indentation before 13368 // the array literal's entries. Nested blocks have the same problem. 13369 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13370 " @\"a\",\n" 13371 " @\"a\"\n" 13372 "]\n" 13373 " copyItems:YES];", 13374 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13375 " @\"a\",\n" 13376 " @\"a\"\n" 13377 " ]\n" 13378 " copyItems:YES];", 13379 Style)); 13380 EXPECT_EQ( 13381 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13382 " copyItems:YES];", 13383 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13384 " copyItems:YES];", 13385 Style)); 13386 13387 verifyFormat("[self.a b:c c:d];", Style); 13388 EXPECT_EQ("[self.a b:c\n" 13389 " c:d];", 13390 format("[self.a b:c\n" 13391 "c:d];", 13392 Style)); 13393 } 13394 13395 TEST_F(FormatTest, FormatsLambdas) { 13396 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 13397 verifyFormat( 13398 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 13399 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 13400 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 13401 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 13402 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 13403 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 13404 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 13405 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 13406 verifyFormat("int x = f(*+[] {});"); 13407 verifyFormat("void f() {\n" 13408 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 13409 "}\n"); 13410 verifyFormat("void f() {\n" 13411 " other(x.begin(), //\n" 13412 " x.end(), //\n" 13413 " [&](int, int) { return 1; });\n" 13414 "}\n"); 13415 verifyFormat("void f() {\n" 13416 " other.other.other.other.other(\n" 13417 " x.begin(), x.end(),\n" 13418 " [something, rather](int, int, int, int, int, int, int) { " 13419 "return 1; });\n" 13420 "}\n"); 13421 verifyFormat( 13422 "void f() {\n" 13423 " other.other.other.other.other(\n" 13424 " x.begin(), x.end(),\n" 13425 " [something, rather](int, int, int, int, int, int, int) {\n" 13426 " //\n" 13427 " });\n" 13428 "}\n"); 13429 verifyFormat("SomeFunction([]() { // A cool function...\n" 13430 " return 43;\n" 13431 "});"); 13432 EXPECT_EQ("SomeFunction([]() {\n" 13433 "#define A a\n" 13434 " return 43;\n" 13435 "});", 13436 format("SomeFunction([](){\n" 13437 "#define A a\n" 13438 "return 43;\n" 13439 "});")); 13440 verifyFormat("void f() {\n" 13441 " SomeFunction([](decltype(x), A *a) {});\n" 13442 "}"); 13443 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13444 " [](const aaaaaaaaaa &a) { return a; });"); 13445 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 13446 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 13447 "});"); 13448 verifyFormat("Constructor()\n" 13449 " : Field([] { // comment\n" 13450 " int i;\n" 13451 " }) {}"); 13452 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 13453 " return some_parameter.size();\n" 13454 "};"); 13455 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 13456 " [](const string &s) { return s; };"); 13457 verifyFormat("int i = aaaaaa ? 1 //\n" 13458 " : [] {\n" 13459 " return 2; //\n" 13460 " }();"); 13461 verifyFormat("llvm::errs() << \"number of twos is \"\n" 13462 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 13463 " return x == 2; // force break\n" 13464 " });"); 13465 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13466 " [=](int iiiiiiiiiiii) {\n" 13467 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 13468 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 13469 " });", 13470 getLLVMStyleWithColumns(60)); 13471 verifyFormat("SomeFunction({[&] {\n" 13472 " // comment\n" 13473 " },\n" 13474 " [&] {\n" 13475 " // comment\n" 13476 " }});"); 13477 verifyFormat("SomeFunction({[&] {\n" 13478 " // comment\n" 13479 "}});"); 13480 verifyFormat( 13481 "virtual aaaaaaaaaaaaaaaa(\n" 13482 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 13483 " aaaaa aaaaaaaaa);"); 13484 13485 // Lambdas with return types. 13486 verifyFormat("int c = []() -> int { return 2; }();\n"); 13487 verifyFormat("int c = []() -> int * { return 2; }();\n"); 13488 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 13489 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 13490 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 13491 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 13492 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 13493 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 13494 verifyFormat("[a, a]() -> a<1> {};"); 13495 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 13496 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 13497 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 13498 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 13499 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 13500 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 13501 verifyFormat("[]() -> foo<!5> { return {}; };"); 13502 verifyFormat("[]() -> foo<~5> { return {}; };"); 13503 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 13504 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 13505 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 13506 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 13507 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 13508 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 13509 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 13510 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 13511 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 13512 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 13513 verifyFormat("namespace bar {\n" 13514 "// broken:\n" 13515 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 13516 "} // namespace bar"); 13517 verifyFormat("namespace bar {\n" 13518 "// broken:\n" 13519 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 13520 "} // namespace bar"); 13521 verifyFormat("namespace bar {\n" 13522 "// broken:\n" 13523 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 13524 "} // namespace bar"); 13525 verifyFormat("namespace bar {\n" 13526 "// broken:\n" 13527 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 13528 "} // namespace bar"); 13529 verifyFormat("namespace bar {\n" 13530 "// broken:\n" 13531 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 13532 "} // namespace bar"); 13533 verifyFormat("namespace bar {\n" 13534 "// broken:\n" 13535 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 13536 "} // namespace bar"); 13537 verifyFormat("namespace bar {\n" 13538 "// broken:\n" 13539 "auto foo{[]() -> foo<!5> { return {}; }};\n" 13540 "} // namespace bar"); 13541 verifyFormat("namespace bar {\n" 13542 "// broken:\n" 13543 "auto foo{[]() -> foo<~5> { return {}; }};\n" 13544 "} // namespace bar"); 13545 verifyFormat("namespace bar {\n" 13546 "// broken:\n" 13547 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 13548 "} // namespace bar"); 13549 verifyFormat("namespace bar {\n" 13550 "// broken:\n" 13551 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 13552 "} // namespace bar"); 13553 verifyFormat("namespace bar {\n" 13554 "// broken:\n" 13555 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 13556 "} // namespace bar"); 13557 verifyFormat("namespace bar {\n" 13558 "// broken:\n" 13559 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 13560 "} // namespace bar"); 13561 verifyFormat("namespace bar {\n" 13562 "// broken:\n" 13563 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 13564 "} // namespace bar"); 13565 verifyFormat("namespace bar {\n" 13566 "// broken:\n" 13567 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 13568 "} // namespace bar"); 13569 verifyFormat("namespace bar {\n" 13570 "// broken:\n" 13571 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 13572 "} // namespace bar"); 13573 verifyFormat("namespace bar {\n" 13574 "// broken:\n" 13575 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 13576 "} // namespace bar"); 13577 verifyFormat("namespace bar {\n" 13578 "// broken:\n" 13579 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 13580 "} // namespace bar"); 13581 verifyFormat("namespace bar {\n" 13582 "// broken:\n" 13583 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 13584 "} // namespace bar"); 13585 verifyFormat("[]() -> a<1> {};"); 13586 verifyFormat("[]() -> a<1> { ; };"); 13587 verifyFormat("[]() -> a<1> { ; }();"); 13588 verifyFormat("[a, a]() -> a<true> {};"); 13589 verifyFormat("[]() -> a<true> {};"); 13590 verifyFormat("[]() -> a<true> { ; };"); 13591 verifyFormat("[]() -> a<true> { ; }();"); 13592 verifyFormat("[a, a]() -> a<false> {};"); 13593 verifyFormat("[]() -> a<false> {};"); 13594 verifyFormat("[]() -> a<false> { ; };"); 13595 verifyFormat("[]() -> a<false> { ; }();"); 13596 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 13597 verifyFormat("namespace bar {\n" 13598 "auto foo{[]() -> foo<false> { ; }};\n" 13599 "} // namespace bar"); 13600 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 13601 " int j) -> int {\n" 13602 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 13603 "};"); 13604 verifyFormat( 13605 "aaaaaaaaaaaaaaaaaaaaaa(\n" 13606 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 13607 " return aaaaaaaaaaaaaaaaa;\n" 13608 " });", 13609 getLLVMStyleWithColumns(70)); 13610 verifyFormat("[]() //\n" 13611 " -> int {\n" 13612 " return 1; //\n" 13613 "};"); 13614 13615 // Lambdas with explicit template argument lists. 13616 verifyFormat( 13617 "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n"); 13618 13619 // Multiple lambdas in the same parentheses change indentation rules. These 13620 // lambdas are forced to start on new lines. 13621 verifyFormat("SomeFunction(\n" 13622 " []() {\n" 13623 " //\n" 13624 " },\n" 13625 " []() {\n" 13626 " //\n" 13627 " });"); 13628 13629 // A lambda passed as arg0 is always pushed to the next line. 13630 verifyFormat("SomeFunction(\n" 13631 " [this] {\n" 13632 " //\n" 13633 " },\n" 13634 " 1);\n"); 13635 13636 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like 13637 // the arg0 case above. 13638 auto Style = getGoogleStyle(); 13639 Style.BinPackArguments = false; 13640 verifyFormat("SomeFunction(\n" 13641 " a,\n" 13642 " [this] {\n" 13643 " //\n" 13644 " },\n" 13645 " b);\n", 13646 Style); 13647 verifyFormat("SomeFunction(\n" 13648 " a,\n" 13649 " [this] {\n" 13650 " //\n" 13651 " },\n" 13652 " b);\n"); 13653 13654 // A lambda with a very long line forces arg0 to be pushed out irrespective of 13655 // the BinPackArguments value (as long as the code is wide enough). 13656 verifyFormat( 13657 "something->SomeFunction(\n" 13658 " a,\n" 13659 " [this] {\n" 13660 " " 13661 "D0000000000000000000000000000000000000000000000000000000000001();\n" 13662 " },\n" 13663 " b);\n"); 13664 13665 // A multi-line lambda is pulled up as long as the introducer fits on the 13666 // previous line and there are no further args. 13667 verifyFormat("function(1, [this, that] {\n" 13668 " //\n" 13669 "});\n"); 13670 verifyFormat("function([this, that] {\n" 13671 " //\n" 13672 "});\n"); 13673 // FIXME: this format is not ideal and we should consider forcing the first 13674 // arg onto its own line. 13675 verifyFormat("function(a, b, c, //\n" 13676 " d, [this, that] {\n" 13677 " //\n" 13678 " });\n"); 13679 13680 // Multiple lambdas are treated correctly even when there is a short arg0. 13681 verifyFormat("SomeFunction(\n" 13682 " 1,\n" 13683 " [this] {\n" 13684 " //\n" 13685 " },\n" 13686 " [this] {\n" 13687 " //\n" 13688 " },\n" 13689 " 1);\n"); 13690 13691 // More complex introducers. 13692 verifyFormat("return [i, args...] {};"); 13693 13694 // Not lambdas. 13695 verifyFormat("constexpr char hello[]{\"hello\"};"); 13696 verifyFormat("double &operator[](int i) { return 0; }\n" 13697 "int i;"); 13698 verifyFormat("std::unique_ptr<int[]> foo() {}"); 13699 verifyFormat("int i = a[a][a]->f();"); 13700 verifyFormat("int i = (*b)[a]->f();"); 13701 13702 // Other corner cases. 13703 verifyFormat("void f() {\n" 13704 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 13705 " );\n" 13706 "}"); 13707 13708 // Lambdas created through weird macros. 13709 verifyFormat("void f() {\n" 13710 " MACRO((const AA &a) { return 1; });\n" 13711 " MACRO((AA &a) { return 1; });\n" 13712 "}"); 13713 13714 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 13715 " doo_dah();\n" 13716 " doo_dah();\n" 13717 " })) {\n" 13718 "}"); 13719 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 13720 " doo_dah();\n" 13721 " doo_dah();\n" 13722 " })) {\n" 13723 "}"); 13724 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n" 13725 " doo_dah();\n" 13726 " doo_dah();\n" 13727 " })) {\n" 13728 "}"); 13729 verifyFormat("auto lambda = []() {\n" 13730 " int a = 2\n" 13731 "#if A\n" 13732 " + 2\n" 13733 "#endif\n" 13734 " ;\n" 13735 "};"); 13736 13737 // Lambdas with complex multiline introducers. 13738 verifyFormat( 13739 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13740 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 13741 " -> ::std::unordered_set<\n" 13742 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 13743 " //\n" 13744 " });"); 13745 13746 FormatStyle DoNotMerge = getLLVMStyle(); 13747 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 13748 verifyFormat("auto c = []() {\n" 13749 " return b;\n" 13750 "};", 13751 "auto c = []() { return b; };", DoNotMerge); 13752 verifyFormat("auto c = []() {\n" 13753 "};", 13754 " auto c = []() {};", DoNotMerge); 13755 13756 FormatStyle MergeEmptyOnly = getLLVMStyle(); 13757 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 13758 verifyFormat("auto c = []() {\n" 13759 " return b;\n" 13760 "};", 13761 "auto c = []() {\n" 13762 " return b;\n" 13763 " };", 13764 MergeEmptyOnly); 13765 verifyFormat("auto c = []() {};", 13766 "auto c = []() {\n" 13767 "};", 13768 MergeEmptyOnly); 13769 13770 FormatStyle MergeInline = getLLVMStyle(); 13771 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 13772 verifyFormat("auto c = []() {\n" 13773 " return b;\n" 13774 "};", 13775 "auto c = []() { return b; };", MergeInline); 13776 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 13777 MergeInline); 13778 verifyFormat("function([]() { return b; }, a)", 13779 "function([]() { return b; }, a)", MergeInline); 13780 verifyFormat("function(a, []() { return b; })", 13781 "function(a, []() { return b; })", MergeInline); 13782 } 13783 13784 TEST_F(FormatTest, EmptyLinesInLambdas) { 13785 verifyFormat("auto lambda = []() {\n" 13786 " x(); //\n" 13787 "};", 13788 "auto lambda = []() {\n" 13789 "\n" 13790 " x(); //\n" 13791 "\n" 13792 "};"); 13793 } 13794 13795 TEST_F(FormatTest, FormatsBlocks) { 13796 FormatStyle ShortBlocks = getLLVMStyle(); 13797 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13798 verifyFormat("int (^Block)(int, int);", ShortBlocks); 13799 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 13800 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 13801 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 13802 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 13803 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 13804 13805 verifyFormat("foo(^{ bar(); });", ShortBlocks); 13806 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 13807 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 13808 13809 verifyFormat("[operation setCompletionBlock:^{\n" 13810 " [self onOperationDone];\n" 13811 "}];"); 13812 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 13813 " [self onOperationDone];\n" 13814 "}]};"); 13815 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 13816 " f();\n" 13817 "}];"); 13818 verifyFormat("int a = [operation block:^int(int *i) {\n" 13819 " return 1;\n" 13820 "}];"); 13821 verifyFormat("[myObject doSomethingWith:arg1\n" 13822 " aaa:^int(int *a) {\n" 13823 " return 1;\n" 13824 " }\n" 13825 " bbb:f(a * bbbbbbbb)];"); 13826 13827 verifyFormat("[operation setCompletionBlock:^{\n" 13828 " [self.delegate newDataAvailable];\n" 13829 "}];", 13830 getLLVMStyleWithColumns(60)); 13831 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 13832 " NSString *path = [self sessionFilePath];\n" 13833 " if (path) {\n" 13834 " // ...\n" 13835 " }\n" 13836 "});"); 13837 verifyFormat("[[SessionService sharedService]\n" 13838 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13839 " if (window) {\n" 13840 " [self windowDidLoad:window];\n" 13841 " } else {\n" 13842 " [self errorLoadingWindow];\n" 13843 " }\n" 13844 " }];"); 13845 verifyFormat("void (^largeBlock)(void) = ^{\n" 13846 " // ...\n" 13847 "};\n", 13848 getLLVMStyleWithColumns(40)); 13849 verifyFormat("[[SessionService sharedService]\n" 13850 " loadWindowWithCompletionBlock: //\n" 13851 " ^(SessionWindow *window) {\n" 13852 " if (window) {\n" 13853 " [self windowDidLoad:window];\n" 13854 " } else {\n" 13855 " [self errorLoadingWindow];\n" 13856 " }\n" 13857 " }];", 13858 getLLVMStyleWithColumns(60)); 13859 verifyFormat("[myObject doSomethingWith:arg1\n" 13860 " firstBlock:^(Foo *a) {\n" 13861 " // ...\n" 13862 " int i;\n" 13863 " }\n" 13864 " secondBlock:^(Bar *b) {\n" 13865 " // ...\n" 13866 " int i;\n" 13867 " }\n" 13868 " thirdBlock:^Foo(Bar *b) {\n" 13869 " // ...\n" 13870 " int i;\n" 13871 " }];"); 13872 verifyFormat("[myObject doSomethingWith:arg1\n" 13873 " firstBlock:-1\n" 13874 " secondBlock:^(Bar *b) {\n" 13875 " // ...\n" 13876 " int i;\n" 13877 " }];"); 13878 13879 verifyFormat("f(^{\n" 13880 " @autoreleasepool {\n" 13881 " if (a) {\n" 13882 " g();\n" 13883 " }\n" 13884 " }\n" 13885 "});"); 13886 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 13887 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 13888 "};"); 13889 13890 FormatStyle FourIndent = getLLVMStyle(); 13891 FourIndent.ObjCBlockIndentWidth = 4; 13892 verifyFormat("[operation setCompletionBlock:^{\n" 13893 " [self onOperationDone];\n" 13894 "}];", 13895 FourIndent); 13896 } 13897 13898 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 13899 FormatStyle ZeroColumn = getLLVMStyle(); 13900 ZeroColumn.ColumnLimit = 0; 13901 13902 verifyFormat("[[SessionService sharedService] " 13903 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13904 " if (window) {\n" 13905 " [self windowDidLoad:window];\n" 13906 " } else {\n" 13907 " [self errorLoadingWindow];\n" 13908 " }\n" 13909 "}];", 13910 ZeroColumn); 13911 EXPECT_EQ("[[SessionService sharedService]\n" 13912 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13913 " if (window) {\n" 13914 " [self windowDidLoad:window];\n" 13915 " } else {\n" 13916 " [self errorLoadingWindow];\n" 13917 " }\n" 13918 " }];", 13919 format("[[SessionService sharedService]\n" 13920 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13921 " if (window) {\n" 13922 " [self windowDidLoad:window];\n" 13923 " } else {\n" 13924 " [self errorLoadingWindow];\n" 13925 " }\n" 13926 "}];", 13927 ZeroColumn)); 13928 verifyFormat("[myObject doSomethingWith:arg1\n" 13929 " firstBlock:^(Foo *a) {\n" 13930 " // ...\n" 13931 " int i;\n" 13932 " }\n" 13933 " secondBlock:^(Bar *b) {\n" 13934 " // ...\n" 13935 " int i;\n" 13936 " }\n" 13937 " thirdBlock:^Foo(Bar *b) {\n" 13938 " // ...\n" 13939 " int i;\n" 13940 " }];", 13941 ZeroColumn); 13942 verifyFormat("f(^{\n" 13943 " @autoreleasepool {\n" 13944 " if (a) {\n" 13945 " g();\n" 13946 " }\n" 13947 " }\n" 13948 "});", 13949 ZeroColumn); 13950 verifyFormat("void (^largeBlock)(void) = ^{\n" 13951 " // ...\n" 13952 "};", 13953 ZeroColumn); 13954 13955 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13956 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 13957 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 13958 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 13959 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 13960 " int i;\n" 13961 "};", 13962 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 13963 } 13964 13965 TEST_F(FormatTest, SupportsCRLF) { 13966 EXPECT_EQ("int a;\r\n" 13967 "int b;\r\n" 13968 "int c;\r\n", 13969 format("int a;\r\n" 13970 " int b;\r\n" 13971 " int c;\r\n", 13972 getLLVMStyle())); 13973 EXPECT_EQ("int a;\r\n" 13974 "int b;\r\n" 13975 "int c;\r\n", 13976 format("int a;\r\n" 13977 " int b;\n" 13978 " int c;\r\n", 13979 getLLVMStyle())); 13980 EXPECT_EQ("int a;\n" 13981 "int b;\n" 13982 "int c;\n", 13983 format("int a;\r\n" 13984 " int b;\n" 13985 " int c;\n", 13986 getLLVMStyle())); 13987 EXPECT_EQ("\"aaaaaaa \"\r\n" 13988 "\"bbbbbbb\";\r\n", 13989 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 13990 EXPECT_EQ("#define A \\\r\n" 13991 " b; \\\r\n" 13992 " c; \\\r\n" 13993 " d;\r\n", 13994 format("#define A \\\r\n" 13995 " b; \\\r\n" 13996 " c; d; \r\n", 13997 getGoogleStyle())); 13998 13999 EXPECT_EQ("/*\r\n" 14000 "multi line block comments\r\n" 14001 "should not introduce\r\n" 14002 "an extra carriage return\r\n" 14003 "*/\r\n", 14004 format("/*\r\n" 14005 "multi line block comments\r\n" 14006 "should not introduce\r\n" 14007 "an extra carriage return\r\n" 14008 "*/\r\n")); 14009 EXPECT_EQ("/*\r\n" 14010 "\r\n" 14011 "*/", 14012 format("/*\r\n" 14013 " \r\r\r\n" 14014 "*/")); 14015 } 14016 14017 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 14018 verifyFormat("MY_CLASS(C) {\n" 14019 " int i;\n" 14020 " int j;\n" 14021 "};"); 14022 } 14023 14024 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 14025 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 14026 TwoIndent.ContinuationIndentWidth = 2; 14027 14028 EXPECT_EQ("int i =\n" 14029 " longFunction(\n" 14030 " arg);", 14031 format("int i = longFunction(arg);", TwoIndent)); 14032 14033 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 14034 SixIndent.ContinuationIndentWidth = 6; 14035 14036 EXPECT_EQ("int i =\n" 14037 " longFunction(\n" 14038 " arg);", 14039 format("int i = longFunction(arg);", SixIndent)); 14040 } 14041 14042 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 14043 FormatStyle Style = getLLVMStyle(); 14044 verifyFormat("int Foo::getter(\n" 14045 " //\n" 14046 ") const {\n" 14047 " return foo;\n" 14048 "}", 14049 Style); 14050 verifyFormat("void Foo::setter(\n" 14051 " //\n" 14052 ") {\n" 14053 " foo = 1;\n" 14054 "}", 14055 Style); 14056 } 14057 14058 TEST_F(FormatTest, SpacesInAngles) { 14059 FormatStyle Spaces = getLLVMStyle(); 14060 Spaces.SpacesInAngles = true; 14061 14062 verifyFormat("static_cast< int >(arg);", Spaces); 14063 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 14064 verifyFormat("f< int, float >();", Spaces); 14065 verifyFormat("template <> g() {}", Spaces); 14066 verifyFormat("template < std::vector< int > > f() {}", Spaces); 14067 verifyFormat("std::function< void(int, int) > fct;", Spaces); 14068 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 14069 Spaces); 14070 14071 Spaces.Standard = FormatStyle::LS_Cpp03; 14072 Spaces.SpacesInAngles = true; 14073 verifyFormat("A< A< int > >();", Spaces); 14074 14075 Spaces.SpacesInAngles = false; 14076 verifyFormat("A<A<int> >();", Spaces); 14077 14078 Spaces.Standard = FormatStyle::LS_Cpp11; 14079 Spaces.SpacesInAngles = true; 14080 verifyFormat("A< A< int > >();", Spaces); 14081 14082 Spaces.SpacesInAngles = false; 14083 verifyFormat("A<A<int>>();", Spaces); 14084 } 14085 14086 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 14087 FormatStyle Style = getLLVMStyle(); 14088 Style.SpaceAfterTemplateKeyword = false; 14089 verifyFormat("template<int> void foo();", Style); 14090 } 14091 14092 TEST_F(FormatTest, TripleAngleBrackets) { 14093 verifyFormat("f<<<1, 1>>>();"); 14094 verifyFormat("f<<<1, 1, 1, s>>>();"); 14095 verifyFormat("f<<<a, b, c, d>>>();"); 14096 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 14097 verifyFormat("f<param><<<1, 1>>>();"); 14098 verifyFormat("f<1><<<1, 1>>>();"); 14099 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 14100 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14101 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 14102 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 14103 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 14104 } 14105 14106 TEST_F(FormatTest, MergeLessLessAtEnd) { 14107 verifyFormat("<<"); 14108 EXPECT_EQ("< < <", format("\\\n<<<")); 14109 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14110 "aaallvm::outs() <<"); 14111 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14112 "aaaallvm::outs()\n <<"); 14113 } 14114 14115 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 14116 std::string code = "#if A\n" 14117 "#if B\n" 14118 "a.\n" 14119 "#endif\n" 14120 " a = 1;\n" 14121 "#else\n" 14122 "#endif\n" 14123 "#if C\n" 14124 "#else\n" 14125 "#endif\n"; 14126 EXPECT_EQ(code, format(code)); 14127 } 14128 14129 TEST_F(FormatTest, HandleConflictMarkers) { 14130 // Git/SVN conflict markers. 14131 EXPECT_EQ("int a;\n" 14132 "void f() {\n" 14133 " callme(some(parameter1,\n" 14134 "<<<<<<< text by the vcs\n" 14135 " parameter2),\n" 14136 "||||||| text by the vcs\n" 14137 " parameter2),\n" 14138 " parameter3,\n" 14139 "======= text by the vcs\n" 14140 " parameter2, parameter3),\n" 14141 ">>>>>>> text by the vcs\n" 14142 " otherparameter);\n", 14143 format("int a;\n" 14144 "void f() {\n" 14145 " callme(some(parameter1,\n" 14146 "<<<<<<< text by the vcs\n" 14147 " parameter2),\n" 14148 "||||||| text by the vcs\n" 14149 " parameter2),\n" 14150 " parameter3,\n" 14151 "======= text by the vcs\n" 14152 " parameter2,\n" 14153 " parameter3),\n" 14154 ">>>>>>> text by the vcs\n" 14155 " otherparameter);\n")); 14156 14157 // Perforce markers. 14158 EXPECT_EQ("void f() {\n" 14159 " function(\n" 14160 ">>>> text by the vcs\n" 14161 " parameter,\n" 14162 "==== text by the vcs\n" 14163 " parameter,\n" 14164 "==== text by the vcs\n" 14165 " parameter,\n" 14166 "<<<< text by the vcs\n" 14167 " parameter);\n", 14168 format("void f() {\n" 14169 " function(\n" 14170 ">>>> text by the vcs\n" 14171 " parameter,\n" 14172 "==== text by the vcs\n" 14173 " parameter,\n" 14174 "==== text by the vcs\n" 14175 " parameter,\n" 14176 "<<<< text by the vcs\n" 14177 " parameter);\n")); 14178 14179 EXPECT_EQ("<<<<<<<\n" 14180 "|||||||\n" 14181 "=======\n" 14182 ">>>>>>>", 14183 format("<<<<<<<\n" 14184 "|||||||\n" 14185 "=======\n" 14186 ">>>>>>>")); 14187 14188 EXPECT_EQ("<<<<<<<\n" 14189 "|||||||\n" 14190 "int i;\n" 14191 "=======\n" 14192 ">>>>>>>", 14193 format("<<<<<<<\n" 14194 "|||||||\n" 14195 "int i;\n" 14196 "=======\n" 14197 ">>>>>>>")); 14198 14199 // FIXME: Handle parsing of macros around conflict markers correctly: 14200 EXPECT_EQ("#define Macro \\\n" 14201 "<<<<<<<\n" 14202 "Something \\\n" 14203 "|||||||\n" 14204 "Else \\\n" 14205 "=======\n" 14206 "Other \\\n" 14207 ">>>>>>>\n" 14208 " End int i;\n", 14209 format("#define Macro \\\n" 14210 "<<<<<<<\n" 14211 " Something \\\n" 14212 "|||||||\n" 14213 " Else \\\n" 14214 "=======\n" 14215 " Other \\\n" 14216 ">>>>>>>\n" 14217 " End\n" 14218 "int i;\n")); 14219 } 14220 14221 TEST_F(FormatTest, DisableRegions) { 14222 EXPECT_EQ("int i;\n" 14223 "// clang-format off\n" 14224 " int j;\n" 14225 "// clang-format on\n" 14226 "int k;", 14227 format(" int i;\n" 14228 " // clang-format off\n" 14229 " int j;\n" 14230 " // clang-format on\n" 14231 " int k;")); 14232 EXPECT_EQ("int i;\n" 14233 "/* clang-format off */\n" 14234 " int j;\n" 14235 "/* clang-format on */\n" 14236 "int k;", 14237 format(" int i;\n" 14238 " /* clang-format off */\n" 14239 " int j;\n" 14240 " /* clang-format on */\n" 14241 " int k;")); 14242 14243 // Don't reflow comments within disabled regions. 14244 EXPECT_EQ("// clang-format off\n" 14245 "// long long long long long long line\n" 14246 "/* clang-format on */\n" 14247 "/* long long long\n" 14248 " * long long long\n" 14249 " * line */\n" 14250 "int i;\n" 14251 "/* clang-format off */\n" 14252 "/* long long long long long long line */\n", 14253 format("// clang-format off\n" 14254 "// long long long long long long line\n" 14255 "/* clang-format on */\n" 14256 "/* long long long long long long line */\n" 14257 "int i;\n" 14258 "/* clang-format off */\n" 14259 "/* long long long long long long line */\n", 14260 getLLVMStyleWithColumns(20))); 14261 } 14262 14263 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 14264 format("? ) ="); 14265 verifyNoCrash("#define a\\\n /**/}"); 14266 } 14267 14268 TEST_F(FormatTest, FormatsTableGenCode) { 14269 FormatStyle Style = getLLVMStyle(); 14270 Style.Language = FormatStyle::LK_TableGen; 14271 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 14272 } 14273 14274 TEST_F(FormatTest, ArrayOfTemplates) { 14275 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 14276 format("auto a = new unique_ptr<int > [ 10];")); 14277 14278 FormatStyle Spaces = getLLVMStyle(); 14279 Spaces.SpacesInSquareBrackets = true; 14280 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 14281 format("auto a = new unique_ptr<int > [10];", Spaces)); 14282 } 14283 14284 TEST_F(FormatTest, ArrayAsTemplateType) { 14285 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 14286 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 14287 14288 FormatStyle Spaces = getLLVMStyle(); 14289 Spaces.SpacesInSquareBrackets = true; 14290 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 14291 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 14292 } 14293 14294 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); } 14295 14296 TEST(FormatStyle, GetStyleWithEmptyFileName) { 14297 llvm::vfs::InMemoryFileSystem FS; 14298 auto Style1 = getStyle("file", "", "Google", "", &FS); 14299 ASSERT_TRUE((bool)Style1); 14300 ASSERT_EQ(*Style1, getGoogleStyle()); 14301 } 14302 14303 TEST(FormatStyle, GetStyleOfFile) { 14304 llvm::vfs::InMemoryFileSystem FS; 14305 // Test 1: format file in the same directory. 14306 ASSERT_TRUE( 14307 FS.addFile("/a/.clang-format", 0, 14308 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 14309 ASSERT_TRUE( 14310 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14311 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 14312 ASSERT_TRUE((bool)Style1); 14313 ASSERT_EQ(*Style1, getLLVMStyle()); 14314 14315 // Test 2.1: fallback to default. 14316 ASSERT_TRUE( 14317 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14318 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 14319 ASSERT_TRUE((bool)Style2); 14320 ASSERT_EQ(*Style2, getMozillaStyle()); 14321 14322 // Test 2.2: no format on 'none' fallback style. 14323 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 14324 ASSERT_TRUE((bool)Style2); 14325 ASSERT_EQ(*Style2, getNoStyle()); 14326 14327 // Test 2.3: format if config is found with no based style while fallback is 14328 // 'none'. 14329 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 14330 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 14331 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 14332 ASSERT_TRUE((bool)Style2); 14333 ASSERT_EQ(*Style2, getLLVMStyle()); 14334 14335 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 14336 Style2 = getStyle("{}", "a.h", "none", "", &FS); 14337 ASSERT_TRUE((bool)Style2); 14338 ASSERT_EQ(*Style2, getLLVMStyle()); 14339 14340 // Test 3: format file in parent directory. 14341 ASSERT_TRUE( 14342 FS.addFile("/c/.clang-format", 0, 14343 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 14344 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 14345 llvm::MemoryBuffer::getMemBuffer("int i;"))); 14346 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 14347 ASSERT_TRUE((bool)Style3); 14348 ASSERT_EQ(*Style3, getGoogleStyle()); 14349 14350 // Test 4: error on invalid fallback style 14351 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 14352 ASSERT_FALSE((bool)Style4); 14353 llvm::consumeError(Style4.takeError()); 14354 14355 // Test 5: error on invalid yaml on command line 14356 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 14357 ASSERT_FALSE((bool)Style5); 14358 llvm::consumeError(Style5.takeError()); 14359 14360 // Test 6: error on invalid style 14361 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 14362 ASSERT_FALSE((bool)Style6); 14363 llvm::consumeError(Style6.takeError()); 14364 14365 // Test 7: found config file, error on parsing it 14366 ASSERT_TRUE( 14367 FS.addFile("/d/.clang-format", 0, 14368 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 14369 "InvalidKey: InvalidValue"))); 14370 ASSERT_TRUE( 14371 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14372 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 14373 ASSERT_FALSE((bool)Style7); 14374 llvm::consumeError(Style7.takeError()); 14375 14376 // Test 8: inferred per-language defaults apply. 14377 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 14378 ASSERT_TRUE((bool)StyleTd); 14379 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 14380 } 14381 14382 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 14383 // Column limit is 20. 14384 std::string Code = "Type *a =\n" 14385 " new Type();\n" 14386 "g(iiiii, 0, jjjjj,\n" 14387 " 0, kkkkk, 0, mm);\n" 14388 "int bad = format ;"; 14389 std::string Expected = "auto a = new Type();\n" 14390 "g(iiiii, nullptr,\n" 14391 " jjjjj, nullptr,\n" 14392 " kkkkk, nullptr,\n" 14393 " mm);\n" 14394 "int bad = format ;"; 14395 FileID ID = Context.createInMemoryFile("format.cpp", Code); 14396 tooling::Replacements Replaces = toReplacements( 14397 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 14398 "auto "), 14399 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 14400 "nullptr"), 14401 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 14402 "nullptr"), 14403 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 14404 "nullptr")}); 14405 14406 format::FormatStyle Style = format::getLLVMStyle(); 14407 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 14408 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 14409 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 14410 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 14411 auto Result = applyAllReplacements(Code, *FormattedReplaces); 14412 EXPECT_TRUE(static_cast<bool>(Result)); 14413 EXPECT_EQ(Expected, *Result); 14414 } 14415 14416 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 14417 std::string Code = "#include \"a.h\"\n" 14418 "#include \"c.h\"\n" 14419 "\n" 14420 "int main() {\n" 14421 " return 0;\n" 14422 "}"; 14423 std::string Expected = "#include \"a.h\"\n" 14424 "#include \"b.h\"\n" 14425 "#include \"c.h\"\n" 14426 "\n" 14427 "int main() {\n" 14428 " return 0;\n" 14429 "}"; 14430 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 14431 tooling::Replacements Replaces = toReplacements( 14432 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 14433 "#include \"b.h\"\n")}); 14434 14435 format::FormatStyle Style = format::getLLVMStyle(); 14436 Style.SortIncludes = true; 14437 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 14438 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 14439 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 14440 auto Result = applyAllReplacements(Code, *FormattedReplaces); 14441 EXPECT_TRUE(static_cast<bool>(Result)); 14442 EXPECT_EQ(Expected, *Result); 14443 } 14444 14445 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 14446 EXPECT_EQ("using std::cin;\n" 14447 "using std::cout;", 14448 format("using std::cout;\n" 14449 "using std::cin;", 14450 getGoogleStyle())); 14451 } 14452 14453 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 14454 format::FormatStyle Style = format::getLLVMStyle(); 14455 Style.Standard = FormatStyle::LS_Cpp03; 14456 // cpp03 recognize this string as identifier u8 and literal character 'a' 14457 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 14458 } 14459 14460 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 14461 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 14462 // all modes, including C++11, C++14 and C++17 14463 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 14464 } 14465 14466 TEST_F(FormatTest, DoNotFormatLikelyXml) { 14467 EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle())); 14468 EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle())); 14469 } 14470 14471 TEST_F(FormatTest, StructuredBindings) { 14472 // Structured bindings is a C++17 feature. 14473 // all modes, including C++11, C++14 and C++17 14474 verifyFormat("auto [a, b] = f();"); 14475 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 14476 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 14477 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 14478 EXPECT_EQ("auto const volatile [a, b] = f();", 14479 format("auto const volatile[a, b] = f();")); 14480 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 14481 EXPECT_EQ("auto &[a, b, c] = f();", 14482 format("auto &[ a , b,c ] = f();")); 14483 EXPECT_EQ("auto &&[a, b, c] = f();", 14484 format("auto &&[ a , b,c ] = f();")); 14485 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 14486 EXPECT_EQ("auto const volatile &&[a, b] = f();", 14487 format("auto const volatile &&[a, b] = f();")); 14488 EXPECT_EQ("auto const &&[a, b] = f();", 14489 format("auto const && [a, b] = f();")); 14490 EXPECT_EQ("const auto &[a, b] = f();", 14491 format("const auto & [a, b] = f();")); 14492 EXPECT_EQ("const auto volatile &&[a, b] = f();", 14493 format("const auto volatile &&[a, b] = f();")); 14494 EXPECT_EQ("volatile const auto &&[a, b] = f();", 14495 format("volatile const auto &&[a, b] = f();")); 14496 EXPECT_EQ("const auto &&[a, b] = f();", 14497 format("const auto && [a, b] = f();")); 14498 14499 // Make sure we don't mistake structured bindings for lambdas. 14500 FormatStyle PointerMiddle = getLLVMStyle(); 14501 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 14502 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 14503 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 14504 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 14505 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 14506 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 14507 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 14508 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 14509 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 14510 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 14511 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 14512 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 14513 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 14514 14515 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 14516 format("for (const auto && [a, b] : some_range) {\n}")); 14517 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 14518 format("for (const auto & [a, b] : some_range) {\n}")); 14519 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 14520 format("for (const auto[a, b] : some_range) {\n}")); 14521 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 14522 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 14523 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 14524 EXPECT_EQ("auto const &[x, y](expr);", 14525 format("auto const & [x,y] (expr);")); 14526 EXPECT_EQ("auto const &&[x, y](expr);", 14527 format("auto const && [x,y] (expr);")); 14528 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 14529 EXPECT_EQ("auto const &[x, y]{expr};", 14530 format("auto const & [x,y] {expr};")); 14531 EXPECT_EQ("auto const &&[x, y]{expr};", 14532 format("auto const && [x,y] {expr};")); 14533 14534 format::FormatStyle Spaces = format::getLLVMStyle(); 14535 Spaces.SpacesInSquareBrackets = true; 14536 verifyFormat("auto [ a, b ] = f();", Spaces); 14537 verifyFormat("auto &&[ a, b ] = f();", Spaces); 14538 verifyFormat("auto &[ a, b ] = f();", Spaces); 14539 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 14540 verifyFormat("auto const &[ a, b ] = f();", Spaces); 14541 } 14542 14543 TEST_F(FormatTest, FileAndCode) { 14544 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 14545 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 14546 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 14547 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 14548 EXPECT_EQ(FormatStyle::LK_ObjC, 14549 guessLanguage("foo.h", "@interface Foo\n@end\n")); 14550 EXPECT_EQ( 14551 FormatStyle::LK_ObjC, 14552 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 14553 EXPECT_EQ(FormatStyle::LK_ObjC, 14554 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 14555 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 14556 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 14557 EXPECT_EQ(FormatStyle::LK_ObjC, 14558 guessLanguage("foo", "@interface Foo\n@end\n")); 14559 EXPECT_EQ(FormatStyle::LK_ObjC, 14560 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 14561 EXPECT_EQ( 14562 FormatStyle::LK_ObjC, 14563 guessLanguage("foo.h", 14564 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 14565 EXPECT_EQ( 14566 FormatStyle::LK_Cpp, 14567 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 14568 } 14569 14570 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 14571 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 14572 EXPECT_EQ(FormatStyle::LK_ObjC, 14573 guessLanguage("foo.h", "array[[calculator getIndex]];")); 14574 EXPECT_EQ(FormatStyle::LK_Cpp, 14575 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 14576 EXPECT_EQ( 14577 FormatStyle::LK_Cpp, 14578 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 14579 EXPECT_EQ(FormatStyle::LK_ObjC, 14580 guessLanguage("foo.h", "[[noreturn foo] bar];")); 14581 EXPECT_EQ(FormatStyle::LK_Cpp, 14582 guessLanguage("foo.h", "[[clang::fallthrough]];")); 14583 EXPECT_EQ(FormatStyle::LK_ObjC, 14584 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 14585 EXPECT_EQ(FormatStyle::LK_Cpp, 14586 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 14587 EXPECT_EQ(FormatStyle::LK_Cpp, 14588 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 14589 EXPECT_EQ(FormatStyle::LK_ObjC, 14590 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 14591 EXPECT_EQ(FormatStyle::LK_Cpp, 14592 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 14593 EXPECT_EQ( 14594 FormatStyle::LK_Cpp, 14595 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 14596 EXPECT_EQ( 14597 FormatStyle::LK_Cpp, 14598 guessLanguage("foo.h", 14599 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 14600 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 14601 } 14602 14603 TEST_F(FormatTest, GuessLanguageWithCaret) { 14604 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 14605 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 14606 EXPECT_EQ(FormatStyle::LK_ObjC, 14607 guessLanguage("foo.h", "int(^)(char, float);")); 14608 EXPECT_EQ(FormatStyle::LK_ObjC, 14609 guessLanguage("foo.h", "int(^foo)(char, float);")); 14610 EXPECT_EQ(FormatStyle::LK_ObjC, 14611 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 14612 EXPECT_EQ(FormatStyle::LK_ObjC, 14613 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 14614 EXPECT_EQ( 14615 FormatStyle::LK_ObjC, 14616 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 14617 } 14618 14619 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 14620 EXPECT_EQ(FormatStyle::LK_Cpp, 14621 guessLanguage("foo.h", "void f() {\n" 14622 " asm (\"mov %[e], %[d]\"\n" 14623 " : [d] \"=rm\" (d)\n" 14624 " [e] \"rm\" (*e));\n" 14625 "}")); 14626 EXPECT_EQ(FormatStyle::LK_Cpp, 14627 guessLanguage("foo.h", "void f() {\n" 14628 " _asm (\"mov %[e], %[d]\"\n" 14629 " : [d] \"=rm\" (d)\n" 14630 " [e] \"rm\" (*e));\n" 14631 "}")); 14632 EXPECT_EQ(FormatStyle::LK_Cpp, 14633 guessLanguage("foo.h", "void f() {\n" 14634 " __asm (\"mov %[e], %[d]\"\n" 14635 " : [d] \"=rm\" (d)\n" 14636 " [e] \"rm\" (*e));\n" 14637 "}")); 14638 EXPECT_EQ(FormatStyle::LK_Cpp, 14639 guessLanguage("foo.h", "void f() {\n" 14640 " __asm__ (\"mov %[e], %[d]\"\n" 14641 " : [d] \"=rm\" (d)\n" 14642 " [e] \"rm\" (*e));\n" 14643 "}")); 14644 EXPECT_EQ(FormatStyle::LK_Cpp, 14645 guessLanguage("foo.h", "void f() {\n" 14646 " asm (\"mov %[e], %[d]\"\n" 14647 " : [d] \"=rm\" (d),\n" 14648 " [e] \"rm\" (*e));\n" 14649 "}")); 14650 EXPECT_EQ(FormatStyle::LK_Cpp, 14651 guessLanguage("foo.h", "void f() {\n" 14652 " asm volatile (\"mov %[e], %[d]\"\n" 14653 " : [d] \"=rm\" (d)\n" 14654 " [e] \"rm\" (*e));\n" 14655 "}")); 14656 } 14657 14658 TEST_F(FormatTest, GuessLanguageWithChildLines) { 14659 EXPECT_EQ(FormatStyle::LK_Cpp, 14660 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 14661 EXPECT_EQ(FormatStyle::LK_ObjC, 14662 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 14663 EXPECT_EQ( 14664 FormatStyle::LK_Cpp, 14665 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 14666 EXPECT_EQ( 14667 FormatStyle::LK_ObjC, 14668 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 14669 } 14670 14671 TEST_F(FormatTest, TypenameMacros) { 14672 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 14673 14674 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 14675 FormatStyle Google = getGoogleStyleWithColumns(0); 14676 Google.TypenameMacros = TypenameMacros; 14677 verifyFormat("struct foo {\n" 14678 " int bar;\n" 14679 " TAILQ_ENTRY(a) bleh;\n" 14680 "};", 14681 Google); 14682 14683 FormatStyle Macros = getLLVMStyle(); 14684 Macros.TypenameMacros = TypenameMacros; 14685 14686 verifyFormat("STACK_OF(int) a;", Macros); 14687 verifyFormat("STACK_OF(int) *a;", Macros); 14688 verifyFormat("STACK_OF(int const *) *a;", Macros); 14689 verifyFormat("STACK_OF(int *const) *a;", Macros); 14690 verifyFormat("STACK_OF(int, string) a;", Macros); 14691 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 14692 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 14693 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 14694 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 14695 14696 Macros.PointerAlignment = FormatStyle::PAS_Left; 14697 verifyFormat("STACK_OF(int)* a;", Macros); 14698 verifyFormat("STACK_OF(int*)* a;", Macros); 14699 } 14700 14701 TEST_F(FormatTest, AmbersandInLamda) { 14702 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899 14703 FormatStyle AlignStyle = getLLVMStyle(); 14704 AlignStyle.PointerAlignment = FormatStyle::PAS_Left; 14705 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 14706 AlignStyle.PointerAlignment = FormatStyle::PAS_Right; 14707 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 14708 } 14709 14710 TEST_F(FormatTest, AlternativeOperators) { 14711 // Test case for ensuring alternate operators are not 14712 // combined with their right most neighbour. 14713 verifyFormat("int a and b;"); 14714 verifyFormat("int a and_eq b;"); 14715 verifyFormat("int a bitand b;"); 14716 verifyFormat("int a bitor b;"); 14717 verifyFormat("int a compl b;"); 14718 verifyFormat("int a not b;"); 14719 verifyFormat("int a not_eq b;"); 14720 verifyFormat("int a or b;"); 14721 verifyFormat("int a xor b;"); 14722 verifyFormat("int a xor_eq b;"); 14723 verifyFormat("return this not_eq bitand other;"); 14724 verifyFormat("bool operator not_eq(const X bitand other)"); 14725 14726 verifyFormat("int a and 5;"); 14727 verifyFormat("int a and_eq 5;"); 14728 verifyFormat("int a bitand 5;"); 14729 verifyFormat("int a bitor 5;"); 14730 verifyFormat("int a compl 5;"); 14731 verifyFormat("int a not 5;"); 14732 verifyFormat("int a not_eq 5;"); 14733 verifyFormat("int a or 5;"); 14734 verifyFormat("int a xor 5;"); 14735 verifyFormat("int a xor_eq 5;"); 14736 14737 verifyFormat("int a compl(5);"); 14738 verifyFormat("int a not(5);"); 14739 14740 /* FIXME handle alternate tokens 14741 * https://en.cppreference.com/w/cpp/language/operator_alternative 14742 // alternative tokens 14743 verifyFormat("compl foo();"); // ~foo(); 14744 verifyFormat("foo() <%%>;"); // foo(); 14745 verifyFormat("void foo() <%%>;"); // void foo(){} 14746 verifyFormat("int a <:1:>;"); // int a[1];[ 14747 verifyFormat("%:define ABC abc"); // #define ABC abc 14748 verifyFormat("%:%:"); // ## 14749 */ 14750 } 14751 14752 TEST_F(FormatTest, STLWhileNotDefineChed) { 14753 verifyFormat("#if defined(while)\n" 14754 "#define while EMIT WARNING C4005\n" 14755 "#endif // while"); 14756 } 14757 14758 } // namespace 14759 } // namespace format 14760 } // namespace clang 14761