1 //===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "clang/Format/Format.h" 10 11 #include "../Tooling/ReplacementTest.h" 12 #include "FormatTestUtils.h" 13 14 #include "clang/Frontend/TextDiagnosticPrinter.h" 15 #include "llvm/Support/Debug.h" 16 #include "llvm/Support/MemoryBuffer.h" 17 #include "gtest/gtest.h" 18 19 #define DEBUG_TYPE "format-test" 20 21 using clang::tooling::ReplacementTest; 22 using clang::tooling::toReplacements; 23 24 namespace clang { 25 namespace format { 26 namespace { 27 28 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); } 29 30 class FormatTest : public ::testing::Test { 31 protected: 32 enum StatusCheck { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck }; 33 34 std::string format(llvm::StringRef Code, 35 const FormatStyle &Style = getLLVMStyle(), 36 StatusCheck CheckComplete = SC_ExpectComplete) { 37 LLVM_DEBUG(llvm::errs() << "---\n"); 38 LLVM_DEBUG(llvm::errs() << Code << "\n\n"); 39 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size())); 40 FormattingAttemptStatus Status; 41 tooling::Replacements Replaces = 42 reformat(Style, Code, Ranges, "<stdin>", &Status); 43 if (CheckComplete != SC_DoNotCheck) { 44 bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete; 45 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete) 46 << Code << "\n\n"; 47 } 48 ReplacementCount = Replaces.size(); 49 auto Result = applyAllReplacements(Code, Replaces); 50 EXPECT_TRUE(static_cast<bool>(Result)); 51 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); 52 return *Result; 53 } 54 55 FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) { 56 Style.ColumnLimit = ColumnLimit; 57 return Style; 58 } 59 60 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 61 return getStyleWithColumns(getLLVMStyle(), ColumnLimit); 62 } 63 64 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) { 65 return getStyleWithColumns(getGoogleStyle(), ColumnLimit); 66 } 67 68 void verifyFormat(llvm::StringRef Expected, llvm::StringRef Code, 69 const FormatStyle &Style = getLLVMStyle()) { 70 EXPECT_EQ(Expected.str(), format(Expected, Style)) 71 << "Expected code is not stable"; 72 EXPECT_EQ(Expected.str(), format(Code, Style)); 73 if (Style.Language == FormatStyle::LK_Cpp) { 74 // Objective-C++ is a superset of C++, so everything checked for C++ 75 // needs to be checked for Objective-C++ as well. 76 FormatStyle ObjCStyle = Style; 77 ObjCStyle.Language = FormatStyle::LK_ObjC; 78 EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle)); 79 } 80 } 81 82 void verifyFormat(llvm::StringRef Code, 83 const FormatStyle &Style = getLLVMStyle()) { 84 verifyFormat(Code, test::messUp(Code), Style); 85 } 86 87 void verifyIncompleteFormat(llvm::StringRef Code, 88 const FormatStyle &Style = getLLVMStyle()) { 89 EXPECT_EQ(Code.str(), 90 format(test::messUp(Code), Style, SC_ExpectIncomplete)); 91 } 92 93 void verifyGoogleFormat(llvm::StringRef Code) { 94 verifyFormat(Code, getGoogleStyle()); 95 } 96 97 void verifyIndependentOfContext(llvm::StringRef text) { 98 verifyFormat(text); 99 verifyFormat(llvm::Twine("void f() { " + text + " }").str()); 100 } 101 102 /// \brief Verify that clang-format does not crash on the given input. 103 void verifyNoCrash(llvm::StringRef Code, 104 const FormatStyle &Style = getLLVMStyle()) { 105 format(Code, Style, SC_DoNotCheck); 106 } 107 108 int ReplacementCount; 109 }; 110 111 TEST_F(FormatTest, MessUp) { 112 EXPECT_EQ("1 2 3", test::messUp("1 2 3")); 113 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n")); 114 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc")); 115 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc")); 116 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne")); 117 } 118 119 TEST_F(FormatTest, DefaultLLVMStyleIsCpp) { 120 EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language); 121 } 122 123 TEST_F(FormatTest, LLVMStyleOverride) { 124 EXPECT_EQ(FormatStyle::LK_Proto, 125 getLLVMStyle(FormatStyle::LK_Proto).Language); 126 } 127 128 //===----------------------------------------------------------------------===// 129 // Basic function tests. 130 //===----------------------------------------------------------------------===// 131 132 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { 133 EXPECT_EQ(";", format(";")); 134 } 135 136 TEST_F(FormatTest, FormatsGlobalStatementsAt0) { 137 EXPECT_EQ("int i;", format(" int i;")); 138 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;")); 139 EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); 140 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); 141 } 142 143 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { 144 EXPECT_EQ("int i;", format("int\ni;")); 145 } 146 147 TEST_F(FormatTest, FormatsNestedBlockStatements) { 148 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}")); 149 } 150 151 TEST_F(FormatTest, FormatsNestedCall) { 152 verifyFormat("Method(f1, f2(f3));"); 153 verifyFormat("Method(f1(f2, f3()));"); 154 verifyFormat("Method(f1(f2, (f3())));"); 155 } 156 157 TEST_F(FormatTest, NestedNameSpecifiers) { 158 verifyFormat("vector<::Type> v;"); 159 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())"); 160 verifyFormat("static constexpr bool Bar = decltype(bar())::value;"); 161 verifyFormat("bool a = 2 < ::SomeFunction();"); 162 verifyFormat("ALWAYS_INLINE ::std::string getName();"); 163 verifyFormat("some::string getName();"); 164 } 165 166 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { 167 EXPECT_EQ("if (a) {\n" 168 " f();\n" 169 "}", 170 format("if(a){f();}")); 171 EXPECT_EQ(4, ReplacementCount); 172 EXPECT_EQ("if (a) {\n" 173 " f();\n" 174 "}", 175 format("if (a) {\n" 176 " f();\n" 177 "}")); 178 EXPECT_EQ(0, ReplacementCount); 179 EXPECT_EQ("/*\r\n" 180 "\r\n" 181 "*/\r\n", 182 format("/*\r\n" 183 "\r\n" 184 "*/\r\n")); 185 EXPECT_EQ(0, ReplacementCount); 186 } 187 188 TEST_F(FormatTest, RemovesEmptyLines) { 189 EXPECT_EQ("class C {\n" 190 " int i;\n" 191 "};", 192 format("class C {\n" 193 " int i;\n" 194 "\n" 195 "};")); 196 197 // Don't remove empty lines at the start of namespaces or extern "C" blocks. 198 EXPECT_EQ("namespace N {\n" 199 "\n" 200 "int i;\n" 201 "}", 202 format("namespace N {\n" 203 "\n" 204 "int i;\n" 205 "}", 206 getGoogleStyle())); 207 EXPECT_EQ("/* something */ namespace N {\n" 208 "\n" 209 "int i;\n" 210 "}", 211 format("/* something */ namespace N {\n" 212 "\n" 213 "int i;\n" 214 "}", 215 getGoogleStyle())); 216 EXPECT_EQ("inline namespace N {\n" 217 "\n" 218 "int i;\n" 219 "}", 220 format("inline namespace N {\n" 221 "\n" 222 "int i;\n" 223 "}", 224 getGoogleStyle())); 225 EXPECT_EQ("/* something */ inline namespace N {\n" 226 "\n" 227 "int i;\n" 228 "}", 229 format("/* something */ inline namespace N {\n" 230 "\n" 231 "int i;\n" 232 "}", 233 getGoogleStyle())); 234 EXPECT_EQ("export namespace N {\n" 235 "\n" 236 "int i;\n" 237 "}", 238 format("export namespace N {\n" 239 "\n" 240 "int i;\n" 241 "}", 242 getGoogleStyle())); 243 EXPECT_EQ("extern /**/ \"C\" /**/ {\n" 244 "\n" 245 "int i;\n" 246 "}", 247 format("extern /**/ \"C\" /**/ {\n" 248 "\n" 249 "int i;\n" 250 "}", 251 getGoogleStyle())); 252 253 // ...but do keep inlining and removing empty lines for non-block extern "C" 254 // functions. 255 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle()); 256 EXPECT_EQ("extern \"C\" int f() {\n" 257 " int i = 42;\n" 258 " return i;\n" 259 "}", 260 format("extern \"C\" int f() {\n" 261 "\n" 262 " int i = 42;\n" 263 " return i;\n" 264 "}", 265 getGoogleStyle())); 266 267 // Remove empty lines at the beginning and end of blocks. 268 EXPECT_EQ("void f() {\n" 269 "\n" 270 " if (a) {\n" 271 "\n" 272 " f();\n" 273 " }\n" 274 "}", 275 format("void f() {\n" 276 "\n" 277 " if (a) {\n" 278 "\n" 279 " f();\n" 280 "\n" 281 " }\n" 282 "\n" 283 "}", 284 getLLVMStyle())); 285 EXPECT_EQ("void f() {\n" 286 " if (a) {\n" 287 " f();\n" 288 " }\n" 289 "}", 290 format("void f() {\n" 291 "\n" 292 " if (a) {\n" 293 "\n" 294 " f();\n" 295 "\n" 296 " }\n" 297 "\n" 298 "}", 299 getGoogleStyle())); 300 301 // Don't remove empty lines in more complex control statements. 302 EXPECT_EQ("void f() {\n" 303 " if (a) {\n" 304 " f();\n" 305 "\n" 306 " } else if (b) {\n" 307 " f();\n" 308 " }\n" 309 "}", 310 format("void f() {\n" 311 " if (a) {\n" 312 " f();\n" 313 "\n" 314 " } else if (b) {\n" 315 " f();\n" 316 "\n" 317 " }\n" 318 "\n" 319 "}")); 320 321 // Don't remove empty lines before namespace endings. 322 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 323 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 324 EXPECT_EQ("namespace {\n" 325 "int i;\n" 326 "\n" 327 "}", 328 format("namespace {\n" 329 "int i;\n" 330 "\n" 331 "}", 332 LLVMWithNoNamespaceFix)); 333 EXPECT_EQ("namespace {\n" 334 "int i;\n" 335 "}", 336 format("namespace {\n" 337 "int i;\n" 338 "}", 339 LLVMWithNoNamespaceFix)); 340 EXPECT_EQ("namespace {\n" 341 "int i;\n" 342 "\n" 343 "};", 344 format("namespace {\n" 345 "int i;\n" 346 "\n" 347 "};", 348 LLVMWithNoNamespaceFix)); 349 EXPECT_EQ("namespace {\n" 350 "int i;\n" 351 "};", 352 format("namespace {\n" 353 "int i;\n" 354 "};", 355 LLVMWithNoNamespaceFix)); 356 EXPECT_EQ("namespace {\n" 357 "int i;\n" 358 "\n" 359 "}", 360 format("namespace {\n" 361 "int i;\n" 362 "\n" 363 "}")); 364 EXPECT_EQ("namespace {\n" 365 "int i;\n" 366 "\n" 367 "} // namespace", 368 format("namespace {\n" 369 "int i;\n" 370 "\n" 371 "} // namespace")); 372 373 FormatStyle Style = getLLVMStyle(); 374 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 375 Style.MaxEmptyLinesToKeep = 2; 376 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 377 Style.BraceWrapping.AfterClass = true; 378 Style.BraceWrapping.AfterFunction = true; 379 Style.KeepEmptyLinesAtTheStartOfBlocks = false; 380 381 EXPECT_EQ("class Foo\n" 382 "{\n" 383 " Foo() {}\n" 384 "\n" 385 " void funk() {}\n" 386 "};", 387 format("class Foo\n" 388 "{\n" 389 " Foo()\n" 390 " {\n" 391 " }\n" 392 "\n" 393 " void funk() {}\n" 394 "};", 395 Style)); 396 } 397 398 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) { 399 verifyFormat("x = (a) and (b);"); 400 verifyFormat("x = (a) or (b);"); 401 verifyFormat("x = (a) bitand (b);"); 402 verifyFormat("x = (a) bitor (b);"); 403 verifyFormat("x = (a) not_eq (b);"); 404 verifyFormat("x = (a) and_eq (b);"); 405 verifyFormat("x = (a) or_eq (b);"); 406 verifyFormat("x = (a) xor (b);"); 407 } 408 409 TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) { 410 verifyFormat("x = compl(a);"); 411 verifyFormat("x = not(a);"); 412 verifyFormat("x = bitand(a);"); 413 // Unary operator must not be merged with the next identifier 414 verifyFormat("x = compl a;"); 415 verifyFormat("x = not a;"); 416 verifyFormat("x = bitand a;"); 417 } 418 419 //===----------------------------------------------------------------------===// 420 // Tests for control statements. 421 //===----------------------------------------------------------------------===// 422 423 TEST_F(FormatTest, FormatIfWithoutCompoundStatement) { 424 verifyFormat("if (true)\n f();\ng();"); 425 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();"); 426 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();"); 427 verifyFormat("if constexpr (true)\n" 428 " f();\ng();"); 429 verifyFormat("if CONSTEXPR (true)\n" 430 " f();\ng();"); 431 verifyFormat("if constexpr (a)\n" 432 " if constexpr (b)\n" 433 " if constexpr (c)\n" 434 " g();\n" 435 "h();"); 436 verifyFormat("if CONSTEXPR (a)\n" 437 " if CONSTEXPR (b)\n" 438 " if CONSTEXPR (c)\n" 439 " g();\n" 440 "h();"); 441 verifyFormat("if constexpr (a)\n" 442 " if constexpr (b) {\n" 443 " f();\n" 444 " }\n" 445 "g();"); 446 verifyFormat("if CONSTEXPR (a)\n" 447 " if CONSTEXPR (b) {\n" 448 " f();\n" 449 " }\n" 450 "g();"); 451 452 FormatStyle AllowsMergedIf = getLLVMStyle(); 453 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 454 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 455 FormatStyle::SIS_WithoutElse; 456 verifyFormat("if (a)\n" 457 " // comment\n" 458 " f();", 459 AllowsMergedIf); 460 verifyFormat("{\n" 461 " if (a)\n" 462 " label:\n" 463 " f();\n" 464 "}", 465 AllowsMergedIf); 466 verifyFormat("#define A \\\n" 467 " if (a) \\\n" 468 " label: \\\n" 469 " f()", 470 AllowsMergedIf); 471 verifyFormat("if (a)\n" 472 " ;", 473 AllowsMergedIf); 474 verifyFormat("if (a)\n" 475 " if (b) return;", 476 AllowsMergedIf); 477 478 verifyFormat("if (a) // Can't merge this\n" 479 " f();\n", 480 AllowsMergedIf); 481 verifyFormat("if (a) /* still don't merge */\n" 482 " f();", 483 AllowsMergedIf); 484 verifyFormat("if (a) { // Never merge this\n" 485 " f();\n" 486 "}", 487 AllowsMergedIf); 488 verifyFormat("if (a) { /* Never merge this */\n" 489 " f();\n" 490 "}", 491 AllowsMergedIf); 492 493 AllowsMergedIf.ColumnLimit = 14; 494 verifyFormat("if (a) return;", AllowsMergedIf); 495 verifyFormat("if (aaaaaaaaa)\n" 496 " return;", 497 AllowsMergedIf); 498 499 AllowsMergedIf.ColumnLimit = 13; 500 verifyFormat("if (a)\n return;", AllowsMergedIf); 501 } 502 503 TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) { 504 FormatStyle AllowsMergedIf = getLLVMStyle(); 505 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 506 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 507 FormatStyle::SIS_WithoutElse; 508 verifyFormat("if (a)\n" 509 " f();\n" 510 "else {\n" 511 " g();\n" 512 "}", 513 AllowsMergedIf); 514 verifyFormat("if (a)\n" 515 " f();\n" 516 "else\n" 517 " g();\n", 518 AllowsMergedIf); 519 520 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 521 522 verifyFormat("if (a) f();\n" 523 "else {\n" 524 " g();\n" 525 "}", 526 AllowsMergedIf); 527 verifyFormat("if (a) f();\n" 528 "else {\n" 529 " if (a) f();\n" 530 " else {\n" 531 " g();\n" 532 " }\n" 533 " g();\n" 534 "}", 535 AllowsMergedIf); 536 } 537 538 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) { 539 FormatStyle AllowsMergedLoops = getLLVMStyle(); 540 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true; 541 verifyFormat("while (true) continue;", AllowsMergedLoops); 542 verifyFormat("for (;;) continue;", AllowsMergedLoops); 543 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops); 544 verifyFormat("while (true)\n" 545 " ;", 546 AllowsMergedLoops); 547 verifyFormat("for (;;)\n" 548 " ;", 549 AllowsMergedLoops); 550 verifyFormat("for (;;)\n" 551 " for (;;) continue;", 552 AllowsMergedLoops); 553 verifyFormat("for (;;) // Can't merge this\n" 554 " continue;", 555 AllowsMergedLoops); 556 verifyFormat("for (;;) /* still don't merge */\n" 557 " continue;", 558 AllowsMergedLoops); 559 verifyFormat("do a++;\n" 560 "while (true);", 561 AllowsMergedLoops); 562 verifyFormat("do /* Don't merge */\n" 563 " a++;\n" 564 "while (true);", 565 AllowsMergedLoops); 566 verifyFormat("do // Don't merge\n" 567 " a++;\n" 568 "while (true);", 569 AllowsMergedLoops); 570 verifyFormat("do\n" 571 " // Don't merge\n" 572 " a++;\n" 573 "while (true);", 574 AllowsMergedLoops); 575 // Without braces labels are interpreted differently. 576 verifyFormat("{\n" 577 " do\n" 578 " label:\n" 579 " a++;\n" 580 " while (true);\n" 581 "}", 582 AllowsMergedLoops); 583 } 584 585 TEST_F(FormatTest, FormatShortBracedStatements) { 586 FormatStyle AllowSimpleBracedStatements = getLLVMStyle(); 587 AllowSimpleBracedStatements.ColumnLimit = 40; 588 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = 589 FormatStyle::SBS_Always; 590 591 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 592 FormatStyle::SIS_WithoutElse; 593 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 594 595 AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom; 596 AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true; 597 AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false; 598 599 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 600 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 601 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 602 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 603 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 604 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 605 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 606 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 607 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 608 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 609 verifyFormat("if (true) {\n" 610 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 611 "}", 612 AllowSimpleBracedStatements); 613 verifyFormat("if (true) { //\n" 614 " f();\n" 615 "}", 616 AllowSimpleBracedStatements); 617 verifyFormat("if (true) {\n" 618 " f();\n" 619 " f();\n" 620 "}", 621 AllowSimpleBracedStatements); 622 verifyFormat("if (true) {\n" 623 " f();\n" 624 "} else {\n" 625 " f();\n" 626 "}", 627 AllowSimpleBracedStatements); 628 629 verifyFormat("struct A2 {\n" 630 " int X;\n" 631 "};", 632 AllowSimpleBracedStatements); 633 verifyFormat("typedef struct A2 {\n" 634 " int X;\n" 635 "} A2_t;", 636 AllowSimpleBracedStatements); 637 verifyFormat("template <int> struct A2 {\n" 638 " struct B {};\n" 639 "};", 640 AllowSimpleBracedStatements); 641 642 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 643 FormatStyle::SIS_Never; 644 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 645 verifyFormat("if (true) {\n" 646 " f();\n" 647 "}", 648 AllowSimpleBracedStatements); 649 verifyFormat("if (true) {\n" 650 " f();\n" 651 "} else {\n" 652 " f();\n" 653 "}", 654 AllowSimpleBracedStatements); 655 656 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 657 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 658 verifyFormat("while (true) {\n" 659 " f();\n" 660 "}", 661 AllowSimpleBracedStatements); 662 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 663 verifyFormat("for (;;) {\n" 664 " f();\n" 665 "}", 666 AllowSimpleBracedStatements); 667 668 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 669 FormatStyle::SIS_WithoutElse; 670 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 671 AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement = 672 FormatStyle::BWACS_Always; 673 674 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 675 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 676 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 677 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 678 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 679 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 680 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 681 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 682 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 683 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 684 verifyFormat("if (true)\n" 685 "{\n" 686 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 687 "}", 688 AllowSimpleBracedStatements); 689 verifyFormat("if (true)\n" 690 "{ //\n" 691 " f();\n" 692 "}", 693 AllowSimpleBracedStatements); 694 verifyFormat("if (true)\n" 695 "{\n" 696 " f();\n" 697 " f();\n" 698 "}", 699 AllowSimpleBracedStatements); 700 verifyFormat("if (true)\n" 701 "{\n" 702 " f();\n" 703 "} else\n" 704 "{\n" 705 " f();\n" 706 "}", 707 AllowSimpleBracedStatements); 708 709 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 710 FormatStyle::SIS_Never; 711 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 712 verifyFormat("if (true)\n" 713 "{\n" 714 " f();\n" 715 "}", 716 AllowSimpleBracedStatements); 717 verifyFormat("if (true)\n" 718 "{\n" 719 " f();\n" 720 "} else\n" 721 "{\n" 722 " f();\n" 723 "}", 724 AllowSimpleBracedStatements); 725 726 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 727 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 728 verifyFormat("while (true)\n" 729 "{\n" 730 " f();\n" 731 "}", 732 AllowSimpleBracedStatements); 733 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 734 verifyFormat("for (;;)\n" 735 "{\n" 736 " f();\n" 737 "}", 738 AllowSimpleBracedStatements); 739 } 740 741 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) { 742 FormatStyle Style = getLLVMStyleWithColumns(60); 743 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 744 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 745 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 746 EXPECT_EQ("#define A \\\n" 747 " if (HANDLEwernufrnuLwrmviferuvnierv) \\\n" 748 " { RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; }\n" 749 "X;", 750 format("#define A \\\n" 751 " if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n" 752 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n" 753 " }\n" 754 "X;", 755 Style)); 756 } 757 758 TEST_F(FormatTest, ParseIfElse) { 759 verifyFormat("if (true)\n" 760 " if (true)\n" 761 " if (true)\n" 762 " f();\n" 763 " else\n" 764 " g();\n" 765 " else\n" 766 " h();\n" 767 "else\n" 768 " i();"); 769 verifyFormat("if (true)\n" 770 " if (true)\n" 771 " if (true) {\n" 772 " if (true)\n" 773 " f();\n" 774 " } else {\n" 775 " g();\n" 776 " }\n" 777 " else\n" 778 " h();\n" 779 "else {\n" 780 " i();\n" 781 "}"); 782 verifyFormat("if (true)\n" 783 " if constexpr (true)\n" 784 " if (true) {\n" 785 " if constexpr (true)\n" 786 " f();\n" 787 " } else {\n" 788 " g();\n" 789 " }\n" 790 " else\n" 791 " h();\n" 792 "else {\n" 793 " i();\n" 794 "}"); 795 verifyFormat("if (true)\n" 796 " if CONSTEXPR (true)\n" 797 " if (true) {\n" 798 " if CONSTEXPR (true)\n" 799 " f();\n" 800 " } else {\n" 801 " g();\n" 802 " }\n" 803 " else\n" 804 " h();\n" 805 "else {\n" 806 " i();\n" 807 "}"); 808 verifyFormat("void f() {\n" 809 " if (a) {\n" 810 " } else {\n" 811 " }\n" 812 "}"); 813 } 814 815 TEST_F(FormatTest, ElseIf) { 816 verifyFormat("if (a) {\n} else if (b) {\n}"); 817 verifyFormat("if (a)\n" 818 " f();\n" 819 "else if (b)\n" 820 " g();\n" 821 "else\n" 822 " h();"); 823 verifyFormat("if constexpr (a)\n" 824 " f();\n" 825 "else if constexpr (b)\n" 826 " g();\n" 827 "else\n" 828 " h();"); 829 verifyFormat("if CONSTEXPR (a)\n" 830 " f();\n" 831 "else if CONSTEXPR (b)\n" 832 " g();\n" 833 "else\n" 834 " h();"); 835 verifyFormat("if (a) {\n" 836 " f();\n" 837 "}\n" 838 "// or else ..\n" 839 "else {\n" 840 " g()\n" 841 "}"); 842 843 verifyFormat("if (a) {\n" 844 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 845 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 846 "}"); 847 verifyFormat("if (a) {\n" 848 "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 849 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 850 "}"); 851 verifyFormat("if (a) {\n" 852 "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 853 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 854 "}"); 855 verifyFormat("if (a) {\n" 856 "} else if (\n" 857 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 858 "}", 859 getLLVMStyleWithColumns(62)); 860 verifyFormat("if (a) {\n" 861 "} else if constexpr (\n" 862 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 863 "}", 864 getLLVMStyleWithColumns(62)); 865 verifyFormat("if (a) {\n" 866 "} else if CONSTEXPR (\n" 867 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 868 "}", 869 getLLVMStyleWithColumns(62)); 870 } 871 872 TEST_F(FormatTest, FormatsForLoop) { 873 verifyFormat( 874 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 875 " ++VeryVeryLongLoopVariable)\n" 876 " ;"); 877 verifyFormat("for (;;)\n" 878 " f();"); 879 verifyFormat("for (;;) {\n}"); 880 verifyFormat("for (;;) {\n" 881 " f();\n" 882 "}"); 883 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 884 885 verifyFormat( 886 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 887 " E = UnwrappedLines.end();\n" 888 " I != E; ++I) {\n}"); 889 890 verifyFormat( 891 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 892 " ++IIIII) {\n}"); 893 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 894 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 895 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 896 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 897 " I = FD->getDeclsInPrototypeScope().begin(),\n" 898 " E = FD->getDeclsInPrototypeScope().end();\n" 899 " I != E; ++I) {\n}"); 900 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n" 901 " I = Container.begin(),\n" 902 " E = Container.end();\n" 903 " I != E; ++I) {\n}", 904 getLLVMStyleWithColumns(76)); 905 906 verifyFormat( 907 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 908 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 909 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 910 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 911 " ++aaaaaaaaaaa) {\n}"); 912 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 913 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n" 914 " ++i) {\n}"); 915 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 916 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 917 "}"); 918 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 919 " aaaaaaaaaa);\n" 920 " iter; ++iter) {\n" 921 "}"); 922 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 923 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 924 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n" 925 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {"); 926 927 // These should not be formatted as Objective-C for-in loops. 928 verifyFormat("for (Foo *x = 0; x != in; x++) {\n}"); 929 verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}"); 930 verifyFormat("Foo *x;\nfor (x in y) {\n}"); 931 verifyFormat( 932 "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}"); 933 934 FormatStyle NoBinPacking = getLLVMStyle(); 935 NoBinPacking.BinPackParameters = false; 936 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 937 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 938 " aaaaaaaaaaaaaaaa,\n" 939 " aaaaaaaaaaaaaaaa,\n" 940 " aaaaaaaaaaaaaaaa);\n" 941 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 942 "}", 943 NoBinPacking); 944 verifyFormat( 945 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 946 " E = UnwrappedLines.end();\n" 947 " I != E;\n" 948 " ++I) {\n}", 949 NoBinPacking); 950 951 FormatStyle AlignLeft = getLLVMStyle(); 952 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 953 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft); 954 } 955 956 TEST_F(FormatTest, RangeBasedForLoops) { 957 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 958 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 959 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 960 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 961 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 962 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 963 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n" 964 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}"); 965 } 966 967 TEST_F(FormatTest, ForEachLoops) { 968 verifyFormat("void f() {\n" 969 " foreach (Item *item, itemlist) {}\n" 970 " Q_FOREACH (Item *item, itemlist) {}\n" 971 " BOOST_FOREACH (Item *item, itemlist) {}\n" 972 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 973 "}"); 974 975 // As function-like macros. 976 verifyFormat("#define foreach(x, y)\n" 977 "#define Q_FOREACH(x, y)\n" 978 "#define BOOST_FOREACH(x, y)\n" 979 "#define UNKNOWN_FOREACH(x, y)\n"); 980 981 // Not as function-like macros. 982 verifyFormat("#define foreach (x, y)\n" 983 "#define Q_FOREACH (x, y)\n" 984 "#define BOOST_FOREACH (x, y)\n" 985 "#define UNKNOWN_FOREACH (x, y)\n"); 986 } 987 988 TEST_F(FormatTest, FormatsWhileLoop) { 989 verifyFormat("while (true) {\n}"); 990 verifyFormat("while (true)\n" 991 " f();"); 992 verifyFormat("while () {\n}"); 993 verifyFormat("while () {\n" 994 " f();\n" 995 "}"); 996 } 997 998 TEST_F(FormatTest, FormatsDoWhile) { 999 verifyFormat("do {\n" 1000 " do_something();\n" 1001 "} while (something());"); 1002 verifyFormat("do\n" 1003 " do_something();\n" 1004 "while (something());"); 1005 } 1006 1007 TEST_F(FormatTest, FormatsSwitchStatement) { 1008 verifyFormat("switch (x) {\n" 1009 "case 1:\n" 1010 " f();\n" 1011 " break;\n" 1012 "case kFoo:\n" 1013 "case ns::kBar:\n" 1014 "case kBaz:\n" 1015 " break;\n" 1016 "default:\n" 1017 " g();\n" 1018 " break;\n" 1019 "}"); 1020 verifyFormat("switch (x) {\n" 1021 "case 1: {\n" 1022 " f();\n" 1023 " break;\n" 1024 "}\n" 1025 "case 2: {\n" 1026 " break;\n" 1027 "}\n" 1028 "}"); 1029 verifyFormat("switch (x) {\n" 1030 "case 1: {\n" 1031 " f();\n" 1032 " {\n" 1033 " g();\n" 1034 " h();\n" 1035 " }\n" 1036 " break;\n" 1037 "}\n" 1038 "}"); 1039 verifyFormat("switch (x) {\n" 1040 "case 1: {\n" 1041 " f();\n" 1042 " if (foo) {\n" 1043 " g();\n" 1044 " h();\n" 1045 " }\n" 1046 " break;\n" 1047 "}\n" 1048 "}"); 1049 verifyFormat("switch (x) {\n" 1050 "case 1: {\n" 1051 " f();\n" 1052 " g();\n" 1053 "} break;\n" 1054 "}"); 1055 verifyFormat("switch (test)\n" 1056 " ;"); 1057 verifyFormat("switch (x) {\n" 1058 "default: {\n" 1059 " // Do nothing.\n" 1060 "}\n" 1061 "}"); 1062 verifyFormat("switch (x) {\n" 1063 "// comment\n" 1064 "// if 1, do f()\n" 1065 "case 1:\n" 1066 " f();\n" 1067 "}"); 1068 verifyFormat("switch (x) {\n" 1069 "case 1:\n" 1070 " // Do amazing stuff\n" 1071 " {\n" 1072 " f();\n" 1073 " g();\n" 1074 " }\n" 1075 " break;\n" 1076 "}"); 1077 verifyFormat("#define A \\\n" 1078 " switch (x) { \\\n" 1079 " case a: \\\n" 1080 " foo = b; \\\n" 1081 " }", 1082 getLLVMStyleWithColumns(20)); 1083 verifyFormat("#define OPERATION_CASE(name) \\\n" 1084 " case OP_name: \\\n" 1085 " return operations::Operation##name\n", 1086 getLLVMStyleWithColumns(40)); 1087 verifyFormat("switch (x) {\n" 1088 "case 1:;\n" 1089 "default:;\n" 1090 " int i;\n" 1091 "}"); 1092 1093 verifyGoogleFormat("switch (x) {\n" 1094 " case 1:\n" 1095 " f();\n" 1096 " break;\n" 1097 " case kFoo:\n" 1098 " case ns::kBar:\n" 1099 " case kBaz:\n" 1100 " break;\n" 1101 " default:\n" 1102 " g();\n" 1103 " break;\n" 1104 "}"); 1105 verifyGoogleFormat("switch (x) {\n" 1106 " case 1: {\n" 1107 " f();\n" 1108 " break;\n" 1109 " }\n" 1110 "}"); 1111 verifyGoogleFormat("switch (test)\n" 1112 " ;"); 1113 1114 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 1115 " case OP_name: \\\n" 1116 " return operations::Operation##name\n"); 1117 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 1118 " // Get the correction operation class.\n" 1119 " switch (OpCode) {\n" 1120 " CASE(Add);\n" 1121 " CASE(Subtract);\n" 1122 " default:\n" 1123 " return operations::Unknown;\n" 1124 " }\n" 1125 "#undef OPERATION_CASE\n" 1126 "}"); 1127 verifyFormat("DEBUG({\n" 1128 " switch (x) {\n" 1129 " case A:\n" 1130 " f();\n" 1131 " break;\n" 1132 " // fallthrough\n" 1133 " case B:\n" 1134 " g();\n" 1135 " break;\n" 1136 " }\n" 1137 "});"); 1138 EXPECT_EQ("DEBUG({\n" 1139 " switch (x) {\n" 1140 " case A:\n" 1141 " f();\n" 1142 " break;\n" 1143 " // On B:\n" 1144 " case B:\n" 1145 " g();\n" 1146 " break;\n" 1147 " }\n" 1148 "});", 1149 format("DEBUG({\n" 1150 " switch (x) {\n" 1151 " case A:\n" 1152 " f();\n" 1153 " break;\n" 1154 " // On B:\n" 1155 " case B:\n" 1156 " g();\n" 1157 " break;\n" 1158 " }\n" 1159 "});", 1160 getLLVMStyle())); 1161 EXPECT_EQ("switch (n) {\n" 1162 "case 0: {\n" 1163 " return false;\n" 1164 "}\n" 1165 "default: {\n" 1166 " return true;\n" 1167 "}\n" 1168 "}", 1169 format("switch (n)\n" 1170 "{\n" 1171 "case 0: {\n" 1172 " return false;\n" 1173 "}\n" 1174 "default: {\n" 1175 " return true;\n" 1176 "}\n" 1177 "}", 1178 getLLVMStyle())); 1179 verifyFormat("switch (a) {\n" 1180 "case (b):\n" 1181 " return;\n" 1182 "}"); 1183 1184 verifyFormat("switch (a) {\n" 1185 "case some_namespace::\n" 1186 " some_constant:\n" 1187 " return;\n" 1188 "}", 1189 getLLVMStyleWithColumns(34)); 1190 1191 FormatStyle Style = getLLVMStyle(); 1192 Style.IndentCaseLabels = true; 1193 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 1194 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1195 Style.BraceWrapping.AfterCaseLabel = true; 1196 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1197 EXPECT_EQ("switch (n)\n" 1198 "{\n" 1199 " case 0:\n" 1200 " {\n" 1201 " return false;\n" 1202 " }\n" 1203 " default:\n" 1204 " {\n" 1205 " return true;\n" 1206 " }\n" 1207 "}", 1208 format("switch (n) {\n" 1209 " case 0: {\n" 1210 " return false;\n" 1211 " }\n" 1212 " default: {\n" 1213 " return true;\n" 1214 " }\n" 1215 "}", 1216 Style)); 1217 Style.BraceWrapping.AfterCaseLabel = false; 1218 EXPECT_EQ("switch (n)\n" 1219 "{\n" 1220 " case 0: {\n" 1221 " return false;\n" 1222 " }\n" 1223 " default: {\n" 1224 " return true;\n" 1225 " }\n" 1226 "}", 1227 format("switch (n) {\n" 1228 " case 0:\n" 1229 " {\n" 1230 " return false;\n" 1231 " }\n" 1232 " default:\n" 1233 " {\n" 1234 " return true;\n" 1235 " }\n" 1236 "}", 1237 Style)); 1238 Style.IndentCaseLabels = false; 1239 Style.IndentCaseBlocks = true; 1240 EXPECT_EQ("switch (n)\n" 1241 "{\n" 1242 "case 0:\n" 1243 " {\n" 1244 " return false;\n" 1245 " }\n" 1246 "case 1:\n" 1247 " break;\n" 1248 "default:\n" 1249 " {\n" 1250 " return true;\n" 1251 " }\n" 1252 "}", 1253 format("switch (n) {\n" 1254 "case 0: {\n" 1255 " return false;\n" 1256 "}\n" 1257 "case 1:\n" 1258 " break;\n" 1259 "default: {\n" 1260 " return true;\n" 1261 "}\n" 1262 "}", 1263 Style)); 1264 Style.IndentCaseLabels = true; 1265 Style.IndentCaseBlocks = true; 1266 EXPECT_EQ("switch (n)\n" 1267 "{\n" 1268 " case 0:\n" 1269 " {\n" 1270 " return false;\n" 1271 " }\n" 1272 " case 1:\n" 1273 " break;\n" 1274 " default:\n" 1275 " {\n" 1276 " return true;\n" 1277 " }\n" 1278 "}", 1279 format("switch (n) {\n" 1280 "case 0: {\n" 1281 " return false;\n" 1282 "}\n" 1283 "case 1:\n" 1284 " break;\n" 1285 "default: {\n" 1286 " return true;\n" 1287 "}\n" 1288 "}", 1289 Style)); 1290 } 1291 1292 TEST_F(FormatTest, CaseRanges) { 1293 verifyFormat("switch (x) {\n" 1294 "case 'A' ... 'Z':\n" 1295 "case 1 ... 5:\n" 1296 "case a ... b:\n" 1297 " break;\n" 1298 "}"); 1299 } 1300 1301 TEST_F(FormatTest, ShortCaseLabels) { 1302 FormatStyle Style = getLLVMStyle(); 1303 Style.AllowShortCaseLabelsOnASingleLine = true; 1304 verifyFormat("switch (a) {\n" 1305 "case 1: x = 1; break;\n" 1306 "case 2: return;\n" 1307 "case 3:\n" 1308 "case 4:\n" 1309 "case 5: return;\n" 1310 "case 6: // comment\n" 1311 " return;\n" 1312 "case 7:\n" 1313 " // comment\n" 1314 " return;\n" 1315 "case 8:\n" 1316 " x = 8; // comment\n" 1317 " break;\n" 1318 "default: y = 1; break;\n" 1319 "}", 1320 Style); 1321 verifyFormat("switch (a) {\n" 1322 "case 0: return; // comment\n" 1323 "case 1: break; // comment\n" 1324 "case 2: return;\n" 1325 "// comment\n" 1326 "case 3: return;\n" 1327 "// comment 1\n" 1328 "// comment 2\n" 1329 "// comment 3\n" 1330 "case 4: break; /* comment */\n" 1331 "case 5:\n" 1332 " // comment\n" 1333 " break;\n" 1334 "case 6: /* comment */ x = 1; break;\n" 1335 "case 7: x = /* comment */ 1; break;\n" 1336 "case 8:\n" 1337 " x = 1; /* comment */\n" 1338 " break;\n" 1339 "case 9:\n" 1340 " break; // comment line 1\n" 1341 " // comment line 2\n" 1342 "}", 1343 Style); 1344 EXPECT_EQ("switch (a) {\n" 1345 "case 1:\n" 1346 " x = 8;\n" 1347 " // fall through\n" 1348 "case 2: x = 8;\n" 1349 "// comment\n" 1350 "case 3:\n" 1351 " return; /* comment line 1\n" 1352 " * comment line 2 */\n" 1353 "case 4: i = 8;\n" 1354 "// something else\n" 1355 "#if FOO\n" 1356 "case 5: break;\n" 1357 "#endif\n" 1358 "}", 1359 format("switch (a) {\n" 1360 "case 1: x = 8;\n" 1361 " // fall through\n" 1362 "case 2:\n" 1363 " x = 8;\n" 1364 "// comment\n" 1365 "case 3:\n" 1366 " return; /* comment line 1\n" 1367 " * comment line 2 */\n" 1368 "case 4:\n" 1369 " i = 8;\n" 1370 "// something else\n" 1371 "#if FOO\n" 1372 "case 5: break;\n" 1373 "#endif\n" 1374 "}", 1375 Style)); 1376 EXPECT_EQ("switch (a) {\n" 1377 "case 0:\n" 1378 " return; // long long long long long long long long long long " 1379 "long long comment\n" 1380 " // line\n" 1381 "}", 1382 format("switch (a) {\n" 1383 "case 0: return; // long long long long long long long long " 1384 "long long long long comment line\n" 1385 "}", 1386 Style)); 1387 EXPECT_EQ("switch (a) {\n" 1388 "case 0:\n" 1389 " return; /* long long long long long long long long long long " 1390 "long long comment\n" 1391 " line */\n" 1392 "}", 1393 format("switch (a) {\n" 1394 "case 0: return; /* long long long long long long long long " 1395 "long long long long comment line */\n" 1396 "}", 1397 Style)); 1398 verifyFormat("switch (a) {\n" 1399 "#if FOO\n" 1400 "case 0: return 0;\n" 1401 "#endif\n" 1402 "}", 1403 Style); 1404 verifyFormat("switch (a) {\n" 1405 "case 1: {\n" 1406 "}\n" 1407 "case 2: {\n" 1408 " return;\n" 1409 "}\n" 1410 "case 3: {\n" 1411 " x = 1;\n" 1412 " return;\n" 1413 "}\n" 1414 "case 4:\n" 1415 " if (x)\n" 1416 " return;\n" 1417 "}", 1418 Style); 1419 Style.ColumnLimit = 21; 1420 verifyFormat("switch (a) {\n" 1421 "case 1: x = 1; break;\n" 1422 "case 2: return;\n" 1423 "case 3:\n" 1424 "case 4:\n" 1425 "case 5: return;\n" 1426 "default:\n" 1427 " y = 1;\n" 1428 " break;\n" 1429 "}", 1430 Style); 1431 Style.ColumnLimit = 80; 1432 Style.AllowShortCaseLabelsOnASingleLine = false; 1433 Style.IndentCaseLabels = true; 1434 EXPECT_EQ("switch (n) {\n" 1435 " default /*comments*/:\n" 1436 " return true;\n" 1437 " case 0:\n" 1438 " return false;\n" 1439 "}", 1440 format("switch (n) {\n" 1441 "default/*comments*/:\n" 1442 " return true;\n" 1443 "case 0:\n" 1444 " return false;\n" 1445 "}", 1446 Style)); 1447 Style.AllowShortCaseLabelsOnASingleLine = true; 1448 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1449 Style.BraceWrapping.AfterCaseLabel = true; 1450 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1451 EXPECT_EQ("switch (n)\n" 1452 "{\n" 1453 " case 0:\n" 1454 " {\n" 1455 " return false;\n" 1456 " }\n" 1457 " default:\n" 1458 " {\n" 1459 " return true;\n" 1460 " }\n" 1461 "}", 1462 format("switch (n) {\n" 1463 " case 0: {\n" 1464 " return false;\n" 1465 " }\n" 1466 " default:\n" 1467 " {\n" 1468 " return true;\n" 1469 " }\n" 1470 "}", 1471 Style)); 1472 } 1473 1474 TEST_F(FormatTest, FormatsLabels) { 1475 verifyFormat("void f() {\n" 1476 " some_code();\n" 1477 "test_label:\n" 1478 " some_other_code();\n" 1479 " {\n" 1480 " some_more_code();\n" 1481 " another_label:\n" 1482 " some_more_code();\n" 1483 " }\n" 1484 "}"); 1485 verifyFormat("{\n" 1486 " some_code();\n" 1487 "test_label:\n" 1488 " some_other_code();\n" 1489 "}"); 1490 verifyFormat("{\n" 1491 " some_code();\n" 1492 "test_label:;\n" 1493 " int i = 0;\n" 1494 "}"); 1495 FormatStyle Style = getLLVMStyle(); 1496 Style.IndentGotoLabels = false; 1497 verifyFormat("void f() {\n" 1498 " some_code();\n" 1499 "test_label:\n" 1500 " some_other_code();\n" 1501 " {\n" 1502 " some_more_code();\n" 1503 "another_label:\n" 1504 " some_more_code();\n" 1505 " }\n" 1506 "}", 1507 Style); 1508 verifyFormat("{\n" 1509 " some_code();\n" 1510 "test_label:\n" 1511 " some_other_code();\n" 1512 "}", 1513 Style); 1514 verifyFormat("{\n" 1515 " some_code();\n" 1516 "test_label:;\n" 1517 " int i = 0;\n" 1518 "}"); 1519 } 1520 1521 TEST_F(FormatTest, MultiLineControlStatements) { 1522 FormatStyle Style = getLLVMStyle(); 1523 Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom; 1524 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine; 1525 Style.ColumnLimit = 20; 1526 // Short lines should keep opening brace on same line. 1527 EXPECT_EQ("if (foo) {\n" 1528 " bar();\n" 1529 "}", 1530 format("if(foo){bar();}", Style)); 1531 EXPECT_EQ("if (foo) {\n" 1532 " bar();\n" 1533 "} else {\n" 1534 " baz();\n" 1535 "}", 1536 format("if(foo){bar();}else{baz();}", Style)); 1537 EXPECT_EQ("if (foo && bar) {\n" 1538 " baz();\n" 1539 "}", 1540 format("if(foo&&bar){baz();}", Style)); 1541 EXPECT_EQ("if (foo) {\n" 1542 " bar();\n" 1543 "} else if (baz) {\n" 1544 " quux();\n" 1545 "}", 1546 format("if(foo){bar();}else if(baz){quux();}", Style)); 1547 EXPECT_EQ( 1548 "if (foo) {\n" 1549 " bar();\n" 1550 "} else if (baz) {\n" 1551 " quux();\n" 1552 "} else {\n" 1553 " foobar();\n" 1554 "}", 1555 format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style)); 1556 EXPECT_EQ("for (;;) {\n" 1557 " foo();\n" 1558 "}", 1559 format("for(;;){foo();}")); 1560 EXPECT_EQ("while (1) {\n" 1561 " foo();\n" 1562 "}", 1563 format("while(1){foo();}", Style)); 1564 EXPECT_EQ("switch (foo) {\n" 1565 "case bar:\n" 1566 " return;\n" 1567 "}", 1568 format("switch(foo){case bar:return;}", Style)); 1569 EXPECT_EQ("try {\n" 1570 " foo();\n" 1571 "} catch (...) {\n" 1572 " bar();\n" 1573 "}", 1574 format("try{foo();}catch(...){bar();}", Style)); 1575 EXPECT_EQ("do {\n" 1576 " foo();\n" 1577 "} while (bar &&\n" 1578 " baz);", 1579 format("do{foo();}while(bar&&baz);", Style)); 1580 // Long lines should put opening brace on new line. 1581 EXPECT_EQ("if (foo && bar &&\n" 1582 " baz)\n" 1583 "{\n" 1584 " quux();\n" 1585 "}", 1586 format("if(foo&&bar&&baz){quux();}", Style)); 1587 EXPECT_EQ("if (foo && bar &&\n" 1588 " baz)\n" 1589 "{\n" 1590 " quux();\n" 1591 "}", 1592 format("if (foo && bar &&\n" 1593 " baz) {\n" 1594 " quux();\n" 1595 "}", 1596 Style)); 1597 EXPECT_EQ("if (foo) {\n" 1598 " bar();\n" 1599 "} else if (baz ||\n" 1600 " quux)\n" 1601 "{\n" 1602 " foobar();\n" 1603 "}", 1604 format("if(foo){bar();}else if(baz||quux){foobar();}", Style)); 1605 EXPECT_EQ( 1606 "if (foo) {\n" 1607 " bar();\n" 1608 "} else if (baz ||\n" 1609 " quux)\n" 1610 "{\n" 1611 " foobar();\n" 1612 "} else {\n" 1613 " barbaz();\n" 1614 "}", 1615 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1616 Style)); 1617 EXPECT_EQ("for (int i = 0;\n" 1618 " i < 10; ++i)\n" 1619 "{\n" 1620 " foo();\n" 1621 "}", 1622 format("for(int i=0;i<10;++i){foo();}", Style)); 1623 EXPECT_EQ("while (foo || bar ||\n" 1624 " baz)\n" 1625 "{\n" 1626 " quux();\n" 1627 "}", 1628 format("while(foo||bar||baz){quux();}", Style)); 1629 EXPECT_EQ("switch (\n" 1630 " foo = barbaz)\n" 1631 "{\n" 1632 "case quux:\n" 1633 " return;\n" 1634 "}", 1635 format("switch(foo=barbaz){case quux:return;}", Style)); 1636 EXPECT_EQ("try {\n" 1637 " foo();\n" 1638 "} catch (\n" 1639 " Exception &bar)\n" 1640 "{\n" 1641 " baz();\n" 1642 "}", 1643 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1644 Style.ColumnLimit = 1645 40; // to concentrate at brace wrapping, not line wrap due to column limit 1646 EXPECT_EQ("try {\n" 1647 " foo();\n" 1648 "} catch (Exception &bar) {\n" 1649 " baz();\n" 1650 "}", 1651 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1652 Style.ColumnLimit = 1653 20; // to concentrate at brace wrapping, not line wrap due to column limit 1654 1655 Style.BraceWrapping.BeforeElse = true; 1656 EXPECT_EQ( 1657 "if (foo) {\n" 1658 " bar();\n" 1659 "}\n" 1660 "else if (baz ||\n" 1661 " quux)\n" 1662 "{\n" 1663 " foobar();\n" 1664 "}\n" 1665 "else {\n" 1666 " barbaz();\n" 1667 "}", 1668 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1669 Style)); 1670 1671 Style.BraceWrapping.BeforeCatch = true; 1672 EXPECT_EQ("try {\n" 1673 " foo();\n" 1674 "}\n" 1675 "catch (...) {\n" 1676 " baz();\n" 1677 "}", 1678 format("try{foo();}catch(...){baz();}", Style)); 1679 } 1680 1681 //===----------------------------------------------------------------------===// 1682 // Tests for classes, namespaces, etc. 1683 //===----------------------------------------------------------------------===// 1684 1685 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1686 verifyFormat("class A {};"); 1687 } 1688 1689 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1690 verifyFormat("class A {\n" 1691 "public:\n" 1692 "public: // comment\n" 1693 "protected:\n" 1694 "private:\n" 1695 " void f() {}\n" 1696 "};"); 1697 verifyFormat("export class A {\n" 1698 "public:\n" 1699 "public: // comment\n" 1700 "protected:\n" 1701 "private:\n" 1702 " void f() {}\n" 1703 "};"); 1704 verifyGoogleFormat("class A {\n" 1705 " public:\n" 1706 " protected:\n" 1707 " private:\n" 1708 " void f() {}\n" 1709 "};"); 1710 verifyGoogleFormat("export class A {\n" 1711 " public:\n" 1712 " protected:\n" 1713 " private:\n" 1714 " void f() {}\n" 1715 "};"); 1716 verifyFormat("class A {\n" 1717 "public slots:\n" 1718 " void f1() {}\n" 1719 "public Q_SLOTS:\n" 1720 " void f2() {}\n" 1721 "protected slots:\n" 1722 " void f3() {}\n" 1723 "protected Q_SLOTS:\n" 1724 " void f4() {}\n" 1725 "private slots:\n" 1726 " void f5() {}\n" 1727 "private Q_SLOTS:\n" 1728 " void f6() {}\n" 1729 "signals:\n" 1730 " void g1();\n" 1731 "Q_SIGNALS:\n" 1732 " void g2();\n" 1733 "};"); 1734 1735 // Don't interpret 'signals' the wrong way. 1736 verifyFormat("signals.set();"); 1737 verifyFormat("for (Signals signals : f()) {\n}"); 1738 verifyFormat("{\n" 1739 " signals.set(); // This needs indentation.\n" 1740 "}"); 1741 verifyFormat("void f() {\n" 1742 "label:\n" 1743 " signals.baz();\n" 1744 "}"); 1745 } 1746 1747 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1748 EXPECT_EQ("class A {\n" 1749 "public:\n" 1750 " void f();\n" 1751 "\n" 1752 "private:\n" 1753 " void g() {}\n" 1754 " // test\n" 1755 "protected:\n" 1756 " int h;\n" 1757 "};", 1758 format("class A {\n" 1759 "public:\n" 1760 "void f();\n" 1761 "private:\n" 1762 "void g() {}\n" 1763 "// test\n" 1764 "protected:\n" 1765 "int h;\n" 1766 "};")); 1767 EXPECT_EQ("class A {\n" 1768 "protected:\n" 1769 "public:\n" 1770 " void f();\n" 1771 "};", 1772 format("class A {\n" 1773 "protected:\n" 1774 "\n" 1775 "public:\n" 1776 "\n" 1777 " void f();\n" 1778 "};")); 1779 1780 // Even ensure proper spacing inside macros. 1781 EXPECT_EQ("#define B \\\n" 1782 " class A { \\\n" 1783 " protected: \\\n" 1784 " public: \\\n" 1785 " void f(); \\\n" 1786 " };", 1787 format("#define B \\\n" 1788 " class A { \\\n" 1789 " protected: \\\n" 1790 " \\\n" 1791 " public: \\\n" 1792 " \\\n" 1793 " void f(); \\\n" 1794 " };", 1795 getGoogleStyle())); 1796 // But don't remove empty lines after macros ending in access specifiers. 1797 EXPECT_EQ("#define A private:\n" 1798 "\n" 1799 "int i;", 1800 format("#define A private:\n" 1801 "\n" 1802 "int i;")); 1803 } 1804 1805 TEST_F(FormatTest, FormatsClasses) { 1806 verifyFormat("class A : public B {};"); 1807 verifyFormat("class A : public ::B {};"); 1808 1809 verifyFormat( 1810 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1811 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1812 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1813 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1814 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1815 verifyFormat( 1816 "class A : public B, public C, public D, public E, public F {};"); 1817 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1818 " public C,\n" 1819 " public D,\n" 1820 " public E,\n" 1821 " public F,\n" 1822 " public G {};"); 1823 1824 verifyFormat("class\n" 1825 " ReallyReallyLongClassName {\n" 1826 " int i;\n" 1827 "};", 1828 getLLVMStyleWithColumns(32)); 1829 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1830 " aaaaaaaaaaaaaaaa> {};"); 1831 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1832 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1833 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1834 verifyFormat("template <class R, class C>\n" 1835 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1836 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1837 verifyFormat("class ::A::B {};"); 1838 } 1839 1840 TEST_F(FormatTest, BreakInheritanceStyle) { 1841 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1842 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1843 FormatStyle::BILS_BeforeComma; 1844 verifyFormat("class MyClass : public X {};", 1845 StyleWithInheritanceBreakBeforeComma); 1846 verifyFormat("class MyClass\n" 1847 " : public X\n" 1848 " , public Y {};", 1849 StyleWithInheritanceBreakBeforeComma); 1850 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1851 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1852 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1853 StyleWithInheritanceBreakBeforeComma); 1854 verifyFormat("struct aaaaaaaaaaaaa\n" 1855 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1856 " aaaaaaaaaaaaaaaa> {};", 1857 StyleWithInheritanceBreakBeforeComma); 1858 1859 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1860 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1861 FormatStyle::BILS_AfterColon; 1862 verifyFormat("class MyClass : public X {};", 1863 StyleWithInheritanceBreakAfterColon); 1864 verifyFormat("class MyClass : public X, public Y {};", 1865 StyleWithInheritanceBreakAfterColon); 1866 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1867 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1868 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1869 StyleWithInheritanceBreakAfterColon); 1870 verifyFormat("struct aaaaaaaaaaaaa :\n" 1871 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1872 " aaaaaaaaaaaaaaaa> {};", 1873 StyleWithInheritanceBreakAfterColon); 1874 } 1875 1876 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1877 verifyFormat("class A {\n} a, b;"); 1878 verifyFormat("struct A {\n} a, b;"); 1879 verifyFormat("union A {\n} a;"); 1880 } 1881 1882 TEST_F(FormatTest, FormatsEnum) { 1883 verifyFormat("enum {\n" 1884 " Zero,\n" 1885 " One = 1,\n" 1886 " Two = One + 1,\n" 1887 " Three = (One + Two),\n" 1888 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1889 " Five = (One, Two, Three, Four, 5)\n" 1890 "};"); 1891 verifyGoogleFormat("enum {\n" 1892 " Zero,\n" 1893 " One = 1,\n" 1894 " Two = One + 1,\n" 1895 " Three = (One + Two),\n" 1896 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1897 " Five = (One, Two, Three, Four, 5)\n" 1898 "};"); 1899 verifyFormat("enum Enum {};"); 1900 verifyFormat("enum {};"); 1901 verifyFormat("enum X E {} d;"); 1902 verifyFormat("enum __attribute__((...)) E {} d;"); 1903 verifyFormat("enum __declspec__((...)) E {} d;"); 1904 verifyFormat("enum {\n" 1905 " Bar = Foo<int, int>::value\n" 1906 "};", 1907 getLLVMStyleWithColumns(30)); 1908 1909 verifyFormat("enum ShortEnum { A, B, C };"); 1910 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1911 1912 EXPECT_EQ("enum KeepEmptyLines {\n" 1913 " ONE,\n" 1914 "\n" 1915 " TWO,\n" 1916 "\n" 1917 " THREE\n" 1918 "}", 1919 format("enum KeepEmptyLines {\n" 1920 " ONE,\n" 1921 "\n" 1922 " TWO,\n" 1923 "\n" 1924 "\n" 1925 " THREE\n" 1926 "}")); 1927 verifyFormat("enum E { // comment\n" 1928 " ONE,\n" 1929 " TWO\n" 1930 "};\n" 1931 "int i;"); 1932 // Not enums. 1933 verifyFormat("enum X f() {\n" 1934 " a();\n" 1935 " return 42;\n" 1936 "}"); 1937 verifyFormat("enum X Type::f() {\n" 1938 " a();\n" 1939 " return 42;\n" 1940 "}"); 1941 verifyFormat("enum ::X f() {\n" 1942 " a();\n" 1943 " return 42;\n" 1944 "}"); 1945 verifyFormat("enum ns::X f() {\n" 1946 " a();\n" 1947 " return 42;\n" 1948 "}"); 1949 } 1950 1951 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1952 verifyFormat("enum Type {\n" 1953 " One = 0; // These semicolons should be commas.\n" 1954 " Two = 1;\n" 1955 "};"); 1956 verifyFormat("namespace n {\n" 1957 "enum Type {\n" 1958 " One,\n" 1959 " Two, // missing };\n" 1960 " int i;\n" 1961 "}\n" 1962 "void g() {}"); 1963 } 1964 1965 TEST_F(FormatTest, FormatsEnumStruct) { 1966 verifyFormat("enum struct {\n" 1967 " Zero,\n" 1968 " One = 1,\n" 1969 " Two = One + 1,\n" 1970 " Three = (One + Two),\n" 1971 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1972 " Five = (One, Two, Three, Four, 5)\n" 1973 "};"); 1974 verifyFormat("enum struct Enum {};"); 1975 verifyFormat("enum struct {};"); 1976 verifyFormat("enum struct X E {} d;"); 1977 verifyFormat("enum struct __attribute__((...)) E {} d;"); 1978 verifyFormat("enum struct __declspec__((...)) E {} d;"); 1979 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1980 } 1981 1982 TEST_F(FormatTest, FormatsEnumClass) { 1983 verifyFormat("enum class {\n" 1984 " Zero,\n" 1985 " One = 1,\n" 1986 " Two = One + 1,\n" 1987 " Three = (One + Two),\n" 1988 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1989 " Five = (One, Two, Three, Four, 5)\n" 1990 "};"); 1991 verifyFormat("enum class Enum {};"); 1992 verifyFormat("enum class {};"); 1993 verifyFormat("enum class X E {} d;"); 1994 verifyFormat("enum class __attribute__((...)) E {} d;"); 1995 verifyFormat("enum class __declspec__((...)) E {} d;"); 1996 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 1997 } 1998 1999 TEST_F(FormatTest, FormatsEnumTypes) { 2000 verifyFormat("enum X : int {\n" 2001 " A, // Force multiple lines.\n" 2002 " B\n" 2003 "};"); 2004 verifyFormat("enum X : int { A, B };"); 2005 verifyFormat("enum X : std::uint32_t { A, B };"); 2006 } 2007 2008 TEST_F(FormatTest, FormatsTypedefEnum) { 2009 FormatStyle Style = getLLVMStyle(); 2010 Style.ColumnLimit = 40; 2011 verifyFormat("typedef enum {} EmptyEnum;"); 2012 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 2013 verifyFormat("typedef enum {\n" 2014 " ZERO = 0,\n" 2015 " ONE = 1,\n" 2016 " TWO = 2,\n" 2017 " THREE = 3\n" 2018 "} LongEnum;", 2019 Style); 2020 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2021 Style.BraceWrapping.AfterEnum = true; 2022 verifyFormat("typedef enum {} EmptyEnum;"); 2023 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 2024 verifyFormat("typedef enum\n" 2025 "{\n" 2026 " ZERO = 0,\n" 2027 " ONE = 1,\n" 2028 " TWO = 2,\n" 2029 " THREE = 3\n" 2030 "} LongEnum;", 2031 Style); 2032 } 2033 2034 TEST_F(FormatTest, FormatsNSEnums) { 2035 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 2036 verifyGoogleFormat( 2037 "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }"); 2038 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 2039 " // Information about someDecentlyLongValue.\n" 2040 " someDecentlyLongValue,\n" 2041 " // Information about anotherDecentlyLongValue.\n" 2042 " anotherDecentlyLongValue,\n" 2043 " // Information about aThirdDecentlyLongValue.\n" 2044 " aThirdDecentlyLongValue\n" 2045 "};"); 2046 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n" 2047 " // Information about someDecentlyLongValue.\n" 2048 " someDecentlyLongValue,\n" 2049 " // Information about anotherDecentlyLongValue.\n" 2050 " anotherDecentlyLongValue,\n" 2051 " // Information about aThirdDecentlyLongValue.\n" 2052 " aThirdDecentlyLongValue\n" 2053 "};"); 2054 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 2055 " a = 1,\n" 2056 " b = 2,\n" 2057 " c = 3,\n" 2058 "};"); 2059 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 2060 " a = 1,\n" 2061 " b = 2,\n" 2062 " c = 3,\n" 2063 "};"); 2064 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n" 2065 " a = 1,\n" 2066 " b = 2,\n" 2067 " c = 3,\n" 2068 "};"); 2069 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 2070 " a = 1,\n" 2071 " b = 2,\n" 2072 " c = 3,\n" 2073 "};"); 2074 } 2075 2076 TEST_F(FormatTest, FormatsBitfields) { 2077 verifyFormat("struct Bitfields {\n" 2078 " unsigned sClass : 8;\n" 2079 " unsigned ValueKind : 2;\n" 2080 "};"); 2081 verifyFormat("struct A {\n" 2082 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 2083 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 2084 "};"); 2085 verifyFormat("struct MyStruct {\n" 2086 " uchar data;\n" 2087 " uchar : 8;\n" 2088 " uchar : 8;\n" 2089 " uchar other;\n" 2090 "};"); 2091 } 2092 2093 TEST_F(FormatTest, FormatsNamespaces) { 2094 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 2095 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 2096 2097 verifyFormat("namespace some_namespace {\n" 2098 "class A {};\n" 2099 "void f() { f(); }\n" 2100 "}", 2101 LLVMWithNoNamespaceFix); 2102 verifyFormat("namespace N::inline D {\n" 2103 "class A {};\n" 2104 "void f() { f(); }\n" 2105 "}", 2106 LLVMWithNoNamespaceFix); 2107 verifyFormat("namespace N::inline D::E {\n" 2108 "class A {};\n" 2109 "void f() { f(); }\n" 2110 "}", 2111 LLVMWithNoNamespaceFix); 2112 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n" 2113 "class A {};\n" 2114 "void f() { f(); }\n" 2115 "}", 2116 LLVMWithNoNamespaceFix); 2117 verifyFormat("/* something */ namespace some_namespace {\n" 2118 "class A {};\n" 2119 "void f() { f(); }\n" 2120 "}", 2121 LLVMWithNoNamespaceFix); 2122 verifyFormat("namespace {\n" 2123 "class A {};\n" 2124 "void f() { f(); }\n" 2125 "}", 2126 LLVMWithNoNamespaceFix); 2127 verifyFormat("/* something */ namespace {\n" 2128 "class A {};\n" 2129 "void f() { f(); }\n" 2130 "}", 2131 LLVMWithNoNamespaceFix); 2132 verifyFormat("inline namespace X {\n" 2133 "class A {};\n" 2134 "void f() { f(); }\n" 2135 "}", 2136 LLVMWithNoNamespaceFix); 2137 verifyFormat("/* something */ inline namespace X {\n" 2138 "class A {};\n" 2139 "void f() { f(); }\n" 2140 "}", 2141 LLVMWithNoNamespaceFix); 2142 verifyFormat("export namespace X {\n" 2143 "class A {};\n" 2144 "void f() { f(); }\n" 2145 "}", 2146 LLVMWithNoNamespaceFix); 2147 verifyFormat("using namespace some_namespace;\n" 2148 "class A {};\n" 2149 "void f() { f(); }", 2150 LLVMWithNoNamespaceFix); 2151 2152 // This code is more common than we thought; if we 2153 // layout this correctly the semicolon will go into 2154 // its own line, which is undesirable. 2155 verifyFormat("namespace {};", LLVMWithNoNamespaceFix); 2156 verifyFormat("namespace {\n" 2157 "class A {};\n" 2158 "};", 2159 LLVMWithNoNamespaceFix); 2160 2161 verifyFormat("namespace {\n" 2162 "int SomeVariable = 0; // comment\n" 2163 "} // namespace", 2164 LLVMWithNoNamespaceFix); 2165 EXPECT_EQ("#ifndef HEADER_GUARD\n" 2166 "#define HEADER_GUARD\n" 2167 "namespace my_namespace {\n" 2168 "int i;\n" 2169 "} // my_namespace\n" 2170 "#endif // HEADER_GUARD", 2171 format("#ifndef HEADER_GUARD\n" 2172 " #define HEADER_GUARD\n" 2173 " namespace my_namespace {\n" 2174 "int i;\n" 2175 "} // my_namespace\n" 2176 "#endif // HEADER_GUARD", 2177 LLVMWithNoNamespaceFix)); 2178 2179 EXPECT_EQ("namespace A::B {\n" 2180 "class C {};\n" 2181 "}", 2182 format("namespace A::B {\n" 2183 "class C {};\n" 2184 "}", 2185 LLVMWithNoNamespaceFix)); 2186 2187 FormatStyle Style = getLLVMStyle(); 2188 Style.NamespaceIndentation = FormatStyle::NI_All; 2189 EXPECT_EQ("namespace out {\n" 2190 " int i;\n" 2191 " namespace in {\n" 2192 " int i;\n" 2193 " } // namespace in\n" 2194 "} // namespace out", 2195 format("namespace out {\n" 2196 "int i;\n" 2197 "namespace in {\n" 2198 "int i;\n" 2199 "} // namespace in\n" 2200 "} // namespace out", 2201 Style)); 2202 2203 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2204 EXPECT_EQ("namespace out {\n" 2205 "int i;\n" 2206 "namespace in {\n" 2207 " int i;\n" 2208 "} // namespace in\n" 2209 "} // namespace out", 2210 format("namespace out {\n" 2211 "int i;\n" 2212 "namespace in {\n" 2213 "int i;\n" 2214 "} // namespace in\n" 2215 "} // namespace out", 2216 Style)); 2217 } 2218 2219 TEST_F(FormatTest, NamespaceMacros) { 2220 FormatStyle Style = getLLVMStyle(); 2221 Style.NamespaceMacros.push_back("TESTSUITE"); 2222 2223 verifyFormat("TESTSUITE(A) {\n" 2224 "int foo();\n" 2225 "} // TESTSUITE(A)", 2226 Style); 2227 2228 verifyFormat("TESTSUITE(A, B) {\n" 2229 "int foo();\n" 2230 "} // TESTSUITE(A)", 2231 Style); 2232 2233 // Properly indent according to NamespaceIndentation style 2234 Style.NamespaceIndentation = FormatStyle::NI_All; 2235 verifyFormat("TESTSUITE(A) {\n" 2236 " int foo();\n" 2237 "} // TESTSUITE(A)", 2238 Style); 2239 verifyFormat("TESTSUITE(A) {\n" 2240 " namespace B {\n" 2241 " int foo();\n" 2242 " } // namespace B\n" 2243 "} // TESTSUITE(A)", 2244 Style); 2245 verifyFormat("namespace A {\n" 2246 " TESTSUITE(B) {\n" 2247 " int foo();\n" 2248 " } // TESTSUITE(B)\n" 2249 "} // namespace A", 2250 Style); 2251 2252 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2253 verifyFormat("TESTSUITE(A) {\n" 2254 "TESTSUITE(B) {\n" 2255 " int foo();\n" 2256 "} // TESTSUITE(B)\n" 2257 "} // TESTSUITE(A)", 2258 Style); 2259 verifyFormat("TESTSUITE(A) {\n" 2260 "namespace B {\n" 2261 " int foo();\n" 2262 "} // namespace B\n" 2263 "} // TESTSUITE(A)", 2264 Style); 2265 verifyFormat("namespace A {\n" 2266 "TESTSUITE(B) {\n" 2267 " int foo();\n" 2268 "} // TESTSUITE(B)\n" 2269 "} // namespace A", 2270 Style); 2271 2272 // Properly merge namespace-macros blocks in CompactNamespaces mode 2273 Style.NamespaceIndentation = FormatStyle::NI_None; 2274 Style.CompactNamespaces = true; 2275 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n" 2276 "}} // TESTSUITE(A::B)", 2277 Style); 2278 2279 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2280 "}} // TESTSUITE(out::in)", 2281 format("TESTSUITE(out) {\n" 2282 "TESTSUITE(in) {\n" 2283 "} // TESTSUITE(in)\n" 2284 "} // TESTSUITE(out)", 2285 Style)); 2286 2287 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2288 "}} // TESTSUITE(out::in)", 2289 format("TESTSUITE(out) {\n" 2290 "TESTSUITE(in) {\n" 2291 "} // TESTSUITE(in)\n" 2292 "} // TESTSUITE(out)", 2293 Style)); 2294 2295 // Do not merge different namespaces/macros 2296 EXPECT_EQ("namespace out {\n" 2297 "TESTSUITE(in) {\n" 2298 "} // TESTSUITE(in)\n" 2299 "} // namespace out", 2300 format("namespace out {\n" 2301 "TESTSUITE(in) {\n" 2302 "} // TESTSUITE(in)\n" 2303 "} // namespace out", 2304 Style)); 2305 EXPECT_EQ("TESTSUITE(out) {\n" 2306 "namespace in {\n" 2307 "} // namespace in\n" 2308 "} // TESTSUITE(out)", 2309 format("TESTSUITE(out) {\n" 2310 "namespace in {\n" 2311 "} // namespace in\n" 2312 "} // TESTSUITE(out)", 2313 Style)); 2314 Style.NamespaceMacros.push_back("FOOBAR"); 2315 EXPECT_EQ("TESTSUITE(out) {\n" 2316 "FOOBAR(in) {\n" 2317 "} // FOOBAR(in)\n" 2318 "} // TESTSUITE(out)", 2319 format("TESTSUITE(out) {\n" 2320 "FOOBAR(in) {\n" 2321 "} // FOOBAR(in)\n" 2322 "} // TESTSUITE(out)", 2323 Style)); 2324 } 2325 2326 TEST_F(FormatTest, FormatsCompactNamespaces) { 2327 FormatStyle Style = getLLVMStyle(); 2328 Style.CompactNamespaces = true; 2329 Style.NamespaceMacros.push_back("TESTSUITE"); 2330 2331 verifyFormat("namespace A { namespace B {\n" 2332 "}} // namespace A::B", 2333 Style); 2334 2335 EXPECT_EQ("namespace out { namespace in {\n" 2336 "}} // namespace out::in", 2337 format("namespace out {\n" 2338 "namespace in {\n" 2339 "} // namespace in\n" 2340 "} // namespace out", 2341 Style)); 2342 2343 // Only namespaces which have both consecutive opening and end get compacted 2344 EXPECT_EQ("namespace out {\n" 2345 "namespace in1 {\n" 2346 "} // namespace in1\n" 2347 "namespace in2 {\n" 2348 "} // namespace in2\n" 2349 "} // namespace out", 2350 format("namespace out {\n" 2351 "namespace in1 {\n" 2352 "} // namespace in1\n" 2353 "namespace in2 {\n" 2354 "} // namespace in2\n" 2355 "} // namespace out", 2356 Style)); 2357 2358 EXPECT_EQ("namespace out {\n" 2359 "int i;\n" 2360 "namespace in {\n" 2361 "int j;\n" 2362 "} // namespace in\n" 2363 "int k;\n" 2364 "} // namespace out", 2365 format("namespace out { int i;\n" 2366 "namespace in { int j; } // namespace in\n" 2367 "int k; } // namespace out", 2368 Style)); 2369 2370 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 2371 "}}} // namespace A::B::C\n", 2372 format("namespace A { namespace B {\n" 2373 "namespace C {\n" 2374 "}} // namespace B::C\n" 2375 "} // namespace A\n", 2376 Style)); 2377 2378 Style.ColumnLimit = 40; 2379 EXPECT_EQ("namespace aaaaaaaaaa {\n" 2380 "namespace bbbbbbbbbb {\n" 2381 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 2382 format("namespace aaaaaaaaaa {\n" 2383 "namespace bbbbbbbbbb {\n" 2384 "} // namespace bbbbbbbbbb\n" 2385 "} // namespace aaaaaaaaaa", 2386 Style)); 2387 2388 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 2389 "namespace cccccc {\n" 2390 "}}} // namespace aaaaaa::bbbbbb::cccccc", 2391 format("namespace aaaaaa {\n" 2392 "namespace bbbbbb {\n" 2393 "namespace cccccc {\n" 2394 "} // namespace cccccc\n" 2395 "} // namespace bbbbbb\n" 2396 "} // namespace aaaaaa", 2397 Style)); 2398 Style.ColumnLimit = 80; 2399 2400 // Extra semicolon after 'inner' closing brace prevents merging 2401 EXPECT_EQ("namespace out { namespace in {\n" 2402 "}; } // namespace out::in", 2403 format("namespace out {\n" 2404 "namespace in {\n" 2405 "}; // namespace in\n" 2406 "} // namespace out", 2407 Style)); 2408 2409 // Extra semicolon after 'outer' closing brace is conserved 2410 EXPECT_EQ("namespace out { namespace in {\n" 2411 "}}; // namespace out::in", 2412 format("namespace out {\n" 2413 "namespace in {\n" 2414 "} // namespace in\n" 2415 "}; // namespace out", 2416 Style)); 2417 2418 Style.NamespaceIndentation = FormatStyle::NI_All; 2419 EXPECT_EQ("namespace out { namespace in {\n" 2420 " int i;\n" 2421 "}} // namespace out::in", 2422 format("namespace out {\n" 2423 "namespace in {\n" 2424 "int i;\n" 2425 "} // namespace in\n" 2426 "} // namespace out", 2427 Style)); 2428 EXPECT_EQ("namespace out { namespace mid {\n" 2429 " namespace in {\n" 2430 " int j;\n" 2431 " } // namespace in\n" 2432 " int k;\n" 2433 "}} // namespace out::mid", 2434 format("namespace out { namespace mid {\n" 2435 "namespace in { int j; } // namespace in\n" 2436 "int k; }} // namespace out::mid", 2437 Style)); 2438 2439 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2440 EXPECT_EQ("namespace out { namespace in {\n" 2441 " int i;\n" 2442 "}} // namespace out::in", 2443 format("namespace out {\n" 2444 "namespace in {\n" 2445 "int i;\n" 2446 "} // namespace in\n" 2447 "} // namespace out", 2448 Style)); 2449 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 2450 " int i;\n" 2451 "}}} // namespace out::mid::in", 2452 format("namespace out {\n" 2453 "namespace mid {\n" 2454 "namespace in {\n" 2455 "int i;\n" 2456 "} // namespace in\n" 2457 "} // namespace mid\n" 2458 "} // namespace out", 2459 Style)); 2460 } 2461 2462 TEST_F(FormatTest, FormatsExternC) { 2463 verifyFormat("extern \"C\" {\nint a;"); 2464 verifyFormat("extern \"C\" {}"); 2465 verifyFormat("extern \"C\" {\n" 2466 "int foo();\n" 2467 "}"); 2468 verifyFormat("extern \"C\" int foo() {}"); 2469 verifyFormat("extern \"C\" int foo();"); 2470 verifyFormat("extern \"C\" int foo() {\n" 2471 " int i = 42;\n" 2472 " return i;\n" 2473 "}"); 2474 2475 FormatStyle Style = getLLVMStyle(); 2476 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2477 Style.BraceWrapping.AfterFunction = true; 2478 verifyFormat("extern \"C\" int foo() {}", Style); 2479 verifyFormat("extern \"C\" int foo();", Style); 2480 verifyFormat("extern \"C\" int foo()\n" 2481 "{\n" 2482 " int i = 42;\n" 2483 " return i;\n" 2484 "}", 2485 Style); 2486 2487 Style.BraceWrapping.AfterExternBlock = true; 2488 Style.BraceWrapping.SplitEmptyRecord = false; 2489 verifyFormat("extern \"C\"\n" 2490 "{}", 2491 Style); 2492 verifyFormat("extern \"C\"\n" 2493 "{\n" 2494 " int foo();\n" 2495 "}", 2496 Style); 2497 } 2498 2499 TEST_F(FormatTest, FormatsInlineASM) { 2500 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2501 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2502 verifyFormat( 2503 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2504 " \"cpuid\\n\\t\"\n" 2505 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2506 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2507 " : \"a\"(value));"); 2508 EXPECT_EQ( 2509 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2510 " __asm {\n" 2511 " mov edx,[that] // vtable in edx\n" 2512 " mov eax,methodIndex\n" 2513 " call [edx][eax*4] // stdcall\n" 2514 " }\n" 2515 "}", 2516 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2517 " __asm {\n" 2518 " mov edx,[that] // vtable in edx\n" 2519 " mov eax,methodIndex\n" 2520 " call [edx][eax*4] // stdcall\n" 2521 " }\n" 2522 "}")); 2523 EXPECT_EQ("_asm {\n" 2524 " xor eax, eax;\n" 2525 " cpuid;\n" 2526 "}", 2527 format("_asm {\n" 2528 " xor eax, eax;\n" 2529 " cpuid;\n" 2530 "}")); 2531 verifyFormat("void function() {\n" 2532 " // comment\n" 2533 " asm(\"\");\n" 2534 "}"); 2535 EXPECT_EQ("__asm {\n" 2536 "}\n" 2537 "int i;", 2538 format("__asm {\n" 2539 "}\n" 2540 "int i;")); 2541 } 2542 2543 TEST_F(FormatTest, FormatTryCatch) { 2544 verifyFormat("try {\n" 2545 " throw a * b;\n" 2546 "} catch (int a) {\n" 2547 " // Do nothing.\n" 2548 "} catch (...) {\n" 2549 " exit(42);\n" 2550 "}"); 2551 2552 // Function-level try statements. 2553 verifyFormat("int f() try { return 4; } catch (...) {\n" 2554 " return 5;\n" 2555 "}"); 2556 verifyFormat("class A {\n" 2557 " int a;\n" 2558 " A() try : a(0) {\n" 2559 " } catch (...) {\n" 2560 " throw;\n" 2561 " }\n" 2562 "};\n"); 2563 2564 // Incomplete try-catch blocks. 2565 verifyIncompleteFormat("try {} catch ("); 2566 } 2567 2568 TEST_F(FormatTest, FormatSEHTryCatch) { 2569 verifyFormat("__try {\n" 2570 " int a = b * c;\n" 2571 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2572 " // Do nothing.\n" 2573 "}"); 2574 2575 verifyFormat("__try {\n" 2576 " int a = b * c;\n" 2577 "} __finally {\n" 2578 " // Do nothing.\n" 2579 "}"); 2580 2581 verifyFormat("DEBUG({\n" 2582 " __try {\n" 2583 " } __finally {\n" 2584 " }\n" 2585 "});\n"); 2586 } 2587 2588 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2589 verifyFormat("try {\n" 2590 " f();\n" 2591 "} catch {\n" 2592 " g();\n" 2593 "}"); 2594 verifyFormat("try {\n" 2595 " f();\n" 2596 "} catch (A a) MACRO(x) {\n" 2597 " g();\n" 2598 "} catch (B b) MACRO(x) {\n" 2599 " g();\n" 2600 "}"); 2601 } 2602 2603 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2604 FormatStyle Style = getLLVMStyle(); 2605 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2606 FormatStyle::BS_WebKit}) { 2607 Style.BreakBeforeBraces = BraceStyle; 2608 verifyFormat("try {\n" 2609 " // something\n" 2610 "} catch (...) {\n" 2611 " // something\n" 2612 "}", 2613 Style); 2614 } 2615 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2616 verifyFormat("try {\n" 2617 " // something\n" 2618 "}\n" 2619 "catch (...) {\n" 2620 " // something\n" 2621 "}", 2622 Style); 2623 verifyFormat("__try {\n" 2624 " // something\n" 2625 "}\n" 2626 "__finally {\n" 2627 " // something\n" 2628 "}", 2629 Style); 2630 verifyFormat("@try {\n" 2631 " // something\n" 2632 "}\n" 2633 "@finally {\n" 2634 " // something\n" 2635 "}", 2636 Style); 2637 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2638 verifyFormat("try\n" 2639 "{\n" 2640 " // something\n" 2641 "}\n" 2642 "catch (...)\n" 2643 "{\n" 2644 " // something\n" 2645 "}", 2646 Style); 2647 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 2648 verifyFormat("try\n" 2649 " {\n" 2650 " // something white\n" 2651 " }\n" 2652 "catch (...)\n" 2653 " {\n" 2654 " // something white\n" 2655 " }", 2656 Style); 2657 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2658 verifyFormat("try\n" 2659 " {\n" 2660 " // something\n" 2661 " }\n" 2662 "catch (...)\n" 2663 " {\n" 2664 " // something\n" 2665 " }", 2666 Style); 2667 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2668 Style.BraceWrapping.BeforeCatch = true; 2669 verifyFormat("try {\n" 2670 " // something\n" 2671 "}\n" 2672 "catch (...) {\n" 2673 " // something\n" 2674 "}", 2675 Style); 2676 } 2677 2678 TEST_F(FormatTest, StaticInitializers) { 2679 verifyFormat("static SomeClass SC = {1, 'a'};"); 2680 2681 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2682 " 100000000, " 2683 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2684 2685 // Here, everything other than the "}" would fit on a line. 2686 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2687 " 10000000000000000000000000};"); 2688 EXPECT_EQ("S s = {a,\n" 2689 "\n" 2690 " b};", 2691 format("S s = {\n" 2692 " a,\n" 2693 "\n" 2694 " b\n" 2695 "};")); 2696 2697 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2698 // line. However, the formatting looks a bit off and this probably doesn't 2699 // happen often in practice. 2700 verifyFormat("static int Variable[1] = {\n" 2701 " {1000000000000000000000000000000000000}};", 2702 getLLVMStyleWithColumns(40)); 2703 } 2704 2705 TEST_F(FormatTest, DesignatedInitializers) { 2706 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2707 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2708 " .bbbbbbbbbb = 2,\n" 2709 " .cccccccccc = 3,\n" 2710 " .dddddddddd = 4,\n" 2711 " .eeeeeeeeee = 5};"); 2712 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2713 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2714 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2715 " .ccccccccccccccccccccccccccc = 3,\n" 2716 " .ddddddddddddddddddddddddddd = 4,\n" 2717 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2718 2719 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2720 2721 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2722 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2723 " [2] = bbbbbbbbbb,\n" 2724 " [3] = cccccccccc,\n" 2725 " [4] = dddddddddd,\n" 2726 " [5] = eeeeeeeeee};"); 2727 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2728 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2729 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2730 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2731 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2732 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2733 } 2734 2735 TEST_F(FormatTest, NestedStaticInitializers) { 2736 verifyFormat("static A x = {{{}}};\n"); 2737 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2738 " {init1, init2, init3, init4}}};", 2739 getLLVMStyleWithColumns(50)); 2740 2741 verifyFormat("somes Status::global_reps[3] = {\n" 2742 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2743 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2744 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2745 getLLVMStyleWithColumns(60)); 2746 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2747 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2748 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2749 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2750 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2751 " {rect.fRight - rect.fLeft, rect.fBottom - " 2752 "rect.fTop}};"); 2753 2754 verifyFormat( 2755 "SomeArrayOfSomeType a = {\n" 2756 " {{1, 2, 3},\n" 2757 " {1, 2, 3},\n" 2758 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2759 " 333333333333333333333333333333},\n" 2760 " {1, 2, 3},\n" 2761 " {1, 2, 3}}};"); 2762 verifyFormat( 2763 "SomeArrayOfSomeType a = {\n" 2764 " {{1, 2, 3}},\n" 2765 " {{1, 2, 3}},\n" 2766 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2767 " 333333333333333333333333333333}},\n" 2768 " {{1, 2, 3}},\n" 2769 " {{1, 2, 3}}};"); 2770 2771 verifyFormat("struct {\n" 2772 " unsigned bit;\n" 2773 " const char *const name;\n" 2774 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2775 " {kOsWin, \"Windows\"},\n" 2776 " {kOsLinux, \"Linux\"},\n" 2777 " {kOsCrOS, \"Chrome OS\"}};"); 2778 verifyFormat("struct {\n" 2779 " unsigned bit;\n" 2780 " const char *const name;\n" 2781 "} kBitsToOs[] = {\n" 2782 " {kOsMac, \"Mac\"},\n" 2783 " {kOsWin, \"Windows\"},\n" 2784 " {kOsLinux, \"Linux\"},\n" 2785 " {kOsCrOS, \"Chrome OS\"},\n" 2786 "};"); 2787 } 2788 2789 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2790 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2791 " \\\n" 2792 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2793 } 2794 2795 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2796 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2797 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2798 2799 // Do break defaulted and deleted functions. 2800 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2801 " default;", 2802 getLLVMStyleWithColumns(40)); 2803 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2804 " delete;", 2805 getLLVMStyleWithColumns(40)); 2806 } 2807 2808 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2809 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2810 getLLVMStyleWithColumns(40)); 2811 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2812 getLLVMStyleWithColumns(40)); 2813 EXPECT_EQ("#define Q \\\n" 2814 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2815 " \"aaaaaaaa.cpp\"", 2816 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2817 getLLVMStyleWithColumns(40))); 2818 } 2819 2820 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2821 EXPECT_EQ("# 123 \"A string literal\"", 2822 format(" # 123 \"A string literal\"")); 2823 } 2824 2825 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2826 EXPECT_EQ("#;", format("#;")); 2827 verifyFormat("#\n;\n;\n;"); 2828 } 2829 2830 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2831 EXPECT_EQ("#line 42 \"test\"\n", 2832 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2833 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2834 getLLVMStyleWithColumns(12))); 2835 } 2836 2837 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2838 EXPECT_EQ("#line 42 \"test\"", 2839 format("# \\\n line \\\n 42 \\\n \"test\"")); 2840 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2841 } 2842 2843 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2844 verifyFormat("#define A \\x20"); 2845 verifyFormat("#define A \\ x20"); 2846 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2847 verifyFormat("#define A ''"); 2848 verifyFormat("#define A ''qqq"); 2849 verifyFormat("#define A `qqq"); 2850 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2851 EXPECT_EQ("const char *c = STRINGIFY(\n" 2852 "\\na : b);", 2853 format("const char * c = STRINGIFY(\n" 2854 "\\na : b);")); 2855 2856 verifyFormat("a\r\\"); 2857 verifyFormat("a\v\\"); 2858 verifyFormat("a\f\\"); 2859 } 2860 2861 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2862 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2863 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2864 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2865 // FIXME: We never break before the macro name. 2866 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2867 2868 verifyFormat("#define A A\n#define A A"); 2869 verifyFormat("#define A(X) A\n#define A A"); 2870 2871 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2872 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2873 } 2874 2875 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2876 EXPECT_EQ("// somecomment\n" 2877 "#include \"a.h\"\n" 2878 "#define A( \\\n" 2879 " A, B)\n" 2880 "#include \"b.h\"\n" 2881 "// somecomment\n", 2882 format(" // somecomment\n" 2883 " #include \"a.h\"\n" 2884 "#define A(A,\\\n" 2885 " B)\n" 2886 " #include \"b.h\"\n" 2887 " // somecomment\n", 2888 getLLVMStyleWithColumns(13))); 2889 } 2890 2891 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2892 2893 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2894 EXPECT_EQ("#define A \\\n" 2895 " c; \\\n" 2896 " e;\n" 2897 "f;", 2898 format("#define A c; e;\n" 2899 "f;", 2900 getLLVMStyleWithColumns(14))); 2901 } 2902 2903 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2904 2905 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2906 EXPECT_EQ("int x,\n" 2907 "#define A\n" 2908 " y;", 2909 format("int x,\n#define A\ny;")); 2910 } 2911 2912 TEST_F(FormatTest, HashInMacroDefinition) { 2913 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2914 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2915 verifyFormat("#define A \\\n" 2916 " { \\\n" 2917 " f(#c); \\\n" 2918 " }", 2919 getLLVMStyleWithColumns(11)); 2920 2921 verifyFormat("#define A(X) \\\n" 2922 " void function##X()", 2923 getLLVMStyleWithColumns(22)); 2924 2925 verifyFormat("#define A(a, b, c) \\\n" 2926 " void a##b##c()", 2927 getLLVMStyleWithColumns(22)); 2928 2929 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2930 } 2931 2932 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2933 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2934 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2935 2936 FormatStyle Style = getLLVMStyle(); 2937 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 2938 verifyFormat("#define true ((foo)1)", Style); 2939 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 2940 verifyFormat("#define false((foo)0)", Style); 2941 } 2942 2943 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2944 EXPECT_EQ("#define A b;", format("#define A \\\n" 2945 " \\\n" 2946 " b;", 2947 getLLVMStyleWithColumns(25))); 2948 EXPECT_EQ("#define A \\\n" 2949 " \\\n" 2950 " a; \\\n" 2951 " b;", 2952 format("#define A \\\n" 2953 " \\\n" 2954 " a; \\\n" 2955 " b;", 2956 getLLVMStyleWithColumns(11))); 2957 EXPECT_EQ("#define A \\\n" 2958 " a; \\\n" 2959 " \\\n" 2960 " b;", 2961 format("#define A \\\n" 2962 " a; \\\n" 2963 " \\\n" 2964 " b;", 2965 getLLVMStyleWithColumns(11))); 2966 } 2967 2968 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 2969 verifyIncompleteFormat("#define A :"); 2970 verifyFormat("#define SOMECASES \\\n" 2971 " case 1: \\\n" 2972 " case 2\n", 2973 getLLVMStyleWithColumns(20)); 2974 verifyFormat("#define MACRO(a) \\\n" 2975 " if (a) \\\n" 2976 " f(); \\\n" 2977 " else \\\n" 2978 " g()", 2979 getLLVMStyleWithColumns(18)); 2980 verifyFormat("#define A template <typename T>"); 2981 verifyIncompleteFormat("#define STR(x) #x\n" 2982 "f(STR(this_is_a_string_literal{));"); 2983 verifyFormat("#pragma omp threadprivate( \\\n" 2984 " y)), // expected-warning", 2985 getLLVMStyleWithColumns(28)); 2986 verifyFormat("#d, = };"); 2987 verifyFormat("#if \"a"); 2988 verifyIncompleteFormat("({\n" 2989 "#define b \\\n" 2990 " } \\\n" 2991 " a\n" 2992 "a", 2993 getLLVMStyleWithColumns(15)); 2994 verifyFormat("#define A \\\n" 2995 " { \\\n" 2996 " {\n" 2997 "#define B \\\n" 2998 " } \\\n" 2999 " }", 3000 getLLVMStyleWithColumns(15)); 3001 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 3002 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 3003 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 3004 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 3005 } 3006 3007 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 3008 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 3009 EXPECT_EQ("class A : public QObject {\n" 3010 " Q_OBJECT\n" 3011 "\n" 3012 " A() {}\n" 3013 "};", 3014 format("class A : public QObject {\n" 3015 " Q_OBJECT\n" 3016 "\n" 3017 " A() {\n}\n" 3018 "} ;")); 3019 EXPECT_EQ("MACRO\n" 3020 "/*static*/ int i;", 3021 format("MACRO\n" 3022 " /*static*/ int i;")); 3023 EXPECT_EQ("SOME_MACRO\n" 3024 "namespace {\n" 3025 "void f();\n" 3026 "} // namespace", 3027 format("SOME_MACRO\n" 3028 " namespace {\n" 3029 "void f( );\n" 3030 "} // namespace")); 3031 // Only if the identifier contains at least 5 characters. 3032 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 3033 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 3034 // Only if everything is upper case. 3035 EXPECT_EQ("class A : public QObject {\n" 3036 " Q_Object A() {}\n" 3037 "};", 3038 format("class A : public QObject {\n" 3039 " Q_Object\n" 3040 " A() {\n}\n" 3041 "} ;")); 3042 3043 // Only if the next line can actually start an unwrapped line. 3044 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 3045 format("SOME_WEIRD_LOG_MACRO\n" 3046 "<< SomeThing;")); 3047 3048 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 3049 "(n, buffers))\n", 3050 getChromiumStyle(FormatStyle::LK_Cpp)); 3051 3052 // See PR41483 3053 EXPECT_EQ("/**/ FOO(a)\n" 3054 "FOO(b)", 3055 format("/**/ FOO(a)\n" 3056 "FOO(b)")); 3057 } 3058 3059 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 3060 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 3061 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 3062 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 3063 "class X {};\n" 3064 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 3065 "int *createScopDetectionPass() { return 0; }", 3066 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 3067 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 3068 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 3069 " class X {};\n" 3070 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 3071 " int *createScopDetectionPass() { return 0; }")); 3072 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 3073 // braces, so that inner block is indented one level more. 3074 EXPECT_EQ("int q() {\n" 3075 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 3076 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 3077 " IPC_END_MESSAGE_MAP()\n" 3078 "}", 3079 format("int q() {\n" 3080 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 3081 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 3082 " IPC_END_MESSAGE_MAP()\n" 3083 "}")); 3084 3085 // Same inside macros. 3086 EXPECT_EQ("#define LIST(L) \\\n" 3087 " L(A) \\\n" 3088 " L(B) \\\n" 3089 " L(C)", 3090 format("#define LIST(L) \\\n" 3091 " L(A) \\\n" 3092 " L(B) \\\n" 3093 " L(C)", 3094 getGoogleStyle())); 3095 3096 // These must not be recognized as macros. 3097 EXPECT_EQ("int q() {\n" 3098 " f(x);\n" 3099 " f(x) {}\n" 3100 " f(x)->g();\n" 3101 " f(x)->*g();\n" 3102 " f(x).g();\n" 3103 " f(x) = x;\n" 3104 " f(x) += x;\n" 3105 " f(x) -= x;\n" 3106 " f(x) *= x;\n" 3107 " f(x) /= x;\n" 3108 " f(x) %= x;\n" 3109 " f(x) &= x;\n" 3110 " f(x) |= x;\n" 3111 " f(x) ^= x;\n" 3112 " f(x) >>= x;\n" 3113 " f(x) <<= x;\n" 3114 " f(x)[y].z();\n" 3115 " LOG(INFO) << x;\n" 3116 " ifstream(x) >> x;\n" 3117 "}\n", 3118 format("int q() {\n" 3119 " f(x)\n;\n" 3120 " f(x)\n {}\n" 3121 " f(x)\n->g();\n" 3122 " f(x)\n->*g();\n" 3123 " f(x)\n.g();\n" 3124 " f(x)\n = x;\n" 3125 " f(x)\n += x;\n" 3126 " f(x)\n -= x;\n" 3127 " f(x)\n *= x;\n" 3128 " f(x)\n /= x;\n" 3129 " f(x)\n %= x;\n" 3130 " f(x)\n &= x;\n" 3131 " f(x)\n |= x;\n" 3132 " f(x)\n ^= x;\n" 3133 " f(x)\n >>= x;\n" 3134 " f(x)\n <<= x;\n" 3135 " f(x)\n[y].z();\n" 3136 " LOG(INFO)\n << x;\n" 3137 " ifstream(x)\n >> x;\n" 3138 "}\n")); 3139 EXPECT_EQ("int q() {\n" 3140 " F(x)\n" 3141 " if (1) {\n" 3142 " }\n" 3143 " F(x)\n" 3144 " while (1) {\n" 3145 " }\n" 3146 " F(x)\n" 3147 " G(x);\n" 3148 " F(x)\n" 3149 " try {\n" 3150 " Q();\n" 3151 " } catch (...) {\n" 3152 " }\n" 3153 "}\n", 3154 format("int q() {\n" 3155 "F(x)\n" 3156 "if (1) {}\n" 3157 "F(x)\n" 3158 "while (1) {}\n" 3159 "F(x)\n" 3160 "G(x);\n" 3161 "F(x)\n" 3162 "try { Q(); } catch (...) {}\n" 3163 "}\n")); 3164 EXPECT_EQ("class A {\n" 3165 " A() : t(0) {}\n" 3166 " A(int i) noexcept() : {}\n" 3167 " A(X x)\n" // FIXME: function-level try blocks are broken. 3168 " try : t(0) {\n" 3169 " } catch (...) {\n" 3170 " }\n" 3171 "};", 3172 format("class A {\n" 3173 " A()\n : t(0) {}\n" 3174 " A(int i)\n noexcept() : {}\n" 3175 " A(X x)\n" 3176 " try : t(0) {} catch (...) {}\n" 3177 "};")); 3178 FormatStyle Style = getLLVMStyle(); 3179 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 3180 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 3181 Style.BraceWrapping.AfterFunction = true; 3182 EXPECT_EQ("void f()\n" 3183 "try\n" 3184 "{\n" 3185 "}", 3186 format("void f() try {\n" 3187 "}", 3188 Style)); 3189 EXPECT_EQ("class SomeClass {\n" 3190 "public:\n" 3191 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3192 "};", 3193 format("class SomeClass {\n" 3194 "public:\n" 3195 " SomeClass()\n" 3196 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3197 "};")); 3198 EXPECT_EQ("class SomeClass {\n" 3199 "public:\n" 3200 " SomeClass()\n" 3201 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3202 "};", 3203 format("class SomeClass {\n" 3204 "public:\n" 3205 " SomeClass()\n" 3206 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3207 "};", 3208 getLLVMStyleWithColumns(40))); 3209 3210 verifyFormat("MACRO(>)"); 3211 3212 // Some macros contain an implicit semicolon. 3213 Style = getLLVMStyle(); 3214 Style.StatementMacros.push_back("FOO"); 3215 verifyFormat("FOO(a) int b = 0;"); 3216 verifyFormat("FOO(a)\n" 3217 "int b = 0;", 3218 Style); 3219 verifyFormat("FOO(a);\n" 3220 "int b = 0;", 3221 Style); 3222 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 3223 "int b = 0;", 3224 Style); 3225 verifyFormat("FOO()\n" 3226 "int b = 0;", 3227 Style); 3228 verifyFormat("FOO\n" 3229 "int b = 0;", 3230 Style); 3231 verifyFormat("void f() {\n" 3232 " FOO(a)\n" 3233 " return a;\n" 3234 "}", 3235 Style); 3236 verifyFormat("FOO(a)\n" 3237 "FOO(b)", 3238 Style); 3239 verifyFormat("int a = 0;\n" 3240 "FOO(b)\n" 3241 "int c = 0;", 3242 Style); 3243 verifyFormat("int a = 0;\n" 3244 "int x = FOO(a)\n" 3245 "int b = 0;", 3246 Style); 3247 verifyFormat("void foo(int a) { FOO(a) }\n" 3248 "uint32_t bar() {}", 3249 Style); 3250 } 3251 3252 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 3253 verifyFormat("#define A \\\n" 3254 " f({ \\\n" 3255 " g(); \\\n" 3256 " });", 3257 getLLVMStyleWithColumns(11)); 3258 } 3259 3260 TEST_F(FormatTest, IndentPreprocessorDirectives) { 3261 FormatStyle Style = getLLVMStyle(); 3262 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 3263 Style.ColumnLimit = 40; 3264 verifyFormat("#ifdef _WIN32\n" 3265 "#define A 0\n" 3266 "#ifdef VAR2\n" 3267 "#define B 1\n" 3268 "#include <someheader.h>\n" 3269 "#define MACRO \\\n" 3270 " some_very_long_func_aaaaaaaaaa();\n" 3271 "#endif\n" 3272 "#else\n" 3273 "#define A 1\n" 3274 "#endif", 3275 Style); 3276 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 3277 verifyFormat("#ifdef _WIN32\n" 3278 "# define A 0\n" 3279 "# ifdef VAR2\n" 3280 "# define B 1\n" 3281 "# include <someheader.h>\n" 3282 "# define MACRO \\\n" 3283 " some_very_long_func_aaaaaaaaaa();\n" 3284 "# endif\n" 3285 "#else\n" 3286 "# define A 1\n" 3287 "#endif", 3288 Style); 3289 verifyFormat("#if A\n" 3290 "# define MACRO \\\n" 3291 " void a(int x) { \\\n" 3292 " b(); \\\n" 3293 " c(); \\\n" 3294 " d(); \\\n" 3295 " e(); \\\n" 3296 " f(); \\\n" 3297 " }\n" 3298 "#endif", 3299 Style); 3300 // Comments before include guard. 3301 verifyFormat("// file comment\n" 3302 "// file comment\n" 3303 "#ifndef HEADER_H\n" 3304 "#define HEADER_H\n" 3305 "code();\n" 3306 "#endif", 3307 Style); 3308 // Test with include guards. 3309 verifyFormat("#ifndef HEADER_H\n" 3310 "#define HEADER_H\n" 3311 "code();\n" 3312 "#endif", 3313 Style); 3314 // Include guards must have a #define with the same variable immediately 3315 // after #ifndef. 3316 verifyFormat("#ifndef NOT_GUARD\n" 3317 "# define FOO\n" 3318 "code();\n" 3319 "#endif", 3320 Style); 3321 3322 // Include guards must cover the entire file. 3323 verifyFormat("code();\n" 3324 "code();\n" 3325 "#ifndef NOT_GUARD\n" 3326 "# define NOT_GUARD\n" 3327 "code();\n" 3328 "#endif", 3329 Style); 3330 verifyFormat("#ifndef NOT_GUARD\n" 3331 "# define NOT_GUARD\n" 3332 "code();\n" 3333 "#endif\n" 3334 "code();", 3335 Style); 3336 // Test with trailing blank lines. 3337 verifyFormat("#ifndef HEADER_H\n" 3338 "#define HEADER_H\n" 3339 "code();\n" 3340 "#endif\n", 3341 Style); 3342 // Include guards don't have #else. 3343 verifyFormat("#ifndef NOT_GUARD\n" 3344 "# define NOT_GUARD\n" 3345 "code();\n" 3346 "#else\n" 3347 "#endif", 3348 Style); 3349 verifyFormat("#ifndef NOT_GUARD\n" 3350 "# define NOT_GUARD\n" 3351 "code();\n" 3352 "#elif FOO\n" 3353 "#endif", 3354 Style); 3355 // Non-identifier #define after potential include guard. 3356 verifyFormat("#ifndef FOO\n" 3357 "# define 1\n" 3358 "#endif\n", 3359 Style); 3360 // #if closes past last non-preprocessor line. 3361 verifyFormat("#ifndef FOO\n" 3362 "#define FOO\n" 3363 "#if 1\n" 3364 "int i;\n" 3365 "# define A 0\n" 3366 "#endif\n" 3367 "#endif\n", 3368 Style); 3369 // Don't crash if there is an #elif directive without a condition. 3370 verifyFormat("#if 1\n" 3371 "int x;\n" 3372 "#elif\n" 3373 "int y;\n" 3374 "#else\n" 3375 "int z;\n" 3376 "#endif", 3377 Style); 3378 // FIXME: This doesn't handle the case where there's code between the 3379 // #ifndef and #define but all other conditions hold. This is because when 3380 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 3381 // previous code line yet, so we can't detect it. 3382 EXPECT_EQ("#ifndef NOT_GUARD\n" 3383 "code();\n" 3384 "#define NOT_GUARD\n" 3385 "code();\n" 3386 "#endif", 3387 format("#ifndef NOT_GUARD\n" 3388 "code();\n" 3389 "# define NOT_GUARD\n" 3390 "code();\n" 3391 "#endif", 3392 Style)); 3393 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 3394 // be outside an include guard. Examples are #pragma once and 3395 // #pragma GCC diagnostic, or anything else that does not change the meaning 3396 // of the file if it's included multiple times. 3397 EXPECT_EQ("#ifdef WIN32\n" 3398 "# pragma once\n" 3399 "#endif\n" 3400 "#ifndef HEADER_H\n" 3401 "# define HEADER_H\n" 3402 "code();\n" 3403 "#endif", 3404 format("#ifdef WIN32\n" 3405 "# pragma once\n" 3406 "#endif\n" 3407 "#ifndef HEADER_H\n" 3408 "#define HEADER_H\n" 3409 "code();\n" 3410 "#endif", 3411 Style)); 3412 // FIXME: This does not detect when there is a single non-preprocessor line 3413 // in front of an include-guard-like structure where other conditions hold 3414 // because ScopedLineState hides the line. 3415 EXPECT_EQ("code();\n" 3416 "#ifndef HEADER_H\n" 3417 "#define HEADER_H\n" 3418 "code();\n" 3419 "#endif", 3420 format("code();\n" 3421 "#ifndef HEADER_H\n" 3422 "# define HEADER_H\n" 3423 "code();\n" 3424 "#endif", 3425 Style)); 3426 // Keep comments aligned with #, otherwise indent comments normally. These 3427 // tests cannot use verifyFormat because messUp manipulates leading 3428 // whitespace. 3429 { 3430 const char *Expected = "" 3431 "void f() {\n" 3432 "#if 1\n" 3433 "// Preprocessor aligned.\n" 3434 "# define A 0\n" 3435 " // Code. Separated by blank line.\n" 3436 "\n" 3437 "# define B 0\n" 3438 " // Code. Not aligned with #\n" 3439 "# define C 0\n" 3440 "#endif"; 3441 const char *ToFormat = "" 3442 "void f() {\n" 3443 "#if 1\n" 3444 "// Preprocessor aligned.\n" 3445 "# define A 0\n" 3446 "// Code. Separated by blank line.\n" 3447 "\n" 3448 "# define B 0\n" 3449 " // Code. Not aligned with #\n" 3450 "# define C 0\n" 3451 "#endif"; 3452 EXPECT_EQ(Expected, format(ToFormat, Style)); 3453 EXPECT_EQ(Expected, format(Expected, Style)); 3454 } 3455 // Keep block quotes aligned. 3456 { 3457 const char *Expected = "" 3458 "void f() {\n" 3459 "#if 1\n" 3460 "/* Preprocessor aligned. */\n" 3461 "# define A 0\n" 3462 " /* Code. Separated by blank line. */\n" 3463 "\n" 3464 "# define B 0\n" 3465 " /* Code. Not aligned with # */\n" 3466 "# define C 0\n" 3467 "#endif"; 3468 const char *ToFormat = "" 3469 "void f() {\n" 3470 "#if 1\n" 3471 "/* Preprocessor aligned. */\n" 3472 "# define A 0\n" 3473 "/* Code. Separated by blank line. */\n" 3474 "\n" 3475 "# define B 0\n" 3476 " /* Code. Not aligned with # */\n" 3477 "# define C 0\n" 3478 "#endif"; 3479 EXPECT_EQ(Expected, format(ToFormat, Style)); 3480 EXPECT_EQ(Expected, format(Expected, Style)); 3481 } 3482 // Keep comments aligned with un-indented directives. 3483 { 3484 const char *Expected = "" 3485 "void f() {\n" 3486 "// Preprocessor aligned.\n" 3487 "#define A 0\n" 3488 " // Code. Separated by blank line.\n" 3489 "\n" 3490 "#define B 0\n" 3491 " // Code. Not aligned with #\n" 3492 "#define C 0\n"; 3493 const char *ToFormat = "" 3494 "void f() {\n" 3495 "// Preprocessor aligned.\n" 3496 "#define A 0\n" 3497 "// Code. Separated by blank line.\n" 3498 "\n" 3499 "#define B 0\n" 3500 " // Code. Not aligned with #\n" 3501 "#define C 0\n"; 3502 EXPECT_EQ(Expected, format(ToFormat, Style)); 3503 EXPECT_EQ(Expected, format(Expected, Style)); 3504 } 3505 // Test AfterHash with tabs. 3506 { 3507 FormatStyle Tabbed = Style; 3508 Tabbed.UseTab = FormatStyle::UT_Always; 3509 Tabbed.IndentWidth = 8; 3510 Tabbed.TabWidth = 8; 3511 verifyFormat("#ifdef _WIN32\n" 3512 "#\tdefine A 0\n" 3513 "#\tifdef VAR2\n" 3514 "#\t\tdefine B 1\n" 3515 "#\t\tinclude <someheader.h>\n" 3516 "#\t\tdefine MACRO \\\n" 3517 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3518 "#\tendif\n" 3519 "#else\n" 3520 "#\tdefine A 1\n" 3521 "#endif", 3522 Tabbed); 3523 } 3524 3525 // Regression test: Multiline-macro inside include guards. 3526 verifyFormat("#ifndef HEADER_H\n" 3527 "#define HEADER_H\n" 3528 "#define A() \\\n" 3529 " int i; \\\n" 3530 " int j;\n" 3531 "#endif // HEADER_H", 3532 getLLVMStyleWithColumns(20)); 3533 3534 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3535 // Basic before hash indent tests 3536 verifyFormat("#ifdef _WIN32\n" 3537 " #define A 0\n" 3538 " #ifdef VAR2\n" 3539 " #define B 1\n" 3540 " #include <someheader.h>\n" 3541 " #define MACRO \\\n" 3542 " some_very_long_func_aaaaaaaaaa();\n" 3543 " #endif\n" 3544 "#else\n" 3545 " #define A 1\n" 3546 "#endif", 3547 Style); 3548 verifyFormat("#if A\n" 3549 " #define MACRO \\\n" 3550 " void a(int x) { \\\n" 3551 " b(); \\\n" 3552 " c(); \\\n" 3553 " d(); \\\n" 3554 " e(); \\\n" 3555 " f(); \\\n" 3556 " }\n" 3557 "#endif", 3558 Style); 3559 // Keep comments aligned with indented directives. These 3560 // tests cannot use verifyFormat because messUp manipulates leading 3561 // whitespace. 3562 { 3563 const char *Expected = "void f() {\n" 3564 "// Aligned to preprocessor.\n" 3565 "#if 1\n" 3566 " // Aligned to code.\n" 3567 " int a;\n" 3568 " #if 1\n" 3569 " // Aligned to preprocessor.\n" 3570 " #define A 0\n" 3571 " // Aligned to code.\n" 3572 " int b;\n" 3573 " #endif\n" 3574 "#endif\n" 3575 "}"; 3576 const char *ToFormat = "void f() {\n" 3577 "// Aligned to preprocessor.\n" 3578 "#if 1\n" 3579 "// Aligned to code.\n" 3580 "int a;\n" 3581 "#if 1\n" 3582 "// Aligned to preprocessor.\n" 3583 "#define A 0\n" 3584 "// Aligned to code.\n" 3585 "int b;\n" 3586 "#endif\n" 3587 "#endif\n" 3588 "}"; 3589 EXPECT_EQ(Expected, format(ToFormat, Style)); 3590 EXPECT_EQ(Expected, format(Expected, Style)); 3591 } 3592 { 3593 const char *Expected = "void f() {\n" 3594 "/* Aligned to preprocessor. */\n" 3595 "#if 1\n" 3596 " /* Aligned to code. */\n" 3597 " int a;\n" 3598 " #if 1\n" 3599 " /* Aligned to preprocessor. */\n" 3600 " #define A 0\n" 3601 " /* Aligned to code. */\n" 3602 " int b;\n" 3603 " #endif\n" 3604 "#endif\n" 3605 "}"; 3606 const char *ToFormat = "void f() {\n" 3607 "/* Aligned to preprocessor. */\n" 3608 "#if 1\n" 3609 "/* Aligned to code. */\n" 3610 "int a;\n" 3611 "#if 1\n" 3612 "/* Aligned to preprocessor. */\n" 3613 "#define A 0\n" 3614 "/* Aligned to code. */\n" 3615 "int b;\n" 3616 "#endif\n" 3617 "#endif\n" 3618 "}"; 3619 EXPECT_EQ(Expected, format(ToFormat, Style)); 3620 EXPECT_EQ(Expected, format(Expected, Style)); 3621 } 3622 3623 // Test single comment before preprocessor 3624 verifyFormat("// Comment\n" 3625 "\n" 3626 "#if 1\n" 3627 "#endif", 3628 Style); 3629 } 3630 3631 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3632 verifyFormat("{\n { a #c; }\n}"); 3633 } 3634 3635 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3636 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3637 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3638 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3639 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3640 } 3641 3642 TEST_F(FormatTest, EscapedNewlines) { 3643 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3644 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3645 format("#define A \\\nint i;\\\n int j;", Narrow)); 3646 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3647 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3648 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3649 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3650 3651 FormatStyle AlignLeft = getLLVMStyle(); 3652 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3653 EXPECT_EQ("#define MACRO(x) \\\n" 3654 "private: \\\n" 3655 " int x(int a);\n", 3656 format("#define MACRO(x) \\\n" 3657 "private: \\\n" 3658 " int x(int a);\n", 3659 AlignLeft)); 3660 3661 // CRLF line endings 3662 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3663 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3664 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3665 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3666 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3667 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3668 EXPECT_EQ("#define MACRO(x) \\\r\n" 3669 "private: \\\r\n" 3670 " int x(int a);\r\n", 3671 format("#define MACRO(x) \\\r\n" 3672 "private: \\\r\n" 3673 " int x(int a);\r\n", 3674 AlignLeft)); 3675 3676 FormatStyle DontAlign = getLLVMStyle(); 3677 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3678 DontAlign.MaxEmptyLinesToKeep = 3; 3679 // FIXME: can't use verifyFormat here because the newline before 3680 // "public:" is not inserted the first time it's reformatted 3681 EXPECT_EQ("#define A \\\n" 3682 " class Foo { \\\n" 3683 " void bar(); \\\n" 3684 "\\\n" 3685 "\\\n" 3686 "\\\n" 3687 " public: \\\n" 3688 " void baz(); \\\n" 3689 " };", 3690 format("#define A \\\n" 3691 " class Foo { \\\n" 3692 " void bar(); \\\n" 3693 "\\\n" 3694 "\\\n" 3695 "\\\n" 3696 " public: \\\n" 3697 " void baz(); \\\n" 3698 " };", 3699 DontAlign)); 3700 } 3701 3702 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3703 verifyFormat("#define A \\\n" 3704 " int v( \\\n" 3705 " a); \\\n" 3706 " int i;", 3707 getLLVMStyleWithColumns(11)); 3708 } 3709 3710 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3711 EXPECT_EQ( 3712 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3713 " \\\n" 3714 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3715 "\n" 3716 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3717 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3718 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3719 "\\\n" 3720 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3721 " \n" 3722 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3723 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3724 } 3725 3726 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3727 EXPECT_EQ("int\n" 3728 "#define A\n" 3729 " a;", 3730 format("int\n#define A\na;")); 3731 verifyFormat("functionCallTo(\n" 3732 " someOtherFunction(\n" 3733 " withSomeParameters, whichInSequence,\n" 3734 " areLongerThanALine(andAnotherCall,\n" 3735 "#define A B\n" 3736 " withMoreParamters,\n" 3737 " whichStronglyInfluenceTheLayout),\n" 3738 " andMoreParameters),\n" 3739 " trailing);", 3740 getLLVMStyleWithColumns(69)); 3741 verifyFormat("Foo::Foo()\n" 3742 "#ifdef BAR\n" 3743 " : baz(0)\n" 3744 "#endif\n" 3745 "{\n" 3746 "}"); 3747 verifyFormat("void f() {\n" 3748 " if (true)\n" 3749 "#ifdef A\n" 3750 " f(42);\n" 3751 " x();\n" 3752 "#else\n" 3753 " g();\n" 3754 " x();\n" 3755 "#endif\n" 3756 "}"); 3757 verifyFormat("void f(param1, param2,\n" 3758 " param3,\n" 3759 "#ifdef A\n" 3760 " param4(param5,\n" 3761 "#ifdef A1\n" 3762 " param6,\n" 3763 "#ifdef A2\n" 3764 " param7),\n" 3765 "#else\n" 3766 " param8),\n" 3767 " param9,\n" 3768 "#endif\n" 3769 " param10,\n" 3770 "#endif\n" 3771 " param11)\n" 3772 "#else\n" 3773 " param12)\n" 3774 "#endif\n" 3775 "{\n" 3776 " x();\n" 3777 "}", 3778 getLLVMStyleWithColumns(28)); 3779 verifyFormat("#if 1\n" 3780 "int i;"); 3781 verifyFormat("#if 1\n" 3782 "#endif\n" 3783 "#if 1\n" 3784 "#else\n" 3785 "#endif\n"); 3786 verifyFormat("DEBUG({\n" 3787 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3788 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3789 "});\n" 3790 "#if a\n" 3791 "#else\n" 3792 "#endif"); 3793 3794 verifyIncompleteFormat("void f(\n" 3795 "#if A\n" 3796 ");\n" 3797 "#else\n" 3798 "#endif"); 3799 } 3800 3801 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3802 verifyFormat("#endif\n" 3803 "#if B"); 3804 } 3805 3806 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3807 FormatStyle SingleLine = getLLVMStyle(); 3808 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3809 verifyFormat("#if 0\n" 3810 "#elif 1\n" 3811 "#endif\n" 3812 "void foo() {\n" 3813 " if (test) foo2();\n" 3814 "}", 3815 SingleLine); 3816 } 3817 3818 TEST_F(FormatTest, LayoutBlockInsideParens) { 3819 verifyFormat("functionCall({ int i; });"); 3820 verifyFormat("functionCall({\n" 3821 " int i;\n" 3822 " int j;\n" 3823 "});"); 3824 verifyFormat("functionCall(\n" 3825 " {\n" 3826 " int i;\n" 3827 " int j;\n" 3828 " },\n" 3829 " aaaa, bbbb, cccc);"); 3830 verifyFormat("functionA(functionB({\n" 3831 " int i;\n" 3832 " int j;\n" 3833 " }),\n" 3834 " aaaa, bbbb, cccc);"); 3835 verifyFormat("functionCall(\n" 3836 " {\n" 3837 " int i;\n" 3838 " int j;\n" 3839 " },\n" 3840 " aaaa, bbbb, // comment\n" 3841 " cccc);"); 3842 verifyFormat("functionA(functionB({\n" 3843 " int i;\n" 3844 " int j;\n" 3845 " }),\n" 3846 " aaaa, bbbb, // comment\n" 3847 " cccc);"); 3848 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3849 verifyFormat("functionCall(aaaa, bbbb, {\n" 3850 " int i;\n" 3851 " int j;\n" 3852 "});"); 3853 verifyFormat( 3854 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3855 " {\n" 3856 " int i; // break\n" 3857 " },\n" 3858 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3859 " ccccccccccccccccc));"); 3860 verifyFormat("DEBUG({\n" 3861 " if (a)\n" 3862 " f();\n" 3863 "});"); 3864 } 3865 3866 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3867 EXPECT_EQ("SOME_MACRO { int i; }\n" 3868 "int i;", 3869 format(" SOME_MACRO {int i;} int i;")); 3870 } 3871 3872 TEST_F(FormatTest, LayoutNestedBlocks) { 3873 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3874 " struct s {\n" 3875 " int i;\n" 3876 " };\n" 3877 " s kBitsToOs[] = {{10}};\n" 3878 " for (int i = 0; i < 10; ++i)\n" 3879 " return;\n" 3880 "}"); 3881 verifyFormat("call(parameter, {\n" 3882 " something();\n" 3883 " // Comment using all columns.\n" 3884 " somethingelse();\n" 3885 "});", 3886 getLLVMStyleWithColumns(40)); 3887 verifyFormat("DEBUG( //\n" 3888 " { f(); }, a);"); 3889 verifyFormat("DEBUG( //\n" 3890 " {\n" 3891 " f(); //\n" 3892 " },\n" 3893 " a);"); 3894 3895 EXPECT_EQ("call(parameter, {\n" 3896 " something();\n" 3897 " // Comment too\n" 3898 " // looooooooooong.\n" 3899 " somethingElse();\n" 3900 "});", 3901 format("call(parameter, {\n" 3902 " something();\n" 3903 " // Comment too looooooooooong.\n" 3904 " somethingElse();\n" 3905 "});", 3906 getLLVMStyleWithColumns(29))); 3907 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3908 EXPECT_EQ("DEBUG({ // comment\n" 3909 " int i;\n" 3910 "});", 3911 format("DEBUG({ // comment\n" 3912 "int i;\n" 3913 "});")); 3914 EXPECT_EQ("DEBUG({\n" 3915 " int i;\n" 3916 "\n" 3917 " // comment\n" 3918 " int j;\n" 3919 "});", 3920 format("DEBUG({\n" 3921 " int i;\n" 3922 "\n" 3923 " // comment\n" 3924 " int j;\n" 3925 "});")); 3926 3927 verifyFormat("DEBUG({\n" 3928 " if (a)\n" 3929 " return;\n" 3930 "});"); 3931 verifyGoogleFormat("DEBUG({\n" 3932 " if (a) return;\n" 3933 "});"); 3934 FormatStyle Style = getGoogleStyle(); 3935 Style.ColumnLimit = 45; 3936 verifyFormat("Debug(\n" 3937 " aaaaa,\n" 3938 " {\n" 3939 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 3940 " },\n" 3941 " a);", 3942 Style); 3943 3944 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 3945 3946 verifyNoCrash("^{v^{a}}"); 3947 } 3948 3949 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 3950 EXPECT_EQ("#define MACRO() \\\n" 3951 " Debug(aaa, /* force line break */ \\\n" 3952 " { \\\n" 3953 " int i; \\\n" 3954 " int j; \\\n" 3955 " })", 3956 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 3957 " { int i; int j; })", 3958 getGoogleStyle())); 3959 3960 EXPECT_EQ("#define A \\\n" 3961 " [] { \\\n" 3962 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3963 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 3964 " }", 3965 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3966 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 3967 getGoogleStyle())); 3968 } 3969 3970 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 3971 EXPECT_EQ("{}", format("{}")); 3972 verifyFormat("enum E {};"); 3973 verifyFormat("enum E {}"); 3974 FormatStyle Style = getLLVMStyle(); 3975 Style.SpaceInEmptyBlock = true; 3976 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 3977 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 3978 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 3979 } 3980 3981 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 3982 FormatStyle Style = getLLVMStyle(); 3983 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 3984 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 3985 verifyFormat("FOO_BEGIN\n" 3986 " FOO_ENTRY\n" 3987 "FOO_END", 3988 Style); 3989 verifyFormat("FOO_BEGIN\n" 3990 " NESTED_FOO_BEGIN\n" 3991 " NESTED_FOO_ENTRY\n" 3992 " NESTED_FOO_END\n" 3993 "FOO_END", 3994 Style); 3995 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 3996 " int x;\n" 3997 " x = 1;\n" 3998 "FOO_END(Baz)", 3999 Style); 4000 } 4001 4002 //===----------------------------------------------------------------------===// 4003 // Line break tests. 4004 //===----------------------------------------------------------------------===// 4005 4006 TEST_F(FormatTest, PreventConfusingIndents) { 4007 verifyFormat( 4008 "void f() {\n" 4009 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 4010 " parameter, parameter, parameter)),\n" 4011 " SecondLongCall(parameter));\n" 4012 "}"); 4013 verifyFormat( 4014 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4015 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4016 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4017 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 4018 verifyFormat( 4019 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4020 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 4021 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 4022 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 4023 verifyFormat( 4024 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 4025 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 4026 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 4027 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 4028 verifyFormat("int a = bbbb && ccc &&\n" 4029 " fffff(\n" 4030 "#define A Just forcing a new line\n" 4031 " ddd);"); 4032 } 4033 4034 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 4035 verifyFormat( 4036 "bool aaaaaaa =\n" 4037 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 4038 " bbbbbbbb();"); 4039 verifyFormat( 4040 "bool aaaaaaa =\n" 4041 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 4042 " bbbbbbbb();"); 4043 4044 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 4045 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 4046 " ccccccccc == ddddddddddd;"); 4047 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 4048 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 4049 " ccccccccc == ddddddddddd;"); 4050 verifyFormat( 4051 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 4052 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 4053 " ccccccccc == ddddddddddd;"); 4054 4055 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 4056 " aaaaaa) &&\n" 4057 " bbbbbb && cccccc;"); 4058 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 4059 " aaaaaa) >>\n" 4060 " bbbbbb;"); 4061 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 4062 " SourceMgr.getSpellingColumnNumber(\n" 4063 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 4064 " 1);"); 4065 4066 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4067 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 4068 " cccccc) {\n}"); 4069 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4070 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 4071 " cccccc) {\n}"); 4072 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4073 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 4074 " cccccc) {\n}"); 4075 verifyFormat("b = a &&\n" 4076 " // Comment\n" 4077 " b.c && d;"); 4078 4079 // If the LHS of a comparison is not a binary expression itself, the 4080 // additional linebreak confuses many people. 4081 verifyFormat( 4082 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4083 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 4084 "}"); 4085 verifyFormat( 4086 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4087 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4088 "}"); 4089 verifyFormat( 4090 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 4091 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4092 "}"); 4093 verifyFormat( 4094 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4095 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 4096 "}"); 4097 // Even explicit parentheses stress the precedence enough to make the 4098 // additional break unnecessary. 4099 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4100 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4101 "}"); 4102 // This cases is borderline, but with the indentation it is still readable. 4103 verifyFormat( 4104 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4105 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4106 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 4107 "}", 4108 getLLVMStyleWithColumns(75)); 4109 4110 // If the LHS is a binary expression, we should still use the additional break 4111 // as otherwise the formatting hides the operator precedence. 4112 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4113 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4114 " 5) {\n" 4115 "}"); 4116 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4117 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 4118 " 5) {\n" 4119 "}"); 4120 4121 FormatStyle OnePerLine = getLLVMStyle(); 4122 OnePerLine.BinPackParameters = false; 4123 verifyFormat( 4124 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4125 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4126 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 4127 OnePerLine); 4128 4129 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 4130 " .aaa(aaaaaaaaaaaaa) *\n" 4131 " aaaaaaa +\n" 4132 " aaaaaaa;", 4133 getLLVMStyleWithColumns(40)); 4134 } 4135 4136 TEST_F(FormatTest, ExpressionIndentation) { 4137 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4138 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4139 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4140 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4141 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 4142 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 4143 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4144 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 4145 " ccccccccccccccccccccccccccccccccccccccccc;"); 4146 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4147 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4148 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4149 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4150 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4151 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4152 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4153 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4154 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4155 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4156 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4157 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4158 verifyFormat("if () {\n" 4159 "} else if (aaaaa && bbbbb > // break\n" 4160 " ccccc) {\n" 4161 "}"); 4162 verifyFormat("if () {\n" 4163 "} else if constexpr (aaaaa && bbbbb > // break\n" 4164 " ccccc) {\n" 4165 "}"); 4166 verifyFormat("if () {\n" 4167 "} else if CONSTEXPR (aaaaa && bbbbb > // break\n" 4168 " ccccc) {\n" 4169 "}"); 4170 verifyFormat("if () {\n" 4171 "} else if (aaaaa &&\n" 4172 " bbbbb > // break\n" 4173 " ccccc &&\n" 4174 " ddddd) {\n" 4175 "}"); 4176 4177 // Presence of a trailing comment used to change indentation of b. 4178 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 4179 " b;\n" 4180 "return aaaaaaaaaaaaaaaaaaa +\n" 4181 " b; //", 4182 getLLVMStyleWithColumns(30)); 4183 } 4184 4185 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 4186 // Not sure what the best system is here. Like this, the LHS can be found 4187 // immediately above an operator (everything with the same or a higher 4188 // indent). The RHS is aligned right of the operator and so compasses 4189 // everything until something with the same indent as the operator is found. 4190 // FIXME: Is this a good system? 4191 FormatStyle Style = getLLVMStyle(); 4192 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 4193 verifyFormat( 4194 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4195 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4196 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4197 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4198 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4199 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4200 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4201 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4202 " > ccccccccccccccccccccccccccccccccccccccccc;", 4203 Style); 4204 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4205 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4206 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4207 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4208 Style); 4209 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4210 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4211 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4212 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4213 Style); 4214 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4215 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4216 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4217 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4218 Style); 4219 verifyFormat("if () {\n" 4220 "} else if (aaaaa\n" 4221 " && bbbbb // break\n" 4222 " > ccccc) {\n" 4223 "}", 4224 Style); 4225 verifyFormat("return (a)\n" 4226 " // comment\n" 4227 " + b;", 4228 Style); 4229 verifyFormat( 4230 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4231 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4232 " + cc;", 4233 Style); 4234 4235 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4236 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4237 Style); 4238 4239 // Forced by comments. 4240 verifyFormat( 4241 "unsigned ContentSize =\n" 4242 " sizeof(int16_t) // DWARF ARange version number\n" 4243 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4244 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4245 " + sizeof(int8_t); // Segment Size (in bytes)"); 4246 4247 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 4248 " == boost::fusion::at_c<1>(iiii).second;", 4249 Style); 4250 4251 Style.ColumnLimit = 60; 4252 verifyFormat("zzzzzzzzzz\n" 4253 " = bbbbbbbbbbbbbbbbb\n" 4254 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 4255 Style); 4256 4257 Style.ColumnLimit = 80; 4258 Style.IndentWidth = 4; 4259 Style.TabWidth = 4; 4260 Style.UseTab = FormatStyle::UT_Always; 4261 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4262 Style.AlignOperands = false; 4263 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 4264 "\t&& (someOtherLongishConditionPart1\n" 4265 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 4266 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && " 4267 "(someOtherLongishConditionPart1 || " 4268 "someOtherEvenLongerNestedConditionPart2);", 4269 Style)); 4270 } 4271 4272 TEST_F(FormatTest, EnforcedOperatorWraps) { 4273 // Here we'd like to wrap after the || operators, but a comment is forcing an 4274 // earlier wrap. 4275 verifyFormat("bool x = aaaaa //\n" 4276 " || bbbbb\n" 4277 " //\n" 4278 " || cccc;"); 4279 } 4280 4281 TEST_F(FormatTest, NoOperandAlignment) { 4282 FormatStyle Style = getLLVMStyle(); 4283 Style.AlignOperands = false; 4284 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 4285 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4286 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4287 Style); 4288 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4289 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4290 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4291 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4292 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4293 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4294 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4295 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4296 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4297 " > ccccccccccccccccccccccccccccccccccccccccc;", 4298 Style); 4299 4300 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4301 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4302 " + cc;", 4303 Style); 4304 verifyFormat("int a = aa\n" 4305 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4306 " * cccccccccccccccccccccccccccccccccccc;\n", 4307 Style); 4308 4309 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4310 verifyFormat("return (a > b\n" 4311 " // comment1\n" 4312 " // comment2\n" 4313 " || c);", 4314 Style); 4315 } 4316 4317 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 4318 FormatStyle Style = getLLVMStyle(); 4319 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4320 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4321 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4322 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4323 Style); 4324 } 4325 4326 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 4327 FormatStyle Style = getLLVMStyle(); 4328 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4329 Style.BinPackArguments = false; 4330 Style.ColumnLimit = 40; 4331 verifyFormat("void test() {\n" 4332 " someFunction(\n" 4333 " this + argument + is + quite\n" 4334 " + long + so + it + gets + wrapped\n" 4335 " + but + remains + bin - packed);\n" 4336 "}", 4337 Style); 4338 verifyFormat("void test() {\n" 4339 " someFunction(arg1,\n" 4340 " this + argument + is\n" 4341 " + quite + long + so\n" 4342 " + it + gets + wrapped\n" 4343 " + but + remains + bin\n" 4344 " - packed,\n" 4345 " arg3);\n" 4346 "}", 4347 Style); 4348 verifyFormat("void test() {\n" 4349 " someFunction(\n" 4350 " arg1,\n" 4351 " this + argument + has\n" 4352 " + anotherFunc(nested,\n" 4353 " calls + whose\n" 4354 " + arguments\n" 4355 " + are + also\n" 4356 " + wrapped,\n" 4357 " in + addition)\n" 4358 " + to + being + bin - packed,\n" 4359 " arg3);\n" 4360 "}", 4361 Style); 4362 4363 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4364 verifyFormat("void test() {\n" 4365 " someFunction(\n" 4366 " arg1,\n" 4367 " this + argument + has +\n" 4368 " anotherFunc(nested,\n" 4369 " calls + whose +\n" 4370 " arguments +\n" 4371 " are + also +\n" 4372 " wrapped,\n" 4373 " in + addition) +\n" 4374 " to + being + bin - packed,\n" 4375 " arg3);\n" 4376 "}", 4377 Style); 4378 } 4379 4380 TEST_F(FormatTest, ConstructorInitializers) { 4381 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4382 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 4383 getLLVMStyleWithColumns(45)); 4384 verifyFormat("Constructor()\n" 4385 " : Inttializer(FitsOnTheLine) {}", 4386 getLLVMStyleWithColumns(44)); 4387 verifyFormat("Constructor()\n" 4388 " : Inttializer(FitsOnTheLine) {}", 4389 getLLVMStyleWithColumns(43)); 4390 4391 verifyFormat("template <typename T>\n" 4392 "Constructor() : Initializer(FitsOnTheLine) {}", 4393 getLLVMStyleWithColumns(45)); 4394 4395 verifyFormat( 4396 "SomeClass::Constructor()\n" 4397 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4398 4399 verifyFormat( 4400 "SomeClass::Constructor()\n" 4401 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4402 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 4403 verifyFormat( 4404 "SomeClass::Constructor()\n" 4405 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4406 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4407 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4408 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4409 " : aaaaaaaaaa(aaaaaa) {}"); 4410 4411 verifyFormat("Constructor()\n" 4412 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4413 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4414 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4415 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 4416 4417 verifyFormat("Constructor()\n" 4418 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4419 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4420 4421 verifyFormat("Constructor(int Parameter = 0)\n" 4422 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4423 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 4424 verifyFormat("Constructor()\n" 4425 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4426 "}", 4427 getLLVMStyleWithColumns(60)); 4428 verifyFormat("Constructor()\n" 4429 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4430 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 4431 4432 // Here a line could be saved by splitting the second initializer onto two 4433 // lines, but that is not desirable. 4434 verifyFormat("Constructor()\n" 4435 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4436 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4437 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4438 4439 FormatStyle OnePerLine = getLLVMStyle(); 4440 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4441 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 4442 verifyFormat("SomeClass::Constructor()\n" 4443 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4444 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4445 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4446 OnePerLine); 4447 verifyFormat("SomeClass::Constructor()\n" 4448 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4449 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4450 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4451 OnePerLine); 4452 verifyFormat("MyClass::MyClass(int var)\n" 4453 " : some_var_(var), // 4 space indent\n" 4454 " some_other_var_(var + 1) { // lined up\n" 4455 "}", 4456 OnePerLine); 4457 verifyFormat("Constructor()\n" 4458 " : aaaaa(aaaaaa),\n" 4459 " aaaaa(aaaaaa),\n" 4460 " aaaaa(aaaaaa),\n" 4461 " aaaaa(aaaaaa),\n" 4462 " aaaaa(aaaaaa) {}", 4463 OnePerLine); 4464 verifyFormat("Constructor()\n" 4465 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4466 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4467 OnePerLine); 4468 OnePerLine.BinPackParameters = false; 4469 verifyFormat( 4470 "Constructor()\n" 4471 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4472 " aaaaaaaaaaa().aaa(),\n" 4473 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4474 OnePerLine); 4475 OnePerLine.ColumnLimit = 60; 4476 verifyFormat("Constructor()\n" 4477 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4478 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4479 OnePerLine); 4480 4481 EXPECT_EQ("Constructor()\n" 4482 " : // Comment forcing unwanted break.\n" 4483 " aaaa(aaaa) {}", 4484 format("Constructor() :\n" 4485 " // Comment forcing unwanted break.\n" 4486 " aaaa(aaaa) {}")); 4487 } 4488 4489 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 4490 FormatStyle Style = getLLVMStyle(); 4491 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4492 Style.ColumnLimit = 60; 4493 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4494 Style.AllowAllConstructorInitializersOnNextLine = true; 4495 Style.BinPackParameters = false; 4496 4497 for (int i = 0; i < 4; ++i) { 4498 // Test all combinations of parameters that should not have an effect. 4499 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4500 Style.AllowAllArgumentsOnNextLine = i & 2; 4501 4502 Style.AllowAllConstructorInitializersOnNextLine = true; 4503 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4504 verifyFormat("Constructor()\n" 4505 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4506 Style); 4507 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4508 4509 Style.AllowAllConstructorInitializersOnNextLine = false; 4510 verifyFormat("Constructor()\n" 4511 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4512 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4513 Style); 4514 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4515 4516 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4517 Style.AllowAllConstructorInitializersOnNextLine = true; 4518 verifyFormat("Constructor()\n" 4519 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4520 Style); 4521 4522 Style.AllowAllConstructorInitializersOnNextLine = false; 4523 verifyFormat("Constructor()\n" 4524 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4525 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4526 Style); 4527 4528 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4529 Style.AllowAllConstructorInitializersOnNextLine = true; 4530 verifyFormat("Constructor() :\n" 4531 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4532 Style); 4533 4534 Style.AllowAllConstructorInitializersOnNextLine = false; 4535 verifyFormat("Constructor() :\n" 4536 " aaaaaaaaaaaaaaaaaa(a),\n" 4537 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4538 Style); 4539 } 4540 4541 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4542 // AllowAllConstructorInitializersOnNextLine in all 4543 // BreakConstructorInitializers modes 4544 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4545 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4546 Style.AllowAllConstructorInitializersOnNextLine = false; 4547 verifyFormat("SomeClassWithALongName::Constructor(\n" 4548 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4549 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4550 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4551 Style); 4552 4553 Style.AllowAllConstructorInitializersOnNextLine = true; 4554 verifyFormat("SomeClassWithALongName::Constructor(\n" 4555 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4556 " int bbbbbbbbbbbbb,\n" 4557 " int cccccccccccccccc)\n" 4558 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4559 Style); 4560 4561 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4562 Style.AllowAllConstructorInitializersOnNextLine = false; 4563 verifyFormat("SomeClassWithALongName::Constructor(\n" 4564 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4565 " int bbbbbbbbbbbbb)\n" 4566 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4567 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4568 Style); 4569 4570 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4571 4572 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4573 verifyFormat("SomeClassWithALongName::Constructor(\n" 4574 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4575 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4576 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4577 Style); 4578 4579 Style.AllowAllConstructorInitializersOnNextLine = true; 4580 verifyFormat("SomeClassWithALongName::Constructor(\n" 4581 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4582 " int bbbbbbbbbbbbb,\n" 4583 " int cccccccccccccccc)\n" 4584 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4585 Style); 4586 4587 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4588 Style.AllowAllConstructorInitializersOnNextLine = false; 4589 verifyFormat("SomeClassWithALongName::Constructor(\n" 4590 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4591 " int bbbbbbbbbbbbb)\n" 4592 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4593 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4594 Style); 4595 4596 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4597 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4598 verifyFormat("SomeClassWithALongName::Constructor(\n" 4599 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4600 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4601 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4602 Style); 4603 4604 Style.AllowAllConstructorInitializersOnNextLine = true; 4605 verifyFormat("SomeClassWithALongName::Constructor(\n" 4606 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4607 " int bbbbbbbbbbbbb,\n" 4608 " int cccccccccccccccc) :\n" 4609 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4610 Style); 4611 4612 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4613 Style.AllowAllConstructorInitializersOnNextLine = false; 4614 verifyFormat("SomeClassWithALongName::Constructor(\n" 4615 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4616 " int bbbbbbbbbbbbb) :\n" 4617 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4618 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4619 Style); 4620 } 4621 4622 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4623 FormatStyle Style = getLLVMStyle(); 4624 Style.ColumnLimit = 60; 4625 Style.BinPackArguments = false; 4626 for (int i = 0; i < 4; ++i) { 4627 // Test all combinations of parameters that should not have an effect. 4628 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4629 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4630 4631 Style.AllowAllArgumentsOnNextLine = true; 4632 verifyFormat("void foo() {\n" 4633 " FunctionCallWithReallyLongName(\n" 4634 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4635 "}", 4636 Style); 4637 Style.AllowAllArgumentsOnNextLine = false; 4638 verifyFormat("void foo() {\n" 4639 " FunctionCallWithReallyLongName(\n" 4640 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4641 " bbbbbbbbbbbb);\n" 4642 "}", 4643 Style); 4644 4645 Style.AllowAllArgumentsOnNextLine = true; 4646 verifyFormat("void foo() {\n" 4647 " auto VariableWithReallyLongName = {\n" 4648 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4649 "}", 4650 Style); 4651 Style.AllowAllArgumentsOnNextLine = false; 4652 verifyFormat("void foo() {\n" 4653 " auto VariableWithReallyLongName = {\n" 4654 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4655 " bbbbbbbbbbbb};\n" 4656 "}", 4657 Style); 4658 } 4659 4660 // This parameter should not affect declarations. 4661 Style.BinPackParameters = false; 4662 Style.AllowAllArgumentsOnNextLine = false; 4663 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4664 verifyFormat("void FunctionCallWithReallyLongName(\n" 4665 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4666 Style); 4667 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4668 verifyFormat("void FunctionCallWithReallyLongName(\n" 4669 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4670 " int bbbbbbbbbbbb);", 4671 Style); 4672 } 4673 4674 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4675 FormatStyle Style = getLLVMStyle(); 4676 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4677 4678 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4679 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4680 getStyleWithColumns(Style, 45)); 4681 verifyFormat("Constructor() :\n" 4682 " Initializer(FitsOnTheLine) {}", 4683 getStyleWithColumns(Style, 44)); 4684 verifyFormat("Constructor() :\n" 4685 " Initializer(FitsOnTheLine) {}", 4686 getStyleWithColumns(Style, 43)); 4687 4688 verifyFormat("template <typename T>\n" 4689 "Constructor() : Initializer(FitsOnTheLine) {}", 4690 getStyleWithColumns(Style, 50)); 4691 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4692 verifyFormat( 4693 "SomeClass::Constructor() :\n" 4694 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4695 Style); 4696 4697 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4698 verifyFormat( 4699 "SomeClass::Constructor() :\n" 4700 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4701 Style); 4702 4703 verifyFormat( 4704 "SomeClass::Constructor() :\n" 4705 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4706 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4707 Style); 4708 verifyFormat( 4709 "SomeClass::Constructor() :\n" 4710 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4711 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4712 Style); 4713 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4714 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4715 " aaaaaaaaaa(aaaaaa) {}", 4716 Style); 4717 4718 verifyFormat("Constructor() :\n" 4719 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4720 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4721 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4722 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4723 Style); 4724 4725 verifyFormat("Constructor() :\n" 4726 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4727 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4728 Style); 4729 4730 verifyFormat("Constructor(int Parameter = 0) :\n" 4731 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4732 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4733 Style); 4734 verifyFormat("Constructor() :\n" 4735 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4736 "}", 4737 getStyleWithColumns(Style, 60)); 4738 verifyFormat("Constructor() :\n" 4739 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4740 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4741 Style); 4742 4743 // Here a line could be saved by splitting the second initializer onto two 4744 // lines, but that is not desirable. 4745 verifyFormat("Constructor() :\n" 4746 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4747 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4748 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4749 Style); 4750 4751 FormatStyle OnePerLine = Style; 4752 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4753 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4754 verifyFormat("SomeClass::Constructor() :\n" 4755 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4756 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4757 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4758 OnePerLine); 4759 verifyFormat("SomeClass::Constructor() :\n" 4760 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4761 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4762 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4763 OnePerLine); 4764 verifyFormat("MyClass::MyClass(int var) :\n" 4765 " some_var_(var), // 4 space indent\n" 4766 " some_other_var_(var + 1) { // lined up\n" 4767 "}", 4768 OnePerLine); 4769 verifyFormat("Constructor() :\n" 4770 " aaaaa(aaaaaa),\n" 4771 " aaaaa(aaaaaa),\n" 4772 " aaaaa(aaaaaa),\n" 4773 " aaaaa(aaaaaa),\n" 4774 " aaaaa(aaaaaa) {}", 4775 OnePerLine); 4776 verifyFormat("Constructor() :\n" 4777 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4778 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4779 OnePerLine); 4780 OnePerLine.BinPackParameters = false; 4781 verifyFormat("Constructor() :\n" 4782 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4783 " aaaaaaaaaaa().aaa(),\n" 4784 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4785 OnePerLine); 4786 OnePerLine.ColumnLimit = 60; 4787 verifyFormat("Constructor() :\n" 4788 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4789 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4790 OnePerLine); 4791 4792 EXPECT_EQ("Constructor() :\n" 4793 " // Comment forcing unwanted break.\n" 4794 " aaaa(aaaa) {}", 4795 format("Constructor() :\n" 4796 " // Comment forcing unwanted break.\n" 4797 " aaaa(aaaa) {}", 4798 Style)); 4799 4800 Style.ColumnLimit = 0; 4801 verifyFormat("SomeClass::Constructor() :\n" 4802 " a(a) {}", 4803 Style); 4804 verifyFormat("SomeClass::Constructor() noexcept :\n" 4805 " a(a) {}", 4806 Style); 4807 verifyFormat("SomeClass::Constructor() :\n" 4808 " a(a), b(b), c(c) {}", 4809 Style); 4810 verifyFormat("SomeClass::Constructor() :\n" 4811 " a(a) {\n" 4812 " foo();\n" 4813 " bar();\n" 4814 "}", 4815 Style); 4816 4817 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4818 verifyFormat("SomeClass::Constructor() :\n" 4819 " a(a), b(b), c(c) {\n" 4820 "}", 4821 Style); 4822 verifyFormat("SomeClass::Constructor() :\n" 4823 " a(a) {\n" 4824 "}", 4825 Style); 4826 4827 Style.ColumnLimit = 80; 4828 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4829 Style.ConstructorInitializerIndentWidth = 2; 4830 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style); 4831 verifyFormat("SomeClass::Constructor() :\n" 4832 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4833 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 4834 Style); 4835 4836 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as 4837 // well 4838 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 4839 verifyFormat( 4840 "class SomeClass\n" 4841 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4842 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4843 Style); 4844 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 4845 verifyFormat( 4846 "class SomeClass\n" 4847 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4848 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4849 Style); 4850 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 4851 verifyFormat( 4852 "class SomeClass :\n" 4853 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4854 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4855 Style); 4856 } 4857 4858 #ifndef EXPENSIVE_CHECKS 4859 // Expensive checks enables libstdc++ checking which includes validating the 4860 // state of ranges used in std::priority_queue - this blows out the 4861 // runtime/scalability of the function and makes this test unacceptably slow. 4862 TEST_F(FormatTest, MemoizationTests) { 4863 // This breaks if the memoization lookup does not take \c Indent and 4864 // \c LastSpace into account. 4865 verifyFormat( 4866 "extern CFRunLoopTimerRef\n" 4867 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 4868 " CFTimeInterval interval, CFOptionFlags flags,\n" 4869 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 4870 " CFRunLoopTimerContext *context) {}"); 4871 4872 // Deep nesting somewhat works around our memoization. 4873 verifyFormat( 4874 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4875 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4876 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4877 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4878 " aaaaa())))))))))))))))))))))))))))))))))))))));", 4879 getLLVMStyleWithColumns(65)); 4880 verifyFormat( 4881 "aaaaa(\n" 4882 " aaaaa,\n" 4883 " aaaaa(\n" 4884 " aaaaa,\n" 4885 " aaaaa(\n" 4886 " aaaaa,\n" 4887 " aaaaa(\n" 4888 " aaaaa,\n" 4889 " aaaaa(\n" 4890 " aaaaa,\n" 4891 " aaaaa(\n" 4892 " aaaaa,\n" 4893 " aaaaa(\n" 4894 " aaaaa,\n" 4895 " aaaaa(\n" 4896 " aaaaa,\n" 4897 " aaaaa(\n" 4898 " aaaaa,\n" 4899 " aaaaa(\n" 4900 " aaaaa,\n" 4901 " aaaaa(\n" 4902 " aaaaa,\n" 4903 " aaaaa(\n" 4904 " aaaaa,\n" 4905 " aaaaa))))))))))));", 4906 getLLVMStyleWithColumns(65)); 4907 verifyFormat( 4908 "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" 4909 " a),\n" 4910 " a),\n" 4911 " a),\n" 4912 " a),\n" 4913 " a),\n" 4914 " a),\n" 4915 " a),\n" 4916 " a),\n" 4917 " a),\n" 4918 " a),\n" 4919 " a),\n" 4920 " a),\n" 4921 " a),\n" 4922 " a),\n" 4923 " a),\n" 4924 " a),\n" 4925 " a)", 4926 getLLVMStyleWithColumns(65)); 4927 4928 // This test takes VERY long when memoization is broken. 4929 FormatStyle OnePerLine = getLLVMStyle(); 4930 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4931 OnePerLine.BinPackParameters = false; 4932 std::string input = "Constructor()\n" 4933 " : aaaa(a,\n"; 4934 for (unsigned i = 0, e = 80; i != e; ++i) { 4935 input += " a,\n"; 4936 } 4937 input += " a) {}"; 4938 verifyFormat(input, OnePerLine); 4939 } 4940 #endif 4941 4942 TEST_F(FormatTest, BreaksAsHighAsPossible) { 4943 verifyFormat( 4944 "void f() {\n" 4945 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 4946 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 4947 " f();\n" 4948 "}"); 4949 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 4950 " Intervals[i - 1].getRange().getLast()) {\n}"); 4951 } 4952 4953 TEST_F(FormatTest, BreaksFunctionDeclarations) { 4954 // Principially, we break function declarations in a certain order: 4955 // 1) break amongst arguments. 4956 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 4957 " Cccccccccccccc cccccccccccccc);"); 4958 verifyFormat("template <class TemplateIt>\n" 4959 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 4960 " TemplateIt *stop) {}"); 4961 4962 // 2) break after return type. 4963 verifyFormat( 4964 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4965 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 4966 getGoogleStyle()); 4967 4968 // 3) break after (. 4969 verifyFormat( 4970 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 4971 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 4972 getGoogleStyle()); 4973 4974 // 4) break before after nested name specifiers. 4975 verifyFormat( 4976 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4977 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 4978 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 4979 getGoogleStyle()); 4980 4981 // However, there are exceptions, if a sufficient amount of lines can be 4982 // saved. 4983 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 4984 // more adjusting. 4985 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4986 " Cccccccccccccc cccccccccc,\n" 4987 " Cccccccccccccc cccccccccc,\n" 4988 " Cccccccccccccc cccccccccc,\n" 4989 " Cccccccccccccc cccccccccc);"); 4990 verifyFormat( 4991 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4992 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4993 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4994 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 4995 getGoogleStyle()); 4996 verifyFormat( 4997 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4998 " Cccccccccccccc cccccccccc,\n" 4999 " Cccccccccccccc cccccccccc,\n" 5000 " Cccccccccccccc cccccccccc,\n" 5001 " Cccccccccccccc cccccccccc,\n" 5002 " Cccccccccccccc cccccccccc,\n" 5003 " Cccccccccccccc cccccccccc);"); 5004 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5005 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5006 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5007 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 5008 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 5009 5010 // Break after multi-line parameters. 5011 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5012 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5013 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5014 " bbbb bbbb);"); 5015 verifyFormat("void SomeLoooooooooooongFunction(\n" 5016 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 5017 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5018 " int bbbbbbbbbbbbb);"); 5019 5020 // Treat overloaded operators like other functions. 5021 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5022 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 5023 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5024 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 5025 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5026 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 5027 verifyGoogleFormat( 5028 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 5029 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 5030 verifyGoogleFormat( 5031 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 5032 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 5033 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5034 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 5035 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 5036 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 5037 verifyGoogleFormat( 5038 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 5039 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5040 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 5041 verifyGoogleFormat("template <typename T>\n" 5042 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5043 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 5044 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 5045 5046 FormatStyle Style = getLLVMStyle(); 5047 Style.PointerAlignment = FormatStyle::PAS_Left; 5048 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5049 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 5050 Style); 5051 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 5052 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5053 Style); 5054 } 5055 5056 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 5057 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 5058 // Prefer keeping `::` followed by `operator` together. 5059 EXPECT_EQ("const aaaa::bbbbbbb &\n" 5060 "ccccccccc::operator++() {\n" 5061 " stuff();\n" 5062 "}", 5063 format("const aaaa::bbbbbbb\n" 5064 "&ccccccccc::operator++() { stuff(); }", 5065 getLLVMStyleWithColumns(40))); 5066 } 5067 5068 TEST_F(FormatTest, TrailingReturnType) { 5069 verifyFormat("auto foo() -> int;\n"); 5070 // correct trailing return type spacing 5071 verifyFormat("auto operator->() -> int;\n"); 5072 verifyFormat("auto operator++(int) -> int;\n"); 5073 5074 verifyFormat("struct S {\n" 5075 " auto bar() const -> int;\n" 5076 "};"); 5077 verifyFormat("template <size_t Order, typename T>\n" 5078 "auto load_img(const std::string &filename)\n" 5079 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 5080 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 5081 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 5082 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 5083 verifyFormat("template <typename T>\n" 5084 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 5085 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 5086 5087 // Not trailing return types. 5088 verifyFormat("void f() { auto a = b->c(); }"); 5089 } 5090 5091 TEST_F(FormatTest, DeductionGuides) { 5092 verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;"); 5093 verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;"); 5094 verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;"); 5095 verifyFormat( 5096 "template <class... T>\n" 5097 "array(T &&... t) -> array<std::common_type_t<T...>, sizeof...(T)>;"); 5098 verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;"); 5099 verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;"); 5100 verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;"); 5101 verifyFormat("template <class T> A() -> A<(3 < 2)>;"); 5102 verifyFormat("template <class T> A() -> A<((3) < (2))>;"); 5103 verifyFormat("template <class T> x() -> x<1>;"); 5104 verifyFormat("template <class T> explicit x(T &) -> x<1>;"); 5105 5106 // Ensure not deduction guides. 5107 verifyFormat("c()->f<int>();"); 5108 verifyFormat("x()->foo<1>;"); 5109 verifyFormat("x = p->foo<3>();"); 5110 verifyFormat("x()->x<1>();"); 5111 verifyFormat("x()->x<1>;"); 5112 } 5113 5114 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 5115 // Avoid breaking before trailing 'const' or other trailing annotations, if 5116 // they are not function-like. 5117 FormatStyle Style = getGoogleStyle(); 5118 Style.ColumnLimit = 47; 5119 verifyFormat("void someLongFunction(\n" 5120 " int someLoooooooooooooongParameter) const {\n}", 5121 getLLVMStyleWithColumns(47)); 5122 verifyFormat("LoooooongReturnType\n" 5123 "someLoooooooongFunction() const {}", 5124 getLLVMStyleWithColumns(47)); 5125 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 5126 " const {}", 5127 Style); 5128 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5129 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 5130 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5131 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 5132 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5133 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 5134 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 5135 " aaaaaaaaaaa aaaaa) const override;"); 5136 verifyGoogleFormat( 5137 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5138 " const override;"); 5139 5140 // Even if the first parameter has to be wrapped. 5141 verifyFormat("void someLongFunction(\n" 5142 " int someLongParameter) const {}", 5143 getLLVMStyleWithColumns(46)); 5144 verifyFormat("void someLongFunction(\n" 5145 " int someLongParameter) const {}", 5146 Style); 5147 verifyFormat("void someLongFunction(\n" 5148 " int someLongParameter) override {}", 5149 Style); 5150 verifyFormat("void someLongFunction(\n" 5151 " int someLongParameter) OVERRIDE {}", 5152 Style); 5153 verifyFormat("void someLongFunction(\n" 5154 " int someLongParameter) final {}", 5155 Style); 5156 verifyFormat("void someLongFunction(\n" 5157 " int someLongParameter) FINAL {}", 5158 Style); 5159 verifyFormat("void someLongFunction(\n" 5160 " int parameter) const override {}", 5161 Style); 5162 5163 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 5164 verifyFormat("void someLongFunction(\n" 5165 " int someLongParameter) const\n" 5166 "{\n" 5167 "}", 5168 Style); 5169 5170 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 5171 verifyFormat("void someLongFunction(\n" 5172 " int someLongParameter) const\n" 5173 " {\n" 5174 " }", 5175 Style); 5176 5177 // Unless these are unknown annotations. 5178 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 5179 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5180 " LONG_AND_UGLY_ANNOTATION;"); 5181 5182 // Breaking before function-like trailing annotations is fine to keep them 5183 // close to their arguments. 5184 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5185 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5186 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5187 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5188 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5189 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 5190 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 5191 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 5192 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 5193 5194 verifyFormat( 5195 "void aaaaaaaaaaaaaaaaaa()\n" 5196 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 5197 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 5198 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5199 " __attribute__((unused));"); 5200 verifyGoogleFormat( 5201 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5202 " GUARDED_BY(aaaaaaaaaaaa);"); 5203 verifyGoogleFormat( 5204 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5205 " GUARDED_BY(aaaaaaaaaaaa);"); 5206 verifyGoogleFormat( 5207 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5208 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5209 verifyGoogleFormat( 5210 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5211 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5212 } 5213 5214 TEST_F(FormatTest, FunctionAnnotations) { 5215 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5216 "int OldFunction(const string ¶meter) {}"); 5217 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5218 "string OldFunction(const string ¶meter) {}"); 5219 verifyFormat("template <typename T>\n" 5220 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5221 "string OldFunction(const string ¶meter) {}"); 5222 5223 // Not function annotations. 5224 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5225 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 5226 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 5227 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 5228 verifyFormat("MACRO(abc).function() // wrap\n" 5229 " << abc;"); 5230 verifyFormat("MACRO(abc)->function() // wrap\n" 5231 " << abc;"); 5232 verifyFormat("MACRO(abc)::function() // wrap\n" 5233 " << abc;"); 5234 } 5235 5236 TEST_F(FormatTest, BreaksDesireably) { 5237 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5238 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5239 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 5240 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5241 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 5242 "}"); 5243 5244 verifyFormat( 5245 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5246 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 5247 5248 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5249 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5250 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5251 5252 verifyFormat( 5253 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5254 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5255 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5256 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5257 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 5258 5259 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5260 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5261 5262 verifyFormat( 5263 "void f() {\n" 5264 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 5265 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5266 "}"); 5267 verifyFormat( 5268 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5269 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5270 verifyFormat( 5271 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5272 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5273 verifyFormat( 5274 "aaaaaa(aaa,\n" 5275 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5276 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5277 " aaaa);"); 5278 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5279 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5280 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5281 5282 // Indent consistently independent of call expression and unary operator. 5283 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5284 " dddddddddddddddddddddddddddddd));"); 5285 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5286 " dddddddddddddddddddddddddddddd));"); 5287 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 5288 " dddddddddddddddddddddddddddddd));"); 5289 5290 // This test case breaks on an incorrect memoization, i.e. an optimization not 5291 // taking into account the StopAt value. 5292 verifyFormat( 5293 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5294 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5295 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5296 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5297 5298 verifyFormat("{\n {\n {\n" 5299 " Annotation.SpaceRequiredBefore =\n" 5300 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 5301 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 5302 " }\n }\n}"); 5303 5304 // Break on an outer level if there was a break on an inner level. 5305 EXPECT_EQ("f(g(h(a, // comment\n" 5306 " b, c),\n" 5307 " d, e),\n" 5308 " x, y);", 5309 format("f(g(h(a, // comment\n" 5310 " b, c), d, e), x, y);")); 5311 5312 // Prefer breaking similar line breaks. 5313 verifyFormat( 5314 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 5315 " NSTrackingMouseEnteredAndExited |\n" 5316 " NSTrackingActiveAlways;"); 5317 } 5318 5319 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 5320 FormatStyle NoBinPacking = getGoogleStyle(); 5321 NoBinPacking.BinPackParameters = false; 5322 NoBinPacking.BinPackArguments = true; 5323 verifyFormat("void f() {\n" 5324 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 5325 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5326 "}", 5327 NoBinPacking); 5328 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 5329 " int aaaaaaaaaaaaaaaaaaaa,\n" 5330 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5331 NoBinPacking); 5332 5333 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5334 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5335 " vector<int> bbbbbbbbbbbbbbb);", 5336 NoBinPacking); 5337 // FIXME: This behavior difference is probably not wanted. However, currently 5338 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 5339 // template arguments from BreakBeforeParameter being set because of the 5340 // one-per-line formatting. 5341 verifyFormat( 5342 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5343 " aaaaaaaaaa> aaaaaaaaaa);", 5344 NoBinPacking); 5345 verifyFormat( 5346 "void fffffffffff(\n" 5347 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 5348 " aaaaaaaaaa);"); 5349 } 5350 5351 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 5352 FormatStyle NoBinPacking = getGoogleStyle(); 5353 NoBinPacking.BinPackParameters = false; 5354 NoBinPacking.BinPackArguments = false; 5355 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 5356 " aaaaaaaaaaaaaaaaaaaa,\n" 5357 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 5358 NoBinPacking); 5359 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 5360 " aaaaaaaaaaaaa,\n" 5361 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 5362 NoBinPacking); 5363 verifyFormat( 5364 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5365 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5366 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5367 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5368 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 5369 NoBinPacking); 5370 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5371 " .aaaaaaaaaaaaaaaaaa();", 5372 NoBinPacking); 5373 verifyFormat("void f() {\n" 5374 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5375 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 5376 "}", 5377 NoBinPacking); 5378 5379 verifyFormat( 5380 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5381 " aaaaaaaaaaaa,\n" 5382 " aaaaaaaaaaaa);", 5383 NoBinPacking); 5384 verifyFormat( 5385 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 5386 " ddddddddddddddddddddddddddddd),\n" 5387 " test);", 5388 NoBinPacking); 5389 5390 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5391 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 5392 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 5393 " aaaaaaaaaaaaaaaaaa;", 5394 NoBinPacking); 5395 verifyFormat("a(\"a\"\n" 5396 " \"a\",\n" 5397 " a);"); 5398 5399 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5400 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 5401 " aaaaaaaaa,\n" 5402 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5403 NoBinPacking); 5404 verifyFormat( 5405 "void f() {\n" 5406 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5407 " .aaaaaaa();\n" 5408 "}", 5409 NoBinPacking); 5410 verifyFormat( 5411 "template <class SomeType, class SomeOtherType>\n" 5412 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 5413 NoBinPacking); 5414 } 5415 5416 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 5417 FormatStyle Style = getLLVMStyleWithColumns(15); 5418 Style.ExperimentalAutoDetectBinPacking = true; 5419 EXPECT_EQ("aaa(aaaa,\n" 5420 " aaaa,\n" 5421 " aaaa);\n" 5422 "aaa(aaaa,\n" 5423 " aaaa,\n" 5424 " aaaa);", 5425 format("aaa(aaaa,\n" // one-per-line 5426 " aaaa,\n" 5427 " aaaa );\n" 5428 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5429 Style)); 5430 EXPECT_EQ("aaa(aaaa, aaaa,\n" 5431 " aaaa);\n" 5432 "aaa(aaaa, aaaa,\n" 5433 " aaaa);", 5434 format("aaa(aaaa, aaaa,\n" // bin-packed 5435 " aaaa );\n" 5436 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5437 Style)); 5438 } 5439 5440 TEST_F(FormatTest, FormatsBuilderPattern) { 5441 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 5442 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 5443 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 5444 " .StartsWith(\".init\", ORDER_INIT)\n" 5445 " .StartsWith(\".fini\", ORDER_FINI)\n" 5446 " .StartsWith(\".hash\", ORDER_HASH)\n" 5447 " .Default(ORDER_TEXT);\n"); 5448 5449 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 5450 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 5451 verifyFormat("aaaaaaa->aaaaaaa\n" 5452 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5453 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5454 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5455 verifyFormat( 5456 "aaaaaaa->aaaaaaa\n" 5457 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5458 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5459 verifyFormat( 5460 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 5461 " aaaaaaaaaaaaaa);"); 5462 verifyFormat( 5463 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 5464 " aaaaaa->aaaaaaaaaaaa()\n" 5465 " ->aaaaaaaaaaaaaaaa(\n" 5466 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5467 " ->aaaaaaaaaaaaaaaaa();"); 5468 verifyGoogleFormat( 5469 "void f() {\n" 5470 " someo->Add((new util::filetools::Handler(dir))\n" 5471 " ->OnEvent1(NewPermanentCallback(\n" 5472 " this, &HandlerHolderClass::EventHandlerCBA))\n" 5473 " ->OnEvent2(NewPermanentCallback(\n" 5474 " this, &HandlerHolderClass::EventHandlerCBB))\n" 5475 " ->OnEvent3(NewPermanentCallback(\n" 5476 " this, &HandlerHolderClass::EventHandlerCBC))\n" 5477 " ->OnEvent5(NewPermanentCallback(\n" 5478 " this, &HandlerHolderClass::EventHandlerCBD))\n" 5479 " ->OnEvent6(NewPermanentCallback(\n" 5480 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 5481 "}"); 5482 5483 verifyFormat( 5484 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 5485 verifyFormat("aaaaaaaaaaaaaaa()\n" 5486 " .aaaaaaaaaaaaaaa()\n" 5487 " .aaaaaaaaaaaaaaa()\n" 5488 " .aaaaaaaaaaaaaaa()\n" 5489 " .aaaaaaaaaaaaaaa();"); 5490 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5491 " .aaaaaaaaaaaaaaa()\n" 5492 " .aaaaaaaaaaaaaaa()\n" 5493 " .aaaaaaaaaaaaaaa();"); 5494 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5495 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5496 " .aaaaaaaaaaaaaaa();"); 5497 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 5498 " ->aaaaaaaaaaaaaae(0)\n" 5499 " ->aaaaaaaaaaaaaaa();"); 5500 5501 // Don't linewrap after very short segments. 5502 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5503 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5504 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5505 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5506 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5507 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5508 verifyFormat("aaa()\n" 5509 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5510 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5511 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5512 5513 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5514 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5515 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 5516 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5517 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 5518 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 5519 5520 // Prefer not to break after empty parentheses. 5521 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 5522 " First->LastNewlineOffset);"); 5523 5524 // Prefer not to create "hanging" indents. 5525 verifyFormat( 5526 "return !soooooooooooooome_map\n" 5527 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5528 " .second;"); 5529 verifyFormat( 5530 "return aaaaaaaaaaaaaaaa\n" 5531 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 5532 " .aaaa(aaaaaaaaaaaaaa);"); 5533 // No hanging indent here. 5534 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5535 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5536 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5537 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5538 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5539 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5540 getLLVMStyleWithColumns(60)); 5541 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5542 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5543 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5544 getLLVMStyleWithColumns(59)); 5545 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5546 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5547 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5548 5549 // Dont break if only closing statements before member call 5550 verifyFormat("test() {\n" 5551 " ([]() -> {\n" 5552 " int b = 32;\n" 5553 " return 3;\n" 5554 " }).foo();\n" 5555 "}"); 5556 verifyFormat("test() {\n" 5557 " (\n" 5558 " []() -> {\n" 5559 " int b = 32;\n" 5560 " return 3;\n" 5561 " },\n" 5562 " foo, bar)\n" 5563 " .foo();\n" 5564 "}"); 5565 verifyFormat("test() {\n" 5566 " ([]() -> {\n" 5567 " int b = 32;\n" 5568 " return 3;\n" 5569 " })\n" 5570 " .foo()\n" 5571 " .bar();\n" 5572 "}"); 5573 verifyFormat("test() {\n" 5574 " ([]() -> {\n" 5575 " int b = 32;\n" 5576 " return 3;\n" 5577 " })\n" 5578 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5579 " \"bbbb\");\n" 5580 "}", 5581 getLLVMStyleWithColumns(30)); 5582 } 5583 5584 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5585 verifyFormat( 5586 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5587 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5588 verifyFormat( 5589 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5590 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5591 5592 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5593 " ccccccccccccccccccccccccc) {\n}"); 5594 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5595 " ccccccccccccccccccccccccc) {\n}"); 5596 5597 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5598 " ccccccccccccccccccccccccc) {\n}"); 5599 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5600 " ccccccccccccccccccccccccc) {\n}"); 5601 5602 verifyFormat( 5603 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5604 " ccccccccccccccccccccccccc) {\n}"); 5605 verifyFormat( 5606 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5607 " ccccccccccccccccccccccccc) {\n}"); 5608 5609 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5610 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5611 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5612 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5613 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5614 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5615 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5616 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5617 5618 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5619 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5620 " aaaaaaaaaaaaaaa != aa) {\n}"); 5621 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5622 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5623 " aaaaaaaaaaaaaaa != aa) {\n}"); 5624 } 5625 5626 TEST_F(FormatTest, BreaksAfterAssignments) { 5627 verifyFormat( 5628 "unsigned Cost =\n" 5629 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5630 " SI->getPointerAddressSpaceee());\n"); 5631 verifyFormat( 5632 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5633 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5634 5635 verifyFormat( 5636 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5637 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5638 verifyFormat("unsigned OriginalStartColumn =\n" 5639 " SourceMgr.getSpellingColumnNumber(\n" 5640 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5641 " 1;"); 5642 } 5643 5644 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5645 FormatStyle Style = getLLVMStyle(); 5646 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5647 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5648 Style); 5649 5650 Style.PenaltyBreakAssignment = 20; 5651 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5652 " cccccccccccccccccccccccccc;", 5653 Style); 5654 } 5655 5656 TEST_F(FormatTest, AlignsAfterAssignments) { 5657 verifyFormat( 5658 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5659 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5660 verifyFormat( 5661 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5662 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5663 verifyFormat( 5664 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5665 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5666 verifyFormat( 5667 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5668 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5669 verifyFormat( 5670 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5671 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5672 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5673 } 5674 5675 TEST_F(FormatTest, AlignsAfterReturn) { 5676 verifyFormat( 5677 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5678 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5679 verifyFormat( 5680 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5681 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5682 verifyFormat( 5683 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5684 " aaaaaaaaaaaaaaaaaaaaaa();"); 5685 verifyFormat( 5686 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5687 " aaaaaaaaaaaaaaaaaaaaaa());"); 5688 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5689 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5690 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5691 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5692 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5693 verifyFormat("return\n" 5694 " // true if code is one of a or b.\n" 5695 " code == a || code == b;"); 5696 } 5697 5698 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5699 verifyFormat( 5700 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5701 " aaaaaaaaa aaaaaaa) {}"); 5702 verifyFormat( 5703 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5704 " aaaaaaaaaaa aaaaaaaaa);"); 5705 verifyFormat( 5706 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5707 " aaaaaaaaaaaaaaaaaaaaa));"); 5708 FormatStyle Style = getLLVMStyle(); 5709 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5710 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5711 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5712 Style); 5713 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5714 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5715 Style); 5716 verifyFormat("SomeLongVariableName->someFunction(\n" 5717 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5718 Style); 5719 verifyFormat( 5720 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5721 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5722 Style); 5723 verifyFormat( 5724 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5725 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5726 Style); 5727 verifyFormat( 5728 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5729 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5730 Style); 5731 5732 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5733 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5734 " b));", 5735 Style); 5736 5737 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5738 Style.BinPackArguments = false; 5739 Style.BinPackParameters = false; 5740 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5741 " aaaaaaaaaaa aaaaaaaa,\n" 5742 " aaaaaaaaa aaaaaaa,\n" 5743 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5744 Style); 5745 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5746 " aaaaaaaaaaa aaaaaaaaa,\n" 5747 " aaaaaaaaaaa aaaaaaaaa,\n" 5748 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5749 Style); 5750 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5751 " aaaaaaaaaaaaaaa,\n" 5752 " aaaaaaaaaaaaaaaaaaaaa,\n" 5753 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5754 Style); 5755 verifyFormat( 5756 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5757 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5758 Style); 5759 verifyFormat( 5760 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5761 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5762 Style); 5763 verifyFormat( 5764 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5765 " aaaaaaaaaaaaaaaaaaaaa(\n" 5766 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5767 " aaaaaaaaaaaaaaaa);", 5768 Style); 5769 verifyFormat( 5770 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5771 " aaaaaaaaaaaaaaaaaaaaa(\n" 5772 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5773 " aaaaaaaaaaaaaaaa);", 5774 Style); 5775 } 5776 5777 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5778 FormatStyle Style = getLLVMStyleWithColumns(40); 5779 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5780 " bbbbbbbbbbbbbbbbbbbbbb);", 5781 Style); 5782 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5783 Style.AlignOperands = false; 5784 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5785 " bbbbbbbbbbbbbbbbbbbbbb);", 5786 Style); 5787 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5788 Style.AlignOperands = true; 5789 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5790 " bbbbbbbbbbbbbbbbbbbbbb);", 5791 Style); 5792 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5793 Style.AlignOperands = false; 5794 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5795 " bbbbbbbbbbbbbbbbbbbbbb);", 5796 Style); 5797 } 5798 5799 TEST_F(FormatTest, BreaksConditionalExpressions) { 5800 verifyFormat( 5801 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5802 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5803 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5804 verifyFormat( 5805 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5806 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5807 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5808 verifyFormat( 5809 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5810 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5811 verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5812 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5813 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5814 verifyFormat( 5815 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5816 " : aaaaaaaaaaaaa);"); 5817 verifyFormat( 5818 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5819 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5820 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5821 " aaaaaaaaaaaaa);"); 5822 verifyFormat( 5823 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5824 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5825 " aaaaaaaaaaaaa);"); 5826 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5827 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5828 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5829 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5830 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5831 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5832 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5833 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5834 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5835 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5836 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5837 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5838 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5839 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5840 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5841 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5842 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5843 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5844 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5845 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5846 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5847 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5848 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5849 " : aaaaaaaaaaaaaaaa;"); 5850 verifyFormat( 5851 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5852 " ? aaaaaaaaaaaaaaa\n" 5853 " : aaaaaaaaaaaaaaa;"); 5854 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5855 " aaaaaaaaa\n" 5856 " ? b\n" 5857 " : c);"); 5858 verifyFormat("return aaaa == bbbb\n" 5859 " // comment\n" 5860 " ? aaaa\n" 5861 " : bbbb;"); 5862 verifyFormat("unsigned Indent =\n" 5863 " format(TheLine.First,\n" 5864 " IndentForLevel[TheLine.Level] >= 0\n" 5865 " ? IndentForLevel[TheLine.Level]\n" 5866 " : TheLine * 2,\n" 5867 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5868 getLLVMStyleWithColumns(60)); 5869 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5870 " ? aaaaaaaaaaaaaaa\n" 5871 " : bbbbbbbbbbbbbbb //\n" 5872 " ? ccccccccccccccc\n" 5873 " : ddddddddddddddd;"); 5874 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5875 " ? aaaaaaaaaaaaaaa\n" 5876 " : (bbbbbbbbbbbbbbb //\n" 5877 " ? ccccccccccccccc\n" 5878 " : ddddddddddddddd);"); 5879 verifyFormat( 5880 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5881 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5882 " aaaaaaaaaaaaaaaaaaaaa +\n" 5883 " aaaaaaaaaaaaaaaaaaaaa\n" 5884 " : aaaaaaaaaa;"); 5885 verifyFormat( 5886 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5887 " : aaaaaaaaaaaaaaaaaaaaaa\n" 5888 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5889 5890 FormatStyle NoBinPacking = getLLVMStyle(); 5891 NoBinPacking.BinPackArguments = false; 5892 verifyFormat( 5893 "void f() {\n" 5894 " g(aaa,\n" 5895 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5896 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5897 " ? aaaaaaaaaaaaaaa\n" 5898 " : aaaaaaaaaaaaaaa);\n" 5899 "}", 5900 NoBinPacking); 5901 verifyFormat( 5902 "void f() {\n" 5903 " g(aaa,\n" 5904 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5905 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5906 " ?: aaaaaaaaaaaaaaa);\n" 5907 "}", 5908 NoBinPacking); 5909 5910 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 5911 " // comment.\n" 5912 " ccccccccccccccccccccccccccccccccccccccc\n" 5913 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5914 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 5915 5916 // Assignments in conditional expressions. Apparently not uncommon :-(. 5917 verifyFormat("return a != b\n" 5918 " // comment\n" 5919 " ? a = b\n" 5920 " : a = b;"); 5921 verifyFormat("return a != b\n" 5922 " // comment\n" 5923 " ? a = a != b\n" 5924 " // comment\n" 5925 " ? a = b\n" 5926 " : a\n" 5927 " : a;\n"); 5928 verifyFormat("return a != b\n" 5929 " // comment\n" 5930 " ? a\n" 5931 " : a = a != b\n" 5932 " // comment\n" 5933 " ? a = b\n" 5934 " : a;"); 5935 } 5936 5937 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 5938 FormatStyle Style = getLLVMStyle(); 5939 Style.BreakBeforeTernaryOperators = false; 5940 Style.ColumnLimit = 70; 5941 verifyFormat( 5942 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5943 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5944 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5945 Style); 5946 verifyFormat( 5947 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5948 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5949 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5950 Style); 5951 verifyFormat( 5952 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5953 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5954 Style); 5955 verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n" 5956 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5957 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5958 Style); 5959 verifyFormat( 5960 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 5961 " aaaaaaaaaaaaa);", 5962 Style); 5963 verifyFormat( 5964 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5965 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5966 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5967 " aaaaaaaaaaaaa);", 5968 Style); 5969 verifyFormat( 5970 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5971 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5972 " aaaaaaaaaaaaa);", 5973 Style); 5974 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5975 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5976 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5977 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5978 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5979 Style); 5980 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5981 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5982 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5983 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5984 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5985 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5986 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5987 Style); 5988 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5989 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 5990 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5991 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5992 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5993 Style); 5994 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5995 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5996 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5997 Style); 5998 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5999 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6000 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 6001 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6002 Style); 6003 verifyFormat( 6004 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6005 " aaaaaaaaaaaaaaa :\n" 6006 " aaaaaaaaaaaaaaa;", 6007 Style); 6008 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 6009 " aaaaaaaaa ?\n" 6010 " b :\n" 6011 " c);", 6012 Style); 6013 verifyFormat("unsigned Indent =\n" 6014 " format(TheLine.First,\n" 6015 " IndentForLevel[TheLine.Level] >= 0 ?\n" 6016 " IndentForLevel[TheLine.Level] :\n" 6017 " TheLine * 2,\n" 6018 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 6019 Style); 6020 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 6021 " aaaaaaaaaaaaaaa :\n" 6022 " bbbbbbbbbbbbbbb ? //\n" 6023 " ccccccccccccccc :\n" 6024 " ddddddddddddddd;", 6025 Style); 6026 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 6027 " aaaaaaaaaaaaaaa :\n" 6028 " (bbbbbbbbbbbbbbb ? //\n" 6029 " ccccccccccccccc :\n" 6030 " ddddddddddddddd);", 6031 Style); 6032 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6033 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 6034 " ccccccccccccccccccccccccccc;", 6035 Style); 6036 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6037 " aaaaa :\n" 6038 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 6039 Style); 6040 } 6041 6042 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 6043 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 6044 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 6045 verifyFormat("bool a = true, b = false;"); 6046 6047 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6048 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 6049 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 6050 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 6051 verifyFormat( 6052 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 6053 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 6054 " d = e && f;"); 6055 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 6056 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 6057 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 6058 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 6059 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 6060 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 6061 6062 FormatStyle Style = getGoogleStyle(); 6063 Style.PointerAlignment = FormatStyle::PAS_Left; 6064 Style.DerivePointerAlignment = false; 6065 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6066 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 6067 " *b = bbbbbbbbbbbbbbbbbbb;", 6068 Style); 6069 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 6070 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 6071 Style); 6072 verifyFormat("vector<int*> a, b;", Style); 6073 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 6074 } 6075 6076 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 6077 verifyFormat("arr[foo ? bar : baz];"); 6078 verifyFormat("f()[foo ? bar : baz];"); 6079 verifyFormat("(a + b)[foo ? bar : baz];"); 6080 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 6081 } 6082 6083 TEST_F(FormatTest, AlignsStringLiterals) { 6084 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 6085 " \"short literal\");"); 6086 verifyFormat( 6087 "looooooooooooooooooooooooongFunction(\n" 6088 " \"short literal\"\n" 6089 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 6090 verifyFormat("someFunction(\"Always break between multi-line\"\n" 6091 " \" string literals\",\n" 6092 " and, other, parameters);"); 6093 EXPECT_EQ("fun + \"1243\" /* comment */\n" 6094 " \"5678\";", 6095 format("fun + \"1243\" /* comment */\n" 6096 " \"5678\";", 6097 getLLVMStyleWithColumns(28))); 6098 EXPECT_EQ( 6099 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 6100 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 6101 " \"aaaaaaaaaaaaaaaa\";", 6102 format("aaaaaa =" 6103 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 6104 "aaaaaaaaaaaaaaaaaaaaa\" " 6105 "\"aaaaaaaaaaaaaaaa\";")); 6106 verifyFormat("a = a + \"a\"\n" 6107 " \"a\"\n" 6108 " \"a\";"); 6109 verifyFormat("f(\"a\", \"b\"\n" 6110 " \"c\");"); 6111 6112 verifyFormat( 6113 "#define LL_FORMAT \"ll\"\n" 6114 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 6115 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 6116 6117 verifyFormat("#define A(X) \\\n" 6118 " \"aaaaa\" #X \"bbbbbb\" \\\n" 6119 " \"ccccc\"", 6120 getLLVMStyleWithColumns(23)); 6121 verifyFormat("#define A \"def\"\n" 6122 "f(\"abc\" A \"ghi\"\n" 6123 " \"jkl\");"); 6124 6125 verifyFormat("f(L\"a\"\n" 6126 " L\"b\");"); 6127 verifyFormat("#define A(X) \\\n" 6128 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 6129 " L\"ccccc\"", 6130 getLLVMStyleWithColumns(25)); 6131 6132 verifyFormat("f(@\"a\"\n" 6133 " @\"b\");"); 6134 verifyFormat("NSString s = @\"a\"\n" 6135 " @\"b\"\n" 6136 " @\"c\";"); 6137 verifyFormat("NSString s = @\"a\"\n" 6138 " \"b\"\n" 6139 " \"c\";"); 6140 } 6141 6142 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 6143 FormatStyle Style = getLLVMStyle(); 6144 // No declarations or definitions should be moved to own line. 6145 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 6146 verifyFormat("class A {\n" 6147 " int f() { return 1; }\n" 6148 " int g();\n" 6149 "};\n" 6150 "int f() { return 1; }\n" 6151 "int g();\n", 6152 Style); 6153 6154 // All declarations and definitions should have the return type moved to its 6155 // own 6156 // line. 6157 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 6158 verifyFormat("class E {\n" 6159 " int\n" 6160 " f() {\n" 6161 " return 1;\n" 6162 " }\n" 6163 " int\n" 6164 " g();\n" 6165 "};\n" 6166 "int\n" 6167 "f() {\n" 6168 " return 1;\n" 6169 "}\n" 6170 "int\n" 6171 "g();\n", 6172 Style); 6173 6174 // Top-level definitions, and no kinds of declarations should have the 6175 // return type moved to its own line. 6176 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 6177 verifyFormat("class B {\n" 6178 " int f() { return 1; }\n" 6179 " int g();\n" 6180 "};\n" 6181 "int\n" 6182 "f() {\n" 6183 " return 1;\n" 6184 "}\n" 6185 "int g();\n", 6186 Style); 6187 6188 // Top-level definitions and declarations should have the return type moved 6189 // to its own line. 6190 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 6191 verifyFormat("class C {\n" 6192 " int f() { return 1; }\n" 6193 " int g();\n" 6194 "};\n" 6195 "int\n" 6196 "f() {\n" 6197 " return 1;\n" 6198 "}\n" 6199 "int\n" 6200 "g();\n", 6201 Style); 6202 6203 // All definitions should have the return type moved to its own line, but no 6204 // kinds of declarations. 6205 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 6206 verifyFormat("class D {\n" 6207 " int\n" 6208 " f() {\n" 6209 " return 1;\n" 6210 " }\n" 6211 " int g();\n" 6212 "};\n" 6213 "int\n" 6214 "f() {\n" 6215 " return 1;\n" 6216 "}\n" 6217 "int g();\n", 6218 Style); 6219 verifyFormat("const char *\n" 6220 "f(void) {\n" // Break here. 6221 " return \"\";\n" 6222 "}\n" 6223 "const char *bar(void);\n", // No break here. 6224 Style); 6225 verifyFormat("template <class T>\n" 6226 "T *\n" 6227 "f(T &c) {\n" // Break here. 6228 " return NULL;\n" 6229 "}\n" 6230 "template <class T> T *f(T &c);\n", // No break here. 6231 Style); 6232 verifyFormat("class C {\n" 6233 " int\n" 6234 " operator+() {\n" 6235 " return 1;\n" 6236 " }\n" 6237 " int\n" 6238 " operator()() {\n" 6239 " return 1;\n" 6240 " }\n" 6241 "};\n", 6242 Style); 6243 verifyFormat("void\n" 6244 "A::operator()() {}\n" 6245 "void\n" 6246 "A::operator>>() {}\n" 6247 "void\n" 6248 "A::operator+() {}\n" 6249 "void\n" 6250 "A::operator*() {}\n" 6251 "void\n" 6252 "A::operator->() {}\n" 6253 "void\n" 6254 "A::operator void *() {}\n" 6255 "void\n" 6256 "A::operator void &() {}\n" 6257 "void\n" 6258 "A::operator void &&() {}\n" 6259 "void\n" 6260 "A::operator char *() {}\n" 6261 "void\n" 6262 "A::operator[]() {}\n" 6263 "void\n" 6264 "A::operator!() {}\n", 6265 Style); 6266 verifyFormat("constexpr auto\n" 6267 "operator()() const -> reference {}\n" 6268 "constexpr auto\n" 6269 "operator>>() const -> reference {}\n" 6270 "constexpr auto\n" 6271 "operator+() const -> reference {}\n" 6272 "constexpr auto\n" 6273 "operator*() const -> reference {}\n" 6274 "constexpr auto\n" 6275 "operator->() const -> reference {}\n" 6276 "constexpr auto\n" 6277 "operator++() const -> reference {}\n" 6278 "constexpr auto\n" 6279 "operator void *() const -> reference {}\n" 6280 "constexpr auto\n" 6281 "operator void &() const -> reference {}\n" 6282 "constexpr auto\n" 6283 "operator void &&() const -> reference {}\n" 6284 "constexpr auto\n" 6285 "operator char *() const -> reference {}\n" 6286 "constexpr auto\n" 6287 "operator!() const -> reference {}\n" 6288 "constexpr auto\n" 6289 "operator[]() const -> reference {}\n", 6290 Style); 6291 verifyFormat("void *operator new(std::size_t s);", // No break here. 6292 Style); 6293 verifyFormat("void *\n" 6294 "operator new(std::size_t s) {}", 6295 Style); 6296 verifyFormat("void *\n" 6297 "operator delete[](void *ptr) {}", 6298 Style); 6299 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 6300 verifyFormat("const char *\n" 6301 "f(void)\n" // Break here. 6302 "{\n" 6303 " return \"\";\n" 6304 "}\n" 6305 "const char *bar(void);\n", // No break here. 6306 Style); 6307 verifyFormat("template <class T>\n" 6308 "T *\n" // Problem here: no line break 6309 "f(T &c)\n" // Break here. 6310 "{\n" 6311 " return NULL;\n" 6312 "}\n" 6313 "template <class T> T *f(T &c);\n", // No break here. 6314 Style); 6315 verifyFormat("int\n" 6316 "foo(A<bool> a)\n" 6317 "{\n" 6318 " return a;\n" 6319 "}\n", 6320 Style); 6321 verifyFormat("int\n" 6322 "foo(A<8> a)\n" 6323 "{\n" 6324 " return a;\n" 6325 "}\n", 6326 Style); 6327 verifyFormat("int\n" 6328 "foo(A<B<bool>, 8> a)\n" 6329 "{\n" 6330 " return a;\n" 6331 "}\n", 6332 Style); 6333 verifyFormat("int\n" 6334 "foo(A<B<8>, bool> a)\n" 6335 "{\n" 6336 " return a;\n" 6337 "}\n", 6338 Style); 6339 verifyFormat("int\n" 6340 "foo(A<B<bool>, bool> a)\n" 6341 "{\n" 6342 " return a;\n" 6343 "}\n", 6344 Style); 6345 verifyFormat("int\n" 6346 "foo(A<B<8>, 8> a)\n" 6347 "{\n" 6348 " return a;\n" 6349 "}\n", 6350 Style); 6351 6352 Style = getGNUStyle(); 6353 6354 // Test for comments at the end of function declarations. 6355 verifyFormat("void\n" 6356 "foo (int a, /*abc*/ int b) // def\n" 6357 "{\n" 6358 "}\n", 6359 Style); 6360 6361 verifyFormat("void\n" 6362 "foo (int a, /* abc */ int b) /* def */\n" 6363 "{\n" 6364 "}\n", 6365 Style); 6366 6367 // Definitions that should not break after return type 6368 verifyFormat("void foo (int a, int b); // def\n", Style); 6369 verifyFormat("void foo (int a, int b); /* def */\n", Style); 6370 verifyFormat("void foo (int a, int b);\n", Style); 6371 } 6372 6373 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 6374 FormatStyle NoBreak = getLLVMStyle(); 6375 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 6376 FormatStyle Break = getLLVMStyle(); 6377 Break.AlwaysBreakBeforeMultilineStrings = true; 6378 verifyFormat("aaaa = \"bbbb\"\n" 6379 " \"cccc\";", 6380 NoBreak); 6381 verifyFormat("aaaa =\n" 6382 " \"bbbb\"\n" 6383 " \"cccc\";", 6384 Break); 6385 verifyFormat("aaaa(\"bbbb\"\n" 6386 " \"cccc\");", 6387 NoBreak); 6388 verifyFormat("aaaa(\n" 6389 " \"bbbb\"\n" 6390 " \"cccc\");", 6391 Break); 6392 verifyFormat("aaaa(qqq, \"bbbb\"\n" 6393 " \"cccc\");", 6394 NoBreak); 6395 verifyFormat("aaaa(qqq,\n" 6396 " \"bbbb\"\n" 6397 " \"cccc\");", 6398 Break); 6399 verifyFormat("aaaa(qqq,\n" 6400 " L\"bbbb\"\n" 6401 " L\"cccc\");", 6402 Break); 6403 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 6404 " \"bbbb\"));", 6405 Break); 6406 verifyFormat("string s = someFunction(\n" 6407 " \"abc\"\n" 6408 " \"abc\");", 6409 Break); 6410 6411 // As we break before unary operators, breaking right after them is bad. 6412 verifyFormat("string foo = abc ? \"x\"\n" 6413 " \"blah blah blah blah blah blah\"\n" 6414 " : \"y\";", 6415 Break); 6416 6417 // Don't break if there is no column gain. 6418 verifyFormat("f(\"aaaa\"\n" 6419 " \"bbbb\");", 6420 Break); 6421 6422 // Treat literals with escaped newlines like multi-line string literals. 6423 EXPECT_EQ("x = \"a\\\n" 6424 "b\\\n" 6425 "c\";", 6426 format("x = \"a\\\n" 6427 "b\\\n" 6428 "c\";", 6429 NoBreak)); 6430 EXPECT_EQ("xxxx =\n" 6431 " \"a\\\n" 6432 "b\\\n" 6433 "c\";", 6434 format("xxxx = \"a\\\n" 6435 "b\\\n" 6436 "c\";", 6437 Break)); 6438 6439 EXPECT_EQ("NSString *const kString =\n" 6440 " @\"aaaa\"\n" 6441 " @\"bbbb\";", 6442 format("NSString *const kString = @\"aaaa\"\n" 6443 "@\"bbbb\";", 6444 Break)); 6445 6446 Break.ColumnLimit = 0; 6447 verifyFormat("const char *hello = \"hello llvm\";", Break); 6448 } 6449 6450 TEST_F(FormatTest, AlignsPipes) { 6451 verifyFormat( 6452 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6453 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6454 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6455 verifyFormat( 6456 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 6457 " << aaaaaaaaaaaaaaaaaaaa;"); 6458 verifyFormat( 6459 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6460 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6461 verifyFormat( 6462 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 6463 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6464 verifyFormat( 6465 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 6466 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 6467 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 6468 verifyFormat( 6469 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6470 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6471 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6472 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6473 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6474 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6475 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6476 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 6477 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 6478 verifyFormat( 6479 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6480 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6481 verifyFormat( 6482 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 6483 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6484 6485 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 6486 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 6487 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6488 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6489 " aaaaaaaaaaaaaaaaaaaaa)\n" 6490 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6491 verifyFormat("LOG_IF(aaa == //\n" 6492 " bbb)\n" 6493 " << a << b;"); 6494 6495 // But sometimes, breaking before the first "<<" is desirable. 6496 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6497 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 6498 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 6499 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6500 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6501 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 6502 " << BEF << IsTemplate << Description << E->getType();"); 6503 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6504 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6505 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6506 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6507 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6508 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6509 " << aaa;"); 6510 6511 verifyFormat( 6512 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6513 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6514 6515 // Incomplete string literal. 6516 EXPECT_EQ("llvm::errs() << \"\n" 6517 " << a;", 6518 format("llvm::errs() << \"\n<<a;")); 6519 6520 verifyFormat("void f() {\n" 6521 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 6522 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 6523 "}"); 6524 6525 // Handle 'endl'. 6526 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 6527 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6528 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6529 6530 // Handle '\n'. 6531 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 6532 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6533 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 6534 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 6535 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 6536 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 6537 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6538 } 6539 6540 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 6541 verifyFormat("return out << \"somepacket = {\\n\"\n" 6542 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 6543 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 6544 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 6545 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 6546 " << \"}\";"); 6547 6548 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6549 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6550 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 6551 verifyFormat( 6552 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 6553 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 6554 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 6555 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 6556 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 6557 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 6558 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6559 verifyFormat( 6560 "void f() {\n" 6561 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 6562 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 6563 "}"); 6564 6565 // Breaking before the first "<<" is generally not desirable. 6566 verifyFormat( 6567 "llvm::errs()\n" 6568 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6569 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6570 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6571 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6572 getLLVMStyleWithColumns(70)); 6573 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6574 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6575 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6576 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6577 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6578 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6579 getLLVMStyleWithColumns(70)); 6580 6581 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6582 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6583 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6584 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6585 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6586 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 6587 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 6588 " (aaaa + aaaa);", 6589 getLLVMStyleWithColumns(40)); 6590 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 6591 " (aaaaaaa + aaaaa));", 6592 getLLVMStyleWithColumns(40)); 6593 verifyFormat( 6594 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 6595 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 6596 " bbbbbbbbbbbbbbbbbbbbbbb);"); 6597 } 6598 6599 TEST_F(FormatTest, UnderstandsEquals) { 6600 verifyFormat( 6601 "aaaaaaaaaaaaaaaaa =\n" 6602 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6603 verifyFormat( 6604 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6605 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6606 verifyFormat( 6607 "if (a) {\n" 6608 " f();\n" 6609 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6610 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 6611 "}"); 6612 6613 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6614 " 100000000 + 10000000) {\n}"); 6615 } 6616 6617 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 6618 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6619 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 6620 6621 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6622 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 6623 6624 verifyFormat( 6625 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 6626 " Parameter2);"); 6627 6628 verifyFormat( 6629 "ShortObject->shortFunction(\n" 6630 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 6631 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 6632 6633 verifyFormat("loooooooooooooongFunction(\n" 6634 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 6635 6636 verifyFormat( 6637 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 6638 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 6639 6640 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6641 " .WillRepeatedly(Return(SomeValue));"); 6642 verifyFormat("void f() {\n" 6643 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6644 " .Times(2)\n" 6645 " .WillRepeatedly(Return(SomeValue));\n" 6646 "}"); 6647 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 6648 " ccccccccccccccccccccccc);"); 6649 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6650 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6651 " .aaaaa(aaaaa),\n" 6652 " aaaaaaaaaaaaaaaaaaaaa);"); 6653 verifyFormat("void f() {\n" 6654 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6655 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 6656 "}"); 6657 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6658 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6659 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6660 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6661 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6662 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6663 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6664 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6665 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 6666 "}"); 6667 6668 // Here, it is not necessary to wrap at "." or "->". 6669 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 6670 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6671 verifyFormat( 6672 "aaaaaaaaaaa->aaaaaaaaa(\n" 6673 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6674 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 6675 6676 verifyFormat( 6677 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6678 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 6679 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 6680 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6681 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 6682 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6683 6684 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6685 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6686 " .a();"); 6687 6688 FormatStyle NoBinPacking = getLLVMStyle(); 6689 NoBinPacking.BinPackParameters = false; 6690 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6691 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6692 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 6693 " aaaaaaaaaaaaaaaaaaa,\n" 6694 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6695 NoBinPacking); 6696 6697 // If there is a subsequent call, change to hanging indentation. 6698 verifyFormat( 6699 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6700 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 6701 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6702 verifyFormat( 6703 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6704 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 6705 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6706 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6707 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6708 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6709 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6710 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6711 } 6712 6713 TEST_F(FormatTest, WrapsTemplateDeclarations) { 6714 verifyFormat("template <typename T>\n" 6715 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6716 verifyFormat("template <typename T>\n" 6717 "// T should be one of {A, B}.\n" 6718 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6719 verifyFormat( 6720 "template <typename T>\n" 6721 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 6722 verifyFormat("template <typename T>\n" 6723 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 6724 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 6725 verifyFormat( 6726 "template <typename T>\n" 6727 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 6728 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 6729 verifyFormat( 6730 "template <typename T>\n" 6731 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 6732 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 6733 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6734 verifyFormat("template <typename T>\n" 6735 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6736 " int aaaaaaaaaaaaaaaaaaaaaa);"); 6737 verifyFormat( 6738 "template <typename T1, typename T2 = char, typename T3 = char,\n" 6739 " typename T4 = char>\n" 6740 "void f();"); 6741 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 6742 " template <typename> class cccccccccccccccccccccc,\n" 6743 " typename ddddddddddddd>\n" 6744 "class C {};"); 6745 verifyFormat( 6746 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 6747 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6748 6749 verifyFormat("void f() {\n" 6750 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 6751 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 6752 "}"); 6753 6754 verifyFormat("template <typename T> class C {};"); 6755 verifyFormat("template <typename T> void f();"); 6756 verifyFormat("template <typename T> void f() {}"); 6757 verifyFormat( 6758 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6759 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6760 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 6761 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6762 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6763 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 6764 " bbbbbbbbbbbbbbbbbbbbbbbb);", 6765 getLLVMStyleWithColumns(72)); 6766 EXPECT_EQ("static_cast<A< //\n" 6767 " B> *>(\n" 6768 "\n" 6769 ");", 6770 format("static_cast<A<//\n" 6771 " B>*>(\n" 6772 "\n" 6773 " );")); 6774 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6775 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 6776 6777 FormatStyle AlwaysBreak = getLLVMStyle(); 6778 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 6779 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 6780 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 6781 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 6782 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6783 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6784 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 6785 verifyFormat("template <template <typename> class Fooooooo,\n" 6786 " template <typename> class Baaaaaaar>\n" 6787 "struct C {};", 6788 AlwaysBreak); 6789 verifyFormat("template <typename T> // T can be A, B or C.\n" 6790 "struct C {};", 6791 AlwaysBreak); 6792 verifyFormat("template <enum E> class A {\n" 6793 "public:\n" 6794 " E *f();\n" 6795 "};"); 6796 6797 FormatStyle NeverBreak = getLLVMStyle(); 6798 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 6799 verifyFormat("template <typename T> class C {};", NeverBreak); 6800 verifyFormat("template <typename T> void f();", NeverBreak); 6801 verifyFormat("template <typename T> void f() {}", NeverBreak); 6802 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6803 "bbbbbbbbbbbbbbbbbbbb) {}", 6804 NeverBreak); 6805 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6806 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6807 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 6808 NeverBreak); 6809 verifyFormat("template <template <typename> class Fooooooo,\n" 6810 " template <typename> class Baaaaaaar>\n" 6811 "struct C {};", 6812 NeverBreak); 6813 verifyFormat("template <typename T> // T can be A, B or C.\n" 6814 "struct C {};", 6815 NeverBreak); 6816 verifyFormat("template <enum E> class A {\n" 6817 "public:\n" 6818 " E *f();\n" 6819 "};", 6820 NeverBreak); 6821 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 6822 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6823 "bbbbbbbbbbbbbbbbbbbb) {}", 6824 NeverBreak); 6825 } 6826 6827 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 6828 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 6829 Style.ColumnLimit = 60; 6830 EXPECT_EQ("// Baseline - no comments.\n" 6831 "template <\n" 6832 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6833 "void f() {}", 6834 format("// Baseline - no comments.\n" 6835 "template <\n" 6836 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6837 "void f() {}", 6838 Style)); 6839 6840 EXPECT_EQ("template <\n" 6841 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6842 "void f() {}", 6843 format("template <\n" 6844 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6845 "void f() {}", 6846 Style)); 6847 6848 EXPECT_EQ( 6849 "template <\n" 6850 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6851 "void f() {}", 6852 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6853 "void f() {}", 6854 Style)); 6855 6856 EXPECT_EQ( 6857 "template <\n" 6858 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6859 " // multiline\n" 6860 "void f() {}", 6861 format("template <\n" 6862 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6863 " // multiline\n" 6864 "void f() {}", 6865 Style)); 6866 6867 EXPECT_EQ( 6868 "template <typename aaaaaaaaaa<\n" 6869 " bbbbbbbbbbbb>::value> // trailing loooong\n" 6870 "void f() {}", 6871 format( 6872 "template <\n" 6873 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 6874 "void f() {}", 6875 Style)); 6876 } 6877 6878 TEST_F(FormatTest, WrapsTemplateParameters) { 6879 FormatStyle Style = getLLVMStyle(); 6880 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6881 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6882 verifyFormat( 6883 "template <typename... a> struct q {};\n" 6884 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6885 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6886 " y;", 6887 Style); 6888 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6889 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6890 verifyFormat( 6891 "template <typename... a> struct r {};\n" 6892 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6893 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6894 " y;", 6895 Style); 6896 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6897 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6898 verifyFormat("template <typename... a> struct s {};\n" 6899 "extern s<\n" 6900 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6901 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6902 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6903 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6904 " y;", 6905 Style); 6906 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6907 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6908 verifyFormat("template <typename... a> struct t {};\n" 6909 "extern t<\n" 6910 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6911 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6912 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6913 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6914 " y;", 6915 Style); 6916 } 6917 6918 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 6919 verifyFormat( 6920 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6921 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6922 verifyFormat( 6923 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6924 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6925 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6926 6927 // FIXME: Should we have the extra indent after the second break? 6928 verifyFormat( 6929 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6930 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6931 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6932 6933 verifyFormat( 6934 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 6935 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 6936 6937 // Breaking at nested name specifiers is generally not desirable. 6938 verifyFormat( 6939 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6940 " aaaaaaaaaaaaaaaaaaaaaaa);"); 6941 6942 verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 6943 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6944 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6945 " aaaaaaaaaaaaaaaaaaaaa);", 6946 getLLVMStyleWithColumns(74)); 6947 6948 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6949 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6950 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6951 } 6952 6953 TEST_F(FormatTest, UnderstandsTemplateParameters) { 6954 verifyFormat("A<int> a;"); 6955 verifyFormat("A<A<A<int>>> a;"); 6956 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 6957 verifyFormat("bool x = a < 1 || 2 > a;"); 6958 verifyFormat("bool x = 5 < f<int>();"); 6959 verifyFormat("bool x = f<int>() > 5;"); 6960 verifyFormat("bool x = 5 < a<int>::x;"); 6961 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 6962 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 6963 6964 verifyGoogleFormat("A<A<int>> a;"); 6965 verifyGoogleFormat("A<A<A<int>>> a;"); 6966 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 6967 verifyGoogleFormat("A<A<int> > a;"); 6968 verifyGoogleFormat("A<A<A<int> > > a;"); 6969 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 6970 verifyGoogleFormat("A<::A<int>> a;"); 6971 verifyGoogleFormat("A<::A> a;"); 6972 verifyGoogleFormat("A< ::A> a;"); 6973 verifyGoogleFormat("A< ::A<int> > a;"); 6974 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 6975 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 6976 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 6977 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 6978 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 6979 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 6980 6981 verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 6982 6983 // template closer followed by a token that starts with > or = 6984 verifyFormat("bool b = a<1> > 1;"); 6985 verifyFormat("bool b = a<1> >= 1;"); 6986 verifyFormat("int i = a<1> >> 1;"); 6987 FormatStyle Style = getLLVMStyle(); 6988 Style.SpaceBeforeAssignmentOperators = false; 6989 verifyFormat("bool b= a<1> == 1;", Style); 6990 verifyFormat("a<int> = 1;", Style); 6991 verifyFormat("a<int> >>= 1;", Style); 6992 6993 verifyFormat("test >> a >> b;"); 6994 verifyFormat("test << a >> b;"); 6995 6996 verifyFormat("f<int>();"); 6997 verifyFormat("template <typename T> void f() {}"); 6998 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 6999 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 7000 "sizeof(char)>::type>;"); 7001 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 7002 verifyFormat("f(a.operator()<A>());"); 7003 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7004 " .template operator()<A>());", 7005 getLLVMStyleWithColumns(35)); 7006 7007 // Not template parameters. 7008 verifyFormat("return a < b && c > d;"); 7009 verifyFormat("void f() {\n" 7010 " while (a < b && c > d) {\n" 7011 " }\n" 7012 "}"); 7013 verifyFormat("template <typename... Types>\n" 7014 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 7015 7016 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7017 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 7018 getLLVMStyleWithColumns(60)); 7019 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 7020 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 7021 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 7022 } 7023 7024 TEST_F(FormatTest, BitshiftOperatorWidth) { 7025 EXPECT_EQ("int a = 1 << 2; /* foo\n" 7026 " bar */", 7027 format("int a=1<<2; /* foo\n" 7028 " bar */")); 7029 7030 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 7031 " bar */", 7032 format("int b =256>>1 ; /* foo\n" 7033 " bar */")); 7034 } 7035 7036 TEST_F(FormatTest, UnderstandsBinaryOperators) { 7037 verifyFormat("COMPARE(a, ==, b);"); 7038 verifyFormat("auto s = sizeof...(Ts) - 1;"); 7039 } 7040 7041 TEST_F(FormatTest, UnderstandsPointersToMembers) { 7042 verifyFormat("int A::*x;"); 7043 verifyFormat("int (S::*func)(void *);"); 7044 verifyFormat("void f() { int (S::*func)(void *); }"); 7045 verifyFormat("typedef bool *(Class::*Member)() const;"); 7046 verifyFormat("void f() {\n" 7047 " (a->*f)();\n" 7048 " a->*x;\n" 7049 " (a.*f)();\n" 7050 " ((*a).*f)();\n" 7051 " a.*x;\n" 7052 "}"); 7053 verifyFormat("void f() {\n" 7054 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7055 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 7056 "}"); 7057 verifyFormat( 7058 "(aaaaaaaaaa->*bbbbbbb)(\n" 7059 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 7060 FormatStyle Style = getLLVMStyle(); 7061 Style.PointerAlignment = FormatStyle::PAS_Left; 7062 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 7063 } 7064 7065 TEST_F(FormatTest, UnderstandsUnaryOperators) { 7066 verifyFormat("int a = -2;"); 7067 verifyFormat("f(-1, -2, -3);"); 7068 verifyFormat("a[-1] = 5;"); 7069 verifyFormat("int a = 5 + -2;"); 7070 verifyFormat("if (i == -1) {\n}"); 7071 verifyFormat("if (i != -1) {\n}"); 7072 verifyFormat("if (i > -1) {\n}"); 7073 verifyFormat("if (i < -1) {\n}"); 7074 verifyFormat("++(a->f());"); 7075 verifyFormat("--(a->f());"); 7076 verifyFormat("(a->f())++;"); 7077 verifyFormat("a[42]++;"); 7078 verifyFormat("if (!(a->f())) {\n}"); 7079 verifyFormat("if (!+i) {\n}"); 7080 verifyFormat("~&a;"); 7081 7082 verifyFormat("a-- > b;"); 7083 verifyFormat("b ? -a : c;"); 7084 verifyFormat("n * sizeof char16;"); 7085 verifyFormat("n * alignof char16;", getGoogleStyle()); 7086 verifyFormat("sizeof(char);"); 7087 verifyFormat("alignof(char);", getGoogleStyle()); 7088 7089 verifyFormat("return -1;"); 7090 verifyFormat("throw -1;"); 7091 verifyFormat("switch (a) {\n" 7092 "case -1:\n" 7093 " break;\n" 7094 "}"); 7095 verifyFormat("#define X -1"); 7096 verifyFormat("#define X -kConstant"); 7097 7098 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 7099 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 7100 7101 verifyFormat("int a = /* confusing comment */ -1;"); 7102 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 7103 verifyFormat("int a = i /* confusing comment */++;"); 7104 7105 verifyFormat("co_yield -1;"); 7106 verifyFormat("co_return -1;"); 7107 } 7108 7109 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 7110 verifyFormat("if (!aaaaaaaaaa( // break\n" 7111 " aaaaa)) {\n" 7112 "}"); 7113 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 7114 " aaaaa));"); 7115 verifyFormat("*aaa = aaaaaaa( // break\n" 7116 " bbbbbb);"); 7117 } 7118 7119 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 7120 verifyFormat("bool operator<();"); 7121 verifyFormat("bool operator>();"); 7122 verifyFormat("bool operator=();"); 7123 verifyFormat("bool operator==();"); 7124 verifyFormat("bool operator!=();"); 7125 verifyFormat("int operator+();"); 7126 verifyFormat("int operator++();"); 7127 verifyFormat("int operator++(int) volatile noexcept;"); 7128 verifyFormat("bool operator,();"); 7129 verifyFormat("bool operator();"); 7130 verifyFormat("bool operator()();"); 7131 verifyFormat("bool operator[]();"); 7132 verifyFormat("operator bool();"); 7133 verifyFormat("operator int();"); 7134 verifyFormat("operator void *();"); 7135 verifyFormat("operator SomeType<int>();"); 7136 verifyFormat("operator SomeType<int, int>();"); 7137 verifyFormat("operator SomeType<SomeType<int>>();"); 7138 verifyFormat("void *operator new(std::size_t size);"); 7139 verifyFormat("void *operator new[](std::size_t size);"); 7140 verifyFormat("void operator delete(void *ptr);"); 7141 verifyFormat("void operator delete[](void *ptr);"); 7142 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 7143 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 7144 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 7145 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 7146 7147 verifyFormat( 7148 "ostream &operator<<(ostream &OutputStream,\n" 7149 " SomeReallyLongType WithSomeReallyLongValue);"); 7150 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 7151 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 7152 " return left.group < right.group;\n" 7153 "}"); 7154 verifyFormat("SomeType &operator=(const SomeType &S);"); 7155 verifyFormat("f.template operator()<int>();"); 7156 7157 verifyGoogleFormat("operator void*();"); 7158 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 7159 verifyGoogleFormat("operator ::A();"); 7160 7161 verifyFormat("using A::operator+;"); 7162 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 7163 "int i;"); 7164 } 7165 7166 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 7167 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 7168 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 7169 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 7170 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 7171 verifyFormat("Deleted &operator=(const Deleted &) &;"); 7172 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 7173 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 7174 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 7175 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 7176 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 7177 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 7178 verifyFormat("void Fn(T const &) const &;"); 7179 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 7180 verifyFormat("template <typename T>\n" 7181 "void F(T) && = delete;", 7182 getGoogleStyle()); 7183 7184 FormatStyle AlignLeft = getLLVMStyle(); 7185 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 7186 verifyFormat("void A::b() && {}", AlignLeft); 7187 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 7188 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 7189 AlignLeft); 7190 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 7191 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 7192 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 7193 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 7194 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 7195 verifyFormat("auto Function(T) & -> void;", AlignLeft); 7196 verifyFormat("void Fn(T const&) const&;", AlignLeft); 7197 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 7198 7199 FormatStyle Spaces = getLLVMStyle(); 7200 Spaces.SpacesInCStyleCastParentheses = true; 7201 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 7202 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 7203 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 7204 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 7205 7206 Spaces.SpacesInCStyleCastParentheses = false; 7207 Spaces.SpacesInParentheses = true; 7208 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 7209 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", 7210 Spaces); 7211 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 7212 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 7213 7214 FormatStyle BreakTemplate = getLLVMStyle(); 7215 BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 7216 7217 verifyFormat("struct f {\n" 7218 " template <class T>\n" 7219 " int &foo(const std::string &str) &noexcept {}\n" 7220 "};", 7221 BreakTemplate); 7222 7223 verifyFormat("struct f {\n" 7224 " template <class T>\n" 7225 " int &foo(const std::string &str) &&noexcept {}\n" 7226 "};", 7227 BreakTemplate); 7228 7229 verifyFormat("struct f {\n" 7230 " template <class T>\n" 7231 " int &foo(const std::string &str) const &noexcept {}\n" 7232 "};", 7233 BreakTemplate); 7234 7235 verifyFormat("struct f {\n" 7236 " template <class T>\n" 7237 " int &foo(const std::string &str) const &noexcept {}\n" 7238 "};", 7239 BreakTemplate); 7240 7241 verifyFormat("struct f {\n" 7242 " template <class T>\n" 7243 " auto foo(const std::string &str) &&noexcept -> int & {}\n" 7244 "};", 7245 BreakTemplate); 7246 7247 FormatStyle AlignLeftBreakTemplate = getLLVMStyle(); 7248 AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations = 7249 FormatStyle::BTDS_Yes; 7250 AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left; 7251 7252 verifyFormat("struct f {\n" 7253 " template <class T>\n" 7254 " int& foo(const std::string& str) & noexcept {}\n" 7255 "};", 7256 AlignLeftBreakTemplate); 7257 7258 verifyFormat("struct f {\n" 7259 " template <class T>\n" 7260 " int& foo(const std::string& str) && noexcept {}\n" 7261 "};", 7262 AlignLeftBreakTemplate); 7263 7264 verifyFormat("struct f {\n" 7265 " template <class T>\n" 7266 " int& foo(const std::string& str) const& noexcept {}\n" 7267 "};", 7268 AlignLeftBreakTemplate); 7269 7270 verifyFormat("struct f {\n" 7271 " template <class T>\n" 7272 " int& foo(const std::string& str) const&& noexcept {}\n" 7273 "};", 7274 AlignLeftBreakTemplate); 7275 7276 verifyFormat("struct f {\n" 7277 " template <class T>\n" 7278 " auto foo(const std::string& str) && noexcept -> int& {}\n" 7279 "};", 7280 AlignLeftBreakTemplate); 7281 7282 // The `&` in `Type&` should not be confused with a trailing `&` of 7283 // DEPRECATED(reason) member function. 7284 verifyFormat("struct f {\n" 7285 " template <class T>\n" 7286 " DEPRECATED(reason)\n" 7287 " Type &foo(arguments) {}\n" 7288 "};", 7289 BreakTemplate); 7290 7291 verifyFormat("struct f {\n" 7292 " template <class T>\n" 7293 " DEPRECATED(reason)\n" 7294 " Type& foo(arguments) {}\n" 7295 "};", 7296 AlignLeftBreakTemplate); 7297 7298 verifyFormat("void (*foopt)(int) = &func;"); 7299 } 7300 7301 TEST_F(FormatTest, UnderstandsNewAndDelete) { 7302 verifyFormat("void f() {\n" 7303 " A *a = new A;\n" 7304 " A *a = new (placement) A;\n" 7305 " delete a;\n" 7306 " delete (A *)a;\n" 7307 "}"); 7308 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7309 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7310 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7311 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7312 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7313 verifyFormat("delete[] h->p;"); 7314 } 7315 7316 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 7317 verifyFormat("int *f(int *a) {}"); 7318 verifyFormat("int main(int argc, char **argv) {}"); 7319 verifyFormat("Test::Test(int b) : a(b * b) {}"); 7320 verifyIndependentOfContext("f(a, *a);"); 7321 verifyFormat("void g() { f(*a); }"); 7322 verifyIndependentOfContext("int a = b * 10;"); 7323 verifyIndependentOfContext("int a = 10 * b;"); 7324 verifyIndependentOfContext("int a = b * c;"); 7325 verifyIndependentOfContext("int a += b * c;"); 7326 verifyIndependentOfContext("int a -= b * c;"); 7327 verifyIndependentOfContext("int a *= b * c;"); 7328 verifyIndependentOfContext("int a /= b * c;"); 7329 verifyIndependentOfContext("int a = *b;"); 7330 verifyIndependentOfContext("int a = *b * c;"); 7331 verifyIndependentOfContext("int a = b * *c;"); 7332 verifyIndependentOfContext("int a = b * (10);"); 7333 verifyIndependentOfContext("S << b * (10);"); 7334 verifyIndependentOfContext("return 10 * b;"); 7335 verifyIndependentOfContext("return *b * *c;"); 7336 verifyIndependentOfContext("return a & ~b;"); 7337 verifyIndependentOfContext("f(b ? *c : *d);"); 7338 verifyIndependentOfContext("int a = b ? *c : *d;"); 7339 verifyIndependentOfContext("*b = a;"); 7340 verifyIndependentOfContext("a * ~b;"); 7341 verifyIndependentOfContext("a * !b;"); 7342 verifyIndependentOfContext("a * +b;"); 7343 verifyIndependentOfContext("a * -b;"); 7344 verifyIndependentOfContext("a * ++b;"); 7345 verifyIndependentOfContext("a * --b;"); 7346 verifyIndependentOfContext("a[4] * b;"); 7347 verifyIndependentOfContext("a[a * a] = 1;"); 7348 verifyIndependentOfContext("f() * b;"); 7349 verifyIndependentOfContext("a * [self dostuff];"); 7350 verifyIndependentOfContext("int x = a * (a + b);"); 7351 verifyIndependentOfContext("(a *)(a + b);"); 7352 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 7353 verifyIndependentOfContext("int *pa = (int *)&a;"); 7354 verifyIndependentOfContext("return sizeof(int **);"); 7355 verifyIndependentOfContext("return sizeof(int ******);"); 7356 verifyIndependentOfContext("return (int **&)a;"); 7357 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 7358 verifyFormat("void f(Type (*parameter)[10]) {}"); 7359 verifyFormat("void f(Type (¶meter)[10]) {}"); 7360 verifyGoogleFormat("return sizeof(int**);"); 7361 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 7362 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 7363 verifyFormat("auto a = [](int **&, int ***) {};"); 7364 verifyFormat("auto PointerBinding = [](const char *S) {};"); 7365 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 7366 verifyFormat("[](const decltype(*a) &value) {}"); 7367 verifyFormat("decltype(a * b) F();"); 7368 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 7369 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 7370 verifyIndependentOfContext("typedef void (*f)(int *a);"); 7371 verifyIndependentOfContext("int i{a * b};"); 7372 verifyIndependentOfContext("aaa && aaa->f();"); 7373 verifyIndependentOfContext("int x = ~*p;"); 7374 verifyFormat("Constructor() : a(a), area(width * height) {}"); 7375 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 7376 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 7377 verifyFormat("void f() { f(a, c * d); }"); 7378 verifyFormat("void f() { f(new a(), c * d); }"); 7379 verifyFormat("void f(const MyOverride &override);"); 7380 verifyFormat("void f(const MyFinal &final);"); 7381 verifyIndependentOfContext("bool a = f() && override.f();"); 7382 verifyIndependentOfContext("bool a = f() && final.f();"); 7383 7384 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 7385 7386 verifyIndependentOfContext("A<int *> a;"); 7387 verifyIndependentOfContext("A<int **> a;"); 7388 verifyIndependentOfContext("A<int *, int *> a;"); 7389 verifyIndependentOfContext("A<int *[]> a;"); 7390 verifyIndependentOfContext( 7391 "const char *const p = reinterpret_cast<const char *const>(q);"); 7392 verifyIndependentOfContext("A<int **, int **> a;"); 7393 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 7394 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 7395 verifyFormat("for (; a && b;) {\n}"); 7396 verifyFormat("bool foo = true && [] { return false; }();"); 7397 7398 verifyFormat( 7399 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7400 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7401 7402 verifyGoogleFormat("int const* a = &b;"); 7403 verifyGoogleFormat("**outparam = 1;"); 7404 verifyGoogleFormat("*outparam = a * b;"); 7405 verifyGoogleFormat("int main(int argc, char** argv) {}"); 7406 verifyGoogleFormat("A<int*> a;"); 7407 verifyGoogleFormat("A<int**> a;"); 7408 verifyGoogleFormat("A<int*, int*> a;"); 7409 verifyGoogleFormat("A<int**, int**> a;"); 7410 verifyGoogleFormat("f(b ? *c : *d);"); 7411 verifyGoogleFormat("int a = b ? *c : *d;"); 7412 verifyGoogleFormat("Type* t = **x;"); 7413 verifyGoogleFormat("Type* t = *++*x;"); 7414 verifyGoogleFormat("*++*x;"); 7415 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 7416 verifyGoogleFormat("Type* t = x++ * y;"); 7417 verifyGoogleFormat( 7418 "const char* const p = reinterpret_cast<const char* const>(q);"); 7419 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 7420 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 7421 verifyGoogleFormat("template <typename T>\n" 7422 "void f(int i = 0, SomeType** temps = NULL);"); 7423 7424 FormatStyle Left = getLLVMStyle(); 7425 Left.PointerAlignment = FormatStyle::PAS_Left; 7426 verifyFormat("x = *a(x) = *a(y);", Left); 7427 verifyFormat("for (;; *a = b) {\n}", Left); 7428 verifyFormat("return *this += 1;", Left); 7429 verifyFormat("throw *x;", Left); 7430 verifyFormat("delete *x;", Left); 7431 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 7432 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 7433 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 7434 verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left); 7435 verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left); 7436 verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left); 7437 7438 verifyIndependentOfContext("a = *(x + y);"); 7439 verifyIndependentOfContext("a = &(x + y);"); 7440 verifyIndependentOfContext("*(x + y).call();"); 7441 verifyIndependentOfContext("&(x + y)->call();"); 7442 verifyFormat("void f() { &(*I).first; }"); 7443 7444 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 7445 verifyFormat( 7446 "int *MyValues = {\n" 7447 " *A, // Operator detection might be confused by the '{'\n" 7448 " *BB // Operator detection might be confused by previous comment\n" 7449 "};"); 7450 7451 verifyIndependentOfContext("if (int *a = &b)"); 7452 verifyIndependentOfContext("if (int &a = *b)"); 7453 verifyIndependentOfContext("if (a & b[i])"); 7454 verifyIndependentOfContext("if constexpr (a & b[i])"); 7455 verifyIndependentOfContext("if CONSTEXPR (a & b[i])"); 7456 verifyIndependentOfContext("if (a * (b * c))"); 7457 verifyIndependentOfContext("if constexpr (a * (b * c))"); 7458 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))"); 7459 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 7460 verifyIndependentOfContext("if (*b[i])"); 7461 verifyIndependentOfContext("if (int *a = (&b))"); 7462 verifyIndependentOfContext("while (int *a = &b)"); 7463 verifyIndependentOfContext("while (a * (b * c))"); 7464 verifyIndependentOfContext("size = sizeof *a;"); 7465 verifyIndependentOfContext("if (a && (b = c))"); 7466 verifyFormat("void f() {\n" 7467 " for (const int &v : Values) {\n" 7468 " }\n" 7469 "}"); 7470 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 7471 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 7472 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 7473 7474 verifyFormat("#define A (!a * b)"); 7475 verifyFormat("#define MACRO \\\n" 7476 " int *i = a * b; \\\n" 7477 " void f(a *b);", 7478 getLLVMStyleWithColumns(19)); 7479 7480 verifyIndependentOfContext("A = new SomeType *[Length];"); 7481 verifyIndependentOfContext("A = new SomeType *[Length]();"); 7482 verifyIndependentOfContext("T **t = new T *;"); 7483 verifyIndependentOfContext("T **t = new T *();"); 7484 verifyGoogleFormat("A = new SomeType*[Length]();"); 7485 verifyGoogleFormat("A = new SomeType*[Length];"); 7486 verifyGoogleFormat("T** t = new T*;"); 7487 verifyGoogleFormat("T** t = new T*();"); 7488 7489 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 7490 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 7491 verifyFormat("template <bool a, bool b> " 7492 "typename t::if<x && y>::type f() {}"); 7493 verifyFormat("template <int *y> f() {}"); 7494 verifyFormat("vector<int *> v;"); 7495 verifyFormat("vector<int *const> v;"); 7496 verifyFormat("vector<int *const **const *> v;"); 7497 verifyFormat("vector<int *volatile> v;"); 7498 verifyFormat("vector<a * b> v;"); 7499 verifyFormat("foo<b && false>();"); 7500 verifyFormat("foo<b & 1>();"); 7501 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 7502 verifyFormat( 7503 "template <class T, class = typename std::enable_if<\n" 7504 " std::is_integral<T>::value &&\n" 7505 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 7506 "void F();", 7507 getLLVMStyleWithColumns(70)); 7508 verifyFormat("template <class T,\n" 7509 " class = typename std::enable_if<\n" 7510 " std::is_integral<T>::value &&\n" 7511 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 7512 " class U>\n" 7513 "void F();", 7514 getLLVMStyleWithColumns(70)); 7515 verifyFormat( 7516 "template <class T,\n" 7517 " class = typename ::std::enable_if<\n" 7518 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 7519 "void F();", 7520 getGoogleStyleWithColumns(68)); 7521 7522 verifyIndependentOfContext("MACRO(int *i);"); 7523 verifyIndependentOfContext("MACRO(auto *a);"); 7524 verifyIndependentOfContext("MACRO(const A *a);"); 7525 verifyIndependentOfContext("MACRO(A *const a);"); 7526 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 7527 verifyFormat("void f() { f(float{1}, a * a); }"); 7528 // FIXME: Is there a way to make this work? 7529 // verifyIndependentOfContext("MACRO(A *a);"); 7530 7531 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 7532 verifyFormat("return options != nullptr && operator==(*options);"); 7533 7534 EXPECT_EQ("#define OP(x) \\\n" 7535 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7536 " return s << a.DebugString(); \\\n" 7537 " }", 7538 format("#define OP(x) \\\n" 7539 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7540 " return s << a.DebugString(); \\\n" 7541 " }", 7542 getLLVMStyleWithColumns(50))); 7543 7544 // FIXME: We cannot handle this case yet; we might be able to figure out that 7545 // foo<x> d > v; doesn't make sense. 7546 verifyFormat("foo<a<b && c> d> v;"); 7547 7548 FormatStyle PointerMiddle = getLLVMStyle(); 7549 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7550 verifyFormat("delete *x;", PointerMiddle); 7551 verifyFormat("int * x;", PointerMiddle); 7552 verifyFormat("int *[] x;", PointerMiddle); 7553 verifyFormat("template <int * y> f() {}", PointerMiddle); 7554 verifyFormat("int * f(int * a) {}", PointerMiddle); 7555 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7556 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7557 verifyFormat("A<int *> a;", PointerMiddle); 7558 verifyFormat("A<int **> a;", PointerMiddle); 7559 verifyFormat("A<int *, int *> a;", PointerMiddle); 7560 verifyFormat("A<int *[]> a;", PointerMiddle); 7561 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7562 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7563 verifyFormat("T ** t = new T *;", PointerMiddle); 7564 7565 // Member function reference qualifiers aren't binary operators. 7566 verifyFormat("string // break\n" 7567 "operator()() & {}"); 7568 verifyFormat("string // break\n" 7569 "operator()() && {}"); 7570 verifyGoogleFormat("template <typename T>\n" 7571 "auto x() & -> int {}"); 7572 } 7573 7574 TEST_F(FormatTest, UnderstandsAttributes) { 7575 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7576 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7577 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7578 FormatStyle AfterType = getLLVMStyle(); 7579 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7580 verifyFormat("__attribute__((nodebug)) void\n" 7581 "foo() {}\n", 7582 AfterType); 7583 } 7584 7585 TEST_F(FormatTest, UnderstandsSquareAttributes) { 7586 verifyFormat("SomeType s [[unused]] (InitValue);"); 7587 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 7588 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 7589 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 7590 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 7591 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7592 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7593 7594 // Make sure we do not mistake attributes for array subscripts. 7595 verifyFormat("int a() {}\n" 7596 "[[unused]] int b() {}\n"); 7597 verifyFormat("NSArray *arr;\n" 7598 "arr[[Foo() bar]];"); 7599 7600 // On the other hand, we still need to correctly find array subscripts. 7601 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 7602 7603 // Make sure that we do not mistake Objective-C method inside array literals 7604 // as attributes, even if those method names are also keywords. 7605 verifyFormat("@[ [foo bar] ];"); 7606 verifyFormat("@[ [NSArray class] ];"); 7607 verifyFormat("@[ [foo enum] ];"); 7608 7609 // Make sure we do not parse attributes as lambda introducers. 7610 FormatStyle MultiLineFunctions = getLLVMStyle(); 7611 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7612 verifyFormat("[[unused]] int b() {\n" 7613 " return 42;\n" 7614 "}\n", 7615 MultiLineFunctions); 7616 } 7617 7618 TEST_F(FormatTest, UnderstandsEllipsis) { 7619 verifyFormat("int printf(const char *fmt, ...);"); 7620 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 7621 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 7622 7623 FormatStyle PointersLeft = getLLVMStyle(); 7624 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 7625 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 7626 } 7627 7628 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 7629 EXPECT_EQ("int *a;\n" 7630 "int *a;\n" 7631 "int *a;", 7632 format("int *a;\n" 7633 "int* a;\n" 7634 "int *a;", 7635 getGoogleStyle())); 7636 EXPECT_EQ("int* a;\n" 7637 "int* a;\n" 7638 "int* a;", 7639 format("int* a;\n" 7640 "int* a;\n" 7641 "int *a;", 7642 getGoogleStyle())); 7643 EXPECT_EQ("int *a;\n" 7644 "int *a;\n" 7645 "int *a;", 7646 format("int *a;\n" 7647 "int * a;\n" 7648 "int * a;", 7649 getGoogleStyle())); 7650 EXPECT_EQ("auto x = [] {\n" 7651 " int *a;\n" 7652 " int *a;\n" 7653 " int *a;\n" 7654 "};", 7655 format("auto x=[]{int *a;\n" 7656 "int * a;\n" 7657 "int * a;};", 7658 getGoogleStyle())); 7659 } 7660 7661 TEST_F(FormatTest, UnderstandsRvalueReferences) { 7662 verifyFormat("int f(int &&a) {}"); 7663 verifyFormat("int f(int a, char &&b) {}"); 7664 verifyFormat("void f() { int &&a = b; }"); 7665 verifyGoogleFormat("int f(int a, char&& b) {}"); 7666 verifyGoogleFormat("void f() { int&& a = b; }"); 7667 7668 verifyIndependentOfContext("A<int &&> a;"); 7669 verifyIndependentOfContext("A<int &&, int &&> a;"); 7670 verifyGoogleFormat("A<int&&> a;"); 7671 verifyGoogleFormat("A<int&&, int&&> a;"); 7672 7673 // Not rvalue references: 7674 verifyFormat("template <bool B, bool C> class A {\n" 7675 " static_assert(B && C, \"Something is wrong\");\n" 7676 "};"); 7677 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 7678 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 7679 verifyFormat("#define A(a, b) (a && b)"); 7680 } 7681 7682 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 7683 verifyFormat("void f() {\n" 7684 " x[aaaaaaaaa -\n" 7685 " b] = 23;\n" 7686 "}", 7687 getLLVMStyleWithColumns(15)); 7688 } 7689 7690 TEST_F(FormatTest, FormatsCasts) { 7691 verifyFormat("Type *A = static_cast<Type *>(P);"); 7692 verifyFormat("Type *A = (Type *)P;"); 7693 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7694 verifyFormat("int a = (int)(2.0f);"); 7695 verifyFormat("int a = (int)2.0f;"); 7696 verifyFormat("x[(int32)y];"); 7697 verifyFormat("x = (int32)y;"); 7698 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7699 verifyFormat("int a = (int)*b;"); 7700 verifyFormat("int a = (int)2.0f;"); 7701 verifyFormat("int a = (int)~0;"); 7702 verifyFormat("int a = (int)++a;"); 7703 verifyFormat("int a = (int)sizeof(int);"); 7704 verifyFormat("int a = (int)+2;"); 7705 verifyFormat("my_int a = (my_int)2.0f;"); 7706 verifyFormat("my_int a = (my_int)sizeof(int);"); 7707 verifyFormat("return (my_int)aaa;"); 7708 verifyFormat("#define x ((int)-1)"); 7709 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7710 verifyFormat("#define p(q) ((int *)&q)"); 7711 verifyFormat("fn(a)(b) + 1;"); 7712 7713 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7714 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7715 verifyFormat("my_int a = (my_int)~0;"); 7716 verifyFormat("my_int a = (my_int)++a;"); 7717 verifyFormat("my_int a = (my_int)-2;"); 7718 verifyFormat("my_int a = (my_int)1;"); 7719 verifyFormat("my_int a = (my_int *)1;"); 7720 verifyFormat("my_int a = (const my_int)-1;"); 7721 verifyFormat("my_int a = (const my_int *)-1;"); 7722 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7723 verifyFormat("my_int a = (ns::my_int)-2;"); 7724 verifyFormat("case (my_int)ONE:"); 7725 verifyFormat("auto x = (X)this;"); 7726 // Casts in Obj-C style calls used to not be recognized as such. 7727 verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle()); 7728 7729 // FIXME: single value wrapped with paren will be treated as cast. 7730 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7731 7732 verifyFormat("{ (void)F; }"); 7733 7734 // Don't break after a cast's 7735 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7736 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7737 " bbbbbbbbbbbbbbbbbbbbbb);"); 7738 7739 // These are not casts. 7740 verifyFormat("void f(int *) {}"); 7741 verifyFormat("f(foo)->b;"); 7742 verifyFormat("f(foo).b;"); 7743 verifyFormat("f(foo)(b);"); 7744 verifyFormat("f(foo)[b];"); 7745 verifyFormat("[](foo) { return 4; }(bar);"); 7746 verifyFormat("(*funptr)(foo)[4];"); 7747 verifyFormat("funptrs[4](foo)[4];"); 7748 verifyFormat("void f(int *);"); 7749 verifyFormat("void f(int *) = 0;"); 7750 verifyFormat("void f(SmallVector<int>) {}"); 7751 verifyFormat("void f(SmallVector<int>);"); 7752 verifyFormat("void f(SmallVector<int>) = 0;"); 7753 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7754 verifyFormat("int a = sizeof(int) * b;"); 7755 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7756 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7757 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7758 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7759 7760 // These are not casts, but at some point were confused with casts. 7761 verifyFormat("virtual void foo(int *) override;"); 7762 verifyFormat("virtual void foo(char &) const;"); 7763 verifyFormat("virtual void foo(int *a, char *) const;"); 7764 verifyFormat("int a = sizeof(int *) + b;"); 7765 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7766 verifyFormat("bool b = f(g<int>) && c;"); 7767 verifyFormat("typedef void (*f)(int i) func;"); 7768 verifyFormat("void operator++(int) noexcept;"); 7769 verifyFormat("void operator++(int &) noexcept;"); 7770 verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t " 7771 "&) noexcept;"); 7772 verifyFormat( 7773 "void operator delete(std::size_t, const std::nothrow_t &) noexcept;"); 7774 verifyFormat("void operator delete(const std::nothrow_t &) noexcept;"); 7775 verifyFormat("void operator delete(std::nothrow_t &) noexcept;"); 7776 verifyFormat("void operator delete(nothrow_t &) noexcept;"); 7777 verifyFormat("void operator delete(foo &) noexcept;"); 7778 verifyFormat("void operator delete(foo) noexcept;"); 7779 verifyFormat("void operator delete(int) noexcept;"); 7780 verifyFormat("void operator delete(int &) noexcept;"); 7781 verifyFormat("void operator delete(int &) volatile noexcept;"); 7782 verifyFormat("void operator delete(int &) const"); 7783 verifyFormat("void operator delete(int &) = default"); 7784 verifyFormat("void operator delete(int &) = delete"); 7785 verifyFormat("void operator delete(int &) [[noreturn]]"); 7786 verifyFormat("void operator delete(int &) throw();"); 7787 verifyFormat("void operator delete(int &) throw(int);"); 7788 verifyFormat("auto operator delete(int &) -> int;"); 7789 verifyFormat("auto operator delete(int &) override"); 7790 verifyFormat("auto operator delete(int &) final"); 7791 7792 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7793 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7794 // FIXME: The indentation here is not ideal. 7795 verifyFormat( 7796 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7797 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7798 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7799 } 7800 7801 TEST_F(FormatTest, FormatsFunctionTypes) { 7802 verifyFormat("A<bool()> a;"); 7803 verifyFormat("A<SomeType()> a;"); 7804 verifyFormat("A<void (*)(int, std::string)> a;"); 7805 verifyFormat("A<void *(int)>;"); 7806 verifyFormat("void *(*a)(int *, SomeType *);"); 7807 verifyFormat("int (*func)(void *);"); 7808 verifyFormat("void f() { int (*func)(void *); }"); 7809 verifyFormat("template <class CallbackClass>\n" 7810 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7811 7812 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7813 verifyGoogleFormat("void* (*a)(int);"); 7814 verifyGoogleFormat( 7815 "template <class CallbackClass>\n" 7816 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7817 7818 // Other constructs can look somewhat like function types: 7819 verifyFormat("A<sizeof(*x)> a;"); 7820 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7821 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7822 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7823 verifyFormat("int x = f(&h)();"); 7824 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7825 verifyFormat("std::function<\n" 7826 " LooooooooooongTemplatedType<\n" 7827 " SomeType>*(\n" 7828 " LooooooooooooooooongType type)>\n" 7829 " function;", 7830 getGoogleStyleWithColumns(40)); 7831 } 7832 7833 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7834 verifyFormat("A (*foo_)[6];"); 7835 verifyFormat("vector<int> (*foo_)[6];"); 7836 } 7837 7838 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7839 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7840 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7841 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7842 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7843 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7844 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7845 7846 // Different ways of ()-initializiation. 7847 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7848 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7849 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7850 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7851 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7852 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7853 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7854 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7855 7856 // Lambdas should not confuse the variable declaration heuristic. 7857 verifyFormat("LooooooooooooooooongType\n" 7858 " variable(nullptr, [](A *a) {});", 7859 getLLVMStyleWithColumns(40)); 7860 } 7861 7862 TEST_F(FormatTest, BreaksLongDeclarations) { 7863 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7864 " AnotherNameForTheLongType;"); 7865 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7866 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7867 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7868 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7869 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7870 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7871 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7872 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7873 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7874 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7875 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7876 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7877 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7878 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7879 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7880 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7881 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7882 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7883 FormatStyle Indented = getLLVMStyle(); 7884 Indented.IndentWrappedFunctionNames = true; 7885 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7886 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7887 Indented); 7888 verifyFormat( 7889 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7890 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7891 Indented); 7892 verifyFormat( 7893 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7894 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7895 Indented); 7896 verifyFormat( 7897 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7898 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7899 Indented); 7900 7901 // FIXME: Without the comment, this breaks after "(". 7902 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7903 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7904 getGoogleStyle()); 7905 7906 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7907 " int LoooooooooooooooooooongParam2) {}"); 7908 verifyFormat( 7909 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7910 " SourceLocation L, IdentifierIn *II,\n" 7911 " Type *T) {}"); 7912 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7913 "ReallyReaaallyLongFunctionName(\n" 7914 " const std::string &SomeParameter,\n" 7915 " const SomeType<string, SomeOtherTemplateParameter>\n" 7916 " &ReallyReallyLongParameterName,\n" 7917 " const SomeType<string, SomeOtherTemplateParameter>\n" 7918 " &AnotherLongParameterName) {}"); 7919 verifyFormat("template <typename A>\n" 7920 "SomeLoooooooooooooooooooooongType<\n" 7921 " typename some_namespace::SomeOtherType<A>::Type>\n" 7922 "Function() {}"); 7923 7924 verifyGoogleFormat( 7925 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7926 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7927 verifyGoogleFormat( 7928 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7929 " SourceLocation L) {}"); 7930 verifyGoogleFormat( 7931 "some_namespace::LongReturnType\n" 7932 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7933 " int first_long_parameter, int second_parameter) {}"); 7934 7935 verifyGoogleFormat("template <typename T>\n" 7936 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7937 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7938 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7939 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7940 7941 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7942 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7943 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7944 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7945 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7946 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 7947 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7948 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 7949 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 7950 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7951 7952 verifyFormat("template <typename T> // Templates on own line.\n" 7953 "static int // Some comment.\n" 7954 "MyFunction(int a);", 7955 getLLVMStyle()); 7956 } 7957 7958 TEST_F(FormatTest, FormatsArrays) { 7959 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7960 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 7961 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 7962 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 7963 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 7964 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 7965 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7966 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7967 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7968 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 7969 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7970 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7971 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7972 verifyFormat( 7973 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 7974 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7975 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 7976 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 7977 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7978 7979 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 7980 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 7981 verifyFormat( 7982 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 7983 " .aaaaaaa[0]\n" 7984 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7985 verifyFormat("a[::b::c];"); 7986 7987 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 7988 7989 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 7990 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 7991 } 7992 7993 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 7994 verifyFormat("(a)->b();"); 7995 verifyFormat("--a;"); 7996 } 7997 7998 TEST_F(FormatTest, HandlesIncludeDirectives) { 7999 verifyFormat("#include <string>\n" 8000 "#include <a/b/c.h>\n" 8001 "#include \"a/b/string\"\n" 8002 "#include \"string.h\"\n" 8003 "#include \"string.h\"\n" 8004 "#include <a-a>\n" 8005 "#include < path with space >\n" 8006 "#include_next <test.h>" 8007 "#include \"abc.h\" // this is included for ABC\n" 8008 "#include \"some long include\" // with a comment\n" 8009 "#include \"some very long include path\"\n" 8010 "#include <some/very/long/include/path>\n", 8011 getLLVMStyleWithColumns(35)); 8012 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 8013 EXPECT_EQ("#include <a>", format("#include<a>")); 8014 8015 verifyFormat("#import <string>"); 8016 verifyFormat("#import <a/b/c.h>"); 8017 verifyFormat("#import \"a/b/string\""); 8018 verifyFormat("#import \"string.h\""); 8019 verifyFormat("#import \"string.h\""); 8020 verifyFormat("#if __has_include(<strstream>)\n" 8021 "#include <strstream>\n" 8022 "#endif"); 8023 8024 verifyFormat("#define MY_IMPORT <a/b>"); 8025 8026 verifyFormat("#if __has_include(<a/b>)"); 8027 verifyFormat("#if __has_include_next(<a/b>)"); 8028 verifyFormat("#define F __has_include(<a/b>)"); 8029 verifyFormat("#define F __has_include_next(<a/b>)"); 8030 8031 // Protocol buffer definition or missing "#". 8032 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 8033 getLLVMStyleWithColumns(30)); 8034 8035 FormatStyle Style = getLLVMStyle(); 8036 Style.AlwaysBreakBeforeMultilineStrings = true; 8037 Style.ColumnLimit = 0; 8038 verifyFormat("#import \"abc.h\"", Style); 8039 8040 // But 'import' might also be a regular C++ namespace. 8041 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8042 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 8043 } 8044 8045 //===----------------------------------------------------------------------===// 8046 // Error recovery tests. 8047 //===----------------------------------------------------------------------===// 8048 8049 TEST_F(FormatTest, IncompleteParameterLists) { 8050 FormatStyle NoBinPacking = getLLVMStyle(); 8051 NoBinPacking.BinPackParameters = false; 8052 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 8053 " double *min_x,\n" 8054 " double *max_x,\n" 8055 " double *min_y,\n" 8056 " double *max_y,\n" 8057 " double *min_z,\n" 8058 " double *max_z, ) {}", 8059 NoBinPacking); 8060 } 8061 8062 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 8063 verifyFormat("void f() { return; }\n42"); 8064 verifyFormat("void f() {\n" 8065 " if (0)\n" 8066 " return;\n" 8067 "}\n" 8068 "42"); 8069 verifyFormat("void f() { return }\n42"); 8070 verifyFormat("void f() {\n" 8071 " if (0)\n" 8072 " return\n" 8073 "}\n" 8074 "42"); 8075 } 8076 8077 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 8078 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 8079 EXPECT_EQ("void f() {\n" 8080 " if (a)\n" 8081 " return\n" 8082 "}", 8083 format("void f ( ) { if ( a ) return }")); 8084 EXPECT_EQ("namespace N {\n" 8085 "void f()\n" 8086 "}", 8087 format("namespace N { void f() }")); 8088 EXPECT_EQ("namespace N {\n" 8089 "void f() {}\n" 8090 "void g()\n" 8091 "} // namespace N", 8092 format("namespace N { void f( ) { } void g( ) }")); 8093 } 8094 8095 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 8096 verifyFormat("int aaaaaaaa =\n" 8097 " // Overlylongcomment\n" 8098 " b;", 8099 getLLVMStyleWithColumns(20)); 8100 verifyFormat("function(\n" 8101 " ShortArgument,\n" 8102 " LoooooooooooongArgument);\n", 8103 getLLVMStyleWithColumns(20)); 8104 } 8105 8106 TEST_F(FormatTest, IncorrectAccessSpecifier) { 8107 verifyFormat("public:"); 8108 verifyFormat("class A {\n" 8109 "public\n" 8110 " void f() {}\n" 8111 "};"); 8112 verifyFormat("public\n" 8113 "int qwerty;"); 8114 verifyFormat("public\n" 8115 "B {}"); 8116 verifyFormat("public\n" 8117 "{}"); 8118 verifyFormat("public\n" 8119 "B { int x; }"); 8120 } 8121 8122 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 8123 verifyFormat("{"); 8124 verifyFormat("#})"); 8125 verifyNoCrash("(/**/[:!] ?[)."); 8126 } 8127 8128 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 8129 // Found by oss-fuzz: 8130 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 8131 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 8132 Style.ColumnLimit = 60; 8133 verifyNoCrash( 8134 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 8135 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 8136 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 8137 Style); 8138 } 8139 8140 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 8141 verifyFormat("do {\n}"); 8142 verifyFormat("do {\n}\n" 8143 "f();"); 8144 verifyFormat("do {\n}\n" 8145 "wheeee(fun);"); 8146 verifyFormat("do {\n" 8147 " f();\n" 8148 "}"); 8149 } 8150 8151 TEST_F(FormatTest, IncorrectCodeMissingParens) { 8152 verifyFormat("if {\n foo;\n foo();\n}"); 8153 verifyFormat("switch {\n foo;\n foo();\n}"); 8154 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 8155 verifyFormat("while {\n foo;\n foo();\n}"); 8156 verifyFormat("do {\n foo;\n foo();\n} while;"); 8157 } 8158 8159 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 8160 verifyIncompleteFormat("namespace {\n" 8161 "class Foo { Foo (\n" 8162 "};\n" 8163 "} // namespace"); 8164 } 8165 8166 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 8167 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 8168 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 8169 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 8170 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 8171 8172 EXPECT_EQ("{\n" 8173 " {\n" 8174 " breakme(\n" 8175 " qwe);\n" 8176 " }\n", 8177 format("{\n" 8178 " {\n" 8179 " breakme(qwe);\n" 8180 "}\n", 8181 getLLVMStyleWithColumns(10))); 8182 } 8183 8184 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 8185 verifyFormat("int x = {\n" 8186 " avariable,\n" 8187 " b(alongervariable)};", 8188 getLLVMStyleWithColumns(25)); 8189 } 8190 8191 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 8192 verifyFormat("return (a)(b){1, 2, 3};"); 8193 } 8194 8195 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 8196 verifyFormat("vector<int> x{1, 2, 3, 4};"); 8197 verifyFormat("vector<int> x{\n" 8198 " 1,\n" 8199 " 2,\n" 8200 " 3,\n" 8201 " 4,\n" 8202 "};"); 8203 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 8204 verifyFormat("f({1, 2});"); 8205 verifyFormat("auto v = Foo{-1};"); 8206 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 8207 verifyFormat("Class::Class : member{1, 2, 3} {}"); 8208 verifyFormat("new vector<int>{1, 2, 3};"); 8209 verifyFormat("new int[3]{1, 2, 3};"); 8210 verifyFormat("new int{1};"); 8211 verifyFormat("return {arg1, arg2};"); 8212 verifyFormat("return {arg1, SomeType{parameter}};"); 8213 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 8214 verifyFormat("new T{arg1, arg2};"); 8215 verifyFormat("f(MyMap[{composite, key}]);"); 8216 verifyFormat("class Class {\n" 8217 " T member = {arg1, arg2};\n" 8218 "};"); 8219 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 8220 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 8221 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 8222 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 8223 verifyFormat("int a = std::is_integral<int>{} + 0;"); 8224 8225 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8226 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8227 verifyFormat("auto i = decltype(x){};"); 8228 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 8229 verifyFormat("Node n{1, Node{1000}, //\n" 8230 " 2};"); 8231 verifyFormat("Aaaa aaaaaaa{\n" 8232 " {\n" 8233 " aaaa,\n" 8234 " },\n" 8235 "};"); 8236 verifyFormat("class C : public D {\n" 8237 " SomeClass SC{2};\n" 8238 "};"); 8239 verifyFormat("class C : public A {\n" 8240 " class D : public B {\n" 8241 " void f() { int i{2}; }\n" 8242 " };\n" 8243 "};"); 8244 verifyFormat("#define A {a, a},"); 8245 8246 // Avoid breaking between equal sign and opening brace 8247 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 8248 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 8249 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 8250 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 8251 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 8252 " {\"ccccccccccccccccccccc\", 2}};", 8253 AvoidBreakingFirstArgument); 8254 8255 // Binpacking only if there is no trailing comma 8256 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 8257 " cccccccccc, dddddddddd};", 8258 getLLVMStyleWithColumns(50)); 8259 verifyFormat("const Aaaaaa aaaaa = {\n" 8260 " aaaaaaaaaaa,\n" 8261 " bbbbbbbbbbb,\n" 8262 " ccccccccccc,\n" 8263 " ddddddddddd,\n" 8264 "};", 8265 getLLVMStyleWithColumns(50)); 8266 8267 // Cases where distinguising braced lists and blocks is hard. 8268 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 8269 verifyFormat("void f() {\n" 8270 " return; // comment\n" 8271 "}\n" 8272 "SomeType t;"); 8273 verifyFormat("void f() {\n" 8274 " if (a) {\n" 8275 " f();\n" 8276 " }\n" 8277 "}\n" 8278 "SomeType t;"); 8279 8280 // In combination with BinPackArguments = false. 8281 FormatStyle NoBinPacking = getLLVMStyle(); 8282 NoBinPacking.BinPackArguments = false; 8283 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 8284 " bbbbb,\n" 8285 " ccccc,\n" 8286 " ddddd,\n" 8287 " eeeee,\n" 8288 " ffffff,\n" 8289 " ggggg,\n" 8290 " hhhhhh,\n" 8291 " iiiiii,\n" 8292 " jjjjjj,\n" 8293 " kkkkkk};", 8294 NoBinPacking); 8295 verifyFormat("const Aaaaaa aaaaa = {\n" 8296 " aaaaa,\n" 8297 " bbbbb,\n" 8298 " ccccc,\n" 8299 " ddddd,\n" 8300 " eeeee,\n" 8301 " ffffff,\n" 8302 " ggggg,\n" 8303 " hhhhhh,\n" 8304 " iiiiii,\n" 8305 " jjjjjj,\n" 8306 " kkkkkk,\n" 8307 "};", 8308 NoBinPacking); 8309 verifyFormat( 8310 "const Aaaaaa aaaaa = {\n" 8311 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 8312 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 8313 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 8314 "};", 8315 NoBinPacking); 8316 8317 NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 8318 EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n" 8319 " CDDDP83848_BMCR_REGISTER,\n" 8320 " CDDDP83848_BMSR_REGISTER,\n" 8321 " CDDDP83848_RBR_REGISTER};", 8322 format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n" 8323 " CDDDP83848_BMSR_REGISTER,\n" 8324 " CDDDP83848_RBR_REGISTER};", 8325 NoBinPacking)); 8326 8327 // FIXME: The alignment of these trailing comments might be bad. Then again, 8328 // this might be utterly useless in real code. 8329 verifyFormat("Constructor::Constructor()\n" 8330 " : some_value{ //\n" 8331 " aaaaaaa, //\n" 8332 " bbbbbbb} {}"); 8333 8334 // In braced lists, the first comment is always assumed to belong to the 8335 // first element. Thus, it can be moved to the next or previous line as 8336 // appropriate. 8337 EXPECT_EQ("function({// First element:\n" 8338 " 1,\n" 8339 " // Second element:\n" 8340 " 2});", 8341 format("function({\n" 8342 " // First element:\n" 8343 " 1,\n" 8344 " // Second element:\n" 8345 " 2});")); 8346 EXPECT_EQ("std::vector<int> MyNumbers{\n" 8347 " // First element:\n" 8348 " 1,\n" 8349 " // Second element:\n" 8350 " 2};", 8351 format("std::vector<int> MyNumbers{// First element:\n" 8352 " 1,\n" 8353 " // Second element:\n" 8354 " 2};", 8355 getLLVMStyleWithColumns(30))); 8356 // A trailing comma should still lead to an enforced line break and no 8357 // binpacking. 8358 EXPECT_EQ("vector<int> SomeVector = {\n" 8359 " // aaa\n" 8360 " 1,\n" 8361 " 2,\n" 8362 "};", 8363 format("vector<int> SomeVector = { // aaa\n" 8364 " 1, 2, };")); 8365 8366 FormatStyle ExtraSpaces = getLLVMStyle(); 8367 ExtraSpaces.Cpp11BracedListStyle = false; 8368 ExtraSpaces.ColumnLimit = 75; 8369 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 8370 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 8371 verifyFormat("f({ 1, 2 });", ExtraSpaces); 8372 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 8373 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 8374 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 8375 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 8376 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 8377 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 8378 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 8379 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 8380 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 8381 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 8382 verifyFormat("class Class {\n" 8383 " T member = { arg1, arg2 };\n" 8384 "};", 8385 ExtraSpaces); 8386 verifyFormat( 8387 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8388 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 8389 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 8390 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 8391 ExtraSpaces); 8392 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 8393 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 8394 ExtraSpaces); 8395 verifyFormat( 8396 "someFunction(OtherParam,\n" 8397 " BracedList{ // comment 1 (Forcing interesting break)\n" 8398 " param1, param2,\n" 8399 " // comment 2\n" 8400 " param3, param4 });", 8401 ExtraSpaces); 8402 verifyFormat( 8403 "std::this_thread::sleep_for(\n" 8404 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 8405 ExtraSpaces); 8406 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 8407 " aaaaaaa,\n" 8408 " aaaaaaaaaa,\n" 8409 " aaaaa,\n" 8410 " aaaaaaaaaaaaaaa,\n" 8411 " aaa,\n" 8412 " aaaaaaaaaa,\n" 8413 " a,\n" 8414 " aaaaaaaaaaaaaaaaaaaaa,\n" 8415 " aaaaaaaaaaaa,\n" 8416 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 8417 " aaaaaaa,\n" 8418 " a};"); 8419 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 8420 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 8421 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 8422 8423 // Avoid breaking between initializer/equal sign and opening brace 8424 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 8425 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 8426 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8427 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8428 " { \"ccccccccccccccccccccc\", 2 }\n" 8429 "};", 8430 ExtraSpaces); 8431 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 8432 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8433 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8434 " { \"ccccccccccccccccccccc\", 2 }\n" 8435 "};", 8436 ExtraSpaces); 8437 8438 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 8439 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 8440 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 8441 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 8442 8443 FormatStyle SpaceBetweenBraces = getLLVMStyle(); 8444 SpaceBetweenBraces.SpacesInAngles = true; 8445 SpaceBetweenBraces.SpacesInParentheses = true; 8446 SpaceBetweenBraces.SpacesInSquareBrackets = true; 8447 verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces); 8448 verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces); 8449 verifyFormat("vector< int > x{ // comment 1\n" 8450 " 1, 2, 3, 4 };", 8451 SpaceBetweenBraces); 8452 SpaceBetweenBraces.ColumnLimit = 20; 8453 EXPECT_EQ("vector< int > x{\n" 8454 " 1, 2, 3, 4 };", 8455 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8456 SpaceBetweenBraces.ColumnLimit = 24; 8457 EXPECT_EQ("vector< int > x{ 1, 2,\n" 8458 " 3, 4 };", 8459 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8460 EXPECT_EQ("vector< int > x{\n" 8461 " 1,\n" 8462 " 2,\n" 8463 " 3,\n" 8464 " 4,\n" 8465 "};", 8466 format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces)); 8467 verifyFormat("vector< int > x{};", SpaceBetweenBraces); 8468 SpaceBetweenBraces.SpaceInEmptyParentheses = true; 8469 verifyFormat("vector< int > x{ };", SpaceBetweenBraces); 8470 } 8471 8472 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 8473 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8474 " 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};"); 8479 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 8480 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8481 " 1, 22, 333, 4444, 55555, //\n" 8482 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8483 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8484 verifyFormat( 8485 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8486 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8487 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 8488 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8489 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8490 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8491 " 7777777};"); 8492 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8493 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8494 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8495 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8496 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8497 " // Separating comment.\n" 8498 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8499 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8500 " // Leading comment\n" 8501 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8502 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8503 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8504 " 1, 1, 1, 1};", 8505 getLLVMStyleWithColumns(39)); 8506 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8507 " 1, 1, 1, 1};", 8508 getLLVMStyleWithColumns(38)); 8509 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 8510 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 8511 getLLVMStyleWithColumns(43)); 8512 verifyFormat( 8513 "static unsigned SomeValues[10][3] = {\n" 8514 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 8515 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 8516 verifyFormat("static auto fields = new vector<string>{\n" 8517 " \"aaaaaaaaaaaaa\",\n" 8518 " \"aaaaaaaaaaaaa\",\n" 8519 " \"aaaaaaaaaaaa\",\n" 8520 " \"aaaaaaaaaaaaaa\",\n" 8521 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8522 " \"aaaaaaaaaaaa\",\n" 8523 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8524 "};"); 8525 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 8526 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 8527 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 8528 " 3, cccccccccccccccccccccc};", 8529 getLLVMStyleWithColumns(60)); 8530 8531 // Trailing commas. 8532 verifyFormat("vector<int> x = {\n" 8533 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 8534 "};", 8535 getLLVMStyleWithColumns(39)); 8536 verifyFormat("vector<int> x = {\n" 8537 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 8538 "};", 8539 getLLVMStyleWithColumns(39)); 8540 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8541 " 1, 1, 1, 1,\n" 8542 " /**/ /**/};", 8543 getLLVMStyleWithColumns(39)); 8544 8545 // Trailing comment in the first line. 8546 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 8547 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 8548 " 111111111, 222222222, 3333333333, 444444444, //\n" 8549 " 11111111, 22222222, 333333333, 44444444};"); 8550 // Trailing comment in the last line. 8551 verifyFormat("int aaaaa[] = {\n" 8552 " 1, 2, 3, // comment\n" 8553 " 4, 5, 6 // comment\n" 8554 "};"); 8555 8556 // With nested lists, we should either format one item per line or all nested 8557 // lists one on line. 8558 // FIXME: For some nested lists, we can do better. 8559 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 8560 " {aaaaaaaaaaaaaaaaaaa},\n" 8561 " {aaaaaaaaaaaaaaaaaaaaa},\n" 8562 " {aaaaaaaaaaaaaaaaa}};", 8563 getLLVMStyleWithColumns(60)); 8564 verifyFormat( 8565 "SomeStruct my_struct_array = {\n" 8566 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 8567 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 8568 " {aaa, aaa},\n" 8569 " {aaa, aaa},\n" 8570 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 8571 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 8572 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 8573 8574 // No column layout should be used here. 8575 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 8576 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 8577 8578 verifyNoCrash("a<,"); 8579 8580 // No braced initializer here. 8581 verifyFormat("void f() {\n" 8582 " struct Dummy {};\n" 8583 " f(v);\n" 8584 "}"); 8585 8586 // Long lists should be formatted in columns even if they are nested. 8587 verifyFormat( 8588 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8589 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8590 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8591 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8592 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8593 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 8594 8595 // Allow "single-column" layout even if that violates the column limit. There 8596 // isn't going to be a better way. 8597 verifyFormat("std::vector<int> a = {\n" 8598 " aaaaaaaa,\n" 8599 " aaaaaaaa,\n" 8600 " aaaaaaaa,\n" 8601 " aaaaaaaa,\n" 8602 " aaaaaaaaaa,\n" 8603 " aaaaaaaa,\n" 8604 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 8605 getLLVMStyleWithColumns(30)); 8606 verifyFormat("vector<int> aaaa = {\n" 8607 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8608 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8609 " aaaaaa.aaaaaaa,\n" 8610 " aaaaaa.aaaaaaa,\n" 8611 " aaaaaa.aaaaaaa,\n" 8612 " aaaaaa.aaaaaaa,\n" 8613 "};"); 8614 8615 // Don't create hanging lists. 8616 verifyFormat("someFunction(Param, {List1, List2,\n" 8617 " List3});", 8618 getLLVMStyleWithColumns(35)); 8619 verifyFormat("someFunction(Param, Param,\n" 8620 " {List1, List2,\n" 8621 " List3});", 8622 getLLVMStyleWithColumns(35)); 8623 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 8624 " aaaaaaaaaaaaaaaaaaaaaaa);"); 8625 } 8626 8627 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 8628 FormatStyle DoNotMerge = getLLVMStyle(); 8629 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8630 8631 verifyFormat("void f() { return 42; }"); 8632 verifyFormat("void f() {\n" 8633 " return 42;\n" 8634 "}", 8635 DoNotMerge); 8636 verifyFormat("void f() {\n" 8637 " // Comment\n" 8638 "}"); 8639 verifyFormat("{\n" 8640 "#error {\n" 8641 " int a;\n" 8642 "}"); 8643 verifyFormat("{\n" 8644 " int a;\n" 8645 "#error {\n" 8646 "}"); 8647 verifyFormat("void f() {} // comment"); 8648 verifyFormat("void f() { int a; } // comment"); 8649 verifyFormat("void f() {\n" 8650 "} // comment", 8651 DoNotMerge); 8652 verifyFormat("void f() {\n" 8653 " int a;\n" 8654 "} // comment", 8655 DoNotMerge); 8656 verifyFormat("void f() {\n" 8657 "} // comment", 8658 getLLVMStyleWithColumns(15)); 8659 8660 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 8661 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 8662 8663 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 8664 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 8665 verifyFormat("class C {\n" 8666 " C()\n" 8667 " : iiiiiiii(nullptr),\n" 8668 " kkkkkkk(nullptr),\n" 8669 " mmmmmmm(nullptr),\n" 8670 " nnnnnnn(nullptr) {}\n" 8671 "};", 8672 getGoogleStyle()); 8673 8674 FormatStyle NoColumnLimit = getLLVMStyle(); 8675 NoColumnLimit.ColumnLimit = 0; 8676 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 8677 EXPECT_EQ("class C {\n" 8678 " A() : b(0) {}\n" 8679 "};", 8680 format("class C{A():b(0){}};", NoColumnLimit)); 8681 EXPECT_EQ("A()\n" 8682 " : b(0) {\n" 8683 "}", 8684 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 8685 8686 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 8687 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 8688 FormatStyle::SFS_None; 8689 EXPECT_EQ("A()\n" 8690 " : b(0) {\n" 8691 "}", 8692 format("A():b(0){}", DoNotMergeNoColumnLimit)); 8693 EXPECT_EQ("A()\n" 8694 " : b(0) {\n" 8695 "}", 8696 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 8697 8698 verifyFormat("#define A \\\n" 8699 " void f() { \\\n" 8700 " int i; \\\n" 8701 " }", 8702 getLLVMStyleWithColumns(20)); 8703 verifyFormat("#define A \\\n" 8704 " void f() { int i; }", 8705 getLLVMStyleWithColumns(21)); 8706 verifyFormat("#define A \\\n" 8707 " void f() { \\\n" 8708 " int i; \\\n" 8709 " } \\\n" 8710 " int j;", 8711 getLLVMStyleWithColumns(22)); 8712 verifyFormat("#define A \\\n" 8713 " void f() { int i; } \\\n" 8714 " int j;", 8715 getLLVMStyleWithColumns(23)); 8716 } 8717 8718 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 8719 FormatStyle MergeEmptyOnly = getLLVMStyle(); 8720 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8721 verifyFormat("class C {\n" 8722 " int f() {}\n" 8723 "};", 8724 MergeEmptyOnly); 8725 verifyFormat("class C {\n" 8726 " int f() {\n" 8727 " return 42;\n" 8728 " }\n" 8729 "};", 8730 MergeEmptyOnly); 8731 verifyFormat("int f() {}", MergeEmptyOnly); 8732 verifyFormat("int f() {\n" 8733 " return 42;\n" 8734 "}", 8735 MergeEmptyOnly); 8736 8737 // Also verify behavior when BraceWrapping.AfterFunction = true 8738 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8739 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 8740 verifyFormat("int f() {}", MergeEmptyOnly); 8741 verifyFormat("class C {\n" 8742 " int f() {}\n" 8743 "};", 8744 MergeEmptyOnly); 8745 } 8746 8747 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 8748 FormatStyle MergeInlineOnly = getLLVMStyle(); 8749 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8750 verifyFormat("class C {\n" 8751 " int f() { return 42; }\n" 8752 "};", 8753 MergeInlineOnly); 8754 verifyFormat("int f() {\n" 8755 " return 42;\n" 8756 "}", 8757 MergeInlineOnly); 8758 8759 // SFS_Inline implies SFS_Empty 8760 verifyFormat("class C {\n" 8761 " int f() {}\n" 8762 "};", 8763 MergeInlineOnly); 8764 verifyFormat("int f() {}", MergeInlineOnly); 8765 8766 // Also verify behavior when BraceWrapping.AfterFunction = true 8767 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8768 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8769 verifyFormat("class C {\n" 8770 " int f() { return 42; }\n" 8771 "};", 8772 MergeInlineOnly); 8773 verifyFormat("int f()\n" 8774 "{\n" 8775 " return 42;\n" 8776 "}", 8777 MergeInlineOnly); 8778 8779 // SFS_Inline implies SFS_Empty 8780 verifyFormat("int f() {}", MergeInlineOnly); 8781 verifyFormat("class C {\n" 8782 " int f() {}\n" 8783 "};", 8784 MergeInlineOnly); 8785 } 8786 8787 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8788 FormatStyle MergeInlineOnly = getLLVMStyle(); 8789 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8790 FormatStyle::SFS_InlineOnly; 8791 verifyFormat("class C {\n" 8792 " int f() { return 42; }\n" 8793 "};", 8794 MergeInlineOnly); 8795 verifyFormat("int f() {\n" 8796 " return 42;\n" 8797 "}", 8798 MergeInlineOnly); 8799 8800 // SFS_InlineOnly does not imply SFS_Empty 8801 verifyFormat("class C {\n" 8802 " int f() {}\n" 8803 "};", 8804 MergeInlineOnly); 8805 verifyFormat("int f() {\n" 8806 "}", 8807 MergeInlineOnly); 8808 8809 // Also verify behavior when BraceWrapping.AfterFunction = true 8810 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8811 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8812 verifyFormat("class C {\n" 8813 " int f() { return 42; }\n" 8814 "};", 8815 MergeInlineOnly); 8816 verifyFormat("int f()\n" 8817 "{\n" 8818 " return 42;\n" 8819 "}", 8820 MergeInlineOnly); 8821 8822 // SFS_InlineOnly does not imply SFS_Empty 8823 verifyFormat("int f()\n" 8824 "{\n" 8825 "}", 8826 MergeInlineOnly); 8827 verifyFormat("class C {\n" 8828 " int f() {}\n" 8829 "};", 8830 MergeInlineOnly); 8831 } 8832 8833 TEST_F(FormatTest, SplitEmptyFunction) { 8834 FormatStyle Style = getLLVMStyle(); 8835 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8836 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8837 Style.BraceWrapping.AfterFunction = true; 8838 Style.BraceWrapping.SplitEmptyFunction = false; 8839 Style.ColumnLimit = 40; 8840 8841 verifyFormat("int f()\n" 8842 "{}", 8843 Style); 8844 verifyFormat("int f()\n" 8845 "{\n" 8846 " return 42;\n" 8847 "}", 8848 Style); 8849 verifyFormat("int f()\n" 8850 "{\n" 8851 " // some comment\n" 8852 "}", 8853 Style); 8854 8855 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8856 verifyFormat("int f() {}", Style); 8857 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8858 "{}", 8859 Style); 8860 verifyFormat("int f()\n" 8861 "{\n" 8862 " return 0;\n" 8863 "}", 8864 Style); 8865 8866 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8867 verifyFormat("class Foo {\n" 8868 " int f() {}\n" 8869 "};\n", 8870 Style); 8871 verifyFormat("class Foo {\n" 8872 " int f() { return 0; }\n" 8873 "};\n", 8874 Style); 8875 verifyFormat("class Foo {\n" 8876 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8877 " {}\n" 8878 "};\n", 8879 Style); 8880 verifyFormat("class Foo {\n" 8881 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8882 " {\n" 8883 " return 0;\n" 8884 " }\n" 8885 "};\n", 8886 Style); 8887 8888 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8889 verifyFormat("int f() {}", Style); 8890 verifyFormat("int f() { return 0; }", Style); 8891 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8892 "{}", 8893 Style); 8894 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8895 "{\n" 8896 " return 0;\n" 8897 "}", 8898 Style); 8899 } 8900 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8901 FormatStyle Style = getLLVMStyle(); 8902 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8903 verifyFormat("#ifdef A\n" 8904 "int f() {}\n" 8905 "#else\n" 8906 "int g() {}\n" 8907 "#endif", 8908 Style); 8909 } 8910 8911 TEST_F(FormatTest, SplitEmptyClass) { 8912 FormatStyle Style = getLLVMStyle(); 8913 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8914 Style.BraceWrapping.AfterClass = true; 8915 Style.BraceWrapping.SplitEmptyRecord = false; 8916 8917 verifyFormat("class Foo\n" 8918 "{};", 8919 Style); 8920 verifyFormat("/* something */ class Foo\n" 8921 "{};", 8922 Style); 8923 verifyFormat("template <typename X> class Foo\n" 8924 "{};", 8925 Style); 8926 verifyFormat("class Foo\n" 8927 "{\n" 8928 " Foo();\n" 8929 "};", 8930 Style); 8931 verifyFormat("typedef class Foo\n" 8932 "{\n" 8933 "} Foo_t;", 8934 Style); 8935 } 8936 8937 TEST_F(FormatTest, SplitEmptyStruct) { 8938 FormatStyle Style = getLLVMStyle(); 8939 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8940 Style.BraceWrapping.AfterStruct = true; 8941 Style.BraceWrapping.SplitEmptyRecord = false; 8942 8943 verifyFormat("struct Foo\n" 8944 "{};", 8945 Style); 8946 verifyFormat("/* something */ struct Foo\n" 8947 "{};", 8948 Style); 8949 verifyFormat("template <typename X> struct Foo\n" 8950 "{};", 8951 Style); 8952 verifyFormat("struct Foo\n" 8953 "{\n" 8954 " Foo();\n" 8955 "};", 8956 Style); 8957 verifyFormat("typedef struct Foo\n" 8958 "{\n" 8959 "} Foo_t;", 8960 Style); 8961 // typedef struct Bar {} Bar_t; 8962 } 8963 8964 TEST_F(FormatTest, SplitEmptyUnion) { 8965 FormatStyle Style = getLLVMStyle(); 8966 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8967 Style.BraceWrapping.AfterUnion = true; 8968 Style.BraceWrapping.SplitEmptyRecord = false; 8969 8970 verifyFormat("union Foo\n" 8971 "{};", 8972 Style); 8973 verifyFormat("/* something */ union Foo\n" 8974 "{};", 8975 Style); 8976 verifyFormat("union Foo\n" 8977 "{\n" 8978 " A,\n" 8979 "};", 8980 Style); 8981 verifyFormat("typedef union Foo\n" 8982 "{\n" 8983 "} Foo_t;", 8984 Style); 8985 } 8986 8987 TEST_F(FormatTest, SplitEmptyNamespace) { 8988 FormatStyle Style = getLLVMStyle(); 8989 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8990 Style.BraceWrapping.AfterNamespace = true; 8991 Style.BraceWrapping.SplitEmptyNamespace = false; 8992 8993 verifyFormat("namespace Foo\n" 8994 "{};", 8995 Style); 8996 verifyFormat("/* something */ namespace Foo\n" 8997 "{};", 8998 Style); 8999 verifyFormat("inline namespace Foo\n" 9000 "{};", 9001 Style); 9002 verifyFormat("/* something */ inline namespace Foo\n" 9003 "{};", 9004 Style); 9005 verifyFormat("export namespace Foo\n" 9006 "{};", 9007 Style); 9008 verifyFormat("namespace Foo\n" 9009 "{\n" 9010 "void Bar();\n" 9011 "};", 9012 Style); 9013 } 9014 9015 TEST_F(FormatTest, NeverMergeShortRecords) { 9016 FormatStyle Style = getLLVMStyle(); 9017 9018 verifyFormat("class Foo {\n" 9019 " Foo();\n" 9020 "};", 9021 Style); 9022 verifyFormat("typedef class Foo {\n" 9023 " Foo();\n" 9024 "} Foo_t;", 9025 Style); 9026 verifyFormat("struct Foo {\n" 9027 " Foo();\n" 9028 "};", 9029 Style); 9030 verifyFormat("typedef struct Foo {\n" 9031 " Foo();\n" 9032 "} Foo_t;", 9033 Style); 9034 verifyFormat("union Foo {\n" 9035 " A,\n" 9036 "};", 9037 Style); 9038 verifyFormat("typedef union Foo {\n" 9039 " A,\n" 9040 "} Foo_t;", 9041 Style); 9042 verifyFormat("namespace Foo {\n" 9043 "void Bar();\n" 9044 "};", 9045 Style); 9046 9047 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9048 Style.BraceWrapping.AfterClass = true; 9049 Style.BraceWrapping.AfterStruct = true; 9050 Style.BraceWrapping.AfterUnion = true; 9051 Style.BraceWrapping.AfterNamespace = true; 9052 verifyFormat("class Foo\n" 9053 "{\n" 9054 " Foo();\n" 9055 "};", 9056 Style); 9057 verifyFormat("typedef class Foo\n" 9058 "{\n" 9059 " Foo();\n" 9060 "} Foo_t;", 9061 Style); 9062 verifyFormat("struct Foo\n" 9063 "{\n" 9064 " Foo();\n" 9065 "};", 9066 Style); 9067 verifyFormat("typedef struct Foo\n" 9068 "{\n" 9069 " Foo();\n" 9070 "} Foo_t;", 9071 Style); 9072 verifyFormat("union Foo\n" 9073 "{\n" 9074 " A,\n" 9075 "};", 9076 Style); 9077 verifyFormat("typedef union Foo\n" 9078 "{\n" 9079 " A,\n" 9080 "} Foo_t;", 9081 Style); 9082 verifyFormat("namespace Foo\n" 9083 "{\n" 9084 "void Bar();\n" 9085 "};", 9086 Style); 9087 } 9088 9089 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 9090 // Elaborate type variable declarations. 9091 verifyFormat("struct foo a = {bar};\nint n;"); 9092 verifyFormat("class foo a = {bar};\nint n;"); 9093 verifyFormat("union foo a = {bar};\nint n;"); 9094 9095 // Elaborate types inside function definitions. 9096 verifyFormat("struct foo f() {}\nint n;"); 9097 verifyFormat("class foo f() {}\nint n;"); 9098 verifyFormat("union foo f() {}\nint n;"); 9099 9100 // Templates. 9101 verifyFormat("template <class X> void f() {}\nint n;"); 9102 verifyFormat("template <struct X> void f() {}\nint n;"); 9103 verifyFormat("template <union X> void f() {}\nint n;"); 9104 9105 // Actual definitions... 9106 verifyFormat("struct {\n} n;"); 9107 verifyFormat( 9108 "template <template <class T, class Y>, class Z> class X {\n} n;"); 9109 verifyFormat("union Z {\n int n;\n} x;"); 9110 verifyFormat("class MACRO Z {\n} n;"); 9111 verifyFormat("class MACRO(X) Z {\n} n;"); 9112 verifyFormat("class __attribute__(X) Z {\n} n;"); 9113 verifyFormat("class __declspec(X) Z {\n} n;"); 9114 verifyFormat("class A##B##C {\n} n;"); 9115 verifyFormat("class alignas(16) Z {\n} n;"); 9116 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 9117 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 9118 9119 // Redefinition from nested context: 9120 verifyFormat("class A::B::C {\n} n;"); 9121 9122 // Template definitions. 9123 verifyFormat( 9124 "template <typename F>\n" 9125 "Matcher(const Matcher<F> &Other,\n" 9126 " typename enable_if_c<is_base_of<F, T>::value &&\n" 9127 " !is_same<F, T>::value>::type * = 0)\n" 9128 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 9129 9130 // FIXME: This is still incorrectly handled at the formatter side. 9131 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 9132 verifyFormat("int i = SomeFunction(a<b, a> b);"); 9133 9134 // FIXME: 9135 // This now gets parsed incorrectly as class definition. 9136 // verifyFormat("class A<int> f() {\n}\nint n;"); 9137 9138 // Elaborate types where incorrectly parsing the structural element would 9139 // break the indent. 9140 verifyFormat("if (true)\n" 9141 " class X x;\n" 9142 "else\n" 9143 " f();\n"); 9144 9145 // This is simply incomplete. Formatting is not important, but must not crash. 9146 verifyFormat("class A:"); 9147 } 9148 9149 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 9150 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 9151 format("#error Leave all white!!!!! space* alone!\n")); 9152 EXPECT_EQ( 9153 "#warning Leave all white!!!!! space* alone!\n", 9154 format("#warning Leave all white!!!!! space* alone!\n")); 9155 EXPECT_EQ("#error 1", format(" # error 1")); 9156 EXPECT_EQ("#warning 1", format(" # warning 1")); 9157 } 9158 9159 TEST_F(FormatTest, FormatHashIfExpressions) { 9160 verifyFormat("#if AAAA && BBBB"); 9161 verifyFormat("#if (AAAA && BBBB)"); 9162 verifyFormat("#elif (AAAA && BBBB)"); 9163 // FIXME: Come up with a better indentation for #elif. 9164 verifyFormat( 9165 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 9166 " defined(BBBBBBBB)\n" 9167 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 9168 " defined(BBBBBBBB)\n" 9169 "#endif", 9170 getLLVMStyleWithColumns(65)); 9171 } 9172 9173 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 9174 FormatStyle AllowsMergedIf = getGoogleStyle(); 9175 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 9176 FormatStyle::SIS_WithoutElse; 9177 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 9178 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 9179 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 9180 EXPECT_EQ("if (true) return 42;", 9181 format("if (true)\nreturn 42;", AllowsMergedIf)); 9182 FormatStyle ShortMergedIf = AllowsMergedIf; 9183 ShortMergedIf.ColumnLimit = 25; 9184 verifyFormat("#define A \\\n" 9185 " if (true) return 42;", 9186 ShortMergedIf); 9187 verifyFormat("#define A \\\n" 9188 " f(); \\\n" 9189 " if (true)\n" 9190 "#define B", 9191 ShortMergedIf); 9192 verifyFormat("#define A \\\n" 9193 " f(); \\\n" 9194 " if (true)\n" 9195 "g();", 9196 ShortMergedIf); 9197 verifyFormat("{\n" 9198 "#ifdef A\n" 9199 " // Comment\n" 9200 " if (true) continue;\n" 9201 "#endif\n" 9202 " // Comment\n" 9203 " if (true) continue;\n" 9204 "}", 9205 ShortMergedIf); 9206 ShortMergedIf.ColumnLimit = 33; 9207 verifyFormat("#define A \\\n" 9208 " if constexpr (true) return 42;", 9209 ShortMergedIf); 9210 verifyFormat("#define A \\\n" 9211 " if CONSTEXPR (true) return 42;", 9212 ShortMergedIf); 9213 ShortMergedIf.ColumnLimit = 29; 9214 verifyFormat("#define A \\\n" 9215 " if (aaaaaaaaaa) return 1; \\\n" 9216 " return 2;", 9217 ShortMergedIf); 9218 ShortMergedIf.ColumnLimit = 28; 9219 verifyFormat("#define A \\\n" 9220 " if (aaaaaaaaaa) \\\n" 9221 " return 1; \\\n" 9222 " return 2;", 9223 ShortMergedIf); 9224 verifyFormat("#define A \\\n" 9225 " if constexpr (aaaaaaa) \\\n" 9226 " return 1; \\\n" 9227 " return 2;", 9228 ShortMergedIf); 9229 verifyFormat("#define A \\\n" 9230 " if CONSTEXPR (aaaaaaa) \\\n" 9231 " return 1; \\\n" 9232 " return 2;", 9233 ShortMergedIf); 9234 } 9235 9236 TEST_F(FormatTest, FormatStarDependingOnContext) { 9237 verifyFormat("void f(int *a);"); 9238 verifyFormat("void f() { f(fint * b); }"); 9239 verifyFormat("class A {\n void f(int *a);\n};"); 9240 verifyFormat("class A {\n int *a;\n};"); 9241 verifyFormat("namespace a {\n" 9242 "namespace b {\n" 9243 "class A {\n" 9244 " void f() {}\n" 9245 " int *a;\n" 9246 "};\n" 9247 "} // namespace b\n" 9248 "} // namespace a"); 9249 } 9250 9251 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 9252 verifyFormat("while"); 9253 verifyFormat("operator"); 9254 } 9255 9256 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 9257 // This code would be painfully slow to format if we didn't skip it. 9258 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 9259 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9260 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9261 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9262 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9263 "A(1, 1)\n" 9264 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 9265 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9266 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9267 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9268 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9269 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9270 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9271 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9272 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9273 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 9274 // Deeply nested part is untouched, rest is formatted. 9275 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 9276 format(std::string("int i;\n") + Code + "int j;\n", 9277 getLLVMStyle(), SC_ExpectIncomplete)); 9278 } 9279 9280 //===----------------------------------------------------------------------===// 9281 // Objective-C tests. 9282 //===----------------------------------------------------------------------===// 9283 9284 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 9285 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 9286 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 9287 format("-(NSUInteger)indexOfObject:(id)anObject;")); 9288 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 9289 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 9290 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 9291 format("-(NSInteger)Method3:(id)anObject;")); 9292 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 9293 format("-(NSInteger)Method4:(id)anObject;")); 9294 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 9295 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 9296 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 9297 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 9298 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9299 "forAllCells:(BOOL)flag;", 9300 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9301 "forAllCells:(BOOL)flag;")); 9302 9303 // Very long objectiveC method declaration. 9304 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 9305 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 9306 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 9307 " inRange:(NSRange)range\n" 9308 " outRange:(NSRange)out_range\n" 9309 " outRange1:(NSRange)out_range1\n" 9310 " outRange2:(NSRange)out_range2\n" 9311 " outRange3:(NSRange)out_range3\n" 9312 " outRange4:(NSRange)out_range4\n" 9313 " outRange5:(NSRange)out_range5\n" 9314 " outRange6:(NSRange)out_range6\n" 9315 " outRange7:(NSRange)out_range7\n" 9316 " outRange8:(NSRange)out_range8\n" 9317 " outRange9:(NSRange)out_range9;"); 9318 9319 // When the function name has to be wrapped. 9320 FormatStyle Style = getLLVMStyle(); 9321 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 9322 // and always indents instead. 9323 Style.IndentWrappedFunctionNames = false; 9324 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9325 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 9326 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 9327 "}", 9328 Style); 9329 Style.IndentWrappedFunctionNames = true; 9330 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9331 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 9332 " anotherName:(NSString)dddddddddddddd {\n" 9333 "}", 9334 Style); 9335 9336 verifyFormat("- (int)sum:(vector<int>)numbers;"); 9337 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 9338 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 9339 // protocol lists (but not for template classes): 9340 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 9341 9342 verifyFormat("- (int (*)())foo:(int (*)())f;"); 9343 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 9344 9345 // If there's no return type (very rare in practice!), LLVM and Google style 9346 // agree. 9347 verifyFormat("- foo;"); 9348 verifyFormat("- foo:(int)f;"); 9349 verifyGoogleFormat("- foo:(int)foo;"); 9350 } 9351 9352 TEST_F(FormatTest, BreaksStringLiterals) { 9353 EXPECT_EQ("\"some text \"\n" 9354 "\"other\";", 9355 format("\"some text other\";", getLLVMStyleWithColumns(12))); 9356 EXPECT_EQ("\"some text \"\n" 9357 "\"other\";", 9358 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 9359 EXPECT_EQ( 9360 "#define A \\\n" 9361 " \"some \" \\\n" 9362 " \"text \" \\\n" 9363 " \"other\";", 9364 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 9365 EXPECT_EQ( 9366 "#define A \\\n" 9367 " \"so \" \\\n" 9368 " \"text \" \\\n" 9369 " \"other\";", 9370 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 9371 9372 EXPECT_EQ("\"some text\"", 9373 format("\"some text\"", getLLVMStyleWithColumns(1))); 9374 EXPECT_EQ("\"some text\"", 9375 format("\"some text\"", getLLVMStyleWithColumns(11))); 9376 EXPECT_EQ("\"some \"\n" 9377 "\"text\"", 9378 format("\"some text\"", getLLVMStyleWithColumns(10))); 9379 EXPECT_EQ("\"some \"\n" 9380 "\"text\"", 9381 format("\"some text\"", getLLVMStyleWithColumns(7))); 9382 EXPECT_EQ("\"some\"\n" 9383 "\" tex\"\n" 9384 "\"t\"", 9385 format("\"some text\"", getLLVMStyleWithColumns(6))); 9386 EXPECT_EQ("\"some\"\n" 9387 "\" tex\"\n" 9388 "\" and\"", 9389 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 9390 EXPECT_EQ("\"some\"\n" 9391 "\"/tex\"\n" 9392 "\"/and\"", 9393 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 9394 9395 EXPECT_EQ("variable =\n" 9396 " \"long string \"\n" 9397 " \"literal\";", 9398 format("variable = \"long string literal\";", 9399 getLLVMStyleWithColumns(20))); 9400 9401 EXPECT_EQ("variable = f(\n" 9402 " \"long string \"\n" 9403 " \"literal\",\n" 9404 " short,\n" 9405 " loooooooooooooooooooong);", 9406 format("variable = f(\"long string literal\", short, " 9407 "loooooooooooooooooooong);", 9408 getLLVMStyleWithColumns(20))); 9409 9410 EXPECT_EQ( 9411 "f(g(\"long string \"\n" 9412 " \"literal\"),\n" 9413 " b);", 9414 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 9415 EXPECT_EQ("f(g(\"long string \"\n" 9416 " \"literal\",\n" 9417 " a),\n" 9418 " b);", 9419 format("f(g(\"long string literal\", a), b);", 9420 getLLVMStyleWithColumns(20))); 9421 EXPECT_EQ( 9422 "f(\"one two\".split(\n" 9423 " variable));", 9424 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 9425 EXPECT_EQ("f(\"one two three four five six \"\n" 9426 " \"seven\".split(\n" 9427 " really_looooong_variable));", 9428 format("f(\"one two three four five six seven\"." 9429 "split(really_looooong_variable));", 9430 getLLVMStyleWithColumns(33))); 9431 9432 EXPECT_EQ("f(\"some \"\n" 9433 " \"text\",\n" 9434 " other);", 9435 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 9436 9437 // Only break as a last resort. 9438 verifyFormat( 9439 "aaaaaaaaaaaaaaaaaaaa(\n" 9440 " aaaaaaaaaaaaaaaaaaaa,\n" 9441 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 9442 9443 EXPECT_EQ("\"splitmea\"\n" 9444 "\"trandomp\"\n" 9445 "\"oint\"", 9446 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 9447 9448 EXPECT_EQ("\"split/\"\n" 9449 "\"pathat/\"\n" 9450 "\"slashes\"", 9451 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9452 9453 EXPECT_EQ("\"split/\"\n" 9454 "\"pathat/\"\n" 9455 "\"slashes\"", 9456 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9457 EXPECT_EQ("\"split at \"\n" 9458 "\"spaces/at/\"\n" 9459 "\"slashes.at.any$\"\n" 9460 "\"non-alphanumeric%\"\n" 9461 "\"1111111111characte\"\n" 9462 "\"rs\"", 9463 format("\"split at " 9464 "spaces/at/" 9465 "slashes.at." 9466 "any$non-" 9467 "alphanumeric%" 9468 "1111111111characte" 9469 "rs\"", 9470 getLLVMStyleWithColumns(20))); 9471 9472 // Verify that splitting the strings understands 9473 // Style::AlwaysBreakBeforeMultilineStrings. 9474 EXPECT_EQ("aaaaaaaaaaaa(\n" 9475 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 9476 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 9477 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 9478 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9479 "aaaaaaaaaaaaaaaaaaaaaa\");", 9480 getGoogleStyle())); 9481 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9482 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 9483 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 9484 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9485 "aaaaaaaaaaaaaaaaaaaaaa\";", 9486 getGoogleStyle())); 9487 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9488 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9489 format("llvm::outs() << " 9490 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 9491 "aaaaaaaaaaaaaaaaaaa\";")); 9492 EXPECT_EQ("ffff(\n" 9493 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9494 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9495 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 9496 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9497 getGoogleStyle())); 9498 9499 FormatStyle Style = getLLVMStyleWithColumns(12); 9500 Style.BreakStringLiterals = false; 9501 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 9502 9503 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 9504 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9505 EXPECT_EQ("#define A \\\n" 9506 " \"some \" \\\n" 9507 " \"text \" \\\n" 9508 " \"other\";", 9509 format("#define A \"some text other\";", AlignLeft)); 9510 } 9511 9512 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 9513 EXPECT_EQ("C a = \"some more \"\n" 9514 " \"text\";", 9515 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 9516 } 9517 9518 TEST_F(FormatTest, FullyRemoveEmptyLines) { 9519 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 9520 NoEmptyLines.MaxEmptyLinesToKeep = 0; 9521 EXPECT_EQ("int i = a(b());", 9522 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 9523 } 9524 9525 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 9526 EXPECT_EQ( 9527 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9528 "(\n" 9529 " \"x\t\");", 9530 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9531 "aaaaaaa(" 9532 "\"x\t\");")); 9533 } 9534 9535 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 9536 EXPECT_EQ( 9537 "u8\"utf8 string \"\n" 9538 "u8\"literal\";", 9539 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 9540 EXPECT_EQ( 9541 "u\"utf16 string \"\n" 9542 "u\"literal\";", 9543 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 9544 EXPECT_EQ( 9545 "U\"utf32 string \"\n" 9546 "U\"literal\";", 9547 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 9548 EXPECT_EQ("L\"wide string \"\n" 9549 "L\"literal\";", 9550 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 9551 EXPECT_EQ("@\"NSString \"\n" 9552 "@\"literal\";", 9553 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 9554 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 9555 9556 // This input makes clang-format try to split the incomplete unicode escape 9557 // sequence, which used to lead to a crasher. 9558 verifyNoCrash( 9559 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 9560 getLLVMStyleWithColumns(60)); 9561 } 9562 9563 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 9564 FormatStyle Style = getGoogleStyleWithColumns(15); 9565 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 9566 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 9567 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 9568 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 9569 EXPECT_EQ("u8R\"x(raw literal)x\";", 9570 format("u8R\"x(raw literal)x\";", Style)); 9571 } 9572 9573 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 9574 FormatStyle Style = getLLVMStyleWithColumns(20); 9575 EXPECT_EQ( 9576 "_T(\"aaaaaaaaaaaaaa\")\n" 9577 "_T(\"aaaaaaaaaaaaaa\")\n" 9578 "_T(\"aaaaaaaaaaaa\")", 9579 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 9580 EXPECT_EQ("f(x,\n" 9581 " _T(\"aaaaaaaaaaaa\")\n" 9582 " _T(\"aaa\"),\n" 9583 " z);", 9584 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 9585 9586 // FIXME: Handle embedded spaces in one iteration. 9587 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 9588 // "_T(\"aaaaaaaaaaaaa\")\n" 9589 // "_T(\"aaaaaaaaaaaaa\")\n" 9590 // "_T(\"a\")", 9591 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9592 // getLLVMStyleWithColumns(20))); 9593 EXPECT_EQ( 9594 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9595 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 9596 EXPECT_EQ("f(\n" 9597 "#if !TEST\n" 9598 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9599 "#endif\n" 9600 ");", 9601 format("f(\n" 9602 "#if !TEST\n" 9603 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9604 "#endif\n" 9605 ");")); 9606 EXPECT_EQ("f(\n" 9607 "\n" 9608 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 9609 format("f(\n" 9610 "\n" 9611 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 9612 } 9613 9614 TEST_F(FormatTest, BreaksStringLiteralOperands) { 9615 // In a function call with two operands, the second can be broken with no line 9616 // break before it. 9617 EXPECT_EQ( 9618 "func(a, \"long long \"\n" 9619 " \"long long\");", 9620 format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24))); 9621 // In a function call with three operands, the second must be broken with a 9622 // line break before it. 9623 EXPECT_EQ("func(a,\n" 9624 " \"long long long \"\n" 9625 " \"long\",\n" 9626 " c);", 9627 format("func(a, \"long long long long\", c);", 9628 getLLVMStyleWithColumns(24))); 9629 // In a function call with three operands, the third must be broken with a 9630 // line break before it. 9631 EXPECT_EQ("func(a, b,\n" 9632 " \"long long long \"\n" 9633 " \"long\");", 9634 format("func(a, b, \"long long long long\");", 9635 getLLVMStyleWithColumns(24))); 9636 // In a function call with three operands, both the second and the third must 9637 // be broken with a line break before them. 9638 EXPECT_EQ("func(a,\n" 9639 " \"long long long \"\n" 9640 " \"long\",\n" 9641 " \"long long long \"\n" 9642 " \"long\");", 9643 format("func(a, \"long long long long\", \"long long long long\");", 9644 getLLVMStyleWithColumns(24))); 9645 // In a chain of << with two operands, the second can be broken with no line 9646 // break before it. 9647 EXPECT_EQ("a << \"line line \"\n" 9648 " \"line\";", 9649 format("a << \"line line line\";", getLLVMStyleWithColumns(20))); 9650 // In a chain of << with three operands, the second can be broken with no line 9651 // break before it. 9652 EXPECT_EQ( 9653 "abcde << \"line \"\n" 9654 " \"line line\"\n" 9655 " << c;", 9656 format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20))); 9657 // In a chain of << with three operands, the third must be broken with a line 9658 // break before it. 9659 EXPECT_EQ( 9660 "a << b\n" 9661 " << \"line line \"\n" 9662 " \"line\";", 9663 format("a << b << \"line line line\";", getLLVMStyleWithColumns(20))); 9664 // In a chain of << with three operands, the second can be broken with no line 9665 // break before it and the third must be broken with a line break before it. 9666 EXPECT_EQ("abcd << \"line line \"\n" 9667 " \"line\"\n" 9668 " << \"line line \"\n" 9669 " \"line\";", 9670 format("abcd << \"line line line\" << \"line line line\";", 9671 getLLVMStyleWithColumns(20))); 9672 // In a chain of binary operators with two operands, the second can be broken 9673 // with no line break before it. 9674 EXPECT_EQ( 9675 "abcd + \"line line \"\n" 9676 " \"line line\";", 9677 format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20))); 9678 // In a chain of binary operators with three operands, the second must be 9679 // broken with a line break before it. 9680 EXPECT_EQ("abcd +\n" 9681 " \"line line \"\n" 9682 " \"line line\" +\n" 9683 " e;", 9684 format("abcd + \"line line line line\" + e;", 9685 getLLVMStyleWithColumns(20))); 9686 // In a function call with two operands, with AlignAfterOpenBracket enabled, 9687 // the first must be broken with a line break before it. 9688 FormatStyle Style = getLLVMStyleWithColumns(25); 9689 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 9690 EXPECT_EQ("someFunction(\n" 9691 " \"long long long \"\n" 9692 " \"long\",\n" 9693 " a);", 9694 format("someFunction(\"long long long long\", a);", Style)); 9695 } 9696 9697 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 9698 EXPECT_EQ( 9699 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9700 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9701 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9702 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9703 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9704 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 9705 } 9706 9707 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 9708 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 9709 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 9710 EXPECT_EQ("fffffffffff(g(R\"x(\n" 9711 "multiline raw string literal xxxxxxxxxxxxxx\n" 9712 ")x\",\n" 9713 " a),\n" 9714 " b);", 9715 format("fffffffffff(g(R\"x(\n" 9716 "multiline raw string literal xxxxxxxxxxxxxx\n" 9717 ")x\", a), b);", 9718 getGoogleStyleWithColumns(20))); 9719 EXPECT_EQ("fffffffffff(\n" 9720 " g(R\"x(qqq\n" 9721 "multiline raw string literal xxxxxxxxxxxxxx\n" 9722 ")x\",\n" 9723 " a),\n" 9724 " b);", 9725 format("fffffffffff(g(R\"x(qqq\n" 9726 "multiline raw string literal xxxxxxxxxxxxxx\n" 9727 ")x\", a), b);", 9728 getGoogleStyleWithColumns(20))); 9729 9730 EXPECT_EQ("fffffffffff(R\"x(\n" 9731 "multiline raw string literal xxxxxxxxxxxxxx\n" 9732 ")x\");", 9733 format("fffffffffff(R\"x(\n" 9734 "multiline raw string literal xxxxxxxxxxxxxx\n" 9735 ")x\");", 9736 getGoogleStyleWithColumns(20))); 9737 EXPECT_EQ("fffffffffff(R\"x(\n" 9738 "multiline raw string literal xxxxxxxxxxxxxx\n" 9739 ")x\" + bbbbbb);", 9740 format("fffffffffff(R\"x(\n" 9741 "multiline raw string literal xxxxxxxxxxxxxx\n" 9742 ")x\" + bbbbbb);", 9743 getGoogleStyleWithColumns(20))); 9744 EXPECT_EQ("fffffffffff(\n" 9745 " R\"x(\n" 9746 "multiline raw string literal xxxxxxxxxxxxxx\n" 9747 ")x\" +\n" 9748 " bbbbbb);", 9749 format("fffffffffff(\n" 9750 " R\"x(\n" 9751 "multiline raw string literal xxxxxxxxxxxxxx\n" 9752 ")x\" + bbbbbb);", 9753 getGoogleStyleWithColumns(20))); 9754 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 9755 format("fffffffffff(\n" 9756 " R\"(single line raw string)\" + bbbbbb);")); 9757 } 9758 9759 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 9760 verifyFormat("string a = \"unterminated;"); 9761 EXPECT_EQ("function(\"unterminated,\n" 9762 " OtherParameter);", 9763 format("function( \"unterminated,\n" 9764 " OtherParameter);")); 9765 } 9766 9767 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9768 FormatStyle Style = getLLVMStyle(); 9769 Style.Standard = FormatStyle::LS_Cpp03; 9770 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9771 format("#define x(_a) printf(\"foo\"_a);", Style)); 9772 } 9773 9774 TEST_F(FormatTest, CppLexVersion) { 9775 FormatStyle Style = getLLVMStyle(); 9776 // Formatting of x * y differs if x is a type. 9777 verifyFormat("void foo() { MACRO(a * b); }", Style); 9778 verifyFormat("void foo() { MACRO(int *b); }", Style); 9779 9780 // LLVM style uses latest lexer. 9781 verifyFormat("void foo() { MACRO(char8_t *b); }", Style); 9782 Style.Standard = FormatStyle::LS_Cpp17; 9783 // But in c++17, char8_t isn't a keyword. 9784 verifyFormat("void foo() { MACRO(char8_t * b); }", Style); 9785 } 9786 9787 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9788 9789 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9790 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9791 " \"ddeeefff\");", 9792 format("someFunction(\"aaabbbcccdddeeefff\");", 9793 getLLVMStyleWithColumns(25))); 9794 EXPECT_EQ("someFunction1234567890(\n" 9795 " \"aaabbbcccdddeeefff\");", 9796 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9797 getLLVMStyleWithColumns(26))); 9798 EXPECT_EQ("someFunction1234567890(\n" 9799 " \"aaabbbcccdddeeeff\"\n" 9800 " \"f\");", 9801 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9802 getLLVMStyleWithColumns(25))); 9803 EXPECT_EQ("someFunction1234567890(\n" 9804 " \"aaabbbcccdddeeeff\"\n" 9805 " \"f\");", 9806 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9807 getLLVMStyleWithColumns(24))); 9808 EXPECT_EQ("someFunction(\n" 9809 " \"aaabbbcc ddde \"\n" 9810 " \"efff\");", 9811 format("someFunction(\"aaabbbcc ddde efff\");", 9812 getLLVMStyleWithColumns(25))); 9813 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9814 " \"ddeeefff\");", 9815 format("someFunction(\"aaabbbccc ddeeefff\");", 9816 getLLVMStyleWithColumns(25))); 9817 EXPECT_EQ("someFunction1234567890(\n" 9818 " \"aaabb \"\n" 9819 " \"cccdddeeefff\");", 9820 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9821 getLLVMStyleWithColumns(25))); 9822 EXPECT_EQ("#define A \\\n" 9823 " string s = \\\n" 9824 " \"123456789\" \\\n" 9825 " \"0\"; \\\n" 9826 " int i;", 9827 format("#define A string s = \"1234567890\"; int i;", 9828 getLLVMStyleWithColumns(20))); 9829 EXPECT_EQ("someFunction(\n" 9830 " \"aaabbbcc \"\n" 9831 " \"dddeeefff\");", 9832 format("someFunction(\"aaabbbcc dddeeefff\");", 9833 getLLVMStyleWithColumns(25))); 9834 } 9835 9836 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9837 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9838 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9839 EXPECT_EQ("\"test\"\n" 9840 "\"\\n\"", 9841 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9842 EXPECT_EQ("\"tes\\\\\"\n" 9843 "\"n\"", 9844 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9845 EXPECT_EQ("\"\\\\\\\\\"\n" 9846 "\"\\n\"", 9847 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9848 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9849 EXPECT_EQ("\"\\uff01\"\n" 9850 "\"test\"", 9851 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9852 EXPECT_EQ("\"\\Uff01ff02\"", 9853 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9854 EXPECT_EQ("\"\\x000000000001\"\n" 9855 "\"next\"", 9856 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9857 EXPECT_EQ("\"\\x000000000001next\"", 9858 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9859 EXPECT_EQ("\"\\x000000000001\"", 9860 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9861 EXPECT_EQ("\"test\"\n" 9862 "\"\\000000\"\n" 9863 "\"000001\"", 9864 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9865 EXPECT_EQ("\"test\\000\"\n" 9866 "\"00000000\"\n" 9867 "\"1\"", 9868 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9869 } 9870 9871 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9872 verifyFormat("void f() {\n" 9873 " return g() {}\n" 9874 " void h() {}"); 9875 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9876 "g();\n" 9877 "}"); 9878 } 9879 9880 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9881 verifyFormat( 9882 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9883 } 9884 9885 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9886 verifyFormat("class X {\n" 9887 " void f() {\n" 9888 " }\n" 9889 "};", 9890 getLLVMStyleWithColumns(12)); 9891 } 9892 9893 TEST_F(FormatTest, ConfigurableIndentWidth) { 9894 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9895 EightIndent.IndentWidth = 8; 9896 EightIndent.ContinuationIndentWidth = 8; 9897 verifyFormat("void f() {\n" 9898 " someFunction();\n" 9899 " if (true) {\n" 9900 " f();\n" 9901 " }\n" 9902 "}", 9903 EightIndent); 9904 verifyFormat("class X {\n" 9905 " void f() {\n" 9906 " }\n" 9907 "};", 9908 EightIndent); 9909 verifyFormat("int x[] = {\n" 9910 " call(),\n" 9911 " call()};", 9912 EightIndent); 9913 } 9914 9915 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9916 verifyFormat("double\n" 9917 "f();", 9918 getLLVMStyleWithColumns(8)); 9919 } 9920 9921 TEST_F(FormatTest, ConfigurableUseOfTab) { 9922 FormatStyle Tab = getLLVMStyleWithColumns(42); 9923 Tab.IndentWidth = 8; 9924 Tab.UseTab = FormatStyle::UT_Always; 9925 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9926 9927 EXPECT_EQ("if (aaaaaaaa && // q\n" 9928 " bb)\t\t// w\n" 9929 "\t;", 9930 format("if (aaaaaaaa &&// q\n" 9931 "bb)// w\n" 9932 ";", 9933 Tab)); 9934 EXPECT_EQ("if (aaa && bbb) // w\n" 9935 "\t;", 9936 format("if(aaa&&bbb)// w\n" 9937 ";", 9938 Tab)); 9939 9940 verifyFormat("class X {\n" 9941 "\tvoid f() {\n" 9942 "\t\tsomeFunction(parameter1,\n" 9943 "\t\t\t parameter2);\n" 9944 "\t}\n" 9945 "};", 9946 Tab); 9947 verifyFormat("#define A \\\n" 9948 "\tvoid f() { \\\n" 9949 "\t\tsomeFunction( \\\n" 9950 "\t\t parameter1, \\\n" 9951 "\t\t parameter2); \\\n" 9952 "\t}", 9953 Tab); 9954 verifyFormat("int a;\t // x\n" 9955 "int bbbbbbbb; // x\n", 9956 Tab); 9957 9958 Tab.TabWidth = 4; 9959 Tab.IndentWidth = 8; 9960 verifyFormat("class TabWidth4Indent8 {\n" 9961 "\t\tvoid f() {\n" 9962 "\t\t\t\tsomeFunction(parameter1,\n" 9963 "\t\t\t\t\t\t\t parameter2);\n" 9964 "\t\t}\n" 9965 "};", 9966 Tab); 9967 9968 Tab.TabWidth = 4; 9969 Tab.IndentWidth = 4; 9970 verifyFormat("class TabWidth4Indent4 {\n" 9971 "\tvoid f() {\n" 9972 "\t\tsomeFunction(parameter1,\n" 9973 "\t\t\t\t\t parameter2);\n" 9974 "\t}\n" 9975 "};", 9976 Tab); 9977 9978 Tab.TabWidth = 8; 9979 Tab.IndentWidth = 4; 9980 verifyFormat("class TabWidth8Indent4 {\n" 9981 " void f() {\n" 9982 "\tsomeFunction(parameter1,\n" 9983 "\t\t parameter2);\n" 9984 " }\n" 9985 "};", 9986 Tab); 9987 9988 Tab.TabWidth = 8; 9989 Tab.IndentWidth = 8; 9990 EXPECT_EQ("/*\n" 9991 "\t a\t\tcomment\n" 9992 "\t in multiple lines\n" 9993 " */", 9994 format(" /*\t \t \n" 9995 " \t \t a\t\tcomment\t \t\n" 9996 " \t \t in multiple lines\t\n" 9997 " \t */", 9998 Tab)); 9999 10000 Tab.UseTab = FormatStyle::UT_ForIndentation; 10001 verifyFormat("{\n" 10002 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10003 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10004 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10005 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10006 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10007 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10008 "};", 10009 Tab); 10010 verifyFormat("enum AA {\n" 10011 "\ta1, // Force multiple lines\n" 10012 "\ta2,\n" 10013 "\ta3\n" 10014 "};", 10015 Tab); 10016 EXPECT_EQ("if (aaaaaaaa && // q\n" 10017 " bb) // w\n" 10018 "\t;", 10019 format("if (aaaaaaaa &&// q\n" 10020 "bb)// w\n" 10021 ";", 10022 Tab)); 10023 verifyFormat("class X {\n" 10024 "\tvoid f() {\n" 10025 "\t\tsomeFunction(parameter1,\n" 10026 "\t\t parameter2);\n" 10027 "\t}\n" 10028 "};", 10029 Tab); 10030 verifyFormat("{\n" 10031 "\tQ(\n" 10032 "\t {\n" 10033 "\t\t int a;\n" 10034 "\t\t someFunction(aaaaaaaa,\n" 10035 "\t\t bbbbbbb);\n" 10036 "\t },\n" 10037 "\t p);\n" 10038 "}", 10039 Tab); 10040 EXPECT_EQ("{\n" 10041 "\t/* aaaa\n" 10042 "\t bbbb */\n" 10043 "}", 10044 format("{\n" 10045 "/* aaaa\n" 10046 " bbbb */\n" 10047 "}", 10048 Tab)); 10049 EXPECT_EQ("{\n" 10050 "\t/*\n" 10051 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10052 "\t bbbbbbbbbbbbb\n" 10053 "\t*/\n" 10054 "}", 10055 format("{\n" 10056 "/*\n" 10057 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10058 "*/\n" 10059 "}", 10060 Tab)); 10061 EXPECT_EQ("{\n" 10062 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10063 "\t// bbbbbbbbbbbbb\n" 10064 "}", 10065 format("{\n" 10066 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10067 "}", 10068 Tab)); 10069 EXPECT_EQ("{\n" 10070 "\t/*\n" 10071 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10072 "\t bbbbbbbbbbbbb\n" 10073 "\t*/\n" 10074 "}", 10075 format("{\n" 10076 "\t/*\n" 10077 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10078 "\t*/\n" 10079 "}", 10080 Tab)); 10081 EXPECT_EQ("{\n" 10082 "\t/*\n" 10083 "\n" 10084 "\t*/\n" 10085 "}", 10086 format("{\n" 10087 "\t/*\n" 10088 "\n" 10089 "\t*/\n" 10090 "}", 10091 Tab)); 10092 EXPECT_EQ("{\n" 10093 "\t/*\n" 10094 " asdf\n" 10095 "\t*/\n" 10096 "}", 10097 format("{\n" 10098 "\t/*\n" 10099 " asdf\n" 10100 "\t*/\n" 10101 "}", 10102 Tab)); 10103 10104 Tab.UseTab = FormatStyle::UT_Never; 10105 EXPECT_EQ("/*\n" 10106 " a\t\tcomment\n" 10107 " in multiple lines\n" 10108 " */", 10109 format(" /*\t \t \n" 10110 " \t \t a\t\tcomment\t \t\n" 10111 " \t \t in multiple lines\t\n" 10112 " \t */", 10113 Tab)); 10114 EXPECT_EQ("/* some\n" 10115 " comment */", 10116 format(" \t \t /* some\n" 10117 " \t \t comment */", 10118 Tab)); 10119 EXPECT_EQ("int a; /* some\n" 10120 " comment */", 10121 format(" \t \t int a; /* some\n" 10122 " \t \t comment */", 10123 Tab)); 10124 10125 EXPECT_EQ("int a; /* some\n" 10126 "comment */", 10127 format(" \t \t int\ta; /* some\n" 10128 " \t \t comment */", 10129 Tab)); 10130 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10131 " comment */", 10132 format(" \t \t f(\"\t\t\"); /* some\n" 10133 " \t \t comment */", 10134 Tab)); 10135 EXPECT_EQ("{\n" 10136 " /*\n" 10137 " * Comment\n" 10138 " */\n" 10139 " int i;\n" 10140 "}", 10141 format("{\n" 10142 "\t/*\n" 10143 "\t * Comment\n" 10144 "\t */\n" 10145 "\t int i;\n" 10146 "}")); 10147 10148 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10149 Tab.TabWidth = 8; 10150 Tab.IndentWidth = 8; 10151 EXPECT_EQ("if (aaaaaaaa && // q\n" 10152 " bb) // w\n" 10153 "\t;", 10154 format("if (aaaaaaaa &&// q\n" 10155 "bb)// w\n" 10156 ";", 10157 Tab)); 10158 EXPECT_EQ("if (aaa && bbb) // w\n" 10159 "\t;", 10160 format("if(aaa&&bbb)// w\n" 10161 ";", 10162 Tab)); 10163 verifyFormat("class X {\n" 10164 "\tvoid f() {\n" 10165 "\t\tsomeFunction(parameter1,\n" 10166 "\t\t\t parameter2);\n" 10167 "\t}\n" 10168 "};", 10169 Tab); 10170 verifyFormat("#define A \\\n" 10171 "\tvoid f() { \\\n" 10172 "\t\tsomeFunction( \\\n" 10173 "\t\t parameter1, \\\n" 10174 "\t\t parameter2); \\\n" 10175 "\t}", 10176 Tab); 10177 Tab.TabWidth = 4; 10178 Tab.IndentWidth = 8; 10179 verifyFormat("class TabWidth4Indent8 {\n" 10180 "\t\tvoid f() {\n" 10181 "\t\t\t\tsomeFunction(parameter1,\n" 10182 "\t\t\t\t\t\t\t parameter2);\n" 10183 "\t\t}\n" 10184 "};", 10185 Tab); 10186 Tab.TabWidth = 4; 10187 Tab.IndentWidth = 4; 10188 verifyFormat("class TabWidth4Indent4 {\n" 10189 "\tvoid f() {\n" 10190 "\t\tsomeFunction(parameter1,\n" 10191 "\t\t\t\t\t parameter2);\n" 10192 "\t}\n" 10193 "};", 10194 Tab); 10195 Tab.TabWidth = 8; 10196 Tab.IndentWidth = 4; 10197 verifyFormat("class TabWidth8Indent4 {\n" 10198 " void f() {\n" 10199 "\tsomeFunction(parameter1,\n" 10200 "\t\t parameter2);\n" 10201 " }\n" 10202 "};", 10203 Tab); 10204 Tab.TabWidth = 8; 10205 Tab.IndentWidth = 8; 10206 EXPECT_EQ("/*\n" 10207 "\t a\t\tcomment\n" 10208 "\t in multiple lines\n" 10209 " */", 10210 format(" /*\t \t \n" 10211 " \t \t a\t\tcomment\t \t\n" 10212 " \t \t in multiple lines\t\n" 10213 " \t */", 10214 Tab)); 10215 verifyFormat("{\n" 10216 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10217 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10218 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10219 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10220 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10221 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10222 "};", 10223 Tab); 10224 verifyFormat("enum AA {\n" 10225 "\ta1, // Force multiple lines\n" 10226 "\ta2,\n" 10227 "\ta3\n" 10228 "};", 10229 Tab); 10230 EXPECT_EQ("if (aaaaaaaa && // q\n" 10231 " bb) // w\n" 10232 "\t;", 10233 format("if (aaaaaaaa &&// q\n" 10234 "bb)// w\n" 10235 ";", 10236 Tab)); 10237 verifyFormat("class X {\n" 10238 "\tvoid f() {\n" 10239 "\t\tsomeFunction(parameter1,\n" 10240 "\t\t\t parameter2);\n" 10241 "\t}\n" 10242 "};", 10243 Tab); 10244 verifyFormat("{\n" 10245 "\tQ(\n" 10246 "\t {\n" 10247 "\t\t int a;\n" 10248 "\t\t someFunction(aaaaaaaa,\n" 10249 "\t\t\t\t bbbbbbb);\n" 10250 "\t },\n" 10251 "\t p);\n" 10252 "}", 10253 Tab); 10254 EXPECT_EQ("{\n" 10255 "\t/* aaaa\n" 10256 "\t bbbb */\n" 10257 "}", 10258 format("{\n" 10259 "/* aaaa\n" 10260 " bbbb */\n" 10261 "}", 10262 Tab)); 10263 EXPECT_EQ("{\n" 10264 "\t/*\n" 10265 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10266 "\t bbbbbbbbbbbbb\n" 10267 "\t*/\n" 10268 "}", 10269 format("{\n" 10270 "/*\n" 10271 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10272 "*/\n" 10273 "}", 10274 Tab)); 10275 EXPECT_EQ("{\n" 10276 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10277 "\t// bbbbbbbbbbbbb\n" 10278 "}", 10279 format("{\n" 10280 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10281 "}", 10282 Tab)); 10283 EXPECT_EQ("{\n" 10284 "\t/*\n" 10285 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10286 "\t bbbbbbbbbbbbb\n" 10287 "\t*/\n" 10288 "}", 10289 format("{\n" 10290 "\t/*\n" 10291 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10292 "\t*/\n" 10293 "}", 10294 Tab)); 10295 EXPECT_EQ("{\n" 10296 "\t/*\n" 10297 "\n" 10298 "\t*/\n" 10299 "}", 10300 format("{\n" 10301 "\t/*\n" 10302 "\n" 10303 "\t*/\n" 10304 "}", 10305 Tab)); 10306 EXPECT_EQ("{\n" 10307 "\t/*\n" 10308 " asdf\n" 10309 "\t*/\n" 10310 "}", 10311 format("{\n" 10312 "\t/*\n" 10313 " asdf\n" 10314 "\t*/\n" 10315 "}", 10316 Tab)); 10317 EXPECT_EQ("/*\n" 10318 "\t a\t\tcomment\n" 10319 "\t in multiple lines\n" 10320 " */", 10321 format(" /*\t \t \n" 10322 " \t \t a\t\tcomment\t \t\n" 10323 " \t \t in multiple lines\t\n" 10324 " \t */", 10325 Tab)); 10326 EXPECT_EQ("/* some\n" 10327 " comment */", 10328 format(" \t \t /* some\n" 10329 " \t \t comment */", 10330 Tab)); 10331 EXPECT_EQ("int a; /* some\n" 10332 " comment */", 10333 format(" \t \t int a; /* some\n" 10334 " \t \t comment */", 10335 Tab)); 10336 EXPECT_EQ("int a; /* some\n" 10337 "comment */", 10338 format(" \t \t int\ta; /* some\n" 10339 " \t \t comment */", 10340 Tab)); 10341 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10342 " comment */", 10343 format(" \t \t f(\"\t\t\"); /* some\n" 10344 " \t \t comment */", 10345 Tab)); 10346 EXPECT_EQ("{\n" 10347 " /*\n" 10348 " * Comment\n" 10349 " */\n" 10350 " int i;\n" 10351 "}", 10352 format("{\n" 10353 "\t/*\n" 10354 "\t * Comment\n" 10355 "\t */\n" 10356 "\t int i;\n" 10357 "}")); 10358 Tab.AlignConsecutiveAssignments = true; 10359 Tab.AlignConsecutiveDeclarations = true; 10360 Tab.TabWidth = 4; 10361 Tab.IndentWidth = 4; 10362 verifyFormat("class Assign {\n" 10363 "\tvoid f() {\n" 10364 "\t\tint x = 123;\n" 10365 "\t\tint random = 4;\n" 10366 "\t\tstd::string alphabet =\n" 10367 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 10368 "\t}\n" 10369 "};", 10370 Tab); 10371 } 10372 10373 TEST_F(FormatTest, ZeroTabWidth) { 10374 FormatStyle Tab = getLLVMStyleWithColumns(42); 10375 Tab.IndentWidth = 8; 10376 Tab.UseTab = FormatStyle::UT_Never; 10377 Tab.TabWidth = 0; 10378 EXPECT_EQ("void a(){\n" 10379 " // line starts with '\t'\n" 10380 "};", 10381 format("void a(){\n" 10382 "\t// line starts with '\t'\n" 10383 "};", 10384 Tab)); 10385 10386 EXPECT_EQ("void a(){\n" 10387 " // line starts with '\t'\n" 10388 "};", 10389 format("void a(){\n" 10390 "\t\t// line starts with '\t'\n" 10391 "};", 10392 Tab)); 10393 10394 Tab.UseTab = FormatStyle::UT_ForIndentation; 10395 EXPECT_EQ("void a(){\n" 10396 " // line starts with '\t'\n" 10397 "};", 10398 format("void a(){\n" 10399 "\t// line starts with '\t'\n" 10400 "};", 10401 Tab)); 10402 10403 EXPECT_EQ("void a(){\n" 10404 " // line starts with '\t'\n" 10405 "};", 10406 format("void a(){\n" 10407 "\t\t// line starts with '\t'\n" 10408 "};", 10409 Tab)); 10410 10411 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10412 EXPECT_EQ("void a(){\n" 10413 " // line starts with '\t'\n" 10414 "};", 10415 format("void a(){\n" 10416 "\t// line starts with '\t'\n" 10417 "};", 10418 Tab)); 10419 10420 EXPECT_EQ("void a(){\n" 10421 " // line starts with '\t'\n" 10422 "};", 10423 format("void a(){\n" 10424 "\t\t// line starts with '\t'\n" 10425 "};", 10426 Tab)); 10427 10428 Tab.UseTab = FormatStyle::UT_Always; 10429 EXPECT_EQ("void a(){\n" 10430 "// line starts with '\t'\n" 10431 "};", 10432 format("void a(){\n" 10433 "\t// line starts with '\t'\n" 10434 "};", 10435 Tab)); 10436 10437 EXPECT_EQ("void a(){\n" 10438 "// line starts with '\t'\n" 10439 "};", 10440 format("void a(){\n" 10441 "\t\t// line starts with '\t'\n" 10442 "};", 10443 Tab)); 10444 } 10445 10446 TEST_F(FormatTest, CalculatesOriginalColumn) { 10447 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10448 "q\"; /* some\n" 10449 " comment */", 10450 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10451 "q\"; /* some\n" 10452 " comment */", 10453 getLLVMStyle())); 10454 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10455 "/* some\n" 10456 " comment */", 10457 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10458 " /* some\n" 10459 " comment */", 10460 getLLVMStyle())); 10461 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10462 "qqq\n" 10463 "/* some\n" 10464 " comment */", 10465 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10466 "qqq\n" 10467 " /* some\n" 10468 " comment */", 10469 getLLVMStyle())); 10470 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10471 "wwww; /* some\n" 10472 " comment */", 10473 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10474 "wwww; /* some\n" 10475 " comment */", 10476 getLLVMStyle())); 10477 } 10478 10479 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 10480 FormatStyle NoSpace = getLLVMStyle(); 10481 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 10482 10483 verifyFormat("while(true)\n" 10484 " continue;", 10485 NoSpace); 10486 verifyFormat("for(;;)\n" 10487 " continue;", 10488 NoSpace); 10489 verifyFormat("if(true)\n" 10490 " f();\n" 10491 "else if(true)\n" 10492 " f();", 10493 NoSpace); 10494 verifyFormat("do {\n" 10495 " do_something();\n" 10496 "} while(something());", 10497 NoSpace); 10498 verifyFormat("switch(x) {\n" 10499 "default:\n" 10500 " break;\n" 10501 "}", 10502 NoSpace); 10503 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 10504 verifyFormat("size_t x = sizeof(x);", NoSpace); 10505 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 10506 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 10507 verifyFormat("alignas(128) char a[128];", NoSpace); 10508 verifyFormat("size_t x = alignof(MyType);", NoSpace); 10509 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 10510 verifyFormat("int f() throw(Deprecated);", NoSpace); 10511 verifyFormat("typedef void (*cb)(int);", NoSpace); 10512 verifyFormat("T A::operator()();", NoSpace); 10513 verifyFormat("X A::operator++(T);", NoSpace); 10514 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 10515 10516 FormatStyle Space = getLLVMStyle(); 10517 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 10518 10519 verifyFormat("int f ();", Space); 10520 verifyFormat("void f (int a, T b) {\n" 10521 " while (true)\n" 10522 " continue;\n" 10523 "}", 10524 Space); 10525 verifyFormat("if (true)\n" 10526 " f ();\n" 10527 "else if (true)\n" 10528 " f ();", 10529 Space); 10530 verifyFormat("do {\n" 10531 " do_something ();\n" 10532 "} while (something ());", 10533 Space); 10534 verifyFormat("switch (x) {\n" 10535 "default:\n" 10536 " break;\n" 10537 "}", 10538 Space); 10539 verifyFormat("A::A () : a (1) {}", Space); 10540 verifyFormat("void f () __attribute__ ((asdf));", Space); 10541 verifyFormat("*(&a + 1);\n" 10542 "&((&a)[1]);\n" 10543 "a[(b + c) * d];\n" 10544 "(((a + 1) * 2) + 3) * 4;", 10545 Space); 10546 verifyFormat("#define A(x) x", Space); 10547 verifyFormat("#define A (x) x", Space); 10548 verifyFormat("#if defined(x)\n" 10549 "#endif", 10550 Space); 10551 verifyFormat("auto i = std::make_unique<int> (5);", Space); 10552 verifyFormat("size_t x = sizeof (x);", Space); 10553 verifyFormat("auto f (int x) -> decltype (x);", Space); 10554 verifyFormat("int f (T x) noexcept (x.create ());", Space); 10555 verifyFormat("alignas (128) char a[128];", Space); 10556 verifyFormat("size_t x = alignof (MyType);", Space); 10557 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 10558 verifyFormat("int f () throw (Deprecated);", Space); 10559 verifyFormat("typedef void (*cb) (int);", Space); 10560 verifyFormat("T A::operator() ();", Space); 10561 verifyFormat("X A::operator++ (T);", Space); 10562 verifyFormat("auto lambda = [] () { return 0; };", Space); 10563 verifyFormat("int x = int (y);", Space); 10564 10565 FormatStyle SomeSpace = getLLVMStyle(); 10566 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 10567 10568 verifyFormat("[]() -> float {}", SomeSpace); 10569 verifyFormat("[] (auto foo) {}", SomeSpace); 10570 verifyFormat("[foo]() -> int {}", SomeSpace); 10571 verifyFormat("int f();", SomeSpace); 10572 verifyFormat("void f (int a, T b) {\n" 10573 " while (true)\n" 10574 " continue;\n" 10575 "}", 10576 SomeSpace); 10577 verifyFormat("if (true)\n" 10578 " f();\n" 10579 "else if (true)\n" 10580 " f();", 10581 SomeSpace); 10582 verifyFormat("do {\n" 10583 " do_something();\n" 10584 "} while (something());", 10585 SomeSpace); 10586 verifyFormat("switch (x) {\n" 10587 "default:\n" 10588 " break;\n" 10589 "}", 10590 SomeSpace); 10591 verifyFormat("A::A() : a (1) {}", SomeSpace); 10592 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 10593 verifyFormat("*(&a + 1);\n" 10594 "&((&a)[1]);\n" 10595 "a[(b + c) * d];\n" 10596 "(((a + 1) * 2) + 3) * 4;", 10597 SomeSpace); 10598 verifyFormat("#define A(x) x", SomeSpace); 10599 verifyFormat("#define A (x) x", SomeSpace); 10600 verifyFormat("#if defined(x)\n" 10601 "#endif", 10602 SomeSpace); 10603 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 10604 verifyFormat("size_t x = sizeof (x);", SomeSpace); 10605 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 10606 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 10607 verifyFormat("alignas (128) char a[128];", SomeSpace); 10608 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 10609 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 10610 SomeSpace); 10611 verifyFormat("int f() throw (Deprecated);", SomeSpace); 10612 verifyFormat("typedef void (*cb) (int);", SomeSpace); 10613 verifyFormat("T A::operator()();", SomeSpace); 10614 verifyFormat("X A::operator++ (T);", SomeSpace); 10615 verifyFormat("int x = int (y);", SomeSpace); 10616 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 10617 } 10618 10619 TEST_F(FormatTest, SpaceAfterLogicalNot) { 10620 FormatStyle Spaces = getLLVMStyle(); 10621 Spaces.SpaceAfterLogicalNot = true; 10622 10623 verifyFormat("bool x = ! y", Spaces); 10624 verifyFormat("if (! isFailure())", Spaces); 10625 verifyFormat("if (! (a && b))", Spaces); 10626 verifyFormat("\"Error!\"", Spaces); 10627 verifyFormat("! ! x", Spaces); 10628 } 10629 10630 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 10631 FormatStyle Spaces = getLLVMStyle(); 10632 10633 Spaces.SpacesInParentheses = true; 10634 verifyFormat("do_something( ::globalVar );", Spaces); 10635 verifyFormat("call( x, y, z );", Spaces); 10636 verifyFormat("call();", Spaces); 10637 verifyFormat("std::function<void( int, int )> callback;", Spaces); 10638 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 10639 Spaces); 10640 verifyFormat("while ( (bool)1 )\n" 10641 " continue;", 10642 Spaces); 10643 verifyFormat("for ( ;; )\n" 10644 " continue;", 10645 Spaces); 10646 verifyFormat("if ( true )\n" 10647 " f();\n" 10648 "else if ( true )\n" 10649 " f();", 10650 Spaces); 10651 verifyFormat("do {\n" 10652 " do_something( (int)i );\n" 10653 "} while ( something() );", 10654 Spaces); 10655 verifyFormat("switch ( x ) {\n" 10656 "default:\n" 10657 " break;\n" 10658 "}", 10659 Spaces); 10660 10661 Spaces.SpacesInParentheses = false; 10662 Spaces.SpacesInCStyleCastParentheses = true; 10663 verifyFormat("Type *A = ( Type * )P;", Spaces); 10664 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 10665 verifyFormat("x = ( int32 )y;", Spaces); 10666 verifyFormat("int a = ( int )(2.0f);", Spaces); 10667 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 10668 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 10669 verifyFormat("#define x (( int )-1)", Spaces); 10670 10671 // Run the first set of tests again with: 10672 Spaces.SpacesInParentheses = false; 10673 Spaces.SpaceInEmptyParentheses = true; 10674 Spaces.SpacesInCStyleCastParentheses = true; 10675 verifyFormat("call(x, y, z);", Spaces); 10676 verifyFormat("call( );", Spaces); 10677 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10678 verifyFormat("while (( bool )1)\n" 10679 " continue;", 10680 Spaces); 10681 verifyFormat("for (;;)\n" 10682 " continue;", 10683 Spaces); 10684 verifyFormat("if (true)\n" 10685 " f( );\n" 10686 "else if (true)\n" 10687 " f( );", 10688 Spaces); 10689 verifyFormat("do {\n" 10690 " do_something(( int )i);\n" 10691 "} while (something( ));", 10692 Spaces); 10693 verifyFormat("switch (x) {\n" 10694 "default:\n" 10695 " break;\n" 10696 "}", 10697 Spaces); 10698 10699 // Run the first set of tests again with: 10700 Spaces.SpaceAfterCStyleCast = true; 10701 verifyFormat("call(x, y, z);", Spaces); 10702 verifyFormat("call( );", Spaces); 10703 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10704 verifyFormat("while (( bool ) 1)\n" 10705 " continue;", 10706 Spaces); 10707 verifyFormat("for (;;)\n" 10708 " continue;", 10709 Spaces); 10710 verifyFormat("if (true)\n" 10711 " f( );\n" 10712 "else if (true)\n" 10713 " f( );", 10714 Spaces); 10715 verifyFormat("do {\n" 10716 " do_something(( int ) i);\n" 10717 "} while (something( ));", 10718 Spaces); 10719 verifyFormat("switch (x) {\n" 10720 "default:\n" 10721 " break;\n" 10722 "}", 10723 Spaces); 10724 10725 // Run subset of tests again with: 10726 Spaces.SpacesInCStyleCastParentheses = false; 10727 Spaces.SpaceAfterCStyleCast = true; 10728 verifyFormat("while ((bool) 1)\n" 10729 " continue;", 10730 Spaces); 10731 verifyFormat("do {\n" 10732 " do_something((int) i);\n" 10733 "} while (something( ));", 10734 Spaces); 10735 } 10736 10737 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 10738 verifyFormat("int a[5];"); 10739 verifyFormat("a[3] += 42;"); 10740 10741 FormatStyle Spaces = getLLVMStyle(); 10742 Spaces.SpacesInSquareBrackets = true; 10743 // Not lambdas. 10744 verifyFormat("int a[ 5 ];", Spaces); 10745 verifyFormat("a[ 3 ] += 42;", Spaces); 10746 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 10747 verifyFormat("double &operator[](int i) { return 0; }\n" 10748 "int i;", 10749 Spaces); 10750 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 10751 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 10752 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 10753 // Lambdas. 10754 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 10755 verifyFormat("return [ i, args... ] {};", Spaces); 10756 verifyFormat("int foo = [ &bar ]() {};", Spaces); 10757 verifyFormat("int foo = [ = ]() {};", Spaces); 10758 verifyFormat("int foo = [ & ]() {};", Spaces); 10759 verifyFormat("int foo = [ =, &bar ]() {};", Spaces); 10760 verifyFormat("int foo = [ &bar, = ]() {};", Spaces); 10761 } 10762 10763 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) { 10764 FormatStyle NoSpaceStyle = getLLVMStyle(); 10765 verifyFormat("int a[5];", NoSpaceStyle); 10766 verifyFormat("a[3] += 42;", NoSpaceStyle); 10767 10768 verifyFormat("int a[1];", NoSpaceStyle); 10769 verifyFormat("int 1 [a];", NoSpaceStyle); 10770 verifyFormat("int a[1][2];", NoSpaceStyle); 10771 verifyFormat("a[7] = 5;", NoSpaceStyle); 10772 verifyFormat("int a = (f())[23];", NoSpaceStyle); 10773 verifyFormat("f([] {})", NoSpaceStyle); 10774 10775 FormatStyle Space = getLLVMStyle(); 10776 Space.SpaceBeforeSquareBrackets = true; 10777 verifyFormat("int c = []() -> int { return 2; }();\n", Space); 10778 verifyFormat("return [i, args...] {};", Space); 10779 10780 verifyFormat("int a [5];", Space); 10781 verifyFormat("a [3] += 42;", Space); 10782 verifyFormat("constexpr char hello []{\"hello\"};", Space); 10783 verifyFormat("double &operator[](int i) { return 0; }\n" 10784 "int i;", 10785 Space); 10786 verifyFormat("std::unique_ptr<int []> foo() {}", Space); 10787 verifyFormat("int i = a [a][a]->f();", Space); 10788 verifyFormat("int i = (*b) [a]->f();", Space); 10789 10790 verifyFormat("int a [1];", Space); 10791 verifyFormat("int 1 [a];", Space); 10792 verifyFormat("int a [1][2];", Space); 10793 verifyFormat("a [7] = 5;", Space); 10794 verifyFormat("int a = (f()) [23];", Space); 10795 verifyFormat("f([] {})", Space); 10796 } 10797 10798 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 10799 verifyFormat("int a = 5;"); 10800 verifyFormat("a += 42;"); 10801 verifyFormat("a or_eq 8;"); 10802 10803 FormatStyle Spaces = getLLVMStyle(); 10804 Spaces.SpaceBeforeAssignmentOperators = false; 10805 verifyFormat("int a= 5;", Spaces); 10806 verifyFormat("a+= 42;", Spaces); 10807 verifyFormat("a or_eq 8;", Spaces); 10808 } 10809 10810 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 10811 verifyFormat("class Foo : public Bar {};"); 10812 verifyFormat("Foo::Foo() : foo(1) {}"); 10813 verifyFormat("for (auto a : b) {\n}"); 10814 verifyFormat("int x = a ? b : c;"); 10815 verifyFormat("{\n" 10816 "label0:\n" 10817 " int x = 0;\n" 10818 "}"); 10819 verifyFormat("switch (x) {\n" 10820 "case 1:\n" 10821 "default:\n" 10822 "}"); 10823 10824 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 10825 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 10826 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 10827 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 10828 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 10829 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 10830 verifyFormat("{\n" 10831 "label1:\n" 10832 " int x = 0;\n" 10833 "}", 10834 CtorInitializerStyle); 10835 verifyFormat("switch (x) {\n" 10836 "case 1:\n" 10837 "default:\n" 10838 "}", 10839 CtorInitializerStyle); 10840 CtorInitializerStyle.BreakConstructorInitializers = 10841 FormatStyle::BCIS_AfterColon; 10842 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 10843 " aaaaaaaaaaaaaaaa(1),\n" 10844 " bbbbbbbbbbbbbbbb(2) {}", 10845 CtorInitializerStyle); 10846 CtorInitializerStyle.BreakConstructorInitializers = 10847 FormatStyle::BCIS_BeforeComma; 10848 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10849 " : aaaaaaaaaaaaaaaa(1)\n" 10850 " , bbbbbbbbbbbbbbbb(2) {}", 10851 CtorInitializerStyle); 10852 CtorInitializerStyle.BreakConstructorInitializers = 10853 FormatStyle::BCIS_BeforeColon; 10854 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10855 " : aaaaaaaaaaaaaaaa(1),\n" 10856 " bbbbbbbbbbbbbbbb(2) {}", 10857 CtorInitializerStyle); 10858 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 10859 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10860 ": aaaaaaaaaaaaaaaa(1),\n" 10861 " bbbbbbbbbbbbbbbb(2) {}", 10862 CtorInitializerStyle); 10863 10864 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 10865 InheritanceStyle.SpaceBeforeInheritanceColon = false; 10866 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 10867 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 10868 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 10869 verifyFormat("int x = a ? b : c;", InheritanceStyle); 10870 verifyFormat("{\n" 10871 "label2:\n" 10872 " int x = 0;\n" 10873 "}", 10874 InheritanceStyle); 10875 verifyFormat("switch (x) {\n" 10876 "case 1:\n" 10877 "default:\n" 10878 "}", 10879 InheritanceStyle); 10880 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 10881 verifyFormat("class Foooooooooooooooooooooo:\n" 10882 " public aaaaaaaaaaaaaaaaaa,\n" 10883 " public bbbbbbbbbbbbbbbbbb {\n" 10884 "}", 10885 InheritanceStyle); 10886 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 10887 verifyFormat("class Foooooooooooooooooooooo\n" 10888 " : public aaaaaaaaaaaaaaaaaa\n" 10889 " , public bbbbbbbbbbbbbbbbbb {\n" 10890 "}", 10891 InheritanceStyle); 10892 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 10893 verifyFormat("class Foooooooooooooooooooooo\n" 10894 " : public aaaaaaaaaaaaaaaaaa,\n" 10895 " public bbbbbbbbbbbbbbbbbb {\n" 10896 "}", 10897 InheritanceStyle); 10898 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 10899 verifyFormat("class Foooooooooooooooooooooo\n" 10900 ": public aaaaaaaaaaaaaaaaaa,\n" 10901 " public bbbbbbbbbbbbbbbbbb {}", 10902 InheritanceStyle); 10903 10904 FormatStyle ForLoopStyle = getLLVMStyle(); 10905 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 10906 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 10907 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 10908 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 10909 verifyFormat("int x = a ? b : c;", ForLoopStyle); 10910 verifyFormat("{\n" 10911 "label2:\n" 10912 " int x = 0;\n" 10913 "}", 10914 ForLoopStyle); 10915 verifyFormat("switch (x) {\n" 10916 "case 1:\n" 10917 "default:\n" 10918 "}", 10919 ForLoopStyle); 10920 10921 FormatStyle NoSpaceStyle = getLLVMStyle(); 10922 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 10923 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 10924 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 10925 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 10926 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 10927 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 10928 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 10929 verifyFormat("{\n" 10930 "label3:\n" 10931 " int x = 0;\n" 10932 "}", 10933 NoSpaceStyle); 10934 verifyFormat("switch (x) {\n" 10935 "case 1:\n" 10936 "default:\n" 10937 "}", 10938 NoSpaceStyle); 10939 } 10940 10941 TEST_F(FormatTest, AlignConsecutiveMacros) { 10942 FormatStyle Style = getLLVMStyle(); 10943 Style.AlignConsecutiveAssignments = true; 10944 Style.AlignConsecutiveDeclarations = true; 10945 Style.AlignConsecutiveMacros = false; 10946 10947 verifyFormat("#define a 3\n" 10948 "#define bbbb 4\n" 10949 "#define ccc (5)", 10950 Style); 10951 10952 verifyFormat("#define f(x) (x * x)\n" 10953 "#define fff(x, y, z) (x * y + z)\n" 10954 "#define ffff(x, y) (x - y)", 10955 Style); 10956 10957 verifyFormat("#define foo(x, y) (x + y)\n" 10958 "#define bar (5, 6)(2 + 2)", 10959 Style); 10960 10961 verifyFormat("#define a 3\n" 10962 "#define bbbb 4\n" 10963 "#define ccc (5)\n" 10964 "#define f(x) (x * x)\n" 10965 "#define fff(x, y, z) (x * y + z)\n" 10966 "#define ffff(x, y) (x - y)", 10967 Style); 10968 10969 Style.AlignConsecutiveMacros = true; 10970 verifyFormat("#define a 3\n" 10971 "#define bbbb 4\n" 10972 "#define ccc (5)", 10973 Style); 10974 10975 verifyFormat("#define f(x) (x * x)\n" 10976 "#define fff(x, y, z) (x * y + z)\n" 10977 "#define ffff(x, y) (x - y)", 10978 Style); 10979 10980 verifyFormat("#define foo(x, y) (x + y)\n" 10981 "#define bar (5, 6)(2 + 2)", 10982 Style); 10983 10984 verifyFormat("#define a 3\n" 10985 "#define bbbb 4\n" 10986 "#define ccc (5)\n" 10987 "#define f(x) (x * x)\n" 10988 "#define fff(x, y, z) (x * y + z)\n" 10989 "#define ffff(x, y) (x - y)", 10990 Style); 10991 10992 verifyFormat("#define a 5\n" 10993 "#define foo(x, y) (x + y)\n" 10994 "#define CCC (6)\n" 10995 "auto lambda = []() {\n" 10996 " auto ii = 0;\n" 10997 " float j = 0;\n" 10998 " return 0;\n" 10999 "};\n" 11000 "int i = 0;\n" 11001 "float i2 = 0;\n" 11002 "auto v = type{\n" 11003 " i = 1, //\n" 11004 " (i = 2), //\n" 11005 " i = 3 //\n" 11006 "};", 11007 Style); 11008 11009 Style.AlignConsecutiveMacros = false; 11010 Style.ColumnLimit = 20; 11011 11012 verifyFormat("#define a \\\n" 11013 " \"aabbbbbbbbbbbb\"\n" 11014 "#define D \\\n" 11015 " \"aabbbbbbbbbbbb\" \\\n" 11016 " \"ccddeeeeeeeee\"\n" 11017 "#define B \\\n" 11018 " \"QQQQQQQQQQQQQ\" \\\n" 11019 " \"FFFFFFFFFFFFF\" \\\n" 11020 " \"LLLLLLLL\"\n", 11021 Style); 11022 11023 Style.AlignConsecutiveMacros = true; 11024 verifyFormat("#define a \\\n" 11025 " \"aabbbbbbbbbbbb\"\n" 11026 "#define D \\\n" 11027 " \"aabbbbbbbbbbbb\" \\\n" 11028 " \"ccddeeeeeeeee\"\n" 11029 "#define B \\\n" 11030 " \"QQQQQQQQQQQQQ\" \\\n" 11031 " \"FFFFFFFFFFFFF\" \\\n" 11032 " \"LLLLLLLL\"\n", 11033 Style); 11034 } 11035 11036 TEST_F(FormatTest, AlignConsecutiveAssignments) { 11037 FormatStyle Alignment = getLLVMStyle(); 11038 Alignment.AlignConsecutiveMacros = true; 11039 Alignment.AlignConsecutiveAssignments = false; 11040 verifyFormat("int a = 5;\n" 11041 "int oneTwoThree = 123;", 11042 Alignment); 11043 verifyFormat("int a = 5;\n" 11044 "int oneTwoThree = 123;", 11045 Alignment); 11046 11047 Alignment.AlignConsecutiveAssignments = true; 11048 verifyFormat("int a = 5;\n" 11049 "int oneTwoThree = 123;", 11050 Alignment); 11051 verifyFormat("int a = method();\n" 11052 "int oneTwoThree = 133;", 11053 Alignment); 11054 verifyFormat("a &= 5;\n" 11055 "bcd *= 5;\n" 11056 "ghtyf += 5;\n" 11057 "dvfvdb -= 5;\n" 11058 "a /= 5;\n" 11059 "vdsvsv %= 5;\n" 11060 "sfdbddfbdfbb ^= 5;\n" 11061 "dvsdsv |= 5;\n" 11062 "int dsvvdvsdvvv = 123;", 11063 Alignment); 11064 verifyFormat("int i = 1, j = 10;\n" 11065 "something = 2000;", 11066 Alignment); 11067 verifyFormat("something = 2000;\n" 11068 "int i = 1, j = 10;\n", 11069 Alignment); 11070 verifyFormat("something = 2000;\n" 11071 "another = 911;\n" 11072 "int i = 1, j = 10;\n" 11073 "oneMore = 1;\n" 11074 "i = 2;", 11075 Alignment); 11076 verifyFormat("int a = 5;\n" 11077 "int one = 1;\n" 11078 "method();\n" 11079 "int oneTwoThree = 123;\n" 11080 "int oneTwo = 12;", 11081 Alignment); 11082 verifyFormat("int oneTwoThree = 123;\n" 11083 "int oneTwo = 12;\n" 11084 "method();\n", 11085 Alignment); 11086 verifyFormat("int oneTwoThree = 123; // comment\n" 11087 "int oneTwo = 12; // comment", 11088 Alignment); 11089 EXPECT_EQ("int a = 5;\n" 11090 "\n" 11091 "int oneTwoThree = 123;", 11092 format("int a = 5;\n" 11093 "\n" 11094 "int oneTwoThree= 123;", 11095 Alignment)); 11096 EXPECT_EQ("int a = 5;\n" 11097 "int one = 1;\n" 11098 "\n" 11099 "int oneTwoThree = 123;", 11100 format("int a = 5;\n" 11101 "int one = 1;\n" 11102 "\n" 11103 "int oneTwoThree = 123;", 11104 Alignment)); 11105 EXPECT_EQ("int a = 5;\n" 11106 "int one = 1;\n" 11107 "\n" 11108 "int oneTwoThree = 123;\n" 11109 "int oneTwo = 12;", 11110 format("int a = 5;\n" 11111 "int one = 1;\n" 11112 "\n" 11113 "int oneTwoThree = 123;\n" 11114 "int oneTwo = 12;", 11115 Alignment)); 11116 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11117 verifyFormat("#define A \\\n" 11118 " int aaaa = 12; \\\n" 11119 " int b = 23; \\\n" 11120 " int ccc = 234; \\\n" 11121 " int dddddddddd = 2345;", 11122 Alignment); 11123 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11124 verifyFormat("#define A \\\n" 11125 " int aaaa = 12; \\\n" 11126 " int b = 23; \\\n" 11127 " int ccc = 234; \\\n" 11128 " int dddddddddd = 2345;", 11129 Alignment); 11130 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11131 verifyFormat("#define A " 11132 " \\\n" 11133 " int aaaa = 12; " 11134 " \\\n" 11135 " int b = 23; " 11136 " \\\n" 11137 " int ccc = 234; " 11138 " \\\n" 11139 " int dddddddddd = 2345;", 11140 Alignment); 11141 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11142 "k = 4, int l = 5,\n" 11143 " int m = 6) {\n" 11144 " int j = 10;\n" 11145 " otherThing = 1;\n" 11146 "}", 11147 Alignment); 11148 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11149 " int i = 1;\n" 11150 " int j = 2;\n" 11151 " int big = 10000;\n" 11152 "}", 11153 Alignment); 11154 verifyFormat("class C {\n" 11155 "public:\n" 11156 " int i = 1;\n" 11157 " virtual void f() = 0;\n" 11158 "};", 11159 Alignment); 11160 verifyFormat("int i = 1;\n" 11161 "if (SomeType t = getSomething()) {\n" 11162 "}\n" 11163 "int j = 2;\n" 11164 "int big = 10000;", 11165 Alignment); 11166 verifyFormat("int j = 7;\n" 11167 "for (int k = 0; k < N; ++k) {\n" 11168 "}\n" 11169 "int j = 2;\n" 11170 "int big = 10000;\n" 11171 "}", 11172 Alignment); 11173 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11174 verifyFormat("int i = 1;\n" 11175 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11176 " = someLooooooooooooooooongFunction();\n" 11177 "int j = 2;", 11178 Alignment); 11179 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11180 verifyFormat("int i = 1;\n" 11181 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11182 " someLooooooooooooooooongFunction();\n" 11183 "int j = 2;", 11184 Alignment); 11185 11186 verifyFormat("auto lambda = []() {\n" 11187 " auto i = 0;\n" 11188 " return 0;\n" 11189 "};\n" 11190 "int i = 0;\n" 11191 "auto v = type{\n" 11192 " i = 1, //\n" 11193 " (i = 2), //\n" 11194 " i = 3 //\n" 11195 "};", 11196 Alignment); 11197 11198 verifyFormat( 11199 "int i = 1;\n" 11200 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11201 " loooooooooooooooooooooongParameterB);\n" 11202 "int j = 2;", 11203 Alignment); 11204 11205 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 11206 " typename B = very_long_type_name_1,\n" 11207 " typename T_2 = very_long_type_name_2>\n" 11208 "auto foo() {}\n", 11209 Alignment); 11210 verifyFormat("int a, b = 1;\n" 11211 "int c = 2;\n" 11212 "int dd = 3;\n", 11213 Alignment); 11214 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11215 "float b[1][] = {{3.f}};\n", 11216 Alignment); 11217 verifyFormat("for (int i = 0; i < 1; i++)\n" 11218 " int x = 1;\n", 11219 Alignment); 11220 verifyFormat("for (i = 0; i < 1; i++)\n" 11221 " x = 1;\n" 11222 "y = 1;\n", 11223 Alignment); 11224 } 11225 11226 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 11227 FormatStyle Alignment = getLLVMStyle(); 11228 Alignment.AlignConsecutiveMacros = true; 11229 Alignment.AlignConsecutiveDeclarations = false; 11230 verifyFormat("float const a = 5;\n" 11231 "int oneTwoThree = 123;", 11232 Alignment); 11233 verifyFormat("int a = 5;\n" 11234 "float const oneTwoThree = 123;", 11235 Alignment); 11236 11237 Alignment.AlignConsecutiveDeclarations = true; 11238 verifyFormat("float const a = 5;\n" 11239 "int oneTwoThree = 123;", 11240 Alignment); 11241 verifyFormat("int a = method();\n" 11242 "float const oneTwoThree = 133;", 11243 Alignment); 11244 verifyFormat("int i = 1, j = 10;\n" 11245 "something = 2000;", 11246 Alignment); 11247 verifyFormat("something = 2000;\n" 11248 "int i = 1, j = 10;\n", 11249 Alignment); 11250 verifyFormat("float something = 2000;\n" 11251 "double another = 911;\n" 11252 "int i = 1, j = 10;\n" 11253 "const int *oneMore = 1;\n" 11254 "unsigned i = 2;", 11255 Alignment); 11256 verifyFormat("float a = 5;\n" 11257 "int one = 1;\n" 11258 "method();\n" 11259 "const double oneTwoThree = 123;\n" 11260 "const unsigned int oneTwo = 12;", 11261 Alignment); 11262 verifyFormat("int oneTwoThree{0}; // comment\n" 11263 "unsigned oneTwo; // comment", 11264 Alignment); 11265 EXPECT_EQ("float const a = 5;\n" 11266 "\n" 11267 "int oneTwoThree = 123;", 11268 format("float const a = 5;\n" 11269 "\n" 11270 "int oneTwoThree= 123;", 11271 Alignment)); 11272 EXPECT_EQ("float a = 5;\n" 11273 "int one = 1;\n" 11274 "\n" 11275 "unsigned oneTwoThree = 123;", 11276 format("float a = 5;\n" 11277 "int one = 1;\n" 11278 "\n" 11279 "unsigned oneTwoThree = 123;", 11280 Alignment)); 11281 EXPECT_EQ("float a = 5;\n" 11282 "int one = 1;\n" 11283 "\n" 11284 "unsigned oneTwoThree = 123;\n" 11285 "int oneTwo = 12;", 11286 format("float a = 5;\n" 11287 "int one = 1;\n" 11288 "\n" 11289 "unsigned oneTwoThree = 123;\n" 11290 "int oneTwo = 12;", 11291 Alignment)); 11292 // Function prototype alignment 11293 verifyFormat("int a();\n" 11294 "double b();", 11295 Alignment); 11296 verifyFormat("int a(int x);\n" 11297 "double b();", 11298 Alignment); 11299 unsigned OldColumnLimit = Alignment.ColumnLimit; 11300 // We need to set ColumnLimit to zero, in order to stress nested alignments, 11301 // otherwise the function parameters will be re-flowed onto a single line. 11302 Alignment.ColumnLimit = 0; 11303 EXPECT_EQ("int a(int x,\n" 11304 " float y);\n" 11305 "double b(int x,\n" 11306 " double y);", 11307 format("int a(int x,\n" 11308 " float y);\n" 11309 "double b(int x,\n" 11310 " double y);", 11311 Alignment)); 11312 // This ensures that function parameters of function declarations are 11313 // correctly indented when their owning functions are indented. 11314 // The failure case here is for 'double y' to not be indented enough. 11315 EXPECT_EQ("double a(int x);\n" 11316 "int b(int y,\n" 11317 " double z);", 11318 format("double a(int x);\n" 11319 "int b(int y,\n" 11320 " double z);", 11321 Alignment)); 11322 // Set ColumnLimit low so that we induce wrapping immediately after 11323 // the function name and opening paren. 11324 Alignment.ColumnLimit = 13; 11325 verifyFormat("int function(\n" 11326 " int x,\n" 11327 " bool y);", 11328 Alignment); 11329 Alignment.ColumnLimit = OldColumnLimit; 11330 // Ensure function pointers don't screw up recursive alignment 11331 verifyFormat("int a(int x, void (*fp)(int y));\n" 11332 "double b();", 11333 Alignment); 11334 Alignment.AlignConsecutiveAssignments = true; 11335 // Ensure recursive alignment is broken by function braces, so that the 11336 // "a = 1" does not align with subsequent assignments inside the function 11337 // body. 11338 verifyFormat("int func(int a = 1) {\n" 11339 " int b = 2;\n" 11340 " int cc = 3;\n" 11341 "}", 11342 Alignment); 11343 verifyFormat("float something = 2000;\n" 11344 "double another = 911;\n" 11345 "int i = 1, j = 10;\n" 11346 "const int *oneMore = 1;\n" 11347 "unsigned i = 2;", 11348 Alignment); 11349 verifyFormat("int oneTwoThree = {0}; // comment\n" 11350 "unsigned oneTwo = 0; // comment", 11351 Alignment); 11352 // Make sure that scope is correctly tracked, in the absence of braces 11353 verifyFormat("for (int i = 0; i < n; i++)\n" 11354 " j = i;\n" 11355 "double x = 1;\n", 11356 Alignment); 11357 verifyFormat("if (int i = 0)\n" 11358 " j = i;\n" 11359 "double x = 1;\n", 11360 Alignment); 11361 // Ensure operator[] and operator() are comprehended 11362 verifyFormat("struct test {\n" 11363 " long long int foo();\n" 11364 " int operator[](int a);\n" 11365 " double bar();\n" 11366 "};\n", 11367 Alignment); 11368 verifyFormat("struct test {\n" 11369 " long long int foo();\n" 11370 " int operator()(int a);\n" 11371 " double bar();\n" 11372 "};\n", 11373 Alignment); 11374 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 11375 " int const i = 1;\n" 11376 " int * j = 2;\n" 11377 " int big = 10000;\n" 11378 "\n" 11379 " unsigned oneTwoThree = 123;\n" 11380 " int oneTwo = 12;\n" 11381 " method();\n" 11382 " float k = 2;\n" 11383 " int ll = 10000;\n" 11384 "}", 11385 format("void SomeFunction(int parameter= 0) {\n" 11386 " int const i= 1;\n" 11387 " int *j=2;\n" 11388 " int big = 10000;\n" 11389 "\n" 11390 "unsigned oneTwoThree =123;\n" 11391 "int oneTwo = 12;\n" 11392 " method();\n" 11393 "float k= 2;\n" 11394 "int ll=10000;\n" 11395 "}", 11396 Alignment)); 11397 Alignment.AlignConsecutiveAssignments = false; 11398 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11399 verifyFormat("#define A \\\n" 11400 " int aaaa = 12; \\\n" 11401 " float b = 23; \\\n" 11402 " const int ccc = 234; \\\n" 11403 " unsigned dddddddddd = 2345;", 11404 Alignment); 11405 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11406 verifyFormat("#define A \\\n" 11407 " int aaaa = 12; \\\n" 11408 " float b = 23; \\\n" 11409 " const int ccc = 234; \\\n" 11410 " unsigned dddddddddd = 2345;", 11411 Alignment); 11412 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11413 Alignment.ColumnLimit = 30; 11414 verifyFormat("#define A \\\n" 11415 " int aaaa = 12; \\\n" 11416 " float b = 23; \\\n" 11417 " const int ccc = 234; \\\n" 11418 " int dddddddddd = 2345;", 11419 Alignment); 11420 Alignment.ColumnLimit = 80; 11421 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11422 "k = 4, int l = 5,\n" 11423 " int m = 6) {\n" 11424 " const int j = 10;\n" 11425 " otherThing = 1;\n" 11426 "}", 11427 Alignment); 11428 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11429 " int const i = 1;\n" 11430 " int * j = 2;\n" 11431 " int big = 10000;\n" 11432 "}", 11433 Alignment); 11434 verifyFormat("class C {\n" 11435 "public:\n" 11436 " int i = 1;\n" 11437 " virtual void f() = 0;\n" 11438 "};", 11439 Alignment); 11440 verifyFormat("float i = 1;\n" 11441 "if (SomeType t = getSomething()) {\n" 11442 "}\n" 11443 "const unsigned j = 2;\n" 11444 "int big = 10000;", 11445 Alignment); 11446 verifyFormat("float j = 7;\n" 11447 "for (int k = 0; k < N; ++k) {\n" 11448 "}\n" 11449 "unsigned j = 2;\n" 11450 "int big = 10000;\n" 11451 "}", 11452 Alignment); 11453 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11454 verifyFormat("float i = 1;\n" 11455 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11456 " = someLooooooooooooooooongFunction();\n" 11457 "int j = 2;", 11458 Alignment); 11459 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11460 verifyFormat("int i = 1;\n" 11461 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11462 " someLooooooooooooooooongFunction();\n" 11463 "int j = 2;", 11464 Alignment); 11465 11466 Alignment.AlignConsecutiveAssignments = true; 11467 verifyFormat("auto lambda = []() {\n" 11468 " auto ii = 0;\n" 11469 " float j = 0;\n" 11470 " return 0;\n" 11471 "};\n" 11472 "int i = 0;\n" 11473 "float i2 = 0;\n" 11474 "auto v = type{\n" 11475 " i = 1, //\n" 11476 " (i = 2), //\n" 11477 " i = 3 //\n" 11478 "};", 11479 Alignment); 11480 Alignment.AlignConsecutiveAssignments = false; 11481 11482 verifyFormat( 11483 "int i = 1;\n" 11484 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11485 " loooooooooooooooooooooongParameterB);\n" 11486 "int j = 2;", 11487 Alignment); 11488 11489 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 11490 // We expect declarations and assignments to align, as long as it doesn't 11491 // exceed the column limit, starting a new alignment sequence whenever it 11492 // happens. 11493 Alignment.AlignConsecutiveAssignments = true; 11494 Alignment.ColumnLimit = 30; 11495 verifyFormat("float ii = 1;\n" 11496 "unsigned j = 2;\n" 11497 "int someVerylongVariable = 1;\n" 11498 "AnotherLongType ll = 123456;\n" 11499 "VeryVeryLongType k = 2;\n" 11500 "int myvar = 1;", 11501 Alignment); 11502 Alignment.ColumnLimit = 80; 11503 Alignment.AlignConsecutiveAssignments = false; 11504 11505 verifyFormat( 11506 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 11507 " typename LongType, typename B>\n" 11508 "auto foo() {}\n", 11509 Alignment); 11510 verifyFormat("float a, b = 1;\n" 11511 "int c = 2;\n" 11512 "int dd = 3;\n", 11513 Alignment); 11514 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11515 "float b[1][] = {{3.f}};\n", 11516 Alignment); 11517 Alignment.AlignConsecutiveAssignments = true; 11518 verifyFormat("float a, b = 1;\n" 11519 "int c = 2;\n" 11520 "int dd = 3;\n", 11521 Alignment); 11522 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11523 "float b[1][] = {{3.f}};\n", 11524 Alignment); 11525 Alignment.AlignConsecutiveAssignments = false; 11526 11527 Alignment.ColumnLimit = 30; 11528 Alignment.BinPackParameters = false; 11529 verifyFormat("void foo(float a,\n" 11530 " float b,\n" 11531 " int c,\n" 11532 " uint32_t *d) {\n" 11533 " int * e = 0;\n" 11534 " float f = 0;\n" 11535 " double g = 0;\n" 11536 "}\n" 11537 "void bar(ino_t a,\n" 11538 " int b,\n" 11539 " uint32_t *c,\n" 11540 " bool d) {}\n", 11541 Alignment); 11542 Alignment.BinPackParameters = true; 11543 Alignment.ColumnLimit = 80; 11544 11545 // Bug 33507 11546 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 11547 verifyFormat( 11548 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 11549 " static const Version verVs2017;\n" 11550 " return true;\n" 11551 "});\n", 11552 Alignment); 11553 Alignment.PointerAlignment = FormatStyle::PAS_Right; 11554 11555 // See llvm.org/PR35641 11556 Alignment.AlignConsecutiveDeclarations = true; 11557 verifyFormat("int func() { //\n" 11558 " int b;\n" 11559 " unsigned c;\n" 11560 "}", 11561 Alignment); 11562 11563 // See PR37175 11564 FormatStyle Style = getMozillaStyle(); 11565 Style.AlignConsecutiveDeclarations = true; 11566 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 11567 "foo(int a);", 11568 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 11569 } 11570 11571 TEST_F(FormatTest, LinuxBraceBreaking) { 11572 FormatStyle LinuxBraceStyle = getLLVMStyle(); 11573 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 11574 verifyFormat("namespace a\n" 11575 "{\n" 11576 "class A\n" 11577 "{\n" 11578 " void f()\n" 11579 " {\n" 11580 " if (true) {\n" 11581 " a();\n" 11582 " b();\n" 11583 " } else {\n" 11584 " a();\n" 11585 " }\n" 11586 " }\n" 11587 " void g() { return; }\n" 11588 "};\n" 11589 "struct B {\n" 11590 " int x;\n" 11591 "};\n" 11592 "} // namespace a\n", 11593 LinuxBraceStyle); 11594 verifyFormat("enum X {\n" 11595 " Y = 0,\n" 11596 "}\n", 11597 LinuxBraceStyle); 11598 verifyFormat("struct S {\n" 11599 " int Type;\n" 11600 " union {\n" 11601 " int x;\n" 11602 " double y;\n" 11603 " } Value;\n" 11604 " class C\n" 11605 " {\n" 11606 " MyFavoriteType Value;\n" 11607 " } Class;\n" 11608 "}\n", 11609 LinuxBraceStyle); 11610 } 11611 11612 TEST_F(FormatTest, MozillaBraceBreaking) { 11613 FormatStyle MozillaBraceStyle = getLLVMStyle(); 11614 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 11615 MozillaBraceStyle.FixNamespaceComments = false; 11616 verifyFormat("namespace a {\n" 11617 "class A\n" 11618 "{\n" 11619 " void f()\n" 11620 " {\n" 11621 " if (true) {\n" 11622 " a();\n" 11623 " b();\n" 11624 " }\n" 11625 " }\n" 11626 " void g() { return; }\n" 11627 "};\n" 11628 "enum E\n" 11629 "{\n" 11630 " A,\n" 11631 " // foo\n" 11632 " B,\n" 11633 " C\n" 11634 "};\n" 11635 "struct B\n" 11636 "{\n" 11637 " int x;\n" 11638 "};\n" 11639 "}\n", 11640 MozillaBraceStyle); 11641 verifyFormat("struct S\n" 11642 "{\n" 11643 " int Type;\n" 11644 " union\n" 11645 " {\n" 11646 " int x;\n" 11647 " double y;\n" 11648 " } Value;\n" 11649 " class C\n" 11650 " {\n" 11651 " MyFavoriteType Value;\n" 11652 " } Class;\n" 11653 "}\n", 11654 MozillaBraceStyle); 11655 } 11656 11657 TEST_F(FormatTest, StroustrupBraceBreaking) { 11658 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 11659 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11660 verifyFormat("namespace a {\n" 11661 "class A {\n" 11662 " void f()\n" 11663 " {\n" 11664 " if (true) {\n" 11665 " a();\n" 11666 " b();\n" 11667 " }\n" 11668 " }\n" 11669 " void g() { return; }\n" 11670 "};\n" 11671 "struct B {\n" 11672 " int x;\n" 11673 "};\n" 11674 "} // namespace a\n", 11675 StroustrupBraceStyle); 11676 11677 verifyFormat("void foo()\n" 11678 "{\n" 11679 " if (a) {\n" 11680 " a();\n" 11681 " }\n" 11682 " else {\n" 11683 " b();\n" 11684 " }\n" 11685 "}\n", 11686 StroustrupBraceStyle); 11687 11688 verifyFormat("#ifdef _DEBUG\n" 11689 "int foo(int i = 0)\n" 11690 "#else\n" 11691 "int foo(int i = 5)\n" 11692 "#endif\n" 11693 "{\n" 11694 " return i;\n" 11695 "}", 11696 StroustrupBraceStyle); 11697 11698 verifyFormat("void foo() {}\n" 11699 "void bar()\n" 11700 "#ifdef _DEBUG\n" 11701 "{\n" 11702 " foo();\n" 11703 "}\n" 11704 "#else\n" 11705 "{\n" 11706 "}\n" 11707 "#endif", 11708 StroustrupBraceStyle); 11709 11710 verifyFormat("void foobar() { int i = 5; }\n" 11711 "#ifdef _DEBUG\n" 11712 "void bar() {}\n" 11713 "#else\n" 11714 "void bar() { foobar(); }\n" 11715 "#endif", 11716 StroustrupBraceStyle); 11717 } 11718 11719 TEST_F(FormatTest, AllmanBraceBreaking) { 11720 FormatStyle AllmanBraceStyle = getLLVMStyle(); 11721 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 11722 11723 EXPECT_EQ("namespace a\n" 11724 "{\n" 11725 "void f();\n" 11726 "void g();\n" 11727 "} // namespace a\n", 11728 format("namespace a\n" 11729 "{\n" 11730 "void f();\n" 11731 "void g();\n" 11732 "}\n", 11733 AllmanBraceStyle)); 11734 11735 verifyFormat("namespace a\n" 11736 "{\n" 11737 "class A\n" 11738 "{\n" 11739 " void f()\n" 11740 " {\n" 11741 " if (true)\n" 11742 " {\n" 11743 " a();\n" 11744 " b();\n" 11745 " }\n" 11746 " }\n" 11747 " void g() { return; }\n" 11748 "};\n" 11749 "struct B\n" 11750 "{\n" 11751 " int x;\n" 11752 "};\n" 11753 "union C\n" 11754 "{\n" 11755 "};\n" 11756 "} // namespace a", 11757 AllmanBraceStyle); 11758 11759 verifyFormat("void f()\n" 11760 "{\n" 11761 " if (true)\n" 11762 " {\n" 11763 " a();\n" 11764 " }\n" 11765 " else if (false)\n" 11766 " {\n" 11767 " b();\n" 11768 " }\n" 11769 " else\n" 11770 " {\n" 11771 " c();\n" 11772 " }\n" 11773 "}\n", 11774 AllmanBraceStyle); 11775 11776 verifyFormat("void f()\n" 11777 "{\n" 11778 " for (int i = 0; i < 10; ++i)\n" 11779 " {\n" 11780 " a();\n" 11781 " }\n" 11782 " while (false)\n" 11783 " {\n" 11784 " b();\n" 11785 " }\n" 11786 " do\n" 11787 " {\n" 11788 " c();\n" 11789 " } while (false)\n" 11790 "}\n", 11791 AllmanBraceStyle); 11792 11793 verifyFormat("void f(int a)\n" 11794 "{\n" 11795 " switch (a)\n" 11796 " {\n" 11797 " case 0:\n" 11798 " break;\n" 11799 " case 1:\n" 11800 " {\n" 11801 " break;\n" 11802 " }\n" 11803 " case 2:\n" 11804 " {\n" 11805 " }\n" 11806 " break;\n" 11807 " default:\n" 11808 " break;\n" 11809 " }\n" 11810 "}\n", 11811 AllmanBraceStyle); 11812 11813 verifyFormat("enum X\n" 11814 "{\n" 11815 " Y = 0,\n" 11816 "}\n", 11817 AllmanBraceStyle); 11818 verifyFormat("enum X\n" 11819 "{\n" 11820 " Y = 0\n" 11821 "}\n", 11822 AllmanBraceStyle); 11823 11824 verifyFormat("@interface BSApplicationController ()\n" 11825 "{\n" 11826 "@private\n" 11827 " id _extraIvar;\n" 11828 "}\n" 11829 "@end\n", 11830 AllmanBraceStyle); 11831 11832 verifyFormat("#ifdef _DEBUG\n" 11833 "int foo(int i = 0)\n" 11834 "#else\n" 11835 "int foo(int i = 5)\n" 11836 "#endif\n" 11837 "{\n" 11838 " return i;\n" 11839 "}", 11840 AllmanBraceStyle); 11841 11842 verifyFormat("void foo() {}\n" 11843 "void bar()\n" 11844 "#ifdef _DEBUG\n" 11845 "{\n" 11846 " foo();\n" 11847 "}\n" 11848 "#else\n" 11849 "{\n" 11850 "}\n" 11851 "#endif", 11852 AllmanBraceStyle); 11853 11854 verifyFormat("void foobar() { int i = 5; }\n" 11855 "#ifdef _DEBUG\n" 11856 "void bar() {}\n" 11857 "#else\n" 11858 "void bar() { foobar(); }\n" 11859 "#endif", 11860 AllmanBraceStyle); 11861 11862 // This shouldn't affect ObjC blocks.. 11863 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 11864 " // ...\n" 11865 " int i;\n" 11866 "}];", 11867 AllmanBraceStyle); 11868 verifyFormat("void (^block)(void) = ^{\n" 11869 " // ...\n" 11870 " int i;\n" 11871 "};", 11872 AllmanBraceStyle); 11873 // .. or dict literals. 11874 verifyFormat("void f()\n" 11875 "{\n" 11876 " // ...\n" 11877 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 11878 "}", 11879 AllmanBraceStyle); 11880 verifyFormat("void f()\n" 11881 "{\n" 11882 " // ...\n" 11883 " [object someMethod:@{a : @\"b\"}];\n" 11884 "}", 11885 AllmanBraceStyle); 11886 verifyFormat("int f()\n" 11887 "{ // comment\n" 11888 " return 42;\n" 11889 "}", 11890 AllmanBraceStyle); 11891 11892 AllmanBraceStyle.ColumnLimit = 19; 11893 verifyFormat("void f() { int i; }", AllmanBraceStyle); 11894 AllmanBraceStyle.ColumnLimit = 18; 11895 verifyFormat("void f()\n" 11896 "{\n" 11897 " int i;\n" 11898 "}", 11899 AllmanBraceStyle); 11900 AllmanBraceStyle.ColumnLimit = 80; 11901 11902 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 11903 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 11904 FormatStyle::SIS_WithoutElse; 11905 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 11906 verifyFormat("void f(bool b)\n" 11907 "{\n" 11908 " if (b)\n" 11909 " {\n" 11910 " return;\n" 11911 " }\n" 11912 "}\n", 11913 BreakBeforeBraceShortIfs); 11914 verifyFormat("void f(bool b)\n" 11915 "{\n" 11916 " if constexpr (b)\n" 11917 " {\n" 11918 " return;\n" 11919 " }\n" 11920 "}\n", 11921 BreakBeforeBraceShortIfs); 11922 verifyFormat("void f(bool b)\n" 11923 "{\n" 11924 " if CONSTEXPR (b)\n" 11925 " {\n" 11926 " return;\n" 11927 " }\n" 11928 "}\n", 11929 BreakBeforeBraceShortIfs); 11930 verifyFormat("void f(bool b)\n" 11931 "{\n" 11932 " if (b) return;\n" 11933 "}\n", 11934 BreakBeforeBraceShortIfs); 11935 verifyFormat("void f(bool b)\n" 11936 "{\n" 11937 " if constexpr (b) return;\n" 11938 "}\n", 11939 BreakBeforeBraceShortIfs); 11940 verifyFormat("void f(bool b)\n" 11941 "{\n" 11942 " if CONSTEXPR (b) return;\n" 11943 "}\n", 11944 BreakBeforeBraceShortIfs); 11945 verifyFormat("void f(bool b)\n" 11946 "{\n" 11947 " while (b)\n" 11948 " {\n" 11949 " return;\n" 11950 " }\n" 11951 "}\n", 11952 BreakBeforeBraceShortIfs); 11953 } 11954 11955 TEST_F(FormatTest, WhitesmithsBraceBreaking) { 11956 FormatStyle WhitesmithsBraceStyle = getLLVMStyle(); 11957 WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 11958 11959 // Make a few changes to the style for testing purposes 11960 WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine = 11961 FormatStyle::SFS_Empty; 11962 WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 11963 WhitesmithsBraceStyle.ColumnLimit = 0; 11964 11965 // FIXME: this test case can't decide whether there should be a blank line 11966 // after the ~D() line or not. It adds one if one doesn't exist in the test 11967 // and it removes the line if one exists. 11968 /* 11969 verifyFormat("class A;\n" 11970 "namespace B\n" 11971 " {\n" 11972 "class C;\n" 11973 "// Comment\n" 11974 "class D\n" 11975 " {\n" 11976 "public:\n" 11977 " D();\n" 11978 " ~D() {}\n" 11979 "private:\n" 11980 " enum E\n" 11981 " {\n" 11982 " F\n" 11983 " }\n" 11984 " };\n" 11985 " } // namespace B\n", 11986 WhitesmithsBraceStyle); 11987 */ 11988 11989 verifyFormat("namespace a\n" 11990 " {\n" 11991 "class A\n" 11992 " {\n" 11993 " void f()\n" 11994 " {\n" 11995 " if (true)\n" 11996 " {\n" 11997 " a();\n" 11998 " b();\n" 11999 " }\n" 12000 " }\n" 12001 " void g()\n" 12002 " {\n" 12003 " return;\n" 12004 " }\n" 12005 " };\n" 12006 "struct B\n" 12007 " {\n" 12008 " int x;\n" 12009 " };\n" 12010 " } // namespace a", 12011 WhitesmithsBraceStyle); 12012 12013 verifyFormat("void f()\n" 12014 " {\n" 12015 " if (true)\n" 12016 " {\n" 12017 " a();\n" 12018 " }\n" 12019 " else if (false)\n" 12020 " {\n" 12021 " b();\n" 12022 " }\n" 12023 " else\n" 12024 " {\n" 12025 " c();\n" 12026 " }\n" 12027 " }\n", 12028 WhitesmithsBraceStyle); 12029 12030 verifyFormat("void f()\n" 12031 " {\n" 12032 " for (int i = 0; i < 10; ++i)\n" 12033 " {\n" 12034 " a();\n" 12035 " }\n" 12036 " while (false)\n" 12037 " {\n" 12038 " b();\n" 12039 " }\n" 12040 " do\n" 12041 " {\n" 12042 " c();\n" 12043 " } while (false)\n" 12044 " }\n", 12045 WhitesmithsBraceStyle); 12046 12047 // FIXME: the block and the break under case 2 in this test don't get indented 12048 // correctly 12049 /* 12050 verifyFormat("void switchTest1(int a)\n" 12051 " {\n" 12052 " switch (a)\n" 12053 " {\n" 12054 " case 2:\n" 12055 " {\n" 12056 " }\n" 12057 " break;\n" 12058 " }\n" 12059 " }\n", 12060 WhitesmithsBraceStyle); 12061 */ 12062 12063 // FIXME: the block and the break under case 2 in this test don't get indented 12064 // correctly 12065 /* 12066 verifyFormat("void switchTest2(int a)\n" 12067 " {\n" 12068 " switch (a)\n" 12069 " {\n" 12070 " case 0:\n" 12071 " break;\n" 12072 " case 1:\n" 12073 " {\n" 12074 " break;\n" 12075 " }\n" 12076 " case 2:\n" 12077 " {\n" 12078 " }\n" 12079 " break;\n" 12080 " default:\n" 12081 " break;\n" 12082 " }\n" 12083 " }\n", 12084 WhitesmithsBraceStyle); 12085 */ 12086 12087 verifyFormat("enum X\n" 12088 " {\n" 12089 " Y = 0, // testing\n" 12090 " }\n", 12091 WhitesmithsBraceStyle); 12092 12093 verifyFormat("enum X\n" 12094 " {\n" 12095 " Y = 0\n" 12096 " }\n", 12097 WhitesmithsBraceStyle); 12098 verifyFormat("enum X\n" 12099 " {\n" 12100 " Y = 0,\n" 12101 " Z = 1\n" 12102 " };\n", 12103 WhitesmithsBraceStyle); 12104 12105 verifyFormat("@interface BSApplicationController ()\n" 12106 " {\n" 12107 "@private\n" 12108 " id _extraIvar;\n" 12109 " }\n" 12110 "@end\n", 12111 WhitesmithsBraceStyle); 12112 12113 verifyFormat("#ifdef _DEBUG\n" 12114 "int foo(int i = 0)\n" 12115 "#else\n" 12116 "int foo(int i = 5)\n" 12117 "#endif\n" 12118 " {\n" 12119 " return i;\n" 12120 " }", 12121 WhitesmithsBraceStyle); 12122 12123 verifyFormat("void foo() {}\n" 12124 "void bar()\n" 12125 "#ifdef _DEBUG\n" 12126 " {\n" 12127 " foo();\n" 12128 " }\n" 12129 "#else\n" 12130 " {\n" 12131 " }\n" 12132 "#endif", 12133 WhitesmithsBraceStyle); 12134 12135 verifyFormat("void foobar()\n" 12136 " {\n" 12137 " int i = 5;\n" 12138 " }\n" 12139 "#ifdef _DEBUG\n" 12140 "void bar()\n" 12141 " {\n" 12142 " }\n" 12143 "#else\n" 12144 "void bar()\n" 12145 " {\n" 12146 " foobar();\n" 12147 " }\n" 12148 "#endif", 12149 WhitesmithsBraceStyle); 12150 12151 // This shouldn't affect ObjC blocks.. 12152 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 12153 " // ...\n" 12154 " int i;\n" 12155 "}];", 12156 WhitesmithsBraceStyle); 12157 verifyFormat("void (^block)(void) = ^{\n" 12158 " // ...\n" 12159 " int i;\n" 12160 "};", 12161 WhitesmithsBraceStyle); 12162 // .. or dict literals. 12163 verifyFormat("void f()\n" 12164 " {\n" 12165 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 12166 " }", 12167 WhitesmithsBraceStyle); 12168 12169 verifyFormat("int f()\n" 12170 " { // comment\n" 12171 " return 42;\n" 12172 " }", 12173 WhitesmithsBraceStyle); 12174 12175 FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle; 12176 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 12177 FormatStyle::SIS_Always; 12178 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 12179 verifyFormat("void f(bool b)\n" 12180 " {\n" 12181 " if (b)\n" 12182 " {\n" 12183 " return;\n" 12184 " }\n" 12185 " }\n", 12186 BreakBeforeBraceShortIfs); 12187 verifyFormat("void f(bool b)\n" 12188 " {\n" 12189 " if (b) return;\n" 12190 " }\n", 12191 BreakBeforeBraceShortIfs); 12192 verifyFormat("void f(bool b)\n" 12193 " {\n" 12194 " while (b)\n" 12195 " {\n" 12196 " return;\n" 12197 " }\n" 12198 " }\n", 12199 BreakBeforeBraceShortIfs); 12200 } 12201 12202 TEST_F(FormatTest, GNUBraceBreaking) { 12203 FormatStyle GNUBraceStyle = getLLVMStyle(); 12204 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 12205 verifyFormat("namespace a\n" 12206 "{\n" 12207 "class A\n" 12208 "{\n" 12209 " void f()\n" 12210 " {\n" 12211 " int a;\n" 12212 " {\n" 12213 " int b;\n" 12214 " }\n" 12215 " if (true)\n" 12216 " {\n" 12217 " a();\n" 12218 " b();\n" 12219 " }\n" 12220 " }\n" 12221 " void g() { return; }\n" 12222 "}\n" 12223 "} // namespace a", 12224 GNUBraceStyle); 12225 12226 verifyFormat("void f()\n" 12227 "{\n" 12228 " if (true)\n" 12229 " {\n" 12230 " a();\n" 12231 " }\n" 12232 " else if (false)\n" 12233 " {\n" 12234 " b();\n" 12235 " }\n" 12236 " else\n" 12237 " {\n" 12238 " c();\n" 12239 " }\n" 12240 "}\n", 12241 GNUBraceStyle); 12242 12243 verifyFormat("void f()\n" 12244 "{\n" 12245 " for (int i = 0; i < 10; ++i)\n" 12246 " {\n" 12247 " a();\n" 12248 " }\n" 12249 " while (false)\n" 12250 " {\n" 12251 " b();\n" 12252 " }\n" 12253 " do\n" 12254 " {\n" 12255 " c();\n" 12256 " }\n" 12257 " while (false);\n" 12258 "}\n", 12259 GNUBraceStyle); 12260 12261 verifyFormat("void f(int a)\n" 12262 "{\n" 12263 " switch (a)\n" 12264 " {\n" 12265 " case 0:\n" 12266 " break;\n" 12267 " case 1:\n" 12268 " {\n" 12269 " break;\n" 12270 " }\n" 12271 " case 2:\n" 12272 " {\n" 12273 " }\n" 12274 " break;\n" 12275 " default:\n" 12276 " break;\n" 12277 " }\n" 12278 "}\n", 12279 GNUBraceStyle); 12280 12281 verifyFormat("enum X\n" 12282 "{\n" 12283 " Y = 0,\n" 12284 "}\n", 12285 GNUBraceStyle); 12286 12287 verifyFormat("@interface BSApplicationController ()\n" 12288 "{\n" 12289 "@private\n" 12290 " id _extraIvar;\n" 12291 "}\n" 12292 "@end\n", 12293 GNUBraceStyle); 12294 12295 verifyFormat("#ifdef _DEBUG\n" 12296 "int foo(int i = 0)\n" 12297 "#else\n" 12298 "int foo(int i = 5)\n" 12299 "#endif\n" 12300 "{\n" 12301 " return i;\n" 12302 "}", 12303 GNUBraceStyle); 12304 12305 verifyFormat("void foo() {}\n" 12306 "void bar()\n" 12307 "#ifdef _DEBUG\n" 12308 "{\n" 12309 " foo();\n" 12310 "}\n" 12311 "#else\n" 12312 "{\n" 12313 "}\n" 12314 "#endif", 12315 GNUBraceStyle); 12316 12317 verifyFormat("void foobar() { int i = 5; }\n" 12318 "#ifdef _DEBUG\n" 12319 "void bar() {}\n" 12320 "#else\n" 12321 "void bar() { foobar(); }\n" 12322 "#endif", 12323 GNUBraceStyle); 12324 } 12325 12326 TEST_F(FormatTest, WebKitBraceBreaking) { 12327 FormatStyle WebKitBraceStyle = getLLVMStyle(); 12328 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 12329 WebKitBraceStyle.FixNamespaceComments = false; 12330 verifyFormat("namespace a {\n" 12331 "class A {\n" 12332 " void f()\n" 12333 " {\n" 12334 " if (true) {\n" 12335 " a();\n" 12336 " b();\n" 12337 " }\n" 12338 " }\n" 12339 " void g() { return; }\n" 12340 "};\n" 12341 "enum E {\n" 12342 " A,\n" 12343 " // foo\n" 12344 " B,\n" 12345 " C\n" 12346 "};\n" 12347 "struct B {\n" 12348 " int x;\n" 12349 "};\n" 12350 "}\n", 12351 WebKitBraceStyle); 12352 verifyFormat("struct S {\n" 12353 " int Type;\n" 12354 " union {\n" 12355 " int x;\n" 12356 " double y;\n" 12357 " } Value;\n" 12358 " class C {\n" 12359 " MyFavoriteType Value;\n" 12360 " } Class;\n" 12361 "};\n", 12362 WebKitBraceStyle); 12363 } 12364 12365 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 12366 verifyFormat("void f() {\n" 12367 " try {\n" 12368 " } catch (const Exception &e) {\n" 12369 " }\n" 12370 "}\n", 12371 getLLVMStyle()); 12372 } 12373 12374 TEST_F(FormatTest, UnderstandsPragmas) { 12375 verifyFormat("#pragma omp reduction(| : var)"); 12376 verifyFormat("#pragma omp reduction(+ : var)"); 12377 12378 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 12379 "(including parentheses).", 12380 format("#pragma mark Any non-hyphenated or hyphenated string " 12381 "(including parentheses).")); 12382 } 12383 12384 TEST_F(FormatTest, UnderstandPragmaOption) { 12385 verifyFormat("#pragma option -C -A"); 12386 12387 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 12388 } 12389 12390 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 12391 FormatStyle Style = getLLVMStyle(); 12392 Style.ColumnLimit = 20; 12393 12394 // See PR41213 12395 EXPECT_EQ("/*\n" 12396 " *\t9012345\n" 12397 " * /8901\n" 12398 " */", 12399 format("/*\n" 12400 " *\t9012345 /8901\n" 12401 " */", 12402 Style)); 12403 EXPECT_EQ("/*\n" 12404 " *345678\n" 12405 " *\t/8901\n" 12406 " */", 12407 format("/*\n" 12408 " *345678\t/8901\n" 12409 " */", 12410 Style)); 12411 12412 verifyFormat("int a; // the\n" 12413 " // comment", 12414 Style); 12415 EXPECT_EQ("int a; /* first line\n" 12416 " * second\n" 12417 " * line third\n" 12418 " * line\n" 12419 " */", 12420 format("int a; /* first line\n" 12421 " * second\n" 12422 " * line third\n" 12423 " * line\n" 12424 " */", 12425 Style)); 12426 EXPECT_EQ("int a; // first line\n" 12427 " // second\n" 12428 " // line third\n" 12429 " // line", 12430 format("int a; // first line\n" 12431 " // second line\n" 12432 " // third line", 12433 Style)); 12434 12435 Style.PenaltyExcessCharacter = 90; 12436 verifyFormat("int a; // the comment", Style); 12437 EXPECT_EQ("int a; // the comment\n" 12438 " // aaa", 12439 format("int a; // the comment aaa", Style)); 12440 EXPECT_EQ("int a; /* first line\n" 12441 " * second line\n" 12442 " * third line\n" 12443 " */", 12444 format("int a; /* first line\n" 12445 " * second line\n" 12446 " * third line\n" 12447 " */", 12448 Style)); 12449 EXPECT_EQ("int a; // first line\n" 12450 " // second line\n" 12451 " // third line", 12452 format("int a; // first line\n" 12453 " // second line\n" 12454 " // third line", 12455 Style)); 12456 // FIXME: Investigate why this is not getting the same layout as the test 12457 // above. 12458 EXPECT_EQ("int a; /* first line\n" 12459 " * second line\n" 12460 " * third line\n" 12461 " */", 12462 format("int a; /* first line second line third line" 12463 "\n*/", 12464 Style)); 12465 12466 EXPECT_EQ("// foo bar baz bazfoo\n" 12467 "// foo bar foo bar\n", 12468 format("// foo bar baz bazfoo\n" 12469 "// foo bar foo bar\n", 12470 Style)); 12471 EXPECT_EQ("// foo bar baz bazfoo\n" 12472 "// foo bar foo bar\n", 12473 format("// foo bar baz bazfoo\n" 12474 "// foo bar foo bar\n", 12475 Style)); 12476 12477 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 12478 // next one. 12479 EXPECT_EQ("// foo bar baz bazfoo\n" 12480 "// bar foo bar\n", 12481 format("// foo bar baz bazfoo bar\n" 12482 "// foo bar\n", 12483 Style)); 12484 12485 EXPECT_EQ("// foo bar baz bazfoo\n" 12486 "// foo bar baz bazfoo\n" 12487 "// bar foo bar\n", 12488 format("// foo bar baz bazfoo\n" 12489 "// foo bar baz bazfoo bar\n" 12490 "// foo bar\n", 12491 Style)); 12492 12493 EXPECT_EQ("// foo bar baz bazfoo\n" 12494 "// foo bar baz bazfoo\n" 12495 "// bar foo bar\n", 12496 format("// foo bar baz bazfoo\n" 12497 "// foo bar baz bazfoo bar\n" 12498 "// foo bar\n", 12499 Style)); 12500 12501 // Make sure we do not keep protruding characters if strict mode reflow is 12502 // cheaper than keeping protruding characters. 12503 Style.ColumnLimit = 21; 12504 EXPECT_EQ( 12505 "// foo foo foo foo\n" 12506 "// foo foo foo foo\n" 12507 "// foo foo foo foo\n", 12508 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style)); 12509 12510 EXPECT_EQ("int a = /* long block\n" 12511 " comment */\n" 12512 " 42;", 12513 format("int a = /* long block comment */ 42;", Style)); 12514 } 12515 12516 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 12517 for (size_t i = 1; i < Styles.size(); ++i) \ 12518 EXPECT_EQ(Styles[0], Styles[i]) \ 12519 << "Style #" << i << " of " << Styles.size() << " differs from Style #0" 12520 12521 TEST_F(FormatTest, GetsPredefinedStyleByName) { 12522 SmallVector<FormatStyle, 3> Styles; 12523 Styles.resize(3); 12524 12525 Styles[0] = getLLVMStyle(); 12526 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 12527 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 12528 EXPECT_ALL_STYLES_EQUAL(Styles); 12529 12530 Styles[0] = getGoogleStyle(); 12531 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 12532 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 12533 EXPECT_ALL_STYLES_EQUAL(Styles); 12534 12535 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12536 EXPECT_TRUE( 12537 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 12538 EXPECT_TRUE( 12539 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 12540 EXPECT_ALL_STYLES_EQUAL(Styles); 12541 12542 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 12543 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 12544 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 12545 EXPECT_ALL_STYLES_EQUAL(Styles); 12546 12547 Styles[0] = getMozillaStyle(); 12548 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 12549 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 12550 EXPECT_ALL_STYLES_EQUAL(Styles); 12551 12552 Styles[0] = getWebKitStyle(); 12553 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 12554 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 12555 EXPECT_ALL_STYLES_EQUAL(Styles); 12556 12557 Styles[0] = getGNUStyle(); 12558 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 12559 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 12560 EXPECT_ALL_STYLES_EQUAL(Styles); 12561 12562 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 12563 } 12564 12565 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 12566 SmallVector<FormatStyle, 8> Styles; 12567 Styles.resize(2); 12568 12569 Styles[0] = getGoogleStyle(); 12570 Styles[1] = getLLVMStyle(); 12571 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12572 EXPECT_ALL_STYLES_EQUAL(Styles); 12573 12574 Styles.resize(5); 12575 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12576 Styles[1] = getLLVMStyle(); 12577 Styles[1].Language = FormatStyle::LK_JavaScript; 12578 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12579 12580 Styles[2] = getLLVMStyle(); 12581 Styles[2].Language = FormatStyle::LK_JavaScript; 12582 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 12583 "BasedOnStyle: Google", 12584 &Styles[2]) 12585 .value()); 12586 12587 Styles[3] = getLLVMStyle(); 12588 Styles[3].Language = FormatStyle::LK_JavaScript; 12589 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 12590 "Language: JavaScript", 12591 &Styles[3]) 12592 .value()); 12593 12594 Styles[4] = getLLVMStyle(); 12595 Styles[4].Language = FormatStyle::LK_JavaScript; 12596 EXPECT_EQ(0, parseConfiguration("---\n" 12597 "BasedOnStyle: LLVM\n" 12598 "IndentWidth: 123\n" 12599 "---\n" 12600 "BasedOnStyle: Google\n" 12601 "Language: JavaScript", 12602 &Styles[4]) 12603 .value()); 12604 EXPECT_ALL_STYLES_EQUAL(Styles); 12605 } 12606 12607 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 12608 Style.FIELD = false; \ 12609 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 12610 EXPECT_TRUE(Style.FIELD); \ 12611 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 12612 EXPECT_FALSE(Style.FIELD); 12613 12614 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 12615 12616 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 12617 Style.STRUCT.FIELD = false; \ 12618 EXPECT_EQ(0, \ 12619 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 12620 .value()); \ 12621 EXPECT_TRUE(Style.STRUCT.FIELD); \ 12622 EXPECT_EQ(0, \ 12623 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 12624 .value()); \ 12625 EXPECT_FALSE(Style.STRUCT.FIELD); 12626 12627 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 12628 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 12629 12630 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 12631 EXPECT_NE(VALUE, Style.FIELD); \ 12632 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 12633 EXPECT_EQ(VALUE, Style.FIELD) 12634 12635 TEST_F(FormatTest, ParsesConfigurationBools) { 12636 FormatStyle Style = {}; 12637 Style.Language = FormatStyle::LK_Cpp; 12638 CHECK_PARSE_BOOL(AlignOperands); 12639 CHECK_PARSE_BOOL(AlignTrailingComments); 12640 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 12641 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 12642 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 12643 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 12644 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 12645 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 12646 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 12647 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 12648 CHECK_PARSE_BOOL(BinPackArguments); 12649 CHECK_PARSE_BOOL(BinPackParameters); 12650 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 12651 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 12652 CHECK_PARSE_BOOL(BreakStringLiterals); 12653 CHECK_PARSE_BOOL(CompactNamespaces); 12654 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 12655 CHECK_PARSE_BOOL(DeriveLineEnding); 12656 CHECK_PARSE_BOOL(DerivePointerAlignment); 12657 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 12658 CHECK_PARSE_BOOL(DisableFormat); 12659 CHECK_PARSE_BOOL(IndentCaseLabels); 12660 CHECK_PARSE_BOOL(IndentCaseBlocks); 12661 CHECK_PARSE_BOOL(IndentGotoLabels); 12662 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 12663 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 12664 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 12665 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 12666 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 12667 CHECK_PARSE_BOOL(ReflowComments); 12668 CHECK_PARSE_BOOL(SortIncludes); 12669 CHECK_PARSE_BOOL(SortUsingDeclarations); 12670 CHECK_PARSE_BOOL(SpacesInParentheses); 12671 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 12672 CHECK_PARSE_BOOL(SpacesInAngles); 12673 CHECK_PARSE_BOOL(SpacesInConditionalStatement); 12674 CHECK_PARSE_BOOL(SpaceInEmptyBlock); 12675 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 12676 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 12677 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 12678 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 12679 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 12680 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 12681 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 12682 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 12683 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 12684 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 12685 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 12686 CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets); 12687 CHECK_PARSE_BOOL(UseCRLF); 12688 12689 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 12690 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 12691 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 12692 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 12693 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 12694 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 12695 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 12696 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 12697 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 12698 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 12699 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 12700 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody); 12701 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 12702 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 12703 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 12704 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 12705 } 12706 12707 #undef CHECK_PARSE_BOOL 12708 12709 TEST_F(FormatTest, ParsesConfiguration) { 12710 FormatStyle Style = {}; 12711 Style.Language = FormatStyle::LK_Cpp; 12712 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 12713 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 12714 ConstructorInitializerIndentWidth, 1234u); 12715 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 12716 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 12717 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 12718 CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u); 12719 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 12720 PenaltyBreakBeforeFirstCallParameter, 1234u); 12721 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 12722 PenaltyBreakTemplateDeclaration, 1234u); 12723 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 12724 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 12725 PenaltyReturnTypeOnItsOwnLine, 1234u); 12726 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 12727 SpacesBeforeTrailingComments, 1234u); 12728 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 12729 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 12730 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 12731 12732 Style.PointerAlignment = FormatStyle::PAS_Middle; 12733 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 12734 FormatStyle::PAS_Left); 12735 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 12736 FormatStyle::PAS_Right); 12737 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 12738 FormatStyle::PAS_Middle); 12739 // For backward compatibility: 12740 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 12741 FormatStyle::PAS_Left); 12742 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 12743 FormatStyle::PAS_Right); 12744 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 12745 FormatStyle::PAS_Middle); 12746 12747 Style.Standard = FormatStyle::LS_Auto; 12748 CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03); 12749 CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11); 12750 CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14); 12751 CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17); 12752 CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20); 12753 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 12754 CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest); 12755 // Legacy aliases: 12756 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 12757 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest); 12758 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 12759 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 12760 12761 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 12762 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 12763 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 12764 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 12765 FormatStyle::BOS_None); 12766 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 12767 FormatStyle::BOS_All); 12768 // For backward compatibility: 12769 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 12770 FormatStyle::BOS_None); 12771 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 12772 FormatStyle::BOS_All); 12773 12774 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 12775 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 12776 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 12777 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 12778 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 12779 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 12780 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 12781 // For backward compatibility: 12782 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 12783 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 12784 12785 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 12786 CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList, 12787 FormatStyle::BILS_BeforeComma); 12788 CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList, 12789 FormatStyle::BILS_AfterColon); 12790 CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList, 12791 FormatStyle::BILS_BeforeColon); 12792 // For backward compatibility: 12793 CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList, 12794 FormatStyle::BILS_BeforeComma); 12795 12796 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 12797 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 12798 FormatStyle::BAS_Align); 12799 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 12800 FormatStyle::BAS_DontAlign); 12801 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 12802 FormatStyle::BAS_AlwaysBreak); 12803 // For backward compatibility: 12804 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 12805 FormatStyle::BAS_DontAlign); 12806 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 12807 FormatStyle::BAS_Align); 12808 12809 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 12810 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 12811 FormatStyle::ENAS_DontAlign); 12812 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 12813 FormatStyle::ENAS_Left); 12814 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 12815 FormatStyle::ENAS_Right); 12816 // For backward compatibility: 12817 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 12818 FormatStyle::ENAS_Left); 12819 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 12820 FormatStyle::ENAS_Right); 12821 12822 Style.UseTab = FormatStyle::UT_ForIndentation; 12823 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 12824 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 12825 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 12826 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 12827 FormatStyle::UT_ForContinuationAndIndentation); 12828 // For backward compatibility: 12829 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 12830 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 12831 12832 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 12833 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never", 12834 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12835 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty", 12836 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty); 12837 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always", 12838 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12839 // For backward compatibility: 12840 CHECK_PARSE("AllowShortBlocksOnASingleLine: false", 12841 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12842 CHECK_PARSE("AllowShortBlocksOnASingleLine: true", 12843 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12844 12845 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 12846 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 12847 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12848 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 12849 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 12850 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 12851 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 12852 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 12853 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12854 // For backward compatibility: 12855 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 12856 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12857 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 12858 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12859 12860 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 12861 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 12862 FormatStyle::SBPO_Never); 12863 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 12864 FormatStyle::SBPO_Always); 12865 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 12866 FormatStyle::SBPO_ControlStatements); 12867 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 12868 FormatStyle::SBPO_NonEmptyParentheses); 12869 // For backward compatibility: 12870 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 12871 FormatStyle::SBPO_Never); 12872 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 12873 FormatStyle::SBPO_ControlStatements); 12874 12875 Style.ColumnLimit = 123; 12876 FormatStyle BaseStyle = getLLVMStyle(); 12877 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 12878 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 12879 12880 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 12881 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 12882 FormatStyle::BS_Attach); 12883 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 12884 FormatStyle::BS_Linux); 12885 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 12886 FormatStyle::BS_Mozilla); 12887 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 12888 FormatStyle::BS_Stroustrup); 12889 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 12890 FormatStyle::BS_Allman); 12891 CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces, 12892 FormatStyle::BS_Whitesmiths); 12893 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 12894 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 12895 FormatStyle::BS_WebKit); 12896 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 12897 FormatStyle::BS_Custom); 12898 12899 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never; 12900 CHECK_PARSE("BraceWrapping:\n" 12901 " AfterControlStatement: MultiLine", 12902 BraceWrapping.AfterControlStatement, 12903 FormatStyle::BWACS_MultiLine); 12904 CHECK_PARSE("BraceWrapping:\n" 12905 " AfterControlStatement: Always", 12906 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 12907 CHECK_PARSE("BraceWrapping:\n" 12908 " AfterControlStatement: Never", 12909 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 12910 // For backward compatibility: 12911 CHECK_PARSE("BraceWrapping:\n" 12912 " AfterControlStatement: true", 12913 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 12914 CHECK_PARSE("BraceWrapping:\n" 12915 " AfterControlStatement: false", 12916 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 12917 12918 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 12919 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 12920 FormatStyle::RTBS_None); 12921 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 12922 FormatStyle::RTBS_All); 12923 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 12924 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 12925 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 12926 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 12927 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 12928 AlwaysBreakAfterReturnType, 12929 FormatStyle::RTBS_TopLevelDefinitions); 12930 12931 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 12932 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", 12933 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No); 12934 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", 12935 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 12936 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", 12937 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 12938 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", 12939 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 12940 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", 12941 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 12942 12943 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 12944 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 12945 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 12946 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 12947 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 12948 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 12949 AlwaysBreakAfterDefinitionReturnType, 12950 FormatStyle::DRTBS_TopLevel); 12951 12952 Style.NamespaceIndentation = FormatStyle::NI_All; 12953 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 12954 FormatStyle::NI_None); 12955 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 12956 FormatStyle::NI_Inner); 12957 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 12958 FormatStyle::NI_All); 12959 12960 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 12961 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 12962 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12963 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 12964 AllowShortIfStatementsOnASingleLine, 12965 FormatStyle::SIS_WithoutElse); 12966 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 12967 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 12968 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 12969 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12970 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 12971 AllowShortIfStatementsOnASingleLine, 12972 FormatStyle::SIS_WithoutElse); 12973 12974 // FIXME: This is required because parsing a configuration simply overwrites 12975 // the first N elements of the list instead of resetting it. 12976 Style.ForEachMacros.clear(); 12977 std::vector<std::string> BoostForeach; 12978 BoostForeach.push_back("BOOST_FOREACH"); 12979 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 12980 std::vector<std::string> BoostAndQForeach; 12981 BoostAndQForeach.push_back("BOOST_FOREACH"); 12982 BoostAndQForeach.push_back("Q_FOREACH"); 12983 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 12984 BoostAndQForeach); 12985 12986 Style.StatementMacros.clear(); 12987 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 12988 std::vector<std::string>{"QUNUSED"}); 12989 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 12990 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 12991 12992 Style.NamespaceMacros.clear(); 12993 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 12994 std::vector<std::string>{"TESTSUITE"}); 12995 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 12996 std::vector<std::string>({"TESTSUITE", "SUITE"})); 12997 12998 Style.IncludeStyle.IncludeCategories.clear(); 12999 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 13000 {"abc/.*", 2, 0}, {".*", 1, 0}}; 13001 CHECK_PARSE("IncludeCategories:\n" 13002 " - Regex: abc/.*\n" 13003 " Priority: 2\n" 13004 " - Regex: .*\n" 13005 " Priority: 1", 13006 IncludeStyle.IncludeCategories, ExpectedCategories); 13007 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 13008 "abc$"); 13009 CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'", 13010 IncludeStyle.IncludeIsMainSourceRegex, "abc$"); 13011 13012 Style.RawStringFormats.clear(); 13013 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 13014 { 13015 FormatStyle::LK_TextProto, 13016 {"pb", "proto"}, 13017 {"PARSE_TEXT_PROTO"}, 13018 /*CanonicalDelimiter=*/"", 13019 "llvm", 13020 }, 13021 { 13022 FormatStyle::LK_Cpp, 13023 {"cc", "cpp"}, 13024 {"C_CODEBLOCK", "CPPEVAL"}, 13025 /*CanonicalDelimiter=*/"cc", 13026 /*BasedOnStyle=*/"", 13027 }, 13028 }; 13029 13030 CHECK_PARSE("RawStringFormats:\n" 13031 " - Language: TextProto\n" 13032 " Delimiters:\n" 13033 " - 'pb'\n" 13034 " - 'proto'\n" 13035 " EnclosingFunctions:\n" 13036 " - 'PARSE_TEXT_PROTO'\n" 13037 " BasedOnStyle: llvm\n" 13038 " - Language: Cpp\n" 13039 " Delimiters:\n" 13040 " - 'cc'\n" 13041 " - 'cpp'\n" 13042 " EnclosingFunctions:\n" 13043 " - 'C_CODEBLOCK'\n" 13044 " - 'CPPEVAL'\n" 13045 " CanonicalDelimiter: 'cc'", 13046 RawStringFormats, ExpectedRawStringFormats); 13047 } 13048 13049 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 13050 FormatStyle Style = {}; 13051 Style.Language = FormatStyle::LK_Cpp; 13052 CHECK_PARSE("Language: Cpp\n" 13053 "IndentWidth: 12", 13054 IndentWidth, 12u); 13055 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 13056 "IndentWidth: 34", 13057 &Style), 13058 ParseError::Unsuitable); 13059 FormatStyle BinPackedTCS = {}; 13060 BinPackedTCS.Language = FormatStyle::LK_JavaScript; 13061 EXPECT_EQ(parseConfiguration("BinPackArguments: true\n" 13062 "InsertTrailingCommas: Wrapped", 13063 &BinPackedTCS), 13064 ParseError::BinPackTrailingCommaConflict); 13065 EXPECT_EQ(12u, Style.IndentWidth); 13066 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 13067 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 13068 13069 Style.Language = FormatStyle::LK_JavaScript; 13070 CHECK_PARSE("Language: JavaScript\n" 13071 "IndentWidth: 12", 13072 IndentWidth, 12u); 13073 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 13074 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 13075 "IndentWidth: 34", 13076 &Style), 13077 ParseError::Unsuitable); 13078 EXPECT_EQ(23u, Style.IndentWidth); 13079 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 13080 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 13081 13082 CHECK_PARSE("BasedOnStyle: LLVM\n" 13083 "IndentWidth: 67", 13084 IndentWidth, 67u); 13085 13086 CHECK_PARSE("---\n" 13087 "Language: JavaScript\n" 13088 "IndentWidth: 12\n" 13089 "---\n" 13090 "Language: Cpp\n" 13091 "IndentWidth: 34\n" 13092 "...\n", 13093 IndentWidth, 12u); 13094 13095 Style.Language = FormatStyle::LK_Cpp; 13096 CHECK_PARSE("---\n" 13097 "Language: JavaScript\n" 13098 "IndentWidth: 12\n" 13099 "---\n" 13100 "Language: Cpp\n" 13101 "IndentWidth: 34\n" 13102 "...\n", 13103 IndentWidth, 34u); 13104 CHECK_PARSE("---\n" 13105 "IndentWidth: 78\n" 13106 "---\n" 13107 "Language: JavaScript\n" 13108 "IndentWidth: 56\n" 13109 "...\n", 13110 IndentWidth, 78u); 13111 13112 Style.ColumnLimit = 123; 13113 Style.IndentWidth = 234; 13114 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 13115 Style.TabWidth = 345; 13116 EXPECT_FALSE(parseConfiguration("---\n" 13117 "IndentWidth: 456\n" 13118 "BreakBeforeBraces: Allman\n" 13119 "---\n" 13120 "Language: JavaScript\n" 13121 "IndentWidth: 111\n" 13122 "TabWidth: 111\n" 13123 "---\n" 13124 "Language: Cpp\n" 13125 "BreakBeforeBraces: Stroustrup\n" 13126 "TabWidth: 789\n" 13127 "...\n", 13128 &Style)); 13129 EXPECT_EQ(123u, Style.ColumnLimit); 13130 EXPECT_EQ(456u, Style.IndentWidth); 13131 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 13132 EXPECT_EQ(789u, Style.TabWidth); 13133 13134 EXPECT_EQ(parseConfiguration("---\n" 13135 "Language: JavaScript\n" 13136 "IndentWidth: 56\n" 13137 "---\n" 13138 "IndentWidth: 78\n" 13139 "...\n", 13140 &Style), 13141 ParseError::Error); 13142 EXPECT_EQ(parseConfiguration("---\n" 13143 "Language: JavaScript\n" 13144 "IndentWidth: 56\n" 13145 "---\n" 13146 "Language: JavaScript\n" 13147 "IndentWidth: 78\n" 13148 "...\n", 13149 &Style), 13150 ParseError::Error); 13151 13152 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 13153 } 13154 13155 #undef CHECK_PARSE 13156 13157 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 13158 FormatStyle Style = {}; 13159 Style.Language = FormatStyle::LK_JavaScript; 13160 Style.BreakBeforeTernaryOperators = true; 13161 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 13162 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 13163 13164 Style.BreakBeforeTernaryOperators = true; 13165 EXPECT_EQ(0, parseConfiguration("---\n" 13166 "BasedOnStyle: Google\n" 13167 "---\n" 13168 "Language: JavaScript\n" 13169 "IndentWidth: 76\n" 13170 "...\n", 13171 &Style) 13172 .value()); 13173 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 13174 EXPECT_EQ(76u, Style.IndentWidth); 13175 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 13176 } 13177 13178 TEST_F(FormatTest, ConfigurationRoundTripTest) { 13179 FormatStyle Style = getLLVMStyle(); 13180 std::string YAML = configurationAsText(Style); 13181 FormatStyle ParsedStyle = {}; 13182 ParsedStyle.Language = FormatStyle::LK_Cpp; 13183 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 13184 EXPECT_EQ(Style, ParsedStyle); 13185 } 13186 13187 TEST_F(FormatTest, WorksFor8bitEncodings) { 13188 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 13189 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 13190 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 13191 "\"\xef\xee\xf0\xf3...\"", 13192 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 13193 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 13194 "\xef\xee\xf0\xf3...\"", 13195 getLLVMStyleWithColumns(12))); 13196 } 13197 13198 TEST_F(FormatTest, HandlesUTF8BOM) { 13199 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 13200 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 13201 format("\xef\xbb\xbf#include <iostream>")); 13202 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 13203 format("\xef\xbb\xbf\n#include <iostream>")); 13204 } 13205 13206 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 13207 #if !defined(_MSC_VER) 13208 13209 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 13210 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 13211 getLLVMStyleWithColumns(35)); 13212 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 13213 getLLVMStyleWithColumns(31)); 13214 verifyFormat("// Однажды в студёную зимнюю пору...", 13215 getLLVMStyleWithColumns(36)); 13216 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 13217 verifyFormat("/* Однажды в студёную зимнюю пору... */", 13218 getLLVMStyleWithColumns(39)); 13219 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 13220 getLLVMStyleWithColumns(35)); 13221 } 13222 13223 TEST_F(FormatTest, SplitsUTF8Strings) { 13224 // Non-printable characters' width is currently considered to be the length in 13225 // bytes in UTF8. The characters can be displayed in very different manner 13226 // (zero-width, single width with a substitution glyph, expanded to their code 13227 // (e.g. "<8d>"), so there's no single correct way to handle them. 13228 EXPECT_EQ("\"aaaaÄ\"\n" 13229 "\"\xc2\x8d\";", 13230 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13231 EXPECT_EQ("\"aaaaaaaÄ\"\n" 13232 "\"\xc2\x8d\";", 13233 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13234 EXPECT_EQ("\"Однажды, в \"\n" 13235 "\"студёную \"\n" 13236 "\"зимнюю \"\n" 13237 "\"пору,\"", 13238 format("\"Однажды, в студёную зимнюю пору,\"", 13239 getLLVMStyleWithColumns(13))); 13240 EXPECT_EQ( 13241 "\"一 二 三 \"\n" 13242 "\"四 五六 \"\n" 13243 "\"七 八 九 \"\n" 13244 "\"十\"", 13245 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 13246 EXPECT_EQ("\"一\t\"\n" 13247 "\"二 \t\"\n" 13248 "\"三 四 \"\n" 13249 "\"五\t\"\n" 13250 "\"六 \t\"\n" 13251 "\"七 \"\n" 13252 "\"八九十\tqq\"", 13253 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 13254 getLLVMStyleWithColumns(11))); 13255 13256 // UTF8 character in an escape sequence. 13257 EXPECT_EQ("\"aaaaaa\"\n" 13258 "\"\\\xC2\x8D\"", 13259 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 13260 } 13261 13262 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 13263 EXPECT_EQ("const char *sssss =\n" 13264 " \"一二三四五六七八\\\n" 13265 " 九 十\";", 13266 format("const char *sssss = \"一二三四五六七八\\\n" 13267 " 九 十\";", 13268 getLLVMStyleWithColumns(30))); 13269 } 13270 13271 TEST_F(FormatTest, SplitsUTF8LineComments) { 13272 EXPECT_EQ("// aaaaÄ\xc2\x8d", 13273 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 13274 EXPECT_EQ("// Я из лесу\n" 13275 "// вышел; был\n" 13276 "// сильный\n" 13277 "// мороз.", 13278 format("// Я из лесу вышел; был сильный мороз.", 13279 getLLVMStyleWithColumns(13))); 13280 EXPECT_EQ("// 一二三\n" 13281 "// 四五六七\n" 13282 "// 八 九\n" 13283 "// 十", 13284 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 13285 } 13286 13287 TEST_F(FormatTest, SplitsUTF8BlockComments) { 13288 EXPECT_EQ("/* Гляжу,\n" 13289 " * поднимается\n" 13290 " * медленно в\n" 13291 " * гору\n" 13292 " * Лошадка,\n" 13293 " * везущая\n" 13294 " * хворосту\n" 13295 " * воз. */", 13296 format("/* Гляжу, поднимается медленно в гору\n" 13297 " * Лошадка, везущая хворосту воз. */", 13298 getLLVMStyleWithColumns(13))); 13299 EXPECT_EQ( 13300 "/* 一二三\n" 13301 " * 四五六七\n" 13302 " * 八 九\n" 13303 " * 十 */", 13304 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 13305 EXPECT_EQ("/* �������� ��������\n" 13306 " * ��������\n" 13307 " * ������-�� */", 13308 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 13309 } 13310 13311 #endif // _MSC_VER 13312 13313 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 13314 FormatStyle Style = getLLVMStyle(); 13315 13316 Style.ConstructorInitializerIndentWidth = 4; 13317 verifyFormat( 13318 "SomeClass::Constructor()\n" 13319 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13320 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13321 Style); 13322 13323 Style.ConstructorInitializerIndentWidth = 2; 13324 verifyFormat( 13325 "SomeClass::Constructor()\n" 13326 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13327 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13328 Style); 13329 13330 Style.ConstructorInitializerIndentWidth = 0; 13331 verifyFormat( 13332 "SomeClass::Constructor()\n" 13333 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13334 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13335 Style); 13336 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 13337 verifyFormat( 13338 "SomeLongTemplateVariableName<\n" 13339 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 13340 Style); 13341 verifyFormat("bool smaller = 1 < " 13342 "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 13343 " " 13344 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 13345 Style); 13346 13347 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 13348 verifyFormat("SomeClass::Constructor() :\n" 13349 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 13350 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 13351 Style); 13352 } 13353 13354 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 13355 FormatStyle Style = getLLVMStyle(); 13356 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 13357 Style.ConstructorInitializerIndentWidth = 4; 13358 verifyFormat("SomeClass::Constructor()\n" 13359 " : a(a)\n" 13360 " , b(b)\n" 13361 " , c(c) {}", 13362 Style); 13363 verifyFormat("SomeClass::Constructor()\n" 13364 " : a(a) {}", 13365 Style); 13366 13367 Style.ColumnLimit = 0; 13368 verifyFormat("SomeClass::Constructor()\n" 13369 " : a(a) {}", 13370 Style); 13371 verifyFormat("SomeClass::Constructor() noexcept\n" 13372 " : a(a) {}", 13373 Style); 13374 verifyFormat("SomeClass::Constructor()\n" 13375 " : a(a)\n" 13376 " , b(b)\n" 13377 " , c(c) {}", 13378 Style); 13379 verifyFormat("SomeClass::Constructor()\n" 13380 " : a(a) {\n" 13381 " foo();\n" 13382 " bar();\n" 13383 "}", 13384 Style); 13385 13386 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 13387 verifyFormat("SomeClass::Constructor()\n" 13388 " : a(a)\n" 13389 " , b(b)\n" 13390 " , c(c) {\n}", 13391 Style); 13392 verifyFormat("SomeClass::Constructor()\n" 13393 " : a(a) {\n}", 13394 Style); 13395 13396 Style.ColumnLimit = 80; 13397 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 13398 Style.ConstructorInitializerIndentWidth = 2; 13399 verifyFormat("SomeClass::Constructor()\n" 13400 " : a(a)\n" 13401 " , b(b)\n" 13402 " , c(c) {}", 13403 Style); 13404 13405 Style.ConstructorInitializerIndentWidth = 0; 13406 verifyFormat("SomeClass::Constructor()\n" 13407 ": a(a)\n" 13408 ", b(b)\n" 13409 ", c(c) {}", 13410 Style); 13411 13412 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 13413 Style.ConstructorInitializerIndentWidth = 4; 13414 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 13415 verifyFormat( 13416 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 13417 Style); 13418 verifyFormat( 13419 "SomeClass::Constructor()\n" 13420 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 13421 Style); 13422 Style.ConstructorInitializerIndentWidth = 4; 13423 Style.ColumnLimit = 60; 13424 verifyFormat("SomeClass::Constructor()\n" 13425 " : aaaaaaaa(aaaaaaaa)\n" 13426 " , aaaaaaaa(aaaaaaaa)\n" 13427 " , aaaaaaaa(aaaaaaaa) {}", 13428 Style); 13429 } 13430 13431 TEST_F(FormatTest, Destructors) { 13432 verifyFormat("void F(int &i) { i.~int(); }"); 13433 verifyFormat("void F(int &i) { i->~int(); }"); 13434 } 13435 13436 TEST_F(FormatTest, FormatsWithWebKitStyle) { 13437 FormatStyle Style = getWebKitStyle(); 13438 13439 // Don't indent in outer namespaces. 13440 verifyFormat("namespace outer {\n" 13441 "int i;\n" 13442 "namespace inner {\n" 13443 " int i;\n" 13444 "} // namespace inner\n" 13445 "} // namespace outer\n" 13446 "namespace other_outer {\n" 13447 "int i;\n" 13448 "}", 13449 Style); 13450 13451 // Don't indent case labels. 13452 verifyFormat("switch (variable) {\n" 13453 "case 1:\n" 13454 "case 2:\n" 13455 " doSomething();\n" 13456 " break;\n" 13457 "default:\n" 13458 " ++variable;\n" 13459 "}", 13460 Style); 13461 13462 // Wrap before binary operators. 13463 EXPECT_EQ("void f()\n" 13464 "{\n" 13465 " if (aaaaaaaaaaaaaaaa\n" 13466 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 13467 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13468 " return;\n" 13469 "}", 13470 format("void f() {\n" 13471 "if (aaaaaaaaaaaaaaaa\n" 13472 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 13473 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13474 "return;\n" 13475 "}", 13476 Style)); 13477 13478 // Allow functions on a single line. 13479 verifyFormat("void f() { return; }", Style); 13480 13481 // Allow empty blocks on a single line and insert a space in empty blocks. 13482 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 13483 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 13484 // However, don't merge non-empty short loops. 13485 EXPECT_EQ("while (true) {\n" 13486 " continue;\n" 13487 "}", 13488 format("while (true) { continue; }", Style)); 13489 13490 // Constructor initializers are formatted one per line with the "," on the 13491 // new line. 13492 verifyFormat("Constructor()\n" 13493 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 13494 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 13495 " aaaaaaaaaaaaaa)\n" 13496 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 13497 "{\n" 13498 "}", 13499 Style); 13500 verifyFormat("SomeClass::Constructor()\n" 13501 " : a(a)\n" 13502 "{\n" 13503 "}", 13504 Style); 13505 EXPECT_EQ("SomeClass::Constructor()\n" 13506 " : a(a)\n" 13507 "{\n" 13508 "}", 13509 format("SomeClass::Constructor():a(a){}", Style)); 13510 verifyFormat("SomeClass::Constructor()\n" 13511 " : a(a)\n" 13512 " , b(b)\n" 13513 " , c(c)\n" 13514 "{\n" 13515 "}", 13516 Style); 13517 verifyFormat("SomeClass::Constructor()\n" 13518 " : a(a)\n" 13519 "{\n" 13520 " foo();\n" 13521 " bar();\n" 13522 "}", 13523 Style); 13524 13525 // Access specifiers should be aligned left. 13526 verifyFormat("class C {\n" 13527 "public:\n" 13528 " int i;\n" 13529 "};", 13530 Style); 13531 13532 // Do not align comments. 13533 verifyFormat("int a; // Do not\n" 13534 "double b; // align comments.", 13535 Style); 13536 13537 // Do not align operands. 13538 EXPECT_EQ("ASSERT(aaaa\n" 13539 " || bbbb);", 13540 format("ASSERT ( aaaa\n||bbbb);", Style)); 13541 13542 // Accept input's line breaks. 13543 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 13544 " || bbbbbbbbbbbbbbb) {\n" 13545 " i++;\n" 13546 "}", 13547 format("if (aaaaaaaaaaaaaaa\n" 13548 "|| bbbbbbbbbbbbbbb) { i++; }", 13549 Style)); 13550 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 13551 " i++;\n" 13552 "}", 13553 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 13554 13555 // Don't automatically break all macro definitions (llvm.org/PR17842). 13556 verifyFormat("#define aNumber 10", Style); 13557 // However, generally keep the line breaks that the user authored. 13558 EXPECT_EQ("#define aNumber \\\n" 13559 " 10", 13560 format("#define aNumber \\\n" 13561 " 10", 13562 Style)); 13563 13564 // Keep empty and one-element array literals on a single line. 13565 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 13566 " copyItems:YES];", 13567 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 13568 "copyItems:YES];", 13569 Style)); 13570 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 13571 " copyItems:YES];", 13572 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 13573 " copyItems:YES];", 13574 Style)); 13575 // FIXME: This does not seem right, there should be more indentation before 13576 // the array literal's entries. Nested blocks have the same problem. 13577 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13578 " @\"a\",\n" 13579 " @\"a\"\n" 13580 "]\n" 13581 " copyItems:YES];", 13582 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13583 " @\"a\",\n" 13584 " @\"a\"\n" 13585 " ]\n" 13586 " copyItems:YES];", 13587 Style)); 13588 EXPECT_EQ( 13589 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13590 " copyItems:YES];", 13591 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13592 " copyItems:YES];", 13593 Style)); 13594 13595 verifyFormat("[self.a b:c c:d];", Style); 13596 EXPECT_EQ("[self.a b:c\n" 13597 " c:d];", 13598 format("[self.a b:c\n" 13599 "c:d];", 13600 Style)); 13601 } 13602 13603 TEST_F(FormatTest, FormatsLambdas) { 13604 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 13605 verifyFormat( 13606 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 13607 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 13608 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 13609 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 13610 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 13611 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 13612 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 13613 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 13614 verifyFormat("int x = f(*+[] {});"); 13615 verifyFormat("void f() {\n" 13616 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 13617 "}\n"); 13618 verifyFormat("void f() {\n" 13619 " other(x.begin(), //\n" 13620 " x.end(), //\n" 13621 " [&](int, int) { return 1; });\n" 13622 "}\n"); 13623 verifyFormat("void f() {\n" 13624 " other.other.other.other.other(\n" 13625 " x.begin(), x.end(),\n" 13626 " [something, rather](int, int, int, int, int, int, int) { " 13627 "return 1; });\n" 13628 "}\n"); 13629 verifyFormat( 13630 "void f() {\n" 13631 " other.other.other.other.other(\n" 13632 " x.begin(), x.end(),\n" 13633 " [something, rather](int, int, int, int, int, int, int) {\n" 13634 " //\n" 13635 " });\n" 13636 "}\n"); 13637 verifyFormat("SomeFunction([]() { // A cool function...\n" 13638 " return 43;\n" 13639 "});"); 13640 EXPECT_EQ("SomeFunction([]() {\n" 13641 "#define A a\n" 13642 " return 43;\n" 13643 "});", 13644 format("SomeFunction([](){\n" 13645 "#define A a\n" 13646 "return 43;\n" 13647 "});")); 13648 verifyFormat("void f() {\n" 13649 " SomeFunction([](decltype(x), A *a) {});\n" 13650 "}"); 13651 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13652 " [](const aaaaaaaaaa &a) { return a; });"); 13653 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 13654 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 13655 "});"); 13656 verifyFormat("Constructor()\n" 13657 " : Field([] { // comment\n" 13658 " int i;\n" 13659 " }) {}"); 13660 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 13661 " return some_parameter.size();\n" 13662 "};"); 13663 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 13664 " [](const string &s) { return s; };"); 13665 verifyFormat("int i = aaaaaa ? 1 //\n" 13666 " : [] {\n" 13667 " return 2; //\n" 13668 " }();"); 13669 verifyFormat("llvm::errs() << \"number of twos is \"\n" 13670 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 13671 " return x == 2; // force break\n" 13672 " });"); 13673 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13674 " [=](int iiiiiiiiiiii) {\n" 13675 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 13676 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 13677 " });", 13678 getLLVMStyleWithColumns(60)); 13679 verifyFormat("SomeFunction({[&] {\n" 13680 " // comment\n" 13681 " },\n" 13682 " [&] {\n" 13683 " // comment\n" 13684 " }});"); 13685 verifyFormat("SomeFunction({[&] {\n" 13686 " // comment\n" 13687 "}});"); 13688 verifyFormat( 13689 "virtual aaaaaaaaaaaaaaaa(\n" 13690 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 13691 " aaaaa aaaaaaaaa);"); 13692 13693 // Lambdas with return types. 13694 verifyFormat("int c = []() -> int { return 2; }();\n"); 13695 verifyFormat("int c = []() -> int * { return 2; }();\n"); 13696 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 13697 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 13698 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 13699 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 13700 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 13701 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 13702 verifyFormat("[a, a]() -> a<1> {};"); 13703 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 13704 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 13705 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 13706 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 13707 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 13708 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 13709 verifyFormat("[]() -> foo<!5> { return {}; };"); 13710 verifyFormat("[]() -> foo<~5> { return {}; };"); 13711 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 13712 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 13713 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 13714 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 13715 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 13716 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 13717 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 13718 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 13719 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 13720 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 13721 verifyFormat("namespace bar {\n" 13722 "// broken:\n" 13723 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 13724 "} // namespace bar"); 13725 verifyFormat("namespace bar {\n" 13726 "// broken:\n" 13727 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 13728 "} // namespace bar"); 13729 verifyFormat("namespace bar {\n" 13730 "// broken:\n" 13731 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 13732 "} // namespace bar"); 13733 verifyFormat("namespace bar {\n" 13734 "// broken:\n" 13735 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 13736 "} // namespace bar"); 13737 verifyFormat("namespace bar {\n" 13738 "// broken:\n" 13739 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 13740 "} // namespace bar"); 13741 verifyFormat("namespace bar {\n" 13742 "// broken:\n" 13743 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 13744 "} // namespace bar"); 13745 verifyFormat("namespace bar {\n" 13746 "// broken:\n" 13747 "auto foo{[]() -> foo<!5> { return {}; }};\n" 13748 "} // namespace bar"); 13749 verifyFormat("namespace bar {\n" 13750 "// broken:\n" 13751 "auto foo{[]() -> foo<~5> { return {}; }};\n" 13752 "} // namespace bar"); 13753 verifyFormat("namespace bar {\n" 13754 "// broken:\n" 13755 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 13756 "} // namespace bar"); 13757 verifyFormat("namespace bar {\n" 13758 "// broken:\n" 13759 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 13760 "} // namespace bar"); 13761 verifyFormat("namespace bar {\n" 13762 "// broken:\n" 13763 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 13764 "} // namespace bar"); 13765 verifyFormat("namespace bar {\n" 13766 "// broken:\n" 13767 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 13768 "} // namespace bar"); 13769 verifyFormat("namespace bar {\n" 13770 "// broken:\n" 13771 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 13772 "} // namespace bar"); 13773 verifyFormat("namespace bar {\n" 13774 "// broken:\n" 13775 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 13776 "} // namespace bar"); 13777 verifyFormat("namespace bar {\n" 13778 "// broken:\n" 13779 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 13780 "} // namespace bar"); 13781 verifyFormat("namespace bar {\n" 13782 "// broken:\n" 13783 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 13784 "} // namespace bar"); 13785 verifyFormat("namespace bar {\n" 13786 "// broken:\n" 13787 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 13788 "} // namespace bar"); 13789 verifyFormat("namespace bar {\n" 13790 "// broken:\n" 13791 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 13792 "} // namespace bar"); 13793 verifyFormat("[]() -> a<1> {};"); 13794 verifyFormat("[]() -> a<1> { ; };"); 13795 verifyFormat("[]() -> a<1> { ; }();"); 13796 verifyFormat("[a, a]() -> a<true> {};"); 13797 verifyFormat("[]() -> a<true> {};"); 13798 verifyFormat("[]() -> a<true> { ; };"); 13799 verifyFormat("[]() -> a<true> { ; }();"); 13800 verifyFormat("[a, a]() -> a<false> {};"); 13801 verifyFormat("[]() -> a<false> {};"); 13802 verifyFormat("[]() -> a<false> { ; };"); 13803 verifyFormat("[]() -> a<false> { ; }();"); 13804 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 13805 verifyFormat("namespace bar {\n" 13806 "auto foo{[]() -> foo<false> { ; }};\n" 13807 "} // namespace bar"); 13808 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 13809 " int j) -> int {\n" 13810 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 13811 "};"); 13812 verifyFormat( 13813 "aaaaaaaaaaaaaaaaaaaaaa(\n" 13814 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 13815 " return aaaaaaaaaaaaaaaaa;\n" 13816 " });", 13817 getLLVMStyleWithColumns(70)); 13818 verifyFormat("[]() //\n" 13819 " -> int {\n" 13820 " return 1; //\n" 13821 "};"); 13822 13823 // Lambdas with explicit template argument lists. 13824 verifyFormat( 13825 "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n"); 13826 13827 // Multiple lambdas in the same parentheses change indentation rules. These 13828 // lambdas are forced to start on new lines. 13829 verifyFormat("SomeFunction(\n" 13830 " []() {\n" 13831 " //\n" 13832 " },\n" 13833 " []() {\n" 13834 " //\n" 13835 " });"); 13836 13837 // A lambda passed as arg0 is always pushed to the next line. 13838 verifyFormat("SomeFunction(\n" 13839 " [this] {\n" 13840 " //\n" 13841 " },\n" 13842 " 1);\n"); 13843 13844 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like 13845 // the arg0 case above. 13846 auto Style = getGoogleStyle(); 13847 Style.BinPackArguments = false; 13848 verifyFormat("SomeFunction(\n" 13849 " a,\n" 13850 " [this] {\n" 13851 " //\n" 13852 " },\n" 13853 " b);\n", 13854 Style); 13855 verifyFormat("SomeFunction(\n" 13856 " a,\n" 13857 " [this] {\n" 13858 " //\n" 13859 " },\n" 13860 " b);\n"); 13861 13862 // A lambda with a very long line forces arg0 to be pushed out irrespective of 13863 // the BinPackArguments value (as long as the code is wide enough). 13864 verifyFormat( 13865 "something->SomeFunction(\n" 13866 " a,\n" 13867 " [this] {\n" 13868 " " 13869 "D0000000000000000000000000000000000000000000000000000000000001();\n" 13870 " },\n" 13871 " b);\n"); 13872 13873 // A multi-line lambda is pulled up as long as the introducer fits on the 13874 // previous line and there are no further args. 13875 verifyFormat("function(1, [this, that] {\n" 13876 " //\n" 13877 "});\n"); 13878 verifyFormat("function([this, that] {\n" 13879 " //\n" 13880 "});\n"); 13881 // FIXME: this format is not ideal and we should consider forcing the first 13882 // arg onto its own line. 13883 verifyFormat("function(a, b, c, //\n" 13884 " d, [this, that] {\n" 13885 " //\n" 13886 " });\n"); 13887 13888 // Multiple lambdas are treated correctly even when there is a short arg0. 13889 verifyFormat("SomeFunction(\n" 13890 " 1,\n" 13891 " [this] {\n" 13892 " //\n" 13893 " },\n" 13894 " [this] {\n" 13895 " //\n" 13896 " },\n" 13897 " 1);\n"); 13898 13899 // More complex introducers. 13900 verifyFormat("return [i, args...] {};"); 13901 13902 // Not lambdas. 13903 verifyFormat("constexpr char hello[]{\"hello\"};"); 13904 verifyFormat("double &operator[](int i) { return 0; }\n" 13905 "int i;"); 13906 verifyFormat("std::unique_ptr<int[]> foo() {}"); 13907 verifyFormat("int i = a[a][a]->f();"); 13908 verifyFormat("int i = (*b)[a]->f();"); 13909 13910 // Other corner cases. 13911 verifyFormat("void f() {\n" 13912 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 13913 " );\n" 13914 "}"); 13915 13916 // Lambdas created through weird macros. 13917 verifyFormat("void f() {\n" 13918 " MACRO((const AA &a) { return 1; });\n" 13919 " MACRO((AA &a) { return 1; });\n" 13920 "}"); 13921 13922 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 13923 " doo_dah();\n" 13924 " doo_dah();\n" 13925 " })) {\n" 13926 "}"); 13927 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 13928 " doo_dah();\n" 13929 " doo_dah();\n" 13930 " })) {\n" 13931 "}"); 13932 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n" 13933 " doo_dah();\n" 13934 " doo_dah();\n" 13935 " })) {\n" 13936 "}"); 13937 verifyFormat("auto lambda = []() {\n" 13938 " int a = 2\n" 13939 "#if A\n" 13940 " + 2\n" 13941 "#endif\n" 13942 " ;\n" 13943 "};"); 13944 13945 // Lambdas with complex multiline introducers. 13946 verifyFormat( 13947 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13948 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 13949 " -> ::std::unordered_set<\n" 13950 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 13951 " //\n" 13952 " });"); 13953 13954 FormatStyle DoNotMerge = getLLVMStyle(); 13955 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 13956 verifyFormat("auto c = []() {\n" 13957 " return b;\n" 13958 "};", 13959 "auto c = []() { return b; };", DoNotMerge); 13960 verifyFormat("auto c = []() {\n" 13961 "};", 13962 " auto c = []() {};", DoNotMerge); 13963 13964 FormatStyle MergeEmptyOnly = getLLVMStyle(); 13965 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 13966 verifyFormat("auto c = []() {\n" 13967 " return b;\n" 13968 "};", 13969 "auto c = []() {\n" 13970 " return b;\n" 13971 " };", 13972 MergeEmptyOnly); 13973 verifyFormat("auto c = []() {};", 13974 "auto c = []() {\n" 13975 "};", 13976 MergeEmptyOnly); 13977 13978 FormatStyle MergeInline = getLLVMStyle(); 13979 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 13980 verifyFormat("auto c = []() {\n" 13981 " return b;\n" 13982 "};", 13983 "auto c = []() { return b; };", MergeInline); 13984 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 13985 MergeInline); 13986 verifyFormat("function([]() { return b; }, a)", 13987 "function([]() { return b; }, a)", MergeInline); 13988 verifyFormat("function(a, []() { return b; })", 13989 "function(a, []() { return b; })", MergeInline); 13990 13991 // Check option "BraceWrapping.BeforeLambdaBody" and different state of 13992 // AllowShortLambdasOnASingleLine 13993 FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle(); 13994 LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom; 13995 LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true; 13996 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 13997 FormatStyle::ShortLambdaStyle::SLS_None; 13998 verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n" 13999 " []()\n" 14000 " {\n" 14001 " return 17;\n" 14002 " });", 14003 LLVMWithBeforeLambdaBody); 14004 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n" 14005 " []()\n" 14006 " {\n" 14007 " });", 14008 LLVMWithBeforeLambdaBody); 14009 verifyFormat("auto fct_SLS_None = []()\n" 14010 "{\n" 14011 " return 17;\n" 14012 "};", 14013 LLVMWithBeforeLambdaBody); 14014 verifyFormat("TwoNestedLambdas_SLS_None(\n" 14015 " []()\n" 14016 " {\n" 14017 " return Call(\n" 14018 " []()\n" 14019 " {\n" 14020 " return 17;\n" 14021 " });\n" 14022 " });", 14023 LLVMWithBeforeLambdaBody); 14024 verifyFormat("void Fct()\n" 14025 "{\n" 14026 " return {[]()\n" 14027 " {\n" 14028 " return 17;\n" 14029 " }};\n" 14030 "}", 14031 LLVMWithBeforeLambdaBody); 14032 14033 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14034 FormatStyle::ShortLambdaStyle::SLS_Empty; 14035 verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n" 14036 " []()\n" 14037 " {\n" 14038 " return 17;\n" 14039 " });", 14040 LLVMWithBeforeLambdaBody); 14041 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});", 14042 LLVMWithBeforeLambdaBody); 14043 verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL" 14044 "ongFunctionName_SLS_Empty(\n" 14045 " []() {});", 14046 LLVMWithBeforeLambdaBody); 14047 verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n" 14048 " []()\n" 14049 " {\n" 14050 " return 17;\n" 14051 " });", 14052 LLVMWithBeforeLambdaBody); 14053 verifyFormat("auto fct_SLS_Empty = []()\n" 14054 "{\n" 14055 " return 17;\n" 14056 "};", 14057 LLVMWithBeforeLambdaBody); 14058 verifyFormat("TwoNestedLambdas_SLS_Empty(\n" 14059 " []()\n" 14060 " {\n" 14061 " return Call([]() {});\n" 14062 " });", 14063 LLVMWithBeforeLambdaBody); 14064 verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n" 14065 " []()\n" 14066 " {\n" 14067 " return Call([]() {});\n" 14068 " });", 14069 LLVMWithBeforeLambdaBody); 14070 verifyFormat( 14071 "FctWithLongLineInLambda_SLS_Empty(\n" 14072 " []()\n" 14073 " {\n" 14074 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14075 " AndShouldNotBeConsiderAsInline,\n" 14076 " LambdaBodyMustBeBreak);\n" 14077 " });", 14078 LLVMWithBeforeLambdaBody); 14079 14080 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14081 FormatStyle::ShortLambdaStyle::SLS_Inline; 14082 verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });", 14083 LLVMWithBeforeLambdaBody); 14084 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});", 14085 LLVMWithBeforeLambdaBody); 14086 verifyFormat("auto fct_SLS_Inline = []()\n" 14087 "{\n" 14088 " return 17;\n" 14089 "};", 14090 LLVMWithBeforeLambdaBody); 14091 verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return " 14092 "17; }); });", 14093 LLVMWithBeforeLambdaBody); 14094 verifyFormat( 14095 "FctWithLongLineInLambda_SLS_Inline(\n" 14096 " []()\n" 14097 " {\n" 14098 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14099 " AndShouldNotBeConsiderAsInline,\n" 14100 " LambdaBodyMustBeBreak);\n" 14101 " });", 14102 LLVMWithBeforeLambdaBody); 14103 verifyFormat("FctWithMultipleParams_SLS_Inline(" 14104 "VeryLongParameterThatShouldAskToBeOnMultiLine,\n" 14105 " []() { return 17; });", 14106 LLVMWithBeforeLambdaBody); 14107 verifyFormat( 14108 "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });", 14109 LLVMWithBeforeLambdaBody); 14110 14111 LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine = 14112 FormatStyle::ShortLambdaStyle::SLS_All; 14113 verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });", 14114 LLVMWithBeforeLambdaBody); 14115 verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});", 14116 LLVMWithBeforeLambdaBody); 14117 verifyFormat("auto fct_SLS_All = []() { return 17; };", 14118 LLVMWithBeforeLambdaBody); 14119 verifyFormat("FctWithOneParam_SLS_All(\n" 14120 " []()\n" 14121 " {\n" 14122 " // A cool function...\n" 14123 " return 43;\n" 14124 " });", 14125 LLVMWithBeforeLambdaBody); 14126 verifyFormat("FctWithMultipleParams_SLS_All(" 14127 "VeryLongParameterThatShouldAskToBeOnMultiLine,\n" 14128 " []() { return 17; });", 14129 LLVMWithBeforeLambdaBody); 14130 verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });", 14131 LLVMWithBeforeLambdaBody); 14132 verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });", 14133 LLVMWithBeforeLambdaBody); 14134 verifyFormat( 14135 "FctWithLongLineInLambda_SLS_All(\n" 14136 " []()\n" 14137 " {\n" 14138 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14139 " AndShouldNotBeConsiderAsInline,\n" 14140 " LambdaBodyMustBeBreak);\n" 14141 " });", 14142 LLVMWithBeforeLambdaBody); 14143 verifyFormat( 14144 "auto fct_SLS_All = []()\n" 14145 "{\n" 14146 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14147 " AndShouldNotBeConsiderAsInline,\n" 14148 " LambdaBodyMustBeBreak);\n" 14149 "};", 14150 LLVMWithBeforeLambdaBody); 14151 LLVMWithBeforeLambdaBody.BinPackParameters = false; 14152 verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);", 14153 LLVMWithBeforeLambdaBody); 14154 verifyFormat( 14155 "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n" 14156 " FirstParam,\n" 14157 " SecondParam,\n" 14158 " ThirdParam,\n" 14159 " FourthParam);", 14160 LLVMWithBeforeLambdaBody); 14161 verifyFormat("FctWithLongLineInLambda_SLS_All(\n" 14162 " []() { return " 14163 "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n" 14164 " FirstParam,\n" 14165 " SecondParam,\n" 14166 " ThirdParam,\n" 14167 " FourthParam);", 14168 LLVMWithBeforeLambdaBody); 14169 verifyFormat( 14170 "FctWithLongLineInLambda_SLS_All(FirstParam,\n" 14171 " SecondParam,\n" 14172 " ThirdParam,\n" 14173 " FourthParam,\n" 14174 " []() { return SomeValueNotSoLong; });", 14175 LLVMWithBeforeLambdaBody); 14176 verifyFormat("FctWithLongLineInLambda_SLS_All(\n" 14177 " []()\n" 14178 " {\n" 14179 " return " 14180 "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB" 14181 "eConsiderAsInline;\n" 14182 " });", 14183 LLVMWithBeforeLambdaBody); 14184 verifyFormat( 14185 "FctWithLongLineInLambda_SLS_All(\n" 14186 " []()\n" 14187 " {\n" 14188 " return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n" 14189 " AndShouldNotBeConsiderAsInline,\n" 14190 " LambdaBodyMustBeBreak);\n" 14191 " });", 14192 LLVMWithBeforeLambdaBody); 14193 verifyFormat("FctWithTwoParams_SLS_All(\n" 14194 " []()\n" 14195 " {\n" 14196 " // A cool function...\n" 14197 " return 43;\n" 14198 " },\n" 14199 " 87);", 14200 LLVMWithBeforeLambdaBody); 14201 verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);", 14202 LLVMWithBeforeLambdaBody); 14203 verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });", 14204 LLVMWithBeforeLambdaBody); 14205 verifyFormat( 14206 "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });", 14207 LLVMWithBeforeLambdaBody); 14208 verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; " 14209 "}); }, x);", 14210 LLVMWithBeforeLambdaBody); 14211 verifyFormat("TwoNestedLambdas_SLS_All(\n" 14212 " []()\n" 14213 " {\n" 14214 " // A cool function...\n" 14215 " return Call([]() { return 17; });\n" 14216 " });", 14217 LLVMWithBeforeLambdaBody); 14218 verifyFormat("TwoNestedLambdas_SLS_All(\n" 14219 " []()\n" 14220 " {\n" 14221 " return Call(\n" 14222 " []()\n" 14223 " {\n" 14224 " // A cool function...\n" 14225 " return 17;\n" 14226 " });\n" 14227 " });", 14228 LLVMWithBeforeLambdaBody); 14229 } 14230 14231 TEST_F(FormatTest, EmptyLinesInLambdas) { 14232 verifyFormat("auto lambda = []() {\n" 14233 " x(); //\n" 14234 "};", 14235 "auto lambda = []() {\n" 14236 "\n" 14237 " x(); //\n" 14238 "\n" 14239 "};"); 14240 } 14241 14242 TEST_F(FormatTest, FormatsBlocks) { 14243 FormatStyle ShortBlocks = getLLVMStyle(); 14244 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 14245 verifyFormat("int (^Block)(int, int);", ShortBlocks); 14246 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 14247 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 14248 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 14249 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 14250 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 14251 14252 verifyFormat("foo(^{ bar(); });", ShortBlocks); 14253 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 14254 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 14255 14256 verifyFormat("[operation setCompletionBlock:^{\n" 14257 " [self onOperationDone];\n" 14258 "}];"); 14259 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 14260 " [self onOperationDone];\n" 14261 "}]};"); 14262 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 14263 " f();\n" 14264 "}];"); 14265 verifyFormat("int a = [operation block:^int(int *i) {\n" 14266 " return 1;\n" 14267 "}];"); 14268 verifyFormat("[myObject doSomethingWith:arg1\n" 14269 " aaa:^int(int *a) {\n" 14270 " return 1;\n" 14271 " }\n" 14272 " bbb:f(a * bbbbbbbb)];"); 14273 14274 verifyFormat("[operation setCompletionBlock:^{\n" 14275 " [self.delegate newDataAvailable];\n" 14276 "}];", 14277 getLLVMStyleWithColumns(60)); 14278 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 14279 " NSString *path = [self sessionFilePath];\n" 14280 " if (path) {\n" 14281 " // ...\n" 14282 " }\n" 14283 "});"); 14284 verifyFormat("[[SessionService sharedService]\n" 14285 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14286 " if (window) {\n" 14287 " [self windowDidLoad:window];\n" 14288 " } else {\n" 14289 " [self errorLoadingWindow];\n" 14290 " }\n" 14291 " }];"); 14292 verifyFormat("void (^largeBlock)(void) = ^{\n" 14293 " // ...\n" 14294 "};\n", 14295 getLLVMStyleWithColumns(40)); 14296 verifyFormat("[[SessionService sharedService]\n" 14297 " loadWindowWithCompletionBlock: //\n" 14298 " ^(SessionWindow *window) {\n" 14299 " if (window) {\n" 14300 " [self windowDidLoad:window];\n" 14301 " } else {\n" 14302 " [self errorLoadingWindow];\n" 14303 " }\n" 14304 " }];", 14305 getLLVMStyleWithColumns(60)); 14306 verifyFormat("[myObject doSomethingWith:arg1\n" 14307 " firstBlock:^(Foo *a) {\n" 14308 " // ...\n" 14309 " int i;\n" 14310 " }\n" 14311 " secondBlock:^(Bar *b) {\n" 14312 " // ...\n" 14313 " int i;\n" 14314 " }\n" 14315 " thirdBlock:^Foo(Bar *b) {\n" 14316 " // ...\n" 14317 " int i;\n" 14318 " }];"); 14319 verifyFormat("[myObject doSomethingWith:arg1\n" 14320 " firstBlock:-1\n" 14321 " secondBlock:^(Bar *b) {\n" 14322 " // ...\n" 14323 " int i;\n" 14324 " }];"); 14325 14326 verifyFormat("f(^{\n" 14327 " @autoreleasepool {\n" 14328 " if (a) {\n" 14329 " g();\n" 14330 " }\n" 14331 " }\n" 14332 "});"); 14333 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 14334 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 14335 "};"); 14336 14337 FormatStyle FourIndent = getLLVMStyle(); 14338 FourIndent.ObjCBlockIndentWidth = 4; 14339 verifyFormat("[operation setCompletionBlock:^{\n" 14340 " [self onOperationDone];\n" 14341 "}];", 14342 FourIndent); 14343 } 14344 14345 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 14346 FormatStyle ZeroColumn = getLLVMStyle(); 14347 ZeroColumn.ColumnLimit = 0; 14348 14349 verifyFormat("[[SessionService sharedService] " 14350 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14351 " if (window) {\n" 14352 " [self windowDidLoad:window];\n" 14353 " } else {\n" 14354 " [self errorLoadingWindow];\n" 14355 " }\n" 14356 "}];", 14357 ZeroColumn); 14358 EXPECT_EQ("[[SessionService sharedService]\n" 14359 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14360 " if (window) {\n" 14361 " [self windowDidLoad:window];\n" 14362 " } else {\n" 14363 " [self errorLoadingWindow];\n" 14364 " }\n" 14365 " }];", 14366 format("[[SessionService sharedService]\n" 14367 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14368 " if (window) {\n" 14369 " [self windowDidLoad:window];\n" 14370 " } else {\n" 14371 " [self errorLoadingWindow];\n" 14372 " }\n" 14373 "}];", 14374 ZeroColumn)); 14375 verifyFormat("[myObject doSomethingWith:arg1\n" 14376 " firstBlock:^(Foo *a) {\n" 14377 " // ...\n" 14378 " int i;\n" 14379 " }\n" 14380 " secondBlock:^(Bar *b) {\n" 14381 " // ...\n" 14382 " int i;\n" 14383 " }\n" 14384 " thirdBlock:^Foo(Bar *b) {\n" 14385 " // ...\n" 14386 " int i;\n" 14387 " }];", 14388 ZeroColumn); 14389 verifyFormat("f(^{\n" 14390 " @autoreleasepool {\n" 14391 " if (a) {\n" 14392 " g();\n" 14393 " }\n" 14394 " }\n" 14395 "});", 14396 ZeroColumn); 14397 verifyFormat("void (^largeBlock)(void) = ^{\n" 14398 " // ...\n" 14399 "};", 14400 ZeroColumn); 14401 14402 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 14403 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 14404 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 14405 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 14406 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 14407 " int i;\n" 14408 "};", 14409 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 14410 } 14411 14412 TEST_F(FormatTest, SupportsCRLF) { 14413 EXPECT_EQ("int a;\r\n" 14414 "int b;\r\n" 14415 "int c;\r\n", 14416 format("int a;\r\n" 14417 " int b;\r\n" 14418 " int c;\r\n", 14419 getLLVMStyle())); 14420 EXPECT_EQ("int a;\r\n" 14421 "int b;\r\n" 14422 "int c;\r\n", 14423 format("int a;\r\n" 14424 " int b;\n" 14425 " int c;\r\n", 14426 getLLVMStyle())); 14427 EXPECT_EQ("int a;\n" 14428 "int b;\n" 14429 "int c;\n", 14430 format("int a;\r\n" 14431 " int b;\n" 14432 " int c;\n", 14433 getLLVMStyle())); 14434 EXPECT_EQ("\"aaaaaaa \"\r\n" 14435 "\"bbbbbbb\";\r\n", 14436 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 14437 EXPECT_EQ("#define A \\\r\n" 14438 " b; \\\r\n" 14439 " c; \\\r\n" 14440 " d;\r\n", 14441 format("#define A \\\r\n" 14442 " b; \\\r\n" 14443 " c; d; \r\n", 14444 getGoogleStyle())); 14445 14446 EXPECT_EQ("/*\r\n" 14447 "multi line block comments\r\n" 14448 "should not introduce\r\n" 14449 "an extra carriage return\r\n" 14450 "*/\r\n", 14451 format("/*\r\n" 14452 "multi line block comments\r\n" 14453 "should not introduce\r\n" 14454 "an extra carriage return\r\n" 14455 "*/\r\n")); 14456 EXPECT_EQ("/*\r\n" 14457 "\r\n" 14458 "*/", 14459 format("/*\r\n" 14460 " \r\r\r\n" 14461 "*/")); 14462 14463 FormatStyle style = getLLVMStyle(); 14464 14465 style.DeriveLineEnding = true; 14466 style.UseCRLF = false; 14467 EXPECT_EQ("union FooBarBazQux {\n" 14468 " int foo;\n" 14469 " int bar;\n" 14470 " int baz;\n" 14471 "};", 14472 format("union FooBarBazQux {\r\n" 14473 " int foo;\n" 14474 " int bar;\r\n" 14475 " int baz;\n" 14476 "};", 14477 style)); 14478 style.UseCRLF = true; 14479 EXPECT_EQ("union FooBarBazQux {\r\n" 14480 " int foo;\r\n" 14481 " int bar;\r\n" 14482 " int baz;\r\n" 14483 "};", 14484 format("union FooBarBazQux {\r\n" 14485 " int foo;\n" 14486 " int bar;\r\n" 14487 " int baz;\n" 14488 "};", 14489 style)); 14490 14491 style.DeriveLineEnding = false; 14492 style.UseCRLF = false; 14493 EXPECT_EQ("union FooBarBazQux {\n" 14494 " int foo;\n" 14495 " int bar;\n" 14496 " int baz;\n" 14497 " int qux;\n" 14498 "};", 14499 format("union FooBarBazQux {\r\n" 14500 " int foo;\n" 14501 " int bar;\r\n" 14502 " int baz;\n" 14503 " int qux;\r\n" 14504 "};", 14505 style)); 14506 style.UseCRLF = true; 14507 EXPECT_EQ("union FooBarBazQux {\r\n" 14508 " int foo;\r\n" 14509 " int bar;\r\n" 14510 " int baz;\r\n" 14511 " int qux;\r\n" 14512 "};", 14513 format("union FooBarBazQux {\r\n" 14514 " int foo;\n" 14515 " int bar;\r\n" 14516 " int baz;\n" 14517 " int qux;\n" 14518 "};", 14519 style)); 14520 14521 style.DeriveLineEnding = true; 14522 style.UseCRLF = false; 14523 EXPECT_EQ("union FooBarBazQux {\r\n" 14524 " int foo;\r\n" 14525 " int bar;\r\n" 14526 " int baz;\r\n" 14527 " int qux;\r\n" 14528 "};", 14529 format("union FooBarBazQux {\r\n" 14530 " int foo;\n" 14531 " int bar;\r\n" 14532 " int baz;\n" 14533 " int qux;\r\n" 14534 "};", 14535 style)); 14536 style.UseCRLF = true; 14537 EXPECT_EQ("union FooBarBazQux {\n" 14538 " int foo;\n" 14539 " int bar;\n" 14540 " int baz;\n" 14541 " int qux;\n" 14542 "};", 14543 format("union FooBarBazQux {\r\n" 14544 " int foo;\n" 14545 " int bar;\r\n" 14546 " int baz;\n" 14547 " int qux;\n" 14548 "};", 14549 style)); 14550 } 14551 14552 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 14553 verifyFormat("MY_CLASS(C) {\n" 14554 " int i;\n" 14555 " int j;\n" 14556 "};"); 14557 } 14558 14559 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 14560 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 14561 TwoIndent.ContinuationIndentWidth = 2; 14562 14563 EXPECT_EQ("int i =\n" 14564 " longFunction(\n" 14565 " arg);", 14566 format("int i = longFunction(arg);", TwoIndent)); 14567 14568 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 14569 SixIndent.ContinuationIndentWidth = 6; 14570 14571 EXPECT_EQ("int i =\n" 14572 " longFunction(\n" 14573 " arg);", 14574 format("int i = longFunction(arg);", SixIndent)); 14575 } 14576 14577 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 14578 FormatStyle Style = getLLVMStyle(); 14579 verifyFormat("int Foo::getter(\n" 14580 " //\n" 14581 ") const {\n" 14582 " return foo;\n" 14583 "}", 14584 Style); 14585 verifyFormat("void Foo::setter(\n" 14586 " //\n" 14587 ") {\n" 14588 " foo = 1;\n" 14589 "}", 14590 Style); 14591 } 14592 14593 TEST_F(FormatTest, SpacesInAngles) { 14594 FormatStyle Spaces = getLLVMStyle(); 14595 Spaces.SpacesInAngles = true; 14596 14597 verifyFormat("static_cast< int >(arg);", Spaces); 14598 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 14599 verifyFormat("f< int, float >();", Spaces); 14600 verifyFormat("template <> g() {}", Spaces); 14601 verifyFormat("template < std::vector< int > > f() {}", Spaces); 14602 verifyFormat("std::function< void(int, int) > fct;", Spaces); 14603 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 14604 Spaces); 14605 14606 Spaces.Standard = FormatStyle::LS_Cpp03; 14607 Spaces.SpacesInAngles = true; 14608 verifyFormat("A< A< int > >();", Spaces); 14609 14610 Spaces.SpacesInAngles = false; 14611 verifyFormat("A<A<int> >();", Spaces); 14612 14613 Spaces.Standard = FormatStyle::LS_Cpp11; 14614 Spaces.SpacesInAngles = true; 14615 verifyFormat("A< A< int > >();", Spaces); 14616 14617 Spaces.SpacesInAngles = false; 14618 verifyFormat("A<A<int>>();", Spaces); 14619 } 14620 14621 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 14622 FormatStyle Style = getLLVMStyle(); 14623 Style.SpaceAfterTemplateKeyword = false; 14624 verifyFormat("template<int> void foo();", Style); 14625 } 14626 14627 TEST_F(FormatTest, TripleAngleBrackets) { 14628 verifyFormat("f<<<1, 1>>>();"); 14629 verifyFormat("f<<<1, 1, 1, s>>>();"); 14630 verifyFormat("f<<<a, b, c, d>>>();"); 14631 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 14632 verifyFormat("f<param><<<1, 1>>>();"); 14633 verifyFormat("f<1><<<1, 1>>>();"); 14634 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 14635 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14636 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 14637 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 14638 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 14639 } 14640 14641 TEST_F(FormatTest, MergeLessLessAtEnd) { 14642 verifyFormat("<<"); 14643 EXPECT_EQ("< < <", format("\\\n<<<")); 14644 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14645 "aaallvm::outs() <<"); 14646 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14647 "aaaallvm::outs()\n <<"); 14648 } 14649 14650 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 14651 std::string code = "#if A\n" 14652 "#if B\n" 14653 "a.\n" 14654 "#endif\n" 14655 " a = 1;\n" 14656 "#else\n" 14657 "#endif\n" 14658 "#if C\n" 14659 "#else\n" 14660 "#endif\n"; 14661 EXPECT_EQ(code, format(code)); 14662 } 14663 14664 TEST_F(FormatTest, HandleConflictMarkers) { 14665 // Git/SVN conflict markers. 14666 EXPECT_EQ("int a;\n" 14667 "void f() {\n" 14668 " callme(some(parameter1,\n" 14669 "<<<<<<< text by the vcs\n" 14670 " parameter2),\n" 14671 "||||||| text by the vcs\n" 14672 " parameter2),\n" 14673 " parameter3,\n" 14674 "======= text by the vcs\n" 14675 " parameter2, parameter3),\n" 14676 ">>>>>>> text by the vcs\n" 14677 " otherparameter);\n", 14678 format("int a;\n" 14679 "void f() {\n" 14680 " callme(some(parameter1,\n" 14681 "<<<<<<< text by the vcs\n" 14682 " parameter2),\n" 14683 "||||||| text by the vcs\n" 14684 " parameter2),\n" 14685 " parameter3,\n" 14686 "======= text by the vcs\n" 14687 " parameter2,\n" 14688 " parameter3),\n" 14689 ">>>>>>> text by the vcs\n" 14690 " otherparameter);\n")); 14691 14692 // Perforce markers. 14693 EXPECT_EQ("void f() {\n" 14694 " function(\n" 14695 ">>>> text by the vcs\n" 14696 " parameter,\n" 14697 "==== text by the vcs\n" 14698 " parameter,\n" 14699 "==== text by the vcs\n" 14700 " parameter,\n" 14701 "<<<< text by the vcs\n" 14702 " parameter);\n", 14703 format("void f() {\n" 14704 " function(\n" 14705 ">>>> text by the vcs\n" 14706 " parameter,\n" 14707 "==== text by the vcs\n" 14708 " parameter,\n" 14709 "==== text by the vcs\n" 14710 " parameter,\n" 14711 "<<<< text by the vcs\n" 14712 " parameter);\n")); 14713 14714 EXPECT_EQ("<<<<<<<\n" 14715 "|||||||\n" 14716 "=======\n" 14717 ">>>>>>>", 14718 format("<<<<<<<\n" 14719 "|||||||\n" 14720 "=======\n" 14721 ">>>>>>>")); 14722 14723 EXPECT_EQ("<<<<<<<\n" 14724 "|||||||\n" 14725 "int i;\n" 14726 "=======\n" 14727 ">>>>>>>", 14728 format("<<<<<<<\n" 14729 "|||||||\n" 14730 "int i;\n" 14731 "=======\n" 14732 ">>>>>>>")); 14733 14734 // FIXME: Handle parsing of macros around conflict markers correctly: 14735 EXPECT_EQ("#define Macro \\\n" 14736 "<<<<<<<\n" 14737 "Something \\\n" 14738 "|||||||\n" 14739 "Else \\\n" 14740 "=======\n" 14741 "Other \\\n" 14742 ">>>>>>>\n" 14743 " End int i;\n", 14744 format("#define Macro \\\n" 14745 "<<<<<<<\n" 14746 " Something \\\n" 14747 "|||||||\n" 14748 " Else \\\n" 14749 "=======\n" 14750 " Other \\\n" 14751 ">>>>>>>\n" 14752 " End\n" 14753 "int i;\n")); 14754 } 14755 14756 TEST_F(FormatTest, DisableRegions) { 14757 EXPECT_EQ("int i;\n" 14758 "// clang-format off\n" 14759 " int j;\n" 14760 "// clang-format on\n" 14761 "int k;", 14762 format(" int i;\n" 14763 " // clang-format off\n" 14764 " int j;\n" 14765 " // clang-format on\n" 14766 " int k;")); 14767 EXPECT_EQ("int i;\n" 14768 "/* clang-format off */\n" 14769 " int j;\n" 14770 "/* clang-format on */\n" 14771 "int k;", 14772 format(" int i;\n" 14773 " /* clang-format off */\n" 14774 " int j;\n" 14775 " /* clang-format on */\n" 14776 " int k;")); 14777 14778 // Don't reflow comments within disabled regions. 14779 EXPECT_EQ("// clang-format off\n" 14780 "// long long long long long long line\n" 14781 "/* clang-format on */\n" 14782 "/* long long long\n" 14783 " * long long long\n" 14784 " * line */\n" 14785 "int i;\n" 14786 "/* clang-format off */\n" 14787 "/* long long long long long long line */\n", 14788 format("// clang-format off\n" 14789 "// long long long long long long line\n" 14790 "/* clang-format on */\n" 14791 "/* long long long long long long line */\n" 14792 "int i;\n" 14793 "/* clang-format off */\n" 14794 "/* long long long long long long line */\n", 14795 getLLVMStyleWithColumns(20))); 14796 } 14797 14798 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 14799 format("? ) ="); 14800 verifyNoCrash("#define a\\\n /**/}"); 14801 } 14802 14803 TEST_F(FormatTest, FormatsTableGenCode) { 14804 FormatStyle Style = getLLVMStyle(); 14805 Style.Language = FormatStyle::LK_TableGen; 14806 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 14807 } 14808 14809 TEST_F(FormatTest, ArrayOfTemplates) { 14810 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 14811 format("auto a = new unique_ptr<int > [ 10];")); 14812 14813 FormatStyle Spaces = getLLVMStyle(); 14814 Spaces.SpacesInSquareBrackets = true; 14815 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 14816 format("auto a = new unique_ptr<int > [10];", Spaces)); 14817 } 14818 14819 TEST_F(FormatTest, ArrayAsTemplateType) { 14820 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 14821 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 14822 14823 FormatStyle Spaces = getLLVMStyle(); 14824 Spaces.SpacesInSquareBrackets = true; 14825 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 14826 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 14827 } 14828 14829 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); } 14830 14831 TEST(FormatStyle, GetStyleWithEmptyFileName) { 14832 llvm::vfs::InMemoryFileSystem FS; 14833 auto Style1 = getStyle("file", "", "Google", "", &FS); 14834 ASSERT_TRUE((bool)Style1); 14835 ASSERT_EQ(*Style1, getGoogleStyle()); 14836 } 14837 14838 TEST(FormatStyle, GetStyleOfFile) { 14839 llvm::vfs::InMemoryFileSystem FS; 14840 // Test 1: format file in the same directory. 14841 ASSERT_TRUE( 14842 FS.addFile("/a/.clang-format", 0, 14843 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 14844 ASSERT_TRUE( 14845 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14846 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 14847 ASSERT_TRUE((bool)Style1); 14848 ASSERT_EQ(*Style1, getLLVMStyle()); 14849 14850 // Test 2.1: fallback to default. 14851 ASSERT_TRUE( 14852 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14853 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 14854 ASSERT_TRUE((bool)Style2); 14855 ASSERT_EQ(*Style2, getMozillaStyle()); 14856 14857 // Test 2.2: no format on 'none' fallback style. 14858 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 14859 ASSERT_TRUE((bool)Style2); 14860 ASSERT_EQ(*Style2, getNoStyle()); 14861 14862 // Test 2.3: format if config is found with no based style while fallback is 14863 // 'none'. 14864 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 14865 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 14866 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 14867 ASSERT_TRUE((bool)Style2); 14868 ASSERT_EQ(*Style2, getLLVMStyle()); 14869 14870 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 14871 Style2 = getStyle("{}", "a.h", "none", "", &FS); 14872 ASSERT_TRUE((bool)Style2); 14873 ASSERT_EQ(*Style2, getLLVMStyle()); 14874 14875 // Test 3: format file in parent directory. 14876 ASSERT_TRUE( 14877 FS.addFile("/c/.clang-format", 0, 14878 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 14879 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 14880 llvm::MemoryBuffer::getMemBuffer("int i;"))); 14881 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 14882 ASSERT_TRUE((bool)Style3); 14883 ASSERT_EQ(*Style3, getGoogleStyle()); 14884 14885 // Test 4: error on invalid fallback style 14886 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 14887 ASSERT_FALSE((bool)Style4); 14888 llvm::consumeError(Style4.takeError()); 14889 14890 // Test 5: error on invalid yaml on command line 14891 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 14892 ASSERT_FALSE((bool)Style5); 14893 llvm::consumeError(Style5.takeError()); 14894 14895 // Test 6: error on invalid style 14896 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 14897 ASSERT_FALSE((bool)Style6); 14898 llvm::consumeError(Style6.takeError()); 14899 14900 // Test 7: found config file, error on parsing it 14901 ASSERT_TRUE( 14902 FS.addFile("/d/.clang-format", 0, 14903 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 14904 "InvalidKey: InvalidValue"))); 14905 ASSERT_TRUE( 14906 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14907 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 14908 ASSERT_FALSE((bool)Style7); 14909 llvm::consumeError(Style7.takeError()); 14910 14911 // Test 8: inferred per-language defaults apply. 14912 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 14913 ASSERT_TRUE((bool)StyleTd); 14914 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 14915 } 14916 14917 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 14918 // Column limit is 20. 14919 std::string Code = "Type *a =\n" 14920 " new Type();\n" 14921 "g(iiiii, 0, jjjjj,\n" 14922 " 0, kkkkk, 0, mm);\n" 14923 "int bad = format ;"; 14924 std::string Expected = "auto a = new Type();\n" 14925 "g(iiiii, nullptr,\n" 14926 " jjjjj, nullptr,\n" 14927 " kkkkk, nullptr,\n" 14928 " mm);\n" 14929 "int bad = format ;"; 14930 FileID ID = Context.createInMemoryFile("format.cpp", Code); 14931 tooling::Replacements Replaces = toReplacements( 14932 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 14933 "auto "), 14934 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 14935 "nullptr"), 14936 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 14937 "nullptr"), 14938 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 14939 "nullptr")}); 14940 14941 format::FormatStyle Style = format::getLLVMStyle(); 14942 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 14943 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 14944 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 14945 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 14946 auto Result = applyAllReplacements(Code, *FormattedReplaces); 14947 EXPECT_TRUE(static_cast<bool>(Result)); 14948 EXPECT_EQ(Expected, *Result); 14949 } 14950 14951 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 14952 std::string Code = "#include \"a.h\"\n" 14953 "#include \"c.h\"\n" 14954 "\n" 14955 "int main() {\n" 14956 " return 0;\n" 14957 "}"; 14958 std::string Expected = "#include \"a.h\"\n" 14959 "#include \"b.h\"\n" 14960 "#include \"c.h\"\n" 14961 "\n" 14962 "int main() {\n" 14963 " return 0;\n" 14964 "}"; 14965 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 14966 tooling::Replacements Replaces = toReplacements( 14967 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 14968 "#include \"b.h\"\n")}); 14969 14970 format::FormatStyle Style = format::getLLVMStyle(); 14971 Style.SortIncludes = true; 14972 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 14973 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 14974 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 14975 auto Result = applyAllReplacements(Code, *FormattedReplaces); 14976 EXPECT_TRUE(static_cast<bool>(Result)); 14977 EXPECT_EQ(Expected, *Result); 14978 } 14979 14980 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 14981 EXPECT_EQ("using std::cin;\n" 14982 "using std::cout;", 14983 format("using std::cout;\n" 14984 "using std::cin;", 14985 getGoogleStyle())); 14986 } 14987 14988 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 14989 format::FormatStyle Style = format::getLLVMStyle(); 14990 Style.Standard = FormatStyle::LS_Cpp03; 14991 // cpp03 recognize this string as identifier u8 and literal character 'a' 14992 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 14993 } 14994 14995 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 14996 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 14997 // all modes, including C++11, C++14 and C++17 14998 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 14999 } 15000 15001 TEST_F(FormatTest, DoNotFormatLikelyXml) { 15002 EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle())); 15003 EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle())); 15004 } 15005 15006 TEST_F(FormatTest, StructuredBindings) { 15007 // Structured bindings is a C++17 feature. 15008 // all modes, including C++11, C++14 and C++17 15009 verifyFormat("auto [a, b] = f();"); 15010 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 15011 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 15012 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 15013 EXPECT_EQ("auto const volatile [a, b] = f();", 15014 format("auto const volatile[a, b] = f();")); 15015 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 15016 EXPECT_EQ("auto &[a, b, c] = f();", 15017 format("auto &[ a , b,c ] = f();")); 15018 EXPECT_EQ("auto &&[a, b, c] = f();", 15019 format("auto &&[ a , b,c ] = f();")); 15020 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 15021 EXPECT_EQ("auto const volatile &&[a, b] = f();", 15022 format("auto const volatile &&[a, b] = f();")); 15023 EXPECT_EQ("auto const &&[a, b] = f();", 15024 format("auto const && [a, b] = f();")); 15025 EXPECT_EQ("const auto &[a, b] = f();", 15026 format("const auto & [a, b] = f();")); 15027 EXPECT_EQ("const auto volatile &&[a, b] = f();", 15028 format("const auto volatile &&[a, b] = f();")); 15029 EXPECT_EQ("volatile const auto &&[a, b] = f();", 15030 format("volatile const auto &&[a, b] = f();")); 15031 EXPECT_EQ("const auto &&[a, b] = f();", 15032 format("const auto && [a, b] = f();")); 15033 15034 // Make sure we don't mistake structured bindings for lambdas. 15035 FormatStyle PointerMiddle = getLLVMStyle(); 15036 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 15037 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 15038 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 15039 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 15040 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 15041 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 15042 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 15043 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 15044 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 15045 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 15046 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 15047 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 15048 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 15049 15050 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 15051 format("for (const auto && [a, b] : some_range) {\n}")); 15052 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 15053 format("for (const auto & [a, b] : some_range) {\n}")); 15054 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 15055 format("for (const auto[a, b] : some_range) {\n}")); 15056 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 15057 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 15058 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 15059 EXPECT_EQ("auto const &[x, y](expr);", 15060 format("auto const & [x,y] (expr);")); 15061 EXPECT_EQ("auto const &&[x, y](expr);", 15062 format("auto const && [x,y] (expr);")); 15063 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 15064 EXPECT_EQ("auto const &[x, y]{expr};", 15065 format("auto const & [x,y] {expr};")); 15066 EXPECT_EQ("auto const &&[x, y]{expr};", 15067 format("auto const && [x,y] {expr};")); 15068 15069 format::FormatStyle Spaces = format::getLLVMStyle(); 15070 Spaces.SpacesInSquareBrackets = true; 15071 verifyFormat("auto [ a, b ] = f();", Spaces); 15072 verifyFormat("auto &&[ a, b ] = f();", Spaces); 15073 verifyFormat("auto &[ a, b ] = f();", Spaces); 15074 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 15075 verifyFormat("auto const &[ a, b ] = f();", Spaces); 15076 } 15077 15078 TEST_F(FormatTest, FileAndCode) { 15079 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 15080 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 15081 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 15082 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 15083 EXPECT_EQ(FormatStyle::LK_ObjC, 15084 guessLanguage("foo.h", "@interface Foo\n@end\n")); 15085 EXPECT_EQ( 15086 FormatStyle::LK_ObjC, 15087 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 15088 EXPECT_EQ(FormatStyle::LK_ObjC, 15089 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 15090 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 15091 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 15092 EXPECT_EQ(FormatStyle::LK_ObjC, 15093 guessLanguage("foo", "@interface Foo\n@end\n")); 15094 EXPECT_EQ(FormatStyle::LK_ObjC, 15095 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 15096 EXPECT_EQ( 15097 FormatStyle::LK_ObjC, 15098 guessLanguage("foo.h", 15099 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 15100 EXPECT_EQ( 15101 FormatStyle::LK_Cpp, 15102 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 15103 } 15104 15105 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 15106 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 15107 EXPECT_EQ(FormatStyle::LK_ObjC, 15108 guessLanguage("foo.h", "array[[calculator getIndex]];")); 15109 EXPECT_EQ(FormatStyle::LK_Cpp, 15110 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 15111 EXPECT_EQ( 15112 FormatStyle::LK_Cpp, 15113 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 15114 EXPECT_EQ(FormatStyle::LK_ObjC, 15115 guessLanguage("foo.h", "[[noreturn foo] bar];")); 15116 EXPECT_EQ(FormatStyle::LK_Cpp, 15117 guessLanguage("foo.h", "[[clang::fallthrough]];")); 15118 EXPECT_EQ(FormatStyle::LK_ObjC, 15119 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 15120 EXPECT_EQ(FormatStyle::LK_Cpp, 15121 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 15122 EXPECT_EQ(FormatStyle::LK_Cpp, 15123 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 15124 EXPECT_EQ(FormatStyle::LK_ObjC, 15125 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 15126 EXPECT_EQ(FormatStyle::LK_Cpp, 15127 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 15128 EXPECT_EQ( 15129 FormatStyle::LK_Cpp, 15130 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 15131 EXPECT_EQ( 15132 FormatStyle::LK_Cpp, 15133 guessLanguage("foo.h", 15134 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 15135 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 15136 } 15137 15138 TEST_F(FormatTest, GuessLanguageWithCaret) { 15139 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 15140 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 15141 EXPECT_EQ(FormatStyle::LK_ObjC, 15142 guessLanguage("foo.h", "int(^)(char, float);")); 15143 EXPECT_EQ(FormatStyle::LK_ObjC, 15144 guessLanguage("foo.h", "int(^foo)(char, float);")); 15145 EXPECT_EQ(FormatStyle::LK_ObjC, 15146 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 15147 EXPECT_EQ(FormatStyle::LK_ObjC, 15148 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 15149 EXPECT_EQ( 15150 FormatStyle::LK_ObjC, 15151 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 15152 } 15153 15154 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) { 15155 // ASM symbolic names are identifiers that must be surrounded by [] without 15156 // space in between: 15157 // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands 15158 15159 // Example from https://bugs.llvm.org/show_bug.cgi?id=45108. 15160 verifyFormat(R"(// 15161 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result)); 15162 )"); 15163 15164 // A list of several ASM symbolic names. 15165 verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)"); 15166 15167 // ASM symbolic names in inline ASM with inputs and outputs. 15168 verifyFormat(R"(// 15169 asm("cmoveq %1, %2, %[result]" 15170 : [result] "=r"(result) 15171 : "r"(test), "r"(new), "[result]"(old)); 15172 )"); 15173 15174 // ASM symbolic names in inline ASM with no outputs. 15175 verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)"); 15176 } 15177 15178 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 15179 EXPECT_EQ(FormatStyle::LK_Cpp, 15180 guessLanguage("foo.h", "void f() {\n" 15181 " asm (\"mov %[e], %[d]\"\n" 15182 " : [d] \"=rm\" (d)\n" 15183 " [e] \"rm\" (*e));\n" 15184 "}")); 15185 EXPECT_EQ(FormatStyle::LK_Cpp, 15186 guessLanguage("foo.h", "void f() {\n" 15187 " _asm (\"mov %[e], %[d]\"\n" 15188 " : [d] \"=rm\" (d)\n" 15189 " [e] \"rm\" (*e));\n" 15190 "}")); 15191 EXPECT_EQ(FormatStyle::LK_Cpp, 15192 guessLanguage("foo.h", "void f() {\n" 15193 " __asm (\"mov %[e], %[d]\"\n" 15194 " : [d] \"=rm\" (d)\n" 15195 " [e] \"rm\" (*e));\n" 15196 "}")); 15197 EXPECT_EQ(FormatStyle::LK_Cpp, 15198 guessLanguage("foo.h", "void f() {\n" 15199 " __asm__ (\"mov %[e], %[d]\"\n" 15200 " : [d] \"=rm\" (d)\n" 15201 " [e] \"rm\" (*e));\n" 15202 "}")); 15203 EXPECT_EQ(FormatStyle::LK_Cpp, 15204 guessLanguage("foo.h", "void f() {\n" 15205 " asm (\"mov %[e], %[d]\"\n" 15206 " : [d] \"=rm\" (d),\n" 15207 " [e] \"rm\" (*e));\n" 15208 "}")); 15209 EXPECT_EQ(FormatStyle::LK_Cpp, 15210 guessLanguage("foo.h", "void f() {\n" 15211 " asm volatile (\"mov %[e], %[d]\"\n" 15212 " : [d] \"=rm\" (d)\n" 15213 " [e] \"rm\" (*e));\n" 15214 "}")); 15215 } 15216 15217 TEST_F(FormatTest, GuessLanguageWithChildLines) { 15218 EXPECT_EQ(FormatStyle::LK_Cpp, 15219 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 15220 EXPECT_EQ(FormatStyle::LK_ObjC, 15221 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 15222 EXPECT_EQ( 15223 FormatStyle::LK_Cpp, 15224 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 15225 EXPECT_EQ( 15226 FormatStyle::LK_ObjC, 15227 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 15228 } 15229 15230 TEST_F(FormatTest, TypenameMacros) { 15231 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 15232 15233 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 15234 FormatStyle Google = getGoogleStyleWithColumns(0); 15235 Google.TypenameMacros = TypenameMacros; 15236 verifyFormat("struct foo {\n" 15237 " int bar;\n" 15238 " TAILQ_ENTRY(a) bleh;\n" 15239 "};", 15240 Google); 15241 15242 FormatStyle Macros = getLLVMStyle(); 15243 Macros.TypenameMacros = TypenameMacros; 15244 15245 verifyFormat("STACK_OF(int) a;", Macros); 15246 verifyFormat("STACK_OF(int) *a;", Macros); 15247 verifyFormat("STACK_OF(int const *) *a;", Macros); 15248 verifyFormat("STACK_OF(int *const) *a;", Macros); 15249 verifyFormat("STACK_OF(int, string) a;", Macros); 15250 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 15251 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 15252 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 15253 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 15254 15255 Macros.PointerAlignment = FormatStyle::PAS_Left; 15256 verifyFormat("STACK_OF(int)* a;", Macros); 15257 verifyFormat("STACK_OF(int*)* a;", Macros); 15258 } 15259 15260 TEST_F(FormatTest, AmbersandInLamda) { 15261 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899 15262 FormatStyle AlignStyle = getLLVMStyle(); 15263 AlignStyle.PointerAlignment = FormatStyle::PAS_Left; 15264 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 15265 AlignStyle.PointerAlignment = FormatStyle::PAS_Right; 15266 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 15267 } 15268 15269 TEST_F(FormatTest, SpacesInConditionalStatement) { 15270 FormatStyle Spaces = getLLVMStyle(); 15271 Spaces.SpacesInConditionalStatement = true; 15272 verifyFormat("for ( int i = 0; i; i++ )\n continue;", Spaces); 15273 verifyFormat("if ( !a )\n return;", Spaces); 15274 verifyFormat("if ( a )\n return;", Spaces); 15275 verifyFormat("if constexpr ( a )\n return;", Spaces); 15276 verifyFormat("switch ( a )\ncase 1:\n return;", Spaces); 15277 verifyFormat("while ( a )\n return;", Spaces); 15278 verifyFormat("while ( (a && b) )\n return;", Spaces); 15279 verifyFormat("do {\n} while ( 1 != 0 );", Spaces); 15280 verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces); 15281 // Check that space on the left of "::" is inserted as expected at beginning 15282 // of condition. 15283 verifyFormat("while ( ::func() )\n return;", Spaces); 15284 } 15285 15286 TEST_F(FormatTest, AlternativeOperators) { 15287 // Test case for ensuring alternate operators are not 15288 // combined with their right most neighbour. 15289 verifyFormat("int a and b;"); 15290 verifyFormat("int a and_eq b;"); 15291 verifyFormat("int a bitand b;"); 15292 verifyFormat("int a bitor b;"); 15293 verifyFormat("int a compl b;"); 15294 verifyFormat("int a not b;"); 15295 verifyFormat("int a not_eq b;"); 15296 verifyFormat("int a or b;"); 15297 verifyFormat("int a xor b;"); 15298 verifyFormat("int a xor_eq b;"); 15299 verifyFormat("return this not_eq bitand other;"); 15300 verifyFormat("bool operator not_eq(const X bitand other)"); 15301 15302 verifyFormat("int a and 5;"); 15303 verifyFormat("int a and_eq 5;"); 15304 verifyFormat("int a bitand 5;"); 15305 verifyFormat("int a bitor 5;"); 15306 verifyFormat("int a compl 5;"); 15307 verifyFormat("int a not 5;"); 15308 verifyFormat("int a not_eq 5;"); 15309 verifyFormat("int a or 5;"); 15310 verifyFormat("int a xor 5;"); 15311 verifyFormat("int a xor_eq 5;"); 15312 15313 verifyFormat("int a compl(5);"); 15314 verifyFormat("int a not(5);"); 15315 15316 /* FIXME handle alternate tokens 15317 * https://en.cppreference.com/w/cpp/language/operator_alternative 15318 // alternative tokens 15319 verifyFormat("compl foo();"); // ~foo(); 15320 verifyFormat("foo() <%%>;"); // foo(); 15321 verifyFormat("void foo() <%%>;"); // void foo(){} 15322 verifyFormat("int a <:1:>;"); // int a[1];[ 15323 verifyFormat("%:define ABC abc"); // #define ABC abc 15324 verifyFormat("%:%:"); // ## 15325 */ 15326 } 15327 15328 TEST_F(FormatTest, STLWhileNotDefineChed) { 15329 verifyFormat("#if defined(while)\n" 15330 "#define while EMIT WARNING C4005\n" 15331 "#endif // while"); 15332 } 15333 15334 TEST_F(FormatTest, OperatorSpacing) { 15335 FormatStyle Style = getLLVMStyle(); 15336 Style.PointerAlignment = FormatStyle::PAS_Right; 15337 verifyFormat("Foo::operator*();", Style); 15338 verifyFormat("Foo::operator void *();", Style); 15339 verifyFormat("Foo::operator()(void *);", Style); 15340 verifyFormat("Foo::operator*(void *);", Style); 15341 verifyFormat("Foo::operator*();", Style); 15342 verifyFormat("operator*(int (*)(), class Foo);", Style); 15343 15344 verifyFormat("Foo::operator&();", Style); 15345 verifyFormat("Foo::operator void &();", Style); 15346 verifyFormat("Foo::operator()(void &);", Style); 15347 verifyFormat("Foo::operator&(void &);", Style); 15348 verifyFormat("Foo::operator&();", Style); 15349 verifyFormat("operator&(int (&)(), class Foo);", Style); 15350 15351 verifyFormat("Foo::operator&&();", Style); 15352 verifyFormat("Foo::operator void &&();", Style); 15353 verifyFormat("Foo::operator()(void &&);", Style); 15354 verifyFormat("Foo::operator&&(void &&);", Style); 15355 verifyFormat("Foo::operator&&();", Style); 15356 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15357 15358 Style.PointerAlignment = FormatStyle::PAS_Left; 15359 verifyFormat("Foo::operator*();", Style); 15360 verifyFormat("Foo::operator void*();", Style); 15361 verifyFormat("Foo::operator/*comment*/ void*();", Style); 15362 verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style); 15363 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style); 15364 verifyFormat("Foo::operator()(void*);", Style); 15365 verifyFormat("Foo::operator*(void*);", Style); 15366 verifyFormat("Foo::operator*();", Style); 15367 verifyFormat("operator*(int (*)(), class Foo);", Style); 15368 15369 verifyFormat("Foo::operator&();", Style); 15370 verifyFormat("Foo::operator void&();", Style); 15371 verifyFormat("Foo::operator/*comment*/ void&();", Style); 15372 verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style); 15373 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style); 15374 verifyFormat("Foo::operator()(void&);", Style); 15375 verifyFormat("Foo::operator&(void&);", Style); 15376 verifyFormat("Foo::operator&();", Style); 15377 verifyFormat("operator&(int (&)(), class Foo);", Style); 15378 15379 verifyFormat("Foo::operator&&();", Style); 15380 verifyFormat("Foo::operator void&&();", Style); 15381 verifyFormat("Foo::operator/*comment*/ void&&();", Style); 15382 verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style); 15383 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style); 15384 verifyFormat("Foo::operator()(void&&);", Style); 15385 verifyFormat("Foo::operator&&(void&&);", Style); 15386 verifyFormat("Foo::operator&&();", Style); 15387 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15388 15389 // PR45107 15390 verifyFormat("operator Vector<String>&();", Style); 15391 verifyFormat("operator foo::Bar*();", Style); 15392 verifyFormat("operator const Foo<X>::Bar<Y>*();", Style); 15393 verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();", 15394 Style); 15395 15396 Style.PointerAlignment = FormatStyle::PAS_Middle; 15397 verifyFormat("Foo::operator*();", Style); 15398 verifyFormat("Foo::operator void *();", Style); 15399 verifyFormat("Foo::operator()(void *);", Style); 15400 verifyFormat("Foo::operator*(void *);", Style); 15401 verifyFormat("Foo::operator*();", Style); 15402 verifyFormat("operator*(int (*)(), class Foo);", Style); 15403 15404 verifyFormat("Foo::operator&();", Style); 15405 verifyFormat("Foo::operator void &();", Style); 15406 verifyFormat("Foo::operator()(void &);", Style); 15407 verifyFormat("Foo::operator&(void &);", Style); 15408 verifyFormat("Foo::operator&();", Style); 15409 verifyFormat("operator&(int (&)(), class Foo);", Style); 15410 15411 verifyFormat("Foo::operator&&();", Style); 15412 verifyFormat("Foo::operator void &&();", Style); 15413 verifyFormat("Foo::operator()(void &&);", Style); 15414 verifyFormat("Foo::operator&&(void &&);", Style); 15415 verifyFormat("Foo::operator&&();", Style); 15416 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15417 } 15418 15419 } // namespace 15420 } // namespace format 15421 } // namespace clang 15422