1 //===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "clang/Format/Format.h" 10 11 #include "../Tooling/ReplacementTest.h" 12 #include "FormatTestUtils.h" 13 14 #include "clang/Frontend/TextDiagnosticPrinter.h" 15 #include "llvm/Support/Debug.h" 16 #include "llvm/Support/MemoryBuffer.h" 17 #include "gtest/gtest.h" 18 19 #define DEBUG_TYPE "format-test" 20 21 using clang::tooling::ReplacementTest; 22 using clang::tooling::toReplacements; 23 24 namespace clang { 25 namespace format { 26 namespace { 27 28 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); } 29 30 class FormatTest : public ::testing::Test { 31 protected: 32 enum StatusCheck { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck }; 33 34 std::string format(llvm::StringRef Code, 35 const FormatStyle &Style = getLLVMStyle(), 36 StatusCheck CheckComplete = SC_ExpectComplete) { 37 LLVM_DEBUG(llvm::errs() << "---\n"); 38 LLVM_DEBUG(llvm::errs() << Code << "\n\n"); 39 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size())); 40 FormattingAttemptStatus Status; 41 tooling::Replacements Replaces = 42 reformat(Style, Code, Ranges, "<stdin>", &Status); 43 if (CheckComplete != SC_DoNotCheck) { 44 bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete; 45 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete) 46 << Code << "\n\n"; 47 } 48 ReplacementCount = Replaces.size(); 49 auto Result = applyAllReplacements(Code, Replaces); 50 EXPECT_TRUE(static_cast<bool>(Result)); 51 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); 52 return *Result; 53 } 54 55 FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) { 56 Style.ColumnLimit = ColumnLimit; 57 return Style; 58 } 59 60 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 61 return getStyleWithColumns(getLLVMStyle(), ColumnLimit); 62 } 63 64 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) { 65 return getStyleWithColumns(getGoogleStyle(), ColumnLimit); 66 } 67 68 void verifyFormat(llvm::StringRef Expected, llvm::StringRef Code, 69 const FormatStyle &Style = getLLVMStyle()) { 70 EXPECT_EQ(Expected.str(), format(Expected, Style)) 71 << "Expected code is not stable"; 72 EXPECT_EQ(Expected.str(), format(Code, Style)); 73 if (Style.Language == FormatStyle::LK_Cpp) { 74 // Objective-C++ is a superset of C++, so everything checked for C++ 75 // needs to be checked for Objective-C++ as well. 76 FormatStyle ObjCStyle = Style; 77 ObjCStyle.Language = FormatStyle::LK_ObjC; 78 EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle)); 79 } 80 } 81 82 void verifyFormat(llvm::StringRef Code, 83 const FormatStyle &Style = getLLVMStyle()) { 84 verifyFormat(Code, test::messUp(Code), Style); 85 } 86 87 void verifyIncompleteFormat(llvm::StringRef Code, 88 const FormatStyle &Style = getLLVMStyle()) { 89 EXPECT_EQ(Code.str(), 90 format(test::messUp(Code), Style, SC_ExpectIncomplete)); 91 } 92 93 void verifyGoogleFormat(llvm::StringRef Code) { 94 verifyFormat(Code, getGoogleStyle()); 95 } 96 97 void verifyIndependentOfContext(llvm::StringRef text) { 98 verifyFormat(text); 99 verifyFormat(llvm::Twine("void f() { " + text + " }").str()); 100 } 101 102 /// \brief Verify that clang-format does not crash on the given input. 103 void verifyNoCrash(llvm::StringRef Code, 104 const FormatStyle &Style = getLLVMStyle()) { 105 format(Code, Style, SC_DoNotCheck); 106 } 107 108 int ReplacementCount; 109 }; 110 111 TEST_F(FormatTest, MessUp) { 112 EXPECT_EQ("1 2 3", test::messUp("1 2 3")); 113 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n")); 114 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc")); 115 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc")); 116 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne")); 117 } 118 119 TEST_F(FormatTest, DefaultLLVMStyleIsCpp) { 120 EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language); 121 } 122 123 TEST_F(FormatTest, LLVMStyleOverride) { 124 EXPECT_EQ(FormatStyle::LK_Proto, 125 getLLVMStyle(FormatStyle::LK_Proto).Language); 126 } 127 128 //===----------------------------------------------------------------------===// 129 // Basic function tests. 130 //===----------------------------------------------------------------------===// 131 132 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { 133 EXPECT_EQ(";", format(";")); 134 } 135 136 TEST_F(FormatTest, FormatsGlobalStatementsAt0) { 137 EXPECT_EQ("int i;", format(" int i;")); 138 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;")); 139 EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); 140 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); 141 } 142 143 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { 144 EXPECT_EQ("int i;", format("int\ni;")); 145 } 146 147 TEST_F(FormatTest, FormatsNestedBlockStatements) { 148 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}")); 149 } 150 151 TEST_F(FormatTest, FormatsNestedCall) { 152 verifyFormat("Method(f1, f2(f3));"); 153 verifyFormat("Method(f1(f2, f3()));"); 154 verifyFormat("Method(f1(f2, (f3())));"); 155 } 156 157 TEST_F(FormatTest, NestedNameSpecifiers) { 158 verifyFormat("vector<::Type> v;"); 159 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())"); 160 verifyFormat("static constexpr bool Bar = decltype(bar())::value;"); 161 verifyFormat("bool a = 2 < ::SomeFunction();"); 162 verifyFormat("ALWAYS_INLINE ::std::string getName();"); 163 verifyFormat("some::string getName();"); 164 } 165 166 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { 167 EXPECT_EQ("if (a) {\n" 168 " f();\n" 169 "}", 170 format("if(a){f();}")); 171 EXPECT_EQ(4, ReplacementCount); 172 EXPECT_EQ("if (a) {\n" 173 " f();\n" 174 "}", 175 format("if (a) {\n" 176 " f();\n" 177 "}")); 178 EXPECT_EQ(0, ReplacementCount); 179 EXPECT_EQ("/*\r\n" 180 "\r\n" 181 "*/\r\n", 182 format("/*\r\n" 183 "\r\n" 184 "*/\r\n")); 185 EXPECT_EQ(0, ReplacementCount); 186 } 187 188 TEST_F(FormatTest, RemovesEmptyLines) { 189 EXPECT_EQ("class C {\n" 190 " int i;\n" 191 "};", 192 format("class C {\n" 193 " int i;\n" 194 "\n" 195 "};")); 196 197 // Don't remove empty lines at the start of namespaces or extern "C" blocks. 198 EXPECT_EQ("namespace N {\n" 199 "\n" 200 "int i;\n" 201 "}", 202 format("namespace N {\n" 203 "\n" 204 "int i;\n" 205 "}", 206 getGoogleStyle())); 207 EXPECT_EQ("/* something */ namespace N {\n" 208 "\n" 209 "int i;\n" 210 "}", 211 format("/* something */ namespace N {\n" 212 "\n" 213 "int i;\n" 214 "}", 215 getGoogleStyle())); 216 EXPECT_EQ("inline namespace N {\n" 217 "\n" 218 "int i;\n" 219 "}", 220 format("inline namespace N {\n" 221 "\n" 222 "int i;\n" 223 "}", 224 getGoogleStyle())); 225 EXPECT_EQ("/* something */ inline namespace N {\n" 226 "\n" 227 "int i;\n" 228 "}", 229 format("/* something */ inline namespace N {\n" 230 "\n" 231 "int i;\n" 232 "}", 233 getGoogleStyle())); 234 EXPECT_EQ("export namespace N {\n" 235 "\n" 236 "int i;\n" 237 "}", 238 format("export namespace N {\n" 239 "\n" 240 "int i;\n" 241 "}", 242 getGoogleStyle())); 243 EXPECT_EQ("extern /**/ \"C\" /**/ {\n" 244 "\n" 245 "int i;\n" 246 "}", 247 format("extern /**/ \"C\" /**/ {\n" 248 "\n" 249 "int i;\n" 250 "}", 251 getGoogleStyle())); 252 253 // ...but do keep inlining and removing empty lines for non-block extern "C" 254 // functions. 255 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle()); 256 EXPECT_EQ("extern \"C\" int f() {\n" 257 " int i = 42;\n" 258 " return i;\n" 259 "}", 260 format("extern \"C\" int f() {\n" 261 "\n" 262 " int i = 42;\n" 263 " return i;\n" 264 "}", 265 getGoogleStyle())); 266 267 // Remove empty lines at the beginning and end of blocks. 268 EXPECT_EQ("void f() {\n" 269 "\n" 270 " if (a) {\n" 271 "\n" 272 " f();\n" 273 " }\n" 274 "}", 275 format("void f() {\n" 276 "\n" 277 " if (a) {\n" 278 "\n" 279 " f();\n" 280 "\n" 281 " }\n" 282 "\n" 283 "}", 284 getLLVMStyle())); 285 EXPECT_EQ("void f() {\n" 286 " if (a) {\n" 287 " f();\n" 288 " }\n" 289 "}", 290 format("void f() {\n" 291 "\n" 292 " if (a) {\n" 293 "\n" 294 " f();\n" 295 "\n" 296 " }\n" 297 "\n" 298 "}", 299 getGoogleStyle())); 300 301 // Don't remove empty lines in more complex control statements. 302 EXPECT_EQ("void f() {\n" 303 " if (a) {\n" 304 " f();\n" 305 "\n" 306 " } else if (b) {\n" 307 " f();\n" 308 " }\n" 309 "}", 310 format("void f() {\n" 311 " if (a) {\n" 312 " f();\n" 313 "\n" 314 " } else if (b) {\n" 315 " f();\n" 316 "\n" 317 " }\n" 318 "\n" 319 "}")); 320 321 // Don't remove empty lines before namespace endings. 322 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 323 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 324 EXPECT_EQ("namespace {\n" 325 "int i;\n" 326 "\n" 327 "}", 328 format("namespace {\n" 329 "int i;\n" 330 "\n" 331 "}", 332 LLVMWithNoNamespaceFix)); 333 EXPECT_EQ("namespace {\n" 334 "int i;\n" 335 "}", 336 format("namespace {\n" 337 "int i;\n" 338 "}", 339 LLVMWithNoNamespaceFix)); 340 EXPECT_EQ("namespace {\n" 341 "int i;\n" 342 "\n" 343 "};", 344 format("namespace {\n" 345 "int i;\n" 346 "\n" 347 "};", 348 LLVMWithNoNamespaceFix)); 349 EXPECT_EQ("namespace {\n" 350 "int i;\n" 351 "};", 352 format("namespace {\n" 353 "int i;\n" 354 "};", 355 LLVMWithNoNamespaceFix)); 356 EXPECT_EQ("namespace {\n" 357 "int i;\n" 358 "\n" 359 "}", 360 format("namespace {\n" 361 "int i;\n" 362 "\n" 363 "}")); 364 EXPECT_EQ("namespace {\n" 365 "int i;\n" 366 "\n" 367 "} // namespace", 368 format("namespace {\n" 369 "int i;\n" 370 "\n" 371 "} // namespace")); 372 373 FormatStyle Style = getLLVMStyle(); 374 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 375 Style.MaxEmptyLinesToKeep = 2; 376 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 377 Style.BraceWrapping.AfterClass = true; 378 Style.BraceWrapping.AfterFunction = true; 379 Style.KeepEmptyLinesAtTheStartOfBlocks = false; 380 381 EXPECT_EQ("class Foo\n" 382 "{\n" 383 " Foo() {}\n" 384 "\n" 385 " void funk() {}\n" 386 "};", 387 format("class Foo\n" 388 "{\n" 389 " Foo()\n" 390 " {\n" 391 " }\n" 392 "\n" 393 " void funk() {}\n" 394 "};", 395 Style)); 396 } 397 398 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) { 399 verifyFormat("x = (a) and (b);"); 400 verifyFormat("x = (a) or (b);"); 401 verifyFormat("x = (a) bitand (b);"); 402 verifyFormat("x = (a) bitor (b);"); 403 verifyFormat("x = (a) not_eq (b);"); 404 verifyFormat("x = (a) and_eq (b);"); 405 verifyFormat("x = (a) or_eq (b);"); 406 verifyFormat("x = (a) xor (b);"); 407 } 408 409 TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) { 410 verifyFormat("x = compl(a);"); 411 verifyFormat("x = not(a);"); 412 verifyFormat("x = bitand(a);"); 413 // Unary operator must not be merged with the next identifier 414 verifyFormat("x = compl a;"); 415 verifyFormat("x = not a;"); 416 verifyFormat("x = bitand a;"); 417 } 418 419 //===----------------------------------------------------------------------===// 420 // Tests for control statements. 421 //===----------------------------------------------------------------------===// 422 423 TEST_F(FormatTest, FormatIfWithoutCompoundStatement) { 424 verifyFormat("if (true)\n f();\ng();"); 425 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();"); 426 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();"); 427 verifyFormat("if constexpr (true)\n" 428 " f();\ng();"); 429 verifyFormat("if CONSTEXPR (true)\n" 430 " f();\ng();"); 431 verifyFormat("if constexpr (a)\n" 432 " if constexpr (b)\n" 433 " if constexpr (c)\n" 434 " g();\n" 435 "h();"); 436 verifyFormat("if CONSTEXPR (a)\n" 437 " if CONSTEXPR (b)\n" 438 " if CONSTEXPR (c)\n" 439 " g();\n" 440 "h();"); 441 verifyFormat("if constexpr (a)\n" 442 " if constexpr (b) {\n" 443 " f();\n" 444 " }\n" 445 "g();"); 446 verifyFormat("if CONSTEXPR (a)\n" 447 " if CONSTEXPR (b) {\n" 448 " f();\n" 449 " }\n" 450 "g();"); 451 452 FormatStyle AllowsMergedIf = getLLVMStyle(); 453 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 454 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 455 FormatStyle::SIS_WithoutElse; 456 verifyFormat("if (a)\n" 457 " // comment\n" 458 " f();", 459 AllowsMergedIf); 460 verifyFormat("{\n" 461 " if (a)\n" 462 " label:\n" 463 " f();\n" 464 "}", 465 AllowsMergedIf); 466 verifyFormat("#define A \\\n" 467 " if (a) \\\n" 468 " label: \\\n" 469 " f()", 470 AllowsMergedIf); 471 verifyFormat("if (a)\n" 472 " ;", 473 AllowsMergedIf); 474 verifyFormat("if (a)\n" 475 " if (b) return;", 476 AllowsMergedIf); 477 478 verifyFormat("if (a) // Can't merge this\n" 479 " f();\n", 480 AllowsMergedIf); 481 verifyFormat("if (a) /* still don't merge */\n" 482 " f();", 483 AllowsMergedIf); 484 verifyFormat("if (a) { // Never merge this\n" 485 " f();\n" 486 "}", 487 AllowsMergedIf); 488 verifyFormat("if (a) { /* Never merge this */\n" 489 " f();\n" 490 "}", 491 AllowsMergedIf); 492 493 AllowsMergedIf.ColumnLimit = 14; 494 verifyFormat("if (a) return;", AllowsMergedIf); 495 verifyFormat("if (aaaaaaaaa)\n" 496 " return;", 497 AllowsMergedIf); 498 499 AllowsMergedIf.ColumnLimit = 13; 500 verifyFormat("if (a)\n return;", AllowsMergedIf); 501 } 502 503 TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) { 504 FormatStyle AllowsMergedIf = getLLVMStyle(); 505 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 506 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 507 FormatStyle::SIS_WithoutElse; 508 verifyFormat("if (a)\n" 509 " f();\n" 510 "else {\n" 511 " g();\n" 512 "}", 513 AllowsMergedIf); 514 verifyFormat("if (a)\n" 515 " f();\n" 516 "else\n" 517 " g();\n", 518 AllowsMergedIf); 519 520 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 521 522 verifyFormat("if (a) f();\n" 523 "else {\n" 524 " g();\n" 525 "}", 526 AllowsMergedIf); 527 verifyFormat("if (a) f();\n" 528 "else {\n" 529 " if (a) f();\n" 530 " else {\n" 531 " g();\n" 532 " }\n" 533 " g();\n" 534 "}", 535 AllowsMergedIf); 536 } 537 538 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) { 539 FormatStyle AllowsMergedLoops = getLLVMStyle(); 540 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true; 541 verifyFormat("while (true) continue;", AllowsMergedLoops); 542 verifyFormat("for (;;) continue;", AllowsMergedLoops); 543 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops); 544 verifyFormat("while (true)\n" 545 " ;", 546 AllowsMergedLoops); 547 verifyFormat("for (;;)\n" 548 " ;", 549 AllowsMergedLoops); 550 verifyFormat("for (;;)\n" 551 " for (;;) continue;", 552 AllowsMergedLoops); 553 verifyFormat("for (;;) // Can't merge this\n" 554 " continue;", 555 AllowsMergedLoops); 556 verifyFormat("for (;;) /* still don't merge */\n" 557 " continue;", 558 AllowsMergedLoops); 559 } 560 561 TEST_F(FormatTest, FormatShortBracedStatements) { 562 FormatStyle AllowSimpleBracedStatements = getLLVMStyle(); 563 AllowSimpleBracedStatements.ColumnLimit = 40; 564 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = 565 FormatStyle::SBS_Always; 566 567 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 568 FormatStyle::SIS_WithoutElse; 569 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 570 571 AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom; 572 AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true; 573 AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false; 574 575 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 576 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 577 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 578 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 579 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 580 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 581 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 582 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 583 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 584 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 585 verifyFormat("if (true) {\n" 586 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 587 "}", 588 AllowSimpleBracedStatements); 589 verifyFormat("if (true) { //\n" 590 " f();\n" 591 "}", 592 AllowSimpleBracedStatements); 593 verifyFormat("if (true) {\n" 594 " f();\n" 595 " f();\n" 596 "}", 597 AllowSimpleBracedStatements); 598 verifyFormat("if (true) {\n" 599 " f();\n" 600 "} else {\n" 601 " f();\n" 602 "}", 603 AllowSimpleBracedStatements); 604 605 verifyFormat("struct A2 {\n" 606 " int X;\n" 607 "};", 608 AllowSimpleBracedStatements); 609 verifyFormat("typedef struct A2 {\n" 610 " int X;\n" 611 "} A2_t;", 612 AllowSimpleBracedStatements); 613 verifyFormat("template <int> struct A2 {\n" 614 " struct B {};\n" 615 "};", 616 AllowSimpleBracedStatements); 617 618 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 619 FormatStyle::SIS_Never; 620 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 621 verifyFormat("if (true) {\n" 622 " f();\n" 623 "}", 624 AllowSimpleBracedStatements); 625 verifyFormat("if (true) {\n" 626 " f();\n" 627 "} else {\n" 628 " f();\n" 629 "}", 630 AllowSimpleBracedStatements); 631 632 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 633 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 634 verifyFormat("while (true) {\n" 635 " f();\n" 636 "}", 637 AllowSimpleBracedStatements); 638 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 639 verifyFormat("for (;;) {\n" 640 " f();\n" 641 "}", 642 AllowSimpleBracedStatements); 643 644 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 645 FormatStyle::SIS_WithoutElse; 646 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 647 AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement = 648 FormatStyle::BWACS_Always; 649 650 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 651 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 652 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 653 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 654 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 655 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 656 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 657 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 658 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 659 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 660 verifyFormat("if (true)\n" 661 "{\n" 662 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 663 "}", 664 AllowSimpleBracedStatements); 665 verifyFormat("if (true)\n" 666 "{ //\n" 667 " f();\n" 668 "}", 669 AllowSimpleBracedStatements); 670 verifyFormat("if (true)\n" 671 "{\n" 672 " f();\n" 673 " f();\n" 674 "}", 675 AllowSimpleBracedStatements); 676 verifyFormat("if (true)\n" 677 "{\n" 678 " f();\n" 679 "} else\n" 680 "{\n" 681 " f();\n" 682 "}", 683 AllowSimpleBracedStatements); 684 685 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 686 FormatStyle::SIS_Never; 687 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 688 verifyFormat("if (true)\n" 689 "{\n" 690 " f();\n" 691 "}", 692 AllowSimpleBracedStatements); 693 verifyFormat("if (true)\n" 694 "{\n" 695 " f();\n" 696 "} else\n" 697 "{\n" 698 " f();\n" 699 "}", 700 AllowSimpleBracedStatements); 701 702 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 703 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 704 verifyFormat("while (true)\n" 705 "{\n" 706 " f();\n" 707 "}", 708 AllowSimpleBracedStatements); 709 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 710 verifyFormat("for (;;)\n" 711 "{\n" 712 " f();\n" 713 "}", 714 AllowSimpleBracedStatements); 715 } 716 717 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) { 718 FormatStyle Style = getLLVMStyleWithColumns(60); 719 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 720 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 721 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 722 EXPECT_EQ("#define A \\\n" 723 " if (HANDLEwernufrnuLwrmviferuvnierv) \\\n" 724 " { RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; }\n" 725 "X;", 726 format("#define A \\\n" 727 " if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n" 728 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n" 729 " }\n" 730 "X;", 731 Style)); 732 } 733 734 TEST_F(FormatTest, ParseIfElse) { 735 verifyFormat("if (true)\n" 736 " if (true)\n" 737 " if (true)\n" 738 " f();\n" 739 " else\n" 740 " g();\n" 741 " else\n" 742 " h();\n" 743 "else\n" 744 " i();"); 745 verifyFormat("if (true)\n" 746 " if (true)\n" 747 " if (true) {\n" 748 " if (true)\n" 749 " f();\n" 750 " } else {\n" 751 " g();\n" 752 " }\n" 753 " else\n" 754 " h();\n" 755 "else {\n" 756 " i();\n" 757 "}"); 758 verifyFormat("if (true)\n" 759 " if constexpr (true)\n" 760 " if (true) {\n" 761 " if constexpr (true)\n" 762 " f();\n" 763 " } else {\n" 764 " g();\n" 765 " }\n" 766 " else\n" 767 " h();\n" 768 "else {\n" 769 " i();\n" 770 "}"); 771 verifyFormat("if (true)\n" 772 " if CONSTEXPR (true)\n" 773 " if (true) {\n" 774 " if CONSTEXPR (true)\n" 775 " f();\n" 776 " } else {\n" 777 " g();\n" 778 " }\n" 779 " else\n" 780 " h();\n" 781 "else {\n" 782 " i();\n" 783 "}"); 784 verifyFormat("void f() {\n" 785 " if (a) {\n" 786 " } else {\n" 787 " }\n" 788 "}"); 789 } 790 791 TEST_F(FormatTest, ElseIf) { 792 verifyFormat("if (a) {\n} else if (b) {\n}"); 793 verifyFormat("if (a)\n" 794 " f();\n" 795 "else if (b)\n" 796 " g();\n" 797 "else\n" 798 " h();"); 799 verifyFormat("if constexpr (a)\n" 800 " f();\n" 801 "else if constexpr (b)\n" 802 " g();\n" 803 "else\n" 804 " h();"); 805 verifyFormat("if CONSTEXPR (a)\n" 806 " f();\n" 807 "else if CONSTEXPR (b)\n" 808 " g();\n" 809 "else\n" 810 " h();"); 811 verifyFormat("if (a) {\n" 812 " f();\n" 813 "}\n" 814 "// or else ..\n" 815 "else {\n" 816 " g()\n" 817 "}"); 818 819 verifyFormat("if (a) {\n" 820 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 821 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 822 "}"); 823 verifyFormat("if (a) {\n" 824 "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 825 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 826 "}"); 827 verifyFormat("if (a) {\n" 828 "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 829 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 830 "}"); 831 verifyFormat("if (a) {\n" 832 "} else if (\n" 833 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 834 "}", 835 getLLVMStyleWithColumns(62)); 836 verifyFormat("if (a) {\n" 837 "} else if constexpr (\n" 838 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 839 "}", 840 getLLVMStyleWithColumns(62)); 841 verifyFormat("if (a) {\n" 842 "} else if CONSTEXPR (\n" 843 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 844 "}", 845 getLLVMStyleWithColumns(62)); 846 } 847 848 TEST_F(FormatTest, FormatsForLoop) { 849 verifyFormat( 850 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 851 " ++VeryVeryLongLoopVariable)\n" 852 " ;"); 853 verifyFormat("for (;;)\n" 854 " f();"); 855 verifyFormat("for (;;) {\n}"); 856 verifyFormat("for (;;) {\n" 857 " f();\n" 858 "}"); 859 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 860 861 verifyFormat( 862 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 863 " E = UnwrappedLines.end();\n" 864 " I != E; ++I) {\n}"); 865 866 verifyFormat( 867 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 868 " ++IIIII) {\n}"); 869 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 870 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 871 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 872 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 873 " I = FD->getDeclsInPrototypeScope().begin(),\n" 874 " E = FD->getDeclsInPrototypeScope().end();\n" 875 " I != E; ++I) {\n}"); 876 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n" 877 " I = Container.begin(),\n" 878 " E = Container.end();\n" 879 " I != E; ++I) {\n}", 880 getLLVMStyleWithColumns(76)); 881 882 verifyFormat( 883 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 884 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 885 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 886 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 887 " ++aaaaaaaaaaa) {\n}"); 888 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 889 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n" 890 " ++i) {\n}"); 891 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 892 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 893 "}"); 894 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 895 " aaaaaaaaaa);\n" 896 " iter; ++iter) {\n" 897 "}"); 898 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 899 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 900 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n" 901 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {"); 902 903 // These should not be formatted as Objective-C for-in loops. 904 verifyFormat("for (Foo *x = 0; x != in; x++) {\n}"); 905 verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}"); 906 verifyFormat("Foo *x;\nfor (x in y) {\n}"); 907 verifyFormat( 908 "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}"); 909 910 FormatStyle NoBinPacking = getLLVMStyle(); 911 NoBinPacking.BinPackParameters = false; 912 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 913 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 914 " aaaaaaaaaaaaaaaa,\n" 915 " aaaaaaaaaaaaaaaa,\n" 916 " aaaaaaaaaaaaaaaa);\n" 917 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 918 "}", 919 NoBinPacking); 920 verifyFormat( 921 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 922 " E = UnwrappedLines.end();\n" 923 " I != E;\n" 924 " ++I) {\n}", 925 NoBinPacking); 926 927 FormatStyle AlignLeft = getLLVMStyle(); 928 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 929 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft); 930 } 931 932 TEST_F(FormatTest, RangeBasedForLoops) { 933 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 934 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 935 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 936 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 937 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 938 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 939 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n" 940 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}"); 941 } 942 943 TEST_F(FormatTest, ForEachLoops) { 944 verifyFormat("void f() {\n" 945 " foreach (Item *item, itemlist) {}\n" 946 " Q_FOREACH (Item *item, itemlist) {}\n" 947 " BOOST_FOREACH (Item *item, itemlist) {}\n" 948 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 949 "}"); 950 951 // As function-like macros. 952 verifyFormat("#define foreach(x, y)\n" 953 "#define Q_FOREACH(x, y)\n" 954 "#define BOOST_FOREACH(x, y)\n" 955 "#define UNKNOWN_FOREACH(x, y)\n"); 956 957 // Not as function-like macros. 958 verifyFormat("#define foreach (x, y)\n" 959 "#define Q_FOREACH (x, y)\n" 960 "#define BOOST_FOREACH (x, y)\n" 961 "#define UNKNOWN_FOREACH (x, y)\n"); 962 } 963 964 TEST_F(FormatTest, FormatsWhileLoop) { 965 verifyFormat("while (true) {\n}"); 966 verifyFormat("while (true)\n" 967 " f();"); 968 verifyFormat("while () {\n}"); 969 verifyFormat("while () {\n" 970 " f();\n" 971 "}"); 972 } 973 974 TEST_F(FormatTest, FormatsDoWhile) { 975 verifyFormat("do {\n" 976 " do_something();\n" 977 "} while (something());"); 978 verifyFormat("do\n" 979 " do_something();\n" 980 "while (something());"); 981 } 982 983 TEST_F(FormatTest, FormatsSwitchStatement) { 984 verifyFormat("switch (x) {\n" 985 "case 1:\n" 986 " f();\n" 987 " break;\n" 988 "case kFoo:\n" 989 "case ns::kBar:\n" 990 "case kBaz:\n" 991 " break;\n" 992 "default:\n" 993 " g();\n" 994 " break;\n" 995 "}"); 996 verifyFormat("switch (x) {\n" 997 "case 1: {\n" 998 " f();\n" 999 " break;\n" 1000 "}\n" 1001 "case 2: {\n" 1002 " break;\n" 1003 "}\n" 1004 "}"); 1005 verifyFormat("switch (x) {\n" 1006 "case 1: {\n" 1007 " f();\n" 1008 " {\n" 1009 " g();\n" 1010 " h();\n" 1011 " }\n" 1012 " break;\n" 1013 "}\n" 1014 "}"); 1015 verifyFormat("switch (x) {\n" 1016 "case 1: {\n" 1017 " f();\n" 1018 " if (foo) {\n" 1019 " g();\n" 1020 " h();\n" 1021 " }\n" 1022 " break;\n" 1023 "}\n" 1024 "}"); 1025 verifyFormat("switch (x) {\n" 1026 "case 1: {\n" 1027 " f();\n" 1028 " g();\n" 1029 "} break;\n" 1030 "}"); 1031 verifyFormat("switch (test)\n" 1032 " ;"); 1033 verifyFormat("switch (x) {\n" 1034 "default: {\n" 1035 " // Do nothing.\n" 1036 "}\n" 1037 "}"); 1038 verifyFormat("switch (x) {\n" 1039 "// comment\n" 1040 "// if 1, do f()\n" 1041 "case 1:\n" 1042 " f();\n" 1043 "}"); 1044 verifyFormat("switch (x) {\n" 1045 "case 1:\n" 1046 " // Do amazing stuff\n" 1047 " {\n" 1048 " f();\n" 1049 " g();\n" 1050 " }\n" 1051 " break;\n" 1052 "}"); 1053 verifyFormat("#define A \\\n" 1054 " switch (x) { \\\n" 1055 " case a: \\\n" 1056 " foo = b; \\\n" 1057 " }", 1058 getLLVMStyleWithColumns(20)); 1059 verifyFormat("#define OPERATION_CASE(name) \\\n" 1060 " case OP_name: \\\n" 1061 " return operations::Operation##name\n", 1062 getLLVMStyleWithColumns(40)); 1063 verifyFormat("switch (x) {\n" 1064 "case 1:;\n" 1065 "default:;\n" 1066 " int i;\n" 1067 "}"); 1068 1069 verifyGoogleFormat("switch (x) {\n" 1070 " case 1:\n" 1071 " f();\n" 1072 " break;\n" 1073 " case kFoo:\n" 1074 " case ns::kBar:\n" 1075 " case kBaz:\n" 1076 " break;\n" 1077 " default:\n" 1078 " g();\n" 1079 " break;\n" 1080 "}"); 1081 verifyGoogleFormat("switch (x) {\n" 1082 " case 1: {\n" 1083 " f();\n" 1084 " break;\n" 1085 " }\n" 1086 "}"); 1087 verifyGoogleFormat("switch (test)\n" 1088 " ;"); 1089 1090 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 1091 " case OP_name: \\\n" 1092 " return operations::Operation##name\n"); 1093 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 1094 " // Get the correction operation class.\n" 1095 " switch (OpCode) {\n" 1096 " CASE(Add);\n" 1097 " CASE(Subtract);\n" 1098 " default:\n" 1099 " return operations::Unknown;\n" 1100 " }\n" 1101 "#undef OPERATION_CASE\n" 1102 "}"); 1103 verifyFormat("DEBUG({\n" 1104 " switch (x) {\n" 1105 " case A:\n" 1106 " f();\n" 1107 " break;\n" 1108 " // fallthrough\n" 1109 " case B:\n" 1110 " g();\n" 1111 " break;\n" 1112 " }\n" 1113 "});"); 1114 EXPECT_EQ("DEBUG({\n" 1115 " switch (x) {\n" 1116 " case A:\n" 1117 " f();\n" 1118 " break;\n" 1119 " // On B:\n" 1120 " case B:\n" 1121 " g();\n" 1122 " break;\n" 1123 " }\n" 1124 "});", 1125 format("DEBUG({\n" 1126 " switch (x) {\n" 1127 " case A:\n" 1128 " f();\n" 1129 " break;\n" 1130 " // On B:\n" 1131 " case B:\n" 1132 " g();\n" 1133 " break;\n" 1134 " }\n" 1135 "});", 1136 getLLVMStyle())); 1137 EXPECT_EQ("switch (n) {\n" 1138 "case 0: {\n" 1139 " return false;\n" 1140 "}\n" 1141 "default: {\n" 1142 " return true;\n" 1143 "}\n" 1144 "}", 1145 format("switch (n)\n" 1146 "{\n" 1147 "case 0: {\n" 1148 " return false;\n" 1149 "}\n" 1150 "default: {\n" 1151 " return true;\n" 1152 "}\n" 1153 "}", 1154 getLLVMStyle())); 1155 verifyFormat("switch (a) {\n" 1156 "case (b):\n" 1157 " return;\n" 1158 "}"); 1159 1160 verifyFormat("switch (a) {\n" 1161 "case some_namespace::\n" 1162 " some_constant:\n" 1163 " return;\n" 1164 "}", 1165 getLLVMStyleWithColumns(34)); 1166 1167 FormatStyle Style = getLLVMStyle(); 1168 Style.IndentCaseLabels = true; 1169 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 1170 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1171 Style.BraceWrapping.AfterCaseLabel = true; 1172 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1173 EXPECT_EQ("switch (n)\n" 1174 "{\n" 1175 " case 0:\n" 1176 " {\n" 1177 " return false;\n" 1178 " }\n" 1179 " default:\n" 1180 " {\n" 1181 " return true;\n" 1182 " }\n" 1183 "}", 1184 format("switch (n) {\n" 1185 " case 0: {\n" 1186 " return false;\n" 1187 " }\n" 1188 " default: {\n" 1189 " return true;\n" 1190 " }\n" 1191 "}", 1192 Style)); 1193 Style.BraceWrapping.AfterCaseLabel = false; 1194 EXPECT_EQ("switch (n)\n" 1195 "{\n" 1196 " case 0: {\n" 1197 " return false;\n" 1198 " }\n" 1199 " default: {\n" 1200 " return true;\n" 1201 " }\n" 1202 "}", 1203 format("switch (n) {\n" 1204 " case 0:\n" 1205 " {\n" 1206 " return false;\n" 1207 " }\n" 1208 " default:\n" 1209 " {\n" 1210 " return true;\n" 1211 " }\n" 1212 "}", 1213 Style)); 1214 } 1215 1216 TEST_F(FormatTest, CaseRanges) { 1217 verifyFormat("switch (x) {\n" 1218 "case 'A' ... 'Z':\n" 1219 "case 1 ... 5:\n" 1220 "case a ... b:\n" 1221 " break;\n" 1222 "}"); 1223 } 1224 1225 TEST_F(FormatTest, ShortCaseLabels) { 1226 FormatStyle Style = getLLVMStyle(); 1227 Style.AllowShortCaseLabelsOnASingleLine = true; 1228 verifyFormat("switch (a) {\n" 1229 "case 1: x = 1; break;\n" 1230 "case 2: return;\n" 1231 "case 3:\n" 1232 "case 4:\n" 1233 "case 5: return;\n" 1234 "case 6: // comment\n" 1235 " return;\n" 1236 "case 7:\n" 1237 " // comment\n" 1238 " return;\n" 1239 "case 8:\n" 1240 " x = 8; // comment\n" 1241 " break;\n" 1242 "default: y = 1; break;\n" 1243 "}", 1244 Style); 1245 verifyFormat("switch (a) {\n" 1246 "case 0: return; // comment\n" 1247 "case 1: break; // comment\n" 1248 "case 2: return;\n" 1249 "// comment\n" 1250 "case 3: return;\n" 1251 "// comment 1\n" 1252 "// comment 2\n" 1253 "// comment 3\n" 1254 "case 4: break; /* comment */\n" 1255 "case 5:\n" 1256 " // comment\n" 1257 " break;\n" 1258 "case 6: /* comment */ x = 1; break;\n" 1259 "case 7: x = /* comment */ 1; break;\n" 1260 "case 8:\n" 1261 " x = 1; /* comment */\n" 1262 " break;\n" 1263 "case 9:\n" 1264 " break; // comment line 1\n" 1265 " // comment line 2\n" 1266 "}", 1267 Style); 1268 EXPECT_EQ("switch (a) {\n" 1269 "case 1:\n" 1270 " x = 8;\n" 1271 " // fall through\n" 1272 "case 2: x = 8;\n" 1273 "// comment\n" 1274 "case 3:\n" 1275 " return; /* comment line 1\n" 1276 " * comment line 2 */\n" 1277 "case 4: i = 8;\n" 1278 "// something else\n" 1279 "#if FOO\n" 1280 "case 5: break;\n" 1281 "#endif\n" 1282 "}", 1283 format("switch (a) {\n" 1284 "case 1: x = 8;\n" 1285 " // fall through\n" 1286 "case 2:\n" 1287 " x = 8;\n" 1288 "// comment\n" 1289 "case 3:\n" 1290 " return; /* comment line 1\n" 1291 " * comment line 2 */\n" 1292 "case 4:\n" 1293 " i = 8;\n" 1294 "// something else\n" 1295 "#if FOO\n" 1296 "case 5: break;\n" 1297 "#endif\n" 1298 "}", 1299 Style)); 1300 EXPECT_EQ("switch (a) {\n" 1301 "case 0:\n" 1302 " return; // long long long long long long long long long long " 1303 "long long comment\n" 1304 " // line\n" 1305 "}", 1306 format("switch (a) {\n" 1307 "case 0: return; // long long long long long long long long " 1308 "long long long long comment line\n" 1309 "}", 1310 Style)); 1311 EXPECT_EQ("switch (a) {\n" 1312 "case 0:\n" 1313 " return; /* long long long long long long long long long long " 1314 "long long comment\n" 1315 " line */\n" 1316 "}", 1317 format("switch (a) {\n" 1318 "case 0: return; /* long long long long long long long long " 1319 "long long long long comment line */\n" 1320 "}", 1321 Style)); 1322 verifyFormat("switch (a) {\n" 1323 "#if FOO\n" 1324 "case 0: return 0;\n" 1325 "#endif\n" 1326 "}", 1327 Style); 1328 verifyFormat("switch (a) {\n" 1329 "case 1: {\n" 1330 "}\n" 1331 "case 2: {\n" 1332 " return;\n" 1333 "}\n" 1334 "case 3: {\n" 1335 " x = 1;\n" 1336 " return;\n" 1337 "}\n" 1338 "case 4:\n" 1339 " if (x)\n" 1340 " return;\n" 1341 "}", 1342 Style); 1343 Style.ColumnLimit = 21; 1344 verifyFormat("switch (a) {\n" 1345 "case 1: x = 1; break;\n" 1346 "case 2: return;\n" 1347 "case 3:\n" 1348 "case 4:\n" 1349 "case 5: return;\n" 1350 "default:\n" 1351 " y = 1;\n" 1352 " break;\n" 1353 "}", 1354 Style); 1355 Style.ColumnLimit = 80; 1356 Style.AllowShortCaseLabelsOnASingleLine = false; 1357 Style.IndentCaseLabels = true; 1358 EXPECT_EQ("switch (n) {\n" 1359 " default /*comments*/:\n" 1360 " return true;\n" 1361 " case 0:\n" 1362 " return false;\n" 1363 "}", 1364 format("switch (n) {\n" 1365 "default/*comments*/:\n" 1366 " return true;\n" 1367 "case 0:\n" 1368 " return false;\n" 1369 "}", 1370 Style)); 1371 Style.AllowShortCaseLabelsOnASingleLine = true; 1372 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1373 Style.BraceWrapping.AfterCaseLabel = true; 1374 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1375 EXPECT_EQ("switch (n)\n" 1376 "{\n" 1377 " case 0:\n" 1378 " {\n" 1379 " return false;\n" 1380 " }\n" 1381 " default:\n" 1382 " {\n" 1383 " return true;\n" 1384 " }\n" 1385 "}", 1386 format("switch (n) {\n" 1387 " case 0: {\n" 1388 " return false;\n" 1389 " }\n" 1390 " default:\n" 1391 " {\n" 1392 " return true;\n" 1393 " }\n" 1394 "}", 1395 Style)); 1396 } 1397 1398 TEST_F(FormatTest, FormatsLabels) { 1399 verifyFormat("void f() {\n" 1400 " some_code();\n" 1401 "test_label:\n" 1402 " some_other_code();\n" 1403 " {\n" 1404 " some_more_code();\n" 1405 " another_label:\n" 1406 " some_more_code();\n" 1407 " }\n" 1408 "}"); 1409 verifyFormat("{\n" 1410 " some_code();\n" 1411 "test_label:\n" 1412 " some_other_code();\n" 1413 "}"); 1414 verifyFormat("{\n" 1415 " some_code();\n" 1416 "test_label:;\n" 1417 " int i = 0;\n" 1418 "}"); 1419 FormatStyle Style = getLLVMStyle(); 1420 Style.IndentGotoLabels = false; 1421 verifyFormat("void f() {\n" 1422 " some_code();\n" 1423 "test_label:\n" 1424 " some_other_code();\n" 1425 " {\n" 1426 " some_more_code();\n" 1427 "another_label:\n" 1428 " some_more_code();\n" 1429 " }\n" 1430 "}", 1431 Style); 1432 verifyFormat("{\n" 1433 " some_code();\n" 1434 "test_label:\n" 1435 " some_other_code();\n" 1436 "}", 1437 Style); 1438 verifyFormat("{\n" 1439 " some_code();\n" 1440 "test_label:;\n" 1441 " int i = 0;\n" 1442 "}"); 1443 } 1444 1445 TEST_F(FormatTest, MultiLineControlStatements) { 1446 FormatStyle Style = getLLVMStyle(); 1447 Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom; 1448 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine; 1449 Style.ColumnLimit = 20; 1450 // Short lines should keep opening brace on same line. 1451 EXPECT_EQ("if (foo) {\n" 1452 " bar();\n" 1453 "}", 1454 format("if(foo){bar();}", Style)); 1455 EXPECT_EQ("if (foo) {\n" 1456 " bar();\n" 1457 "} else {\n" 1458 " baz();\n" 1459 "}", 1460 format("if(foo){bar();}else{baz();}", Style)); 1461 EXPECT_EQ("if (foo && bar) {\n" 1462 " baz();\n" 1463 "}", 1464 format("if(foo&&bar){baz();}", Style)); 1465 EXPECT_EQ("if (foo) {\n" 1466 " bar();\n" 1467 "} else if (baz) {\n" 1468 " quux();\n" 1469 "}", 1470 format("if(foo){bar();}else if(baz){quux();}", Style)); 1471 EXPECT_EQ( 1472 "if (foo) {\n" 1473 " bar();\n" 1474 "} else if (baz) {\n" 1475 " quux();\n" 1476 "} else {\n" 1477 " foobar();\n" 1478 "}", 1479 format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style)); 1480 EXPECT_EQ("for (;;) {\n" 1481 " foo();\n" 1482 "}", 1483 format("for(;;){foo();}")); 1484 EXPECT_EQ("while (1) {\n" 1485 " foo();\n" 1486 "}", 1487 format("while(1){foo();}", Style)); 1488 EXPECT_EQ("switch (foo) {\n" 1489 "case bar:\n" 1490 " return;\n" 1491 "}", 1492 format("switch(foo){case bar:return;}", Style)); 1493 EXPECT_EQ("try {\n" 1494 " foo();\n" 1495 "} catch (...) {\n" 1496 " bar();\n" 1497 "}", 1498 format("try{foo();}catch(...){bar();}", Style)); 1499 EXPECT_EQ("do {\n" 1500 " foo();\n" 1501 "} while (bar &&\n" 1502 " baz);", 1503 format("do{foo();}while(bar&&baz);", Style)); 1504 // Long lines should put opening brace on new line. 1505 EXPECT_EQ("if (foo && bar &&\n" 1506 " baz)\n" 1507 "{\n" 1508 " quux();\n" 1509 "}", 1510 format("if(foo&&bar&&baz){quux();}", Style)); 1511 EXPECT_EQ("if (foo && bar &&\n" 1512 " baz)\n" 1513 "{\n" 1514 " quux();\n" 1515 "}", 1516 format("if (foo && bar &&\n" 1517 " baz) {\n" 1518 " quux();\n" 1519 "}", 1520 Style)); 1521 EXPECT_EQ("if (foo) {\n" 1522 " bar();\n" 1523 "} else if (baz ||\n" 1524 " quux)\n" 1525 "{\n" 1526 " foobar();\n" 1527 "}", 1528 format("if(foo){bar();}else if(baz||quux){foobar();}", Style)); 1529 EXPECT_EQ( 1530 "if (foo) {\n" 1531 " bar();\n" 1532 "} else if (baz ||\n" 1533 " quux)\n" 1534 "{\n" 1535 " foobar();\n" 1536 "} else {\n" 1537 " barbaz();\n" 1538 "}", 1539 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1540 Style)); 1541 EXPECT_EQ("for (int i = 0;\n" 1542 " i < 10; ++i)\n" 1543 "{\n" 1544 " foo();\n" 1545 "}", 1546 format("for(int i=0;i<10;++i){foo();}", Style)); 1547 EXPECT_EQ("while (foo || bar ||\n" 1548 " baz)\n" 1549 "{\n" 1550 " quux();\n" 1551 "}", 1552 format("while(foo||bar||baz){quux();}", Style)); 1553 EXPECT_EQ("switch (\n" 1554 " foo = barbaz)\n" 1555 "{\n" 1556 "case quux:\n" 1557 " return;\n" 1558 "}", 1559 format("switch(foo=barbaz){case quux:return;}", Style)); 1560 EXPECT_EQ("try {\n" 1561 " foo();\n" 1562 "} catch (\n" 1563 " Exception &bar)\n" 1564 "{\n" 1565 " baz();\n" 1566 "}", 1567 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1568 } 1569 1570 //===----------------------------------------------------------------------===// 1571 // Tests for classes, namespaces, etc. 1572 //===----------------------------------------------------------------------===// 1573 1574 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1575 verifyFormat("class A {};"); 1576 } 1577 1578 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1579 verifyFormat("class A {\n" 1580 "public:\n" 1581 "public: // comment\n" 1582 "protected:\n" 1583 "private:\n" 1584 " void f() {}\n" 1585 "};"); 1586 verifyFormat("export class A {\n" 1587 "public:\n" 1588 "public: // comment\n" 1589 "protected:\n" 1590 "private:\n" 1591 " void f() {}\n" 1592 "};"); 1593 verifyGoogleFormat("class A {\n" 1594 " public:\n" 1595 " protected:\n" 1596 " private:\n" 1597 " void f() {}\n" 1598 "};"); 1599 verifyGoogleFormat("export class A {\n" 1600 " public:\n" 1601 " protected:\n" 1602 " private:\n" 1603 " void f() {}\n" 1604 "};"); 1605 verifyFormat("class A {\n" 1606 "public slots:\n" 1607 " void f1() {}\n" 1608 "public Q_SLOTS:\n" 1609 " void f2() {}\n" 1610 "protected slots:\n" 1611 " void f3() {}\n" 1612 "protected Q_SLOTS:\n" 1613 " void f4() {}\n" 1614 "private slots:\n" 1615 " void f5() {}\n" 1616 "private Q_SLOTS:\n" 1617 " void f6() {}\n" 1618 "signals:\n" 1619 " void g1();\n" 1620 "Q_SIGNALS:\n" 1621 " void g2();\n" 1622 "};"); 1623 1624 // Don't interpret 'signals' the wrong way. 1625 verifyFormat("signals.set();"); 1626 verifyFormat("for (Signals signals : f()) {\n}"); 1627 verifyFormat("{\n" 1628 " signals.set(); // This needs indentation.\n" 1629 "}"); 1630 verifyFormat("void f() {\n" 1631 "label:\n" 1632 " signals.baz();\n" 1633 "}"); 1634 } 1635 1636 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1637 EXPECT_EQ("class A {\n" 1638 "public:\n" 1639 " void f();\n" 1640 "\n" 1641 "private:\n" 1642 " void g() {}\n" 1643 " // test\n" 1644 "protected:\n" 1645 " int h;\n" 1646 "};", 1647 format("class A {\n" 1648 "public:\n" 1649 "void f();\n" 1650 "private:\n" 1651 "void g() {}\n" 1652 "// test\n" 1653 "protected:\n" 1654 "int h;\n" 1655 "};")); 1656 EXPECT_EQ("class A {\n" 1657 "protected:\n" 1658 "public:\n" 1659 " void f();\n" 1660 "};", 1661 format("class A {\n" 1662 "protected:\n" 1663 "\n" 1664 "public:\n" 1665 "\n" 1666 " void f();\n" 1667 "};")); 1668 1669 // Even ensure proper spacing inside macros. 1670 EXPECT_EQ("#define B \\\n" 1671 " class A { \\\n" 1672 " protected: \\\n" 1673 " public: \\\n" 1674 " void f(); \\\n" 1675 " };", 1676 format("#define B \\\n" 1677 " class A { \\\n" 1678 " protected: \\\n" 1679 " \\\n" 1680 " public: \\\n" 1681 " \\\n" 1682 " void f(); \\\n" 1683 " };", 1684 getGoogleStyle())); 1685 // But don't remove empty lines after macros ending in access specifiers. 1686 EXPECT_EQ("#define A private:\n" 1687 "\n" 1688 "int i;", 1689 format("#define A private:\n" 1690 "\n" 1691 "int i;")); 1692 } 1693 1694 TEST_F(FormatTest, FormatsClasses) { 1695 verifyFormat("class A : public B {};"); 1696 verifyFormat("class A : public ::B {};"); 1697 1698 verifyFormat( 1699 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1700 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1701 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1702 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1703 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1704 verifyFormat( 1705 "class A : public B, public C, public D, public E, public F {};"); 1706 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1707 " public C,\n" 1708 " public D,\n" 1709 " public E,\n" 1710 " public F,\n" 1711 " public G {};"); 1712 1713 verifyFormat("class\n" 1714 " ReallyReallyLongClassName {\n" 1715 " int i;\n" 1716 "};", 1717 getLLVMStyleWithColumns(32)); 1718 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1719 " aaaaaaaaaaaaaaaa> {};"); 1720 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1721 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1722 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1723 verifyFormat("template <class R, class C>\n" 1724 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1725 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1726 verifyFormat("class ::A::B {};"); 1727 } 1728 1729 TEST_F(FormatTest, BreakInheritanceStyle) { 1730 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1731 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1732 FormatStyle::BILS_BeforeComma; 1733 verifyFormat("class MyClass : public X {};", 1734 StyleWithInheritanceBreakBeforeComma); 1735 verifyFormat("class MyClass\n" 1736 " : public X\n" 1737 " , public Y {};", 1738 StyleWithInheritanceBreakBeforeComma); 1739 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1740 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1741 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1742 StyleWithInheritanceBreakBeforeComma); 1743 verifyFormat("struct aaaaaaaaaaaaa\n" 1744 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1745 " aaaaaaaaaaaaaaaa> {};", 1746 StyleWithInheritanceBreakBeforeComma); 1747 1748 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1749 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1750 FormatStyle::BILS_AfterColon; 1751 verifyFormat("class MyClass : public X {};", 1752 StyleWithInheritanceBreakAfterColon); 1753 verifyFormat("class MyClass : public X, public Y {};", 1754 StyleWithInheritanceBreakAfterColon); 1755 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1756 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1757 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1758 StyleWithInheritanceBreakAfterColon); 1759 verifyFormat("struct aaaaaaaaaaaaa :\n" 1760 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1761 " aaaaaaaaaaaaaaaa> {};", 1762 StyleWithInheritanceBreakAfterColon); 1763 } 1764 1765 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1766 verifyFormat("class A {\n} a, b;"); 1767 verifyFormat("struct A {\n} a, b;"); 1768 verifyFormat("union A {\n} a;"); 1769 } 1770 1771 TEST_F(FormatTest, FormatsEnum) { 1772 verifyFormat("enum {\n" 1773 " Zero,\n" 1774 " One = 1,\n" 1775 " Two = One + 1,\n" 1776 " Three = (One + Two),\n" 1777 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1778 " Five = (One, Two, Three, Four, 5)\n" 1779 "};"); 1780 verifyGoogleFormat("enum {\n" 1781 " Zero,\n" 1782 " One = 1,\n" 1783 " Two = One + 1,\n" 1784 " Three = (One + Two),\n" 1785 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1786 " Five = (One, Two, Three, Four, 5)\n" 1787 "};"); 1788 verifyFormat("enum Enum {};"); 1789 verifyFormat("enum {};"); 1790 verifyFormat("enum X E {} d;"); 1791 verifyFormat("enum __attribute__((...)) E {} d;"); 1792 verifyFormat("enum __declspec__((...)) E {} d;"); 1793 verifyFormat("enum {\n" 1794 " Bar = Foo<int, int>::value\n" 1795 "};", 1796 getLLVMStyleWithColumns(30)); 1797 1798 verifyFormat("enum ShortEnum { A, B, C };"); 1799 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1800 1801 EXPECT_EQ("enum KeepEmptyLines {\n" 1802 " ONE,\n" 1803 "\n" 1804 " TWO,\n" 1805 "\n" 1806 " THREE\n" 1807 "}", 1808 format("enum KeepEmptyLines {\n" 1809 " ONE,\n" 1810 "\n" 1811 " TWO,\n" 1812 "\n" 1813 "\n" 1814 " THREE\n" 1815 "}")); 1816 verifyFormat("enum E { // comment\n" 1817 " ONE,\n" 1818 " TWO\n" 1819 "};\n" 1820 "int i;"); 1821 // Not enums. 1822 verifyFormat("enum X f() {\n" 1823 " a();\n" 1824 " return 42;\n" 1825 "}"); 1826 verifyFormat("enum X Type::f() {\n" 1827 " a();\n" 1828 " return 42;\n" 1829 "}"); 1830 verifyFormat("enum ::X f() {\n" 1831 " a();\n" 1832 " return 42;\n" 1833 "}"); 1834 verifyFormat("enum ns::X f() {\n" 1835 " a();\n" 1836 " return 42;\n" 1837 "}"); 1838 } 1839 1840 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1841 verifyFormat("enum Type {\n" 1842 " One = 0; // These semicolons should be commas.\n" 1843 " Two = 1;\n" 1844 "};"); 1845 verifyFormat("namespace n {\n" 1846 "enum Type {\n" 1847 " One,\n" 1848 " Two, // missing };\n" 1849 " int i;\n" 1850 "}\n" 1851 "void g() {}"); 1852 } 1853 1854 TEST_F(FormatTest, FormatsEnumStruct) { 1855 verifyFormat("enum struct {\n" 1856 " Zero,\n" 1857 " One = 1,\n" 1858 " Two = One + 1,\n" 1859 " Three = (One + Two),\n" 1860 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1861 " Five = (One, Two, Three, Four, 5)\n" 1862 "};"); 1863 verifyFormat("enum struct Enum {};"); 1864 verifyFormat("enum struct {};"); 1865 verifyFormat("enum struct X E {} d;"); 1866 verifyFormat("enum struct __attribute__((...)) E {} d;"); 1867 verifyFormat("enum struct __declspec__((...)) E {} d;"); 1868 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1869 } 1870 1871 TEST_F(FormatTest, FormatsEnumClass) { 1872 verifyFormat("enum class {\n" 1873 " Zero,\n" 1874 " One = 1,\n" 1875 " Two = One + 1,\n" 1876 " Three = (One + Two),\n" 1877 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1878 " Five = (One, Two, Three, Four, 5)\n" 1879 "};"); 1880 verifyFormat("enum class Enum {};"); 1881 verifyFormat("enum class {};"); 1882 verifyFormat("enum class X E {} d;"); 1883 verifyFormat("enum class __attribute__((...)) E {} d;"); 1884 verifyFormat("enum class __declspec__((...)) E {} d;"); 1885 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 1886 } 1887 1888 TEST_F(FormatTest, FormatsEnumTypes) { 1889 verifyFormat("enum X : int {\n" 1890 " A, // Force multiple lines.\n" 1891 " B\n" 1892 "};"); 1893 verifyFormat("enum X : int { A, B };"); 1894 verifyFormat("enum X : std::uint32_t { A, B };"); 1895 } 1896 1897 TEST_F(FormatTest, FormatsTypedefEnum) { 1898 FormatStyle Style = getLLVMStyle(); 1899 Style.ColumnLimit = 40; 1900 verifyFormat("typedef enum {} EmptyEnum;"); 1901 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1902 verifyFormat("typedef enum {\n" 1903 " ZERO = 0,\n" 1904 " ONE = 1,\n" 1905 " TWO = 2,\n" 1906 " THREE = 3\n" 1907 "} LongEnum;", 1908 Style); 1909 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1910 Style.BraceWrapping.AfterEnum = true; 1911 verifyFormat("typedef enum {} EmptyEnum;"); 1912 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1913 verifyFormat("typedef enum\n" 1914 "{\n" 1915 " ZERO = 0,\n" 1916 " ONE = 1,\n" 1917 " TWO = 2,\n" 1918 " THREE = 3\n" 1919 "} LongEnum;", 1920 Style); 1921 } 1922 1923 TEST_F(FormatTest, FormatsNSEnums) { 1924 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1925 verifyGoogleFormat( 1926 "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }"); 1927 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 1928 " // Information about someDecentlyLongValue.\n" 1929 " someDecentlyLongValue,\n" 1930 " // Information about anotherDecentlyLongValue.\n" 1931 " anotherDecentlyLongValue,\n" 1932 " // Information about aThirdDecentlyLongValue.\n" 1933 " aThirdDecentlyLongValue\n" 1934 "};"); 1935 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n" 1936 " // Information about someDecentlyLongValue.\n" 1937 " someDecentlyLongValue,\n" 1938 " // Information about anotherDecentlyLongValue.\n" 1939 " anotherDecentlyLongValue,\n" 1940 " // Information about aThirdDecentlyLongValue.\n" 1941 " aThirdDecentlyLongValue\n" 1942 "};"); 1943 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 1944 " a = 1,\n" 1945 " b = 2,\n" 1946 " c = 3,\n" 1947 "};"); 1948 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 1949 " a = 1,\n" 1950 " b = 2,\n" 1951 " c = 3,\n" 1952 "};"); 1953 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n" 1954 " a = 1,\n" 1955 " b = 2,\n" 1956 " c = 3,\n" 1957 "};"); 1958 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 1959 " a = 1,\n" 1960 " b = 2,\n" 1961 " c = 3,\n" 1962 "};"); 1963 } 1964 1965 TEST_F(FormatTest, FormatsBitfields) { 1966 verifyFormat("struct Bitfields {\n" 1967 " unsigned sClass : 8;\n" 1968 " unsigned ValueKind : 2;\n" 1969 "};"); 1970 verifyFormat("struct A {\n" 1971 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 1972 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 1973 "};"); 1974 verifyFormat("struct MyStruct {\n" 1975 " uchar data;\n" 1976 " uchar : 8;\n" 1977 " uchar : 8;\n" 1978 " uchar other;\n" 1979 "};"); 1980 } 1981 1982 TEST_F(FormatTest, FormatsNamespaces) { 1983 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 1984 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 1985 1986 verifyFormat("namespace some_namespace {\n" 1987 "class A {};\n" 1988 "void f() { f(); }\n" 1989 "}", 1990 LLVMWithNoNamespaceFix); 1991 verifyFormat("namespace N::inline D {\n" 1992 "class A {};\n" 1993 "void f() { f(); }\n" 1994 "}", 1995 LLVMWithNoNamespaceFix); 1996 verifyFormat("namespace N::inline D::E {\n" 1997 "class A {};\n" 1998 "void f() { f(); }\n" 1999 "}", 2000 LLVMWithNoNamespaceFix); 2001 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n" 2002 "class A {};\n" 2003 "void f() { f(); }\n" 2004 "}", 2005 LLVMWithNoNamespaceFix); 2006 verifyFormat("/* something */ namespace some_namespace {\n" 2007 "class A {};\n" 2008 "void f() { f(); }\n" 2009 "}", 2010 LLVMWithNoNamespaceFix); 2011 verifyFormat("namespace {\n" 2012 "class A {};\n" 2013 "void f() { f(); }\n" 2014 "}", 2015 LLVMWithNoNamespaceFix); 2016 verifyFormat("/* something */ namespace {\n" 2017 "class A {};\n" 2018 "void f() { f(); }\n" 2019 "}", 2020 LLVMWithNoNamespaceFix); 2021 verifyFormat("inline namespace X {\n" 2022 "class A {};\n" 2023 "void f() { f(); }\n" 2024 "}", 2025 LLVMWithNoNamespaceFix); 2026 verifyFormat("/* something */ inline namespace X {\n" 2027 "class A {};\n" 2028 "void f() { f(); }\n" 2029 "}", 2030 LLVMWithNoNamespaceFix); 2031 verifyFormat("export namespace X {\n" 2032 "class A {};\n" 2033 "void f() { f(); }\n" 2034 "}", 2035 LLVMWithNoNamespaceFix); 2036 verifyFormat("using namespace some_namespace;\n" 2037 "class A {};\n" 2038 "void f() { f(); }", 2039 LLVMWithNoNamespaceFix); 2040 2041 // This code is more common than we thought; if we 2042 // layout this correctly the semicolon will go into 2043 // its own line, which is undesirable. 2044 verifyFormat("namespace {};", LLVMWithNoNamespaceFix); 2045 verifyFormat("namespace {\n" 2046 "class A {};\n" 2047 "};", 2048 LLVMWithNoNamespaceFix); 2049 2050 verifyFormat("namespace {\n" 2051 "int SomeVariable = 0; // comment\n" 2052 "} // namespace", 2053 LLVMWithNoNamespaceFix); 2054 EXPECT_EQ("#ifndef HEADER_GUARD\n" 2055 "#define HEADER_GUARD\n" 2056 "namespace my_namespace {\n" 2057 "int i;\n" 2058 "} // my_namespace\n" 2059 "#endif // HEADER_GUARD", 2060 format("#ifndef HEADER_GUARD\n" 2061 " #define HEADER_GUARD\n" 2062 " namespace my_namespace {\n" 2063 "int i;\n" 2064 "} // my_namespace\n" 2065 "#endif // HEADER_GUARD", 2066 LLVMWithNoNamespaceFix)); 2067 2068 EXPECT_EQ("namespace A::B {\n" 2069 "class C {};\n" 2070 "}", 2071 format("namespace A::B {\n" 2072 "class C {};\n" 2073 "}", 2074 LLVMWithNoNamespaceFix)); 2075 2076 FormatStyle Style = getLLVMStyle(); 2077 Style.NamespaceIndentation = FormatStyle::NI_All; 2078 EXPECT_EQ("namespace out {\n" 2079 " int i;\n" 2080 " namespace in {\n" 2081 " int i;\n" 2082 " } // namespace in\n" 2083 "} // namespace out", 2084 format("namespace out {\n" 2085 "int i;\n" 2086 "namespace in {\n" 2087 "int i;\n" 2088 "} // namespace in\n" 2089 "} // namespace out", 2090 Style)); 2091 2092 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2093 EXPECT_EQ("namespace out {\n" 2094 "int i;\n" 2095 "namespace in {\n" 2096 " int i;\n" 2097 "} // namespace in\n" 2098 "} // namespace out", 2099 format("namespace out {\n" 2100 "int i;\n" 2101 "namespace in {\n" 2102 "int i;\n" 2103 "} // namespace in\n" 2104 "} // namespace out", 2105 Style)); 2106 } 2107 2108 TEST_F(FormatTest, NamespaceMacros) { 2109 FormatStyle Style = getLLVMStyle(); 2110 Style.NamespaceMacros.push_back("TESTSUITE"); 2111 2112 verifyFormat("TESTSUITE(A) {\n" 2113 "int foo();\n" 2114 "} // TESTSUITE(A)", 2115 Style); 2116 2117 verifyFormat("TESTSUITE(A, B) {\n" 2118 "int foo();\n" 2119 "} // TESTSUITE(A)", 2120 Style); 2121 2122 // Properly indent according to NamespaceIndentation style 2123 Style.NamespaceIndentation = FormatStyle::NI_All; 2124 verifyFormat("TESTSUITE(A) {\n" 2125 " int foo();\n" 2126 "} // TESTSUITE(A)", 2127 Style); 2128 verifyFormat("TESTSUITE(A) {\n" 2129 " namespace B {\n" 2130 " int foo();\n" 2131 " } // namespace B\n" 2132 "} // TESTSUITE(A)", 2133 Style); 2134 verifyFormat("namespace A {\n" 2135 " TESTSUITE(B) {\n" 2136 " int foo();\n" 2137 " } // TESTSUITE(B)\n" 2138 "} // namespace A", 2139 Style); 2140 2141 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2142 verifyFormat("TESTSUITE(A) {\n" 2143 "TESTSUITE(B) {\n" 2144 " int foo();\n" 2145 "} // TESTSUITE(B)\n" 2146 "} // TESTSUITE(A)", 2147 Style); 2148 verifyFormat("TESTSUITE(A) {\n" 2149 "namespace B {\n" 2150 " int foo();\n" 2151 "} // namespace B\n" 2152 "} // TESTSUITE(A)", 2153 Style); 2154 verifyFormat("namespace A {\n" 2155 "TESTSUITE(B) {\n" 2156 " int foo();\n" 2157 "} // TESTSUITE(B)\n" 2158 "} // namespace A", 2159 Style); 2160 2161 // Properly merge namespace-macros blocks in CompactNamespaces mode 2162 Style.NamespaceIndentation = FormatStyle::NI_None; 2163 Style.CompactNamespaces = true; 2164 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n" 2165 "}} // TESTSUITE(A::B)", 2166 Style); 2167 2168 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2169 "}} // TESTSUITE(out::in)", 2170 format("TESTSUITE(out) {\n" 2171 "TESTSUITE(in) {\n" 2172 "} // TESTSUITE(in)\n" 2173 "} // TESTSUITE(out)", 2174 Style)); 2175 2176 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2177 "}} // TESTSUITE(out::in)", 2178 format("TESTSUITE(out) {\n" 2179 "TESTSUITE(in) {\n" 2180 "} // TESTSUITE(in)\n" 2181 "} // TESTSUITE(out)", 2182 Style)); 2183 2184 // Do not merge different namespaces/macros 2185 EXPECT_EQ("namespace out {\n" 2186 "TESTSUITE(in) {\n" 2187 "} // TESTSUITE(in)\n" 2188 "} // namespace out", 2189 format("namespace out {\n" 2190 "TESTSUITE(in) {\n" 2191 "} // TESTSUITE(in)\n" 2192 "} // namespace out", 2193 Style)); 2194 EXPECT_EQ("TESTSUITE(out) {\n" 2195 "namespace in {\n" 2196 "} // namespace in\n" 2197 "} // TESTSUITE(out)", 2198 format("TESTSUITE(out) {\n" 2199 "namespace in {\n" 2200 "} // namespace in\n" 2201 "} // TESTSUITE(out)", 2202 Style)); 2203 Style.NamespaceMacros.push_back("FOOBAR"); 2204 EXPECT_EQ("TESTSUITE(out) {\n" 2205 "FOOBAR(in) {\n" 2206 "} // FOOBAR(in)\n" 2207 "} // TESTSUITE(out)", 2208 format("TESTSUITE(out) {\n" 2209 "FOOBAR(in) {\n" 2210 "} // FOOBAR(in)\n" 2211 "} // TESTSUITE(out)", 2212 Style)); 2213 } 2214 2215 TEST_F(FormatTest, FormatsCompactNamespaces) { 2216 FormatStyle Style = getLLVMStyle(); 2217 Style.CompactNamespaces = true; 2218 Style.NamespaceMacros.push_back("TESTSUITE"); 2219 2220 verifyFormat("namespace A { namespace B {\n" 2221 "}} // namespace A::B", 2222 Style); 2223 2224 EXPECT_EQ("namespace out { namespace in {\n" 2225 "}} // namespace out::in", 2226 format("namespace out {\n" 2227 "namespace in {\n" 2228 "} // namespace in\n" 2229 "} // namespace out", 2230 Style)); 2231 2232 // Only namespaces which have both consecutive opening and end get compacted 2233 EXPECT_EQ("namespace out {\n" 2234 "namespace in1 {\n" 2235 "} // namespace in1\n" 2236 "namespace in2 {\n" 2237 "} // namespace in2\n" 2238 "} // namespace out", 2239 format("namespace out {\n" 2240 "namespace in1 {\n" 2241 "} // namespace in1\n" 2242 "namespace in2 {\n" 2243 "} // namespace in2\n" 2244 "} // namespace out", 2245 Style)); 2246 2247 EXPECT_EQ("namespace out {\n" 2248 "int i;\n" 2249 "namespace in {\n" 2250 "int j;\n" 2251 "} // namespace in\n" 2252 "int k;\n" 2253 "} // namespace out", 2254 format("namespace out { int i;\n" 2255 "namespace in { int j; } // namespace in\n" 2256 "int k; } // namespace out", 2257 Style)); 2258 2259 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 2260 "}}} // namespace A::B::C\n", 2261 format("namespace A { namespace B {\n" 2262 "namespace C {\n" 2263 "}} // namespace B::C\n" 2264 "} // namespace A\n", 2265 Style)); 2266 2267 Style.ColumnLimit = 40; 2268 EXPECT_EQ("namespace aaaaaaaaaa {\n" 2269 "namespace bbbbbbbbbb {\n" 2270 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 2271 format("namespace aaaaaaaaaa {\n" 2272 "namespace bbbbbbbbbb {\n" 2273 "} // namespace bbbbbbbbbb\n" 2274 "} // namespace aaaaaaaaaa", 2275 Style)); 2276 2277 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 2278 "namespace cccccc {\n" 2279 "}}} // namespace aaaaaa::bbbbbb::cccccc", 2280 format("namespace aaaaaa {\n" 2281 "namespace bbbbbb {\n" 2282 "namespace cccccc {\n" 2283 "} // namespace cccccc\n" 2284 "} // namespace bbbbbb\n" 2285 "} // namespace aaaaaa", 2286 Style)); 2287 Style.ColumnLimit = 80; 2288 2289 // Extra semicolon after 'inner' closing brace prevents merging 2290 EXPECT_EQ("namespace out { namespace in {\n" 2291 "}; } // namespace out::in", 2292 format("namespace out {\n" 2293 "namespace in {\n" 2294 "}; // namespace in\n" 2295 "} // namespace out", 2296 Style)); 2297 2298 // Extra semicolon after 'outer' closing brace is conserved 2299 EXPECT_EQ("namespace out { namespace in {\n" 2300 "}}; // namespace out::in", 2301 format("namespace out {\n" 2302 "namespace in {\n" 2303 "} // namespace in\n" 2304 "}; // namespace out", 2305 Style)); 2306 2307 Style.NamespaceIndentation = FormatStyle::NI_All; 2308 EXPECT_EQ("namespace out { namespace in {\n" 2309 " int i;\n" 2310 "}} // namespace out::in", 2311 format("namespace out {\n" 2312 "namespace in {\n" 2313 "int i;\n" 2314 "} // namespace in\n" 2315 "} // namespace out", 2316 Style)); 2317 EXPECT_EQ("namespace out { namespace mid {\n" 2318 " namespace in {\n" 2319 " int j;\n" 2320 " } // namespace in\n" 2321 " int k;\n" 2322 "}} // namespace out::mid", 2323 format("namespace out { namespace mid {\n" 2324 "namespace in { int j; } // namespace in\n" 2325 "int k; }} // namespace out::mid", 2326 Style)); 2327 2328 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2329 EXPECT_EQ("namespace out { namespace in {\n" 2330 " int i;\n" 2331 "}} // namespace out::in", 2332 format("namespace out {\n" 2333 "namespace in {\n" 2334 "int i;\n" 2335 "} // namespace in\n" 2336 "} // namespace out", 2337 Style)); 2338 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 2339 " int i;\n" 2340 "}}} // namespace out::mid::in", 2341 format("namespace out {\n" 2342 "namespace mid {\n" 2343 "namespace in {\n" 2344 "int i;\n" 2345 "} // namespace in\n" 2346 "} // namespace mid\n" 2347 "} // namespace out", 2348 Style)); 2349 } 2350 2351 TEST_F(FormatTest, FormatsExternC) { 2352 verifyFormat("extern \"C\" {\nint a;"); 2353 verifyFormat("extern \"C\" {}"); 2354 verifyFormat("extern \"C\" {\n" 2355 "int foo();\n" 2356 "}"); 2357 verifyFormat("extern \"C\" int foo() {}"); 2358 verifyFormat("extern \"C\" int foo();"); 2359 verifyFormat("extern \"C\" int foo() {\n" 2360 " int i = 42;\n" 2361 " return i;\n" 2362 "}"); 2363 2364 FormatStyle Style = getLLVMStyle(); 2365 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2366 Style.BraceWrapping.AfterFunction = true; 2367 verifyFormat("extern \"C\" int foo() {}", Style); 2368 verifyFormat("extern \"C\" int foo();", Style); 2369 verifyFormat("extern \"C\" int foo()\n" 2370 "{\n" 2371 " int i = 42;\n" 2372 " return i;\n" 2373 "}", 2374 Style); 2375 2376 Style.BraceWrapping.AfterExternBlock = true; 2377 Style.BraceWrapping.SplitEmptyRecord = false; 2378 verifyFormat("extern \"C\"\n" 2379 "{}", 2380 Style); 2381 verifyFormat("extern \"C\"\n" 2382 "{\n" 2383 " int foo();\n" 2384 "}", 2385 Style); 2386 } 2387 2388 TEST_F(FormatTest, FormatsInlineASM) { 2389 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2390 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2391 verifyFormat( 2392 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2393 " \"cpuid\\n\\t\"\n" 2394 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2395 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2396 " : \"a\"(value));"); 2397 EXPECT_EQ( 2398 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2399 " __asm {\n" 2400 " mov edx,[that] // vtable in edx\n" 2401 " mov eax,methodIndex\n" 2402 " call [edx][eax*4] // stdcall\n" 2403 " }\n" 2404 "}", 2405 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2406 " __asm {\n" 2407 " mov edx,[that] // vtable in edx\n" 2408 " mov eax,methodIndex\n" 2409 " call [edx][eax*4] // stdcall\n" 2410 " }\n" 2411 "}")); 2412 EXPECT_EQ("_asm {\n" 2413 " xor eax, eax;\n" 2414 " cpuid;\n" 2415 "}", 2416 format("_asm {\n" 2417 " xor eax, eax;\n" 2418 " cpuid;\n" 2419 "}")); 2420 verifyFormat("void function() {\n" 2421 " // comment\n" 2422 " asm(\"\");\n" 2423 "}"); 2424 EXPECT_EQ("__asm {\n" 2425 "}\n" 2426 "int i;", 2427 format("__asm {\n" 2428 "}\n" 2429 "int i;")); 2430 } 2431 2432 TEST_F(FormatTest, FormatTryCatch) { 2433 verifyFormat("try {\n" 2434 " throw a * b;\n" 2435 "} catch (int a) {\n" 2436 " // Do nothing.\n" 2437 "} catch (...) {\n" 2438 " exit(42);\n" 2439 "}"); 2440 2441 // Function-level try statements. 2442 verifyFormat("int f() try { return 4; } catch (...) {\n" 2443 " return 5;\n" 2444 "}"); 2445 verifyFormat("class A {\n" 2446 " int a;\n" 2447 " A() try : a(0) {\n" 2448 " } catch (...) {\n" 2449 " throw;\n" 2450 " }\n" 2451 "};\n"); 2452 2453 // Incomplete try-catch blocks. 2454 verifyIncompleteFormat("try {} catch ("); 2455 } 2456 2457 TEST_F(FormatTest, FormatSEHTryCatch) { 2458 verifyFormat("__try {\n" 2459 " int a = b * c;\n" 2460 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2461 " // Do nothing.\n" 2462 "}"); 2463 2464 verifyFormat("__try {\n" 2465 " int a = b * c;\n" 2466 "} __finally {\n" 2467 " // Do nothing.\n" 2468 "}"); 2469 2470 verifyFormat("DEBUG({\n" 2471 " __try {\n" 2472 " } __finally {\n" 2473 " }\n" 2474 "});\n"); 2475 } 2476 2477 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2478 verifyFormat("try {\n" 2479 " f();\n" 2480 "} catch {\n" 2481 " g();\n" 2482 "}"); 2483 verifyFormat("try {\n" 2484 " f();\n" 2485 "} catch (A a) MACRO(x) {\n" 2486 " g();\n" 2487 "} catch (B b) MACRO(x) {\n" 2488 " g();\n" 2489 "}"); 2490 } 2491 2492 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2493 FormatStyle Style = getLLVMStyle(); 2494 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2495 FormatStyle::BS_WebKit}) { 2496 Style.BreakBeforeBraces = BraceStyle; 2497 verifyFormat("try {\n" 2498 " // something\n" 2499 "} catch (...) {\n" 2500 " // something\n" 2501 "}", 2502 Style); 2503 } 2504 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2505 verifyFormat("try {\n" 2506 " // something\n" 2507 "}\n" 2508 "catch (...) {\n" 2509 " // something\n" 2510 "}", 2511 Style); 2512 verifyFormat("__try {\n" 2513 " // something\n" 2514 "}\n" 2515 "__finally {\n" 2516 " // something\n" 2517 "}", 2518 Style); 2519 verifyFormat("@try {\n" 2520 " // something\n" 2521 "}\n" 2522 "@finally {\n" 2523 " // something\n" 2524 "}", 2525 Style); 2526 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2527 verifyFormat("try\n" 2528 "{\n" 2529 " // something\n" 2530 "}\n" 2531 "catch (...)\n" 2532 "{\n" 2533 " // something\n" 2534 "}", 2535 Style); 2536 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 2537 verifyFormat("try\n" 2538 " {\n" 2539 " // something white\n" 2540 " }\n" 2541 "catch (...)\n" 2542 " {\n" 2543 " // something white\n" 2544 " }", 2545 Style); 2546 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2547 verifyFormat("try\n" 2548 " {\n" 2549 " // something\n" 2550 " }\n" 2551 "catch (...)\n" 2552 " {\n" 2553 " // something\n" 2554 " }", 2555 Style); 2556 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2557 Style.BraceWrapping.BeforeCatch = true; 2558 verifyFormat("try {\n" 2559 " // something\n" 2560 "}\n" 2561 "catch (...) {\n" 2562 " // something\n" 2563 "}", 2564 Style); 2565 } 2566 2567 TEST_F(FormatTest, StaticInitializers) { 2568 verifyFormat("static SomeClass SC = {1, 'a'};"); 2569 2570 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2571 " 100000000, " 2572 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2573 2574 // Here, everything other than the "}" would fit on a line. 2575 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2576 " 10000000000000000000000000};"); 2577 EXPECT_EQ("S s = {a,\n" 2578 "\n" 2579 " b};", 2580 format("S s = {\n" 2581 " a,\n" 2582 "\n" 2583 " b\n" 2584 "};")); 2585 2586 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2587 // line. However, the formatting looks a bit off and this probably doesn't 2588 // happen often in practice. 2589 verifyFormat("static int Variable[1] = {\n" 2590 " {1000000000000000000000000000000000000}};", 2591 getLLVMStyleWithColumns(40)); 2592 } 2593 2594 TEST_F(FormatTest, DesignatedInitializers) { 2595 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2596 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2597 " .bbbbbbbbbb = 2,\n" 2598 " .cccccccccc = 3,\n" 2599 " .dddddddddd = 4,\n" 2600 " .eeeeeeeeee = 5};"); 2601 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2602 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2603 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2604 " .ccccccccccccccccccccccccccc = 3,\n" 2605 " .ddddddddddddddddddddddddddd = 4,\n" 2606 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2607 2608 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2609 2610 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2611 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2612 " [2] = bbbbbbbbbb,\n" 2613 " [3] = cccccccccc,\n" 2614 " [4] = dddddddddd,\n" 2615 " [5] = eeeeeeeeee};"); 2616 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2617 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2618 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2619 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2620 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2621 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2622 } 2623 2624 TEST_F(FormatTest, NestedStaticInitializers) { 2625 verifyFormat("static A x = {{{}}};\n"); 2626 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2627 " {init1, init2, init3, init4}}};", 2628 getLLVMStyleWithColumns(50)); 2629 2630 verifyFormat("somes Status::global_reps[3] = {\n" 2631 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2632 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2633 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2634 getLLVMStyleWithColumns(60)); 2635 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2636 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2637 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2638 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2639 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2640 " {rect.fRight - rect.fLeft, rect.fBottom - " 2641 "rect.fTop}};"); 2642 2643 verifyFormat( 2644 "SomeArrayOfSomeType a = {\n" 2645 " {{1, 2, 3},\n" 2646 " {1, 2, 3},\n" 2647 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2648 " 333333333333333333333333333333},\n" 2649 " {1, 2, 3},\n" 2650 " {1, 2, 3}}};"); 2651 verifyFormat( 2652 "SomeArrayOfSomeType a = {\n" 2653 " {{1, 2, 3}},\n" 2654 " {{1, 2, 3}},\n" 2655 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2656 " 333333333333333333333333333333}},\n" 2657 " {{1, 2, 3}},\n" 2658 " {{1, 2, 3}}};"); 2659 2660 verifyFormat("struct {\n" 2661 " unsigned bit;\n" 2662 " const char *const name;\n" 2663 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2664 " {kOsWin, \"Windows\"},\n" 2665 " {kOsLinux, \"Linux\"},\n" 2666 " {kOsCrOS, \"Chrome OS\"}};"); 2667 verifyFormat("struct {\n" 2668 " unsigned bit;\n" 2669 " const char *const name;\n" 2670 "} kBitsToOs[] = {\n" 2671 " {kOsMac, \"Mac\"},\n" 2672 " {kOsWin, \"Windows\"},\n" 2673 " {kOsLinux, \"Linux\"},\n" 2674 " {kOsCrOS, \"Chrome OS\"},\n" 2675 "};"); 2676 } 2677 2678 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2679 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2680 " \\\n" 2681 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2682 } 2683 2684 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2685 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2686 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2687 2688 // Do break defaulted and deleted functions. 2689 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2690 " default;", 2691 getLLVMStyleWithColumns(40)); 2692 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2693 " delete;", 2694 getLLVMStyleWithColumns(40)); 2695 } 2696 2697 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2698 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2699 getLLVMStyleWithColumns(40)); 2700 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2701 getLLVMStyleWithColumns(40)); 2702 EXPECT_EQ("#define Q \\\n" 2703 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2704 " \"aaaaaaaa.cpp\"", 2705 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2706 getLLVMStyleWithColumns(40))); 2707 } 2708 2709 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2710 EXPECT_EQ("# 123 \"A string literal\"", 2711 format(" # 123 \"A string literal\"")); 2712 } 2713 2714 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2715 EXPECT_EQ("#;", format("#;")); 2716 verifyFormat("#\n;\n;\n;"); 2717 } 2718 2719 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2720 EXPECT_EQ("#line 42 \"test\"\n", 2721 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2722 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2723 getLLVMStyleWithColumns(12))); 2724 } 2725 2726 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2727 EXPECT_EQ("#line 42 \"test\"", 2728 format("# \\\n line \\\n 42 \\\n \"test\"")); 2729 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2730 } 2731 2732 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2733 verifyFormat("#define A \\x20"); 2734 verifyFormat("#define A \\ x20"); 2735 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2736 verifyFormat("#define A ''"); 2737 verifyFormat("#define A ''qqq"); 2738 verifyFormat("#define A `qqq"); 2739 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2740 EXPECT_EQ("const char *c = STRINGIFY(\n" 2741 "\\na : b);", 2742 format("const char * c = STRINGIFY(\n" 2743 "\\na : b);")); 2744 2745 verifyFormat("a\r\\"); 2746 verifyFormat("a\v\\"); 2747 verifyFormat("a\f\\"); 2748 } 2749 2750 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2751 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2752 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2753 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2754 // FIXME: We never break before the macro name. 2755 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2756 2757 verifyFormat("#define A A\n#define A A"); 2758 verifyFormat("#define A(X) A\n#define A A"); 2759 2760 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2761 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2762 } 2763 2764 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2765 EXPECT_EQ("// somecomment\n" 2766 "#include \"a.h\"\n" 2767 "#define A( \\\n" 2768 " A, B)\n" 2769 "#include \"b.h\"\n" 2770 "// somecomment\n", 2771 format(" // somecomment\n" 2772 " #include \"a.h\"\n" 2773 "#define A(A,\\\n" 2774 " B)\n" 2775 " #include \"b.h\"\n" 2776 " // somecomment\n", 2777 getLLVMStyleWithColumns(13))); 2778 } 2779 2780 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2781 2782 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2783 EXPECT_EQ("#define A \\\n" 2784 " c; \\\n" 2785 " e;\n" 2786 "f;", 2787 format("#define A c; e;\n" 2788 "f;", 2789 getLLVMStyleWithColumns(14))); 2790 } 2791 2792 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2793 2794 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2795 EXPECT_EQ("int x,\n" 2796 "#define A\n" 2797 " y;", 2798 format("int x,\n#define A\ny;")); 2799 } 2800 2801 TEST_F(FormatTest, HashInMacroDefinition) { 2802 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2803 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2804 verifyFormat("#define A \\\n" 2805 " { \\\n" 2806 " f(#c); \\\n" 2807 " }", 2808 getLLVMStyleWithColumns(11)); 2809 2810 verifyFormat("#define A(X) \\\n" 2811 " void function##X()", 2812 getLLVMStyleWithColumns(22)); 2813 2814 verifyFormat("#define A(a, b, c) \\\n" 2815 " void a##b##c()", 2816 getLLVMStyleWithColumns(22)); 2817 2818 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2819 } 2820 2821 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2822 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2823 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2824 2825 FormatStyle Style = getLLVMStyle(); 2826 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 2827 verifyFormat("#define true ((foo)1)", Style); 2828 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 2829 verifyFormat("#define false((foo)0)", Style); 2830 } 2831 2832 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2833 EXPECT_EQ("#define A b;", format("#define A \\\n" 2834 " \\\n" 2835 " b;", 2836 getLLVMStyleWithColumns(25))); 2837 EXPECT_EQ("#define A \\\n" 2838 " \\\n" 2839 " a; \\\n" 2840 " b;", 2841 format("#define A \\\n" 2842 " \\\n" 2843 " a; \\\n" 2844 " b;", 2845 getLLVMStyleWithColumns(11))); 2846 EXPECT_EQ("#define A \\\n" 2847 " a; \\\n" 2848 " \\\n" 2849 " b;", 2850 format("#define A \\\n" 2851 " a; \\\n" 2852 " \\\n" 2853 " b;", 2854 getLLVMStyleWithColumns(11))); 2855 } 2856 2857 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 2858 verifyIncompleteFormat("#define A :"); 2859 verifyFormat("#define SOMECASES \\\n" 2860 " case 1: \\\n" 2861 " case 2\n", 2862 getLLVMStyleWithColumns(20)); 2863 verifyFormat("#define MACRO(a) \\\n" 2864 " if (a) \\\n" 2865 " f(); \\\n" 2866 " else \\\n" 2867 " g()", 2868 getLLVMStyleWithColumns(18)); 2869 verifyFormat("#define A template <typename T>"); 2870 verifyIncompleteFormat("#define STR(x) #x\n" 2871 "f(STR(this_is_a_string_literal{));"); 2872 verifyFormat("#pragma omp threadprivate( \\\n" 2873 " y)), // expected-warning", 2874 getLLVMStyleWithColumns(28)); 2875 verifyFormat("#d, = };"); 2876 verifyFormat("#if \"a"); 2877 verifyIncompleteFormat("({\n" 2878 "#define b \\\n" 2879 " } \\\n" 2880 " a\n" 2881 "a", 2882 getLLVMStyleWithColumns(15)); 2883 verifyFormat("#define A \\\n" 2884 " { \\\n" 2885 " {\n" 2886 "#define B \\\n" 2887 " } \\\n" 2888 " }", 2889 getLLVMStyleWithColumns(15)); 2890 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 2891 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 2892 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 2893 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 2894 } 2895 2896 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 2897 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 2898 EXPECT_EQ("class A : public QObject {\n" 2899 " Q_OBJECT\n" 2900 "\n" 2901 " A() {}\n" 2902 "};", 2903 format("class A : public QObject {\n" 2904 " Q_OBJECT\n" 2905 "\n" 2906 " A() {\n}\n" 2907 "} ;")); 2908 EXPECT_EQ("MACRO\n" 2909 "/*static*/ int i;", 2910 format("MACRO\n" 2911 " /*static*/ int i;")); 2912 EXPECT_EQ("SOME_MACRO\n" 2913 "namespace {\n" 2914 "void f();\n" 2915 "} // namespace", 2916 format("SOME_MACRO\n" 2917 " namespace {\n" 2918 "void f( );\n" 2919 "} // namespace")); 2920 // Only if the identifier contains at least 5 characters. 2921 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 2922 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 2923 // Only if everything is upper case. 2924 EXPECT_EQ("class A : public QObject {\n" 2925 " Q_Object A() {}\n" 2926 "};", 2927 format("class A : public QObject {\n" 2928 " Q_Object\n" 2929 " A() {\n}\n" 2930 "} ;")); 2931 2932 // Only if the next line can actually start an unwrapped line. 2933 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 2934 format("SOME_WEIRD_LOG_MACRO\n" 2935 "<< SomeThing;")); 2936 2937 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 2938 "(n, buffers))\n", 2939 getChromiumStyle(FormatStyle::LK_Cpp)); 2940 2941 // See PR41483 2942 EXPECT_EQ("/**/ FOO(a)\n" 2943 "FOO(b)", 2944 format("/**/ FOO(a)\n" 2945 "FOO(b)")); 2946 } 2947 2948 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 2949 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2950 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2951 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2952 "class X {};\n" 2953 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2954 "int *createScopDetectionPass() { return 0; }", 2955 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2956 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2957 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2958 " class X {};\n" 2959 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2960 " int *createScopDetectionPass() { return 0; }")); 2961 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 2962 // braces, so that inner block is indented one level more. 2963 EXPECT_EQ("int q() {\n" 2964 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2965 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2966 " IPC_END_MESSAGE_MAP()\n" 2967 "}", 2968 format("int q() {\n" 2969 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2970 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2971 " IPC_END_MESSAGE_MAP()\n" 2972 "}")); 2973 2974 // Same inside macros. 2975 EXPECT_EQ("#define LIST(L) \\\n" 2976 " L(A) \\\n" 2977 " L(B) \\\n" 2978 " L(C)", 2979 format("#define LIST(L) \\\n" 2980 " L(A) \\\n" 2981 " L(B) \\\n" 2982 " L(C)", 2983 getGoogleStyle())); 2984 2985 // These must not be recognized as macros. 2986 EXPECT_EQ("int q() {\n" 2987 " f(x);\n" 2988 " f(x) {}\n" 2989 " f(x)->g();\n" 2990 " f(x)->*g();\n" 2991 " f(x).g();\n" 2992 " f(x) = x;\n" 2993 " f(x) += x;\n" 2994 " f(x) -= x;\n" 2995 " f(x) *= x;\n" 2996 " f(x) /= x;\n" 2997 " f(x) %= x;\n" 2998 " f(x) &= x;\n" 2999 " f(x) |= x;\n" 3000 " f(x) ^= x;\n" 3001 " f(x) >>= x;\n" 3002 " f(x) <<= x;\n" 3003 " f(x)[y].z();\n" 3004 " LOG(INFO) << x;\n" 3005 " ifstream(x) >> x;\n" 3006 "}\n", 3007 format("int q() {\n" 3008 " f(x)\n;\n" 3009 " f(x)\n {}\n" 3010 " f(x)\n->g();\n" 3011 " f(x)\n->*g();\n" 3012 " f(x)\n.g();\n" 3013 " f(x)\n = x;\n" 3014 " f(x)\n += x;\n" 3015 " f(x)\n -= x;\n" 3016 " f(x)\n *= x;\n" 3017 " f(x)\n /= x;\n" 3018 " f(x)\n %= x;\n" 3019 " f(x)\n &= x;\n" 3020 " f(x)\n |= x;\n" 3021 " f(x)\n ^= x;\n" 3022 " f(x)\n >>= x;\n" 3023 " f(x)\n <<= x;\n" 3024 " f(x)\n[y].z();\n" 3025 " LOG(INFO)\n << x;\n" 3026 " ifstream(x)\n >> x;\n" 3027 "}\n")); 3028 EXPECT_EQ("int q() {\n" 3029 " F(x)\n" 3030 " if (1) {\n" 3031 " }\n" 3032 " F(x)\n" 3033 " while (1) {\n" 3034 " }\n" 3035 " F(x)\n" 3036 " G(x);\n" 3037 " F(x)\n" 3038 " try {\n" 3039 " Q();\n" 3040 " } catch (...) {\n" 3041 " }\n" 3042 "}\n", 3043 format("int q() {\n" 3044 "F(x)\n" 3045 "if (1) {}\n" 3046 "F(x)\n" 3047 "while (1) {}\n" 3048 "F(x)\n" 3049 "G(x);\n" 3050 "F(x)\n" 3051 "try { Q(); } catch (...) {}\n" 3052 "}\n")); 3053 EXPECT_EQ("class A {\n" 3054 " A() : t(0) {}\n" 3055 " A(int i) noexcept() : {}\n" 3056 " A(X x)\n" // FIXME: function-level try blocks are broken. 3057 " try : t(0) {\n" 3058 " } catch (...) {\n" 3059 " }\n" 3060 "};", 3061 format("class A {\n" 3062 " A()\n : t(0) {}\n" 3063 " A(int i)\n noexcept() : {}\n" 3064 " A(X x)\n" 3065 " try : t(0) {} catch (...) {}\n" 3066 "};")); 3067 FormatStyle Style = getLLVMStyle(); 3068 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 3069 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 3070 Style.BraceWrapping.AfterFunction = true; 3071 EXPECT_EQ("void f()\n" 3072 "try\n" 3073 "{\n" 3074 "}", 3075 format("void f() try {\n" 3076 "}", 3077 Style)); 3078 EXPECT_EQ("class SomeClass {\n" 3079 "public:\n" 3080 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3081 "};", 3082 format("class SomeClass {\n" 3083 "public:\n" 3084 " SomeClass()\n" 3085 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3086 "};")); 3087 EXPECT_EQ("class SomeClass {\n" 3088 "public:\n" 3089 " SomeClass()\n" 3090 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3091 "};", 3092 format("class SomeClass {\n" 3093 "public:\n" 3094 " SomeClass()\n" 3095 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3096 "};", 3097 getLLVMStyleWithColumns(40))); 3098 3099 verifyFormat("MACRO(>)"); 3100 3101 // Some macros contain an implicit semicolon. 3102 Style = getLLVMStyle(); 3103 Style.StatementMacros.push_back("FOO"); 3104 verifyFormat("FOO(a) int b = 0;"); 3105 verifyFormat("FOO(a)\n" 3106 "int b = 0;", 3107 Style); 3108 verifyFormat("FOO(a);\n" 3109 "int b = 0;", 3110 Style); 3111 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 3112 "int b = 0;", 3113 Style); 3114 verifyFormat("FOO()\n" 3115 "int b = 0;", 3116 Style); 3117 verifyFormat("FOO\n" 3118 "int b = 0;", 3119 Style); 3120 verifyFormat("void f() {\n" 3121 " FOO(a)\n" 3122 " return a;\n" 3123 "}", 3124 Style); 3125 verifyFormat("FOO(a)\n" 3126 "FOO(b)", 3127 Style); 3128 verifyFormat("int a = 0;\n" 3129 "FOO(b)\n" 3130 "int c = 0;", 3131 Style); 3132 verifyFormat("int a = 0;\n" 3133 "int x = FOO(a)\n" 3134 "int b = 0;", 3135 Style); 3136 verifyFormat("void foo(int a) { FOO(a) }\n" 3137 "uint32_t bar() {}", 3138 Style); 3139 } 3140 3141 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 3142 verifyFormat("#define A \\\n" 3143 " f({ \\\n" 3144 " g(); \\\n" 3145 " });", 3146 getLLVMStyleWithColumns(11)); 3147 } 3148 3149 TEST_F(FormatTest, IndentPreprocessorDirectives) { 3150 FormatStyle Style = getLLVMStyle(); 3151 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 3152 Style.ColumnLimit = 40; 3153 verifyFormat("#ifdef _WIN32\n" 3154 "#define A 0\n" 3155 "#ifdef VAR2\n" 3156 "#define B 1\n" 3157 "#include <someheader.h>\n" 3158 "#define MACRO \\\n" 3159 " some_very_long_func_aaaaaaaaaa();\n" 3160 "#endif\n" 3161 "#else\n" 3162 "#define A 1\n" 3163 "#endif", 3164 Style); 3165 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 3166 verifyFormat("#ifdef _WIN32\n" 3167 "# define A 0\n" 3168 "# ifdef VAR2\n" 3169 "# define B 1\n" 3170 "# include <someheader.h>\n" 3171 "# define MACRO \\\n" 3172 " some_very_long_func_aaaaaaaaaa();\n" 3173 "# endif\n" 3174 "#else\n" 3175 "# define A 1\n" 3176 "#endif", 3177 Style); 3178 verifyFormat("#if A\n" 3179 "# define MACRO \\\n" 3180 " void a(int x) { \\\n" 3181 " b(); \\\n" 3182 " c(); \\\n" 3183 " d(); \\\n" 3184 " e(); \\\n" 3185 " f(); \\\n" 3186 " }\n" 3187 "#endif", 3188 Style); 3189 // Comments before include guard. 3190 verifyFormat("// file comment\n" 3191 "// file comment\n" 3192 "#ifndef HEADER_H\n" 3193 "#define HEADER_H\n" 3194 "code();\n" 3195 "#endif", 3196 Style); 3197 // Test with include guards. 3198 verifyFormat("#ifndef HEADER_H\n" 3199 "#define HEADER_H\n" 3200 "code();\n" 3201 "#endif", 3202 Style); 3203 // Include guards must have a #define with the same variable immediately 3204 // after #ifndef. 3205 verifyFormat("#ifndef NOT_GUARD\n" 3206 "# define FOO\n" 3207 "code();\n" 3208 "#endif", 3209 Style); 3210 3211 // Include guards must cover the entire file. 3212 verifyFormat("code();\n" 3213 "code();\n" 3214 "#ifndef NOT_GUARD\n" 3215 "# define NOT_GUARD\n" 3216 "code();\n" 3217 "#endif", 3218 Style); 3219 verifyFormat("#ifndef NOT_GUARD\n" 3220 "# define NOT_GUARD\n" 3221 "code();\n" 3222 "#endif\n" 3223 "code();", 3224 Style); 3225 // Test with trailing blank lines. 3226 verifyFormat("#ifndef HEADER_H\n" 3227 "#define HEADER_H\n" 3228 "code();\n" 3229 "#endif\n", 3230 Style); 3231 // Include guards don't have #else. 3232 verifyFormat("#ifndef NOT_GUARD\n" 3233 "# define NOT_GUARD\n" 3234 "code();\n" 3235 "#else\n" 3236 "#endif", 3237 Style); 3238 verifyFormat("#ifndef NOT_GUARD\n" 3239 "# define NOT_GUARD\n" 3240 "code();\n" 3241 "#elif FOO\n" 3242 "#endif", 3243 Style); 3244 // Non-identifier #define after potential include guard. 3245 verifyFormat("#ifndef FOO\n" 3246 "# define 1\n" 3247 "#endif\n", 3248 Style); 3249 // #if closes past last non-preprocessor line. 3250 verifyFormat("#ifndef FOO\n" 3251 "#define FOO\n" 3252 "#if 1\n" 3253 "int i;\n" 3254 "# define A 0\n" 3255 "#endif\n" 3256 "#endif\n", 3257 Style); 3258 // Don't crash if there is an #elif directive without a condition. 3259 verifyFormat("#if 1\n" 3260 "int x;\n" 3261 "#elif\n" 3262 "int y;\n" 3263 "#else\n" 3264 "int z;\n" 3265 "#endif", 3266 Style); 3267 // FIXME: This doesn't handle the case where there's code between the 3268 // #ifndef and #define but all other conditions hold. This is because when 3269 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 3270 // previous code line yet, so we can't detect it. 3271 EXPECT_EQ("#ifndef NOT_GUARD\n" 3272 "code();\n" 3273 "#define NOT_GUARD\n" 3274 "code();\n" 3275 "#endif", 3276 format("#ifndef NOT_GUARD\n" 3277 "code();\n" 3278 "# define NOT_GUARD\n" 3279 "code();\n" 3280 "#endif", 3281 Style)); 3282 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 3283 // be outside an include guard. Examples are #pragma once and 3284 // #pragma GCC diagnostic, or anything else that does not change the meaning 3285 // of the file if it's included multiple times. 3286 EXPECT_EQ("#ifdef WIN32\n" 3287 "# pragma once\n" 3288 "#endif\n" 3289 "#ifndef HEADER_H\n" 3290 "# define HEADER_H\n" 3291 "code();\n" 3292 "#endif", 3293 format("#ifdef WIN32\n" 3294 "# pragma once\n" 3295 "#endif\n" 3296 "#ifndef HEADER_H\n" 3297 "#define HEADER_H\n" 3298 "code();\n" 3299 "#endif", 3300 Style)); 3301 // FIXME: This does not detect when there is a single non-preprocessor line 3302 // in front of an include-guard-like structure where other conditions hold 3303 // because ScopedLineState hides the line. 3304 EXPECT_EQ("code();\n" 3305 "#ifndef HEADER_H\n" 3306 "#define HEADER_H\n" 3307 "code();\n" 3308 "#endif", 3309 format("code();\n" 3310 "#ifndef HEADER_H\n" 3311 "# define HEADER_H\n" 3312 "code();\n" 3313 "#endif", 3314 Style)); 3315 // Keep comments aligned with #, otherwise indent comments normally. These 3316 // tests cannot use verifyFormat because messUp manipulates leading 3317 // whitespace. 3318 { 3319 const char *Expected = "" 3320 "void f() {\n" 3321 "#if 1\n" 3322 "// Preprocessor aligned.\n" 3323 "# define A 0\n" 3324 " // Code. Separated by blank line.\n" 3325 "\n" 3326 "# define B 0\n" 3327 " // Code. Not aligned with #\n" 3328 "# define C 0\n" 3329 "#endif"; 3330 const char *ToFormat = "" 3331 "void f() {\n" 3332 "#if 1\n" 3333 "// Preprocessor aligned.\n" 3334 "# define A 0\n" 3335 "// Code. Separated by blank line.\n" 3336 "\n" 3337 "# define B 0\n" 3338 " // Code. Not aligned with #\n" 3339 "# define C 0\n" 3340 "#endif"; 3341 EXPECT_EQ(Expected, format(ToFormat, Style)); 3342 EXPECT_EQ(Expected, format(Expected, Style)); 3343 } 3344 // Keep block quotes aligned. 3345 { 3346 const char *Expected = "" 3347 "void f() {\n" 3348 "#if 1\n" 3349 "/* Preprocessor aligned. */\n" 3350 "# define A 0\n" 3351 " /* Code. Separated by blank line. */\n" 3352 "\n" 3353 "# define B 0\n" 3354 " /* Code. Not aligned with # */\n" 3355 "# define C 0\n" 3356 "#endif"; 3357 const char *ToFormat = "" 3358 "void f() {\n" 3359 "#if 1\n" 3360 "/* Preprocessor aligned. */\n" 3361 "# define A 0\n" 3362 "/* Code. Separated by blank line. */\n" 3363 "\n" 3364 "# define B 0\n" 3365 " /* Code. Not aligned with # */\n" 3366 "# define C 0\n" 3367 "#endif"; 3368 EXPECT_EQ(Expected, format(ToFormat, Style)); 3369 EXPECT_EQ(Expected, format(Expected, Style)); 3370 } 3371 // Keep comments aligned with un-indented directives. 3372 { 3373 const char *Expected = "" 3374 "void f() {\n" 3375 "// Preprocessor aligned.\n" 3376 "#define A 0\n" 3377 " // Code. Separated by blank line.\n" 3378 "\n" 3379 "#define B 0\n" 3380 " // Code. Not aligned with #\n" 3381 "#define C 0\n"; 3382 const char *ToFormat = "" 3383 "void f() {\n" 3384 "// Preprocessor aligned.\n" 3385 "#define A 0\n" 3386 "// Code. Separated by blank line.\n" 3387 "\n" 3388 "#define B 0\n" 3389 " // Code. Not aligned with #\n" 3390 "#define C 0\n"; 3391 EXPECT_EQ(Expected, format(ToFormat, Style)); 3392 EXPECT_EQ(Expected, format(Expected, Style)); 3393 } 3394 // Test AfterHash with tabs. 3395 { 3396 FormatStyle Tabbed = Style; 3397 Tabbed.UseTab = FormatStyle::UT_Always; 3398 Tabbed.IndentWidth = 8; 3399 Tabbed.TabWidth = 8; 3400 verifyFormat("#ifdef _WIN32\n" 3401 "#\tdefine A 0\n" 3402 "#\tifdef VAR2\n" 3403 "#\t\tdefine B 1\n" 3404 "#\t\tinclude <someheader.h>\n" 3405 "#\t\tdefine MACRO \\\n" 3406 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3407 "#\tendif\n" 3408 "#else\n" 3409 "#\tdefine A 1\n" 3410 "#endif", 3411 Tabbed); 3412 } 3413 3414 // Regression test: Multiline-macro inside include guards. 3415 verifyFormat("#ifndef HEADER_H\n" 3416 "#define HEADER_H\n" 3417 "#define A() \\\n" 3418 " int i; \\\n" 3419 " int j;\n" 3420 "#endif // HEADER_H", 3421 getLLVMStyleWithColumns(20)); 3422 3423 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3424 // Basic before hash indent tests 3425 verifyFormat("#ifdef _WIN32\n" 3426 " #define A 0\n" 3427 " #ifdef VAR2\n" 3428 " #define B 1\n" 3429 " #include <someheader.h>\n" 3430 " #define MACRO \\\n" 3431 " some_very_long_func_aaaaaaaaaa();\n" 3432 " #endif\n" 3433 "#else\n" 3434 " #define A 1\n" 3435 "#endif", 3436 Style); 3437 verifyFormat("#if A\n" 3438 " #define MACRO \\\n" 3439 " void a(int x) { \\\n" 3440 " b(); \\\n" 3441 " c(); \\\n" 3442 " d(); \\\n" 3443 " e(); \\\n" 3444 " f(); \\\n" 3445 " }\n" 3446 "#endif", 3447 Style); 3448 // Keep comments aligned with indented directives. These 3449 // tests cannot use verifyFormat because messUp manipulates leading 3450 // whitespace. 3451 { 3452 const char *Expected = "void f() {\n" 3453 "// Aligned to preprocessor.\n" 3454 "#if 1\n" 3455 " // Aligned to code.\n" 3456 " int a;\n" 3457 " #if 1\n" 3458 " // Aligned to preprocessor.\n" 3459 " #define A 0\n" 3460 " // Aligned to code.\n" 3461 " int b;\n" 3462 " #endif\n" 3463 "#endif\n" 3464 "}"; 3465 const char *ToFormat = "void f() {\n" 3466 "// Aligned to preprocessor.\n" 3467 "#if 1\n" 3468 "// Aligned to code.\n" 3469 "int a;\n" 3470 "#if 1\n" 3471 "// Aligned to preprocessor.\n" 3472 "#define A 0\n" 3473 "// Aligned to code.\n" 3474 "int b;\n" 3475 "#endif\n" 3476 "#endif\n" 3477 "}"; 3478 EXPECT_EQ(Expected, format(ToFormat, Style)); 3479 EXPECT_EQ(Expected, format(Expected, Style)); 3480 } 3481 { 3482 const char *Expected = "void f() {\n" 3483 "/* Aligned to preprocessor. */\n" 3484 "#if 1\n" 3485 " /* Aligned to code. */\n" 3486 " int a;\n" 3487 " #if 1\n" 3488 " /* Aligned to preprocessor. */\n" 3489 " #define A 0\n" 3490 " /* Aligned to code. */\n" 3491 " int b;\n" 3492 " #endif\n" 3493 "#endif\n" 3494 "}"; 3495 const char *ToFormat = "void f() {\n" 3496 "/* Aligned to preprocessor. */\n" 3497 "#if 1\n" 3498 "/* Aligned to code. */\n" 3499 "int a;\n" 3500 "#if 1\n" 3501 "/* Aligned to preprocessor. */\n" 3502 "#define A 0\n" 3503 "/* Aligned to code. */\n" 3504 "int b;\n" 3505 "#endif\n" 3506 "#endif\n" 3507 "}"; 3508 EXPECT_EQ(Expected, format(ToFormat, Style)); 3509 EXPECT_EQ(Expected, format(Expected, Style)); 3510 } 3511 3512 // Test single comment before preprocessor 3513 verifyFormat("// Comment\n" 3514 "\n" 3515 "#if 1\n" 3516 "#endif", 3517 Style); 3518 } 3519 3520 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3521 verifyFormat("{\n { a #c; }\n}"); 3522 } 3523 3524 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3525 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3526 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3527 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3528 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3529 } 3530 3531 TEST_F(FormatTest, EscapedNewlines) { 3532 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3533 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3534 format("#define A \\\nint i;\\\n int j;", Narrow)); 3535 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3536 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3537 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3538 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3539 3540 FormatStyle AlignLeft = getLLVMStyle(); 3541 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3542 EXPECT_EQ("#define MACRO(x) \\\n" 3543 "private: \\\n" 3544 " int x(int a);\n", 3545 format("#define MACRO(x) \\\n" 3546 "private: \\\n" 3547 " int x(int a);\n", 3548 AlignLeft)); 3549 3550 // CRLF line endings 3551 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3552 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3553 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3554 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3555 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3556 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3557 EXPECT_EQ("#define MACRO(x) \\\r\n" 3558 "private: \\\r\n" 3559 " int x(int a);\r\n", 3560 format("#define MACRO(x) \\\r\n" 3561 "private: \\\r\n" 3562 " int x(int a);\r\n", 3563 AlignLeft)); 3564 3565 FormatStyle DontAlign = getLLVMStyle(); 3566 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3567 DontAlign.MaxEmptyLinesToKeep = 3; 3568 // FIXME: can't use verifyFormat here because the newline before 3569 // "public:" is not inserted the first time it's reformatted 3570 EXPECT_EQ("#define A \\\n" 3571 " class Foo { \\\n" 3572 " void bar(); \\\n" 3573 "\\\n" 3574 "\\\n" 3575 "\\\n" 3576 " public: \\\n" 3577 " void baz(); \\\n" 3578 " };", 3579 format("#define A \\\n" 3580 " class Foo { \\\n" 3581 " void bar(); \\\n" 3582 "\\\n" 3583 "\\\n" 3584 "\\\n" 3585 " public: \\\n" 3586 " void baz(); \\\n" 3587 " };", 3588 DontAlign)); 3589 } 3590 3591 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3592 verifyFormat("#define A \\\n" 3593 " int v( \\\n" 3594 " a); \\\n" 3595 " int i;", 3596 getLLVMStyleWithColumns(11)); 3597 } 3598 3599 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3600 EXPECT_EQ( 3601 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3602 " \\\n" 3603 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3604 "\n" 3605 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3606 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3607 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3608 "\\\n" 3609 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3610 " \n" 3611 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3612 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3613 } 3614 3615 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3616 EXPECT_EQ("int\n" 3617 "#define A\n" 3618 " a;", 3619 format("int\n#define A\na;")); 3620 verifyFormat("functionCallTo(\n" 3621 " someOtherFunction(\n" 3622 " withSomeParameters, whichInSequence,\n" 3623 " areLongerThanALine(andAnotherCall,\n" 3624 "#define A B\n" 3625 " withMoreParamters,\n" 3626 " whichStronglyInfluenceTheLayout),\n" 3627 " andMoreParameters),\n" 3628 " trailing);", 3629 getLLVMStyleWithColumns(69)); 3630 verifyFormat("Foo::Foo()\n" 3631 "#ifdef BAR\n" 3632 " : baz(0)\n" 3633 "#endif\n" 3634 "{\n" 3635 "}"); 3636 verifyFormat("void f() {\n" 3637 " if (true)\n" 3638 "#ifdef A\n" 3639 " f(42);\n" 3640 " x();\n" 3641 "#else\n" 3642 " g();\n" 3643 " x();\n" 3644 "#endif\n" 3645 "}"); 3646 verifyFormat("void f(param1, param2,\n" 3647 " param3,\n" 3648 "#ifdef A\n" 3649 " param4(param5,\n" 3650 "#ifdef A1\n" 3651 " param6,\n" 3652 "#ifdef A2\n" 3653 " param7),\n" 3654 "#else\n" 3655 " param8),\n" 3656 " param9,\n" 3657 "#endif\n" 3658 " param10,\n" 3659 "#endif\n" 3660 " param11)\n" 3661 "#else\n" 3662 " param12)\n" 3663 "#endif\n" 3664 "{\n" 3665 " x();\n" 3666 "}", 3667 getLLVMStyleWithColumns(28)); 3668 verifyFormat("#if 1\n" 3669 "int i;"); 3670 verifyFormat("#if 1\n" 3671 "#endif\n" 3672 "#if 1\n" 3673 "#else\n" 3674 "#endif\n"); 3675 verifyFormat("DEBUG({\n" 3676 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3677 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3678 "});\n" 3679 "#if a\n" 3680 "#else\n" 3681 "#endif"); 3682 3683 verifyIncompleteFormat("void f(\n" 3684 "#if A\n" 3685 ");\n" 3686 "#else\n" 3687 "#endif"); 3688 } 3689 3690 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3691 verifyFormat("#endif\n" 3692 "#if B"); 3693 } 3694 3695 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3696 FormatStyle SingleLine = getLLVMStyle(); 3697 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3698 verifyFormat("#if 0\n" 3699 "#elif 1\n" 3700 "#endif\n" 3701 "void foo() {\n" 3702 " if (test) foo2();\n" 3703 "}", 3704 SingleLine); 3705 } 3706 3707 TEST_F(FormatTest, LayoutBlockInsideParens) { 3708 verifyFormat("functionCall({ int i; });"); 3709 verifyFormat("functionCall({\n" 3710 " int i;\n" 3711 " int j;\n" 3712 "});"); 3713 verifyFormat("functionCall(\n" 3714 " {\n" 3715 " int i;\n" 3716 " int j;\n" 3717 " },\n" 3718 " aaaa, bbbb, cccc);"); 3719 verifyFormat("functionA(functionB({\n" 3720 " int i;\n" 3721 " int j;\n" 3722 " }),\n" 3723 " aaaa, bbbb, cccc);"); 3724 verifyFormat("functionCall(\n" 3725 " {\n" 3726 " int i;\n" 3727 " int j;\n" 3728 " },\n" 3729 " aaaa, bbbb, // comment\n" 3730 " cccc);"); 3731 verifyFormat("functionA(functionB({\n" 3732 " int i;\n" 3733 " int j;\n" 3734 " }),\n" 3735 " aaaa, bbbb, // comment\n" 3736 " cccc);"); 3737 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3738 verifyFormat("functionCall(aaaa, bbbb, {\n" 3739 " int i;\n" 3740 " int j;\n" 3741 "});"); 3742 verifyFormat( 3743 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3744 " {\n" 3745 " int i; // break\n" 3746 " },\n" 3747 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3748 " ccccccccccccccccc));"); 3749 verifyFormat("DEBUG({\n" 3750 " if (a)\n" 3751 " f();\n" 3752 "});"); 3753 } 3754 3755 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3756 EXPECT_EQ("SOME_MACRO { int i; }\n" 3757 "int i;", 3758 format(" SOME_MACRO {int i;} int i;")); 3759 } 3760 3761 TEST_F(FormatTest, LayoutNestedBlocks) { 3762 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3763 " struct s {\n" 3764 " int i;\n" 3765 " };\n" 3766 " s kBitsToOs[] = {{10}};\n" 3767 " for (int i = 0; i < 10; ++i)\n" 3768 " return;\n" 3769 "}"); 3770 verifyFormat("call(parameter, {\n" 3771 " something();\n" 3772 " // Comment using all columns.\n" 3773 " somethingelse();\n" 3774 "});", 3775 getLLVMStyleWithColumns(40)); 3776 verifyFormat("DEBUG( //\n" 3777 " { f(); }, a);"); 3778 verifyFormat("DEBUG( //\n" 3779 " {\n" 3780 " f(); //\n" 3781 " },\n" 3782 " a);"); 3783 3784 EXPECT_EQ("call(parameter, {\n" 3785 " something();\n" 3786 " // Comment too\n" 3787 " // looooooooooong.\n" 3788 " somethingElse();\n" 3789 "});", 3790 format("call(parameter, {\n" 3791 " something();\n" 3792 " // Comment too looooooooooong.\n" 3793 " somethingElse();\n" 3794 "});", 3795 getLLVMStyleWithColumns(29))); 3796 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3797 EXPECT_EQ("DEBUG({ // comment\n" 3798 " int i;\n" 3799 "});", 3800 format("DEBUG({ // comment\n" 3801 "int i;\n" 3802 "});")); 3803 EXPECT_EQ("DEBUG({\n" 3804 " int i;\n" 3805 "\n" 3806 " // comment\n" 3807 " int j;\n" 3808 "});", 3809 format("DEBUG({\n" 3810 " int i;\n" 3811 "\n" 3812 " // comment\n" 3813 " int j;\n" 3814 "});")); 3815 3816 verifyFormat("DEBUG({\n" 3817 " if (a)\n" 3818 " return;\n" 3819 "});"); 3820 verifyGoogleFormat("DEBUG({\n" 3821 " if (a) return;\n" 3822 "});"); 3823 FormatStyle Style = getGoogleStyle(); 3824 Style.ColumnLimit = 45; 3825 verifyFormat("Debug(\n" 3826 " aaaaa,\n" 3827 " {\n" 3828 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 3829 " },\n" 3830 " a);", 3831 Style); 3832 3833 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 3834 3835 verifyNoCrash("^{v^{a}}"); 3836 } 3837 3838 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 3839 EXPECT_EQ("#define MACRO() \\\n" 3840 " Debug(aaa, /* force line break */ \\\n" 3841 " { \\\n" 3842 " int i; \\\n" 3843 " int j; \\\n" 3844 " })", 3845 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 3846 " { int i; int j; })", 3847 getGoogleStyle())); 3848 3849 EXPECT_EQ("#define A \\\n" 3850 " [] { \\\n" 3851 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3852 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 3853 " }", 3854 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3855 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 3856 getGoogleStyle())); 3857 } 3858 3859 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 3860 EXPECT_EQ("{}", format("{}")); 3861 verifyFormat("enum E {};"); 3862 verifyFormat("enum E {}"); 3863 FormatStyle Style = getLLVMStyle(); 3864 Style.SpaceInEmptyBlock = true; 3865 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 3866 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 3867 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 3868 } 3869 3870 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 3871 FormatStyle Style = getLLVMStyle(); 3872 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 3873 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 3874 verifyFormat("FOO_BEGIN\n" 3875 " FOO_ENTRY\n" 3876 "FOO_END", 3877 Style); 3878 verifyFormat("FOO_BEGIN\n" 3879 " NESTED_FOO_BEGIN\n" 3880 " NESTED_FOO_ENTRY\n" 3881 " NESTED_FOO_END\n" 3882 "FOO_END", 3883 Style); 3884 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 3885 " int x;\n" 3886 " x = 1;\n" 3887 "FOO_END(Baz)", 3888 Style); 3889 } 3890 3891 //===----------------------------------------------------------------------===// 3892 // Line break tests. 3893 //===----------------------------------------------------------------------===// 3894 3895 TEST_F(FormatTest, PreventConfusingIndents) { 3896 verifyFormat( 3897 "void f() {\n" 3898 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 3899 " parameter, parameter, parameter)),\n" 3900 " SecondLongCall(parameter));\n" 3901 "}"); 3902 verifyFormat( 3903 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3904 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3905 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3906 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 3907 verifyFormat( 3908 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3909 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 3910 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 3911 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 3912 verifyFormat( 3913 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 3914 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 3915 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 3916 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 3917 verifyFormat("int a = bbbb && ccc &&\n" 3918 " fffff(\n" 3919 "#define A Just forcing a new line\n" 3920 " ddd);"); 3921 } 3922 3923 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 3924 verifyFormat( 3925 "bool aaaaaaa =\n" 3926 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 3927 " bbbbbbbb();"); 3928 verifyFormat( 3929 "bool aaaaaaa =\n" 3930 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 3931 " bbbbbbbb();"); 3932 3933 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3934 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 3935 " ccccccccc == ddddddddddd;"); 3936 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 3937 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 3938 " ccccccccc == ddddddddddd;"); 3939 verifyFormat( 3940 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 3941 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 3942 " ccccccccc == ddddddddddd;"); 3943 3944 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3945 " aaaaaa) &&\n" 3946 " bbbbbb && cccccc;"); 3947 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 3948 " aaaaaa) >>\n" 3949 " bbbbbb;"); 3950 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 3951 " SourceMgr.getSpellingColumnNumber(\n" 3952 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 3953 " 1);"); 3954 3955 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3956 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 3957 " cccccc) {\n}"); 3958 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3959 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3960 " cccccc) {\n}"); 3961 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3962 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 3963 " cccccc) {\n}"); 3964 verifyFormat("b = a &&\n" 3965 " // Comment\n" 3966 " b.c && d;"); 3967 3968 // If the LHS of a comparison is not a binary expression itself, the 3969 // additional linebreak confuses many people. 3970 verifyFormat( 3971 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3972 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 3973 "}"); 3974 verifyFormat( 3975 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3976 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3977 "}"); 3978 verifyFormat( 3979 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 3980 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3981 "}"); 3982 verifyFormat( 3983 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3984 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 3985 "}"); 3986 // Even explicit parentheses stress the precedence enough to make the 3987 // additional break unnecessary. 3988 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3989 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 3990 "}"); 3991 // This cases is borderline, but with the indentation it is still readable. 3992 verifyFormat( 3993 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3994 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3995 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 3996 "}", 3997 getLLVMStyleWithColumns(75)); 3998 3999 // If the LHS is a binary expression, we should still use the additional break 4000 // as otherwise the formatting hides the operator precedence. 4001 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4002 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4003 " 5) {\n" 4004 "}"); 4005 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4006 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 4007 " 5) {\n" 4008 "}"); 4009 4010 FormatStyle OnePerLine = getLLVMStyle(); 4011 OnePerLine.BinPackParameters = false; 4012 verifyFormat( 4013 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4014 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4015 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 4016 OnePerLine); 4017 4018 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 4019 " .aaa(aaaaaaaaaaaaa) *\n" 4020 " aaaaaaa +\n" 4021 " aaaaaaa;", 4022 getLLVMStyleWithColumns(40)); 4023 } 4024 4025 TEST_F(FormatTest, ExpressionIndentation) { 4026 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4027 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4028 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4029 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4030 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 4031 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 4032 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4033 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 4034 " ccccccccccccccccccccccccccccccccccccccccc;"); 4035 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4036 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4037 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4038 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4039 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4040 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4041 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4042 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4043 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4044 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4045 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4046 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4047 verifyFormat("if () {\n" 4048 "} else if (aaaaa && bbbbb > // break\n" 4049 " ccccc) {\n" 4050 "}"); 4051 verifyFormat("if () {\n" 4052 "} else if constexpr (aaaaa && bbbbb > // break\n" 4053 " ccccc) {\n" 4054 "}"); 4055 verifyFormat("if () {\n" 4056 "} else if CONSTEXPR (aaaaa && bbbbb > // break\n" 4057 " ccccc) {\n" 4058 "}"); 4059 verifyFormat("if () {\n" 4060 "} else if (aaaaa &&\n" 4061 " bbbbb > // break\n" 4062 " ccccc &&\n" 4063 " ddddd) {\n" 4064 "}"); 4065 4066 // Presence of a trailing comment used to change indentation of b. 4067 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 4068 " b;\n" 4069 "return aaaaaaaaaaaaaaaaaaa +\n" 4070 " b; //", 4071 getLLVMStyleWithColumns(30)); 4072 } 4073 4074 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 4075 // Not sure what the best system is here. Like this, the LHS can be found 4076 // immediately above an operator (everything with the same or a higher 4077 // indent). The RHS is aligned right of the operator and so compasses 4078 // everything until something with the same indent as the operator is found. 4079 // FIXME: Is this a good system? 4080 FormatStyle Style = getLLVMStyle(); 4081 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 4082 verifyFormat( 4083 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4084 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4085 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4086 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4087 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4088 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4089 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4090 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4091 " > ccccccccccccccccccccccccccccccccccccccccc;", 4092 Style); 4093 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4094 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4095 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4096 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4097 Style); 4098 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4099 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4100 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4101 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4102 Style); 4103 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4104 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4105 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4106 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4107 Style); 4108 verifyFormat("if () {\n" 4109 "} else if (aaaaa\n" 4110 " && bbbbb // break\n" 4111 " > ccccc) {\n" 4112 "}", 4113 Style); 4114 verifyFormat("return (a)\n" 4115 " // comment\n" 4116 " + b;", 4117 Style); 4118 verifyFormat( 4119 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4120 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4121 " + cc;", 4122 Style); 4123 4124 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4125 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4126 Style); 4127 4128 // Forced by comments. 4129 verifyFormat( 4130 "unsigned ContentSize =\n" 4131 " sizeof(int16_t) // DWARF ARange version number\n" 4132 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4133 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4134 " + sizeof(int8_t); // Segment Size (in bytes)"); 4135 4136 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 4137 " == boost::fusion::at_c<1>(iiii).second;", 4138 Style); 4139 4140 Style.ColumnLimit = 60; 4141 verifyFormat("zzzzzzzzzz\n" 4142 " = bbbbbbbbbbbbbbbbb\n" 4143 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 4144 Style); 4145 4146 Style.ColumnLimit = 80; 4147 Style.IndentWidth = 4; 4148 Style.TabWidth = 4; 4149 Style.UseTab = FormatStyle::UT_Always; 4150 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4151 Style.AlignOperands = false; 4152 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 4153 "\t&& (someOtherLongishConditionPart1\n" 4154 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 4155 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && " 4156 "(someOtherLongishConditionPart1 || " 4157 "someOtherEvenLongerNestedConditionPart2);", 4158 Style)); 4159 } 4160 4161 TEST_F(FormatTest, EnforcedOperatorWraps) { 4162 // Here we'd like to wrap after the || operators, but a comment is forcing an 4163 // earlier wrap. 4164 verifyFormat("bool x = aaaaa //\n" 4165 " || bbbbb\n" 4166 " //\n" 4167 " || cccc;"); 4168 } 4169 4170 TEST_F(FormatTest, NoOperandAlignment) { 4171 FormatStyle Style = getLLVMStyle(); 4172 Style.AlignOperands = false; 4173 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 4174 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4175 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4176 Style); 4177 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4178 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4179 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4180 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4181 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4182 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4183 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4184 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4185 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4186 " > ccccccccccccccccccccccccccccccccccccccccc;", 4187 Style); 4188 4189 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4190 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4191 " + cc;", 4192 Style); 4193 verifyFormat("int a = aa\n" 4194 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4195 " * cccccccccccccccccccccccccccccccccccc;\n", 4196 Style); 4197 4198 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4199 verifyFormat("return (a > b\n" 4200 " // comment1\n" 4201 " // comment2\n" 4202 " || c);", 4203 Style); 4204 } 4205 4206 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 4207 FormatStyle Style = getLLVMStyle(); 4208 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4209 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4210 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4211 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4212 Style); 4213 } 4214 4215 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 4216 FormatStyle Style = getLLVMStyle(); 4217 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4218 Style.BinPackArguments = false; 4219 Style.ColumnLimit = 40; 4220 verifyFormat("void test() {\n" 4221 " someFunction(\n" 4222 " this + argument + is + quite\n" 4223 " + long + so + it + gets + wrapped\n" 4224 " + but + remains + bin - packed);\n" 4225 "}", 4226 Style); 4227 verifyFormat("void test() {\n" 4228 " someFunction(arg1,\n" 4229 " this + argument + is\n" 4230 " + quite + long + so\n" 4231 " + it + gets + wrapped\n" 4232 " + but + remains + bin\n" 4233 " - packed,\n" 4234 " arg3);\n" 4235 "}", 4236 Style); 4237 verifyFormat("void test() {\n" 4238 " someFunction(\n" 4239 " arg1,\n" 4240 " this + argument + has\n" 4241 " + anotherFunc(nested,\n" 4242 " calls + whose\n" 4243 " + arguments\n" 4244 " + are + also\n" 4245 " + wrapped,\n" 4246 " in + addition)\n" 4247 " + to + being + bin - packed,\n" 4248 " arg3);\n" 4249 "}", 4250 Style); 4251 4252 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4253 verifyFormat("void test() {\n" 4254 " someFunction(\n" 4255 " arg1,\n" 4256 " this + argument + has +\n" 4257 " anotherFunc(nested,\n" 4258 " calls + whose +\n" 4259 " arguments +\n" 4260 " are + also +\n" 4261 " wrapped,\n" 4262 " in + addition) +\n" 4263 " to + being + bin - packed,\n" 4264 " arg3);\n" 4265 "}", 4266 Style); 4267 } 4268 4269 TEST_F(FormatTest, ConstructorInitializers) { 4270 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4271 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 4272 getLLVMStyleWithColumns(45)); 4273 verifyFormat("Constructor()\n" 4274 " : Inttializer(FitsOnTheLine) {}", 4275 getLLVMStyleWithColumns(44)); 4276 verifyFormat("Constructor()\n" 4277 " : Inttializer(FitsOnTheLine) {}", 4278 getLLVMStyleWithColumns(43)); 4279 4280 verifyFormat("template <typename T>\n" 4281 "Constructor() : Initializer(FitsOnTheLine) {}", 4282 getLLVMStyleWithColumns(45)); 4283 4284 verifyFormat( 4285 "SomeClass::Constructor()\n" 4286 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4287 4288 verifyFormat( 4289 "SomeClass::Constructor()\n" 4290 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4291 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 4292 verifyFormat( 4293 "SomeClass::Constructor()\n" 4294 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4295 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4296 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4297 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4298 " : aaaaaaaaaa(aaaaaa) {}"); 4299 4300 verifyFormat("Constructor()\n" 4301 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4302 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4303 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4304 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 4305 4306 verifyFormat("Constructor()\n" 4307 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4308 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4309 4310 verifyFormat("Constructor(int Parameter = 0)\n" 4311 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4312 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 4313 verifyFormat("Constructor()\n" 4314 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4315 "}", 4316 getLLVMStyleWithColumns(60)); 4317 verifyFormat("Constructor()\n" 4318 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4319 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 4320 4321 // Here a line could be saved by splitting the second initializer onto two 4322 // lines, but that is not desirable. 4323 verifyFormat("Constructor()\n" 4324 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4325 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4326 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4327 4328 FormatStyle OnePerLine = getLLVMStyle(); 4329 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4330 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 4331 verifyFormat("SomeClass::Constructor()\n" 4332 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4333 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4334 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4335 OnePerLine); 4336 verifyFormat("SomeClass::Constructor()\n" 4337 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4338 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4339 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4340 OnePerLine); 4341 verifyFormat("MyClass::MyClass(int var)\n" 4342 " : some_var_(var), // 4 space indent\n" 4343 " some_other_var_(var + 1) { // lined up\n" 4344 "}", 4345 OnePerLine); 4346 verifyFormat("Constructor()\n" 4347 " : aaaaa(aaaaaa),\n" 4348 " aaaaa(aaaaaa),\n" 4349 " aaaaa(aaaaaa),\n" 4350 " aaaaa(aaaaaa),\n" 4351 " aaaaa(aaaaaa) {}", 4352 OnePerLine); 4353 verifyFormat("Constructor()\n" 4354 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4355 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4356 OnePerLine); 4357 OnePerLine.BinPackParameters = false; 4358 verifyFormat( 4359 "Constructor()\n" 4360 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4361 " aaaaaaaaaaa().aaa(),\n" 4362 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4363 OnePerLine); 4364 OnePerLine.ColumnLimit = 60; 4365 verifyFormat("Constructor()\n" 4366 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4367 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4368 OnePerLine); 4369 4370 EXPECT_EQ("Constructor()\n" 4371 " : // Comment forcing unwanted break.\n" 4372 " aaaa(aaaa) {}", 4373 format("Constructor() :\n" 4374 " // Comment forcing unwanted break.\n" 4375 " aaaa(aaaa) {}")); 4376 } 4377 4378 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 4379 FormatStyle Style = getLLVMStyle(); 4380 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4381 Style.ColumnLimit = 60; 4382 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4383 Style.AllowAllConstructorInitializersOnNextLine = true; 4384 Style.BinPackParameters = false; 4385 4386 for (int i = 0; i < 4; ++i) { 4387 // Test all combinations of parameters that should not have an effect. 4388 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4389 Style.AllowAllArgumentsOnNextLine = i & 2; 4390 4391 Style.AllowAllConstructorInitializersOnNextLine = true; 4392 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4393 verifyFormat("Constructor()\n" 4394 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4395 Style); 4396 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4397 4398 Style.AllowAllConstructorInitializersOnNextLine = false; 4399 verifyFormat("Constructor()\n" 4400 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4401 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4402 Style); 4403 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4404 4405 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4406 Style.AllowAllConstructorInitializersOnNextLine = true; 4407 verifyFormat("Constructor()\n" 4408 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4409 Style); 4410 4411 Style.AllowAllConstructorInitializersOnNextLine = false; 4412 verifyFormat("Constructor()\n" 4413 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4414 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4415 Style); 4416 4417 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4418 Style.AllowAllConstructorInitializersOnNextLine = true; 4419 verifyFormat("Constructor() :\n" 4420 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4421 Style); 4422 4423 Style.AllowAllConstructorInitializersOnNextLine = false; 4424 verifyFormat("Constructor() :\n" 4425 " aaaaaaaaaaaaaaaaaa(a),\n" 4426 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4427 Style); 4428 } 4429 4430 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4431 // AllowAllConstructorInitializersOnNextLine in all 4432 // BreakConstructorInitializers modes 4433 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4434 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4435 Style.AllowAllConstructorInitializersOnNextLine = false; 4436 verifyFormat("SomeClassWithALongName::Constructor(\n" 4437 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4438 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4439 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4440 Style); 4441 4442 Style.AllowAllConstructorInitializersOnNextLine = true; 4443 verifyFormat("SomeClassWithALongName::Constructor(\n" 4444 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4445 " int bbbbbbbbbbbbb,\n" 4446 " int cccccccccccccccc)\n" 4447 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4448 Style); 4449 4450 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4451 Style.AllowAllConstructorInitializersOnNextLine = false; 4452 verifyFormat("SomeClassWithALongName::Constructor(\n" 4453 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4454 " int bbbbbbbbbbbbb)\n" 4455 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4456 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4457 Style); 4458 4459 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4460 4461 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4462 verifyFormat("SomeClassWithALongName::Constructor(\n" 4463 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4464 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4465 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4466 Style); 4467 4468 Style.AllowAllConstructorInitializersOnNextLine = true; 4469 verifyFormat("SomeClassWithALongName::Constructor(\n" 4470 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4471 " int bbbbbbbbbbbbb,\n" 4472 " int cccccccccccccccc)\n" 4473 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4474 Style); 4475 4476 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4477 Style.AllowAllConstructorInitializersOnNextLine = false; 4478 verifyFormat("SomeClassWithALongName::Constructor(\n" 4479 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4480 " int bbbbbbbbbbbbb)\n" 4481 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4482 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4483 Style); 4484 4485 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4486 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4487 verifyFormat("SomeClassWithALongName::Constructor(\n" 4488 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4489 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4490 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4491 Style); 4492 4493 Style.AllowAllConstructorInitializersOnNextLine = true; 4494 verifyFormat("SomeClassWithALongName::Constructor(\n" 4495 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4496 " int bbbbbbbbbbbbb,\n" 4497 " int cccccccccccccccc) :\n" 4498 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4499 Style); 4500 4501 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4502 Style.AllowAllConstructorInitializersOnNextLine = false; 4503 verifyFormat("SomeClassWithALongName::Constructor(\n" 4504 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4505 " int bbbbbbbbbbbbb) :\n" 4506 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4507 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4508 Style); 4509 } 4510 4511 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4512 FormatStyle Style = getLLVMStyle(); 4513 Style.ColumnLimit = 60; 4514 Style.BinPackArguments = false; 4515 for (int i = 0; i < 4; ++i) { 4516 // Test all combinations of parameters that should not have an effect. 4517 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4518 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4519 4520 Style.AllowAllArgumentsOnNextLine = true; 4521 verifyFormat("void foo() {\n" 4522 " FunctionCallWithReallyLongName(\n" 4523 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4524 "}", 4525 Style); 4526 Style.AllowAllArgumentsOnNextLine = false; 4527 verifyFormat("void foo() {\n" 4528 " FunctionCallWithReallyLongName(\n" 4529 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4530 " bbbbbbbbbbbb);\n" 4531 "}", 4532 Style); 4533 4534 Style.AllowAllArgumentsOnNextLine = true; 4535 verifyFormat("void foo() {\n" 4536 " auto VariableWithReallyLongName = {\n" 4537 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4538 "}", 4539 Style); 4540 Style.AllowAllArgumentsOnNextLine = false; 4541 verifyFormat("void foo() {\n" 4542 " auto VariableWithReallyLongName = {\n" 4543 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4544 " bbbbbbbbbbbb};\n" 4545 "}", 4546 Style); 4547 } 4548 4549 // This parameter should not affect declarations. 4550 Style.BinPackParameters = false; 4551 Style.AllowAllArgumentsOnNextLine = false; 4552 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4553 verifyFormat("void FunctionCallWithReallyLongName(\n" 4554 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4555 Style); 4556 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4557 verifyFormat("void FunctionCallWithReallyLongName(\n" 4558 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4559 " int bbbbbbbbbbbb);", 4560 Style); 4561 } 4562 4563 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4564 FormatStyle Style = getLLVMStyle(); 4565 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4566 4567 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4568 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4569 getStyleWithColumns(Style, 45)); 4570 verifyFormat("Constructor() :\n" 4571 " Initializer(FitsOnTheLine) {}", 4572 getStyleWithColumns(Style, 44)); 4573 verifyFormat("Constructor() :\n" 4574 " Initializer(FitsOnTheLine) {}", 4575 getStyleWithColumns(Style, 43)); 4576 4577 verifyFormat("template <typename T>\n" 4578 "Constructor() : Initializer(FitsOnTheLine) {}", 4579 getStyleWithColumns(Style, 50)); 4580 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4581 verifyFormat( 4582 "SomeClass::Constructor() :\n" 4583 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4584 Style); 4585 4586 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4587 verifyFormat( 4588 "SomeClass::Constructor() :\n" 4589 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4590 Style); 4591 4592 verifyFormat( 4593 "SomeClass::Constructor() :\n" 4594 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4595 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4596 Style); 4597 verifyFormat( 4598 "SomeClass::Constructor() :\n" 4599 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4600 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4601 Style); 4602 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4603 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4604 " aaaaaaaaaa(aaaaaa) {}", 4605 Style); 4606 4607 verifyFormat("Constructor() :\n" 4608 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4609 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4610 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4611 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4612 Style); 4613 4614 verifyFormat("Constructor() :\n" 4615 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4616 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4617 Style); 4618 4619 verifyFormat("Constructor(int Parameter = 0) :\n" 4620 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4621 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4622 Style); 4623 verifyFormat("Constructor() :\n" 4624 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4625 "}", 4626 getStyleWithColumns(Style, 60)); 4627 verifyFormat("Constructor() :\n" 4628 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4629 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4630 Style); 4631 4632 // Here a line could be saved by splitting the second initializer onto two 4633 // lines, but that is not desirable. 4634 verifyFormat("Constructor() :\n" 4635 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4636 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4637 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4638 Style); 4639 4640 FormatStyle OnePerLine = Style; 4641 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4642 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4643 verifyFormat("SomeClass::Constructor() :\n" 4644 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4645 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4646 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4647 OnePerLine); 4648 verifyFormat("SomeClass::Constructor() :\n" 4649 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4650 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4651 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4652 OnePerLine); 4653 verifyFormat("MyClass::MyClass(int var) :\n" 4654 " some_var_(var), // 4 space indent\n" 4655 " some_other_var_(var + 1) { // lined up\n" 4656 "}", 4657 OnePerLine); 4658 verifyFormat("Constructor() :\n" 4659 " aaaaa(aaaaaa),\n" 4660 " aaaaa(aaaaaa),\n" 4661 " aaaaa(aaaaaa),\n" 4662 " aaaaa(aaaaaa),\n" 4663 " aaaaa(aaaaaa) {}", 4664 OnePerLine); 4665 verifyFormat("Constructor() :\n" 4666 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4667 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4668 OnePerLine); 4669 OnePerLine.BinPackParameters = false; 4670 verifyFormat("Constructor() :\n" 4671 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4672 " aaaaaaaaaaa().aaa(),\n" 4673 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4674 OnePerLine); 4675 OnePerLine.ColumnLimit = 60; 4676 verifyFormat("Constructor() :\n" 4677 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4678 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4679 OnePerLine); 4680 4681 EXPECT_EQ("Constructor() :\n" 4682 " // Comment forcing unwanted break.\n" 4683 " aaaa(aaaa) {}", 4684 format("Constructor() :\n" 4685 " // Comment forcing unwanted break.\n" 4686 " aaaa(aaaa) {}", 4687 Style)); 4688 4689 Style.ColumnLimit = 0; 4690 verifyFormat("SomeClass::Constructor() :\n" 4691 " a(a) {}", 4692 Style); 4693 verifyFormat("SomeClass::Constructor() noexcept :\n" 4694 " a(a) {}", 4695 Style); 4696 verifyFormat("SomeClass::Constructor() :\n" 4697 " a(a), b(b), c(c) {}", 4698 Style); 4699 verifyFormat("SomeClass::Constructor() :\n" 4700 " a(a) {\n" 4701 " foo();\n" 4702 " bar();\n" 4703 "}", 4704 Style); 4705 4706 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4707 verifyFormat("SomeClass::Constructor() :\n" 4708 " a(a), b(b), c(c) {\n" 4709 "}", 4710 Style); 4711 verifyFormat("SomeClass::Constructor() :\n" 4712 " a(a) {\n" 4713 "}", 4714 Style); 4715 4716 Style.ColumnLimit = 80; 4717 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4718 Style.ConstructorInitializerIndentWidth = 2; 4719 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style); 4720 verifyFormat("SomeClass::Constructor() :\n" 4721 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4722 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 4723 Style); 4724 4725 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as 4726 // well 4727 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 4728 verifyFormat( 4729 "class SomeClass\n" 4730 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4731 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4732 Style); 4733 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 4734 verifyFormat( 4735 "class SomeClass\n" 4736 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4737 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4738 Style); 4739 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 4740 verifyFormat( 4741 "class SomeClass :\n" 4742 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4743 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4744 Style); 4745 } 4746 4747 #ifndef EXPENSIVE_CHECKS 4748 // Expensive checks enables libstdc++ checking which includes validating the 4749 // state of ranges used in std::priority_queue - this blows out the 4750 // runtime/scalability of the function and makes this test unacceptably slow. 4751 TEST_F(FormatTest, MemoizationTests) { 4752 // This breaks if the memoization lookup does not take \c Indent and 4753 // \c LastSpace into account. 4754 verifyFormat( 4755 "extern CFRunLoopTimerRef\n" 4756 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 4757 " CFTimeInterval interval, CFOptionFlags flags,\n" 4758 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 4759 " CFRunLoopTimerContext *context) {}"); 4760 4761 // Deep nesting somewhat works around our memoization. 4762 verifyFormat( 4763 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4764 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4765 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4766 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4767 " aaaaa())))))))))))))))))))))))))))))))))))))));", 4768 getLLVMStyleWithColumns(65)); 4769 verifyFormat( 4770 "aaaaa(\n" 4771 " aaaaa,\n" 4772 " aaaaa(\n" 4773 " aaaaa,\n" 4774 " aaaaa(\n" 4775 " aaaaa,\n" 4776 " aaaaa(\n" 4777 " aaaaa,\n" 4778 " aaaaa(\n" 4779 " aaaaa,\n" 4780 " aaaaa(\n" 4781 " aaaaa,\n" 4782 " aaaaa(\n" 4783 " aaaaa,\n" 4784 " aaaaa(\n" 4785 " aaaaa,\n" 4786 " aaaaa(\n" 4787 " aaaaa,\n" 4788 " aaaaa(\n" 4789 " aaaaa,\n" 4790 " aaaaa(\n" 4791 " aaaaa,\n" 4792 " aaaaa(\n" 4793 " aaaaa,\n" 4794 " aaaaa))))))))))));", 4795 getLLVMStyleWithColumns(65)); 4796 verifyFormat( 4797 "a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(), a), a), a), a),\n" 4798 " a),\n" 4799 " a),\n" 4800 " a),\n" 4801 " a),\n" 4802 " a),\n" 4803 " a),\n" 4804 " a),\n" 4805 " a),\n" 4806 " a),\n" 4807 " a),\n" 4808 " a),\n" 4809 " a),\n" 4810 " a),\n" 4811 " a),\n" 4812 " a),\n" 4813 " a),\n" 4814 " a)", 4815 getLLVMStyleWithColumns(65)); 4816 4817 // This test takes VERY long when memoization is broken. 4818 FormatStyle OnePerLine = getLLVMStyle(); 4819 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4820 OnePerLine.BinPackParameters = false; 4821 std::string input = "Constructor()\n" 4822 " : aaaa(a,\n"; 4823 for (unsigned i = 0, e = 80; i != e; ++i) { 4824 input += " a,\n"; 4825 } 4826 input += " a) {}"; 4827 verifyFormat(input, OnePerLine); 4828 } 4829 #endif 4830 4831 TEST_F(FormatTest, BreaksAsHighAsPossible) { 4832 verifyFormat( 4833 "void f() {\n" 4834 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 4835 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 4836 " f();\n" 4837 "}"); 4838 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 4839 " Intervals[i - 1].getRange().getLast()) {\n}"); 4840 } 4841 4842 TEST_F(FormatTest, BreaksFunctionDeclarations) { 4843 // Principially, we break function declarations in a certain order: 4844 // 1) break amongst arguments. 4845 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 4846 " Cccccccccccccc cccccccccccccc);"); 4847 verifyFormat("template <class TemplateIt>\n" 4848 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 4849 " TemplateIt *stop) {}"); 4850 4851 // 2) break after return type. 4852 verifyFormat( 4853 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4854 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 4855 getGoogleStyle()); 4856 4857 // 3) break after (. 4858 verifyFormat( 4859 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 4860 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 4861 getGoogleStyle()); 4862 4863 // 4) break before after nested name specifiers. 4864 verifyFormat( 4865 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4866 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 4867 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 4868 getGoogleStyle()); 4869 4870 // However, there are exceptions, if a sufficient amount of lines can be 4871 // saved. 4872 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 4873 // more adjusting. 4874 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4875 " Cccccccccccccc cccccccccc,\n" 4876 " Cccccccccccccc cccccccccc,\n" 4877 " Cccccccccccccc cccccccccc,\n" 4878 " Cccccccccccccc cccccccccc);"); 4879 verifyFormat( 4880 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4881 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4882 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4883 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 4884 getGoogleStyle()); 4885 verifyFormat( 4886 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4887 " Cccccccccccccc cccccccccc,\n" 4888 " Cccccccccccccc cccccccccc,\n" 4889 " Cccccccccccccc cccccccccc,\n" 4890 " Cccccccccccccc cccccccccc,\n" 4891 " Cccccccccccccc cccccccccc,\n" 4892 " Cccccccccccccc cccccccccc);"); 4893 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4894 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4895 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4896 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4897 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 4898 4899 // Break after multi-line parameters. 4900 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4901 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4902 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4903 " bbbb bbbb);"); 4904 verifyFormat("void SomeLoooooooooooongFunction(\n" 4905 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 4906 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4907 " int bbbbbbbbbbbbb);"); 4908 4909 // Treat overloaded operators like other functions. 4910 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4911 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 4912 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4913 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 4914 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4915 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 4916 verifyGoogleFormat( 4917 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 4918 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4919 verifyGoogleFormat( 4920 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 4921 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 4922 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4923 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4924 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 4925 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 4926 verifyGoogleFormat( 4927 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 4928 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4929 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 4930 verifyGoogleFormat("template <typename T>\n" 4931 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4932 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 4933 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 4934 4935 FormatStyle Style = getLLVMStyle(); 4936 Style.PointerAlignment = FormatStyle::PAS_Left; 4937 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4938 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 4939 Style); 4940 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 4941 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4942 Style); 4943 } 4944 4945 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 4946 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 4947 // Prefer keeping `::` followed by `operator` together. 4948 EXPECT_EQ("const aaaa::bbbbbbb &\n" 4949 "ccccccccc::operator++() {\n" 4950 " stuff();\n" 4951 "}", 4952 format("const aaaa::bbbbbbb\n" 4953 "&ccccccccc::operator++() { stuff(); }", 4954 getLLVMStyleWithColumns(40))); 4955 } 4956 4957 TEST_F(FormatTest, TrailingReturnType) { 4958 verifyFormat("auto foo() -> int;\n"); 4959 // correct trailing return type spacing 4960 verifyFormat("auto operator->() -> int;\n"); 4961 verifyFormat("auto operator++(int) -> int;\n"); 4962 4963 verifyFormat("struct S {\n" 4964 " auto bar() const -> int;\n" 4965 "};"); 4966 verifyFormat("template <size_t Order, typename T>\n" 4967 "auto load_img(const std::string &filename)\n" 4968 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 4969 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 4970 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 4971 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 4972 verifyFormat("template <typename T>\n" 4973 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 4974 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 4975 4976 // Not trailing return types. 4977 verifyFormat("void f() { auto a = b->c(); }"); 4978 } 4979 4980 TEST_F(FormatTest, DeductionGuides) { 4981 verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;"); 4982 verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;"); 4983 verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;"); 4984 verifyFormat( 4985 "template <class... T>\n" 4986 "array(T &&... t) -> array<std::common_type_t<T...>, sizeof...(T)>;"); 4987 verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;"); 4988 verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;"); 4989 verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;"); 4990 verifyFormat("template <class T> A() -> A<(3 < 2)>;"); 4991 verifyFormat("template <class T> A() -> A<((3) < (2))>;"); 4992 verifyFormat("template <class T> x() -> x<1>;"); 4993 verifyFormat("template <class T> explicit x(T &) -> x<1>;"); 4994 4995 // Ensure not deduction guides. 4996 verifyFormat("c()->f<int>();"); 4997 verifyFormat("x()->foo<1>;"); 4998 verifyFormat("x = p->foo<3>();"); 4999 verifyFormat("x()->x<1>();"); 5000 verifyFormat("x()->x<1>;"); 5001 } 5002 5003 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 5004 // Avoid breaking before trailing 'const' or other trailing annotations, if 5005 // they are not function-like. 5006 FormatStyle Style = getGoogleStyle(); 5007 Style.ColumnLimit = 47; 5008 verifyFormat("void someLongFunction(\n" 5009 " int someLoooooooooooooongParameter) const {\n}", 5010 getLLVMStyleWithColumns(47)); 5011 verifyFormat("LoooooongReturnType\n" 5012 "someLoooooooongFunction() const {}", 5013 getLLVMStyleWithColumns(47)); 5014 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 5015 " const {}", 5016 Style); 5017 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5018 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 5019 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5020 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 5021 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5022 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 5023 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 5024 " aaaaaaaaaaa aaaaa) const override;"); 5025 verifyGoogleFormat( 5026 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5027 " const override;"); 5028 5029 // Even if the first parameter has to be wrapped. 5030 verifyFormat("void someLongFunction(\n" 5031 " int someLongParameter) const {}", 5032 getLLVMStyleWithColumns(46)); 5033 verifyFormat("void someLongFunction(\n" 5034 " int someLongParameter) const {}", 5035 Style); 5036 verifyFormat("void someLongFunction(\n" 5037 " int someLongParameter) override {}", 5038 Style); 5039 verifyFormat("void someLongFunction(\n" 5040 " int someLongParameter) OVERRIDE {}", 5041 Style); 5042 verifyFormat("void someLongFunction(\n" 5043 " int someLongParameter) final {}", 5044 Style); 5045 verifyFormat("void someLongFunction(\n" 5046 " int someLongParameter) FINAL {}", 5047 Style); 5048 verifyFormat("void someLongFunction(\n" 5049 " int parameter) const override {}", 5050 Style); 5051 5052 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 5053 verifyFormat("void someLongFunction(\n" 5054 " int someLongParameter) const\n" 5055 "{\n" 5056 "}", 5057 Style); 5058 5059 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 5060 verifyFormat("void someLongFunction(\n" 5061 " int someLongParameter) const\n" 5062 " {\n" 5063 " }", 5064 Style); 5065 5066 // Unless these are unknown annotations. 5067 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 5068 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5069 " LONG_AND_UGLY_ANNOTATION;"); 5070 5071 // Breaking before function-like trailing annotations is fine to keep them 5072 // close to their arguments. 5073 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5074 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5075 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5076 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5077 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5078 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 5079 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 5080 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 5081 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 5082 5083 verifyFormat( 5084 "void aaaaaaaaaaaaaaaaaa()\n" 5085 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 5086 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 5087 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5088 " __attribute__((unused));"); 5089 verifyGoogleFormat( 5090 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5091 " GUARDED_BY(aaaaaaaaaaaa);"); 5092 verifyGoogleFormat( 5093 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5094 " GUARDED_BY(aaaaaaaaaaaa);"); 5095 verifyGoogleFormat( 5096 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5097 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5098 verifyGoogleFormat( 5099 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5100 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5101 } 5102 5103 TEST_F(FormatTest, FunctionAnnotations) { 5104 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5105 "int OldFunction(const string ¶meter) {}"); 5106 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5107 "string OldFunction(const string ¶meter) {}"); 5108 verifyFormat("template <typename T>\n" 5109 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5110 "string OldFunction(const string ¶meter) {}"); 5111 5112 // Not function annotations. 5113 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5114 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 5115 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 5116 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 5117 verifyFormat("MACRO(abc).function() // wrap\n" 5118 " << abc;"); 5119 verifyFormat("MACRO(abc)->function() // wrap\n" 5120 " << abc;"); 5121 verifyFormat("MACRO(abc)::function() // wrap\n" 5122 " << abc;"); 5123 } 5124 5125 TEST_F(FormatTest, BreaksDesireably) { 5126 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5127 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5128 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 5129 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5130 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 5131 "}"); 5132 5133 verifyFormat( 5134 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5135 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 5136 5137 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5138 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5139 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5140 5141 verifyFormat( 5142 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5143 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5144 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5145 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5146 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 5147 5148 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5149 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5150 5151 verifyFormat( 5152 "void f() {\n" 5153 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 5154 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5155 "}"); 5156 verifyFormat( 5157 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5158 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5159 verifyFormat( 5160 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5161 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5162 verifyFormat( 5163 "aaaaaa(aaa,\n" 5164 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5165 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5166 " aaaa);"); 5167 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5168 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5169 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5170 5171 // Indent consistently independent of call expression and unary operator. 5172 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5173 " dddddddddddddddddddddddddddddd));"); 5174 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5175 " dddddddddddddddddddddddddddddd));"); 5176 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 5177 " dddddddddddddddddddddddddddddd));"); 5178 5179 // This test case breaks on an incorrect memoization, i.e. an optimization not 5180 // taking into account the StopAt value. 5181 verifyFormat( 5182 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5183 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5184 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5185 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5186 5187 verifyFormat("{\n {\n {\n" 5188 " Annotation.SpaceRequiredBefore =\n" 5189 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 5190 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 5191 " }\n }\n}"); 5192 5193 // Break on an outer level if there was a break on an inner level. 5194 EXPECT_EQ("f(g(h(a, // comment\n" 5195 " b, c),\n" 5196 " d, e),\n" 5197 " x, y);", 5198 format("f(g(h(a, // comment\n" 5199 " b, c), d, e), x, y);")); 5200 5201 // Prefer breaking similar line breaks. 5202 verifyFormat( 5203 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 5204 " NSTrackingMouseEnteredAndExited |\n" 5205 " NSTrackingActiveAlways;"); 5206 } 5207 5208 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 5209 FormatStyle NoBinPacking = getGoogleStyle(); 5210 NoBinPacking.BinPackParameters = false; 5211 NoBinPacking.BinPackArguments = true; 5212 verifyFormat("void f() {\n" 5213 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 5214 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5215 "}", 5216 NoBinPacking); 5217 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 5218 " int aaaaaaaaaaaaaaaaaaaa,\n" 5219 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5220 NoBinPacking); 5221 5222 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5223 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5224 " vector<int> bbbbbbbbbbbbbbb);", 5225 NoBinPacking); 5226 // FIXME: This behavior difference is probably not wanted. However, currently 5227 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 5228 // template arguments from BreakBeforeParameter being set because of the 5229 // one-per-line formatting. 5230 verifyFormat( 5231 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5232 " aaaaaaaaaa> aaaaaaaaaa);", 5233 NoBinPacking); 5234 verifyFormat( 5235 "void fffffffffff(\n" 5236 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 5237 " aaaaaaaaaa);"); 5238 } 5239 5240 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 5241 FormatStyle NoBinPacking = getGoogleStyle(); 5242 NoBinPacking.BinPackParameters = false; 5243 NoBinPacking.BinPackArguments = false; 5244 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 5245 " aaaaaaaaaaaaaaaaaaaa,\n" 5246 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 5247 NoBinPacking); 5248 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 5249 " aaaaaaaaaaaaa,\n" 5250 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 5251 NoBinPacking); 5252 verifyFormat( 5253 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5254 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5255 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5256 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5257 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 5258 NoBinPacking); 5259 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5260 " .aaaaaaaaaaaaaaaaaa();", 5261 NoBinPacking); 5262 verifyFormat("void f() {\n" 5263 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5264 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 5265 "}", 5266 NoBinPacking); 5267 5268 verifyFormat( 5269 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5270 " aaaaaaaaaaaa,\n" 5271 " aaaaaaaaaaaa);", 5272 NoBinPacking); 5273 verifyFormat( 5274 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 5275 " ddddddddddddddddddddddddddddd),\n" 5276 " test);", 5277 NoBinPacking); 5278 5279 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5280 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 5281 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 5282 " aaaaaaaaaaaaaaaaaa;", 5283 NoBinPacking); 5284 verifyFormat("a(\"a\"\n" 5285 " \"a\",\n" 5286 " a);"); 5287 5288 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5289 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 5290 " aaaaaaaaa,\n" 5291 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5292 NoBinPacking); 5293 verifyFormat( 5294 "void f() {\n" 5295 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5296 " .aaaaaaa();\n" 5297 "}", 5298 NoBinPacking); 5299 verifyFormat( 5300 "template <class SomeType, class SomeOtherType>\n" 5301 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 5302 NoBinPacking); 5303 } 5304 5305 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 5306 FormatStyle Style = getLLVMStyleWithColumns(15); 5307 Style.ExperimentalAutoDetectBinPacking = true; 5308 EXPECT_EQ("aaa(aaaa,\n" 5309 " aaaa,\n" 5310 " aaaa);\n" 5311 "aaa(aaaa,\n" 5312 " aaaa,\n" 5313 " aaaa);", 5314 format("aaa(aaaa,\n" // one-per-line 5315 " aaaa,\n" 5316 " aaaa );\n" 5317 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5318 Style)); 5319 EXPECT_EQ("aaa(aaaa, aaaa,\n" 5320 " aaaa);\n" 5321 "aaa(aaaa, aaaa,\n" 5322 " aaaa);", 5323 format("aaa(aaaa, aaaa,\n" // bin-packed 5324 " aaaa );\n" 5325 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5326 Style)); 5327 } 5328 5329 TEST_F(FormatTest, FormatsBuilderPattern) { 5330 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 5331 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 5332 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 5333 " .StartsWith(\".init\", ORDER_INIT)\n" 5334 " .StartsWith(\".fini\", ORDER_FINI)\n" 5335 " .StartsWith(\".hash\", ORDER_HASH)\n" 5336 " .Default(ORDER_TEXT);\n"); 5337 5338 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 5339 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 5340 verifyFormat("aaaaaaa->aaaaaaa\n" 5341 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5342 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5343 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5344 verifyFormat( 5345 "aaaaaaa->aaaaaaa\n" 5346 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5347 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5348 verifyFormat( 5349 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 5350 " aaaaaaaaaaaaaa);"); 5351 verifyFormat( 5352 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 5353 " aaaaaa->aaaaaaaaaaaa()\n" 5354 " ->aaaaaaaaaaaaaaaa(\n" 5355 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5356 " ->aaaaaaaaaaaaaaaaa();"); 5357 verifyGoogleFormat( 5358 "void f() {\n" 5359 " someo->Add((new util::filetools::Handler(dir))\n" 5360 " ->OnEvent1(NewPermanentCallback(\n" 5361 " this, &HandlerHolderClass::EventHandlerCBA))\n" 5362 " ->OnEvent2(NewPermanentCallback(\n" 5363 " this, &HandlerHolderClass::EventHandlerCBB))\n" 5364 " ->OnEvent3(NewPermanentCallback(\n" 5365 " this, &HandlerHolderClass::EventHandlerCBC))\n" 5366 " ->OnEvent5(NewPermanentCallback(\n" 5367 " this, &HandlerHolderClass::EventHandlerCBD))\n" 5368 " ->OnEvent6(NewPermanentCallback(\n" 5369 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 5370 "}"); 5371 5372 verifyFormat( 5373 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 5374 verifyFormat("aaaaaaaaaaaaaaa()\n" 5375 " .aaaaaaaaaaaaaaa()\n" 5376 " .aaaaaaaaaaaaaaa()\n" 5377 " .aaaaaaaaaaaaaaa()\n" 5378 " .aaaaaaaaaaaaaaa();"); 5379 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5380 " .aaaaaaaaaaaaaaa()\n" 5381 " .aaaaaaaaaaaaaaa()\n" 5382 " .aaaaaaaaaaaaaaa();"); 5383 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5384 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5385 " .aaaaaaaaaaaaaaa();"); 5386 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 5387 " ->aaaaaaaaaaaaaae(0)\n" 5388 " ->aaaaaaaaaaaaaaa();"); 5389 5390 // Don't linewrap after very short segments. 5391 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5392 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5393 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5394 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5395 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5396 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5397 verifyFormat("aaa()\n" 5398 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5399 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5400 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5401 5402 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5403 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5404 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 5405 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5406 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 5407 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 5408 5409 // Prefer not to break after empty parentheses. 5410 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 5411 " First->LastNewlineOffset);"); 5412 5413 // Prefer not to create "hanging" indents. 5414 verifyFormat( 5415 "return !soooooooooooooome_map\n" 5416 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5417 " .second;"); 5418 verifyFormat( 5419 "return aaaaaaaaaaaaaaaa\n" 5420 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 5421 " .aaaa(aaaaaaaaaaaaaa);"); 5422 // No hanging indent here. 5423 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5424 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5425 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5426 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5427 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5428 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5429 getLLVMStyleWithColumns(60)); 5430 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5431 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5432 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5433 getLLVMStyleWithColumns(59)); 5434 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5435 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5436 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5437 5438 // Dont break if only closing statements before member call 5439 verifyFormat("test() {\n" 5440 " ([]() -> {\n" 5441 " int b = 32;\n" 5442 " return 3;\n" 5443 " }).foo();\n" 5444 "}"); 5445 verifyFormat("test() {\n" 5446 " (\n" 5447 " []() -> {\n" 5448 " int b = 32;\n" 5449 " return 3;\n" 5450 " },\n" 5451 " foo, bar)\n" 5452 " .foo();\n" 5453 "}"); 5454 verifyFormat("test() {\n" 5455 " ([]() -> {\n" 5456 " int b = 32;\n" 5457 " return 3;\n" 5458 " })\n" 5459 " .foo()\n" 5460 " .bar();\n" 5461 "}"); 5462 verifyFormat("test() {\n" 5463 " ([]() -> {\n" 5464 " int b = 32;\n" 5465 " return 3;\n" 5466 " })\n" 5467 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5468 " \"bbbb\");\n" 5469 "}", 5470 getLLVMStyleWithColumns(30)); 5471 } 5472 5473 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5474 verifyFormat( 5475 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5476 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5477 verifyFormat( 5478 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5479 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5480 5481 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5482 " ccccccccccccccccccccccccc) {\n}"); 5483 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5484 " ccccccccccccccccccccccccc) {\n}"); 5485 5486 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5487 " ccccccccccccccccccccccccc) {\n}"); 5488 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5489 " ccccccccccccccccccccccccc) {\n}"); 5490 5491 verifyFormat( 5492 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5493 " ccccccccccccccccccccccccc) {\n}"); 5494 verifyFormat( 5495 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5496 " ccccccccccccccccccccccccc) {\n}"); 5497 5498 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5499 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5500 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5501 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5502 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5503 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5504 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5505 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5506 5507 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5508 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5509 " aaaaaaaaaaaaaaa != aa) {\n}"); 5510 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5511 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5512 " aaaaaaaaaaaaaaa != aa) {\n}"); 5513 } 5514 5515 TEST_F(FormatTest, BreaksAfterAssignments) { 5516 verifyFormat( 5517 "unsigned Cost =\n" 5518 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5519 " SI->getPointerAddressSpaceee());\n"); 5520 verifyFormat( 5521 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5522 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5523 5524 verifyFormat( 5525 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5526 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5527 verifyFormat("unsigned OriginalStartColumn =\n" 5528 " SourceMgr.getSpellingColumnNumber(\n" 5529 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5530 " 1;"); 5531 } 5532 5533 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5534 FormatStyle Style = getLLVMStyle(); 5535 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5536 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5537 Style); 5538 5539 Style.PenaltyBreakAssignment = 20; 5540 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5541 " cccccccccccccccccccccccccc;", 5542 Style); 5543 } 5544 5545 TEST_F(FormatTest, AlignsAfterAssignments) { 5546 verifyFormat( 5547 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5548 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5549 verifyFormat( 5550 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5551 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5552 verifyFormat( 5553 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5554 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5555 verifyFormat( 5556 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5557 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5558 verifyFormat( 5559 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5560 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5561 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5562 } 5563 5564 TEST_F(FormatTest, AlignsAfterReturn) { 5565 verifyFormat( 5566 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5567 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5568 verifyFormat( 5569 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5570 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5571 verifyFormat( 5572 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5573 " aaaaaaaaaaaaaaaaaaaaaa();"); 5574 verifyFormat( 5575 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5576 " aaaaaaaaaaaaaaaaaaaaaa());"); 5577 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5578 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5579 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5580 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5581 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5582 verifyFormat("return\n" 5583 " // true if code is one of a or b.\n" 5584 " code == a || code == b;"); 5585 } 5586 5587 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5588 verifyFormat( 5589 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5590 " aaaaaaaaa aaaaaaa) {}"); 5591 verifyFormat( 5592 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5593 " aaaaaaaaaaa aaaaaaaaa);"); 5594 verifyFormat( 5595 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5596 " aaaaaaaaaaaaaaaaaaaaa));"); 5597 FormatStyle Style = getLLVMStyle(); 5598 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5599 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5600 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5601 Style); 5602 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5603 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5604 Style); 5605 verifyFormat("SomeLongVariableName->someFunction(\n" 5606 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5607 Style); 5608 verifyFormat( 5609 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5610 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5611 Style); 5612 verifyFormat( 5613 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5614 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5615 Style); 5616 verifyFormat( 5617 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5618 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5619 Style); 5620 5621 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5622 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5623 " b));", 5624 Style); 5625 5626 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5627 Style.BinPackArguments = false; 5628 Style.BinPackParameters = false; 5629 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5630 " aaaaaaaaaaa aaaaaaaa,\n" 5631 " aaaaaaaaa aaaaaaa,\n" 5632 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5633 Style); 5634 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5635 " aaaaaaaaaaa aaaaaaaaa,\n" 5636 " aaaaaaaaaaa aaaaaaaaa,\n" 5637 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5638 Style); 5639 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5640 " aaaaaaaaaaaaaaa,\n" 5641 " aaaaaaaaaaaaaaaaaaaaa,\n" 5642 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5643 Style); 5644 verifyFormat( 5645 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5646 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5647 Style); 5648 verifyFormat( 5649 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5650 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5651 Style); 5652 verifyFormat( 5653 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5654 " aaaaaaaaaaaaaaaaaaaaa(\n" 5655 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5656 " aaaaaaaaaaaaaaaa);", 5657 Style); 5658 verifyFormat( 5659 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5660 " aaaaaaaaaaaaaaaaaaaaa(\n" 5661 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5662 " aaaaaaaaaaaaaaaa);", 5663 Style); 5664 } 5665 5666 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5667 FormatStyle Style = getLLVMStyleWithColumns(40); 5668 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5669 " bbbbbbbbbbbbbbbbbbbbbb);", 5670 Style); 5671 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5672 Style.AlignOperands = false; 5673 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5674 " bbbbbbbbbbbbbbbbbbbbbb);", 5675 Style); 5676 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5677 Style.AlignOperands = true; 5678 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5679 " bbbbbbbbbbbbbbbbbbbbbb);", 5680 Style); 5681 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5682 Style.AlignOperands = false; 5683 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5684 " bbbbbbbbbbbbbbbbbbbbbb);", 5685 Style); 5686 } 5687 5688 TEST_F(FormatTest, BreaksConditionalExpressions) { 5689 verifyFormat( 5690 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5691 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5692 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5693 verifyFormat( 5694 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5695 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5696 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5697 verifyFormat( 5698 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5699 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5700 verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5701 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5702 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5703 verifyFormat( 5704 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5705 " : aaaaaaaaaaaaa);"); 5706 verifyFormat( 5707 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5708 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5709 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5710 " aaaaaaaaaaaaa);"); 5711 verifyFormat( 5712 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5713 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5714 " aaaaaaaaaaaaa);"); 5715 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5716 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5717 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5718 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5719 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5720 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5721 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5722 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5723 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5724 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5725 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5726 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5727 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5728 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5729 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5730 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5731 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5732 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5733 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5734 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5735 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5736 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5737 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5738 " : aaaaaaaaaaaaaaaa;"); 5739 verifyFormat( 5740 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5741 " ? aaaaaaaaaaaaaaa\n" 5742 " : aaaaaaaaaaaaaaa;"); 5743 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5744 " aaaaaaaaa\n" 5745 " ? b\n" 5746 " : c);"); 5747 verifyFormat("return aaaa == bbbb\n" 5748 " // comment\n" 5749 " ? aaaa\n" 5750 " : bbbb;"); 5751 verifyFormat("unsigned Indent =\n" 5752 " format(TheLine.First,\n" 5753 " IndentForLevel[TheLine.Level] >= 0\n" 5754 " ? IndentForLevel[TheLine.Level]\n" 5755 " : TheLine * 2,\n" 5756 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5757 getLLVMStyleWithColumns(60)); 5758 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5759 " ? aaaaaaaaaaaaaaa\n" 5760 " : bbbbbbbbbbbbbbb //\n" 5761 " ? ccccccccccccccc\n" 5762 " : ddddddddddddddd;"); 5763 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5764 " ? aaaaaaaaaaaaaaa\n" 5765 " : (bbbbbbbbbbbbbbb //\n" 5766 " ? ccccccccccccccc\n" 5767 " : ddddddddddddddd);"); 5768 verifyFormat( 5769 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5770 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5771 " aaaaaaaaaaaaaaaaaaaaa +\n" 5772 " aaaaaaaaaaaaaaaaaaaaa\n" 5773 " : aaaaaaaaaa;"); 5774 verifyFormat( 5775 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5776 " : aaaaaaaaaaaaaaaaaaaaaa\n" 5777 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5778 5779 FormatStyle NoBinPacking = getLLVMStyle(); 5780 NoBinPacking.BinPackArguments = false; 5781 verifyFormat( 5782 "void f() {\n" 5783 " g(aaa,\n" 5784 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5785 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5786 " ? aaaaaaaaaaaaaaa\n" 5787 " : aaaaaaaaaaaaaaa);\n" 5788 "}", 5789 NoBinPacking); 5790 verifyFormat( 5791 "void f() {\n" 5792 " g(aaa,\n" 5793 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5794 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5795 " ?: aaaaaaaaaaaaaaa);\n" 5796 "}", 5797 NoBinPacking); 5798 5799 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 5800 " // comment.\n" 5801 " ccccccccccccccccccccccccccccccccccccccc\n" 5802 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5803 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 5804 5805 // Assignments in conditional expressions. Apparently not uncommon :-(. 5806 verifyFormat("return a != b\n" 5807 " // comment\n" 5808 " ? a = b\n" 5809 " : a = b;"); 5810 verifyFormat("return a != b\n" 5811 " // comment\n" 5812 " ? a = a != b\n" 5813 " // comment\n" 5814 " ? a = b\n" 5815 " : a\n" 5816 " : a;\n"); 5817 verifyFormat("return a != b\n" 5818 " // comment\n" 5819 " ? a\n" 5820 " : a = a != b\n" 5821 " // comment\n" 5822 " ? a = b\n" 5823 " : a;"); 5824 } 5825 5826 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 5827 FormatStyle Style = getLLVMStyle(); 5828 Style.BreakBeforeTernaryOperators = false; 5829 Style.ColumnLimit = 70; 5830 verifyFormat( 5831 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5832 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5833 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5834 Style); 5835 verifyFormat( 5836 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5837 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5838 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5839 Style); 5840 verifyFormat( 5841 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5842 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5843 Style); 5844 verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n" 5845 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5846 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5847 Style); 5848 verifyFormat( 5849 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 5850 " aaaaaaaaaaaaa);", 5851 Style); 5852 verifyFormat( 5853 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5854 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5855 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5856 " aaaaaaaaaaaaa);", 5857 Style); 5858 verifyFormat( 5859 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5860 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5861 " aaaaaaaaaaaaa);", 5862 Style); 5863 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5864 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5865 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5866 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5867 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5868 Style); 5869 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5870 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5871 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5872 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5873 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5874 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5875 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5876 Style); 5877 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5878 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 5879 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5880 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5881 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5882 Style); 5883 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5884 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5885 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5886 Style); 5887 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5888 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5889 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5890 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5891 Style); 5892 verifyFormat( 5893 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5894 " aaaaaaaaaaaaaaa :\n" 5895 " aaaaaaaaaaaaaaa;", 5896 Style); 5897 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5898 " aaaaaaaaa ?\n" 5899 " b :\n" 5900 " c);", 5901 Style); 5902 verifyFormat("unsigned Indent =\n" 5903 " format(TheLine.First,\n" 5904 " IndentForLevel[TheLine.Level] >= 0 ?\n" 5905 " IndentForLevel[TheLine.Level] :\n" 5906 " TheLine * 2,\n" 5907 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5908 Style); 5909 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5910 " aaaaaaaaaaaaaaa :\n" 5911 " bbbbbbbbbbbbbbb ? //\n" 5912 " ccccccccccccccc :\n" 5913 " ddddddddddddddd;", 5914 Style); 5915 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5916 " aaaaaaaaaaaaaaa :\n" 5917 " (bbbbbbbbbbbbbbb ? //\n" 5918 " ccccccccccccccc :\n" 5919 " ddddddddddddddd);", 5920 Style); 5921 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5922 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 5923 " ccccccccccccccccccccccccccc;", 5924 Style); 5925 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5926 " aaaaa :\n" 5927 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 5928 Style); 5929 } 5930 5931 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 5932 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 5933 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 5934 verifyFormat("bool a = true, b = false;"); 5935 5936 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5937 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 5938 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 5939 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 5940 verifyFormat( 5941 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 5942 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 5943 " d = e && f;"); 5944 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 5945 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 5946 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5947 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 5948 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 5949 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 5950 5951 FormatStyle Style = getGoogleStyle(); 5952 Style.PointerAlignment = FormatStyle::PAS_Left; 5953 Style.DerivePointerAlignment = false; 5954 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5955 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 5956 " *b = bbbbbbbbbbbbbbbbbbb;", 5957 Style); 5958 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 5959 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 5960 Style); 5961 verifyFormat("vector<int*> a, b;", Style); 5962 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 5963 } 5964 5965 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 5966 verifyFormat("arr[foo ? bar : baz];"); 5967 verifyFormat("f()[foo ? bar : baz];"); 5968 verifyFormat("(a + b)[foo ? bar : baz];"); 5969 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 5970 } 5971 5972 TEST_F(FormatTest, AlignsStringLiterals) { 5973 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 5974 " \"short literal\");"); 5975 verifyFormat( 5976 "looooooooooooooooooooooooongFunction(\n" 5977 " \"short literal\"\n" 5978 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 5979 verifyFormat("someFunction(\"Always break between multi-line\"\n" 5980 " \" string literals\",\n" 5981 " and, other, parameters);"); 5982 EXPECT_EQ("fun + \"1243\" /* comment */\n" 5983 " \"5678\";", 5984 format("fun + \"1243\" /* comment */\n" 5985 " \"5678\";", 5986 getLLVMStyleWithColumns(28))); 5987 EXPECT_EQ( 5988 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 5989 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 5990 " \"aaaaaaaaaaaaaaaa\";", 5991 format("aaaaaa =" 5992 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 5993 "aaaaaaaaaaaaaaaaaaaaa\" " 5994 "\"aaaaaaaaaaaaaaaa\";")); 5995 verifyFormat("a = a + \"a\"\n" 5996 " \"a\"\n" 5997 " \"a\";"); 5998 verifyFormat("f(\"a\", \"b\"\n" 5999 " \"c\");"); 6000 6001 verifyFormat( 6002 "#define LL_FORMAT \"ll\"\n" 6003 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 6004 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 6005 6006 verifyFormat("#define A(X) \\\n" 6007 " \"aaaaa\" #X \"bbbbbb\" \\\n" 6008 " \"ccccc\"", 6009 getLLVMStyleWithColumns(23)); 6010 verifyFormat("#define A \"def\"\n" 6011 "f(\"abc\" A \"ghi\"\n" 6012 " \"jkl\");"); 6013 6014 verifyFormat("f(L\"a\"\n" 6015 " L\"b\");"); 6016 verifyFormat("#define A(X) \\\n" 6017 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 6018 " L\"ccccc\"", 6019 getLLVMStyleWithColumns(25)); 6020 6021 verifyFormat("f(@\"a\"\n" 6022 " @\"b\");"); 6023 verifyFormat("NSString s = @\"a\"\n" 6024 " @\"b\"\n" 6025 " @\"c\";"); 6026 verifyFormat("NSString s = @\"a\"\n" 6027 " \"b\"\n" 6028 " \"c\";"); 6029 } 6030 6031 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 6032 FormatStyle Style = getLLVMStyle(); 6033 // No declarations or definitions should be moved to own line. 6034 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 6035 verifyFormat("class A {\n" 6036 " int f() { return 1; }\n" 6037 " int g();\n" 6038 "};\n" 6039 "int f() { return 1; }\n" 6040 "int g();\n", 6041 Style); 6042 6043 // All declarations and definitions should have the return type moved to its 6044 // own 6045 // line. 6046 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 6047 verifyFormat("class E {\n" 6048 " int\n" 6049 " f() {\n" 6050 " return 1;\n" 6051 " }\n" 6052 " int\n" 6053 " g();\n" 6054 "};\n" 6055 "int\n" 6056 "f() {\n" 6057 " return 1;\n" 6058 "}\n" 6059 "int\n" 6060 "g();\n", 6061 Style); 6062 6063 // Top-level definitions, and no kinds of declarations should have the 6064 // return type moved to its own line. 6065 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 6066 verifyFormat("class B {\n" 6067 " int f() { return 1; }\n" 6068 " int g();\n" 6069 "};\n" 6070 "int\n" 6071 "f() {\n" 6072 " return 1;\n" 6073 "}\n" 6074 "int g();\n", 6075 Style); 6076 6077 // Top-level definitions and declarations should have the return type moved 6078 // to its own line. 6079 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 6080 verifyFormat("class C {\n" 6081 " int f() { return 1; }\n" 6082 " int g();\n" 6083 "};\n" 6084 "int\n" 6085 "f() {\n" 6086 " return 1;\n" 6087 "}\n" 6088 "int\n" 6089 "g();\n", 6090 Style); 6091 6092 // All definitions should have the return type moved to its own line, but no 6093 // kinds of declarations. 6094 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 6095 verifyFormat("class D {\n" 6096 " int\n" 6097 " f() {\n" 6098 " return 1;\n" 6099 " }\n" 6100 " int g();\n" 6101 "};\n" 6102 "int\n" 6103 "f() {\n" 6104 " return 1;\n" 6105 "}\n" 6106 "int g();\n", 6107 Style); 6108 verifyFormat("const char *\n" 6109 "f(void) {\n" // Break here. 6110 " return \"\";\n" 6111 "}\n" 6112 "const char *bar(void);\n", // No break here. 6113 Style); 6114 verifyFormat("template <class T>\n" 6115 "T *\n" 6116 "f(T &c) {\n" // Break here. 6117 " return NULL;\n" 6118 "}\n" 6119 "template <class T> T *f(T &c);\n", // No break here. 6120 Style); 6121 verifyFormat("class C {\n" 6122 " int\n" 6123 " operator+() {\n" 6124 " return 1;\n" 6125 " }\n" 6126 " int\n" 6127 " operator()() {\n" 6128 " return 1;\n" 6129 " }\n" 6130 "};\n", 6131 Style); 6132 verifyFormat("void\n" 6133 "A::operator()() {}\n" 6134 "void\n" 6135 "A::operator>>() {}\n" 6136 "void\n" 6137 "A::operator+() {}\n" 6138 "void\n" 6139 "A::operator*() {}\n" 6140 "void\n" 6141 "A::operator->() {}\n" 6142 "void\n" 6143 "A::operator void *() {}\n" 6144 "void\n" 6145 "A::operator void &() {}\n" 6146 "void\n" 6147 "A::operator void &&() {}\n" 6148 "void\n" 6149 "A::operator char *() {}\n" 6150 "void\n" 6151 "A::operator[]() {}\n" 6152 "void\n" 6153 "A::operator!() {}\n", 6154 Style); 6155 verifyFormat("constexpr auto\n" 6156 "operator()() const -> reference {}\n" 6157 "constexpr auto\n" 6158 "operator>>() const -> reference {}\n" 6159 "constexpr auto\n" 6160 "operator+() const -> reference {}\n" 6161 "constexpr auto\n" 6162 "operator*() const -> reference {}\n" 6163 "constexpr auto\n" 6164 "operator->() const -> reference {}\n" 6165 "constexpr auto\n" 6166 "operator++() const -> reference {}\n" 6167 "constexpr auto\n" 6168 "operator void *() const -> reference {}\n" 6169 "constexpr auto\n" 6170 "operator void &() const -> reference {}\n" 6171 "constexpr auto\n" 6172 "operator void &&() const -> reference {}\n" 6173 "constexpr auto\n" 6174 "operator char *() const -> reference {}\n" 6175 "constexpr auto\n" 6176 "operator!() const -> reference {}\n" 6177 "constexpr auto\n" 6178 "operator[]() const -> reference {}\n", 6179 Style); 6180 verifyFormat("void *operator new(std::size_t s);", // No break here. 6181 Style); 6182 verifyFormat("void *\n" 6183 "operator new(std::size_t s) {}", 6184 Style); 6185 verifyFormat("void *\n" 6186 "operator delete[](void *ptr) {}", 6187 Style); 6188 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 6189 verifyFormat("const char *\n" 6190 "f(void)\n" // Break here. 6191 "{\n" 6192 " return \"\";\n" 6193 "}\n" 6194 "const char *bar(void);\n", // No break here. 6195 Style); 6196 verifyFormat("template <class T>\n" 6197 "T *\n" // Problem here: no line break 6198 "f(T &c)\n" // Break here. 6199 "{\n" 6200 " return NULL;\n" 6201 "}\n" 6202 "template <class T> T *f(T &c);\n", // No break here. 6203 Style); 6204 verifyFormat("int\n" 6205 "foo(A<bool> a)\n" 6206 "{\n" 6207 " return a;\n" 6208 "}\n", 6209 Style); 6210 verifyFormat("int\n" 6211 "foo(A<8> a)\n" 6212 "{\n" 6213 " return a;\n" 6214 "}\n", 6215 Style); 6216 verifyFormat("int\n" 6217 "foo(A<B<bool>, 8> a)\n" 6218 "{\n" 6219 " return a;\n" 6220 "}\n", 6221 Style); 6222 verifyFormat("int\n" 6223 "foo(A<B<8>, bool> a)\n" 6224 "{\n" 6225 " return a;\n" 6226 "}\n", 6227 Style); 6228 verifyFormat("int\n" 6229 "foo(A<B<bool>, bool> a)\n" 6230 "{\n" 6231 " return a;\n" 6232 "}\n", 6233 Style); 6234 verifyFormat("int\n" 6235 "foo(A<B<8>, 8> a)\n" 6236 "{\n" 6237 " return a;\n" 6238 "}\n", 6239 Style); 6240 6241 Style = getGNUStyle(); 6242 6243 // Test for comments at the end of function declarations. 6244 verifyFormat("void\n" 6245 "foo (int a, /*abc*/ int b) // def\n" 6246 "{\n" 6247 "}\n", 6248 Style); 6249 6250 verifyFormat("void\n" 6251 "foo (int a, /* abc */ int b) /* def */\n" 6252 "{\n" 6253 "}\n", 6254 Style); 6255 6256 // Definitions that should not break after return type 6257 verifyFormat("void foo (int a, int b); // def\n", Style); 6258 verifyFormat("void foo (int a, int b); /* def */\n", Style); 6259 verifyFormat("void foo (int a, int b);\n", Style); 6260 } 6261 6262 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 6263 FormatStyle NoBreak = getLLVMStyle(); 6264 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 6265 FormatStyle Break = getLLVMStyle(); 6266 Break.AlwaysBreakBeforeMultilineStrings = true; 6267 verifyFormat("aaaa = \"bbbb\"\n" 6268 " \"cccc\";", 6269 NoBreak); 6270 verifyFormat("aaaa =\n" 6271 " \"bbbb\"\n" 6272 " \"cccc\";", 6273 Break); 6274 verifyFormat("aaaa(\"bbbb\"\n" 6275 " \"cccc\");", 6276 NoBreak); 6277 verifyFormat("aaaa(\n" 6278 " \"bbbb\"\n" 6279 " \"cccc\");", 6280 Break); 6281 verifyFormat("aaaa(qqq, \"bbbb\"\n" 6282 " \"cccc\");", 6283 NoBreak); 6284 verifyFormat("aaaa(qqq,\n" 6285 " \"bbbb\"\n" 6286 " \"cccc\");", 6287 Break); 6288 verifyFormat("aaaa(qqq,\n" 6289 " L\"bbbb\"\n" 6290 " L\"cccc\");", 6291 Break); 6292 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 6293 " \"bbbb\"));", 6294 Break); 6295 verifyFormat("string s = someFunction(\n" 6296 " \"abc\"\n" 6297 " \"abc\");", 6298 Break); 6299 6300 // As we break before unary operators, breaking right after them is bad. 6301 verifyFormat("string foo = abc ? \"x\"\n" 6302 " \"blah blah blah blah blah blah\"\n" 6303 " : \"y\";", 6304 Break); 6305 6306 // Don't break if there is no column gain. 6307 verifyFormat("f(\"aaaa\"\n" 6308 " \"bbbb\");", 6309 Break); 6310 6311 // Treat literals with escaped newlines like multi-line string literals. 6312 EXPECT_EQ("x = \"a\\\n" 6313 "b\\\n" 6314 "c\";", 6315 format("x = \"a\\\n" 6316 "b\\\n" 6317 "c\";", 6318 NoBreak)); 6319 EXPECT_EQ("xxxx =\n" 6320 " \"a\\\n" 6321 "b\\\n" 6322 "c\";", 6323 format("xxxx = \"a\\\n" 6324 "b\\\n" 6325 "c\";", 6326 Break)); 6327 6328 EXPECT_EQ("NSString *const kString =\n" 6329 " @\"aaaa\"\n" 6330 " @\"bbbb\";", 6331 format("NSString *const kString = @\"aaaa\"\n" 6332 "@\"bbbb\";", 6333 Break)); 6334 6335 Break.ColumnLimit = 0; 6336 verifyFormat("const char *hello = \"hello llvm\";", Break); 6337 } 6338 6339 TEST_F(FormatTest, AlignsPipes) { 6340 verifyFormat( 6341 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6342 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6343 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6344 verifyFormat( 6345 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 6346 " << aaaaaaaaaaaaaaaaaaaa;"); 6347 verifyFormat( 6348 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6349 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6350 verifyFormat( 6351 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 6352 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6353 verifyFormat( 6354 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 6355 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 6356 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 6357 verifyFormat( 6358 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6359 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6360 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6361 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6362 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6363 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6364 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6365 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 6366 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 6367 verifyFormat( 6368 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6369 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6370 verifyFormat( 6371 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 6372 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6373 6374 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 6375 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 6376 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6377 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6378 " aaaaaaaaaaaaaaaaaaaaa)\n" 6379 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6380 verifyFormat("LOG_IF(aaa == //\n" 6381 " bbb)\n" 6382 " << a << b;"); 6383 6384 // But sometimes, breaking before the first "<<" is desirable. 6385 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6386 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 6387 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 6388 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6389 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6390 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 6391 " << BEF << IsTemplate << Description << E->getType();"); 6392 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6393 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6394 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6395 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6396 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6397 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6398 " << aaa;"); 6399 6400 verifyFormat( 6401 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6402 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6403 6404 // Incomplete string literal. 6405 EXPECT_EQ("llvm::errs() << \"\n" 6406 " << a;", 6407 format("llvm::errs() << \"\n<<a;")); 6408 6409 verifyFormat("void f() {\n" 6410 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 6411 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 6412 "}"); 6413 6414 // Handle 'endl'. 6415 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 6416 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6417 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6418 6419 // Handle '\n'. 6420 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 6421 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6422 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 6423 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 6424 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 6425 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 6426 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6427 } 6428 6429 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 6430 verifyFormat("return out << \"somepacket = {\\n\"\n" 6431 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 6432 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 6433 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 6434 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 6435 " << \"}\";"); 6436 6437 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6438 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6439 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 6440 verifyFormat( 6441 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 6442 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 6443 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 6444 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 6445 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 6446 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 6447 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6448 verifyFormat( 6449 "void f() {\n" 6450 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 6451 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 6452 "}"); 6453 6454 // Breaking before the first "<<" is generally not desirable. 6455 verifyFormat( 6456 "llvm::errs()\n" 6457 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6458 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6459 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6460 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6461 getLLVMStyleWithColumns(70)); 6462 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6463 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6464 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6465 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6466 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6467 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6468 getLLVMStyleWithColumns(70)); 6469 6470 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6471 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6472 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6473 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6474 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6475 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 6476 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 6477 " (aaaa + aaaa);", 6478 getLLVMStyleWithColumns(40)); 6479 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 6480 " (aaaaaaa + aaaaa));", 6481 getLLVMStyleWithColumns(40)); 6482 verifyFormat( 6483 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 6484 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 6485 " bbbbbbbbbbbbbbbbbbbbbbb);"); 6486 } 6487 6488 TEST_F(FormatTest, UnderstandsEquals) { 6489 verifyFormat( 6490 "aaaaaaaaaaaaaaaaa =\n" 6491 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6492 verifyFormat( 6493 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6494 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6495 verifyFormat( 6496 "if (a) {\n" 6497 " f();\n" 6498 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6499 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 6500 "}"); 6501 6502 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6503 " 100000000 + 10000000) {\n}"); 6504 } 6505 6506 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 6507 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6508 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 6509 6510 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6511 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 6512 6513 verifyFormat( 6514 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 6515 " Parameter2);"); 6516 6517 verifyFormat( 6518 "ShortObject->shortFunction(\n" 6519 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 6520 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 6521 6522 verifyFormat("loooooooooooooongFunction(\n" 6523 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 6524 6525 verifyFormat( 6526 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 6527 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 6528 6529 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6530 " .WillRepeatedly(Return(SomeValue));"); 6531 verifyFormat("void f() {\n" 6532 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6533 " .Times(2)\n" 6534 " .WillRepeatedly(Return(SomeValue));\n" 6535 "}"); 6536 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 6537 " ccccccccccccccccccccccc);"); 6538 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6539 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6540 " .aaaaa(aaaaa),\n" 6541 " aaaaaaaaaaaaaaaaaaaaa);"); 6542 verifyFormat("void f() {\n" 6543 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6544 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 6545 "}"); 6546 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6547 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6548 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6549 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6550 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6551 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6552 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6553 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6554 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 6555 "}"); 6556 6557 // Here, it is not necessary to wrap at "." or "->". 6558 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 6559 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6560 verifyFormat( 6561 "aaaaaaaaaaa->aaaaaaaaa(\n" 6562 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6563 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 6564 6565 verifyFormat( 6566 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6567 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 6568 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 6569 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6570 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 6571 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6572 6573 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6574 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6575 " .a();"); 6576 6577 FormatStyle NoBinPacking = getLLVMStyle(); 6578 NoBinPacking.BinPackParameters = false; 6579 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6580 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6581 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 6582 " aaaaaaaaaaaaaaaaaaa,\n" 6583 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6584 NoBinPacking); 6585 6586 // If there is a subsequent call, change to hanging indentation. 6587 verifyFormat( 6588 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6589 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 6590 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6591 verifyFormat( 6592 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6593 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 6594 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6595 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6596 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6597 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6598 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6599 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6600 } 6601 6602 TEST_F(FormatTest, WrapsTemplateDeclarations) { 6603 verifyFormat("template <typename T>\n" 6604 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6605 verifyFormat("template <typename T>\n" 6606 "// T should be one of {A, B}.\n" 6607 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6608 verifyFormat( 6609 "template <typename T>\n" 6610 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 6611 verifyFormat("template <typename T>\n" 6612 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 6613 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 6614 verifyFormat( 6615 "template <typename T>\n" 6616 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 6617 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 6618 verifyFormat( 6619 "template <typename T>\n" 6620 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 6621 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 6622 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6623 verifyFormat("template <typename T>\n" 6624 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6625 " int aaaaaaaaaaaaaaaaaaaaaa);"); 6626 verifyFormat( 6627 "template <typename T1, typename T2 = char, typename T3 = char,\n" 6628 " typename T4 = char>\n" 6629 "void f();"); 6630 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 6631 " template <typename> class cccccccccccccccccccccc,\n" 6632 " typename ddddddddddddd>\n" 6633 "class C {};"); 6634 verifyFormat( 6635 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 6636 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6637 6638 verifyFormat("void f() {\n" 6639 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 6640 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 6641 "}"); 6642 6643 verifyFormat("template <typename T> class C {};"); 6644 verifyFormat("template <typename T> void f();"); 6645 verifyFormat("template <typename T> void f() {}"); 6646 verifyFormat( 6647 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6648 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6649 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 6650 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6651 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6652 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 6653 " bbbbbbbbbbbbbbbbbbbbbbbb);", 6654 getLLVMStyleWithColumns(72)); 6655 EXPECT_EQ("static_cast<A< //\n" 6656 " B> *>(\n" 6657 "\n" 6658 ");", 6659 format("static_cast<A<//\n" 6660 " B>*>(\n" 6661 "\n" 6662 " );")); 6663 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6664 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 6665 6666 FormatStyle AlwaysBreak = getLLVMStyle(); 6667 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 6668 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 6669 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 6670 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 6671 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6672 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6673 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 6674 verifyFormat("template <template <typename> class Fooooooo,\n" 6675 " template <typename> class Baaaaaaar>\n" 6676 "struct C {};", 6677 AlwaysBreak); 6678 verifyFormat("template <typename T> // T can be A, B or C.\n" 6679 "struct C {};", 6680 AlwaysBreak); 6681 verifyFormat("template <enum E> class A {\n" 6682 "public:\n" 6683 " E *f();\n" 6684 "};"); 6685 6686 FormatStyle NeverBreak = getLLVMStyle(); 6687 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 6688 verifyFormat("template <typename T> class C {};", NeverBreak); 6689 verifyFormat("template <typename T> void f();", NeverBreak); 6690 verifyFormat("template <typename T> void f() {}", NeverBreak); 6691 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6692 "bbbbbbbbbbbbbbbbbbbb) {}", 6693 NeverBreak); 6694 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6695 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6696 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 6697 NeverBreak); 6698 verifyFormat("template <template <typename> class Fooooooo,\n" 6699 " template <typename> class Baaaaaaar>\n" 6700 "struct C {};", 6701 NeverBreak); 6702 verifyFormat("template <typename T> // T can be A, B or C.\n" 6703 "struct C {};", 6704 NeverBreak); 6705 verifyFormat("template <enum E> class A {\n" 6706 "public:\n" 6707 " E *f();\n" 6708 "};", 6709 NeverBreak); 6710 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 6711 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6712 "bbbbbbbbbbbbbbbbbbbb) {}", 6713 NeverBreak); 6714 } 6715 6716 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 6717 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 6718 Style.ColumnLimit = 60; 6719 EXPECT_EQ("// Baseline - no comments.\n" 6720 "template <\n" 6721 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6722 "void f() {}", 6723 format("// Baseline - no comments.\n" 6724 "template <\n" 6725 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6726 "void f() {}", 6727 Style)); 6728 6729 EXPECT_EQ("template <\n" 6730 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6731 "void f() {}", 6732 format("template <\n" 6733 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6734 "void f() {}", 6735 Style)); 6736 6737 EXPECT_EQ( 6738 "template <\n" 6739 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6740 "void f() {}", 6741 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6742 "void f() {}", 6743 Style)); 6744 6745 EXPECT_EQ( 6746 "template <\n" 6747 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6748 " // multiline\n" 6749 "void f() {}", 6750 format("template <\n" 6751 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6752 " // multiline\n" 6753 "void f() {}", 6754 Style)); 6755 6756 EXPECT_EQ( 6757 "template <typename aaaaaaaaaa<\n" 6758 " bbbbbbbbbbbb>::value> // trailing loooong\n" 6759 "void f() {}", 6760 format( 6761 "template <\n" 6762 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 6763 "void f() {}", 6764 Style)); 6765 } 6766 6767 TEST_F(FormatTest, WrapsTemplateParameters) { 6768 FormatStyle Style = getLLVMStyle(); 6769 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6770 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6771 verifyFormat( 6772 "template <typename... a> struct q {};\n" 6773 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6774 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6775 " y;", 6776 Style); 6777 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6778 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6779 verifyFormat( 6780 "template <typename... a> struct r {};\n" 6781 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6782 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6783 " y;", 6784 Style); 6785 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6786 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6787 verifyFormat("template <typename... a> struct s {};\n" 6788 "extern s<\n" 6789 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6790 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6791 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6792 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6793 " y;", 6794 Style); 6795 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6796 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6797 verifyFormat("template <typename... a> struct t {};\n" 6798 "extern t<\n" 6799 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6800 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6801 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6802 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6803 " y;", 6804 Style); 6805 } 6806 6807 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 6808 verifyFormat( 6809 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6810 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6811 verifyFormat( 6812 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6813 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6814 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6815 6816 // FIXME: Should we have the extra indent after the second break? 6817 verifyFormat( 6818 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6819 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6820 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6821 6822 verifyFormat( 6823 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 6824 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 6825 6826 // Breaking at nested name specifiers is generally not desirable. 6827 verifyFormat( 6828 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6829 " aaaaaaaaaaaaaaaaaaaaaaa);"); 6830 6831 verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 6832 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6833 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6834 " aaaaaaaaaaaaaaaaaaaaa);", 6835 getLLVMStyleWithColumns(74)); 6836 6837 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6838 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6839 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6840 } 6841 6842 TEST_F(FormatTest, UnderstandsTemplateParameters) { 6843 verifyFormat("A<int> a;"); 6844 verifyFormat("A<A<A<int>>> a;"); 6845 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 6846 verifyFormat("bool x = a < 1 || 2 > a;"); 6847 verifyFormat("bool x = 5 < f<int>();"); 6848 verifyFormat("bool x = f<int>() > 5;"); 6849 verifyFormat("bool x = 5 < a<int>::x;"); 6850 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 6851 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 6852 6853 verifyGoogleFormat("A<A<int>> a;"); 6854 verifyGoogleFormat("A<A<A<int>>> a;"); 6855 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 6856 verifyGoogleFormat("A<A<int> > a;"); 6857 verifyGoogleFormat("A<A<A<int> > > a;"); 6858 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 6859 verifyGoogleFormat("A<::A<int>> a;"); 6860 verifyGoogleFormat("A<::A> a;"); 6861 verifyGoogleFormat("A< ::A> a;"); 6862 verifyGoogleFormat("A< ::A<int> > a;"); 6863 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 6864 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 6865 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 6866 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 6867 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 6868 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 6869 6870 verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 6871 6872 // template closer followed by a token that starts with > or = 6873 verifyFormat("bool b = a<1> > 1;"); 6874 verifyFormat("bool b = a<1> >= 1;"); 6875 verifyFormat("int i = a<1> >> 1;"); 6876 FormatStyle Style = getLLVMStyle(); 6877 Style.SpaceBeforeAssignmentOperators = false; 6878 verifyFormat("bool b= a<1> == 1;", Style); 6879 verifyFormat("a<int> = 1;", Style); 6880 verifyFormat("a<int> >>= 1;", Style); 6881 6882 verifyFormat("test >> a >> b;"); 6883 verifyFormat("test << a >> b;"); 6884 6885 verifyFormat("f<int>();"); 6886 verifyFormat("template <typename T> void f() {}"); 6887 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 6888 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 6889 "sizeof(char)>::type>;"); 6890 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 6891 verifyFormat("f(a.operator()<A>());"); 6892 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6893 " .template operator()<A>());", 6894 getLLVMStyleWithColumns(35)); 6895 6896 // Not template parameters. 6897 verifyFormat("return a < b && c > d;"); 6898 verifyFormat("void f() {\n" 6899 " while (a < b && c > d) {\n" 6900 " }\n" 6901 "}"); 6902 verifyFormat("template <typename... Types>\n" 6903 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 6904 6905 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6906 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 6907 getLLVMStyleWithColumns(60)); 6908 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 6909 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 6910 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 6911 } 6912 6913 TEST_F(FormatTest, BitshiftOperatorWidth) { 6914 EXPECT_EQ("int a = 1 << 2; /* foo\n" 6915 " bar */", 6916 format("int a=1<<2; /* foo\n" 6917 " bar */")); 6918 6919 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 6920 " bar */", 6921 format("int b =256>>1 ; /* foo\n" 6922 " bar */")); 6923 } 6924 6925 TEST_F(FormatTest, UnderstandsBinaryOperators) { 6926 verifyFormat("COMPARE(a, ==, b);"); 6927 verifyFormat("auto s = sizeof...(Ts) - 1;"); 6928 } 6929 6930 TEST_F(FormatTest, UnderstandsPointersToMembers) { 6931 verifyFormat("int A::*x;"); 6932 verifyFormat("int (S::*func)(void *);"); 6933 verifyFormat("void f() { int (S::*func)(void *); }"); 6934 verifyFormat("typedef bool *(Class::*Member)() const;"); 6935 verifyFormat("void f() {\n" 6936 " (a->*f)();\n" 6937 " a->*x;\n" 6938 " (a.*f)();\n" 6939 " ((*a).*f)();\n" 6940 " a.*x;\n" 6941 "}"); 6942 verifyFormat("void f() {\n" 6943 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 6944 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 6945 "}"); 6946 verifyFormat( 6947 "(aaaaaaaaaa->*bbbbbbb)(\n" 6948 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6949 FormatStyle Style = getLLVMStyle(); 6950 Style.PointerAlignment = FormatStyle::PAS_Left; 6951 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 6952 } 6953 6954 TEST_F(FormatTest, UnderstandsUnaryOperators) { 6955 verifyFormat("int a = -2;"); 6956 verifyFormat("f(-1, -2, -3);"); 6957 verifyFormat("a[-1] = 5;"); 6958 verifyFormat("int a = 5 + -2;"); 6959 verifyFormat("if (i == -1) {\n}"); 6960 verifyFormat("if (i != -1) {\n}"); 6961 verifyFormat("if (i > -1) {\n}"); 6962 verifyFormat("if (i < -1) {\n}"); 6963 verifyFormat("++(a->f());"); 6964 verifyFormat("--(a->f());"); 6965 verifyFormat("(a->f())++;"); 6966 verifyFormat("a[42]++;"); 6967 verifyFormat("if (!(a->f())) {\n}"); 6968 verifyFormat("if (!+i) {\n}"); 6969 verifyFormat("~&a;"); 6970 6971 verifyFormat("a-- > b;"); 6972 verifyFormat("b ? -a : c;"); 6973 verifyFormat("n * sizeof char16;"); 6974 verifyFormat("n * alignof char16;", getGoogleStyle()); 6975 verifyFormat("sizeof(char);"); 6976 verifyFormat("alignof(char);", getGoogleStyle()); 6977 6978 verifyFormat("return -1;"); 6979 verifyFormat("throw -1;"); 6980 verifyFormat("switch (a) {\n" 6981 "case -1:\n" 6982 " break;\n" 6983 "}"); 6984 verifyFormat("#define X -1"); 6985 verifyFormat("#define X -kConstant"); 6986 6987 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 6988 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 6989 6990 verifyFormat("int a = /* confusing comment */ -1;"); 6991 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 6992 verifyFormat("int a = i /* confusing comment */++;"); 6993 6994 verifyFormat("co_yield -1;"); 6995 verifyFormat("co_return -1;"); 6996 } 6997 6998 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 6999 verifyFormat("if (!aaaaaaaaaa( // break\n" 7000 " aaaaa)) {\n" 7001 "}"); 7002 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 7003 " aaaaa));"); 7004 verifyFormat("*aaa = aaaaaaa( // break\n" 7005 " bbbbbb);"); 7006 } 7007 7008 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 7009 verifyFormat("bool operator<();"); 7010 verifyFormat("bool operator>();"); 7011 verifyFormat("bool operator=();"); 7012 verifyFormat("bool operator==();"); 7013 verifyFormat("bool operator!=();"); 7014 verifyFormat("int operator+();"); 7015 verifyFormat("int operator++();"); 7016 verifyFormat("int operator++(int) volatile noexcept;"); 7017 verifyFormat("bool operator,();"); 7018 verifyFormat("bool operator();"); 7019 verifyFormat("bool operator()();"); 7020 verifyFormat("bool operator[]();"); 7021 verifyFormat("operator bool();"); 7022 verifyFormat("operator int();"); 7023 verifyFormat("operator void *();"); 7024 verifyFormat("operator SomeType<int>();"); 7025 verifyFormat("operator SomeType<int, int>();"); 7026 verifyFormat("operator SomeType<SomeType<int>>();"); 7027 verifyFormat("void *operator new(std::size_t size);"); 7028 verifyFormat("void *operator new[](std::size_t size);"); 7029 verifyFormat("void operator delete(void *ptr);"); 7030 verifyFormat("void operator delete[](void *ptr);"); 7031 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 7032 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 7033 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 7034 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 7035 7036 verifyFormat( 7037 "ostream &operator<<(ostream &OutputStream,\n" 7038 " SomeReallyLongType WithSomeReallyLongValue);"); 7039 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 7040 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 7041 " return left.group < right.group;\n" 7042 "}"); 7043 verifyFormat("SomeType &operator=(const SomeType &S);"); 7044 verifyFormat("f.template operator()<int>();"); 7045 7046 verifyGoogleFormat("operator void*();"); 7047 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 7048 verifyGoogleFormat("operator ::A();"); 7049 7050 verifyFormat("using A::operator+;"); 7051 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 7052 "int i;"); 7053 } 7054 7055 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 7056 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 7057 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 7058 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 7059 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 7060 verifyFormat("Deleted &operator=(const Deleted &) &;"); 7061 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 7062 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 7063 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 7064 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 7065 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 7066 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 7067 verifyFormat("void Fn(T const &) const &;"); 7068 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 7069 verifyFormat("template <typename T>\n" 7070 "void F(T) && = delete;", 7071 getGoogleStyle()); 7072 7073 FormatStyle AlignLeft = getLLVMStyle(); 7074 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 7075 verifyFormat("void A::b() && {}", AlignLeft); 7076 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 7077 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 7078 AlignLeft); 7079 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 7080 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 7081 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 7082 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 7083 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 7084 verifyFormat("auto Function(T) & -> void;", AlignLeft); 7085 verifyFormat("void Fn(T const&) const&;", AlignLeft); 7086 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 7087 7088 FormatStyle Spaces = getLLVMStyle(); 7089 Spaces.SpacesInCStyleCastParentheses = true; 7090 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 7091 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 7092 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 7093 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 7094 7095 Spaces.SpacesInCStyleCastParentheses = false; 7096 Spaces.SpacesInParentheses = true; 7097 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 7098 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", 7099 Spaces); 7100 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 7101 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 7102 7103 FormatStyle BreakTemplate = getLLVMStyle(); 7104 BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 7105 7106 verifyFormat("struct f {\n" 7107 " template <class T>\n" 7108 " int &foo(const std::string &str) &noexcept {}\n" 7109 "};", 7110 BreakTemplate); 7111 7112 verifyFormat("struct f {\n" 7113 " template <class T>\n" 7114 " int &foo(const std::string &str) &&noexcept {}\n" 7115 "};", 7116 BreakTemplate); 7117 7118 verifyFormat("struct f {\n" 7119 " template <class T>\n" 7120 " int &foo(const std::string &str) const &noexcept {}\n" 7121 "};", 7122 BreakTemplate); 7123 7124 verifyFormat("struct f {\n" 7125 " template <class T>\n" 7126 " int &foo(const std::string &str) const &noexcept {}\n" 7127 "};", 7128 BreakTemplate); 7129 7130 verifyFormat("struct f {\n" 7131 " template <class T>\n" 7132 " auto foo(const std::string &str) &&noexcept -> int & {}\n" 7133 "};", 7134 BreakTemplate); 7135 7136 FormatStyle AlignLeftBreakTemplate = getLLVMStyle(); 7137 AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations = 7138 FormatStyle::BTDS_Yes; 7139 AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left; 7140 7141 verifyFormat("struct f {\n" 7142 " template <class T>\n" 7143 " int& foo(const std::string& str) & noexcept {}\n" 7144 "};", 7145 AlignLeftBreakTemplate); 7146 7147 verifyFormat("struct f {\n" 7148 " template <class T>\n" 7149 " int& foo(const std::string& str) && noexcept {}\n" 7150 "};", 7151 AlignLeftBreakTemplate); 7152 7153 verifyFormat("struct f {\n" 7154 " template <class T>\n" 7155 " int& foo(const std::string& str) const& noexcept {}\n" 7156 "};", 7157 AlignLeftBreakTemplate); 7158 7159 verifyFormat("struct f {\n" 7160 " template <class T>\n" 7161 " int& foo(const std::string& str) const&& noexcept {}\n" 7162 "};", 7163 AlignLeftBreakTemplate); 7164 7165 verifyFormat("struct f {\n" 7166 " template <class T>\n" 7167 " auto foo(const std::string& str) && noexcept -> int& {}\n" 7168 "};", 7169 AlignLeftBreakTemplate); 7170 7171 // The `&` in `Type&` should not be confused with a trailing `&` of 7172 // DEPRECATED(reason) member function. 7173 verifyFormat("struct f {\n" 7174 " template <class T>\n" 7175 " DEPRECATED(reason)\n" 7176 " Type &foo(arguments) {}\n" 7177 "};", 7178 BreakTemplate); 7179 7180 verifyFormat("struct f {\n" 7181 " template <class T>\n" 7182 " DEPRECATED(reason)\n" 7183 " Type& foo(arguments) {}\n" 7184 "};", 7185 AlignLeftBreakTemplate); 7186 7187 verifyFormat("void (*foopt)(int) = &func;"); 7188 } 7189 7190 TEST_F(FormatTest, UnderstandsNewAndDelete) { 7191 verifyFormat("void f() {\n" 7192 " A *a = new A;\n" 7193 " A *a = new (placement) A;\n" 7194 " delete a;\n" 7195 " delete (A *)a;\n" 7196 "}"); 7197 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7198 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7199 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7200 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7201 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7202 verifyFormat("delete[] h->p;"); 7203 } 7204 7205 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 7206 verifyFormat("int *f(int *a) {}"); 7207 verifyFormat("int main(int argc, char **argv) {}"); 7208 verifyFormat("Test::Test(int b) : a(b * b) {}"); 7209 verifyIndependentOfContext("f(a, *a);"); 7210 verifyFormat("void g() { f(*a); }"); 7211 verifyIndependentOfContext("int a = b * 10;"); 7212 verifyIndependentOfContext("int a = 10 * b;"); 7213 verifyIndependentOfContext("int a = b * c;"); 7214 verifyIndependentOfContext("int a += b * c;"); 7215 verifyIndependentOfContext("int a -= b * c;"); 7216 verifyIndependentOfContext("int a *= b * c;"); 7217 verifyIndependentOfContext("int a /= b * c;"); 7218 verifyIndependentOfContext("int a = *b;"); 7219 verifyIndependentOfContext("int a = *b * c;"); 7220 verifyIndependentOfContext("int a = b * *c;"); 7221 verifyIndependentOfContext("int a = b * (10);"); 7222 verifyIndependentOfContext("S << b * (10);"); 7223 verifyIndependentOfContext("return 10 * b;"); 7224 verifyIndependentOfContext("return *b * *c;"); 7225 verifyIndependentOfContext("return a & ~b;"); 7226 verifyIndependentOfContext("f(b ? *c : *d);"); 7227 verifyIndependentOfContext("int a = b ? *c : *d;"); 7228 verifyIndependentOfContext("*b = a;"); 7229 verifyIndependentOfContext("a * ~b;"); 7230 verifyIndependentOfContext("a * !b;"); 7231 verifyIndependentOfContext("a * +b;"); 7232 verifyIndependentOfContext("a * -b;"); 7233 verifyIndependentOfContext("a * ++b;"); 7234 verifyIndependentOfContext("a * --b;"); 7235 verifyIndependentOfContext("a[4] * b;"); 7236 verifyIndependentOfContext("a[a * a] = 1;"); 7237 verifyIndependentOfContext("f() * b;"); 7238 verifyIndependentOfContext("a * [self dostuff];"); 7239 verifyIndependentOfContext("int x = a * (a + b);"); 7240 verifyIndependentOfContext("(a *)(a + b);"); 7241 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 7242 verifyIndependentOfContext("int *pa = (int *)&a;"); 7243 verifyIndependentOfContext("return sizeof(int **);"); 7244 verifyIndependentOfContext("return sizeof(int ******);"); 7245 verifyIndependentOfContext("return (int **&)a;"); 7246 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 7247 verifyFormat("void f(Type (*parameter)[10]) {}"); 7248 verifyFormat("void f(Type (¶meter)[10]) {}"); 7249 verifyGoogleFormat("return sizeof(int**);"); 7250 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 7251 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 7252 verifyFormat("auto a = [](int **&, int ***) {};"); 7253 verifyFormat("auto PointerBinding = [](const char *S) {};"); 7254 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 7255 verifyFormat("[](const decltype(*a) &value) {}"); 7256 verifyFormat("decltype(a * b) F();"); 7257 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 7258 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 7259 verifyIndependentOfContext("typedef void (*f)(int *a);"); 7260 verifyIndependentOfContext("int i{a * b};"); 7261 verifyIndependentOfContext("aaa && aaa->f();"); 7262 verifyIndependentOfContext("int x = ~*p;"); 7263 verifyFormat("Constructor() : a(a), area(width * height) {}"); 7264 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 7265 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 7266 verifyFormat("void f() { f(a, c * d); }"); 7267 verifyFormat("void f() { f(new a(), c * d); }"); 7268 verifyFormat("void f(const MyOverride &override);"); 7269 verifyFormat("void f(const MyFinal &final);"); 7270 verifyIndependentOfContext("bool a = f() && override.f();"); 7271 verifyIndependentOfContext("bool a = f() && final.f();"); 7272 7273 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 7274 7275 verifyIndependentOfContext("A<int *> a;"); 7276 verifyIndependentOfContext("A<int **> a;"); 7277 verifyIndependentOfContext("A<int *, int *> a;"); 7278 verifyIndependentOfContext("A<int *[]> a;"); 7279 verifyIndependentOfContext( 7280 "const char *const p = reinterpret_cast<const char *const>(q);"); 7281 verifyIndependentOfContext("A<int **, int **> a;"); 7282 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 7283 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 7284 verifyFormat("for (; a && b;) {\n}"); 7285 verifyFormat("bool foo = true && [] { return false; }();"); 7286 7287 verifyFormat( 7288 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7289 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7290 7291 verifyGoogleFormat("int const* a = &b;"); 7292 verifyGoogleFormat("**outparam = 1;"); 7293 verifyGoogleFormat("*outparam = a * b;"); 7294 verifyGoogleFormat("int main(int argc, char** argv) {}"); 7295 verifyGoogleFormat("A<int*> a;"); 7296 verifyGoogleFormat("A<int**> a;"); 7297 verifyGoogleFormat("A<int*, int*> a;"); 7298 verifyGoogleFormat("A<int**, int**> a;"); 7299 verifyGoogleFormat("f(b ? *c : *d);"); 7300 verifyGoogleFormat("int a = b ? *c : *d;"); 7301 verifyGoogleFormat("Type* t = **x;"); 7302 verifyGoogleFormat("Type* t = *++*x;"); 7303 verifyGoogleFormat("*++*x;"); 7304 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 7305 verifyGoogleFormat("Type* t = x++ * y;"); 7306 verifyGoogleFormat( 7307 "const char* const p = reinterpret_cast<const char* const>(q);"); 7308 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 7309 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 7310 verifyGoogleFormat("template <typename T>\n" 7311 "void f(int i = 0, SomeType** temps = NULL);"); 7312 7313 FormatStyle Left = getLLVMStyle(); 7314 Left.PointerAlignment = FormatStyle::PAS_Left; 7315 verifyFormat("x = *a(x) = *a(y);", Left); 7316 verifyFormat("for (;; *a = b) {\n}", Left); 7317 verifyFormat("return *this += 1;", Left); 7318 verifyFormat("throw *x;", Left); 7319 verifyFormat("delete *x;", Left); 7320 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 7321 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 7322 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 7323 7324 verifyIndependentOfContext("a = *(x + y);"); 7325 verifyIndependentOfContext("a = &(x + y);"); 7326 verifyIndependentOfContext("*(x + y).call();"); 7327 verifyIndependentOfContext("&(x + y)->call();"); 7328 verifyFormat("void f() { &(*I).first; }"); 7329 7330 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 7331 verifyFormat( 7332 "int *MyValues = {\n" 7333 " *A, // Operator detection might be confused by the '{'\n" 7334 " *BB // Operator detection might be confused by previous comment\n" 7335 "};"); 7336 7337 verifyIndependentOfContext("if (int *a = &b)"); 7338 verifyIndependentOfContext("if (int &a = *b)"); 7339 verifyIndependentOfContext("if (a & b[i])"); 7340 verifyIndependentOfContext("if constexpr (a & b[i])"); 7341 verifyIndependentOfContext("if CONSTEXPR (a & b[i])"); 7342 verifyIndependentOfContext("if (a * (b * c))"); 7343 verifyIndependentOfContext("if constexpr (a * (b * c))"); 7344 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))"); 7345 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 7346 verifyIndependentOfContext("if (*b[i])"); 7347 verifyIndependentOfContext("if (int *a = (&b))"); 7348 verifyIndependentOfContext("while (int *a = &b)"); 7349 verifyIndependentOfContext("while (a * (b * c))"); 7350 verifyIndependentOfContext("size = sizeof *a;"); 7351 verifyIndependentOfContext("if (a && (b = c))"); 7352 verifyFormat("void f() {\n" 7353 " for (const int &v : Values) {\n" 7354 " }\n" 7355 "}"); 7356 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 7357 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 7358 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 7359 7360 verifyFormat("#define A (!a * b)"); 7361 verifyFormat("#define MACRO \\\n" 7362 " int *i = a * b; \\\n" 7363 " void f(a *b);", 7364 getLLVMStyleWithColumns(19)); 7365 7366 verifyIndependentOfContext("A = new SomeType *[Length];"); 7367 verifyIndependentOfContext("A = new SomeType *[Length]();"); 7368 verifyIndependentOfContext("T **t = new T *;"); 7369 verifyIndependentOfContext("T **t = new T *();"); 7370 verifyGoogleFormat("A = new SomeType*[Length]();"); 7371 verifyGoogleFormat("A = new SomeType*[Length];"); 7372 verifyGoogleFormat("T** t = new T*;"); 7373 verifyGoogleFormat("T** t = new T*();"); 7374 7375 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 7376 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 7377 verifyFormat("template <bool a, bool b> " 7378 "typename t::if<x && y>::type f() {}"); 7379 verifyFormat("template <int *y> f() {}"); 7380 verifyFormat("vector<int *> v;"); 7381 verifyFormat("vector<int *const> v;"); 7382 verifyFormat("vector<int *const **const *> v;"); 7383 verifyFormat("vector<int *volatile> v;"); 7384 verifyFormat("vector<a * b> v;"); 7385 verifyFormat("foo<b && false>();"); 7386 verifyFormat("foo<b & 1>();"); 7387 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 7388 verifyFormat( 7389 "template <class T, class = typename std::enable_if<\n" 7390 " std::is_integral<T>::value &&\n" 7391 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 7392 "void F();", 7393 getLLVMStyleWithColumns(70)); 7394 verifyFormat("template <class T,\n" 7395 " class = typename std::enable_if<\n" 7396 " std::is_integral<T>::value &&\n" 7397 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 7398 " class U>\n" 7399 "void F();", 7400 getLLVMStyleWithColumns(70)); 7401 verifyFormat( 7402 "template <class T,\n" 7403 " class = typename ::std::enable_if<\n" 7404 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 7405 "void F();", 7406 getGoogleStyleWithColumns(68)); 7407 7408 verifyIndependentOfContext("MACRO(int *i);"); 7409 verifyIndependentOfContext("MACRO(auto *a);"); 7410 verifyIndependentOfContext("MACRO(const A *a);"); 7411 verifyIndependentOfContext("MACRO(A *const a);"); 7412 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 7413 verifyFormat("void f() { f(float{1}, a * a); }"); 7414 // FIXME: Is there a way to make this work? 7415 // verifyIndependentOfContext("MACRO(A *a);"); 7416 7417 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 7418 verifyFormat("return options != nullptr && operator==(*options);"); 7419 7420 EXPECT_EQ("#define OP(x) \\\n" 7421 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7422 " return s << a.DebugString(); \\\n" 7423 " }", 7424 format("#define OP(x) \\\n" 7425 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7426 " return s << a.DebugString(); \\\n" 7427 " }", 7428 getLLVMStyleWithColumns(50))); 7429 7430 // FIXME: We cannot handle this case yet; we might be able to figure out that 7431 // foo<x> d > v; doesn't make sense. 7432 verifyFormat("foo<a<b && c> d> v;"); 7433 7434 FormatStyle PointerMiddle = getLLVMStyle(); 7435 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7436 verifyFormat("delete *x;", PointerMiddle); 7437 verifyFormat("int * x;", PointerMiddle); 7438 verifyFormat("int *[] x;", PointerMiddle); 7439 verifyFormat("template <int * y> f() {}", PointerMiddle); 7440 verifyFormat("int * f(int * a) {}", PointerMiddle); 7441 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7442 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7443 verifyFormat("A<int *> a;", PointerMiddle); 7444 verifyFormat("A<int **> a;", PointerMiddle); 7445 verifyFormat("A<int *, int *> a;", PointerMiddle); 7446 verifyFormat("A<int *[]> a;", PointerMiddle); 7447 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7448 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7449 verifyFormat("T ** t = new T *;", PointerMiddle); 7450 7451 // Member function reference qualifiers aren't binary operators. 7452 verifyFormat("string // break\n" 7453 "operator()() & {}"); 7454 verifyFormat("string // break\n" 7455 "operator()() && {}"); 7456 verifyGoogleFormat("template <typename T>\n" 7457 "auto x() & -> int {}"); 7458 } 7459 7460 TEST_F(FormatTest, UnderstandsAttributes) { 7461 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7462 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7463 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7464 FormatStyle AfterType = getLLVMStyle(); 7465 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7466 verifyFormat("__attribute__((nodebug)) void\n" 7467 "foo() {}\n", 7468 AfterType); 7469 } 7470 7471 TEST_F(FormatTest, UnderstandsSquareAttributes) { 7472 verifyFormat("SomeType s [[unused]] (InitValue);"); 7473 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 7474 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 7475 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 7476 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 7477 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7478 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7479 7480 // Make sure we do not mistake attributes for array subscripts. 7481 verifyFormat("int a() {}\n" 7482 "[[unused]] int b() {}\n"); 7483 verifyFormat("NSArray *arr;\n" 7484 "arr[[Foo() bar]];"); 7485 7486 // On the other hand, we still need to correctly find array subscripts. 7487 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 7488 7489 // Make sure that we do not mistake Objective-C method inside array literals 7490 // as attributes, even if those method names are also keywords. 7491 verifyFormat("@[ [foo bar] ];"); 7492 verifyFormat("@[ [NSArray class] ];"); 7493 verifyFormat("@[ [foo enum] ];"); 7494 7495 // Make sure we do not parse attributes as lambda introducers. 7496 FormatStyle MultiLineFunctions = getLLVMStyle(); 7497 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7498 verifyFormat("[[unused]] int b() {\n" 7499 " return 42;\n" 7500 "}\n", 7501 MultiLineFunctions); 7502 } 7503 7504 TEST_F(FormatTest, UnderstandsEllipsis) { 7505 verifyFormat("int printf(const char *fmt, ...);"); 7506 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 7507 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 7508 7509 FormatStyle PointersLeft = getLLVMStyle(); 7510 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 7511 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 7512 } 7513 7514 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 7515 EXPECT_EQ("int *a;\n" 7516 "int *a;\n" 7517 "int *a;", 7518 format("int *a;\n" 7519 "int* a;\n" 7520 "int *a;", 7521 getGoogleStyle())); 7522 EXPECT_EQ("int* a;\n" 7523 "int* a;\n" 7524 "int* a;", 7525 format("int* a;\n" 7526 "int* a;\n" 7527 "int *a;", 7528 getGoogleStyle())); 7529 EXPECT_EQ("int *a;\n" 7530 "int *a;\n" 7531 "int *a;", 7532 format("int *a;\n" 7533 "int * a;\n" 7534 "int * a;", 7535 getGoogleStyle())); 7536 EXPECT_EQ("auto x = [] {\n" 7537 " int *a;\n" 7538 " int *a;\n" 7539 " int *a;\n" 7540 "};", 7541 format("auto x=[]{int *a;\n" 7542 "int * a;\n" 7543 "int * a;};", 7544 getGoogleStyle())); 7545 } 7546 7547 TEST_F(FormatTest, UnderstandsRvalueReferences) { 7548 verifyFormat("int f(int &&a) {}"); 7549 verifyFormat("int f(int a, char &&b) {}"); 7550 verifyFormat("void f() { int &&a = b; }"); 7551 verifyGoogleFormat("int f(int a, char&& b) {}"); 7552 verifyGoogleFormat("void f() { int&& a = b; }"); 7553 7554 verifyIndependentOfContext("A<int &&> a;"); 7555 verifyIndependentOfContext("A<int &&, int &&> a;"); 7556 verifyGoogleFormat("A<int&&> a;"); 7557 verifyGoogleFormat("A<int&&, int&&> a;"); 7558 7559 // Not rvalue references: 7560 verifyFormat("template <bool B, bool C> class A {\n" 7561 " static_assert(B && C, \"Something is wrong\");\n" 7562 "};"); 7563 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 7564 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 7565 verifyFormat("#define A(a, b) (a && b)"); 7566 } 7567 7568 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 7569 verifyFormat("void f() {\n" 7570 " x[aaaaaaaaa -\n" 7571 " b] = 23;\n" 7572 "}", 7573 getLLVMStyleWithColumns(15)); 7574 } 7575 7576 TEST_F(FormatTest, FormatsCasts) { 7577 verifyFormat("Type *A = static_cast<Type *>(P);"); 7578 verifyFormat("Type *A = (Type *)P;"); 7579 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7580 verifyFormat("int a = (int)(2.0f);"); 7581 verifyFormat("int a = (int)2.0f;"); 7582 verifyFormat("x[(int32)y];"); 7583 verifyFormat("x = (int32)y;"); 7584 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7585 verifyFormat("int a = (int)*b;"); 7586 verifyFormat("int a = (int)2.0f;"); 7587 verifyFormat("int a = (int)~0;"); 7588 verifyFormat("int a = (int)++a;"); 7589 verifyFormat("int a = (int)sizeof(int);"); 7590 verifyFormat("int a = (int)+2;"); 7591 verifyFormat("my_int a = (my_int)2.0f;"); 7592 verifyFormat("my_int a = (my_int)sizeof(int);"); 7593 verifyFormat("return (my_int)aaa;"); 7594 verifyFormat("#define x ((int)-1)"); 7595 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7596 verifyFormat("#define p(q) ((int *)&q)"); 7597 verifyFormat("fn(a)(b) + 1;"); 7598 7599 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7600 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7601 verifyFormat("my_int a = (my_int)~0;"); 7602 verifyFormat("my_int a = (my_int)++a;"); 7603 verifyFormat("my_int a = (my_int)-2;"); 7604 verifyFormat("my_int a = (my_int)1;"); 7605 verifyFormat("my_int a = (my_int *)1;"); 7606 verifyFormat("my_int a = (const my_int)-1;"); 7607 verifyFormat("my_int a = (const my_int *)-1;"); 7608 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7609 verifyFormat("my_int a = (ns::my_int)-2;"); 7610 verifyFormat("case (my_int)ONE:"); 7611 verifyFormat("auto x = (X)this;"); 7612 // Casts in Obj-C style calls used to not be recognized as such. 7613 verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle()); 7614 7615 // FIXME: single value wrapped with paren will be treated as cast. 7616 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7617 7618 verifyFormat("{ (void)F; }"); 7619 7620 // Don't break after a cast's 7621 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7622 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7623 " bbbbbbbbbbbbbbbbbbbbbb);"); 7624 7625 // These are not casts. 7626 verifyFormat("void f(int *) {}"); 7627 verifyFormat("f(foo)->b;"); 7628 verifyFormat("f(foo).b;"); 7629 verifyFormat("f(foo)(b);"); 7630 verifyFormat("f(foo)[b];"); 7631 verifyFormat("[](foo) { return 4; }(bar);"); 7632 verifyFormat("(*funptr)(foo)[4];"); 7633 verifyFormat("funptrs[4](foo)[4];"); 7634 verifyFormat("void f(int *);"); 7635 verifyFormat("void f(int *) = 0;"); 7636 verifyFormat("void f(SmallVector<int>) {}"); 7637 verifyFormat("void f(SmallVector<int>);"); 7638 verifyFormat("void f(SmallVector<int>) = 0;"); 7639 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7640 verifyFormat("int a = sizeof(int) * b;"); 7641 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7642 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7643 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7644 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7645 7646 // These are not casts, but at some point were confused with casts. 7647 verifyFormat("virtual void foo(int *) override;"); 7648 verifyFormat("virtual void foo(char &) const;"); 7649 verifyFormat("virtual void foo(int *a, char *) const;"); 7650 verifyFormat("int a = sizeof(int *) + b;"); 7651 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7652 verifyFormat("bool b = f(g<int>) && c;"); 7653 verifyFormat("typedef void (*f)(int i) func;"); 7654 verifyFormat("void operator++(int) noexcept;"); 7655 verifyFormat("void operator++(int &) noexcept;"); 7656 verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t " 7657 "&) noexcept;"); 7658 verifyFormat( 7659 "void operator delete(std::size_t, const std::nothrow_t &) noexcept;"); 7660 verifyFormat("void operator delete(const std::nothrow_t &) noexcept;"); 7661 verifyFormat("void operator delete(std::nothrow_t &) noexcept;"); 7662 verifyFormat("void operator delete(nothrow_t &) noexcept;"); 7663 verifyFormat("void operator delete(foo &) noexcept;"); 7664 verifyFormat("void operator delete(foo) noexcept;"); 7665 verifyFormat("void operator delete(int) noexcept;"); 7666 verifyFormat("void operator delete(int &) noexcept;"); 7667 verifyFormat("void operator delete(int &) volatile noexcept;"); 7668 verifyFormat("void operator delete(int &) const"); 7669 verifyFormat("void operator delete(int &) = default"); 7670 verifyFormat("void operator delete(int &) = delete"); 7671 verifyFormat("void operator delete(int &) [[noreturn]]"); 7672 verifyFormat("void operator delete(int &) throw();"); 7673 verifyFormat("void operator delete(int &) throw(int);"); 7674 verifyFormat("auto operator delete(int &) -> int;"); 7675 verifyFormat("auto operator delete(int &) override"); 7676 verifyFormat("auto operator delete(int &) final"); 7677 7678 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7679 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7680 // FIXME: The indentation here is not ideal. 7681 verifyFormat( 7682 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7683 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7684 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7685 } 7686 7687 TEST_F(FormatTest, FormatsFunctionTypes) { 7688 verifyFormat("A<bool()> a;"); 7689 verifyFormat("A<SomeType()> a;"); 7690 verifyFormat("A<void (*)(int, std::string)> a;"); 7691 verifyFormat("A<void *(int)>;"); 7692 verifyFormat("void *(*a)(int *, SomeType *);"); 7693 verifyFormat("int (*func)(void *);"); 7694 verifyFormat("void f() { int (*func)(void *); }"); 7695 verifyFormat("template <class CallbackClass>\n" 7696 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7697 7698 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7699 verifyGoogleFormat("void* (*a)(int);"); 7700 verifyGoogleFormat( 7701 "template <class CallbackClass>\n" 7702 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7703 7704 // Other constructs can look somewhat like function types: 7705 verifyFormat("A<sizeof(*x)> a;"); 7706 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7707 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7708 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7709 verifyFormat("int x = f(&h)();"); 7710 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7711 verifyFormat("std::function<\n" 7712 " LooooooooooongTemplatedType<\n" 7713 " SomeType>*(\n" 7714 " LooooooooooooooooongType type)>\n" 7715 " function;", 7716 getGoogleStyleWithColumns(40)); 7717 } 7718 7719 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7720 verifyFormat("A (*foo_)[6];"); 7721 verifyFormat("vector<int> (*foo_)[6];"); 7722 } 7723 7724 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7725 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7726 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7727 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7728 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7729 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7730 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7731 7732 // Different ways of ()-initializiation. 7733 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7734 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7735 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7736 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7737 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7738 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7739 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7740 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7741 7742 // Lambdas should not confuse the variable declaration heuristic. 7743 verifyFormat("LooooooooooooooooongType\n" 7744 " variable(nullptr, [](A *a) {});", 7745 getLLVMStyleWithColumns(40)); 7746 } 7747 7748 TEST_F(FormatTest, BreaksLongDeclarations) { 7749 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7750 " AnotherNameForTheLongType;"); 7751 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7752 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7753 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7754 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7755 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7756 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7757 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7758 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7759 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7760 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7761 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7762 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7763 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7764 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7765 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7766 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7767 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7768 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7769 FormatStyle Indented = getLLVMStyle(); 7770 Indented.IndentWrappedFunctionNames = true; 7771 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7772 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7773 Indented); 7774 verifyFormat( 7775 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7776 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7777 Indented); 7778 verifyFormat( 7779 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7780 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7781 Indented); 7782 verifyFormat( 7783 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7784 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7785 Indented); 7786 7787 // FIXME: Without the comment, this breaks after "(". 7788 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7789 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7790 getGoogleStyle()); 7791 7792 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7793 " int LoooooooooooooooooooongParam2) {}"); 7794 verifyFormat( 7795 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7796 " SourceLocation L, IdentifierIn *II,\n" 7797 " Type *T) {}"); 7798 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7799 "ReallyReaaallyLongFunctionName(\n" 7800 " const std::string &SomeParameter,\n" 7801 " const SomeType<string, SomeOtherTemplateParameter>\n" 7802 " &ReallyReallyLongParameterName,\n" 7803 " const SomeType<string, SomeOtherTemplateParameter>\n" 7804 " &AnotherLongParameterName) {}"); 7805 verifyFormat("template <typename A>\n" 7806 "SomeLoooooooooooooooooooooongType<\n" 7807 " typename some_namespace::SomeOtherType<A>::Type>\n" 7808 "Function() {}"); 7809 7810 verifyGoogleFormat( 7811 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7812 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7813 verifyGoogleFormat( 7814 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7815 " SourceLocation L) {}"); 7816 verifyGoogleFormat( 7817 "some_namespace::LongReturnType\n" 7818 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7819 " int first_long_parameter, int second_parameter) {}"); 7820 7821 verifyGoogleFormat("template <typename T>\n" 7822 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7823 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7824 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7825 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7826 7827 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7828 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7829 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7830 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7831 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7832 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 7833 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7834 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 7835 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 7836 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7837 7838 verifyFormat("template <typename T> // Templates on own line.\n" 7839 "static int // Some comment.\n" 7840 "MyFunction(int a);", 7841 getLLVMStyle()); 7842 } 7843 7844 TEST_F(FormatTest, FormatsArrays) { 7845 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7846 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 7847 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 7848 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 7849 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 7850 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 7851 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7852 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7853 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7854 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 7855 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7856 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7857 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7858 verifyFormat( 7859 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 7860 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7861 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 7862 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 7863 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7864 7865 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 7866 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 7867 verifyFormat( 7868 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 7869 " .aaaaaaa[0]\n" 7870 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7871 verifyFormat("a[::b::c];"); 7872 7873 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 7874 7875 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 7876 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 7877 } 7878 7879 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 7880 verifyFormat("(a)->b();"); 7881 verifyFormat("--a;"); 7882 } 7883 7884 TEST_F(FormatTest, HandlesIncludeDirectives) { 7885 verifyFormat("#include <string>\n" 7886 "#include <a/b/c.h>\n" 7887 "#include \"a/b/string\"\n" 7888 "#include \"string.h\"\n" 7889 "#include \"string.h\"\n" 7890 "#include <a-a>\n" 7891 "#include < path with space >\n" 7892 "#include_next <test.h>" 7893 "#include \"abc.h\" // this is included for ABC\n" 7894 "#include \"some long include\" // with a comment\n" 7895 "#include \"some very long include path\"\n" 7896 "#include <some/very/long/include/path>\n", 7897 getLLVMStyleWithColumns(35)); 7898 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 7899 EXPECT_EQ("#include <a>", format("#include<a>")); 7900 7901 verifyFormat("#import <string>"); 7902 verifyFormat("#import <a/b/c.h>"); 7903 verifyFormat("#import \"a/b/string\""); 7904 verifyFormat("#import \"string.h\""); 7905 verifyFormat("#import \"string.h\""); 7906 verifyFormat("#if __has_include(<strstream>)\n" 7907 "#include <strstream>\n" 7908 "#endif"); 7909 7910 verifyFormat("#define MY_IMPORT <a/b>"); 7911 7912 verifyFormat("#if __has_include(<a/b>)"); 7913 verifyFormat("#if __has_include_next(<a/b>)"); 7914 verifyFormat("#define F __has_include(<a/b>)"); 7915 verifyFormat("#define F __has_include_next(<a/b>)"); 7916 7917 // Protocol buffer definition or missing "#". 7918 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 7919 getLLVMStyleWithColumns(30)); 7920 7921 FormatStyle Style = getLLVMStyle(); 7922 Style.AlwaysBreakBeforeMultilineStrings = true; 7923 Style.ColumnLimit = 0; 7924 verifyFormat("#import \"abc.h\"", Style); 7925 7926 // But 'import' might also be a regular C++ namespace. 7927 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7928 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7929 } 7930 7931 //===----------------------------------------------------------------------===// 7932 // Error recovery tests. 7933 //===----------------------------------------------------------------------===// 7934 7935 TEST_F(FormatTest, IncompleteParameterLists) { 7936 FormatStyle NoBinPacking = getLLVMStyle(); 7937 NoBinPacking.BinPackParameters = false; 7938 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 7939 " double *min_x,\n" 7940 " double *max_x,\n" 7941 " double *min_y,\n" 7942 " double *max_y,\n" 7943 " double *min_z,\n" 7944 " double *max_z, ) {}", 7945 NoBinPacking); 7946 } 7947 7948 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 7949 verifyFormat("void f() { return; }\n42"); 7950 verifyFormat("void f() {\n" 7951 " if (0)\n" 7952 " return;\n" 7953 "}\n" 7954 "42"); 7955 verifyFormat("void f() { return }\n42"); 7956 verifyFormat("void f() {\n" 7957 " if (0)\n" 7958 " return\n" 7959 "}\n" 7960 "42"); 7961 } 7962 7963 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 7964 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 7965 EXPECT_EQ("void f() {\n" 7966 " if (a)\n" 7967 " return\n" 7968 "}", 7969 format("void f ( ) { if ( a ) return }")); 7970 EXPECT_EQ("namespace N {\n" 7971 "void f()\n" 7972 "}", 7973 format("namespace N { void f() }")); 7974 EXPECT_EQ("namespace N {\n" 7975 "void f() {}\n" 7976 "void g()\n" 7977 "} // namespace N", 7978 format("namespace N { void f( ) { } void g( ) }")); 7979 } 7980 7981 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 7982 verifyFormat("int aaaaaaaa =\n" 7983 " // Overlylongcomment\n" 7984 " b;", 7985 getLLVMStyleWithColumns(20)); 7986 verifyFormat("function(\n" 7987 " ShortArgument,\n" 7988 " LoooooooooooongArgument);\n", 7989 getLLVMStyleWithColumns(20)); 7990 } 7991 7992 TEST_F(FormatTest, IncorrectAccessSpecifier) { 7993 verifyFormat("public:"); 7994 verifyFormat("class A {\n" 7995 "public\n" 7996 " void f() {}\n" 7997 "};"); 7998 verifyFormat("public\n" 7999 "int qwerty;"); 8000 verifyFormat("public\n" 8001 "B {}"); 8002 verifyFormat("public\n" 8003 "{}"); 8004 verifyFormat("public\n" 8005 "B { int x; }"); 8006 } 8007 8008 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 8009 verifyFormat("{"); 8010 verifyFormat("#})"); 8011 verifyNoCrash("(/**/[:!] ?[)."); 8012 } 8013 8014 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 8015 // Found by oss-fuzz: 8016 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 8017 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 8018 Style.ColumnLimit = 60; 8019 verifyNoCrash( 8020 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 8021 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 8022 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 8023 Style); 8024 } 8025 8026 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 8027 verifyFormat("do {\n}"); 8028 verifyFormat("do {\n}\n" 8029 "f();"); 8030 verifyFormat("do {\n}\n" 8031 "wheeee(fun);"); 8032 verifyFormat("do {\n" 8033 " f();\n" 8034 "}"); 8035 } 8036 8037 TEST_F(FormatTest, IncorrectCodeMissingParens) { 8038 verifyFormat("if {\n foo;\n foo();\n}"); 8039 verifyFormat("switch {\n foo;\n foo();\n}"); 8040 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 8041 verifyFormat("while {\n foo;\n foo();\n}"); 8042 verifyFormat("do {\n foo;\n foo();\n} while;"); 8043 } 8044 8045 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 8046 verifyIncompleteFormat("namespace {\n" 8047 "class Foo { Foo (\n" 8048 "};\n" 8049 "} // namespace"); 8050 } 8051 8052 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 8053 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 8054 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 8055 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 8056 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 8057 8058 EXPECT_EQ("{\n" 8059 " {\n" 8060 " breakme(\n" 8061 " qwe);\n" 8062 " }\n", 8063 format("{\n" 8064 " {\n" 8065 " breakme(qwe);\n" 8066 "}\n", 8067 getLLVMStyleWithColumns(10))); 8068 } 8069 8070 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 8071 verifyFormat("int x = {\n" 8072 " avariable,\n" 8073 " b(alongervariable)};", 8074 getLLVMStyleWithColumns(25)); 8075 } 8076 8077 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 8078 verifyFormat("return (a)(b){1, 2, 3};"); 8079 } 8080 8081 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 8082 verifyFormat("vector<int> x{1, 2, 3, 4};"); 8083 verifyFormat("vector<int> x{\n" 8084 " 1,\n" 8085 " 2,\n" 8086 " 3,\n" 8087 " 4,\n" 8088 "};"); 8089 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 8090 verifyFormat("f({1, 2});"); 8091 verifyFormat("auto v = Foo{-1};"); 8092 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 8093 verifyFormat("Class::Class : member{1, 2, 3} {}"); 8094 verifyFormat("new vector<int>{1, 2, 3};"); 8095 verifyFormat("new int[3]{1, 2, 3};"); 8096 verifyFormat("new int{1};"); 8097 verifyFormat("return {arg1, arg2};"); 8098 verifyFormat("return {arg1, SomeType{parameter}};"); 8099 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 8100 verifyFormat("new T{arg1, arg2};"); 8101 verifyFormat("f(MyMap[{composite, key}]);"); 8102 verifyFormat("class Class {\n" 8103 " T member = {arg1, arg2};\n" 8104 "};"); 8105 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 8106 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 8107 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 8108 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 8109 verifyFormat("int a = std::is_integral<int>{} + 0;"); 8110 8111 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8112 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8113 verifyFormat("auto i = decltype(x){};"); 8114 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 8115 verifyFormat("Node n{1, Node{1000}, //\n" 8116 " 2};"); 8117 verifyFormat("Aaaa aaaaaaa{\n" 8118 " {\n" 8119 " aaaa,\n" 8120 " },\n" 8121 "};"); 8122 verifyFormat("class C : public D {\n" 8123 " SomeClass SC{2};\n" 8124 "};"); 8125 verifyFormat("class C : public A {\n" 8126 " class D : public B {\n" 8127 " void f() { int i{2}; }\n" 8128 " };\n" 8129 "};"); 8130 verifyFormat("#define A {a, a},"); 8131 8132 // Avoid breaking between equal sign and opening brace 8133 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 8134 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 8135 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 8136 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 8137 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 8138 " {\"ccccccccccccccccccccc\", 2}};", 8139 AvoidBreakingFirstArgument); 8140 8141 // Binpacking only if there is no trailing comma 8142 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 8143 " cccccccccc, dddddddddd};", 8144 getLLVMStyleWithColumns(50)); 8145 verifyFormat("const Aaaaaa aaaaa = {\n" 8146 " aaaaaaaaaaa,\n" 8147 " bbbbbbbbbbb,\n" 8148 " ccccccccccc,\n" 8149 " ddddddddddd,\n" 8150 "};", 8151 getLLVMStyleWithColumns(50)); 8152 8153 // Cases where distinguising braced lists and blocks is hard. 8154 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 8155 verifyFormat("void f() {\n" 8156 " return; // comment\n" 8157 "}\n" 8158 "SomeType t;"); 8159 verifyFormat("void f() {\n" 8160 " if (a) {\n" 8161 " f();\n" 8162 " }\n" 8163 "}\n" 8164 "SomeType t;"); 8165 8166 // In combination with BinPackArguments = false. 8167 FormatStyle NoBinPacking = getLLVMStyle(); 8168 NoBinPacking.BinPackArguments = false; 8169 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 8170 " bbbbb,\n" 8171 " ccccc,\n" 8172 " ddddd,\n" 8173 " eeeee,\n" 8174 " ffffff,\n" 8175 " ggggg,\n" 8176 " hhhhhh,\n" 8177 " iiiiii,\n" 8178 " jjjjjj,\n" 8179 " kkkkkk};", 8180 NoBinPacking); 8181 verifyFormat("const Aaaaaa aaaaa = {\n" 8182 " aaaaa,\n" 8183 " bbbbb,\n" 8184 " ccccc,\n" 8185 " ddddd,\n" 8186 " eeeee,\n" 8187 " ffffff,\n" 8188 " ggggg,\n" 8189 " hhhhhh,\n" 8190 " iiiiii,\n" 8191 " jjjjjj,\n" 8192 " kkkkkk,\n" 8193 "};", 8194 NoBinPacking); 8195 verifyFormat( 8196 "const Aaaaaa aaaaa = {\n" 8197 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 8198 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 8199 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 8200 "};", 8201 NoBinPacking); 8202 8203 NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 8204 EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n" 8205 " CDDDP83848_BMCR_REGISTER,\n" 8206 " CDDDP83848_BMSR_REGISTER,\n" 8207 " CDDDP83848_RBR_REGISTER};", 8208 format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n" 8209 " CDDDP83848_BMSR_REGISTER,\n" 8210 " CDDDP83848_RBR_REGISTER};", 8211 NoBinPacking)); 8212 8213 // FIXME: The alignment of these trailing comments might be bad. Then again, 8214 // this might be utterly useless in real code. 8215 verifyFormat("Constructor::Constructor()\n" 8216 " : some_value{ //\n" 8217 " aaaaaaa, //\n" 8218 " bbbbbbb} {}"); 8219 8220 // In braced lists, the first comment is always assumed to belong to the 8221 // first element. Thus, it can be moved to the next or previous line as 8222 // appropriate. 8223 EXPECT_EQ("function({// First element:\n" 8224 " 1,\n" 8225 " // Second element:\n" 8226 " 2});", 8227 format("function({\n" 8228 " // First element:\n" 8229 " 1,\n" 8230 " // Second element:\n" 8231 " 2});")); 8232 EXPECT_EQ("std::vector<int> MyNumbers{\n" 8233 " // First element:\n" 8234 " 1,\n" 8235 " // Second element:\n" 8236 " 2};", 8237 format("std::vector<int> MyNumbers{// First element:\n" 8238 " 1,\n" 8239 " // Second element:\n" 8240 " 2};", 8241 getLLVMStyleWithColumns(30))); 8242 // A trailing comma should still lead to an enforced line break and no 8243 // binpacking. 8244 EXPECT_EQ("vector<int> SomeVector = {\n" 8245 " // aaa\n" 8246 " 1,\n" 8247 " 2,\n" 8248 "};", 8249 format("vector<int> SomeVector = { // aaa\n" 8250 " 1, 2, };")); 8251 8252 FormatStyle ExtraSpaces = getLLVMStyle(); 8253 ExtraSpaces.Cpp11BracedListStyle = false; 8254 ExtraSpaces.ColumnLimit = 75; 8255 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 8256 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 8257 verifyFormat("f({ 1, 2 });", ExtraSpaces); 8258 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 8259 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 8260 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 8261 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 8262 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 8263 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 8264 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 8265 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 8266 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 8267 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 8268 verifyFormat("class Class {\n" 8269 " T member = { arg1, arg2 };\n" 8270 "};", 8271 ExtraSpaces); 8272 verifyFormat( 8273 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8274 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 8275 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 8276 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 8277 ExtraSpaces); 8278 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 8279 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 8280 ExtraSpaces); 8281 verifyFormat( 8282 "someFunction(OtherParam,\n" 8283 " BracedList{ // comment 1 (Forcing interesting break)\n" 8284 " param1, param2,\n" 8285 " // comment 2\n" 8286 " param3, param4 });", 8287 ExtraSpaces); 8288 verifyFormat( 8289 "std::this_thread::sleep_for(\n" 8290 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 8291 ExtraSpaces); 8292 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 8293 " aaaaaaa,\n" 8294 " aaaaaaaaaa,\n" 8295 " aaaaa,\n" 8296 " aaaaaaaaaaaaaaa,\n" 8297 " aaa,\n" 8298 " aaaaaaaaaa,\n" 8299 " a,\n" 8300 " aaaaaaaaaaaaaaaaaaaaa,\n" 8301 " aaaaaaaaaaaa,\n" 8302 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 8303 " aaaaaaa,\n" 8304 " a};"); 8305 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 8306 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 8307 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 8308 8309 // Avoid breaking between initializer/equal sign and opening brace 8310 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 8311 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 8312 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8313 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8314 " { \"ccccccccccccccccccccc\", 2 }\n" 8315 "};", 8316 ExtraSpaces); 8317 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 8318 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8319 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8320 " { \"ccccccccccccccccccccc\", 2 }\n" 8321 "};", 8322 ExtraSpaces); 8323 8324 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 8325 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 8326 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 8327 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 8328 8329 FormatStyle SpaceBetweenBraces = getLLVMStyle(); 8330 SpaceBetweenBraces.SpacesInAngles = true; 8331 SpaceBetweenBraces.SpacesInParentheses = true; 8332 SpaceBetweenBraces.SpacesInSquareBrackets = true; 8333 verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces); 8334 verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces); 8335 verifyFormat("vector< int > x{ // comment 1\n" 8336 " 1, 2, 3, 4 };", 8337 SpaceBetweenBraces); 8338 SpaceBetweenBraces.ColumnLimit = 20; 8339 EXPECT_EQ("vector< int > x{\n" 8340 " 1, 2, 3, 4 };", 8341 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8342 SpaceBetweenBraces.ColumnLimit = 24; 8343 EXPECT_EQ("vector< int > x{ 1, 2,\n" 8344 " 3, 4 };", 8345 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8346 EXPECT_EQ("vector< int > x{\n" 8347 " 1,\n" 8348 " 2,\n" 8349 " 3,\n" 8350 " 4,\n" 8351 "};", 8352 format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces)); 8353 verifyFormat("vector< int > x{};", SpaceBetweenBraces); 8354 SpaceBetweenBraces.SpaceInEmptyParentheses = true; 8355 verifyFormat("vector< int > x{ };", SpaceBetweenBraces); 8356 } 8357 8358 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 8359 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8360 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8361 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8362 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8363 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8364 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8365 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 8366 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8367 " 1, 22, 333, 4444, 55555, //\n" 8368 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8369 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8370 verifyFormat( 8371 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8372 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8373 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 8374 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8375 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8376 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8377 " 7777777};"); 8378 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8379 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8380 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8381 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8382 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8383 " // Separating comment.\n" 8384 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8385 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8386 " // Leading comment\n" 8387 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8388 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8389 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8390 " 1, 1, 1, 1};", 8391 getLLVMStyleWithColumns(39)); 8392 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8393 " 1, 1, 1, 1};", 8394 getLLVMStyleWithColumns(38)); 8395 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 8396 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 8397 getLLVMStyleWithColumns(43)); 8398 verifyFormat( 8399 "static unsigned SomeValues[10][3] = {\n" 8400 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 8401 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 8402 verifyFormat("static auto fields = new vector<string>{\n" 8403 " \"aaaaaaaaaaaaa\",\n" 8404 " \"aaaaaaaaaaaaa\",\n" 8405 " \"aaaaaaaaaaaa\",\n" 8406 " \"aaaaaaaaaaaaaa\",\n" 8407 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8408 " \"aaaaaaaaaaaa\",\n" 8409 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8410 "};"); 8411 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 8412 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 8413 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 8414 " 3, cccccccccccccccccccccc};", 8415 getLLVMStyleWithColumns(60)); 8416 8417 // Trailing commas. 8418 verifyFormat("vector<int> x = {\n" 8419 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 8420 "};", 8421 getLLVMStyleWithColumns(39)); 8422 verifyFormat("vector<int> x = {\n" 8423 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 8424 "};", 8425 getLLVMStyleWithColumns(39)); 8426 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8427 " 1, 1, 1, 1,\n" 8428 " /**/ /**/};", 8429 getLLVMStyleWithColumns(39)); 8430 8431 // Trailing comment in the first line. 8432 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 8433 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 8434 " 111111111, 222222222, 3333333333, 444444444, //\n" 8435 " 11111111, 22222222, 333333333, 44444444};"); 8436 // Trailing comment in the last line. 8437 verifyFormat("int aaaaa[] = {\n" 8438 " 1, 2, 3, // comment\n" 8439 " 4, 5, 6 // comment\n" 8440 "};"); 8441 8442 // With nested lists, we should either format one item per line or all nested 8443 // lists one on line. 8444 // FIXME: For some nested lists, we can do better. 8445 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 8446 " {aaaaaaaaaaaaaaaaaaa},\n" 8447 " {aaaaaaaaaaaaaaaaaaaaa},\n" 8448 " {aaaaaaaaaaaaaaaaa}};", 8449 getLLVMStyleWithColumns(60)); 8450 verifyFormat( 8451 "SomeStruct my_struct_array = {\n" 8452 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 8453 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 8454 " {aaa, aaa},\n" 8455 " {aaa, aaa},\n" 8456 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 8457 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 8458 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 8459 8460 // No column layout should be used here. 8461 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 8462 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 8463 8464 verifyNoCrash("a<,"); 8465 8466 // No braced initializer here. 8467 verifyFormat("void f() {\n" 8468 " struct Dummy {};\n" 8469 " f(v);\n" 8470 "}"); 8471 8472 // Long lists should be formatted in columns even if they are nested. 8473 verifyFormat( 8474 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8475 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8476 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8477 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8478 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8479 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 8480 8481 // Allow "single-column" layout even if that violates the column limit. There 8482 // isn't going to be a better way. 8483 verifyFormat("std::vector<int> a = {\n" 8484 " aaaaaaaa,\n" 8485 " aaaaaaaa,\n" 8486 " aaaaaaaa,\n" 8487 " aaaaaaaa,\n" 8488 " aaaaaaaaaa,\n" 8489 " aaaaaaaa,\n" 8490 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 8491 getLLVMStyleWithColumns(30)); 8492 verifyFormat("vector<int> aaaa = {\n" 8493 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8494 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8495 " aaaaaa.aaaaaaa,\n" 8496 " aaaaaa.aaaaaaa,\n" 8497 " aaaaaa.aaaaaaa,\n" 8498 " aaaaaa.aaaaaaa,\n" 8499 "};"); 8500 8501 // Don't create hanging lists. 8502 verifyFormat("someFunction(Param, {List1, List2,\n" 8503 " List3});", 8504 getLLVMStyleWithColumns(35)); 8505 verifyFormat("someFunction(Param, Param,\n" 8506 " {List1, List2,\n" 8507 " List3});", 8508 getLLVMStyleWithColumns(35)); 8509 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 8510 " aaaaaaaaaaaaaaaaaaaaaaa);"); 8511 } 8512 8513 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 8514 FormatStyle DoNotMerge = getLLVMStyle(); 8515 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8516 8517 verifyFormat("void f() { return 42; }"); 8518 verifyFormat("void f() {\n" 8519 " return 42;\n" 8520 "}", 8521 DoNotMerge); 8522 verifyFormat("void f() {\n" 8523 " // Comment\n" 8524 "}"); 8525 verifyFormat("{\n" 8526 "#error {\n" 8527 " int a;\n" 8528 "}"); 8529 verifyFormat("{\n" 8530 " int a;\n" 8531 "#error {\n" 8532 "}"); 8533 verifyFormat("void f() {} // comment"); 8534 verifyFormat("void f() { int a; } // comment"); 8535 verifyFormat("void f() {\n" 8536 "} // comment", 8537 DoNotMerge); 8538 verifyFormat("void f() {\n" 8539 " int a;\n" 8540 "} // comment", 8541 DoNotMerge); 8542 verifyFormat("void f() {\n" 8543 "} // comment", 8544 getLLVMStyleWithColumns(15)); 8545 8546 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 8547 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 8548 8549 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 8550 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 8551 verifyFormat("class C {\n" 8552 " C()\n" 8553 " : iiiiiiii(nullptr),\n" 8554 " kkkkkkk(nullptr),\n" 8555 " mmmmmmm(nullptr),\n" 8556 " nnnnnnn(nullptr) {}\n" 8557 "};", 8558 getGoogleStyle()); 8559 8560 FormatStyle NoColumnLimit = getLLVMStyle(); 8561 NoColumnLimit.ColumnLimit = 0; 8562 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 8563 EXPECT_EQ("class C {\n" 8564 " A() : b(0) {}\n" 8565 "};", 8566 format("class C{A():b(0){}};", NoColumnLimit)); 8567 EXPECT_EQ("A()\n" 8568 " : b(0) {\n" 8569 "}", 8570 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 8571 8572 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 8573 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 8574 FormatStyle::SFS_None; 8575 EXPECT_EQ("A()\n" 8576 " : b(0) {\n" 8577 "}", 8578 format("A():b(0){}", DoNotMergeNoColumnLimit)); 8579 EXPECT_EQ("A()\n" 8580 " : b(0) {\n" 8581 "}", 8582 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 8583 8584 verifyFormat("#define A \\\n" 8585 " void f() { \\\n" 8586 " int i; \\\n" 8587 " }", 8588 getLLVMStyleWithColumns(20)); 8589 verifyFormat("#define A \\\n" 8590 " void f() { int i; }", 8591 getLLVMStyleWithColumns(21)); 8592 verifyFormat("#define A \\\n" 8593 " void f() { \\\n" 8594 " int i; \\\n" 8595 " } \\\n" 8596 " int j;", 8597 getLLVMStyleWithColumns(22)); 8598 verifyFormat("#define A \\\n" 8599 " void f() { int i; } \\\n" 8600 " int j;", 8601 getLLVMStyleWithColumns(23)); 8602 } 8603 8604 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 8605 FormatStyle MergeEmptyOnly = getLLVMStyle(); 8606 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8607 verifyFormat("class C {\n" 8608 " int f() {}\n" 8609 "};", 8610 MergeEmptyOnly); 8611 verifyFormat("class C {\n" 8612 " int f() {\n" 8613 " return 42;\n" 8614 " }\n" 8615 "};", 8616 MergeEmptyOnly); 8617 verifyFormat("int f() {}", MergeEmptyOnly); 8618 verifyFormat("int f() {\n" 8619 " return 42;\n" 8620 "}", 8621 MergeEmptyOnly); 8622 8623 // Also verify behavior when BraceWrapping.AfterFunction = true 8624 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8625 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 8626 verifyFormat("int f() {}", MergeEmptyOnly); 8627 verifyFormat("class C {\n" 8628 " int f() {}\n" 8629 "};", 8630 MergeEmptyOnly); 8631 } 8632 8633 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 8634 FormatStyle MergeInlineOnly = getLLVMStyle(); 8635 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8636 verifyFormat("class C {\n" 8637 " int f() { return 42; }\n" 8638 "};", 8639 MergeInlineOnly); 8640 verifyFormat("int f() {\n" 8641 " return 42;\n" 8642 "}", 8643 MergeInlineOnly); 8644 8645 // SFS_Inline implies SFS_Empty 8646 verifyFormat("class C {\n" 8647 " int f() {}\n" 8648 "};", 8649 MergeInlineOnly); 8650 verifyFormat("int f() {}", MergeInlineOnly); 8651 8652 // Also verify behavior when BraceWrapping.AfterFunction = true 8653 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8654 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8655 verifyFormat("class C {\n" 8656 " int f() { return 42; }\n" 8657 "};", 8658 MergeInlineOnly); 8659 verifyFormat("int f()\n" 8660 "{\n" 8661 " return 42;\n" 8662 "}", 8663 MergeInlineOnly); 8664 8665 // SFS_Inline implies SFS_Empty 8666 verifyFormat("int f() {}", MergeInlineOnly); 8667 verifyFormat("class C {\n" 8668 " int f() {}\n" 8669 "};", 8670 MergeInlineOnly); 8671 } 8672 8673 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8674 FormatStyle MergeInlineOnly = getLLVMStyle(); 8675 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8676 FormatStyle::SFS_InlineOnly; 8677 verifyFormat("class C {\n" 8678 " int f() { return 42; }\n" 8679 "};", 8680 MergeInlineOnly); 8681 verifyFormat("int f() {\n" 8682 " return 42;\n" 8683 "}", 8684 MergeInlineOnly); 8685 8686 // SFS_InlineOnly does not imply SFS_Empty 8687 verifyFormat("class C {\n" 8688 " int f() {}\n" 8689 "};", 8690 MergeInlineOnly); 8691 verifyFormat("int f() {\n" 8692 "}", 8693 MergeInlineOnly); 8694 8695 // Also verify behavior when BraceWrapping.AfterFunction = true 8696 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8697 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8698 verifyFormat("class C {\n" 8699 " int f() { return 42; }\n" 8700 "};", 8701 MergeInlineOnly); 8702 verifyFormat("int f()\n" 8703 "{\n" 8704 " return 42;\n" 8705 "}", 8706 MergeInlineOnly); 8707 8708 // SFS_InlineOnly does not imply SFS_Empty 8709 verifyFormat("int f()\n" 8710 "{\n" 8711 "}", 8712 MergeInlineOnly); 8713 verifyFormat("class C {\n" 8714 " int f() {}\n" 8715 "};", 8716 MergeInlineOnly); 8717 } 8718 8719 TEST_F(FormatTest, SplitEmptyFunction) { 8720 FormatStyle Style = getLLVMStyle(); 8721 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8722 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8723 Style.BraceWrapping.AfterFunction = true; 8724 Style.BraceWrapping.SplitEmptyFunction = false; 8725 Style.ColumnLimit = 40; 8726 8727 verifyFormat("int f()\n" 8728 "{}", 8729 Style); 8730 verifyFormat("int f()\n" 8731 "{\n" 8732 " return 42;\n" 8733 "}", 8734 Style); 8735 verifyFormat("int f()\n" 8736 "{\n" 8737 " // some comment\n" 8738 "}", 8739 Style); 8740 8741 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8742 verifyFormat("int f() {}", Style); 8743 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8744 "{}", 8745 Style); 8746 verifyFormat("int f()\n" 8747 "{\n" 8748 " return 0;\n" 8749 "}", 8750 Style); 8751 8752 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8753 verifyFormat("class Foo {\n" 8754 " int f() {}\n" 8755 "};\n", 8756 Style); 8757 verifyFormat("class Foo {\n" 8758 " int f() { return 0; }\n" 8759 "};\n", 8760 Style); 8761 verifyFormat("class Foo {\n" 8762 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8763 " {}\n" 8764 "};\n", 8765 Style); 8766 verifyFormat("class Foo {\n" 8767 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8768 " {\n" 8769 " return 0;\n" 8770 " }\n" 8771 "};\n", 8772 Style); 8773 8774 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8775 verifyFormat("int f() {}", Style); 8776 verifyFormat("int f() { return 0; }", Style); 8777 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8778 "{}", 8779 Style); 8780 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8781 "{\n" 8782 " return 0;\n" 8783 "}", 8784 Style); 8785 } 8786 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8787 FormatStyle Style = getLLVMStyle(); 8788 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8789 verifyFormat("#ifdef A\n" 8790 "int f() {}\n" 8791 "#else\n" 8792 "int g() {}\n" 8793 "#endif", 8794 Style); 8795 } 8796 8797 TEST_F(FormatTest, SplitEmptyClass) { 8798 FormatStyle Style = getLLVMStyle(); 8799 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8800 Style.BraceWrapping.AfterClass = true; 8801 Style.BraceWrapping.SplitEmptyRecord = false; 8802 8803 verifyFormat("class Foo\n" 8804 "{};", 8805 Style); 8806 verifyFormat("/* something */ class Foo\n" 8807 "{};", 8808 Style); 8809 verifyFormat("template <typename X> class Foo\n" 8810 "{};", 8811 Style); 8812 verifyFormat("class Foo\n" 8813 "{\n" 8814 " Foo();\n" 8815 "};", 8816 Style); 8817 verifyFormat("typedef class Foo\n" 8818 "{\n" 8819 "} Foo_t;", 8820 Style); 8821 } 8822 8823 TEST_F(FormatTest, SplitEmptyStruct) { 8824 FormatStyle Style = getLLVMStyle(); 8825 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8826 Style.BraceWrapping.AfterStruct = true; 8827 Style.BraceWrapping.SplitEmptyRecord = false; 8828 8829 verifyFormat("struct Foo\n" 8830 "{};", 8831 Style); 8832 verifyFormat("/* something */ struct Foo\n" 8833 "{};", 8834 Style); 8835 verifyFormat("template <typename X> struct Foo\n" 8836 "{};", 8837 Style); 8838 verifyFormat("struct Foo\n" 8839 "{\n" 8840 " Foo();\n" 8841 "};", 8842 Style); 8843 verifyFormat("typedef struct Foo\n" 8844 "{\n" 8845 "} Foo_t;", 8846 Style); 8847 // typedef struct Bar {} Bar_t; 8848 } 8849 8850 TEST_F(FormatTest, SplitEmptyUnion) { 8851 FormatStyle Style = getLLVMStyle(); 8852 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8853 Style.BraceWrapping.AfterUnion = true; 8854 Style.BraceWrapping.SplitEmptyRecord = false; 8855 8856 verifyFormat("union Foo\n" 8857 "{};", 8858 Style); 8859 verifyFormat("/* something */ union Foo\n" 8860 "{};", 8861 Style); 8862 verifyFormat("union Foo\n" 8863 "{\n" 8864 " A,\n" 8865 "};", 8866 Style); 8867 verifyFormat("typedef union Foo\n" 8868 "{\n" 8869 "} Foo_t;", 8870 Style); 8871 } 8872 8873 TEST_F(FormatTest, SplitEmptyNamespace) { 8874 FormatStyle Style = getLLVMStyle(); 8875 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8876 Style.BraceWrapping.AfterNamespace = true; 8877 Style.BraceWrapping.SplitEmptyNamespace = false; 8878 8879 verifyFormat("namespace Foo\n" 8880 "{};", 8881 Style); 8882 verifyFormat("/* something */ namespace Foo\n" 8883 "{};", 8884 Style); 8885 verifyFormat("inline namespace Foo\n" 8886 "{};", 8887 Style); 8888 verifyFormat("/* something */ inline namespace Foo\n" 8889 "{};", 8890 Style); 8891 verifyFormat("export namespace Foo\n" 8892 "{};", 8893 Style); 8894 verifyFormat("namespace Foo\n" 8895 "{\n" 8896 "void Bar();\n" 8897 "};", 8898 Style); 8899 } 8900 8901 TEST_F(FormatTest, NeverMergeShortRecords) { 8902 FormatStyle Style = getLLVMStyle(); 8903 8904 verifyFormat("class Foo {\n" 8905 " Foo();\n" 8906 "};", 8907 Style); 8908 verifyFormat("typedef class Foo {\n" 8909 " Foo();\n" 8910 "} Foo_t;", 8911 Style); 8912 verifyFormat("struct Foo {\n" 8913 " Foo();\n" 8914 "};", 8915 Style); 8916 verifyFormat("typedef struct Foo {\n" 8917 " Foo();\n" 8918 "} Foo_t;", 8919 Style); 8920 verifyFormat("union Foo {\n" 8921 " A,\n" 8922 "};", 8923 Style); 8924 verifyFormat("typedef union Foo {\n" 8925 " A,\n" 8926 "} Foo_t;", 8927 Style); 8928 verifyFormat("namespace Foo {\n" 8929 "void Bar();\n" 8930 "};", 8931 Style); 8932 8933 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8934 Style.BraceWrapping.AfterClass = true; 8935 Style.BraceWrapping.AfterStruct = true; 8936 Style.BraceWrapping.AfterUnion = true; 8937 Style.BraceWrapping.AfterNamespace = true; 8938 verifyFormat("class Foo\n" 8939 "{\n" 8940 " Foo();\n" 8941 "};", 8942 Style); 8943 verifyFormat("typedef class Foo\n" 8944 "{\n" 8945 " Foo();\n" 8946 "} Foo_t;", 8947 Style); 8948 verifyFormat("struct Foo\n" 8949 "{\n" 8950 " Foo();\n" 8951 "};", 8952 Style); 8953 verifyFormat("typedef struct Foo\n" 8954 "{\n" 8955 " Foo();\n" 8956 "} Foo_t;", 8957 Style); 8958 verifyFormat("union Foo\n" 8959 "{\n" 8960 " A,\n" 8961 "};", 8962 Style); 8963 verifyFormat("typedef union Foo\n" 8964 "{\n" 8965 " A,\n" 8966 "} Foo_t;", 8967 Style); 8968 verifyFormat("namespace Foo\n" 8969 "{\n" 8970 "void Bar();\n" 8971 "};", 8972 Style); 8973 } 8974 8975 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 8976 // Elaborate type variable declarations. 8977 verifyFormat("struct foo a = {bar};\nint n;"); 8978 verifyFormat("class foo a = {bar};\nint n;"); 8979 verifyFormat("union foo a = {bar};\nint n;"); 8980 8981 // Elaborate types inside function definitions. 8982 verifyFormat("struct foo f() {}\nint n;"); 8983 verifyFormat("class foo f() {}\nint n;"); 8984 verifyFormat("union foo f() {}\nint n;"); 8985 8986 // Templates. 8987 verifyFormat("template <class X> void f() {}\nint n;"); 8988 verifyFormat("template <struct X> void f() {}\nint n;"); 8989 verifyFormat("template <union X> void f() {}\nint n;"); 8990 8991 // Actual definitions... 8992 verifyFormat("struct {\n} n;"); 8993 verifyFormat( 8994 "template <template <class T, class Y>, class Z> class X {\n} n;"); 8995 verifyFormat("union Z {\n int n;\n} x;"); 8996 verifyFormat("class MACRO Z {\n} n;"); 8997 verifyFormat("class MACRO(X) Z {\n} n;"); 8998 verifyFormat("class __attribute__(X) Z {\n} n;"); 8999 verifyFormat("class __declspec(X) Z {\n} n;"); 9000 verifyFormat("class A##B##C {\n} n;"); 9001 verifyFormat("class alignas(16) Z {\n} n;"); 9002 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 9003 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 9004 9005 // Redefinition from nested context: 9006 verifyFormat("class A::B::C {\n} n;"); 9007 9008 // Template definitions. 9009 verifyFormat( 9010 "template <typename F>\n" 9011 "Matcher(const Matcher<F> &Other,\n" 9012 " typename enable_if_c<is_base_of<F, T>::value &&\n" 9013 " !is_same<F, T>::value>::type * = 0)\n" 9014 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 9015 9016 // FIXME: This is still incorrectly handled at the formatter side. 9017 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 9018 verifyFormat("int i = SomeFunction(a<b, a> b);"); 9019 9020 // FIXME: 9021 // This now gets parsed incorrectly as class definition. 9022 // verifyFormat("class A<int> f() {\n}\nint n;"); 9023 9024 // Elaborate types where incorrectly parsing the structural element would 9025 // break the indent. 9026 verifyFormat("if (true)\n" 9027 " class X x;\n" 9028 "else\n" 9029 " f();\n"); 9030 9031 // This is simply incomplete. Formatting is not important, but must not crash. 9032 verifyFormat("class A:"); 9033 } 9034 9035 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 9036 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 9037 format("#error Leave all white!!!!! space* alone!\n")); 9038 EXPECT_EQ( 9039 "#warning Leave all white!!!!! space* alone!\n", 9040 format("#warning Leave all white!!!!! space* alone!\n")); 9041 EXPECT_EQ("#error 1", format(" # error 1")); 9042 EXPECT_EQ("#warning 1", format(" # warning 1")); 9043 } 9044 9045 TEST_F(FormatTest, FormatHashIfExpressions) { 9046 verifyFormat("#if AAAA && BBBB"); 9047 verifyFormat("#if (AAAA && BBBB)"); 9048 verifyFormat("#elif (AAAA && BBBB)"); 9049 // FIXME: Come up with a better indentation for #elif. 9050 verifyFormat( 9051 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 9052 " defined(BBBBBBBB)\n" 9053 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 9054 " defined(BBBBBBBB)\n" 9055 "#endif", 9056 getLLVMStyleWithColumns(65)); 9057 } 9058 9059 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 9060 FormatStyle AllowsMergedIf = getGoogleStyle(); 9061 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 9062 FormatStyle::SIS_WithoutElse; 9063 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 9064 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 9065 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 9066 EXPECT_EQ("if (true) return 42;", 9067 format("if (true)\nreturn 42;", AllowsMergedIf)); 9068 FormatStyle ShortMergedIf = AllowsMergedIf; 9069 ShortMergedIf.ColumnLimit = 25; 9070 verifyFormat("#define A \\\n" 9071 " if (true) return 42;", 9072 ShortMergedIf); 9073 verifyFormat("#define A \\\n" 9074 " f(); \\\n" 9075 " if (true)\n" 9076 "#define B", 9077 ShortMergedIf); 9078 verifyFormat("#define A \\\n" 9079 " f(); \\\n" 9080 " if (true)\n" 9081 "g();", 9082 ShortMergedIf); 9083 verifyFormat("{\n" 9084 "#ifdef A\n" 9085 " // Comment\n" 9086 " if (true) continue;\n" 9087 "#endif\n" 9088 " // Comment\n" 9089 " if (true) continue;\n" 9090 "}", 9091 ShortMergedIf); 9092 ShortMergedIf.ColumnLimit = 33; 9093 verifyFormat("#define A \\\n" 9094 " if constexpr (true) return 42;", 9095 ShortMergedIf); 9096 verifyFormat("#define A \\\n" 9097 " if CONSTEXPR (true) return 42;", 9098 ShortMergedIf); 9099 ShortMergedIf.ColumnLimit = 29; 9100 verifyFormat("#define A \\\n" 9101 " if (aaaaaaaaaa) return 1; \\\n" 9102 " return 2;", 9103 ShortMergedIf); 9104 ShortMergedIf.ColumnLimit = 28; 9105 verifyFormat("#define A \\\n" 9106 " if (aaaaaaaaaa) \\\n" 9107 " return 1; \\\n" 9108 " return 2;", 9109 ShortMergedIf); 9110 verifyFormat("#define A \\\n" 9111 " if constexpr (aaaaaaa) \\\n" 9112 " return 1; \\\n" 9113 " return 2;", 9114 ShortMergedIf); 9115 verifyFormat("#define A \\\n" 9116 " if CONSTEXPR (aaaaaaa) \\\n" 9117 " return 1; \\\n" 9118 " return 2;", 9119 ShortMergedIf); 9120 } 9121 9122 TEST_F(FormatTest, FormatStarDependingOnContext) { 9123 verifyFormat("void f(int *a);"); 9124 verifyFormat("void f() { f(fint * b); }"); 9125 verifyFormat("class A {\n void f(int *a);\n};"); 9126 verifyFormat("class A {\n int *a;\n};"); 9127 verifyFormat("namespace a {\n" 9128 "namespace b {\n" 9129 "class A {\n" 9130 " void f() {}\n" 9131 " int *a;\n" 9132 "};\n" 9133 "} // namespace b\n" 9134 "} // namespace a"); 9135 } 9136 9137 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 9138 verifyFormat("while"); 9139 verifyFormat("operator"); 9140 } 9141 9142 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 9143 // This code would be painfully slow to format if we didn't skip it. 9144 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 9145 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9146 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9147 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9148 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9149 "A(1, 1)\n" 9150 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 9151 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9152 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9153 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9154 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9155 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9156 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9157 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9158 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9159 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 9160 // Deeply nested part is untouched, rest is formatted. 9161 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 9162 format(std::string("int i;\n") + Code + "int j;\n", 9163 getLLVMStyle(), SC_ExpectIncomplete)); 9164 } 9165 9166 //===----------------------------------------------------------------------===// 9167 // Objective-C tests. 9168 //===----------------------------------------------------------------------===// 9169 9170 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 9171 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 9172 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 9173 format("-(NSUInteger)indexOfObject:(id)anObject;")); 9174 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 9175 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 9176 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 9177 format("-(NSInteger)Method3:(id)anObject;")); 9178 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 9179 format("-(NSInteger)Method4:(id)anObject;")); 9180 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 9181 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 9182 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 9183 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 9184 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9185 "forAllCells:(BOOL)flag;", 9186 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9187 "forAllCells:(BOOL)flag;")); 9188 9189 // Very long objectiveC method declaration. 9190 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 9191 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 9192 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 9193 " inRange:(NSRange)range\n" 9194 " outRange:(NSRange)out_range\n" 9195 " outRange1:(NSRange)out_range1\n" 9196 " outRange2:(NSRange)out_range2\n" 9197 " outRange3:(NSRange)out_range3\n" 9198 " outRange4:(NSRange)out_range4\n" 9199 " outRange5:(NSRange)out_range5\n" 9200 " outRange6:(NSRange)out_range6\n" 9201 " outRange7:(NSRange)out_range7\n" 9202 " outRange8:(NSRange)out_range8\n" 9203 " outRange9:(NSRange)out_range9;"); 9204 9205 // When the function name has to be wrapped. 9206 FormatStyle Style = getLLVMStyle(); 9207 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 9208 // and always indents instead. 9209 Style.IndentWrappedFunctionNames = false; 9210 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9211 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 9212 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 9213 "}", 9214 Style); 9215 Style.IndentWrappedFunctionNames = true; 9216 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9217 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 9218 " anotherName:(NSString)dddddddddddddd {\n" 9219 "}", 9220 Style); 9221 9222 verifyFormat("- (int)sum:(vector<int>)numbers;"); 9223 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 9224 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 9225 // protocol lists (but not for template classes): 9226 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 9227 9228 verifyFormat("- (int (*)())foo:(int (*)())f;"); 9229 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 9230 9231 // If there's no return type (very rare in practice!), LLVM and Google style 9232 // agree. 9233 verifyFormat("- foo;"); 9234 verifyFormat("- foo:(int)f;"); 9235 verifyGoogleFormat("- foo:(int)foo;"); 9236 } 9237 9238 TEST_F(FormatTest, BreaksStringLiterals) { 9239 EXPECT_EQ("\"some text \"\n" 9240 "\"other\";", 9241 format("\"some text other\";", getLLVMStyleWithColumns(12))); 9242 EXPECT_EQ("\"some text \"\n" 9243 "\"other\";", 9244 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 9245 EXPECT_EQ( 9246 "#define A \\\n" 9247 " \"some \" \\\n" 9248 " \"text \" \\\n" 9249 " \"other\";", 9250 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 9251 EXPECT_EQ( 9252 "#define A \\\n" 9253 " \"so \" \\\n" 9254 " \"text \" \\\n" 9255 " \"other\";", 9256 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 9257 9258 EXPECT_EQ("\"some text\"", 9259 format("\"some text\"", getLLVMStyleWithColumns(1))); 9260 EXPECT_EQ("\"some text\"", 9261 format("\"some text\"", getLLVMStyleWithColumns(11))); 9262 EXPECT_EQ("\"some \"\n" 9263 "\"text\"", 9264 format("\"some text\"", getLLVMStyleWithColumns(10))); 9265 EXPECT_EQ("\"some \"\n" 9266 "\"text\"", 9267 format("\"some text\"", getLLVMStyleWithColumns(7))); 9268 EXPECT_EQ("\"some\"\n" 9269 "\" tex\"\n" 9270 "\"t\"", 9271 format("\"some text\"", getLLVMStyleWithColumns(6))); 9272 EXPECT_EQ("\"some\"\n" 9273 "\" tex\"\n" 9274 "\" and\"", 9275 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 9276 EXPECT_EQ("\"some\"\n" 9277 "\"/tex\"\n" 9278 "\"/and\"", 9279 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 9280 9281 EXPECT_EQ("variable =\n" 9282 " \"long string \"\n" 9283 " \"literal\";", 9284 format("variable = \"long string literal\";", 9285 getLLVMStyleWithColumns(20))); 9286 9287 EXPECT_EQ("variable = f(\n" 9288 " \"long string \"\n" 9289 " \"literal\",\n" 9290 " short,\n" 9291 " loooooooooooooooooooong);", 9292 format("variable = f(\"long string literal\", short, " 9293 "loooooooooooooooooooong);", 9294 getLLVMStyleWithColumns(20))); 9295 9296 EXPECT_EQ( 9297 "f(g(\"long string \"\n" 9298 " \"literal\"),\n" 9299 " b);", 9300 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 9301 EXPECT_EQ("f(g(\"long string \"\n" 9302 " \"literal\",\n" 9303 " a),\n" 9304 " b);", 9305 format("f(g(\"long string literal\", a), b);", 9306 getLLVMStyleWithColumns(20))); 9307 EXPECT_EQ( 9308 "f(\"one two\".split(\n" 9309 " variable));", 9310 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 9311 EXPECT_EQ("f(\"one two three four five six \"\n" 9312 " \"seven\".split(\n" 9313 " really_looooong_variable));", 9314 format("f(\"one two three four five six seven\"." 9315 "split(really_looooong_variable));", 9316 getLLVMStyleWithColumns(33))); 9317 9318 EXPECT_EQ("f(\"some \"\n" 9319 " \"text\",\n" 9320 " other);", 9321 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 9322 9323 // Only break as a last resort. 9324 verifyFormat( 9325 "aaaaaaaaaaaaaaaaaaaa(\n" 9326 " aaaaaaaaaaaaaaaaaaaa,\n" 9327 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 9328 9329 EXPECT_EQ("\"splitmea\"\n" 9330 "\"trandomp\"\n" 9331 "\"oint\"", 9332 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 9333 9334 EXPECT_EQ("\"split/\"\n" 9335 "\"pathat/\"\n" 9336 "\"slashes\"", 9337 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9338 9339 EXPECT_EQ("\"split/\"\n" 9340 "\"pathat/\"\n" 9341 "\"slashes\"", 9342 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9343 EXPECT_EQ("\"split at \"\n" 9344 "\"spaces/at/\"\n" 9345 "\"slashes.at.any$\"\n" 9346 "\"non-alphanumeric%\"\n" 9347 "\"1111111111characte\"\n" 9348 "\"rs\"", 9349 format("\"split at " 9350 "spaces/at/" 9351 "slashes.at." 9352 "any$non-" 9353 "alphanumeric%" 9354 "1111111111characte" 9355 "rs\"", 9356 getLLVMStyleWithColumns(20))); 9357 9358 // Verify that splitting the strings understands 9359 // Style::AlwaysBreakBeforeMultilineStrings. 9360 EXPECT_EQ("aaaaaaaaaaaa(\n" 9361 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 9362 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 9363 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 9364 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9365 "aaaaaaaaaaaaaaaaaaaaaa\");", 9366 getGoogleStyle())); 9367 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9368 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 9369 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 9370 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9371 "aaaaaaaaaaaaaaaaaaaaaa\";", 9372 getGoogleStyle())); 9373 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9374 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9375 format("llvm::outs() << " 9376 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 9377 "aaaaaaaaaaaaaaaaaaa\";")); 9378 EXPECT_EQ("ffff(\n" 9379 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9380 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9381 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 9382 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9383 getGoogleStyle())); 9384 9385 FormatStyle Style = getLLVMStyleWithColumns(12); 9386 Style.BreakStringLiterals = false; 9387 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 9388 9389 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 9390 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9391 EXPECT_EQ("#define A \\\n" 9392 " \"some \" \\\n" 9393 " \"text \" \\\n" 9394 " \"other\";", 9395 format("#define A \"some text other\";", AlignLeft)); 9396 } 9397 9398 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 9399 EXPECT_EQ("C a = \"some more \"\n" 9400 " \"text\";", 9401 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 9402 } 9403 9404 TEST_F(FormatTest, FullyRemoveEmptyLines) { 9405 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 9406 NoEmptyLines.MaxEmptyLinesToKeep = 0; 9407 EXPECT_EQ("int i = a(b());", 9408 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 9409 } 9410 9411 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 9412 EXPECT_EQ( 9413 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9414 "(\n" 9415 " \"x\t\");", 9416 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9417 "aaaaaaa(" 9418 "\"x\t\");")); 9419 } 9420 9421 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 9422 EXPECT_EQ( 9423 "u8\"utf8 string \"\n" 9424 "u8\"literal\";", 9425 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 9426 EXPECT_EQ( 9427 "u\"utf16 string \"\n" 9428 "u\"literal\";", 9429 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 9430 EXPECT_EQ( 9431 "U\"utf32 string \"\n" 9432 "U\"literal\";", 9433 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 9434 EXPECT_EQ("L\"wide string \"\n" 9435 "L\"literal\";", 9436 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 9437 EXPECT_EQ("@\"NSString \"\n" 9438 "@\"literal\";", 9439 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 9440 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 9441 9442 // This input makes clang-format try to split the incomplete unicode escape 9443 // sequence, which used to lead to a crasher. 9444 verifyNoCrash( 9445 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 9446 getLLVMStyleWithColumns(60)); 9447 } 9448 9449 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 9450 FormatStyle Style = getGoogleStyleWithColumns(15); 9451 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 9452 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 9453 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 9454 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 9455 EXPECT_EQ("u8R\"x(raw literal)x\";", 9456 format("u8R\"x(raw literal)x\";", Style)); 9457 } 9458 9459 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 9460 FormatStyle Style = getLLVMStyleWithColumns(20); 9461 EXPECT_EQ( 9462 "_T(\"aaaaaaaaaaaaaa\")\n" 9463 "_T(\"aaaaaaaaaaaaaa\")\n" 9464 "_T(\"aaaaaaaaaaaa\")", 9465 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 9466 EXPECT_EQ("f(x,\n" 9467 " _T(\"aaaaaaaaaaaa\")\n" 9468 " _T(\"aaa\"),\n" 9469 " z);", 9470 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 9471 9472 // FIXME: Handle embedded spaces in one iteration. 9473 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 9474 // "_T(\"aaaaaaaaaaaaa\")\n" 9475 // "_T(\"aaaaaaaaaaaaa\")\n" 9476 // "_T(\"a\")", 9477 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9478 // getLLVMStyleWithColumns(20))); 9479 EXPECT_EQ( 9480 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9481 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 9482 EXPECT_EQ("f(\n" 9483 "#if !TEST\n" 9484 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9485 "#endif\n" 9486 ");", 9487 format("f(\n" 9488 "#if !TEST\n" 9489 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9490 "#endif\n" 9491 ");")); 9492 EXPECT_EQ("f(\n" 9493 "\n" 9494 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 9495 format("f(\n" 9496 "\n" 9497 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 9498 } 9499 9500 TEST_F(FormatTest, BreaksStringLiteralOperands) { 9501 // In a function call with two operands, the second can be broken with no line 9502 // break before it. 9503 EXPECT_EQ( 9504 "func(a, \"long long \"\n" 9505 " \"long long\");", 9506 format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24))); 9507 // In a function call with three operands, the second must be broken with a 9508 // line break before it. 9509 EXPECT_EQ("func(a,\n" 9510 " \"long long long \"\n" 9511 " \"long\",\n" 9512 " c);", 9513 format("func(a, \"long long long long\", c);", 9514 getLLVMStyleWithColumns(24))); 9515 // In a function call with three operands, the third must be broken with a 9516 // line break before it. 9517 EXPECT_EQ("func(a, b,\n" 9518 " \"long long long \"\n" 9519 " \"long\");", 9520 format("func(a, b, \"long long long long\");", 9521 getLLVMStyleWithColumns(24))); 9522 // In a function call with three operands, both the second and the third must 9523 // be broken with a line break before them. 9524 EXPECT_EQ("func(a,\n" 9525 " \"long long long \"\n" 9526 " \"long\",\n" 9527 " \"long long long \"\n" 9528 " \"long\");", 9529 format("func(a, \"long long long long\", \"long long long long\");", 9530 getLLVMStyleWithColumns(24))); 9531 // In a chain of << with two operands, the second can be broken with no line 9532 // break before it. 9533 EXPECT_EQ("a << \"line line \"\n" 9534 " \"line\";", 9535 format("a << \"line line line\";", getLLVMStyleWithColumns(20))); 9536 // In a chain of << with three operands, the second can be broken with no line 9537 // break before it. 9538 EXPECT_EQ( 9539 "abcde << \"line \"\n" 9540 " \"line line\"\n" 9541 " << c;", 9542 format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20))); 9543 // In a chain of << with three operands, the third must be broken with a line 9544 // break before it. 9545 EXPECT_EQ( 9546 "a << b\n" 9547 " << \"line line \"\n" 9548 " \"line\";", 9549 format("a << b << \"line line line\";", getLLVMStyleWithColumns(20))); 9550 // In a chain of << with three operands, the second can be broken with no line 9551 // break before it and the third must be broken with a line break before it. 9552 EXPECT_EQ("abcd << \"line line \"\n" 9553 " \"line\"\n" 9554 " << \"line line \"\n" 9555 " \"line\";", 9556 format("abcd << \"line line line\" << \"line line line\";", 9557 getLLVMStyleWithColumns(20))); 9558 // In a chain of binary operators with two operands, the second can be broken 9559 // with no line break before it. 9560 EXPECT_EQ( 9561 "abcd + \"line line \"\n" 9562 " \"line line\";", 9563 format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20))); 9564 // In a chain of binary operators with three operands, the second must be 9565 // broken with a line break before it. 9566 EXPECT_EQ("abcd +\n" 9567 " \"line line \"\n" 9568 " \"line line\" +\n" 9569 " e;", 9570 format("abcd + \"line line line line\" + e;", 9571 getLLVMStyleWithColumns(20))); 9572 // In a function call with two operands, with AlignAfterOpenBracket enabled, 9573 // the first must be broken with a line break before it. 9574 FormatStyle Style = getLLVMStyleWithColumns(25); 9575 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 9576 EXPECT_EQ("someFunction(\n" 9577 " \"long long long \"\n" 9578 " \"long\",\n" 9579 " a);", 9580 format("someFunction(\"long long long long\", a);", Style)); 9581 } 9582 9583 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 9584 EXPECT_EQ( 9585 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9586 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9587 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9588 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9589 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9590 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 9591 } 9592 9593 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 9594 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 9595 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 9596 EXPECT_EQ("fffffffffff(g(R\"x(\n" 9597 "multiline raw string literal xxxxxxxxxxxxxx\n" 9598 ")x\",\n" 9599 " a),\n" 9600 " b);", 9601 format("fffffffffff(g(R\"x(\n" 9602 "multiline raw string literal xxxxxxxxxxxxxx\n" 9603 ")x\", a), b);", 9604 getGoogleStyleWithColumns(20))); 9605 EXPECT_EQ("fffffffffff(\n" 9606 " g(R\"x(qqq\n" 9607 "multiline raw string literal xxxxxxxxxxxxxx\n" 9608 ")x\",\n" 9609 " a),\n" 9610 " b);", 9611 format("fffffffffff(g(R\"x(qqq\n" 9612 "multiline raw string literal xxxxxxxxxxxxxx\n" 9613 ")x\", a), b);", 9614 getGoogleStyleWithColumns(20))); 9615 9616 EXPECT_EQ("fffffffffff(R\"x(\n" 9617 "multiline raw string literal xxxxxxxxxxxxxx\n" 9618 ")x\");", 9619 format("fffffffffff(R\"x(\n" 9620 "multiline raw string literal xxxxxxxxxxxxxx\n" 9621 ")x\");", 9622 getGoogleStyleWithColumns(20))); 9623 EXPECT_EQ("fffffffffff(R\"x(\n" 9624 "multiline raw string literal xxxxxxxxxxxxxx\n" 9625 ")x\" + bbbbbb);", 9626 format("fffffffffff(R\"x(\n" 9627 "multiline raw string literal xxxxxxxxxxxxxx\n" 9628 ")x\" + bbbbbb);", 9629 getGoogleStyleWithColumns(20))); 9630 EXPECT_EQ("fffffffffff(\n" 9631 " R\"x(\n" 9632 "multiline raw string literal xxxxxxxxxxxxxx\n" 9633 ")x\" +\n" 9634 " bbbbbb);", 9635 format("fffffffffff(\n" 9636 " R\"x(\n" 9637 "multiline raw string literal xxxxxxxxxxxxxx\n" 9638 ")x\" + bbbbbb);", 9639 getGoogleStyleWithColumns(20))); 9640 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 9641 format("fffffffffff(\n" 9642 " R\"(single line raw string)\" + bbbbbb);")); 9643 } 9644 9645 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 9646 verifyFormat("string a = \"unterminated;"); 9647 EXPECT_EQ("function(\"unterminated,\n" 9648 " OtherParameter);", 9649 format("function( \"unterminated,\n" 9650 " OtherParameter);")); 9651 } 9652 9653 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9654 FormatStyle Style = getLLVMStyle(); 9655 Style.Standard = FormatStyle::LS_Cpp03; 9656 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9657 format("#define x(_a) printf(\"foo\"_a);", Style)); 9658 } 9659 9660 TEST_F(FormatTest, CppLexVersion) { 9661 FormatStyle Style = getLLVMStyle(); 9662 // Formatting of x * y differs if x is a type. 9663 verifyFormat("void foo() { MACRO(a * b); }", Style); 9664 verifyFormat("void foo() { MACRO(int *b); }", Style); 9665 9666 // LLVM style uses latest lexer. 9667 verifyFormat("void foo() { MACRO(char8_t *b); }", Style); 9668 Style.Standard = FormatStyle::LS_Cpp17; 9669 // But in c++17, char8_t isn't a keyword. 9670 verifyFormat("void foo() { MACRO(char8_t * b); }", Style); 9671 } 9672 9673 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9674 9675 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9676 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9677 " \"ddeeefff\");", 9678 format("someFunction(\"aaabbbcccdddeeefff\");", 9679 getLLVMStyleWithColumns(25))); 9680 EXPECT_EQ("someFunction1234567890(\n" 9681 " \"aaabbbcccdddeeefff\");", 9682 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9683 getLLVMStyleWithColumns(26))); 9684 EXPECT_EQ("someFunction1234567890(\n" 9685 " \"aaabbbcccdddeeeff\"\n" 9686 " \"f\");", 9687 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9688 getLLVMStyleWithColumns(25))); 9689 EXPECT_EQ("someFunction1234567890(\n" 9690 " \"aaabbbcccdddeeeff\"\n" 9691 " \"f\");", 9692 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9693 getLLVMStyleWithColumns(24))); 9694 EXPECT_EQ("someFunction(\n" 9695 " \"aaabbbcc ddde \"\n" 9696 " \"efff\");", 9697 format("someFunction(\"aaabbbcc ddde efff\");", 9698 getLLVMStyleWithColumns(25))); 9699 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9700 " \"ddeeefff\");", 9701 format("someFunction(\"aaabbbccc ddeeefff\");", 9702 getLLVMStyleWithColumns(25))); 9703 EXPECT_EQ("someFunction1234567890(\n" 9704 " \"aaabb \"\n" 9705 " \"cccdddeeefff\");", 9706 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9707 getLLVMStyleWithColumns(25))); 9708 EXPECT_EQ("#define A \\\n" 9709 " string s = \\\n" 9710 " \"123456789\" \\\n" 9711 " \"0\"; \\\n" 9712 " int i;", 9713 format("#define A string s = \"1234567890\"; int i;", 9714 getLLVMStyleWithColumns(20))); 9715 EXPECT_EQ("someFunction(\n" 9716 " \"aaabbbcc \"\n" 9717 " \"dddeeefff\");", 9718 format("someFunction(\"aaabbbcc dddeeefff\");", 9719 getLLVMStyleWithColumns(25))); 9720 } 9721 9722 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9723 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9724 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9725 EXPECT_EQ("\"test\"\n" 9726 "\"\\n\"", 9727 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9728 EXPECT_EQ("\"tes\\\\\"\n" 9729 "\"n\"", 9730 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9731 EXPECT_EQ("\"\\\\\\\\\"\n" 9732 "\"\\n\"", 9733 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9734 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9735 EXPECT_EQ("\"\\uff01\"\n" 9736 "\"test\"", 9737 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9738 EXPECT_EQ("\"\\Uff01ff02\"", 9739 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9740 EXPECT_EQ("\"\\x000000000001\"\n" 9741 "\"next\"", 9742 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9743 EXPECT_EQ("\"\\x000000000001next\"", 9744 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9745 EXPECT_EQ("\"\\x000000000001\"", 9746 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9747 EXPECT_EQ("\"test\"\n" 9748 "\"\\000000\"\n" 9749 "\"000001\"", 9750 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9751 EXPECT_EQ("\"test\\000\"\n" 9752 "\"00000000\"\n" 9753 "\"1\"", 9754 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9755 } 9756 9757 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9758 verifyFormat("void f() {\n" 9759 " return g() {}\n" 9760 " void h() {}"); 9761 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9762 "g();\n" 9763 "}"); 9764 } 9765 9766 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9767 verifyFormat( 9768 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9769 } 9770 9771 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9772 verifyFormat("class X {\n" 9773 " void f() {\n" 9774 " }\n" 9775 "};", 9776 getLLVMStyleWithColumns(12)); 9777 } 9778 9779 TEST_F(FormatTest, ConfigurableIndentWidth) { 9780 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9781 EightIndent.IndentWidth = 8; 9782 EightIndent.ContinuationIndentWidth = 8; 9783 verifyFormat("void f() {\n" 9784 " someFunction();\n" 9785 " if (true) {\n" 9786 " f();\n" 9787 " }\n" 9788 "}", 9789 EightIndent); 9790 verifyFormat("class X {\n" 9791 " void f() {\n" 9792 " }\n" 9793 "};", 9794 EightIndent); 9795 verifyFormat("int x[] = {\n" 9796 " call(),\n" 9797 " call()};", 9798 EightIndent); 9799 } 9800 9801 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9802 verifyFormat("double\n" 9803 "f();", 9804 getLLVMStyleWithColumns(8)); 9805 } 9806 9807 TEST_F(FormatTest, ConfigurableUseOfTab) { 9808 FormatStyle Tab = getLLVMStyleWithColumns(42); 9809 Tab.IndentWidth = 8; 9810 Tab.UseTab = FormatStyle::UT_Always; 9811 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9812 9813 EXPECT_EQ("if (aaaaaaaa && // q\n" 9814 " bb)\t\t// w\n" 9815 "\t;", 9816 format("if (aaaaaaaa &&// q\n" 9817 "bb)// w\n" 9818 ";", 9819 Tab)); 9820 EXPECT_EQ("if (aaa && bbb) // w\n" 9821 "\t;", 9822 format("if(aaa&&bbb)// w\n" 9823 ";", 9824 Tab)); 9825 9826 verifyFormat("class X {\n" 9827 "\tvoid f() {\n" 9828 "\t\tsomeFunction(parameter1,\n" 9829 "\t\t\t parameter2);\n" 9830 "\t}\n" 9831 "};", 9832 Tab); 9833 verifyFormat("#define A \\\n" 9834 "\tvoid f() { \\\n" 9835 "\t\tsomeFunction( \\\n" 9836 "\t\t parameter1, \\\n" 9837 "\t\t parameter2); \\\n" 9838 "\t}", 9839 Tab); 9840 verifyFormat("int a;\t // x\n" 9841 "int bbbbbbbb; // x\n", 9842 Tab); 9843 9844 Tab.TabWidth = 4; 9845 Tab.IndentWidth = 8; 9846 verifyFormat("class TabWidth4Indent8 {\n" 9847 "\t\tvoid f() {\n" 9848 "\t\t\t\tsomeFunction(parameter1,\n" 9849 "\t\t\t\t\t\t\t parameter2);\n" 9850 "\t\t}\n" 9851 "};", 9852 Tab); 9853 9854 Tab.TabWidth = 4; 9855 Tab.IndentWidth = 4; 9856 verifyFormat("class TabWidth4Indent4 {\n" 9857 "\tvoid f() {\n" 9858 "\t\tsomeFunction(parameter1,\n" 9859 "\t\t\t\t\t parameter2);\n" 9860 "\t}\n" 9861 "};", 9862 Tab); 9863 9864 Tab.TabWidth = 8; 9865 Tab.IndentWidth = 4; 9866 verifyFormat("class TabWidth8Indent4 {\n" 9867 " void f() {\n" 9868 "\tsomeFunction(parameter1,\n" 9869 "\t\t parameter2);\n" 9870 " }\n" 9871 "};", 9872 Tab); 9873 9874 Tab.TabWidth = 8; 9875 Tab.IndentWidth = 8; 9876 EXPECT_EQ("/*\n" 9877 "\t a\t\tcomment\n" 9878 "\t in multiple lines\n" 9879 " */", 9880 format(" /*\t \t \n" 9881 " \t \t a\t\tcomment\t \t\n" 9882 " \t \t in multiple lines\t\n" 9883 " \t */", 9884 Tab)); 9885 9886 Tab.UseTab = FormatStyle::UT_ForIndentation; 9887 verifyFormat("{\n" 9888 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9889 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9890 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9891 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9892 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9893 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9894 "};", 9895 Tab); 9896 verifyFormat("enum AA {\n" 9897 "\ta1, // Force multiple lines\n" 9898 "\ta2,\n" 9899 "\ta3\n" 9900 "};", 9901 Tab); 9902 EXPECT_EQ("if (aaaaaaaa && // q\n" 9903 " bb) // w\n" 9904 "\t;", 9905 format("if (aaaaaaaa &&// q\n" 9906 "bb)// w\n" 9907 ";", 9908 Tab)); 9909 verifyFormat("class X {\n" 9910 "\tvoid f() {\n" 9911 "\t\tsomeFunction(parameter1,\n" 9912 "\t\t parameter2);\n" 9913 "\t}\n" 9914 "};", 9915 Tab); 9916 verifyFormat("{\n" 9917 "\tQ(\n" 9918 "\t {\n" 9919 "\t\t int a;\n" 9920 "\t\t someFunction(aaaaaaaa,\n" 9921 "\t\t bbbbbbb);\n" 9922 "\t },\n" 9923 "\t p);\n" 9924 "}", 9925 Tab); 9926 EXPECT_EQ("{\n" 9927 "\t/* aaaa\n" 9928 "\t bbbb */\n" 9929 "}", 9930 format("{\n" 9931 "/* aaaa\n" 9932 " bbbb */\n" 9933 "}", 9934 Tab)); 9935 EXPECT_EQ("{\n" 9936 "\t/*\n" 9937 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9938 "\t bbbbbbbbbbbbb\n" 9939 "\t*/\n" 9940 "}", 9941 format("{\n" 9942 "/*\n" 9943 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9944 "*/\n" 9945 "}", 9946 Tab)); 9947 EXPECT_EQ("{\n" 9948 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9949 "\t// bbbbbbbbbbbbb\n" 9950 "}", 9951 format("{\n" 9952 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9953 "}", 9954 Tab)); 9955 EXPECT_EQ("{\n" 9956 "\t/*\n" 9957 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 9958 "\t bbbbbbbbbbbbb\n" 9959 "\t*/\n" 9960 "}", 9961 format("{\n" 9962 "\t/*\n" 9963 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 9964 "\t*/\n" 9965 "}", 9966 Tab)); 9967 EXPECT_EQ("{\n" 9968 "\t/*\n" 9969 "\n" 9970 "\t*/\n" 9971 "}", 9972 format("{\n" 9973 "\t/*\n" 9974 "\n" 9975 "\t*/\n" 9976 "}", 9977 Tab)); 9978 EXPECT_EQ("{\n" 9979 "\t/*\n" 9980 " asdf\n" 9981 "\t*/\n" 9982 "}", 9983 format("{\n" 9984 "\t/*\n" 9985 " asdf\n" 9986 "\t*/\n" 9987 "}", 9988 Tab)); 9989 9990 Tab.UseTab = FormatStyle::UT_Never; 9991 EXPECT_EQ("/*\n" 9992 " a\t\tcomment\n" 9993 " in multiple lines\n" 9994 " */", 9995 format(" /*\t \t \n" 9996 " \t \t a\t\tcomment\t \t\n" 9997 " \t \t in multiple lines\t\n" 9998 " \t */", 9999 Tab)); 10000 EXPECT_EQ("/* some\n" 10001 " comment */", 10002 format(" \t \t /* some\n" 10003 " \t \t comment */", 10004 Tab)); 10005 EXPECT_EQ("int a; /* some\n" 10006 " comment */", 10007 format(" \t \t int a; /* some\n" 10008 " \t \t comment */", 10009 Tab)); 10010 10011 EXPECT_EQ("int a; /* some\n" 10012 "comment */", 10013 format(" \t \t int\ta; /* some\n" 10014 " \t \t comment */", 10015 Tab)); 10016 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10017 " comment */", 10018 format(" \t \t f(\"\t\t\"); /* some\n" 10019 " \t \t comment */", 10020 Tab)); 10021 EXPECT_EQ("{\n" 10022 " /*\n" 10023 " * Comment\n" 10024 " */\n" 10025 " int i;\n" 10026 "}", 10027 format("{\n" 10028 "\t/*\n" 10029 "\t * Comment\n" 10030 "\t */\n" 10031 "\t int i;\n" 10032 "}")); 10033 10034 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10035 Tab.TabWidth = 8; 10036 Tab.IndentWidth = 8; 10037 EXPECT_EQ("if (aaaaaaaa && // q\n" 10038 " bb) // w\n" 10039 "\t;", 10040 format("if (aaaaaaaa &&// q\n" 10041 "bb)// w\n" 10042 ";", 10043 Tab)); 10044 EXPECT_EQ("if (aaa && bbb) // w\n" 10045 "\t;", 10046 format("if(aaa&&bbb)// w\n" 10047 ";", 10048 Tab)); 10049 verifyFormat("class X {\n" 10050 "\tvoid f() {\n" 10051 "\t\tsomeFunction(parameter1,\n" 10052 "\t\t\t parameter2);\n" 10053 "\t}\n" 10054 "};", 10055 Tab); 10056 verifyFormat("#define A \\\n" 10057 "\tvoid f() { \\\n" 10058 "\t\tsomeFunction( \\\n" 10059 "\t\t parameter1, \\\n" 10060 "\t\t parameter2); \\\n" 10061 "\t}", 10062 Tab); 10063 Tab.TabWidth = 4; 10064 Tab.IndentWidth = 8; 10065 verifyFormat("class TabWidth4Indent8 {\n" 10066 "\t\tvoid f() {\n" 10067 "\t\t\t\tsomeFunction(parameter1,\n" 10068 "\t\t\t\t\t\t\t parameter2);\n" 10069 "\t\t}\n" 10070 "};", 10071 Tab); 10072 Tab.TabWidth = 4; 10073 Tab.IndentWidth = 4; 10074 verifyFormat("class TabWidth4Indent4 {\n" 10075 "\tvoid f() {\n" 10076 "\t\tsomeFunction(parameter1,\n" 10077 "\t\t\t\t\t parameter2);\n" 10078 "\t}\n" 10079 "};", 10080 Tab); 10081 Tab.TabWidth = 8; 10082 Tab.IndentWidth = 4; 10083 verifyFormat("class TabWidth8Indent4 {\n" 10084 " void f() {\n" 10085 "\tsomeFunction(parameter1,\n" 10086 "\t\t parameter2);\n" 10087 " }\n" 10088 "};", 10089 Tab); 10090 Tab.TabWidth = 8; 10091 Tab.IndentWidth = 8; 10092 EXPECT_EQ("/*\n" 10093 "\t a\t\tcomment\n" 10094 "\t in multiple lines\n" 10095 " */", 10096 format(" /*\t \t \n" 10097 " \t \t a\t\tcomment\t \t\n" 10098 " \t \t in multiple lines\t\n" 10099 " \t */", 10100 Tab)); 10101 verifyFormat("{\n" 10102 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10103 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10104 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10105 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10106 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10107 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10108 "};", 10109 Tab); 10110 verifyFormat("enum AA {\n" 10111 "\ta1, // Force multiple lines\n" 10112 "\ta2,\n" 10113 "\ta3\n" 10114 "};", 10115 Tab); 10116 EXPECT_EQ("if (aaaaaaaa && // q\n" 10117 " bb) // w\n" 10118 "\t;", 10119 format("if (aaaaaaaa &&// q\n" 10120 "bb)// w\n" 10121 ";", 10122 Tab)); 10123 verifyFormat("class X {\n" 10124 "\tvoid f() {\n" 10125 "\t\tsomeFunction(parameter1,\n" 10126 "\t\t\t parameter2);\n" 10127 "\t}\n" 10128 "};", 10129 Tab); 10130 verifyFormat("{\n" 10131 "\tQ(\n" 10132 "\t {\n" 10133 "\t\t int a;\n" 10134 "\t\t someFunction(aaaaaaaa,\n" 10135 "\t\t\t\t bbbbbbb);\n" 10136 "\t },\n" 10137 "\t p);\n" 10138 "}", 10139 Tab); 10140 EXPECT_EQ("{\n" 10141 "\t/* aaaa\n" 10142 "\t bbbb */\n" 10143 "}", 10144 format("{\n" 10145 "/* aaaa\n" 10146 " bbbb */\n" 10147 "}", 10148 Tab)); 10149 EXPECT_EQ("{\n" 10150 "\t/*\n" 10151 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10152 "\t bbbbbbbbbbbbb\n" 10153 "\t*/\n" 10154 "}", 10155 format("{\n" 10156 "/*\n" 10157 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10158 "*/\n" 10159 "}", 10160 Tab)); 10161 EXPECT_EQ("{\n" 10162 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10163 "\t// bbbbbbbbbbbbb\n" 10164 "}", 10165 format("{\n" 10166 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10167 "}", 10168 Tab)); 10169 EXPECT_EQ("{\n" 10170 "\t/*\n" 10171 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10172 "\t bbbbbbbbbbbbb\n" 10173 "\t*/\n" 10174 "}", 10175 format("{\n" 10176 "\t/*\n" 10177 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10178 "\t*/\n" 10179 "}", 10180 Tab)); 10181 EXPECT_EQ("{\n" 10182 "\t/*\n" 10183 "\n" 10184 "\t*/\n" 10185 "}", 10186 format("{\n" 10187 "\t/*\n" 10188 "\n" 10189 "\t*/\n" 10190 "}", 10191 Tab)); 10192 EXPECT_EQ("{\n" 10193 "\t/*\n" 10194 " asdf\n" 10195 "\t*/\n" 10196 "}", 10197 format("{\n" 10198 "\t/*\n" 10199 " asdf\n" 10200 "\t*/\n" 10201 "}", 10202 Tab)); 10203 EXPECT_EQ("/*\n" 10204 "\t a\t\tcomment\n" 10205 "\t in multiple lines\n" 10206 " */", 10207 format(" /*\t \t \n" 10208 " \t \t a\t\tcomment\t \t\n" 10209 " \t \t in multiple lines\t\n" 10210 " \t */", 10211 Tab)); 10212 EXPECT_EQ("/* some\n" 10213 " comment */", 10214 format(" \t \t /* some\n" 10215 " \t \t comment */", 10216 Tab)); 10217 EXPECT_EQ("int a; /* some\n" 10218 " comment */", 10219 format(" \t \t int a; /* some\n" 10220 " \t \t comment */", 10221 Tab)); 10222 EXPECT_EQ("int a; /* some\n" 10223 "comment */", 10224 format(" \t \t int\ta; /* some\n" 10225 " \t \t comment */", 10226 Tab)); 10227 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10228 " comment */", 10229 format(" \t \t f(\"\t\t\"); /* some\n" 10230 " \t \t comment */", 10231 Tab)); 10232 EXPECT_EQ("{\n" 10233 " /*\n" 10234 " * Comment\n" 10235 " */\n" 10236 " int i;\n" 10237 "}", 10238 format("{\n" 10239 "\t/*\n" 10240 "\t * Comment\n" 10241 "\t */\n" 10242 "\t int i;\n" 10243 "}")); 10244 Tab.AlignConsecutiveAssignments = true; 10245 Tab.AlignConsecutiveDeclarations = true; 10246 Tab.TabWidth = 4; 10247 Tab.IndentWidth = 4; 10248 verifyFormat("class Assign {\n" 10249 "\tvoid f() {\n" 10250 "\t\tint x = 123;\n" 10251 "\t\tint random = 4;\n" 10252 "\t\tstd::string alphabet =\n" 10253 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 10254 "\t}\n" 10255 "};", 10256 Tab); 10257 } 10258 10259 TEST_F(FormatTest, ZeroTabWidth) { 10260 FormatStyle Tab = getLLVMStyleWithColumns(42); 10261 Tab.IndentWidth = 8; 10262 Tab.UseTab = FormatStyle::UT_Never; 10263 Tab.TabWidth = 0; 10264 EXPECT_EQ("void a(){\n" 10265 " // line starts with '\t'\n" 10266 "};", 10267 format("void a(){\n" 10268 "\t// line starts with '\t'\n" 10269 "};", 10270 Tab)); 10271 10272 EXPECT_EQ("void a(){\n" 10273 " // line starts with '\t'\n" 10274 "};", 10275 format("void a(){\n" 10276 "\t\t// line starts with '\t'\n" 10277 "};", 10278 Tab)); 10279 10280 Tab.UseTab = FormatStyle::UT_ForIndentation; 10281 EXPECT_EQ("void a(){\n" 10282 " // line starts with '\t'\n" 10283 "};", 10284 format("void a(){\n" 10285 "\t// line starts with '\t'\n" 10286 "};", 10287 Tab)); 10288 10289 EXPECT_EQ("void a(){\n" 10290 " // line starts with '\t'\n" 10291 "};", 10292 format("void a(){\n" 10293 "\t\t// line starts with '\t'\n" 10294 "};", 10295 Tab)); 10296 10297 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10298 EXPECT_EQ("void a(){\n" 10299 " // line starts with '\t'\n" 10300 "};", 10301 format("void a(){\n" 10302 "\t// line starts with '\t'\n" 10303 "};", 10304 Tab)); 10305 10306 EXPECT_EQ("void a(){\n" 10307 " // line starts with '\t'\n" 10308 "};", 10309 format("void a(){\n" 10310 "\t\t// line starts with '\t'\n" 10311 "};", 10312 Tab)); 10313 10314 Tab.UseTab = FormatStyle::UT_Always; 10315 EXPECT_EQ("void a(){\n" 10316 "// line starts with '\t'\n" 10317 "};", 10318 format("void a(){\n" 10319 "\t// line starts with '\t'\n" 10320 "};", 10321 Tab)); 10322 10323 EXPECT_EQ("void a(){\n" 10324 "// line starts with '\t'\n" 10325 "};", 10326 format("void a(){\n" 10327 "\t\t// line starts with '\t'\n" 10328 "};", 10329 Tab)); 10330 } 10331 10332 TEST_F(FormatTest, CalculatesOriginalColumn) { 10333 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10334 "q\"; /* some\n" 10335 " comment */", 10336 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10337 "q\"; /* some\n" 10338 " comment */", 10339 getLLVMStyle())); 10340 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10341 "/* some\n" 10342 " comment */", 10343 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10344 " /* some\n" 10345 " comment */", 10346 getLLVMStyle())); 10347 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10348 "qqq\n" 10349 "/* some\n" 10350 " comment */", 10351 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10352 "qqq\n" 10353 " /* some\n" 10354 " comment */", 10355 getLLVMStyle())); 10356 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10357 "wwww; /* some\n" 10358 " comment */", 10359 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10360 "wwww; /* some\n" 10361 " comment */", 10362 getLLVMStyle())); 10363 } 10364 10365 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 10366 FormatStyle NoSpace = getLLVMStyle(); 10367 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 10368 10369 verifyFormat("while(true)\n" 10370 " continue;", 10371 NoSpace); 10372 verifyFormat("for(;;)\n" 10373 " continue;", 10374 NoSpace); 10375 verifyFormat("if(true)\n" 10376 " f();\n" 10377 "else if(true)\n" 10378 " f();", 10379 NoSpace); 10380 verifyFormat("do {\n" 10381 " do_something();\n" 10382 "} while(something());", 10383 NoSpace); 10384 verifyFormat("switch(x) {\n" 10385 "default:\n" 10386 " break;\n" 10387 "}", 10388 NoSpace); 10389 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 10390 verifyFormat("size_t x = sizeof(x);", NoSpace); 10391 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 10392 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 10393 verifyFormat("alignas(128) char a[128];", NoSpace); 10394 verifyFormat("size_t x = alignof(MyType);", NoSpace); 10395 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 10396 verifyFormat("int f() throw(Deprecated);", NoSpace); 10397 verifyFormat("typedef void (*cb)(int);", NoSpace); 10398 verifyFormat("T A::operator()();", NoSpace); 10399 verifyFormat("X A::operator++(T);", NoSpace); 10400 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 10401 10402 FormatStyle Space = getLLVMStyle(); 10403 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 10404 10405 verifyFormat("int f ();", Space); 10406 verifyFormat("void f (int a, T b) {\n" 10407 " while (true)\n" 10408 " continue;\n" 10409 "}", 10410 Space); 10411 verifyFormat("if (true)\n" 10412 " f ();\n" 10413 "else if (true)\n" 10414 " f ();", 10415 Space); 10416 verifyFormat("do {\n" 10417 " do_something ();\n" 10418 "} while (something ());", 10419 Space); 10420 verifyFormat("switch (x) {\n" 10421 "default:\n" 10422 " break;\n" 10423 "}", 10424 Space); 10425 verifyFormat("A::A () : a (1) {}", Space); 10426 verifyFormat("void f () __attribute__ ((asdf));", Space); 10427 verifyFormat("*(&a + 1);\n" 10428 "&((&a)[1]);\n" 10429 "a[(b + c) * d];\n" 10430 "(((a + 1) * 2) + 3) * 4;", 10431 Space); 10432 verifyFormat("#define A(x) x", Space); 10433 verifyFormat("#define A (x) x", Space); 10434 verifyFormat("#if defined(x)\n" 10435 "#endif", 10436 Space); 10437 verifyFormat("auto i = std::make_unique<int> (5);", Space); 10438 verifyFormat("size_t x = sizeof (x);", Space); 10439 verifyFormat("auto f (int x) -> decltype (x);", Space); 10440 verifyFormat("int f (T x) noexcept (x.create ());", Space); 10441 verifyFormat("alignas (128) char a[128];", Space); 10442 verifyFormat("size_t x = alignof (MyType);", Space); 10443 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 10444 verifyFormat("int f () throw (Deprecated);", Space); 10445 verifyFormat("typedef void (*cb) (int);", Space); 10446 verifyFormat("T A::operator() ();", Space); 10447 verifyFormat("X A::operator++ (T);", Space); 10448 verifyFormat("auto lambda = [] () { return 0; };", Space); 10449 verifyFormat("int x = int (y);", Space); 10450 10451 FormatStyle SomeSpace = getLLVMStyle(); 10452 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 10453 10454 verifyFormat("[]() -> float {}", SomeSpace); 10455 verifyFormat("[] (auto foo) {}", SomeSpace); 10456 verifyFormat("[foo]() -> int {}", SomeSpace); 10457 verifyFormat("int f();", SomeSpace); 10458 verifyFormat("void f (int a, T b) {\n" 10459 " while (true)\n" 10460 " continue;\n" 10461 "}", 10462 SomeSpace); 10463 verifyFormat("if (true)\n" 10464 " f();\n" 10465 "else if (true)\n" 10466 " f();", 10467 SomeSpace); 10468 verifyFormat("do {\n" 10469 " do_something();\n" 10470 "} while (something());", 10471 SomeSpace); 10472 verifyFormat("switch (x) {\n" 10473 "default:\n" 10474 " break;\n" 10475 "}", 10476 SomeSpace); 10477 verifyFormat("A::A() : a (1) {}", SomeSpace); 10478 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 10479 verifyFormat("*(&a + 1);\n" 10480 "&((&a)[1]);\n" 10481 "a[(b + c) * d];\n" 10482 "(((a + 1) * 2) + 3) * 4;", 10483 SomeSpace); 10484 verifyFormat("#define A(x) x", SomeSpace); 10485 verifyFormat("#define A (x) x", SomeSpace); 10486 verifyFormat("#if defined(x)\n" 10487 "#endif", 10488 SomeSpace); 10489 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 10490 verifyFormat("size_t x = sizeof (x);", SomeSpace); 10491 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 10492 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 10493 verifyFormat("alignas (128) char a[128];", SomeSpace); 10494 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 10495 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 10496 SomeSpace); 10497 verifyFormat("int f() throw (Deprecated);", SomeSpace); 10498 verifyFormat("typedef void (*cb) (int);", SomeSpace); 10499 verifyFormat("T A::operator()();", SomeSpace); 10500 verifyFormat("X A::operator++ (T);", SomeSpace); 10501 verifyFormat("int x = int (y);", SomeSpace); 10502 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 10503 } 10504 10505 TEST_F(FormatTest, SpaceAfterLogicalNot) { 10506 FormatStyle Spaces = getLLVMStyle(); 10507 Spaces.SpaceAfterLogicalNot = true; 10508 10509 verifyFormat("bool x = ! y", Spaces); 10510 verifyFormat("if (! isFailure())", Spaces); 10511 verifyFormat("if (! (a && b))", Spaces); 10512 verifyFormat("\"Error!\"", Spaces); 10513 verifyFormat("! ! x", Spaces); 10514 } 10515 10516 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 10517 FormatStyle Spaces = getLLVMStyle(); 10518 10519 Spaces.SpacesInParentheses = true; 10520 verifyFormat("do_something( ::globalVar );", Spaces); 10521 verifyFormat("call( x, y, z );", Spaces); 10522 verifyFormat("call();", Spaces); 10523 verifyFormat("std::function<void( int, int )> callback;", Spaces); 10524 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 10525 Spaces); 10526 verifyFormat("while ( (bool)1 )\n" 10527 " continue;", 10528 Spaces); 10529 verifyFormat("for ( ;; )\n" 10530 " continue;", 10531 Spaces); 10532 verifyFormat("if ( true )\n" 10533 " f();\n" 10534 "else if ( true )\n" 10535 " f();", 10536 Spaces); 10537 verifyFormat("do {\n" 10538 " do_something( (int)i );\n" 10539 "} while ( something() );", 10540 Spaces); 10541 verifyFormat("switch ( x ) {\n" 10542 "default:\n" 10543 " break;\n" 10544 "}", 10545 Spaces); 10546 10547 Spaces.SpacesInParentheses = false; 10548 Spaces.SpacesInCStyleCastParentheses = true; 10549 verifyFormat("Type *A = ( Type * )P;", Spaces); 10550 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 10551 verifyFormat("x = ( int32 )y;", Spaces); 10552 verifyFormat("int a = ( int )(2.0f);", Spaces); 10553 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 10554 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 10555 verifyFormat("#define x (( int )-1)", Spaces); 10556 10557 // Run the first set of tests again with: 10558 Spaces.SpacesInParentheses = false; 10559 Spaces.SpaceInEmptyParentheses = true; 10560 Spaces.SpacesInCStyleCastParentheses = true; 10561 verifyFormat("call(x, y, z);", Spaces); 10562 verifyFormat("call( );", Spaces); 10563 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10564 verifyFormat("while (( bool )1)\n" 10565 " continue;", 10566 Spaces); 10567 verifyFormat("for (;;)\n" 10568 " continue;", 10569 Spaces); 10570 verifyFormat("if (true)\n" 10571 " f( );\n" 10572 "else if (true)\n" 10573 " f( );", 10574 Spaces); 10575 verifyFormat("do {\n" 10576 " do_something(( int )i);\n" 10577 "} while (something( ));", 10578 Spaces); 10579 verifyFormat("switch (x) {\n" 10580 "default:\n" 10581 " break;\n" 10582 "}", 10583 Spaces); 10584 10585 // Run the first set of tests again with: 10586 Spaces.SpaceAfterCStyleCast = true; 10587 verifyFormat("call(x, y, z);", Spaces); 10588 verifyFormat("call( );", Spaces); 10589 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10590 verifyFormat("while (( bool ) 1)\n" 10591 " continue;", 10592 Spaces); 10593 verifyFormat("for (;;)\n" 10594 " continue;", 10595 Spaces); 10596 verifyFormat("if (true)\n" 10597 " f( );\n" 10598 "else if (true)\n" 10599 " f( );", 10600 Spaces); 10601 verifyFormat("do {\n" 10602 " do_something(( int ) i);\n" 10603 "} while (something( ));", 10604 Spaces); 10605 verifyFormat("switch (x) {\n" 10606 "default:\n" 10607 " break;\n" 10608 "}", 10609 Spaces); 10610 10611 // Run subset of tests again with: 10612 Spaces.SpacesInCStyleCastParentheses = false; 10613 Spaces.SpaceAfterCStyleCast = true; 10614 verifyFormat("while ((bool) 1)\n" 10615 " continue;", 10616 Spaces); 10617 verifyFormat("do {\n" 10618 " do_something((int) i);\n" 10619 "} while (something( ));", 10620 Spaces); 10621 } 10622 10623 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 10624 verifyFormat("int a[5];"); 10625 verifyFormat("a[3] += 42;"); 10626 10627 FormatStyle Spaces = getLLVMStyle(); 10628 Spaces.SpacesInSquareBrackets = true; 10629 // Not lambdas. 10630 verifyFormat("int a[ 5 ];", Spaces); 10631 verifyFormat("a[ 3 ] += 42;", Spaces); 10632 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 10633 verifyFormat("double &operator[](int i) { return 0; }\n" 10634 "int i;", 10635 Spaces); 10636 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 10637 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 10638 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 10639 // Lambdas. 10640 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 10641 verifyFormat("return [ i, args... ] {};", Spaces); 10642 verifyFormat("int foo = [ &bar ]() {};", Spaces); 10643 verifyFormat("int foo = [ = ]() {};", Spaces); 10644 verifyFormat("int foo = [ & ]() {};", Spaces); 10645 verifyFormat("int foo = [ =, &bar ]() {};", Spaces); 10646 verifyFormat("int foo = [ &bar, = ]() {};", Spaces); 10647 } 10648 10649 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) { 10650 FormatStyle NoSpaceStyle = getLLVMStyle(); 10651 verifyFormat("int a[5];", NoSpaceStyle); 10652 verifyFormat("a[3] += 42;", NoSpaceStyle); 10653 10654 verifyFormat("int a[1];", NoSpaceStyle); 10655 verifyFormat("int 1 [a];", NoSpaceStyle); 10656 verifyFormat("int a[1][2];", NoSpaceStyle); 10657 verifyFormat("a[7] = 5;", NoSpaceStyle); 10658 verifyFormat("int a = (f())[23];", NoSpaceStyle); 10659 verifyFormat("f([] {})", NoSpaceStyle); 10660 10661 FormatStyle Space = getLLVMStyle(); 10662 Space.SpaceBeforeSquareBrackets = true; 10663 verifyFormat("int c = []() -> int { return 2; }();\n", Space); 10664 verifyFormat("return [i, args...] {};", Space); 10665 10666 verifyFormat("int a [5];", Space); 10667 verifyFormat("a [3] += 42;", Space); 10668 verifyFormat("constexpr char hello []{\"hello\"};", Space); 10669 verifyFormat("double &operator[](int i) { return 0; }\n" 10670 "int i;", 10671 Space); 10672 verifyFormat("std::unique_ptr<int []> foo() {}", Space); 10673 verifyFormat("int i = a [a][a]->f();", Space); 10674 verifyFormat("int i = (*b) [a]->f();", Space); 10675 10676 verifyFormat("int a [1];", Space); 10677 verifyFormat("int 1 [a];", Space); 10678 verifyFormat("int a [1][2];", Space); 10679 verifyFormat("a [7] = 5;", Space); 10680 verifyFormat("int a = (f()) [23];", Space); 10681 verifyFormat("f([] {})", Space); 10682 } 10683 10684 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 10685 verifyFormat("int a = 5;"); 10686 verifyFormat("a += 42;"); 10687 verifyFormat("a or_eq 8;"); 10688 10689 FormatStyle Spaces = getLLVMStyle(); 10690 Spaces.SpaceBeforeAssignmentOperators = false; 10691 verifyFormat("int a= 5;", Spaces); 10692 verifyFormat("a+= 42;", Spaces); 10693 verifyFormat("a or_eq 8;", Spaces); 10694 } 10695 10696 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 10697 verifyFormat("class Foo : public Bar {};"); 10698 verifyFormat("Foo::Foo() : foo(1) {}"); 10699 verifyFormat("for (auto a : b) {\n}"); 10700 verifyFormat("int x = a ? b : c;"); 10701 verifyFormat("{\n" 10702 "label0:\n" 10703 " int x = 0;\n" 10704 "}"); 10705 verifyFormat("switch (x) {\n" 10706 "case 1:\n" 10707 "default:\n" 10708 "}"); 10709 10710 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 10711 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 10712 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 10713 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 10714 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 10715 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 10716 verifyFormat("{\n" 10717 "label1:\n" 10718 " int x = 0;\n" 10719 "}", 10720 CtorInitializerStyle); 10721 verifyFormat("switch (x) {\n" 10722 "case 1:\n" 10723 "default:\n" 10724 "}", 10725 CtorInitializerStyle); 10726 CtorInitializerStyle.BreakConstructorInitializers = 10727 FormatStyle::BCIS_AfterColon; 10728 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 10729 " aaaaaaaaaaaaaaaa(1),\n" 10730 " bbbbbbbbbbbbbbbb(2) {}", 10731 CtorInitializerStyle); 10732 CtorInitializerStyle.BreakConstructorInitializers = 10733 FormatStyle::BCIS_BeforeComma; 10734 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10735 " : aaaaaaaaaaaaaaaa(1)\n" 10736 " , bbbbbbbbbbbbbbbb(2) {}", 10737 CtorInitializerStyle); 10738 CtorInitializerStyle.BreakConstructorInitializers = 10739 FormatStyle::BCIS_BeforeColon; 10740 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10741 " : aaaaaaaaaaaaaaaa(1),\n" 10742 " bbbbbbbbbbbbbbbb(2) {}", 10743 CtorInitializerStyle); 10744 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 10745 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10746 ": aaaaaaaaaaaaaaaa(1),\n" 10747 " bbbbbbbbbbbbbbbb(2) {}", 10748 CtorInitializerStyle); 10749 10750 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 10751 InheritanceStyle.SpaceBeforeInheritanceColon = false; 10752 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 10753 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 10754 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 10755 verifyFormat("int x = a ? b : c;", InheritanceStyle); 10756 verifyFormat("{\n" 10757 "label2:\n" 10758 " int x = 0;\n" 10759 "}", 10760 InheritanceStyle); 10761 verifyFormat("switch (x) {\n" 10762 "case 1:\n" 10763 "default:\n" 10764 "}", 10765 InheritanceStyle); 10766 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 10767 verifyFormat("class Foooooooooooooooooooooo:\n" 10768 " public aaaaaaaaaaaaaaaaaa,\n" 10769 " public bbbbbbbbbbbbbbbbbb {\n" 10770 "}", 10771 InheritanceStyle); 10772 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 10773 verifyFormat("class Foooooooooooooooooooooo\n" 10774 " : public aaaaaaaaaaaaaaaaaa\n" 10775 " , public bbbbbbbbbbbbbbbbbb {\n" 10776 "}", 10777 InheritanceStyle); 10778 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 10779 verifyFormat("class Foooooooooooooooooooooo\n" 10780 " : public aaaaaaaaaaaaaaaaaa,\n" 10781 " public bbbbbbbbbbbbbbbbbb {\n" 10782 "}", 10783 InheritanceStyle); 10784 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 10785 verifyFormat("class Foooooooooooooooooooooo\n" 10786 ": public aaaaaaaaaaaaaaaaaa,\n" 10787 " public bbbbbbbbbbbbbbbbbb {}", 10788 InheritanceStyle); 10789 10790 FormatStyle ForLoopStyle = getLLVMStyle(); 10791 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 10792 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 10793 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 10794 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 10795 verifyFormat("int x = a ? b : c;", ForLoopStyle); 10796 verifyFormat("{\n" 10797 "label2:\n" 10798 " int x = 0;\n" 10799 "}", 10800 ForLoopStyle); 10801 verifyFormat("switch (x) {\n" 10802 "case 1:\n" 10803 "default:\n" 10804 "}", 10805 ForLoopStyle); 10806 10807 FormatStyle NoSpaceStyle = getLLVMStyle(); 10808 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 10809 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 10810 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 10811 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 10812 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 10813 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 10814 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 10815 verifyFormat("{\n" 10816 "label3:\n" 10817 " int x = 0;\n" 10818 "}", 10819 NoSpaceStyle); 10820 verifyFormat("switch (x) {\n" 10821 "case 1:\n" 10822 "default:\n" 10823 "}", 10824 NoSpaceStyle); 10825 } 10826 10827 TEST_F(FormatTest, AlignConsecutiveMacros) { 10828 FormatStyle Style = getLLVMStyle(); 10829 Style.AlignConsecutiveAssignments = true; 10830 Style.AlignConsecutiveDeclarations = true; 10831 Style.AlignConsecutiveMacros = false; 10832 10833 verifyFormat("#define a 3\n" 10834 "#define bbbb 4\n" 10835 "#define ccc (5)", 10836 Style); 10837 10838 verifyFormat("#define f(x) (x * x)\n" 10839 "#define fff(x, y, z) (x * y + z)\n" 10840 "#define ffff(x, y) (x - y)", 10841 Style); 10842 10843 verifyFormat("#define foo(x, y) (x + y)\n" 10844 "#define bar (5, 6)(2 + 2)", 10845 Style); 10846 10847 verifyFormat("#define a 3\n" 10848 "#define bbbb 4\n" 10849 "#define ccc (5)\n" 10850 "#define f(x) (x * x)\n" 10851 "#define fff(x, y, z) (x * y + z)\n" 10852 "#define ffff(x, y) (x - y)", 10853 Style); 10854 10855 Style.AlignConsecutiveMacros = true; 10856 verifyFormat("#define a 3\n" 10857 "#define bbbb 4\n" 10858 "#define ccc (5)", 10859 Style); 10860 10861 verifyFormat("#define f(x) (x * x)\n" 10862 "#define fff(x, y, z) (x * y + z)\n" 10863 "#define ffff(x, y) (x - y)", 10864 Style); 10865 10866 verifyFormat("#define foo(x, y) (x + y)\n" 10867 "#define bar (5, 6)(2 + 2)", 10868 Style); 10869 10870 verifyFormat("#define a 3\n" 10871 "#define bbbb 4\n" 10872 "#define ccc (5)\n" 10873 "#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 a 5\n" 10879 "#define foo(x, y) (x + y)\n" 10880 "#define CCC (6)\n" 10881 "auto lambda = []() {\n" 10882 " auto ii = 0;\n" 10883 " float j = 0;\n" 10884 " return 0;\n" 10885 "};\n" 10886 "int i = 0;\n" 10887 "float i2 = 0;\n" 10888 "auto v = type{\n" 10889 " i = 1, //\n" 10890 " (i = 2), //\n" 10891 " i = 3 //\n" 10892 "};", 10893 Style); 10894 10895 Style.AlignConsecutiveMacros = false; 10896 Style.ColumnLimit = 20; 10897 10898 verifyFormat("#define a \\\n" 10899 " \"aabbbbbbbbbbbb\"\n" 10900 "#define D \\\n" 10901 " \"aabbbbbbbbbbbb\" \\\n" 10902 " \"ccddeeeeeeeee\"\n" 10903 "#define B \\\n" 10904 " \"QQQQQQQQQQQQQ\" \\\n" 10905 " \"FFFFFFFFFFFFF\" \\\n" 10906 " \"LLLLLLLL\"\n", 10907 Style); 10908 10909 Style.AlignConsecutiveMacros = true; 10910 verifyFormat("#define a \\\n" 10911 " \"aabbbbbbbbbbbb\"\n" 10912 "#define D \\\n" 10913 " \"aabbbbbbbbbbbb\" \\\n" 10914 " \"ccddeeeeeeeee\"\n" 10915 "#define B \\\n" 10916 " \"QQQQQQQQQQQQQ\" \\\n" 10917 " \"FFFFFFFFFFFFF\" \\\n" 10918 " \"LLLLLLLL\"\n", 10919 Style); 10920 } 10921 10922 TEST_F(FormatTest, AlignConsecutiveAssignments) { 10923 FormatStyle Alignment = getLLVMStyle(); 10924 Alignment.AlignConsecutiveMacros = true; 10925 Alignment.AlignConsecutiveAssignments = false; 10926 verifyFormat("int a = 5;\n" 10927 "int oneTwoThree = 123;", 10928 Alignment); 10929 verifyFormat("int a = 5;\n" 10930 "int oneTwoThree = 123;", 10931 Alignment); 10932 10933 Alignment.AlignConsecutiveAssignments = true; 10934 verifyFormat("int a = 5;\n" 10935 "int oneTwoThree = 123;", 10936 Alignment); 10937 verifyFormat("int a = method();\n" 10938 "int oneTwoThree = 133;", 10939 Alignment); 10940 verifyFormat("a &= 5;\n" 10941 "bcd *= 5;\n" 10942 "ghtyf += 5;\n" 10943 "dvfvdb -= 5;\n" 10944 "a /= 5;\n" 10945 "vdsvsv %= 5;\n" 10946 "sfdbddfbdfbb ^= 5;\n" 10947 "dvsdsv |= 5;\n" 10948 "int dsvvdvsdvvv = 123;", 10949 Alignment); 10950 verifyFormat("int i = 1, j = 10;\n" 10951 "something = 2000;", 10952 Alignment); 10953 verifyFormat("something = 2000;\n" 10954 "int i = 1, j = 10;\n", 10955 Alignment); 10956 verifyFormat("something = 2000;\n" 10957 "another = 911;\n" 10958 "int i = 1, j = 10;\n" 10959 "oneMore = 1;\n" 10960 "i = 2;", 10961 Alignment); 10962 verifyFormat("int a = 5;\n" 10963 "int one = 1;\n" 10964 "method();\n" 10965 "int oneTwoThree = 123;\n" 10966 "int oneTwo = 12;", 10967 Alignment); 10968 verifyFormat("int oneTwoThree = 123;\n" 10969 "int oneTwo = 12;\n" 10970 "method();\n", 10971 Alignment); 10972 verifyFormat("int oneTwoThree = 123; // comment\n" 10973 "int oneTwo = 12; // comment", 10974 Alignment); 10975 EXPECT_EQ("int a = 5;\n" 10976 "\n" 10977 "int oneTwoThree = 123;", 10978 format("int a = 5;\n" 10979 "\n" 10980 "int oneTwoThree= 123;", 10981 Alignment)); 10982 EXPECT_EQ("int a = 5;\n" 10983 "int one = 1;\n" 10984 "\n" 10985 "int oneTwoThree = 123;", 10986 format("int a = 5;\n" 10987 "int one = 1;\n" 10988 "\n" 10989 "int oneTwoThree = 123;", 10990 Alignment)); 10991 EXPECT_EQ("int a = 5;\n" 10992 "int one = 1;\n" 10993 "\n" 10994 "int oneTwoThree = 123;\n" 10995 "int oneTwo = 12;", 10996 format("int a = 5;\n" 10997 "int one = 1;\n" 10998 "\n" 10999 "int oneTwoThree = 123;\n" 11000 "int oneTwo = 12;", 11001 Alignment)); 11002 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11003 verifyFormat("#define A \\\n" 11004 " int aaaa = 12; \\\n" 11005 " int b = 23; \\\n" 11006 " int ccc = 234; \\\n" 11007 " int dddddddddd = 2345;", 11008 Alignment); 11009 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11010 verifyFormat("#define A \\\n" 11011 " int aaaa = 12; \\\n" 11012 " int b = 23; \\\n" 11013 " int ccc = 234; \\\n" 11014 " int dddddddddd = 2345;", 11015 Alignment); 11016 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11017 verifyFormat("#define A " 11018 " \\\n" 11019 " int aaaa = 12; " 11020 " \\\n" 11021 " int b = 23; " 11022 " \\\n" 11023 " int ccc = 234; " 11024 " \\\n" 11025 " int dddddddddd = 2345;", 11026 Alignment); 11027 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11028 "k = 4, int l = 5,\n" 11029 " int m = 6) {\n" 11030 " int j = 10;\n" 11031 " otherThing = 1;\n" 11032 "}", 11033 Alignment); 11034 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11035 " int i = 1;\n" 11036 " int j = 2;\n" 11037 " int big = 10000;\n" 11038 "}", 11039 Alignment); 11040 verifyFormat("class C {\n" 11041 "public:\n" 11042 " int i = 1;\n" 11043 " virtual void f() = 0;\n" 11044 "};", 11045 Alignment); 11046 verifyFormat("int i = 1;\n" 11047 "if (SomeType t = getSomething()) {\n" 11048 "}\n" 11049 "int j = 2;\n" 11050 "int big = 10000;", 11051 Alignment); 11052 verifyFormat("int j = 7;\n" 11053 "for (int k = 0; k < N; ++k) {\n" 11054 "}\n" 11055 "int j = 2;\n" 11056 "int big = 10000;\n" 11057 "}", 11058 Alignment); 11059 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11060 verifyFormat("int i = 1;\n" 11061 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11062 " = someLooooooooooooooooongFunction();\n" 11063 "int j = 2;", 11064 Alignment); 11065 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11066 verifyFormat("int i = 1;\n" 11067 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11068 " someLooooooooooooooooongFunction();\n" 11069 "int j = 2;", 11070 Alignment); 11071 11072 verifyFormat("auto lambda = []() {\n" 11073 " auto i = 0;\n" 11074 " return 0;\n" 11075 "};\n" 11076 "int i = 0;\n" 11077 "auto v = type{\n" 11078 " i = 1, //\n" 11079 " (i = 2), //\n" 11080 " i = 3 //\n" 11081 "};", 11082 Alignment); 11083 11084 verifyFormat( 11085 "int i = 1;\n" 11086 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11087 " loooooooooooooooooooooongParameterB);\n" 11088 "int j = 2;", 11089 Alignment); 11090 11091 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 11092 " typename B = very_long_type_name_1,\n" 11093 " typename T_2 = very_long_type_name_2>\n" 11094 "auto foo() {}\n", 11095 Alignment); 11096 verifyFormat("int a, b = 1;\n" 11097 "int c = 2;\n" 11098 "int dd = 3;\n", 11099 Alignment); 11100 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11101 "float b[1][] = {{3.f}};\n", 11102 Alignment); 11103 verifyFormat("for (int i = 0; i < 1; i++)\n" 11104 " int x = 1;\n", 11105 Alignment); 11106 verifyFormat("for (i = 0; i < 1; i++)\n" 11107 " x = 1;\n" 11108 "y = 1;\n", 11109 Alignment); 11110 } 11111 11112 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 11113 FormatStyle Alignment = getLLVMStyle(); 11114 Alignment.AlignConsecutiveMacros = true; 11115 Alignment.AlignConsecutiveDeclarations = false; 11116 verifyFormat("float const a = 5;\n" 11117 "int oneTwoThree = 123;", 11118 Alignment); 11119 verifyFormat("int a = 5;\n" 11120 "float const oneTwoThree = 123;", 11121 Alignment); 11122 11123 Alignment.AlignConsecutiveDeclarations = true; 11124 verifyFormat("float const a = 5;\n" 11125 "int oneTwoThree = 123;", 11126 Alignment); 11127 verifyFormat("int a = method();\n" 11128 "float const oneTwoThree = 133;", 11129 Alignment); 11130 verifyFormat("int i = 1, j = 10;\n" 11131 "something = 2000;", 11132 Alignment); 11133 verifyFormat("something = 2000;\n" 11134 "int i = 1, j = 10;\n", 11135 Alignment); 11136 verifyFormat("float something = 2000;\n" 11137 "double another = 911;\n" 11138 "int i = 1, j = 10;\n" 11139 "const int *oneMore = 1;\n" 11140 "unsigned i = 2;", 11141 Alignment); 11142 verifyFormat("float a = 5;\n" 11143 "int one = 1;\n" 11144 "method();\n" 11145 "const double oneTwoThree = 123;\n" 11146 "const unsigned int oneTwo = 12;", 11147 Alignment); 11148 verifyFormat("int oneTwoThree{0}; // comment\n" 11149 "unsigned oneTwo; // comment", 11150 Alignment); 11151 EXPECT_EQ("float const a = 5;\n" 11152 "\n" 11153 "int oneTwoThree = 123;", 11154 format("float const a = 5;\n" 11155 "\n" 11156 "int oneTwoThree= 123;", 11157 Alignment)); 11158 EXPECT_EQ("float a = 5;\n" 11159 "int one = 1;\n" 11160 "\n" 11161 "unsigned oneTwoThree = 123;", 11162 format("float a = 5;\n" 11163 "int one = 1;\n" 11164 "\n" 11165 "unsigned oneTwoThree = 123;", 11166 Alignment)); 11167 EXPECT_EQ("float a = 5;\n" 11168 "int one = 1;\n" 11169 "\n" 11170 "unsigned oneTwoThree = 123;\n" 11171 "int oneTwo = 12;", 11172 format("float a = 5;\n" 11173 "int one = 1;\n" 11174 "\n" 11175 "unsigned oneTwoThree = 123;\n" 11176 "int oneTwo = 12;", 11177 Alignment)); 11178 // Function prototype alignment 11179 verifyFormat("int a();\n" 11180 "double b();", 11181 Alignment); 11182 verifyFormat("int a(int x);\n" 11183 "double b();", 11184 Alignment); 11185 unsigned OldColumnLimit = Alignment.ColumnLimit; 11186 // We need to set ColumnLimit to zero, in order to stress nested alignments, 11187 // otherwise the function parameters will be re-flowed onto a single line. 11188 Alignment.ColumnLimit = 0; 11189 EXPECT_EQ("int a(int x,\n" 11190 " float y);\n" 11191 "double b(int x,\n" 11192 " double y);", 11193 format("int a(int x,\n" 11194 " float y);\n" 11195 "double b(int x,\n" 11196 " double y);", 11197 Alignment)); 11198 // This ensures that function parameters of function declarations are 11199 // correctly indented when their owning functions are indented. 11200 // The failure case here is for 'double y' to not be indented enough. 11201 EXPECT_EQ("double a(int x);\n" 11202 "int b(int y,\n" 11203 " double z);", 11204 format("double a(int x);\n" 11205 "int b(int y,\n" 11206 " double z);", 11207 Alignment)); 11208 // Set ColumnLimit low so that we induce wrapping immediately after 11209 // the function name and opening paren. 11210 Alignment.ColumnLimit = 13; 11211 verifyFormat("int function(\n" 11212 " int x,\n" 11213 " bool y);", 11214 Alignment); 11215 Alignment.ColumnLimit = OldColumnLimit; 11216 // Ensure function pointers don't screw up recursive alignment 11217 verifyFormat("int a(int x, void (*fp)(int y));\n" 11218 "double b();", 11219 Alignment); 11220 Alignment.AlignConsecutiveAssignments = true; 11221 // Ensure recursive alignment is broken by function braces, so that the 11222 // "a = 1" does not align with subsequent assignments inside the function 11223 // body. 11224 verifyFormat("int func(int a = 1) {\n" 11225 " int b = 2;\n" 11226 " int cc = 3;\n" 11227 "}", 11228 Alignment); 11229 verifyFormat("float something = 2000;\n" 11230 "double another = 911;\n" 11231 "int i = 1, j = 10;\n" 11232 "const int *oneMore = 1;\n" 11233 "unsigned i = 2;", 11234 Alignment); 11235 verifyFormat("int oneTwoThree = {0}; // comment\n" 11236 "unsigned oneTwo = 0; // comment", 11237 Alignment); 11238 // Make sure that scope is correctly tracked, in the absence of braces 11239 verifyFormat("for (int i = 0; i < n; i++)\n" 11240 " j = i;\n" 11241 "double x = 1;\n", 11242 Alignment); 11243 verifyFormat("if (int i = 0)\n" 11244 " j = i;\n" 11245 "double x = 1;\n", 11246 Alignment); 11247 // Ensure operator[] and operator() are comprehended 11248 verifyFormat("struct test {\n" 11249 " long long int foo();\n" 11250 " int operator[](int a);\n" 11251 " double bar();\n" 11252 "};\n", 11253 Alignment); 11254 verifyFormat("struct test {\n" 11255 " long long int foo();\n" 11256 " int operator()(int a);\n" 11257 " double bar();\n" 11258 "};\n", 11259 Alignment); 11260 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 11261 " int const i = 1;\n" 11262 " int * j = 2;\n" 11263 " int big = 10000;\n" 11264 "\n" 11265 " unsigned oneTwoThree = 123;\n" 11266 " int oneTwo = 12;\n" 11267 " method();\n" 11268 " float k = 2;\n" 11269 " int ll = 10000;\n" 11270 "}", 11271 format("void SomeFunction(int parameter= 0) {\n" 11272 " int const i= 1;\n" 11273 " int *j=2;\n" 11274 " int big = 10000;\n" 11275 "\n" 11276 "unsigned oneTwoThree =123;\n" 11277 "int oneTwo = 12;\n" 11278 " method();\n" 11279 "float k= 2;\n" 11280 "int ll=10000;\n" 11281 "}", 11282 Alignment)); 11283 Alignment.AlignConsecutiveAssignments = false; 11284 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11285 verifyFormat("#define A \\\n" 11286 " int aaaa = 12; \\\n" 11287 " float b = 23; \\\n" 11288 " const int ccc = 234; \\\n" 11289 " unsigned dddddddddd = 2345;", 11290 Alignment); 11291 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11292 verifyFormat("#define A \\\n" 11293 " int aaaa = 12; \\\n" 11294 " float b = 23; \\\n" 11295 " const int ccc = 234; \\\n" 11296 " unsigned dddddddddd = 2345;", 11297 Alignment); 11298 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11299 Alignment.ColumnLimit = 30; 11300 verifyFormat("#define A \\\n" 11301 " int aaaa = 12; \\\n" 11302 " float b = 23; \\\n" 11303 " const int ccc = 234; \\\n" 11304 " int dddddddddd = 2345;", 11305 Alignment); 11306 Alignment.ColumnLimit = 80; 11307 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11308 "k = 4, int l = 5,\n" 11309 " int m = 6) {\n" 11310 " const int j = 10;\n" 11311 " otherThing = 1;\n" 11312 "}", 11313 Alignment); 11314 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11315 " int const i = 1;\n" 11316 " int * j = 2;\n" 11317 " int big = 10000;\n" 11318 "}", 11319 Alignment); 11320 verifyFormat("class C {\n" 11321 "public:\n" 11322 " int i = 1;\n" 11323 " virtual void f() = 0;\n" 11324 "};", 11325 Alignment); 11326 verifyFormat("float i = 1;\n" 11327 "if (SomeType t = getSomething()) {\n" 11328 "}\n" 11329 "const unsigned j = 2;\n" 11330 "int big = 10000;", 11331 Alignment); 11332 verifyFormat("float j = 7;\n" 11333 "for (int k = 0; k < N; ++k) {\n" 11334 "}\n" 11335 "unsigned j = 2;\n" 11336 "int big = 10000;\n" 11337 "}", 11338 Alignment); 11339 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11340 verifyFormat("float i = 1;\n" 11341 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11342 " = someLooooooooooooooooongFunction();\n" 11343 "int j = 2;", 11344 Alignment); 11345 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11346 verifyFormat("int i = 1;\n" 11347 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11348 " someLooooooooooooooooongFunction();\n" 11349 "int j = 2;", 11350 Alignment); 11351 11352 Alignment.AlignConsecutiveAssignments = true; 11353 verifyFormat("auto lambda = []() {\n" 11354 " auto ii = 0;\n" 11355 " float j = 0;\n" 11356 " return 0;\n" 11357 "};\n" 11358 "int i = 0;\n" 11359 "float i2 = 0;\n" 11360 "auto v = type{\n" 11361 " i = 1, //\n" 11362 " (i = 2), //\n" 11363 " i = 3 //\n" 11364 "};", 11365 Alignment); 11366 Alignment.AlignConsecutiveAssignments = false; 11367 11368 verifyFormat( 11369 "int i = 1;\n" 11370 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11371 " loooooooooooooooooooooongParameterB);\n" 11372 "int j = 2;", 11373 Alignment); 11374 11375 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 11376 // We expect declarations and assignments to align, as long as it doesn't 11377 // exceed the column limit, starting a new alignment sequence whenever it 11378 // happens. 11379 Alignment.AlignConsecutiveAssignments = true; 11380 Alignment.ColumnLimit = 30; 11381 verifyFormat("float ii = 1;\n" 11382 "unsigned j = 2;\n" 11383 "int someVerylongVariable = 1;\n" 11384 "AnotherLongType ll = 123456;\n" 11385 "VeryVeryLongType k = 2;\n" 11386 "int myvar = 1;", 11387 Alignment); 11388 Alignment.ColumnLimit = 80; 11389 Alignment.AlignConsecutiveAssignments = false; 11390 11391 verifyFormat( 11392 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 11393 " typename LongType, typename B>\n" 11394 "auto foo() {}\n", 11395 Alignment); 11396 verifyFormat("float a, b = 1;\n" 11397 "int c = 2;\n" 11398 "int dd = 3;\n", 11399 Alignment); 11400 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11401 "float b[1][] = {{3.f}};\n", 11402 Alignment); 11403 Alignment.AlignConsecutiveAssignments = true; 11404 verifyFormat("float a, b = 1;\n" 11405 "int c = 2;\n" 11406 "int dd = 3;\n", 11407 Alignment); 11408 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11409 "float b[1][] = {{3.f}};\n", 11410 Alignment); 11411 Alignment.AlignConsecutiveAssignments = false; 11412 11413 Alignment.ColumnLimit = 30; 11414 Alignment.BinPackParameters = false; 11415 verifyFormat("void foo(float a,\n" 11416 " float b,\n" 11417 " int c,\n" 11418 " uint32_t *d) {\n" 11419 " int * e = 0;\n" 11420 " float f = 0;\n" 11421 " double g = 0;\n" 11422 "}\n" 11423 "void bar(ino_t a,\n" 11424 " int b,\n" 11425 " uint32_t *c,\n" 11426 " bool d) {}\n", 11427 Alignment); 11428 Alignment.BinPackParameters = true; 11429 Alignment.ColumnLimit = 80; 11430 11431 // Bug 33507 11432 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 11433 verifyFormat( 11434 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 11435 " static const Version verVs2017;\n" 11436 " return true;\n" 11437 "});\n", 11438 Alignment); 11439 Alignment.PointerAlignment = FormatStyle::PAS_Right; 11440 11441 // See llvm.org/PR35641 11442 Alignment.AlignConsecutiveDeclarations = true; 11443 verifyFormat("int func() { //\n" 11444 " int b;\n" 11445 " unsigned c;\n" 11446 "}", 11447 Alignment); 11448 11449 // See PR37175 11450 FormatStyle Style = getMozillaStyle(); 11451 Style.AlignConsecutiveDeclarations = true; 11452 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 11453 "foo(int a);", 11454 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 11455 } 11456 11457 TEST_F(FormatTest, LinuxBraceBreaking) { 11458 FormatStyle LinuxBraceStyle = getLLVMStyle(); 11459 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 11460 verifyFormat("namespace a\n" 11461 "{\n" 11462 "class A\n" 11463 "{\n" 11464 " void f()\n" 11465 " {\n" 11466 " if (true) {\n" 11467 " a();\n" 11468 " b();\n" 11469 " } else {\n" 11470 " a();\n" 11471 " }\n" 11472 " }\n" 11473 " void g() { return; }\n" 11474 "};\n" 11475 "struct B {\n" 11476 " int x;\n" 11477 "};\n" 11478 "} // namespace a\n", 11479 LinuxBraceStyle); 11480 verifyFormat("enum X {\n" 11481 " Y = 0,\n" 11482 "}\n", 11483 LinuxBraceStyle); 11484 verifyFormat("struct S {\n" 11485 " int Type;\n" 11486 " union {\n" 11487 " int x;\n" 11488 " double y;\n" 11489 " } Value;\n" 11490 " class C\n" 11491 " {\n" 11492 " MyFavoriteType Value;\n" 11493 " } Class;\n" 11494 "}\n", 11495 LinuxBraceStyle); 11496 } 11497 11498 TEST_F(FormatTest, MozillaBraceBreaking) { 11499 FormatStyle MozillaBraceStyle = getLLVMStyle(); 11500 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 11501 MozillaBraceStyle.FixNamespaceComments = false; 11502 verifyFormat("namespace a {\n" 11503 "class A\n" 11504 "{\n" 11505 " void f()\n" 11506 " {\n" 11507 " if (true) {\n" 11508 " a();\n" 11509 " b();\n" 11510 " }\n" 11511 " }\n" 11512 " void g() { return; }\n" 11513 "};\n" 11514 "enum E\n" 11515 "{\n" 11516 " A,\n" 11517 " // foo\n" 11518 " B,\n" 11519 " C\n" 11520 "};\n" 11521 "struct B\n" 11522 "{\n" 11523 " int x;\n" 11524 "};\n" 11525 "}\n", 11526 MozillaBraceStyle); 11527 verifyFormat("struct S\n" 11528 "{\n" 11529 " int Type;\n" 11530 " union\n" 11531 " {\n" 11532 " int x;\n" 11533 " double y;\n" 11534 " } Value;\n" 11535 " class C\n" 11536 " {\n" 11537 " MyFavoriteType Value;\n" 11538 " } Class;\n" 11539 "}\n", 11540 MozillaBraceStyle); 11541 } 11542 11543 TEST_F(FormatTest, StroustrupBraceBreaking) { 11544 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 11545 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11546 verifyFormat("namespace a {\n" 11547 "class A {\n" 11548 " void f()\n" 11549 " {\n" 11550 " if (true) {\n" 11551 " a();\n" 11552 " b();\n" 11553 " }\n" 11554 " }\n" 11555 " void g() { return; }\n" 11556 "};\n" 11557 "struct B {\n" 11558 " int x;\n" 11559 "};\n" 11560 "} // namespace a\n", 11561 StroustrupBraceStyle); 11562 11563 verifyFormat("void foo()\n" 11564 "{\n" 11565 " if (a) {\n" 11566 " a();\n" 11567 " }\n" 11568 " else {\n" 11569 " b();\n" 11570 " }\n" 11571 "}\n", 11572 StroustrupBraceStyle); 11573 11574 verifyFormat("#ifdef _DEBUG\n" 11575 "int foo(int i = 0)\n" 11576 "#else\n" 11577 "int foo(int i = 5)\n" 11578 "#endif\n" 11579 "{\n" 11580 " return i;\n" 11581 "}", 11582 StroustrupBraceStyle); 11583 11584 verifyFormat("void foo() {}\n" 11585 "void bar()\n" 11586 "#ifdef _DEBUG\n" 11587 "{\n" 11588 " foo();\n" 11589 "}\n" 11590 "#else\n" 11591 "{\n" 11592 "}\n" 11593 "#endif", 11594 StroustrupBraceStyle); 11595 11596 verifyFormat("void foobar() { int i = 5; }\n" 11597 "#ifdef _DEBUG\n" 11598 "void bar() {}\n" 11599 "#else\n" 11600 "void bar() { foobar(); }\n" 11601 "#endif", 11602 StroustrupBraceStyle); 11603 } 11604 11605 TEST_F(FormatTest, AllmanBraceBreaking) { 11606 FormatStyle AllmanBraceStyle = getLLVMStyle(); 11607 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 11608 11609 EXPECT_EQ("namespace a\n" 11610 "{\n" 11611 "void f();\n" 11612 "void g();\n" 11613 "} // namespace a\n", 11614 format("namespace a\n" 11615 "{\n" 11616 "void f();\n" 11617 "void g();\n" 11618 "}\n", 11619 AllmanBraceStyle)); 11620 11621 verifyFormat("namespace a\n" 11622 "{\n" 11623 "class A\n" 11624 "{\n" 11625 " void f()\n" 11626 " {\n" 11627 " if (true)\n" 11628 " {\n" 11629 " a();\n" 11630 " b();\n" 11631 " }\n" 11632 " }\n" 11633 " void g() { return; }\n" 11634 "};\n" 11635 "struct B\n" 11636 "{\n" 11637 " int x;\n" 11638 "};\n" 11639 "union C\n" 11640 "{\n" 11641 "};\n" 11642 "} // namespace a", 11643 AllmanBraceStyle); 11644 11645 verifyFormat("void f()\n" 11646 "{\n" 11647 " if (true)\n" 11648 " {\n" 11649 " a();\n" 11650 " }\n" 11651 " else if (false)\n" 11652 " {\n" 11653 " b();\n" 11654 " }\n" 11655 " else\n" 11656 " {\n" 11657 " c();\n" 11658 " }\n" 11659 "}\n", 11660 AllmanBraceStyle); 11661 11662 verifyFormat("void f()\n" 11663 "{\n" 11664 " for (int i = 0; i < 10; ++i)\n" 11665 " {\n" 11666 " a();\n" 11667 " }\n" 11668 " while (false)\n" 11669 " {\n" 11670 " b();\n" 11671 " }\n" 11672 " do\n" 11673 " {\n" 11674 " c();\n" 11675 " } while (false)\n" 11676 "}\n", 11677 AllmanBraceStyle); 11678 11679 verifyFormat("void f(int a)\n" 11680 "{\n" 11681 " switch (a)\n" 11682 " {\n" 11683 " case 0:\n" 11684 " break;\n" 11685 " case 1:\n" 11686 " {\n" 11687 " break;\n" 11688 " }\n" 11689 " case 2:\n" 11690 " {\n" 11691 " }\n" 11692 " break;\n" 11693 " default:\n" 11694 " break;\n" 11695 " }\n" 11696 "}\n", 11697 AllmanBraceStyle); 11698 11699 verifyFormat("enum X\n" 11700 "{\n" 11701 " Y = 0,\n" 11702 "}\n", 11703 AllmanBraceStyle); 11704 verifyFormat("enum X\n" 11705 "{\n" 11706 " Y = 0\n" 11707 "}\n", 11708 AllmanBraceStyle); 11709 11710 verifyFormat("@interface BSApplicationController ()\n" 11711 "{\n" 11712 "@private\n" 11713 " id _extraIvar;\n" 11714 "}\n" 11715 "@end\n", 11716 AllmanBraceStyle); 11717 11718 verifyFormat("#ifdef _DEBUG\n" 11719 "int foo(int i = 0)\n" 11720 "#else\n" 11721 "int foo(int i = 5)\n" 11722 "#endif\n" 11723 "{\n" 11724 " return i;\n" 11725 "}", 11726 AllmanBraceStyle); 11727 11728 verifyFormat("void foo() {}\n" 11729 "void bar()\n" 11730 "#ifdef _DEBUG\n" 11731 "{\n" 11732 " foo();\n" 11733 "}\n" 11734 "#else\n" 11735 "{\n" 11736 "}\n" 11737 "#endif", 11738 AllmanBraceStyle); 11739 11740 verifyFormat("void foobar() { int i = 5; }\n" 11741 "#ifdef _DEBUG\n" 11742 "void bar() {}\n" 11743 "#else\n" 11744 "void bar() { foobar(); }\n" 11745 "#endif", 11746 AllmanBraceStyle); 11747 11748 // This shouldn't affect ObjC blocks.. 11749 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 11750 " // ...\n" 11751 " int i;\n" 11752 "}];", 11753 AllmanBraceStyle); 11754 verifyFormat("void (^block)(void) = ^{\n" 11755 " // ...\n" 11756 " int i;\n" 11757 "};", 11758 AllmanBraceStyle); 11759 // .. or dict literals. 11760 verifyFormat("void f()\n" 11761 "{\n" 11762 " // ...\n" 11763 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 11764 "}", 11765 AllmanBraceStyle); 11766 verifyFormat("void f()\n" 11767 "{\n" 11768 " // ...\n" 11769 " [object someMethod:@{a : @\"b\"}];\n" 11770 "}", 11771 AllmanBraceStyle); 11772 verifyFormat("int f()\n" 11773 "{ // comment\n" 11774 " return 42;\n" 11775 "}", 11776 AllmanBraceStyle); 11777 11778 AllmanBraceStyle.ColumnLimit = 19; 11779 verifyFormat("void f() { int i; }", AllmanBraceStyle); 11780 AllmanBraceStyle.ColumnLimit = 18; 11781 verifyFormat("void f()\n" 11782 "{\n" 11783 " int i;\n" 11784 "}", 11785 AllmanBraceStyle); 11786 AllmanBraceStyle.ColumnLimit = 80; 11787 11788 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 11789 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 11790 FormatStyle::SIS_WithoutElse; 11791 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 11792 verifyFormat("void f(bool b)\n" 11793 "{\n" 11794 " if (b)\n" 11795 " {\n" 11796 " return;\n" 11797 " }\n" 11798 "}\n", 11799 BreakBeforeBraceShortIfs); 11800 verifyFormat("void f(bool b)\n" 11801 "{\n" 11802 " if constexpr (b)\n" 11803 " {\n" 11804 " return;\n" 11805 " }\n" 11806 "}\n", 11807 BreakBeforeBraceShortIfs); 11808 verifyFormat("void f(bool b)\n" 11809 "{\n" 11810 " if CONSTEXPR (b)\n" 11811 " {\n" 11812 " return;\n" 11813 " }\n" 11814 "}\n", 11815 BreakBeforeBraceShortIfs); 11816 verifyFormat("void f(bool b)\n" 11817 "{\n" 11818 " if (b) return;\n" 11819 "}\n", 11820 BreakBeforeBraceShortIfs); 11821 verifyFormat("void f(bool b)\n" 11822 "{\n" 11823 " if constexpr (b) return;\n" 11824 "}\n", 11825 BreakBeforeBraceShortIfs); 11826 verifyFormat("void f(bool b)\n" 11827 "{\n" 11828 " if CONSTEXPR (b) return;\n" 11829 "}\n", 11830 BreakBeforeBraceShortIfs); 11831 verifyFormat("void f(bool b)\n" 11832 "{\n" 11833 " while (b)\n" 11834 " {\n" 11835 " return;\n" 11836 " }\n" 11837 "}\n", 11838 BreakBeforeBraceShortIfs); 11839 } 11840 11841 TEST_F(FormatTest, WhitesmithsBraceBreaking) { 11842 FormatStyle WhitesmithsBraceStyle = getLLVMStyle(); 11843 WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 11844 11845 // Make a few changes to the style for testing purposes 11846 WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine = 11847 FormatStyle::SFS_Empty; 11848 WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 11849 WhitesmithsBraceStyle.ColumnLimit = 0; 11850 11851 // FIXME: this test case can't decide whether there should be a blank line 11852 // after the ~D() line or not. It adds one if one doesn't exist in the test 11853 // and it removes the line if one exists. 11854 /* 11855 verifyFormat("class A;\n" 11856 "namespace B\n" 11857 " {\n" 11858 "class C;\n" 11859 "// Comment\n" 11860 "class D\n" 11861 " {\n" 11862 "public:\n" 11863 " D();\n" 11864 " ~D() {}\n" 11865 "private:\n" 11866 " enum E\n" 11867 " {\n" 11868 " F\n" 11869 " }\n" 11870 " };\n" 11871 " } // namespace B\n", 11872 WhitesmithsBraceStyle); 11873 */ 11874 11875 verifyFormat("namespace a\n" 11876 " {\n" 11877 "class A\n" 11878 " {\n" 11879 " void f()\n" 11880 " {\n" 11881 " if (true)\n" 11882 " {\n" 11883 " a();\n" 11884 " b();\n" 11885 " }\n" 11886 " }\n" 11887 " void g()\n" 11888 " {\n" 11889 " return;\n" 11890 " }\n" 11891 " };\n" 11892 "struct B\n" 11893 " {\n" 11894 " int x;\n" 11895 " };\n" 11896 " } // namespace a", 11897 WhitesmithsBraceStyle); 11898 11899 verifyFormat("void f()\n" 11900 " {\n" 11901 " if (true)\n" 11902 " {\n" 11903 " a();\n" 11904 " }\n" 11905 " else if (false)\n" 11906 " {\n" 11907 " b();\n" 11908 " }\n" 11909 " else\n" 11910 " {\n" 11911 " c();\n" 11912 " }\n" 11913 " }\n", 11914 WhitesmithsBraceStyle); 11915 11916 verifyFormat("void f()\n" 11917 " {\n" 11918 " for (int i = 0; i < 10; ++i)\n" 11919 " {\n" 11920 " a();\n" 11921 " }\n" 11922 " while (false)\n" 11923 " {\n" 11924 " b();\n" 11925 " }\n" 11926 " do\n" 11927 " {\n" 11928 " c();\n" 11929 " } while (false)\n" 11930 " }\n", 11931 WhitesmithsBraceStyle); 11932 11933 // FIXME: the block and the break under case 2 in this test don't get indented 11934 // correctly 11935 /* 11936 verifyFormat("void switchTest1(int a)\n" 11937 " {\n" 11938 " switch (a)\n" 11939 " {\n" 11940 " case 2:\n" 11941 " {\n" 11942 " }\n" 11943 " break;\n" 11944 " }\n" 11945 " }\n", 11946 WhitesmithsBraceStyle); 11947 */ 11948 11949 // FIXME: the block and the break under case 2 in this test don't get indented 11950 // correctly 11951 /* 11952 verifyFormat("void switchTest2(int a)\n" 11953 " {\n" 11954 " switch (a)\n" 11955 " {\n" 11956 " case 0:\n" 11957 " break;\n" 11958 " case 1:\n" 11959 " {\n" 11960 " break;\n" 11961 " }\n" 11962 " case 2:\n" 11963 " {\n" 11964 " }\n" 11965 " break;\n" 11966 " default:\n" 11967 " break;\n" 11968 " }\n" 11969 " }\n", 11970 WhitesmithsBraceStyle); 11971 */ 11972 11973 verifyFormat("enum X\n" 11974 " {\n" 11975 " Y = 0, // testing\n" 11976 " }\n", 11977 WhitesmithsBraceStyle); 11978 11979 verifyFormat("enum X\n" 11980 " {\n" 11981 " Y = 0\n" 11982 " }\n", 11983 WhitesmithsBraceStyle); 11984 verifyFormat("enum X\n" 11985 " {\n" 11986 " Y = 0,\n" 11987 " Z = 1\n" 11988 " };\n", 11989 WhitesmithsBraceStyle); 11990 11991 verifyFormat("@interface BSApplicationController ()\n" 11992 " {\n" 11993 "@private\n" 11994 " id _extraIvar;\n" 11995 " }\n" 11996 "@end\n", 11997 WhitesmithsBraceStyle); 11998 11999 verifyFormat("#ifdef _DEBUG\n" 12000 "int foo(int i = 0)\n" 12001 "#else\n" 12002 "int foo(int i = 5)\n" 12003 "#endif\n" 12004 " {\n" 12005 " return i;\n" 12006 " }", 12007 WhitesmithsBraceStyle); 12008 12009 verifyFormat("void foo() {}\n" 12010 "void bar()\n" 12011 "#ifdef _DEBUG\n" 12012 " {\n" 12013 " foo();\n" 12014 " }\n" 12015 "#else\n" 12016 " {\n" 12017 " }\n" 12018 "#endif", 12019 WhitesmithsBraceStyle); 12020 12021 verifyFormat("void foobar()\n" 12022 " {\n" 12023 " int i = 5;\n" 12024 " }\n" 12025 "#ifdef _DEBUG\n" 12026 "void bar()\n" 12027 " {\n" 12028 " }\n" 12029 "#else\n" 12030 "void bar()\n" 12031 " {\n" 12032 " foobar();\n" 12033 " }\n" 12034 "#endif", 12035 WhitesmithsBraceStyle); 12036 12037 // This shouldn't affect ObjC blocks.. 12038 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 12039 " // ...\n" 12040 " int i;\n" 12041 "}];", 12042 WhitesmithsBraceStyle); 12043 verifyFormat("void (^block)(void) = ^{\n" 12044 " // ...\n" 12045 " int i;\n" 12046 "};", 12047 WhitesmithsBraceStyle); 12048 // .. or dict literals. 12049 verifyFormat("void f()\n" 12050 " {\n" 12051 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 12052 " }", 12053 WhitesmithsBraceStyle); 12054 12055 verifyFormat("int f()\n" 12056 " { // comment\n" 12057 " return 42;\n" 12058 " }", 12059 WhitesmithsBraceStyle); 12060 12061 FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle; 12062 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 12063 FormatStyle::SIS_Always; 12064 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 12065 verifyFormat("void f(bool b)\n" 12066 " {\n" 12067 " if (b)\n" 12068 " {\n" 12069 " return;\n" 12070 " }\n" 12071 " }\n", 12072 BreakBeforeBraceShortIfs); 12073 verifyFormat("void f(bool b)\n" 12074 " {\n" 12075 " if (b) return;\n" 12076 " }\n", 12077 BreakBeforeBraceShortIfs); 12078 verifyFormat("void f(bool b)\n" 12079 " {\n" 12080 " while (b)\n" 12081 " {\n" 12082 " return;\n" 12083 " }\n" 12084 " }\n", 12085 BreakBeforeBraceShortIfs); 12086 } 12087 12088 TEST_F(FormatTest, GNUBraceBreaking) { 12089 FormatStyle GNUBraceStyle = getLLVMStyle(); 12090 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 12091 verifyFormat("namespace a\n" 12092 "{\n" 12093 "class A\n" 12094 "{\n" 12095 " void f()\n" 12096 " {\n" 12097 " int a;\n" 12098 " {\n" 12099 " int b;\n" 12100 " }\n" 12101 " if (true)\n" 12102 " {\n" 12103 " a();\n" 12104 " b();\n" 12105 " }\n" 12106 " }\n" 12107 " void g() { return; }\n" 12108 "}\n" 12109 "} // namespace a", 12110 GNUBraceStyle); 12111 12112 verifyFormat("void f()\n" 12113 "{\n" 12114 " if (true)\n" 12115 " {\n" 12116 " a();\n" 12117 " }\n" 12118 " else if (false)\n" 12119 " {\n" 12120 " b();\n" 12121 " }\n" 12122 " else\n" 12123 " {\n" 12124 " c();\n" 12125 " }\n" 12126 "}\n", 12127 GNUBraceStyle); 12128 12129 verifyFormat("void f()\n" 12130 "{\n" 12131 " for (int i = 0; i < 10; ++i)\n" 12132 " {\n" 12133 " a();\n" 12134 " }\n" 12135 " while (false)\n" 12136 " {\n" 12137 " b();\n" 12138 " }\n" 12139 " do\n" 12140 " {\n" 12141 " c();\n" 12142 " }\n" 12143 " while (false);\n" 12144 "}\n", 12145 GNUBraceStyle); 12146 12147 verifyFormat("void f(int a)\n" 12148 "{\n" 12149 " switch (a)\n" 12150 " {\n" 12151 " case 0:\n" 12152 " break;\n" 12153 " case 1:\n" 12154 " {\n" 12155 " break;\n" 12156 " }\n" 12157 " case 2:\n" 12158 " {\n" 12159 " }\n" 12160 " break;\n" 12161 " default:\n" 12162 " break;\n" 12163 " }\n" 12164 "}\n", 12165 GNUBraceStyle); 12166 12167 verifyFormat("enum X\n" 12168 "{\n" 12169 " Y = 0,\n" 12170 "}\n", 12171 GNUBraceStyle); 12172 12173 verifyFormat("@interface BSApplicationController ()\n" 12174 "{\n" 12175 "@private\n" 12176 " id _extraIvar;\n" 12177 "}\n" 12178 "@end\n", 12179 GNUBraceStyle); 12180 12181 verifyFormat("#ifdef _DEBUG\n" 12182 "int foo(int i = 0)\n" 12183 "#else\n" 12184 "int foo(int i = 5)\n" 12185 "#endif\n" 12186 "{\n" 12187 " return i;\n" 12188 "}", 12189 GNUBraceStyle); 12190 12191 verifyFormat("void foo() {}\n" 12192 "void bar()\n" 12193 "#ifdef _DEBUG\n" 12194 "{\n" 12195 " foo();\n" 12196 "}\n" 12197 "#else\n" 12198 "{\n" 12199 "}\n" 12200 "#endif", 12201 GNUBraceStyle); 12202 12203 verifyFormat("void foobar() { int i = 5; }\n" 12204 "#ifdef _DEBUG\n" 12205 "void bar() {}\n" 12206 "#else\n" 12207 "void bar() { foobar(); }\n" 12208 "#endif", 12209 GNUBraceStyle); 12210 } 12211 12212 TEST_F(FormatTest, WebKitBraceBreaking) { 12213 FormatStyle WebKitBraceStyle = getLLVMStyle(); 12214 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 12215 WebKitBraceStyle.FixNamespaceComments = false; 12216 verifyFormat("namespace a {\n" 12217 "class A {\n" 12218 " void f()\n" 12219 " {\n" 12220 " if (true) {\n" 12221 " a();\n" 12222 " b();\n" 12223 " }\n" 12224 " }\n" 12225 " void g() { return; }\n" 12226 "};\n" 12227 "enum E {\n" 12228 " A,\n" 12229 " // foo\n" 12230 " B,\n" 12231 " C\n" 12232 "};\n" 12233 "struct B {\n" 12234 " int x;\n" 12235 "};\n" 12236 "}\n", 12237 WebKitBraceStyle); 12238 verifyFormat("struct S {\n" 12239 " int Type;\n" 12240 " union {\n" 12241 " int x;\n" 12242 " double y;\n" 12243 " } Value;\n" 12244 " class C {\n" 12245 " MyFavoriteType Value;\n" 12246 " } Class;\n" 12247 "};\n", 12248 WebKitBraceStyle); 12249 } 12250 12251 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 12252 verifyFormat("void f() {\n" 12253 " try {\n" 12254 " } catch (const Exception &e) {\n" 12255 " }\n" 12256 "}\n", 12257 getLLVMStyle()); 12258 } 12259 12260 TEST_F(FormatTest, UnderstandsPragmas) { 12261 verifyFormat("#pragma omp reduction(| : var)"); 12262 verifyFormat("#pragma omp reduction(+ : var)"); 12263 12264 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 12265 "(including parentheses).", 12266 format("#pragma mark Any non-hyphenated or hyphenated string " 12267 "(including parentheses).")); 12268 } 12269 12270 TEST_F(FormatTest, UnderstandPragmaOption) { 12271 verifyFormat("#pragma option -C -A"); 12272 12273 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 12274 } 12275 12276 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 12277 FormatStyle Style = getLLVMStyle(); 12278 Style.ColumnLimit = 20; 12279 12280 // See PR41213 12281 EXPECT_EQ("/*\n" 12282 " *\t9012345\n" 12283 " * /8901\n" 12284 " */", 12285 format("/*\n" 12286 " *\t9012345 /8901\n" 12287 " */", 12288 Style)); 12289 EXPECT_EQ("/*\n" 12290 " *345678\n" 12291 " *\t/8901\n" 12292 " */", 12293 format("/*\n" 12294 " *345678\t/8901\n" 12295 " */", 12296 Style)); 12297 12298 verifyFormat("int a; // the\n" 12299 " // comment", 12300 Style); 12301 EXPECT_EQ("int a; /* first line\n" 12302 " * second\n" 12303 " * line third\n" 12304 " * line\n" 12305 " */", 12306 format("int a; /* first line\n" 12307 " * second\n" 12308 " * line third\n" 12309 " * line\n" 12310 " */", 12311 Style)); 12312 EXPECT_EQ("int a; // first line\n" 12313 " // second\n" 12314 " // line third\n" 12315 " // line", 12316 format("int a; // first line\n" 12317 " // second line\n" 12318 " // third line", 12319 Style)); 12320 12321 Style.PenaltyExcessCharacter = 90; 12322 verifyFormat("int a; // the comment", Style); 12323 EXPECT_EQ("int a; // the comment\n" 12324 " // aaa", 12325 format("int a; // the comment aaa", Style)); 12326 EXPECT_EQ("int a; /* first line\n" 12327 " * second line\n" 12328 " * third line\n" 12329 " */", 12330 format("int a; /* first line\n" 12331 " * second line\n" 12332 " * third line\n" 12333 " */", 12334 Style)); 12335 EXPECT_EQ("int a; // first line\n" 12336 " // second line\n" 12337 " // third line", 12338 format("int a; // first line\n" 12339 " // second line\n" 12340 " // third line", 12341 Style)); 12342 // FIXME: Investigate why this is not getting the same layout as the test 12343 // above. 12344 EXPECT_EQ("int a; /* first line\n" 12345 " * second line\n" 12346 " * third line\n" 12347 " */", 12348 format("int a; /* first line second line third line" 12349 "\n*/", 12350 Style)); 12351 12352 EXPECT_EQ("// foo bar baz bazfoo\n" 12353 "// foo bar foo bar\n", 12354 format("// foo bar baz bazfoo\n" 12355 "// foo bar foo bar\n", 12356 Style)); 12357 EXPECT_EQ("// foo bar baz bazfoo\n" 12358 "// foo bar foo bar\n", 12359 format("// foo bar baz bazfoo\n" 12360 "// foo bar foo bar\n", 12361 Style)); 12362 12363 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 12364 // next one. 12365 EXPECT_EQ("// foo bar baz bazfoo\n" 12366 "// bar foo bar\n", 12367 format("// foo bar baz bazfoo bar\n" 12368 "// foo bar\n", 12369 Style)); 12370 12371 EXPECT_EQ("// foo bar baz bazfoo\n" 12372 "// foo bar baz bazfoo\n" 12373 "// bar foo bar\n", 12374 format("// foo bar baz bazfoo\n" 12375 "// foo bar baz bazfoo bar\n" 12376 "// foo bar\n", 12377 Style)); 12378 12379 EXPECT_EQ("// foo bar baz bazfoo\n" 12380 "// foo bar baz bazfoo\n" 12381 "// bar foo bar\n", 12382 format("// foo bar baz bazfoo\n" 12383 "// foo bar baz bazfoo bar\n" 12384 "// foo bar\n", 12385 Style)); 12386 12387 // Make sure we do not keep protruding characters if strict mode reflow is 12388 // cheaper than keeping protruding characters. 12389 Style.ColumnLimit = 21; 12390 EXPECT_EQ( 12391 "// foo foo foo foo\n" 12392 "// foo foo foo foo\n" 12393 "// foo foo foo foo\n", 12394 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style)); 12395 12396 EXPECT_EQ("int a = /* long block\n" 12397 " comment */\n" 12398 " 42;", 12399 format("int a = /* long block comment */ 42;", Style)); 12400 } 12401 12402 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 12403 for (size_t i = 1; i < Styles.size(); ++i) \ 12404 EXPECT_EQ(Styles[0], Styles[i]) \ 12405 << "Style #" << i << " of " << Styles.size() << " differs from Style #0" 12406 12407 TEST_F(FormatTest, GetsPredefinedStyleByName) { 12408 SmallVector<FormatStyle, 3> Styles; 12409 Styles.resize(3); 12410 12411 Styles[0] = getLLVMStyle(); 12412 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 12413 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 12414 EXPECT_ALL_STYLES_EQUAL(Styles); 12415 12416 Styles[0] = getGoogleStyle(); 12417 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 12418 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 12419 EXPECT_ALL_STYLES_EQUAL(Styles); 12420 12421 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12422 EXPECT_TRUE( 12423 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 12424 EXPECT_TRUE( 12425 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 12426 EXPECT_ALL_STYLES_EQUAL(Styles); 12427 12428 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 12429 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 12430 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 12431 EXPECT_ALL_STYLES_EQUAL(Styles); 12432 12433 Styles[0] = getMozillaStyle(); 12434 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 12435 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 12436 EXPECT_ALL_STYLES_EQUAL(Styles); 12437 12438 Styles[0] = getWebKitStyle(); 12439 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 12440 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 12441 EXPECT_ALL_STYLES_EQUAL(Styles); 12442 12443 Styles[0] = getGNUStyle(); 12444 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 12445 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 12446 EXPECT_ALL_STYLES_EQUAL(Styles); 12447 12448 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 12449 } 12450 12451 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 12452 SmallVector<FormatStyle, 8> Styles; 12453 Styles.resize(2); 12454 12455 Styles[0] = getGoogleStyle(); 12456 Styles[1] = getLLVMStyle(); 12457 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12458 EXPECT_ALL_STYLES_EQUAL(Styles); 12459 12460 Styles.resize(5); 12461 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12462 Styles[1] = getLLVMStyle(); 12463 Styles[1].Language = FormatStyle::LK_JavaScript; 12464 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12465 12466 Styles[2] = getLLVMStyle(); 12467 Styles[2].Language = FormatStyle::LK_JavaScript; 12468 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 12469 "BasedOnStyle: Google", 12470 &Styles[2]) 12471 .value()); 12472 12473 Styles[3] = getLLVMStyle(); 12474 Styles[3].Language = FormatStyle::LK_JavaScript; 12475 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 12476 "Language: JavaScript", 12477 &Styles[3]) 12478 .value()); 12479 12480 Styles[4] = getLLVMStyle(); 12481 Styles[4].Language = FormatStyle::LK_JavaScript; 12482 EXPECT_EQ(0, parseConfiguration("---\n" 12483 "BasedOnStyle: LLVM\n" 12484 "IndentWidth: 123\n" 12485 "---\n" 12486 "BasedOnStyle: Google\n" 12487 "Language: JavaScript", 12488 &Styles[4]) 12489 .value()); 12490 EXPECT_ALL_STYLES_EQUAL(Styles); 12491 } 12492 12493 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 12494 Style.FIELD = false; \ 12495 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 12496 EXPECT_TRUE(Style.FIELD); \ 12497 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 12498 EXPECT_FALSE(Style.FIELD); 12499 12500 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 12501 12502 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 12503 Style.STRUCT.FIELD = false; \ 12504 EXPECT_EQ(0, \ 12505 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 12506 .value()); \ 12507 EXPECT_TRUE(Style.STRUCT.FIELD); \ 12508 EXPECT_EQ(0, \ 12509 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 12510 .value()); \ 12511 EXPECT_FALSE(Style.STRUCT.FIELD); 12512 12513 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 12514 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 12515 12516 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 12517 EXPECT_NE(VALUE, Style.FIELD); \ 12518 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 12519 EXPECT_EQ(VALUE, Style.FIELD) 12520 12521 TEST_F(FormatTest, ParsesConfigurationBools) { 12522 FormatStyle Style = {}; 12523 Style.Language = FormatStyle::LK_Cpp; 12524 CHECK_PARSE_BOOL(AlignOperands); 12525 CHECK_PARSE_BOOL(AlignTrailingComments); 12526 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 12527 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 12528 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 12529 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 12530 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 12531 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 12532 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 12533 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 12534 CHECK_PARSE_BOOL(BinPackArguments); 12535 CHECK_PARSE_BOOL(BinPackParameters); 12536 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 12537 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 12538 CHECK_PARSE_BOOL(BreakStringLiterals); 12539 CHECK_PARSE_BOOL(CompactNamespaces); 12540 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 12541 CHECK_PARSE_BOOL(DeriveLineEnding); 12542 CHECK_PARSE_BOOL(DerivePointerAlignment); 12543 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 12544 CHECK_PARSE_BOOL(DisableFormat); 12545 CHECK_PARSE_BOOL(IndentCaseLabels); 12546 CHECK_PARSE_BOOL(IndentGotoLabels); 12547 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 12548 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 12549 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 12550 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 12551 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 12552 CHECK_PARSE_BOOL(ReflowComments); 12553 CHECK_PARSE_BOOL(SortIncludes); 12554 CHECK_PARSE_BOOL(SortUsingDeclarations); 12555 CHECK_PARSE_BOOL(SpacesInParentheses); 12556 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 12557 CHECK_PARSE_BOOL(SpacesInAngles); 12558 CHECK_PARSE_BOOL(SpacesInConditionalStatement); 12559 CHECK_PARSE_BOOL(SpaceInEmptyBlock); 12560 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 12561 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 12562 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 12563 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 12564 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 12565 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 12566 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 12567 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 12568 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 12569 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 12570 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 12571 CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets); 12572 CHECK_PARSE_BOOL(UseCRLF); 12573 12574 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 12575 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 12576 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 12577 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 12578 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 12579 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 12580 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 12581 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 12582 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 12583 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 12584 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 12585 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 12586 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 12587 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 12588 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 12589 } 12590 12591 #undef CHECK_PARSE_BOOL 12592 12593 TEST_F(FormatTest, ParsesConfiguration) { 12594 FormatStyle Style = {}; 12595 Style.Language = FormatStyle::LK_Cpp; 12596 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 12597 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 12598 ConstructorInitializerIndentWidth, 1234u); 12599 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 12600 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 12601 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 12602 CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u); 12603 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 12604 PenaltyBreakBeforeFirstCallParameter, 1234u); 12605 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 12606 PenaltyBreakTemplateDeclaration, 1234u); 12607 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 12608 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 12609 PenaltyReturnTypeOnItsOwnLine, 1234u); 12610 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 12611 SpacesBeforeTrailingComments, 1234u); 12612 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 12613 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 12614 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 12615 12616 Style.PointerAlignment = FormatStyle::PAS_Middle; 12617 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 12618 FormatStyle::PAS_Left); 12619 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 12620 FormatStyle::PAS_Right); 12621 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 12622 FormatStyle::PAS_Middle); 12623 // For backward compatibility: 12624 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 12625 FormatStyle::PAS_Left); 12626 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 12627 FormatStyle::PAS_Right); 12628 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 12629 FormatStyle::PAS_Middle); 12630 12631 Style.Standard = FormatStyle::LS_Auto; 12632 CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03); 12633 CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11); 12634 CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14); 12635 CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17); 12636 CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20); 12637 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 12638 CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest); 12639 // Legacy aliases: 12640 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 12641 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest); 12642 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 12643 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 12644 12645 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 12646 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 12647 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 12648 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 12649 FormatStyle::BOS_None); 12650 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 12651 FormatStyle::BOS_All); 12652 // For backward compatibility: 12653 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 12654 FormatStyle::BOS_None); 12655 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 12656 FormatStyle::BOS_All); 12657 12658 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 12659 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 12660 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 12661 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 12662 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 12663 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 12664 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 12665 // For backward compatibility: 12666 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 12667 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 12668 12669 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 12670 CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList, 12671 FormatStyle::BILS_BeforeComma); 12672 CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList, 12673 FormatStyle::BILS_AfterColon); 12674 CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList, 12675 FormatStyle::BILS_BeforeColon); 12676 // For backward compatibility: 12677 CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList, 12678 FormatStyle::BILS_BeforeComma); 12679 12680 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 12681 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 12682 FormatStyle::BAS_Align); 12683 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 12684 FormatStyle::BAS_DontAlign); 12685 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 12686 FormatStyle::BAS_AlwaysBreak); 12687 // For backward compatibility: 12688 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 12689 FormatStyle::BAS_DontAlign); 12690 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 12691 FormatStyle::BAS_Align); 12692 12693 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 12694 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 12695 FormatStyle::ENAS_DontAlign); 12696 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 12697 FormatStyle::ENAS_Left); 12698 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 12699 FormatStyle::ENAS_Right); 12700 // For backward compatibility: 12701 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 12702 FormatStyle::ENAS_Left); 12703 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 12704 FormatStyle::ENAS_Right); 12705 12706 Style.UseTab = FormatStyle::UT_ForIndentation; 12707 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 12708 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 12709 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 12710 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 12711 FormatStyle::UT_ForContinuationAndIndentation); 12712 // For backward compatibility: 12713 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 12714 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 12715 12716 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 12717 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never", 12718 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12719 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty", 12720 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty); 12721 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always", 12722 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12723 // For backward compatibility: 12724 CHECK_PARSE("AllowShortBlocksOnASingleLine: false", 12725 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12726 CHECK_PARSE("AllowShortBlocksOnASingleLine: true", 12727 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12728 12729 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 12730 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 12731 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12732 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 12733 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 12734 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 12735 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 12736 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 12737 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12738 // For backward compatibility: 12739 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 12740 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12741 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 12742 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12743 12744 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 12745 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 12746 FormatStyle::SBPO_Never); 12747 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 12748 FormatStyle::SBPO_Always); 12749 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 12750 FormatStyle::SBPO_ControlStatements); 12751 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 12752 FormatStyle::SBPO_NonEmptyParentheses); 12753 // For backward compatibility: 12754 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 12755 FormatStyle::SBPO_Never); 12756 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 12757 FormatStyle::SBPO_ControlStatements); 12758 12759 Style.ColumnLimit = 123; 12760 FormatStyle BaseStyle = getLLVMStyle(); 12761 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 12762 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 12763 12764 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 12765 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 12766 FormatStyle::BS_Attach); 12767 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 12768 FormatStyle::BS_Linux); 12769 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 12770 FormatStyle::BS_Mozilla); 12771 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 12772 FormatStyle::BS_Stroustrup); 12773 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 12774 FormatStyle::BS_Allman); 12775 CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces, 12776 FormatStyle::BS_Whitesmiths); 12777 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 12778 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 12779 FormatStyle::BS_WebKit); 12780 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 12781 FormatStyle::BS_Custom); 12782 12783 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never; 12784 CHECK_PARSE("BraceWrapping:\n" 12785 " AfterControlStatement: MultiLine", 12786 BraceWrapping.AfterControlStatement, 12787 FormatStyle::BWACS_MultiLine); 12788 CHECK_PARSE("BraceWrapping:\n" 12789 " AfterControlStatement: Always", 12790 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 12791 CHECK_PARSE("BraceWrapping:\n" 12792 " AfterControlStatement: Never", 12793 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 12794 // For backward compatibility: 12795 CHECK_PARSE("BraceWrapping:\n" 12796 " AfterControlStatement: true", 12797 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 12798 CHECK_PARSE("BraceWrapping:\n" 12799 " AfterControlStatement: false", 12800 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 12801 12802 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 12803 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 12804 FormatStyle::RTBS_None); 12805 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 12806 FormatStyle::RTBS_All); 12807 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 12808 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 12809 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 12810 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 12811 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 12812 AlwaysBreakAfterReturnType, 12813 FormatStyle::RTBS_TopLevelDefinitions); 12814 12815 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 12816 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", 12817 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No); 12818 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", 12819 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 12820 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", 12821 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 12822 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", 12823 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 12824 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", 12825 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 12826 12827 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 12828 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 12829 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 12830 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 12831 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 12832 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 12833 AlwaysBreakAfterDefinitionReturnType, 12834 FormatStyle::DRTBS_TopLevel); 12835 12836 Style.NamespaceIndentation = FormatStyle::NI_All; 12837 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 12838 FormatStyle::NI_None); 12839 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 12840 FormatStyle::NI_Inner); 12841 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 12842 FormatStyle::NI_All); 12843 12844 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 12845 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 12846 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12847 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 12848 AllowShortIfStatementsOnASingleLine, 12849 FormatStyle::SIS_WithoutElse); 12850 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 12851 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 12852 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 12853 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12854 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 12855 AllowShortIfStatementsOnASingleLine, 12856 FormatStyle::SIS_WithoutElse); 12857 12858 // FIXME: This is required because parsing a configuration simply overwrites 12859 // the first N elements of the list instead of resetting it. 12860 Style.ForEachMacros.clear(); 12861 std::vector<std::string> BoostForeach; 12862 BoostForeach.push_back("BOOST_FOREACH"); 12863 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 12864 std::vector<std::string> BoostAndQForeach; 12865 BoostAndQForeach.push_back("BOOST_FOREACH"); 12866 BoostAndQForeach.push_back("Q_FOREACH"); 12867 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 12868 BoostAndQForeach); 12869 12870 Style.StatementMacros.clear(); 12871 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 12872 std::vector<std::string>{"QUNUSED"}); 12873 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 12874 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 12875 12876 Style.NamespaceMacros.clear(); 12877 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 12878 std::vector<std::string>{"TESTSUITE"}); 12879 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 12880 std::vector<std::string>({"TESTSUITE", "SUITE"})); 12881 12882 Style.IncludeStyle.IncludeCategories.clear(); 12883 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 12884 {"abc/.*", 2, 0}, {".*", 1, 0}}; 12885 CHECK_PARSE("IncludeCategories:\n" 12886 " - Regex: abc/.*\n" 12887 " Priority: 2\n" 12888 " - Regex: .*\n" 12889 " Priority: 1", 12890 IncludeStyle.IncludeCategories, ExpectedCategories); 12891 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 12892 "abc$"); 12893 CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'", 12894 IncludeStyle.IncludeIsMainSourceRegex, "abc$"); 12895 12896 Style.RawStringFormats.clear(); 12897 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 12898 { 12899 FormatStyle::LK_TextProto, 12900 {"pb", "proto"}, 12901 {"PARSE_TEXT_PROTO"}, 12902 /*CanonicalDelimiter=*/"", 12903 "llvm", 12904 }, 12905 { 12906 FormatStyle::LK_Cpp, 12907 {"cc", "cpp"}, 12908 {"C_CODEBLOCK", "CPPEVAL"}, 12909 /*CanonicalDelimiter=*/"cc", 12910 /*BasedOnStyle=*/"", 12911 }, 12912 }; 12913 12914 CHECK_PARSE("RawStringFormats:\n" 12915 " - Language: TextProto\n" 12916 " Delimiters:\n" 12917 " - 'pb'\n" 12918 " - 'proto'\n" 12919 " EnclosingFunctions:\n" 12920 " - 'PARSE_TEXT_PROTO'\n" 12921 " BasedOnStyle: llvm\n" 12922 " - Language: Cpp\n" 12923 " Delimiters:\n" 12924 " - 'cc'\n" 12925 " - 'cpp'\n" 12926 " EnclosingFunctions:\n" 12927 " - 'C_CODEBLOCK'\n" 12928 " - 'CPPEVAL'\n" 12929 " CanonicalDelimiter: 'cc'", 12930 RawStringFormats, ExpectedRawStringFormats); 12931 } 12932 12933 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 12934 FormatStyle Style = {}; 12935 Style.Language = FormatStyle::LK_Cpp; 12936 CHECK_PARSE("Language: Cpp\n" 12937 "IndentWidth: 12", 12938 IndentWidth, 12u); 12939 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 12940 "IndentWidth: 34", 12941 &Style), 12942 ParseError::Unsuitable); 12943 EXPECT_EQ(12u, Style.IndentWidth); 12944 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12945 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 12946 12947 Style.Language = FormatStyle::LK_JavaScript; 12948 CHECK_PARSE("Language: JavaScript\n" 12949 "IndentWidth: 12", 12950 IndentWidth, 12u); 12951 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 12952 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 12953 "IndentWidth: 34", 12954 &Style), 12955 ParseError::Unsuitable); 12956 EXPECT_EQ(23u, Style.IndentWidth); 12957 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 12958 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 12959 12960 CHECK_PARSE("BasedOnStyle: LLVM\n" 12961 "IndentWidth: 67", 12962 IndentWidth, 67u); 12963 12964 CHECK_PARSE("---\n" 12965 "Language: JavaScript\n" 12966 "IndentWidth: 12\n" 12967 "---\n" 12968 "Language: Cpp\n" 12969 "IndentWidth: 34\n" 12970 "...\n", 12971 IndentWidth, 12u); 12972 12973 Style.Language = FormatStyle::LK_Cpp; 12974 CHECK_PARSE("---\n" 12975 "Language: JavaScript\n" 12976 "IndentWidth: 12\n" 12977 "---\n" 12978 "Language: Cpp\n" 12979 "IndentWidth: 34\n" 12980 "...\n", 12981 IndentWidth, 34u); 12982 CHECK_PARSE("---\n" 12983 "IndentWidth: 78\n" 12984 "---\n" 12985 "Language: JavaScript\n" 12986 "IndentWidth: 56\n" 12987 "...\n", 12988 IndentWidth, 78u); 12989 12990 Style.ColumnLimit = 123; 12991 Style.IndentWidth = 234; 12992 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 12993 Style.TabWidth = 345; 12994 EXPECT_FALSE(parseConfiguration("---\n" 12995 "IndentWidth: 456\n" 12996 "BreakBeforeBraces: Allman\n" 12997 "---\n" 12998 "Language: JavaScript\n" 12999 "IndentWidth: 111\n" 13000 "TabWidth: 111\n" 13001 "---\n" 13002 "Language: Cpp\n" 13003 "BreakBeforeBraces: Stroustrup\n" 13004 "TabWidth: 789\n" 13005 "...\n", 13006 &Style)); 13007 EXPECT_EQ(123u, Style.ColumnLimit); 13008 EXPECT_EQ(456u, Style.IndentWidth); 13009 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 13010 EXPECT_EQ(789u, Style.TabWidth); 13011 13012 EXPECT_EQ(parseConfiguration("---\n" 13013 "Language: JavaScript\n" 13014 "IndentWidth: 56\n" 13015 "---\n" 13016 "IndentWidth: 78\n" 13017 "...\n", 13018 &Style), 13019 ParseError::Error); 13020 EXPECT_EQ(parseConfiguration("---\n" 13021 "Language: JavaScript\n" 13022 "IndentWidth: 56\n" 13023 "---\n" 13024 "Language: JavaScript\n" 13025 "IndentWidth: 78\n" 13026 "...\n", 13027 &Style), 13028 ParseError::Error); 13029 13030 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 13031 } 13032 13033 #undef CHECK_PARSE 13034 13035 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 13036 FormatStyle Style = {}; 13037 Style.Language = FormatStyle::LK_JavaScript; 13038 Style.BreakBeforeTernaryOperators = true; 13039 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 13040 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 13041 13042 Style.BreakBeforeTernaryOperators = true; 13043 EXPECT_EQ(0, parseConfiguration("---\n" 13044 "BasedOnStyle: Google\n" 13045 "---\n" 13046 "Language: JavaScript\n" 13047 "IndentWidth: 76\n" 13048 "...\n", 13049 &Style) 13050 .value()); 13051 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 13052 EXPECT_EQ(76u, Style.IndentWidth); 13053 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 13054 } 13055 13056 TEST_F(FormatTest, ConfigurationRoundTripTest) { 13057 FormatStyle Style = getLLVMStyle(); 13058 std::string YAML = configurationAsText(Style); 13059 FormatStyle ParsedStyle = {}; 13060 ParsedStyle.Language = FormatStyle::LK_Cpp; 13061 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 13062 EXPECT_EQ(Style, ParsedStyle); 13063 } 13064 13065 TEST_F(FormatTest, WorksFor8bitEncodings) { 13066 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 13067 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 13068 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 13069 "\"\xef\xee\xf0\xf3...\"", 13070 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 13071 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 13072 "\xef\xee\xf0\xf3...\"", 13073 getLLVMStyleWithColumns(12))); 13074 } 13075 13076 TEST_F(FormatTest, HandlesUTF8BOM) { 13077 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 13078 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 13079 format("\xef\xbb\xbf#include <iostream>")); 13080 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 13081 format("\xef\xbb\xbf\n#include <iostream>")); 13082 } 13083 13084 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 13085 #if !defined(_MSC_VER) 13086 13087 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 13088 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 13089 getLLVMStyleWithColumns(35)); 13090 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 13091 getLLVMStyleWithColumns(31)); 13092 verifyFormat("// Однажды в студёную зимнюю пору...", 13093 getLLVMStyleWithColumns(36)); 13094 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 13095 verifyFormat("/* Однажды в студёную зимнюю пору... */", 13096 getLLVMStyleWithColumns(39)); 13097 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 13098 getLLVMStyleWithColumns(35)); 13099 } 13100 13101 TEST_F(FormatTest, SplitsUTF8Strings) { 13102 // Non-printable characters' width is currently considered to be the length in 13103 // bytes in UTF8. The characters can be displayed in very different manner 13104 // (zero-width, single width with a substitution glyph, expanded to their code 13105 // (e.g. "<8d>"), so there's no single correct way to handle them. 13106 EXPECT_EQ("\"aaaaÄ\"\n" 13107 "\"\xc2\x8d\";", 13108 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13109 EXPECT_EQ("\"aaaaaaaÄ\"\n" 13110 "\"\xc2\x8d\";", 13111 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13112 EXPECT_EQ("\"Однажды, в \"\n" 13113 "\"студёную \"\n" 13114 "\"зимнюю \"\n" 13115 "\"пору,\"", 13116 format("\"Однажды, в студёную зимнюю пору,\"", 13117 getLLVMStyleWithColumns(13))); 13118 EXPECT_EQ( 13119 "\"一 二 三 \"\n" 13120 "\"四 五六 \"\n" 13121 "\"七 八 九 \"\n" 13122 "\"十\"", 13123 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 13124 EXPECT_EQ("\"一\t\"\n" 13125 "\"二 \t\"\n" 13126 "\"三 四 \"\n" 13127 "\"五\t\"\n" 13128 "\"六 \t\"\n" 13129 "\"七 \"\n" 13130 "\"八九十\tqq\"", 13131 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 13132 getLLVMStyleWithColumns(11))); 13133 13134 // UTF8 character in an escape sequence. 13135 EXPECT_EQ("\"aaaaaa\"\n" 13136 "\"\\\xC2\x8D\"", 13137 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 13138 } 13139 13140 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 13141 EXPECT_EQ("const char *sssss =\n" 13142 " \"一二三四五六七八\\\n" 13143 " 九 十\";", 13144 format("const char *sssss = \"一二三四五六七八\\\n" 13145 " 九 十\";", 13146 getLLVMStyleWithColumns(30))); 13147 } 13148 13149 TEST_F(FormatTest, SplitsUTF8LineComments) { 13150 EXPECT_EQ("// aaaaÄ\xc2\x8d", 13151 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 13152 EXPECT_EQ("// Я из лесу\n" 13153 "// вышел; был\n" 13154 "// сильный\n" 13155 "// мороз.", 13156 format("// Я из лесу вышел; был сильный мороз.", 13157 getLLVMStyleWithColumns(13))); 13158 EXPECT_EQ("// 一二三\n" 13159 "// 四五六七\n" 13160 "// 八 九\n" 13161 "// 十", 13162 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 13163 } 13164 13165 TEST_F(FormatTest, SplitsUTF8BlockComments) { 13166 EXPECT_EQ("/* Гляжу,\n" 13167 " * поднимается\n" 13168 " * медленно в\n" 13169 " * гору\n" 13170 " * Лошадка,\n" 13171 " * везущая\n" 13172 " * хворосту\n" 13173 " * воз. */", 13174 format("/* Гляжу, поднимается медленно в гору\n" 13175 " * Лошадка, везущая хворосту воз. */", 13176 getLLVMStyleWithColumns(13))); 13177 EXPECT_EQ( 13178 "/* 一二三\n" 13179 " * 四五六七\n" 13180 " * 八 九\n" 13181 " * 十 */", 13182 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 13183 EXPECT_EQ("/* �������� ��������\n" 13184 " * ��������\n" 13185 " * ������-�� */", 13186 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 13187 } 13188 13189 #endif // _MSC_VER 13190 13191 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 13192 FormatStyle Style = getLLVMStyle(); 13193 13194 Style.ConstructorInitializerIndentWidth = 4; 13195 verifyFormat( 13196 "SomeClass::Constructor()\n" 13197 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13198 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13199 Style); 13200 13201 Style.ConstructorInitializerIndentWidth = 2; 13202 verifyFormat( 13203 "SomeClass::Constructor()\n" 13204 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13205 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13206 Style); 13207 13208 Style.ConstructorInitializerIndentWidth = 0; 13209 verifyFormat( 13210 "SomeClass::Constructor()\n" 13211 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13212 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13213 Style); 13214 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 13215 verifyFormat( 13216 "SomeLongTemplateVariableName<\n" 13217 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 13218 Style); 13219 verifyFormat("bool smaller = 1 < " 13220 "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 13221 " " 13222 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 13223 Style); 13224 13225 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 13226 verifyFormat("SomeClass::Constructor() :\n" 13227 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 13228 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 13229 Style); 13230 } 13231 13232 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 13233 FormatStyle Style = getLLVMStyle(); 13234 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 13235 Style.ConstructorInitializerIndentWidth = 4; 13236 verifyFormat("SomeClass::Constructor()\n" 13237 " : a(a)\n" 13238 " , b(b)\n" 13239 " , c(c) {}", 13240 Style); 13241 verifyFormat("SomeClass::Constructor()\n" 13242 " : a(a) {}", 13243 Style); 13244 13245 Style.ColumnLimit = 0; 13246 verifyFormat("SomeClass::Constructor()\n" 13247 " : a(a) {}", 13248 Style); 13249 verifyFormat("SomeClass::Constructor() noexcept\n" 13250 " : a(a) {}", 13251 Style); 13252 verifyFormat("SomeClass::Constructor()\n" 13253 " : a(a)\n" 13254 " , b(b)\n" 13255 " , c(c) {}", 13256 Style); 13257 verifyFormat("SomeClass::Constructor()\n" 13258 " : a(a) {\n" 13259 " foo();\n" 13260 " bar();\n" 13261 "}", 13262 Style); 13263 13264 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 13265 verifyFormat("SomeClass::Constructor()\n" 13266 " : a(a)\n" 13267 " , b(b)\n" 13268 " , c(c) {\n}", 13269 Style); 13270 verifyFormat("SomeClass::Constructor()\n" 13271 " : a(a) {\n}", 13272 Style); 13273 13274 Style.ColumnLimit = 80; 13275 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 13276 Style.ConstructorInitializerIndentWidth = 2; 13277 verifyFormat("SomeClass::Constructor()\n" 13278 " : a(a)\n" 13279 " , b(b)\n" 13280 " , c(c) {}", 13281 Style); 13282 13283 Style.ConstructorInitializerIndentWidth = 0; 13284 verifyFormat("SomeClass::Constructor()\n" 13285 ": a(a)\n" 13286 ", b(b)\n" 13287 ", c(c) {}", 13288 Style); 13289 13290 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 13291 Style.ConstructorInitializerIndentWidth = 4; 13292 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 13293 verifyFormat( 13294 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 13295 Style); 13296 verifyFormat( 13297 "SomeClass::Constructor()\n" 13298 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 13299 Style); 13300 Style.ConstructorInitializerIndentWidth = 4; 13301 Style.ColumnLimit = 60; 13302 verifyFormat("SomeClass::Constructor()\n" 13303 " : aaaaaaaa(aaaaaaaa)\n" 13304 " , aaaaaaaa(aaaaaaaa)\n" 13305 " , aaaaaaaa(aaaaaaaa) {}", 13306 Style); 13307 } 13308 13309 TEST_F(FormatTest, Destructors) { 13310 verifyFormat("void F(int &i) { i.~int(); }"); 13311 verifyFormat("void F(int &i) { i->~int(); }"); 13312 } 13313 13314 TEST_F(FormatTest, FormatsWithWebKitStyle) { 13315 FormatStyle Style = getWebKitStyle(); 13316 13317 // Don't indent in outer namespaces. 13318 verifyFormat("namespace outer {\n" 13319 "int i;\n" 13320 "namespace inner {\n" 13321 " int i;\n" 13322 "} // namespace inner\n" 13323 "} // namespace outer\n" 13324 "namespace other_outer {\n" 13325 "int i;\n" 13326 "}", 13327 Style); 13328 13329 // Don't indent case labels. 13330 verifyFormat("switch (variable) {\n" 13331 "case 1:\n" 13332 "case 2:\n" 13333 " doSomething();\n" 13334 " break;\n" 13335 "default:\n" 13336 " ++variable;\n" 13337 "}", 13338 Style); 13339 13340 // Wrap before binary operators. 13341 EXPECT_EQ("void f()\n" 13342 "{\n" 13343 " if (aaaaaaaaaaaaaaaa\n" 13344 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 13345 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13346 " return;\n" 13347 "}", 13348 format("void f() {\n" 13349 "if (aaaaaaaaaaaaaaaa\n" 13350 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 13351 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13352 "return;\n" 13353 "}", 13354 Style)); 13355 13356 // Allow functions on a single line. 13357 verifyFormat("void f() { return; }", Style); 13358 13359 // Allow empty blocks on a single line and insert a space in empty blocks. 13360 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 13361 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 13362 // However, don't merge non-empty short loops. 13363 EXPECT_EQ("while (true) {\n" 13364 " continue;\n" 13365 "}", 13366 format("while (true) { continue; }", Style)); 13367 13368 // Constructor initializers are formatted one per line with the "," on the 13369 // new line. 13370 verifyFormat("Constructor()\n" 13371 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 13372 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 13373 " aaaaaaaaaaaaaa)\n" 13374 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 13375 "{\n" 13376 "}", 13377 Style); 13378 verifyFormat("SomeClass::Constructor()\n" 13379 " : a(a)\n" 13380 "{\n" 13381 "}", 13382 Style); 13383 EXPECT_EQ("SomeClass::Constructor()\n" 13384 " : a(a)\n" 13385 "{\n" 13386 "}", 13387 format("SomeClass::Constructor():a(a){}", Style)); 13388 verifyFormat("SomeClass::Constructor()\n" 13389 " : a(a)\n" 13390 " , b(b)\n" 13391 " , c(c)\n" 13392 "{\n" 13393 "}", 13394 Style); 13395 verifyFormat("SomeClass::Constructor()\n" 13396 " : a(a)\n" 13397 "{\n" 13398 " foo();\n" 13399 " bar();\n" 13400 "}", 13401 Style); 13402 13403 // Access specifiers should be aligned left. 13404 verifyFormat("class C {\n" 13405 "public:\n" 13406 " int i;\n" 13407 "};", 13408 Style); 13409 13410 // Do not align comments. 13411 verifyFormat("int a; // Do not\n" 13412 "double b; // align comments.", 13413 Style); 13414 13415 // Do not align operands. 13416 EXPECT_EQ("ASSERT(aaaa\n" 13417 " || bbbb);", 13418 format("ASSERT ( aaaa\n||bbbb);", Style)); 13419 13420 // Accept input's line breaks. 13421 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 13422 " || bbbbbbbbbbbbbbb) {\n" 13423 " i++;\n" 13424 "}", 13425 format("if (aaaaaaaaaaaaaaa\n" 13426 "|| bbbbbbbbbbbbbbb) { i++; }", 13427 Style)); 13428 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 13429 " i++;\n" 13430 "}", 13431 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 13432 13433 // Don't automatically break all macro definitions (llvm.org/PR17842). 13434 verifyFormat("#define aNumber 10", Style); 13435 // However, generally keep the line breaks that the user authored. 13436 EXPECT_EQ("#define aNumber \\\n" 13437 " 10", 13438 format("#define aNumber \\\n" 13439 " 10", 13440 Style)); 13441 13442 // Keep empty and one-element array literals on a single line. 13443 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 13444 " copyItems:YES];", 13445 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 13446 "copyItems:YES];", 13447 Style)); 13448 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 13449 " copyItems:YES];", 13450 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 13451 " copyItems:YES];", 13452 Style)); 13453 // FIXME: This does not seem right, there should be more indentation before 13454 // the array literal's entries. Nested blocks have the same problem. 13455 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13456 " @\"a\",\n" 13457 " @\"a\"\n" 13458 "]\n" 13459 " copyItems:YES];", 13460 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13461 " @\"a\",\n" 13462 " @\"a\"\n" 13463 " ]\n" 13464 " copyItems:YES];", 13465 Style)); 13466 EXPECT_EQ( 13467 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13468 " copyItems:YES];", 13469 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13470 " copyItems:YES];", 13471 Style)); 13472 13473 verifyFormat("[self.a b:c c:d];", Style); 13474 EXPECT_EQ("[self.a b:c\n" 13475 " c:d];", 13476 format("[self.a b:c\n" 13477 "c:d];", 13478 Style)); 13479 } 13480 13481 TEST_F(FormatTest, FormatsLambdas) { 13482 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 13483 verifyFormat( 13484 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 13485 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 13486 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 13487 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 13488 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 13489 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 13490 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 13491 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 13492 verifyFormat("int x = f(*+[] {});"); 13493 verifyFormat("void f() {\n" 13494 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 13495 "}\n"); 13496 verifyFormat("void f() {\n" 13497 " other(x.begin(), //\n" 13498 " x.end(), //\n" 13499 " [&](int, int) { return 1; });\n" 13500 "}\n"); 13501 verifyFormat("void f() {\n" 13502 " other.other.other.other.other(\n" 13503 " x.begin(), x.end(),\n" 13504 " [something, rather](int, int, int, int, int, int, int) { " 13505 "return 1; });\n" 13506 "}\n"); 13507 verifyFormat( 13508 "void f() {\n" 13509 " other.other.other.other.other(\n" 13510 " x.begin(), x.end(),\n" 13511 " [something, rather](int, int, int, int, int, int, int) {\n" 13512 " //\n" 13513 " });\n" 13514 "}\n"); 13515 verifyFormat("SomeFunction([]() { // A cool function...\n" 13516 " return 43;\n" 13517 "});"); 13518 EXPECT_EQ("SomeFunction([]() {\n" 13519 "#define A a\n" 13520 " return 43;\n" 13521 "});", 13522 format("SomeFunction([](){\n" 13523 "#define A a\n" 13524 "return 43;\n" 13525 "});")); 13526 verifyFormat("void f() {\n" 13527 " SomeFunction([](decltype(x), A *a) {});\n" 13528 "}"); 13529 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13530 " [](const aaaaaaaaaa &a) { return a; });"); 13531 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 13532 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 13533 "});"); 13534 verifyFormat("Constructor()\n" 13535 " : Field([] { // comment\n" 13536 " int i;\n" 13537 " }) {}"); 13538 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 13539 " return some_parameter.size();\n" 13540 "};"); 13541 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 13542 " [](const string &s) { return s; };"); 13543 verifyFormat("int i = aaaaaa ? 1 //\n" 13544 " : [] {\n" 13545 " return 2; //\n" 13546 " }();"); 13547 verifyFormat("llvm::errs() << \"number of twos is \"\n" 13548 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 13549 " return x == 2; // force break\n" 13550 " });"); 13551 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13552 " [=](int iiiiiiiiiiii) {\n" 13553 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 13554 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 13555 " });", 13556 getLLVMStyleWithColumns(60)); 13557 verifyFormat("SomeFunction({[&] {\n" 13558 " // comment\n" 13559 " },\n" 13560 " [&] {\n" 13561 " // comment\n" 13562 " }});"); 13563 verifyFormat("SomeFunction({[&] {\n" 13564 " // comment\n" 13565 "}});"); 13566 verifyFormat( 13567 "virtual aaaaaaaaaaaaaaaa(\n" 13568 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 13569 " aaaaa aaaaaaaaa);"); 13570 13571 // Lambdas with return types. 13572 verifyFormat("int c = []() -> int { return 2; }();\n"); 13573 verifyFormat("int c = []() -> int * { return 2; }();\n"); 13574 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 13575 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 13576 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 13577 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 13578 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 13579 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 13580 verifyFormat("[a, a]() -> a<1> {};"); 13581 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 13582 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 13583 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 13584 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 13585 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 13586 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 13587 verifyFormat("[]() -> foo<!5> { return {}; };"); 13588 verifyFormat("[]() -> foo<~5> { return {}; };"); 13589 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 13590 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 13591 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 13592 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 13593 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 13594 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 13595 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 13596 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 13597 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 13598 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 13599 verifyFormat("namespace bar {\n" 13600 "// broken:\n" 13601 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 13602 "} // namespace bar"); 13603 verifyFormat("namespace bar {\n" 13604 "// broken:\n" 13605 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 13606 "} // namespace bar"); 13607 verifyFormat("namespace bar {\n" 13608 "// broken:\n" 13609 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 13610 "} // namespace bar"); 13611 verifyFormat("namespace bar {\n" 13612 "// broken:\n" 13613 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 13614 "} // namespace bar"); 13615 verifyFormat("namespace bar {\n" 13616 "// broken:\n" 13617 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 13618 "} // namespace bar"); 13619 verifyFormat("namespace bar {\n" 13620 "// broken:\n" 13621 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 13622 "} // namespace bar"); 13623 verifyFormat("namespace bar {\n" 13624 "// broken:\n" 13625 "auto foo{[]() -> foo<!5> { return {}; }};\n" 13626 "} // namespace bar"); 13627 verifyFormat("namespace bar {\n" 13628 "// broken:\n" 13629 "auto foo{[]() -> foo<~5> { return {}; }};\n" 13630 "} // namespace bar"); 13631 verifyFormat("namespace bar {\n" 13632 "// broken:\n" 13633 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 13634 "} // namespace bar"); 13635 verifyFormat("namespace bar {\n" 13636 "// broken:\n" 13637 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 13638 "} // namespace bar"); 13639 verifyFormat("namespace bar {\n" 13640 "// broken:\n" 13641 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 13642 "} // namespace bar"); 13643 verifyFormat("namespace bar {\n" 13644 "// broken:\n" 13645 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 13646 "} // namespace bar"); 13647 verifyFormat("namespace bar {\n" 13648 "// broken:\n" 13649 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 13650 "} // namespace bar"); 13651 verifyFormat("namespace bar {\n" 13652 "// broken:\n" 13653 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 13654 "} // namespace bar"); 13655 verifyFormat("namespace bar {\n" 13656 "// broken:\n" 13657 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 13658 "} // namespace bar"); 13659 verifyFormat("namespace bar {\n" 13660 "// broken:\n" 13661 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 13662 "} // namespace bar"); 13663 verifyFormat("namespace bar {\n" 13664 "// broken:\n" 13665 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 13666 "} // namespace bar"); 13667 verifyFormat("namespace bar {\n" 13668 "// broken:\n" 13669 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 13670 "} // namespace bar"); 13671 verifyFormat("[]() -> a<1> {};"); 13672 verifyFormat("[]() -> a<1> { ; };"); 13673 verifyFormat("[]() -> a<1> { ; }();"); 13674 verifyFormat("[a, a]() -> a<true> {};"); 13675 verifyFormat("[]() -> a<true> {};"); 13676 verifyFormat("[]() -> a<true> { ; };"); 13677 verifyFormat("[]() -> a<true> { ; }();"); 13678 verifyFormat("[a, a]() -> a<false> {};"); 13679 verifyFormat("[]() -> a<false> {};"); 13680 verifyFormat("[]() -> a<false> { ; };"); 13681 verifyFormat("[]() -> a<false> { ; }();"); 13682 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 13683 verifyFormat("namespace bar {\n" 13684 "auto foo{[]() -> foo<false> { ; }};\n" 13685 "} // namespace bar"); 13686 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 13687 " int j) -> int {\n" 13688 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 13689 "};"); 13690 verifyFormat( 13691 "aaaaaaaaaaaaaaaaaaaaaa(\n" 13692 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 13693 " return aaaaaaaaaaaaaaaaa;\n" 13694 " });", 13695 getLLVMStyleWithColumns(70)); 13696 verifyFormat("[]() //\n" 13697 " -> int {\n" 13698 " return 1; //\n" 13699 "};"); 13700 13701 // Lambdas with explicit template argument lists. 13702 verifyFormat( 13703 "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n"); 13704 13705 // Multiple lambdas in the same parentheses change indentation rules. These 13706 // lambdas are forced to start on new lines. 13707 verifyFormat("SomeFunction(\n" 13708 " []() {\n" 13709 " //\n" 13710 " },\n" 13711 " []() {\n" 13712 " //\n" 13713 " });"); 13714 13715 // A lambda passed as arg0 is always pushed to the next line. 13716 verifyFormat("SomeFunction(\n" 13717 " [this] {\n" 13718 " //\n" 13719 " },\n" 13720 " 1);\n"); 13721 13722 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like 13723 // the arg0 case above. 13724 auto Style = getGoogleStyle(); 13725 Style.BinPackArguments = false; 13726 verifyFormat("SomeFunction(\n" 13727 " a,\n" 13728 " [this] {\n" 13729 " //\n" 13730 " },\n" 13731 " b);\n", 13732 Style); 13733 verifyFormat("SomeFunction(\n" 13734 " a,\n" 13735 " [this] {\n" 13736 " //\n" 13737 " },\n" 13738 " b);\n"); 13739 13740 // A lambda with a very long line forces arg0 to be pushed out irrespective of 13741 // the BinPackArguments value (as long as the code is wide enough). 13742 verifyFormat( 13743 "something->SomeFunction(\n" 13744 " a,\n" 13745 " [this] {\n" 13746 " " 13747 "D0000000000000000000000000000000000000000000000000000000000001();\n" 13748 " },\n" 13749 " b);\n"); 13750 13751 // A multi-line lambda is pulled up as long as the introducer fits on the 13752 // previous line and there are no further args. 13753 verifyFormat("function(1, [this, that] {\n" 13754 " //\n" 13755 "});\n"); 13756 verifyFormat("function([this, that] {\n" 13757 " //\n" 13758 "});\n"); 13759 // FIXME: this format is not ideal and we should consider forcing the first 13760 // arg onto its own line. 13761 verifyFormat("function(a, b, c, //\n" 13762 " d, [this, that] {\n" 13763 " //\n" 13764 " });\n"); 13765 13766 // Multiple lambdas are treated correctly even when there is a short arg0. 13767 verifyFormat("SomeFunction(\n" 13768 " 1,\n" 13769 " [this] {\n" 13770 " //\n" 13771 " },\n" 13772 " [this] {\n" 13773 " //\n" 13774 " },\n" 13775 " 1);\n"); 13776 13777 // More complex introducers. 13778 verifyFormat("return [i, args...] {};"); 13779 13780 // Not lambdas. 13781 verifyFormat("constexpr char hello[]{\"hello\"};"); 13782 verifyFormat("double &operator[](int i) { return 0; }\n" 13783 "int i;"); 13784 verifyFormat("std::unique_ptr<int[]> foo() {}"); 13785 verifyFormat("int i = a[a][a]->f();"); 13786 verifyFormat("int i = (*b)[a]->f();"); 13787 13788 // Other corner cases. 13789 verifyFormat("void f() {\n" 13790 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 13791 " );\n" 13792 "}"); 13793 13794 // Lambdas created through weird macros. 13795 verifyFormat("void f() {\n" 13796 " MACRO((const AA &a) { return 1; });\n" 13797 " MACRO((AA &a) { return 1; });\n" 13798 "}"); 13799 13800 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 13801 " doo_dah();\n" 13802 " doo_dah();\n" 13803 " })) {\n" 13804 "}"); 13805 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 13806 " doo_dah();\n" 13807 " doo_dah();\n" 13808 " })) {\n" 13809 "}"); 13810 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n" 13811 " doo_dah();\n" 13812 " doo_dah();\n" 13813 " })) {\n" 13814 "}"); 13815 verifyFormat("auto lambda = []() {\n" 13816 " int a = 2\n" 13817 "#if A\n" 13818 " + 2\n" 13819 "#endif\n" 13820 " ;\n" 13821 "};"); 13822 13823 // Lambdas with complex multiline introducers. 13824 verifyFormat( 13825 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13826 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 13827 " -> ::std::unordered_set<\n" 13828 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 13829 " //\n" 13830 " });"); 13831 13832 FormatStyle DoNotMerge = getLLVMStyle(); 13833 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 13834 verifyFormat("auto c = []() {\n" 13835 " return b;\n" 13836 "};", 13837 "auto c = []() { return b; };", DoNotMerge); 13838 verifyFormat("auto c = []() {\n" 13839 "};", 13840 " auto c = []() {};", DoNotMerge); 13841 13842 FormatStyle MergeEmptyOnly = getLLVMStyle(); 13843 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 13844 verifyFormat("auto c = []() {\n" 13845 " return b;\n" 13846 "};", 13847 "auto c = []() {\n" 13848 " return b;\n" 13849 " };", 13850 MergeEmptyOnly); 13851 verifyFormat("auto c = []() {};", 13852 "auto c = []() {\n" 13853 "};", 13854 MergeEmptyOnly); 13855 13856 FormatStyle MergeInline = getLLVMStyle(); 13857 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 13858 verifyFormat("auto c = []() {\n" 13859 " return b;\n" 13860 "};", 13861 "auto c = []() { return b; };", MergeInline); 13862 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 13863 MergeInline); 13864 verifyFormat("function([]() { return b; }, a)", 13865 "function([]() { return b; }, a)", MergeInline); 13866 verifyFormat("function(a, []() { return b; })", 13867 "function(a, []() { return b; })", MergeInline); 13868 } 13869 13870 TEST_F(FormatTest, EmptyLinesInLambdas) { 13871 verifyFormat("auto lambda = []() {\n" 13872 " x(); //\n" 13873 "};", 13874 "auto lambda = []() {\n" 13875 "\n" 13876 " x(); //\n" 13877 "\n" 13878 "};"); 13879 } 13880 13881 TEST_F(FormatTest, FormatsBlocks) { 13882 FormatStyle ShortBlocks = getLLVMStyle(); 13883 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13884 verifyFormat("int (^Block)(int, int);", ShortBlocks); 13885 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 13886 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 13887 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 13888 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 13889 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 13890 13891 verifyFormat("foo(^{ bar(); });", ShortBlocks); 13892 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 13893 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 13894 13895 verifyFormat("[operation setCompletionBlock:^{\n" 13896 " [self onOperationDone];\n" 13897 "}];"); 13898 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 13899 " [self onOperationDone];\n" 13900 "}]};"); 13901 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 13902 " f();\n" 13903 "}];"); 13904 verifyFormat("int a = [operation block:^int(int *i) {\n" 13905 " return 1;\n" 13906 "}];"); 13907 verifyFormat("[myObject doSomethingWith:arg1\n" 13908 " aaa:^int(int *a) {\n" 13909 " return 1;\n" 13910 " }\n" 13911 " bbb:f(a * bbbbbbbb)];"); 13912 13913 verifyFormat("[operation setCompletionBlock:^{\n" 13914 " [self.delegate newDataAvailable];\n" 13915 "}];", 13916 getLLVMStyleWithColumns(60)); 13917 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 13918 " NSString *path = [self sessionFilePath];\n" 13919 " if (path) {\n" 13920 " // ...\n" 13921 " }\n" 13922 "});"); 13923 verifyFormat("[[SessionService sharedService]\n" 13924 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13925 " if (window) {\n" 13926 " [self windowDidLoad:window];\n" 13927 " } else {\n" 13928 " [self errorLoadingWindow];\n" 13929 " }\n" 13930 " }];"); 13931 verifyFormat("void (^largeBlock)(void) = ^{\n" 13932 " // ...\n" 13933 "};\n", 13934 getLLVMStyleWithColumns(40)); 13935 verifyFormat("[[SessionService sharedService]\n" 13936 " loadWindowWithCompletionBlock: //\n" 13937 " ^(SessionWindow *window) {\n" 13938 " if (window) {\n" 13939 " [self windowDidLoad:window];\n" 13940 " } else {\n" 13941 " [self errorLoadingWindow];\n" 13942 " }\n" 13943 " }];", 13944 getLLVMStyleWithColumns(60)); 13945 verifyFormat("[myObject doSomethingWith:arg1\n" 13946 " firstBlock:^(Foo *a) {\n" 13947 " // ...\n" 13948 " int i;\n" 13949 " }\n" 13950 " secondBlock:^(Bar *b) {\n" 13951 " // ...\n" 13952 " int i;\n" 13953 " }\n" 13954 " thirdBlock:^Foo(Bar *b) {\n" 13955 " // ...\n" 13956 " int i;\n" 13957 " }];"); 13958 verifyFormat("[myObject doSomethingWith:arg1\n" 13959 " firstBlock:-1\n" 13960 " secondBlock:^(Bar *b) {\n" 13961 " // ...\n" 13962 " int i;\n" 13963 " }];"); 13964 13965 verifyFormat("f(^{\n" 13966 " @autoreleasepool {\n" 13967 " if (a) {\n" 13968 " g();\n" 13969 " }\n" 13970 " }\n" 13971 "});"); 13972 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 13973 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 13974 "};"); 13975 13976 FormatStyle FourIndent = getLLVMStyle(); 13977 FourIndent.ObjCBlockIndentWidth = 4; 13978 verifyFormat("[operation setCompletionBlock:^{\n" 13979 " [self onOperationDone];\n" 13980 "}];", 13981 FourIndent); 13982 } 13983 13984 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 13985 FormatStyle ZeroColumn = getLLVMStyle(); 13986 ZeroColumn.ColumnLimit = 0; 13987 13988 verifyFormat("[[SessionService sharedService] " 13989 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13990 " if (window) {\n" 13991 " [self windowDidLoad:window];\n" 13992 " } else {\n" 13993 " [self errorLoadingWindow];\n" 13994 " }\n" 13995 "}];", 13996 ZeroColumn); 13997 EXPECT_EQ("[[SessionService sharedService]\n" 13998 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 13999 " if (window) {\n" 14000 " [self windowDidLoad:window];\n" 14001 " } else {\n" 14002 " [self errorLoadingWindow];\n" 14003 " }\n" 14004 " }];", 14005 format("[[SessionService sharedService]\n" 14006 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14007 " if (window) {\n" 14008 " [self windowDidLoad:window];\n" 14009 " } else {\n" 14010 " [self errorLoadingWindow];\n" 14011 " }\n" 14012 "}];", 14013 ZeroColumn)); 14014 verifyFormat("[myObject doSomethingWith:arg1\n" 14015 " firstBlock:^(Foo *a) {\n" 14016 " // ...\n" 14017 " int i;\n" 14018 " }\n" 14019 " secondBlock:^(Bar *b) {\n" 14020 " // ...\n" 14021 " int i;\n" 14022 " }\n" 14023 " thirdBlock:^Foo(Bar *b) {\n" 14024 " // ...\n" 14025 " int i;\n" 14026 " }];", 14027 ZeroColumn); 14028 verifyFormat("f(^{\n" 14029 " @autoreleasepool {\n" 14030 " if (a) {\n" 14031 " g();\n" 14032 " }\n" 14033 " }\n" 14034 "});", 14035 ZeroColumn); 14036 verifyFormat("void (^largeBlock)(void) = ^{\n" 14037 " // ...\n" 14038 "};", 14039 ZeroColumn); 14040 14041 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 14042 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 14043 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 14044 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 14045 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 14046 " int i;\n" 14047 "};", 14048 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 14049 } 14050 14051 TEST_F(FormatTest, SupportsCRLF) { 14052 EXPECT_EQ("int a;\r\n" 14053 "int b;\r\n" 14054 "int c;\r\n", 14055 format("int a;\r\n" 14056 " int b;\r\n" 14057 " int c;\r\n", 14058 getLLVMStyle())); 14059 EXPECT_EQ("int a;\r\n" 14060 "int b;\r\n" 14061 "int c;\r\n", 14062 format("int a;\r\n" 14063 " int b;\n" 14064 " int c;\r\n", 14065 getLLVMStyle())); 14066 EXPECT_EQ("int a;\n" 14067 "int b;\n" 14068 "int c;\n", 14069 format("int a;\r\n" 14070 " int b;\n" 14071 " int c;\n", 14072 getLLVMStyle())); 14073 EXPECT_EQ("\"aaaaaaa \"\r\n" 14074 "\"bbbbbbb\";\r\n", 14075 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 14076 EXPECT_EQ("#define A \\\r\n" 14077 " b; \\\r\n" 14078 " c; \\\r\n" 14079 " d;\r\n", 14080 format("#define A \\\r\n" 14081 " b; \\\r\n" 14082 " c; d; \r\n", 14083 getGoogleStyle())); 14084 14085 EXPECT_EQ("/*\r\n" 14086 "multi line block comments\r\n" 14087 "should not introduce\r\n" 14088 "an extra carriage return\r\n" 14089 "*/\r\n", 14090 format("/*\r\n" 14091 "multi line block comments\r\n" 14092 "should not introduce\r\n" 14093 "an extra carriage return\r\n" 14094 "*/\r\n")); 14095 EXPECT_EQ("/*\r\n" 14096 "\r\n" 14097 "*/", 14098 format("/*\r\n" 14099 " \r\r\r\n" 14100 "*/")); 14101 14102 FormatStyle style = getLLVMStyle(); 14103 14104 style.DeriveLineEnding = true; 14105 style.UseCRLF = false; 14106 EXPECT_EQ("union FooBarBazQux {\n" 14107 " int foo;\n" 14108 " int bar;\n" 14109 " int baz;\n" 14110 "};", 14111 format("union FooBarBazQux {\r\n" 14112 " int foo;\n" 14113 " int bar;\r\n" 14114 " int baz;\n" 14115 "};", 14116 style)); 14117 style.UseCRLF = true; 14118 EXPECT_EQ("union FooBarBazQux {\r\n" 14119 " int foo;\r\n" 14120 " int bar;\r\n" 14121 " int baz;\r\n" 14122 "};", 14123 format("union FooBarBazQux {\r\n" 14124 " int foo;\n" 14125 " int bar;\r\n" 14126 " int baz;\n" 14127 "};", 14128 style)); 14129 14130 style.DeriveLineEnding = false; 14131 style.UseCRLF = false; 14132 EXPECT_EQ("union FooBarBazQux {\n" 14133 " int foo;\n" 14134 " int bar;\n" 14135 " int baz;\n" 14136 " int qux;\n" 14137 "};", 14138 format("union FooBarBazQux {\r\n" 14139 " int foo;\n" 14140 " int bar;\r\n" 14141 " int baz;\n" 14142 " int qux;\r\n" 14143 "};", 14144 style)); 14145 style.UseCRLF = true; 14146 EXPECT_EQ("union FooBarBazQux {\r\n" 14147 " int foo;\r\n" 14148 " int bar;\r\n" 14149 " int baz;\r\n" 14150 " int qux;\r\n" 14151 "};", 14152 format("union FooBarBazQux {\r\n" 14153 " int foo;\n" 14154 " int bar;\r\n" 14155 " int baz;\n" 14156 " int qux;\n" 14157 "};", 14158 style)); 14159 14160 style.DeriveLineEnding = true; 14161 style.UseCRLF = false; 14162 EXPECT_EQ("union FooBarBazQux {\r\n" 14163 " int foo;\r\n" 14164 " int bar;\r\n" 14165 " int baz;\r\n" 14166 " int qux;\r\n" 14167 "};", 14168 format("union FooBarBazQux {\r\n" 14169 " int foo;\n" 14170 " int bar;\r\n" 14171 " int baz;\n" 14172 " int qux;\r\n" 14173 "};", 14174 style)); 14175 style.UseCRLF = true; 14176 EXPECT_EQ("union FooBarBazQux {\n" 14177 " int foo;\n" 14178 " int bar;\n" 14179 " int baz;\n" 14180 " int qux;\n" 14181 "};", 14182 format("union FooBarBazQux {\r\n" 14183 " int foo;\n" 14184 " int bar;\r\n" 14185 " int baz;\n" 14186 " int qux;\n" 14187 "};", 14188 style)); 14189 } 14190 14191 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 14192 verifyFormat("MY_CLASS(C) {\n" 14193 " int i;\n" 14194 " int j;\n" 14195 "};"); 14196 } 14197 14198 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 14199 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 14200 TwoIndent.ContinuationIndentWidth = 2; 14201 14202 EXPECT_EQ("int i =\n" 14203 " longFunction(\n" 14204 " arg);", 14205 format("int i = longFunction(arg);", TwoIndent)); 14206 14207 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 14208 SixIndent.ContinuationIndentWidth = 6; 14209 14210 EXPECT_EQ("int i =\n" 14211 " longFunction(\n" 14212 " arg);", 14213 format("int i = longFunction(arg);", SixIndent)); 14214 } 14215 14216 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 14217 FormatStyle Style = getLLVMStyle(); 14218 verifyFormat("int Foo::getter(\n" 14219 " //\n" 14220 ") const {\n" 14221 " return foo;\n" 14222 "}", 14223 Style); 14224 verifyFormat("void Foo::setter(\n" 14225 " //\n" 14226 ") {\n" 14227 " foo = 1;\n" 14228 "}", 14229 Style); 14230 } 14231 14232 TEST_F(FormatTest, SpacesInAngles) { 14233 FormatStyle Spaces = getLLVMStyle(); 14234 Spaces.SpacesInAngles = true; 14235 14236 verifyFormat("static_cast< int >(arg);", Spaces); 14237 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 14238 verifyFormat("f< int, float >();", Spaces); 14239 verifyFormat("template <> g() {}", Spaces); 14240 verifyFormat("template < std::vector< int > > f() {}", Spaces); 14241 verifyFormat("std::function< void(int, int) > fct;", Spaces); 14242 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 14243 Spaces); 14244 14245 Spaces.Standard = FormatStyle::LS_Cpp03; 14246 Spaces.SpacesInAngles = true; 14247 verifyFormat("A< A< int > >();", Spaces); 14248 14249 Spaces.SpacesInAngles = false; 14250 verifyFormat("A<A<int> >();", Spaces); 14251 14252 Spaces.Standard = FormatStyle::LS_Cpp11; 14253 Spaces.SpacesInAngles = true; 14254 verifyFormat("A< A< int > >();", Spaces); 14255 14256 Spaces.SpacesInAngles = false; 14257 verifyFormat("A<A<int>>();", Spaces); 14258 } 14259 14260 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 14261 FormatStyle Style = getLLVMStyle(); 14262 Style.SpaceAfterTemplateKeyword = false; 14263 verifyFormat("template<int> void foo();", Style); 14264 } 14265 14266 TEST_F(FormatTest, TripleAngleBrackets) { 14267 verifyFormat("f<<<1, 1>>>();"); 14268 verifyFormat("f<<<1, 1, 1, s>>>();"); 14269 verifyFormat("f<<<a, b, c, d>>>();"); 14270 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 14271 verifyFormat("f<param><<<1, 1>>>();"); 14272 verifyFormat("f<1><<<1, 1>>>();"); 14273 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 14274 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14275 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 14276 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 14277 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 14278 } 14279 14280 TEST_F(FormatTest, MergeLessLessAtEnd) { 14281 verifyFormat("<<"); 14282 EXPECT_EQ("< < <", format("\\\n<<<")); 14283 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14284 "aaallvm::outs() <<"); 14285 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14286 "aaaallvm::outs()\n <<"); 14287 } 14288 14289 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 14290 std::string code = "#if A\n" 14291 "#if B\n" 14292 "a.\n" 14293 "#endif\n" 14294 " a = 1;\n" 14295 "#else\n" 14296 "#endif\n" 14297 "#if C\n" 14298 "#else\n" 14299 "#endif\n"; 14300 EXPECT_EQ(code, format(code)); 14301 } 14302 14303 TEST_F(FormatTest, HandleConflictMarkers) { 14304 // Git/SVN conflict markers. 14305 EXPECT_EQ("int a;\n" 14306 "void f() {\n" 14307 " callme(some(parameter1,\n" 14308 "<<<<<<< text by the vcs\n" 14309 " parameter2),\n" 14310 "||||||| text by the vcs\n" 14311 " parameter2),\n" 14312 " parameter3,\n" 14313 "======= text by the vcs\n" 14314 " parameter2, parameter3),\n" 14315 ">>>>>>> text by the vcs\n" 14316 " otherparameter);\n", 14317 format("int a;\n" 14318 "void f() {\n" 14319 " callme(some(parameter1,\n" 14320 "<<<<<<< text by the vcs\n" 14321 " parameter2),\n" 14322 "||||||| text by the vcs\n" 14323 " parameter2),\n" 14324 " parameter3,\n" 14325 "======= text by the vcs\n" 14326 " parameter2,\n" 14327 " parameter3),\n" 14328 ">>>>>>> text by the vcs\n" 14329 " otherparameter);\n")); 14330 14331 // Perforce markers. 14332 EXPECT_EQ("void f() {\n" 14333 " function(\n" 14334 ">>>> text by the vcs\n" 14335 " parameter,\n" 14336 "==== text by the vcs\n" 14337 " parameter,\n" 14338 "==== text by the vcs\n" 14339 " parameter,\n" 14340 "<<<< text by the vcs\n" 14341 " parameter);\n", 14342 format("void f() {\n" 14343 " function(\n" 14344 ">>>> text by the vcs\n" 14345 " parameter,\n" 14346 "==== text by the vcs\n" 14347 " parameter,\n" 14348 "==== text by the vcs\n" 14349 " parameter,\n" 14350 "<<<< text by the vcs\n" 14351 " parameter);\n")); 14352 14353 EXPECT_EQ("<<<<<<<\n" 14354 "|||||||\n" 14355 "=======\n" 14356 ">>>>>>>", 14357 format("<<<<<<<\n" 14358 "|||||||\n" 14359 "=======\n" 14360 ">>>>>>>")); 14361 14362 EXPECT_EQ("<<<<<<<\n" 14363 "|||||||\n" 14364 "int i;\n" 14365 "=======\n" 14366 ">>>>>>>", 14367 format("<<<<<<<\n" 14368 "|||||||\n" 14369 "int i;\n" 14370 "=======\n" 14371 ">>>>>>>")); 14372 14373 // FIXME: Handle parsing of macros around conflict markers correctly: 14374 EXPECT_EQ("#define Macro \\\n" 14375 "<<<<<<<\n" 14376 "Something \\\n" 14377 "|||||||\n" 14378 "Else \\\n" 14379 "=======\n" 14380 "Other \\\n" 14381 ">>>>>>>\n" 14382 " End int i;\n", 14383 format("#define Macro \\\n" 14384 "<<<<<<<\n" 14385 " Something \\\n" 14386 "|||||||\n" 14387 " Else \\\n" 14388 "=======\n" 14389 " Other \\\n" 14390 ">>>>>>>\n" 14391 " End\n" 14392 "int i;\n")); 14393 } 14394 14395 TEST_F(FormatTest, DisableRegions) { 14396 EXPECT_EQ("int i;\n" 14397 "// clang-format off\n" 14398 " int j;\n" 14399 "// clang-format on\n" 14400 "int k;", 14401 format(" int i;\n" 14402 " // clang-format off\n" 14403 " int j;\n" 14404 " // clang-format on\n" 14405 " int k;")); 14406 EXPECT_EQ("int i;\n" 14407 "/* clang-format off */\n" 14408 " int j;\n" 14409 "/* clang-format on */\n" 14410 "int k;", 14411 format(" int i;\n" 14412 " /* clang-format off */\n" 14413 " int j;\n" 14414 " /* clang-format on */\n" 14415 " int k;")); 14416 14417 // Don't reflow comments within disabled regions. 14418 EXPECT_EQ("// clang-format off\n" 14419 "// long long long long long long line\n" 14420 "/* clang-format on */\n" 14421 "/* long long long\n" 14422 " * long long long\n" 14423 " * line */\n" 14424 "int i;\n" 14425 "/* clang-format off */\n" 14426 "/* long long long long long long line */\n", 14427 format("// clang-format off\n" 14428 "// long long long long long long line\n" 14429 "/* clang-format on */\n" 14430 "/* long long long long long long line */\n" 14431 "int i;\n" 14432 "/* clang-format off */\n" 14433 "/* long long long long long long line */\n", 14434 getLLVMStyleWithColumns(20))); 14435 } 14436 14437 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 14438 format("? ) ="); 14439 verifyNoCrash("#define a\\\n /**/}"); 14440 } 14441 14442 TEST_F(FormatTest, FormatsTableGenCode) { 14443 FormatStyle Style = getLLVMStyle(); 14444 Style.Language = FormatStyle::LK_TableGen; 14445 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 14446 } 14447 14448 TEST_F(FormatTest, ArrayOfTemplates) { 14449 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 14450 format("auto a = new unique_ptr<int > [ 10];")); 14451 14452 FormatStyle Spaces = getLLVMStyle(); 14453 Spaces.SpacesInSquareBrackets = true; 14454 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 14455 format("auto a = new unique_ptr<int > [10];", Spaces)); 14456 } 14457 14458 TEST_F(FormatTest, ArrayAsTemplateType) { 14459 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 14460 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 14461 14462 FormatStyle Spaces = getLLVMStyle(); 14463 Spaces.SpacesInSquareBrackets = true; 14464 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 14465 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 14466 } 14467 14468 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); } 14469 14470 TEST(FormatStyle, GetStyleWithEmptyFileName) { 14471 llvm::vfs::InMemoryFileSystem FS; 14472 auto Style1 = getStyle("file", "", "Google", "", &FS); 14473 ASSERT_TRUE((bool)Style1); 14474 ASSERT_EQ(*Style1, getGoogleStyle()); 14475 } 14476 14477 TEST(FormatStyle, GetStyleOfFile) { 14478 llvm::vfs::InMemoryFileSystem FS; 14479 // Test 1: format file in the same directory. 14480 ASSERT_TRUE( 14481 FS.addFile("/a/.clang-format", 0, 14482 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 14483 ASSERT_TRUE( 14484 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14485 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 14486 ASSERT_TRUE((bool)Style1); 14487 ASSERT_EQ(*Style1, getLLVMStyle()); 14488 14489 // Test 2.1: fallback to default. 14490 ASSERT_TRUE( 14491 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14492 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 14493 ASSERT_TRUE((bool)Style2); 14494 ASSERT_EQ(*Style2, getMozillaStyle()); 14495 14496 // Test 2.2: no format on 'none' fallback style. 14497 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 14498 ASSERT_TRUE((bool)Style2); 14499 ASSERT_EQ(*Style2, getNoStyle()); 14500 14501 // Test 2.3: format if config is found with no based style while fallback is 14502 // 'none'. 14503 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 14504 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 14505 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 14506 ASSERT_TRUE((bool)Style2); 14507 ASSERT_EQ(*Style2, getLLVMStyle()); 14508 14509 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 14510 Style2 = getStyle("{}", "a.h", "none", "", &FS); 14511 ASSERT_TRUE((bool)Style2); 14512 ASSERT_EQ(*Style2, getLLVMStyle()); 14513 14514 // Test 3: format file in parent directory. 14515 ASSERT_TRUE( 14516 FS.addFile("/c/.clang-format", 0, 14517 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 14518 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 14519 llvm::MemoryBuffer::getMemBuffer("int i;"))); 14520 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 14521 ASSERT_TRUE((bool)Style3); 14522 ASSERT_EQ(*Style3, getGoogleStyle()); 14523 14524 // Test 4: error on invalid fallback style 14525 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 14526 ASSERT_FALSE((bool)Style4); 14527 llvm::consumeError(Style4.takeError()); 14528 14529 // Test 5: error on invalid yaml on command line 14530 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 14531 ASSERT_FALSE((bool)Style5); 14532 llvm::consumeError(Style5.takeError()); 14533 14534 // Test 6: error on invalid style 14535 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 14536 ASSERT_FALSE((bool)Style6); 14537 llvm::consumeError(Style6.takeError()); 14538 14539 // Test 7: found config file, error on parsing it 14540 ASSERT_TRUE( 14541 FS.addFile("/d/.clang-format", 0, 14542 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 14543 "InvalidKey: InvalidValue"))); 14544 ASSERT_TRUE( 14545 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14546 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 14547 ASSERT_FALSE((bool)Style7); 14548 llvm::consumeError(Style7.takeError()); 14549 14550 // Test 8: inferred per-language defaults apply. 14551 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 14552 ASSERT_TRUE((bool)StyleTd); 14553 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 14554 } 14555 14556 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 14557 // Column limit is 20. 14558 std::string Code = "Type *a =\n" 14559 " new Type();\n" 14560 "g(iiiii, 0, jjjjj,\n" 14561 " 0, kkkkk, 0, mm);\n" 14562 "int bad = format ;"; 14563 std::string Expected = "auto a = new Type();\n" 14564 "g(iiiii, nullptr,\n" 14565 " jjjjj, nullptr,\n" 14566 " kkkkk, nullptr,\n" 14567 " mm);\n" 14568 "int bad = format ;"; 14569 FileID ID = Context.createInMemoryFile("format.cpp", Code); 14570 tooling::Replacements Replaces = toReplacements( 14571 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 14572 "auto "), 14573 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 14574 "nullptr"), 14575 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 14576 "nullptr"), 14577 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 14578 "nullptr")}); 14579 14580 format::FormatStyle Style = format::getLLVMStyle(); 14581 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 14582 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 14583 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 14584 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 14585 auto Result = applyAllReplacements(Code, *FormattedReplaces); 14586 EXPECT_TRUE(static_cast<bool>(Result)); 14587 EXPECT_EQ(Expected, *Result); 14588 } 14589 14590 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 14591 std::string Code = "#include \"a.h\"\n" 14592 "#include \"c.h\"\n" 14593 "\n" 14594 "int main() {\n" 14595 " return 0;\n" 14596 "}"; 14597 std::string Expected = "#include \"a.h\"\n" 14598 "#include \"b.h\"\n" 14599 "#include \"c.h\"\n" 14600 "\n" 14601 "int main() {\n" 14602 " return 0;\n" 14603 "}"; 14604 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 14605 tooling::Replacements Replaces = toReplacements( 14606 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 14607 "#include \"b.h\"\n")}); 14608 14609 format::FormatStyle Style = format::getLLVMStyle(); 14610 Style.SortIncludes = true; 14611 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 14612 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 14613 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 14614 auto Result = applyAllReplacements(Code, *FormattedReplaces); 14615 EXPECT_TRUE(static_cast<bool>(Result)); 14616 EXPECT_EQ(Expected, *Result); 14617 } 14618 14619 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 14620 EXPECT_EQ("using std::cin;\n" 14621 "using std::cout;", 14622 format("using std::cout;\n" 14623 "using std::cin;", 14624 getGoogleStyle())); 14625 } 14626 14627 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 14628 format::FormatStyle Style = format::getLLVMStyle(); 14629 Style.Standard = FormatStyle::LS_Cpp03; 14630 // cpp03 recognize this string as identifier u8 and literal character 'a' 14631 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 14632 } 14633 14634 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 14635 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 14636 // all modes, including C++11, C++14 and C++17 14637 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 14638 } 14639 14640 TEST_F(FormatTest, DoNotFormatLikelyXml) { 14641 EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle())); 14642 EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle())); 14643 } 14644 14645 TEST_F(FormatTest, StructuredBindings) { 14646 // Structured bindings is a C++17 feature. 14647 // all modes, including C++11, C++14 and C++17 14648 verifyFormat("auto [a, b] = f();"); 14649 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 14650 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 14651 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 14652 EXPECT_EQ("auto const volatile [a, b] = f();", 14653 format("auto const volatile[a, b] = f();")); 14654 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 14655 EXPECT_EQ("auto &[a, b, c] = f();", 14656 format("auto &[ a , b,c ] = f();")); 14657 EXPECT_EQ("auto &&[a, b, c] = f();", 14658 format("auto &&[ a , b,c ] = f();")); 14659 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 14660 EXPECT_EQ("auto const volatile &&[a, b] = f();", 14661 format("auto const volatile &&[a, b] = f();")); 14662 EXPECT_EQ("auto const &&[a, b] = f();", 14663 format("auto const && [a, b] = f();")); 14664 EXPECT_EQ("const auto &[a, b] = f();", 14665 format("const auto & [a, b] = f();")); 14666 EXPECT_EQ("const auto volatile &&[a, b] = f();", 14667 format("const auto volatile &&[a, b] = f();")); 14668 EXPECT_EQ("volatile const auto &&[a, b] = f();", 14669 format("volatile const auto &&[a, b] = f();")); 14670 EXPECT_EQ("const auto &&[a, b] = f();", 14671 format("const auto && [a, b] = f();")); 14672 14673 // Make sure we don't mistake structured bindings for lambdas. 14674 FormatStyle PointerMiddle = getLLVMStyle(); 14675 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 14676 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 14677 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 14678 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 14679 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 14680 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 14681 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 14682 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 14683 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 14684 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 14685 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 14686 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 14687 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 14688 14689 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 14690 format("for (const auto && [a, b] : some_range) {\n}")); 14691 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 14692 format("for (const auto & [a, b] : some_range) {\n}")); 14693 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 14694 format("for (const auto[a, b] : some_range) {\n}")); 14695 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 14696 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 14697 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 14698 EXPECT_EQ("auto const &[x, y](expr);", 14699 format("auto const & [x,y] (expr);")); 14700 EXPECT_EQ("auto const &&[x, y](expr);", 14701 format("auto const && [x,y] (expr);")); 14702 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 14703 EXPECT_EQ("auto const &[x, y]{expr};", 14704 format("auto const & [x,y] {expr};")); 14705 EXPECT_EQ("auto const &&[x, y]{expr};", 14706 format("auto const && [x,y] {expr};")); 14707 14708 format::FormatStyle Spaces = format::getLLVMStyle(); 14709 Spaces.SpacesInSquareBrackets = true; 14710 verifyFormat("auto [ a, b ] = f();", Spaces); 14711 verifyFormat("auto &&[ a, b ] = f();", Spaces); 14712 verifyFormat("auto &[ a, b ] = f();", Spaces); 14713 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 14714 verifyFormat("auto const &[ a, b ] = f();", Spaces); 14715 } 14716 14717 TEST_F(FormatTest, FileAndCode) { 14718 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 14719 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 14720 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 14721 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 14722 EXPECT_EQ(FormatStyle::LK_ObjC, 14723 guessLanguage("foo.h", "@interface Foo\n@end\n")); 14724 EXPECT_EQ( 14725 FormatStyle::LK_ObjC, 14726 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 14727 EXPECT_EQ(FormatStyle::LK_ObjC, 14728 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 14729 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 14730 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 14731 EXPECT_EQ(FormatStyle::LK_ObjC, 14732 guessLanguage("foo", "@interface Foo\n@end\n")); 14733 EXPECT_EQ(FormatStyle::LK_ObjC, 14734 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 14735 EXPECT_EQ( 14736 FormatStyle::LK_ObjC, 14737 guessLanguage("foo.h", 14738 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 14739 EXPECT_EQ( 14740 FormatStyle::LK_Cpp, 14741 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 14742 } 14743 14744 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 14745 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 14746 EXPECT_EQ(FormatStyle::LK_ObjC, 14747 guessLanguage("foo.h", "array[[calculator getIndex]];")); 14748 EXPECT_EQ(FormatStyle::LK_Cpp, 14749 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 14750 EXPECT_EQ( 14751 FormatStyle::LK_Cpp, 14752 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 14753 EXPECT_EQ(FormatStyle::LK_ObjC, 14754 guessLanguage("foo.h", "[[noreturn foo] bar];")); 14755 EXPECT_EQ(FormatStyle::LK_Cpp, 14756 guessLanguage("foo.h", "[[clang::fallthrough]];")); 14757 EXPECT_EQ(FormatStyle::LK_ObjC, 14758 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 14759 EXPECT_EQ(FormatStyle::LK_Cpp, 14760 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 14761 EXPECT_EQ(FormatStyle::LK_Cpp, 14762 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 14763 EXPECT_EQ(FormatStyle::LK_ObjC, 14764 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 14765 EXPECT_EQ(FormatStyle::LK_Cpp, 14766 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 14767 EXPECT_EQ( 14768 FormatStyle::LK_Cpp, 14769 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 14770 EXPECT_EQ( 14771 FormatStyle::LK_Cpp, 14772 guessLanguage("foo.h", 14773 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 14774 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 14775 } 14776 14777 TEST_F(FormatTest, GuessLanguageWithCaret) { 14778 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 14779 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 14780 EXPECT_EQ(FormatStyle::LK_ObjC, 14781 guessLanguage("foo.h", "int(^)(char, float);")); 14782 EXPECT_EQ(FormatStyle::LK_ObjC, 14783 guessLanguage("foo.h", "int(^foo)(char, float);")); 14784 EXPECT_EQ(FormatStyle::LK_ObjC, 14785 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 14786 EXPECT_EQ(FormatStyle::LK_ObjC, 14787 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 14788 EXPECT_EQ( 14789 FormatStyle::LK_ObjC, 14790 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 14791 } 14792 14793 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 14794 EXPECT_EQ(FormatStyle::LK_Cpp, 14795 guessLanguage("foo.h", "void f() {\n" 14796 " asm (\"mov %[e], %[d]\"\n" 14797 " : [d] \"=rm\" (d)\n" 14798 " [e] \"rm\" (*e));\n" 14799 "}")); 14800 EXPECT_EQ(FormatStyle::LK_Cpp, 14801 guessLanguage("foo.h", "void f() {\n" 14802 " _asm (\"mov %[e], %[d]\"\n" 14803 " : [d] \"=rm\" (d)\n" 14804 " [e] \"rm\" (*e));\n" 14805 "}")); 14806 EXPECT_EQ(FormatStyle::LK_Cpp, 14807 guessLanguage("foo.h", "void f() {\n" 14808 " __asm (\"mov %[e], %[d]\"\n" 14809 " : [d] \"=rm\" (d)\n" 14810 " [e] \"rm\" (*e));\n" 14811 "}")); 14812 EXPECT_EQ(FormatStyle::LK_Cpp, 14813 guessLanguage("foo.h", "void f() {\n" 14814 " __asm__ (\"mov %[e], %[d]\"\n" 14815 " : [d] \"=rm\" (d)\n" 14816 " [e] \"rm\" (*e));\n" 14817 "}")); 14818 EXPECT_EQ(FormatStyle::LK_Cpp, 14819 guessLanguage("foo.h", "void f() {\n" 14820 " asm (\"mov %[e], %[d]\"\n" 14821 " : [d] \"=rm\" (d),\n" 14822 " [e] \"rm\" (*e));\n" 14823 "}")); 14824 EXPECT_EQ(FormatStyle::LK_Cpp, 14825 guessLanguage("foo.h", "void f() {\n" 14826 " asm volatile (\"mov %[e], %[d]\"\n" 14827 " : [d] \"=rm\" (d)\n" 14828 " [e] \"rm\" (*e));\n" 14829 "}")); 14830 } 14831 14832 TEST_F(FormatTest, GuessLanguageWithChildLines) { 14833 EXPECT_EQ(FormatStyle::LK_Cpp, 14834 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 14835 EXPECT_EQ(FormatStyle::LK_ObjC, 14836 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 14837 EXPECT_EQ( 14838 FormatStyle::LK_Cpp, 14839 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 14840 EXPECT_EQ( 14841 FormatStyle::LK_ObjC, 14842 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 14843 } 14844 14845 TEST_F(FormatTest, TypenameMacros) { 14846 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 14847 14848 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 14849 FormatStyle Google = getGoogleStyleWithColumns(0); 14850 Google.TypenameMacros = TypenameMacros; 14851 verifyFormat("struct foo {\n" 14852 " int bar;\n" 14853 " TAILQ_ENTRY(a) bleh;\n" 14854 "};", 14855 Google); 14856 14857 FormatStyle Macros = getLLVMStyle(); 14858 Macros.TypenameMacros = TypenameMacros; 14859 14860 verifyFormat("STACK_OF(int) a;", Macros); 14861 verifyFormat("STACK_OF(int) *a;", Macros); 14862 verifyFormat("STACK_OF(int const *) *a;", Macros); 14863 verifyFormat("STACK_OF(int *const) *a;", Macros); 14864 verifyFormat("STACK_OF(int, string) a;", Macros); 14865 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 14866 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 14867 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 14868 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 14869 14870 Macros.PointerAlignment = FormatStyle::PAS_Left; 14871 verifyFormat("STACK_OF(int)* a;", Macros); 14872 verifyFormat("STACK_OF(int*)* a;", Macros); 14873 } 14874 14875 TEST_F(FormatTest, AmbersandInLamda) { 14876 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899 14877 FormatStyle AlignStyle = getLLVMStyle(); 14878 AlignStyle.PointerAlignment = FormatStyle::PAS_Left; 14879 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 14880 AlignStyle.PointerAlignment = FormatStyle::PAS_Right; 14881 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 14882 } 14883 14884 TEST_F(FormatTest, SpacesInConditionalStatement) { 14885 FormatStyle Spaces = getLLVMStyle(); 14886 Spaces.SpacesInConditionalStatement = true; 14887 verifyFormat("for ( int i = 0; i; i++ )\n continue;", Spaces); 14888 verifyFormat("if ( !a )\n return;", Spaces); 14889 verifyFormat("if ( a )\n return;", Spaces); 14890 verifyFormat("if constexpr ( a )\n return;", Spaces); 14891 verifyFormat("switch ( a )\ncase 1:\n return;", Spaces); 14892 verifyFormat("while ( a )\n return;", Spaces); 14893 verifyFormat("while ( (a && b) )\n return;", Spaces); 14894 verifyFormat("do {\n} while ( 1 != 0 );", Spaces); 14895 // Check that space on the left of "::" is inserted as expected at beginning 14896 // of condition. 14897 verifyFormat("while ( ::func() )\n return;", Spaces); 14898 } 14899 14900 TEST_F(FormatTest, AlternativeOperators) { 14901 // Test case for ensuring alternate operators are not 14902 // combined with their right most neighbour. 14903 verifyFormat("int a and b;"); 14904 verifyFormat("int a and_eq b;"); 14905 verifyFormat("int a bitand b;"); 14906 verifyFormat("int a bitor b;"); 14907 verifyFormat("int a compl b;"); 14908 verifyFormat("int a not b;"); 14909 verifyFormat("int a not_eq b;"); 14910 verifyFormat("int a or b;"); 14911 verifyFormat("int a xor b;"); 14912 verifyFormat("int a xor_eq b;"); 14913 verifyFormat("return this not_eq bitand other;"); 14914 verifyFormat("bool operator not_eq(const X bitand other)"); 14915 14916 verifyFormat("int a and 5;"); 14917 verifyFormat("int a and_eq 5;"); 14918 verifyFormat("int a bitand 5;"); 14919 verifyFormat("int a bitor 5;"); 14920 verifyFormat("int a compl 5;"); 14921 verifyFormat("int a not 5;"); 14922 verifyFormat("int a not_eq 5;"); 14923 verifyFormat("int a or 5;"); 14924 verifyFormat("int a xor 5;"); 14925 verifyFormat("int a xor_eq 5;"); 14926 14927 verifyFormat("int a compl(5);"); 14928 verifyFormat("int a not(5);"); 14929 14930 /* FIXME handle alternate tokens 14931 * https://en.cppreference.com/w/cpp/language/operator_alternative 14932 // alternative tokens 14933 verifyFormat("compl foo();"); // ~foo(); 14934 verifyFormat("foo() <%%>;"); // foo(); 14935 verifyFormat("void foo() <%%>;"); // void foo(){} 14936 verifyFormat("int a <:1:>;"); // int a[1];[ 14937 verifyFormat("%:define ABC abc"); // #define ABC abc 14938 verifyFormat("%:%:"); // ## 14939 */ 14940 } 14941 14942 TEST_F(FormatTest, STLWhileNotDefineChed) { 14943 verifyFormat("#if defined(while)\n" 14944 "#define while EMIT WARNING C4005\n" 14945 "#endif // while"); 14946 } 14947 14948 TEST_F(FormatTest, OperatorSpacing) { 14949 FormatStyle Style = getLLVMStyle(); 14950 Style.PointerAlignment = FormatStyle::PAS_Right; 14951 verifyFormat("Foo::operator*();", Style); 14952 verifyFormat("Foo::operator void *();", Style); 14953 verifyFormat("Foo::operator()(void *);", Style); 14954 verifyFormat("Foo::operator*(void *);", Style); 14955 verifyFormat("Foo::operator*();", Style); 14956 verifyFormat("operator*(int (*)(), class Foo);", Style); 14957 14958 verifyFormat("Foo::operator&();", Style); 14959 verifyFormat("Foo::operator void &();", Style); 14960 verifyFormat("Foo::operator()(void &);", Style); 14961 verifyFormat("Foo::operator&(void &);", Style); 14962 verifyFormat("Foo::operator&();", Style); 14963 verifyFormat("operator&(int (&)(), class Foo);", Style); 14964 14965 verifyFormat("Foo::operator&&();", Style); 14966 verifyFormat("Foo::operator void &&();", Style); 14967 verifyFormat("Foo::operator()(void &&);", Style); 14968 verifyFormat("Foo::operator&&(void &&);", Style); 14969 verifyFormat("Foo::operator&&();", Style); 14970 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 14971 14972 Style.PointerAlignment = FormatStyle::PAS_Left; 14973 verifyFormat("Foo::operator*();", Style); 14974 verifyFormat("Foo::operator void*();", Style); 14975 verifyFormat("Foo::operator()(void*);", Style); 14976 verifyFormat("Foo::operator*(void*);", Style); 14977 verifyFormat("Foo::operator*();", Style); 14978 verifyFormat("operator*(int (*)(), class Foo);", Style); 14979 14980 verifyFormat("Foo::operator&();", Style); 14981 verifyFormat("Foo::operator void&();", Style); 14982 verifyFormat("Foo::operator()(void&);", Style); 14983 verifyFormat("Foo::operator&(void&);", Style); 14984 verifyFormat("Foo::operator&();", Style); 14985 verifyFormat("operator&(int (&)(), class Foo);", Style); 14986 14987 verifyFormat("Foo::operator&&();", Style); 14988 verifyFormat("Foo::operator void&&();", Style); 14989 verifyFormat("Foo::operator()(void&&);", Style); 14990 verifyFormat("Foo::operator&&(void&&);", Style); 14991 verifyFormat("Foo::operator&&();", Style); 14992 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 14993 14994 Style.PointerAlignment = FormatStyle::PAS_Middle; 14995 verifyFormat("Foo::operator*();", Style); 14996 verifyFormat("Foo::operator void *();", Style); 14997 verifyFormat("Foo::operator()(void *);", Style); 14998 verifyFormat("Foo::operator*(void *);", Style); 14999 verifyFormat("Foo::operator*();", Style); 15000 verifyFormat("operator*(int (*)(), class Foo);", Style); 15001 15002 verifyFormat("Foo::operator&();", Style); 15003 verifyFormat("Foo::operator void &();", Style); 15004 verifyFormat("Foo::operator()(void &);", Style); 15005 verifyFormat("Foo::operator&(void &);", Style); 15006 verifyFormat("Foo::operator&();", Style); 15007 verifyFormat("operator&(int (&)(), class Foo);", Style); 15008 15009 verifyFormat("Foo::operator&&();", Style); 15010 verifyFormat("Foo::operator void &&();", Style); 15011 verifyFormat("Foo::operator()(void &&);", Style); 15012 verifyFormat("Foo::operator&&(void &&);", Style); 15013 verifyFormat("Foo::operator&&();", Style); 15014 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15015 } 15016 15017 } // namespace 15018 } // namespace format 15019 } // namespace clang 15020