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 Style.ColumnLimit = 1569 40; // to concentrate at brace wrapping, not line wrap due to column limit 1570 EXPECT_EQ("try {\n" 1571 " foo();\n" 1572 "} catch (Exception &bar) {\n" 1573 " baz();\n" 1574 "}", 1575 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1576 Style.ColumnLimit = 1577 20; // to concentrate at brace wrapping, not line wrap due to column limit 1578 1579 Style.BraceWrapping.BeforeElse = true; 1580 EXPECT_EQ( 1581 "if (foo) {\n" 1582 " bar();\n" 1583 "}\n" 1584 "else if (baz ||\n" 1585 " quux)\n" 1586 "{\n" 1587 " foobar();\n" 1588 "}\n" 1589 "else {\n" 1590 " barbaz();\n" 1591 "}", 1592 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1593 Style)); 1594 1595 Style.BraceWrapping.BeforeCatch = true; 1596 EXPECT_EQ("try {\n" 1597 " foo();\n" 1598 "}\n" 1599 "catch (...) {\n" 1600 " baz();\n" 1601 "}", 1602 format("try{foo();}catch(...){baz();}", Style)); 1603 } 1604 1605 //===----------------------------------------------------------------------===// 1606 // Tests for classes, namespaces, etc. 1607 //===----------------------------------------------------------------------===// 1608 1609 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1610 verifyFormat("class A {};"); 1611 } 1612 1613 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1614 verifyFormat("class A {\n" 1615 "public:\n" 1616 "public: // comment\n" 1617 "protected:\n" 1618 "private:\n" 1619 " void f() {}\n" 1620 "};"); 1621 verifyFormat("export class A {\n" 1622 "public:\n" 1623 "public: // comment\n" 1624 "protected:\n" 1625 "private:\n" 1626 " void f() {}\n" 1627 "};"); 1628 verifyGoogleFormat("class A {\n" 1629 " public:\n" 1630 " protected:\n" 1631 " private:\n" 1632 " void f() {}\n" 1633 "};"); 1634 verifyGoogleFormat("export class A {\n" 1635 " public:\n" 1636 " protected:\n" 1637 " private:\n" 1638 " void f() {}\n" 1639 "};"); 1640 verifyFormat("class A {\n" 1641 "public slots:\n" 1642 " void f1() {}\n" 1643 "public Q_SLOTS:\n" 1644 " void f2() {}\n" 1645 "protected slots:\n" 1646 " void f3() {}\n" 1647 "protected Q_SLOTS:\n" 1648 " void f4() {}\n" 1649 "private slots:\n" 1650 " void f5() {}\n" 1651 "private Q_SLOTS:\n" 1652 " void f6() {}\n" 1653 "signals:\n" 1654 " void g1();\n" 1655 "Q_SIGNALS:\n" 1656 " void g2();\n" 1657 "};"); 1658 1659 // Don't interpret 'signals' the wrong way. 1660 verifyFormat("signals.set();"); 1661 verifyFormat("for (Signals signals : f()) {\n}"); 1662 verifyFormat("{\n" 1663 " signals.set(); // This needs indentation.\n" 1664 "}"); 1665 verifyFormat("void f() {\n" 1666 "label:\n" 1667 " signals.baz();\n" 1668 "}"); 1669 } 1670 1671 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1672 EXPECT_EQ("class A {\n" 1673 "public:\n" 1674 " void f();\n" 1675 "\n" 1676 "private:\n" 1677 " void g() {}\n" 1678 " // test\n" 1679 "protected:\n" 1680 " int h;\n" 1681 "};", 1682 format("class A {\n" 1683 "public:\n" 1684 "void f();\n" 1685 "private:\n" 1686 "void g() {}\n" 1687 "// test\n" 1688 "protected:\n" 1689 "int h;\n" 1690 "};")); 1691 EXPECT_EQ("class A {\n" 1692 "protected:\n" 1693 "public:\n" 1694 " void f();\n" 1695 "};", 1696 format("class A {\n" 1697 "protected:\n" 1698 "\n" 1699 "public:\n" 1700 "\n" 1701 " void f();\n" 1702 "};")); 1703 1704 // Even ensure proper spacing inside macros. 1705 EXPECT_EQ("#define B \\\n" 1706 " class A { \\\n" 1707 " protected: \\\n" 1708 " public: \\\n" 1709 " void f(); \\\n" 1710 " };", 1711 format("#define B \\\n" 1712 " class A { \\\n" 1713 " protected: \\\n" 1714 " \\\n" 1715 " public: \\\n" 1716 " \\\n" 1717 " void f(); \\\n" 1718 " };", 1719 getGoogleStyle())); 1720 // But don't remove empty lines after macros ending in access specifiers. 1721 EXPECT_EQ("#define A private:\n" 1722 "\n" 1723 "int i;", 1724 format("#define A private:\n" 1725 "\n" 1726 "int i;")); 1727 } 1728 1729 TEST_F(FormatTest, FormatsClasses) { 1730 verifyFormat("class A : public B {};"); 1731 verifyFormat("class A : public ::B {};"); 1732 1733 verifyFormat( 1734 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1735 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1736 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1737 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1738 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1739 verifyFormat( 1740 "class A : public B, public C, public D, public E, public F {};"); 1741 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1742 " public C,\n" 1743 " public D,\n" 1744 " public E,\n" 1745 " public F,\n" 1746 " public G {};"); 1747 1748 verifyFormat("class\n" 1749 " ReallyReallyLongClassName {\n" 1750 " int i;\n" 1751 "};", 1752 getLLVMStyleWithColumns(32)); 1753 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1754 " aaaaaaaaaaaaaaaa> {};"); 1755 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1756 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1757 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1758 verifyFormat("template <class R, class C>\n" 1759 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1760 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1761 verifyFormat("class ::A::B {};"); 1762 } 1763 1764 TEST_F(FormatTest, BreakInheritanceStyle) { 1765 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1766 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1767 FormatStyle::BILS_BeforeComma; 1768 verifyFormat("class MyClass : public X {};", 1769 StyleWithInheritanceBreakBeforeComma); 1770 verifyFormat("class MyClass\n" 1771 " : public X\n" 1772 " , public Y {};", 1773 StyleWithInheritanceBreakBeforeComma); 1774 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1775 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1776 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1777 StyleWithInheritanceBreakBeforeComma); 1778 verifyFormat("struct aaaaaaaaaaaaa\n" 1779 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1780 " aaaaaaaaaaaaaaaa> {};", 1781 StyleWithInheritanceBreakBeforeComma); 1782 1783 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1784 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1785 FormatStyle::BILS_AfterColon; 1786 verifyFormat("class MyClass : public X {};", 1787 StyleWithInheritanceBreakAfterColon); 1788 verifyFormat("class MyClass : public X, public Y {};", 1789 StyleWithInheritanceBreakAfterColon); 1790 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1791 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1792 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1793 StyleWithInheritanceBreakAfterColon); 1794 verifyFormat("struct aaaaaaaaaaaaa :\n" 1795 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1796 " aaaaaaaaaaaaaaaa> {};", 1797 StyleWithInheritanceBreakAfterColon); 1798 } 1799 1800 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1801 verifyFormat("class A {\n} a, b;"); 1802 verifyFormat("struct A {\n} a, b;"); 1803 verifyFormat("union A {\n} a;"); 1804 } 1805 1806 TEST_F(FormatTest, FormatsEnum) { 1807 verifyFormat("enum {\n" 1808 " Zero,\n" 1809 " One = 1,\n" 1810 " Two = One + 1,\n" 1811 " Three = (One + Two),\n" 1812 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1813 " Five = (One, Two, Three, Four, 5)\n" 1814 "};"); 1815 verifyGoogleFormat("enum {\n" 1816 " Zero,\n" 1817 " One = 1,\n" 1818 " Two = One + 1,\n" 1819 " Three = (One + Two),\n" 1820 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1821 " Five = (One, Two, Three, Four, 5)\n" 1822 "};"); 1823 verifyFormat("enum Enum {};"); 1824 verifyFormat("enum {};"); 1825 verifyFormat("enum X E {} d;"); 1826 verifyFormat("enum __attribute__((...)) E {} d;"); 1827 verifyFormat("enum __declspec__((...)) E {} d;"); 1828 verifyFormat("enum {\n" 1829 " Bar = Foo<int, int>::value\n" 1830 "};", 1831 getLLVMStyleWithColumns(30)); 1832 1833 verifyFormat("enum ShortEnum { A, B, C };"); 1834 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1835 1836 EXPECT_EQ("enum KeepEmptyLines {\n" 1837 " ONE,\n" 1838 "\n" 1839 " TWO,\n" 1840 "\n" 1841 " THREE\n" 1842 "}", 1843 format("enum KeepEmptyLines {\n" 1844 " ONE,\n" 1845 "\n" 1846 " TWO,\n" 1847 "\n" 1848 "\n" 1849 " THREE\n" 1850 "}")); 1851 verifyFormat("enum E { // comment\n" 1852 " ONE,\n" 1853 " TWO\n" 1854 "};\n" 1855 "int i;"); 1856 // Not enums. 1857 verifyFormat("enum X f() {\n" 1858 " a();\n" 1859 " return 42;\n" 1860 "}"); 1861 verifyFormat("enum X Type::f() {\n" 1862 " a();\n" 1863 " return 42;\n" 1864 "}"); 1865 verifyFormat("enum ::X f() {\n" 1866 " a();\n" 1867 " return 42;\n" 1868 "}"); 1869 verifyFormat("enum ns::X f() {\n" 1870 " a();\n" 1871 " return 42;\n" 1872 "}"); 1873 } 1874 1875 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1876 verifyFormat("enum Type {\n" 1877 " One = 0; // These semicolons should be commas.\n" 1878 " Two = 1;\n" 1879 "};"); 1880 verifyFormat("namespace n {\n" 1881 "enum Type {\n" 1882 " One,\n" 1883 " Two, // missing };\n" 1884 " int i;\n" 1885 "}\n" 1886 "void g() {}"); 1887 } 1888 1889 TEST_F(FormatTest, FormatsEnumStruct) { 1890 verifyFormat("enum struct {\n" 1891 " Zero,\n" 1892 " One = 1,\n" 1893 " Two = One + 1,\n" 1894 " Three = (One + Two),\n" 1895 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1896 " Five = (One, Two, Three, Four, 5)\n" 1897 "};"); 1898 verifyFormat("enum struct Enum {};"); 1899 verifyFormat("enum struct {};"); 1900 verifyFormat("enum struct X E {} d;"); 1901 verifyFormat("enum struct __attribute__((...)) E {} d;"); 1902 verifyFormat("enum struct __declspec__((...)) E {} d;"); 1903 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1904 } 1905 1906 TEST_F(FormatTest, FormatsEnumClass) { 1907 verifyFormat("enum class {\n" 1908 " Zero,\n" 1909 " One = 1,\n" 1910 " Two = One + 1,\n" 1911 " Three = (One + Two),\n" 1912 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1913 " Five = (One, Two, Three, Four, 5)\n" 1914 "};"); 1915 verifyFormat("enum class Enum {};"); 1916 verifyFormat("enum class {};"); 1917 verifyFormat("enum class X E {} d;"); 1918 verifyFormat("enum class __attribute__((...)) E {} d;"); 1919 verifyFormat("enum class __declspec__((...)) E {} d;"); 1920 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 1921 } 1922 1923 TEST_F(FormatTest, FormatsEnumTypes) { 1924 verifyFormat("enum X : int {\n" 1925 " A, // Force multiple lines.\n" 1926 " B\n" 1927 "};"); 1928 verifyFormat("enum X : int { A, B };"); 1929 verifyFormat("enum X : std::uint32_t { A, B };"); 1930 } 1931 1932 TEST_F(FormatTest, FormatsTypedefEnum) { 1933 FormatStyle Style = getLLVMStyle(); 1934 Style.ColumnLimit = 40; 1935 verifyFormat("typedef enum {} EmptyEnum;"); 1936 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1937 verifyFormat("typedef enum {\n" 1938 " ZERO = 0,\n" 1939 " ONE = 1,\n" 1940 " TWO = 2,\n" 1941 " THREE = 3\n" 1942 "} LongEnum;", 1943 Style); 1944 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1945 Style.BraceWrapping.AfterEnum = true; 1946 verifyFormat("typedef enum {} EmptyEnum;"); 1947 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1948 verifyFormat("typedef enum\n" 1949 "{\n" 1950 " ZERO = 0,\n" 1951 " ONE = 1,\n" 1952 " TWO = 2,\n" 1953 " THREE = 3\n" 1954 "} LongEnum;", 1955 Style); 1956 } 1957 1958 TEST_F(FormatTest, FormatsNSEnums) { 1959 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1960 verifyGoogleFormat( 1961 "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1962 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 1963 " // Information about someDecentlyLongValue.\n" 1964 " someDecentlyLongValue,\n" 1965 " // Information about anotherDecentlyLongValue.\n" 1966 " anotherDecentlyLongValue,\n" 1967 " // Information about aThirdDecentlyLongValue.\n" 1968 " aThirdDecentlyLongValue\n" 1969 "};"); 1970 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n" 1971 " // Information about someDecentlyLongValue.\n" 1972 " someDecentlyLongValue,\n" 1973 " // Information about anotherDecentlyLongValue.\n" 1974 " anotherDecentlyLongValue,\n" 1975 " // Information about aThirdDecentlyLongValue.\n" 1976 " aThirdDecentlyLongValue\n" 1977 "};"); 1978 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 1979 " a = 1,\n" 1980 " b = 2,\n" 1981 " c = 3,\n" 1982 "};"); 1983 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 1984 " a = 1,\n" 1985 " b = 2,\n" 1986 " c = 3,\n" 1987 "};"); 1988 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n" 1989 " a = 1,\n" 1990 " b = 2,\n" 1991 " c = 3,\n" 1992 "};"); 1993 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 1994 " a = 1,\n" 1995 " b = 2,\n" 1996 " c = 3,\n" 1997 "};"); 1998 } 1999 2000 TEST_F(FormatTest, FormatsBitfields) { 2001 verifyFormat("struct Bitfields {\n" 2002 " unsigned sClass : 8;\n" 2003 " unsigned ValueKind : 2;\n" 2004 "};"); 2005 verifyFormat("struct A {\n" 2006 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 2007 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 2008 "};"); 2009 verifyFormat("struct MyStruct {\n" 2010 " uchar data;\n" 2011 " uchar : 8;\n" 2012 " uchar : 8;\n" 2013 " uchar other;\n" 2014 "};"); 2015 } 2016 2017 TEST_F(FormatTest, FormatsNamespaces) { 2018 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 2019 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 2020 2021 verifyFormat("namespace some_namespace {\n" 2022 "class A {};\n" 2023 "void f() { f(); }\n" 2024 "}", 2025 LLVMWithNoNamespaceFix); 2026 verifyFormat("namespace N::inline D {\n" 2027 "class A {};\n" 2028 "void f() { f(); }\n" 2029 "}", 2030 LLVMWithNoNamespaceFix); 2031 verifyFormat("namespace N::inline D::E {\n" 2032 "class A {};\n" 2033 "void f() { f(); }\n" 2034 "}", 2035 LLVMWithNoNamespaceFix); 2036 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n" 2037 "class A {};\n" 2038 "void f() { f(); }\n" 2039 "}", 2040 LLVMWithNoNamespaceFix); 2041 verifyFormat("/* something */ namespace some_namespace {\n" 2042 "class A {};\n" 2043 "void f() { f(); }\n" 2044 "}", 2045 LLVMWithNoNamespaceFix); 2046 verifyFormat("namespace {\n" 2047 "class A {};\n" 2048 "void f() { f(); }\n" 2049 "}", 2050 LLVMWithNoNamespaceFix); 2051 verifyFormat("/* something */ namespace {\n" 2052 "class A {};\n" 2053 "void f() { f(); }\n" 2054 "}", 2055 LLVMWithNoNamespaceFix); 2056 verifyFormat("inline namespace X {\n" 2057 "class A {};\n" 2058 "void f() { f(); }\n" 2059 "}", 2060 LLVMWithNoNamespaceFix); 2061 verifyFormat("/* something */ inline namespace X {\n" 2062 "class A {};\n" 2063 "void f() { f(); }\n" 2064 "}", 2065 LLVMWithNoNamespaceFix); 2066 verifyFormat("export namespace X {\n" 2067 "class A {};\n" 2068 "void f() { f(); }\n" 2069 "}", 2070 LLVMWithNoNamespaceFix); 2071 verifyFormat("using namespace some_namespace;\n" 2072 "class A {};\n" 2073 "void f() { f(); }", 2074 LLVMWithNoNamespaceFix); 2075 2076 // This code is more common than we thought; if we 2077 // layout this correctly the semicolon will go into 2078 // its own line, which is undesirable. 2079 verifyFormat("namespace {};", LLVMWithNoNamespaceFix); 2080 verifyFormat("namespace {\n" 2081 "class A {};\n" 2082 "};", 2083 LLVMWithNoNamespaceFix); 2084 2085 verifyFormat("namespace {\n" 2086 "int SomeVariable = 0; // comment\n" 2087 "} // namespace", 2088 LLVMWithNoNamespaceFix); 2089 EXPECT_EQ("#ifndef HEADER_GUARD\n" 2090 "#define HEADER_GUARD\n" 2091 "namespace my_namespace {\n" 2092 "int i;\n" 2093 "} // my_namespace\n" 2094 "#endif // HEADER_GUARD", 2095 format("#ifndef HEADER_GUARD\n" 2096 " #define HEADER_GUARD\n" 2097 " namespace my_namespace {\n" 2098 "int i;\n" 2099 "} // my_namespace\n" 2100 "#endif // HEADER_GUARD", 2101 LLVMWithNoNamespaceFix)); 2102 2103 EXPECT_EQ("namespace A::B {\n" 2104 "class C {};\n" 2105 "}", 2106 format("namespace A::B {\n" 2107 "class C {};\n" 2108 "}", 2109 LLVMWithNoNamespaceFix)); 2110 2111 FormatStyle Style = getLLVMStyle(); 2112 Style.NamespaceIndentation = FormatStyle::NI_All; 2113 EXPECT_EQ("namespace out {\n" 2114 " int i;\n" 2115 " namespace in {\n" 2116 " int i;\n" 2117 " } // namespace in\n" 2118 "} // namespace out", 2119 format("namespace out {\n" 2120 "int i;\n" 2121 "namespace in {\n" 2122 "int i;\n" 2123 "} // namespace in\n" 2124 "} // namespace out", 2125 Style)); 2126 2127 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2128 EXPECT_EQ("namespace out {\n" 2129 "int i;\n" 2130 "namespace in {\n" 2131 " int i;\n" 2132 "} // namespace in\n" 2133 "} // namespace out", 2134 format("namespace out {\n" 2135 "int i;\n" 2136 "namespace in {\n" 2137 "int i;\n" 2138 "} // namespace in\n" 2139 "} // namespace out", 2140 Style)); 2141 } 2142 2143 TEST_F(FormatTest, NamespaceMacros) { 2144 FormatStyle Style = getLLVMStyle(); 2145 Style.NamespaceMacros.push_back("TESTSUITE"); 2146 2147 verifyFormat("TESTSUITE(A) {\n" 2148 "int foo();\n" 2149 "} // TESTSUITE(A)", 2150 Style); 2151 2152 verifyFormat("TESTSUITE(A, B) {\n" 2153 "int foo();\n" 2154 "} // TESTSUITE(A)", 2155 Style); 2156 2157 // Properly indent according to NamespaceIndentation style 2158 Style.NamespaceIndentation = FormatStyle::NI_All; 2159 verifyFormat("TESTSUITE(A) {\n" 2160 " int foo();\n" 2161 "} // TESTSUITE(A)", 2162 Style); 2163 verifyFormat("TESTSUITE(A) {\n" 2164 " namespace B {\n" 2165 " int foo();\n" 2166 " } // namespace B\n" 2167 "} // TESTSUITE(A)", 2168 Style); 2169 verifyFormat("namespace A {\n" 2170 " TESTSUITE(B) {\n" 2171 " int foo();\n" 2172 " } // TESTSUITE(B)\n" 2173 "} // namespace A", 2174 Style); 2175 2176 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2177 verifyFormat("TESTSUITE(A) {\n" 2178 "TESTSUITE(B) {\n" 2179 " int foo();\n" 2180 "} // TESTSUITE(B)\n" 2181 "} // TESTSUITE(A)", 2182 Style); 2183 verifyFormat("TESTSUITE(A) {\n" 2184 "namespace B {\n" 2185 " int foo();\n" 2186 "} // namespace B\n" 2187 "} // TESTSUITE(A)", 2188 Style); 2189 verifyFormat("namespace A {\n" 2190 "TESTSUITE(B) {\n" 2191 " int foo();\n" 2192 "} // TESTSUITE(B)\n" 2193 "} // namespace A", 2194 Style); 2195 2196 // Properly merge namespace-macros blocks in CompactNamespaces mode 2197 Style.NamespaceIndentation = FormatStyle::NI_None; 2198 Style.CompactNamespaces = true; 2199 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n" 2200 "}} // TESTSUITE(A::B)", 2201 Style); 2202 2203 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2204 "}} // TESTSUITE(out::in)", 2205 format("TESTSUITE(out) {\n" 2206 "TESTSUITE(in) {\n" 2207 "} // TESTSUITE(in)\n" 2208 "} // TESTSUITE(out)", 2209 Style)); 2210 2211 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2212 "}} // TESTSUITE(out::in)", 2213 format("TESTSUITE(out) {\n" 2214 "TESTSUITE(in) {\n" 2215 "} // TESTSUITE(in)\n" 2216 "} // TESTSUITE(out)", 2217 Style)); 2218 2219 // Do not merge different namespaces/macros 2220 EXPECT_EQ("namespace out {\n" 2221 "TESTSUITE(in) {\n" 2222 "} // TESTSUITE(in)\n" 2223 "} // namespace out", 2224 format("namespace out {\n" 2225 "TESTSUITE(in) {\n" 2226 "} // TESTSUITE(in)\n" 2227 "} // namespace out", 2228 Style)); 2229 EXPECT_EQ("TESTSUITE(out) {\n" 2230 "namespace in {\n" 2231 "} // namespace in\n" 2232 "} // TESTSUITE(out)", 2233 format("TESTSUITE(out) {\n" 2234 "namespace in {\n" 2235 "} // namespace in\n" 2236 "} // TESTSUITE(out)", 2237 Style)); 2238 Style.NamespaceMacros.push_back("FOOBAR"); 2239 EXPECT_EQ("TESTSUITE(out) {\n" 2240 "FOOBAR(in) {\n" 2241 "} // FOOBAR(in)\n" 2242 "} // TESTSUITE(out)", 2243 format("TESTSUITE(out) {\n" 2244 "FOOBAR(in) {\n" 2245 "} // FOOBAR(in)\n" 2246 "} // TESTSUITE(out)", 2247 Style)); 2248 } 2249 2250 TEST_F(FormatTest, FormatsCompactNamespaces) { 2251 FormatStyle Style = getLLVMStyle(); 2252 Style.CompactNamespaces = true; 2253 Style.NamespaceMacros.push_back("TESTSUITE"); 2254 2255 verifyFormat("namespace A { namespace B {\n" 2256 "}} // namespace A::B", 2257 Style); 2258 2259 EXPECT_EQ("namespace out { namespace in {\n" 2260 "}} // namespace out::in", 2261 format("namespace out {\n" 2262 "namespace in {\n" 2263 "} // namespace in\n" 2264 "} // namespace out", 2265 Style)); 2266 2267 // Only namespaces which have both consecutive opening and end get compacted 2268 EXPECT_EQ("namespace out {\n" 2269 "namespace in1 {\n" 2270 "} // namespace in1\n" 2271 "namespace in2 {\n" 2272 "} // namespace in2\n" 2273 "} // namespace out", 2274 format("namespace out {\n" 2275 "namespace in1 {\n" 2276 "} // namespace in1\n" 2277 "namespace in2 {\n" 2278 "} // namespace in2\n" 2279 "} // namespace out", 2280 Style)); 2281 2282 EXPECT_EQ("namespace out {\n" 2283 "int i;\n" 2284 "namespace in {\n" 2285 "int j;\n" 2286 "} // namespace in\n" 2287 "int k;\n" 2288 "} // namespace out", 2289 format("namespace out { int i;\n" 2290 "namespace in { int j; } // namespace in\n" 2291 "int k; } // namespace out", 2292 Style)); 2293 2294 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 2295 "}}} // namespace A::B::C\n", 2296 format("namespace A { namespace B {\n" 2297 "namespace C {\n" 2298 "}} // namespace B::C\n" 2299 "} // namespace A\n", 2300 Style)); 2301 2302 Style.ColumnLimit = 40; 2303 EXPECT_EQ("namespace aaaaaaaaaa {\n" 2304 "namespace bbbbbbbbbb {\n" 2305 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 2306 format("namespace aaaaaaaaaa {\n" 2307 "namespace bbbbbbbbbb {\n" 2308 "} // namespace bbbbbbbbbb\n" 2309 "} // namespace aaaaaaaaaa", 2310 Style)); 2311 2312 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 2313 "namespace cccccc {\n" 2314 "}}} // namespace aaaaaa::bbbbbb::cccccc", 2315 format("namespace aaaaaa {\n" 2316 "namespace bbbbbb {\n" 2317 "namespace cccccc {\n" 2318 "} // namespace cccccc\n" 2319 "} // namespace bbbbbb\n" 2320 "} // namespace aaaaaa", 2321 Style)); 2322 Style.ColumnLimit = 80; 2323 2324 // Extra semicolon after 'inner' closing brace prevents merging 2325 EXPECT_EQ("namespace out { namespace in {\n" 2326 "}; } // namespace out::in", 2327 format("namespace out {\n" 2328 "namespace in {\n" 2329 "}; // namespace in\n" 2330 "} // namespace out", 2331 Style)); 2332 2333 // Extra semicolon after 'outer' closing brace is conserved 2334 EXPECT_EQ("namespace out { namespace in {\n" 2335 "}}; // namespace out::in", 2336 format("namespace out {\n" 2337 "namespace in {\n" 2338 "} // namespace in\n" 2339 "}; // namespace out", 2340 Style)); 2341 2342 Style.NamespaceIndentation = FormatStyle::NI_All; 2343 EXPECT_EQ("namespace out { namespace in {\n" 2344 " int i;\n" 2345 "}} // namespace out::in", 2346 format("namespace out {\n" 2347 "namespace in {\n" 2348 "int i;\n" 2349 "} // namespace in\n" 2350 "} // namespace out", 2351 Style)); 2352 EXPECT_EQ("namespace out { namespace mid {\n" 2353 " namespace in {\n" 2354 " int j;\n" 2355 " } // namespace in\n" 2356 " int k;\n" 2357 "}} // namespace out::mid", 2358 format("namespace out { namespace mid {\n" 2359 "namespace in { int j; } // namespace in\n" 2360 "int k; }} // namespace out::mid", 2361 Style)); 2362 2363 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2364 EXPECT_EQ("namespace out { namespace in {\n" 2365 " int i;\n" 2366 "}} // namespace out::in", 2367 format("namespace out {\n" 2368 "namespace in {\n" 2369 "int i;\n" 2370 "} // namespace in\n" 2371 "} // namespace out", 2372 Style)); 2373 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 2374 " int i;\n" 2375 "}}} // namespace out::mid::in", 2376 format("namespace out {\n" 2377 "namespace mid {\n" 2378 "namespace in {\n" 2379 "int i;\n" 2380 "} // namespace in\n" 2381 "} // namespace mid\n" 2382 "} // namespace out", 2383 Style)); 2384 } 2385 2386 TEST_F(FormatTest, FormatsExternC) { 2387 verifyFormat("extern \"C\" {\nint a;"); 2388 verifyFormat("extern \"C\" {}"); 2389 verifyFormat("extern \"C\" {\n" 2390 "int foo();\n" 2391 "}"); 2392 verifyFormat("extern \"C\" int foo() {}"); 2393 verifyFormat("extern \"C\" int foo();"); 2394 verifyFormat("extern \"C\" int foo() {\n" 2395 " int i = 42;\n" 2396 " return i;\n" 2397 "}"); 2398 2399 FormatStyle Style = getLLVMStyle(); 2400 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2401 Style.BraceWrapping.AfterFunction = true; 2402 verifyFormat("extern \"C\" int foo() {}", Style); 2403 verifyFormat("extern \"C\" int foo();", Style); 2404 verifyFormat("extern \"C\" int foo()\n" 2405 "{\n" 2406 " int i = 42;\n" 2407 " return i;\n" 2408 "}", 2409 Style); 2410 2411 Style.BraceWrapping.AfterExternBlock = true; 2412 Style.BraceWrapping.SplitEmptyRecord = false; 2413 verifyFormat("extern \"C\"\n" 2414 "{}", 2415 Style); 2416 verifyFormat("extern \"C\"\n" 2417 "{\n" 2418 " int foo();\n" 2419 "}", 2420 Style); 2421 } 2422 2423 TEST_F(FormatTest, FormatsInlineASM) { 2424 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2425 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2426 verifyFormat( 2427 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2428 " \"cpuid\\n\\t\"\n" 2429 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2430 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2431 " : \"a\"(value));"); 2432 EXPECT_EQ( 2433 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2434 " __asm {\n" 2435 " mov edx,[that] // vtable in edx\n" 2436 " mov eax,methodIndex\n" 2437 " call [edx][eax*4] // stdcall\n" 2438 " }\n" 2439 "}", 2440 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2441 " __asm {\n" 2442 " mov edx,[that] // vtable in edx\n" 2443 " mov eax,methodIndex\n" 2444 " call [edx][eax*4] // stdcall\n" 2445 " }\n" 2446 "}")); 2447 EXPECT_EQ("_asm {\n" 2448 " xor eax, eax;\n" 2449 " cpuid;\n" 2450 "}", 2451 format("_asm {\n" 2452 " xor eax, eax;\n" 2453 " cpuid;\n" 2454 "}")); 2455 verifyFormat("void function() {\n" 2456 " // comment\n" 2457 " asm(\"\");\n" 2458 "}"); 2459 EXPECT_EQ("__asm {\n" 2460 "}\n" 2461 "int i;", 2462 format("__asm {\n" 2463 "}\n" 2464 "int i;")); 2465 } 2466 2467 TEST_F(FormatTest, FormatTryCatch) { 2468 verifyFormat("try {\n" 2469 " throw a * b;\n" 2470 "} catch (int a) {\n" 2471 " // Do nothing.\n" 2472 "} catch (...) {\n" 2473 " exit(42);\n" 2474 "}"); 2475 2476 // Function-level try statements. 2477 verifyFormat("int f() try { return 4; } catch (...) {\n" 2478 " return 5;\n" 2479 "}"); 2480 verifyFormat("class A {\n" 2481 " int a;\n" 2482 " A() try : a(0) {\n" 2483 " } catch (...) {\n" 2484 " throw;\n" 2485 " }\n" 2486 "};\n"); 2487 2488 // Incomplete try-catch blocks. 2489 verifyIncompleteFormat("try {} catch ("); 2490 } 2491 2492 TEST_F(FormatTest, FormatSEHTryCatch) { 2493 verifyFormat("__try {\n" 2494 " int a = b * c;\n" 2495 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2496 " // Do nothing.\n" 2497 "}"); 2498 2499 verifyFormat("__try {\n" 2500 " int a = b * c;\n" 2501 "} __finally {\n" 2502 " // Do nothing.\n" 2503 "}"); 2504 2505 verifyFormat("DEBUG({\n" 2506 " __try {\n" 2507 " } __finally {\n" 2508 " }\n" 2509 "});\n"); 2510 } 2511 2512 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2513 verifyFormat("try {\n" 2514 " f();\n" 2515 "} catch {\n" 2516 " g();\n" 2517 "}"); 2518 verifyFormat("try {\n" 2519 " f();\n" 2520 "} catch (A a) MACRO(x) {\n" 2521 " g();\n" 2522 "} catch (B b) MACRO(x) {\n" 2523 " g();\n" 2524 "}"); 2525 } 2526 2527 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2528 FormatStyle Style = getLLVMStyle(); 2529 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2530 FormatStyle::BS_WebKit}) { 2531 Style.BreakBeforeBraces = BraceStyle; 2532 verifyFormat("try {\n" 2533 " // something\n" 2534 "} catch (...) {\n" 2535 " // something\n" 2536 "}", 2537 Style); 2538 } 2539 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2540 verifyFormat("try {\n" 2541 " // something\n" 2542 "}\n" 2543 "catch (...) {\n" 2544 " // something\n" 2545 "}", 2546 Style); 2547 verifyFormat("__try {\n" 2548 " // something\n" 2549 "}\n" 2550 "__finally {\n" 2551 " // something\n" 2552 "}", 2553 Style); 2554 verifyFormat("@try {\n" 2555 " // something\n" 2556 "}\n" 2557 "@finally {\n" 2558 " // something\n" 2559 "}", 2560 Style); 2561 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2562 verifyFormat("try\n" 2563 "{\n" 2564 " // something\n" 2565 "}\n" 2566 "catch (...)\n" 2567 "{\n" 2568 " // something\n" 2569 "}", 2570 Style); 2571 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 2572 verifyFormat("try\n" 2573 " {\n" 2574 " // something white\n" 2575 " }\n" 2576 "catch (...)\n" 2577 " {\n" 2578 " // something white\n" 2579 " }", 2580 Style); 2581 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2582 verifyFormat("try\n" 2583 " {\n" 2584 " // something\n" 2585 " }\n" 2586 "catch (...)\n" 2587 " {\n" 2588 " // something\n" 2589 " }", 2590 Style); 2591 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2592 Style.BraceWrapping.BeforeCatch = true; 2593 verifyFormat("try {\n" 2594 " // something\n" 2595 "}\n" 2596 "catch (...) {\n" 2597 " // something\n" 2598 "}", 2599 Style); 2600 } 2601 2602 TEST_F(FormatTest, StaticInitializers) { 2603 verifyFormat("static SomeClass SC = {1, 'a'};"); 2604 2605 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2606 " 100000000, " 2607 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2608 2609 // Here, everything other than the "}" would fit on a line. 2610 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2611 " 10000000000000000000000000};"); 2612 EXPECT_EQ("S s = {a,\n" 2613 "\n" 2614 " b};", 2615 format("S s = {\n" 2616 " a,\n" 2617 "\n" 2618 " b\n" 2619 "};")); 2620 2621 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2622 // line. However, the formatting looks a bit off and this probably doesn't 2623 // happen often in practice. 2624 verifyFormat("static int Variable[1] = {\n" 2625 " {1000000000000000000000000000000000000}};", 2626 getLLVMStyleWithColumns(40)); 2627 } 2628 2629 TEST_F(FormatTest, DesignatedInitializers) { 2630 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2631 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2632 " .bbbbbbbbbb = 2,\n" 2633 " .cccccccccc = 3,\n" 2634 " .dddddddddd = 4,\n" 2635 " .eeeeeeeeee = 5};"); 2636 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2637 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2638 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2639 " .ccccccccccccccccccccccccccc = 3,\n" 2640 " .ddddddddddddddddddddddddddd = 4,\n" 2641 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2642 2643 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2644 2645 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2646 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2647 " [2] = bbbbbbbbbb,\n" 2648 " [3] = cccccccccc,\n" 2649 " [4] = dddddddddd,\n" 2650 " [5] = eeeeeeeeee};"); 2651 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2652 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2653 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2654 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2655 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2656 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2657 } 2658 2659 TEST_F(FormatTest, NestedStaticInitializers) { 2660 verifyFormat("static A x = {{{}}};\n"); 2661 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2662 " {init1, init2, init3, init4}}};", 2663 getLLVMStyleWithColumns(50)); 2664 2665 verifyFormat("somes Status::global_reps[3] = {\n" 2666 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2667 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2668 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2669 getLLVMStyleWithColumns(60)); 2670 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2671 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2672 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2673 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2674 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2675 " {rect.fRight - rect.fLeft, rect.fBottom - " 2676 "rect.fTop}};"); 2677 2678 verifyFormat( 2679 "SomeArrayOfSomeType a = {\n" 2680 " {{1, 2, 3},\n" 2681 " {1, 2, 3},\n" 2682 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2683 " 333333333333333333333333333333},\n" 2684 " {1, 2, 3},\n" 2685 " {1, 2, 3}}};"); 2686 verifyFormat( 2687 "SomeArrayOfSomeType a = {\n" 2688 " {{1, 2, 3}},\n" 2689 " {{1, 2, 3}},\n" 2690 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2691 " 333333333333333333333333333333}},\n" 2692 " {{1, 2, 3}},\n" 2693 " {{1, 2, 3}}};"); 2694 2695 verifyFormat("struct {\n" 2696 " unsigned bit;\n" 2697 " const char *const name;\n" 2698 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2699 " {kOsWin, \"Windows\"},\n" 2700 " {kOsLinux, \"Linux\"},\n" 2701 " {kOsCrOS, \"Chrome OS\"}};"); 2702 verifyFormat("struct {\n" 2703 " unsigned bit;\n" 2704 " const char *const name;\n" 2705 "} kBitsToOs[] = {\n" 2706 " {kOsMac, \"Mac\"},\n" 2707 " {kOsWin, \"Windows\"},\n" 2708 " {kOsLinux, \"Linux\"},\n" 2709 " {kOsCrOS, \"Chrome OS\"},\n" 2710 "};"); 2711 } 2712 2713 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2714 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2715 " \\\n" 2716 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2717 } 2718 2719 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2720 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2721 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2722 2723 // Do break defaulted and deleted functions. 2724 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2725 " default;", 2726 getLLVMStyleWithColumns(40)); 2727 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2728 " delete;", 2729 getLLVMStyleWithColumns(40)); 2730 } 2731 2732 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2733 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2734 getLLVMStyleWithColumns(40)); 2735 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2736 getLLVMStyleWithColumns(40)); 2737 EXPECT_EQ("#define Q \\\n" 2738 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2739 " \"aaaaaaaa.cpp\"", 2740 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2741 getLLVMStyleWithColumns(40))); 2742 } 2743 2744 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2745 EXPECT_EQ("# 123 \"A string literal\"", 2746 format(" # 123 \"A string literal\"")); 2747 } 2748 2749 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2750 EXPECT_EQ("#;", format("#;")); 2751 verifyFormat("#\n;\n;\n;"); 2752 } 2753 2754 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2755 EXPECT_EQ("#line 42 \"test\"\n", 2756 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2757 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2758 getLLVMStyleWithColumns(12))); 2759 } 2760 2761 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2762 EXPECT_EQ("#line 42 \"test\"", 2763 format("# \\\n line \\\n 42 \\\n \"test\"")); 2764 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2765 } 2766 2767 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2768 verifyFormat("#define A \\x20"); 2769 verifyFormat("#define A \\ x20"); 2770 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2771 verifyFormat("#define A ''"); 2772 verifyFormat("#define A ''qqq"); 2773 verifyFormat("#define A `qqq"); 2774 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2775 EXPECT_EQ("const char *c = STRINGIFY(\n" 2776 "\\na : b);", 2777 format("const char * c = STRINGIFY(\n" 2778 "\\na : b);")); 2779 2780 verifyFormat("a\r\\"); 2781 verifyFormat("a\v\\"); 2782 verifyFormat("a\f\\"); 2783 } 2784 2785 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2786 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2787 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2788 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2789 // FIXME: We never break before the macro name. 2790 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2791 2792 verifyFormat("#define A A\n#define A A"); 2793 verifyFormat("#define A(X) A\n#define A A"); 2794 2795 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2796 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2797 } 2798 2799 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2800 EXPECT_EQ("// somecomment\n" 2801 "#include \"a.h\"\n" 2802 "#define A( \\\n" 2803 " A, B)\n" 2804 "#include \"b.h\"\n" 2805 "// somecomment\n", 2806 format(" // somecomment\n" 2807 " #include \"a.h\"\n" 2808 "#define A(A,\\\n" 2809 " B)\n" 2810 " #include \"b.h\"\n" 2811 " // somecomment\n", 2812 getLLVMStyleWithColumns(13))); 2813 } 2814 2815 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2816 2817 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2818 EXPECT_EQ("#define A \\\n" 2819 " c; \\\n" 2820 " e;\n" 2821 "f;", 2822 format("#define A c; e;\n" 2823 "f;", 2824 getLLVMStyleWithColumns(14))); 2825 } 2826 2827 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2828 2829 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2830 EXPECT_EQ("int x,\n" 2831 "#define A\n" 2832 " y;", 2833 format("int x,\n#define A\ny;")); 2834 } 2835 2836 TEST_F(FormatTest, HashInMacroDefinition) { 2837 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2838 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2839 verifyFormat("#define A \\\n" 2840 " { \\\n" 2841 " f(#c); \\\n" 2842 " }", 2843 getLLVMStyleWithColumns(11)); 2844 2845 verifyFormat("#define A(X) \\\n" 2846 " void function##X()", 2847 getLLVMStyleWithColumns(22)); 2848 2849 verifyFormat("#define A(a, b, c) \\\n" 2850 " void a##b##c()", 2851 getLLVMStyleWithColumns(22)); 2852 2853 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2854 } 2855 2856 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2857 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2858 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2859 2860 FormatStyle Style = getLLVMStyle(); 2861 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 2862 verifyFormat("#define true ((foo)1)", Style); 2863 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 2864 verifyFormat("#define false((foo)0)", Style); 2865 } 2866 2867 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2868 EXPECT_EQ("#define A b;", format("#define A \\\n" 2869 " \\\n" 2870 " b;", 2871 getLLVMStyleWithColumns(25))); 2872 EXPECT_EQ("#define A \\\n" 2873 " \\\n" 2874 " a; \\\n" 2875 " b;", 2876 format("#define A \\\n" 2877 " \\\n" 2878 " a; \\\n" 2879 " b;", 2880 getLLVMStyleWithColumns(11))); 2881 EXPECT_EQ("#define A \\\n" 2882 " a; \\\n" 2883 " \\\n" 2884 " b;", 2885 format("#define A \\\n" 2886 " a; \\\n" 2887 " \\\n" 2888 " b;", 2889 getLLVMStyleWithColumns(11))); 2890 } 2891 2892 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 2893 verifyIncompleteFormat("#define A :"); 2894 verifyFormat("#define SOMECASES \\\n" 2895 " case 1: \\\n" 2896 " case 2\n", 2897 getLLVMStyleWithColumns(20)); 2898 verifyFormat("#define MACRO(a) \\\n" 2899 " if (a) \\\n" 2900 " f(); \\\n" 2901 " else \\\n" 2902 " g()", 2903 getLLVMStyleWithColumns(18)); 2904 verifyFormat("#define A template <typename T>"); 2905 verifyIncompleteFormat("#define STR(x) #x\n" 2906 "f(STR(this_is_a_string_literal{));"); 2907 verifyFormat("#pragma omp threadprivate( \\\n" 2908 " y)), // expected-warning", 2909 getLLVMStyleWithColumns(28)); 2910 verifyFormat("#d, = };"); 2911 verifyFormat("#if \"a"); 2912 verifyIncompleteFormat("({\n" 2913 "#define b \\\n" 2914 " } \\\n" 2915 " a\n" 2916 "a", 2917 getLLVMStyleWithColumns(15)); 2918 verifyFormat("#define A \\\n" 2919 " { \\\n" 2920 " {\n" 2921 "#define B \\\n" 2922 " } \\\n" 2923 " }", 2924 getLLVMStyleWithColumns(15)); 2925 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 2926 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 2927 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 2928 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 2929 } 2930 2931 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 2932 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 2933 EXPECT_EQ("class A : public QObject {\n" 2934 " Q_OBJECT\n" 2935 "\n" 2936 " A() {}\n" 2937 "};", 2938 format("class A : public QObject {\n" 2939 " Q_OBJECT\n" 2940 "\n" 2941 " A() {\n}\n" 2942 "} ;")); 2943 EXPECT_EQ("MACRO\n" 2944 "/*static*/ int i;", 2945 format("MACRO\n" 2946 " /*static*/ int i;")); 2947 EXPECT_EQ("SOME_MACRO\n" 2948 "namespace {\n" 2949 "void f();\n" 2950 "} // namespace", 2951 format("SOME_MACRO\n" 2952 " namespace {\n" 2953 "void f( );\n" 2954 "} // namespace")); 2955 // Only if the identifier contains at least 5 characters. 2956 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 2957 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 2958 // Only if everything is upper case. 2959 EXPECT_EQ("class A : public QObject {\n" 2960 " Q_Object A() {}\n" 2961 "};", 2962 format("class A : public QObject {\n" 2963 " Q_Object\n" 2964 " A() {\n}\n" 2965 "} ;")); 2966 2967 // Only if the next line can actually start an unwrapped line. 2968 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 2969 format("SOME_WEIRD_LOG_MACRO\n" 2970 "<< SomeThing;")); 2971 2972 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 2973 "(n, buffers))\n", 2974 getChromiumStyle(FormatStyle::LK_Cpp)); 2975 2976 // See PR41483 2977 EXPECT_EQ("/**/ FOO(a)\n" 2978 "FOO(b)", 2979 format("/**/ FOO(a)\n" 2980 "FOO(b)")); 2981 } 2982 2983 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 2984 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2985 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2986 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2987 "class X {};\n" 2988 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2989 "int *createScopDetectionPass() { return 0; }", 2990 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2991 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2992 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2993 " class X {};\n" 2994 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2995 " int *createScopDetectionPass() { return 0; }")); 2996 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 2997 // braces, so that inner block is indented one level more. 2998 EXPECT_EQ("int q() {\n" 2999 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 3000 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 3001 " IPC_END_MESSAGE_MAP()\n" 3002 "}", 3003 format("int q() {\n" 3004 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 3005 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 3006 " IPC_END_MESSAGE_MAP()\n" 3007 "}")); 3008 3009 // Same inside macros. 3010 EXPECT_EQ("#define LIST(L) \\\n" 3011 " L(A) \\\n" 3012 " L(B) \\\n" 3013 " L(C)", 3014 format("#define LIST(L) \\\n" 3015 " L(A) \\\n" 3016 " L(B) \\\n" 3017 " L(C)", 3018 getGoogleStyle())); 3019 3020 // These must not be recognized as macros. 3021 EXPECT_EQ("int q() {\n" 3022 " f(x);\n" 3023 " f(x) {}\n" 3024 " f(x)->g();\n" 3025 " f(x)->*g();\n" 3026 " f(x).g();\n" 3027 " f(x) = x;\n" 3028 " f(x) += x;\n" 3029 " f(x) -= x;\n" 3030 " f(x) *= x;\n" 3031 " f(x) /= x;\n" 3032 " f(x) %= x;\n" 3033 " f(x) &= x;\n" 3034 " f(x) |= x;\n" 3035 " f(x) ^= x;\n" 3036 " f(x) >>= x;\n" 3037 " f(x) <<= x;\n" 3038 " f(x)[y].z();\n" 3039 " LOG(INFO) << x;\n" 3040 " ifstream(x) >> x;\n" 3041 "}\n", 3042 format("int q() {\n" 3043 " f(x)\n;\n" 3044 " f(x)\n {}\n" 3045 " f(x)\n->g();\n" 3046 " f(x)\n->*g();\n" 3047 " f(x)\n.g();\n" 3048 " f(x)\n = x;\n" 3049 " f(x)\n += x;\n" 3050 " f(x)\n -= x;\n" 3051 " f(x)\n *= x;\n" 3052 " f(x)\n /= x;\n" 3053 " f(x)\n %= x;\n" 3054 " f(x)\n &= x;\n" 3055 " f(x)\n |= x;\n" 3056 " f(x)\n ^= x;\n" 3057 " f(x)\n >>= x;\n" 3058 " f(x)\n <<= x;\n" 3059 " f(x)\n[y].z();\n" 3060 " LOG(INFO)\n << x;\n" 3061 " ifstream(x)\n >> x;\n" 3062 "}\n")); 3063 EXPECT_EQ("int q() {\n" 3064 " F(x)\n" 3065 " if (1) {\n" 3066 " }\n" 3067 " F(x)\n" 3068 " while (1) {\n" 3069 " }\n" 3070 " F(x)\n" 3071 " G(x);\n" 3072 " F(x)\n" 3073 " try {\n" 3074 " Q();\n" 3075 " } catch (...) {\n" 3076 " }\n" 3077 "}\n", 3078 format("int q() {\n" 3079 "F(x)\n" 3080 "if (1) {}\n" 3081 "F(x)\n" 3082 "while (1) {}\n" 3083 "F(x)\n" 3084 "G(x);\n" 3085 "F(x)\n" 3086 "try { Q(); } catch (...) {}\n" 3087 "}\n")); 3088 EXPECT_EQ("class A {\n" 3089 " A() : t(0) {}\n" 3090 " A(int i) noexcept() : {}\n" 3091 " A(X x)\n" // FIXME: function-level try blocks are broken. 3092 " try : t(0) {\n" 3093 " } catch (...) {\n" 3094 " }\n" 3095 "};", 3096 format("class A {\n" 3097 " A()\n : t(0) {}\n" 3098 " A(int i)\n noexcept() : {}\n" 3099 " A(X x)\n" 3100 " try : t(0) {} catch (...) {}\n" 3101 "};")); 3102 FormatStyle Style = getLLVMStyle(); 3103 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 3104 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 3105 Style.BraceWrapping.AfterFunction = true; 3106 EXPECT_EQ("void f()\n" 3107 "try\n" 3108 "{\n" 3109 "}", 3110 format("void f() try {\n" 3111 "}", 3112 Style)); 3113 EXPECT_EQ("class SomeClass {\n" 3114 "public:\n" 3115 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3116 "};", 3117 format("class SomeClass {\n" 3118 "public:\n" 3119 " SomeClass()\n" 3120 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3121 "};")); 3122 EXPECT_EQ("class SomeClass {\n" 3123 "public:\n" 3124 " SomeClass()\n" 3125 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3126 "};", 3127 format("class SomeClass {\n" 3128 "public:\n" 3129 " SomeClass()\n" 3130 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3131 "};", 3132 getLLVMStyleWithColumns(40))); 3133 3134 verifyFormat("MACRO(>)"); 3135 3136 // Some macros contain an implicit semicolon. 3137 Style = getLLVMStyle(); 3138 Style.StatementMacros.push_back("FOO"); 3139 verifyFormat("FOO(a) int b = 0;"); 3140 verifyFormat("FOO(a)\n" 3141 "int b = 0;", 3142 Style); 3143 verifyFormat("FOO(a);\n" 3144 "int b = 0;", 3145 Style); 3146 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 3147 "int b = 0;", 3148 Style); 3149 verifyFormat("FOO()\n" 3150 "int b = 0;", 3151 Style); 3152 verifyFormat("FOO\n" 3153 "int b = 0;", 3154 Style); 3155 verifyFormat("void f() {\n" 3156 " FOO(a)\n" 3157 " return a;\n" 3158 "}", 3159 Style); 3160 verifyFormat("FOO(a)\n" 3161 "FOO(b)", 3162 Style); 3163 verifyFormat("int a = 0;\n" 3164 "FOO(b)\n" 3165 "int c = 0;", 3166 Style); 3167 verifyFormat("int a = 0;\n" 3168 "int x = FOO(a)\n" 3169 "int b = 0;", 3170 Style); 3171 verifyFormat("void foo(int a) { FOO(a) }\n" 3172 "uint32_t bar() {}", 3173 Style); 3174 } 3175 3176 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 3177 verifyFormat("#define A \\\n" 3178 " f({ \\\n" 3179 " g(); \\\n" 3180 " });", 3181 getLLVMStyleWithColumns(11)); 3182 } 3183 3184 TEST_F(FormatTest, IndentPreprocessorDirectives) { 3185 FormatStyle Style = getLLVMStyle(); 3186 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 3187 Style.ColumnLimit = 40; 3188 verifyFormat("#ifdef _WIN32\n" 3189 "#define A 0\n" 3190 "#ifdef VAR2\n" 3191 "#define B 1\n" 3192 "#include <someheader.h>\n" 3193 "#define MACRO \\\n" 3194 " some_very_long_func_aaaaaaaaaa();\n" 3195 "#endif\n" 3196 "#else\n" 3197 "#define A 1\n" 3198 "#endif", 3199 Style); 3200 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 3201 verifyFormat("#ifdef _WIN32\n" 3202 "# define A 0\n" 3203 "# ifdef VAR2\n" 3204 "# define B 1\n" 3205 "# include <someheader.h>\n" 3206 "# define MACRO \\\n" 3207 " some_very_long_func_aaaaaaaaaa();\n" 3208 "# endif\n" 3209 "#else\n" 3210 "# define A 1\n" 3211 "#endif", 3212 Style); 3213 verifyFormat("#if A\n" 3214 "# define MACRO \\\n" 3215 " void a(int x) { \\\n" 3216 " b(); \\\n" 3217 " c(); \\\n" 3218 " d(); \\\n" 3219 " e(); \\\n" 3220 " f(); \\\n" 3221 " }\n" 3222 "#endif", 3223 Style); 3224 // Comments before include guard. 3225 verifyFormat("// file comment\n" 3226 "// file comment\n" 3227 "#ifndef HEADER_H\n" 3228 "#define HEADER_H\n" 3229 "code();\n" 3230 "#endif", 3231 Style); 3232 // Test with include guards. 3233 verifyFormat("#ifndef HEADER_H\n" 3234 "#define HEADER_H\n" 3235 "code();\n" 3236 "#endif", 3237 Style); 3238 // Include guards must have a #define with the same variable immediately 3239 // after #ifndef. 3240 verifyFormat("#ifndef NOT_GUARD\n" 3241 "# define FOO\n" 3242 "code();\n" 3243 "#endif", 3244 Style); 3245 3246 // Include guards must cover the entire file. 3247 verifyFormat("code();\n" 3248 "code();\n" 3249 "#ifndef NOT_GUARD\n" 3250 "# define NOT_GUARD\n" 3251 "code();\n" 3252 "#endif", 3253 Style); 3254 verifyFormat("#ifndef NOT_GUARD\n" 3255 "# define NOT_GUARD\n" 3256 "code();\n" 3257 "#endif\n" 3258 "code();", 3259 Style); 3260 // Test with trailing blank lines. 3261 verifyFormat("#ifndef HEADER_H\n" 3262 "#define HEADER_H\n" 3263 "code();\n" 3264 "#endif\n", 3265 Style); 3266 // Include guards don't have #else. 3267 verifyFormat("#ifndef NOT_GUARD\n" 3268 "# define NOT_GUARD\n" 3269 "code();\n" 3270 "#else\n" 3271 "#endif", 3272 Style); 3273 verifyFormat("#ifndef NOT_GUARD\n" 3274 "# define NOT_GUARD\n" 3275 "code();\n" 3276 "#elif FOO\n" 3277 "#endif", 3278 Style); 3279 // Non-identifier #define after potential include guard. 3280 verifyFormat("#ifndef FOO\n" 3281 "# define 1\n" 3282 "#endif\n", 3283 Style); 3284 // #if closes past last non-preprocessor line. 3285 verifyFormat("#ifndef FOO\n" 3286 "#define FOO\n" 3287 "#if 1\n" 3288 "int i;\n" 3289 "# define A 0\n" 3290 "#endif\n" 3291 "#endif\n", 3292 Style); 3293 // Don't crash if there is an #elif directive without a condition. 3294 verifyFormat("#if 1\n" 3295 "int x;\n" 3296 "#elif\n" 3297 "int y;\n" 3298 "#else\n" 3299 "int z;\n" 3300 "#endif", 3301 Style); 3302 // FIXME: This doesn't handle the case where there's code between the 3303 // #ifndef and #define but all other conditions hold. This is because when 3304 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 3305 // previous code line yet, so we can't detect it. 3306 EXPECT_EQ("#ifndef NOT_GUARD\n" 3307 "code();\n" 3308 "#define NOT_GUARD\n" 3309 "code();\n" 3310 "#endif", 3311 format("#ifndef NOT_GUARD\n" 3312 "code();\n" 3313 "# define NOT_GUARD\n" 3314 "code();\n" 3315 "#endif", 3316 Style)); 3317 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 3318 // be outside an include guard. Examples are #pragma once and 3319 // #pragma GCC diagnostic, or anything else that does not change the meaning 3320 // of the file if it's included multiple times. 3321 EXPECT_EQ("#ifdef WIN32\n" 3322 "# pragma once\n" 3323 "#endif\n" 3324 "#ifndef HEADER_H\n" 3325 "# define HEADER_H\n" 3326 "code();\n" 3327 "#endif", 3328 format("#ifdef WIN32\n" 3329 "# pragma once\n" 3330 "#endif\n" 3331 "#ifndef HEADER_H\n" 3332 "#define HEADER_H\n" 3333 "code();\n" 3334 "#endif", 3335 Style)); 3336 // FIXME: This does not detect when there is a single non-preprocessor line 3337 // in front of an include-guard-like structure where other conditions hold 3338 // because ScopedLineState hides the line. 3339 EXPECT_EQ("code();\n" 3340 "#ifndef HEADER_H\n" 3341 "#define HEADER_H\n" 3342 "code();\n" 3343 "#endif", 3344 format("code();\n" 3345 "#ifndef HEADER_H\n" 3346 "# define HEADER_H\n" 3347 "code();\n" 3348 "#endif", 3349 Style)); 3350 // Keep comments aligned with #, otherwise indent comments normally. These 3351 // tests cannot use verifyFormat because messUp manipulates leading 3352 // whitespace. 3353 { 3354 const char *Expected = "" 3355 "void f() {\n" 3356 "#if 1\n" 3357 "// Preprocessor aligned.\n" 3358 "# define A 0\n" 3359 " // Code. Separated by blank line.\n" 3360 "\n" 3361 "# define B 0\n" 3362 " // Code. Not aligned with #\n" 3363 "# define C 0\n" 3364 "#endif"; 3365 const char *ToFormat = "" 3366 "void f() {\n" 3367 "#if 1\n" 3368 "// Preprocessor aligned.\n" 3369 "# define A 0\n" 3370 "// Code. Separated by blank line.\n" 3371 "\n" 3372 "# define B 0\n" 3373 " // Code. Not aligned with #\n" 3374 "# define C 0\n" 3375 "#endif"; 3376 EXPECT_EQ(Expected, format(ToFormat, Style)); 3377 EXPECT_EQ(Expected, format(Expected, Style)); 3378 } 3379 // Keep block quotes aligned. 3380 { 3381 const char *Expected = "" 3382 "void f() {\n" 3383 "#if 1\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 "#endif"; 3392 const char *ToFormat = "" 3393 "void f() {\n" 3394 "#if 1\n" 3395 "/* Preprocessor aligned. */\n" 3396 "# define A 0\n" 3397 "/* Code. Separated by blank line. */\n" 3398 "\n" 3399 "# define B 0\n" 3400 " /* Code. Not aligned with # */\n" 3401 "# define C 0\n" 3402 "#endif"; 3403 EXPECT_EQ(Expected, format(ToFormat, Style)); 3404 EXPECT_EQ(Expected, format(Expected, Style)); 3405 } 3406 // Keep comments aligned with un-indented directives. 3407 { 3408 const char *Expected = "" 3409 "void f() {\n" 3410 "// Preprocessor aligned.\n" 3411 "#define A 0\n" 3412 " // Code. Separated by blank line.\n" 3413 "\n" 3414 "#define B 0\n" 3415 " // Code. Not aligned with #\n" 3416 "#define C 0\n"; 3417 const char *ToFormat = "" 3418 "void f() {\n" 3419 "// Preprocessor aligned.\n" 3420 "#define A 0\n" 3421 "// Code. Separated by blank line.\n" 3422 "\n" 3423 "#define B 0\n" 3424 " // Code. Not aligned with #\n" 3425 "#define C 0\n"; 3426 EXPECT_EQ(Expected, format(ToFormat, Style)); 3427 EXPECT_EQ(Expected, format(Expected, Style)); 3428 } 3429 // Test AfterHash with tabs. 3430 { 3431 FormatStyle Tabbed = Style; 3432 Tabbed.UseTab = FormatStyle::UT_Always; 3433 Tabbed.IndentWidth = 8; 3434 Tabbed.TabWidth = 8; 3435 verifyFormat("#ifdef _WIN32\n" 3436 "#\tdefine A 0\n" 3437 "#\tifdef VAR2\n" 3438 "#\t\tdefine B 1\n" 3439 "#\t\tinclude <someheader.h>\n" 3440 "#\t\tdefine MACRO \\\n" 3441 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3442 "#\tendif\n" 3443 "#else\n" 3444 "#\tdefine A 1\n" 3445 "#endif", 3446 Tabbed); 3447 } 3448 3449 // Regression test: Multiline-macro inside include guards. 3450 verifyFormat("#ifndef HEADER_H\n" 3451 "#define HEADER_H\n" 3452 "#define A() \\\n" 3453 " int i; \\\n" 3454 " int j;\n" 3455 "#endif // HEADER_H", 3456 getLLVMStyleWithColumns(20)); 3457 3458 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3459 // Basic before hash indent tests 3460 verifyFormat("#ifdef _WIN32\n" 3461 " #define A 0\n" 3462 " #ifdef VAR2\n" 3463 " #define B 1\n" 3464 " #include <someheader.h>\n" 3465 " #define MACRO \\\n" 3466 " some_very_long_func_aaaaaaaaaa();\n" 3467 " #endif\n" 3468 "#else\n" 3469 " #define A 1\n" 3470 "#endif", 3471 Style); 3472 verifyFormat("#if A\n" 3473 " #define MACRO \\\n" 3474 " void a(int x) { \\\n" 3475 " b(); \\\n" 3476 " c(); \\\n" 3477 " d(); \\\n" 3478 " e(); \\\n" 3479 " f(); \\\n" 3480 " }\n" 3481 "#endif", 3482 Style); 3483 // Keep comments aligned with indented directives. These 3484 // tests cannot use verifyFormat because messUp manipulates leading 3485 // whitespace. 3486 { 3487 const char *Expected = "void f() {\n" 3488 "// Aligned to preprocessor.\n" 3489 "#if 1\n" 3490 " // Aligned to code.\n" 3491 " int a;\n" 3492 " #if 1\n" 3493 " // Aligned to preprocessor.\n" 3494 " #define A 0\n" 3495 " // Aligned to code.\n" 3496 " int b;\n" 3497 " #endif\n" 3498 "#endif\n" 3499 "}"; 3500 const char *ToFormat = "void f() {\n" 3501 "// Aligned to preprocessor.\n" 3502 "#if 1\n" 3503 "// Aligned to code.\n" 3504 "int a;\n" 3505 "#if 1\n" 3506 "// Aligned to preprocessor.\n" 3507 "#define A 0\n" 3508 "// Aligned to code.\n" 3509 "int b;\n" 3510 "#endif\n" 3511 "#endif\n" 3512 "}"; 3513 EXPECT_EQ(Expected, format(ToFormat, Style)); 3514 EXPECT_EQ(Expected, format(Expected, Style)); 3515 } 3516 { 3517 const char *Expected = "void f() {\n" 3518 "/* Aligned to preprocessor. */\n" 3519 "#if 1\n" 3520 " /* Aligned to code. */\n" 3521 " int a;\n" 3522 " #if 1\n" 3523 " /* Aligned to preprocessor. */\n" 3524 " #define A 0\n" 3525 " /* Aligned to code. */\n" 3526 " int b;\n" 3527 " #endif\n" 3528 "#endif\n" 3529 "}"; 3530 const char *ToFormat = "void f() {\n" 3531 "/* Aligned to preprocessor. */\n" 3532 "#if 1\n" 3533 "/* Aligned to code. */\n" 3534 "int a;\n" 3535 "#if 1\n" 3536 "/* Aligned to preprocessor. */\n" 3537 "#define A 0\n" 3538 "/* Aligned to code. */\n" 3539 "int b;\n" 3540 "#endif\n" 3541 "#endif\n" 3542 "}"; 3543 EXPECT_EQ(Expected, format(ToFormat, Style)); 3544 EXPECT_EQ(Expected, format(Expected, Style)); 3545 } 3546 3547 // Test single comment before preprocessor 3548 verifyFormat("// Comment\n" 3549 "\n" 3550 "#if 1\n" 3551 "#endif", 3552 Style); 3553 } 3554 3555 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3556 verifyFormat("{\n { a #c; }\n}"); 3557 } 3558 3559 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3560 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3561 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3562 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3563 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3564 } 3565 3566 TEST_F(FormatTest, EscapedNewlines) { 3567 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3568 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3569 format("#define A \\\nint i;\\\n int j;", Narrow)); 3570 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3571 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3572 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3573 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3574 3575 FormatStyle AlignLeft = getLLVMStyle(); 3576 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3577 EXPECT_EQ("#define MACRO(x) \\\n" 3578 "private: \\\n" 3579 " int x(int a);\n", 3580 format("#define MACRO(x) \\\n" 3581 "private: \\\n" 3582 " int x(int a);\n", 3583 AlignLeft)); 3584 3585 // CRLF line endings 3586 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3587 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3588 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3589 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3590 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3591 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3592 EXPECT_EQ("#define MACRO(x) \\\r\n" 3593 "private: \\\r\n" 3594 " int x(int a);\r\n", 3595 format("#define MACRO(x) \\\r\n" 3596 "private: \\\r\n" 3597 " int x(int a);\r\n", 3598 AlignLeft)); 3599 3600 FormatStyle DontAlign = getLLVMStyle(); 3601 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3602 DontAlign.MaxEmptyLinesToKeep = 3; 3603 // FIXME: can't use verifyFormat here because the newline before 3604 // "public:" is not inserted the first time it's reformatted 3605 EXPECT_EQ("#define A \\\n" 3606 " class Foo { \\\n" 3607 " void bar(); \\\n" 3608 "\\\n" 3609 "\\\n" 3610 "\\\n" 3611 " public: \\\n" 3612 " void baz(); \\\n" 3613 " };", 3614 format("#define A \\\n" 3615 " class Foo { \\\n" 3616 " void bar(); \\\n" 3617 "\\\n" 3618 "\\\n" 3619 "\\\n" 3620 " public: \\\n" 3621 " void baz(); \\\n" 3622 " };", 3623 DontAlign)); 3624 } 3625 3626 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3627 verifyFormat("#define A \\\n" 3628 " int v( \\\n" 3629 " a); \\\n" 3630 " int i;", 3631 getLLVMStyleWithColumns(11)); 3632 } 3633 3634 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3635 EXPECT_EQ( 3636 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3637 " \\\n" 3638 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3639 "\n" 3640 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3641 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3642 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3643 "\\\n" 3644 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3645 " \n" 3646 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3647 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3648 } 3649 3650 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3651 EXPECT_EQ("int\n" 3652 "#define A\n" 3653 " a;", 3654 format("int\n#define A\na;")); 3655 verifyFormat("functionCallTo(\n" 3656 " someOtherFunction(\n" 3657 " withSomeParameters, whichInSequence,\n" 3658 " areLongerThanALine(andAnotherCall,\n" 3659 "#define A B\n" 3660 " withMoreParamters,\n" 3661 " whichStronglyInfluenceTheLayout),\n" 3662 " andMoreParameters),\n" 3663 " trailing);", 3664 getLLVMStyleWithColumns(69)); 3665 verifyFormat("Foo::Foo()\n" 3666 "#ifdef BAR\n" 3667 " : baz(0)\n" 3668 "#endif\n" 3669 "{\n" 3670 "}"); 3671 verifyFormat("void f() {\n" 3672 " if (true)\n" 3673 "#ifdef A\n" 3674 " f(42);\n" 3675 " x();\n" 3676 "#else\n" 3677 " g();\n" 3678 " x();\n" 3679 "#endif\n" 3680 "}"); 3681 verifyFormat("void f(param1, param2,\n" 3682 " param3,\n" 3683 "#ifdef A\n" 3684 " param4(param5,\n" 3685 "#ifdef A1\n" 3686 " param6,\n" 3687 "#ifdef A2\n" 3688 " param7),\n" 3689 "#else\n" 3690 " param8),\n" 3691 " param9,\n" 3692 "#endif\n" 3693 " param10,\n" 3694 "#endif\n" 3695 " param11)\n" 3696 "#else\n" 3697 " param12)\n" 3698 "#endif\n" 3699 "{\n" 3700 " x();\n" 3701 "}", 3702 getLLVMStyleWithColumns(28)); 3703 verifyFormat("#if 1\n" 3704 "int i;"); 3705 verifyFormat("#if 1\n" 3706 "#endif\n" 3707 "#if 1\n" 3708 "#else\n" 3709 "#endif\n"); 3710 verifyFormat("DEBUG({\n" 3711 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3712 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3713 "});\n" 3714 "#if a\n" 3715 "#else\n" 3716 "#endif"); 3717 3718 verifyIncompleteFormat("void f(\n" 3719 "#if A\n" 3720 ");\n" 3721 "#else\n" 3722 "#endif"); 3723 } 3724 3725 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3726 verifyFormat("#endif\n" 3727 "#if B"); 3728 } 3729 3730 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3731 FormatStyle SingleLine = getLLVMStyle(); 3732 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3733 verifyFormat("#if 0\n" 3734 "#elif 1\n" 3735 "#endif\n" 3736 "void foo() {\n" 3737 " if (test) foo2();\n" 3738 "}", 3739 SingleLine); 3740 } 3741 3742 TEST_F(FormatTest, LayoutBlockInsideParens) { 3743 verifyFormat("functionCall({ int i; });"); 3744 verifyFormat("functionCall({\n" 3745 " int i;\n" 3746 " int j;\n" 3747 "});"); 3748 verifyFormat("functionCall(\n" 3749 " {\n" 3750 " int i;\n" 3751 " int j;\n" 3752 " },\n" 3753 " aaaa, bbbb, cccc);"); 3754 verifyFormat("functionA(functionB({\n" 3755 " int i;\n" 3756 " int j;\n" 3757 " }),\n" 3758 " aaaa, bbbb, cccc);"); 3759 verifyFormat("functionCall(\n" 3760 " {\n" 3761 " int i;\n" 3762 " int j;\n" 3763 " },\n" 3764 " aaaa, bbbb, // comment\n" 3765 " cccc);"); 3766 verifyFormat("functionA(functionB({\n" 3767 " int i;\n" 3768 " int j;\n" 3769 " }),\n" 3770 " aaaa, bbbb, // comment\n" 3771 " cccc);"); 3772 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3773 verifyFormat("functionCall(aaaa, bbbb, {\n" 3774 " int i;\n" 3775 " int j;\n" 3776 "});"); 3777 verifyFormat( 3778 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3779 " {\n" 3780 " int i; // break\n" 3781 " },\n" 3782 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3783 " ccccccccccccccccc));"); 3784 verifyFormat("DEBUG({\n" 3785 " if (a)\n" 3786 " f();\n" 3787 "});"); 3788 } 3789 3790 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3791 EXPECT_EQ("SOME_MACRO { int i; }\n" 3792 "int i;", 3793 format(" SOME_MACRO {int i;} int i;")); 3794 } 3795 3796 TEST_F(FormatTest, LayoutNestedBlocks) { 3797 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3798 " struct s {\n" 3799 " int i;\n" 3800 " };\n" 3801 " s kBitsToOs[] = {{10}};\n" 3802 " for (int i = 0; i < 10; ++i)\n" 3803 " return;\n" 3804 "}"); 3805 verifyFormat("call(parameter, {\n" 3806 " something();\n" 3807 " // Comment using all columns.\n" 3808 " somethingelse();\n" 3809 "});", 3810 getLLVMStyleWithColumns(40)); 3811 verifyFormat("DEBUG( //\n" 3812 " { f(); }, a);"); 3813 verifyFormat("DEBUG( //\n" 3814 " {\n" 3815 " f(); //\n" 3816 " },\n" 3817 " a);"); 3818 3819 EXPECT_EQ("call(parameter, {\n" 3820 " something();\n" 3821 " // Comment too\n" 3822 " // looooooooooong.\n" 3823 " somethingElse();\n" 3824 "});", 3825 format("call(parameter, {\n" 3826 " something();\n" 3827 " // Comment too looooooooooong.\n" 3828 " somethingElse();\n" 3829 "});", 3830 getLLVMStyleWithColumns(29))); 3831 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3832 EXPECT_EQ("DEBUG({ // comment\n" 3833 " int i;\n" 3834 "});", 3835 format("DEBUG({ // comment\n" 3836 "int i;\n" 3837 "});")); 3838 EXPECT_EQ("DEBUG({\n" 3839 " int i;\n" 3840 "\n" 3841 " // comment\n" 3842 " int j;\n" 3843 "});", 3844 format("DEBUG({\n" 3845 " int i;\n" 3846 "\n" 3847 " // comment\n" 3848 " int j;\n" 3849 "});")); 3850 3851 verifyFormat("DEBUG({\n" 3852 " if (a)\n" 3853 " return;\n" 3854 "});"); 3855 verifyGoogleFormat("DEBUG({\n" 3856 " if (a) return;\n" 3857 "});"); 3858 FormatStyle Style = getGoogleStyle(); 3859 Style.ColumnLimit = 45; 3860 verifyFormat("Debug(\n" 3861 " aaaaa,\n" 3862 " {\n" 3863 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 3864 " },\n" 3865 " a);", 3866 Style); 3867 3868 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 3869 3870 verifyNoCrash("^{v^{a}}"); 3871 } 3872 3873 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 3874 EXPECT_EQ("#define MACRO() \\\n" 3875 " Debug(aaa, /* force line break */ \\\n" 3876 " { \\\n" 3877 " int i; \\\n" 3878 " int j; \\\n" 3879 " })", 3880 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 3881 " { int i; int j; })", 3882 getGoogleStyle())); 3883 3884 EXPECT_EQ("#define A \\\n" 3885 " [] { \\\n" 3886 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3887 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 3888 " }", 3889 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3890 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 3891 getGoogleStyle())); 3892 } 3893 3894 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 3895 EXPECT_EQ("{}", format("{}")); 3896 verifyFormat("enum E {};"); 3897 verifyFormat("enum E {}"); 3898 FormatStyle Style = getLLVMStyle(); 3899 Style.SpaceInEmptyBlock = true; 3900 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 3901 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 3902 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 3903 } 3904 3905 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 3906 FormatStyle Style = getLLVMStyle(); 3907 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 3908 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 3909 verifyFormat("FOO_BEGIN\n" 3910 " FOO_ENTRY\n" 3911 "FOO_END", 3912 Style); 3913 verifyFormat("FOO_BEGIN\n" 3914 " NESTED_FOO_BEGIN\n" 3915 " NESTED_FOO_ENTRY\n" 3916 " NESTED_FOO_END\n" 3917 "FOO_END", 3918 Style); 3919 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 3920 " int x;\n" 3921 " x = 1;\n" 3922 "FOO_END(Baz)", 3923 Style); 3924 } 3925 3926 //===----------------------------------------------------------------------===// 3927 // Line break tests. 3928 //===----------------------------------------------------------------------===// 3929 3930 TEST_F(FormatTest, PreventConfusingIndents) { 3931 verifyFormat( 3932 "void f() {\n" 3933 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 3934 " parameter, parameter, parameter)),\n" 3935 " SecondLongCall(parameter));\n" 3936 "}"); 3937 verifyFormat( 3938 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3939 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3940 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3941 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 3942 verifyFormat( 3943 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3944 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 3945 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 3946 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 3947 verifyFormat( 3948 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 3949 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 3950 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 3951 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 3952 verifyFormat("int a = bbbb && ccc &&\n" 3953 " fffff(\n" 3954 "#define A Just forcing a new line\n" 3955 " ddd);"); 3956 } 3957 3958 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 3959 verifyFormat( 3960 "bool aaaaaaa =\n" 3961 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 3962 " bbbbbbbb();"); 3963 verifyFormat( 3964 "bool aaaaaaa =\n" 3965 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 3966 " bbbbbbbb();"); 3967 3968 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3969 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 3970 " ccccccccc == ddddddddddd;"); 3971 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3972 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 3973 " ccccccccc == ddddddddddd;"); 3974 verifyFormat( 3975 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 3976 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 3977 " ccccccccc == ddddddddddd;"); 3978 3979 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3980 " aaaaaa) &&\n" 3981 " bbbbbb && cccccc;"); 3982 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3983 " aaaaaa) >>\n" 3984 " bbbbbb;"); 3985 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 3986 " SourceMgr.getSpellingColumnNumber(\n" 3987 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 3988 " 1);"); 3989 3990 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3991 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 3992 " cccccc) {\n}"); 3993 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3994 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3995 " cccccc) {\n}"); 3996 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3997 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3998 " cccccc) {\n}"); 3999 verifyFormat("b = a &&\n" 4000 " // Comment\n" 4001 " b.c && d;"); 4002 4003 // If the LHS of a comparison is not a binary expression itself, the 4004 // additional linebreak confuses many people. 4005 verifyFormat( 4006 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4007 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 4008 "}"); 4009 verifyFormat( 4010 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4011 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4012 "}"); 4013 verifyFormat( 4014 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 4015 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4016 "}"); 4017 verifyFormat( 4018 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4019 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 4020 "}"); 4021 // Even explicit parentheses stress the precedence enough to make the 4022 // additional break unnecessary. 4023 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4024 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4025 "}"); 4026 // This cases is borderline, but with the indentation it is still readable. 4027 verifyFormat( 4028 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4029 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4030 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 4031 "}", 4032 getLLVMStyleWithColumns(75)); 4033 4034 // If the LHS is a binary expression, we should still use the additional break 4035 // as otherwise the formatting hides the operator precedence. 4036 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4037 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4038 " 5) {\n" 4039 "}"); 4040 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4041 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 4042 " 5) {\n" 4043 "}"); 4044 4045 FormatStyle OnePerLine = getLLVMStyle(); 4046 OnePerLine.BinPackParameters = false; 4047 verifyFormat( 4048 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4049 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4050 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 4051 OnePerLine); 4052 4053 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 4054 " .aaa(aaaaaaaaaaaaa) *\n" 4055 " aaaaaaa +\n" 4056 " aaaaaaa;", 4057 getLLVMStyleWithColumns(40)); 4058 } 4059 4060 TEST_F(FormatTest, ExpressionIndentation) { 4061 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4062 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4063 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4064 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4065 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 4066 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 4067 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4068 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 4069 " ccccccccccccccccccccccccccccccccccccccccc;"); 4070 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4071 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4072 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4073 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4074 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4075 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4076 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4077 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4078 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4079 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4080 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4081 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4082 verifyFormat("if () {\n" 4083 "} else if (aaaaa && bbbbb > // break\n" 4084 " ccccc) {\n" 4085 "}"); 4086 verifyFormat("if () {\n" 4087 "} else if constexpr (aaaaa && bbbbb > // break\n" 4088 " ccccc) {\n" 4089 "}"); 4090 verifyFormat("if () {\n" 4091 "} else if CONSTEXPR (aaaaa && bbbbb > // break\n" 4092 " ccccc) {\n" 4093 "}"); 4094 verifyFormat("if () {\n" 4095 "} else if (aaaaa &&\n" 4096 " bbbbb > // break\n" 4097 " ccccc &&\n" 4098 " ddddd) {\n" 4099 "}"); 4100 4101 // Presence of a trailing comment used to change indentation of b. 4102 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 4103 " b;\n" 4104 "return aaaaaaaaaaaaaaaaaaa +\n" 4105 " b; //", 4106 getLLVMStyleWithColumns(30)); 4107 } 4108 4109 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 4110 // Not sure what the best system is here. Like this, the LHS can be found 4111 // immediately above an operator (everything with the same or a higher 4112 // indent). The RHS is aligned right of the operator and so compasses 4113 // everything until something with the same indent as the operator is found. 4114 // FIXME: Is this a good system? 4115 FormatStyle Style = getLLVMStyle(); 4116 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 4117 verifyFormat( 4118 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4119 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4120 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4121 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4122 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4123 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4124 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4125 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4126 " > ccccccccccccccccccccccccccccccccccccccccc;", 4127 Style); 4128 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4129 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4130 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4131 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4132 Style); 4133 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4134 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4135 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4136 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4137 Style); 4138 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4139 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4140 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4141 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4142 Style); 4143 verifyFormat("if () {\n" 4144 "} else if (aaaaa\n" 4145 " && bbbbb // break\n" 4146 " > ccccc) {\n" 4147 "}", 4148 Style); 4149 verifyFormat("return (a)\n" 4150 " // comment\n" 4151 " + b;", 4152 Style); 4153 verifyFormat( 4154 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4155 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4156 " + cc;", 4157 Style); 4158 4159 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4160 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4161 Style); 4162 4163 // Forced by comments. 4164 verifyFormat( 4165 "unsigned ContentSize =\n" 4166 " sizeof(int16_t) // DWARF ARange version number\n" 4167 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4168 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4169 " + sizeof(int8_t); // Segment Size (in bytes)"); 4170 4171 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 4172 " == boost::fusion::at_c<1>(iiii).second;", 4173 Style); 4174 4175 Style.ColumnLimit = 60; 4176 verifyFormat("zzzzzzzzzz\n" 4177 " = bbbbbbbbbbbbbbbbb\n" 4178 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 4179 Style); 4180 4181 Style.ColumnLimit = 80; 4182 Style.IndentWidth = 4; 4183 Style.TabWidth = 4; 4184 Style.UseTab = FormatStyle::UT_Always; 4185 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4186 Style.AlignOperands = false; 4187 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 4188 "\t&& (someOtherLongishConditionPart1\n" 4189 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 4190 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && " 4191 "(someOtherLongishConditionPart1 || " 4192 "someOtherEvenLongerNestedConditionPart2);", 4193 Style)); 4194 } 4195 4196 TEST_F(FormatTest, EnforcedOperatorWraps) { 4197 // Here we'd like to wrap after the || operators, but a comment is forcing an 4198 // earlier wrap. 4199 verifyFormat("bool x = aaaaa //\n" 4200 " || bbbbb\n" 4201 " //\n" 4202 " || cccc;"); 4203 } 4204 4205 TEST_F(FormatTest, NoOperandAlignment) { 4206 FormatStyle Style = getLLVMStyle(); 4207 Style.AlignOperands = false; 4208 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 4209 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4210 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4211 Style); 4212 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4213 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4214 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4215 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4216 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4217 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4218 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4219 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4220 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4221 " > ccccccccccccccccccccccccccccccccccccccccc;", 4222 Style); 4223 4224 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4225 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4226 " + cc;", 4227 Style); 4228 verifyFormat("int a = aa\n" 4229 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4230 " * cccccccccccccccccccccccccccccccccccc;\n", 4231 Style); 4232 4233 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4234 verifyFormat("return (a > b\n" 4235 " // comment1\n" 4236 " // comment2\n" 4237 " || c);", 4238 Style); 4239 } 4240 4241 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 4242 FormatStyle Style = getLLVMStyle(); 4243 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4244 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4245 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4246 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4247 Style); 4248 } 4249 4250 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 4251 FormatStyle Style = getLLVMStyle(); 4252 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4253 Style.BinPackArguments = false; 4254 Style.ColumnLimit = 40; 4255 verifyFormat("void test() {\n" 4256 " someFunction(\n" 4257 " this + argument + is + quite\n" 4258 " + long + so + it + gets + wrapped\n" 4259 " + but + remains + bin - packed);\n" 4260 "}", 4261 Style); 4262 verifyFormat("void test() {\n" 4263 " someFunction(arg1,\n" 4264 " this + argument + is\n" 4265 " + quite + long + so\n" 4266 " + it + gets + wrapped\n" 4267 " + but + remains + bin\n" 4268 " - packed,\n" 4269 " arg3);\n" 4270 "}", 4271 Style); 4272 verifyFormat("void test() {\n" 4273 " someFunction(\n" 4274 " arg1,\n" 4275 " this + argument + has\n" 4276 " + anotherFunc(nested,\n" 4277 " calls + whose\n" 4278 " + arguments\n" 4279 " + are + also\n" 4280 " + wrapped,\n" 4281 " in + addition)\n" 4282 " + to + being + bin - packed,\n" 4283 " arg3);\n" 4284 "}", 4285 Style); 4286 4287 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4288 verifyFormat("void test() {\n" 4289 " someFunction(\n" 4290 " arg1,\n" 4291 " this + argument + has +\n" 4292 " anotherFunc(nested,\n" 4293 " calls + whose +\n" 4294 " arguments +\n" 4295 " are + also +\n" 4296 " wrapped,\n" 4297 " in + addition) +\n" 4298 " to + being + bin - packed,\n" 4299 " arg3);\n" 4300 "}", 4301 Style); 4302 } 4303 4304 TEST_F(FormatTest, ConstructorInitializers) { 4305 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4306 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 4307 getLLVMStyleWithColumns(45)); 4308 verifyFormat("Constructor()\n" 4309 " : Inttializer(FitsOnTheLine) {}", 4310 getLLVMStyleWithColumns(44)); 4311 verifyFormat("Constructor()\n" 4312 " : Inttializer(FitsOnTheLine) {}", 4313 getLLVMStyleWithColumns(43)); 4314 4315 verifyFormat("template <typename T>\n" 4316 "Constructor() : Initializer(FitsOnTheLine) {}", 4317 getLLVMStyleWithColumns(45)); 4318 4319 verifyFormat( 4320 "SomeClass::Constructor()\n" 4321 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4322 4323 verifyFormat( 4324 "SomeClass::Constructor()\n" 4325 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4326 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 4327 verifyFormat( 4328 "SomeClass::Constructor()\n" 4329 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4330 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4331 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4332 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4333 " : aaaaaaaaaa(aaaaaa) {}"); 4334 4335 verifyFormat("Constructor()\n" 4336 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4337 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4338 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4339 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 4340 4341 verifyFormat("Constructor()\n" 4342 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4343 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4344 4345 verifyFormat("Constructor(int Parameter = 0)\n" 4346 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4347 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 4348 verifyFormat("Constructor()\n" 4349 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4350 "}", 4351 getLLVMStyleWithColumns(60)); 4352 verifyFormat("Constructor()\n" 4353 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4354 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 4355 4356 // Here a line could be saved by splitting the second initializer onto two 4357 // lines, but that is not desirable. 4358 verifyFormat("Constructor()\n" 4359 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4360 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4361 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4362 4363 FormatStyle OnePerLine = getLLVMStyle(); 4364 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4365 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 4366 verifyFormat("SomeClass::Constructor()\n" 4367 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4368 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4369 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4370 OnePerLine); 4371 verifyFormat("SomeClass::Constructor()\n" 4372 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4373 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4374 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4375 OnePerLine); 4376 verifyFormat("MyClass::MyClass(int var)\n" 4377 " : some_var_(var), // 4 space indent\n" 4378 " some_other_var_(var + 1) { // lined up\n" 4379 "}", 4380 OnePerLine); 4381 verifyFormat("Constructor()\n" 4382 " : aaaaa(aaaaaa),\n" 4383 " aaaaa(aaaaaa),\n" 4384 " aaaaa(aaaaaa),\n" 4385 " aaaaa(aaaaaa),\n" 4386 " aaaaa(aaaaaa) {}", 4387 OnePerLine); 4388 verifyFormat("Constructor()\n" 4389 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4390 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4391 OnePerLine); 4392 OnePerLine.BinPackParameters = false; 4393 verifyFormat( 4394 "Constructor()\n" 4395 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4396 " aaaaaaaaaaa().aaa(),\n" 4397 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4398 OnePerLine); 4399 OnePerLine.ColumnLimit = 60; 4400 verifyFormat("Constructor()\n" 4401 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4402 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4403 OnePerLine); 4404 4405 EXPECT_EQ("Constructor()\n" 4406 " : // Comment forcing unwanted break.\n" 4407 " aaaa(aaaa) {}", 4408 format("Constructor() :\n" 4409 " // Comment forcing unwanted break.\n" 4410 " aaaa(aaaa) {}")); 4411 } 4412 4413 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 4414 FormatStyle Style = getLLVMStyle(); 4415 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4416 Style.ColumnLimit = 60; 4417 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4418 Style.AllowAllConstructorInitializersOnNextLine = true; 4419 Style.BinPackParameters = false; 4420 4421 for (int i = 0; i < 4; ++i) { 4422 // Test all combinations of parameters that should not have an effect. 4423 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4424 Style.AllowAllArgumentsOnNextLine = i & 2; 4425 4426 Style.AllowAllConstructorInitializersOnNextLine = true; 4427 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4428 verifyFormat("Constructor()\n" 4429 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4430 Style); 4431 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4432 4433 Style.AllowAllConstructorInitializersOnNextLine = false; 4434 verifyFormat("Constructor()\n" 4435 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4436 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4437 Style); 4438 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4439 4440 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4441 Style.AllowAllConstructorInitializersOnNextLine = true; 4442 verifyFormat("Constructor()\n" 4443 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4444 Style); 4445 4446 Style.AllowAllConstructorInitializersOnNextLine = false; 4447 verifyFormat("Constructor()\n" 4448 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4449 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4450 Style); 4451 4452 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4453 Style.AllowAllConstructorInitializersOnNextLine = true; 4454 verifyFormat("Constructor() :\n" 4455 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4456 Style); 4457 4458 Style.AllowAllConstructorInitializersOnNextLine = false; 4459 verifyFormat("Constructor() :\n" 4460 " aaaaaaaaaaaaaaaaaa(a),\n" 4461 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4462 Style); 4463 } 4464 4465 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4466 // AllowAllConstructorInitializersOnNextLine in all 4467 // BreakConstructorInitializers modes 4468 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4469 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4470 Style.AllowAllConstructorInitializersOnNextLine = false; 4471 verifyFormat("SomeClassWithALongName::Constructor(\n" 4472 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4473 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4474 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4475 Style); 4476 4477 Style.AllowAllConstructorInitializersOnNextLine = true; 4478 verifyFormat("SomeClassWithALongName::Constructor(\n" 4479 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4480 " int bbbbbbbbbbbbb,\n" 4481 " int cccccccccccccccc)\n" 4482 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4483 Style); 4484 4485 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4486 Style.AllowAllConstructorInitializersOnNextLine = false; 4487 verifyFormat("SomeClassWithALongName::Constructor(\n" 4488 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4489 " int bbbbbbbbbbbbb)\n" 4490 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4491 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4492 Style); 4493 4494 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4495 4496 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4497 verifyFormat("SomeClassWithALongName::Constructor(\n" 4498 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4499 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4500 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4501 Style); 4502 4503 Style.AllowAllConstructorInitializersOnNextLine = true; 4504 verifyFormat("SomeClassWithALongName::Constructor(\n" 4505 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4506 " int bbbbbbbbbbbbb,\n" 4507 " int cccccccccccccccc)\n" 4508 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4509 Style); 4510 4511 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4512 Style.AllowAllConstructorInitializersOnNextLine = false; 4513 verifyFormat("SomeClassWithALongName::Constructor(\n" 4514 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4515 " int bbbbbbbbbbbbb)\n" 4516 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4517 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4518 Style); 4519 4520 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4521 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4522 verifyFormat("SomeClassWithALongName::Constructor(\n" 4523 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4524 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4525 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4526 Style); 4527 4528 Style.AllowAllConstructorInitializersOnNextLine = true; 4529 verifyFormat("SomeClassWithALongName::Constructor(\n" 4530 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4531 " int bbbbbbbbbbbbb,\n" 4532 " int cccccccccccccccc) :\n" 4533 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4534 Style); 4535 4536 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4537 Style.AllowAllConstructorInitializersOnNextLine = false; 4538 verifyFormat("SomeClassWithALongName::Constructor(\n" 4539 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4540 " int bbbbbbbbbbbbb) :\n" 4541 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4542 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4543 Style); 4544 } 4545 4546 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4547 FormatStyle Style = getLLVMStyle(); 4548 Style.ColumnLimit = 60; 4549 Style.BinPackArguments = false; 4550 for (int i = 0; i < 4; ++i) { 4551 // Test all combinations of parameters that should not have an effect. 4552 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4553 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4554 4555 Style.AllowAllArgumentsOnNextLine = true; 4556 verifyFormat("void foo() {\n" 4557 " FunctionCallWithReallyLongName(\n" 4558 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4559 "}", 4560 Style); 4561 Style.AllowAllArgumentsOnNextLine = false; 4562 verifyFormat("void foo() {\n" 4563 " FunctionCallWithReallyLongName(\n" 4564 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4565 " bbbbbbbbbbbb);\n" 4566 "}", 4567 Style); 4568 4569 Style.AllowAllArgumentsOnNextLine = true; 4570 verifyFormat("void foo() {\n" 4571 " auto VariableWithReallyLongName = {\n" 4572 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4573 "}", 4574 Style); 4575 Style.AllowAllArgumentsOnNextLine = false; 4576 verifyFormat("void foo() {\n" 4577 " auto VariableWithReallyLongName = {\n" 4578 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4579 " bbbbbbbbbbbb};\n" 4580 "}", 4581 Style); 4582 } 4583 4584 // This parameter should not affect declarations. 4585 Style.BinPackParameters = false; 4586 Style.AllowAllArgumentsOnNextLine = false; 4587 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4588 verifyFormat("void FunctionCallWithReallyLongName(\n" 4589 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4590 Style); 4591 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4592 verifyFormat("void FunctionCallWithReallyLongName(\n" 4593 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4594 " int bbbbbbbbbbbb);", 4595 Style); 4596 } 4597 4598 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4599 FormatStyle Style = getLLVMStyle(); 4600 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4601 4602 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4603 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4604 getStyleWithColumns(Style, 45)); 4605 verifyFormat("Constructor() :\n" 4606 " Initializer(FitsOnTheLine) {}", 4607 getStyleWithColumns(Style, 44)); 4608 verifyFormat("Constructor() :\n" 4609 " Initializer(FitsOnTheLine) {}", 4610 getStyleWithColumns(Style, 43)); 4611 4612 verifyFormat("template <typename T>\n" 4613 "Constructor() : Initializer(FitsOnTheLine) {}", 4614 getStyleWithColumns(Style, 50)); 4615 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4616 verifyFormat( 4617 "SomeClass::Constructor() :\n" 4618 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4619 Style); 4620 4621 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4622 verifyFormat( 4623 "SomeClass::Constructor() :\n" 4624 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4625 Style); 4626 4627 verifyFormat( 4628 "SomeClass::Constructor() :\n" 4629 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4630 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4631 Style); 4632 verifyFormat( 4633 "SomeClass::Constructor() :\n" 4634 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4635 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4636 Style); 4637 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4638 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4639 " aaaaaaaaaa(aaaaaa) {}", 4640 Style); 4641 4642 verifyFormat("Constructor() :\n" 4643 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4644 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4645 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4646 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4647 Style); 4648 4649 verifyFormat("Constructor() :\n" 4650 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4651 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4652 Style); 4653 4654 verifyFormat("Constructor(int Parameter = 0) :\n" 4655 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4656 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4657 Style); 4658 verifyFormat("Constructor() :\n" 4659 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4660 "}", 4661 getStyleWithColumns(Style, 60)); 4662 verifyFormat("Constructor() :\n" 4663 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4664 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4665 Style); 4666 4667 // Here a line could be saved by splitting the second initializer onto two 4668 // lines, but that is not desirable. 4669 verifyFormat("Constructor() :\n" 4670 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4671 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4672 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4673 Style); 4674 4675 FormatStyle OnePerLine = Style; 4676 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4677 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4678 verifyFormat("SomeClass::Constructor() :\n" 4679 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4680 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4681 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4682 OnePerLine); 4683 verifyFormat("SomeClass::Constructor() :\n" 4684 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4685 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4686 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4687 OnePerLine); 4688 verifyFormat("MyClass::MyClass(int var) :\n" 4689 " some_var_(var), // 4 space indent\n" 4690 " some_other_var_(var + 1) { // lined up\n" 4691 "}", 4692 OnePerLine); 4693 verifyFormat("Constructor() :\n" 4694 " aaaaa(aaaaaa),\n" 4695 " aaaaa(aaaaaa),\n" 4696 " aaaaa(aaaaaa),\n" 4697 " aaaaa(aaaaaa),\n" 4698 " aaaaa(aaaaaa) {}", 4699 OnePerLine); 4700 verifyFormat("Constructor() :\n" 4701 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4702 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4703 OnePerLine); 4704 OnePerLine.BinPackParameters = false; 4705 verifyFormat("Constructor() :\n" 4706 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4707 " aaaaaaaaaaa().aaa(),\n" 4708 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4709 OnePerLine); 4710 OnePerLine.ColumnLimit = 60; 4711 verifyFormat("Constructor() :\n" 4712 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4713 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4714 OnePerLine); 4715 4716 EXPECT_EQ("Constructor() :\n" 4717 " // Comment forcing unwanted break.\n" 4718 " aaaa(aaaa) {}", 4719 format("Constructor() :\n" 4720 " // Comment forcing unwanted break.\n" 4721 " aaaa(aaaa) {}", 4722 Style)); 4723 4724 Style.ColumnLimit = 0; 4725 verifyFormat("SomeClass::Constructor() :\n" 4726 " a(a) {}", 4727 Style); 4728 verifyFormat("SomeClass::Constructor() noexcept :\n" 4729 " a(a) {}", 4730 Style); 4731 verifyFormat("SomeClass::Constructor() :\n" 4732 " a(a), b(b), c(c) {}", 4733 Style); 4734 verifyFormat("SomeClass::Constructor() :\n" 4735 " a(a) {\n" 4736 " foo();\n" 4737 " bar();\n" 4738 "}", 4739 Style); 4740 4741 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4742 verifyFormat("SomeClass::Constructor() :\n" 4743 " a(a), b(b), c(c) {\n" 4744 "}", 4745 Style); 4746 verifyFormat("SomeClass::Constructor() :\n" 4747 " a(a) {\n" 4748 "}", 4749 Style); 4750 4751 Style.ColumnLimit = 80; 4752 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4753 Style.ConstructorInitializerIndentWidth = 2; 4754 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style); 4755 verifyFormat("SomeClass::Constructor() :\n" 4756 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4757 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 4758 Style); 4759 4760 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as 4761 // well 4762 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 4763 verifyFormat( 4764 "class SomeClass\n" 4765 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4766 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4767 Style); 4768 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 4769 verifyFormat( 4770 "class SomeClass\n" 4771 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4772 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4773 Style); 4774 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 4775 verifyFormat( 4776 "class SomeClass :\n" 4777 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4778 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4779 Style); 4780 } 4781 4782 #ifndef EXPENSIVE_CHECKS 4783 // Expensive checks enables libstdc++ checking which includes validating the 4784 // state of ranges used in std::priority_queue - this blows out the 4785 // runtime/scalability of the function and makes this test unacceptably slow. 4786 TEST_F(FormatTest, MemoizationTests) { 4787 // This breaks if the memoization lookup does not take \c Indent and 4788 // \c LastSpace into account. 4789 verifyFormat( 4790 "extern CFRunLoopTimerRef\n" 4791 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 4792 " CFTimeInterval interval, CFOptionFlags flags,\n" 4793 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 4794 " CFRunLoopTimerContext *context) {}"); 4795 4796 // Deep nesting somewhat works around our memoization. 4797 verifyFormat( 4798 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4799 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4800 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4801 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4802 " aaaaa())))))))))))))))))))))))))))))))))))))));", 4803 getLLVMStyleWithColumns(65)); 4804 verifyFormat( 4805 "aaaaa(\n" 4806 " aaaaa,\n" 4807 " aaaaa(\n" 4808 " aaaaa,\n" 4809 " aaaaa(\n" 4810 " aaaaa,\n" 4811 " aaaaa(\n" 4812 " aaaaa,\n" 4813 " aaaaa(\n" 4814 " aaaaa,\n" 4815 " aaaaa(\n" 4816 " aaaaa,\n" 4817 " aaaaa(\n" 4818 " aaaaa,\n" 4819 " aaaaa(\n" 4820 " aaaaa,\n" 4821 " aaaaa(\n" 4822 " aaaaa,\n" 4823 " aaaaa(\n" 4824 " aaaaa,\n" 4825 " aaaaa(\n" 4826 " aaaaa,\n" 4827 " aaaaa(\n" 4828 " aaaaa,\n" 4829 " aaaaa))))))))))));", 4830 getLLVMStyleWithColumns(65)); 4831 verifyFormat( 4832 "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" 4833 " a),\n" 4834 " a),\n" 4835 " a),\n" 4836 " a),\n" 4837 " a),\n" 4838 " a),\n" 4839 " a),\n" 4840 " a),\n" 4841 " a),\n" 4842 " a),\n" 4843 " a),\n" 4844 " a),\n" 4845 " a),\n" 4846 " a),\n" 4847 " a),\n" 4848 " a),\n" 4849 " a)", 4850 getLLVMStyleWithColumns(65)); 4851 4852 // This test takes VERY long when memoization is broken. 4853 FormatStyle OnePerLine = getLLVMStyle(); 4854 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4855 OnePerLine.BinPackParameters = false; 4856 std::string input = "Constructor()\n" 4857 " : aaaa(a,\n"; 4858 for (unsigned i = 0, e = 80; i != e; ++i) { 4859 input += " a,\n"; 4860 } 4861 input += " a) {}"; 4862 verifyFormat(input, OnePerLine); 4863 } 4864 #endif 4865 4866 TEST_F(FormatTest, BreaksAsHighAsPossible) { 4867 verifyFormat( 4868 "void f() {\n" 4869 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 4870 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 4871 " f();\n" 4872 "}"); 4873 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 4874 " Intervals[i - 1].getRange().getLast()) {\n}"); 4875 } 4876 4877 TEST_F(FormatTest, BreaksFunctionDeclarations) { 4878 // Principially, we break function declarations in a certain order: 4879 // 1) break amongst arguments. 4880 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 4881 " Cccccccccccccc cccccccccccccc);"); 4882 verifyFormat("template <class TemplateIt>\n" 4883 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 4884 " TemplateIt *stop) {}"); 4885 4886 // 2) break after return type. 4887 verifyFormat( 4888 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4889 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 4890 getGoogleStyle()); 4891 4892 // 3) break after (. 4893 verifyFormat( 4894 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 4895 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 4896 getGoogleStyle()); 4897 4898 // 4) break before after nested name specifiers. 4899 verifyFormat( 4900 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4901 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 4902 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 4903 getGoogleStyle()); 4904 4905 // However, there are exceptions, if a sufficient amount of lines can be 4906 // saved. 4907 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 4908 // more adjusting. 4909 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4910 " Cccccccccccccc cccccccccc,\n" 4911 " Cccccccccccccc cccccccccc,\n" 4912 " Cccccccccccccc cccccccccc,\n" 4913 " Cccccccccccccc cccccccccc);"); 4914 verifyFormat( 4915 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4916 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4917 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4918 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 4919 getGoogleStyle()); 4920 verifyFormat( 4921 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4922 " Cccccccccccccc cccccccccc,\n" 4923 " Cccccccccccccc cccccccccc,\n" 4924 " Cccccccccccccc cccccccccc,\n" 4925 " Cccccccccccccc cccccccccc,\n" 4926 " Cccccccccccccc cccccccccc,\n" 4927 " Cccccccccccccc cccccccccc);"); 4928 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4929 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4930 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4931 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4932 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 4933 4934 // Break after multi-line parameters. 4935 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4936 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4937 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4938 " bbbb bbbb);"); 4939 verifyFormat("void SomeLoooooooooooongFunction(\n" 4940 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 4941 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4942 " int bbbbbbbbbbbbb);"); 4943 4944 // Treat overloaded operators like other functions. 4945 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4946 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 4947 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4948 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 4949 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4950 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 4951 verifyGoogleFormat( 4952 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 4953 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4954 verifyGoogleFormat( 4955 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 4956 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4957 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4958 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4959 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 4960 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4961 verifyGoogleFormat( 4962 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 4963 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4964 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 4965 verifyGoogleFormat("template <typename T>\n" 4966 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4967 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 4968 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 4969 4970 FormatStyle Style = getLLVMStyle(); 4971 Style.PointerAlignment = FormatStyle::PAS_Left; 4972 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4973 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 4974 Style); 4975 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 4976 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4977 Style); 4978 } 4979 4980 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 4981 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 4982 // Prefer keeping `::` followed by `operator` together. 4983 EXPECT_EQ("const aaaa::bbbbbbb &\n" 4984 "ccccccccc::operator++() {\n" 4985 " stuff();\n" 4986 "}", 4987 format("const aaaa::bbbbbbb\n" 4988 "&ccccccccc::operator++() { stuff(); }", 4989 getLLVMStyleWithColumns(40))); 4990 } 4991 4992 TEST_F(FormatTest, TrailingReturnType) { 4993 verifyFormat("auto foo() -> int;\n"); 4994 // correct trailing return type spacing 4995 verifyFormat("auto operator->() -> int;\n"); 4996 verifyFormat("auto operator++(int) -> int;\n"); 4997 4998 verifyFormat("struct S {\n" 4999 " auto bar() const -> int;\n" 5000 "};"); 5001 verifyFormat("template <size_t Order, typename T>\n" 5002 "auto load_img(const std::string &filename)\n" 5003 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 5004 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 5005 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 5006 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 5007 verifyFormat("template <typename T>\n" 5008 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 5009 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 5010 5011 // Not trailing return types. 5012 verifyFormat("void f() { auto a = b->c(); }"); 5013 } 5014 5015 TEST_F(FormatTest, DeductionGuides) { 5016 verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;"); 5017 verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;"); 5018 verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;"); 5019 verifyFormat( 5020 "template <class... T>\n" 5021 "array(T &&... t) -> array<std::common_type_t<T...>, sizeof...(T)>;"); 5022 verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;"); 5023 verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;"); 5024 verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;"); 5025 verifyFormat("template <class T> A() -> A<(3 < 2)>;"); 5026 verifyFormat("template <class T> A() -> A<((3) < (2))>;"); 5027 verifyFormat("template <class T> x() -> x<1>;"); 5028 verifyFormat("template <class T> explicit x(T &) -> x<1>;"); 5029 5030 // Ensure not deduction guides. 5031 verifyFormat("c()->f<int>();"); 5032 verifyFormat("x()->foo<1>;"); 5033 verifyFormat("x = p->foo<3>();"); 5034 verifyFormat("x()->x<1>();"); 5035 verifyFormat("x()->x<1>;"); 5036 } 5037 5038 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 5039 // Avoid breaking before trailing 'const' or other trailing annotations, if 5040 // they are not function-like. 5041 FormatStyle Style = getGoogleStyle(); 5042 Style.ColumnLimit = 47; 5043 verifyFormat("void someLongFunction(\n" 5044 " int someLoooooooooooooongParameter) const {\n}", 5045 getLLVMStyleWithColumns(47)); 5046 verifyFormat("LoooooongReturnType\n" 5047 "someLoooooooongFunction() const {}", 5048 getLLVMStyleWithColumns(47)); 5049 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 5050 " const {}", 5051 Style); 5052 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5053 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 5054 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5055 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 5056 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5057 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 5058 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 5059 " aaaaaaaaaaa aaaaa) const override;"); 5060 verifyGoogleFormat( 5061 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5062 " const override;"); 5063 5064 // Even if the first parameter has to be wrapped. 5065 verifyFormat("void someLongFunction(\n" 5066 " int someLongParameter) const {}", 5067 getLLVMStyleWithColumns(46)); 5068 verifyFormat("void someLongFunction(\n" 5069 " int someLongParameter) const {}", 5070 Style); 5071 verifyFormat("void someLongFunction(\n" 5072 " int someLongParameter) override {}", 5073 Style); 5074 verifyFormat("void someLongFunction(\n" 5075 " int someLongParameter) OVERRIDE {}", 5076 Style); 5077 verifyFormat("void someLongFunction(\n" 5078 " int someLongParameter) final {}", 5079 Style); 5080 verifyFormat("void someLongFunction(\n" 5081 " int someLongParameter) FINAL {}", 5082 Style); 5083 verifyFormat("void someLongFunction(\n" 5084 " int parameter) const override {}", 5085 Style); 5086 5087 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 5088 verifyFormat("void someLongFunction(\n" 5089 " int someLongParameter) const\n" 5090 "{\n" 5091 "}", 5092 Style); 5093 5094 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 5095 verifyFormat("void someLongFunction(\n" 5096 " int someLongParameter) const\n" 5097 " {\n" 5098 " }", 5099 Style); 5100 5101 // Unless these are unknown annotations. 5102 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 5103 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5104 " LONG_AND_UGLY_ANNOTATION;"); 5105 5106 // Breaking before function-like trailing annotations is fine to keep them 5107 // close to their arguments. 5108 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5109 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5110 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5111 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5112 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5113 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 5114 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 5115 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 5116 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 5117 5118 verifyFormat( 5119 "void aaaaaaaaaaaaaaaaaa()\n" 5120 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 5121 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 5122 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5123 " __attribute__((unused));"); 5124 verifyGoogleFormat( 5125 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5126 " GUARDED_BY(aaaaaaaaaaaa);"); 5127 verifyGoogleFormat( 5128 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5129 " GUARDED_BY(aaaaaaaaaaaa);"); 5130 verifyGoogleFormat( 5131 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5132 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5133 verifyGoogleFormat( 5134 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5135 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5136 } 5137 5138 TEST_F(FormatTest, FunctionAnnotations) { 5139 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5140 "int OldFunction(const string ¶meter) {}"); 5141 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5142 "string OldFunction(const string ¶meter) {}"); 5143 verifyFormat("template <typename T>\n" 5144 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5145 "string OldFunction(const string ¶meter) {}"); 5146 5147 // Not function annotations. 5148 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5149 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 5150 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 5151 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 5152 verifyFormat("MACRO(abc).function() // wrap\n" 5153 " << abc;"); 5154 verifyFormat("MACRO(abc)->function() // wrap\n" 5155 " << abc;"); 5156 verifyFormat("MACRO(abc)::function() // wrap\n" 5157 " << abc;"); 5158 } 5159 5160 TEST_F(FormatTest, BreaksDesireably) { 5161 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5162 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5163 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 5164 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5165 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 5166 "}"); 5167 5168 verifyFormat( 5169 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5170 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 5171 5172 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5173 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5174 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5175 5176 verifyFormat( 5177 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5178 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5179 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5180 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5181 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 5182 5183 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5184 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5185 5186 verifyFormat( 5187 "void f() {\n" 5188 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 5189 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5190 "}"); 5191 verifyFormat( 5192 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5193 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5194 verifyFormat( 5195 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5196 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5197 verifyFormat( 5198 "aaaaaa(aaa,\n" 5199 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5200 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5201 " aaaa);"); 5202 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5203 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5204 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5205 5206 // Indent consistently independent of call expression and unary operator. 5207 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5208 " dddddddddddddddddddddddddddddd));"); 5209 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5210 " dddddddddddddddddddddddddddddd));"); 5211 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 5212 " dddddddddddddddddddddddddddddd));"); 5213 5214 // This test case breaks on an incorrect memoization, i.e. an optimization not 5215 // taking into account the StopAt value. 5216 verifyFormat( 5217 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5218 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5219 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5220 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5221 5222 verifyFormat("{\n {\n {\n" 5223 " Annotation.SpaceRequiredBefore =\n" 5224 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 5225 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 5226 " }\n }\n}"); 5227 5228 // Break on an outer level if there was a break on an inner level. 5229 EXPECT_EQ("f(g(h(a, // comment\n" 5230 " b, c),\n" 5231 " d, e),\n" 5232 " x, y);", 5233 format("f(g(h(a, // comment\n" 5234 " b, c), d, e), x, y);")); 5235 5236 // Prefer breaking similar line breaks. 5237 verifyFormat( 5238 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 5239 " NSTrackingMouseEnteredAndExited |\n" 5240 " NSTrackingActiveAlways;"); 5241 } 5242 5243 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 5244 FormatStyle NoBinPacking = getGoogleStyle(); 5245 NoBinPacking.BinPackParameters = false; 5246 NoBinPacking.BinPackArguments = true; 5247 verifyFormat("void f() {\n" 5248 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 5249 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5250 "}", 5251 NoBinPacking); 5252 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 5253 " int aaaaaaaaaaaaaaaaaaaa,\n" 5254 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5255 NoBinPacking); 5256 5257 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5258 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5259 " vector<int> bbbbbbbbbbbbbbb);", 5260 NoBinPacking); 5261 // FIXME: This behavior difference is probably not wanted. However, currently 5262 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 5263 // template arguments from BreakBeforeParameter being set because of the 5264 // one-per-line formatting. 5265 verifyFormat( 5266 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5267 " aaaaaaaaaa> aaaaaaaaaa);", 5268 NoBinPacking); 5269 verifyFormat( 5270 "void fffffffffff(\n" 5271 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 5272 " aaaaaaaaaa);"); 5273 } 5274 5275 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 5276 FormatStyle NoBinPacking = getGoogleStyle(); 5277 NoBinPacking.BinPackParameters = false; 5278 NoBinPacking.BinPackArguments = false; 5279 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 5280 " aaaaaaaaaaaaaaaaaaaa,\n" 5281 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 5282 NoBinPacking); 5283 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 5284 " aaaaaaaaaaaaa,\n" 5285 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 5286 NoBinPacking); 5287 verifyFormat( 5288 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5289 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5290 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5291 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5292 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 5293 NoBinPacking); 5294 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5295 " .aaaaaaaaaaaaaaaaaa();", 5296 NoBinPacking); 5297 verifyFormat("void f() {\n" 5298 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5299 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 5300 "}", 5301 NoBinPacking); 5302 5303 verifyFormat( 5304 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5305 " aaaaaaaaaaaa,\n" 5306 " aaaaaaaaaaaa);", 5307 NoBinPacking); 5308 verifyFormat( 5309 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 5310 " ddddddddddddddddddddddddddddd),\n" 5311 " test);", 5312 NoBinPacking); 5313 5314 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5315 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 5316 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 5317 " aaaaaaaaaaaaaaaaaa;", 5318 NoBinPacking); 5319 verifyFormat("a(\"a\"\n" 5320 " \"a\",\n" 5321 " a);"); 5322 5323 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5324 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 5325 " aaaaaaaaa,\n" 5326 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5327 NoBinPacking); 5328 verifyFormat( 5329 "void f() {\n" 5330 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5331 " .aaaaaaa();\n" 5332 "}", 5333 NoBinPacking); 5334 verifyFormat( 5335 "template <class SomeType, class SomeOtherType>\n" 5336 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 5337 NoBinPacking); 5338 } 5339 5340 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 5341 FormatStyle Style = getLLVMStyleWithColumns(15); 5342 Style.ExperimentalAutoDetectBinPacking = true; 5343 EXPECT_EQ("aaa(aaaa,\n" 5344 " aaaa,\n" 5345 " aaaa);\n" 5346 "aaa(aaaa,\n" 5347 " aaaa,\n" 5348 " aaaa);", 5349 format("aaa(aaaa,\n" // one-per-line 5350 " aaaa,\n" 5351 " aaaa );\n" 5352 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5353 Style)); 5354 EXPECT_EQ("aaa(aaaa, aaaa,\n" 5355 " aaaa);\n" 5356 "aaa(aaaa, aaaa,\n" 5357 " aaaa);", 5358 format("aaa(aaaa, aaaa,\n" // bin-packed 5359 " aaaa );\n" 5360 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5361 Style)); 5362 } 5363 5364 TEST_F(FormatTest, FormatsBuilderPattern) { 5365 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 5366 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 5367 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 5368 " .StartsWith(\".init\", ORDER_INIT)\n" 5369 " .StartsWith(\".fini\", ORDER_FINI)\n" 5370 " .StartsWith(\".hash\", ORDER_HASH)\n" 5371 " .Default(ORDER_TEXT);\n"); 5372 5373 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 5374 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 5375 verifyFormat("aaaaaaa->aaaaaaa\n" 5376 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5377 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5378 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5379 verifyFormat( 5380 "aaaaaaa->aaaaaaa\n" 5381 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5382 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5383 verifyFormat( 5384 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 5385 " aaaaaaaaaaaaaa);"); 5386 verifyFormat( 5387 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 5388 " aaaaaa->aaaaaaaaaaaa()\n" 5389 " ->aaaaaaaaaaaaaaaa(\n" 5390 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5391 " ->aaaaaaaaaaaaaaaaa();"); 5392 verifyGoogleFormat( 5393 "void f() {\n" 5394 " someo->Add((new util::filetools::Handler(dir))\n" 5395 " ->OnEvent1(NewPermanentCallback(\n" 5396 " this, &HandlerHolderClass::EventHandlerCBA))\n" 5397 " ->OnEvent2(NewPermanentCallback(\n" 5398 " this, &HandlerHolderClass::EventHandlerCBB))\n" 5399 " ->OnEvent3(NewPermanentCallback(\n" 5400 " this, &HandlerHolderClass::EventHandlerCBC))\n" 5401 " ->OnEvent5(NewPermanentCallback(\n" 5402 " this, &HandlerHolderClass::EventHandlerCBD))\n" 5403 " ->OnEvent6(NewPermanentCallback(\n" 5404 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 5405 "}"); 5406 5407 verifyFormat( 5408 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 5409 verifyFormat("aaaaaaaaaaaaaaa()\n" 5410 " .aaaaaaaaaaaaaaa()\n" 5411 " .aaaaaaaaaaaaaaa()\n" 5412 " .aaaaaaaaaaaaaaa()\n" 5413 " .aaaaaaaaaaaaaaa();"); 5414 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5415 " .aaaaaaaaaaaaaaa()\n" 5416 " .aaaaaaaaaaaaaaa()\n" 5417 " .aaaaaaaaaaaaaaa();"); 5418 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5419 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5420 " .aaaaaaaaaaaaaaa();"); 5421 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 5422 " ->aaaaaaaaaaaaaae(0)\n" 5423 " ->aaaaaaaaaaaaaaa();"); 5424 5425 // Don't linewrap after very short segments. 5426 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5427 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5428 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5429 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5430 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5431 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5432 verifyFormat("aaa()\n" 5433 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5434 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5435 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5436 5437 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5438 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5439 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 5440 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5441 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 5442 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 5443 5444 // Prefer not to break after empty parentheses. 5445 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 5446 " First->LastNewlineOffset);"); 5447 5448 // Prefer not to create "hanging" indents. 5449 verifyFormat( 5450 "return !soooooooooooooome_map\n" 5451 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5452 " .second;"); 5453 verifyFormat( 5454 "return aaaaaaaaaaaaaaaa\n" 5455 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 5456 " .aaaa(aaaaaaaaaaaaaa);"); 5457 // No hanging indent here. 5458 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5459 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5460 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5461 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5462 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5463 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5464 getLLVMStyleWithColumns(60)); 5465 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5466 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5467 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5468 getLLVMStyleWithColumns(59)); 5469 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5470 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5471 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5472 5473 // Dont break if only closing statements before member call 5474 verifyFormat("test() {\n" 5475 " ([]() -> {\n" 5476 " int b = 32;\n" 5477 " return 3;\n" 5478 " }).foo();\n" 5479 "}"); 5480 verifyFormat("test() {\n" 5481 " (\n" 5482 " []() -> {\n" 5483 " int b = 32;\n" 5484 " return 3;\n" 5485 " },\n" 5486 " foo, bar)\n" 5487 " .foo();\n" 5488 "}"); 5489 verifyFormat("test() {\n" 5490 " ([]() -> {\n" 5491 " int b = 32;\n" 5492 " return 3;\n" 5493 " })\n" 5494 " .foo()\n" 5495 " .bar();\n" 5496 "}"); 5497 verifyFormat("test() {\n" 5498 " ([]() -> {\n" 5499 " int b = 32;\n" 5500 " return 3;\n" 5501 " })\n" 5502 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5503 " \"bbbb\");\n" 5504 "}", 5505 getLLVMStyleWithColumns(30)); 5506 } 5507 5508 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5509 verifyFormat( 5510 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5511 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5512 verifyFormat( 5513 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5514 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5515 5516 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5517 " ccccccccccccccccccccccccc) {\n}"); 5518 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5519 " ccccccccccccccccccccccccc) {\n}"); 5520 5521 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5522 " ccccccccccccccccccccccccc) {\n}"); 5523 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5524 " ccccccccccccccccccccccccc) {\n}"); 5525 5526 verifyFormat( 5527 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5528 " ccccccccccccccccccccccccc) {\n}"); 5529 verifyFormat( 5530 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5531 " ccccccccccccccccccccccccc) {\n}"); 5532 5533 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5534 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5535 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5536 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5537 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5538 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5539 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5540 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5541 5542 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5543 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5544 " aaaaaaaaaaaaaaa != aa) {\n}"); 5545 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5546 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5547 " aaaaaaaaaaaaaaa != aa) {\n}"); 5548 } 5549 5550 TEST_F(FormatTest, BreaksAfterAssignments) { 5551 verifyFormat( 5552 "unsigned Cost =\n" 5553 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5554 " SI->getPointerAddressSpaceee());\n"); 5555 verifyFormat( 5556 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5557 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5558 5559 verifyFormat( 5560 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5561 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5562 verifyFormat("unsigned OriginalStartColumn =\n" 5563 " SourceMgr.getSpellingColumnNumber(\n" 5564 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5565 " 1;"); 5566 } 5567 5568 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5569 FormatStyle Style = getLLVMStyle(); 5570 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5571 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5572 Style); 5573 5574 Style.PenaltyBreakAssignment = 20; 5575 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5576 " cccccccccccccccccccccccccc;", 5577 Style); 5578 } 5579 5580 TEST_F(FormatTest, AlignsAfterAssignments) { 5581 verifyFormat( 5582 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5583 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5584 verifyFormat( 5585 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5586 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5587 verifyFormat( 5588 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5589 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5590 verifyFormat( 5591 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5592 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5593 verifyFormat( 5594 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5595 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5596 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5597 } 5598 5599 TEST_F(FormatTest, AlignsAfterReturn) { 5600 verifyFormat( 5601 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5602 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5603 verifyFormat( 5604 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5605 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5606 verifyFormat( 5607 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5608 " aaaaaaaaaaaaaaaaaaaaaa();"); 5609 verifyFormat( 5610 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5611 " aaaaaaaaaaaaaaaaaaaaaa());"); 5612 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5613 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5614 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5615 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5616 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5617 verifyFormat("return\n" 5618 " // true if code is one of a or b.\n" 5619 " code == a || code == b;"); 5620 } 5621 5622 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5623 verifyFormat( 5624 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5625 " aaaaaaaaa aaaaaaa) {}"); 5626 verifyFormat( 5627 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5628 " aaaaaaaaaaa aaaaaaaaa);"); 5629 verifyFormat( 5630 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5631 " aaaaaaaaaaaaaaaaaaaaa));"); 5632 FormatStyle Style = getLLVMStyle(); 5633 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5634 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5635 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5636 Style); 5637 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5638 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5639 Style); 5640 verifyFormat("SomeLongVariableName->someFunction(\n" 5641 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5642 Style); 5643 verifyFormat( 5644 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5645 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5646 Style); 5647 verifyFormat( 5648 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5649 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5650 Style); 5651 verifyFormat( 5652 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5653 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5654 Style); 5655 5656 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5657 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5658 " b));", 5659 Style); 5660 5661 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5662 Style.BinPackArguments = false; 5663 Style.BinPackParameters = false; 5664 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5665 " aaaaaaaaaaa aaaaaaaa,\n" 5666 " aaaaaaaaa aaaaaaa,\n" 5667 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5668 Style); 5669 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5670 " aaaaaaaaaaa aaaaaaaaa,\n" 5671 " aaaaaaaaaaa aaaaaaaaa,\n" 5672 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5673 Style); 5674 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5675 " aaaaaaaaaaaaaaa,\n" 5676 " aaaaaaaaaaaaaaaaaaaaa,\n" 5677 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5678 Style); 5679 verifyFormat( 5680 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5681 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5682 Style); 5683 verifyFormat( 5684 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5685 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5686 Style); 5687 verifyFormat( 5688 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5689 " aaaaaaaaaaaaaaaaaaaaa(\n" 5690 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5691 " aaaaaaaaaaaaaaaa);", 5692 Style); 5693 verifyFormat( 5694 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5695 " aaaaaaaaaaaaaaaaaaaaa(\n" 5696 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5697 " aaaaaaaaaaaaaaaa);", 5698 Style); 5699 } 5700 5701 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5702 FormatStyle Style = getLLVMStyleWithColumns(40); 5703 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5704 " bbbbbbbbbbbbbbbbbbbbbb);", 5705 Style); 5706 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5707 Style.AlignOperands = false; 5708 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5709 " bbbbbbbbbbbbbbbbbbbbbb);", 5710 Style); 5711 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5712 Style.AlignOperands = true; 5713 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5714 " bbbbbbbbbbbbbbbbbbbbbb);", 5715 Style); 5716 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5717 Style.AlignOperands = false; 5718 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5719 " bbbbbbbbbbbbbbbbbbbbbb);", 5720 Style); 5721 } 5722 5723 TEST_F(FormatTest, BreaksConditionalExpressions) { 5724 verifyFormat( 5725 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5726 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5727 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5728 verifyFormat( 5729 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5730 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5731 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5732 verifyFormat( 5733 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5734 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5735 verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5736 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5737 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5738 verifyFormat( 5739 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5740 " : aaaaaaaaaaaaa);"); 5741 verifyFormat( 5742 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5743 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5744 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5745 " aaaaaaaaaaaaa);"); 5746 verifyFormat( 5747 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5748 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5749 " aaaaaaaaaaaaa);"); 5750 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5751 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5752 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5753 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5754 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5755 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5756 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5757 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5758 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5759 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5760 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5761 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5762 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5763 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5764 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5765 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5766 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5767 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5768 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5769 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5770 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5771 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5772 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5773 " : aaaaaaaaaaaaaaaa;"); 5774 verifyFormat( 5775 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5776 " ? aaaaaaaaaaaaaaa\n" 5777 " : aaaaaaaaaaaaaaa;"); 5778 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5779 " aaaaaaaaa\n" 5780 " ? b\n" 5781 " : c);"); 5782 verifyFormat("return aaaa == bbbb\n" 5783 " // comment\n" 5784 " ? aaaa\n" 5785 " : bbbb;"); 5786 verifyFormat("unsigned Indent =\n" 5787 " format(TheLine.First,\n" 5788 " IndentForLevel[TheLine.Level] >= 0\n" 5789 " ? IndentForLevel[TheLine.Level]\n" 5790 " : TheLine * 2,\n" 5791 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5792 getLLVMStyleWithColumns(60)); 5793 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5794 " ? aaaaaaaaaaaaaaa\n" 5795 " : bbbbbbbbbbbbbbb //\n" 5796 " ? ccccccccccccccc\n" 5797 " : ddddddddddddddd;"); 5798 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5799 " ? aaaaaaaaaaaaaaa\n" 5800 " : (bbbbbbbbbbbbbbb //\n" 5801 " ? ccccccccccccccc\n" 5802 " : ddddddddddddddd);"); 5803 verifyFormat( 5804 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5805 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5806 " aaaaaaaaaaaaaaaaaaaaa +\n" 5807 " aaaaaaaaaaaaaaaaaaaaa\n" 5808 " : aaaaaaaaaa;"); 5809 verifyFormat( 5810 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5811 " : aaaaaaaaaaaaaaaaaaaaaa\n" 5812 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5813 5814 FormatStyle NoBinPacking = getLLVMStyle(); 5815 NoBinPacking.BinPackArguments = false; 5816 verifyFormat( 5817 "void f() {\n" 5818 " g(aaa,\n" 5819 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5820 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5821 " ? aaaaaaaaaaaaaaa\n" 5822 " : aaaaaaaaaaaaaaa);\n" 5823 "}", 5824 NoBinPacking); 5825 verifyFormat( 5826 "void f() {\n" 5827 " g(aaa,\n" 5828 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5829 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5830 " ?: aaaaaaaaaaaaaaa);\n" 5831 "}", 5832 NoBinPacking); 5833 5834 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 5835 " // comment.\n" 5836 " ccccccccccccccccccccccccccccccccccccccc\n" 5837 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5838 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 5839 5840 // Assignments in conditional expressions. Apparently not uncommon :-(. 5841 verifyFormat("return a != b\n" 5842 " // comment\n" 5843 " ? a = b\n" 5844 " : a = b;"); 5845 verifyFormat("return a != b\n" 5846 " // comment\n" 5847 " ? a = a != b\n" 5848 " // comment\n" 5849 " ? a = b\n" 5850 " : a\n" 5851 " : a;\n"); 5852 verifyFormat("return a != b\n" 5853 " // comment\n" 5854 " ? a\n" 5855 " : a = a != b\n" 5856 " // comment\n" 5857 " ? a = b\n" 5858 " : a;"); 5859 } 5860 5861 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 5862 FormatStyle Style = getLLVMStyle(); 5863 Style.BreakBeforeTernaryOperators = false; 5864 Style.ColumnLimit = 70; 5865 verifyFormat( 5866 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5867 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5868 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5869 Style); 5870 verifyFormat( 5871 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5872 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5873 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5874 Style); 5875 verifyFormat( 5876 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5877 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5878 Style); 5879 verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n" 5880 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5881 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5882 Style); 5883 verifyFormat( 5884 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 5885 " aaaaaaaaaaaaa);", 5886 Style); 5887 verifyFormat( 5888 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5889 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5890 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5891 " aaaaaaaaaaaaa);", 5892 Style); 5893 verifyFormat( 5894 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5895 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5896 " aaaaaaaaaaaaa);", 5897 Style); 5898 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5899 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5900 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5901 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5902 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5903 Style); 5904 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5905 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5906 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5907 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5908 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5909 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5910 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5911 Style); 5912 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5913 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 5914 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5915 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5916 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5917 Style); 5918 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5919 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5920 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5921 Style); 5922 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5923 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5924 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5925 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5926 Style); 5927 verifyFormat( 5928 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5929 " aaaaaaaaaaaaaaa :\n" 5930 " aaaaaaaaaaaaaaa;", 5931 Style); 5932 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5933 " aaaaaaaaa ?\n" 5934 " b :\n" 5935 " c);", 5936 Style); 5937 verifyFormat("unsigned Indent =\n" 5938 " format(TheLine.First,\n" 5939 " IndentForLevel[TheLine.Level] >= 0 ?\n" 5940 " IndentForLevel[TheLine.Level] :\n" 5941 " TheLine * 2,\n" 5942 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5943 Style); 5944 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5945 " aaaaaaaaaaaaaaa :\n" 5946 " bbbbbbbbbbbbbbb ? //\n" 5947 " ccccccccccccccc :\n" 5948 " ddddddddddddddd;", 5949 Style); 5950 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5951 " aaaaaaaaaaaaaaa :\n" 5952 " (bbbbbbbbbbbbbbb ? //\n" 5953 " ccccccccccccccc :\n" 5954 " ddddddddddddddd);", 5955 Style); 5956 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5957 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 5958 " ccccccccccccccccccccccccccc;", 5959 Style); 5960 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5961 " aaaaa :\n" 5962 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 5963 Style); 5964 } 5965 5966 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 5967 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 5968 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 5969 verifyFormat("bool a = true, b = false;"); 5970 5971 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5972 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 5973 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 5974 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 5975 verifyFormat( 5976 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 5977 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 5978 " d = e && f;"); 5979 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 5980 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 5981 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5982 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 5983 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 5984 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 5985 5986 FormatStyle Style = getGoogleStyle(); 5987 Style.PointerAlignment = FormatStyle::PAS_Left; 5988 Style.DerivePointerAlignment = false; 5989 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5990 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 5991 " *b = bbbbbbbbbbbbbbbbbbb;", 5992 Style); 5993 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5994 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 5995 Style); 5996 verifyFormat("vector<int*> a, b;", Style); 5997 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 5998 } 5999 6000 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 6001 verifyFormat("arr[foo ? bar : baz];"); 6002 verifyFormat("f()[foo ? bar : baz];"); 6003 verifyFormat("(a + b)[foo ? bar : baz];"); 6004 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 6005 } 6006 6007 TEST_F(FormatTest, AlignsStringLiterals) { 6008 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 6009 " \"short literal\");"); 6010 verifyFormat( 6011 "looooooooooooooooooooooooongFunction(\n" 6012 " \"short literal\"\n" 6013 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 6014 verifyFormat("someFunction(\"Always break between multi-line\"\n" 6015 " \" string literals\",\n" 6016 " and, other, parameters);"); 6017 EXPECT_EQ("fun + \"1243\" /* comment */\n" 6018 " \"5678\";", 6019 format("fun + \"1243\" /* comment */\n" 6020 " \"5678\";", 6021 getLLVMStyleWithColumns(28))); 6022 EXPECT_EQ( 6023 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 6024 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 6025 " \"aaaaaaaaaaaaaaaa\";", 6026 format("aaaaaa =" 6027 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 6028 "aaaaaaaaaaaaaaaaaaaaa\" " 6029 "\"aaaaaaaaaaaaaaaa\";")); 6030 verifyFormat("a = a + \"a\"\n" 6031 " \"a\"\n" 6032 " \"a\";"); 6033 verifyFormat("f(\"a\", \"b\"\n" 6034 " \"c\");"); 6035 6036 verifyFormat( 6037 "#define LL_FORMAT \"ll\"\n" 6038 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 6039 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 6040 6041 verifyFormat("#define A(X) \\\n" 6042 " \"aaaaa\" #X \"bbbbbb\" \\\n" 6043 " \"ccccc\"", 6044 getLLVMStyleWithColumns(23)); 6045 verifyFormat("#define A \"def\"\n" 6046 "f(\"abc\" A \"ghi\"\n" 6047 " \"jkl\");"); 6048 6049 verifyFormat("f(L\"a\"\n" 6050 " L\"b\");"); 6051 verifyFormat("#define A(X) \\\n" 6052 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 6053 " L\"ccccc\"", 6054 getLLVMStyleWithColumns(25)); 6055 6056 verifyFormat("f(@\"a\"\n" 6057 " @\"b\");"); 6058 verifyFormat("NSString s = @\"a\"\n" 6059 " @\"b\"\n" 6060 " @\"c\";"); 6061 verifyFormat("NSString s = @\"a\"\n" 6062 " \"b\"\n" 6063 " \"c\";"); 6064 } 6065 6066 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 6067 FormatStyle Style = getLLVMStyle(); 6068 // No declarations or definitions should be moved to own line. 6069 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 6070 verifyFormat("class A {\n" 6071 " int f() { return 1; }\n" 6072 " int g();\n" 6073 "};\n" 6074 "int f() { return 1; }\n" 6075 "int g();\n", 6076 Style); 6077 6078 // All declarations and definitions should have the return type moved to its 6079 // own 6080 // line. 6081 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 6082 verifyFormat("class E {\n" 6083 " int\n" 6084 " f() {\n" 6085 " return 1;\n" 6086 " }\n" 6087 " int\n" 6088 " g();\n" 6089 "};\n" 6090 "int\n" 6091 "f() {\n" 6092 " return 1;\n" 6093 "}\n" 6094 "int\n" 6095 "g();\n", 6096 Style); 6097 6098 // Top-level definitions, and no kinds of declarations should have the 6099 // return type moved to its own line. 6100 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 6101 verifyFormat("class B {\n" 6102 " int f() { return 1; }\n" 6103 " int g();\n" 6104 "};\n" 6105 "int\n" 6106 "f() {\n" 6107 " return 1;\n" 6108 "}\n" 6109 "int g();\n", 6110 Style); 6111 6112 // Top-level definitions and declarations should have the return type moved 6113 // to its own line. 6114 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 6115 verifyFormat("class C {\n" 6116 " int f() { return 1; }\n" 6117 " int g();\n" 6118 "};\n" 6119 "int\n" 6120 "f() {\n" 6121 " return 1;\n" 6122 "}\n" 6123 "int\n" 6124 "g();\n", 6125 Style); 6126 6127 // All definitions should have the return type moved to its own line, but no 6128 // kinds of declarations. 6129 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 6130 verifyFormat("class D {\n" 6131 " int\n" 6132 " f() {\n" 6133 " return 1;\n" 6134 " }\n" 6135 " int g();\n" 6136 "};\n" 6137 "int\n" 6138 "f() {\n" 6139 " return 1;\n" 6140 "}\n" 6141 "int g();\n", 6142 Style); 6143 verifyFormat("const char *\n" 6144 "f(void) {\n" // Break here. 6145 " return \"\";\n" 6146 "}\n" 6147 "const char *bar(void);\n", // No break here. 6148 Style); 6149 verifyFormat("template <class T>\n" 6150 "T *\n" 6151 "f(T &c) {\n" // Break here. 6152 " return NULL;\n" 6153 "}\n" 6154 "template <class T> T *f(T &c);\n", // No break here. 6155 Style); 6156 verifyFormat("class C {\n" 6157 " int\n" 6158 " operator+() {\n" 6159 " return 1;\n" 6160 " }\n" 6161 " int\n" 6162 " operator()() {\n" 6163 " return 1;\n" 6164 " }\n" 6165 "};\n", 6166 Style); 6167 verifyFormat("void\n" 6168 "A::operator()() {}\n" 6169 "void\n" 6170 "A::operator>>() {}\n" 6171 "void\n" 6172 "A::operator+() {}\n" 6173 "void\n" 6174 "A::operator*() {}\n" 6175 "void\n" 6176 "A::operator->() {}\n" 6177 "void\n" 6178 "A::operator void *() {}\n" 6179 "void\n" 6180 "A::operator void &() {}\n" 6181 "void\n" 6182 "A::operator void &&() {}\n" 6183 "void\n" 6184 "A::operator char *() {}\n" 6185 "void\n" 6186 "A::operator[]() {}\n" 6187 "void\n" 6188 "A::operator!() {}\n", 6189 Style); 6190 verifyFormat("constexpr auto\n" 6191 "operator()() const -> reference {}\n" 6192 "constexpr auto\n" 6193 "operator>>() const -> reference {}\n" 6194 "constexpr auto\n" 6195 "operator+() const -> reference {}\n" 6196 "constexpr auto\n" 6197 "operator*() const -> reference {}\n" 6198 "constexpr auto\n" 6199 "operator->() const -> reference {}\n" 6200 "constexpr auto\n" 6201 "operator++() const -> reference {}\n" 6202 "constexpr auto\n" 6203 "operator void *() const -> reference {}\n" 6204 "constexpr auto\n" 6205 "operator void &() const -> reference {}\n" 6206 "constexpr auto\n" 6207 "operator void &&() const -> reference {}\n" 6208 "constexpr auto\n" 6209 "operator char *() const -> reference {}\n" 6210 "constexpr auto\n" 6211 "operator!() const -> reference {}\n" 6212 "constexpr auto\n" 6213 "operator[]() const -> reference {}\n", 6214 Style); 6215 verifyFormat("void *operator new(std::size_t s);", // No break here. 6216 Style); 6217 verifyFormat("void *\n" 6218 "operator new(std::size_t s) {}", 6219 Style); 6220 verifyFormat("void *\n" 6221 "operator delete[](void *ptr) {}", 6222 Style); 6223 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 6224 verifyFormat("const char *\n" 6225 "f(void)\n" // Break here. 6226 "{\n" 6227 " return \"\";\n" 6228 "}\n" 6229 "const char *bar(void);\n", // No break here. 6230 Style); 6231 verifyFormat("template <class T>\n" 6232 "T *\n" // Problem here: no line break 6233 "f(T &c)\n" // Break here. 6234 "{\n" 6235 " return NULL;\n" 6236 "}\n" 6237 "template <class T> T *f(T &c);\n", // No break here. 6238 Style); 6239 verifyFormat("int\n" 6240 "foo(A<bool> a)\n" 6241 "{\n" 6242 " return a;\n" 6243 "}\n", 6244 Style); 6245 verifyFormat("int\n" 6246 "foo(A<8> a)\n" 6247 "{\n" 6248 " return a;\n" 6249 "}\n", 6250 Style); 6251 verifyFormat("int\n" 6252 "foo(A<B<bool>, 8> a)\n" 6253 "{\n" 6254 " return a;\n" 6255 "}\n", 6256 Style); 6257 verifyFormat("int\n" 6258 "foo(A<B<8>, bool> a)\n" 6259 "{\n" 6260 " return a;\n" 6261 "}\n", 6262 Style); 6263 verifyFormat("int\n" 6264 "foo(A<B<bool>, bool> a)\n" 6265 "{\n" 6266 " return a;\n" 6267 "}\n", 6268 Style); 6269 verifyFormat("int\n" 6270 "foo(A<B<8>, 8> a)\n" 6271 "{\n" 6272 " return a;\n" 6273 "}\n", 6274 Style); 6275 6276 Style = getGNUStyle(); 6277 6278 // Test for comments at the end of function declarations. 6279 verifyFormat("void\n" 6280 "foo (int a, /*abc*/ int b) // def\n" 6281 "{\n" 6282 "}\n", 6283 Style); 6284 6285 verifyFormat("void\n" 6286 "foo (int a, /* abc */ int b) /* def */\n" 6287 "{\n" 6288 "}\n", 6289 Style); 6290 6291 // Definitions that should not break after return type 6292 verifyFormat("void foo (int a, int b); // def\n", Style); 6293 verifyFormat("void foo (int a, int b); /* def */\n", Style); 6294 verifyFormat("void foo (int a, int b);\n", Style); 6295 } 6296 6297 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 6298 FormatStyle NoBreak = getLLVMStyle(); 6299 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 6300 FormatStyle Break = getLLVMStyle(); 6301 Break.AlwaysBreakBeforeMultilineStrings = true; 6302 verifyFormat("aaaa = \"bbbb\"\n" 6303 " \"cccc\";", 6304 NoBreak); 6305 verifyFormat("aaaa =\n" 6306 " \"bbbb\"\n" 6307 " \"cccc\";", 6308 Break); 6309 verifyFormat("aaaa(\"bbbb\"\n" 6310 " \"cccc\");", 6311 NoBreak); 6312 verifyFormat("aaaa(\n" 6313 " \"bbbb\"\n" 6314 " \"cccc\");", 6315 Break); 6316 verifyFormat("aaaa(qqq, \"bbbb\"\n" 6317 " \"cccc\");", 6318 NoBreak); 6319 verifyFormat("aaaa(qqq,\n" 6320 " \"bbbb\"\n" 6321 " \"cccc\");", 6322 Break); 6323 verifyFormat("aaaa(qqq,\n" 6324 " L\"bbbb\"\n" 6325 " L\"cccc\");", 6326 Break); 6327 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 6328 " \"bbbb\"));", 6329 Break); 6330 verifyFormat("string s = someFunction(\n" 6331 " \"abc\"\n" 6332 " \"abc\");", 6333 Break); 6334 6335 // As we break before unary operators, breaking right after them is bad. 6336 verifyFormat("string foo = abc ? \"x\"\n" 6337 " \"blah blah blah blah blah blah\"\n" 6338 " : \"y\";", 6339 Break); 6340 6341 // Don't break if there is no column gain. 6342 verifyFormat("f(\"aaaa\"\n" 6343 " \"bbbb\");", 6344 Break); 6345 6346 // Treat literals with escaped newlines like multi-line string literals. 6347 EXPECT_EQ("x = \"a\\\n" 6348 "b\\\n" 6349 "c\";", 6350 format("x = \"a\\\n" 6351 "b\\\n" 6352 "c\";", 6353 NoBreak)); 6354 EXPECT_EQ("xxxx =\n" 6355 " \"a\\\n" 6356 "b\\\n" 6357 "c\";", 6358 format("xxxx = \"a\\\n" 6359 "b\\\n" 6360 "c\";", 6361 Break)); 6362 6363 EXPECT_EQ("NSString *const kString =\n" 6364 " @\"aaaa\"\n" 6365 " @\"bbbb\";", 6366 format("NSString *const kString = @\"aaaa\"\n" 6367 "@\"bbbb\";", 6368 Break)); 6369 6370 Break.ColumnLimit = 0; 6371 verifyFormat("const char *hello = \"hello llvm\";", Break); 6372 } 6373 6374 TEST_F(FormatTest, AlignsPipes) { 6375 verifyFormat( 6376 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6377 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6378 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6379 verifyFormat( 6380 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 6381 " << aaaaaaaaaaaaaaaaaaaa;"); 6382 verifyFormat( 6383 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6384 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6385 verifyFormat( 6386 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 6387 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6388 verifyFormat( 6389 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 6390 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 6391 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 6392 verifyFormat( 6393 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6394 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6395 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6396 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6397 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6398 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6399 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6400 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 6401 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 6402 verifyFormat( 6403 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6404 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6405 verifyFormat( 6406 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 6407 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6408 6409 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 6410 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 6411 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6412 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6413 " aaaaaaaaaaaaaaaaaaaaa)\n" 6414 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6415 verifyFormat("LOG_IF(aaa == //\n" 6416 " bbb)\n" 6417 " << a << b;"); 6418 6419 // But sometimes, breaking before the first "<<" is desirable. 6420 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6421 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 6422 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 6423 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6424 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6425 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 6426 " << BEF << IsTemplate << Description << E->getType();"); 6427 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6428 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6429 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6430 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6431 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6432 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6433 " << aaa;"); 6434 6435 verifyFormat( 6436 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6437 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6438 6439 // Incomplete string literal. 6440 EXPECT_EQ("llvm::errs() << \"\n" 6441 " << a;", 6442 format("llvm::errs() << \"\n<<a;")); 6443 6444 verifyFormat("void f() {\n" 6445 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 6446 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 6447 "}"); 6448 6449 // Handle 'endl'. 6450 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 6451 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6452 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6453 6454 // Handle '\n'. 6455 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 6456 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6457 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 6458 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 6459 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 6460 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 6461 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6462 } 6463 6464 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 6465 verifyFormat("return out << \"somepacket = {\\n\"\n" 6466 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 6467 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 6468 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 6469 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 6470 " << \"}\";"); 6471 6472 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6473 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6474 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 6475 verifyFormat( 6476 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 6477 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 6478 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 6479 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 6480 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 6481 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 6482 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6483 verifyFormat( 6484 "void f() {\n" 6485 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 6486 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 6487 "}"); 6488 6489 // Breaking before the first "<<" is generally not desirable. 6490 verifyFormat( 6491 "llvm::errs()\n" 6492 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6493 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6494 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6495 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6496 getLLVMStyleWithColumns(70)); 6497 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6498 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6499 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6500 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6501 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6502 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6503 getLLVMStyleWithColumns(70)); 6504 6505 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6506 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6507 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6508 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6509 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6510 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 6511 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 6512 " (aaaa + aaaa);", 6513 getLLVMStyleWithColumns(40)); 6514 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 6515 " (aaaaaaa + aaaaa));", 6516 getLLVMStyleWithColumns(40)); 6517 verifyFormat( 6518 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 6519 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 6520 " bbbbbbbbbbbbbbbbbbbbbbb);"); 6521 } 6522 6523 TEST_F(FormatTest, UnderstandsEquals) { 6524 verifyFormat( 6525 "aaaaaaaaaaaaaaaaa =\n" 6526 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6527 verifyFormat( 6528 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6529 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6530 verifyFormat( 6531 "if (a) {\n" 6532 " f();\n" 6533 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6534 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 6535 "}"); 6536 6537 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6538 " 100000000 + 10000000) {\n}"); 6539 } 6540 6541 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 6542 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6543 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 6544 6545 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6546 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 6547 6548 verifyFormat( 6549 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 6550 " Parameter2);"); 6551 6552 verifyFormat( 6553 "ShortObject->shortFunction(\n" 6554 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 6555 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 6556 6557 verifyFormat("loooooooooooooongFunction(\n" 6558 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 6559 6560 verifyFormat( 6561 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 6562 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 6563 6564 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6565 " .WillRepeatedly(Return(SomeValue));"); 6566 verifyFormat("void f() {\n" 6567 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6568 " .Times(2)\n" 6569 " .WillRepeatedly(Return(SomeValue));\n" 6570 "}"); 6571 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 6572 " ccccccccccccccccccccccc);"); 6573 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6574 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6575 " .aaaaa(aaaaa),\n" 6576 " aaaaaaaaaaaaaaaaaaaaa);"); 6577 verifyFormat("void f() {\n" 6578 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6579 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 6580 "}"); 6581 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6582 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6583 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6584 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6585 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6586 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6587 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6588 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6589 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 6590 "}"); 6591 6592 // Here, it is not necessary to wrap at "." or "->". 6593 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 6594 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6595 verifyFormat( 6596 "aaaaaaaaaaa->aaaaaaaaa(\n" 6597 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6598 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 6599 6600 verifyFormat( 6601 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6602 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 6603 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 6604 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6605 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 6606 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6607 6608 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6609 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6610 " .a();"); 6611 6612 FormatStyle NoBinPacking = getLLVMStyle(); 6613 NoBinPacking.BinPackParameters = false; 6614 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6615 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6616 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 6617 " aaaaaaaaaaaaaaaaaaa,\n" 6618 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6619 NoBinPacking); 6620 6621 // If there is a subsequent call, change to hanging indentation. 6622 verifyFormat( 6623 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6624 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 6625 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6626 verifyFormat( 6627 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6628 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 6629 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6630 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6631 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6632 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6633 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6634 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6635 } 6636 6637 TEST_F(FormatTest, WrapsTemplateDeclarations) { 6638 verifyFormat("template <typename T>\n" 6639 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6640 verifyFormat("template <typename T>\n" 6641 "// T should be one of {A, B}.\n" 6642 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6643 verifyFormat( 6644 "template <typename T>\n" 6645 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 6646 verifyFormat("template <typename T>\n" 6647 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 6648 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 6649 verifyFormat( 6650 "template <typename T>\n" 6651 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 6652 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 6653 verifyFormat( 6654 "template <typename T>\n" 6655 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 6656 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 6657 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6658 verifyFormat("template <typename T>\n" 6659 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6660 " int aaaaaaaaaaaaaaaaaaaaaa);"); 6661 verifyFormat( 6662 "template <typename T1, typename T2 = char, typename T3 = char,\n" 6663 " typename T4 = char>\n" 6664 "void f();"); 6665 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 6666 " template <typename> class cccccccccccccccccccccc,\n" 6667 " typename ddddddddddddd>\n" 6668 "class C {};"); 6669 verifyFormat( 6670 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 6671 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6672 6673 verifyFormat("void f() {\n" 6674 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 6675 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 6676 "}"); 6677 6678 verifyFormat("template <typename T> class C {};"); 6679 verifyFormat("template <typename T> void f();"); 6680 verifyFormat("template <typename T> void f() {}"); 6681 verifyFormat( 6682 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6683 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6684 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 6685 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6686 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6687 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 6688 " bbbbbbbbbbbbbbbbbbbbbbbb);", 6689 getLLVMStyleWithColumns(72)); 6690 EXPECT_EQ("static_cast<A< //\n" 6691 " B> *>(\n" 6692 "\n" 6693 ");", 6694 format("static_cast<A<//\n" 6695 " B>*>(\n" 6696 "\n" 6697 " );")); 6698 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6699 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 6700 6701 FormatStyle AlwaysBreak = getLLVMStyle(); 6702 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 6703 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 6704 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 6705 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 6706 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6707 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6708 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 6709 verifyFormat("template <template <typename> class Fooooooo,\n" 6710 " template <typename> class Baaaaaaar>\n" 6711 "struct C {};", 6712 AlwaysBreak); 6713 verifyFormat("template <typename T> // T can be A, B or C.\n" 6714 "struct C {};", 6715 AlwaysBreak); 6716 verifyFormat("template <enum E> class A {\n" 6717 "public:\n" 6718 " E *f();\n" 6719 "};"); 6720 6721 FormatStyle NeverBreak = getLLVMStyle(); 6722 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 6723 verifyFormat("template <typename T> class C {};", NeverBreak); 6724 verifyFormat("template <typename T> void f();", NeverBreak); 6725 verifyFormat("template <typename T> void f() {}", NeverBreak); 6726 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6727 "bbbbbbbbbbbbbbbbbbbb) {}", 6728 NeverBreak); 6729 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6730 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6731 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 6732 NeverBreak); 6733 verifyFormat("template <template <typename> class Fooooooo,\n" 6734 " template <typename> class Baaaaaaar>\n" 6735 "struct C {};", 6736 NeverBreak); 6737 verifyFormat("template <typename T> // T can be A, B or C.\n" 6738 "struct C {};", 6739 NeverBreak); 6740 verifyFormat("template <enum E> class A {\n" 6741 "public:\n" 6742 " E *f();\n" 6743 "};", 6744 NeverBreak); 6745 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 6746 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6747 "bbbbbbbbbbbbbbbbbbbb) {}", 6748 NeverBreak); 6749 } 6750 6751 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 6752 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 6753 Style.ColumnLimit = 60; 6754 EXPECT_EQ("// Baseline - no comments.\n" 6755 "template <\n" 6756 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6757 "void f() {}", 6758 format("// Baseline - no comments.\n" 6759 "template <\n" 6760 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6761 "void f() {}", 6762 Style)); 6763 6764 EXPECT_EQ("template <\n" 6765 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6766 "void f() {}", 6767 format("template <\n" 6768 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6769 "void f() {}", 6770 Style)); 6771 6772 EXPECT_EQ( 6773 "template <\n" 6774 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6775 "void f() {}", 6776 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6777 "void f() {}", 6778 Style)); 6779 6780 EXPECT_EQ( 6781 "template <\n" 6782 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6783 " // multiline\n" 6784 "void f() {}", 6785 format("template <\n" 6786 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6787 " // multiline\n" 6788 "void f() {}", 6789 Style)); 6790 6791 EXPECT_EQ( 6792 "template <typename aaaaaaaaaa<\n" 6793 " bbbbbbbbbbbb>::value> // trailing loooong\n" 6794 "void f() {}", 6795 format( 6796 "template <\n" 6797 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 6798 "void f() {}", 6799 Style)); 6800 } 6801 6802 TEST_F(FormatTest, WrapsTemplateParameters) { 6803 FormatStyle Style = getLLVMStyle(); 6804 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6805 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6806 verifyFormat( 6807 "template <typename... a> struct q {};\n" 6808 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6809 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6810 " y;", 6811 Style); 6812 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6813 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6814 verifyFormat( 6815 "template <typename... a> struct r {};\n" 6816 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6817 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6818 " y;", 6819 Style); 6820 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6821 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6822 verifyFormat("template <typename... a> struct s {};\n" 6823 "extern s<\n" 6824 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6825 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6826 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6827 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6828 " y;", 6829 Style); 6830 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6831 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6832 verifyFormat("template <typename... a> struct t {};\n" 6833 "extern t<\n" 6834 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6835 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6836 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6837 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6838 " y;", 6839 Style); 6840 } 6841 6842 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 6843 verifyFormat( 6844 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6845 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6846 verifyFormat( 6847 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6848 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6849 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6850 6851 // FIXME: Should we have the extra indent after the second break? 6852 verifyFormat( 6853 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6854 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6855 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6856 6857 verifyFormat( 6858 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 6859 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 6860 6861 // Breaking at nested name specifiers is generally not desirable. 6862 verifyFormat( 6863 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6864 " aaaaaaaaaaaaaaaaaaaaaaa);"); 6865 6866 verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 6867 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6868 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6869 " aaaaaaaaaaaaaaaaaaaaa);", 6870 getLLVMStyleWithColumns(74)); 6871 6872 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6873 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6874 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6875 } 6876 6877 TEST_F(FormatTest, UnderstandsTemplateParameters) { 6878 verifyFormat("A<int> a;"); 6879 verifyFormat("A<A<A<int>>> a;"); 6880 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 6881 verifyFormat("bool x = a < 1 || 2 > a;"); 6882 verifyFormat("bool x = 5 < f<int>();"); 6883 verifyFormat("bool x = f<int>() > 5;"); 6884 verifyFormat("bool x = 5 < a<int>::x;"); 6885 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 6886 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 6887 6888 verifyGoogleFormat("A<A<int>> a;"); 6889 verifyGoogleFormat("A<A<A<int>>> a;"); 6890 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 6891 verifyGoogleFormat("A<A<int> > a;"); 6892 verifyGoogleFormat("A<A<A<int> > > a;"); 6893 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 6894 verifyGoogleFormat("A<::A<int>> a;"); 6895 verifyGoogleFormat("A<::A> a;"); 6896 verifyGoogleFormat("A< ::A> a;"); 6897 verifyGoogleFormat("A< ::A<int> > a;"); 6898 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 6899 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 6900 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 6901 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 6902 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 6903 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 6904 6905 verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 6906 6907 // template closer followed by a token that starts with > or = 6908 verifyFormat("bool b = a<1> > 1;"); 6909 verifyFormat("bool b = a<1> >= 1;"); 6910 verifyFormat("int i = a<1> >> 1;"); 6911 FormatStyle Style = getLLVMStyle(); 6912 Style.SpaceBeforeAssignmentOperators = false; 6913 verifyFormat("bool b= a<1> == 1;", Style); 6914 verifyFormat("a<int> = 1;", Style); 6915 verifyFormat("a<int> >>= 1;", Style); 6916 6917 verifyFormat("test >> a >> b;"); 6918 verifyFormat("test << a >> b;"); 6919 6920 verifyFormat("f<int>();"); 6921 verifyFormat("template <typename T> void f() {}"); 6922 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 6923 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 6924 "sizeof(char)>::type>;"); 6925 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 6926 verifyFormat("f(a.operator()<A>());"); 6927 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6928 " .template operator()<A>());", 6929 getLLVMStyleWithColumns(35)); 6930 6931 // Not template parameters. 6932 verifyFormat("return a < b && c > d;"); 6933 verifyFormat("void f() {\n" 6934 " while (a < b && c > d) {\n" 6935 " }\n" 6936 "}"); 6937 verifyFormat("template <typename... Types>\n" 6938 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 6939 6940 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6941 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 6942 getLLVMStyleWithColumns(60)); 6943 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 6944 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 6945 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 6946 } 6947 6948 TEST_F(FormatTest, BitshiftOperatorWidth) { 6949 EXPECT_EQ("int a = 1 << 2; /* foo\n" 6950 " bar */", 6951 format("int a=1<<2; /* foo\n" 6952 " bar */")); 6953 6954 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 6955 " bar */", 6956 format("int b =256>>1 ; /* foo\n" 6957 " bar */")); 6958 } 6959 6960 TEST_F(FormatTest, UnderstandsBinaryOperators) { 6961 verifyFormat("COMPARE(a, ==, b);"); 6962 verifyFormat("auto s = sizeof...(Ts) - 1;"); 6963 } 6964 6965 TEST_F(FormatTest, UnderstandsPointersToMembers) { 6966 verifyFormat("int A::*x;"); 6967 verifyFormat("int (S::*func)(void *);"); 6968 verifyFormat("void f() { int (S::*func)(void *); }"); 6969 verifyFormat("typedef bool *(Class::*Member)() const;"); 6970 verifyFormat("void f() {\n" 6971 " (a->*f)();\n" 6972 " a->*x;\n" 6973 " (a.*f)();\n" 6974 " ((*a).*f)();\n" 6975 " a.*x;\n" 6976 "}"); 6977 verifyFormat("void f() {\n" 6978 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 6979 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 6980 "}"); 6981 verifyFormat( 6982 "(aaaaaaaaaa->*bbbbbbb)(\n" 6983 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6984 FormatStyle Style = getLLVMStyle(); 6985 Style.PointerAlignment = FormatStyle::PAS_Left; 6986 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 6987 } 6988 6989 TEST_F(FormatTest, UnderstandsUnaryOperators) { 6990 verifyFormat("int a = -2;"); 6991 verifyFormat("f(-1, -2, -3);"); 6992 verifyFormat("a[-1] = 5;"); 6993 verifyFormat("int a = 5 + -2;"); 6994 verifyFormat("if (i == -1) {\n}"); 6995 verifyFormat("if (i != -1) {\n}"); 6996 verifyFormat("if (i > -1) {\n}"); 6997 verifyFormat("if (i < -1) {\n}"); 6998 verifyFormat("++(a->f());"); 6999 verifyFormat("--(a->f());"); 7000 verifyFormat("(a->f())++;"); 7001 verifyFormat("a[42]++;"); 7002 verifyFormat("if (!(a->f())) {\n}"); 7003 verifyFormat("if (!+i) {\n}"); 7004 verifyFormat("~&a;"); 7005 7006 verifyFormat("a-- > b;"); 7007 verifyFormat("b ? -a : c;"); 7008 verifyFormat("n * sizeof char16;"); 7009 verifyFormat("n * alignof char16;", getGoogleStyle()); 7010 verifyFormat("sizeof(char);"); 7011 verifyFormat("alignof(char);", getGoogleStyle()); 7012 7013 verifyFormat("return -1;"); 7014 verifyFormat("throw -1;"); 7015 verifyFormat("switch (a) {\n" 7016 "case -1:\n" 7017 " break;\n" 7018 "}"); 7019 verifyFormat("#define X -1"); 7020 verifyFormat("#define X -kConstant"); 7021 7022 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 7023 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 7024 7025 verifyFormat("int a = /* confusing comment */ -1;"); 7026 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 7027 verifyFormat("int a = i /* confusing comment */++;"); 7028 7029 verifyFormat("co_yield -1;"); 7030 verifyFormat("co_return -1;"); 7031 } 7032 7033 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 7034 verifyFormat("if (!aaaaaaaaaa( // break\n" 7035 " aaaaa)) {\n" 7036 "}"); 7037 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 7038 " aaaaa));"); 7039 verifyFormat("*aaa = aaaaaaa( // break\n" 7040 " bbbbbb);"); 7041 } 7042 7043 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 7044 verifyFormat("bool operator<();"); 7045 verifyFormat("bool operator>();"); 7046 verifyFormat("bool operator=();"); 7047 verifyFormat("bool operator==();"); 7048 verifyFormat("bool operator!=();"); 7049 verifyFormat("int operator+();"); 7050 verifyFormat("int operator++();"); 7051 verifyFormat("int operator++(int) volatile noexcept;"); 7052 verifyFormat("bool operator,();"); 7053 verifyFormat("bool operator();"); 7054 verifyFormat("bool operator()();"); 7055 verifyFormat("bool operator[]();"); 7056 verifyFormat("operator bool();"); 7057 verifyFormat("operator int();"); 7058 verifyFormat("operator void *();"); 7059 verifyFormat("operator SomeType<int>();"); 7060 verifyFormat("operator SomeType<int, int>();"); 7061 verifyFormat("operator SomeType<SomeType<int>>();"); 7062 verifyFormat("void *operator new(std::size_t size);"); 7063 verifyFormat("void *operator new[](std::size_t size);"); 7064 verifyFormat("void operator delete(void *ptr);"); 7065 verifyFormat("void operator delete[](void *ptr);"); 7066 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 7067 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 7068 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 7069 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 7070 7071 verifyFormat( 7072 "ostream &operator<<(ostream &OutputStream,\n" 7073 " SomeReallyLongType WithSomeReallyLongValue);"); 7074 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 7075 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 7076 " return left.group < right.group;\n" 7077 "}"); 7078 verifyFormat("SomeType &operator=(const SomeType &S);"); 7079 verifyFormat("f.template operator()<int>();"); 7080 7081 verifyGoogleFormat("operator void*();"); 7082 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 7083 verifyGoogleFormat("operator ::A();"); 7084 7085 verifyFormat("using A::operator+;"); 7086 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 7087 "int i;"); 7088 } 7089 7090 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 7091 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 7092 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 7093 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 7094 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 7095 verifyFormat("Deleted &operator=(const Deleted &) &;"); 7096 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 7097 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 7098 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 7099 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 7100 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 7101 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 7102 verifyFormat("void Fn(T const &) const &;"); 7103 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 7104 verifyFormat("template <typename T>\n" 7105 "void F(T) && = delete;", 7106 getGoogleStyle()); 7107 7108 FormatStyle AlignLeft = getLLVMStyle(); 7109 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 7110 verifyFormat("void A::b() && {}", AlignLeft); 7111 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 7112 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 7113 AlignLeft); 7114 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 7115 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 7116 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 7117 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 7118 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 7119 verifyFormat("auto Function(T) & -> void;", AlignLeft); 7120 verifyFormat("void Fn(T const&) const&;", AlignLeft); 7121 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 7122 7123 FormatStyle Spaces = getLLVMStyle(); 7124 Spaces.SpacesInCStyleCastParentheses = true; 7125 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 7126 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 7127 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 7128 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 7129 7130 Spaces.SpacesInCStyleCastParentheses = false; 7131 Spaces.SpacesInParentheses = true; 7132 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 7133 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", 7134 Spaces); 7135 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 7136 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 7137 7138 FormatStyle BreakTemplate = getLLVMStyle(); 7139 BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 7140 7141 verifyFormat("struct f {\n" 7142 " template <class T>\n" 7143 " int &foo(const std::string &str) &noexcept {}\n" 7144 "};", 7145 BreakTemplate); 7146 7147 verifyFormat("struct f {\n" 7148 " template <class T>\n" 7149 " int &foo(const std::string &str) &&noexcept {}\n" 7150 "};", 7151 BreakTemplate); 7152 7153 verifyFormat("struct f {\n" 7154 " template <class T>\n" 7155 " int &foo(const std::string &str) const &noexcept {}\n" 7156 "};", 7157 BreakTemplate); 7158 7159 verifyFormat("struct f {\n" 7160 " template <class T>\n" 7161 " int &foo(const std::string &str) const &noexcept {}\n" 7162 "};", 7163 BreakTemplate); 7164 7165 verifyFormat("struct f {\n" 7166 " template <class T>\n" 7167 " auto foo(const std::string &str) &&noexcept -> int & {}\n" 7168 "};", 7169 BreakTemplate); 7170 7171 FormatStyle AlignLeftBreakTemplate = getLLVMStyle(); 7172 AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations = 7173 FormatStyle::BTDS_Yes; 7174 AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left; 7175 7176 verifyFormat("struct f {\n" 7177 " template <class T>\n" 7178 " int& foo(const std::string& str) & noexcept {}\n" 7179 "};", 7180 AlignLeftBreakTemplate); 7181 7182 verifyFormat("struct f {\n" 7183 " template <class T>\n" 7184 " int& foo(const std::string& str) && noexcept {}\n" 7185 "};", 7186 AlignLeftBreakTemplate); 7187 7188 verifyFormat("struct f {\n" 7189 " template <class T>\n" 7190 " int& foo(const std::string& str) const& noexcept {}\n" 7191 "};", 7192 AlignLeftBreakTemplate); 7193 7194 verifyFormat("struct f {\n" 7195 " template <class T>\n" 7196 " int& foo(const std::string& str) const&& noexcept {}\n" 7197 "};", 7198 AlignLeftBreakTemplate); 7199 7200 verifyFormat("struct f {\n" 7201 " template <class T>\n" 7202 " auto foo(const std::string& str) && noexcept -> int& {}\n" 7203 "};", 7204 AlignLeftBreakTemplate); 7205 7206 // The `&` in `Type&` should not be confused with a trailing `&` of 7207 // DEPRECATED(reason) member function. 7208 verifyFormat("struct f {\n" 7209 " template <class T>\n" 7210 " DEPRECATED(reason)\n" 7211 " Type &foo(arguments) {}\n" 7212 "};", 7213 BreakTemplate); 7214 7215 verifyFormat("struct f {\n" 7216 " template <class T>\n" 7217 " DEPRECATED(reason)\n" 7218 " Type& foo(arguments) {}\n" 7219 "};", 7220 AlignLeftBreakTemplate); 7221 7222 verifyFormat("void (*foopt)(int) = &func;"); 7223 } 7224 7225 TEST_F(FormatTest, UnderstandsNewAndDelete) { 7226 verifyFormat("void f() {\n" 7227 " A *a = new A;\n" 7228 " A *a = new (placement) A;\n" 7229 " delete a;\n" 7230 " delete (A *)a;\n" 7231 "}"); 7232 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7233 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7234 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7235 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7236 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7237 verifyFormat("delete[] h->p;"); 7238 } 7239 7240 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 7241 verifyFormat("int *f(int *a) {}"); 7242 verifyFormat("int main(int argc, char **argv) {}"); 7243 verifyFormat("Test::Test(int b) : a(b * b) {}"); 7244 verifyIndependentOfContext("f(a, *a);"); 7245 verifyFormat("void g() { f(*a); }"); 7246 verifyIndependentOfContext("int a = b * 10;"); 7247 verifyIndependentOfContext("int a = 10 * b;"); 7248 verifyIndependentOfContext("int a = b * c;"); 7249 verifyIndependentOfContext("int a += b * c;"); 7250 verifyIndependentOfContext("int a -= b * c;"); 7251 verifyIndependentOfContext("int a *= b * c;"); 7252 verifyIndependentOfContext("int a /= b * c;"); 7253 verifyIndependentOfContext("int a = *b;"); 7254 verifyIndependentOfContext("int a = *b * c;"); 7255 verifyIndependentOfContext("int a = b * *c;"); 7256 verifyIndependentOfContext("int a = b * (10);"); 7257 verifyIndependentOfContext("S << b * (10);"); 7258 verifyIndependentOfContext("return 10 * b;"); 7259 verifyIndependentOfContext("return *b * *c;"); 7260 verifyIndependentOfContext("return a & ~b;"); 7261 verifyIndependentOfContext("f(b ? *c : *d);"); 7262 verifyIndependentOfContext("int a = b ? *c : *d;"); 7263 verifyIndependentOfContext("*b = a;"); 7264 verifyIndependentOfContext("a * ~b;"); 7265 verifyIndependentOfContext("a * !b;"); 7266 verifyIndependentOfContext("a * +b;"); 7267 verifyIndependentOfContext("a * -b;"); 7268 verifyIndependentOfContext("a * ++b;"); 7269 verifyIndependentOfContext("a * --b;"); 7270 verifyIndependentOfContext("a[4] * b;"); 7271 verifyIndependentOfContext("a[a * a] = 1;"); 7272 verifyIndependentOfContext("f() * b;"); 7273 verifyIndependentOfContext("a * [self dostuff];"); 7274 verifyIndependentOfContext("int x = a * (a + b);"); 7275 verifyIndependentOfContext("(a *)(a + b);"); 7276 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 7277 verifyIndependentOfContext("int *pa = (int *)&a;"); 7278 verifyIndependentOfContext("return sizeof(int **);"); 7279 verifyIndependentOfContext("return sizeof(int ******);"); 7280 verifyIndependentOfContext("return (int **&)a;"); 7281 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 7282 verifyFormat("void f(Type (*parameter)[10]) {}"); 7283 verifyFormat("void f(Type (¶meter)[10]) {}"); 7284 verifyGoogleFormat("return sizeof(int**);"); 7285 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 7286 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 7287 verifyFormat("auto a = [](int **&, int ***) {};"); 7288 verifyFormat("auto PointerBinding = [](const char *S) {};"); 7289 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 7290 verifyFormat("[](const decltype(*a) &value) {}"); 7291 verifyFormat("decltype(a * b) F();"); 7292 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 7293 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 7294 verifyIndependentOfContext("typedef void (*f)(int *a);"); 7295 verifyIndependentOfContext("int i{a * b};"); 7296 verifyIndependentOfContext("aaa && aaa->f();"); 7297 verifyIndependentOfContext("int x = ~*p;"); 7298 verifyFormat("Constructor() : a(a), area(width * height) {}"); 7299 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 7300 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 7301 verifyFormat("void f() { f(a, c * d); }"); 7302 verifyFormat("void f() { f(new a(), c * d); }"); 7303 verifyFormat("void f(const MyOverride &override);"); 7304 verifyFormat("void f(const MyFinal &final);"); 7305 verifyIndependentOfContext("bool a = f() && override.f();"); 7306 verifyIndependentOfContext("bool a = f() && final.f();"); 7307 7308 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 7309 7310 verifyIndependentOfContext("A<int *> a;"); 7311 verifyIndependentOfContext("A<int **> a;"); 7312 verifyIndependentOfContext("A<int *, int *> a;"); 7313 verifyIndependentOfContext("A<int *[]> a;"); 7314 verifyIndependentOfContext( 7315 "const char *const p = reinterpret_cast<const char *const>(q);"); 7316 verifyIndependentOfContext("A<int **, int **> a;"); 7317 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 7318 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 7319 verifyFormat("for (; a && b;) {\n}"); 7320 verifyFormat("bool foo = true && [] { return false; }();"); 7321 7322 verifyFormat( 7323 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7324 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7325 7326 verifyGoogleFormat("int const* a = &b;"); 7327 verifyGoogleFormat("**outparam = 1;"); 7328 verifyGoogleFormat("*outparam = a * b;"); 7329 verifyGoogleFormat("int main(int argc, char** argv) {}"); 7330 verifyGoogleFormat("A<int*> a;"); 7331 verifyGoogleFormat("A<int**> a;"); 7332 verifyGoogleFormat("A<int*, int*> a;"); 7333 verifyGoogleFormat("A<int**, int**> a;"); 7334 verifyGoogleFormat("f(b ? *c : *d);"); 7335 verifyGoogleFormat("int a = b ? *c : *d;"); 7336 verifyGoogleFormat("Type* t = **x;"); 7337 verifyGoogleFormat("Type* t = *++*x;"); 7338 verifyGoogleFormat("*++*x;"); 7339 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 7340 verifyGoogleFormat("Type* t = x++ * y;"); 7341 verifyGoogleFormat( 7342 "const char* const p = reinterpret_cast<const char* const>(q);"); 7343 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 7344 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 7345 verifyGoogleFormat("template <typename T>\n" 7346 "void f(int i = 0, SomeType** temps = NULL);"); 7347 7348 FormatStyle Left = getLLVMStyle(); 7349 Left.PointerAlignment = FormatStyle::PAS_Left; 7350 verifyFormat("x = *a(x) = *a(y);", Left); 7351 verifyFormat("for (;; *a = b) {\n}", Left); 7352 verifyFormat("return *this += 1;", Left); 7353 verifyFormat("throw *x;", Left); 7354 verifyFormat("delete *x;", Left); 7355 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 7356 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 7357 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 7358 7359 verifyIndependentOfContext("a = *(x + y);"); 7360 verifyIndependentOfContext("a = &(x + y);"); 7361 verifyIndependentOfContext("*(x + y).call();"); 7362 verifyIndependentOfContext("&(x + y)->call();"); 7363 verifyFormat("void f() { &(*I).first; }"); 7364 7365 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 7366 verifyFormat( 7367 "int *MyValues = {\n" 7368 " *A, // Operator detection might be confused by the '{'\n" 7369 " *BB // Operator detection might be confused by previous comment\n" 7370 "};"); 7371 7372 verifyIndependentOfContext("if (int *a = &b)"); 7373 verifyIndependentOfContext("if (int &a = *b)"); 7374 verifyIndependentOfContext("if (a & b[i])"); 7375 verifyIndependentOfContext("if constexpr (a & b[i])"); 7376 verifyIndependentOfContext("if CONSTEXPR (a & b[i])"); 7377 verifyIndependentOfContext("if (a * (b * c))"); 7378 verifyIndependentOfContext("if constexpr (a * (b * c))"); 7379 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))"); 7380 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 7381 verifyIndependentOfContext("if (*b[i])"); 7382 verifyIndependentOfContext("if (int *a = (&b))"); 7383 verifyIndependentOfContext("while (int *a = &b)"); 7384 verifyIndependentOfContext("while (a * (b * c))"); 7385 verifyIndependentOfContext("size = sizeof *a;"); 7386 verifyIndependentOfContext("if (a && (b = c))"); 7387 verifyFormat("void f() {\n" 7388 " for (const int &v : Values) {\n" 7389 " }\n" 7390 "}"); 7391 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 7392 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 7393 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 7394 7395 verifyFormat("#define A (!a * b)"); 7396 verifyFormat("#define MACRO \\\n" 7397 " int *i = a * b; \\\n" 7398 " void f(a *b);", 7399 getLLVMStyleWithColumns(19)); 7400 7401 verifyIndependentOfContext("A = new SomeType *[Length];"); 7402 verifyIndependentOfContext("A = new SomeType *[Length]();"); 7403 verifyIndependentOfContext("T **t = new T *;"); 7404 verifyIndependentOfContext("T **t = new T *();"); 7405 verifyGoogleFormat("A = new SomeType*[Length]();"); 7406 verifyGoogleFormat("A = new SomeType*[Length];"); 7407 verifyGoogleFormat("T** t = new T*;"); 7408 verifyGoogleFormat("T** t = new T*();"); 7409 7410 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 7411 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 7412 verifyFormat("template <bool a, bool b> " 7413 "typename t::if<x && y>::type f() {}"); 7414 verifyFormat("template <int *y> f() {}"); 7415 verifyFormat("vector<int *> v;"); 7416 verifyFormat("vector<int *const> v;"); 7417 verifyFormat("vector<int *const **const *> v;"); 7418 verifyFormat("vector<int *volatile> v;"); 7419 verifyFormat("vector<a * b> v;"); 7420 verifyFormat("foo<b && false>();"); 7421 verifyFormat("foo<b & 1>();"); 7422 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 7423 verifyFormat( 7424 "template <class T, class = typename std::enable_if<\n" 7425 " std::is_integral<T>::value &&\n" 7426 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 7427 "void F();", 7428 getLLVMStyleWithColumns(70)); 7429 verifyFormat("template <class T,\n" 7430 " class = typename std::enable_if<\n" 7431 " std::is_integral<T>::value &&\n" 7432 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 7433 " class U>\n" 7434 "void F();", 7435 getLLVMStyleWithColumns(70)); 7436 verifyFormat( 7437 "template <class T,\n" 7438 " class = typename ::std::enable_if<\n" 7439 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 7440 "void F();", 7441 getGoogleStyleWithColumns(68)); 7442 7443 verifyIndependentOfContext("MACRO(int *i);"); 7444 verifyIndependentOfContext("MACRO(auto *a);"); 7445 verifyIndependentOfContext("MACRO(const A *a);"); 7446 verifyIndependentOfContext("MACRO(A *const a);"); 7447 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 7448 verifyFormat("void f() { f(float{1}, a * a); }"); 7449 // FIXME: Is there a way to make this work? 7450 // verifyIndependentOfContext("MACRO(A *a);"); 7451 7452 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 7453 verifyFormat("return options != nullptr && operator==(*options);"); 7454 7455 EXPECT_EQ("#define OP(x) \\\n" 7456 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7457 " return s << a.DebugString(); \\\n" 7458 " }", 7459 format("#define OP(x) \\\n" 7460 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7461 " return s << a.DebugString(); \\\n" 7462 " }", 7463 getLLVMStyleWithColumns(50))); 7464 7465 // FIXME: We cannot handle this case yet; we might be able to figure out that 7466 // foo<x> d > v; doesn't make sense. 7467 verifyFormat("foo<a<b && c> d> v;"); 7468 7469 FormatStyle PointerMiddle = getLLVMStyle(); 7470 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7471 verifyFormat("delete *x;", PointerMiddle); 7472 verifyFormat("int * x;", PointerMiddle); 7473 verifyFormat("int *[] x;", PointerMiddle); 7474 verifyFormat("template <int * y> f() {}", PointerMiddle); 7475 verifyFormat("int * f(int * a) {}", PointerMiddle); 7476 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7477 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7478 verifyFormat("A<int *> a;", PointerMiddle); 7479 verifyFormat("A<int **> a;", PointerMiddle); 7480 verifyFormat("A<int *, int *> a;", PointerMiddle); 7481 verifyFormat("A<int *[]> a;", PointerMiddle); 7482 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7483 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7484 verifyFormat("T ** t = new T *;", PointerMiddle); 7485 7486 // Member function reference qualifiers aren't binary operators. 7487 verifyFormat("string // break\n" 7488 "operator()() & {}"); 7489 verifyFormat("string // break\n" 7490 "operator()() && {}"); 7491 verifyGoogleFormat("template <typename T>\n" 7492 "auto x() & -> int {}"); 7493 } 7494 7495 TEST_F(FormatTest, UnderstandsAttributes) { 7496 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7497 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7498 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7499 FormatStyle AfterType = getLLVMStyle(); 7500 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7501 verifyFormat("__attribute__((nodebug)) void\n" 7502 "foo() {}\n", 7503 AfterType); 7504 } 7505 7506 TEST_F(FormatTest, UnderstandsSquareAttributes) { 7507 verifyFormat("SomeType s [[unused]] (InitValue);"); 7508 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 7509 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 7510 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 7511 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 7512 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7513 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7514 7515 // Make sure we do not mistake attributes for array subscripts. 7516 verifyFormat("int a() {}\n" 7517 "[[unused]] int b() {}\n"); 7518 verifyFormat("NSArray *arr;\n" 7519 "arr[[Foo() bar]];"); 7520 7521 // On the other hand, we still need to correctly find array subscripts. 7522 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 7523 7524 // Make sure that we do not mistake Objective-C method inside array literals 7525 // as attributes, even if those method names are also keywords. 7526 verifyFormat("@[ [foo bar] ];"); 7527 verifyFormat("@[ [NSArray class] ];"); 7528 verifyFormat("@[ [foo enum] ];"); 7529 7530 // Make sure we do not parse attributes as lambda introducers. 7531 FormatStyle MultiLineFunctions = getLLVMStyle(); 7532 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7533 verifyFormat("[[unused]] int b() {\n" 7534 " return 42;\n" 7535 "}\n", 7536 MultiLineFunctions); 7537 } 7538 7539 TEST_F(FormatTest, UnderstandsEllipsis) { 7540 verifyFormat("int printf(const char *fmt, ...);"); 7541 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 7542 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 7543 7544 FormatStyle PointersLeft = getLLVMStyle(); 7545 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 7546 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 7547 } 7548 7549 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 7550 EXPECT_EQ("int *a;\n" 7551 "int *a;\n" 7552 "int *a;", 7553 format("int *a;\n" 7554 "int* a;\n" 7555 "int *a;", 7556 getGoogleStyle())); 7557 EXPECT_EQ("int* a;\n" 7558 "int* a;\n" 7559 "int* a;", 7560 format("int* a;\n" 7561 "int* a;\n" 7562 "int *a;", 7563 getGoogleStyle())); 7564 EXPECT_EQ("int *a;\n" 7565 "int *a;\n" 7566 "int *a;", 7567 format("int *a;\n" 7568 "int * a;\n" 7569 "int * a;", 7570 getGoogleStyle())); 7571 EXPECT_EQ("auto x = [] {\n" 7572 " int *a;\n" 7573 " int *a;\n" 7574 " int *a;\n" 7575 "};", 7576 format("auto x=[]{int *a;\n" 7577 "int * a;\n" 7578 "int * a;};", 7579 getGoogleStyle())); 7580 } 7581 7582 TEST_F(FormatTest, UnderstandsRvalueReferences) { 7583 verifyFormat("int f(int &&a) {}"); 7584 verifyFormat("int f(int a, char &&b) {}"); 7585 verifyFormat("void f() { int &&a = b; }"); 7586 verifyGoogleFormat("int f(int a, char&& b) {}"); 7587 verifyGoogleFormat("void f() { int&& a = b; }"); 7588 7589 verifyIndependentOfContext("A<int &&> a;"); 7590 verifyIndependentOfContext("A<int &&, int &&> a;"); 7591 verifyGoogleFormat("A<int&&> a;"); 7592 verifyGoogleFormat("A<int&&, int&&> a;"); 7593 7594 // Not rvalue references: 7595 verifyFormat("template <bool B, bool C> class A {\n" 7596 " static_assert(B && C, \"Something is wrong\");\n" 7597 "};"); 7598 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 7599 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 7600 verifyFormat("#define A(a, b) (a && b)"); 7601 } 7602 7603 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 7604 verifyFormat("void f() {\n" 7605 " x[aaaaaaaaa -\n" 7606 " b] = 23;\n" 7607 "}", 7608 getLLVMStyleWithColumns(15)); 7609 } 7610 7611 TEST_F(FormatTest, FormatsCasts) { 7612 verifyFormat("Type *A = static_cast<Type *>(P);"); 7613 verifyFormat("Type *A = (Type *)P;"); 7614 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7615 verifyFormat("int a = (int)(2.0f);"); 7616 verifyFormat("int a = (int)2.0f;"); 7617 verifyFormat("x[(int32)y];"); 7618 verifyFormat("x = (int32)y;"); 7619 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7620 verifyFormat("int a = (int)*b;"); 7621 verifyFormat("int a = (int)2.0f;"); 7622 verifyFormat("int a = (int)~0;"); 7623 verifyFormat("int a = (int)++a;"); 7624 verifyFormat("int a = (int)sizeof(int);"); 7625 verifyFormat("int a = (int)+2;"); 7626 verifyFormat("my_int a = (my_int)2.0f;"); 7627 verifyFormat("my_int a = (my_int)sizeof(int);"); 7628 verifyFormat("return (my_int)aaa;"); 7629 verifyFormat("#define x ((int)-1)"); 7630 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7631 verifyFormat("#define p(q) ((int *)&q)"); 7632 verifyFormat("fn(a)(b) + 1;"); 7633 7634 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7635 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7636 verifyFormat("my_int a = (my_int)~0;"); 7637 verifyFormat("my_int a = (my_int)++a;"); 7638 verifyFormat("my_int a = (my_int)-2;"); 7639 verifyFormat("my_int a = (my_int)1;"); 7640 verifyFormat("my_int a = (my_int *)1;"); 7641 verifyFormat("my_int a = (const my_int)-1;"); 7642 verifyFormat("my_int a = (const my_int *)-1;"); 7643 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7644 verifyFormat("my_int a = (ns::my_int)-2;"); 7645 verifyFormat("case (my_int)ONE:"); 7646 verifyFormat("auto x = (X)this;"); 7647 // Casts in Obj-C style calls used to not be recognized as such. 7648 verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle()); 7649 7650 // FIXME: single value wrapped with paren will be treated as cast. 7651 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7652 7653 verifyFormat("{ (void)F; }"); 7654 7655 // Don't break after a cast's 7656 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7657 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7658 " bbbbbbbbbbbbbbbbbbbbbb);"); 7659 7660 // These are not casts. 7661 verifyFormat("void f(int *) {}"); 7662 verifyFormat("f(foo)->b;"); 7663 verifyFormat("f(foo).b;"); 7664 verifyFormat("f(foo)(b);"); 7665 verifyFormat("f(foo)[b];"); 7666 verifyFormat("[](foo) { return 4; }(bar);"); 7667 verifyFormat("(*funptr)(foo)[4];"); 7668 verifyFormat("funptrs[4](foo)[4];"); 7669 verifyFormat("void f(int *);"); 7670 verifyFormat("void f(int *) = 0;"); 7671 verifyFormat("void f(SmallVector<int>) {}"); 7672 verifyFormat("void f(SmallVector<int>);"); 7673 verifyFormat("void f(SmallVector<int>) = 0;"); 7674 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7675 verifyFormat("int a = sizeof(int) * b;"); 7676 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7677 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7678 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7679 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7680 7681 // These are not casts, but at some point were confused with casts. 7682 verifyFormat("virtual void foo(int *) override;"); 7683 verifyFormat("virtual void foo(char &) const;"); 7684 verifyFormat("virtual void foo(int *a, char *) const;"); 7685 verifyFormat("int a = sizeof(int *) + b;"); 7686 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7687 verifyFormat("bool b = f(g<int>) && c;"); 7688 verifyFormat("typedef void (*f)(int i) func;"); 7689 verifyFormat("void operator++(int) noexcept;"); 7690 verifyFormat("void operator++(int &) noexcept;"); 7691 verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t " 7692 "&) noexcept;"); 7693 verifyFormat( 7694 "void operator delete(std::size_t, const std::nothrow_t &) noexcept;"); 7695 verifyFormat("void operator delete(const std::nothrow_t &) noexcept;"); 7696 verifyFormat("void operator delete(std::nothrow_t &) noexcept;"); 7697 verifyFormat("void operator delete(nothrow_t &) noexcept;"); 7698 verifyFormat("void operator delete(foo &) noexcept;"); 7699 verifyFormat("void operator delete(foo) noexcept;"); 7700 verifyFormat("void operator delete(int) noexcept;"); 7701 verifyFormat("void operator delete(int &) noexcept;"); 7702 verifyFormat("void operator delete(int &) volatile noexcept;"); 7703 verifyFormat("void operator delete(int &) const"); 7704 verifyFormat("void operator delete(int &) = default"); 7705 verifyFormat("void operator delete(int &) = delete"); 7706 verifyFormat("void operator delete(int &) [[noreturn]]"); 7707 verifyFormat("void operator delete(int &) throw();"); 7708 verifyFormat("void operator delete(int &) throw(int);"); 7709 verifyFormat("auto operator delete(int &) -> int;"); 7710 verifyFormat("auto operator delete(int &) override"); 7711 verifyFormat("auto operator delete(int &) final"); 7712 7713 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7714 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7715 // FIXME: The indentation here is not ideal. 7716 verifyFormat( 7717 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7718 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7719 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7720 } 7721 7722 TEST_F(FormatTest, FormatsFunctionTypes) { 7723 verifyFormat("A<bool()> a;"); 7724 verifyFormat("A<SomeType()> a;"); 7725 verifyFormat("A<void (*)(int, std::string)> a;"); 7726 verifyFormat("A<void *(int)>;"); 7727 verifyFormat("void *(*a)(int *, SomeType *);"); 7728 verifyFormat("int (*func)(void *);"); 7729 verifyFormat("void f() { int (*func)(void *); }"); 7730 verifyFormat("template <class CallbackClass>\n" 7731 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7732 7733 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7734 verifyGoogleFormat("void* (*a)(int);"); 7735 verifyGoogleFormat( 7736 "template <class CallbackClass>\n" 7737 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7738 7739 // Other constructs can look somewhat like function types: 7740 verifyFormat("A<sizeof(*x)> a;"); 7741 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7742 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7743 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7744 verifyFormat("int x = f(&h)();"); 7745 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7746 verifyFormat("std::function<\n" 7747 " LooooooooooongTemplatedType<\n" 7748 " SomeType>*(\n" 7749 " LooooooooooooooooongType type)>\n" 7750 " function;", 7751 getGoogleStyleWithColumns(40)); 7752 } 7753 7754 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7755 verifyFormat("A (*foo_)[6];"); 7756 verifyFormat("vector<int> (*foo_)[6];"); 7757 } 7758 7759 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7760 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7761 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7762 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7763 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7764 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7765 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7766 7767 // Different ways of ()-initializiation. 7768 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7769 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7770 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7771 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7772 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7773 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7774 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7775 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7776 7777 // Lambdas should not confuse the variable declaration heuristic. 7778 verifyFormat("LooooooooooooooooongType\n" 7779 " variable(nullptr, [](A *a) {});", 7780 getLLVMStyleWithColumns(40)); 7781 } 7782 7783 TEST_F(FormatTest, BreaksLongDeclarations) { 7784 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7785 " AnotherNameForTheLongType;"); 7786 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7787 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7788 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7789 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7790 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7791 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7792 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7793 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7794 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7795 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7796 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7797 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7798 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7799 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7800 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7801 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7802 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7803 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7804 FormatStyle Indented = getLLVMStyle(); 7805 Indented.IndentWrappedFunctionNames = true; 7806 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7807 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7808 Indented); 7809 verifyFormat( 7810 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7811 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7812 Indented); 7813 verifyFormat( 7814 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7815 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7816 Indented); 7817 verifyFormat( 7818 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7819 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7820 Indented); 7821 7822 // FIXME: Without the comment, this breaks after "(". 7823 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7824 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7825 getGoogleStyle()); 7826 7827 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7828 " int LoooooooooooooooooooongParam2) {}"); 7829 verifyFormat( 7830 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7831 " SourceLocation L, IdentifierIn *II,\n" 7832 " Type *T) {}"); 7833 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7834 "ReallyReaaallyLongFunctionName(\n" 7835 " const std::string &SomeParameter,\n" 7836 " const SomeType<string, SomeOtherTemplateParameter>\n" 7837 " &ReallyReallyLongParameterName,\n" 7838 " const SomeType<string, SomeOtherTemplateParameter>\n" 7839 " &AnotherLongParameterName) {}"); 7840 verifyFormat("template <typename A>\n" 7841 "SomeLoooooooooooooooooooooongType<\n" 7842 " typename some_namespace::SomeOtherType<A>::Type>\n" 7843 "Function() {}"); 7844 7845 verifyGoogleFormat( 7846 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7847 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7848 verifyGoogleFormat( 7849 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7850 " SourceLocation L) {}"); 7851 verifyGoogleFormat( 7852 "some_namespace::LongReturnType\n" 7853 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7854 " int first_long_parameter, int second_parameter) {}"); 7855 7856 verifyGoogleFormat("template <typename T>\n" 7857 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7858 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7859 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7860 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7861 7862 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7863 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7864 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7865 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7866 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7867 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 7868 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7869 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 7870 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 7871 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7872 7873 verifyFormat("template <typename T> // Templates on own line.\n" 7874 "static int // Some comment.\n" 7875 "MyFunction(int a);", 7876 getLLVMStyle()); 7877 } 7878 7879 TEST_F(FormatTest, FormatsArrays) { 7880 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7881 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 7882 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 7883 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 7884 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 7885 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 7886 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7887 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7888 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7889 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 7890 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7891 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7892 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7893 verifyFormat( 7894 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 7895 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7896 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 7897 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 7898 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7899 7900 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 7901 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 7902 verifyFormat( 7903 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 7904 " .aaaaaaa[0]\n" 7905 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7906 verifyFormat("a[::b::c];"); 7907 7908 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 7909 7910 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 7911 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 7912 } 7913 7914 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 7915 verifyFormat("(a)->b();"); 7916 verifyFormat("--a;"); 7917 } 7918 7919 TEST_F(FormatTest, HandlesIncludeDirectives) { 7920 verifyFormat("#include <string>\n" 7921 "#include <a/b/c.h>\n" 7922 "#include \"a/b/string\"\n" 7923 "#include \"string.h\"\n" 7924 "#include \"string.h\"\n" 7925 "#include <a-a>\n" 7926 "#include < path with space >\n" 7927 "#include_next <test.h>" 7928 "#include \"abc.h\" // this is included for ABC\n" 7929 "#include \"some long include\" // with a comment\n" 7930 "#include \"some very long include path\"\n" 7931 "#include <some/very/long/include/path>\n", 7932 getLLVMStyleWithColumns(35)); 7933 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 7934 EXPECT_EQ("#include <a>", format("#include<a>")); 7935 7936 verifyFormat("#import <string>"); 7937 verifyFormat("#import <a/b/c.h>"); 7938 verifyFormat("#import \"a/b/string\""); 7939 verifyFormat("#import \"string.h\""); 7940 verifyFormat("#import \"string.h\""); 7941 verifyFormat("#if __has_include(<strstream>)\n" 7942 "#include <strstream>\n" 7943 "#endif"); 7944 7945 verifyFormat("#define MY_IMPORT <a/b>"); 7946 7947 verifyFormat("#if __has_include(<a/b>)"); 7948 verifyFormat("#if __has_include_next(<a/b>)"); 7949 verifyFormat("#define F __has_include(<a/b>)"); 7950 verifyFormat("#define F __has_include_next(<a/b>)"); 7951 7952 // Protocol buffer definition or missing "#". 7953 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 7954 getLLVMStyleWithColumns(30)); 7955 7956 FormatStyle Style = getLLVMStyle(); 7957 Style.AlwaysBreakBeforeMultilineStrings = true; 7958 Style.ColumnLimit = 0; 7959 verifyFormat("#import \"abc.h\"", Style); 7960 7961 // But 'import' might also be a regular C++ namespace. 7962 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7963 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7964 } 7965 7966 //===----------------------------------------------------------------------===// 7967 // Error recovery tests. 7968 //===----------------------------------------------------------------------===// 7969 7970 TEST_F(FormatTest, IncompleteParameterLists) { 7971 FormatStyle NoBinPacking = getLLVMStyle(); 7972 NoBinPacking.BinPackParameters = false; 7973 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 7974 " double *min_x,\n" 7975 " double *max_x,\n" 7976 " double *min_y,\n" 7977 " double *max_y,\n" 7978 " double *min_z,\n" 7979 " double *max_z, ) {}", 7980 NoBinPacking); 7981 } 7982 7983 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 7984 verifyFormat("void f() { return; }\n42"); 7985 verifyFormat("void f() {\n" 7986 " if (0)\n" 7987 " return;\n" 7988 "}\n" 7989 "42"); 7990 verifyFormat("void f() { return }\n42"); 7991 verifyFormat("void f() {\n" 7992 " if (0)\n" 7993 " return\n" 7994 "}\n" 7995 "42"); 7996 } 7997 7998 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 7999 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 8000 EXPECT_EQ("void f() {\n" 8001 " if (a)\n" 8002 " return\n" 8003 "}", 8004 format("void f ( ) { if ( a ) return }")); 8005 EXPECT_EQ("namespace N {\n" 8006 "void f()\n" 8007 "}", 8008 format("namespace N { void f() }")); 8009 EXPECT_EQ("namespace N {\n" 8010 "void f() {}\n" 8011 "void g()\n" 8012 "} // namespace N", 8013 format("namespace N { void f( ) { } void g( ) }")); 8014 } 8015 8016 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 8017 verifyFormat("int aaaaaaaa =\n" 8018 " // Overlylongcomment\n" 8019 " b;", 8020 getLLVMStyleWithColumns(20)); 8021 verifyFormat("function(\n" 8022 " ShortArgument,\n" 8023 " LoooooooooooongArgument);\n", 8024 getLLVMStyleWithColumns(20)); 8025 } 8026 8027 TEST_F(FormatTest, IncorrectAccessSpecifier) { 8028 verifyFormat("public:"); 8029 verifyFormat("class A {\n" 8030 "public\n" 8031 " void f() {}\n" 8032 "};"); 8033 verifyFormat("public\n" 8034 "int qwerty;"); 8035 verifyFormat("public\n" 8036 "B {}"); 8037 verifyFormat("public\n" 8038 "{}"); 8039 verifyFormat("public\n" 8040 "B { int x; }"); 8041 } 8042 8043 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 8044 verifyFormat("{"); 8045 verifyFormat("#})"); 8046 verifyNoCrash("(/**/[:!] ?[)."); 8047 } 8048 8049 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 8050 // Found by oss-fuzz: 8051 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 8052 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 8053 Style.ColumnLimit = 60; 8054 verifyNoCrash( 8055 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 8056 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 8057 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 8058 Style); 8059 } 8060 8061 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 8062 verifyFormat("do {\n}"); 8063 verifyFormat("do {\n}\n" 8064 "f();"); 8065 verifyFormat("do {\n}\n" 8066 "wheeee(fun);"); 8067 verifyFormat("do {\n" 8068 " f();\n" 8069 "}"); 8070 } 8071 8072 TEST_F(FormatTest, IncorrectCodeMissingParens) { 8073 verifyFormat("if {\n foo;\n foo();\n}"); 8074 verifyFormat("switch {\n foo;\n foo();\n}"); 8075 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 8076 verifyFormat("while {\n foo;\n foo();\n}"); 8077 verifyFormat("do {\n foo;\n foo();\n} while;"); 8078 } 8079 8080 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 8081 verifyIncompleteFormat("namespace {\n" 8082 "class Foo { Foo (\n" 8083 "};\n" 8084 "} // namespace"); 8085 } 8086 8087 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 8088 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 8089 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 8090 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 8091 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 8092 8093 EXPECT_EQ("{\n" 8094 " {\n" 8095 " breakme(\n" 8096 " qwe);\n" 8097 " }\n", 8098 format("{\n" 8099 " {\n" 8100 " breakme(qwe);\n" 8101 "}\n", 8102 getLLVMStyleWithColumns(10))); 8103 } 8104 8105 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 8106 verifyFormat("int x = {\n" 8107 " avariable,\n" 8108 " b(alongervariable)};", 8109 getLLVMStyleWithColumns(25)); 8110 } 8111 8112 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 8113 verifyFormat("return (a)(b){1, 2, 3};"); 8114 } 8115 8116 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 8117 verifyFormat("vector<int> x{1, 2, 3, 4};"); 8118 verifyFormat("vector<int> x{\n" 8119 " 1,\n" 8120 " 2,\n" 8121 " 3,\n" 8122 " 4,\n" 8123 "};"); 8124 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 8125 verifyFormat("f({1, 2});"); 8126 verifyFormat("auto v = Foo{-1};"); 8127 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 8128 verifyFormat("Class::Class : member{1, 2, 3} {}"); 8129 verifyFormat("new vector<int>{1, 2, 3};"); 8130 verifyFormat("new int[3]{1, 2, 3};"); 8131 verifyFormat("new int{1};"); 8132 verifyFormat("return {arg1, arg2};"); 8133 verifyFormat("return {arg1, SomeType{parameter}};"); 8134 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 8135 verifyFormat("new T{arg1, arg2};"); 8136 verifyFormat("f(MyMap[{composite, key}]);"); 8137 verifyFormat("class Class {\n" 8138 " T member = {arg1, arg2};\n" 8139 "};"); 8140 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 8141 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 8142 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 8143 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 8144 verifyFormat("int a = std::is_integral<int>{} + 0;"); 8145 8146 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8147 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8148 verifyFormat("auto i = decltype(x){};"); 8149 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 8150 verifyFormat("Node n{1, Node{1000}, //\n" 8151 " 2};"); 8152 verifyFormat("Aaaa aaaaaaa{\n" 8153 " {\n" 8154 " aaaa,\n" 8155 " },\n" 8156 "};"); 8157 verifyFormat("class C : public D {\n" 8158 " SomeClass SC{2};\n" 8159 "};"); 8160 verifyFormat("class C : public A {\n" 8161 " class D : public B {\n" 8162 " void f() { int i{2}; }\n" 8163 " };\n" 8164 "};"); 8165 verifyFormat("#define A {a, a},"); 8166 8167 // Avoid breaking between equal sign and opening brace 8168 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 8169 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 8170 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 8171 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 8172 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 8173 " {\"ccccccccccccccccccccc\", 2}};", 8174 AvoidBreakingFirstArgument); 8175 8176 // Binpacking only if there is no trailing comma 8177 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 8178 " cccccccccc, dddddddddd};", 8179 getLLVMStyleWithColumns(50)); 8180 verifyFormat("const Aaaaaa aaaaa = {\n" 8181 " aaaaaaaaaaa,\n" 8182 " bbbbbbbbbbb,\n" 8183 " ccccccccccc,\n" 8184 " ddddddddddd,\n" 8185 "};", 8186 getLLVMStyleWithColumns(50)); 8187 8188 // Cases where distinguising braced lists and blocks is hard. 8189 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 8190 verifyFormat("void f() {\n" 8191 " return; // comment\n" 8192 "}\n" 8193 "SomeType t;"); 8194 verifyFormat("void f() {\n" 8195 " if (a) {\n" 8196 " f();\n" 8197 " }\n" 8198 "}\n" 8199 "SomeType t;"); 8200 8201 // In combination with BinPackArguments = false. 8202 FormatStyle NoBinPacking = getLLVMStyle(); 8203 NoBinPacking.BinPackArguments = false; 8204 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 8205 " bbbbb,\n" 8206 " ccccc,\n" 8207 " ddddd,\n" 8208 " eeeee,\n" 8209 " ffffff,\n" 8210 " ggggg,\n" 8211 " hhhhhh,\n" 8212 " iiiiii,\n" 8213 " jjjjjj,\n" 8214 " kkkkkk};", 8215 NoBinPacking); 8216 verifyFormat("const Aaaaaa aaaaa = {\n" 8217 " aaaaa,\n" 8218 " bbbbb,\n" 8219 " ccccc,\n" 8220 " ddddd,\n" 8221 " eeeee,\n" 8222 " ffffff,\n" 8223 " ggggg,\n" 8224 " hhhhhh,\n" 8225 " iiiiii,\n" 8226 " jjjjjj,\n" 8227 " kkkkkk,\n" 8228 "};", 8229 NoBinPacking); 8230 verifyFormat( 8231 "const Aaaaaa aaaaa = {\n" 8232 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 8233 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 8234 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 8235 "};", 8236 NoBinPacking); 8237 8238 NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 8239 EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n" 8240 " CDDDP83848_BMCR_REGISTER,\n" 8241 " CDDDP83848_BMSR_REGISTER,\n" 8242 " CDDDP83848_RBR_REGISTER};", 8243 format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n" 8244 " CDDDP83848_BMSR_REGISTER,\n" 8245 " CDDDP83848_RBR_REGISTER};", 8246 NoBinPacking)); 8247 8248 // FIXME: The alignment of these trailing comments might be bad. Then again, 8249 // this might be utterly useless in real code. 8250 verifyFormat("Constructor::Constructor()\n" 8251 " : some_value{ //\n" 8252 " aaaaaaa, //\n" 8253 " bbbbbbb} {}"); 8254 8255 // In braced lists, the first comment is always assumed to belong to the 8256 // first element. Thus, it can be moved to the next or previous line as 8257 // appropriate. 8258 EXPECT_EQ("function({// First element:\n" 8259 " 1,\n" 8260 " // Second element:\n" 8261 " 2});", 8262 format("function({\n" 8263 " // First element:\n" 8264 " 1,\n" 8265 " // Second element:\n" 8266 " 2});")); 8267 EXPECT_EQ("std::vector<int> MyNumbers{\n" 8268 " // First element:\n" 8269 " 1,\n" 8270 " // Second element:\n" 8271 " 2};", 8272 format("std::vector<int> MyNumbers{// First element:\n" 8273 " 1,\n" 8274 " // Second element:\n" 8275 " 2};", 8276 getLLVMStyleWithColumns(30))); 8277 // A trailing comma should still lead to an enforced line break and no 8278 // binpacking. 8279 EXPECT_EQ("vector<int> SomeVector = {\n" 8280 " // aaa\n" 8281 " 1,\n" 8282 " 2,\n" 8283 "};", 8284 format("vector<int> SomeVector = { // aaa\n" 8285 " 1, 2, };")); 8286 8287 FormatStyle ExtraSpaces = getLLVMStyle(); 8288 ExtraSpaces.Cpp11BracedListStyle = false; 8289 ExtraSpaces.ColumnLimit = 75; 8290 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 8291 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 8292 verifyFormat("f({ 1, 2 });", ExtraSpaces); 8293 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 8294 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 8295 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 8296 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 8297 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 8298 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 8299 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 8300 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 8301 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 8302 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 8303 verifyFormat("class Class {\n" 8304 " T member = { arg1, arg2 };\n" 8305 "};", 8306 ExtraSpaces); 8307 verifyFormat( 8308 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8309 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 8310 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 8311 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 8312 ExtraSpaces); 8313 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 8314 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 8315 ExtraSpaces); 8316 verifyFormat( 8317 "someFunction(OtherParam,\n" 8318 " BracedList{ // comment 1 (Forcing interesting break)\n" 8319 " param1, param2,\n" 8320 " // comment 2\n" 8321 " param3, param4 });", 8322 ExtraSpaces); 8323 verifyFormat( 8324 "std::this_thread::sleep_for(\n" 8325 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 8326 ExtraSpaces); 8327 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 8328 " aaaaaaa,\n" 8329 " aaaaaaaaaa,\n" 8330 " aaaaa,\n" 8331 " aaaaaaaaaaaaaaa,\n" 8332 " aaa,\n" 8333 " aaaaaaaaaa,\n" 8334 " a,\n" 8335 " aaaaaaaaaaaaaaaaaaaaa,\n" 8336 " aaaaaaaaaaaa,\n" 8337 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 8338 " aaaaaaa,\n" 8339 " a};"); 8340 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 8341 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 8342 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 8343 8344 // Avoid breaking between initializer/equal sign and opening brace 8345 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 8346 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 8347 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8348 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8349 " { \"ccccccccccccccccccccc\", 2 }\n" 8350 "};", 8351 ExtraSpaces); 8352 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 8353 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8354 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8355 " { \"ccccccccccccccccccccc\", 2 }\n" 8356 "};", 8357 ExtraSpaces); 8358 8359 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 8360 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 8361 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 8362 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 8363 8364 FormatStyle SpaceBetweenBraces = getLLVMStyle(); 8365 SpaceBetweenBraces.SpacesInAngles = true; 8366 SpaceBetweenBraces.SpacesInParentheses = true; 8367 SpaceBetweenBraces.SpacesInSquareBrackets = true; 8368 verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces); 8369 verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces); 8370 verifyFormat("vector< int > x{ // comment 1\n" 8371 " 1, 2, 3, 4 };", 8372 SpaceBetweenBraces); 8373 SpaceBetweenBraces.ColumnLimit = 20; 8374 EXPECT_EQ("vector< int > x{\n" 8375 " 1, 2, 3, 4 };", 8376 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8377 SpaceBetweenBraces.ColumnLimit = 24; 8378 EXPECT_EQ("vector< int > x{ 1, 2,\n" 8379 " 3, 4 };", 8380 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8381 EXPECT_EQ("vector< int > x{\n" 8382 " 1,\n" 8383 " 2,\n" 8384 " 3,\n" 8385 " 4,\n" 8386 "};", 8387 format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces)); 8388 verifyFormat("vector< int > x{};", SpaceBetweenBraces); 8389 SpaceBetweenBraces.SpaceInEmptyParentheses = true; 8390 verifyFormat("vector< int > x{ };", SpaceBetweenBraces); 8391 } 8392 8393 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 8394 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8395 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8396 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8397 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8398 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8399 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8400 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 8401 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8402 " 1, 22, 333, 4444, 55555, //\n" 8403 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8404 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8405 verifyFormat( 8406 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8407 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8408 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 8409 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8410 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8411 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8412 " 7777777};"); 8413 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8414 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8415 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8416 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8417 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8418 " // Separating comment.\n" 8419 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8420 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8421 " // Leading comment\n" 8422 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8423 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8424 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8425 " 1, 1, 1, 1};", 8426 getLLVMStyleWithColumns(39)); 8427 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8428 " 1, 1, 1, 1};", 8429 getLLVMStyleWithColumns(38)); 8430 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 8431 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 8432 getLLVMStyleWithColumns(43)); 8433 verifyFormat( 8434 "static unsigned SomeValues[10][3] = {\n" 8435 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 8436 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 8437 verifyFormat("static auto fields = new vector<string>{\n" 8438 " \"aaaaaaaaaaaaa\",\n" 8439 " \"aaaaaaaaaaaaa\",\n" 8440 " \"aaaaaaaaaaaa\",\n" 8441 " \"aaaaaaaaaaaaaa\",\n" 8442 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8443 " \"aaaaaaaaaaaa\",\n" 8444 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8445 "};"); 8446 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 8447 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 8448 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 8449 " 3, cccccccccccccccccccccc};", 8450 getLLVMStyleWithColumns(60)); 8451 8452 // Trailing commas. 8453 verifyFormat("vector<int> x = {\n" 8454 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 8455 "};", 8456 getLLVMStyleWithColumns(39)); 8457 verifyFormat("vector<int> x = {\n" 8458 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 8459 "};", 8460 getLLVMStyleWithColumns(39)); 8461 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8462 " 1, 1, 1, 1,\n" 8463 " /**/ /**/};", 8464 getLLVMStyleWithColumns(39)); 8465 8466 // Trailing comment in the first line. 8467 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 8468 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 8469 " 111111111, 222222222, 3333333333, 444444444, //\n" 8470 " 11111111, 22222222, 333333333, 44444444};"); 8471 // Trailing comment in the last line. 8472 verifyFormat("int aaaaa[] = {\n" 8473 " 1, 2, 3, // comment\n" 8474 " 4, 5, 6 // comment\n" 8475 "};"); 8476 8477 // With nested lists, we should either format one item per line or all nested 8478 // lists one on line. 8479 // FIXME: For some nested lists, we can do better. 8480 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 8481 " {aaaaaaaaaaaaaaaaaaa},\n" 8482 " {aaaaaaaaaaaaaaaaaaaaa},\n" 8483 " {aaaaaaaaaaaaaaaaa}};", 8484 getLLVMStyleWithColumns(60)); 8485 verifyFormat( 8486 "SomeStruct my_struct_array = {\n" 8487 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 8488 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 8489 " {aaa, aaa},\n" 8490 " {aaa, aaa},\n" 8491 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 8492 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 8493 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 8494 8495 // No column layout should be used here. 8496 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 8497 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 8498 8499 verifyNoCrash("a<,"); 8500 8501 // No braced initializer here. 8502 verifyFormat("void f() {\n" 8503 " struct Dummy {};\n" 8504 " f(v);\n" 8505 "}"); 8506 8507 // Long lists should be formatted in columns even if they are nested. 8508 verifyFormat( 8509 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8510 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8511 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8512 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8513 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8514 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 8515 8516 // Allow "single-column" layout even if that violates the column limit. There 8517 // isn't going to be a better way. 8518 verifyFormat("std::vector<int> a = {\n" 8519 " aaaaaaaa,\n" 8520 " aaaaaaaa,\n" 8521 " aaaaaaaa,\n" 8522 " aaaaaaaa,\n" 8523 " aaaaaaaaaa,\n" 8524 " aaaaaaaa,\n" 8525 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 8526 getLLVMStyleWithColumns(30)); 8527 verifyFormat("vector<int> aaaa = {\n" 8528 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8529 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8530 " aaaaaa.aaaaaaa,\n" 8531 " aaaaaa.aaaaaaa,\n" 8532 " aaaaaa.aaaaaaa,\n" 8533 " aaaaaa.aaaaaaa,\n" 8534 "};"); 8535 8536 // Don't create hanging lists. 8537 verifyFormat("someFunction(Param, {List1, List2,\n" 8538 " List3});", 8539 getLLVMStyleWithColumns(35)); 8540 verifyFormat("someFunction(Param, Param,\n" 8541 " {List1, List2,\n" 8542 " List3});", 8543 getLLVMStyleWithColumns(35)); 8544 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 8545 " aaaaaaaaaaaaaaaaaaaaaaa);"); 8546 } 8547 8548 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 8549 FormatStyle DoNotMerge = getLLVMStyle(); 8550 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8551 8552 verifyFormat("void f() { return 42; }"); 8553 verifyFormat("void f() {\n" 8554 " return 42;\n" 8555 "}", 8556 DoNotMerge); 8557 verifyFormat("void f() {\n" 8558 " // Comment\n" 8559 "}"); 8560 verifyFormat("{\n" 8561 "#error {\n" 8562 " int a;\n" 8563 "}"); 8564 verifyFormat("{\n" 8565 " int a;\n" 8566 "#error {\n" 8567 "}"); 8568 verifyFormat("void f() {} // comment"); 8569 verifyFormat("void f() { int a; } // comment"); 8570 verifyFormat("void f() {\n" 8571 "} // comment", 8572 DoNotMerge); 8573 verifyFormat("void f() {\n" 8574 " int a;\n" 8575 "} // comment", 8576 DoNotMerge); 8577 verifyFormat("void f() {\n" 8578 "} // comment", 8579 getLLVMStyleWithColumns(15)); 8580 8581 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 8582 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 8583 8584 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 8585 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 8586 verifyFormat("class C {\n" 8587 " C()\n" 8588 " : iiiiiiii(nullptr),\n" 8589 " kkkkkkk(nullptr),\n" 8590 " mmmmmmm(nullptr),\n" 8591 " nnnnnnn(nullptr) {}\n" 8592 "};", 8593 getGoogleStyle()); 8594 8595 FormatStyle NoColumnLimit = getLLVMStyle(); 8596 NoColumnLimit.ColumnLimit = 0; 8597 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 8598 EXPECT_EQ("class C {\n" 8599 " A() : b(0) {}\n" 8600 "};", 8601 format("class C{A():b(0){}};", NoColumnLimit)); 8602 EXPECT_EQ("A()\n" 8603 " : b(0) {\n" 8604 "}", 8605 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 8606 8607 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 8608 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 8609 FormatStyle::SFS_None; 8610 EXPECT_EQ("A()\n" 8611 " : b(0) {\n" 8612 "}", 8613 format("A():b(0){}", DoNotMergeNoColumnLimit)); 8614 EXPECT_EQ("A()\n" 8615 " : b(0) {\n" 8616 "}", 8617 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 8618 8619 verifyFormat("#define A \\\n" 8620 " void f() { \\\n" 8621 " int i; \\\n" 8622 " }", 8623 getLLVMStyleWithColumns(20)); 8624 verifyFormat("#define A \\\n" 8625 " void f() { int i; }", 8626 getLLVMStyleWithColumns(21)); 8627 verifyFormat("#define A \\\n" 8628 " void f() { \\\n" 8629 " int i; \\\n" 8630 " } \\\n" 8631 " int j;", 8632 getLLVMStyleWithColumns(22)); 8633 verifyFormat("#define A \\\n" 8634 " void f() { int i; } \\\n" 8635 " int j;", 8636 getLLVMStyleWithColumns(23)); 8637 } 8638 8639 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 8640 FormatStyle MergeEmptyOnly = getLLVMStyle(); 8641 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8642 verifyFormat("class C {\n" 8643 " int f() {}\n" 8644 "};", 8645 MergeEmptyOnly); 8646 verifyFormat("class C {\n" 8647 " int f() {\n" 8648 " return 42;\n" 8649 " }\n" 8650 "};", 8651 MergeEmptyOnly); 8652 verifyFormat("int f() {}", MergeEmptyOnly); 8653 verifyFormat("int f() {\n" 8654 " return 42;\n" 8655 "}", 8656 MergeEmptyOnly); 8657 8658 // Also verify behavior when BraceWrapping.AfterFunction = true 8659 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8660 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 8661 verifyFormat("int f() {}", MergeEmptyOnly); 8662 verifyFormat("class C {\n" 8663 " int f() {}\n" 8664 "};", 8665 MergeEmptyOnly); 8666 } 8667 8668 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 8669 FormatStyle MergeInlineOnly = getLLVMStyle(); 8670 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8671 verifyFormat("class C {\n" 8672 " int f() { return 42; }\n" 8673 "};", 8674 MergeInlineOnly); 8675 verifyFormat("int f() {\n" 8676 " return 42;\n" 8677 "}", 8678 MergeInlineOnly); 8679 8680 // SFS_Inline implies SFS_Empty 8681 verifyFormat("class C {\n" 8682 " int f() {}\n" 8683 "};", 8684 MergeInlineOnly); 8685 verifyFormat("int f() {}", MergeInlineOnly); 8686 8687 // Also verify behavior when BraceWrapping.AfterFunction = true 8688 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8689 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8690 verifyFormat("class C {\n" 8691 " int f() { return 42; }\n" 8692 "};", 8693 MergeInlineOnly); 8694 verifyFormat("int f()\n" 8695 "{\n" 8696 " return 42;\n" 8697 "}", 8698 MergeInlineOnly); 8699 8700 // SFS_Inline implies SFS_Empty 8701 verifyFormat("int f() {}", MergeInlineOnly); 8702 verifyFormat("class C {\n" 8703 " int f() {}\n" 8704 "};", 8705 MergeInlineOnly); 8706 } 8707 8708 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8709 FormatStyle MergeInlineOnly = getLLVMStyle(); 8710 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8711 FormatStyle::SFS_InlineOnly; 8712 verifyFormat("class C {\n" 8713 " int f() { return 42; }\n" 8714 "};", 8715 MergeInlineOnly); 8716 verifyFormat("int f() {\n" 8717 " return 42;\n" 8718 "}", 8719 MergeInlineOnly); 8720 8721 // SFS_InlineOnly does not imply SFS_Empty 8722 verifyFormat("class C {\n" 8723 " int f() {}\n" 8724 "};", 8725 MergeInlineOnly); 8726 verifyFormat("int f() {\n" 8727 "}", 8728 MergeInlineOnly); 8729 8730 // Also verify behavior when BraceWrapping.AfterFunction = true 8731 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8732 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8733 verifyFormat("class C {\n" 8734 " int f() { return 42; }\n" 8735 "};", 8736 MergeInlineOnly); 8737 verifyFormat("int f()\n" 8738 "{\n" 8739 " return 42;\n" 8740 "}", 8741 MergeInlineOnly); 8742 8743 // SFS_InlineOnly does not imply SFS_Empty 8744 verifyFormat("int f()\n" 8745 "{\n" 8746 "}", 8747 MergeInlineOnly); 8748 verifyFormat("class C {\n" 8749 " int f() {}\n" 8750 "};", 8751 MergeInlineOnly); 8752 } 8753 8754 TEST_F(FormatTest, SplitEmptyFunction) { 8755 FormatStyle Style = getLLVMStyle(); 8756 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8757 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8758 Style.BraceWrapping.AfterFunction = true; 8759 Style.BraceWrapping.SplitEmptyFunction = false; 8760 Style.ColumnLimit = 40; 8761 8762 verifyFormat("int f()\n" 8763 "{}", 8764 Style); 8765 verifyFormat("int f()\n" 8766 "{\n" 8767 " return 42;\n" 8768 "}", 8769 Style); 8770 verifyFormat("int f()\n" 8771 "{\n" 8772 " // some comment\n" 8773 "}", 8774 Style); 8775 8776 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8777 verifyFormat("int f() {}", Style); 8778 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8779 "{}", 8780 Style); 8781 verifyFormat("int f()\n" 8782 "{\n" 8783 " return 0;\n" 8784 "}", 8785 Style); 8786 8787 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8788 verifyFormat("class Foo {\n" 8789 " int f() {}\n" 8790 "};\n", 8791 Style); 8792 verifyFormat("class Foo {\n" 8793 " int f() { return 0; }\n" 8794 "};\n", 8795 Style); 8796 verifyFormat("class Foo {\n" 8797 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8798 " {}\n" 8799 "};\n", 8800 Style); 8801 verifyFormat("class Foo {\n" 8802 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8803 " {\n" 8804 " return 0;\n" 8805 " }\n" 8806 "};\n", 8807 Style); 8808 8809 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8810 verifyFormat("int f() {}", Style); 8811 verifyFormat("int f() { return 0; }", Style); 8812 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8813 "{}", 8814 Style); 8815 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8816 "{\n" 8817 " return 0;\n" 8818 "}", 8819 Style); 8820 } 8821 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8822 FormatStyle Style = getLLVMStyle(); 8823 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8824 verifyFormat("#ifdef A\n" 8825 "int f() {}\n" 8826 "#else\n" 8827 "int g() {}\n" 8828 "#endif", 8829 Style); 8830 } 8831 8832 TEST_F(FormatTest, SplitEmptyClass) { 8833 FormatStyle Style = getLLVMStyle(); 8834 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8835 Style.BraceWrapping.AfterClass = true; 8836 Style.BraceWrapping.SplitEmptyRecord = false; 8837 8838 verifyFormat("class Foo\n" 8839 "{};", 8840 Style); 8841 verifyFormat("/* something */ class Foo\n" 8842 "{};", 8843 Style); 8844 verifyFormat("template <typename X> class Foo\n" 8845 "{};", 8846 Style); 8847 verifyFormat("class Foo\n" 8848 "{\n" 8849 " Foo();\n" 8850 "};", 8851 Style); 8852 verifyFormat("typedef class Foo\n" 8853 "{\n" 8854 "} Foo_t;", 8855 Style); 8856 } 8857 8858 TEST_F(FormatTest, SplitEmptyStruct) { 8859 FormatStyle Style = getLLVMStyle(); 8860 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8861 Style.BraceWrapping.AfterStruct = true; 8862 Style.BraceWrapping.SplitEmptyRecord = false; 8863 8864 verifyFormat("struct Foo\n" 8865 "{};", 8866 Style); 8867 verifyFormat("/* something */ struct Foo\n" 8868 "{};", 8869 Style); 8870 verifyFormat("template <typename X> struct Foo\n" 8871 "{};", 8872 Style); 8873 verifyFormat("struct Foo\n" 8874 "{\n" 8875 " Foo();\n" 8876 "};", 8877 Style); 8878 verifyFormat("typedef struct Foo\n" 8879 "{\n" 8880 "} Foo_t;", 8881 Style); 8882 // typedef struct Bar {} Bar_t; 8883 } 8884 8885 TEST_F(FormatTest, SplitEmptyUnion) { 8886 FormatStyle Style = getLLVMStyle(); 8887 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8888 Style.BraceWrapping.AfterUnion = true; 8889 Style.BraceWrapping.SplitEmptyRecord = false; 8890 8891 verifyFormat("union Foo\n" 8892 "{};", 8893 Style); 8894 verifyFormat("/* something */ union Foo\n" 8895 "{};", 8896 Style); 8897 verifyFormat("union Foo\n" 8898 "{\n" 8899 " A,\n" 8900 "};", 8901 Style); 8902 verifyFormat("typedef union Foo\n" 8903 "{\n" 8904 "} Foo_t;", 8905 Style); 8906 } 8907 8908 TEST_F(FormatTest, SplitEmptyNamespace) { 8909 FormatStyle Style = getLLVMStyle(); 8910 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8911 Style.BraceWrapping.AfterNamespace = true; 8912 Style.BraceWrapping.SplitEmptyNamespace = false; 8913 8914 verifyFormat("namespace Foo\n" 8915 "{};", 8916 Style); 8917 verifyFormat("/* something */ namespace Foo\n" 8918 "{};", 8919 Style); 8920 verifyFormat("inline namespace Foo\n" 8921 "{};", 8922 Style); 8923 verifyFormat("/* something */ inline namespace Foo\n" 8924 "{};", 8925 Style); 8926 verifyFormat("export namespace Foo\n" 8927 "{};", 8928 Style); 8929 verifyFormat("namespace Foo\n" 8930 "{\n" 8931 "void Bar();\n" 8932 "};", 8933 Style); 8934 } 8935 8936 TEST_F(FormatTest, NeverMergeShortRecords) { 8937 FormatStyle Style = getLLVMStyle(); 8938 8939 verifyFormat("class Foo {\n" 8940 " Foo();\n" 8941 "};", 8942 Style); 8943 verifyFormat("typedef class Foo {\n" 8944 " Foo();\n" 8945 "} Foo_t;", 8946 Style); 8947 verifyFormat("struct Foo {\n" 8948 " Foo();\n" 8949 "};", 8950 Style); 8951 verifyFormat("typedef struct Foo {\n" 8952 " Foo();\n" 8953 "} Foo_t;", 8954 Style); 8955 verifyFormat("union Foo {\n" 8956 " A,\n" 8957 "};", 8958 Style); 8959 verifyFormat("typedef union Foo {\n" 8960 " A,\n" 8961 "} Foo_t;", 8962 Style); 8963 verifyFormat("namespace Foo {\n" 8964 "void Bar();\n" 8965 "};", 8966 Style); 8967 8968 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8969 Style.BraceWrapping.AfterClass = true; 8970 Style.BraceWrapping.AfterStruct = true; 8971 Style.BraceWrapping.AfterUnion = true; 8972 Style.BraceWrapping.AfterNamespace = true; 8973 verifyFormat("class Foo\n" 8974 "{\n" 8975 " Foo();\n" 8976 "};", 8977 Style); 8978 verifyFormat("typedef class Foo\n" 8979 "{\n" 8980 " Foo();\n" 8981 "} Foo_t;", 8982 Style); 8983 verifyFormat("struct Foo\n" 8984 "{\n" 8985 " Foo();\n" 8986 "};", 8987 Style); 8988 verifyFormat("typedef struct Foo\n" 8989 "{\n" 8990 " Foo();\n" 8991 "} Foo_t;", 8992 Style); 8993 verifyFormat("union Foo\n" 8994 "{\n" 8995 " A,\n" 8996 "};", 8997 Style); 8998 verifyFormat("typedef union Foo\n" 8999 "{\n" 9000 " A,\n" 9001 "} Foo_t;", 9002 Style); 9003 verifyFormat("namespace Foo\n" 9004 "{\n" 9005 "void Bar();\n" 9006 "};", 9007 Style); 9008 } 9009 9010 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 9011 // Elaborate type variable declarations. 9012 verifyFormat("struct foo a = {bar};\nint n;"); 9013 verifyFormat("class foo a = {bar};\nint n;"); 9014 verifyFormat("union foo a = {bar};\nint n;"); 9015 9016 // Elaborate types inside function definitions. 9017 verifyFormat("struct foo f() {}\nint n;"); 9018 verifyFormat("class foo f() {}\nint n;"); 9019 verifyFormat("union foo f() {}\nint n;"); 9020 9021 // Templates. 9022 verifyFormat("template <class X> void f() {}\nint n;"); 9023 verifyFormat("template <struct X> void f() {}\nint n;"); 9024 verifyFormat("template <union X> void f() {}\nint n;"); 9025 9026 // Actual definitions... 9027 verifyFormat("struct {\n} n;"); 9028 verifyFormat( 9029 "template <template <class T, class Y>, class Z> class X {\n} n;"); 9030 verifyFormat("union Z {\n int n;\n} x;"); 9031 verifyFormat("class MACRO Z {\n} n;"); 9032 verifyFormat("class MACRO(X) Z {\n} n;"); 9033 verifyFormat("class __attribute__(X) Z {\n} n;"); 9034 verifyFormat("class __declspec(X) Z {\n} n;"); 9035 verifyFormat("class A##B##C {\n} n;"); 9036 verifyFormat("class alignas(16) Z {\n} n;"); 9037 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 9038 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 9039 9040 // Redefinition from nested context: 9041 verifyFormat("class A::B::C {\n} n;"); 9042 9043 // Template definitions. 9044 verifyFormat( 9045 "template <typename F>\n" 9046 "Matcher(const Matcher<F> &Other,\n" 9047 " typename enable_if_c<is_base_of<F, T>::value &&\n" 9048 " !is_same<F, T>::value>::type * = 0)\n" 9049 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 9050 9051 // FIXME: This is still incorrectly handled at the formatter side. 9052 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 9053 verifyFormat("int i = SomeFunction(a<b, a> b);"); 9054 9055 // FIXME: 9056 // This now gets parsed incorrectly as class definition. 9057 // verifyFormat("class A<int> f() {\n}\nint n;"); 9058 9059 // Elaborate types where incorrectly parsing the structural element would 9060 // break the indent. 9061 verifyFormat("if (true)\n" 9062 " class X x;\n" 9063 "else\n" 9064 " f();\n"); 9065 9066 // This is simply incomplete. Formatting is not important, but must not crash. 9067 verifyFormat("class A:"); 9068 } 9069 9070 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 9071 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 9072 format("#error Leave all white!!!!! space* alone!\n")); 9073 EXPECT_EQ( 9074 "#warning Leave all white!!!!! space* alone!\n", 9075 format("#warning Leave all white!!!!! space* alone!\n")); 9076 EXPECT_EQ("#error 1", format(" # error 1")); 9077 EXPECT_EQ("#warning 1", format(" # warning 1")); 9078 } 9079 9080 TEST_F(FormatTest, FormatHashIfExpressions) { 9081 verifyFormat("#if AAAA && BBBB"); 9082 verifyFormat("#if (AAAA && BBBB)"); 9083 verifyFormat("#elif (AAAA && BBBB)"); 9084 // FIXME: Come up with a better indentation for #elif. 9085 verifyFormat( 9086 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 9087 " defined(BBBBBBBB)\n" 9088 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 9089 " defined(BBBBBBBB)\n" 9090 "#endif", 9091 getLLVMStyleWithColumns(65)); 9092 } 9093 9094 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 9095 FormatStyle AllowsMergedIf = getGoogleStyle(); 9096 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 9097 FormatStyle::SIS_WithoutElse; 9098 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 9099 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 9100 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 9101 EXPECT_EQ("if (true) return 42;", 9102 format("if (true)\nreturn 42;", AllowsMergedIf)); 9103 FormatStyle ShortMergedIf = AllowsMergedIf; 9104 ShortMergedIf.ColumnLimit = 25; 9105 verifyFormat("#define A \\\n" 9106 " if (true) return 42;", 9107 ShortMergedIf); 9108 verifyFormat("#define A \\\n" 9109 " f(); \\\n" 9110 " if (true)\n" 9111 "#define B", 9112 ShortMergedIf); 9113 verifyFormat("#define A \\\n" 9114 " f(); \\\n" 9115 " if (true)\n" 9116 "g();", 9117 ShortMergedIf); 9118 verifyFormat("{\n" 9119 "#ifdef A\n" 9120 " // Comment\n" 9121 " if (true) continue;\n" 9122 "#endif\n" 9123 " // Comment\n" 9124 " if (true) continue;\n" 9125 "}", 9126 ShortMergedIf); 9127 ShortMergedIf.ColumnLimit = 33; 9128 verifyFormat("#define A \\\n" 9129 " if constexpr (true) return 42;", 9130 ShortMergedIf); 9131 verifyFormat("#define A \\\n" 9132 " if CONSTEXPR (true) return 42;", 9133 ShortMergedIf); 9134 ShortMergedIf.ColumnLimit = 29; 9135 verifyFormat("#define A \\\n" 9136 " if (aaaaaaaaaa) return 1; \\\n" 9137 " return 2;", 9138 ShortMergedIf); 9139 ShortMergedIf.ColumnLimit = 28; 9140 verifyFormat("#define A \\\n" 9141 " if (aaaaaaaaaa) \\\n" 9142 " return 1; \\\n" 9143 " return 2;", 9144 ShortMergedIf); 9145 verifyFormat("#define A \\\n" 9146 " if constexpr (aaaaaaa) \\\n" 9147 " return 1; \\\n" 9148 " return 2;", 9149 ShortMergedIf); 9150 verifyFormat("#define A \\\n" 9151 " if CONSTEXPR (aaaaaaa) \\\n" 9152 " return 1; \\\n" 9153 " return 2;", 9154 ShortMergedIf); 9155 } 9156 9157 TEST_F(FormatTest, FormatStarDependingOnContext) { 9158 verifyFormat("void f(int *a);"); 9159 verifyFormat("void f() { f(fint * b); }"); 9160 verifyFormat("class A {\n void f(int *a);\n};"); 9161 verifyFormat("class A {\n int *a;\n};"); 9162 verifyFormat("namespace a {\n" 9163 "namespace b {\n" 9164 "class A {\n" 9165 " void f() {}\n" 9166 " int *a;\n" 9167 "};\n" 9168 "} // namespace b\n" 9169 "} // namespace a"); 9170 } 9171 9172 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 9173 verifyFormat("while"); 9174 verifyFormat("operator"); 9175 } 9176 9177 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 9178 // This code would be painfully slow to format if we didn't skip it. 9179 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 9180 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9181 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9182 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9183 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9184 "A(1, 1)\n" 9185 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 9186 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9187 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9188 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9189 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9190 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9191 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9192 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9193 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9194 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 9195 // Deeply nested part is untouched, rest is formatted. 9196 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 9197 format(std::string("int i;\n") + Code + "int j;\n", 9198 getLLVMStyle(), SC_ExpectIncomplete)); 9199 } 9200 9201 //===----------------------------------------------------------------------===// 9202 // Objective-C tests. 9203 //===----------------------------------------------------------------------===// 9204 9205 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 9206 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 9207 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 9208 format("-(NSUInteger)indexOfObject:(id)anObject;")); 9209 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 9210 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 9211 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 9212 format("-(NSInteger)Method3:(id)anObject;")); 9213 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 9214 format("-(NSInteger)Method4:(id)anObject;")); 9215 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 9216 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 9217 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 9218 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 9219 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9220 "forAllCells:(BOOL)flag;", 9221 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9222 "forAllCells:(BOOL)flag;")); 9223 9224 // Very long objectiveC method declaration. 9225 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 9226 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 9227 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 9228 " inRange:(NSRange)range\n" 9229 " outRange:(NSRange)out_range\n" 9230 " outRange1:(NSRange)out_range1\n" 9231 " outRange2:(NSRange)out_range2\n" 9232 " outRange3:(NSRange)out_range3\n" 9233 " outRange4:(NSRange)out_range4\n" 9234 " outRange5:(NSRange)out_range5\n" 9235 " outRange6:(NSRange)out_range6\n" 9236 " outRange7:(NSRange)out_range7\n" 9237 " outRange8:(NSRange)out_range8\n" 9238 " outRange9:(NSRange)out_range9;"); 9239 9240 // When the function name has to be wrapped. 9241 FormatStyle Style = getLLVMStyle(); 9242 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 9243 // and always indents instead. 9244 Style.IndentWrappedFunctionNames = false; 9245 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9246 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 9247 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 9248 "}", 9249 Style); 9250 Style.IndentWrappedFunctionNames = true; 9251 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9252 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 9253 " anotherName:(NSString)dddddddddddddd {\n" 9254 "}", 9255 Style); 9256 9257 verifyFormat("- (int)sum:(vector<int>)numbers;"); 9258 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 9259 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 9260 // protocol lists (but not for template classes): 9261 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 9262 9263 verifyFormat("- (int (*)())foo:(int (*)())f;"); 9264 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 9265 9266 // If there's no return type (very rare in practice!), LLVM and Google style 9267 // agree. 9268 verifyFormat("- foo;"); 9269 verifyFormat("- foo:(int)f;"); 9270 verifyGoogleFormat("- foo:(int)foo;"); 9271 } 9272 9273 TEST_F(FormatTest, BreaksStringLiterals) { 9274 EXPECT_EQ("\"some text \"\n" 9275 "\"other\";", 9276 format("\"some text other\";", getLLVMStyleWithColumns(12))); 9277 EXPECT_EQ("\"some text \"\n" 9278 "\"other\";", 9279 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 9280 EXPECT_EQ( 9281 "#define A \\\n" 9282 " \"some \" \\\n" 9283 " \"text \" \\\n" 9284 " \"other\";", 9285 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 9286 EXPECT_EQ( 9287 "#define A \\\n" 9288 " \"so \" \\\n" 9289 " \"text \" \\\n" 9290 " \"other\";", 9291 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 9292 9293 EXPECT_EQ("\"some text\"", 9294 format("\"some text\"", getLLVMStyleWithColumns(1))); 9295 EXPECT_EQ("\"some text\"", 9296 format("\"some text\"", getLLVMStyleWithColumns(11))); 9297 EXPECT_EQ("\"some \"\n" 9298 "\"text\"", 9299 format("\"some text\"", getLLVMStyleWithColumns(10))); 9300 EXPECT_EQ("\"some \"\n" 9301 "\"text\"", 9302 format("\"some text\"", getLLVMStyleWithColumns(7))); 9303 EXPECT_EQ("\"some\"\n" 9304 "\" tex\"\n" 9305 "\"t\"", 9306 format("\"some text\"", getLLVMStyleWithColumns(6))); 9307 EXPECT_EQ("\"some\"\n" 9308 "\" tex\"\n" 9309 "\" and\"", 9310 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 9311 EXPECT_EQ("\"some\"\n" 9312 "\"/tex\"\n" 9313 "\"/and\"", 9314 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 9315 9316 EXPECT_EQ("variable =\n" 9317 " \"long string \"\n" 9318 " \"literal\";", 9319 format("variable = \"long string literal\";", 9320 getLLVMStyleWithColumns(20))); 9321 9322 EXPECT_EQ("variable = f(\n" 9323 " \"long string \"\n" 9324 " \"literal\",\n" 9325 " short,\n" 9326 " loooooooooooooooooooong);", 9327 format("variable = f(\"long string literal\", short, " 9328 "loooooooooooooooooooong);", 9329 getLLVMStyleWithColumns(20))); 9330 9331 EXPECT_EQ( 9332 "f(g(\"long string \"\n" 9333 " \"literal\"),\n" 9334 " b);", 9335 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 9336 EXPECT_EQ("f(g(\"long string \"\n" 9337 " \"literal\",\n" 9338 " a),\n" 9339 " b);", 9340 format("f(g(\"long string literal\", a), b);", 9341 getLLVMStyleWithColumns(20))); 9342 EXPECT_EQ( 9343 "f(\"one two\".split(\n" 9344 " variable));", 9345 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 9346 EXPECT_EQ("f(\"one two three four five six \"\n" 9347 " \"seven\".split(\n" 9348 " really_looooong_variable));", 9349 format("f(\"one two three four five six seven\"." 9350 "split(really_looooong_variable));", 9351 getLLVMStyleWithColumns(33))); 9352 9353 EXPECT_EQ("f(\"some \"\n" 9354 " \"text\",\n" 9355 " other);", 9356 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 9357 9358 // Only break as a last resort. 9359 verifyFormat( 9360 "aaaaaaaaaaaaaaaaaaaa(\n" 9361 " aaaaaaaaaaaaaaaaaaaa,\n" 9362 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 9363 9364 EXPECT_EQ("\"splitmea\"\n" 9365 "\"trandomp\"\n" 9366 "\"oint\"", 9367 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 9368 9369 EXPECT_EQ("\"split/\"\n" 9370 "\"pathat/\"\n" 9371 "\"slashes\"", 9372 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9373 9374 EXPECT_EQ("\"split/\"\n" 9375 "\"pathat/\"\n" 9376 "\"slashes\"", 9377 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9378 EXPECT_EQ("\"split at \"\n" 9379 "\"spaces/at/\"\n" 9380 "\"slashes.at.any$\"\n" 9381 "\"non-alphanumeric%\"\n" 9382 "\"1111111111characte\"\n" 9383 "\"rs\"", 9384 format("\"split at " 9385 "spaces/at/" 9386 "slashes.at." 9387 "any$non-" 9388 "alphanumeric%" 9389 "1111111111characte" 9390 "rs\"", 9391 getLLVMStyleWithColumns(20))); 9392 9393 // Verify that splitting the strings understands 9394 // Style::AlwaysBreakBeforeMultilineStrings. 9395 EXPECT_EQ("aaaaaaaaaaaa(\n" 9396 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 9397 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 9398 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 9399 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9400 "aaaaaaaaaaaaaaaaaaaaaa\");", 9401 getGoogleStyle())); 9402 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9403 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 9404 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 9405 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9406 "aaaaaaaaaaaaaaaaaaaaaa\";", 9407 getGoogleStyle())); 9408 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9409 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9410 format("llvm::outs() << " 9411 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 9412 "aaaaaaaaaaaaaaaaaaa\";")); 9413 EXPECT_EQ("ffff(\n" 9414 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9415 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9416 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 9417 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9418 getGoogleStyle())); 9419 9420 FormatStyle Style = getLLVMStyleWithColumns(12); 9421 Style.BreakStringLiterals = false; 9422 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 9423 9424 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 9425 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9426 EXPECT_EQ("#define A \\\n" 9427 " \"some \" \\\n" 9428 " \"text \" \\\n" 9429 " \"other\";", 9430 format("#define A \"some text other\";", AlignLeft)); 9431 } 9432 9433 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 9434 EXPECT_EQ("C a = \"some more \"\n" 9435 " \"text\";", 9436 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 9437 } 9438 9439 TEST_F(FormatTest, FullyRemoveEmptyLines) { 9440 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 9441 NoEmptyLines.MaxEmptyLinesToKeep = 0; 9442 EXPECT_EQ("int i = a(b());", 9443 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 9444 } 9445 9446 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 9447 EXPECT_EQ( 9448 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9449 "(\n" 9450 " \"x\t\");", 9451 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9452 "aaaaaaa(" 9453 "\"x\t\");")); 9454 } 9455 9456 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 9457 EXPECT_EQ( 9458 "u8\"utf8 string \"\n" 9459 "u8\"literal\";", 9460 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 9461 EXPECT_EQ( 9462 "u\"utf16 string \"\n" 9463 "u\"literal\";", 9464 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 9465 EXPECT_EQ( 9466 "U\"utf32 string \"\n" 9467 "U\"literal\";", 9468 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 9469 EXPECT_EQ("L\"wide string \"\n" 9470 "L\"literal\";", 9471 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 9472 EXPECT_EQ("@\"NSString \"\n" 9473 "@\"literal\";", 9474 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 9475 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 9476 9477 // This input makes clang-format try to split the incomplete unicode escape 9478 // sequence, which used to lead to a crasher. 9479 verifyNoCrash( 9480 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 9481 getLLVMStyleWithColumns(60)); 9482 } 9483 9484 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 9485 FormatStyle Style = getGoogleStyleWithColumns(15); 9486 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 9487 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 9488 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 9489 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 9490 EXPECT_EQ("u8R\"x(raw literal)x\";", 9491 format("u8R\"x(raw literal)x\";", Style)); 9492 } 9493 9494 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 9495 FormatStyle Style = getLLVMStyleWithColumns(20); 9496 EXPECT_EQ( 9497 "_T(\"aaaaaaaaaaaaaa\")\n" 9498 "_T(\"aaaaaaaaaaaaaa\")\n" 9499 "_T(\"aaaaaaaaaaaa\")", 9500 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 9501 EXPECT_EQ("f(x,\n" 9502 " _T(\"aaaaaaaaaaaa\")\n" 9503 " _T(\"aaa\"),\n" 9504 " z);", 9505 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 9506 9507 // FIXME: Handle embedded spaces in one iteration. 9508 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 9509 // "_T(\"aaaaaaaaaaaaa\")\n" 9510 // "_T(\"aaaaaaaaaaaaa\")\n" 9511 // "_T(\"a\")", 9512 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9513 // getLLVMStyleWithColumns(20))); 9514 EXPECT_EQ( 9515 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9516 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 9517 EXPECT_EQ("f(\n" 9518 "#if !TEST\n" 9519 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9520 "#endif\n" 9521 ");", 9522 format("f(\n" 9523 "#if !TEST\n" 9524 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9525 "#endif\n" 9526 ");")); 9527 EXPECT_EQ("f(\n" 9528 "\n" 9529 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 9530 format("f(\n" 9531 "\n" 9532 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 9533 } 9534 9535 TEST_F(FormatTest, BreaksStringLiteralOperands) { 9536 // In a function call with two operands, the second can be broken with no line 9537 // break before it. 9538 EXPECT_EQ( 9539 "func(a, \"long long \"\n" 9540 " \"long long\");", 9541 format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24))); 9542 // In a function call with three operands, the second must be broken with a 9543 // line break before it. 9544 EXPECT_EQ("func(a,\n" 9545 " \"long long long \"\n" 9546 " \"long\",\n" 9547 " c);", 9548 format("func(a, \"long long long long\", c);", 9549 getLLVMStyleWithColumns(24))); 9550 // In a function call with three operands, the third must be broken with a 9551 // line break before it. 9552 EXPECT_EQ("func(a, b,\n" 9553 " \"long long long \"\n" 9554 " \"long\");", 9555 format("func(a, b, \"long long long long\");", 9556 getLLVMStyleWithColumns(24))); 9557 // In a function call with three operands, both the second and the third must 9558 // be broken with a line break before them. 9559 EXPECT_EQ("func(a,\n" 9560 " \"long long long \"\n" 9561 " \"long\",\n" 9562 " \"long long long \"\n" 9563 " \"long\");", 9564 format("func(a, \"long long long long\", \"long long long long\");", 9565 getLLVMStyleWithColumns(24))); 9566 // In a chain of << with two operands, the second can be broken with no line 9567 // break before it. 9568 EXPECT_EQ("a << \"line line \"\n" 9569 " \"line\";", 9570 format("a << \"line line line\";", getLLVMStyleWithColumns(20))); 9571 // In a chain of << with three operands, the second can be broken with no line 9572 // break before it. 9573 EXPECT_EQ( 9574 "abcde << \"line \"\n" 9575 " \"line line\"\n" 9576 " << c;", 9577 format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20))); 9578 // In a chain of << with three operands, the third must be broken with a line 9579 // break before it. 9580 EXPECT_EQ( 9581 "a << b\n" 9582 " << \"line line \"\n" 9583 " \"line\";", 9584 format("a << b << \"line line line\";", getLLVMStyleWithColumns(20))); 9585 // In a chain of << with three operands, the second can be broken with no line 9586 // break before it and the third must be broken with a line break before it. 9587 EXPECT_EQ("abcd << \"line line \"\n" 9588 " \"line\"\n" 9589 " << \"line line \"\n" 9590 " \"line\";", 9591 format("abcd << \"line line line\" << \"line line line\";", 9592 getLLVMStyleWithColumns(20))); 9593 // In a chain of binary operators with two operands, the second can be broken 9594 // with no line break before it. 9595 EXPECT_EQ( 9596 "abcd + \"line line \"\n" 9597 " \"line line\";", 9598 format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20))); 9599 // In a chain of binary operators with three operands, the second must be 9600 // broken with a line break before it. 9601 EXPECT_EQ("abcd +\n" 9602 " \"line line \"\n" 9603 " \"line line\" +\n" 9604 " e;", 9605 format("abcd + \"line line line line\" + e;", 9606 getLLVMStyleWithColumns(20))); 9607 // In a function call with two operands, with AlignAfterOpenBracket enabled, 9608 // the first must be broken with a line break before it. 9609 FormatStyle Style = getLLVMStyleWithColumns(25); 9610 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 9611 EXPECT_EQ("someFunction(\n" 9612 " \"long long long \"\n" 9613 " \"long\",\n" 9614 " a);", 9615 format("someFunction(\"long long long long\", a);", Style)); 9616 } 9617 9618 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 9619 EXPECT_EQ( 9620 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9621 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9622 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9623 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9624 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9625 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 9626 } 9627 9628 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 9629 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 9630 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 9631 EXPECT_EQ("fffffffffff(g(R\"x(\n" 9632 "multiline raw string literal xxxxxxxxxxxxxx\n" 9633 ")x\",\n" 9634 " a),\n" 9635 " b);", 9636 format("fffffffffff(g(R\"x(\n" 9637 "multiline raw string literal xxxxxxxxxxxxxx\n" 9638 ")x\", a), b);", 9639 getGoogleStyleWithColumns(20))); 9640 EXPECT_EQ("fffffffffff(\n" 9641 " g(R\"x(qqq\n" 9642 "multiline raw string literal xxxxxxxxxxxxxx\n" 9643 ")x\",\n" 9644 " a),\n" 9645 " b);", 9646 format("fffffffffff(g(R\"x(qqq\n" 9647 "multiline raw string literal xxxxxxxxxxxxxx\n" 9648 ")x\", a), b);", 9649 getGoogleStyleWithColumns(20))); 9650 9651 EXPECT_EQ("fffffffffff(R\"x(\n" 9652 "multiline raw string literal xxxxxxxxxxxxxx\n" 9653 ")x\");", 9654 format("fffffffffff(R\"x(\n" 9655 "multiline raw string literal xxxxxxxxxxxxxx\n" 9656 ")x\");", 9657 getGoogleStyleWithColumns(20))); 9658 EXPECT_EQ("fffffffffff(R\"x(\n" 9659 "multiline raw string literal xxxxxxxxxxxxxx\n" 9660 ")x\" + bbbbbb);", 9661 format("fffffffffff(R\"x(\n" 9662 "multiline raw string literal xxxxxxxxxxxxxx\n" 9663 ")x\" + bbbbbb);", 9664 getGoogleStyleWithColumns(20))); 9665 EXPECT_EQ("fffffffffff(\n" 9666 " R\"x(\n" 9667 "multiline raw string literal xxxxxxxxxxxxxx\n" 9668 ")x\" +\n" 9669 " bbbbbb);", 9670 format("fffffffffff(\n" 9671 " R\"x(\n" 9672 "multiline raw string literal xxxxxxxxxxxxxx\n" 9673 ")x\" + bbbbbb);", 9674 getGoogleStyleWithColumns(20))); 9675 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 9676 format("fffffffffff(\n" 9677 " R\"(single line raw string)\" + bbbbbb);")); 9678 } 9679 9680 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 9681 verifyFormat("string a = \"unterminated;"); 9682 EXPECT_EQ("function(\"unterminated,\n" 9683 " OtherParameter);", 9684 format("function( \"unterminated,\n" 9685 " OtherParameter);")); 9686 } 9687 9688 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9689 FormatStyle Style = getLLVMStyle(); 9690 Style.Standard = FormatStyle::LS_Cpp03; 9691 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9692 format("#define x(_a) printf(\"foo\"_a);", Style)); 9693 } 9694 9695 TEST_F(FormatTest, CppLexVersion) { 9696 FormatStyle Style = getLLVMStyle(); 9697 // Formatting of x * y differs if x is a type. 9698 verifyFormat("void foo() { MACRO(a * b); }", Style); 9699 verifyFormat("void foo() { MACRO(int *b); }", Style); 9700 9701 // LLVM style uses latest lexer. 9702 verifyFormat("void foo() { MACRO(char8_t *b); }", Style); 9703 Style.Standard = FormatStyle::LS_Cpp17; 9704 // But in c++17, char8_t isn't a keyword. 9705 verifyFormat("void foo() { MACRO(char8_t * b); }", Style); 9706 } 9707 9708 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9709 9710 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9711 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9712 " \"ddeeefff\");", 9713 format("someFunction(\"aaabbbcccdddeeefff\");", 9714 getLLVMStyleWithColumns(25))); 9715 EXPECT_EQ("someFunction1234567890(\n" 9716 " \"aaabbbcccdddeeefff\");", 9717 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9718 getLLVMStyleWithColumns(26))); 9719 EXPECT_EQ("someFunction1234567890(\n" 9720 " \"aaabbbcccdddeeeff\"\n" 9721 " \"f\");", 9722 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9723 getLLVMStyleWithColumns(25))); 9724 EXPECT_EQ("someFunction1234567890(\n" 9725 " \"aaabbbcccdddeeeff\"\n" 9726 " \"f\");", 9727 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9728 getLLVMStyleWithColumns(24))); 9729 EXPECT_EQ("someFunction(\n" 9730 " \"aaabbbcc ddde \"\n" 9731 " \"efff\");", 9732 format("someFunction(\"aaabbbcc ddde efff\");", 9733 getLLVMStyleWithColumns(25))); 9734 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9735 " \"ddeeefff\");", 9736 format("someFunction(\"aaabbbccc ddeeefff\");", 9737 getLLVMStyleWithColumns(25))); 9738 EXPECT_EQ("someFunction1234567890(\n" 9739 " \"aaabb \"\n" 9740 " \"cccdddeeefff\");", 9741 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9742 getLLVMStyleWithColumns(25))); 9743 EXPECT_EQ("#define A \\\n" 9744 " string s = \\\n" 9745 " \"123456789\" \\\n" 9746 " \"0\"; \\\n" 9747 " int i;", 9748 format("#define A string s = \"1234567890\"; int i;", 9749 getLLVMStyleWithColumns(20))); 9750 EXPECT_EQ("someFunction(\n" 9751 " \"aaabbbcc \"\n" 9752 " \"dddeeefff\");", 9753 format("someFunction(\"aaabbbcc dddeeefff\");", 9754 getLLVMStyleWithColumns(25))); 9755 } 9756 9757 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9758 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9759 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9760 EXPECT_EQ("\"test\"\n" 9761 "\"\\n\"", 9762 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9763 EXPECT_EQ("\"tes\\\\\"\n" 9764 "\"n\"", 9765 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9766 EXPECT_EQ("\"\\\\\\\\\"\n" 9767 "\"\\n\"", 9768 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9769 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9770 EXPECT_EQ("\"\\uff01\"\n" 9771 "\"test\"", 9772 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9773 EXPECT_EQ("\"\\Uff01ff02\"", 9774 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9775 EXPECT_EQ("\"\\x000000000001\"\n" 9776 "\"next\"", 9777 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9778 EXPECT_EQ("\"\\x000000000001next\"", 9779 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9780 EXPECT_EQ("\"\\x000000000001\"", 9781 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9782 EXPECT_EQ("\"test\"\n" 9783 "\"\\000000\"\n" 9784 "\"000001\"", 9785 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9786 EXPECT_EQ("\"test\\000\"\n" 9787 "\"00000000\"\n" 9788 "\"1\"", 9789 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9790 } 9791 9792 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9793 verifyFormat("void f() {\n" 9794 " return g() {}\n" 9795 " void h() {}"); 9796 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9797 "g();\n" 9798 "}"); 9799 } 9800 9801 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9802 verifyFormat( 9803 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9804 } 9805 9806 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9807 verifyFormat("class X {\n" 9808 " void f() {\n" 9809 " }\n" 9810 "};", 9811 getLLVMStyleWithColumns(12)); 9812 } 9813 9814 TEST_F(FormatTest, ConfigurableIndentWidth) { 9815 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9816 EightIndent.IndentWidth = 8; 9817 EightIndent.ContinuationIndentWidth = 8; 9818 verifyFormat("void f() {\n" 9819 " someFunction();\n" 9820 " if (true) {\n" 9821 " f();\n" 9822 " }\n" 9823 "}", 9824 EightIndent); 9825 verifyFormat("class X {\n" 9826 " void f() {\n" 9827 " }\n" 9828 "};", 9829 EightIndent); 9830 verifyFormat("int x[] = {\n" 9831 " call(),\n" 9832 " call()};", 9833 EightIndent); 9834 } 9835 9836 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9837 verifyFormat("double\n" 9838 "f();", 9839 getLLVMStyleWithColumns(8)); 9840 } 9841 9842 TEST_F(FormatTest, ConfigurableUseOfTab) { 9843 FormatStyle Tab = getLLVMStyleWithColumns(42); 9844 Tab.IndentWidth = 8; 9845 Tab.UseTab = FormatStyle::UT_Always; 9846 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9847 9848 EXPECT_EQ("if (aaaaaaaa && // q\n" 9849 " bb)\t\t// w\n" 9850 "\t;", 9851 format("if (aaaaaaaa &&// q\n" 9852 "bb)// w\n" 9853 ";", 9854 Tab)); 9855 EXPECT_EQ("if (aaa && bbb) // w\n" 9856 "\t;", 9857 format("if(aaa&&bbb)// w\n" 9858 ";", 9859 Tab)); 9860 9861 verifyFormat("class X {\n" 9862 "\tvoid f() {\n" 9863 "\t\tsomeFunction(parameter1,\n" 9864 "\t\t\t parameter2);\n" 9865 "\t}\n" 9866 "};", 9867 Tab); 9868 verifyFormat("#define A \\\n" 9869 "\tvoid f() { \\\n" 9870 "\t\tsomeFunction( \\\n" 9871 "\t\t parameter1, \\\n" 9872 "\t\t parameter2); \\\n" 9873 "\t}", 9874 Tab); 9875 verifyFormat("int a;\t // x\n" 9876 "int bbbbbbbb; // x\n", 9877 Tab); 9878 9879 Tab.TabWidth = 4; 9880 Tab.IndentWidth = 8; 9881 verifyFormat("class TabWidth4Indent8 {\n" 9882 "\t\tvoid f() {\n" 9883 "\t\t\t\tsomeFunction(parameter1,\n" 9884 "\t\t\t\t\t\t\t parameter2);\n" 9885 "\t\t}\n" 9886 "};", 9887 Tab); 9888 9889 Tab.TabWidth = 4; 9890 Tab.IndentWidth = 4; 9891 verifyFormat("class TabWidth4Indent4 {\n" 9892 "\tvoid f() {\n" 9893 "\t\tsomeFunction(parameter1,\n" 9894 "\t\t\t\t\t parameter2);\n" 9895 "\t}\n" 9896 "};", 9897 Tab); 9898 9899 Tab.TabWidth = 8; 9900 Tab.IndentWidth = 4; 9901 verifyFormat("class TabWidth8Indent4 {\n" 9902 " void f() {\n" 9903 "\tsomeFunction(parameter1,\n" 9904 "\t\t parameter2);\n" 9905 " }\n" 9906 "};", 9907 Tab); 9908 9909 Tab.TabWidth = 8; 9910 Tab.IndentWidth = 8; 9911 EXPECT_EQ("/*\n" 9912 "\t a\t\tcomment\n" 9913 "\t in multiple lines\n" 9914 " */", 9915 format(" /*\t \t \n" 9916 " \t \t a\t\tcomment\t \t\n" 9917 " \t \t in multiple lines\t\n" 9918 " \t */", 9919 Tab)); 9920 9921 Tab.UseTab = FormatStyle::UT_ForIndentation; 9922 verifyFormat("{\n" 9923 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9924 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9925 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9926 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9927 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9928 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9929 "};", 9930 Tab); 9931 verifyFormat("enum AA {\n" 9932 "\ta1, // Force multiple lines\n" 9933 "\ta2,\n" 9934 "\ta3\n" 9935 "};", 9936 Tab); 9937 EXPECT_EQ("if (aaaaaaaa && // q\n" 9938 " bb) // w\n" 9939 "\t;", 9940 format("if (aaaaaaaa &&// q\n" 9941 "bb)// w\n" 9942 ";", 9943 Tab)); 9944 verifyFormat("class X {\n" 9945 "\tvoid f() {\n" 9946 "\t\tsomeFunction(parameter1,\n" 9947 "\t\t parameter2);\n" 9948 "\t}\n" 9949 "};", 9950 Tab); 9951 verifyFormat("{\n" 9952 "\tQ(\n" 9953 "\t {\n" 9954 "\t\t int a;\n" 9955 "\t\t someFunction(aaaaaaaa,\n" 9956 "\t\t bbbbbbb);\n" 9957 "\t },\n" 9958 "\t p);\n" 9959 "}", 9960 Tab); 9961 EXPECT_EQ("{\n" 9962 "\t/* aaaa\n" 9963 "\t bbbb */\n" 9964 "}", 9965 format("{\n" 9966 "/* aaaa\n" 9967 " bbbb */\n" 9968 "}", 9969 Tab)); 9970 EXPECT_EQ("{\n" 9971 "\t/*\n" 9972 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9973 "\t bbbbbbbbbbbbb\n" 9974 "\t*/\n" 9975 "}", 9976 format("{\n" 9977 "/*\n" 9978 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9979 "*/\n" 9980 "}", 9981 Tab)); 9982 EXPECT_EQ("{\n" 9983 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9984 "\t// bbbbbbbbbbbbb\n" 9985 "}", 9986 format("{\n" 9987 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9988 "}", 9989 Tab)); 9990 EXPECT_EQ("{\n" 9991 "\t/*\n" 9992 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9993 "\t bbbbbbbbbbbbb\n" 9994 "\t*/\n" 9995 "}", 9996 format("{\n" 9997 "\t/*\n" 9998 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9999 "\t*/\n" 10000 "}", 10001 Tab)); 10002 EXPECT_EQ("{\n" 10003 "\t/*\n" 10004 "\n" 10005 "\t*/\n" 10006 "}", 10007 format("{\n" 10008 "\t/*\n" 10009 "\n" 10010 "\t*/\n" 10011 "}", 10012 Tab)); 10013 EXPECT_EQ("{\n" 10014 "\t/*\n" 10015 " asdf\n" 10016 "\t*/\n" 10017 "}", 10018 format("{\n" 10019 "\t/*\n" 10020 " asdf\n" 10021 "\t*/\n" 10022 "}", 10023 Tab)); 10024 10025 Tab.UseTab = FormatStyle::UT_Never; 10026 EXPECT_EQ("/*\n" 10027 " a\t\tcomment\n" 10028 " in multiple lines\n" 10029 " */", 10030 format(" /*\t \t \n" 10031 " \t \t a\t\tcomment\t \t\n" 10032 " \t \t in multiple lines\t\n" 10033 " \t */", 10034 Tab)); 10035 EXPECT_EQ("/* some\n" 10036 " comment */", 10037 format(" \t \t /* some\n" 10038 " \t \t comment */", 10039 Tab)); 10040 EXPECT_EQ("int a; /* some\n" 10041 " comment */", 10042 format(" \t \t int a; /* some\n" 10043 " \t \t comment */", 10044 Tab)); 10045 10046 EXPECT_EQ("int a; /* some\n" 10047 "comment */", 10048 format(" \t \t int\ta; /* some\n" 10049 " \t \t comment */", 10050 Tab)); 10051 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10052 " comment */", 10053 format(" \t \t f(\"\t\t\"); /* some\n" 10054 " \t \t comment */", 10055 Tab)); 10056 EXPECT_EQ("{\n" 10057 " /*\n" 10058 " * Comment\n" 10059 " */\n" 10060 " int i;\n" 10061 "}", 10062 format("{\n" 10063 "\t/*\n" 10064 "\t * Comment\n" 10065 "\t */\n" 10066 "\t int i;\n" 10067 "}")); 10068 10069 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10070 Tab.TabWidth = 8; 10071 Tab.IndentWidth = 8; 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 EXPECT_EQ("if (aaa && bbb) // w\n" 10080 "\t;", 10081 format("if(aaa&&bbb)// w\n" 10082 ";", 10083 Tab)); 10084 verifyFormat("class X {\n" 10085 "\tvoid f() {\n" 10086 "\t\tsomeFunction(parameter1,\n" 10087 "\t\t\t parameter2);\n" 10088 "\t}\n" 10089 "};", 10090 Tab); 10091 verifyFormat("#define A \\\n" 10092 "\tvoid f() { \\\n" 10093 "\t\tsomeFunction( \\\n" 10094 "\t\t parameter1, \\\n" 10095 "\t\t parameter2); \\\n" 10096 "\t}", 10097 Tab); 10098 Tab.TabWidth = 4; 10099 Tab.IndentWidth = 8; 10100 verifyFormat("class TabWidth4Indent8 {\n" 10101 "\t\tvoid f() {\n" 10102 "\t\t\t\tsomeFunction(parameter1,\n" 10103 "\t\t\t\t\t\t\t parameter2);\n" 10104 "\t\t}\n" 10105 "};", 10106 Tab); 10107 Tab.TabWidth = 4; 10108 Tab.IndentWidth = 4; 10109 verifyFormat("class TabWidth4Indent4 {\n" 10110 "\tvoid f() {\n" 10111 "\t\tsomeFunction(parameter1,\n" 10112 "\t\t\t\t\t parameter2);\n" 10113 "\t}\n" 10114 "};", 10115 Tab); 10116 Tab.TabWidth = 8; 10117 Tab.IndentWidth = 4; 10118 verifyFormat("class TabWidth8Indent4 {\n" 10119 " void f() {\n" 10120 "\tsomeFunction(parameter1,\n" 10121 "\t\t parameter2);\n" 10122 " }\n" 10123 "};", 10124 Tab); 10125 Tab.TabWidth = 8; 10126 Tab.IndentWidth = 8; 10127 EXPECT_EQ("/*\n" 10128 "\t a\t\tcomment\n" 10129 "\t in multiple lines\n" 10130 " */", 10131 format(" /*\t \t \n" 10132 " \t \t a\t\tcomment\t \t\n" 10133 " \t \t in multiple lines\t\n" 10134 " \t */", 10135 Tab)); 10136 verifyFormat("{\n" 10137 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10138 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10139 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10140 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10141 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10142 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10143 "};", 10144 Tab); 10145 verifyFormat("enum AA {\n" 10146 "\ta1, // Force multiple lines\n" 10147 "\ta2,\n" 10148 "\ta3\n" 10149 "};", 10150 Tab); 10151 EXPECT_EQ("if (aaaaaaaa && // q\n" 10152 " bb) // w\n" 10153 "\t;", 10154 format("if (aaaaaaaa &&// q\n" 10155 "bb)// w\n" 10156 ";", 10157 Tab)); 10158 verifyFormat("class X {\n" 10159 "\tvoid f() {\n" 10160 "\t\tsomeFunction(parameter1,\n" 10161 "\t\t\t parameter2);\n" 10162 "\t}\n" 10163 "};", 10164 Tab); 10165 verifyFormat("{\n" 10166 "\tQ(\n" 10167 "\t {\n" 10168 "\t\t int a;\n" 10169 "\t\t someFunction(aaaaaaaa,\n" 10170 "\t\t\t\t bbbbbbb);\n" 10171 "\t },\n" 10172 "\t p);\n" 10173 "}", 10174 Tab); 10175 EXPECT_EQ("{\n" 10176 "\t/* aaaa\n" 10177 "\t bbbb */\n" 10178 "}", 10179 format("{\n" 10180 "/* aaaa\n" 10181 " bbbb */\n" 10182 "}", 10183 Tab)); 10184 EXPECT_EQ("{\n" 10185 "\t/*\n" 10186 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10187 "\t bbbbbbbbbbbbb\n" 10188 "\t*/\n" 10189 "}", 10190 format("{\n" 10191 "/*\n" 10192 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10193 "*/\n" 10194 "}", 10195 Tab)); 10196 EXPECT_EQ("{\n" 10197 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10198 "\t// bbbbbbbbbbbbb\n" 10199 "}", 10200 format("{\n" 10201 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10202 "}", 10203 Tab)); 10204 EXPECT_EQ("{\n" 10205 "\t/*\n" 10206 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10207 "\t bbbbbbbbbbbbb\n" 10208 "\t*/\n" 10209 "}", 10210 format("{\n" 10211 "\t/*\n" 10212 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10213 "\t*/\n" 10214 "}", 10215 Tab)); 10216 EXPECT_EQ("{\n" 10217 "\t/*\n" 10218 "\n" 10219 "\t*/\n" 10220 "}", 10221 format("{\n" 10222 "\t/*\n" 10223 "\n" 10224 "\t*/\n" 10225 "}", 10226 Tab)); 10227 EXPECT_EQ("{\n" 10228 "\t/*\n" 10229 " asdf\n" 10230 "\t*/\n" 10231 "}", 10232 format("{\n" 10233 "\t/*\n" 10234 " asdf\n" 10235 "\t*/\n" 10236 "}", 10237 Tab)); 10238 EXPECT_EQ("/*\n" 10239 "\t a\t\tcomment\n" 10240 "\t in multiple lines\n" 10241 " */", 10242 format(" /*\t \t \n" 10243 " \t \t a\t\tcomment\t \t\n" 10244 " \t \t in multiple lines\t\n" 10245 " \t */", 10246 Tab)); 10247 EXPECT_EQ("/* some\n" 10248 " comment */", 10249 format(" \t \t /* some\n" 10250 " \t \t comment */", 10251 Tab)); 10252 EXPECT_EQ("int a; /* some\n" 10253 " comment */", 10254 format(" \t \t int a; /* some\n" 10255 " \t \t comment */", 10256 Tab)); 10257 EXPECT_EQ("int a; /* some\n" 10258 "comment */", 10259 format(" \t \t int\ta; /* some\n" 10260 " \t \t comment */", 10261 Tab)); 10262 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10263 " comment */", 10264 format(" \t \t f(\"\t\t\"); /* some\n" 10265 " \t \t comment */", 10266 Tab)); 10267 EXPECT_EQ("{\n" 10268 " /*\n" 10269 " * Comment\n" 10270 " */\n" 10271 " int i;\n" 10272 "}", 10273 format("{\n" 10274 "\t/*\n" 10275 "\t * Comment\n" 10276 "\t */\n" 10277 "\t int i;\n" 10278 "}")); 10279 Tab.AlignConsecutiveAssignments = true; 10280 Tab.AlignConsecutiveDeclarations = true; 10281 Tab.TabWidth = 4; 10282 Tab.IndentWidth = 4; 10283 verifyFormat("class Assign {\n" 10284 "\tvoid f() {\n" 10285 "\t\tint x = 123;\n" 10286 "\t\tint random = 4;\n" 10287 "\t\tstd::string alphabet =\n" 10288 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 10289 "\t}\n" 10290 "};", 10291 Tab); 10292 } 10293 10294 TEST_F(FormatTest, ZeroTabWidth) { 10295 FormatStyle Tab = getLLVMStyleWithColumns(42); 10296 Tab.IndentWidth = 8; 10297 Tab.UseTab = FormatStyle::UT_Never; 10298 Tab.TabWidth = 0; 10299 EXPECT_EQ("void a(){\n" 10300 " // line starts with '\t'\n" 10301 "};", 10302 format("void a(){\n" 10303 "\t// line starts with '\t'\n" 10304 "};", 10305 Tab)); 10306 10307 EXPECT_EQ("void a(){\n" 10308 " // line starts with '\t'\n" 10309 "};", 10310 format("void a(){\n" 10311 "\t\t// line starts with '\t'\n" 10312 "};", 10313 Tab)); 10314 10315 Tab.UseTab = FormatStyle::UT_ForIndentation; 10316 EXPECT_EQ("void a(){\n" 10317 " // line starts with '\t'\n" 10318 "};", 10319 format("void a(){\n" 10320 "\t// line starts with '\t'\n" 10321 "};", 10322 Tab)); 10323 10324 EXPECT_EQ("void a(){\n" 10325 " // line starts with '\t'\n" 10326 "};", 10327 format("void a(){\n" 10328 "\t\t// line starts with '\t'\n" 10329 "};", 10330 Tab)); 10331 10332 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10333 EXPECT_EQ("void a(){\n" 10334 " // line starts with '\t'\n" 10335 "};", 10336 format("void a(){\n" 10337 "\t// line starts with '\t'\n" 10338 "};", 10339 Tab)); 10340 10341 EXPECT_EQ("void a(){\n" 10342 " // line starts with '\t'\n" 10343 "};", 10344 format("void a(){\n" 10345 "\t\t// line starts with '\t'\n" 10346 "};", 10347 Tab)); 10348 10349 Tab.UseTab = FormatStyle::UT_Always; 10350 EXPECT_EQ("void a(){\n" 10351 "// line starts with '\t'\n" 10352 "};", 10353 format("void a(){\n" 10354 "\t// line starts with '\t'\n" 10355 "};", 10356 Tab)); 10357 10358 EXPECT_EQ("void a(){\n" 10359 "// line starts with '\t'\n" 10360 "};", 10361 format("void a(){\n" 10362 "\t\t// line starts with '\t'\n" 10363 "};", 10364 Tab)); 10365 } 10366 10367 TEST_F(FormatTest, CalculatesOriginalColumn) { 10368 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10369 "q\"; /* some\n" 10370 " comment */", 10371 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10372 "q\"; /* some\n" 10373 " comment */", 10374 getLLVMStyle())); 10375 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10376 "/* some\n" 10377 " comment */", 10378 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10379 " /* some\n" 10380 " comment */", 10381 getLLVMStyle())); 10382 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10383 "qqq\n" 10384 "/* some\n" 10385 " comment */", 10386 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10387 "qqq\n" 10388 " /* some\n" 10389 " comment */", 10390 getLLVMStyle())); 10391 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10392 "wwww; /* some\n" 10393 " comment */", 10394 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10395 "wwww; /* some\n" 10396 " comment */", 10397 getLLVMStyle())); 10398 } 10399 10400 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 10401 FormatStyle NoSpace = getLLVMStyle(); 10402 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 10403 10404 verifyFormat("while(true)\n" 10405 " continue;", 10406 NoSpace); 10407 verifyFormat("for(;;)\n" 10408 " continue;", 10409 NoSpace); 10410 verifyFormat("if(true)\n" 10411 " f();\n" 10412 "else if(true)\n" 10413 " f();", 10414 NoSpace); 10415 verifyFormat("do {\n" 10416 " do_something();\n" 10417 "} while(something());", 10418 NoSpace); 10419 verifyFormat("switch(x) {\n" 10420 "default:\n" 10421 " break;\n" 10422 "}", 10423 NoSpace); 10424 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 10425 verifyFormat("size_t x = sizeof(x);", NoSpace); 10426 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 10427 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 10428 verifyFormat("alignas(128) char a[128];", NoSpace); 10429 verifyFormat("size_t x = alignof(MyType);", NoSpace); 10430 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 10431 verifyFormat("int f() throw(Deprecated);", NoSpace); 10432 verifyFormat("typedef void (*cb)(int);", NoSpace); 10433 verifyFormat("T A::operator()();", NoSpace); 10434 verifyFormat("X A::operator++(T);", NoSpace); 10435 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 10436 10437 FormatStyle Space = getLLVMStyle(); 10438 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 10439 10440 verifyFormat("int f ();", Space); 10441 verifyFormat("void f (int a, T b) {\n" 10442 " while (true)\n" 10443 " continue;\n" 10444 "}", 10445 Space); 10446 verifyFormat("if (true)\n" 10447 " f ();\n" 10448 "else if (true)\n" 10449 " f ();", 10450 Space); 10451 verifyFormat("do {\n" 10452 " do_something ();\n" 10453 "} while (something ());", 10454 Space); 10455 verifyFormat("switch (x) {\n" 10456 "default:\n" 10457 " break;\n" 10458 "}", 10459 Space); 10460 verifyFormat("A::A () : a (1) {}", Space); 10461 verifyFormat("void f () __attribute__ ((asdf));", Space); 10462 verifyFormat("*(&a + 1);\n" 10463 "&((&a)[1]);\n" 10464 "a[(b + c) * d];\n" 10465 "(((a + 1) * 2) + 3) * 4;", 10466 Space); 10467 verifyFormat("#define A(x) x", Space); 10468 verifyFormat("#define A (x) x", Space); 10469 verifyFormat("#if defined(x)\n" 10470 "#endif", 10471 Space); 10472 verifyFormat("auto i = std::make_unique<int> (5);", Space); 10473 verifyFormat("size_t x = sizeof (x);", Space); 10474 verifyFormat("auto f (int x) -> decltype (x);", Space); 10475 verifyFormat("int f (T x) noexcept (x.create ());", Space); 10476 verifyFormat("alignas (128) char a[128];", Space); 10477 verifyFormat("size_t x = alignof (MyType);", Space); 10478 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 10479 verifyFormat("int f () throw (Deprecated);", Space); 10480 verifyFormat("typedef void (*cb) (int);", Space); 10481 verifyFormat("T A::operator() ();", Space); 10482 verifyFormat("X A::operator++ (T);", Space); 10483 verifyFormat("auto lambda = [] () { return 0; };", Space); 10484 verifyFormat("int x = int (y);", Space); 10485 10486 FormatStyle SomeSpace = getLLVMStyle(); 10487 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 10488 10489 verifyFormat("[]() -> float {}", SomeSpace); 10490 verifyFormat("[] (auto foo) {}", SomeSpace); 10491 verifyFormat("[foo]() -> int {}", SomeSpace); 10492 verifyFormat("int f();", SomeSpace); 10493 verifyFormat("void f (int a, T b) {\n" 10494 " while (true)\n" 10495 " continue;\n" 10496 "}", 10497 SomeSpace); 10498 verifyFormat("if (true)\n" 10499 " f();\n" 10500 "else if (true)\n" 10501 " f();", 10502 SomeSpace); 10503 verifyFormat("do {\n" 10504 " do_something();\n" 10505 "} while (something());", 10506 SomeSpace); 10507 verifyFormat("switch (x) {\n" 10508 "default:\n" 10509 " break;\n" 10510 "}", 10511 SomeSpace); 10512 verifyFormat("A::A() : a (1) {}", SomeSpace); 10513 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 10514 verifyFormat("*(&a + 1);\n" 10515 "&((&a)[1]);\n" 10516 "a[(b + c) * d];\n" 10517 "(((a + 1) * 2) + 3) * 4;", 10518 SomeSpace); 10519 verifyFormat("#define A(x) x", SomeSpace); 10520 verifyFormat("#define A (x) x", SomeSpace); 10521 verifyFormat("#if defined(x)\n" 10522 "#endif", 10523 SomeSpace); 10524 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 10525 verifyFormat("size_t x = sizeof (x);", SomeSpace); 10526 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 10527 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 10528 verifyFormat("alignas (128) char a[128];", SomeSpace); 10529 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 10530 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 10531 SomeSpace); 10532 verifyFormat("int f() throw (Deprecated);", SomeSpace); 10533 verifyFormat("typedef void (*cb) (int);", SomeSpace); 10534 verifyFormat("T A::operator()();", SomeSpace); 10535 verifyFormat("X A::operator++ (T);", SomeSpace); 10536 verifyFormat("int x = int (y);", SomeSpace); 10537 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 10538 } 10539 10540 TEST_F(FormatTest, SpaceAfterLogicalNot) { 10541 FormatStyle Spaces = getLLVMStyle(); 10542 Spaces.SpaceAfterLogicalNot = true; 10543 10544 verifyFormat("bool x = ! y", Spaces); 10545 verifyFormat("if (! isFailure())", Spaces); 10546 verifyFormat("if (! (a && b))", Spaces); 10547 verifyFormat("\"Error!\"", Spaces); 10548 verifyFormat("! ! x", Spaces); 10549 } 10550 10551 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 10552 FormatStyle Spaces = getLLVMStyle(); 10553 10554 Spaces.SpacesInParentheses = true; 10555 verifyFormat("do_something( ::globalVar );", Spaces); 10556 verifyFormat("call( x, y, z );", Spaces); 10557 verifyFormat("call();", Spaces); 10558 verifyFormat("std::function<void( int, int )> callback;", Spaces); 10559 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 10560 Spaces); 10561 verifyFormat("while ( (bool)1 )\n" 10562 " continue;", 10563 Spaces); 10564 verifyFormat("for ( ;; )\n" 10565 " continue;", 10566 Spaces); 10567 verifyFormat("if ( true )\n" 10568 " f();\n" 10569 "else if ( true )\n" 10570 " f();", 10571 Spaces); 10572 verifyFormat("do {\n" 10573 " do_something( (int)i );\n" 10574 "} while ( something() );", 10575 Spaces); 10576 verifyFormat("switch ( x ) {\n" 10577 "default:\n" 10578 " break;\n" 10579 "}", 10580 Spaces); 10581 10582 Spaces.SpacesInParentheses = false; 10583 Spaces.SpacesInCStyleCastParentheses = true; 10584 verifyFormat("Type *A = ( Type * )P;", Spaces); 10585 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 10586 verifyFormat("x = ( int32 )y;", Spaces); 10587 verifyFormat("int a = ( int )(2.0f);", Spaces); 10588 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 10589 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 10590 verifyFormat("#define x (( int )-1)", Spaces); 10591 10592 // Run the first set of tests again with: 10593 Spaces.SpacesInParentheses = false; 10594 Spaces.SpaceInEmptyParentheses = true; 10595 Spaces.SpacesInCStyleCastParentheses = true; 10596 verifyFormat("call(x, y, z);", Spaces); 10597 verifyFormat("call( );", Spaces); 10598 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10599 verifyFormat("while (( bool )1)\n" 10600 " continue;", 10601 Spaces); 10602 verifyFormat("for (;;)\n" 10603 " continue;", 10604 Spaces); 10605 verifyFormat("if (true)\n" 10606 " f( );\n" 10607 "else if (true)\n" 10608 " f( );", 10609 Spaces); 10610 verifyFormat("do {\n" 10611 " do_something(( int )i);\n" 10612 "} while (something( ));", 10613 Spaces); 10614 verifyFormat("switch (x) {\n" 10615 "default:\n" 10616 " break;\n" 10617 "}", 10618 Spaces); 10619 10620 // Run the first set of tests again with: 10621 Spaces.SpaceAfterCStyleCast = true; 10622 verifyFormat("call(x, y, z);", Spaces); 10623 verifyFormat("call( );", Spaces); 10624 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10625 verifyFormat("while (( bool ) 1)\n" 10626 " continue;", 10627 Spaces); 10628 verifyFormat("for (;;)\n" 10629 " continue;", 10630 Spaces); 10631 verifyFormat("if (true)\n" 10632 " f( );\n" 10633 "else if (true)\n" 10634 " f( );", 10635 Spaces); 10636 verifyFormat("do {\n" 10637 " do_something(( int ) i);\n" 10638 "} while (something( ));", 10639 Spaces); 10640 verifyFormat("switch (x) {\n" 10641 "default:\n" 10642 " break;\n" 10643 "}", 10644 Spaces); 10645 10646 // Run subset of tests again with: 10647 Spaces.SpacesInCStyleCastParentheses = false; 10648 Spaces.SpaceAfterCStyleCast = true; 10649 verifyFormat("while ((bool) 1)\n" 10650 " continue;", 10651 Spaces); 10652 verifyFormat("do {\n" 10653 " do_something((int) i);\n" 10654 "} while (something( ));", 10655 Spaces); 10656 } 10657 10658 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 10659 verifyFormat("int a[5];"); 10660 verifyFormat("a[3] += 42;"); 10661 10662 FormatStyle Spaces = getLLVMStyle(); 10663 Spaces.SpacesInSquareBrackets = true; 10664 // Not lambdas. 10665 verifyFormat("int a[ 5 ];", Spaces); 10666 verifyFormat("a[ 3 ] += 42;", Spaces); 10667 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 10668 verifyFormat("double &operator[](int i) { return 0; }\n" 10669 "int i;", 10670 Spaces); 10671 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 10672 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 10673 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 10674 // Lambdas. 10675 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 10676 verifyFormat("return [ i, args... ] {};", Spaces); 10677 verifyFormat("int foo = [ &bar ]() {};", Spaces); 10678 verifyFormat("int foo = [ = ]() {};", Spaces); 10679 verifyFormat("int foo = [ & ]() {};", Spaces); 10680 verifyFormat("int foo = [ =, &bar ]() {};", Spaces); 10681 verifyFormat("int foo = [ &bar, = ]() {};", Spaces); 10682 } 10683 10684 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) { 10685 FormatStyle NoSpaceStyle = getLLVMStyle(); 10686 verifyFormat("int a[5];", NoSpaceStyle); 10687 verifyFormat("a[3] += 42;", NoSpaceStyle); 10688 10689 verifyFormat("int a[1];", NoSpaceStyle); 10690 verifyFormat("int 1 [a];", NoSpaceStyle); 10691 verifyFormat("int a[1][2];", NoSpaceStyle); 10692 verifyFormat("a[7] = 5;", NoSpaceStyle); 10693 verifyFormat("int a = (f())[23];", NoSpaceStyle); 10694 verifyFormat("f([] {})", NoSpaceStyle); 10695 10696 FormatStyle Space = getLLVMStyle(); 10697 Space.SpaceBeforeSquareBrackets = true; 10698 verifyFormat("int c = []() -> int { return 2; }();\n", Space); 10699 verifyFormat("return [i, args...] {};", Space); 10700 10701 verifyFormat("int a [5];", Space); 10702 verifyFormat("a [3] += 42;", Space); 10703 verifyFormat("constexpr char hello []{\"hello\"};", Space); 10704 verifyFormat("double &operator[](int i) { return 0; }\n" 10705 "int i;", 10706 Space); 10707 verifyFormat("std::unique_ptr<int []> foo() {}", Space); 10708 verifyFormat("int i = a [a][a]->f();", Space); 10709 verifyFormat("int i = (*b) [a]->f();", Space); 10710 10711 verifyFormat("int a [1];", Space); 10712 verifyFormat("int 1 [a];", Space); 10713 verifyFormat("int a [1][2];", Space); 10714 verifyFormat("a [7] = 5;", Space); 10715 verifyFormat("int a = (f()) [23];", Space); 10716 verifyFormat("f([] {})", Space); 10717 } 10718 10719 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 10720 verifyFormat("int a = 5;"); 10721 verifyFormat("a += 42;"); 10722 verifyFormat("a or_eq 8;"); 10723 10724 FormatStyle Spaces = getLLVMStyle(); 10725 Spaces.SpaceBeforeAssignmentOperators = false; 10726 verifyFormat("int a= 5;", Spaces); 10727 verifyFormat("a+= 42;", Spaces); 10728 verifyFormat("a or_eq 8;", Spaces); 10729 } 10730 10731 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 10732 verifyFormat("class Foo : public Bar {};"); 10733 verifyFormat("Foo::Foo() : foo(1) {}"); 10734 verifyFormat("for (auto a : b) {\n}"); 10735 verifyFormat("int x = a ? b : c;"); 10736 verifyFormat("{\n" 10737 "label0:\n" 10738 " int x = 0;\n" 10739 "}"); 10740 verifyFormat("switch (x) {\n" 10741 "case 1:\n" 10742 "default:\n" 10743 "}"); 10744 10745 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 10746 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 10747 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 10748 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 10749 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 10750 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 10751 verifyFormat("{\n" 10752 "label1:\n" 10753 " int x = 0;\n" 10754 "}", 10755 CtorInitializerStyle); 10756 verifyFormat("switch (x) {\n" 10757 "case 1:\n" 10758 "default:\n" 10759 "}", 10760 CtorInitializerStyle); 10761 CtorInitializerStyle.BreakConstructorInitializers = 10762 FormatStyle::BCIS_AfterColon; 10763 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 10764 " aaaaaaaaaaaaaaaa(1),\n" 10765 " bbbbbbbbbbbbbbbb(2) {}", 10766 CtorInitializerStyle); 10767 CtorInitializerStyle.BreakConstructorInitializers = 10768 FormatStyle::BCIS_BeforeComma; 10769 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10770 " : aaaaaaaaaaaaaaaa(1)\n" 10771 " , bbbbbbbbbbbbbbbb(2) {}", 10772 CtorInitializerStyle); 10773 CtorInitializerStyle.BreakConstructorInitializers = 10774 FormatStyle::BCIS_BeforeColon; 10775 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10776 " : aaaaaaaaaaaaaaaa(1),\n" 10777 " bbbbbbbbbbbbbbbb(2) {}", 10778 CtorInitializerStyle); 10779 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 10780 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10781 ": aaaaaaaaaaaaaaaa(1),\n" 10782 " bbbbbbbbbbbbbbbb(2) {}", 10783 CtorInitializerStyle); 10784 10785 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 10786 InheritanceStyle.SpaceBeforeInheritanceColon = false; 10787 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 10788 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 10789 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 10790 verifyFormat("int x = a ? b : c;", InheritanceStyle); 10791 verifyFormat("{\n" 10792 "label2:\n" 10793 " int x = 0;\n" 10794 "}", 10795 InheritanceStyle); 10796 verifyFormat("switch (x) {\n" 10797 "case 1:\n" 10798 "default:\n" 10799 "}", 10800 InheritanceStyle); 10801 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 10802 verifyFormat("class Foooooooooooooooooooooo:\n" 10803 " public aaaaaaaaaaaaaaaaaa,\n" 10804 " public bbbbbbbbbbbbbbbbbb {\n" 10805 "}", 10806 InheritanceStyle); 10807 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 10808 verifyFormat("class Foooooooooooooooooooooo\n" 10809 " : public aaaaaaaaaaaaaaaaaa\n" 10810 " , public bbbbbbbbbbbbbbbbbb {\n" 10811 "}", 10812 InheritanceStyle); 10813 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 10814 verifyFormat("class Foooooooooooooooooooooo\n" 10815 " : public aaaaaaaaaaaaaaaaaa,\n" 10816 " public bbbbbbbbbbbbbbbbbb {\n" 10817 "}", 10818 InheritanceStyle); 10819 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 10820 verifyFormat("class Foooooooooooooooooooooo\n" 10821 ": public aaaaaaaaaaaaaaaaaa,\n" 10822 " public bbbbbbbbbbbbbbbbbb {}", 10823 InheritanceStyle); 10824 10825 FormatStyle ForLoopStyle = getLLVMStyle(); 10826 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 10827 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 10828 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 10829 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 10830 verifyFormat("int x = a ? b : c;", ForLoopStyle); 10831 verifyFormat("{\n" 10832 "label2:\n" 10833 " int x = 0;\n" 10834 "}", 10835 ForLoopStyle); 10836 verifyFormat("switch (x) {\n" 10837 "case 1:\n" 10838 "default:\n" 10839 "}", 10840 ForLoopStyle); 10841 10842 FormatStyle NoSpaceStyle = getLLVMStyle(); 10843 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 10844 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 10845 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 10846 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 10847 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 10848 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 10849 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 10850 verifyFormat("{\n" 10851 "label3:\n" 10852 " int x = 0;\n" 10853 "}", 10854 NoSpaceStyle); 10855 verifyFormat("switch (x) {\n" 10856 "case 1:\n" 10857 "default:\n" 10858 "}", 10859 NoSpaceStyle); 10860 } 10861 10862 TEST_F(FormatTest, AlignConsecutiveMacros) { 10863 FormatStyle Style = getLLVMStyle(); 10864 Style.AlignConsecutiveAssignments = true; 10865 Style.AlignConsecutiveDeclarations = true; 10866 Style.AlignConsecutiveMacros = false; 10867 10868 verifyFormat("#define a 3\n" 10869 "#define bbbb 4\n" 10870 "#define ccc (5)", 10871 Style); 10872 10873 verifyFormat("#define f(x) (x * x)\n" 10874 "#define fff(x, y, z) (x * y + z)\n" 10875 "#define ffff(x, y) (x - y)", 10876 Style); 10877 10878 verifyFormat("#define foo(x, y) (x + y)\n" 10879 "#define bar (5, 6)(2 + 2)", 10880 Style); 10881 10882 verifyFormat("#define a 3\n" 10883 "#define bbbb 4\n" 10884 "#define ccc (5)\n" 10885 "#define f(x) (x * x)\n" 10886 "#define fff(x, y, z) (x * y + z)\n" 10887 "#define ffff(x, y) (x - y)", 10888 Style); 10889 10890 Style.AlignConsecutiveMacros = true; 10891 verifyFormat("#define a 3\n" 10892 "#define bbbb 4\n" 10893 "#define ccc (5)", 10894 Style); 10895 10896 verifyFormat("#define f(x) (x * x)\n" 10897 "#define fff(x, y, z) (x * y + z)\n" 10898 "#define ffff(x, y) (x - y)", 10899 Style); 10900 10901 verifyFormat("#define foo(x, y) (x + y)\n" 10902 "#define bar (5, 6)(2 + 2)", 10903 Style); 10904 10905 verifyFormat("#define a 3\n" 10906 "#define bbbb 4\n" 10907 "#define ccc (5)\n" 10908 "#define f(x) (x * x)\n" 10909 "#define fff(x, y, z) (x * y + z)\n" 10910 "#define ffff(x, y) (x - y)", 10911 Style); 10912 10913 verifyFormat("#define a 5\n" 10914 "#define foo(x, y) (x + y)\n" 10915 "#define CCC (6)\n" 10916 "auto lambda = []() {\n" 10917 " auto ii = 0;\n" 10918 " float j = 0;\n" 10919 " return 0;\n" 10920 "};\n" 10921 "int i = 0;\n" 10922 "float i2 = 0;\n" 10923 "auto v = type{\n" 10924 " i = 1, //\n" 10925 " (i = 2), //\n" 10926 " i = 3 //\n" 10927 "};", 10928 Style); 10929 10930 Style.AlignConsecutiveMacros = false; 10931 Style.ColumnLimit = 20; 10932 10933 verifyFormat("#define a \\\n" 10934 " \"aabbbbbbbbbbbb\"\n" 10935 "#define D \\\n" 10936 " \"aabbbbbbbbbbbb\" \\\n" 10937 " \"ccddeeeeeeeee\"\n" 10938 "#define B \\\n" 10939 " \"QQQQQQQQQQQQQ\" \\\n" 10940 " \"FFFFFFFFFFFFF\" \\\n" 10941 " \"LLLLLLLL\"\n", 10942 Style); 10943 10944 Style.AlignConsecutiveMacros = true; 10945 verifyFormat("#define a \\\n" 10946 " \"aabbbbbbbbbbbb\"\n" 10947 "#define D \\\n" 10948 " \"aabbbbbbbbbbbb\" \\\n" 10949 " \"ccddeeeeeeeee\"\n" 10950 "#define B \\\n" 10951 " \"QQQQQQQQQQQQQ\" \\\n" 10952 " \"FFFFFFFFFFFFF\" \\\n" 10953 " \"LLLLLLLL\"\n", 10954 Style); 10955 } 10956 10957 TEST_F(FormatTest, AlignConsecutiveAssignments) { 10958 FormatStyle Alignment = getLLVMStyle(); 10959 Alignment.AlignConsecutiveMacros = true; 10960 Alignment.AlignConsecutiveAssignments = false; 10961 verifyFormat("int a = 5;\n" 10962 "int oneTwoThree = 123;", 10963 Alignment); 10964 verifyFormat("int a = 5;\n" 10965 "int oneTwoThree = 123;", 10966 Alignment); 10967 10968 Alignment.AlignConsecutiveAssignments = true; 10969 verifyFormat("int a = 5;\n" 10970 "int oneTwoThree = 123;", 10971 Alignment); 10972 verifyFormat("int a = method();\n" 10973 "int oneTwoThree = 133;", 10974 Alignment); 10975 verifyFormat("a &= 5;\n" 10976 "bcd *= 5;\n" 10977 "ghtyf += 5;\n" 10978 "dvfvdb -= 5;\n" 10979 "a /= 5;\n" 10980 "vdsvsv %= 5;\n" 10981 "sfdbddfbdfbb ^= 5;\n" 10982 "dvsdsv |= 5;\n" 10983 "int dsvvdvsdvvv = 123;", 10984 Alignment); 10985 verifyFormat("int i = 1, j = 10;\n" 10986 "something = 2000;", 10987 Alignment); 10988 verifyFormat("something = 2000;\n" 10989 "int i = 1, j = 10;\n", 10990 Alignment); 10991 verifyFormat("something = 2000;\n" 10992 "another = 911;\n" 10993 "int i = 1, j = 10;\n" 10994 "oneMore = 1;\n" 10995 "i = 2;", 10996 Alignment); 10997 verifyFormat("int a = 5;\n" 10998 "int one = 1;\n" 10999 "method();\n" 11000 "int oneTwoThree = 123;\n" 11001 "int oneTwo = 12;", 11002 Alignment); 11003 verifyFormat("int oneTwoThree = 123;\n" 11004 "int oneTwo = 12;\n" 11005 "method();\n", 11006 Alignment); 11007 verifyFormat("int oneTwoThree = 123; // comment\n" 11008 "int oneTwo = 12; // comment", 11009 Alignment); 11010 EXPECT_EQ("int a = 5;\n" 11011 "\n" 11012 "int oneTwoThree = 123;", 11013 format("int a = 5;\n" 11014 "\n" 11015 "int oneTwoThree= 123;", 11016 Alignment)); 11017 EXPECT_EQ("int a = 5;\n" 11018 "int one = 1;\n" 11019 "\n" 11020 "int oneTwoThree = 123;", 11021 format("int a = 5;\n" 11022 "int one = 1;\n" 11023 "\n" 11024 "int oneTwoThree = 123;", 11025 Alignment)); 11026 EXPECT_EQ("int a = 5;\n" 11027 "int one = 1;\n" 11028 "\n" 11029 "int oneTwoThree = 123;\n" 11030 "int oneTwo = 12;", 11031 format("int a = 5;\n" 11032 "int one = 1;\n" 11033 "\n" 11034 "int oneTwoThree = 123;\n" 11035 "int oneTwo = 12;", 11036 Alignment)); 11037 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11038 verifyFormat("#define A \\\n" 11039 " int aaaa = 12; \\\n" 11040 " int b = 23; \\\n" 11041 " int ccc = 234; \\\n" 11042 " int dddddddddd = 2345;", 11043 Alignment); 11044 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11045 verifyFormat("#define A \\\n" 11046 " int aaaa = 12; \\\n" 11047 " int b = 23; \\\n" 11048 " int ccc = 234; \\\n" 11049 " int dddddddddd = 2345;", 11050 Alignment); 11051 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11052 verifyFormat("#define A " 11053 " \\\n" 11054 " int aaaa = 12; " 11055 " \\\n" 11056 " int b = 23; " 11057 " \\\n" 11058 " int ccc = 234; " 11059 " \\\n" 11060 " int dddddddddd = 2345;", 11061 Alignment); 11062 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11063 "k = 4, int l = 5,\n" 11064 " int m = 6) {\n" 11065 " int j = 10;\n" 11066 " otherThing = 1;\n" 11067 "}", 11068 Alignment); 11069 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11070 " int i = 1;\n" 11071 " int j = 2;\n" 11072 " int big = 10000;\n" 11073 "}", 11074 Alignment); 11075 verifyFormat("class C {\n" 11076 "public:\n" 11077 " int i = 1;\n" 11078 " virtual void f() = 0;\n" 11079 "};", 11080 Alignment); 11081 verifyFormat("int i = 1;\n" 11082 "if (SomeType t = getSomething()) {\n" 11083 "}\n" 11084 "int j = 2;\n" 11085 "int big = 10000;", 11086 Alignment); 11087 verifyFormat("int j = 7;\n" 11088 "for (int k = 0; k < N; ++k) {\n" 11089 "}\n" 11090 "int j = 2;\n" 11091 "int big = 10000;\n" 11092 "}", 11093 Alignment); 11094 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11095 verifyFormat("int i = 1;\n" 11096 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11097 " = someLooooooooooooooooongFunction();\n" 11098 "int j = 2;", 11099 Alignment); 11100 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11101 verifyFormat("int i = 1;\n" 11102 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11103 " someLooooooooooooooooongFunction();\n" 11104 "int j = 2;", 11105 Alignment); 11106 11107 verifyFormat("auto lambda = []() {\n" 11108 " auto i = 0;\n" 11109 " return 0;\n" 11110 "};\n" 11111 "int i = 0;\n" 11112 "auto v = type{\n" 11113 " i = 1, //\n" 11114 " (i = 2), //\n" 11115 " i = 3 //\n" 11116 "};", 11117 Alignment); 11118 11119 verifyFormat( 11120 "int i = 1;\n" 11121 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11122 " loooooooooooooooooooooongParameterB);\n" 11123 "int j = 2;", 11124 Alignment); 11125 11126 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 11127 " typename B = very_long_type_name_1,\n" 11128 " typename T_2 = very_long_type_name_2>\n" 11129 "auto foo() {}\n", 11130 Alignment); 11131 verifyFormat("int a, b = 1;\n" 11132 "int c = 2;\n" 11133 "int dd = 3;\n", 11134 Alignment); 11135 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11136 "float b[1][] = {{3.f}};\n", 11137 Alignment); 11138 verifyFormat("for (int i = 0; i < 1; i++)\n" 11139 " int x = 1;\n", 11140 Alignment); 11141 verifyFormat("for (i = 0; i < 1; i++)\n" 11142 " x = 1;\n" 11143 "y = 1;\n", 11144 Alignment); 11145 } 11146 11147 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 11148 FormatStyle Alignment = getLLVMStyle(); 11149 Alignment.AlignConsecutiveMacros = true; 11150 Alignment.AlignConsecutiveDeclarations = false; 11151 verifyFormat("float const a = 5;\n" 11152 "int oneTwoThree = 123;", 11153 Alignment); 11154 verifyFormat("int a = 5;\n" 11155 "float const oneTwoThree = 123;", 11156 Alignment); 11157 11158 Alignment.AlignConsecutiveDeclarations = true; 11159 verifyFormat("float const a = 5;\n" 11160 "int oneTwoThree = 123;", 11161 Alignment); 11162 verifyFormat("int a = method();\n" 11163 "float const oneTwoThree = 133;", 11164 Alignment); 11165 verifyFormat("int i = 1, j = 10;\n" 11166 "something = 2000;", 11167 Alignment); 11168 verifyFormat("something = 2000;\n" 11169 "int i = 1, j = 10;\n", 11170 Alignment); 11171 verifyFormat("float something = 2000;\n" 11172 "double another = 911;\n" 11173 "int i = 1, j = 10;\n" 11174 "const int *oneMore = 1;\n" 11175 "unsigned i = 2;", 11176 Alignment); 11177 verifyFormat("float a = 5;\n" 11178 "int one = 1;\n" 11179 "method();\n" 11180 "const double oneTwoThree = 123;\n" 11181 "const unsigned int oneTwo = 12;", 11182 Alignment); 11183 verifyFormat("int oneTwoThree{0}; // comment\n" 11184 "unsigned oneTwo; // comment", 11185 Alignment); 11186 EXPECT_EQ("float const a = 5;\n" 11187 "\n" 11188 "int oneTwoThree = 123;", 11189 format("float const a = 5;\n" 11190 "\n" 11191 "int oneTwoThree= 123;", 11192 Alignment)); 11193 EXPECT_EQ("float a = 5;\n" 11194 "int one = 1;\n" 11195 "\n" 11196 "unsigned oneTwoThree = 123;", 11197 format("float a = 5;\n" 11198 "int one = 1;\n" 11199 "\n" 11200 "unsigned oneTwoThree = 123;", 11201 Alignment)); 11202 EXPECT_EQ("float a = 5;\n" 11203 "int one = 1;\n" 11204 "\n" 11205 "unsigned oneTwoThree = 123;\n" 11206 "int oneTwo = 12;", 11207 format("float a = 5;\n" 11208 "int one = 1;\n" 11209 "\n" 11210 "unsigned oneTwoThree = 123;\n" 11211 "int oneTwo = 12;", 11212 Alignment)); 11213 // Function prototype alignment 11214 verifyFormat("int a();\n" 11215 "double b();", 11216 Alignment); 11217 verifyFormat("int a(int x);\n" 11218 "double b();", 11219 Alignment); 11220 unsigned OldColumnLimit = Alignment.ColumnLimit; 11221 // We need to set ColumnLimit to zero, in order to stress nested alignments, 11222 // otherwise the function parameters will be re-flowed onto a single line. 11223 Alignment.ColumnLimit = 0; 11224 EXPECT_EQ("int a(int x,\n" 11225 " float y);\n" 11226 "double b(int x,\n" 11227 " double y);", 11228 format("int a(int x,\n" 11229 " float y);\n" 11230 "double b(int x,\n" 11231 " double y);", 11232 Alignment)); 11233 // This ensures that function parameters of function declarations are 11234 // correctly indented when their owning functions are indented. 11235 // The failure case here is for 'double y' to not be indented enough. 11236 EXPECT_EQ("double a(int x);\n" 11237 "int b(int y,\n" 11238 " double z);", 11239 format("double a(int x);\n" 11240 "int b(int y,\n" 11241 " double z);", 11242 Alignment)); 11243 // Set ColumnLimit low so that we induce wrapping immediately after 11244 // the function name and opening paren. 11245 Alignment.ColumnLimit = 13; 11246 verifyFormat("int function(\n" 11247 " int x,\n" 11248 " bool y);", 11249 Alignment); 11250 Alignment.ColumnLimit = OldColumnLimit; 11251 // Ensure function pointers don't screw up recursive alignment 11252 verifyFormat("int a(int x, void (*fp)(int y));\n" 11253 "double b();", 11254 Alignment); 11255 Alignment.AlignConsecutiveAssignments = true; 11256 // Ensure recursive alignment is broken by function braces, so that the 11257 // "a = 1" does not align with subsequent assignments inside the function 11258 // body. 11259 verifyFormat("int func(int a = 1) {\n" 11260 " int b = 2;\n" 11261 " int cc = 3;\n" 11262 "}", 11263 Alignment); 11264 verifyFormat("float something = 2000;\n" 11265 "double another = 911;\n" 11266 "int i = 1, j = 10;\n" 11267 "const int *oneMore = 1;\n" 11268 "unsigned i = 2;", 11269 Alignment); 11270 verifyFormat("int oneTwoThree = {0}; // comment\n" 11271 "unsigned oneTwo = 0; // comment", 11272 Alignment); 11273 // Make sure that scope is correctly tracked, in the absence of braces 11274 verifyFormat("for (int i = 0; i < n; i++)\n" 11275 " j = i;\n" 11276 "double x = 1;\n", 11277 Alignment); 11278 verifyFormat("if (int i = 0)\n" 11279 " j = i;\n" 11280 "double x = 1;\n", 11281 Alignment); 11282 // Ensure operator[] and operator() are comprehended 11283 verifyFormat("struct test {\n" 11284 " long long int foo();\n" 11285 " int operator[](int a);\n" 11286 " double bar();\n" 11287 "};\n", 11288 Alignment); 11289 verifyFormat("struct test {\n" 11290 " long long int foo();\n" 11291 " int operator()(int a);\n" 11292 " double bar();\n" 11293 "};\n", 11294 Alignment); 11295 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 11296 " int const i = 1;\n" 11297 " int * j = 2;\n" 11298 " int big = 10000;\n" 11299 "\n" 11300 " unsigned oneTwoThree = 123;\n" 11301 " int oneTwo = 12;\n" 11302 " method();\n" 11303 " float k = 2;\n" 11304 " int ll = 10000;\n" 11305 "}", 11306 format("void SomeFunction(int parameter= 0) {\n" 11307 " int const i= 1;\n" 11308 " int *j=2;\n" 11309 " int big = 10000;\n" 11310 "\n" 11311 "unsigned oneTwoThree =123;\n" 11312 "int oneTwo = 12;\n" 11313 " method();\n" 11314 "float k= 2;\n" 11315 "int ll=10000;\n" 11316 "}", 11317 Alignment)); 11318 Alignment.AlignConsecutiveAssignments = false; 11319 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11320 verifyFormat("#define A \\\n" 11321 " int aaaa = 12; \\\n" 11322 " float b = 23; \\\n" 11323 " const int ccc = 234; \\\n" 11324 " unsigned dddddddddd = 2345;", 11325 Alignment); 11326 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11327 verifyFormat("#define A \\\n" 11328 " int aaaa = 12; \\\n" 11329 " float b = 23; \\\n" 11330 " const int ccc = 234; \\\n" 11331 " unsigned dddddddddd = 2345;", 11332 Alignment); 11333 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11334 Alignment.ColumnLimit = 30; 11335 verifyFormat("#define A \\\n" 11336 " int aaaa = 12; \\\n" 11337 " float b = 23; \\\n" 11338 " const int ccc = 234; \\\n" 11339 " int dddddddddd = 2345;", 11340 Alignment); 11341 Alignment.ColumnLimit = 80; 11342 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11343 "k = 4, int l = 5,\n" 11344 " int m = 6) {\n" 11345 " const int j = 10;\n" 11346 " otherThing = 1;\n" 11347 "}", 11348 Alignment); 11349 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11350 " int const i = 1;\n" 11351 " int * j = 2;\n" 11352 " int big = 10000;\n" 11353 "}", 11354 Alignment); 11355 verifyFormat("class C {\n" 11356 "public:\n" 11357 " int i = 1;\n" 11358 " virtual void f() = 0;\n" 11359 "};", 11360 Alignment); 11361 verifyFormat("float i = 1;\n" 11362 "if (SomeType t = getSomething()) {\n" 11363 "}\n" 11364 "const unsigned j = 2;\n" 11365 "int big = 10000;", 11366 Alignment); 11367 verifyFormat("float j = 7;\n" 11368 "for (int k = 0; k < N; ++k) {\n" 11369 "}\n" 11370 "unsigned j = 2;\n" 11371 "int big = 10000;\n" 11372 "}", 11373 Alignment); 11374 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11375 verifyFormat("float i = 1;\n" 11376 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11377 " = someLooooooooooooooooongFunction();\n" 11378 "int j = 2;", 11379 Alignment); 11380 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11381 verifyFormat("int i = 1;\n" 11382 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11383 " someLooooooooooooooooongFunction();\n" 11384 "int j = 2;", 11385 Alignment); 11386 11387 Alignment.AlignConsecutiveAssignments = true; 11388 verifyFormat("auto lambda = []() {\n" 11389 " auto ii = 0;\n" 11390 " float j = 0;\n" 11391 " return 0;\n" 11392 "};\n" 11393 "int i = 0;\n" 11394 "float i2 = 0;\n" 11395 "auto v = type{\n" 11396 " i = 1, //\n" 11397 " (i = 2), //\n" 11398 " i = 3 //\n" 11399 "};", 11400 Alignment); 11401 Alignment.AlignConsecutiveAssignments = false; 11402 11403 verifyFormat( 11404 "int i = 1;\n" 11405 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11406 " loooooooooooooooooooooongParameterB);\n" 11407 "int j = 2;", 11408 Alignment); 11409 11410 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 11411 // We expect declarations and assignments to align, as long as it doesn't 11412 // exceed the column limit, starting a new alignment sequence whenever it 11413 // happens. 11414 Alignment.AlignConsecutiveAssignments = true; 11415 Alignment.ColumnLimit = 30; 11416 verifyFormat("float ii = 1;\n" 11417 "unsigned j = 2;\n" 11418 "int someVerylongVariable = 1;\n" 11419 "AnotherLongType ll = 123456;\n" 11420 "VeryVeryLongType k = 2;\n" 11421 "int myvar = 1;", 11422 Alignment); 11423 Alignment.ColumnLimit = 80; 11424 Alignment.AlignConsecutiveAssignments = false; 11425 11426 verifyFormat( 11427 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 11428 " typename LongType, typename B>\n" 11429 "auto foo() {}\n", 11430 Alignment); 11431 verifyFormat("float a, b = 1;\n" 11432 "int c = 2;\n" 11433 "int dd = 3;\n", 11434 Alignment); 11435 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11436 "float b[1][] = {{3.f}};\n", 11437 Alignment); 11438 Alignment.AlignConsecutiveAssignments = true; 11439 verifyFormat("float a, b = 1;\n" 11440 "int c = 2;\n" 11441 "int dd = 3;\n", 11442 Alignment); 11443 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11444 "float b[1][] = {{3.f}};\n", 11445 Alignment); 11446 Alignment.AlignConsecutiveAssignments = false; 11447 11448 Alignment.ColumnLimit = 30; 11449 Alignment.BinPackParameters = false; 11450 verifyFormat("void foo(float a,\n" 11451 " float b,\n" 11452 " int c,\n" 11453 " uint32_t *d) {\n" 11454 " int * e = 0;\n" 11455 " float f = 0;\n" 11456 " double g = 0;\n" 11457 "}\n" 11458 "void bar(ino_t a,\n" 11459 " int b,\n" 11460 " uint32_t *c,\n" 11461 " bool d) {}\n", 11462 Alignment); 11463 Alignment.BinPackParameters = true; 11464 Alignment.ColumnLimit = 80; 11465 11466 // Bug 33507 11467 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 11468 verifyFormat( 11469 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 11470 " static const Version verVs2017;\n" 11471 " return true;\n" 11472 "});\n", 11473 Alignment); 11474 Alignment.PointerAlignment = FormatStyle::PAS_Right; 11475 11476 // See llvm.org/PR35641 11477 Alignment.AlignConsecutiveDeclarations = true; 11478 verifyFormat("int func() { //\n" 11479 " int b;\n" 11480 " unsigned c;\n" 11481 "}", 11482 Alignment); 11483 11484 // See PR37175 11485 FormatStyle Style = getMozillaStyle(); 11486 Style.AlignConsecutiveDeclarations = true; 11487 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 11488 "foo(int a);", 11489 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 11490 } 11491 11492 TEST_F(FormatTest, LinuxBraceBreaking) { 11493 FormatStyle LinuxBraceStyle = getLLVMStyle(); 11494 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 11495 verifyFormat("namespace a\n" 11496 "{\n" 11497 "class A\n" 11498 "{\n" 11499 " void f()\n" 11500 " {\n" 11501 " if (true) {\n" 11502 " a();\n" 11503 " b();\n" 11504 " } else {\n" 11505 " a();\n" 11506 " }\n" 11507 " }\n" 11508 " void g() { return; }\n" 11509 "};\n" 11510 "struct B {\n" 11511 " int x;\n" 11512 "};\n" 11513 "} // namespace a\n", 11514 LinuxBraceStyle); 11515 verifyFormat("enum X {\n" 11516 " Y = 0,\n" 11517 "}\n", 11518 LinuxBraceStyle); 11519 verifyFormat("struct S {\n" 11520 " int Type;\n" 11521 " union {\n" 11522 " int x;\n" 11523 " double y;\n" 11524 " } Value;\n" 11525 " class C\n" 11526 " {\n" 11527 " MyFavoriteType Value;\n" 11528 " } Class;\n" 11529 "}\n", 11530 LinuxBraceStyle); 11531 } 11532 11533 TEST_F(FormatTest, MozillaBraceBreaking) { 11534 FormatStyle MozillaBraceStyle = getLLVMStyle(); 11535 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 11536 MozillaBraceStyle.FixNamespaceComments = false; 11537 verifyFormat("namespace a {\n" 11538 "class A\n" 11539 "{\n" 11540 " void f()\n" 11541 " {\n" 11542 " if (true) {\n" 11543 " a();\n" 11544 " b();\n" 11545 " }\n" 11546 " }\n" 11547 " void g() { return; }\n" 11548 "};\n" 11549 "enum E\n" 11550 "{\n" 11551 " A,\n" 11552 " // foo\n" 11553 " B,\n" 11554 " C\n" 11555 "};\n" 11556 "struct B\n" 11557 "{\n" 11558 " int x;\n" 11559 "};\n" 11560 "}\n", 11561 MozillaBraceStyle); 11562 verifyFormat("struct S\n" 11563 "{\n" 11564 " int Type;\n" 11565 " union\n" 11566 " {\n" 11567 " int x;\n" 11568 " double y;\n" 11569 " } Value;\n" 11570 " class C\n" 11571 " {\n" 11572 " MyFavoriteType Value;\n" 11573 " } Class;\n" 11574 "}\n", 11575 MozillaBraceStyle); 11576 } 11577 11578 TEST_F(FormatTest, StroustrupBraceBreaking) { 11579 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 11580 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11581 verifyFormat("namespace a {\n" 11582 "class A {\n" 11583 " void f()\n" 11584 " {\n" 11585 " if (true) {\n" 11586 " a();\n" 11587 " b();\n" 11588 " }\n" 11589 " }\n" 11590 " void g() { return; }\n" 11591 "};\n" 11592 "struct B {\n" 11593 " int x;\n" 11594 "};\n" 11595 "} // namespace a\n", 11596 StroustrupBraceStyle); 11597 11598 verifyFormat("void foo()\n" 11599 "{\n" 11600 " if (a) {\n" 11601 " a();\n" 11602 " }\n" 11603 " else {\n" 11604 " b();\n" 11605 " }\n" 11606 "}\n", 11607 StroustrupBraceStyle); 11608 11609 verifyFormat("#ifdef _DEBUG\n" 11610 "int foo(int i = 0)\n" 11611 "#else\n" 11612 "int foo(int i = 5)\n" 11613 "#endif\n" 11614 "{\n" 11615 " return i;\n" 11616 "}", 11617 StroustrupBraceStyle); 11618 11619 verifyFormat("void foo() {}\n" 11620 "void bar()\n" 11621 "#ifdef _DEBUG\n" 11622 "{\n" 11623 " foo();\n" 11624 "}\n" 11625 "#else\n" 11626 "{\n" 11627 "}\n" 11628 "#endif", 11629 StroustrupBraceStyle); 11630 11631 verifyFormat("void foobar() { int i = 5; }\n" 11632 "#ifdef _DEBUG\n" 11633 "void bar() {}\n" 11634 "#else\n" 11635 "void bar() { foobar(); }\n" 11636 "#endif", 11637 StroustrupBraceStyle); 11638 } 11639 11640 TEST_F(FormatTest, AllmanBraceBreaking) { 11641 FormatStyle AllmanBraceStyle = getLLVMStyle(); 11642 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 11643 11644 EXPECT_EQ("namespace a\n" 11645 "{\n" 11646 "void f();\n" 11647 "void g();\n" 11648 "} // namespace a\n", 11649 format("namespace a\n" 11650 "{\n" 11651 "void f();\n" 11652 "void g();\n" 11653 "}\n", 11654 AllmanBraceStyle)); 11655 11656 verifyFormat("namespace a\n" 11657 "{\n" 11658 "class A\n" 11659 "{\n" 11660 " void f()\n" 11661 " {\n" 11662 " if (true)\n" 11663 " {\n" 11664 " a();\n" 11665 " b();\n" 11666 " }\n" 11667 " }\n" 11668 " void g() { return; }\n" 11669 "};\n" 11670 "struct B\n" 11671 "{\n" 11672 " int x;\n" 11673 "};\n" 11674 "union C\n" 11675 "{\n" 11676 "};\n" 11677 "} // namespace a", 11678 AllmanBraceStyle); 11679 11680 verifyFormat("void f()\n" 11681 "{\n" 11682 " if (true)\n" 11683 " {\n" 11684 " a();\n" 11685 " }\n" 11686 " else if (false)\n" 11687 " {\n" 11688 " b();\n" 11689 " }\n" 11690 " else\n" 11691 " {\n" 11692 " c();\n" 11693 " }\n" 11694 "}\n", 11695 AllmanBraceStyle); 11696 11697 verifyFormat("void f()\n" 11698 "{\n" 11699 " for (int i = 0; i < 10; ++i)\n" 11700 " {\n" 11701 " a();\n" 11702 " }\n" 11703 " while (false)\n" 11704 " {\n" 11705 " b();\n" 11706 " }\n" 11707 " do\n" 11708 " {\n" 11709 " c();\n" 11710 " } while (false)\n" 11711 "}\n", 11712 AllmanBraceStyle); 11713 11714 verifyFormat("void f(int a)\n" 11715 "{\n" 11716 " switch (a)\n" 11717 " {\n" 11718 " case 0:\n" 11719 " break;\n" 11720 " case 1:\n" 11721 " {\n" 11722 " break;\n" 11723 " }\n" 11724 " case 2:\n" 11725 " {\n" 11726 " }\n" 11727 " break;\n" 11728 " default:\n" 11729 " break;\n" 11730 " }\n" 11731 "}\n", 11732 AllmanBraceStyle); 11733 11734 verifyFormat("enum X\n" 11735 "{\n" 11736 " Y = 0,\n" 11737 "}\n", 11738 AllmanBraceStyle); 11739 verifyFormat("enum X\n" 11740 "{\n" 11741 " Y = 0\n" 11742 "}\n", 11743 AllmanBraceStyle); 11744 11745 verifyFormat("@interface BSApplicationController ()\n" 11746 "{\n" 11747 "@private\n" 11748 " id _extraIvar;\n" 11749 "}\n" 11750 "@end\n", 11751 AllmanBraceStyle); 11752 11753 verifyFormat("#ifdef _DEBUG\n" 11754 "int foo(int i = 0)\n" 11755 "#else\n" 11756 "int foo(int i = 5)\n" 11757 "#endif\n" 11758 "{\n" 11759 " return i;\n" 11760 "}", 11761 AllmanBraceStyle); 11762 11763 verifyFormat("void foo() {}\n" 11764 "void bar()\n" 11765 "#ifdef _DEBUG\n" 11766 "{\n" 11767 " foo();\n" 11768 "}\n" 11769 "#else\n" 11770 "{\n" 11771 "}\n" 11772 "#endif", 11773 AllmanBraceStyle); 11774 11775 verifyFormat("void foobar() { int i = 5; }\n" 11776 "#ifdef _DEBUG\n" 11777 "void bar() {}\n" 11778 "#else\n" 11779 "void bar() { foobar(); }\n" 11780 "#endif", 11781 AllmanBraceStyle); 11782 11783 // This shouldn't affect ObjC blocks.. 11784 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 11785 " // ...\n" 11786 " int i;\n" 11787 "}];", 11788 AllmanBraceStyle); 11789 verifyFormat("void (^block)(void) = ^{\n" 11790 " // ...\n" 11791 " int i;\n" 11792 "};", 11793 AllmanBraceStyle); 11794 // .. or dict literals. 11795 verifyFormat("void f()\n" 11796 "{\n" 11797 " // ...\n" 11798 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 11799 "}", 11800 AllmanBraceStyle); 11801 verifyFormat("void f()\n" 11802 "{\n" 11803 " // ...\n" 11804 " [object someMethod:@{a : @\"b\"}];\n" 11805 "}", 11806 AllmanBraceStyle); 11807 verifyFormat("int f()\n" 11808 "{ // comment\n" 11809 " return 42;\n" 11810 "}", 11811 AllmanBraceStyle); 11812 11813 AllmanBraceStyle.ColumnLimit = 19; 11814 verifyFormat("void f() { int i; }", AllmanBraceStyle); 11815 AllmanBraceStyle.ColumnLimit = 18; 11816 verifyFormat("void f()\n" 11817 "{\n" 11818 " int i;\n" 11819 "}", 11820 AllmanBraceStyle); 11821 AllmanBraceStyle.ColumnLimit = 80; 11822 11823 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 11824 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 11825 FormatStyle::SIS_WithoutElse; 11826 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 11827 verifyFormat("void f(bool b)\n" 11828 "{\n" 11829 " if (b)\n" 11830 " {\n" 11831 " return;\n" 11832 " }\n" 11833 "}\n", 11834 BreakBeforeBraceShortIfs); 11835 verifyFormat("void f(bool b)\n" 11836 "{\n" 11837 " if constexpr (b)\n" 11838 " {\n" 11839 " return;\n" 11840 " }\n" 11841 "}\n", 11842 BreakBeforeBraceShortIfs); 11843 verifyFormat("void f(bool b)\n" 11844 "{\n" 11845 " if CONSTEXPR (b)\n" 11846 " {\n" 11847 " return;\n" 11848 " }\n" 11849 "}\n", 11850 BreakBeforeBraceShortIfs); 11851 verifyFormat("void f(bool b)\n" 11852 "{\n" 11853 " if (b) return;\n" 11854 "}\n", 11855 BreakBeforeBraceShortIfs); 11856 verifyFormat("void f(bool b)\n" 11857 "{\n" 11858 " if constexpr (b) return;\n" 11859 "}\n", 11860 BreakBeforeBraceShortIfs); 11861 verifyFormat("void f(bool b)\n" 11862 "{\n" 11863 " if CONSTEXPR (b) return;\n" 11864 "}\n", 11865 BreakBeforeBraceShortIfs); 11866 verifyFormat("void f(bool b)\n" 11867 "{\n" 11868 " while (b)\n" 11869 " {\n" 11870 " return;\n" 11871 " }\n" 11872 "}\n", 11873 BreakBeforeBraceShortIfs); 11874 } 11875 11876 TEST_F(FormatTest, WhitesmithsBraceBreaking) { 11877 FormatStyle WhitesmithsBraceStyle = getLLVMStyle(); 11878 WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 11879 11880 // Make a few changes to the style for testing purposes 11881 WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine = 11882 FormatStyle::SFS_Empty; 11883 WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 11884 WhitesmithsBraceStyle.ColumnLimit = 0; 11885 11886 // FIXME: this test case can't decide whether there should be a blank line 11887 // after the ~D() line or not. It adds one if one doesn't exist in the test 11888 // and it removes the line if one exists. 11889 /* 11890 verifyFormat("class A;\n" 11891 "namespace B\n" 11892 " {\n" 11893 "class C;\n" 11894 "// Comment\n" 11895 "class D\n" 11896 " {\n" 11897 "public:\n" 11898 " D();\n" 11899 " ~D() {}\n" 11900 "private:\n" 11901 " enum E\n" 11902 " {\n" 11903 " F\n" 11904 " }\n" 11905 " };\n" 11906 " } // namespace B\n", 11907 WhitesmithsBraceStyle); 11908 */ 11909 11910 verifyFormat("namespace a\n" 11911 " {\n" 11912 "class A\n" 11913 " {\n" 11914 " void f()\n" 11915 " {\n" 11916 " if (true)\n" 11917 " {\n" 11918 " a();\n" 11919 " b();\n" 11920 " }\n" 11921 " }\n" 11922 " void g()\n" 11923 " {\n" 11924 " return;\n" 11925 " }\n" 11926 " };\n" 11927 "struct B\n" 11928 " {\n" 11929 " int x;\n" 11930 " };\n" 11931 " } // namespace a", 11932 WhitesmithsBraceStyle); 11933 11934 verifyFormat("void f()\n" 11935 " {\n" 11936 " if (true)\n" 11937 " {\n" 11938 " a();\n" 11939 " }\n" 11940 " else if (false)\n" 11941 " {\n" 11942 " b();\n" 11943 " }\n" 11944 " else\n" 11945 " {\n" 11946 " c();\n" 11947 " }\n" 11948 " }\n", 11949 WhitesmithsBraceStyle); 11950 11951 verifyFormat("void f()\n" 11952 " {\n" 11953 " for (int i = 0; i < 10; ++i)\n" 11954 " {\n" 11955 " a();\n" 11956 " }\n" 11957 " while (false)\n" 11958 " {\n" 11959 " b();\n" 11960 " }\n" 11961 " do\n" 11962 " {\n" 11963 " c();\n" 11964 " } while (false)\n" 11965 " }\n", 11966 WhitesmithsBraceStyle); 11967 11968 // FIXME: the block and the break under case 2 in this test don't get indented 11969 // correctly 11970 /* 11971 verifyFormat("void switchTest1(int a)\n" 11972 " {\n" 11973 " switch (a)\n" 11974 " {\n" 11975 " case 2:\n" 11976 " {\n" 11977 " }\n" 11978 " break;\n" 11979 " }\n" 11980 " }\n", 11981 WhitesmithsBraceStyle); 11982 */ 11983 11984 // FIXME: the block and the break under case 2 in this test don't get indented 11985 // correctly 11986 /* 11987 verifyFormat("void switchTest2(int a)\n" 11988 " {\n" 11989 " switch (a)\n" 11990 " {\n" 11991 " case 0:\n" 11992 " break;\n" 11993 " case 1:\n" 11994 " {\n" 11995 " break;\n" 11996 " }\n" 11997 " case 2:\n" 11998 " {\n" 11999 " }\n" 12000 " break;\n" 12001 " default:\n" 12002 " break;\n" 12003 " }\n" 12004 " }\n", 12005 WhitesmithsBraceStyle); 12006 */ 12007 12008 verifyFormat("enum X\n" 12009 " {\n" 12010 " Y = 0, // testing\n" 12011 " }\n", 12012 WhitesmithsBraceStyle); 12013 12014 verifyFormat("enum X\n" 12015 " {\n" 12016 " Y = 0\n" 12017 " }\n", 12018 WhitesmithsBraceStyle); 12019 verifyFormat("enum X\n" 12020 " {\n" 12021 " Y = 0,\n" 12022 " Z = 1\n" 12023 " };\n", 12024 WhitesmithsBraceStyle); 12025 12026 verifyFormat("@interface BSApplicationController ()\n" 12027 " {\n" 12028 "@private\n" 12029 " id _extraIvar;\n" 12030 " }\n" 12031 "@end\n", 12032 WhitesmithsBraceStyle); 12033 12034 verifyFormat("#ifdef _DEBUG\n" 12035 "int foo(int i = 0)\n" 12036 "#else\n" 12037 "int foo(int i = 5)\n" 12038 "#endif\n" 12039 " {\n" 12040 " return i;\n" 12041 " }", 12042 WhitesmithsBraceStyle); 12043 12044 verifyFormat("void foo() {}\n" 12045 "void bar()\n" 12046 "#ifdef _DEBUG\n" 12047 " {\n" 12048 " foo();\n" 12049 " }\n" 12050 "#else\n" 12051 " {\n" 12052 " }\n" 12053 "#endif", 12054 WhitesmithsBraceStyle); 12055 12056 verifyFormat("void foobar()\n" 12057 " {\n" 12058 " int i = 5;\n" 12059 " }\n" 12060 "#ifdef _DEBUG\n" 12061 "void bar()\n" 12062 " {\n" 12063 " }\n" 12064 "#else\n" 12065 "void bar()\n" 12066 " {\n" 12067 " foobar();\n" 12068 " }\n" 12069 "#endif", 12070 WhitesmithsBraceStyle); 12071 12072 // This shouldn't affect ObjC blocks.. 12073 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 12074 " // ...\n" 12075 " int i;\n" 12076 "}];", 12077 WhitesmithsBraceStyle); 12078 verifyFormat("void (^block)(void) = ^{\n" 12079 " // ...\n" 12080 " int i;\n" 12081 "};", 12082 WhitesmithsBraceStyle); 12083 // .. or dict literals. 12084 verifyFormat("void f()\n" 12085 " {\n" 12086 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 12087 " }", 12088 WhitesmithsBraceStyle); 12089 12090 verifyFormat("int f()\n" 12091 " { // comment\n" 12092 " return 42;\n" 12093 " }", 12094 WhitesmithsBraceStyle); 12095 12096 FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle; 12097 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 12098 FormatStyle::SIS_Always; 12099 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 12100 verifyFormat("void f(bool b)\n" 12101 " {\n" 12102 " if (b)\n" 12103 " {\n" 12104 " return;\n" 12105 " }\n" 12106 " }\n", 12107 BreakBeforeBraceShortIfs); 12108 verifyFormat("void f(bool b)\n" 12109 " {\n" 12110 " if (b) return;\n" 12111 " }\n", 12112 BreakBeforeBraceShortIfs); 12113 verifyFormat("void f(bool b)\n" 12114 " {\n" 12115 " while (b)\n" 12116 " {\n" 12117 " return;\n" 12118 " }\n" 12119 " }\n", 12120 BreakBeforeBraceShortIfs); 12121 } 12122 12123 TEST_F(FormatTest, GNUBraceBreaking) { 12124 FormatStyle GNUBraceStyle = getLLVMStyle(); 12125 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 12126 verifyFormat("namespace a\n" 12127 "{\n" 12128 "class A\n" 12129 "{\n" 12130 " void f()\n" 12131 " {\n" 12132 " int a;\n" 12133 " {\n" 12134 " int b;\n" 12135 " }\n" 12136 " if (true)\n" 12137 " {\n" 12138 " a();\n" 12139 " b();\n" 12140 " }\n" 12141 " }\n" 12142 " void g() { return; }\n" 12143 "}\n" 12144 "} // namespace a", 12145 GNUBraceStyle); 12146 12147 verifyFormat("void f()\n" 12148 "{\n" 12149 " if (true)\n" 12150 " {\n" 12151 " a();\n" 12152 " }\n" 12153 " else if (false)\n" 12154 " {\n" 12155 " b();\n" 12156 " }\n" 12157 " else\n" 12158 " {\n" 12159 " c();\n" 12160 " }\n" 12161 "}\n", 12162 GNUBraceStyle); 12163 12164 verifyFormat("void f()\n" 12165 "{\n" 12166 " for (int i = 0; i < 10; ++i)\n" 12167 " {\n" 12168 " a();\n" 12169 " }\n" 12170 " while (false)\n" 12171 " {\n" 12172 " b();\n" 12173 " }\n" 12174 " do\n" 12175 " {\n" 12176 " c();\n" 12177 " }\n" 12178 " while (false);\n" 12179 "}\n", 12180 GNUBraceStyle); 12181 12182 verifyFormat("void f(int a)\n" 12183 "{\n" 12184 " switch (a)\n" 12185 " {\n" 12186 " case 0:\n" 12187 " break;\n" 12188 " case 1:\n" 12189 " {\n" 12190 " break;\n" 12191 " }\n" 12192 " case 2:\n" 12193 " {\n" 12194 " }\n" 12195 " break;\n" 12196 " default:\n" 12197 " break;\n" 12198 " }\n" 12199 "}\n", 12200 GNUBraceStyle); 12201 12202 verifyFormat("enum X\n" 12203 "{\n" 12204 " Y = 0,\n" 12205 "}\n", 12206 GNUBraceStyle); 12207 12208 verifyFormat("@interface BSApplicationController ()\n" 12209 "{\n" 12210 "@private\n" 12211 " id _extraIvar;\n" 12212 "}\n" 12213 "@end\n", 12214 GNUBraceStyle); 12215 12216 verifyFormat("#ifdef _DEBUG\n" 12217 "int foo(int i = 0)\n" 12218 "#else\n" 12219 "int foo(int i = 5)\n" 12220 "#endif\n" 12221 "{\n" 12222 " return i;\n" 12223 "}", 12224 GNUBraceStyle); 12225 12226 verifyFormat("void foo() {}\n" 12227 "void bar()\n" 12228 "#ifdef _DEBUG\n" 12229 "{\n" 12230 " foo();\n" 12231 "}\n" 12232 "#else\n" 12233 "{\n" 12234 "}\n" 12235 "#endif", 12236 GNUBraceStyle); 12237 12238 verifyFormat("void foobar() { int i = 5; }\n" 12239 "#ifdef _DEBUG\n" 12240 "void bar() {}\n" 12241 "#else\n" 12242 "void bar() { foobar(); }\n" 12243 "#endif", 12244 GNUBraceStyle); 12245 } 12246 12247 TEST_F(FormatTest, WebKitBraceBreaking) { 12248 FormatStyle WebKitBraceStyle = getLLVMStyle(); 12249 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 12250 WebKitBraceStyle.FixNamespaceComments = false; 12251 verifyFormat("namespace a {\n" 12252 "class A {\n" 12253 " void f()\n" 12254 " {\n" 12255 " if (true) {\n" 12256 " a();\n" 12257 " b();\n" 12258 " }\n" 12259 " }\n" 12260 " void g() { return; }\n" 12261 "};\n" 12262 "enum E {\n" 12263 " A,\n" 12264 " // foo\n" 12265 " B,\n" 12266 " C\n" 12267 "};\n" 12268 "struct B {\n" 12269 " int x;\n" 12270 "};\n" 12271 "}\n", 12272 WebKitBraceStyle); 12273 verifyFormat("struct S {\n" 12274 " int Type;\n" 12275 " union {\n" 12276 " int x;\n" 12277 " double y;\n" 12278 " } Value;\n" 12279 " class C {\n" 12280 " MyFavoriteType Value;\n" 12281 " } Class;\n" 12282 "};\n", 12283 WebKitBraceStyle); 12284 } 12285 12286 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 12287 verifyFormat("void f() {\n" 12288 " try {\n" 12289 " } catch (const Exception &e) {\n" 12290 " }\n" 12291 "}\n", 12292 getLLVMStyle()); 12293 } 12294 12295 TEST_F(FormatTest, UnderstandsPragmas) { 12296 verifyFormat("#pragma omp reduction(| : var)"); 12297 verifyFormat("#pragma omp reduction(+ : var)"); 12298 12299 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 12300 "(including parentheses).", 12301 format("#pragma mark Any non-hyphenated or hyphenated string " 12302 "(including parentheses).")); 12303 } 12304 12305 TEST_F(FormatTest, UnderstandPragmaOption) { 12306 verifyFormat("#pragma option -C -A"); 12307 12308 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 12309 } 12310 12311 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 12312 FormatStyle Style = getLLVMStyle(); 12313 Style.ColumnLimit = 20; 12314 12315 // See PR41213 12316 EXPECT_EQ("/*\n" 12317 " *\t9012345\n" 12318 " * /8901\n" 12319 " */", 12320 format("/*\n" 12321 " *\t9012345 /8901\n" 12322 " */", 12323 Style)); 12324 EXPECT_EQ("/*\n" 12325 " *345678\n" 12326 " *\t/8901\n" 12327 " */", 12328 format("/*\n" 12329 " *345678\t/8901\n" 12330 " */", 12331 Style)); 12332 12333 verifyFormat("int a; // the\n" 12334 " // comment", 12335 Style); 12336 EXPECT_EQ("int a; /* first line\n" 12337 " * second\n" 12338 " * line third\n" 12339 " * line\n" 12340 " */", 12341 format("int a; /* first line\n" 12342 " * second\n" 12343 " * line third\n" 12344 " * line\n" 12345 " */", 12346 Style)); 12347 EXPECT_EQ("int a; // first line\n" 12348 " // second\n" 12349 " // line third\n" 12350 " // line", 12351 format("int a; // first line\n" 12352 " // second line\n" 12353 " // third line", 12354 Style)); 12355 12356 Style.PenaltyExcessCharacter = 90; 12357 verifyFormat("int a; // the comment", Style); 12358 EXPECT_EQ("int a; // the comment\n" 12359 " // aaa", 12360 format("int a; // the comment aaa", Style)); 12361 EXPECT_EQ("int a; /* first line\n" 12362 " * second line\n" 12363 " * third line\n" 12364 " */", 12365 format("int a; /* first line\n" 12366 " * second line\n" 12367 " * third line\n" 12368 " */", 12369 Style)); 12370 EXPECT_EQ("int a; // first line\n" 12371 " // second line\n" 12372 " // third line", 12373 format("int a; // first line\n" 12374 " // second line\n" 12375 " // third line", 12376 Style)); 12377 // FIXME: Investigate why this is not getting the same layout as the test 12378 // above. 12379 EXPECT_EQ("int a; /* first line\n" 12380 " * second line\n" 12381 " * third line\n" 12382 " */", 12383 format("int a; /* first line second line third line" 12384 "\n*/", 12385 Style)); 12386 12387 EXPECT_EQ("// foo bar baz bazfoo\n" 12388 "// foo bar foo bar\n", 12389 format("// foo bar baz bazfoo\n" 12390 "// foo bar foo bar\n", 12391 Style)); 12392 EXPECT_EQ("// foo bar baz bazfoo\n" 12393 "// foo bar foo bar\n", 12394 format("// foo bar baz bazfoo\n" 12395 "// foo bar foo bar\n", 12396 Style)); 12397 12398 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 12399 // next one. 12400 EXPECT_EQ("// foo bar baz bazfoo\n" 12401 "// bar foo bar\n", 12402 format("// foo bar baz bazfoo bar\n" 12403 "// foo bar\n", 12404 Style)); 12405 12406 EXPECT_EQ("// foo bar baz bazfoo\n" 12407 "// foo bar baz bazfoo\n" 12408 "// bar foo bar\n", 12409 format("// foo bar baz bazfoo\n" 12410 "// foo bar baz bazfoo bar\n" 12411 "// foo bar\n", 12412 Style)); 12413 12414 EXPECT_EQ("// foo bar baz bazfoo\n" 12415 "// foo bar baz bazfoo\n" 12416 "// bar foo bar\n", 12417 format("// foo bar baz bazfoo\n" 12418 "// foo bar baz bazfoo bar\n" 12419 "// foo bar\n", 12420 Style)); 12421 12422 // Make sure we do not keep protruding characters if strict mode reflow is 12423 // cheaper than keeping protruding characters. 12424 Style.ColumnLimit = 21; 12425 EXPECT_EQ( 12426 "// foo foo foo foo\n" 12427 "// foo foo foo foo\n" 12428 "// foo foo foo foo\n", 12429 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style)); 12430 12431 EXPECT_EQ("int a = /* long block\n" 12432 " comment */\n" 12433 " 42;", 12434 format("int a = /* long block comment */ 42;", Style)); 12435 } 12436 12437 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 12438 for (size_t i = 1; i < Styles.size(); ++i) \ 12439 EXPECT_EQ(Styles[0], Styles[i]) \ 12440 << "Style #" << i << " of " << Styles.size() << " differs from Style #0" 12441 12442 TEST_F(FormatTest, GetsPredefinedStyleByName) { 12443 SmallVector<FormatStyle, 3> Styles; 12444 Styles.resize(3); 12445 12446 Styles[0] = getLLVMStyle(); 12447 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 12448 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 12449 EXPECT_ALL_STYLES_EQUAL(Styles); 12450 12451 Styles[0] = getGoogleStyle(); 12452 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 12453 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 12454 EXPECT_ALL_STYLES_EQUAL(Styles); 12455 12456 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12457 EXPECT_TRUE( 12458 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 12459 EXPECT_TRUE( 12460 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 12461 EXPECT_ALL_STYLES_EQUAL(Styles); 12462 12463 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 12464 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 12465 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 12466 EXPECT_ALL_STYLES_EQUAL(Styles); 12467 12468 Styles[0] = getMozillaStyle(); 12469 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 12470 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 12471 EXPECT_ALL_STYLES_EQUAL(Styles); 12472 12473 Styles[0] = getWebKitStyle(); 12474 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 12475 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 12476 EXPECT_ALL_STYLES_EQUAL(Styles); 12477 12478 Styles[0] = getGNUStyle(); 12479 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 12480 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 12481 EXPECT_ALL_STYLES_EQUAL(Styles); 12482 12483 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 12484 } 12485 12486 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 12487 SmallVector<FormatStyle, 8> Styles; 12488 Styles.resize(2); 12489 12490 Styles[0] = getGoogleStyle(); 12491 Styles[1] = getLLVMStyle(); 12492 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12493 EXPECT_ALL_STYLES_EQUAL(Styles); 12494 12495 Styles.resize(5); 12496 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12497 Styles[1] = getLLVMStyle(); 12498 Styles[1].Language = FormatStyle::LK_JavaScript; 12499 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12500 12501 Styles[2] = getLLVMStyle(); 12502 Styles[2].Language = FormatStyle::LK_JavaScript; 12503 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 12504 "BasedOnStyle: Google", 12505 &Styles[2]) 12506 .value()); 12507 12508 Styles[3] = getLLVMStyle(); 12509 Styles[3].Language = FormatStyle::LK_JavaScript; 12510 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 12511 "Language: JavaScript", 12512 &Styles[3]) 12513 .value()); 12514 12515 Styles[4] = getLLVMStyle(); 12516 Styles[4].Language = FormatStyle::LK_JavaScript; 12517 EXPECT_EQ(0, parseConfiguration("---\n" 12518 "BasedOnStyle: LLVM\n" 12519 "IndentWidth: 123\n" 12520 "---\n" 12521 "BasedOnStyle: Google\n" 12522 "Language: JavaScript", 12523 &Styles[4]) 12524 .value()); 12525 EXPECT_ALL_STYLES_EQUAL(Styles); 12526 } 12527 12528 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 12529 Style.FIELD = false; \ 12530 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 12531 EXPECT_TRUE(Style.FIELD); \ 12532 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 12533 EXPECT_FALSE(Style.FIELD); 12534 12535 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 12536 12537 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 12538 Style.STRUCT.FIELD = false; \ 12539 EXPECT_EQ(0, \ 12540 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 12541 .value()); \ 12542 EXPECT_TRUE(Style.STRUCT.FIELD); \ 12543 EXPECT_EQ(0, \ 12544 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 12545 .value()); \ 12546 EXPECT_FALSE(Style.STRUCT.FIELD); 12547 12548 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 12549 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 12550 12551 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 12552 EXPECT_NE(VALUE, Style.FIELD); \ 12553 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 12554 EXPECT_EQ(VALUE, Style.FIELD) 12555 12556 TEST_F(FormatTest, ParsesConfigurationBools) { 12557 FormatStyle Style = {}; 12558 Style.Language = FormatStyle::LK_Cpp; 12559 CHECK_PARSE_BOOL(AlignOperands); 12560 CHECK_PARSE_BOOL(AlignTrailingComments); 12561 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 12562 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 12563 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 12564 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 12565 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 12566 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 12567 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 12568 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 12569 CHECK_PARSE_BOOL(BinPackArguments); 12570 CHECK_PARSE_BOOL(BinPackParameters); 12571 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 12572 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 12573 CHECK_PARSE_BOOL(BreakStringLiterals); 12574 CHECK_PARSE_BOOL(CompactNamespaces); 12575 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 12576 CHECK_PARSE_BOOL(DeriveLineEnding); 12577 CHECK_PARSE_BOOL(DerivePointerAlignment); 12578 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 12579 CHECK_PARSE_BOOL(DisableFormat); 12580 CHECK_PARSE_BOOL(IndentCaseLabels); 12581 CHECK_PARSE_BOOL(IndentGotoLabels); 12582 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 12583 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 12584 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 12585 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 12586 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 12587 CHECK_PARSE_BOOL(ReflowComments); 12588 CHECK_PARSE_BOOL(SortIncludes); 12589 CHECK_PARSE_BOOL(SortUsingDeclarations); 12590 CHECK_PARSE_BOOL(SpacesInParentheses); 12591 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 12592 CHECK_PARSE_BOOL(SpacesInAngles); 12593 CHECK_PARSE_BOOL(SpacesInConditionalStatement); 12594 CHECK_PARSE_BOOL(SpaceInEmptyBlock); 12595 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 12596 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 12597 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 12598 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 12599 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 12600 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 12601 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 12602 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 12603 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 12604 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 12605 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 12606 CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets); 12607 CHECK_PARSE_BOOL(UseCRLF); 12608 12609 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 12610 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 12611 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 12612 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 12613 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 12614 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 12615 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 12616 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 12617 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 12618 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 12619 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 12620 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 12621 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 12622 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 12623 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 12624 } 12625 12626 #undef CHECK_PARSE_BOOL 12627 12628 TEST_F(FormatTest, ParsesConfiguration) { 12629 FormatStyle Style = {}; 12630 Style.Language = FormatStyle::LK_Cpp; 12631 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 12632 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 12633 ConstructorInitializerIndentWidth, 1234u); 12634 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 12635 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 12636 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 12637 CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u); 12638 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 12639 PenaltyBreakBeforeFirstCallParameter, 1234u); 12640 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 12641 PenaltyBreakTemplateDeclaration, 1234u); 12642 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 12643 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 12644 PenaltyReturnTypeOnItsOwnLine, 1234u); 12645 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 12646 SpacesBeforeTrailingComments, 1234u); 12647 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 12648 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 12649 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 12650 12651 Style.PointerAlignment = FormatStyle::PAS_Middle; 12652 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 12653 FormatStyle::PAS_Left); 12654 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 12655 FormatStyle::PAS_Right); 12656 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 12657 FormatStyle::PAS_Middle); 12658 // For backward compatibility: 12659 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 12660 FormatStyle::PAS_Left); 12661 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 12662 FormatStyle::PAS_Right); 12663 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 12664 FormatStyle::PAS_Middle); 12665 12666 Style.Standard = FormatStyle::LS_Auto; 12667 CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03); 12668 CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11); 12669 CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14); 12670 CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17); 12671 CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20); 12672 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 12673 CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest); 12674 // Legacy aliases: 12675 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 12676 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest); 12677 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 12678 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 12679 12680 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 12681 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 12682 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 12683 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 12684 FormatStyle::BOS_None); 12685 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 12686 FormatStyle::BOS_All); 12687 // For backward compatibility: 12688 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 12689 FormatStyle::BOS_None); 12690 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 12691 FormatStyle::BOS_All); 12692 12693 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 12694 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 12695 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 12696 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 12697 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 12698 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 12699 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 12700 // For backward compatibility: 12701 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 12702 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 12703 12704 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 12705 CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList, 12706 FormatStyle::BILS_BeforeComma); 12707 CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList, 12708 FormatStyle::BILS_AfterColon); 12709 CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList, 12710 FormatStyle::BILS_BeforeColon); 12711 // For backward compatibility: 12712 CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList, 12713 FormatStyle::BILS_BeforeComma); 12714 12715 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 12716 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 12717 FormatStyle::BAS_Align); 12718 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 12719 FormatStyle::BAS_DontAlign); 12720 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 12721 FormatStyle::BAS_AlwaysBreak); 12722 // For backward compatibility: 12723 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 12724 FormatStyle::BAS_DontAlign); 12725 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 12726 FormatStyle::BAS_Align); 12727 12728 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 12729 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 12730 FormatStyle::ENAS_DontAlign); 12731 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 12732 FormatStyle::ENAS_Left); 12733 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 12734 FormatStyle::ENAS_Right); 12735 // For backward compatibility: 12736 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 12737 FormatStyle::ENAS_Left); 12738 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 12739 FormatStyle::ENAS_Right); 12740 12741 Style.UseTab = FormatStyle::UT_ForIndentation; 12742 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 12743 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 12744 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 12745 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 12746 FormatStyle::UT_ForContinuationAndIndentation); 12747 // For backward compatibility: 12748 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 12749 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 12750 12751 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 12752 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never", 12753 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12754 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty", 12755 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty); 12756 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always", 12757 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12758 // For backward compatibility: 12759 CHECK_PARSE("AllowShortBlocksOnASingleLine: false", 12760 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12761 CHECK_PARSE("AllowShortBlocksOnASingleLine: true", 12762 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12763 12764 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 12765 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 12766 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12767 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 12768 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 12769 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 12770 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 12771 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 12772 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12773 // For backward compatibility: 12774 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 12775 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12776 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 12777 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12778 12779 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 12780 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 12781 FormatStyle::SBPO_Never); 12782 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 12783 FormatStyle::SBPO_Always); 12784 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 12785 FormatStyle::SBPO_ControlStatements); 12786 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 12787 FormatStyle::SBPO_NonEmptyParentheses); 12788 // For backward compatibility: 12789 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 12790 FormatStyle::SBPO_Never); 12791 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 12792 FormatStyle::SBPO_ControlStatements); 12793 12794 Style.ColumnLimit = 123; 12795 FormatStyle BaseStyle = getLLVMStyle(); 12796 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 12797 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 12798 12799 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 12800 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 12801 FormatStyle::BS_Attach); 12802 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 12803 FormatStyle::BS_Linux); 12804 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 12805 FormatStyle::BS_Mozilla); 12806 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 12807 FormatStyle::BS_Stroustrup); 12808 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 12809 FormatStyle::BS_Allman); 12810 CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces, 12811 FormatStyle::BS_Whitesmiths); 12812 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 12813 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 12814 FormatStyle::BS_WebKit); 12815 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 12816 FormatStyle::BS_Custom); 12817 12818 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never; 12819 CHECK_PARSE("BraceWrapping:\n" 12820 " AfterControlStatement: MultiLine", 12821 BraceWrapping.AfterControlStatement, 12822 FormatStyle::BWACS_MultiLine); 12823 CHECK_PARSE("BraceWrapping:\n" 12824 " AfterControlStatement: Always", 12825 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 12826 CHECK_PARSE("BraceWrapping:\n" 12827 " AfterControlStatement: Never", 12828 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 12829 // For backward compatibility: 12830 CHECK_PARSE("BraceWrapping:\n" 12831 " AfterControlStatement: true", 12832 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 12833 CHECK_PARSE("BraceWrapping:\n" 12834 " AfterControlStatement: false", 12835 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 12836 12837 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 12838 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 12839 FormatStyle::RTBS_None); 12840 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 12841 FormatStyle::RTBS_All); 12842 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 12843 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 12844 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 12845 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 12846 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 12847 AlwaysBreakAfterReturnType, 12848 FormatStyle::RTBS_TopLevelDefinitions); 12849 12850 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 12851 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", 12852 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No); 12853 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", 12854 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 12855 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", 12856 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 12857 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", 12858 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 12859 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", 12860 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 12861 12862 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 12863 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 12864 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 12865 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 12866 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 12867 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 12868 AlwaysBreakAfterDefinitionReturnType, 12869 FormatStyle::DRTBS_TopLevel); 12870 12871 Style.NamespaceIndentation = FormatStyle::NI_All; 12872 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 12873 FormatStyle::NI_None); 12874 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 12875 FormatStyle::NI_Inner); 12876 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 12877 FormatStyle::NI_All); 12878 12879 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 12880 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 12881 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12882 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 12883 AllowShortIfStatementsOnASingleLine, 12884 FormatStyle::SIS_WithoutElse); 12885 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 12886 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 12887 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 12888 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12889 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 12890 AllowShortIfStatementsOnASingleLine, 12891 FormatStyle::SIS_WithoutElse); 12892 12893 // FIXME: This is required because parsing a configuration simply overwrites 12894 // the first N elements of the list instead of resetting it. 12895 Style.ForEachMacros.clear(); 12896 std::vector<std::string> BoostForeach; 12897 BoostForeach.push_back("BOOST_FOREACH"); 12898 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 12899 std::vector<std::string> BoostAndQForeach; 12900 BoostAndQForeach.push_back("BOOST_FOREACH"); 12901 BoostAndQForeach.push_back("Q_FOREACH"); 12902 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 12903 BoostAndQForeach); 12904 12905 Style.StatementMacros.clear(); 12906 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 12907 std::vector<std::string>{"QUNUSED"}); 12908 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 12909 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 12910 12911 Style.NamespaceMacros.clear(); 12912 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 12913 std::vector<std::string>{"TESTSUITE"}); 12914 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 12915 std::vector<std::string>({"TESTSUITE", "SUITE"})); 12916 12917 Style.IncludeStyle.IncludeCategories.clear(); 12918 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 12919 {"abc/.*", 2, 0}, {".*", 1, 0}}; 12920 CHECK_PARSE("IncludeCategories:\n" 12921 " - Regex: abc/.*\n" 12922 " Priority: 2\n" 12923 " - Regex: .*\n" 12924 " Priority: 1", 12925 IncludeStyle.IncludeCategories, ExpectedCategories); 12926 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 12927 "abc$"); 12928 CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'", 12929 IncludeStyle.IncludeIsMainSourceRegex, "abc$"); 12930 12931 Style.RawStringFormats.clear(); 12932 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 12933 { 12934 FormatStyle::LK_TextProto, 12935 {"pb", "proto"}, 12936 {"PARSE_TEXT_PROTO"}, 12937 /*CanonicalDelimiter=*/"", 12938 "llvm", 12939 }, 12940 { 12941 FormatStyle::LK_Cpp, 12942 {"cc", "cpp"}, 12943 {"C_CODEBLOCK", "CPPEVAL"}, 12944 /*CanonicalDelimiter=*/"cc", 12945 /*BasedOnStyle=*/"", 12946 }, 12947 }; 12948 12949 CHECK_PARSE("RawStringFormats:\n" 12950 " - Language: TextProto\n" 12951 " Delimiters:\n" 12952 " - 'pb'\n" 12953 " - 'proto'\n" 12954 " EnclosingFunctions:\n" 12955 " - 'PARSE_TEXT_PROTO'\n" 12956 " BasedOnStyle: llvm\n" 12957 " - Language: Cpp\n" 12958 " Delimiters:\n" 12959 " - 'cc'\n" 12960 " - 'cpp'\n" 12961 " EnclosingFunctions:\n" 12962 " - 'C_CODEBLOCK'\n" 12963 " - 'CPPEVAL'\n" 12964 " CanonicalDelimiter: 'cc'", 12965 RawStringFormats, ExpectedRawStringFormats); 12966 } 12967 12968 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 12969 FormatStyle Style = {}; 12970 Style.Language = FormatStyle::LK_Cpp; 12971 CHECK_PARSE("Language: Cpp\n" 12972 "IndentWidth: 12", 12973 IndentWidth, 12u); 12974 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 12975 "IndentWidth: 34", 12976 &Style), 12977 ParseError::Unsuitable); 12978 EXPECT_EQ(12u, Style.IndentWidth); 12979 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12980 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12981 12982 Style.Language = FormatStyle::LK_JavaScript; 12983 CHECK_PARSE("Language: JavaScript\n" 12984 "IndentWidth: 12", 12985 IndentWidth, 12u); 12986 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 12987 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 12988 "IndentWidth: 34", 12989 &Style), 12990 ParseError::Unsuitable); 12991 EXPECT_EQ(23u, Style.IndentWidth); 12992 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12993 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12994 12995 CHECK_PARSE("BasedOnStyle: LLVM\n" 12996 "IndentWidth: 67", 12997 IndentWidth, 67u); 12998 12999 CHECK_PARSE("---\n" 13000 "Language: JavaScript\n" 13001 "IndentWidth: 12\n" 13002 "---\n" 13003 "Language: Cpp\n" 13004 "IndentWidth: 34\n" 13005 "...\n", 13006 IndentWidth, 12u); 13007 13008 Style.Language = FormatStyle::LK_Cpp; 13009 CHECK_PARSE("---\n" 13010 "Language: JavaScript\n" 13011 "IndentWidth: 12\n" 13012 "---\n" 13013 "Language: Cpp\n" 13014 "IndentWidth: 34\n" 13015 "...\n", 13016 IndentWidth, 34u); 13017 CHECK_PARSE("---\n" 13018 "IndentWidth: 78\n" 13019 "---\n" 13020 "Language: JavaScript\n" 13021 "IndentWidth: 56\n" 13022 "...\n", 13023 IndentWidth, 78u); 13024 13025 Style.ColumnLimit = 123; 13026 Style.IndentWidth = 234; 13027 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 13028 Style.TabWidth = 345; 13029 EXPECT_FALSE(parseConfiguration("---\n" 13030 "IndentWidth: 456\n" 13031 "BreakBeforeBraces: Allman\n" 13032 "---\n" 13033 "Language: JavaScript\n" 13034 "IndentWidth: 111\n" 13035 "TabWidth: 111\n" 13036 "---\n" 13037 "Language: Cpp\n" 13038 "BreakBeforeBraces: Stroustrup\n" 13039 "TabWidth: 789\n" 13040 "...\n", 13041 &Style)); 13042 EXPECT_EQ(123u, Style.ColumnLimit); 13043 EXPECT_EQ(456u, Style.IndentWidth); 13044 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 13045 EXPECT_EQ(789u, Style.TabWidth); 13046 13047 EXPECT_EQ(parseConfiguration("---\n" 13048 "Language: JavaScript\n" 13049 "IndentWidth: 56\n" 13050 "---\n" 13051 "IndentWidth: 78\n" 13052 "...\n", 13053 &Style), 13054 ParseError::Error); 13055 EXPECT_EQ(parseConfiguration("---\n" 13056 "Language: JavaScript\n" 13057 "IndentWidth: 56\n" 13058 "---\n" 13059 "Language: JavaScript\n" 13060 "IndentWidth: 78\n" 13061 "...\n", 13062 &Style), 13063 ParseError::Error); 13064 13065 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 13066 } 13067 13068 #undef CHECK_PARSE 13069 13070 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 13071 FormatStyle Style = {}; 13072 Style.Language = FormatStyle::LK_JavaScript; 13073 Style.BreakBeforeTernaryOperators = true; 13074 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 13075 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 13076 13077 Style.BreakBeforeTernaryOperators = true; 13078 EXPECT_EQ(0, parseConfiguration("---\n" 13079 "BasedOnStyle: Google\n" 13080 "---\n" 13081 "Language: JavaScript\n" 13082 "IndentWidth: 76\n" 13083 "...\n", 13084 &Style) 13085 .value()); 13086 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 13087 EXPECT_EQ(76u, Style.IndentWidth); 13088 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 13089 } 13090 13091 TEST_F(FormatTest, ConfigurationRoundTripTest) { 13092 FormatStyle Style = getLLVMStyle(); 13093 std::string YAML = configurationAsText(Style); 13094 FormatStyle ParsedStyle = {}; 13095 ParsedStyle.Language = FormatStyle::LK_Cpp; 13096 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 13097 EXPECT_EQ(Style, ParsedStyle); 13098 } 13099 13100 TEST_F(FormatTest, WorksFor8bitEncodings) { 13101 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 13102 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 13103 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 13104 "\"\xef\xee\xf0\xf3...\"", 13105 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 13106 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 13107 "\xef\xee\xf0\xf3...\"", 13108 getLLVMStyleWithColumns(12))); 13109 } 13110 13111 TEST_F(FormatTest, HandlesUTF8BOM) { 13112 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 13113 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 13114 format("\xef\xbb\xbf#include <iostream>")); 13115 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 13116 format("\xef\xbb\xbf\n#include <iostream>")); 13117 } 13118 13119 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 13120 #if !defined(_MSC_VER) 13121 13122 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 13123 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 13124 getLLVMStyleWithColumns(35)); 13125 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 13126 getLLVMStyleWithColumns(31)); 13127 verifyFormat("// Однажды в студёную зимнюю пору...", 13128 getLLVMStyleWithColumns(36)); 13129 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 13130 verifyFormat("/* Однажды в студёную зимнюю пору... */", 13131 getLLVMStyleWithColumns(39)); 13132 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 13133 getLLVMStyleWithColumns(35)); 13134 } 13135 13136 TEST_F(FormatTest, SplitsUTF8Strings) { 13137 // Non-printable characters' width is currently considered to be the length in 13138 // bytes in UTF8. The characters can be displayed in very different manner 13139 // (zero-width, single width with a substitution glyph, expanded to their code 13140 // (e.g. "<8d>"), so there's no single correct way to handle them. 13141 EXPECT_EQ("\"aaaaÄ\"\n" 13142 "\"\xc2\x8d\";", 13143 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13144 EXPECT_EQ("\"aaaaaaaÄ\"\n" 13145 "\"\xc2\x8d\";", 13146 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13147 EXPECT_EQ("\"Однажды, в \"\n" 13148 "\"студёную \"\n" 13149 "\"зимнюю \"\n" 13150 "\"пору,\"", 13151 format("\"Однажды, в студёную зимнюю пору,\"", 13152 getLLVMStyleWithColumns(13))); 13153 EXPECT_EQ( 13154 "\"一 二 三 \"\n" 13155 "\"四 五六 \"\n" 13156 "\"七 八 九 \"\n" 13157 "\"十\"", 13158 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 13159 EXPECT_EQ("\"一\t\"\n" 13160 "\"二 \t\"\n" 13161 "\"三 四 \"\n" 13162 "\"五\t\"\n" 13163 "\"六 \t\"\n" 13164 "\"七 \"\n" 13165 "\"八九十\tqq\"", 13166 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 13167 getLLVMStyleWithColumns(11))); 13168 13169 // UTF8 character in an escape sequence. 13170 EXPECT_EQ("\"aaaaaa\"\n" 13171 "\"\\\xC2\x8D\"", 13172 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 13173 } 13174 13175 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 13176 EXPECT_EQ("const char *sssss =\n" 13177 " \"一二三四五六七八\\\n" 13178 " 九 十\";", 13179 format("const char *sssss = \"一二三四五六七八\\\n" 13180 " 九 十\";", 13181 getLLVMStyleWithColumns(30))); 13182 } 13183 13184 TEST_F(FormatTest, SplitsUTF8LineComments) { 13185 EXPECT_EQ("// aaaaÄ\xc2\x8d", 13186 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 13187 EXPECT_EQ("// Я из лесу\n" 13188 "// вышел; был\n" 13189 "// сильный\n" 13190 "// мороз.", 13191 format("// Я из лесу вышел; был сильный мороз.", 13192 getLLVMStyleWithColumns(13))); 13193 EXPECT_EQ("// 一二三\n" 13194 "// 四五六七\n" 13195 "// 八 九\n" 13196 "// 十", 13197 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 13198 } 13199 13200 TEST_F(FormatTest, SplitsUTF8BlockComments) { 13201 EXPECT_EQ("/* Гляжу,\n" 13202 " * поднимается\n" 13203 " * медленно в\n" 13204 " * гору\n" 13205 " * Лошадка,\n" 13206 " * везущая\n" 13207 " * хворосту\n" 13208 " * воз. */", 13209 format("/* Гляжу, поднимается медленно в гору\n" 13210 " * Лошадка, везущая хворосту воз. */", 13211 getLLVMStyleWithColumns(13))); 13212 EXPECT_EQ( 13213 "/* 一二三\n" 13214 " * 四五六七\n" 13215 " * 八 九\n" 13216 " * 十 */", 13217 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 13218 EXPECT_EQ("/* �������� ��������\n" 13219 " * ��������\n" 13220 " * ������-�� */", 13221 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 13222 } 13223 13224 #endif // _MSC_VER 13225 13226 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 13227 FormatStyle Style = getLLVMStyle(); 13228 13229 Style.ConstructorInitializerIndentWidth = 4; 13230 verifyFormat( 13231 "SomeClass::Constructor()\n" 13232 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13233 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13234 Style); 13235 13236 Style.ConstructorInitializerIndentWidth = 2; 13237 verifyFormat( 13238 "SomeClass::Constructor()\n" 13239 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13240 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13241 Style); 13242 13243 Style.ConstructorInitializerIndentWidth = 0; 13244 verifyFormat( 13245 "SomeClass::Constructor()\n" 13246 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13247 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13248 Style); 13249 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 13250 verifyFormat( 13251 "SomeLongTemplateVariableName<\n" 13252 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 13253 Style); 13254 verifyFormat("bool smaller = 1 < " 13255 "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 13256 " " 13257 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 13258 Style); 13259 13260 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 13261 verifyFormat("SomeClass::Constructor() :\n" 13262 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 13263 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 13264 Style); 13265 } 13266 13267 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 13268 FormatStyle Style = getLLVMStyle(); 13269 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 13270 Style.ConstructorInitializerIndentWidth = 4; 13271 verifyFormat("SomeClass::Constructor()\n" 13272 " : a(a)\n" 13273 " , b(b)\n" 13274 " , c(c) {}", 13275 Style); 13276 verifyFormat("SomeClass::Constructor()\n" 13277 " : a(a) {}", 13278 Style); 13279 13280 Style.ColumnLimit = 0; 13281 verifyFormat("SomeClass::Constructor()\n" 13282 " : a(a) {}", 13283 Style); 13284 verifyFormat("SomeClass::Constructor() noexcept\n" 13285 " : a(a) {}", 13286 Style); 13287 verifyFormat("SomeClass::Constructor()\n" 13288 " : a(a)\n" 13289 " , b(b)\n" 13290 " , c(c) {}", 13291 Style); 13292 verifyFormat("SomeClass::Constructor()\n" 13293 " : a(a) {\n" 13294 " foo();\n" 13295 " bar();\n" 13296 "}", 13297 Style); 13298 13299 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 13300 verifyFormat("SomeClass::Constructor()\n" 13301 " : a(a)\n" 13302 " , b(b)\n" 13303 " , c(c) {\n}", 13304 Style); 13305 verifyFormat("SomeClass::Constructor()\n" 13306 " : a(a) {\n}", 13307 Style); 13308 13309 Style.ColumnLimit = 80; 13310 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 13311 Style.ConstructorInitializerIndentWidth = 2; 13312 verifyFormat("SomeClass::Constructor()\n" 13313 " : a(a)\n" 13314 " , b(b)\n" 13315 " , c(c) {}", 13316 Style); 13317 13318 Style.ConstructorInitializerIndentWidth = 0; 13319 verifyFormat("SomeClass::Constructor()\n" 13320 ": a(a)\n" 13321 ", b(b)\n" 13322 ", c(c) {}", 13323 Style); 13324 13325 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 13326 Style.ConstructorInitializerIndentWidth = 4; 13327 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 13328 verifyFormat( 13329 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 13330 Style); 13331 verifyFormat( 13332 "SomeClass::Constructor()\n" 13333 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 13334 Style); 13335 Style.ConstructorInitializerIndentWidth = 4; 13336 Style.ColumnLimit = 60; 13337 verifyFormat("SomeClass::Constructor()\n" 13338 " : aaaaaaaa(aaaaaaaa)\n" 13339 " , aaaaaaaa(aaaaaaaa)\n" 13340 " , aaaaaaaa(aaaaaaaa) {}", 13341 Style); 13342 } 13343 13344 TEST_F(FormatTest, Destructors) { 13345 verifyFormat("void F(int &i) { i.~int(); }"); 13346 verifyFormat("void F(int &i) { i->~int(); }"); 13347 } 13348 13349 TEST_F(FormatTest, FormatsWithWebKitStyle) { 13350 FormatStyle Style = getWebKitStyle(); 13351 13352 // Don't indent in outer namespaces. 13353 verifyFormat("namespace outer {\n" 13354 "int i;\n" 13355 "namespace inner {\n" 13356 " int i;\n" 13357 "} // namespace inner\n" 13358 "} // namespace outer\n" 13359 "namespace other_outer {\n" 13360 "int i;\n" 13361 "}", 13362 Style); 13363 13364 // Don't indent case labels. 13365 verifyFormat("switch (variable) {\n" 13366 "case 1:\n" 13367 "case 2:\n" 13368 " doSomething();\n" 13369 " break;\n" 13370 "default:\n" 13371 " ++variable;\n" 13372 "}", 13373 Style); 13374 13375 // Wrap before binary operators. 13376 EXPECT_EQ("void f()\n" 13377 "{\n" 13378 " if (aaaaaaaaaaaaaaaa\n" 13379 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 13380 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13381 " return;\n" 13382 "}", 13383 format("void f() {\n" 13384 "if (aaaaaaaaaaaaaaaa\n" 13385 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 13386 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13387 "return;\n" 13388 "}", 13389 Style)); 13390 13391 // Allow functions on a single line. 13392 verifyFormat("void f() { return; }", Style); 13393 13394 // Allow empty blocks on a single line and insert a space in empty blocks. 13395 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 13396 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 13397 // However, don't merge non-empty short loops. 13398 EXPECT_EQ("while (true) {\n" 13399 " continue;\n" 13400 "}", 13401 format("while (true) { continue; }", Style)); 13402 13403 // Constructor initializers are formatted one per line with the "," on the 13404 // new line. 13405 verifyFormat("Constructor()\n" 13406 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 13407 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 13408 " aaaaaaaaaaaaaa)\n" 13409 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 13410 "{\n" 13411 "}", 13412 Style); 13413 verifyFormat("SomeClass::Constructor()\n" 13414 " : a(a)\n" 13415 "{\n" 13416 "}", 13417 Style); 13418 EXPECT_EQ("SomeClass::Constructor()\n" 13419 " : a(a)\n" 13420 "{\n" 13421 "}", 13422 format("SomeClass::Constructor():a(a){}", Style)); 13423 verifyFormat("SomeClass::Constructor()\n" 13424 " : a(a)\n" 13425 " , b(b)\n" 13426 " , c(c)\n" 13427 "{\n" 13428 "}", 13429 Style); 13430 verifyFormat("SomeClass::Constructor()\n" 13431 " : a(a)\n" 13432 "{\n" 13433 " foo();\n" 13434 " bar();\n" 13435 "}", 13436 Style); 13437 13438 // Access specifiers should be aligned left. 13439 verifyFormat("class C {\n" 13440 "public:\n" 13441 " int i;\n" 13442 "};", 13443 Style); 13444 13445 // Do not align comments. 13446 verifyFormat("int a; // Do not\n" 13447 "double b; // align comments.", 13448 Style); 13449 13450 // Do not align operands. 13451 EXPECT_EQ("ASSERT(aaaa\n" 13452 " || bbbb);", 13453 format("ASSERT ( aaaa\n||bbbb);", Style)); 13454 13455 // Accept input's line breaks. 13456 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 13457 " || bbbbbbbbbbbbbbb) {\n" 13458 " i++;\n" 13459 "}", 13460 format("if (aaaaaaaaaaaaaaa\n" 13461 "|| bbbbbbbbbbbbbbb) { i++; }", 13462 Style)); 13463 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 13464 " i++;\n" 13465 "}", 13466 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 13467 13468 // Don't automatically break all macro definitions (llvm.org/PR17842). 13469 verifyFormat("#define aNumber 10", Style); 13470 // However, generally keep the line breaks that the user authored. 13471 EXPECT_EQ("#define aNumber \\\n" 13472 " 10", 13473 format("#define aNumber \\\n" 13474 " 10", 13475 Style)); 13476 13477 // Keep empty and one-element array literals on a single line. 13478 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 13479 " copyItems:YES];", 13480 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 13481 "copyItems:YES];", 13482 Style)); 13483 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 13484 " copyItems:YES];", 13485 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 13486 " copyItems:YES];", 13487 Style)); 13488 // FIXME: This does not seem right, there should be more indentation before 13489 // the array literal's entries. Nested blocks have the same problem. 13490 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13491 " @\"a\",\n" 13492 " @\"a\"\n" 13493 "]\n" 13494 " copyItems:YES];", 13495 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13496 " @\"a\",\n" 13497 " @\"a\"\n" 13498 " ]\n" 13499 " copyItems:YES];", 13500 Style)); 13501 EXPECT_EQ( 13502 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13503 " copyItems:YES];", 13504 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13505 " copyItems:YES];", 13506 Style)); 13507 13508 verifyFormat("[self.a b:c c:d];", Style); 13509 EXPECT_EQ("[self.a b:c\n" 13510 " c:d];", 13511 format("[self.a b:c\n" 13512 "c:d];", 13513 Style)); 13514 } 13515 13516 TEST_F(FormatTest, FormatsLambdas) { 13517 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 13518 verifyFormat( 13519 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 13520 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 13521 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 13522 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 13523 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 13524 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 13525 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 13526 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 13527 verifyFormat("int x = f(*+[] {});"); 13528 verifyFormat("void f() {\n" 13529 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 13530 "}\n"); 13531 verifyFormat("void f() {\n" 13532 " other(x.begin(), //\n" 13533 " x.end(), //\n" 13534 " [&](int, int) { return 1; });\n" 13535 "}\n"); 13536 verifyFormat("void f() {\n" 13537 " other.other.other.other.other(\n" 13538 " x.begin(), x.end(),\n" 13539 " [something, rather](int, int, int, int, int, int, int) { " 13540 "return 1; });\n" 13541 "}\n"); 13542 verifyFormat( 13543 "void f() {\n" 13544 " other.other.other.other.other(\n" 13545 " x.begin(), x.end(),\n" 13546 " [something, rather](int, int, int, int, int, int, int) {\n" 13547 " //\n" 13548 " });\n" 13549 "}\n"); 13550 verifyFormat("SomeFunction([]() { // A cool function...\n" 13551 " return 43;\n" 13552 "});"); 13553 EXPECT_EQ("SomeFunction([]() {\n" 13554 "#define A a\n" 13555 " return 43;\n" 13556 "});", 13557 format("SomeFunction([](){\n" 13558 "#define A a\n" 13559 "return 43;\n" 13560 "});")); 13561 verifyFormat("void f() {\n" 13562 " SomeFunction([](decltype(x), A *a) {});\n" 13563 "}"); 13564 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13565 " [](const aaaaaaaaaa &a) { return a; });"); 13566 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 13567 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 13568 "});"); 13569 verifyFormat("Constructor()\n" 13570 " : Field([] { // comment\n" 13571 " int i;\n" 13572 " }) {}"); 13573 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 13574 " return some_parameter.size();\n" 13575 "};"); 13576 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 13577 " [](const string &s) { return s; };"); 13578 verifyFormat("int i = aaaaaa ? 1 //\n" 13579 " : [] {\n" 13580 " return 2; //\n" 13581 " }();"); 13582 verifyFormat("llvm::errs() << \"number of twos is \"\n" 13583 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 13584 " return x == 2; // force break\n" 13585 " });"); 13586 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13587 " [=](int iiiiiiiiiiii) {\n" 13588 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 13589 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 13590 " });", 13591 getLLVMStyleWithColumns(60)); 13592 verifyFormat("SomeFunction({[&] {\n" 13593 " // comment\n" 13594 " },\n" 13595 " [&] {\n" 13596 " // comment\n" 13597 " }});"); 13598 verifyFormat("SomeFunction({[&] {\n" 13599 " // comment\n" 13600 "}});"); 13601 verifyFormat( 13602 "virtual aaaaaaaaaaaaaaaa(\n" 13603 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 13604 " aaaaa aaaaaaaaa);"); 13605 13606 // Lambdas with return types. 13607 verifyFormat("int c = []() -> int { return 2; }();\n"); 13608 verifyFormat("int c = []() -> int * { return 2; }();\n"); 13609 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 13610 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 13611 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 13612 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 13613 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 13614 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 13615 verifyFormat("[a, a]() -> a<1> {};"); 13616 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 13617 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 13618 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 13619 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 13620 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 13621 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 13622 verifyFormat("[]() -> foo<!5> { return {}; };"); 13623 verifyFormat("[]() -> foo<~5> { return {}; };"); 13624 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 13625 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 13626 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 13627 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 13628 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 13629 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 13630 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 13631 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 13632 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 13633 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 13634 verifyFormat("namespace bar {\n" 13635 "// broken:\n" 13636 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 13637 "} // namespace bar"); 13638 verifyFormat("namespace bar {\n" 13639 "// broken:\n" 13640 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 13641 "} // namespace bar"); 13642 verifyFormat("namespace bar {\n" 13643 "// broken:\n" 13644 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 13645 "} // namespace bar"); 13646 verifyFormat("namespace bar {\n" 13647 "// broken:\n" 13648 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 13649 "} // namespace bar"); 13650 verifyFormat("namespace bar {\n" 13651 "// broken:\n" 13652 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 13653 "} // namespace bar"); 13654 verifyFormat("namespace bar {\n" 13655 "// broken:\n" 13656 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 13657 "} // namespace bar"); 13658 verifyFormat("namespace bar {\n" 13659 "// broken:\n" 13660 "auto foo{[]() -> foo<!5> { return {}; }};\n" 13661 "} // namespace bar"); 13662 verifyFormat("namespace bar {\n" 13663 "// broken:\n" 13664 "auto foo{[]() -> foo<~5> { return {}; }};\n" 13665 "} // namespace bar"); 13666 verifyFormat("namespace bar {\n" 13667 "// broken:\n" 13668 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 13669 "} // namespace bar"); 13670 verifyFormat("namespace bar {\n" 13671 "// broken:\n" 13672 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 13673 "} // namespace bar"); 13674 verifyFormat("namespace bar {\n" 13675 "// broken:\n" 13676 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 13677 "} // namespace bar"); 13678 verifyFormat("namespace bar {\n" 13679 "// broken:\n" 13680 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 13681 "} // namespace bar"); 13682 verifyFormat("namespace bar {\n" 13683 "// broken:\n" 13684 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 13685 "} // namespace bar"); 13686 verifyFormat("namespace bar {\n" 13687 "// broken:\n" 13688 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 13689 "} // namespace bar"); 13690 verifyFormat("namespace bar {\n" 13691 "// broken:\n" 13692 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 13693 "} // namespace bar"); 13694 verifyFormat("namespace bar {\n" 13695 "// broken:\n" 13696 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 13697 "} // namespace bar"); 13698 verifyFormat("namespace bar {\n" 13699 "// broken:\n" 13700 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 13701 "} // namespace bar"); 13702 verifyFormat("namespace bar {\n" 13703 "// broken:\n" 13704 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 13705 "} // namespace bar"); 13706 verifyFormat("[]() -> a<1> {};"); 13707 verifyFormat("[]() -> a<1> { ; };"); 13708 verifyFormat("[]() -> a<1> { ; }();"); 13709 verifyFormat("[a, a]() -> a<true> {};"); 13710 verifyFormat("[]() -> a<true> {};"); 13711 verifyFormat("[]() -> a<true> { ; };"); 13712 verifyFormat("[]() -> a<true> { ; }();"); 13713 verifyFormat("[a, a]() -> a<false> {};"); 13714 verifyFormat("[]() -> a<false> {};"); 13715 verifyFormat("[]() -> a<false> { ; };"); 13716 verifyFormat("[]() -> a<false> { ; }();"); 13717 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 13718 verifyFormat("namespace bar {\n" 13719 "auto foo{[]() -> foo<false> { ; }};\n" 13720 "} // namespace bar"); 13721 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 13722 " int j) -> int {\n" 13723 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 13724 "};"); 13725 verifyFormat( 13726 "aaaaaaaaaaaaaaaaaaaaaa(\n" 13727 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 13728 " return aaaaaaaaaaaaaaaaa;\n" 13729 " });", 13730 getLLVMStyleWithColumns(70)); 13731 verifyFormat("[]() //\n" 13732 " -> int {\n" 13733 " return 1; //\n" 13734 "};"); 13735 13736 // Lambdas with explicit template argument lists. 13737 verifyFormat( 13738 "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n"); 13739 13740 // Multiple lambdas in the same parentheses change indentation rules. These 13741 // lambdas are forced to start on new lines. 13742 verifyFormat("SomeFunction(\n" 13743 " []() {\n" 13744 " //\n" 13745 " },\n" 13746 " []() {\n" 13747 " //\n" 13748 " });"); 13749 13750 // A lambda passed as arg0 is always pushed to the next line. 13751 verifyFormat("SomeFunction(\n" 13752 " [this] {\n" 13753 " //\n" 13754 " },\n" 13755 " 1);\n"); 13756 13757 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like 13758 // the arg0 case above. 13759 auto Style = getGoogleStyle(); 13760 Style.BinPackArguments = false; 13761 verifyFormat("SomeFunction(\n" 13762 " a,\n" 13763 " [this] {\n" 13764 " //\n" 13765 " },\n" 13766 " b);\n", 13767 Style); 13768 verifyFormat("SomeFunction(\n" 13769 " a,\n" 13770 " [this] {\n" 13771 " //\n" 13772 " },\n" 13773 " b);\n"); 13774 13775 // A lambda with a very long line forces arg0 to be pushed out irrespective of 13776 // the BinPackArguments value (as long as the code is wide enough). 13777 verifyFormat( 13778 "something->SomeFunction(\n" 13779 " a,\n" 13780 " [this] {\n" 13781 " " 13782 "D0000000000000000000000000000000000000000000000000000000000001();\n" 13783 " },\n" 13784 " b);\n"); 13785 13786 // A multi-line lambda is pulled up as long as the introducer fits on the 13787 // previous line and there are no further args. 13788 verifyFormat("function(1, [this, that] {\n" 13789 " //\n" 13790 "});\n"); 13791 verifyFormat("function([this, that] {\n" 13792 " //\n" 13793 "});\n"); 13794 // FIXME: this format is not ideal and we should consider forcing the first 13795 // arg onto its own line. 13796 verifyFormat("function(a, b, c, //\n" 13797 " d, [this, that] {\n" 13798 " //\n" 13799 " });\n"); 13800 13801 // Multiple lambdas are treated correctly even when there is a short arg0. 13802 verifyFormat("SomeFunction(\n" 13803 " 1,\n" 13804 " [this] {\n" 13805 " //\n" 13806 " },\n" 13807 " [this] {\n" 13808 " //\n" 13809 " },\n" 13810 " 1);\n"); 13811 13812 // More complex introducers. 13813 verifyFormat("return [i, args...] {};"); 13814 13815 // Not lambdas. 13816 verifyFormat("constexpr char hello[]{\"hello\"};"); 13817 verifyFormat("double &operator[](int i) { return 0; }\n" 13818 "int i;"); 13819 verifyFormat("std::unique_ptr<int[]> foo() {}"); 13820 verifyFormat("int i = a[a][a]->f();"); 13821 verifyFormat("int i = (*b)[a]->f();"); 13822 13823 // Other corner cases. 13824 verifyFormat("void f() {\n" 13825 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 13826 " );\n" 13827 "}"); 13828 13829 // Lambdas created through weird macros. 13830 verifyFormat("void f() {\n" 13831 " MACRO((const AA &a) { return 1; });\n" 13832 " MACRO((AA &a) { return 1; });\n" 13833 "}"); 13834 13835 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 13836 " doo_dah();\n" 13837 " doo_dah();\n" 13838 " })) {\n" 13839 "}"); 13840 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 13841 " doo_dah();\n" 13842 " doo_dah();\n" 13843 " })) {\n" 13844 "}"); 13845 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n" 13846 " doo_dah();\n" 13847 " doo_dah();\n" 13848 " })) {\n" 13849 "}"); 13850 verifyFormat("auto lambda = []() {\n" 13851 " int a = 2\n" 13852 "#if A\n" 13853 " + 2\n" 13854 "#endif\n" 13855 " ;\n" 13856 "};"); 13857 13858 // Lambdas with complex multiline introducers. 13859 verifyFormat( 13860 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13861 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 13862 " -> ::std::unordered_set<\n" 13863 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 13864 " //\n" 13865 " });"); 13866 13867 FormatStyle DoNotMerge = getLLVMStyle(); 13868 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 13869 verifyFormat("auto c = []() {\n" 13870 " return b;\n" 13871 "};", 13872 "auto c = []() { return b; };", DoNotMerge); 13873 verifyFormat("auto c = []() {\n" 13874 "};", 13875 " auto c = []() {};", DoNotMerge); 13876 13877 FormatStyle MergeEmptyOnly = getLLVMStyle(); 13878 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 13879 verifyFormat("auto c = []() {\n" 13880 " return b;\n" 13881 "};", 13882 "auto c = []() {\n" 13883 " return b;\n" 13884 " };", 13885 MergeEmptyOnly); 13886 verifyFormat("auto c = []() {};", 13887 "auto c = []() {\n" 13888 "};", 13889 MergeEmptyOnly); 13890 13891 FormatStyle MergeInline = getLLVMStyle(); 13892 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 13893 verifyFormat("auto c = []() {\n" 13894 " return b;\n" 13895 "};", 13896 "auto c = []() { return b; };", MergeInline); 13897 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 13898 MergeInline); 13899 verifyFormat("function([]() { return b; }, a)", 13900 "function([]() { return b; }, a)", MergeInline); 13901 verifyFormat("function(a, []() { return b; })", 13902 "function(a, []() { return b; })", MergeInline); 13903 } 13904 13905 TEST_F(FormatTest, EmptyLinesInLambdas) { 13906 verifyFormat("auto lambda = []() {\n" 13907 " x(); //\n" 13908 "};", 13909 "auto lambda = []() {\n" 13910 "\n" 13911 " x(); //\n" 13912 "\n" 13913 "};"); 13914 } 13915 13916 TEST_F(FormatTest, FormatsBlocks) { 13917 FormatStyle ShortBlocks = getLLVMStyle(); 13918 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13919 verifyFormat("int (^Block)(int, int);", ShortBlocks); 13920 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 13921 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 13922 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 13923 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 13924 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 13925 13926 verifyFormat("foo(^{ bar(); });", ShortBlocks); 13927 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 13928 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 13929 13930 verifyFormat("[operation setCompletionBlock:^{\n" 13931 " [self onOperationDone];\n" 13932 "}];"); 13933 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 13934 " [self onOperationDone];\n" 13935 "}]};"); 13936 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 13937 " f();\n" 13938 "}];"); 13939 verifyFormat("int a = [operation block:^int(int *i) {\n" 13940 " return 1;\n" 13941 "}];"); 13942 verifyFormat("[myObject doSomethingWith:arg1\n" 13943 " aaa:^int(int *a) {\n" 13944 " return 1;\n" 13945 " }\n" 13946 " bbb:f(a * bbbbbbbb)];"); 13947 13948 verifyFormat("[operation setCompletionBlock:^{\n" 13949 " [self.delegate newDataAvailable];\n" 13950 "}];", 13951 getLLVMStyleWithColumns(60)); 13952 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 13953 " NSString *path = [self sessionFilePath];\n" 13954 " if (path) {\n" 13955 " // ...\n" 13956 " }\n" 13957 "});"); 13958 verifyFormat("[[SessionService sharedService]\n" 13959 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13960 " if (window) {\n" 13961 " [self windowDidLoad:window];\n" 13962 " } else {\n" 13963 " [self errorLoadingWindow];\n" 13964 " }\n" 13965 " }];"); 13966 verifyFormat("void (^largeBlock)(void) = ^{\n" 13967 " // ...\n" 13968 "};\n", 13969 getLLVMStyleWithColumns(40)); 13970 verifyFormat("[[SessionService sharedService]\n" 13971 " loadWindowWithCompletionBlock: //\n" 13972 " ^(SessionWindow *window) {\n" 13973 " if (window) {\n" 13974 " [self windowDidLoad:window];\n" 13975 " } else {\n" 13976 " [self errorLoadingWindow];\n" 13977 " }\n" 13978 " }];", 13979 getLLVMStyleWithColumns(60)); 13980 verifyFormat("[myObject doSomethingWith:arg1\n" 13981 " firstBlock:^(Foo *a) {\n" 13982 " // ...\n" 13983 " int i;\n" 13984 " }\n" 13985 " secondBlock:^(Bar *b) {\n" 13986 " // ...\n" 13987 " int i;\n" 13988 " }\n" 13989 " thirdBlock:^Foo(Bar *b) {\n" 13990 " // ...\n" 13991 " int i;\n" 13992 " }];"); 13993 verifyFormat("[myObject doSomethingWith:arg1\n" 13994 " firstBlock:-1\n" 13995 " secondBlock:^(Bar *b) {\n" 13996 " // ...\n" 13997 " int i;\n" 13998 " }];"); 13999 14000 verifyFormat("f(^{\n" 14001 " @autoreleasepool {\n" 14002 " if (a) {\n" 14003 " g();\n" 14004 " }\n" 14005 " }\n" 14006 "});"); 14007 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 14008 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 14009 "};"); 14010 14011 FormatStyle FourIndent = getLLVMStyle(); 14012 FourIndent.ObjCBlockIndentWidth = 4; 14013 verifyFormat("[operation setCompletionBlock:^{\n" 14014 " [self onOperationDone];\n" 14015 "}];", 14016 FourIndent); 14017 } 14018 14019 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 14020 FormatStyle ZeroColumn = getLLVMStyle(); 14021 ZeroColumn.ColumnLimit = 0; 14022 14023 verifyFormat("[[SessionService sharedService] " 14024 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14025 " if (window) {\n" 14026 " [self windowDidLoad:window];\n" 14027 " } else {\n" 14028 " [self errorLoadingWindow];\n" 14029 " }\n" 14030 "}];", 14031 ZeroColumn); 14032 EXPECT_EQ("[[SessionService sharedService]\n" 14033 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14034 " if (window) {\n" 14035 " [self windowDidLoad:window];\n" 14036 " } else {\n" 14037 " [self errorLoadingWindow];\n" 14038 " }\n" 14039 " }];", 14040 format("[[SessionService sharedService]\n" 14041 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14042 " if (window) {\n" 14043 " [self windowDidLoad:window];\n" 14044 " } else {\n" 14045 " [self errorLoadingWindow];\n" 14046 " }\n" 14047 "}];", 14048 ZeroColumn)); 14049 verifyFormat("[myObject doSomethingWith:arg1\n" 14050 " firstBlock:^(Foo *a) {\n" 14051 " // ...\n" 14052 " int i;\n" 14053 " }\n" 14054 " secondBlock:^(Bar *b) {\n" 14055 " // ...\n" 14056 " int i;\n" 14057 " }\n" 14058 " thirdBlock:^Foo(Bar *b) {\n" 14059 " // ...\n" 14060 " int i;\n" 14061 " }];", 14062 ZeroColumn); 14063 verifyFormat("f(^{\n" 14064 " @autoreleasepool {\n" 14065 " if (a) {\n" 14066 " g();\n" 14067 " }\n" 14068 " }\n" 14069 "});", 14070 ZeroColumn); 14071 verifyFormat("void (^largeBlock)(void) = ^{\n" 14072 " // ...\n" 14073 "};", 14074 ZeroColumn); 14075 14076 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 14077 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 14078 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 14079 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 14080 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 14081 " int i;\n" 14082 "};", 14083 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 14084 } 14085 14086 TEST_F(FormatTest, SupportsCRLF) { 14087 EXPECT_EQ("int a;\r\n" 14088 "int b;\r\n" 14089 "int c;\r\n", 14090 format("int a;\r\n" 14091 " int b;\r\n" 14092 " int c;\r\n", 14093 getLLVMStyle())); 14094 EXPECT_EQ("int a;\r\n" 14095 "int b;\r\n" 14096 "int c;\r\n", 14097 format("int a;\r\n" 14098 " int b;\n" 14099 " int c;\r\n", 14100 getLLVMStyle())); 14101 EXPECT_EQ("int a;\n" 14102 "int b;\n" 14103 "int c;\n", 14104 format("int a;\r\n" 14105 " int b;\n" 14106 " int c;\n", 14107 getLLVMStyle())); 14108 EXPECT_EQ("\"aaaaaaa \"\r\n" 14109 "\"bbbbbbb\";\r\n", 14110 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 14111 EXPECT_EQ("#define A \\\r\n" 14112 " b; \\\r\n" 14113 " c; \\\r\n" 14114 " d;\r\n", 14115 format("#define A \\\r\n" 14116 " b; \\\r\n" 14117 " c; d; \r\n", 14118 getGoogleStyle())); 14119 14120 EXPECT_EQ("/*\r\n" 14121 "multi line block comments\r\n" 14122 "should not introduce\r\n" 14123 "an extra carriage return\r\n" 14124 "*/\r\n", 14125 format("/*\r\n" 14126 "multi line block comments\r\n" 14127 "should not introduce\r\n" 14128 "an extra carriage return\r\n" 14129 "*/\r\n")); 14130 EXPECT_EQ("/*\r\n" 14131 "\r\n" 14132 "*/", 14133 format("/*\r\n" 14134 " \r\r\r\n" 14135 "*/")); 14136 14137 FormatStyle style = getLLVMStyle(); 14138 14139 style.DeriveLineEnding = true; 14140 style.UseCRLF = false; 14141 EXPECT_EQ("union FooBarBazQux {\n" 14142 " int foo;\n" 14143 " int bar;\n" 14144 " int baz;\n" 14145 "};", 14146 format("union FooBarBazQux {\r\n" 14147 " int foo;\n" 14148 " int bar;\r\n" 14149 " int baz;\n" 14150 "};", 14151 style)); 14152 style.UseCRLF = true; 14153 EXPECT_EQ("union FooBarBazQux {\r\n" 14154 " int foo;\r\n" 14155 " int bar;\r\n" 14156 " int baz;\r\n" 14157 "};", 14158 format("union FooBarBazQux {\r\n" 14159 " int foo;\n" 14160 " int bar;\r\n" 14161 " int baz;\n" 14162 "};", 14163 style)); 14164 14165 style.DeriveLineEnding = false; 14166 style.UseCRLF = false; 14167 EXPECT_EQ("union FooBarBazQux {\n" 14168 " int foo;\n" 14169 " int bar;\n" 14170 " int baz;\n" 14171 " int qux;\n" 14172 "};", 14173 format("union FooBarBazQux {\r\n" 14174 " int foo;\n" 14175 " int bar;\r\n" 14176 " int baz;\n" 14177 " int qux;\r\n" 14178 "};", 14179 style)); 14180 style.UseCRLF = true; 14181 EXPECT_EQ("union FooBarBazQux {\r\n" 14182 " int foo;\r\n" 14183 " int bar;\r\n" 14184 " int baz;\r\n" 14185 " int qux;\r\n" 14186 "};", 14187 format("union FooBarBazQux {\r\n" 14188 " int foo;\n" 14189 " int bar;\r\n" 14190 " int baz;\n" 14191 " int qux;\n" 14192 "};", 14193 style)); 14194 14195 style.DeriveLineEnding = true; 14196 style.UseCRLF = false; 14197 EXPECT_EQ("union FooBarBazQux {\r\n" 14198 " int foo;\r\n" 14199 " int bar;\r\n" 14200 " int baz;\r\n" 14201 " int qux;\r\n" 14202 "};", 14203 format("union FooBarBazQux {\r\n" 14204 " int foo;\n" 14205 " int bar;\r\n" 14206 " int baz;\n" 14207 " int qux;\r\n" 14208 "};", 14209 style)); 14210 style.UseCRLF = true; 14211 EXPECT_EQ("union FooBarBazQux {\n" 14212 " int foo;\n" 14213 " int bar;\n" 14214 " int baz;\n" 14215 " int qux;\n" 14216 "};", 14217 format("union FooBarBazQux {\r\n" 14218 " int foo;\n" 14219 " int bar;\r\n" 14220 " int baz;\n" 14221 " int qux;\n" 14222 "};", 14223 style)); 14224 } 14225 14226 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 14227 verifyFormat("MY_CLASS(C) {\n" 14228 " int i;\n" 14229 " int j;\n" 14230 "};"); 14231 } 14232 14233 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 14234 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 14235 TwoIndent.ContinuationIndentWidth = 2; 14236 14237 EXPECT_EQ("int i =\n" 14238 " longFunction(\n" 14239 " arg);", 14240 format("int i = longFunction(arg);", TwoIndent)); 14241 14242 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 14243 SixIndent.ContinuationIndentWidth = 6; 14244 14245 EXPECT_EQ("int i =\n" 14246 " longFunction(\n" 14247 " arg);", 14248 format("int i = longFunction(arg);", SixIndent)); 14249 } 14250 14251 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 14252 FormatStyle Style = getLLVMStyle(); 14253 verifyFormat("int Foo::getter(\n" 14254 " //\n" 14255 ") const {\n" 14256 " return foo;\n" 14257 "}", 14258 Style); 14259 verifyFormat("void Foo::setter(\n" 14260 " //\n" 14261 ") {\n" 14262 " foo = 1;\n" 14263 "}", 14264 Style); 14265 } 14266 14267 TEST_F(FormatTest, SpacesInAngles) { 14268 FormatStyle Spaces = getLLVMStyle(); 14269 Spaces.SpacesInAngles = true; 14270 14271 verifyFormat("static_cast< int >(arg);", Spaces); 14272 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 14273 verifyFormat("f< int, float >();", Spaces); 14274 verifyFormat("template <> g() {}", Spaces); 14275 verifyFormat("template < std::vector< int > > f() {}", Spaces); 14276 verifyFormat("std::function< void(int, int) > fct;", Spaces); 14277 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 14278 Spaces); 14279 14280 Spaces.Standard = FormatStyle::LS_Cpp03; 14281 Spaces.SpacesInAngles = true; 14282 verifyFormat("A< A< int > >();", Spaces); 14283 14284 Spaces.SpacesInAngles = false; 14285 verifyFormat("A<A<int> >();", Spaces); 14286 14287 Spaces.Standard = FormatStyle::LS_Cpp11; 14288 Spaces.SpacesInAngles = true; 14289 verifyFormat("A< A< int > >();", Spaces); 14290 14291 Spaces.SpacesInAngles = false; 14292 verifyFormat("A<A<int>>();", Spaces); 14293 } 14294 14295 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 14296 FormatStyle Style = getLLVMStyle(); 14297 Style.SpaceAfterTemplateKeyword = false; 14298 verifyFormat("template<int> void foo();", Style); 14299 } 14300 14301 TEST_F(FormatTest, TripleAngleBrackets) { 14302 verifyFormat("f<<<1, 1>>>();"); 14303 verifyFormat("f<<<1, 1, 1, s>>>();"); 14304 verifyFormat("f<<<a, b, c, d>>>();"); 14305 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 14306 verifyFormat("f<param><<<1, 1>>>();"); 14307 verifyFormat("f<1><<<1, 1>>>();"); 14308 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 14309 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14310 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 14311 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 14312 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 14313 } 14314 14315 TEST_F(FormatTest, MergeLessLessAtEnd) { 14316 verifyFormat("<<"); 14317 EXPECT_EQ("< < <", format("\\\n<<<")); 14318 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14319 "aaallvm::outs() <<"); 14320 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14321 "aaaallvm::outs()\n <<"); 14322 } 14323 14324 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 14325 std::string code = "#if A\n" 14326 "#if B\n" 14327 "a.\n" 14328 "#endif\n" 14329 " a = 1;\n" 14330 "#else\n" 14331 "#endif\n" 14332 "#if C\n" 14333 "#else\n" 14334 "#endif\n"; 14335 EXPECT_EQ(code, format(code)); 14336 } 14337 14338 TEST_F(FormatTest, HandleConflictMarkers) { 14339 // Git/SVN conflict markers. 14340 EXPECT_EQ("int a;\n" 14341 "void f() {\n" 14342 " callme(some(parameter1,\n" 14343 "<<<<<<< text by the vcs\n" 14344 " parameter2),\n" 14345 "||||||| text by the vcs\n" 14346 " parameter2),\n" 14347 " parameter3,\n" 14348 "======= text by the vcs\n" 14349 " parameter2, parameter3),\n" 14350 ">>>>>>> text by the vcs\n" 14351 " otherparameter);\n", 14352 format("int a;\n" 14353 "void f() {\n" 14354 " callme(some(parameter1,\n" 14355 "<<<<<<< text by the vcs\n" 14356 " parameter2),\n" 14357 "||||||| text by the vcs\n" 14358 " parameter2),\n" 14359 " parameter3,\n" 14360 "======= text by the vcs\n" 14361 " parameter2,\n" 14362 " parameter3),\n" 14363 ">>>>>>> text by the vcs\n" 14364 " otherparameter);\n")); 14365 14366 // Perforce markers. 14367 EXPECT_EQ("void f() {\n" 14368 " function(\n" 14369 ">>>> text by the vcs\n" 14370 " parameter,\n" 14371 "==== text by the vcs\n" 14372 " parameter,\n" 14373 "==== text by the vcs\n" 14374 " parameter,\n" 14375 "<<<< text by the vcs\n" 14376 " parameter);\n", 14377 format("void f() {\n" 14378 " function(\n" 14379 ">>>> text by the vcs\n" 14380 " parameter,\n" 14381 "==== text by the vcs\n" 14382 " parameter,\n" 14383 "==== text by the vcs\n" 14384 " parameter,\n" 14385 "<<<< text by the vcs\n" 14386 " parameter);\n")); 14387 14388 EXPECT_EQ("<<<<<<<\n" 14389 "|||||||\n" 14390 "=======\n" 14391 ">>>>>>>", 14392 format("<<<<<<<\n" 14393 "|||||||\n" 14394 "=======\n" 14395 ">>>>>>>")); 14396 14397 EXPECT_EQ("<<<<<<<\n" 14398 "|||||||\n" 14399 "int i;\n" 14400 "=======\n" 14401 ">>>>>>>", 14402 format("<<<<<<<\n" 14403 "|||||||\n" 14404 "int i;\n" 14405 "=======\n" 14406 ">>>>>>>")); 14407 14408 // FIXME: Handle parsing of macros around conflict markers correctly: 14409 EXPECT_EQ("#define Macro \\\n" 14410 "<<<<<<<\n" 14411 "Something \\\n" 14412 "|||||||\n" 14413 "Else \\\n" 14414 "=======\n" 14415 "Other \\\n" 14416 ">>>>>>>\n" 14417 " End int i;\n", 14418 format("#define Macro \\\n" 14419 "<<<<<<<\n" 14420 " Something \\\n" 14421 "|||||||\n" 14422 " Else \\\n" 14423 "=======\n" 14424 " Other \\\n" 14425 ">>>>>>>\n" 14426 " End\n" 14427 "int i;\n")); 14428 } 14429 14430 TEST_F(FormatTest, DisableRegions) { 14431 EXPECT_EQ("int i;\n" 14432 "// clang-format off\n" 14433 " int j;\n" 14434 "// clang-format on\n" 14435 "int k;", 14436 format(" int i;\n" 14437 " // clang-format off\n" 14438 " int j;\n" 14439 " // clang-format on\n" 14440 " int k;")); 14441 EXPECT_EQ("int i;\n" 14442 "/* clang-format off */\n" 14443 " int j;\n" 14444 "/* clang-format on */\n" 14445 "int k;", 14446 format(" int i;\n" 14447 " /* clang-format off */\n" 14448 " int j;\n" 14449 " /* clang-format on */\n" 14450 " int k;")); 14451 14452 // Don't reflow comments within disabled regions. 14453 EXPECT_EQ("// clang-format off\n" 14454 "// long long long long long long line\n" 14455 "/* clang-format on */\n" 14456 "/* long long long\n" 14457 " * long long long\n" 14458 " * line */\n" 14459 "int i;\n" 14460 "/* clang-format off */\n" 14461 "/* long long long long long long line */\n", 14462 format("// clang-format off\n" 14463 "// long long long long long long line\n" 14464 "/* clang-format on */\n" 14465 "/* long long long long long long line */\n" 14466 "int i;\n" 14467 "/* clang-format off */\n" 14468 "/* long long long long long long line */\n", 14469 getLLVMStyleWithColumns(20))); 14470 } 14471 14472 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 14473 format("? ) ="); 14474 verifyNoCrash("#define a\\\n /**/}"); 14475 } 14476 14477 TEST_F(FormatTest, FormatsTableGenCode) { 14478 FormatStyle Style = getLLVMStyle(); 14479 Style.Language = FormatStyle::LK_TableGen; 14480 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 14481 } 14482 14483 TEST_F(FormatTest, ArrayOfTemplates) { 14484 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 14485 format("auto a = new unique_ptr<int > [ 10];")); 14486 14487 FormatStyle Spaces = getLLVMStyle(); 14488 Spaces.SpacesInSquareBrackets = true; 14489 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 14490 format("auto a = new unique_ptr<int > [10];", Spaces)); 14491 } 14492 14493 TEST_F(FormatTest, ArrayAsTemplateType) { 14494 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 14495 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 14496 14497 FormatStyle Spaces = getLLVMStyle(); 14498 Spaces.SpacesInSquareBrackets = true; 14499 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 14500 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 14501 } 14502 14503 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); } 14504 14505 TEST(FormatStyle, GetStyleWithEmptyFileName) { 14506 llvm::vfs::InMemoryFileSystem FS; 14507 auto Style1 = getStyle("file", "", "Google", "", &FS); 14508 ASSERT_TRUE((bool)Style1); 14509 ASSERT_EQ(*Style1, getGoogleStyle()); 14510 } 14511 14512 TEST(FormatStyle, GetStyleOfFile) { 14513 llvm::vfs::InMemoryFileSystem FS; 14514 // Test 1: format file in the same directory. 14515 ASSERT_TRUE( 14516 FS.addFile("/a/.clang-format", 0, 14517 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 14518 ASSERT_TRUE( 14519 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14520 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 14521 ASSERT_TRUE((bool)Style1); 14522 ASSERT_EQ(*Style1, getLLVMStyle()); 14523 14524 // Test 2.1: fallback to default. 14525 ASSERT_TRUE( 14526 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14527 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 14528 ASSERT_TRUE((bool)Style2); 14529 ASSERT_EQ(*Style2, getMozillaStyle()); 14530 14531 // Test 2.2: no format on 'none' fallback style. 14532 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 14533 ASSERT_TRUE((bool)Style2); 14534 ASSERT_EQ(*Style2, getNoStyle()); 14535 14536 // Test 2.3: format if config is found with no based style while fallback is 14537 // 'none'. 14538 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 14539 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 14540 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 14541 ASSERT_TRUE((bool)Style2); 14542 ASSERT_EQ(*Style2, getLLVMStyle()); 14543 14544 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 14545 Style2 = getStyle("{}", "a.h", "none", "", &FS); 14546 ASSERT_TRUE((bool)Style2); 14547 ASSERT_EQ(*Style2, getLLVMStyle()); 14548 14549 // Test 3: format file in parent directory. 14550 ASSERT_TRUE( 14551 FS.addFile("/c/.clang-format", 0, 14552 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 14553 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 14554 llvm::MemoryBuffer::getMemBuffer("int i;"))); 14555 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 14556 ASSERT_TRUE((bool)Style3); 14557 ASSERT_EQ(*Style3, getGoogleStyle()); 14558 14559 // Test 4: error on invalid fallback style 14560 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 14561 ASSERT_FALSE((bool)Style4); 14562 llvm::consumeError(Style4.takeError()); 14563 14564 // Test 5: error on invalid yaml on command line 14565 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 14566 ASSERT_FALSE((bool)Style5); 14567 llvm::consumeError(Style5.takeError()); 14568 14569 // Test 6: error on invalid style 14570 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 14571 ASSERT_FALSE((bool)Style6); 14572 llvm::consumeError(Style6.takeError()); 14573 14574 // Test 7: found config file, error on parsing it 14575 ASSERT_TRUE( 14576 FS.addFile("/d/.clang-format", 0, 14577 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 14578 "InvalidKey: InvalidValue"))); 14579 ASSERT_TRUE( 14580 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14581 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 14582 ASSERT_FALSE((bool)Style7); 14583 llvm::consumeError(Style7.takeError()); 14584 14585 // Test 8: inferred per-language defaults apply. 14586 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 14587 ASSERT_TRUE((bool)StyleTd); 14588 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 14589 } 14590 14591 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 14592 // Column limit is 20. 14593 std::string Code = "Type *a =\n" 14594 " new Type();\n" 14595 "g(iiiii, 0, jjjjj,\n" 14596 " 0, kkkkk, 0, mm);\n" 14597 "int bad = format ;"; 14598 std::string Expected = "auto a = new Type();\n" 14599 "g(iiiii, nullptr,\n" 14600 " jjjjj, nullptr,\n" 14601 " kkkkk, nullptr,\n" 14602 " mm);\n" 14603 "int bad = format ;"; 14604 FileID ID = Context.createInMemoryFile("format.cpp", Code); 14605 tooling::Replacements Replaces = toReplacements( 14606 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 14607 "auto "), 14608 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 14609 "nullptr"), 14610 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 14611 "nullptr"), 14612 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 14613 "nullptr")}); 14614 14615 format::FormatStyle Style = format::getLLVMStyle(); 14616 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 14617 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 14618 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 14619 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 14620 auto Result = applyAllReplacements(Code, *FormattedReplaces); 14621 EXPECT_TRUE(static_cast<bool>(Result)); 14622 EXPECT_EQ(Expected, *Result); 14623 } 14624 14625 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 14626 std::string Code = "#include \"a.h\"\n" 14627 "#include \"c.h\"\n" 14628 "\n" 14629 "int main() {\n" 14630 " return 0;\n" 14631 "}"; 14632 std::string Expected = "#include \"a.h\"\n" 14633 "#include \"b.h\"\n" 14634 "#include \"c.h\"\n" 14635 "\n" 14636 "int main() {\n" 14637 " return 0;\n" 14638 "}"; 14639 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 14640 tooling::Replacements Replaces = toReplacements( 14641 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 14642 "#include \"b.h\"\n")}); 14643 14644 format::FormatStyle Style = format::getLLVMStyle(); 14645 Style.SortIncludes = true; 14646 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 14647 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 14648 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 14649 auto Result = applyAllReplacements(Code, *FormattedReplaces); 14650 EXPECT_TRUE(static_cast<bool>(Result)); 14651 EXPECT_EQ(Expected, *Result); 14652 } 14653 14654 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 14655 EXPECT_EQ("using std::cin;\n" 14656 "using std::cout;", 14657 format("using std::cout;\n" 14658 "using std::cin;", 14659 getGoogleStyle())); 14660 } 14661 14662 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 14663 format::FormatStyle Style = format::getLLVMStyle(); 14664 Style.Standard = FormatStyle::LS_Cpp03; 14665 // cpp03 recognize this string as identifier u8 and literal character 'a' 14666 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 14667 } 14668 14669 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 14670 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 14671 // all modes, including C++11, C++14 and C++17 14672 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 14673 } 14674 14675 TEST_F(FormatTest, DoNotFormatLikelyXml) { 14676 EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle())); 14677 EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle())); 14678 } 14679 14680 TEST_F(FormatTest, StructuredBindings) { 14681 // Structured bindings is a C++17 feature. 14682 // all modes, including C++11, C++14 and C++17 14683 verifyFormat("auto [a, b] = f();"); 14684 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 14685 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 14686 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 14687 EXPECT_EQ("auto const volatile [a, b] = f();", 14688 format("auto const volatile[a, b] = f();")); 14689 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 14690 EXPECT_EQ("auto &[a, b, c] = f();", 14691 format("auto &[ a , b,c ] = f();")); 14692 EXPECT_EQ("auto &&[a, b, c] = f();", 14693 format("auto &&[ a , b,c ] = f();")); 14694 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 14695 EXPECT_EQ("auto const volatile &&[a, b] = f();", 14696 format("auto const volatile &&[a, b] = f();")); 14697 EXPECT_EQ("auto const &&[a, b] = f();", 14698 format("auto const && [a, b] = f();")); 14699 EXPECT_EQ("const auto &[a, b] = f();", 14700 format("const auto & [a, b] = f();")); 14701 EXPECT_EQ("const auto volatile &&[a, b] = f();", 14702 format("const auto volatile &&[a, b] = f();")); 14703 EXPECT_EQ("volatile const auto &&[a, b] = f();", 14704 format("volatile const auto &&[a, b] = f();")); 14705 EXPECT_EQ("const auto &&[a, b] = f();", 14706 format("const auto && [a, b] = f();")); 14707 14708 // Make sure we don't mistake structured bindings for lambdas. 14709 FormatStyle PointerMiddle = getLLVMStyle(); 14710 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 14711 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 14712 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 14713 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 14714 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 14715 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 14716 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 14717 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 14718 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 14719 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 14720 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 14721 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 14722 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 14723 14724 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 14725 format("for (const auto && [a, b] : some_range) {\n}")); 14726 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 14727 format("for (const auto & [a, b] : some_range) {\n}")); 14728 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 14729 format("for (const auto[a, b] : some_range) {\n}")); 14730 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 14731 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 14732 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 14733 EXPECT_EQ("auto const &[x, y](expr);", 14734 format("auto const & [x,y] (expr);")); 14735 EXPECT_EQ("auto const &&[x, y](expr);", 14736 format("auto const && [x,y] (expr);")); 14737 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 14738 EXPECT_EQ("auto const &[x, y]{expr};", 14739 format("auto const & [x,y] {expr};")); 14740 EXPECT_EQ("auto const &&[x, y]{expr};", 14741 format("auto const && [x,y] {expr};")); 14742 14743 format::FormatStyle Spaces = format::getLLVMStyle(); 14744 Spaces.SpacesInSquareBrackets = true; 14745 verifyFormat("auto [ a, b ] = f();", Spaces); 14746 verifyFormat("auto &&[ a, b ] = f();", Spaces); 14747 verifyFormat("auto &[ a, b ] = f();", Spaces); 14748 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 14749 verifyFormat("auto const &[ a, b ] = f();", Spaces); 14750 } 14751 14752 TEST_F(FormatTest, FileAndCode) { 14753 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 14754 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 14755 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 14756 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 14757 EXPECT_EQ(FormatStyle::LK_ObjC, 14758 guessLanguage("foo.h", "@interface Foo\n@end\n")); 14759 EXPECT_EQ( 14760 FormatStyle::LK_ObjC, 14761 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 14762 EXPECT_EQ(FormatStyle::LK_ObjC, 14763 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 14764 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 14765 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 14766 EXPECT_EQ(FormatStyle::LK_ObjC, 14767 guessLanguage("foo", "@interface Foo\n@end\n")); 14768 EXPECT_EQ(FormatStyle::LK_ObjC, 14769 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 14770 EXPECT_EQ( 14771 FormatStyle::LK_ObjC, 14772 guessLanguage("foo.h", 14773 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 14774 EXPECT_EQ( 14775 FormatStyle::LK_Cpp, 14776 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 14777 } 14778 14779 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 14780 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 14781 EXPECT_EQ(FormatStyle::LK_ObjC, 14782 guessLanguage("foo.h", "array[[calculator getIndex]];")); 14783 EXPECT_EQ(FormatStyle::LK_Cpp, 14784 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 14785 EXPECT_EQ( 14786 FormatStyle::LK_Cpp, 14787 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 14788 EXPECT_EQ(FormatStyle::LK_ObjC, 14789 guessLanguage("foo.h", "[[noreturn foo] bar];")); 14790 EXPECT_EQ(FormatStyle::LK_Cpp, 14791 guessLanguage("foo.h", "[[clang::fallthrough]];")); 14792 EXPECT_EQ(FormatStyle::LK_ObjC, 14793 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 14794 EXPECT_EQ(FormatStyle::LK_Cpp, 14795 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 14796 EXPECT_EQ(FormatStyle::LK_Cpp, 14797 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 14798 EXPECT_EQ(FormatStyle::LK_ObjC, 14799 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 14800 EXPECT_EQ(FormatStyle::LK_Cpp, 14801 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 14802 EXPECT_EQ( 14803 FormatStyle::LK_Cpp, 14804 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 14805 EXPECT_EQ( 14806 FormatStyle::LK_Cpp, 14807 guessLanguage("foo.h", 14808 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 14809 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 14810 } 14811 14812 TEST_F(FormatTest, GuessLanguageWithCaret) { 14813 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 14814 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 14815 EXPECT_EQ(FormatStyle::LK_ObjC, 14816 guessLanguage("foo.h", "int(^)(char, float);")); 14817 EXPECT_EQ(FormatStyle::LK_ObjC, 14818 guessLanguage("foo.h", "int(^foo)(char, float);")); 14819 EXPECT_EQ(FormatStyle::LK_ObjC, 14820 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 14821 EXPECT_EQ(FormatStyle::LK_ObjC, 14822 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 14823 EXPECT_EQ( 14824 FormatStyle::LK_ObjC, 14825 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 14826 } 14827 14828 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 14829 EXPECT_EQ(FormatStyle::LK_Cpp, 14830 guessLanguage("foo.h", "void f() {\n" 14831 " asm (\"mov %[e], %[d]\"\n" 14832 " : [d] \"=rm\" (d)\n" 14833 " [e] \"rm\" (*e));\n" 14834 "}")); 14835 EXPECT_EQ(FormatStyle::LK_Cpp, 14836 guessLanguage("foo.h", "void f() {\n" 14837 " _asm (\"mov %[e], %[d]\"\n" 14838 " : [d] \"=rm\" (d)\n" 14839 " [e] \"rm\" (*e));\n" 14840 "}")); 14841 EXPECT_EQ(FormatStyle::LK_Cpp, 14842 guessLanguage("foo.h", "void f() {\n" 14843 " __asm (\"mov %[e], %[d]\"\n" 14844 " : [d] \"=rm\" (d)\n" 14845 " [e] \"rm\" (*e));\n" 14846 "}")); 14847 EXPECT_EQ(FormatStyle::LK_Cpp, 14848 guessLanguage("foo.h", "void f() {\n" 14849 " __asm__ (\"mov %[e], %[d]\"\n" 14850 " : [d] \"=rm\" (d)\n" 14851 " [e] \"rm\" (*e));\n" 14852 "}")); 14853 EXPECT_EQ(FormatStyle::LK_Cpp, 14854 guessLanguage("foo.h", "void f() {\n" 14855 " asm (\"mov %[e], %[d]\"\n" 14856 " : [d] \"=rm\" (d),\n" 14857 " [e] \"rm\" (*e));\n" 14858 "}")); 14859 EXPECT_EQ(FormatStyle::LK_Cpp, 14860 guessLanguage("foo.h", "void f() {\n" 14861 " asm volatile (\"mov %[e], %[d]\"\n" 14862 " : [d] \"=rm\" (d)\n" 14863 " [e] \"rm\" (*e));\n" 14864 "}")); 14865 } 14866 14867 TEST_F(FormatTest, GuessLanguageWithChildLines) { 14868 EXPECT_EQ(FormatStyle::LK_Cpp, 14869 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 14870 EXPECT_EQ(FormatStyle::LK_ObjC, 14871 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 14872 EXPECT_EQ( 14873 FormatStyle::LK_Cpp, 14874 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 14875 EXPECT_EQ( 14876 FormatStyle::LK_ObjC, 14877 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 14878 } 14879 14880 TEST_F(FormatTest, TypenameMacros) { 14881 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 14882 14883 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 14884 FormatStyle Google = getGoogleStyleWithColumns(0); 14885 Google.TypenameMacros = TypenameMacros; 14886 verifyFormat("struct foo {\n" 14887 " int bar;\n" 14888 " TAILQ_ENTRY(a) bleh;\n" 14889 "};", 14890 Google); 14891 14892 FormatStyle Macros = getLLVMStyle(); 14893 Macros.TypenameMacros = TypenameMacros; 14894 14895 verifyFormat("STACK_OF(int) a;", Macros); 14896 verifyFormat("STACK_OF(int) *a;", Macros); 14897 verifyFormat("STACK_OF(int const *) *a;", Macros); 14898 verifyFormat("STACK_OF(int *const) *a;", Macros); 14899 verifyFormat("STACK_OF(int, string) a;", Macros); 14900 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 14901 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 14902 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 14903 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 14904 14905 Macros.PointerAlignment = FormatStyle::PAS_Left; 14906 verifyFormat("STACK_OF(int)* a;", Macros); 14907 verifyFormat("STACK_OF(int*)* a;", Macros); 14908 } 14909 14910 TEST_F(FormatTest, AmbersandInLamda) { 14911 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899 14912 FormatStyle AlignStyle = getLLVMStyle(); 14913 AlignStyle.PointerAlignment = FormatStyle::PAS_Left; 14914 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 14915 AlignStyle.PointerAlignment = FormatStyle::PAS_Right; 14916 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 14917 } 14918 14919 TEST_F(FormatTest, SpacesInConditionalStatement) { 14920 FormatStyle Spaces = getLLVMStyle(); 14921 Spaces.SpacesInConditionalStatement = true; 14922 verifyFormat("for ( int i = 0; i; i++ )\n continue;", Spaces); 14923 verifyFormat("if ( !a )\n return;", Spaces); 14924 verifyFormat("if ( a )\n return;", Spaces); 14925 verifyFormat("if constexpr ( a )\n return;", Spaces); 14926 verifyFormat("switch ( a )\ncase 1:\n return;", Spaces); 14927 verifyFormat("while ( a )\n return;", Spaces); 14928 verifyFormat("while ( (a && b) )\n return;", Spaces); 14929 verifyFormat("do {\n} while ( 1 != 0 );", Spaces); 14930 // Check that space on the left of "::" is inserted as expected at beginning 14931 // of condition. 14932 verifyFormat("while ( ::func() )\n return;", Spaces); 14933 } 14934 14935 TEST_F(FormatTest, AlternativeOperators) { 14936 // Test case for ensuring alternate operators are not 14937 // combined with their right most neighbour. 14938 verifyFormat("int a and b;"); 14939 verifyFormat("int a and_eq b;"); 14940 verifyFormat("int a bitand b;"); 14941 verifyFormat("int a bitor b;"); 14942 verifyFormat("int a compl b;"); 14943 verifyFormat("int a not b;"); 14944 verifyFormat("int a not_eq b;"); 14945 verifyFormat("int a or b;"); 14946 verifyFormat("int a xor b;"); 14947 verifyFormat("int a xor_eq b;"); 14948 verifyFormat("return this not_eq bitand other;"); 14949 verifyFormat("bool operator not_eq(const X bitand other)"); 14950 14951 verifyFormat("int a and 5;"); 14952 verifyFormat("int a and_eq 5;"); 14953 verifyFormat("int a bitand 5;"); 14954 verifyFormat("int a bitor 5;"); 14955 verifyFormat("int a compl 5;"); 14956 verifyFormat("int a not 5;"); 14957 verifyFormat("int a not_eq 5;"); 14958 verifyFormat("int a or 5;"); 14959 verifyFormat("int a xor 5;"); 14960 verifyFormat("int a xor_eq 5;"); 14961 14962 verifyFormat("int a compl(5);"); 14963 verifyFormat("int a not(5);"); 14964 14965 /* FIXME handle alternate tokens 14966 * https://en.cppreference.com/w/cpp/language/operator_alternative 14967 // alternative tokens 14968 verifyFormat("compl foo();"); // ~foo(); 14969 verifyFormat("foo() <%%>;"); // foo(); 14970 verifyFormat("void foo() <%%>;"); // void foo(){} 14971 verifyFormat("int a <:1:>;"); // int a[1];[ 14972 verifyFormat("%:define ABC abc"); // #define ABC abc 14973 verifyFormat("%:%:"); // ## 14974 */ 14975 } 14976 14977 TEST_F(FormatTest, STLWhileNotDefineChed) { 14978 verifyFormat("#if defined(while)\n" 14979 "#define while EMIT WARNING C4005\n" 14980 "#endif // while"); 14981 } 14982 14983 TEST_F(FormatTest, OperatorSpacing) { 14984 FormatStyle Style = getLLVMStyle(); 14985 Style.PointerAlignment = FormatStyle::PAS_Right; 14986 verifyFormat("Foo::operator*();", Style); 14987 verifyFormat("Foo::operator void *();", Style); 14988 verifyFormat("Foo::operator()(void *);", Style); 14989 verifyFormat("Foo::operator*(void *);", Style); 14990 verifyFormat("Foo::operator*();", Style); 14991 verifyFormat("operator*(int (*)(), class Foo);", Style); 14992 14993 verifyFormat("Foo::operator&();", Style); 14994 verifyFormat("Foo::operator void &();", Style); 14995 verifyFormat("Foo::operator()(void &);", Style); 14996 verifyFormat("Foo::operator&(void &);", Style); 14997 verifyFormat("Foo::operator&();", Style); 14998 verifyFormat("operator&(int (&)(), class Foo);", Style); 14999 15000 verifyFormat("Foo::operator&&();", Style); 15001 verifyFormat("Foo::operator void &&();", Style); 15002 verifyFormat("Foo::operator()(void &&);", Style); 15003 verifyFormat("Foo::operator&&(void &&);", Style); 15004 verifyFormat("Foo::operator&&();", Style); 15005 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15006 15007 Style.PointerAlignment = FormatStyle::PAS_Left; 15008 verifyFormat("Foo::operator*();", Style); 15009 verifyFormat("Foo::operator void*();", Style); 15010 verifyFormat("Foo::operator()(void*);", Style); 15011 verifyFormat("Foo::operator*(void*);", Style); 15012 verifyFormat("Foo::operator*();", Style); 15013 verifyFormat("operator*(int (*)(), class Foo);", Style); 15014 15015 verifyFormat("Foo::operator&();", Style); 15016 verifyFormat("Foo::operator void&();", Style); 15017 verifyFormat("Foo::operator()(void&);", Style); 15018 verifyFormat("Foo::operator&(void&);", Style); 15019 verifyFormat("Foo::operator&();", Style); 15020 verifyFormat("operator&(int (&)(), class Foo);", Style); 15021 15022 verifyFormat("Foo::operator&&();", Style); 15023 verifyFormat("Foo::operator void&&();", Style); 15024 verifyFormat("Foo::operator()(void&&);", Style); 15025 verifyFormat("Foo::operator&&(void&&);", Style); 15026 verifyFormat("Foo::operator&&();", Style); 15027 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15028 15029 Style.PointerAlignment = FormatStyle::PAS_Middle; 15030 verifyFormat("Foo::operator*();", Style); 15031 verifyFormat("Foo::operator void *();", Style); 15032 verifyFormat("Foo::operator()(void *);", Style); 15033 verifyFormat("Foo::operator*(void *);", Style); 15034 verifyFormat("Foo::operator*();", Style); 15035 verifyFormat("operator*(int (*)(), class Foo);", Style); 15036 15037 verifyFormat("Foo::operator&();", Style); 15038 verifyFormat("Foo::operator void &();", Style); 15039 verifyFormat("Foo::operator()(void &);", Style); 15040 verifyFormat("Foo::operator&(void &);", Style); 15041 verifyFormat("Foo::operator&();", Style); 15042 verifyFormat("operator&(int (&)(), class Foo);", Style); 15043 15044 verifyFormat("Foo::operator&&();", Style); 15045 verifyFormat("Foo::operator void &&();", Style); 15046 verifyFormat("Foo::operator()(void &&);", Style); 15047 verifyFormat("Foo::operator&&(void &&);", Style); 15048 verifyFormat("Foo::operator&&();", Style); 15049 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15050 } 15051 15052 } // namespace 15053 } // namespace format 15054 } // namespace clang 15055