1 //===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "clang/Format/Format.h" 10 11 #include "../Tooling/ReplacementTest.h" 12 #include "FormatTestUtils.h" 13 14 #include "clang/Frontend/TextDiagnosticPrinter.h" 15 #include "llvm/Support/Debug.h" 16 #include "llvm/Support/MemoryBuffer.h" 17 #include "gtest/gtest.h" 18 19 #define DEBUG_TYPE "format-test" 20 21 using clang::tooling::ReplacementTest; 22 using clang::tooling::toReplacements; 23 24 namespace clang { 25 namespace format { 26 namespace { 27 28 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); } 29 30 class FormatTest : public ::testing::Test { 31 protected: 32 enum StatusCheck { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck }; 33 34 std::string format(llvm::StringRef Code, 35 const FormatStyle &Style = getLLVMStyle(), 36 StatusCheck CheckComplete = SC_ExpectComplete) { 37 LLVM_DEBUG(llvm::errs() << "---\n"); 38 LLVM_DEBUG(llvm::errs() << Code << "\n\n"); 39 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size())); 40 FormattingAttemptStatus Status; 41 tooling::Replacements Replaces = 42 reformat(Style, Code, Ranges, "<stdin>", &Status); 43 if (CheckComplete != SC_DoNotCheck) { 44 bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete; 45 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete) 46 << Code << "\n\n"; 47 } 48 ReplacementCount = Replaces.size(); 49 auto Result = applyAllReplacements(Code, Replaces); 50 EXPECT_TRUE(static_cast<bool>(Result)); 51 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); 52 return *Result; 53 } 54 55 FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) { 56 Style.ColumnLimit = ColumnLimit; 57 return Style; 58 } 59 60 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 61 return getStyleWithColumns(getLLVMStyle(), ColumnLimit); 62 } 63 64 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) { 65 return getStyleWithColumns(getGoogleStyle(), ColumnLimit); 66 } 67 68 void verifyFormat(llvm::StringRef Expected, llvm::StringRef Code, 69 const FormatStyle &Style = getLLVMStyle()) { 70 EXPECT_EQ(Expected.str(), format(Expected, Style)) 71 << "Expected code is not stable"; 72 EXPECT_EQ(Expected.str(), format(Code, Style)); 73 if (Style.Language == FormatStyle::LK_Cpp) { 74 // Objective-C++ is a superset of C++, so everything checked for C++ 75 // needs to be checked for Objective-C++ as well. 76 FormatStyle ObjCStyle = Style; 77 ObjCStyle.Language = FormatStyle::LK_ObjC; 78 EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle)); 79 } 80 } 81 82 void verifyFormat(llvm::StringRef Code, 83 const FormatStyle &Style = getLLVMStyle()) { 84 verifyFormat(Code, test::messUp(Code), Style); 85 } 86 87 void verifyIncompleteFormat(llvm::StringRef Code, 88 const FormatStyle &Style = getLLVMStyle()) { 89 EXPECT_EQ(Code.str(), 90 format(test::messUp(Code), Style, SC_ExpectIncomplete)); 91 } 92 93 void verifyGoogleFormat(llvm::StringRef Code) { 94 verifyFormat(Code, getGoogleStyle()); 95 } 96 97 void verifyIndependentOfContext(llvm::StringRef text) { 98 verifyFormat(text); 99 verifyFormat(llvm::Twine("void f() { " + text + " }").str()); 100 } 101 102 /// \brief Verify that clang-format does not crash on the given input. 103 void verifyNoCrash(llvm::StringRef Code, 104 const FormatStyle &Style = getLLVMStyle()) { 105 format(Code, Style, SC_DoNotCheck); 106 } 107 108 int ReplacementCount; 109 }; 110 111 TEST_F(FormatTest, MessUp) { 112 EXPECT_EQ("1 2 3", test::messUp("1 2 3")); 113 EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n")); 114 EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc")); 115 EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc")); 116 EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne")); 117 } 118 119 TEST_F(FormatTest, DefaultLLVMStyleIsCpp) { 120 EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language); 121 } 122 123 TEST_F(FormatTest, LLVMStyleOverride) { 124 EXPECT_EQ(FormatStyle::LK_Proto, 125 getLLVMStyle(FormatStyle::LK_Proto).Language); 126 } 127 128 //===----------------------------------------------------------------------===// 129 // Basic function tests. 130 //===----------------------------------------------------------------------===// 131 132 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { 133 EXPECT_EQ(";", format(";")); 134 } 135 136 TEST_F(FormatTest, FormatsGlobalStatementsAt0) { 137 EXPECT_EQ("int i;", format(" int i;")); 138 EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;")); 139 EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); 140 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); 141 } 142 143 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { 144 EXPECT_EQ("int i;", format("int\ni;")); 145 } 146 147 TEST_F(FormatTest, FormatsNestedBlockStatements) { 148 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}")); 149 } 150 151 TEST_F(FormatTest, FormatsNestedCall) { 152 verifyFormat("Method(f1, f2(f3));"); 153 verifyFormat("Method(f1(f2, f3()));"); 154 verifyFormat("Method(f1(f2, (f3())));"); 155 } 156 157 TEST_F(FormatTest, NestedNameSpecifiers) { 158 verifyFormat("vector<::Type> v;"); 159 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())"); 160 verifyFormat("static constexpr bool Bar = decltype(bar())::value;"); 161 verifyFormat("bool a = 2 < ::SomeFunction();"); 162 verifyFormat("ALWAYS_INLINE ::std::string getName();"); 163 verifyFormat("some::string getName();"); 164 } 165 166 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { 167 EXPECT_EQ("if (a) {\n" 168 " f();\n" 169 "}", 170 format("if(a){f();}")); 171 EXPECT_EQ(4, ReplacementCount); 172 EXPECT_EQ("if (a) {\n" 173 " f();\n" 174 "}", 175 format("if (a) {\n" 176 " f();\n" 177 "}")); 178 EXPECT_EQ(0, ReplacementCount); 179 EXPECT_EQ("/*\r\n" 180 "\r\n" 181 "*/\r\n", 182 format("/*\r\n" 183 "\r\n" 184 "*/\r\n")); 185 EXPECT_EQ(0, ReplacementCount); 186 } 187 188 TEST_F(FormatTest, RemovesEmptyLines) { 189 EXPECT_EQ("class C {\n" 190 " int i;\n" 191 "};", 192 format("class C {\n" 193 " int i;\n" 194 "\n" 195 "};")); 196 197 // Don't remove empty lines at the start of namespaces or extern "C" blocks. 198 EXPECT_EQ("namespace N {\n" 199 "\n" 200 "int i;\n" 201 "}", 202 format("namespace N {\n" 203 "\n" 204 "int i;\n" 205 "}", 206 getGoogleStyle())); 207 EXPECT_EQ("/* something */ namespace N {\n" 208 "\n" 209 "int i;\n" 210 "}", 211 format("/* something */ namespace N {\n" 212 "\n" 213 "int i;\n" 214 "}", 215 getGoogleStyle())); 216 EXPECT_EQ("inline namespace N {\n" 217 "\n" 218 "int i;\n" 219 "}", 220 format("inline namespace N {\n" 221 "\n" 222 "int i;\n" 223 "}", 224 getGoogleStyle())); 225 EXPECT_EQ("/* something */ inline namespace N {\n" 226 "\n" 227 "int i;\n" 228 "}", 229 format("/* something */ inline namespace N {\n" 230 "\n" 231 "int i;\n" 232 "}", 233 getGoogleStyle())); 234 EXPECT_EQ("export namespace N {\n" 235 "\n" 236 "int i;\n" 237 "}", 238 format("export namespace N {\n" 239 "\n" 240 "int i;\n" 241 "}", 242 getGoogleStyle())); 243 EXPECT_EQ("extern /**/ \"C\" /**/ {\n" 244 "\n" 245 "int i;\n" 246 "}", 247 format("extern /**/ \"C\" /**/ {\n" 248 "\n" 249 "int i;\n" 250 "}", 251 getGoogleStyle())); 252 253 // ...but do keep inlining and removing empty lines for non-block extern "C" 254 // functions. 255 verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle()); 256 EXPECT_EQ("extern \"C\" int f() {\n" 257 " int i = 42;\n" 258 " return i;\n" 259 "}", 260 format("extern \"C\" int f() {\n" 261 "\n" 262 " int i = 42;\n" 263 " return i;\n" 264 "}", 265 getGoogleStyle())); 266 267 // Remove empty lines at the beginning and end of blocks. 268 EXPECT_EQ("void f() {\n" 269 "\n" 270 " if (a) {\n" 271 "\n" 272 " f();\n" 273 " }\n" 274 "}", 275 format("void f() {\n" 276 "\n" 277 " if (a) {\n" 278 "\n" 279 " f();\n" 280 "\n" 281 " }\n" 282 "\n" 283 "}", 284 getLLVMStyle())); 285 EXPECT_EQ("void f() {\n" 286 " if (a) {\n" 287 " f();\n" 288 " }\n" 289 "}", 290 format("void f() {\n" 291 "\n" 292 " if (a) {\n" 293 "\n" 294 " f();\n" 295 "\n" 296 " }\n" 297 "\n" 298 "}", 299 getGoogleStyle())); 300 301 // Don't remove empty lines in more complex control statements. 302 EXPECT_EQ("void f() {\n" 303 " if (a) {\n" 304 " f();\n" 305 "\n" 306 " } else if (b) {\n" 307 " f();\n" 308 " }\n" 309 "}", 310 format("void f() {\n" 311 " if (a) {\n" 312 " f();\n" 313 "\n" 314 " } else if (b) {\n" 315 " f();\n" 316 "\n" 317 " }\n" 318 "\n" 319 "}")); 320 321 // Don't remove empty lines before namespace endings. 322 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 323 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 324 EXPECT_EQ("namespace {\n" 325 "int i;\n" 326 "\n" 327 "}", 328 format("namespace {\n" 329 "int i;\n" 330 "\n" 331 "}", 332 LLVMWithNoNamespaceFix)); 333 EXPECT_EQ("namespace {\n" 334 "int i;\n" 335 "}", 336 format("namespace {\n" 337 "int i;\n" 338 "}", 339 LLVMWithNoNamespaceFix)); 340 EXPECT_EQ("namespace {\n" 341 "int i;\n" 342 "\n" 343 "};", 344 format("namespace {\n" 345 "int i;\n" 346 "\n" 347 "};", 348 LLVMWithNoNamespaceFix)); 349 EXPECT_EQ("namespace {\n" 350 "int i;\n" 351 "};", 352 format("namespace {\n" 353 "int i;\n" 354 "};", 355 LLVMWithNoNamespaceFix)); 356 EXPECT_EQ("namespace {\n" 357 "int i;\n" 358 "\n" 359 "}", 360 format("namespace {\n" 361 "int i;\n" 362 "\n" 363 "}")); 364 EXPECT_EQ("namespace {\n" 365 "int i;\n" 366 "\n" 367 "} // namespace", 368 format("namespace {\n" 369 "int i;\n" 370 "\n" 371 "} // namespace")); 372 373 FormatStyle Style = getLLVMStyle(); 374 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 375 Style.MaxEmptyLinesToKeep = 2; 376 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 377 Style.BraceWrapping.AfterClass = true; 378 Style.BraceWrapping.AfterFunction = true; 379 Style.KeepEmptyLinesAtTheStartOfBlocks = false; 380 381 EXPECT_EQ("class Foo\n" 382 "{\n" 383 " Foo() {}\n" 384 "\n" 385 " void funk() {}\n" 386 "};", 387 format("class Foo\n" 388 "{\n" 389 " Foo()\n" 390 " {\n" 391 " }\n" 392 "\n" 393 " void funk() {}\n" 394 "};", 395 Style)); 396 } 397 398 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) { 399 verifyFormat("x = (a) and (b);"); 400 verifyFormat("x = (a) or (b);"); 401 verifyFormat("x = (a) bitand (b);"); 402 verifyFormat("x = (a) bitor (b);"); 403 verifyFormat("x = (a) not_eq (b);"); 404 verifyFormat("x = (a) and_eq (b);"); 405 verifyFormat("x = (a) or_eq (b);"); 406 verifyFormat("x = (a) xor (b);"); 407 } 408 409 TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) { 410 verifyFormat("x = compl(a);"); 411 verifyFormat("x = not(a);"); 412 verifyFormat("x = bitand(a);"); 413 // Unary operator must not be merged with the next identifier 414 verifyFormat("x = compl a;"); 415 verifyFormat("x = not a;"); 416 verifyFormat("x = bitand a;"); 417 } 418 419 //===----------------------------------------------------------------------===// 420 // Tests for control statements. 421 //===----------------------------------------------------------------------===// 422 423 TEST_F(FormatTest, FormatIfWithoutCompoundStatement) { 424 verifyFormat("if (true)\n f();\ng();"); 425 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();"); 426 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();"); 427 verifyFormat("if constexpr (true)\n" 428 " f();\ng();"); 429 verifyFormat("if CONSTEXPR (true)\n" 430 " f();\ng();"); 431 verifyFormat("if constexpr (a)\n" 432 " if constexpr (b)\n" 433 " if constexpr (c)\n" 434 " g();\n" 435 "h();"); 436 verifyFormat("if CONSTEXPR (a)\n" 437 " if CONSTEXPR (b)\n" 438 " if CONSTEXPR (c)\n" 439 " g();\n" 440 "h();"); 441 verifyFormat("if constexpr (a)\n" 442 " if constexpr (b) {\n" 443 " f();\n" 444 " }\n" 445 "g();"); 446 verifyFormat("if CONSTEXPR (a)\n" 447 " if CONSTEXPR (b) {\n" 448 " f();\n" 449 " }\n" 450 "g();"); 451 452 FormatStyle AllowsMergedIf = getLLVMStyle(); 453 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 454 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 455 FormatStyle::SIS_WithoutElse; 456 verifyFormat("if (a)\n" 457 " // comment\n" 458 " f();", 459 AllowsMergedIf); 460 verifyFormat("{\n" 461 " if (a)\n" 462 " label:\n" 463 " f();\n" 464 "}", 465 AllowsMergedIf); 466 verifyFormat("#define A \\\n" 467 " if (a) \\\n" 468 " label: \\\n" 469 " f()", 470 AllowsMergedIf); 471 verifyFormat("if (a)\n" 472 " ;", 473 AllowsMergedIf); 474 verifyFormat("if (a)\n" 475 " if (b) return;", 476 AllowsMergedIf); 477 478 verifyFormat("if (a) // Can't merge this\n" 479 " f();\n", 480 AllowsMergedIf); 481 verifyFormat("if (a) /* still don't merge */\n" 482 " f();", 483 AllowsMergedIf); 484 verifyFormat("if (a) { // Never merge this\n" 485 " f();\n" 486 "}", 487 AllowsMergedIf); 488 verifyFormat("if (a) { /* Never merge this */\n" 489 " f();\n" 490 "}", 491 AllowsMergedIf); 492 493 AllowsMergedIf.ColumnLimit = 14; 494 verifyFormat("if (a) return;", AllowsMergedIf); 495 verifyFormat("if (aaaaaaaaa)\n" 496 " return;", 497 AllowsMergedIf); 498 499 AllowsMergedIf.ColumnLimit = 13; 500 verifyFormat("if (a)\n return;", AllowsMergedIf); 501 } 502 503 TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) { 504 FormatStyle AllowsMergedIf = getLLVMStyle(); 505 AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; 506 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 507 FormatStyle::SIS_WithoutElse; 508 verifyFormat("if (a)\n" 509 " f();\n" 510 "else {\n" 511 " g();\n" 512 "}", 513 AllowsMergedIf); 514 verifyFormat("if (a)\n" 515 " f();\n" 516 "else\n" 517 " g();\n", 518 AllowsMergedIf); 519 520 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 521 522 verifyFormat("if (a) f();\n" 523 "else {\n" 524 " g();\n" 525 "}", 526 AllowsMergedIf); 527 verifyFormat("if (a) f();\n" 528 "else {\n" 529 " if (a) f();\n" 530 " else {\n" 531 " g();\n" 532 " }\n" 533 " g();\n" 534 "}", 535 AllowsMergedIf); 536 } 537 538 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) { 539 FormatStyle AllowsMergedLoops = getLLVMStyle(); 540 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true; 541 verifyFormat("while (true) continue;", AllowsMergedLoops); 542 verifyFormat("for (;;) continue;", AllowsMergedLoops); 543 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops); 544 verifyFormat("while (true)\n" 545 " ;", 546 AllowsMergedLoops); 547 verifyFormat("for (;;)\n" 548 " ;", 549 AllowsMergedLoops); 550 verifyFormat("for (;;)\n" 551 " for (;;) continue;", 552 AllowsMergedLoops); 553 verifyFormat("for (;;) // Can't merge this\n" 554 " continue;", 555 AllowsMergedLoops); 556 verifyFormat("for (;;) /* still don't merge */\n" 557 " continue;", 558 AllowsMergedLoops); 559 } 560 561 TEST_F(FormatTest, FormatShortBracedStatements) { 562 FormatStyle AllowSimpleBracedStatements = getLLVMStyle(); 563 AllowSimpleBracedStatements.ColumnLimit = 40; 564 AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = 565 FormatStyle::SBS_Always; 566 567 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 568 FormatStyle::SIS_WithoutElse; 569 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 570 571 AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom; 572 AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true; 573 AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false; 574 575 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 576 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 577 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 578 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 579 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 580 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 581 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 582 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 583 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 584 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 585 verifyFormat("if (true) {\n" 586 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 587 "}", 588 AllowSimpleBracedStatements); 589 verifyFormat("if (true) { //\n" 590 " f();\n" 591 "}", 592 AllowSimpleBracedStatements); 593 verifyFormat("if (true) {\n" 594 " f();\n" 595 " f();\n" 596 "}", 597 AllowSimpleBracedStatements); 598 verifyFormat("if (true) {\n" 599 " f();\n" 600 "} else {\n" 601 " f();\n" 602 "}", 603 AllowSimpleBracedStatements); 604 605 verifyFormat("struct A2 {\n" 606 " int X;\n" 607 "};", 608 AllowSimpleBracedStatements); 609 verifyFormat("typedef struct A2 {\n" 610 " int X;\n" 611 "} A2_t;", 612 AllowSimpleBracedStatements); 613 verifyFormat("template <int> struct A2 {\n" 614 " struct B {};\n" 615 "};", 616 AllowSimpleBracedStatements); 617 618 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 619 FormatStyle::SIS_Never; 620 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 621 verifyFormat("if (true) {\n" 622 " f();\n" 623 "}", 624 AllowSimpleBracedStatements); 625 verifyFormat("if (true) {\n" 626 " f();\n" 627 "} else {\n" 628 " f();\n" 629 "}", 630 AllowSimpleBracedStatements); 631 632 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 633 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 634 verifyFormat("while (true) {\n" 635 " f();\n" 636 "}", 637 AllowSimpleBracedStatements); 638 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 639 verifyFormat("for (;;) {\n" 640 " f();\n" 641 "}", 642 AllowSimpleBracedStatements); 643 644 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 645 FormatStyle::SIS_WithoutElse; 646 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; 647 AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement = 648 FormatStyle::BWACS_Always; 649 650 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 651 verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); 652 verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); 653 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 654 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 655 verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); 656 verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); 657 verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); 658 verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); 659 verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); 660 verifyFormat("if (true)\n" 661 "{\n" 662 " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" 663 "}", 664 AllowSimpleBracedStatements); 665 verifyFormat("if (true)\n" 666 "{ //\n" 667 " f();\n" 668 "}", 669 AllowSimpleBracedStatements); 670 verifyFormat("if (true)\n" 671 "{\n" 672 " f();\n" 673 " f();\n" 674 "}", 675 AllowSimpleBracedStatements); 676 verifyFormat("if (true)\n" 677 "{\n" 678 " f();\n" 679 "} else\n" 680 "{\n" 681 " f();\n" 682 "}", 683 AllowSimpleBracedStatements); 684 685 AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = 686 FormatStyle::SIS_Never; 687 verifyFormat("if (true) {}", AllowSimpleBracedStatements); 688 verifyFormat("if (true)\n" 689 "{\n" 690 " f();\n" 691 "}", 692 AllowSimpleBracedStatements); 693 verifyFormat("if (true)\n" 694 "{\n" 695 " f();\n" 696 "} else\n" 697 "{\n" 698 " f();\n" 699 "}", 700 AllowSimpleBracedStatements); 701 702 AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; 703 verifyFormat("while (true) {}", AllowSimpleBracedStatements); 704 verifyFormat("while (true)\n" 705 "{\n" 706 " f();\n" 707 "}", 708 AllowSimpleBracedStatements); 709 verifyFormat("for (;;) {}", AllowSimpleBracedStatements); 710 verifyFormat("for (;;)\n" 711 "{\n" 712 " f();\n" 713 "}", 714 AllowSimpleBracedStatements); 715 } 716 717 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) { 718 FormatStyle Style = getLLVMStyleWithColumns(60); 719 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 720 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 721 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 722 EXPECT_EQ("#define A \\\n" 723 " if (HANDLEwernufrnuLwrmviferuvnierv) \\\n" 724 " { RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; }\n" 725 "X;", 726 format("#define A \\\n" 727 " if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n" 728 " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n" 729 " }\n" 730 "X;", 731 Style)); 732 } 733 734 TEST_F(FormatTest, ParseIfElse) { 735 verifyFormat("if (true)\n" 736 " if (true)\n" 737 " if (true)\n" 738 " f();\n" 739 " else\n" 740 " g();\n" 741 " else\n" 742 " h();\n" 743 "else\n" 744 " i();"); 745 verifyFormat("if (true)\n" 746 " if (true)\n" 747 " if (true) {\n" 748 " if (true)\n" 749 " f();\n" 750 " } else {\n" 751 " g();\n" 752 " }\n" 753 " else\n" 754 " h();\n" 755 "else {\n" 756 " i();\n" 757 "}"); 758 verifyFormat("if (true)\n" 759 " if constexpr (true)\n" 760 " if (true) {\n" 761 " if constexpr (true)\n" 762 " f();\n" 763 " } else {\n" 764 " g();\n" 765 " }\n" 766 " else\n" 767 " h();\n" 768 "else {\n" 769 " i();\n" 770 "}"); 771 verifyFormat("if (true)\n" 772 " if CONSTEXPR (true)\n" 773 " if (true) {\n" 774 " if CONSTEXPR (true)\n" 775 " f();\n" 776 " } else {\n" 777 " g();\n" 778 " }\n" 779 " else\n" 780 " h();\n" 781 "else {\n" 782 " i();\n" 783 "}"); 784 verifyFormat("void f() {\n" 785 " if (a) {\n" 786 " } else {\n" 787 " }\n" 788 "}"); 789 } 790 791 TEST_F(FormatTest, ElseIf) { 792 verifyFormat("if (a) {\n} else if (b) {\n}"); 793 verifyFormat("if (a)\n" 794 " f();\n" 795 "else if (b)\n" 796 " g();\n" 797 "else\n" 798 " h();"); 799 verifyFormat("if constexpr (a)\n" 800 " f();\n" 801 "else if constexpr (b)\n" 802 " g();\n" 803 "else\n" 804 " h();"); 805 verifyFormat("if CONSTEXPR (a)\n" 806 " f();\n" 807 "else if CONSTEXPR (b)\n" 808 " g();\n" 809 "else\n" 810 " h();"); 811 verifyFormat("if (a) {\n" 812 " f();\n" 813 "}\n" 814 "// or else ..\n" 815 "else {\n" 816 " g()\n" 817 "}"); 818 819 verifyFormat("if (a) {\n" 820 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 821 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 822 "}"); 823 verifyFormat("if (a) {\n" 824 "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 825 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 826 "}"); 827 verifyFormat("if (a) {\n" 828 "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 829 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 830 "}"); 831 verifyFormat("if (a) {\n" 832 "} else if (\n" 833 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 834 "}", 835 getLLVMStyleWithColumns(62)); 836 verifyFormat("if (a) {\n" 837 "} else if constexpr (\n" 838 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 839 "}", 840 getLLVMStyleWithColumns(62)); 841 verifyFormat("if (a) {\n" 842 "} else if CONSTEXPR (\n" 843 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 844 "}", 845 getLLVMStyleWithColumns(62)); 846 } 847 848 TEST_F(FormatTest, FormatsForLoop) { 849 verifyFormat( 850 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 851 " ++VeryVeryLongLoopVariable)\n" 852 " ;"); 853 verifyFormat("for (;;)\n" 854 " f();"); 855 verifyFormat("for (;;) {\n}"); 856 verifyFormat("for (;;) {\n" 857 " f();\n" 858 "}"); 859 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 860 861 verifyFormat( 862 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 863 " E = UnwrappedLines.end();\n" 864 " I != E; ++I) {\n}"); 865 866 verifyFormat( 867 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 868 " ++IIIII) {\n}"); 869 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 870 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 871 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 872 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 873 " I = FD->getDeclsInPrototypeScope().begin(),\n" 874 " E = FD->getDeclsInPrototypeScope().end();\n" 875 " I != E; ++I) {\n}"); 876 verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n" 877 " I = Container.begin(),\n" 878 " E = Container.end();\n" 879 " I != E; ++I) {\n}", 880 getLLVMStyleWithColumns(76)); 881 882 verifyFormat( 883 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 884 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 885 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 886 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 887 " ++aaaaaaaaaaa) {\n}"); 888 verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 889 " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n" 890 " ++i) {\n}"); 891 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 892 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 893 "}"); 894 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 895 " aaaaaaaaaa);\n" 896 " iter; ++iter) {\n" 897 "}"); 898 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 899 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 900 " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n" 901 " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {"); 902 903 // These should not be formatted as Objective-C for-in loops. 904 verifyFormat("for (Foo *x = 0; x != in; x++) {\n}"); 905 verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}"); 906 verifyFormat("Foo *x;\nfor (x in y) {\n}"); 907 verifyFormat( 908 "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}"); 909 910 FormatStyle NoBinPacking = getLLVMStyle(); 911 NoBinPacking.BinPackParameters = false; 912 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 913 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 914 " aaaaaaaaaaaaaaaa,\n" 915 " aaaaaaaaaaaaaaaa,\n" 916 " aaaaaaaaaaaaaaaa);\n" 917 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 918 "}", 919 NoBinPacking); 920 verifyFormat( 921 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 922 " E = UnwrappedLines.end();\n" 923 " I != E;\n" 924 " ++I) {\n}", 925 NoBinPacking); 926 927 FormatStyle AlignLeft = getLLVMStyle(); 928 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 929 verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft); 930 } 931 932 TEST_F(FormatTest, RangeBasedForLoops) { 933 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 934 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 935 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 936 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 937 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 938 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 939 verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n" 940 " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}"); 941 } 942 943 TEST_F(FormatTest, ForEachLoops) { 944 verifyFormat("void f() {\n" 945 " foreach (Item *item, itemlist) {}\n" 946 " Q_FOREACH (Item *item, itemlist) {}\n" 947 " BOOST_FOREACH (Item *item, itemlist) {}\n" 948 " UNKNOWN_FORACH(Item * item, itemlist) {}\n" 949 "}"); 950 951 // As function-like macros. 952 verifyFormat("#define foreach(x, y)\n" 953 "#define Q_FOREACH(x, y)\n" 954 "#define BOOST_FOREACH(x, y)\n" 955 "#define UNKNOWN_FOREACH(x, y)\n"); 956 957 // Not as function-like macros. 958 verifyFormat("#define foreach (x, y)\n" 959 "#define Q_FOREACH (x, y)\n" 960 "#define BOOST_FOREACH (x, y)\n" 961 "#define UNKNOWN_FOREACH (x, y)\n"); 962 } 963 964 TEST_F(FormatTest, FormatsWhileLoop) { 965 verifyFormat("while (true) {\n}"); 966 verifyFormat("while (true)\n" 967 " f();"); 968 verifyFormat("while () {\n}"); 969 verifyFormat("while () {\n" 970 " f();\n" 971 "}"); 972 } 973 974 TEST_F(FormatTest, FormatsDoWhile) { 975 verifyFormat("do {\n" 976 " do_something();\n" 977 "} while (something());"); 978 verifyFormat("do\n" 979 " do_something();\n" 980 "while (something());"); 981 } 982 983 TEST_F(FormatTest, FormatsSwitchStatement) { 984 verifyFormat("switch (x) {\n" 985 "case 1:\n" 986 " f();\n" 987 " break;\n" 988 "case kFoo:\n" 989 "case ns::kBar:\n" 990 "case kBaz:\n" 991 " break;\n" 992 "default:\n" 993 " g();\n" 994 " break;\n" 995 "}"); 996 verifyFormat("switch (x) {\n" 997 "case 1: {\n" 998 " f();\n" 999 " break;\n" 1000 "}\n" 1001 "case 2: {\n" 1002 " break;\n" 1003 "}\n" 1004 "}"); 1005 verifyFormat("switch (x) {\n" 1006 "case 1: {\n" 1007 " f();\n" 1008 " {\n" 1009 " g();\n" 1010 " h();\n" 1011 " }\n" 1012 " break;\n" 1013 "}\n" 1014 "}"); 1015 verifyFormat("switch (x) {\n" 1016 "case 1: {\n" 1017 " f();\n" 1018 " if (foo) {\n" 1019 " g();\n" 1020 " h();\n" 1021 " }\n" 1022 " break;\n" 1023 "}\n" 1024 "}"); 1025 verifyFormat("switch (x) {\n" 1026 "case 1: {\n" 1027 " f();\n" 1028 " g();\n" 1029 "} break;\n" 1030 "}"); 1031 verifyFormat("switch (test)\n" 1032 " ;"); 1033 verifyFormat("switch (x) {\n" 1034 "default: {\n" 1035 " // Do nothing.\n" 1036 "}\n" 1037 "}"); 1038 verifyFormat("switch (x) {\n" 1039 "// comment\n" 1040 "// if 1, do f()\n" 1041 "case 1:\n" 1042 " f();\n" 1043 "}"); 1044 verifyFormat("switch (x) {\n" 1045 "case 1:\n" 1046 " // Do amazing stuff\n" 1047 " {\n" 1048 " f();\n" 1049 " g();\n" 1050 " }\n" 1051 " break;\n" 1052 "}"); 1053 verifyFormat("#define A \\\n" 1054 " switch (x) { \\\n" 1055 " case a: \\\n" 1056 " foo = b; \\\n" 1057 " }", 1058 getLLVMStyleWithColumns(20)); 1059 verifyFormat("#define OPERATION_CASE(name) \\\n" 1060 " case OP_name: \\\n" 1061 " return operations::Operation##name\n", 1062 getLLVMStyleWithColumns(40)); 1063 verifyFormat("switch (x) {\n" 1064 "case 1:;\n" 1065 "default:;\n" 1066 " int i;\n" 1067 "}"); 1068 1069 verifyGoogleFormat("switch (x) {\n" 1070 " case 1:\n" 1071 " f();\n" 1072 " break;\n" 1073 " case kFoo:\n" 1074 " case ns::kBar:\n" 1075 " case kBaz:\n" 1076 " break;\n" 1077 " default:\n" 1078 " g();\n" 1079 " break;\n" 1080 "}"); 1081 verifyGoogleFormat("switch (x) {\n" 1082 " case 1: {\n" 1083 " f();\n" 1084 " break;\n" 1085 " }\n" 1086 "}"); 1087 verifyGoogleFormat("switch (test)\n" 1088 " ;"); 1089 1090 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 1091 " case OP_name: \\\n" 1092 " return operations::Operation##name\n"); 1093 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 1094 " // Get the correction operation class.\n" 1095 " switch (OpCode) {\n" 1096 " CASE(Add);\n" 1097 " CASE(Subtract);\n" 1098 " default:\n" 1099 " return operations::Unknown;\n" 1100 " }\n" 1101 "#undef OPERATION_CASE\n" 1102 "}"); 1103 verifyFormat("DEBUG({\n" 1104 " switch (x) {\n" 1105 " case A:\n" 1106 " f();\n" 1107 " break;\n" 1108 " // fallthrough\n" 1109 " case B:\n" 1110 " g();\n" 1111 " break;\n" 1112 " }\n" 1113 "});"); 1114 EXPECT_EQ("DEBUG({\n" 1115 " switch (x) {\n" 1116 " case A:\n" 1117 " f();\n" 1118 " break;\n" 1119 " // On B:\n" 1120 " case B:\n" 1121 " g();\n" 1122 " break;\n" 1123 " }\n" 1124 "});", 1125 format("DEBUG({\n" 1126 " switch (x) {\n" 1127 " case A:\n" 1128 " f();\n" 1129 " break;\n" 1130 " // On B:\n" 1131 " case B:\n" 1132 " g();\n" 1133 " break;\n" 1134 " }\n" 1135 "});", 1136 getLLVMStyle())); 1137 EXPECT_EQ("switch (n) {\n" 1138 "case 0: {\n" 1139 " return false;\n" 1140 "}\n" 1141 "default: {\n" 1142 " return true;\n" 1143 "}\n" 1144 "}", 1145 format("switch (n)\n" 1146 "{\n" 1147 "case 0: {\n" 1148 " return false;\n" 1149 "}\n" 1150 "default: {\n" 1151 " return true;\n" 1152 "}\n" 1153 "}", 1154 getLLVMStyle())); 1155 verifyFormat("switch (a) {\n" 1156 "case (b):\n" 1157 " return;\n" 1158 "}"); 1159 1160 verifyFormat("switch (a) {\n" 1161 "case some_namespace::\n" 1162 " some_constant:\n" 1163 " return;\n" 1164 "}", 1165 getLLVMStyleWithColumns(34)); 1166 1167 FormatStyle Style = getLLVMStyle(); 1168 Style.IndentCaseLabels = true; 1169 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 1170 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1171 Style.BraceWrapping.AfterCaseLabel = true; 1172 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1173 EXPECT_EQ("switch (n)\n" 1174 "{\n" 1175 " case 0:\n" 1176 " {\n" 1177 " return false;\n" 1178 " }\n" 1179 " default:\n" 1180 " {\n" 1181 " return true;\n" 1182 " }\n" 1183 "}", 1184 format("switch (n) {\n" 1185 " case 0: {\n" 1186 " return false;\n" 1187 " }\n" 1188 " default: {\n" 1189 " return true;\n" 1190 " }\n" 1191 "}", 1192 Style)); 1193 Style.BraceWrapping.AfterCaseLabel = false; 1194 EXPECT_EQ("switch (n)\n" 1195 "{\n" 1196 " case 0: {\n" 1197 " return false;\n" 1198 " }\n" 1199 " default: {\n" 1200 " return true;\n" 1201 " }\n" 1202 "}", 1203 format("switch (n) {\n" 1204 " case 0:\n" 1205 " {\n" 1206 " return false;\n" 1207 " }\n" 1208 " default:\n" 1209 " {\n" 1210 " return true;\n" 1211 " }\n" 1212 "}", 1213 Style)); 1214 Style.IndentCaseLabels = false; 1215 Style.IndentCaseBlocks = true; 1216 EXPECT_EQ("switch (n)\n" 1217 "{\n" 1218 "case 0:\n" 1219 " {\n" 1220 " return false;\n" 1221 " }\n" 1222 "case 1:\n" 1223 " break;\n" 1224 "default:\n" 1225 " {\n" 1226 " return true;\n" 1227 " }\n" 1228 "}", 1229 format("switch (n) {\n" 1230 "case 0: {\n" 1231 " return false;\n" 1232 "}\n" 1233 "case 1:\n" 1234 " break;\n" 1235 "default: {\n" 1236 " return true;\n" 1237 "}\n" 1238 "}", 1239 Style)); 1240 Style.IndentCaseLabels = true; 1241 Style.IndentCaseBlocks = true; 1242 EXPECT_EQ("switch (n)\n" 1243 "{\n" 1244 " case 0:\n" 1245 " {\n" 1246 " return false;\n" 1247 " }\n" 1248 " case 1:\n" 1249 " break;\n" 1250 " default:\n" 1251 " {\n" 1252 " return true;\n" 1253 " }\n" 1254 "}", 1255 format("switch (n) {\n" 1256 "case 0: {\n" 1257 " return false;\n" 1258 "}\n" 1259 "case 1:\n" 1260 " break;\n" 1261 "default: {\n" 1262 " return true;\n" 1263 "}\n" 1264 "}", 1265 Style)); 1266 } 1267 1268 TEST_F(FormatTest, CaseRanges) { 1269 verifyFormat("switch (x) {\n" 1270 "case 'A' ... 'Z':\n" 1271 "case 1 ... 5:\n" 1272 "case a ... b:\n" 1273 " break;\n" 1274 "}"); 1275 } 1276 1277 TEST_F(FormatTest, ShortCaseLabels) { 1278 FormatStyle Style = getLLVMStyle(); 1279 Style.AllowShortCaseLabelsOnASingleLine = true; 1280 verifyFormat("switch (a) {\n" 1281 "case 1: x = 1; break;\n" 1282 "case 2: return;\n" 1283 "case 3:\n" 1284 "case 4:\n" 1285 "case 5: return;\n" 1286 "case 6: // comment\n" 1287 " return;\n" 1288 "case 7:\n" 1289 " // comment\n" 1290 " return;\n" 1291 "case 8:\n" 1292 " x = 8; // comment\n" 1293 " break;\n" 1294 "default: y = 1; break;\n" 1295 "}", 1296 Style); 1297 verifyFormat("switch (a) {\n" 1298 "case 0: return; // comment\n" 1299 "case 1: break; // comment\n" 1300 "case 2: return;\n" 1301 "// comment\n" 1302 "case 3: return;\n" 1303 "// comment 1\n" 1304 "// comment 2\n" 1305 "// comment 3\n" 1306 "case 4: break; /* comment */\n" 1307 "case 5:\n" 1308 " // comment\n" 1309 " break;\n" 1310 "case 6: /* comment */ x = 1; break;\n" 1311 "case 7: x = /* comment */ 1; break;\n" 1312 "case 8:\n" 1313 " x = 1; /* comment */\n" 1314 " break;\n" 1315 "case 9:\n" 1316 " break; // comment line 1\n" 1317 " // comment line 2\n" 1318 "}", 1319 Style); 1320 EXPECT_EQ("switch (a) {\n" 1321 "case 1:\n" 1322 " x = 8;\n" 1323 " // fall through\n" 1324 "case 2: x = 8;\n" 1325 "// comment\n" 1326 "case 3:\n" 1327 " return; /* comment line 1\n" 1328 " * comment line 2 */\n" 1329 "case 4: i = 8;\n" 1330 "// something else\n" 1331 "#if FOO\n" 1332 "case 5: break;\n" 1333 "#endif\n" 1334 "}", 1335 format("switch (a) {\n" 1336 "case 1: x = 8;\n" 1337 " // fall through\n" 1338 "case 2:\n" 1339 " x = 8;\n" 1340 "// comment\n" 1341 "case 3:\n" 1342 " return; /* comment line 1\n" 1343 " * comment line 2 */\n" 1344 "case 4:\n" 1345 " i = 8;\n" 1346 "// something else\n" 1347 "#if FOO\n" 1348 "case 5: break;\n" 1349 "#endif\n" 1350 "}", 1351 Style)); 1352 EXPECT_EQ("switch (a) {\n" 1353 "case 0:\n" 1354 " return; // long long long long long long long long long long " 1355 "long long comment\n" 1356 " // line\n" 1357 "}", 1358 format("switch (a) {\n" 1359 "case 0: return; // long long long long long long long long " 1360 "long long long long comment line\n" 1361 "}", 1362 Style)); 1363 EXPECT_EQ("switch (a) {\n" 1364 "case 0:\n" 1365 " return; /* long long long long long long long long long long " 1366 "long long comment\n" 1367 " line */\n" 1368 "}", 1369 format("switch (a) {\n" 1370 "case 0: return; /* long long long long long long long long " 1371 "long long long long comment line */\n" 1372 "}", 1373 Style)); 1374 verifyFormat("switch (a) {\n" 1375 "#if FOO\n" 1376 "case 0: return 0;\n" 1377 "#endif\n" 1378 "}", 1379 Style); 1380 verifyFormat("switch (a) {\n" 1381 "case 1: {\n" 1382 "}\n" 1383 "case 2: {\n" 1384 " return;\n" 1385 "}\n" 1386 "case 3: {\n" 1387 " x = 1;\n" 1388 " return;\n" 1389 "}\n" 1390 "case 4:\n" 1391 " if (x)\n" 1392 " return;\n" 1393 "}", 1394 Style); 1395 Style.ColumnLimit = 21; 1396 verifyFormat("switch (a) {\n" 1397 "case 1: x = 1; break;\n" 1398 "case 2: return;\n" 1399 "case 3:\n" 1400 "case 4:\n" 1401 "case 5: return;\n" 1402 "default:\n" 1403 " y = 1;\n" 1404 " break;\n" 1405 "}", 1406 Style); 1407 Style.ColumnLimit = 80; 1408 Style.AllowShortCaseLabelsOnASingleLine = false; 1409 Style.IndentCaseLabels = true; 1410 EXPECT_EQ("switch (n) {\n" 1411 " default /*comments*/:\n" 1412 " return true;\n" 1413 " case 0:\n" 1414 " return false;\n" 1415 "}", 1416 format("switch (n) {\n" 1417 "default/*comments*/:\n" 1418 " return true;\n" 1419 "case 0:\n" 1420 " return false;\n" 1421 "}", 1422 Style)); 1423 Style.AllowShortCaseLabelsOnASingleLine = true; 1424 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1425 Style.BraceWrapping.AfterCaseLabel = true; 1426 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 1427 EXPECT_EQ("switch (n)\n" 1428 "{\n" 1429 " case 0:\n" 1430 " {\n" 1431 " return false;\n" 1432 " }\n" 1433 " default:\n" 1434 " {\n" 1435 " return true;\n" 1436 " }\n" 1437 "}", 1438 format("switch (n) {\n" 1439 " case 0: {\n" 1440 " return false;\n" 1441 " }\n" 1442 " default:\n" 1443 " {\n" 1444 " return true;\n" 1445 " }\n" 1446 "}", 1447 Style)); 1448 } 1449 1450 TEST_F(FormatTest, FormatsLabels) { 1451 verifyFormat("void f() {\n" 1452 " some_code();\n" 1453 "test_label:\n" 1454 " some_other_code();\n" 1455 " {\n" 1456 " some_more_code();\n" 1457 " another_label:\n" 1458 " some_more_code();\n" 1459 " }\n" 1460 "}"); 1461 verifyFormat("{\n" 1462 " some_code();\n" 1463 "test_label:\n" 1464 " some_other_code();\n" 1465 "}"); 1466 verifyFormat("{\n" 1467 " some_code();\n" 1468 "test_label:;\n" 1469 " int i = 0;\n" 1470 "}"); 1471 FormatStyle Style = getLLVMStyle(); 1472 Style.IndentGotoLabels = false; 1473 verifyFormat("void f() {\n" 1474 " some_code();\n" 1475 "test_label:\n" 1476 " some_other_code();\n" 1477 " {\n" 1478 " some_more_code();\n" 1479 "another_label:\n" 1480 " some_more_code();\n" 1481 " }\n" 1482 "}", 1483 Style); 1484 verifyFormat("{\n" 1485 " some_code();\n" 1486 "test_label:\n" 1487 " some_other_code();\n" 1488 "}", 1489 Style); 1490 verifyFormat("{\n" 1491 " some_code();\n" 1492 "test_label:;\n" 1493 " int i = 0;\n" 1494 "}"); 1495 } 1496 1497 TEST_F(FormatTest, MultiLineControlStatements) { 1498 FormatStyle Style = getLLVMStyle(); 1499 Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom; 1500 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine; 1501 Style.ColumnLimit = 20; 1502 // Short lines should keep opening brace on same line. 1503 EXPECT_EQ("if (foo) {\n" 1504 " bar();\n" 1505 "}", 1506 format("if(foo){bar();}", Style)); 1507 EXPECT_EQ("if (foo) {\n" 1508 " bar();\n" 1509 "} else {\n" 1510 " baz();\n" 1511 "}", 1512 format("if(foo){bar();}else{baz();}", Style)); 1513 EXPECT_EQ("if (foo && bar) {\n" 1514 " baz();\n" 1515 "}", 1516 format("if(foo&&bar){baz();}", Style)); 1517 EXPECT_EQ("if (foo) {\n" 1518 " bar();\n" 1519 "} else if (baz) {\n" 1520 " quux();\n" 1521 "}", 1522 format("if(foo){bar();}else if(baz){quux();}", Style)); 1523 EXPECT_EQ( 1524 "if (foo) {\n" 1525 " bar();\n" 1526 "} else if (baz) {\n" 1527 " quux();\n" 1528 "} else {\n" 1529 " foobar();\n" 1530 "}", 1531 format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style)); 1532 EXPECT_EQ("for (;;) {\n" 1533 " foo();\n" 1534 "}", 1535 format("for(;;){foo();}")); 1536 EXPECT_EQ("while (1) {\n" 1537 " foo();\n" 1538 "}", 1539 format("while(1){foo();}", Style)); 1540 EXPECT_EQ("switch (foo) {\n" 1541 "case bar:\n" 1542 " return;\n" 1543 "}", 1544 format("switch(foo){case bar:return;}", Style)); 1545 EXPECT_EQ("try {\n" 1546 " foo();\n" 1547 "} catch (...) {\n" 1548 " bar();\n" 1549 "}", 1550 format("try{foo();}catch(...){bar();}", Style)); 1551 EXPECT_EQ("do {\n" 1552 " foo();\n" 1553 "} while (bar &&\n" 1554 " baz);", 1555 format("do{foo();}while(bar&&baz);", Style)); 1556 // Long lines should put opening brace on new line. 1557 EXPECT_EQ("if (foo && bar &&\n" 1558 " baz)\n" 1559 "{\n" 1560 " quux();\n" 1561 "}", 1562 format("if(foo&&bar&&baz){quux();}", Style)); 1563 EXPECT_EQ("if (foo && bar &&\n" 1564 " baz)\n" 1565 "{\n" 1566 " quux();\n" 1567 "}", 1568 format("if (foo && bar &&\n" 1569 " baz) {\n" 1570 " quux();\n" 1571 "}", 1572 Style)); 1573 EXPECT_EQ("if (foo) {\n" 1574 " bar();\n" 1575 "} else if (baz ||\n" 1576 " quux)\n" 1577 "{\n" 1578 " foobar();\n" 1579 "}", 1580 format("if(foo){bar();}else if(baz||quux){foobar();}", Style)); 1581 EXPECT_EQ( 1582 "if (foo) {\n" 1583 " bar();\n" 1584 "} else if (baz ||\n" 1585 " quux)\n" 1586 "{\n" 1587 " foobar();\n" 1588 "} else {\n" 1589 " barbaz();\n" 1590 "}", 1591 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1592 Style)); 1593 EXPECT_EQ("for (int i = 0;\n" 1594 " i < 10; ++i)\n" 1595 "{\n" 1596 " foo();\n" 1597 "}", 1598 format("for(int i=0;i<10;++i){foo();}", Style)); 1599 EXPECT_EQ("while (foo || bar ||\n" 1600 " baz)\n" 1601 "{\n" 1602 " quux();\n" 1603 "}", 1604 format("while(foo||bar||baz){quux();}", Style)); 1605 EXPECT_EQ("switch (\n" 1606 " foo = barbaz)\n" 1607 "{\n" 1608 "case quux:\n" 1609 " return;\n" 1610 "}", 1611 format("switch(foo=barbaz){case quux:return;}", Style)); 1612 EXPECT_EQ("try {\n" 1613 " foo();\n" 1614 "} catch (\n" 1615 " Exception &bar)\n" 1616 "{\n" 1617 " baz();\n" 1618 "}", 1619 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1620 Style.ColumnLimit = 1621 40; // to concentrate at brace wrapping, not line wrap due to column limit 1622 EXPECT_EQ("try {\n" 1623 " foo();\n" 1624 "} catch (Exception &bar) {\n" 1625 " baz();\n" 1626 "}", 1627 format("try{foo();}catch(Exception&bar){baz();}", Style)); 1628 Style.ColumnLimit = 1629 20; // to concentrate at brace wrapping, not line wrap due to column limit 1630 1631 Style.BraceWrapping.BeforeElse = true; 1632 EXPECT_EQ( 1633 "if (foo) {\n" 1634 " bar();\n" 1635 "}\n" 1636 "else if (baz ||\n" 1637 " quux)\n" 1638 "{\n" 1639 " foobar();\n" 1640 "}\n" 1641 "else {\n" 1642 " barbaz();\n" 1643 "}", 1644 format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", 1645 Style)); 1646 1647 Style.BraceWrapping.BeforeCatch = true; 1648 EXPECT_EQ("try {\n" 1649 " foo();\n" 1650 "}\n" 1651 "catch (...) {\n" 1652 " baz();\n" 1653 "}", 1654 format("try{foo();}catch(...){baz();}", Style)); 1655 } 1656 1657 //===----------------------------------------------------------------------===// 1658 // Tests for classes, namespaces, etc. 1659 //===----------------------------------------------------------------------===// 1660 1661 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1662 verifyFormat("class A {};"); 1663 } 1664 1665 TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1666 verifyFormat("class A {\n" 1667 "public:\n" 1668 "public: // comment\n" 1669 "protected:\n" 1670 "private:\n" 1671 " void f() {}\n" 1672 "};"); 1673 verifyFormat("export class A {\n" 1674 "public:\n" 1675 "public: // comment\n" 1676 "protected:\n" 1677 "private:\n" 1678 " void f() {}\n" 1679 "};"); 1680 verifyGoogleFormat("class A {\n" 1681 " public:\n" 1682 " protected:\n" 1683 " private:\n" 1684 " void f() {}\n" 1685 "};"); 1686 verifyGoogleFormat("export class A {\n" 1687 " public:\n" 1688 " protected:\n" 1689 " private:\n" 1690 " void f() {}\n" 1691 "};"); 1692 verifyFormat("class A {\n" 1693 "public slots:\n" 1694 " void f1() {}\n" 1695 "public Q_SLOTS:\n" 1696 " void f2() {}\n" 1697 "protected slots:\n" 1698 " void f3() {}\n" 1699 "protected Q_SLOTS:\n" 1700 " void f4() {}\n" 1701 "private slots:\n" 1702 " void f5() {}\n" 1703 "private Q_SLOTS:\n" 1704 " void f6() {}\n" 1705 "signals:\n" 1706 " void g1();\n" 1707 "Q_SIGNALS:\n" 1708 " void g2();\n" 1709 "};"); 1710 1711 // Don't interpret 'signals' the wrong way. 1712 verifyFormat("signals.set();"); 1713 verifyFormat("for (Signals signals : f()) {\n}"); 1714 verifyFormat("{\n" 1715 " signals.set(); // This needs indentation.\n" 1716 "}"); 1717 verifyFormat("void f() {\n" 1718 "label:\n" 1719 " signals.baz();\n" 1720 "}"); 1721 } 1722 1723 TEST_F(FormatTest, SeparatesLogicalBlocks) { 1724 EXPECT_EQ("class A {\n" 1725 "public:\n" 1726 " void f();\n" 1727 "\n" 1728 "private:\n" 1729 " void g() {}\n" 1730 " // test\n" 1731 "protected:\n" 1732 " int h;\n" 1733 "};", 1734 format("class A {\n" 1735 "public:\n" 1736 "void f();\n" 1737 "private:\n" 1738 "void g() {}\n" 1739 "// test\n" 1740 "protected:\n" 1741 "int h;\n" 1742 "};")); 1743 EXPECT_EQ("class A {\n" 1744 "protected:\n" 1745 "public:\n" 1746 " void f();\n" 1747 "};", 1748 format("class A {\n" 1749 "protected:\n" 1750 "\n" 1751 "public:\n" 1752 "\n" 1753 " void f();\n" 1754 "};")); 1755 1756 // Even ensure proper spacing inside macros. 1757 EXPECT_EQ("#define B \\\n" 1758 " class A { \\\n" 1759 " protected: \\\n" 1760 " public: \\\n" 1761 " void f(); \\\n" 1762 " };", 1763 format("#define B \\\n" 1764 " class A { \\\n" 1765 " protected: \\\n" 1766 " \\\n" 1767 " public: \\\n" 1768 " \\\n" 1769 " void f(); \\\n" 1770 " };", 1771 getGoogleStyle())); 1772 // But don't remove empty lines after macros ending in access specifiers. 1773 EXPECT_EQ("#define A private:\n" 1774 "\n" 1775 "int i;", 1776 format("#define A private:\n" 1777 "\n" 1778 "int i;")); 1779 } 1780 1781 TEST_F(FormatTest, FormatsClasses) { 1782 verifyFormat("class A : public B {};"); 1783 verifyFormat("class A : public ::B {};"); 1784 1785 verifyFormat( 1786 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1787 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1788 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1789 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1790 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1791 verifyFormat( 1792 "class A : public B, public C, public D, public E, public F {};"); 1793 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1794 " public C,\n" 1795 " public D,\n" 1796 " public E,\n" 1797 " public F,\n" 1798 " public G {};"); 1799 1800 verifyFormat("class\n" 1801 " ReallyReallyLongClassName {\n" 1802 " int i;\n" 1803 "};", 1804 getLLVMStyleWithColumns(32)); 1805 verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" 1806 " aaaaaaaaaaaaaaaa> {};"); 1807 verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" 1808 " : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n" 1809 " aaaaaaaaaaaaaaaaaaaaaa> {};"); 1810 verifyFormat("template <class R, class C>\n" 1811 "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n" 1812 " : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};"); 1813 verifyFormat("class ::A::B {};"); 1814 } 1815 1816 TEST_F(FormatTest, BreakInheritanceStyle) { 1817 FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); 1818 StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = 1819 FormatStyle::BILS_BeforeComma; 1820 verifyFormat("class MyClass : public X {};", 1821 StyleWithInheritanceBreakBeforeComma); 1822 verifyFormat("class MyClass\n" 1823 " : public X\n" 1824 " , public Y {};", 1825 StyleWithInheritanceBreakBeforeComma); 1826 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" 1827 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" 1828 " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1829 StyleWithInheritanceBreakBeforeComma); 1830 verifyFormat("struct aaaaaaaaaaaaa\n" 1831 " : public aaaaaaaaaaaaaaaaaaa< // break\n" 1832 " aaaaaaaaaaaaaaaa> {};", 1833 StyleWithInheritanceBreakBeforeComma); 1834 1835 FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); 1836 StyleWithInheritanceBreakAfterColon.BreakInheritanceList = 1837 FormatStyle::BILS_AfterColon; 1838 verifyFormat("class MyClass : public X {};", 1839 StyleWithInheritanceBreakAfterColon); 1840 verifyFormat("class MyClass : public X, public Y {};", 1841 StyleWithInheritanceBreakAfterColon); 1842 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" 1843 " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1844 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", 1845 StyleWithInheritanceBreakAfterColon); 1846 verifyFormat("struct aaaaaaaaaaaaa :\n" 1847 " public aaaaaaaaaaaaaaaaaaa< // break\n" 1848 " aaaaaaaaaaaaaaaa> {};", 1849 StyleWithInheritanceBreakAfterColon); 1850 } 1851 1852 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1853 verifyFormat("class A {\n} a, b;"); 1854 verifyFormat("struct A {\n} a, b;"); 1855 verifyFormat("union A {\n} a;"); 1856 } 1857 1858 TEST_F(FormatTest, FormatsEnum) { 1859 verifyFormat("enum {\n" 1860 " Zero,\n" 1861 " One = 1,\n" 1862 " Two = One + 1,\n" 1863 " Three = (One + Two),\n" 1864 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1865 " Five = (One, Two, Three, Four, 5)\n" 1866 "};"); 1867 verifyGoogleFormat("enum {\n" 1868 " Zero,\n" 1869 " One = 1,\n" 1870 " Two = One + 1,\n" 1871 " Three = (One + Two),\n" 1872 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1873 " Five = (One, Two, Three, Four, 5)\n" 1874 "};"); 1875 verifyFormat("enum Enum {};"); 1876 verifyFormat("enum {};"); 1877 verifyFormat("enum X E {} d;"); 1878 verifyFormat("enum __attribute__((...)) E {} d;"); 1879 verifyFormat("enum __declspec__((...)) E {} d;"); 1880 verifyFormat("enum {\n" 1881 " Bar = Foo<int, int>::value\n" 1882 "};", 1883 getLLVMStyleWithColumns(30)); 1884 1885 verifyFormat("enum ShortEnum { A, B, C };"); 1886 verifyGoogleFormat("enum ShortEnum { A, B, C };"); 1887 1888 EXPECT_EQ("enum KeepEmptyLines {\n" 1889 " ONE,\n" 1890 "\n" 1891 " TWO,\n" 1892 "\n" 1893 " THREE\n" 1894 "}", 1895 format("enum KeepEmptyLines {\n" 1896 " ONE,\n" 1897 "\n" 1898 " TWO,\n" 1899 "\n" 1900 "\n" 1901 " THREE\n" 1902 "}")); 1903 verifyFormat("enum E { // comment\n" 1904 " ONE,\n" 1905 " TWO\n" 1906 "};\n" 1907 "int i;"); 1908 // Not enums. 1909 verifyFormat("enum X f() {\n" 1910 " a();\n" 1911 " return 42;\n" 1912 "}"); 1913 verifyFormat("enum X Type::f() {\n" 1914 " a();\n" 1915 " return 42;\n" 1916 "}"); 1917 verifyFormat("enum ::X f() {\n" 1918 " a();\n" 1919 " return 42;\n" 1920 "}"); 1921 verifyFormat("enum ns::X f() {\n" 1922 " a();\n" 1923 " return 42;\n" 1924 "}"); 1925 } 1926 1927 TEST_F(FormatTest, FormatsEnumsWithErrors) { 1928 verifyFormat("enum Type {\n" 1929 " One = 0; // These semicolons should be commas.\n" 1930 " Two = 1;\n" 1931 "};"); 1932 verifyFormat("namespace n {\n" 1933 "enum Type {\n" 1934 " One,\n" 1935 " Two, // missing };\n" 1936 " int i;\n" 1937 "}\n" 1938 "void g() {}"); 1939 } 1940 1941 TEST_F(FormatTest, FormatsEnumStruct) { 1942 verifyFormat("enum struct {\n" 1943 " Zero,\n" 1944 " One = 1,\n" 1945 " Two = One + 1,\n" 1946 " Three = (One + Two),\n" 1947 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1948 " Five = (One, Two, Three, Four, 5)\n" 1949 "};"); 1950 verifyFormat("enum struct Enum {};"); 1951 verifyFormat("enum struct {};"); 1952 verifyFormat("enum struct X E {} d;"); 1953 verifyFormat("enum struct __attribute__((...)) E {} d;"); 1954 verifyFormat("enum struct __declspec__((...)) E {} d;"); 1955 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1956 } 1957 1958 TEST_F(FormatTest, FormatsEnumClass) { 1959 verifyFormat("enum class {\n" 1960 " Zero,\n" 1961 " One = 1,\n" 1962 " Two = One + 1,\n" 1963 " Three = (One + Two),\n" 1964 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1965 " Five = (One, Two, Three, Four, 5)\n" 1966 "};"); 1967 verifyFormat("enum class Enum {};"); 1968 verifyFormat("enum class {};"); 1969 verifyFormat("enum class X E {} d;"); 1970 verifyFormat("enum class __attribute__((...)) E {} d;"); 1971 verifyFormat("enum class __declspec__((...)) E {} d;"); 1972 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 1973 } 1974 1975 TEST_F(FormatTest, FormatsEnumTypes) { 1976 verifyFormat("enum X : int {\n" 1977 " A, // Force multiple lines.\n" 1978 " B\n" 1979 "};"); 1980 verifyFormat("enum X : int { A, B };"); 1981 verifyFormat("enum X : std::uint32_t { A, B };"); 1982 } 1983 1984 TEST_F(FormatTest, FormatsTypedefEnum) { 1985 FormatStyle Style = getLLVMStyle(); 1986 Style.ColumnLimit = 40; 1987 verifyFormat("typedef enum {} EmptyEnum;"); 1988 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 1989 verifyFormat("typedef enum {\n" 1990 " ZERO = 0,\n" 1991 " ONE = 1,\n" 1992 " TWO = 2,\n" 1993 " THREE = 3\n" 1994 "} LongEnum;", 1995 Style); 1996 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 1997 Style.BraceWrapping.AfterEnum = true; 1998 verifyFormat("typedef enum {} EmptyEnum;"); 1999 verifyFormat("typedef enum { A, B, C } ShortEnum;"); 2000 verifyFormat("typedef enum\n" 2001 "{\n" 2002 " ZERO = 0,\n" 2003 " ONE = 1,\n" 2004 " TWO = 2,\n" 2005 " THREE = 3\n" 2006 "} LongEnum;", 2007 Style); 2008 } 2009 2010 TEST_F(FormatTest, FormatsNSEnums) { 2011 verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); 2012 verifyGoogleFormat( 2013 "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }"); 2014 verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" 2015 " // Information about someDecentlyLongValue.\n" 2016 " someDecentlyLongValue,\n" 2017 " // Information about anotherDecentlyLongValue.\n" 2018 " anotherDecentlyLongValue,\n" 2019 " // Information about aThirdDecentlyLongValue.\n" 2020 " aThirdDecentlyLongValue\n" 2021 "};"); 2022 verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n" 2023 " // Information about someDecentlyLongValue.\n" 2024 " someDecentlyLongValue,\n" 2025 " // Information about anotherDecentlyLongValue.\n" 2026 " anotherDecentlyLongValue,\n" 2027 " // Information about aThirdDecentlyLongValue.\n" 2028 " aThirdDecentlyLongValue\n" 2029 "};"); 2030 verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" 2031 " a = 1,\n" 2032 " b = 2,\n" 2033 " c = 3,\n" 2034 "};"); 2035 verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" 2036 " a = 1,\n" 2037 " b = 2,\n" 2038 " c = 3,\n" 2039 "};"); 2040 verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n" 2041 " a = 1,\n" 2042 " b = 2,\n" 2043 " c = 3,\n" 2044 "};"); 2045 verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" 2046 " a = 1,\n" 2047 " b = 2,\n" 2048 " c = 3,\n" 2049 "};"); 2050 } 2051 2052 TEST_F(FormatTest, FormatsBitfields) { 2053 verifyFormat("struct Bitfields {\n" 2054 " unsigned sClass : 8;\n" 2055 " unsigned ValueKind : 2;\n" 2056 "};"); 2057 verifyFormat("struct A {\n" 2058 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" 2059 " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" 2060 "};"); 2061 verifyFormat("struct MyStruct {\n" 2062 " uchar data;\n" 2063 " uchar : 8;\n" 2064 " uchar : 8;\n" 2065 " uchar other;\n" 2066 "};"); 2067 } 2068 2069 TEST_F(FormatTest, FormatsNamespaces) { 2070 FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); 2071 LLVMWithNoNamespaceFix.FixNamespaceComments = false; 2072 2073 verifyFormat("namespace some_namespace {\n" 2074 "class A {};\n" 2075 "void f() { f(); }\n" 2076 "}", 2077 LLVMWithNoNamespaceFix); 2078 verifyFormat("namespace N::inline D {\n" 2079 "class A {};\n" 2080 "void f() { f(); }\n" 2081 "}", 2082 LLVMWithNoNamespaceFix); 2083 verifyFormat("namespace N::inline D::E {\n" 2084 "class A {};\n" 2085 "void f() { f(); }\n" 2086 "}", 2087 LLVMWithNoNamespaceFix); 2088 verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n" 2089 "class A {};\n" 2090 "void f() { f(); }\n" 2091 "}", 2092 LLVMWithNoNamespaceFix); 2093 verifyFormat("/* something */ namespace some_namespace {\n" 2094 "class A {};\n" 2095 "void f() { f(); }\n" 2096 "}", 2097 LLVMWithNoNamespaceFix); 2098 verifyFormat("namespace {\n" 2099 "class A {};\n" 2100 "void f() { f(); }\n" 2101 "}", 2102 LLVMWithNoNamespaceFix); 2103 verifyFormat("/* something */ namespace {\n" 2104 "class A {};\n" 2105 "void f() { f(); }\n" 2106 "}", 2107 LLVMWithNoNamespaceFix); 2108 verifyFormat("inline namespace X {\n" 2109 "class A {};\n" 2110 "void f() { f(); }\n" 2111 "}", 2112 LLVMWithNoNamespaceFix); 2113 verifyFormat("/* something */ inline namespace X {\n" 2114 "class A {};\n" 2115 "void f() { f(); }\n" 2116 "}", 2117 LLVMWithNoNamespaceFix); 2118 verifyFormat("export namespace X {\n" 2119 "class A {};\n" 2120 "void f() { f(); }\n" 2121 "}", 2122 LLVMWithNoNamespaceFix); 2123 verifyFormat("using namespace some_namespace;\n" 2124 "class A {};\n" 2125 "void f() { f(); }", 2126 LLVMWithNoNamespaceFix); 2127 2128 // This code is more common than we thought; if we 2129 // layout this correctly the semicolon will go into 2130 // its own line, which is undesirable. 2131 verifyFormat("namespace {};", LLVMWithNoNamespaceFix); 2132 verifyFormat("namespace {\n" 2133 "class A {};\n" 2134 "};", 2135 LLVMWithNoNamespaceFix); 2136 2137 verifyFormat("namespace {\n" 2138 "int SomeVariable = 0; // comment\n" 2139 "} // namespace", 2140 LLVMWithNoNamespaceFix); 2141 EXPECT_EQ("#ifndef HEADER_GUARD\n" 2142 "#define HEADER_GUARD\n" 2143 "namespace my_namespace {\n" 2144 "int i;\n" 2145 "} // my_namespace\n" 2146 "#endif // HEADER_GUARD", 2147 format("#ifndef HEADER_GUARD\n" 2148 " #define HEADER_GUARD\n" 2149 " namespace my_namespace {\n" 2150 "int i;\n" 2151 "} // my_namespace\n" 2152 "#endif // HEADER_GUARD", 2153 LLVMWithNoNamespaceFix)); 2154 2155 EXPECT_EQ("namespace A::B {\n" 2156 "class C {};\n" 2157 "}", 2158 format("namespace A::B {\n" 2159 "class C {};\n" 2160 "}", 2161 LLVMWithNoNamespaceFix)); 2162 2163 FormatStyle Style = getLLVMStyle(); 2164 Style.NamespaceIndentation = FormatStyle::NI_All; 2165 EXPECT_EQ("namespace out {\n" 2166 " int i;\n" 2167 " namespace in {\n" 2168 " int i;\n" 2169 " } // namespace in\n" 2170 "} // namespace out", 2171 format("namespace out {\n" 2172 "int i;\n" 2173 "namespace in {\n" 2174 "int i;\n" 2175 "} // namespace in\n" 2176 "} // namespace out", 2177 Style)); 2178 2179 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2180 EXPECT_EQ("namespace out {\n" 2181 "int i;\n" 2182 "namespace in {\n" 2183 " int i;\n" 2184 "} // namespace in\n" 2185 "} // namespace out", 2186 format("namespace out {\n" 2187 "int i;\n" 2188 "namespace in {\n" 2189 "int i;\n" 2190 "} // namespace in\n" 2191 "} // namespace out", 2192 Style)); 2193 } 2194 2195 TEST_F(FormatTest, NamespaceMacros) { 2196 FormatStyle Style = getLLVMStyle(); 2197 Style.NamespaceMacros.push_back("TESTSUITE"); 2198 2199 verifyFormat("TESTSUITE(A) {\n" 2200 "int foo();\n" 2201 "} // TESTSUITE(A)", 2202 Style); 2203 2204 verifyFormat("TESTSUITE(A, B) {\n" 2205 "int foo();\n" 2206 "} // TESTSUITE(A)", 2207 Style); 2208 2209 // Properly indent according to NamespaceIndentation style 2210 Style.NamespaceIndentation = FormatStyle::NI_All; 2211 verifyFormat("TESTSUITE(A) {\n" 2212 " int foo();\n" 2213 "} // TESTSUITE(A)", 2214 Style); 2215 verifyFormat("TESTSUITE(A) {\n" 2216 " namespace B {\n" 2217 " int foo();\n" 2218 " } // namespace B\n" 2219 "} // TESTSUITE(A)", 2220 Style); 2221 verifyFormat("namespace A {\n" 2222 " TESTSUITE(B) {\n" 2223 " int foo();\n" 2224 " } // TESTSUITE(B)\n" 2225 "} // namespace A", 2226 Style); 2227 2228 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2229 verifyFormat("TESTSUITE(A) {\n" 2230 "TESTSUITE(B) {\n" 2231 " int foo();\n" 2232 "} // TESTSUITE(B)\n" 2233 "} // TESTSUITE(A)", 2234 Style); 2235 verifyFormat("TESTSUITE(A) {\n" 2236 "namespace B {\n" 2237 " int foo();\n" 2238 "} // namespace B\n" 2239 "} // TESTSUITE(A)", 2240 Style); 2241 verifyFormat("namespace A {\n" 2242 "TESTSUITE(B) {\n" 2243 " int foo();\n" 2244 "} // TESTSUITE(B)\n" 2245 "} // namespace A", 2246 Style); 2247 2248 // Properly merge namespace-macros blocks in CompactNamespaces mode 2249 Style.NamespaceIndentation = FormatStyle::NI_None; 2250 Style.CompactNamespaces = true; 2251 verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n" 2252 "}} // TESTSUITE(A::B)", 2253 Style); 2254 2255 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2256 "}} // TESTSUITE(out::in)", 2257 format("TESTSUITE(out) {\n" 2258 "TESTSUITE(in) {\n" 2259 "} // TESTSUITE(in)\n" 2260 "} // TESTSUITE(out)", 2261 Style)); 2262 2263 EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n" 2264 "}} // TESTSUITE(out::in)", 2265 format("TESTSUITE(out) {\n" 2266 "TESTSUITE(in) {\n" 2267 "} // TESTSUITE(in)\n" 2268 "} // TESTSUITE(out)", 2269 Style)); 2270 2271 // Do not merge different namespaces/macros 2272 EXPECT_EQ("namespace out {\n" 2273 "TESTSUITE(in) {\n" 2274 "} // TESTSUITE(in)\n" 2275 "} // namespace out", 2276 format("namespace out {\n" 2277 "TESTSUITE(in) {\n" 2278 "} // TESTSUITE(in)\n" 2279 "} // namespace out", 2280 Style)); 2281 EXPECT_EQ("TESTSUITE(out) {\n" 2282 "namespace in {\n" 2283 "} // namespace in\n" 2284 "} // TESTSUITE(out)", 2285 format("TESTSUITE(out) {\n" 2286 "namespace in {\n" 2287 "} // namespace in\n" 2288 "} // TESTSUITE(out)", 2289 Style)); 2290 Style.NamespaceMacros.push_back("FOOBAR"); 2291 EXPECT_EQ("TESTSUITE(out) {\n" 2292 "FOOBAR(in) {\n" 2293 "} // FOOBAR(in)\n" 2294 "} // TESTSUITE(out)", 2295 format("TESTSUITE(out) {\n" 2296 "FOOBAR(in) {\n" 2297 "} // FOOBAR(in)\n" 2298 "} // TESTSUITE(out)", 2299 Style)); 2300 } 2301 2302 TEST_F(FormatTest, FormatsCompactNamespaces) { 2303 FormatStyle Style = getLLVMStyle(); 2304 Style.CompactNamespaces = true; 2305 Style.NamespaceMacros.push_back("TESTSUITE"); 2306 2307 verifyFormat("namespace A { namespace B {\n" 2308 "}} // namespace A::B", 2309 Style); 2310 2311 EXPECT_EQ("namespace out { namespace in {\n" 2312 "}} // namespace out::in", 2313 format("namespace out {\n" 2314 "namespace in {\n" 2315 "} // namespace in\n" 2316 "} // namespace out", 2317 Style)); 2318 2319 // Only namespaces which have both consecutive opening and end get compacted 2320 EXPECT_EQ("namespace out {\n" 2321 "namespace in1 {\n" 2322 "} // namespace in1\n" 2323 "namespace in2 {\n" 2324 "} // namespace in2\n" 2325 "} // namespace out", 2326 format("namespace out {\n" 2327 "namespace in1 {\n" 2328 "} // namespace in1\n" 2329 "namespace in2 {\n" 2330 "} // namespace in2\n" 2331 "} // namespace out", 2332 Style)); 2333 2334 EXPECT_EQ("namespace out {\n" 2335 "int i;\n" 2336 "namespace in {\n" 2337 "int j;\n" 2338 "} // namespace in\n" 2339 "int k;\n" 2340 "} // namespace out", 2341 format("namespace out { int i;\n" 2342 "namespace in { int j; } // namespace in\n" 2343 "int k; } // namespace out", 2344 Style)); 2345 2346 EXPECT_EQ("namespace A { namespace B { namespace C {\n" 2347 "}}} // namespace A::B::C\n", 2348 format("namespace A { namespace B {\n" 2349 "namespace C {\n" 2350 "}} // namespace B::C\n" 2351 "} // namespace A\n", 2352 Style)); 2353 2354 Style.ColumnLimit = 40; 2355 EXPECT_EQ("namespace aaaaaaaaaa {\n" 2356 "namespace bbbbbbbbbb {\n" 2357 "}} // namespace aaaaaaaaaa::bbbbbbbbbb", 2358 format("namespace aaaaaaaaaa {\n" 2359 "namespace bbbbbbbbbb {\n" 2360 "} // namespace bbbbbbbbbb\n" 2361 "} // namespace aaaaaaaaaa", 2362 Style)); 2363 2364 EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n" 2365 "namespace cccccc {\n" 2366 "}}} // namespace aaaaaa::bbbbbb::cccccc", 2367 format("namespace aaaaaa {\n" 2368 "namespace bbbbbb {\n" 2369 "namespace cccccc {\n" 2370 "} // namespace cccccc\n" 2371 "} // namespace bbbbbb\n" 2372 "} // namespace aaaaaa", 2373 Style)); 2374 Style.ColumnLimit = 80; 2375 2376 // Extra semicolon after 'inner' closing brace prevents merging 2377 EXPECT_EQ("namespace out { namespace in {\n" 2378 "}; } // namespace out::in", 2379 format("namespace out {\n" 2380 "namespace in {\n" 2381 "}; // namespace in\n" 2382 "} // namespace out", 2383 Style)); 2384 2385 // Extra semicolon after 'outer' closing brace is conserved 2386 EXPECT_EQ("namespace out { namespace in {\n" 2387 "}}; // namespace out::in", 2388 format("namespace out {\n" 2389 "namespace in {\n" 2390 "} // namespace in\n" 2391 "}; // namespace out", 2392 Style)); 2393 2394 Style.NamespaceIndentation = FormatStyle::NI_All; 2395 EXPECT_EQ("namespace out { namespace in {\n" 2396 " int i;\n" 2397 "}} // namespace out::in", 2398 format("namespace out {\n" 2399 "namespace in {\n" 2400 "int i;\n" 2401 "} // namespace in\n" 2402 "} // namespace out", 2403 Style)); 2404 EXPECT_EQ("namespace out { namespace mid {\n" 2405 " namespace in {\n" 2406 " int j;\n" 2407 " } // namespace in\n" 2408 " int k;\n" 2409 "}} // namespace out::mid", 2410 format("namespace out { namespace mid {\n" 2411 "namespace in { int j; } // namespace in\n" 2412 "int k; }} // namespace out::mid", 2413 Style)); 2414 2415 Style.NamespaceIndentation = FormatStyle::NI_Inner; 2416 EXPECT_EQ("namespace out { namespace in {\n" 2417 " int i;\n" 2418 "}} // namespace out::in", 2419 format("namespace out {\n" 2420 "namespace in {\n" 2421 "int i;\n" 2422 "} // namespace in\n" 2423 "} // namespace out", 2424 Style)); 2425 EXPECT_EQ("namespace out { namespace mid { namespace in {\n" 2426 " int i;\n" 2427 "}}} // namespace out::mid::in", 2428 format("namespace out {\n" 2429 "namespace mid {\n" 2430 "namespace in {\n" 2431 "int i;\n" 2432 "} // namespace in\n" 2433 "} // namespace mid\n" 2434 "} // namespace out", 2435 Style)); 2436 } 2437 2438 TEST_F(FormatTest, FormatsExternC) { 2439 verifyFormat("extern \"C\" {\nint a;"); 2440 verifyFormat("extern \"C\" {}"); 2441 verifyFormat("extern \"C\" {\n" 2442 "int foo();\n" 2443 "}"); 2444 verifyFormat("extern \"C\" int foo() {}"); 2445 verifyFormat("extern \"C\" int foo();"); 2446 verifyFormat("extern \"C\" int foo() {\n" 2447 " int i = 42;\n" 2448 " return i;\n" 2449 "}"); 2450 2451 FormatStyle Style = getLLVMStyle(); 2452 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2453 Style.BraceWrapping.AfterFunction = true; 2454 verifyFormat("extern \"C\" int foo() {}", Style); 2455 verifyFormat("extern \"C\" int foo();", Style); 2456 verifyFormat("extern \"C\" int foo()\n" 2457 "{\n" 2458 " int i = 42;\n" 2459 " return i;\n" 2460 "}", 2461 Style); 2462 2463 Style.BraceWrapping.AfterExternBlock = true; 2464 Style.BraceWrapping.SplitEmptyRecord = false; 2465 verifyFormat("extern \"C\"\n" 2466 "{}", 2467 Style); 2468 verifyFormat("extern \"C\"\n" 2469 "{\n" 2470 " int foo();\n" 2471 "}", 2472 Style); 2473 } 2474 2475 TEST_F(FormatTest, FormatsInlineASM) { 2476 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 2477 verifyFormat("asm(\"nop\" ::: \"memory\");"); 2478 verifyFormat( 2479 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 2480 " \"cpuid\\n\\t\"\n" 2481 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 2482 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 2483 " : \"a\"(value));"); 2484 EXPECT_EQ( 2485 "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2486 " __asm {\n" 2487 " mov edx,[that] // vtable in edx\n" 2488 " mov eax,methodIndex\n" 2489 " call [edx][eax*4] // stdcall\n" 2490 " }\n" 2491 "}", 2492 format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" 2493 " __asm {\n" 2494 " mov edx,[that] // vtable in edx\n" 2495 " mov eax,methodIndex\n" 2496 " call [edx][eax*4] // stdcall\n" 2497 " }\n" 2498 "}")); 2499 EXPECT_EQ("_asm {\n" 2500 " xor eax, eax;\n" 2501 " cpuid;\n" 2502 "}", 2503 format("_asm {\n" 2504 " xor eax, eax;\n" 2505 " cpuid;\n" 2506 "}")); 2507 verifyFormat("void function() {\n" 2508 " // comment\n" 2509 " asm(\"\");\n" 2510 "}"); 2511 EXPECT_EQ("__asm {\n" 2512 "}\n" 2513 "int i;", 2514 format("__asm {\n" 2515 "}\n" 2516 "int i;")); 2517 } 2518 2519 TEST_F(FormatTest, FormatTryCatch) { 2520 verifyFormat("try {\n" 2521 " throw a * b;\n" 2522 "} catch (int a) {\n" 2523 " // Do nothing.\n" 2524 "} catch (...) {\n" 2525 " exit(42);\n" 2526 "}"); 2527 2528 // Function-level try statements. 2529 verifyFormat("int f() try { return 4; } catch (...) {\n" 2530 " return 5;\n" 2531 "}"); 2532 verifyFormat("class A {\n" 2533 " int a;\n" 2534 " A() try : a(0) {\n" 2535 " } catch (...) {\n" 2536 " throw;\n" 2537 " }\n" 2538 "};\n"); 2539 2540 // Incomplete try-catch blocks. 2541 verifyIncompleteFormat("try {} catch ("); 2542 } 2543 2544 TEST_F(FormatTest, FormatSEHTryCatch) { 2545 verifyFormat("__try {\n" 2546 " int a = b * c;\n" 2547 "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" 2548 " // Do nothing.\n" 2549 "}"); 2550 2551 verifyFormat("__try {\n" 2552 " int a = b * c;\n" 2553 "} __finally {\n" 2554 " // Do nothing.\n" 2555 "}"); 2556 2557 verifyFormat("DEBUG({\n" 2558 " __try {\n" 2559 " } __finally {\n" 2560 " }\n" 2561 "});\n"); 2562 } 2563 2564 TEST_F(FormatTest, IncompleteTryCatchBlocks) { 2565 verifyFormat("try {\n" 2566 " f();\n" 2567 "} catch {\n" 2568 " g();\n" 2569 "}"); 2570 verifyFormat("try {\n" 2571 " f();\n" 2572 "} catch (A a) MACRO(x) {\n" 2573 " g();\n" 2574 "} catch (B b) MACRO(x) {\n" 2575 " g();\n" 2576 "}"); 2577 } 2578 2579 TEST_F(FormatTest, FormatTryCatchBraceStyles) { 2580 FormatStyle Style = getLLVMStyle(); 2581 for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, 2582 FormatStyle::BS_WebKit}) { 2583 Style.BreakBeforeBraces = BraceStyle; 2584 verifyFormat("try {\n" 2585 " // something\n" 2586 "} catch (...) {\n" 2587 " // something\n" 2588 "}", 2589 Style); 2590 } 2591 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 2592 verifyFormat("try {\n" 2593 " // something\n" 2594 "}\n" 2595 "catch (...) {\n" 2596 " // something\n" 2597 "}", 2598 Style); 2599 verifyFormat("__try {\n" 2600 " // something\n" 2601 "}\n" 2602 "__finally {\n" 2603 " // something\n" 2604 "}", 2605 Style); 2606 verifyFormat("@try {\n" 2607 " // something\n" 2608 "}\n" 2609 "@finally {\n" 2610 " // something\n" 2611 "}", 2612 Style); 2613 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 2614 verifyFormat("try\n" 2615 "{\n" 2616 " // something\n" 2617 "}\n" 2618 "catch (...)\n" 2619 "{\n" 2620 " // something\n" 2621 "}", 2622 Style); 2623 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 2624 verifyFormat("try\n" 2625 " {\n" 2626 " // something white\n" 2627 " }\n" 2628 "catch (...)\n" 2629 " {\n" 2630 " // something white\n" 2631 " }", 2632 Style); 2633 Style.BreakBeforeBraces = FormatStyle::BS_GNU; 2634 verifyFormat("try\n" 2635 " {\n" 2636 " // something\n" 2637 " }\n" 2638 "catch (...)\n" 2639 " {\n" 2640 " // something\n" 2641 " }", 2642 Style); 2643 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 2644 Style.BraceWrapping.BeforeCatch = true; 2645 verifyFormat("try {\n" 2646 " // something\n" 2647 "}\n" 2648 "catch (...) {\n" 2649 " // something\n" 2650 "}", 2651 Style); 2652 } 2653 2654 TEST_F(FormatTest, StaticInitializers) { 2655 verifyFormat("static SomeClass SC = {1, 'a'};"); 2656 2657 verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" 2658 " 100000000, " 2659 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); 2660 2661 // Here, everything other than the "}" would fit on a line. 2662 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 2663 " 10000000000000000000000000};"); 2664 EXPECT_EQ("S s = {a,\n" 2665 "\n" 2666 " b};", 2667 format("S s = {\n" 2668 " a,\n" 2669 "\n" 2670 " b\n" 2671 "};")); 2672 2673 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 2674 // line. However, the formatting looks a bit off and this probably doesn't 2675 // happen often in practice. 2676 verifyFormat("static int Variable[1] = {\n" 2677 " {1000000000000000000000000000000000000}};", 2678 getLLVMStyleWithColumns(40)); 2679 } 2680 2681 TEST_F(FormatTest, DesignatedInitializers) { 2682 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 2683 verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n" 2684 " .bbbbbbbbbb = 2,\n" 2685 " .cccccccccc = 3,\n" 2686 " .dddddddddd = 4,\n" 2687 " .eeeeeeeeee = 5};"); 2688 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2689 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 2690 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 2691 " .ccccccccccccccccccccccccccc = 3,\n" 2692 " .ddddddddddddddddddddddddddd = 4,\n" 2693 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};"); 2694 2695 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 2696 2697 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 2698 verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" 2699 " [2] = bbbbbbbbbb,\n" 2700 " [3] = cccccccccc,\n" 2701 " [4] = dddddddddd,\n" 2702 " [5] = eeeeeeeeee};"); 2703 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 2704 " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2705 " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2706 " [3] = cccccccccccccccccccccccccccccccccccccc,\n" 2707 " [4] = dddddddddddddddddddddddddddddddddddddd,\n" 2708 " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); 2709 } 2710 2711 TEST_F(FormatTest, NestedStaticInitializers) { 2712 verifyFormat("static A x = {{{}}};\n"); 2713 verifyFormat("static A x = {{{init1, init2, init3, init4},\n" 2714 " {init1, init2, init3, init4}}};", 2715 getLLVMStyleWithColumns(50)); 2716 2717 verifyFormat("somes Status::global_reps[3] = {\n" 2718 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2719 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2720 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};", 2721 getLLVMStyleWithColumns(60)); 2722 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 2723 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 2724 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 2725 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 2726 verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n" 2727 " {rect.fRight - rect.fLeft, rect.fBottom - " 2728 "rect.fTop}};"); 2729 2730 verifyFormat( 2731 "SomeArrayOfSomeType a = {\n" 2732 " {{1, 2, 3},\n" 2733 " {1, 2, 3},\n" 2734 " {111111111111111111111111111111, 222222222222222222222222222222,\n" 2735 " 333333333333333333333333333333},\n" 2736 " {1, 2, 3},\n" 2737 " {1, 2, 3}}};"); 2738 verifyFormat( 2739 "SomeArrayOfSomeType a = {\n" 2740 " {{1, 2, 3}},\n" 2741 " {{1, 2, 3}},\n" 2742 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 2743 " 333333333333333333333333333333}},\n" 2744 " {{1, 2, 3}},\n" 2745 " {{1, 2, 3}}};"); 2746 2747 verifyFormat("struct {\n" 2748 " unsigned bit;\n" 2749 " const char *const name;\n" 2750 "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n" 2751 " {kOsWin, \"Windows\"},\n" 2752 " {kOsLinux, \"Linux\"},\n" 2753 " {kOsCrOS, \"Chrome OS\"}};"); 2754 verifyFormat("struct {\n" 2755 " unsigned bit;\n" 2756 " const char *const name;\n" 2757 "} kBitsToOs[] = {\n" 2758 " {kOsMac, \"Mac\"},\n" 2759 " {kOsWin, \"Windows\"},\n" 2760 " {kOsLinux, \"Linux\"},\n" 2761 " {kOsCrOS, \"Chrome OS\"},\n" 2762 "};"); 2763 } 2764 2765 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 2766 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2767 " \\\n" 2768 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 2769 } 2770 2771 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 2772 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 2773 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 2774 2775 // Do break defaulted and deleted functions. 2776 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2777 " default;", 2778 getLLVMStyleWithColumns(40)); 2779 verifyFormat("virtual void ~Deeeeeeeestructor() =\n" 2780 " delete;", 2781 getLLVMStyleWithColumns(40)); 2782 } 2783 2784 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { 2785 verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", 2786 getLLVMStyleWithColumns(40)); 2787 verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2788 getLLVMStyleWithColumns(40)); 2789 EXPECT_EQ("#define Q \\\n" 2790 " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" 2791 " \"aaaaaaaa.cpp\"", 2792 format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", 2793 getLLVMStyleWithColumns(40))); 2794 } 2795 2796 TEST_F(FormatTest, UnderstandsLinePPDirective) { 2797 EXPECT_EQ("# 123 \"A string literal\"", 2798 format(" # 123 \"A string literal\"")); 2799 } 2800 2801 TEST_F(FormatTest, LayoutUnknownPPDirective) { 2802 EXPECT_EQ("#;", format("#;")); 2803 verifyFormat("#\n;\n;\n;"); 2804 } 2805 2806 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 2807 EXPECT_EQ("#line 42 \"test\"\n", 2808 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 2809 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 2810 getLLVMStyleWithColumns(12))); 2811 } 2812 2813 TEST_F(FormatTest, EndOfFileEndsPPDirective) { 2814 EXPECT_EQ("#line 42 \"test\"", 2815 format("# \\\n line \\\n 42 \\\n \"test\"")); 2816 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 2817 } 2818 2819 TEST_F(FormatTest, DoesntRemoveUnknownTokens) { 2820 verifyFormat("#define A \\x20"); 2821 verifyFormat("#define A \\ x20"); 2822 EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); 2823 verifyFormat("#define A ''"); 2824 verifyFormat("#define A ''qqq"); 2825 verifyFormat("#define A `qqq"); 2826 verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); 2827 EXPECT_EQ("const char *c = STRINGIFY(\n" 2828 "\\na : b);", 2829 format("const char * c = STRINGIFY(\n" 2830 "\\na : b);")); 2831 2832 verifyFormat("a\r\\"); 2833 verifyFormat("a\v\\"); 2834 verifyFormat("a\f\\"); 2835 } 2836 2837 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 2838 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 2839 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 2840 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 2841 // FIXME: We never break before the macro name. 2842 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 2843 2844 verifyFormat("#define A A\n#define A A"); 2845 verifyFormat("#define A(X) A\n#define A A"); 2846 2847 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 2848 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 2849 } 2850 2851 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 2852 EXPECT_EQ("// somecomment\n" 2853 "#include \"a.h\"\n" 2854 "#define A( \\\n" 2855 " A, B)\n" 2856 "#include \"b.h\"\n" 2857 "// somecomment\n", 2858 format(" // somecomment\n" 2859 " #include \"a.h\"\n" 2860 "#define A(A,\\\n" 2861 " B)\n" 2862 " #include \"b.h\"\n" 2863 " // somecomment\n", 2864 getLLVMStyleWithColumns(13))); 2865 } 2866 2867 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 2868 2869 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 2870 EXPECT_EQ("#define A \\\n" 2871 " c; \\\n" 2872 " e;\n" 2873 "f;", 2874 format("#define A c; e;\n" 2875 "f;", 2876 getLLVMStyleWithColumns(14))); 2877 } 2878 2879 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 2880 2881 TEST_F(FormatTest, MacroDefinitionInsideStatement) { 2882 EXPECT_EQ("int x,\n" 2883 "#define A\n" 2884 " y;", 2885 format("int x,\n#define A\ny;")); 2886 } 2887 2888 TEST_F(FormatTest, HashInMacroDefinition) { 2889 EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); 2890 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 2891 verifyFormat("#define A \\\n" 2892 " { \\\n" 2893 " f(#c); \\\n" 2894 " }", 2895 getLLVMStyleWithColumns(11)); 2896 2897 verifyFormat("#define A(X) \\\n" 2898 " void function##X()", 2899 getLLVMStyleWithColumns(22)); 2900 2901 verifyFormat("#define A(a, b, c) \\\n" 2902 " void a##b##c()", 2903 getLLVMStyleWithColumns(22)); 2904 2905 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 2906 } 2907 2908 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 2909 EXPECT_EQ("#define A (x)", format("#define A (x)")); 2910 EXPECT_EQ("#define A(x)", format("#define A(x)")); 2911 2912 FormatStyle Style = getLLVMStyle(); 2913 Style.SpaceBeforeParens = FormatStyle::SBPO_Never; 2914 verifyFormat("#define true ((foo)1)", Style); 2915 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 2916 verifyFormat("#define false((foo)0)", Style); 2917 } 2918 2919 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 2920 EXPECT_EQ("#define A b;", format("#define A \\\n" 2921 " \\\n" 2922 " b;", 2923 getLLVMStyleWithColumns(25))); 2924 EXPECT_EQ("#define A \\\n" 2925 " \\\n" 2926 " a; \\\n" 2927 " b;", 2928 format("#define A \\\n" 2929 " \\\n" 2930 " a; \\\n" 2931 " b;", 2932 getLLVMStyleWithColumns(11))); 2933 EXPECT_EQ("#define A \\\n" 2934 " a; \\\n" 2935 " \\\n" 2936 " b;", 2937 format("#define A \\\n" 2938 " a; \\\n" 2939 " \\\n" 2940 " b;", 2941 getLLVMStyleWithColumns(11))); 2942 } 2943 2944 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 2945 verifyIncompleteFormat("#define A :"); 2946 verifyFormat("#define SOMECASES \\\n" 2947 " case 1: \\\n" 2948 " case 2\n", 2949 getLLVMStyleWithColumns(20)); 2950 verifyFormat("#define MACRO(a) \\\n" 2951 " if (a) \\\n" 2952 " f(); \\\n" 2953 " else \\\n" 2954 " g()", 2955 getLLVMStyleWithColumns(18)); 2956 verifyFormat("#define A template <typename T>"); 2957 verifyIncompleteFormat("#define STR(x) #x\n" 2958 "f(STR(this_is_a_string_literal{));"); 2959 verifyFormat("#pragma omp threadprivate( \\\n" 2960 " y)), // expected-warning", 2961 getLLVMStyleWithColumns(28)); 2962 verifyFormat("#d, = };"); 2963 verifyFormat("#if \"a"); 2964 verifyIncompleteFormat("({\n" 2965 "#define b \\\n" 2966 " } \\\n" 2967 " a\n" 2968 "a", 2969 getLLVMStyleWithColumns(15)); 2970 verifyFormat("#define A \\\n" 2971 " { \\\n" 2972 " {\n" 2973 "#define B \\\n" 2974 " } \\\n" 2975 " }", 2976 getLLVMStyleWithColumns(15)); 2977 verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); 2978 verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); 2979 verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); 2980 verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); 2981 } 2982 2983 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 2984 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 2985 EXPECT_EQ("class A : public QObject {\n" 2986 " Q_OBJECT\n" 2987 "\n" 2988 " A() {}\n" 2989 "};", 2990 format("class A : public QObject {\n" 2991 " Q_OBJECT\n" 2992 "\n" 2993 " A() {\n}\n" 2994 "} ;")); 2995 EXPECT_EQ("MACRO\n" 2996 "/*static*/ int i;", 2997 format("MACRO\n" 2998 " /*static*/ int i;")); 2999 EXPECT_EQ("SOME_MACRO\n" 3000 "namespace {\n" 3001 "void f();\n" 3002 "} // namespace", 3003 format("SOME_MACRO\n" 3004 " namespace {\n" 3005 "void f( );\n" 3006 "} // namespace")); 3007 // Only if the identifier contains at least 5 characters. 3008 EXPECT_EQ("HTTP f();", format("HTTP\nf();")); 3009 EXPECT_EQ("MACRO\nf();", format("MACRO\nf();")); 3010 // Only if everything is upper case. 3011 EXPECT_EQ("class A : public QObject {\n" 3012 " Q_Object A() {}\n" 3013 "};", 3014 format("class A : public QObject {\n" 3015 " Q_Object\n" 3016 " A() {\n}\n" 3017 "} ;")); 3018 3019 // Only if the next line can actually start an unwrapped line. 3020 EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;", 3021 format("SOME_WEIRD_LOG_MACRO\n" 3022 "<< SomeThing;")); 3023 3024 verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " 3025 "(n, buffers))\n", 3026 getChromiumStyle(FormatStyle::LK_Cpp)); 3027 3028 // See PR41483 3029 EXPECT_EQ("/**/ FOO(a)\n" 3030 "FOO(b)", 3031 format("/**/ FOO(a)\n" 3032 "FOO(b)")); 3033 } 3034 3035 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 3036 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 3037 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 3038 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 3039 "class X {};\n" 3040 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 3041 "int *createScopDetectionPass() { return 0; }", 3042 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 3043 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 3044 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 3045 " class X {};\n" 3046 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 3047 " int *createScopDetectionPass() { return 0; }")); 3048 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 3049 // braces, so that inner block is indented one level more. 3050 EXPECT_EQ("int q() {\n" 3051 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 3052 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 3053 " IPC_END_MESSAGE_MAP()\n" 3054 "}", 3055 format("int q() {\n" 3056 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 3057 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 3058 " IPC_END_MESSAGE_MAP()\n" 3059 "}")); 3060 3061 // Same inside macros. 3062 EXPECT_EQ("#define LIST(L) \\\n" 3063 " L(A) \\\n" 3064 " L(B) \\\n" 3065 " L(C)", 3066 format("#define LIST(L) \\\n" 3067 " L(A) \\\n" 3068 " L(B) \\\n" 3069 " L(C)", 3070 getGoogleStyle())); 3071 3072 // These must not be recognized as macros. 3073 EXPECT_EQ("int q() {\n" 3074 " f(x);\n" 3075 " f(x) {}\n" 3076 " f(x)->g();\n" 3077 " f(x)->*g();\n" 3078 " f(x).g();\n" 3079 " f(x) = x;\n" 3080 " f(x) += x;\n" 3081 " f(x) -= x;\n" 3082 " f(x) *= x;\n" 3083 " f(x) /= x;\n" 3084 " f(x) %= x;\n" 3085 " f(x) &= x;\n" 3086 " f(x) |= x;\n" 3087 " f(x) ^= x;\n" 3088 " f(x) >>= x;\n" 3089 " f(x) <<= x;\n" 3090 " f(x)[y].z();\n" 3091 " LOG(INFO) << x;\n" 3092 " ifstream(x) >> x;\n" 3093 "}\n", 3094 format("int q() {\n" 3095 " f(x)\n;\n" 3096 " f(x)\n {}\n" 3097 " f(x)\n->g();\n" 3098 " f(x)\n->*g();\n" 3099 " f(x)\n.g();\n" 3100 " f(x)\n = x;\n" 3101 " f(x)\n += x;\n" 3102 " f(x)\n -= x;\n" 3103 " f(x)\n *= x;\n" 3104 " f(x)\n /= x;\n" 3105 " f(x)\n %= x;\n" 3106 " f(x)\n &= x;\n" 3107 " f(x)\n |= x;\n" 3108 " f(x)\n ^= x;\n" 3109 " f(x)\n >>= x;\n" 3110 " f(x)\n <<= x;\n" 3111 " f(x)\n[y].z();\n" 3112 " LOG(INFO)\n << x;\n" 3113 " ifstream(x)\n >> x;\n" 3114 "}\n")); 3115 EXPECT_EQ("int q() {\n" 3116 " F(x)\n" 3117 " if (1) {\n" 3118 " }\n" 3119 " F(x)\n" 3120 " while (1) {\n" 3121 " }\n" 3122 " F(x)\n" 3123 " G(x);\n" 3124 " F(x)\n" 3125 " try {\n" 3126 " Q();\n" 3127 " } catch (...) {\n" 3128 " }\n" 3129 "}\n", 3130 format("int q() {\n" 3131 "F(x)\n" 3132 "if (1) {}\n" 3133 "F(x)\n" 3134 "while (1) {}\n" 3135 "F(x)\n" 3136 "G(x);\n" 3137 "F(x)\n" 3138 "try { Q(); } catch (...) {}\n" 3139 "}\n")); 3140 EXPECT_EQ("class A {\n" 3141 " A() : t(0) {}\n" 3142 " A(int i) noexcept() : {}\n" 3143 " A(X x)\n" // FIXME: function-level try blocks are broken. 3144 " try : t(0) {\n" 3145 " } catch (...) {\n" 3146 " }\n" 3147 "};", 3148 format("class A {\n" 3149 " A()\n : t(0) {}\n" 3150 " A(int i)\n noexcept() : {}\n" 3151 " A(X x)\n" 3152 " try : t(0) {} catch (...) {}\n" 3153 "};")); 3154 FormatStyle Style = getLLVMStyle(); 3155 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 3156 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; 3157 Style.BraceWrapping.AfterFunction = true; 3158 EXPECT_EQ("void f()\n" 3159 "try\n" 3160 "{\n" 3161 "}", 3162 format("void f() try {\n" 3163 "}", 3164 Style)); 3165 EXPECT_EQ("class SomeClass {\n" 3166 "public:\n" 3167 " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3168 "};", 3169 format("class SomeClass {\n" 3170 "public:\n" 3171 " SomeClass()\n" 3172 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3173 "};")); 3174 EXPECT_EQ("class SomeClass {\n" 3175 "public:\n" 3176 " SomeClass()\n" 3177 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3178 "};", 3179 format("class SomeClass {\n" 3180 "public:\n" 3181 " SomeClass()\n" 3182 " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" 3183 "};", 3184 getLLVMStyleWithColumns(40))); 3185 3186 verifyFormat("MACRO(>)"); 3187 3188 // Some macros contain an implicit semicolon. 3189 Style = getLLVMStyle(); 3190 Style.StatementMacros.push_back("FOO"); 3191 verifyFormat("FOO(a) int b = 0;"); 3192 verifyFormat("FOO(a)\n" 3193 "int b = 0;", 3194 Style); 3195 verifyFormat("FOO(a);\n" 3196 "int b = 0;", 3197 Style); 3198 verifyFormat("FOO(argc, argv, \"4.0.2\")\n" 3199 "int b = 0;", 3200 Style); 3201 verifyFormat("FOO()\n" 3202 "int b = 0;", 3203 Style); 3204 verifyFormat("FOO\n" 3205 "int b = 0;", 3206 Style); 3207 verifyFormat("void f() {\n" 3208 " FOO(a)\n" 3209 " return a;\n" 3210 "}", 3211 Style); 3212 verifyFormat("FOO(a)\n" 3213 "FOO(b)", 3214 Style); 3215 verifyFormat("int a = 0;\n" 3216 "FOO(b)\n" 3217 "int c = 0;", 3218 Style); 3219 verifyFormat("int a = 0;\n" 3220 "int x = FOO(a)\n" 3221 "int b = 0;", 3222 Style); 3223 verifyFormat("void foo(int a) { FOO(a) }\n" 3224 "uint32_t bar() {}", 3225 Style); 3226 } 3227 3228 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 3229 verifyFormat("#define A \\\n" 3230 " f({ \\\n" 3231 " g(); \\\n" 3232 " });", 3233 getLLVMStyleWithColumns(11)); 3234 } 3235 3236 TEST_F(FormatTest, IndentPreprocessorDirectives) { 3237 FormatStyle Style = getLLVMStyle(); 3238 Style.IndentPPDirectives = FormatStyle::PPDIS_None; 3239 Style.ColumnLimit = 40; 3240 verifyFormat("#ifdef _WIN32\n" 3241 "#define A 0\n" 3242 "#ifdef VAR2\n" 3243 "#define B 1\n" 3244 "#include <someheader.h>\n" 3245 "#define MACRO \\\n" 3246 " some_very_long_func_aaaaaaaaaa();\n" 3247 "#endif\n" 3248 "#else\n" 3249 "#define A 1\n" 3250 "#endif", 3251 Style); 3252 Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; 3253 verifyFormat("#ifdef _WIN32\n" 3254 "# define A 0\n" 3255 "# ifdef VAR2\n" 3256 "# define B 1\n" 3257 "# include <someheader.h>\n" 3258 "# define MACRO \\\n" 3259 " some_very_long_func_aaaaaaaaaa();\n" 3260 "# endif\n" 3261 "#else\n" 3262 "# define A 1\n" 3263 "#endif", 3264 Style); 3265 verifyFormat("#if A\n" 3266 "# define MACRO \\\n" 3267 " void a(int x) { \\\n" 3268 " b(); \\\n" 3269 " c(); \\\n" 3270 " d(); \\\n" 3271 " e(); \\\n" 3272 " f(); \\\n" 3273 " }\n" 3274 "#endif", 3275 Style); 3276 // Comments before include guard. 3277 verifyFormat("// file comment\n" 3278 "// file comment\n" 3279 "#ifndef HEADER_H\n" 3280 "#define HEADER_H\n" 3281 "code();\n" 3282 "#endif", 3283 Style); 3284 // Test with include guards. 3285 verifyFormat("#ifndef HEADER_H\n" 3286 "#define HEADER_H\n" 3287 "code();\n" 3288 "#endif", 3289 Style); 3290 // Include guards must have a #define with the same variable immediately 3291 // after #ifndef. 3292 verifyFormat("#ifndef NOT_GUARD\n" 3293 "# define FOO\n" 3294 "code();\n" 3295 "#endif", 3296 Style); 3297 3298 // Include guards must cover the entire file. 3299 verifyFormat("code();\n" 3300 "code();\n" 3301 "#ifndef NOT_GUARD\n" 3302 "# define NOT_GUARD\n" 3303 "code();\n" 3304 "#endif", 3305 Style); 3306 verifyFormat("#ifndef NOT_GUARD\n" 3307 "# define NOT_GUARD\n" 3308 "code();\n" 3309 "#endif\n" 3310 "code();", 3311 Style); 3312 // Test with trailing blank lines. 3313 verifyFormat("#ifndef HEADER_H\n" 3314 "#define HEADER_H\n" 3315 "code();\n" 3316 "#endif\n", 3317 Style); 3318 // Include guards don't have #else. 3319 verifyFormat("#ifndef NOT_GUARD\n" 3320 "# define NOT_GUARD\n" 3321 "code();\n" 3322 "#else\n" 3323 "#endif", 3324 Style); 3325 verifyFormat("#ifndef NOT_GUARD\n" 3326 "# define NOT_GUARD\n" 3327 "code();\n" 3328 "#elif FOO\n" 3329 "#endif", 3330 Style); 3331 // Non-identifier #define after potential include guard. 3332 verifyFormat("#ifndef FOO\n" 3333 "# define 1\n" 3334 "#endif\n", 3335 Style); 3336 // #if closes past last non-preprocessor line. 3337 verifyFormat("#ifndef FOO\n" 3338 "#define FOO\n" 3339 "#if 1\n" 3340 "int i;\n" 3341 "# define A 0\n" 3342 "#endif\n" 3343 "#endif\n", 3344 Style); 3345 // Don't crash if there is an #elif directive without a condition. 3346 verifyFormat("#if 1\n" 3347 "int x;\n" 3348 "#elif\n" 3349 "int y;\n" 3350 "#else\n" 3351 "int z;\n" 3352 "#endif", 3353 Style); 3354 // FIXME: This doesn't handle the case where there's code between the 3355 // #ifndef and #define but all other conditions hold. This is because when 3356 // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the 3357 // previous code line yet, so we can't detect it. 3358 EXPECT_EQ("#ifndef NOT_GUARD\n" 3359 "code();\n" 3360 "#define NOT_GUARD\n" 3361 "code();\n" 3362 "#endif", 3363 format("#ifndef NOT_GUARD\n" 3364 "code();\n" 3365 "# define NOT_GUARD\n" 3366 "code();\n" 3367 "#endif", 3368 Style)); 3369 // FIXME: This doesn't handle cases where legitimate preprocessor lines may 3370 // be outside an include guard. Examples are #pragma once and 3371 // #pragma GCC diagnostic, or anything else that does not change the meaning 3372 // of the file if it's included multiple times. 3373 EXPECT_EQ("#ifdef WIN32\n" 3374 "# pragma once\n" 3375 "#endif\n" 3376 "#ifndef HEADER_H\n" 3377 "# define HEADER_H\n" 3378 "code();\n" 3379 "#endif", 3380 format("#ifdef WIN32\n" 3381 "# pragma once\n" 3382 "#endif\n" 3383 "#ifndef HEADER_H\n" 3384 "#define HEADER_H\n" 3385 "code();\n" 3386 "#endif", 3387 Style)); 3388 // FIXME: This does not detect when there is a single non-preprocessor line 3389 // in front of an include-guard-like structure where other conditions hold 3390 // because ScopedLineState hides the line. 3391 EXPECT_EQ("code();\n" 3392 "#ifndef HEADER_H\n" 3393 "#define HEADER_H\n" 3394 "code();\n" 3395 "#endif", 3396 format("code();\n" 3397 "#ifndef HEADER_H\n" 3398 "# define HEADER_H\n" 3399 "code();\n" 3400 "#endif", 3401 Style)); 3402 // Keep comments aligned with #, otherwise indent comments normally. These 3403 // tests cannot use verifyFormat because messUp manipulates leading 3404 // whitespace. 3405 { 3406 const char *Expected = "" 3407 "void f() {\n" 3408 "#if 1\n" 3409 "// Preprocessor aligned.\n" 3410 "# define A 0\n" 3411 " // Code. Separated by blank line.\n" 3412 "\n" 3413 "# define B 0\n" 3414 " // Code. Not aligned with #\n" 3415 "# define C 0\n" 3416 "#endif"; 3417 const char *ToFormat = "" 3418 "void f() {\n" 3419 "#if 1\n" 3420 "// Preprocessor aligned.\n" 3421 "# define A 0\n" 3422 "// Code. Separated by blank line.\n" 3423 "\n" 3424 "# define B 0\n" 3425 " // Code. Not aligned with #\n" 3426 "# define C 0\n" 3427 "#endif"; 3428 EXPECT_EQ(Expected, format(ToFormat, Style)); 3429 EXPECT_EQ(Expected, format(Expected, Style)); 3430 } 3431 // Keep block quotes aligned. 3432 { 3433 const char *Expected = "" 3434 "void f() {\n" 3435 "#if 1\n" 3436 "/* Preprocessor aligned. */\n" 3437 "# define A 0\n" 3438 " /* Code. Separated by blank line. */\n" 3439 "\n" 3440 "# define B 0\n" 3441 " /* Code. Not aligned with # */\n" 3442 "# define C 0\n" 3443 "#endif"; 3444 const char *ToFormat = "" 3445 "void f() {\n" 3446 "#if 1\n" 3447 "/* Preprocessor aligned. */\n" 3448 "# define A 0\n" 3449 "/* Code. Separated by blank line. */\n" 3450 "\n" 3451 "# define B 0\n" 3452 " /* Code. Not aligned with # */\n" 3453 "# define C 0\n" 3454 "#endif"; 3455 EXPECT_EQ(Expected, format(ToFormat, Style)); 3456 EXPECT_EQ(Expected, format(Expected, Style)); 3457 } 3458 // Keep comments aligned with un-indented directives. 3459 { 3460 const char *Expected = "" 3461 "void f() {\n" 3462 "// Preprocessor aligned.\n" 3463 "#define A 0\n" 3464 " // Code. Separated by blank line.\n" 3465 "\n" 3466 "#define B 0\n" 3467 " // Code. Not aligned with #\n" 3468 "#define C 0\n"; 3469 const char *ToFormat = "" 3470 "void f() {\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 EXPECT_EQ(Expected, format(ToFormat, Style)); 3479 EXPECT_EQ(Expected, format(Expected, Style)); 3480 } 3481 // Test AfterHash with tabs. 3482 { 3483 FormatStyle Tabbed = Style; 3484 Tabbed.UseTab = FormatStyle::UT_Always; 3485 Tabbed.IndentWidth = 8; 3486 Tabbed.TabWidth = 8; 3487 verifyFormat("#ifdef _WIN32\n" 3488 "#\tdefine A 0\n" 3489 "#\tifdef VAR2\n" 3490 "#\t\tdefine B 1\n" 3491 "#\t\tinclude <someheader.h>\n" 3492 "#\t\tdefine MACRO \\\n" 3493 "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" 3494 "#\tendif\n" 3495 "#else\n" 3496 "#\tdefine A 1\n" 3497 "#endif", 3498 Tabbed); 3499 } 3500 3501 // Regression test: Multiline-macro inside include guards. 3502 verifyFormat("#ifndef HEADER_H\n" 3503 "#define HEADER_H\n" 3504 "#define A() \\\n" 3505 " int i; \\\n" 3506 " int j;\n" 3507 "#endif // HEADER_H", 3508 getLLVMStyleWithColumns(20)); 3509 3510 Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; 3511 // Basic before hash indent tests 3512 verifyFormat("#ifdef _WIN32\n" 3513 " #define A 0\n" 3514 " #ifdef VAR2\n" 3515 " #define B 1\n" 3516 " #include <someheader.h>\n" 3517 " #define MACRO \\\n" 3518 " some_very_long_func_aaaaaaaaaa();\n" 3519 " #endif\n" 3520 "#else\n" 3521 " #define A 1\n" 3522 "#endif", 3523 Style); 3524 verifyFormat("#if A\n" 3525 " #define MACRO \\\n" 3526 " void a(int x) { \\\n" 3527 " b(); \\\n" 3528 " c(); \\\n" 3529 " d(); \\\n" 3530 " e(); \\\n" 3531 " f(); \\\n" 3532 " }\n" 3533 "#endif", 3534 Style); 3535 // Keep comments aligned with indented directives. These 3536 // tests cannot use verifyFormat because messUp manipulates leading 3537 // whitespace. 3538 { 3539 const char *Expected = "void f() {\n" 3540 "// Aligned to preprocessor.\n" 3541 "#if 1\n" 3542 " // Aligned to code.\n" 3543 " int a;\n" 3544 " #if 1\n" 3545 " // Aligned to preprocessor.\n" 3546 " #define A 0\n" 3547 " // Aligned to code.\n" 3548 " int b;\n" 3549 " #endif\n" 3550 "#endif\n" 3551 "}"; 3552 const char *ToFormat = "void f() {\n" 3553 "// Aligned to preprocessor.\n" 3554 "#if 1\n" 3555 "// Aligned to code.\n" 3556 "int a;\n" 3557 "#if 1\n" 3558 "// Aligned to preprocessor.\n" 3559 "#define A 0\n" 3560 "// Aligned to code.\n" 3561 "int b;\n" 3562 "#endif\n" 3563 "#endif\n" 3564 "}"; 3565 EXPECT_EQ(Expected, format(ToFormat, Style)); 3566 EXPECT_EQ(Expected, format(Expected, Style)); 3567 } 3568 { 3569 const char *Expected = "void f() {\n" 3570 "/* Aligned to preprocessor. */\n" 3571 "#if 1\n" 3572 " /* Aligned to code. */\n" 3573 " int a;\n" 3574 " #if 1\n" 3575 " /* Aligned to preprocessor. */\n" 3576 " #define A 0\n" 3577 " /* Aligned to code. */\n" 3578 " int b;\n" 3579 " #endif\n" 3580 "#endif\n" 3581 "}"; 3582 const char *ToFormat = "void f() {\n" 3583 "/* Aligned to preprocessor. */\n" 3584 "#if 1\n" 3585 "/* Aligned to code. */\n" 3586 "int a;\n" 3587 "#if 1\n" 3588 "/* Aligned to preprocessor. */\n" 3589 "#define A 0\n" 3590 "/* Aligned to code. */\n" 3591 "int b;\n" 3592 "#endif\n" 3593 "#endif\n" 3594 "}"; 3595 EXPECT_EQ(Expected, format(ToFormat, Style)); 3596 EXPECT_EQ(Expected, format(Expected, Style)); 3597 } 3598 3599 // Test single comment before preprocessor 3600 verifyFormat("// Comment\n" 3601 "\n" 3602 "#if 1\n" 3603 "#endif", 3604 Style); 3605 } 3606 3607 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 3608 verifyFormat("{\n { a #c; }\n}"); 3609 } 3610 3611 TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 3612 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 3613 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 3614 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 3615 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 3616 } 3617 3618 TEST_F(FormatTest, EscapedNewlines) { 3619 FormatStyle Narrow = getLLVMStyleWithColumns(11); 3620 EXPECT_EQ("#define A \\\n int i; \\\n int j;", 3621 format("#define A \\\nint i;\\\n int j;", Narrow)); 3622 EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;")); 3623 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3624 EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */")); 3625 EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>")); 3626 3627 FormatStyle AlignLeft = getLLVMStyle(); 3628 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 3629 EXPECT_EQ("#define MACRO(x) \\\n" 3630 "private: \\\n" 3631 " int x(int a);\n", 3632 format("#define MACRO(x) \\\n" 3633 "private: \\\n" 3634 " int x(int a);\n", 3635 AlignLeft)); 3636 3637 // CRLF line endings 3638 EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;", 3639 format("#define A \\\r\nint i;\\\r\n int j;", Narrow)); 3640 EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;")); 3641 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 3642 EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */")); 3643 EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>")); 3644 EXPECT_EQ("#define MACRO(x) \\\r\n" 3645 "private: \\\r\n" 3646 " int x(int a);\r\n", 3647 format("#define MACRO(x) \\\r\n" 3648 "private: \\\r\n" 3649 " int x(int a);\r\n", 3650 AlignLeft)); 3651 3652 FormatStyle DontAlign = getLLVMStyle(); 3653 DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 3654 DontAlign.MaxEmptyLinesToKeep = 3; 3655 // FIXME: can't use verifyFormat here because the newline before 3656 // "public:" is not inserted the first time it's reformatted 3657 EXPECT_EQ("#define A \\\n" 3658 " class Foo { \\\n" 3659 " void bar(); \\\n" 3660 "\\\n" 3661 "\\\n" 3662 "\\\n" 3663 " public: \\\n" 3664 " void baz(); \\\n" 3665 " };", 3666 format("#define A \\\n" 3667 " class Foo { \\\n" 3668 " void bar(); \\\n" 3669 "\\\n" 3670 "\\\n" 3671 "\\\n" 3672 " public: \\\n" 3673 " void baz(); \\\n" 3674 " };", 3675 DontAlign)); 3676 } 3677 3678 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 3679 verifyFormat("#define A \\\n" 3680 " int v( \\\n" 3681 " a); \\\n" 3682 " int i;", 3683 getLLVMStyleWithColumns(11)); 3684 } 3685 3686 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 3687 EXPECT_EQ( 3688 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3689 " \\\n" 3690 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3691 "\n" 3692 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3693 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 3694 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 3695 "\\\n" 3696 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 3697 " \n" 3698 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 3699 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 3700 } 3701 3702 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 3703 EXPECT_EQ("int\n" 3704 "#define A\n" 3705 " a;", 3706 format("int\n#define A\na;")); 3707 verifyFormat("functionCallTo(\n" 3708 " someOtherFunction(\n" 3709 " withSomeParameters, whichInSequence,\n" 3710 " areLongerThanALine(andAnotherCall,\n" 3711 "#define A B\n" 3712 " withMoreParamters,\n" 3713 " whichStronglyInfluenceTheLayout),\n" 3714 " andMoreParameters),\n" 3715 " trailing);", 3716 getLLVMStyleWithColumns(69)); 3717 verifyFormat("Foo::Foo()\n" 3718 "#ifdef BAR\n" 3719 " : baz(0)\n" 3720 "#endif\n" 3721 "{\n" 3722 "}"); 3723 verifyFormat("void f() {\n" 3724 " if (true)\n" 3725 "#ifdef A\n" 3726 " f(42);\n" 3727 " x();\n" 3728 "#else\n" 3729 " g();\n" 3730 " x();\n" 3731 "#endif\n" 3732 "}"); 3733 verifyFormat("void f(param1, param2,\n" 3734 " param3,\n" 3735 "#ifdef A\n" 3736 " param4(param5,\n" 3737 "#ifdef A1\n" 3738 " param6,\n" 3739 "#ifdef A2\n" 3740 " param7),\n" 3741 "#else\n" 3742 " param8),\n" 3743 " param9,\n" 3744 "#endif\n" 3745 " param10,\n" 3746 "#endif\n" 3747 " param11)\n" 3748 "#else\n" 3749 " param12)\n" 3750 "#endif\n" 3751 "{\n" 3752 " x();\n" 3753 "}", 3754 getLLVMStyleWithColumns(28)); 3755 verifyFormat("#if 1\n" 3756 "int i;"); 3757 verifyFormat("#if 1\n" 3758 "#endif\n" 3759 "#if 1\n" 3760 "#else\n" 3761 "#endif\n"); 3762 verifyFormat("DEBUG({\n" 3763 " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3764 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 3765 "});\n" 3766 "#if a\n" 3767 "#else\n" 3768 "#endif"); 3769 3770 verifyIncompleteFormat("void f(\n" 3771 "#if A\n" 3772 ");\n" 3773 "#else\n" 3774 "#endif"); 3775 } 3776 3777 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { 3778 verifyFormat("#endif\n" 3779 "#if B"); 3780 } 3781 3782 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { 3783 FormatStyle SingleLine = getLLVMStyle(); 3784 SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; 3785 verifyFormat("#if 0\n" 3786 "#elif 1\n" 3787 "#endif\n" 3788 "void foo() {\n" 3789 " if (test) foo2();\n" 3790 "}", 3791 SingleLine); 3792 } 3793 3794 TEST_F(FormatTest, LayoutBlockInsideParens) { 3795 verifyFormat("functionCall({ int i; });"); 3796 verifyFormat("functionCall({\n" 3797 " int i;\n" 3798 " int j;\n" 3799 "});"); 3800 verifyFormat("functionCall(\n" 3801 " {\n" 3802 " int i;\n" 3803 " int j;\n" 3804 " },\n" 3805 " aaaa, bbbb, cccc);"); 3806 verifyFormat("functionA(functionB({\n" 3807 " int i;\n" 3808 " int j;\n" 3809 " }),\n" 3810 " aaaa, bbbb, cccc);"); 3811 verifyFormat("functionCall(\n" 3812 " {\n" 3813 " int i;\n" 3814 " int j;\n" 3815 " },\n" 3816 " aaaa, bbbb, // comment\n" 3817 " cccc);"); 3818 verifyFormat("functionA(functionB({\n" 3819 " int i;\n" 3820 " int j;\n" 3821 " }),\n" 3822 " aaaa, bbbb, // comment\n" 3823 " cccc);"); 3824 verifyFormat("functionCall(aaaa, bbbb, { int i; });"); 3825 verifyFormat("functionCall(aaaa, bbbb, {\n" 3826 " int i;\n" 3827 " int j;\n" 3828 "});"); 3829 verifyFormat( 3830 "Aaa(\n" // FIXME: There shouldn't be a linebreak here. 3831 " {\n" 3832 " int i; // break\n" 3833 " },\n" 3834 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 3835 " ccccccccccccccccc));"); 3836 verifyFormat("DEBUG({\n" 3837 " if (a)\n" 3838 " f();\n" 3839 "});"); 3840 } 3841 3842 TEST_F(FormatTest, LayoutBlockInsideStatement) { 3843 EXPECT_EQ("SOME_MACRO { int i; }\n" 3844 "int i;", 3845 format(" SOME_MACRO {int i;} int i;")); 3846 } 3847 3848 TEST_F(FormatTest, LayoutNestedBlocks) { 3849 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 3850 " struct s {\n" 3851 " int i;\n" 3852 " };\n" 3853 " s kBitsToOs[] = {{10}};\n" 3854 " for (int i = 0; i < 10; ++i)\n" 3855 " return;\n" 3856 "}"); 3857 verifyFormat("call(parameter, {\n" 3858 " something();\n" 3859 " // Comment using all columns.\n" 3860 " somethingelse();\n" 3861 "});", 3862 getLLVMStyleWithColumns(40)); 3863 verifyFormat("DEBUG( //\n" 3864 " { f(); }, a);"); 3865 verifyFormat("DEBUG( //\n" 3866 " {\n" 3867 " f(); //\n" 3868 " },\n" 3869 " a);"); 3870 3871 EXPECT_EQ("call(parameter, {\n" 3872 " something();\n" 3873 " // Comment too\n" 3874 " // looooooooooong.\n" 3875 " somethingElse();\n" 3876 "});", 3877 format("call(parameter, {\n" 3878 " something();\n" 3879 " // Comment too looooooooooong.\n" 3880 " somethingElse();\n" 3881 "});", 3882 getLLVMStyleWithColumns(29))); 3883 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 3884 EXPECT_EQ("DEBUG({ // comment\n" 3885 " int i;\n" 3886 "});", 3887 format("DEBUG({ // comment\n" 3888 "int i;\n" 3889 "});")); 3890 EXPECT_EQ("DEBUG({\n" 3891 " int i;\n" 3892 "\n" 3893 " // comment\n" 3894 " int j;\n" 3895 "});", 3896 format("DEBUG({\n" 3897 " int i;\n" 3898 "\n" 3899 " // comment\n" 3900 " int j;\n" 3901 "});")); 3902 3903 verifyFormat("DEBUG({\n" 3904 " if (a)\n" 3905 " return;\n" 3906 "});"); 3907 verifyGoogleFormat("DEBUG({\n" 3908 " if (a) return;\n" 3909 "});"); 3910 FormatStyle Style = getGoogleStyle(); 3911 Style.ColumnLimit = 45; 3912 verifyFormat("Debug(\n" 3913 " aaaaa,\n" 3914 " {\n" 3915 " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" 3916 " },\n" 3917 " a);", 3918 Style); 3919 3920 verifyFormat("SomeFunction({MACRO({ return output; }), b});"); 3921 3922 verifyNoCrash("^{v^{a}}"); 3923 } 3924 3925 TEST_F(FormatTest, FormatNestedBlocksInMacros) { 3926 EXPECT_EQ("#define MACRO() \\\n" 3927 " Debug(aaa, /* force line break */ \\\n" 3928 " { \\\n" 3929 " int i; \\\n" 3930 " int j; \\\n" 3931 " })", 3932 format("#define MACRO() Debug(aaa, /* force line break */ \\\n" 3933 " { int i; int j; })", 3934 getGoogleStyle())); 3935 3936 EXPECT_EQ("#define A \\\n" 3937 " [] { \\\n" 3938 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3939 " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" 3940 " }", 3941 format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" 3942 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", 3943 getGoogleStyle())); 3944 } 3945 3946 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 3947 EXPECT_EQ("{}", format("{}")); 3948 verifyFormat("enum E {};"); 3949 verifyFormat("enum E {}"); 3950 FormatStyle Style = getLLVMStyle(); 3951 Style.SpaceInEmptyBlock = true; 3952 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 3953 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 3954 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 3955 } 3956 3957 TEST_F(FormatTest, FormatBeginBlockEndMacros) { 3958 FormatStyle Style = getLLVMStyle(); 3959 Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; 3960 Style.MacroBlockEnd = "^[A-Z_]+_END$"; 3961 verifyFormat("FOO_BEGIN\n" 3962 " FOO_ENTRY\n" 3963 "FOO_END", 3964 Style); 3965 verifyFormat("FOO_BEGIN\n" 3966 " NESTED_FOO_BEGIN\n" 3967 " NESTED_FOO_ENTRY\n" 3968 " NESTED_FOO_END\n" 3969 "FOO_END", 3970 Style); 3971 verifyFormat("FOO_BEGIN(Foo, Bar)\n" 3972 " int x;\n" 3973 " x = 1;\n" 3974 "FOO_END(Baz)", 3975 Style); 3976 } 3977 3978 //===----------------------------------------------------------------------===// 3979 // Line break tests. 3980 //===----------------------------------------------------------------------===// 3981 3982 TEST_F(FormatTest, PreventConfusingIndents) { 3983 verifyFormat( 3984 "void f() {\n" 3985 " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 3986 " parameter, parameter, parameter)),\n" 3987 " SecondLongCall(parameter));\n" 3988 "}"); 3989 verifyFormat( 3990 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3991 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 3992 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3993 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 3994 verifyFormat( 3995 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3996 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 3997 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 3998 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 3999 verifyFormat( 4000 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 4001 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 4002 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 4003 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 4004 verifyFormat("int a = bbbb && ccc &&\n" 4005 " fffff(\n" 4006 "#define A Just forcing a new line\n" 4007 " ddd);"); 4008 } 4009 4010 TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 4011 verifyFormat( 4012 "bool aaaaaaa =\n" 4013 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 4014 " bbbbbbbb();"); 4015 verifyFormat( 4016 "bool aaaaaaa =\n" 4017 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" 4018 " bbbbbbbb();"); 4019 4020 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 4021 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 4022 " ccccccccc == ddddddddddd;"); 4023 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 4024 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" 4025 " ccccccccc == ddddddddddd;"); 4026 verifyFormat( 4027 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 4028 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" 4029 " ccccccccc == ddddddddddd;"); 4030 4031 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 4032 " aaaaaa) &&\n" 4033 " bbbbbb && cccccc;"); 4034 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 4035 " aaaaaa) >>\n" 4036 " bbbbbb;"); 4037 verifyFormat("aa = Whitespaces.addUntouchableComment(\n" 4038 " SourceMgr.getSpellingColumnNumber(\n" 4039 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 4040 " 1);"); 4041 4042 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4043 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 4044 " cccccc) {\n}"); 4045 verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4046 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 4047 " cccccc) {\n}"); 4048 verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4049 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" 4050 " cccccc) {\n}"); 4051 verifyFormat("b = a &&\n" 4052 " // Comment\n" 4053 " b.c && d;"); 4054 4055 // If the LHS of a comparison is not a binary expression itself, the 4056 // additional linebreak confuses many people. 4057 verifyFormat( 4058 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4059 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 4060 "}"); 4061 verifyFormat( 4062 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4063 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4064 "}"); 4065 verifyFormat( 4066 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 4067 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4068 "}"); 4069 verifyFormat( 4070 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4071 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n" 4072 "}"); 4073 // Even explicit parentheses stress the precedence enough to make the 4074 // additional break unnecessary. 4075 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4076 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 4077 "}"); 4078 // This cases is borderline, but with the indentation it is still readable. 4079 verifyFormat( 4080 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4081 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4082 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 4083 "}", 4084 getLLVMStyleWithColumns(75)); 4085 4086 // If the LHS is a binary expression, we should still use the additional break 4087 // as otherwise the formatting hides the operator precedence. 4088 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4089 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4090 " 5) {\n" 4091 "}"); 4092 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4093 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" 4094 " 5) {\n" 4095 "}"); 4096 4097 FormatStyle OnePerLine = getLLVMStyle(); 4098 OnePerLine.BinPackParameters = false; 4099 verifyFormat( 4100 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4101 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4102 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 4103 OnePerLine); 4104 4105 verifyFormat("int i = someFunction(aaaaaaa, 0)\n" 4106 " .aaa(aaaaaaaaaaaaa) *\n" 4107 " aaaaaaa +\n" 4108 " aaaaaaa;", 4109 getLLVMStyleWithColumns(40)); 4110 } 4111 4112 TEST_F(FormatTest, ExpressionIndentation) { 4113 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4114 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4115 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4116 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4117 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 4118 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 4119 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4120 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 4121 " ccccccccccccccccccccccccccccccccccccccccc;"); 4122 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4123 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4124 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4125 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4126 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4127 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4128 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4129 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4130 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 4131 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 4132 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4133 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 4134 verifyFormat("if () {\n" 4135 "} else if (aaaaa && bbbbb > // break\n" 4136 " ccccc) {\n" 4137 "}"); 4138 verifyFormat("if () {\n" 4139 "} else if constexpr (aaaaa && bbbbb > // break\n" 4140 " ccccc) {\n" 4141 "}"); 4142 verifyFormat("if () {\n" 4143 "} else if CONSTEXPR (aaaaa && bbbbb > // break\n" 4144 " ccccc) {\n" 4145 "}"); 4146 verifyFormat("if () {\n" 4147 "} else if (aaaaa &&\n" 4148 " bbbbb > // break\n" 4149 " ccccc &&\n" 4150 " ddddd) {\n" 4151 "}"); 4152 4153 // Presence of a trailing comment used to change indentation of b. 4154 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 4155 " b;\n" 4156 "return aaaaaaaaaaaaaaaaaaa +\n" 4157 " b; //", 4158 getLLVMStyleWithColumns(30)); 4159 } 4160 4161 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 4162 // Not sure what the best system is here. Like this, the LHS can be found 4163 // immediately above an operator (everything with the same or a higher 4164 // indent). The RHS is aligned right of the operator and so compasses 4165 // everything until something with the same indent as the operator is found. 4166 // FIXME: Is this a good system? 4167 FormatStyle Style = getLLVMStyle(); 4168 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 4169 verifyFormat( 4170 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4171 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4172 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4173 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4174 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4175 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4176 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4177 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4178 " > ccccccccccccccccccccccccccccccccccccccccc;", 4179 Style); 4180 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4181 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4182 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4183 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4184 Style); 4185 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4186 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4187 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4188 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4189 Style); 4190 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4191 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4192 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4193 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 4194 Style); 4195 verifyFormat("if () {\n" 4196 "} else if (aaaaa\n" 4197 " && bbbbb // break\n" 4198 " > ccccc) {\n" 4199 "}", 4200 Style); 4201 verifyFormat("return (a)\n" 4202 " // comment\n" 4203 " + b;", 4204 Style); 4205 verifyFormat( 4206 "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4207 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4208 " + cc;", 4209 Style); 4210 4211 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4212 " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 4213 Style); 4214 4215 // Forced by comments. 4216 verifyFormat( 4217 "unsigned ContentSize =\n" 4218 " sizeof(int16_t) // DWARF ARange version number\n" 4219 " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" 4220 " + sizeof(int8_t) // Pointer Size (in bytes)\n" 4221 " + sizeof(int8_t); // Segment Size (in bytes)"); 4222 4223 verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" 4224 " == boost::fusion::at_c<1>(iiii).second;", 4225 Style); 4226 4227 Style.ColumnLimit = 60; 4228 verifyFormat("zzzzzzzzzz\n" 4229 " = bbbbbbbbbbbbbbbbb\n" 4230 " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", 4231 Style); 4232 4233 Style.ColumnLimit = 80; 4234 Style.IndentWidth = 4; 4235 Style.TabWidth = 4; 4236 Style.UseTab = FormatStyle::UT_Always; 4237 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4238 Style.AlignOperands = false; 4239 EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" 4240 "\t&& (someOtherLongishConditionPart1\n" 4241 "\t\t|| someOtherEvenLongerNestedConditionPart2);", 4242 format("return someVeryVeryLongConditionThatBarelyFitsOnALine && " 4243 "(someOtherLongishConditionPart1 || " 4244 "someOtherEvenLongerNestedConditionPart2);", 4245 Style)); 4246 } 4247 4248 TEST_F(FormatTest, EnforcedOperatorWraps) { 4249 // Here we'd like to wrap after the || operators, but a comment is forcing an 4250 // earlier wrap. 4251 verifyFormat("bool x = aaaaa //\n" 4252 " || bbbbb\n" 4253 " //\n" 4254 " || cccc;"); 4255 } 4256 4257 TEST_F(FormatTest, NoOperandAlignment) { 4258 FormatStyle Style = getLLVMStyle(); 4259 Style.AlignOperands = false; 4260 verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" 4261 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 4262 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 4263 Style); 4264 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4265 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4266 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4267 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4268 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4269 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4270 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4271 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4272 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4273 " > ccccccccccccccccccccccccccccccccccccccccc;", 4274 Style); 4275 4276 verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4277 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4278 " + cc;", 4279 Style); 4280 verifyFormat("int a = aa\n" 4281 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 4282 " * cccccccccccccccccccccccccccccccccccc;\n", 4283 Style); 4284 4285 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 4286 verifyFormat("return (a > b\n" 4287 " // comment1\n" 4288 " // comment2\n" 4289 " || c);", 4290 Style); 4291 } 4292 4293 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { 4294 FormatStyle Style = getLLVMStyle(); 4295 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4296 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 4297 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4298 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 4299 Style); 4300 } 4301 4302 TEST_F(FormatTest, AllowBinPackingInsideArguments) { 4303 FormatStyle Style = getLLVMStyle(); 4304 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 4305 Style.BinPackArguments = false; 4306 Style.ColumnLimit = 40; 4307 verifyFormat("void test() {\n" 4308 " someFunction(\n" 4309 " this + argument + is + quite\n" 4310 " + long + so + it + gets + wrapped\n" 4311 " + but + remains + bin - packed);\n" 4312 "}", 4313 Style); 4314 verifyFormat("void test() {\n" 4315 " someFunction(arg1,\n" 4316 " this + argument + is\n" 4317 " + quite + long + so\n" 4318 " + it + gets + wrapped\n" 4319 " + but + remains + bin\n" 4320 " - packed,\n" 4321 " arg3);\n" 4322 "}", 4323 Style); 4324 verifyFormat("void test() {\n" 4325 " someFunction(\n" 4326 " arg1,\n" 4327 " this + argument + has\n" 4328 " + anotherFunc(nested,\n" 4329 " calls + whose\n" 4330 " + arguments\n" 4331 " + are + also\n" 4332 " + wrapped,\n" 4333 " in + addition)\n" 4334 " + to + being + bin - packed,\n" 4335 " arg3);\n" 4336 "}", 4337 Style); 4338 4339 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 4340 verifyFormat("void test() {\n" 4341 " someFunction(\n" 4342 " arg1,\n" 4343 " this + argument + has +\n" 4344 " anotherFunc(nested,\n" 4345 " calls + whose +\n" 4346 " arguments +\n" 4347 " are + also +\n" 4348 " wrapped,\n" 4349 " in + addition) +\n" 4350 " to + being + bin - packed,\n" 4351 " arg3);\n" 4352 "}", 4353 Style); 4354 } 4355 4356 TEST_F(FormatTest, ConstructorInitializers) { 4357 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4358 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 4359 getLLVMStyleWithColumns(45)); 4360 verifyFormat("Constructor()\n" 4361 " : Inttializer(FitsOnTheLine) {}", 4362 getLLVMStyleWithColumns(44)); 4363 verifyFormat("Constructor()\n" 4364 " : Inttializer(FitsOnTheLine) {}", 4365 getLLVMStyleWithColumns(43)); 4366 4367 verifyFormat("template <typename T>\n" 4368 "Constructor() : Initializer(FitsOnTheLine) {}", 4369 getLLVMStyleWithColumns(45)); 4370 4371 verifyFormat( 4372 "SomeClass::Constructor()\n" 4373 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4374 4375 verifyFormat( 4376 "SomeClass::Constructor()\n" 4377 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4378 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 4379 verifyFormat( 4380 "SomeClass::Constructor()\n" 4381 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4382 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 4383 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4384 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 4385 " : aaaaaaaaaa(aaaaaa) {}"); 4386 4387 verifyFormat("Constructor()\n" 4388 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4389 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4390 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4391 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 4392 4393 verifyFormat("Constructor()\n" 4394 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4395 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4396 4397 verifyFormat("Constructor(int Parameter = 0)\n" 4398 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4399 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 4400 verifyFormat("Constructor()\n" 4401 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4402 "}", 4403 getLLVMStyleWithColumns(60)); 4404 verifyFormat("Constructor()\n" 4405 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4406 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); 4407 4408 // Here a line could be saved by splitting the second initializer onto two 4409 // lines, but that is not desirable. 4410 verifyFormat("Constructor()\n" 4411 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4412 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4413 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 4414 4415 FormatStyle OnePerLine = getLLVMStyle(); 4416 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4417 OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 4418 verifyFormat("SomeClass::Constructor()\n" 4419 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4420 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4421 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4422 OnePerLine); 4423 verifyFormat("SomeClass::Constructor()\n" 4424 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4425 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4426 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4427 OnePerLine); 4428 verifyFormat("MyClass::MyClass(int var)\n" 4429 " : some_var_(var), // 4 space indent\n" 4430 " some_other_var_(var + 1) { // lined up\n" 4431 "}", 4432 OnePerLine); 4433 verifyFormat("Constructor()\n" 4434 " : aaaaa(aaaaaa),\n" 4435 " aaaaa(aaaaaa),\n" 4436 " aaaaa(aaaaaa),\n" 4437 " aaaaa(aaaaaa),\n" 4438 " aaaaa(aaaaaa) {}", 4439 OnePerLine); 4440 verifyFormat("Constructor()\n" 4441 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4442 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4443 OnePerLine); 4444 OnePerLine.BinPackParameters = false; 4445 verifyFormat( 4446 "Constructor()\n" 4447 " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4448 " aaaaaaaaaaa().aaa(),\n" 4449 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4450 OnePerLine); 4451 OnePerLine.ColumnLimit = 60; 4452 verifyFormat("Constructor()\n" 4453 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4454 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4455 OnePerLine); 4456 4457 EXPECT_EQ("Constructor()\n" 4458 " : // Comment forcing unwanted break.\n" 4459 " aaaa(aaaa) {}", 4460 format("Constructor() :\n" 4461 " // Comment forcing unwanted break.\n" 4462 " aaaa(aaaa) {}")); 4463 } 4464 4465 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { 4466 FormatStyle Style = getLLVMStyle(); 4467 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4468 Style.ColumnLimit = 60; 4469 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4470 Style.AllowAllConstructorInitializersOnNextLine = true; 4471 Style.BinPackParameters = false; 4472 4473 for (int i = 0; i < 4; ++i) { 4474 // Test all combinations of parameters that should not have an effect. 4475 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4476 Style.AllowAllArgumentsOnNextLine = i & 2; 4477 4478 Style.AllowAllConstructorInitializersOnNextLine = true; 4479 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4480 verifyFormat("Constructor()\n" 4481 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4482 Style); 4483 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4484 4485 Style.AllowAllConstructorInitializersOnNextLine = false; 4486 verifyFormat("Constructor()\n" 4487 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4488 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4489 Style); 4490 verifyFormat("Constructor() : a(a), b(b) {}", Style); 4491 4492 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4493 Style.AllowAllConstructorInitializersOnNextLine = true; 4494 verifyFormat("Constructor()\n" 4495 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4496 Style); 4497 4498 Style.AllowAllConstructorInitializersOnNextLine = false; 4499 verifyFormat("Constructor()\n" 4500 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4501 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4502 Style); 4503 4504 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4505 Style.AllowAllConstructorInitializersOnNextLine = true; 4506 verifyFormat("Constructor() :\n" 4507 " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4508 Style); 4509 4510 Style.AllowAllConstructorInitializersOnNextLine = false; 4511 verifyFormat("Constructor() :\n" 4512 " aaaaaaaaaaaaaaaaaa(a),\n" 4513 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4514 Style); 4515 } 4516 4517 // Test interactions between AllowAllParametersOfDeclarationOnNextLine and 4518 // AllowAllConstructorInitializersOnNextLine in all 4519 // BreakConstructorInitializers modes 4520 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 4521 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4522 Style.AllowAllConstructorInitializersOnNextLine = false; 4523 verifyFormat("SomeClassWithALongName::Constructor(\n" 4524 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4525 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4526 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4527 Style); 4528 4529 Style.AllowAllConstructorInitializersOnNextLine = true; 4530 verifyFormat("SomeClassWithALongName::Constructor(\n" 4531 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4532 " int bbbbbbbbbbbbb,\n" 4533 " int cccccccccccccccc)\n" 4534 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4535 Style); 4536 4537 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4538 Style.AllowAllConstructorInitializersOnNextLine = false; 4539 verifyFormat("SomeClassWithALongName::Constructor(\n" 4540 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4541 " int bbbbbbbbbbbbb)\n" 4542 " : aaaaaaaaaaaaaaaaaaaa(a)\n" 4543 " , bbbbbbbbbbbbbbbbbbbbb(b) {}", 4544 Style); 4545 4546 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 4547 4548 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4549 verifyFormat("SomeClassWithALongName::Constructor(\n" 4550 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" 4551 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4552 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4553 Style); 4554 4555 Style.AllowAllConstructorInitializersOnNextLine = true; 4556 verifyFormat("SomeClassWithALongName::Constructor(\n" 4557 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4558 " int bbbbbbbbbbbbb,\n" 4559 " int cccccccccccccccc)\n" 4560 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4561 Style); 4562 4563 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4564 Style.AllowAllConstructorInitializersOnNextLine = false; 4565 verifyFormat("SomeClassWithALongName::Constructor(\n" 4566 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4567 " int bbbbbbbbbbbbb)\n" 4568 " : aaaaaaaaaaaaaaaaaaaa(a),\n" 4569 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4570 Style); 4571 4572 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4573 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4574 verifyFormat("SomeClassWithALongName::Constructor(\n" 4575 " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" 4576 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4577 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4578 Style); 4579 4580 Style.AllowAllConstructorInitializersOnNextLine = true; 4581 verifyFormat("SomeClassWithALongName::Constructor(\n" 4582 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4583 " int bbbbbbbbbbbbb,\n" 4584 " int cccccccccccccccc) :\n" 4585 " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", 4586 Style); 4587 4588 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4589 Style.AllowAllConstructorInitializersOnNextLine = false; 4590 verifyFormat("SomeClassWithALongName::Constructor(\n" 4591 " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" 4592 " int bbbbbbbbbbbbb) :\n" 4593 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4594 " bbbbbbbbbbbbbbbbbbbbb(b) {}", 4595 Style); 4596 } 4597 4598 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 4599 FormatStyle Style = getLLVMStyle(); 4600 Style.ColumnLimit = 60; 4601 Style.BinPackArguments = false; 4602 for (int i = 0; i < 4; ++i) { 4603 // Test all combinations of parameters that should not have an effect. 4604 Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; 4605 Style.AllowAllConstructorInitializersOnNextLine = i & 2; 4606 4607 Style.AllowAllArgumentsOnNextLine = true; 4608 verifyFormat("void foo() {\n" 4609 " FunctionCallWithReallyLongName(\n" 4610 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" 4611 "}", 4612 Style); 4613 Style.AllowAllArgumentsOnNextLine = false; 4614 verifyFormat("void foo() {\n" 4615 " FunctionCallWithReallyLongName(\n" 4616 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4617 " bbbbbbbbbbbb);\n" 4618 "}", 4619 Style); 4620 4621 Style.AllowAllArgumentsOnNextLine = true; 4622 verifyFormat("void foo() {\n" 4623 " auto VariableWithReallyLongName = {\n" 4624 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" 4625 "}", 4626 Style); 4627 Style.AllowAllArgumentsOnNextLine = false; 4628 verifyFormat("void foo() {\n" 4629 " auto VariableWithReallyLongName = {\n" 4630 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4631 " bbbbbbbbbbbb};\n" 4632 "}", 4633 Style); 4634 } 4635 4636 // This parameter should not affect declarations. 4637 Style.BinPackParameters = false; 4638 Style.AllowAllArgumentsOnNextLine = false; 4639 Style.AllowAllParametersOfDeclarationOnNextLine = true; 4640 verifyFormat("void FunctionCallWithReallyLongName(\n" 4641 " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", 4642 Style); 4643 Style.AllowAllParametersOfDeclarationOnNextLine = false; 4644 verifyFormat("void FunctionCallWithReallyLongName(\n" 4645 " int aaaaaaaaaaaaaaaaaaaaaaa,\n" 4646 " int bbbbbbbbbbbb);", 4647 Style); 4648 } 4649 4650 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { 4651 FormatStyle Style = getLLVMStyle(); 4652 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 4653 4654 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 4655 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", 4656 getStyleWithColumns(Style, 45)); 4657 verifyFormat("Constructor() :\n" 4658 " Initializer(FitsOnTheLine) {}", 4659 getStyleWithColumns(Style, 44)); 4660 verifyFormat("Constructor() :\n" 4661 " Initializer(FitsOnTheLine) {}", 4662 getStyleWithColumns(Style, 43)); 4663 4664 verifyFormat("template <typename T>\n" 4665 "Constructor() : Initializer(FitsOnTheLine) {}", 4666 getStyleWithColumns(Style, 50)); 4667 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4668 verifyFormat( 4669 "SomeClass::Constructor() :\n" 4670 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4671 Style); 4672 4673 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false; 4674 verifyFormat( 4675 "SomeClass::Constructor() :\n" 4676 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4677 Style); 4678 4679 verifyFormat( 4680 "SomeClass::Constructor() :\n" 4681 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4682 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4683 Style); 4684 verifyFormat( 4685 "SomeClass::Constructor() :\n" 4686 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4687 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", 4688 Style); 4689 verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4690 " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 4691 " aaaaaaaaaa(aaaaaa) {}", 4692 Style); 4693 4694 verifyFormat("Constructor() :\n" 4695 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4696 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4697 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 4698 " aaaaaaaaaaaaaaaaaaaaaaa() {}", 4699 Style); 4700 4701 verifyFormat("Constructor() :\n" 4702 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4703 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4704 Style); 4705 4706 verifyFormat("Constructor(int Parameter = 0) :\n" 4707 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 4708 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", 4709 Style); 4710 verifyFormat("Constructor() :\n" 4711 " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 4712 "}", 4713 getStyleWithColumns(Style, 60)); 4714 verifyFormat("Constructor() :\n" 4715 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4716 " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", 4717 Style); 4718 4719 // Here a line could be saved by splitting the second initializer onto two 4720 // lines, but that is not desirable. 4721 verifyFormat("Constructor() :\n" 4722 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 4723 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 4724 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4725 Style); 4726 4727 FormatStyle OnePerLine = Style; 4728 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4729 OnePerLine.AllowAllConstructorInitializersOnNextLine = false; 4730 verifyFormat("SomeClass::Constructor() :\n" 4731 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4732 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4733 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4734 OnePerLine); 4735 verifyFormat("SomeClass::Constructor() :\n" 4736 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 4737 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 4738 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 4739 OnePerLine); 4740 verifyFormat("MyClass::MyClass(int var) :\n" 4741 " some_var_(var), // 4 space indent\n" 4742 " some_other_var_(var + 1) { // lined up\n" 4743 "}", 4744 OnePerLine); 4745 verifyFormat("Constructor() :\n" 4746 " aaaaa(aaaaaa),\n" 4747 " aaaaa(aaaaaa),\n" 4748 " aaaaa(aaaaaa),\n" 4749 " aaaaa(aaaaaa),\n" 4750 " aaaaa(aaaaaa) {}", 4751 OnePerLine); 4752 verifyFormat("Constructor() :\n" 4753 " aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 4754 " aaaaaaaaaaaaaaaaaaaaaa) {}", 4755 OnePerLine); 4756 OnePerLine.BinPackParameters = false; 4757 verifyFormat("Constructor() :\n" 4758 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 4759 " aaaaaaaaaaa().aaa(),\n" 4760 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 4761 OnePerLine); 4762 OnePerLine.ColumnLimit = 60; 4763 verifyFormat("Constructor() :\n" 4764 " aaaaaaaaaaaaaaaaaaaa(a),\n" 4765 " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", 4766 OnePerLine); 4767 4768 EXPECT_EQ("Constructor() :\n" 4769 " // Comment forcing unwanted break.\n" 4770 " aaaa(aaaa) {}", 4771 format("Constructor() :\n" 4772 " // Comment forcing unwanted break.\n" 4773 " aaaa(aaaa) {}", 4774 Style)); 4775 4776 Style.ColumnLimit = 0; 4777 verifyFormat("SomeClass::Constructor() :\n" 4778 " a(a) {}", 4779 Style); 4780 verifyFormat("SomeClass::Constructor() noexcept :\n" 4781 " a(a) {}", 4782 Style); 4783 verifyFormat("SomeClass::Constructor() :\n" 4784 " a(a), b(b), c(c) {}", 4785 Style); 4786 verifyFormat("SomeClass::Constructor() :\n" 4787 " a(a) {\n" 4788 " foo();\n" 4789 " bar();\n" 4790 "}", 4791 Style); 4792 4793 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 4794 verifyFormat("SomeClass::Constructor() :\n" 4795 " a(a), b(b), c(c) {\n" 4796 "}", 4797 Style); 4798 verifyFormat("SomeClass::Constructor() :\n" 4799 " a(a) {\n" 4800 "}", 4801 Style); 4802 4803 Style.ColumnLimit = 80; 4804 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 4805 Style.ConstructorInitializerIndentWidth = 2; 4806 verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style); 4807 verifyFormat("SomeClass::Constructor() :\n" 4808 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4809 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", 4810 Style); 4811 4812 // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as 4813 // well 4814 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 4815 verifyFormat( 4816 "class SomeClass\n" 4817 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4818 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4819 Style); 4820 Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 4821 verifyFormat( 4822 "class SomeClass\n" 4823 " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4824 " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4825 Style); 4826 Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; 4827 verifyFormat( 4828 "class SomeClass :\n" 4829 " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4830 " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", 4831 Style); 4832 } 4833 4834 #ifndef EXPENSIVE_CHECKS 4835 // Expensive checks enables libstdc++ checking which includes validating the 4836 // state of ranges used in std::priority_queue - this blows out the 4837 // runtime/scalability of the function and makes this test unacceptably slow. 4838 TEST_F(FormatTest, MemoizationTests) { 4839 // This breaks if the memoization lookup does not take \c Indent and 4840 // \c LastSpace into account. 4841 verifyFormat( 4842 "extern CFRunLoopTimerRef\n" 4843 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 4844 " CFTimeInterval interval, CFOptionFlags flags,\n" 4845 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 4846 " CFRunLoopTimerContext *context) {}"); 4847 4848 // Deep nesting somewhat works around our memoization. 4849 verifyFormat( 4850 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4851 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4852 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4853 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 4854 " aaaaa())))))))))))))))))))))))))))))))))))))));", 4855 getLLVMStyleWithColumns(65)); 4856 verifyFormat( 4857 "aaaaa(\n" 4858 " aaaaa,\n" 4859 " aaaaa(\n" 4860 " aaaaa,\n" 4861 " aaaaa(\n" 4862 " aaaaa,\n" 4863 " aaaaa(\n" 4864 " aaaaa,\n" 4865 " aaaaa(\n" 4866 " aaaaa,\n" 4867 " aaaaa(\n" 4868 " aaaaa,\n" 4869 " aaaaa(\n" 4870 " aaaaa,\n" 4871 " aaaaa(\n" 4872 " aaaaa,\n" 4873 " aaaaa(\n" 4874 " aaaaa,\n" 4875 " aaaaa(\n" 4876 " aaaaa,\n" 4877 " aaaaa(\n" 4878 " aaaaa,\n" 4879 " aaaaa(\n" 4880 " aaaaa,\n" 4881 " aaaaa))))))))))));", 4882 getLLVMStyleWithColumns(65)); 4883 verifyFormat( 4884 "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" 4885 " a),\n" 4886 " a),\n" 4887 " a),\n" 4888 " a),\n" 4889 " a),\n" 4890 " a),\n" 4891 " a),\n" 4892 " a),\n" 4893 " a),\n" 4894 " a),\n" 4895 " a),\n" 4896 " a),\n" 4897 " a),\n" 4898 " a),\n" 4899 " a),\n" 4900 " a),\n" 4901 " a)", 4902 getLLVMStyleWithColumns(65)); 4903 4904 // This test takes VERY long when memoization is broken. 4905 FormatStyle OnePerLine = getLLVMStyle(); 4906 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 4907 OnePerLine.BinPackParameters = false; 4908 std::string input = "Constructor()\n" 4909 " : aaaa(a,\n"; 4910 for (unsigned i = 0, e = 80; i != e; ++i) { 4911 input += " a,\n"; 4912 } 4913 input += " a) {}"; 4914 verifyFormat(input, OnePerLine); 4915 } 4916 #endif 4917 4918 TEST_F(FormatTest, BreaksAsHighAsPossible) { 4919 verifyFormat( 4920 "void f() {\n" 4921 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 4922 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 4923 " f();\n" 4924 "}"); 4925 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 4926 " Intervals[i - 1].getRange().getLast()) {\n}"); 4927 } 4928 4929 TEST_F(FormatTest, BreaksFunctionDeclarations) { 4930 // Principially, we break function declarations in a certain order: 4931 // 1) break amongst arguments. 4932 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 4933 " Cccccccccccccc cccccccccccccc);"); 4934 verifyFormat("template <class TemplateIt>\n" 4935 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 4936 " TemplateIt *stop) {}"); 4937 4938 // 2) break after return type. 4939 verifyFormat( 4940 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4941 "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 4942 getGoogleStyle()); 4943 4944 // 3) break after (. 4945 verifyFormat( 4946 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 4947 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 4948 getGoogleStyle()); 4949 4950 // 4) break before after nested name specifiers. 4951 verifyFormat( 4952 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4953 "SomeClasssssssssssssssssssssssssssssssssssssss::\n" 4954 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 4955 getGoogleStyle()); 4956 4957 // However, there are exceptions, if a sufficient amount of lines can be 4958 // saved. 4959 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 4960 // more adjusting. 4961 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4962 " Cccccccccccccc cccccccccc,\n" 4963 " Cccccccccccccc cccccccccc,\n" 4964 " Cccccccccccccc cccccccccc,\n" 4965 " Cccccccccccccc cccccccccc);"); 4966 verifyFormat( 4967 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4968 "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4969 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4970 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 4971 getGoogleStyle()); 4972 verifyFormat( 4973 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 4974 " Cccccccccccccc cccccccccc,\n" 4975 " Cccccccccccccc cccccccccc,\n" 4976 " Cccccccccccccc cccccccccc,\n" 4977 " Cccccccccccccc cccccccccc,\n" 4978 " Cccccccccccccc cccccccccc,\n" 4979 " Cccccccccccccc cccccccccc);"); 4980 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 4981 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4982 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4983 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 4984 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 4985 4986 // Break after multi-line parameters. 4987 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 4988 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4989 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4990 " bbbb bbbb);"); 4991 verifyFormat("void SomeLoooooooooooongFunction(\n" 4992 " std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 4993 " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4994 " int bbbbbbbbbbbbb);"); 4995 4996 // Treat overloaded operators like other functions. 4997 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 4998 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 4999 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5000 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 5001 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 5002 "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); 5003 verifyGoogleFormat( 5004 "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" 5005 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 5006 verifyGoogleFormat( 5007 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 5008 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 5009 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5010 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 5011 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" 5012 "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); 5013 verifyGoogleFormat( 5014 "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n" 5015 "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5016 " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); 5017 verifyGoogleFormat("template <typename T>\n" 5018 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5019 "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n" 5020 " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); 5021 5022 FormatStyle Style = getLLVMStyle(); 5023 Style.PointerAlignment = FormatStyle::PAS_Left; 5024 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5025 " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", 5026 Style); 5027 verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 5028 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5029 Style); 5030 } 5031 5032 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { 5033 // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: 5034 // Prefer keeping `::` followed by `operator` together. 5035 EXPECT_EQ("const aaaa::bbbbbbb &\n" 5036 "ccccccccc::operator++() {\n" 5037 " stuff();\n" 5038 "}", 5039 format("const aaaa::bbbbbbb\n" 5040 "&ccccccccc::operator++() { stuff(); }", 5041 getLLVMStyleWithColumns(40))); 5042 } 5043 5044 TEST_F(FormatTest, TrailingReturnType) { 5045 verifyFormat("auto foo() -> int;\n"); 5046 // correct trailing return type spacing 5047 verifyFormat("auto operator->() -> int;\n"); 5048 verifyFormat("auto operator++(int) -> int;\n"); 5049 5050 verifyFormat("struct S {\n" 5051 " auto bar() const -> int;\n" 5052 "};"); 5053 verifyFormat("template <size_t Order, typename T>\n" 5054 "auto load_img(const std::string &filename)\n" 5055 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 5056 verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" 5057 " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); 5058 verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); 5059 verifyFormat("template <typename T>\n" 5060 "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" 5061 " -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());"); 5062 5063 // Not trailing return types. 5064 verifyFormat("void f() { auto a = b->c(); }"); 5065 } 5066 5067 TEST_F(FormatTest, DeductionGuides) { 5068 verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;"); 5069 verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;"); 5070 verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;"); 5071 verifyFormat( 5072 "template <class... T>\n" 5073 "array(T &&... t) -> array<std::common_type_t<T...>, sizeof...(T)>;"); 5074 verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;"); 5075 verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;"); 5076 verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;"); 5077 verifyFormat("template <class T> A() -> A<(3 < 2)>;"); 5078 verifyFormat("template <class T> A() -> A<((3) < (2))>;"); 5079 verifyFormat("template <class T> x() -> x<1>;"); 5080 verifyFormat("template <class T> explicit x(T &) -> x<1>;"); 5081 5082 // Ensure not deduction guides. 5083 verifyFormat("c()->f<int>();"); 5084 verifyFormat("x()->foo<1>;"); 5085 verifyFormat("x = p->foo<3>();"); 5086 verifyFormat("x()->x<1>();"); 5087 verifyFormat("x()->x<1>;"); 5088 } 5089 5090 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 5091 // Avoid breaking before trailing 'const' or other trailing annotations, if 5092 // they are not function-like. 5093 FormatStyle Style = getGoogleStyle(); 5094 Style.ColumnLimit = 47; 5095 verifyFormat("void someLongFunction(\n" 5096 " int someLoooooooooooooongParameter) const {\n}", 5097 getLLVMStyleWithColumns(47)); 5098 verifyFormat("LoooooongReturnType\n" 5099 "someLoooooooongFunction() const {}", 5100 getLLVMStyleWithColumns(47)); 5101 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 5102 " const {}", 5103 Style); 5104 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5105 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 5106 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5107 " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); 5108 verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" 5109 " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); 5110 verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" 5111 " aaaaaaaaaaa aaaaa) const override;"); 5112 verifyGoogleFormat( 5113 "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5114 " const override;"); 5115 5116 // Even if the first parameter has to be wrapped. 5117 verifyFormat("void someLongFunction(\n" 5118 " int someLongParameter) const {}", 5119 getLLVMStyleWithColumns(46)); 5120 verifyFormat("void someLongFunction(\n" 5121 " int someLongParameter) const {}", 5122 Style); 5123 verifyFormat("void someLongFunction(\n" 5124 " int someLongParameter) override {}", 5125 Style); 5126 verifyFormat("void someLongFunction(\n" 5127 " int someLongParameter) OVERRIDE {}", 5128 Style); 5129 verifyFormat("void someLongFunction(\n" 5130 " int someLongParameter) final {}", 5131 Style); 5132 verifyFormat("void someLongFunction(\n" 5133 " int someLongParameter) FINAL {}", 5134 Style); 5135 verifyFormat("void someLongFunction(\n" 5136 " int parameter) const override {}", 5137 Style); 5138 5139 Style.BreakBeforeBraces = FormatStyle::BS_Allman; 5140 verifyFormat("void someLongFunction(\n" 5141 " int someLongParameter) const\n" 5142 "{\n" 5143 "}", 5144 Style); 5145 5146 Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 5147 verifyFormat("void someLongFunction(\n" 5148 " int someLongParameter) const\n" 5149 " {\n" 5150 " }", 5151 Style); 5152 5153 // Unless these are unknown annotations. 5154 verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" 5155 " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5156 " LONG_AND_UGLY_ANNOTATION;"); 5157 5158 // Breaking before function-like trailing annotations is fine to keep them 5159 // close to their arguments. 5160 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5161 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5162 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5163 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 5164 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 5165 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 5166 verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" 5167 " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); 5168 verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); 5169 5170 verifyFormat( 5171 "void aaaaaaaaaaaaaaaaaa()\n" 5172 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 5173 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 5174 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5175 " __attribute__((unused));"); 5176 verifyGoogleFormat( 5177 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5178 " GUARDED_BY(aaaaaaaaaaaa);"); 5179 verifyGoogleFormat( 5180 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5181 " GUARDED_BY(aaaaaaaaaaaa);"); 5182 verifyGoogleFormat( 5183 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5184 " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5185 verifyGoogleFormat( 5186 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" 5187 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5188 } 5189 5190 TEST_F(FormatTest, FunctionAnnotations) { 5191 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5192 "int OldFunction(const string ¶meter) {}"); 5193 verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5194 "string OldFunction(const string ¶meter) {}"); 5195 verifyFormat("template <typename T>\n" 5196 "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" 5197 "string OldFunction(const string ¶meter) {}"); 5198 5199 // Not function annotations. 5200 verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5201 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); 5202 verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" 5203 " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); 5204 verifyFormat("MACRO(abc).function() // wrap\n" 5205 " << abc;"); 5206 verifyFormat("MACRO(abc)->function() // wrap\n" 5207 " << abc;"); 5208 verifyFormat("MACRO(abc)::function() // wrap\n" 5209 " << abc;"); 5210 } 5211 5212 TEST_F(FormatTest, BreaksDesireably) { 5213 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5214 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 5215 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 5216 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5217 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 5218 "}"); 5219 5220 verifyFormat( 5221 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5222 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 5223 5224 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5225 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5226 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5227 5228 verifyFormat( 5229 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5230 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5231 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5232 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5233 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 5234 5235 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5236 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5237 5238 verifyFormat( 5239 "void f() {\n" 5240 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 5241 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5242 "}"); 5243 verifyFormat( 5244 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5245 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5246 verifyFormat( 5247 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5248 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 5249 verifyFormat( 5250 "aaaaaa(aaa,\n" 5251 " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5252 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5253 " aaaa);"); 5254 verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5255 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5256 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5257 5258 // Indent consistently independent of call expression and unary operator. 5259 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5260 " dddddddddddddddddddddddddddddd));"); 5261 verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 5262 " dddddddddddddddddddddddddddddd));"); 5263 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 5264 " dddddddddddddddddddddddddddddd));"); 5265 5266 // This test case breaks on an incorrect memoization, i.e. an optimization not 5267 // taking into account the StopAt value. 5268 verifyFormat( 5269 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5270 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5271 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 5272 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5273 5274 verifyFormat("{\n {\n {\n" 5275 " Annotation.SpaceRequiredBefore =\n" 5276 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 5277 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 5278 " }\n }\n}"); 5279 5280 // Break on an outer level if there was a break on an inner level. 5281 EXPECT_EQ("f(g(h(a, // comment\n" 5282 " b, c),\n" 5283 " d, e),\n" 5284 " x, y);", 5285 format("f(g(h(a, // comment\n" 5286 " b, c), d, e), x, y);")); 5287 5288 // Prefer breaking similar line breaks. 5289 verifyFormat( 5290 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 5291 " NSTrackingMouseEnteredAndExited |\n" 5292 " NSTrackingActiveAlways;"); 5293 } 5294 5295 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) { 5296 FormatStyle NoBinPacking = getGoogleStyle(); 5297 NoBinPacking.BinPackParameters = false; 5298 NoBinPacking.BinPackArguments = true; 5299 verifyFormat("void f() {\n" 5300 " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" 5301 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 5302 "}", 5303 NoBinPacking); 5304 verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" 5305 " int aaaaaaaaaaaaaaaaaaaa,\n" 5306 " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5307 NoBinPacking); 5308 5309 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5310 verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5311 " vector<int> bbbbbbbbbbbbbbb);", 5312 NoBinPacking); 5313 // FIXME: This behavior difference is probably not wanted. However, currently 5314 // we cannot distinguish BreakBeforeParameter being set because of the wrapped 5315 // template arguments from BreakBeforeParameter being set because of the 5316 // one-per-line formatting. 5317 verifyFormat( 5318 "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5319 " aaaaaaaaaa> aaaaaaaaaa);", 5320 NoBinPacking); 5321 verifyFormat( 5322 "void fffffffffff(\n" 5323 " aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n" 5324 " aaaaaaaaaa);"); 5325 } 5326 5327 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 5328 FormatStyle NoBinPacking = getGoogleStyle(); 5329 NoBinPacking.BinPackParameters = false; 5330 NoBinPacking.BinPackArguments = false; 5331 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 5332 " aaaaaaaaaaaaaaaaaaaa,\n" 5333 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 5334 NoBinPacking); 5335 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 5336 " aaaaaaaaaaaaa,\n" 5337 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 5338 NoBinPacking); 5339 verifyFormat( 5340 "aaaaaaaa(aaaaaaaaaaaaa,\n" 5341 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5342 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 5343 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5344 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 5345 NoBinPacking); 5346 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5347 " .aaaaaaaaaaaaaaaaaa();", 5348 NoBinPacking); 5349 verifyFormat("void f() {\n" 5350 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5351 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" 5352 "}", 5353 NoBinPacking); 5354 5355 verifyFormat( 5356 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5357 " aaaaaaaaaaaa,\n" 5358 " aaaaaaaaaaaa);", 5359 NoBinPacking); 5360 verifyFormat( 5361 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 5362 " ddddddddddddddddddddddddddddd),\n" 5363 " test);", 5364 NoBinPacking); 5365 5366 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 5367 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 5368 " aaaaaaaaaaaaaaaaaaaaaaa>\n" 5369 " aaaaaaaaaaaaaaaaaa;", 5370 NoBinPacking); 5371 verifyFormat("a(\"a\"\n" 5372 " \"a\",\n" 5373 " a);"); 5374 5375 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 5376 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 5377 " aaaaaaaaa,\n" 5378 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5379 NoBinPacking); 5380 verifyFormat( 5381 "void f() {\n" 5382 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 5383 " .aaaaaaa();\n" 5384 "}", 5385 NoBinPacking); 5386 verifyFormat( 5387 "template <class SomeType, class SomeOtherType>\n" 5388 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 5389 NoBinPacking); 5390 } 5391 5392 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 5393 FormatStyle Style = getLLVMStyleWithColumns(15); 5394 Style.ExperimentalAutoDetectBinPacking = true; 5395 EXPECT_EQ("aaa(aaaa,\n" 5396 " aaaa,\n" 5397 " aaaa);\n" 5398 "aaa(aaaa,\n" 5399 " aaaa,\n" 5400 " aaaa);", 5401 format("aaa(aaaa,\n" // one-per-line 5402 " aaaa,\n" 5403 " aaaa );\n" 5404 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5405 Style)); 5406 EXPECT_EQ("aaa(aaaa, aaaa,\n" 5407 " aaaa);\n" 5408 "aaa(aaaa, aaaa,\n" 5409 " aaaa);", 5410 format("aaa(aaaa, aaaa,\n" // bin-packed 5411 " aaaa );\n" 5412 "aaa(aaaa, aaaa, aaaa);", // inconclusive 5413 Style)); 5414 } 5415 5416 TEST_F(FormatTest, FormatsBuilderPattern) { 5417 verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n" 5418 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 5419 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 5420 " .StartsWith(\".init\", ORDER_INIT)\n" 5421 " .StartsWith(\".fini\", ORDER_FINI)\n" 5422 " .StartsWith(\".hash\", ORDER_HASH)\n" 5423 " .Default(ORDER_TEXT);\n"); 5424 5425 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 5426 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 5427 verifyFormat("aaaaaaa->aaaaaaa\n" 5428 " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5429 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5430 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5431 verifyFormat( 5432 "aaaaaaa->aaaaaaa\n" 5433 " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5434 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 5435 verifyFormat( 5436 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 5437 " aaaaaaaaaaaaaa);"); 5438 verifyFormat( 5439 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 5440 " aaaaaa->aaaaaaaaaaaa()\n" 5441 " ->aaaaaaaaaaaaaaaa(\n" 5442 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5443 " ->aaaaaaaaaaaaaaaaa();"); 5444 verifyGoogleFormat( 5445 "void f() {\n" 5446 " someo->Add((new util::filetools::Handler(dir))\n" 5447 " ->OnEvent1(NewPermanentCallback(\n" 5448 " this, &HandlerHolderClass::EventHandlerCBA))\n" 5449 " ->OnEvent2(NewPermanentCallback(\n" 5450 " this, &HandlerHolderClass::EventHandlerCBB))\n" 5451 " ->OnEvent3(NewPermanentCallback(\n" 5452 " this, &HandlerHolderClass::EventHandlerCBC))\n" 5453 " ->OnEvent5(NewPermanentCallback(\n" 5454 " this, &HandlerHolderClass::EventHandlerCBD))\n" 5455 " ->OnEvent6(NewPermanentCallback(\n" 5456 " this, &HandlerHolderClass::EventHandlerCBE)));\n" 5457 "}"); 5458 5459 verifyFormat( 5460 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 5461 verifyFormat("aaaaaaaaaaaaaaa()\n" 5462 " .aaaaaaaaaaaaaaa()\n" 5463 " .aaaaaaaaaaaaaaa()\n" 5464 " .aaaaaaaaaaaaaaa()\n" 5465 " .aaaaaaaaaaaaaaa();"); 5466 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5467 " .aaaaaaaaaaaaaaa()\n" 5468 " .aaaaaaaaaaaaaaa()\n" 5469 " .aaaaaaaaaaaaaaa();"); 5470 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5471 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 5472 " .aaaaaaaaaaaaaaa();"); 5473 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 5474 " ->aaaaaaaaaaaaaae(0)\n" 5475 " ->aaaaaaaaaaaaaaa();"); 5476 5477 // Don't linewrap after very short segments. 5478 verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5479 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5480 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5481 verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5482 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5483 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5484 verifyFormat("aaa()\n" 5485 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5486 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5487 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 5488 5489 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5490 " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 5491 " .has<bbbbbbbbbbbbbbbbbbbbb>();"); 5492 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" 5493 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 5494 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); 5495 5496 // Prefer not to break after empty parentheses. 5497 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 5498 " First->LastNewlineOffset);"); 5499 5500 // Prefer not to create "hanging" indents. 5501 verifyFormat( 5502 "return !soooooooooooooome_map\n" 5503 " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5504 " .second;"); 5505 verifyFormat( 5506 "return aaaaaaaaaaaaaaaa\n" 5507 " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" 5508 " .aaaa(aaaaaaaaaaaaaa);"); 5509 // No hanging indent here. 5510 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" 5511 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5512 verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" 5513 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5514 verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5515 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5516 getLLVMStyleWithColumns(60)); 5517 verifyFormat("aaaaaaaaaaaaaaaaaa\n" 5518 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" 5519 " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5520 getLLVMStyleWithColumns(59)); 5521 verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5522 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5523 " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5524 5525 // Dont break if only closing statements before member call 5526 verifyFormat("test() {\n" 5527 " ([]() -> {\n" 5528 " int b = 32;\n" 5529 " return 3;\n" 5530 " }).foo();\n" 5531 "}"); 5532 verifyFormat("test() {\n" 5533 " (\n" 5534 " []() -> {\n" 5535 " int b = 32;\n" 5536 " return 3;\n" 5537 " },\n" 5538 " foo, bar)\n" 5539 " .foo();\n" 5540 "}"); 5541 verifyFormat("test() {\n" 5542 " ([]() -> {\n" 5543 " int b = 32;\n" 5544 " return 3;\n" 5545 " })\n" 5546 " .foo()\n" 5547 " .bar();\n" 5548 "}"); 5549 verifyFormat("test() {\n" 5550 " ([]() -> {\n" 5551 " int b = 32;\n" 5552 " return 3;\n" 5553 " })\n" 5554 " .foo(\"aaaaaaaaaaaaaaaaa\"\n" 5555 " \"bbbb\");\n" 5556 "}", 5557 getLLVMStyleWithColumns(30)); 5558 } 5559 5560 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 5561 verifyFormat( 5562 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 5563 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 5564 verifyFormat( 5565 "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" 5566 " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); 5567 5568 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5569 " ccccccccccccccccccccccccc) {\n}"); 5570 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" 5571 " ccccccccccccccccccccccccc) {\n}"); 5572 5573 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 5574 " ccccccccccccccccccccccccc) {\n}"); 5575 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" 5576 " ccccccccccccccccccccccccc) {\n}"); 5577 5578 verifyFormat( 5579 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 5580 " ccccccccccccccccccccccccc) {\n}"); 5581 verifyFormat( 5582 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" 5583 " ccccccccccccccccccccccccc) {\n}"); 5584 5585 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 5586 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 5587 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 5588 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5589 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" 5590 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" 5591 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" 5592 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 5593 5594 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 5595 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 5596 " aaaaaaaaaaaaaaa != aa) {\n}"); 5597 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" 5598 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" 5599 " aaaaaaaaaaaaaaa != aa) {\n}"); 5600 } 5601 5602 TEST_F(FormatTest, BreaksAfterAssignments) { 5603 verifyFormat( 5604 "unsigned Cost =\n" 5605 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 5606 " SI->getPointerAddressSpaceee());\n"); 5607 verifyFormat( 5608 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 5609 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 5610 5611 verifyFormat( 5612 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 5613 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 5614 verifyFormat("unsigned OriginalStartColumn =\n" 5615 " SourceMgr.getSpellingColumnNumber(\n" 5616 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 5617 " 1;"); 5618 } 5619 5620 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) { 5621 FormatStyle Style = getLLVMStyle(); 5622 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 5623 " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", 5624 Style); 5625 5626 Style.PenaltyBreakAssignment = 20; 5627 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 5628 " cccccccccccccccccccccccccc;", 5629 Style); 5630 } 5631 5632 TEST_F(FormatTest, AlignsAfterAssignments) { 5633 verifyFormat( 5634 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5635 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5636 verifyFormat( 5637 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5638 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5639 verifyFormat( 5640 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5641 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5642 verifyFormat( 5643 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5644 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5645 verifyFormat( 5646 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5647 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 5648 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 5649 } 5650 5651 TEST_F(FormatTest, AlignsAfterReturn) { 5652 verifyFormat( 5653 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5654 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 5655 verifyFormat( 5656 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5657 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 5658 verifyFormat( 5659 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5660 " aaaaaaaaaaaaaaaaaaaaaa();"); 5661 verifyFormat( 5662 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 5663 " aaaaaaaaaaaaaaaaaaaaaa());"); 5664 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5665 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5666 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5667 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 5668 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5669 verifyFormat("return\n" 5670 " // true if code is one of a or b.\n" 5671 " code == a || code == b;"); 5672 } 5673 5674 TEST_F(FormatTest, AlignsAfterOpenBracket) { 5675 verifyFormat( 5676 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5677 " aaaaaaaaa aaaaaaa) {}"); 5678 verifyFormat( 5679 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5680 " aaaaaaaaaaa aaaaaaaaa);"); 5681 verifyFormat( 5682 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5683 " aaaaaaaaaaaaaaaaaaaaa));"); 5684 FormatStyle Style = getLLVMStyle(); 5685 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5686 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5687 " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", 5688 Style); 5689 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5690 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", 5691 Style); 5692 verifyFormat("SomeLongVariableName->someFunction(\n" 5693 " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", 5694 Style); 5695 verifyFormat( 5696 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" 5697 " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5698 Style); 5699 verifyFormat( 5700 "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" 5701 " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5702 Style); 5703 verifyFormat( 5704 "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" 5705 " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5706 Style); 5707 5708 verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" 5709 " ccccccc(aaaaaaaaaaaaaaaaa, //\n" 5710 " b));", 5711 Style); 5712 5713 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 5714 Style.BinPackArguments = false; 5715 Style.BinPackParameters = false; 5716 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5717 " aaaaaaaaaaa aaaaaaaa,\n" 5718 " aaaaaaaaa aaaaaaa,\n" 5719 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", 5720 Style); 5721 verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" 5722 " aaaaaaaaaaa aaaaaaaaa,\n" 5723 " aaaaaaaaaaa aaaaaaaaa,\n" 5724 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5725 Style); 5726 verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" 5727 " aaaaaaaaaaaaaaa,\n" 5728 " aaaaaaaaaaaaaaaaaaaaa,\n" 5729 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", 5730 Style); 5731 verifyFormat( 5732 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" 5733 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5734 Style); 5735 verifyFormat( 5736 "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" 5737 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", 5738 Style); 5739 verifyFormat( 5740 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5741 " aaaaaaaaaaaaaaaaaaaaa(\n" 5742 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" 5743 " aaaaaaaaaaaaaaaa);", 5744 Style); 5745 verifyFormat( 5746 "aaaaaaaaaaaaaaaaaaaaaaaa(\n" 5747 " aaaaaaaaaaaaaaaaaaaaa(\n" 5748 " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" 5749 " aaaaaaaaaaaaaaaa);", 5750 Style); 5751 } 5752 5753 TEST_F(FormatTest, ParenthesesAndOperandAlignment) { 5754 FormatStyle Style = getLLVMStyleWithColumns(40); 5755 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5756 " bbbbbbbbbbbbbbbbbbbbbb);", 5757 Style); 5758 Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; 5759 Style.AlignOperands = false; 5760 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5761 " bbbbbbbbbbbbbbbbbbbbbb);", 5762 Style); 5763 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5764 Style.AlignOperands = true; 5765 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5766 " bbbbbbbbbbbbbbbbbbbbbb);", 5767 Style); 5768 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 5769 Style.AlignOperands = false; 5770 verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" 5771 " bbbbbbbbbbbbbbbbbbbbbb);", 5772 Style); 5773 } 5774 5775 TEST_F(FormatTest, BreaksConditionalExpressions) { 5776 verifyFormat( 5777 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5778 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5779 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5780 verifyFormat( 5781 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5782 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5783 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5784 verifyFormat( 5785 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5786 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5787 verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n" 5788 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5789 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5790 verifyFormat( 5791 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 5792 " : aaaaaaaaaaaaa);"); 5793 verifyFormat( 5794 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5795 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5796 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5797 " aaaaaaaaaaaaa);"); 5798 verifyFormat( 5799 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5800 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5801 " aaaaaaaaaaaaa);"); 5802 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5803 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5804 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5805 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5806 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5807 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5808 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5809 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5810 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 5811 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5812 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5813 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5814 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5815 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5816 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5817 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5818 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 5819 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5820 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5821 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5822 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5823 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5824 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5825 " : aaaaaaaaaaaaaaaa;"); 5826 verifyFormat( 5827 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5828 " ? aaaaaaaaaaaaaaa\n" 5829 " : aaaaaaaaaaaaaaa;"); 5830 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5831 " aaaaaaaaa\n" 5832 " ? b\n" 5833 " : c);"); 5834 verifyFormat("return aaaa == bbbb\n" 5835 " // comment\n" 5836 " ? aaaa\n" 5837 " : bbbb;"); 5838 verifyFormat("unsigned Indent =\n" 5839 " format(TheLine.First,\n" 5840 " IndentForLevel[TheLine.Level] >= 0\n" 5841 " ? IndentForLevel[TheLine.Level]\n" 5842 " : TheLine * 2,\n" 5843 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5844 getLLVMStyleWithColumns(60)); 5845 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5846 " ? aaaaaaaaaaaaaaa\n" 5847 " : bbbbbbbbbbbbbbb //\n" 5848 " ? ccccccccccccccc\n" 5849 " : ddddddddddddddd;"); 5850 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 5851 " ? aaaaaaaaaaaaaaa\n" 5852 " : (bbbbbbbbbbbbbbb //\n" 5853 " ? ccccccccccccccc\n" 5854 " : ddddddddddddddd);"); 5855 verifyFormat( 5856 "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5857 " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 5858 " aaaaaaaaaaaaaaaaaaaaa +\n" 5859 " aaaaaaaaaaaaaaaaaaaaa\n" 5860 " : aaaaaaaaaa;"); 5861 verifyFormat( 5862 "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5863 " : aaaaaaaaaaaaaaaaaaaaaa\n" 5864 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 5865 5866 FormatStyle NoBinPacking = getLLVMStyle(); 5867 NoBinPacking.BinPackArguments = false; 5868 verifyFormat( 5869 "void f() {\n" 5870 " g(aaa,\n" 5871 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5872 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5873 " ? aaaaaaaaaaaaaaa\n" 5874 " : aaaaaaaaaaaaaaa);\n" 5875 "}", 5876 NoBinPacking); 5877 verifyFormat( 5878 "void f() {\n" 5879 " g(aaa,\n" 5880 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 5881 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5882 " ?: aaaaaaaaaaaaaaa);\n" 5883 "}", 5884 NoBinPacking); 5885 5886 verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" 5887 " // comment.\n" 5888 " ccccccccccccccccccccccccccccccccccccccc\n" 5889 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 5890 " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); 5891 5892 // Assignments in conditional expressions. Apparently not uncommon :-(. 5893 verifyFormat("return a != b\n" 5894 " // comment\n" 5895 " ? a = b\n" 5896 " : a = b;"); 5897 verifyFormat("return a != b\n" 5898 " // comment\n" 5899 " ? a = a != b\n" 5900 " // comment\n" 5901 " ? a = b\n" 5902 " : a\n" 5903 " : a;\n"); 5904 verifyFormat("return a != b\n" 5905 " // comment\n" 5906 " ? a\n" 5907 " : a = a != b\n" 5908 " // comment\n" 5909 " ? a = b\n" 5910 " : a;"); 5911 } 5912 5913 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { 5914 FormatStyle Style = getLLVMStyle(); 5915 Style.BreakBeforeTernaryOperators = false; 5916 Style.ColumnLimit = 70; 5917 verifyFormat( 5918 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5919 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5920 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5921 Style); 5922 verifyFormat( 5923 "aaaa(aaaaaaaaaa, aaaaaaaa,\n" 5924 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5925 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5926 Style); 5927 verifyFormat( 5928 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5929 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5930 Style); 5931 verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n" 5932 " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5933 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5934 Style); 5935 verifyFormat( 5936 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 5937 " aaaaaaaaaaaaa);", 5938 Style); 5939 verifyFormat( 5940 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5941 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5942 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5943 " aaaaaaaaaaaaa);", 5944 Style); 5945 verifyFormat( 5946 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5947 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5948 " aaaaaaaaaaaaa);", 5949 Style); 5950 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5951 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5952 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5953 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5954 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5955 Style); 5956 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5957 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5958 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5959 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" 5960 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5961 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5962 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5963 Style); 5964 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 5965 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" 5966 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 5967 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 5968 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", 5969 Style); 5970 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5971 " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5972 " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5973 Style); 5974 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 5975 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5976 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 5977 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 5978 Style); 5979 verifyFormat( 5980 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 5981 " aaaaaaaaaaaaaaa :\n" 5982 " aaaaaaaaaaaaaaa;", 5983 Style); 5984 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 5985 " aaaaaaaaa ?\n" 5986 " b :\n" 5987 " c);", 5988 Style); 5989 verifyFormat("unsigned Indent =\n" 5990 " format(TheLine.First,\n" 5991 " IndentForLevel[TheLine.Level] >= 0 ?\n" 5992 " IndentForLevel[TheLine.Level] :\n" 5993 " TheLine * 2,\n" 5994 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 5995 Style); 5996 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 5997 " aaaaaaaaaaaaaaa :\n" 5998 " bbbbbbbbbbbbbbb ? //\n" 5999 " ccccccccccccccc :\n" 6000 " ddddddddddddddd;", 6001 Style); 6002 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" 6003 " aaaaaaaaaaaaaaa :\n" 6004 " (bbbbbbbbbbbbbbb ? //\n" 6005 " ccccccccccccccc :\n" 6006 " ddddddddddddddd);", 6007 Style); 6008 verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6009 " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" 6010 " ccccccccccccccccccccccccccc;", 6011 Style); 6012 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 6013 " aaaaa :\n" 6014 " bbbbbbbbbbbbbbb + cccccccccccccccc;", 6015 Style); 6016 } 6017 6018 TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 6019 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 6020 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 6021 verifyFormat("bool a = true, b = false;"); 6022 6023 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6024 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 6025 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 6026 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 6027 verifyFormat( 6028 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 6029 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 6030 " d = e && f;"); 6031 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 6032 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 6033 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 6034 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 6035 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 6036 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 6037 6038 FormatStyle Style = getGoogleStyle(); 6039 Style.PointerAlignment = FormatStyle::PAS_Left; 6040 Style.DerivePointerAlignment = false; 6041 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6042 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 6043 " *b = bbbbbbbbbbbbbbbbbbb;", 6044 Style); 6045 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 6046 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", 6047 Style); 6048 verifyFormat("vector<int*> a, b;", Style); 6049 verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); 6050 } 6051 6052 TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 6053 verifyFormat("arr[foo ? bar : baz];"); 6054 verifyFormat("f()[foo ? bar : baz];"); 6055 verifyFormat("(a + b)[foo ? bar : baz];"); 6056 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 6057 } 6058 6059 TEST_F(FormatTest, AlignsStringLiterals) { 6060 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 6061 " \"short literal\");"); 6062 verifyFormat( 6063 "looooooooooooooooooooooooongFunction(\n" 6064 " \"short literal\"\n" 6065 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 6066 verifyFormat("someFunction(\"Always break between multi-line\"\n" 6067 " \" string literals\",\n" 6068 " and, other, parameters);"); 6069 EXPECT_EQ("fun + \"1243\" /* comment */\n" 6070 " \"5678\";", 6071 format("fun + \"1243\" /* comment */\n" 6072 " \"5678\";", 6073 getLLVMStyleWithColumns(28))); 6074 EXPECT_EQ( 6075 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 6076 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 6077 " \"aaaaaaaaaaaaaaaa\";", 6078 format("aaaaaa =" 6079 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 6080 "aaaaaaaaaaaaaaaaaaaaa\" " 6081 "\"aaaaaaaaaaaaaaaa\";")); 6082 verifyFormat("a = a + \"a\"\n" 6083 " \"a\"\n" 6084 " \"a\";"); 6085 verifyFormat("f(\"a\", \"b\"\n" 6086 " \"c\");"); 6087 6088 verifyFormat( 6089 "#define LL_FORMAT \"ll\"\n" 6090 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 6091 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 6092 6093 verifyFormat("#define A(X) \\\n" 6094 " \"aaaaa\" #X \"bbbbbb\" \\\n" 6095 " \"ccccc\"", 6096 getLLVMStyleWithColumns(23)); 6097 verifyFormat("#define A \"def\"\n" 6098 "f(\"abc\" A \"ghi\"\n" 6099 " \"jkl\");"); 6100 6101 verifyFormat("f(L\"a\"\n" 6102 " L\"b\");"); 6103 verifyFormat("#define A(X) \\\n" 6104 " L\"aaaaa\" #X L\"bbbbbb\" \\\n" 6105 " L\"ccccc\"", 6106 getLLVMStyleWithColumns(25)); 6107 6108 verifyFormat("f(@\"a\"\n" 6109 " @\"b\");"); 6110 verifyFormat("NSString s = @\"a\"\n" 6111 " @\"b\"\n" 6112 " @\"c\";"); 6113 verifyFormat("NSString s = @\"a\"\n" 6114 " \"b\"\n" 6115 " \"c\";"); 6116 } 6117 6118 TEST_F(FormatTest, ReturnTypeBreakingStyle) { 6119 FormatStyle Style = getLLVMStyle(); 6120 // No declarations or definitions should be moved to own line. 6121 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None; 6122 verifyFormat("class A {\n" 6123 " int f() { return 1; }\n" 6124 " int g();\n" 6125 "};\n" 6126 "int f() { return 1; }\n" 6127 "int g();\n", 6128 Style); 6129 6130 // All declarations and definitions should have the return type moved to its 6131 // own 6132 // line. 6133 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 6134 verifyFormat("class E {\n" 6135 " int\n" 6136 " f() {\n" 6137 " return 1;\n" 6138 " }\n" 6139 " int\n" 6140 " g();\n" 6141 "};\n" 6142 "int\n" 6143 "f() {\n" 6144 " return 1;\n" 6145 "}\n" 6146 "int\n" 6147 "g();\n", 6148 Style); 6149 6150 // Top-level definitions, and no kinds of declarations should have the 6151 // return type moved to its own line. 6152 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; 6153 verifyFormat("class B {\n" 6154 " int f() { return 1; }\n" 6155 " int g();\n" 6156 "};\n" 6157 "int\n" 6158 "f() {\n" 6159 " return 1;\n" 6160 "}\n" 6161 "int g();\n", 6162 Style); 6163 6164 // Top-level definitions and declarations should have the return type moved 6165 // to its own line. 6166 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel; 6167 verifyFormat("class C {\n" 6168 " int f() { return 1; }\n" 6169 " int g();\n" 6170 "};\n" 6171 "int\n" 6172 "f() {\n" 6173 " return 1;\n" 6174 "}\n" 6175 "int\n" 6176 "g();\n", 6177 Style); 6178 6179 // All definitions should have the return type moved to its own line, but no 6180 // kinds of declarations. 6181 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 6182 verifyFormat("class D {\n" 6183 " int\n" 6184 " f() {\n" 6185 " return 1;\n" 6186 " }\n" 6187 " int g();\n" 6188 "};\n" 6189 "int\n" 6190 "f() {\n" 6191 " return 1;\n" 6192 "}\n" 6193 "int g();\n", 6194 Style); 6195 verifyFormat("const char *\n" 6196 "f(void) {\n" // Break here. 6197 " return \"\";\n" 6198 "}\n" 6199 "const char *bar(void);\n", // No break here. 6200 Style); 6201 verifyFormat("template <class T>\n" 6202 "T *\n" 6203 "f(T &c) {\n" // Break here. 6204 " return NULL;\n" 6205 "}\n" 6206 "template <class T> T *f(T &c);\n", // No break here. 6207 Style); 6208 verifyFormat("class C {\n" 6209 " int\n" 6210 " operator+() {\n" 6211 " return 1;\n" 6212 " }\n" 6213 " int\n" 6214 " operator()() {\n" 6215 " return 1;\n" 6216 " }\n" 6217 "};\n", 6218 Style); 6219 verifyFormat("void\n" 6220 "A::operator()() {}\n" 6221 "void\n" 6222 "A::operator>>() {}\n" 6223 "void\n" 6224 "A::operator+() {}\n" 6225 "void\n" 6226 "A::operator*() {}\n" 6227 "void\n" 6228 "A::operator->() {}\n" 6229 "void\n" 6230 "A::operator void *() {}\n" 6231 "void\n" 6232 "A::operator void &() {}\n" 6233 "void\n" 6234 "A::operator void &&() {}\n" 6235 "void\n" 6236 "A::operator char *() {}\n" 6237 "void\n" 6238 "A::operator[]() {}\n" 6239 "void\n" 6240 "A::operator!() {}\n", 6241 Style); 6242 verifyFormat("constexpr auto\n" 6243 "operator()() const -> reference {}\n" 6244 "constexpr auto\n" 6245 "operator>>() const -> reference {}\n" 6246 "constexpr auto\n" 6247 "operator+() const -> reference {}\n" 6248 "constexpr auto\n" 6249 "operator*() const -> reference {}\n" 6250 "constexpr auto\n" 6251 "operator->() const -> reference {}\n" 6252 "constexpr auto\n" 6253 "operator++() const -> reference {}\n" 6254 "constexpr auto\n" 6255 "operator void *() const -> reference {}\n" 6256 "constexpr auto\n" 6257 "operator void &() const -> reference {}\n" 6258 "constexpr auto\n" 6259 "operator void &&() const -> reference {}\n" 6260 "constexpr auto\n" 6261 "operator char *() const -> reference {}\n" 6262 "constexpr auto\n" 6263 "operator!() const -> reference {}\n" 6264 "constexpr auto\n" 6265 "operator[]() const -> reference {}\n", 6266 Style); 6267 verifyFormat("void *operator new(std::size_t s);", // No break here. 6268 Style); 6269 verifyFormat("void *\n" 6270 "operator new(std::size_t s) {}", 6271 Style); 6272 verifyFormat("void *\n" 6273 "operator delete[](void *ptr) {}", 6274 Style); 6275 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 6276 verifyFormat("const char *\n" 6277 "f(void)\n" // Break here. 6278 "{\n" 6279 " return \"\";\n" 6280 "}\n" 6281 "const char *bar(void);\n", // No break here. 6282 Style); 6283 verifyFormat("template <class T>\n" 6284 "T *\n" // Problem here: no line break 6285 "f(T &c)\n" // Break here. 6286 "{\n" 6287 " return NULL;\n" 6288 "}\n" 6289 "template <class T> T *f(T &c);\n", // No break here. 6290 Style); 6291 verifyFormat("int\n" 6292 "foo(A<bool> a)\n" 6293 "{\n" 6294 " return a;\n" 6295 "}\n", 6296 Style); 6297 verifyFormat("int\n" 6298 "foo(A<8> a)\n" 6299 "{\n" 6300 " return a;\n" 6301 "}\n", 6302 Style); 6303 verifyFormat("int\n" 6304 "foo(A<B<bool>, 8> a)\n" 6305 "{\n" 6306 " return a;\n" 6307 "}\n", 6308 Style); 6309 verifyFormat("int\n" 6310 "foo(A<B<8>, bool> a)\n" 6311 "{\n" 6312 " return a;\n" 6313 "}\n", 6314 Style); 6315 verifyFormat("int\n" 6316 "foo(A<B<bool>, bool> a)\n" 6317 "{\n" 6318 " return a;\n" 6319 "}\n", 6320 Style); 6321 verifyFormat("int\n" 6322 "foo(A<B<8>, 8> a)\n" 6323 "{\n" 6324 " return a;\n" 6325 "}\n", 6326 Style); 6327 6328 Style = getGNUStyle(); 6329 6330 // Test for comments at the end of function declarations. 6331 verifyFormat("void\n" 6332 "foo (int a, /*abc*/ int b) // def\n" 6333 "{\n" 6334 "}\n", 6335 Style); 6336 6337 verifyFormat("void\n" 6338 "foo (int a, /* abc */ int b) /* def */\n" 6339 "{\n" 6340 "}\n", 6341 Style); 6342 6343 // Definitions that should not break after return type 6344 verifyFormat("void foo (int a, int b); // def\n", Style); 6345 verifyFormat("void foo (int a, int b); /* def */\n", Style); 6346 verifyFormat("void foo (int a, int b);\n", Style); 6347 } 6348 6349 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 6350 FormatStyle NoBreak = getLLVMStyle(); 6351 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 6352 FormatStyle Break = getLLVMStyle(); 6353 Break.AlwaysBreakBeforeMultilineStrings = true; 6354 verifyFormat("aaaa = \"bbbb\"\n" 6355 " \"cccc\";", 6356 NoBreak); 6357 verifyFormat("aaaa =\n" 6358 " \"bbbb\"\n" 6359 " \"cccc\";", 6360 Break); 6361 verifyFormat("aaaa(\"bbbb\"\n" 6362 " \"cccc\");", 6363 NoBreak); 6364 verifyFormat("aaaa(\n" 6365 " \"bbbb\"\n" 6366 " \"cccc\");", 6367 Break); 6368 verifyFormat("aaaa(qqq, \"bbbb\"\n" 6369 " \"cccc\");", 6370 NoBreak); 6371 verifyFormat("aaaa(qqq,\n" 6372 " \"bbbb\"\n" 6373 " \"cccc\");", 6374 Break); 6375 verifyFormat("aaaa(qqq,\n" 6376 " L\"bbbb\"\n" 6377 " L\"cccc\");", 6378 Break); 6379 verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" 6380 " \"bbbb\"));", 6381 Break); 6382 verifyFormat("string s = someFunction(\n" 6383 " \"abc\"\n" 6384 " \"abc\");", 6385 Break); 6386 6387 // As we break before unary operators, breaking right after them is bad. 6388 verifyFormat("string foo = abc ? \"x\"\n" 6389 " \"blah blah blah blah blah blah\"\n" 6390 " : \"y\";", 6391 Break); 6392 6393 // Don't break if there is no column gain. 6394 verifyFormat("f(\"aaaa\"\n" 6395 " \"bbbb\");", 6396 Break); 6397 6398 // Treat literals with escaped newlines like multi-line string literals. 6399 EXPECT_EQ("x = \"a\\\n" 6400 "b\\\n" 6401 "c\";", 6402 format("x = \"a\\\n" 6403 "b\\\n" 6404 "c\";", 6405 NoBreak)); 6406 EXPECT_EQ("xxxx =\n" 6407 " \"a\\\n" 6408 "b\\\n" 6409 "c\";", 6410 format("xxxx = \"a\\\n" 6411 "b\\\n" 6412 "c\";", 6413 Break)); 6414 6415 EXPECT_EQ("NSString *const kString =\n" 6416 " @\"aaaa\"\n" 6417 " @\"bbbb\";", 6418 format("NSString *const kString = @\"aaaa\"\n" 6419 "@\"bbbb\";", 6420 Break)); 6421 6422 Break.ColumnLimit = 0; 6423 verifyFormat("const char *hello = \"hello llvm\";", Break); 6424 } 6425 6426 TEST_F(FormatTest, AlignsPipes) { 6427 verifyFormat( 6428 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6429 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6430 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6431 verifyFormat( 6432 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 6433 " << aaaaaaaaaaaaaaaaaaaa;"); 6434 verifyFormat( 6435 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6436 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6437 verifyFormat( 6438 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" 6439 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6440 verifyFormat( 6441 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 6442 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 6443 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 6444 verifyFormat( 6445 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6446 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6447 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6448 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6449 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6450 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6451 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6452 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" 6453 " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); 6454 verifyFormat( 6455 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6456 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6457 verifyFormat( 6458 "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" 6459 " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6460 6461 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" 6462 " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); 6463 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6464 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6465 " aaaaaaaaaaaaaaaaaaaaa)\n" 6466 " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6467 verifyFormat("LOG_IF(aaa == //\n" 6468 " bbb)\n" 6469 " << a << b;"); 6470 6471 // But sometimes, breaking before the first "<<" is desirable. 6472 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6473 " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 6474 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 6475 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6476 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6477 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 6478 " << BEF << IsTemplate << Description << E->getType();"); 6479 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6480 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6481 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6482 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" 6483 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6484 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6485 " << aaa;"); 6486 6487 verifyFormat( 6488 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6489 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6490 6491 // Incomplete string literal. 6492 EXPECT_EQ("llvm::errs() << \"\n" 6493 " << a;", 6494 format("llvm::errs() << \"\n<<a;")); 6495 6496 verifyFormat("void f() {\n" 6497 " CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n" 6498 " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" 6499 "}"); 6500 6501 // Handle 'endl'. 6502 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" 6503 " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6504 verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); 6505 6506 // Handle '\n'. 6507 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" 6508 " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6509 verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" 6510 " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); 6511 verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" 6512 " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); 6513 verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); 6514 } 6515 6516 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 6517 verifyFormat("return out << \"somepacket = {\\n\"\n" 6518 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 6519 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 6520 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 6521 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 6522 " << \"}\";"); 6523 6524 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6525 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 6526 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 6527 verifyFormat( 6528 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 6529 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 6530 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 6531 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 6532 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 6533 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 6534 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 6535 verifyFormat( 6536 "void f() {\n" 6537 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 6538 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 6539 "}"); 6540 6541 // Breaking before the first "<<" is generally not desirable. 6542 verifyFormat( 6543 "llvm::errs()\n" 6544 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6545 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6546 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6547 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6548 getLLVMStyleWithColumns(70)); 6549 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6550 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6551 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6552 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6553 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 6554 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 6555 getLLVMStyleWithColumns(70)); 6556 6557 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6558 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" 6559 " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); 6560 verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6561 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" 6562 " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); 6563 verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" 6564 " (aaaa + aaaa);", 6565 getLLVMStyleWithColumns(40)); 6566 verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" 6567 " (aaaaaaa + aaaaa));", 6568 getLLVMStyleWithColumns(40)); 6569 verifyFormat( 6570 "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" 6571 " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" 6572 " bbbbbbbbbbbbbbbbbbbbbbb);"); 6573 } 6574 6575 TEST_F(FormatTest, UnderstandsEquals) { 6576 verifyFormat( 6577 "aaaaaaaaaaaaaaaaa =\n" 6578 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 6579 verifyFormat( 6580 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6581 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6582 verifyFormat( 6583 "if (a) {\n" 6584 " f();\n" 6585 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6586 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 6587 "}"); 6588 6589 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 6590 " 100000000 + 10000000) {\n}"); 6591 } 6592 6593 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 6594 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6595 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 6596 6597 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 6598 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 6599 6600 verifyFormat( 6601 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 6602 " Parameter2);"); 6603 6604 verifyFormat( 6605 "ShortObject->shortFunction(\n" 6606 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 6607 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 6608 6609 verifyFormat("loooooooooooooongFunction(\n" 6610 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 6611 6612 verifyFormat( 6613 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 6614 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 6615 6616 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6617 " .WillRepeatedly(Return(SomeValue));"); 6618 verifyFormat("void f() {\n" 6619 " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 6620 " .Times(2)\n" 6621 " .WillRepeatedly(Return(SomeValue));\n" 6622 "}"); 6623 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" 6624 " ccccccccccccccccccccccc);"); 6625 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6626 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6627 " .aaaaa(aaaaa),\n" 6628 " aaaaaaaaaaaaaaaaaaaaa);"); 6629 verifyFormat("void f() {\n" 6630 " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6631 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" 6632 "}"); 6633 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6634 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6635 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6636 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6637 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 6638 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6639 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6640 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6641 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 6642 "}"); 6643 6644 // Here, it is not necessary to wrap at "." or "->". 6645 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 6646 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 6647 verifyFormat( 6648 "aaaaaaaaaaa->aaaaaaaaa(\n" 6649 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6650 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 6651 6652 verifyFormat( 6653 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6654 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 6655 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 6656 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6657 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 6658 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 6659 6660 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6661 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6662 " .a();"); 6663 6664 FormatStyle NoBinPacking = getLLVMStyle(); 6665 NoBinPacking.BinPackParameters = false; 6666 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6667 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 6668 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 6669 " aaaaaaaaaaaaaaaaaaa,\n" 6670 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 6671 NoBinPacking); 6672 6673 // If there is a subsequent call, change to hanging indentation. 6674 verifyFormat( 6675 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6676 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 6677 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6678 verifyFormat( 6679 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6680 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 6681 verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6682 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6683 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6684 verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6685 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6686 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6687 } 6688 6689 TEST_F(FormatTest, WrapsTemplateDeclarations) { 6690 verifyFormat("template <typename T>\n" 6691 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6692 verifyFormat("template <typename T>\n" 6693 "// T should be one of {A, B}.\n" 6694 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 6695 verifyFormat( 6696 "template <typename T>\n" 6697 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 6698 verifyFormat("template <typename T>\n" 6699 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 6700 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 6701 verifyFormat( 6702 "template <typename T>\n" 6703 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 6704 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 6705 verifyFormat( 6706 "template <typename T>\n" 6707 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 6708 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 6709 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6710 verifyFormat("template <typename T>\n" 6711 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6712 " int aaaaaaaaaaaaaaaaaaaaaa);"); 6713 verifyFormat( 6714 "template <typename T1, typename T2 = char, typename T3 = char,\n" 6715 " typename T4 = char>\n" 6716 "void f();"); 6717 verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n" 6718 " template <typename> class cccccccccccccccccccccc,\n" 6719 " typename ddddddddddddd>\n" 6720 "class C {};"); 6721 verifyFormat( 6722 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 6723 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 6724 6725 verifyFormat("void f() {\n" 6726 " a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 6727 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" 6728 "}"); 6729 6730 verifyFormat("template <typename T> class C {};"); 6731 verifyFormat("template <typename T> void f();"); 6732 verifyFormat("template <typename T> void f() {}"); 6733 verifyFormat( 6734 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6735 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6736 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 6737 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 6738 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6739 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 6740 " bbbbbbbbbbbbbbbbbbbbbbbb);", 6741 getLLVMStyleWithColumns(72)); 6742 EXPECT_EQ("static_cast<A< //\n" 6743 " B> *>(\n" 6744 "\n" 6745 ");", 6746 format("static_cast<A<//\n" 6747 " B>*>(\n" 6748 "\n" 6749 " );")); 6750 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6751 " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); 6752 6753 FormatStyle AlwaysBreak = getLLVMStyle(); 6754 AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 6755 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 6756 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 6757 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 6758 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6759 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6760 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 6761 verifyFormat("template <template <typename> class Fooooooo,\n" 6762 " template <typename> class Baaaaaaar>\n" 6763 "struct C {};", 6764 AlwaysBreak); 6765 verifyFormat("template <typename T> // T can be A, B or C.\n" 6766 "struct C {};", 6767 AlwaysBreak); 6768 verifyFormat("template <enum E> class A {\n" 6769 "public:\n" 6770 " E *f();\n" 6771 "};"); 6772 6773 FormatStyle NeverBreak = getLLVMStyle(); 6774 NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No; 6775 verifyFormat("template <typename T> class C {};", NeverBreak); 6776 verifyFormat("template <typename T> void f();", NeverBreak); 6777 verifyFormat("template <typename T> void f() {}", NeverBreak); 6778 verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6779 "bbbbbbbbbbbbbbbbbbbb) {}", 6780 NeverBreak); 6781 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6782 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 6783 " ccccccccccccccccccccccccccccccccccccccccccccccc);", 6784 NeverBreak); 6785 verifyFormat("template <template <typename> class Fooooooo,\n" 6786 " template <typename> class Baaaaaaar>\n" 6787 "struct C {};", 6788 NeverBreak); 6789 verifyFormat("template <typename T> // T can be A, B or C.\n" 6790 "struct C {};", 6791 NeverBreak); 6792 verifyFormat("template <enum E> class A {\n" 6793 "public:\n" 6794 " E *f();\n" 6795 "};", 6796 NeverBreak); 6797 NeverBreak.PenaltyBreakTemplateDeclaration = 100; 6798 verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa " 6799 "bbbbbbbbbbbbbbbbbbbb) {}", 6800 NeverBreak); 6801 } 6802 6803 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) { 6804 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 6805 Style.ColumnLimit = 60; 6806 EXPECT_EQ("// Baseline - no comments.\n" 6807 "template <\n" 6808 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6809 "void f() {}", 6810 format("// Baseline - no comments.\n" 6811 "template <\n" 6812 " typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n" 6813 "void f() {}", 6814 Style)); 6815 6816 EXPECT_EQ("template <\n" 6817 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6818 "void f() {}", 6819 format("template <\n" 6820 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6821 "void f() {}", 6822 Style)); 6823 6824 EXPECT_EQ( 6825 "template <\n" 6826 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6827 "void f() {}", 6828 format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n" 6829 "void f() {}", 6830 Style)); 6831 6832 EXPECT_EQ( 6833 "template <\n" 6834 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6835 " // multiline\n" 6836 "void f() {}", 6837 format("template <\n" 6838 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n" 6839 " // multiline\n" 6840 "void f() {}", 6841 Style)); 6842 6843 EXPECT_EQ( 6844 "template <typename aaaaaaaaaa<\n" 6845 " bbbbbbbbbbbb>::value> // trailing loooong\n" 6846 "void f() {}", 6847 format( 6848 "template <\n" 6849 " typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n" 6850 "void f() {}", 6851 Style)); 6852 } 6853 6854 TEST_F(FormatTest, WrapsTemplateParameters) { 6855 FormatStyle Style = getLLVMStyle(); 6856 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6857 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6858 verifyFormat( 6859 "template <typename... a> struct q {};\n" 6860 "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6861 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6862 " y;", 6863 Style); 6864 Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; 6865 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6866 verifyFormat( 6867 "template <typename... a> struct r {};\n" 6868 "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n" 6869 " aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n" 6870 " y;", 6871 Style); 6872 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6873 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 6874 verifyFormat("template <typename... a> struct s {};\n" 6875 "extern s<\n" 6876 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6877 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6878 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6879 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6880 " y;", 6881 Style); 6882 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 6883 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 6884 verifyFormat("template <typename... a> struct t {};\n" 6885 "extern t<\n" 6886 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6887 "aaaaaaaaaaaaaaaaaaaaaa,\n" 6888 " aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, " 6889 "aaaaaaaaaaaaaaaaaaaaaa>\n" 6890 " y;", 6891 Style); 6892 } 6893 6894 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 6895 verifyFormat( 6896 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6897 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6898 verifyFormat( 6899 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6900 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6901 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 6902 6903 // FIXME: Should we have the extra indent after the second break? 6904 verifyFormat( 6905 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6906 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6907 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6908 6909 verifyFormat( 6910 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 6911 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 6912 6913 // Breaking at nested name specifiers is generally not desirable. 6914 verifyFormat( 6915 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6916 " aaaaaaaaaaaaaaaaaaaaaaa);"); 6917 6918 verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n" 6919 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6920 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 6921 " aaaaaaaaaaaaaaaaaaaaa);", 6922 getLLVMStyleWithColumns(74)); 6923 6924 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 6925 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6926 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 6927 } 6928 6929 TEST_F(FormatTest, UnderstandsTemplateParameters) { 6930 verifyFormat("A<int> a;"); 6931 verifyFormat("A<A<A<int>>> a;"); 6932 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 6933 verifyFormat("bool x = a < 1 || 2 > a;"); 6934 verifyFormat("bool x = 5 < f<int>();"); 6935 verifyFormat("bool x = f<int>() > 5;"); 6936 verifyFormat("bool x = 5 < a<int>::x;"); 6937 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 6938 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 6939 6940 verifyGoogleFormat("A<A<int>> a;"); 6941 verifyGoogleFormat("A<A<A<int>>> a;"); 6942 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 6943 verifyGoogleFormat("A<A<int> > a;"); 6944 verifyGoogleFormat("A<A<A<int> > > a;"); 6945 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 6946 verifyGoogleFormat("A<::A<int>> a;"); 6947 verifyGoogleFormat("A<::A> a;"); 6948 verifyGoogleFormat("A< ::A> a;"); 6949 verifyGoogleFormat("A< ::A<int> > a;"); 6950 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 6951 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 6952 EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle())); 6953 EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle())); 6954 EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };", 6955 format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle())); 6956 6957 verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp)); 6958 6959 // template closer followed by a token that starts with > or = 6960 verifyFormat("bool b = a<1> > 1;"); 6961 verifyFormat("bool b = a<1> >= 1;"); 6962 verifyFormat("int i = a<1> >> 1;"); 6963 FormatStyle Style = getLLVMStyle(); 6964 Style.SpaceBeforeAssignmentOperators = false; 6965 verifyFormat("bool b= a<1> == 1;", Style); 6966 verifyFormat("a<int> = 1;", Style); 6967 verifyFormat("a<int> >>= 1;", Style); 6968 6969 verifyFormat("test >> a >> b;"); 6970 verifyFormat("test << a >> b;"); 6971 6972 verifyFormat("f<int>();"); 6973 verifyFormat("template <typename T> void f() {}"); 6974 verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;"); 6975 verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : " 6976 "sizeof(char)>::type>;"); 6977 verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};"); 6978 verifyFormat("f(a.operator()<A>());"); 6979 verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 6980 " .template operator()<A>());", 6981 getLLVMStyleWithColumns(35)); 6982 6983 // Not template parameters. 6984 verifyFormat("return a < b && c > d;"); 6985 verifyFormat("void f() {\n" 6986 " while (a < b && c > d) {\n" 6987 " }\n" 6988 "}"); 6989 verifyFormat("template <typename... Types>\n" 6990 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 6991 6992 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 6993 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);", 6994 getLLVMStyleWithColumns(60)); 6995 verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");"); 6996 verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}"); 6997 verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <"); 6998 } 6999 7000 TEST_F(FormatTest, BitshiftOperatorWidth) { 7001 EXPECT_EQ("int a = 1 << 2; /* foo\n" 7002 " bar */", 7003 format("int a=1<<2; /* foo\n" 7004 " bar */")); 7005 7006 EXPECT_EQ("int b = 256 >> 1; /* foo\n" 7007 " bar */", 7008 format("int b =256>>1 ; /* foo\n" 7009 " bar */")); 7010 } 7011 7012 TEST_F(FormatTest, UnderstandsBinaryOperators) { 7013 verifyFormat("COMPARE(a, ==, b);"); 7014 verifyFormat("auto s = sizeof...(Ts) - 1;"); 7015 } 7016 7017 TEST_F(FormatTest, UnderstandsPointersToMembers) { 7018 verifyFormat("int A::*x;"); 7019 verifyFormat("int (S::*func)(void *);"); 7020 verifyFormat("void f() { int (S::*func)(void *); }"); 7021 verifyFormat("typedef bool *(Class::*Member)() const;"); 7022 verifyFormat("void f() {\n" 7023 " (a->*f)();\n" 7024 " a->*x;\n" 7025 " (a.*f)();\n" 7026 " ((*a).*f)();\n" 7027 " a.*x;\n" 7028 "}"); 7029 verifyFormat("void f() {\n" 7030 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7031 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 7032 "}"); 7033 verifyFormat( 7034 "(aaaaaaaaaa->*bbbbbbb)(\n" 7035 " aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 7036 FormatStyle Style = getLLVMStyle(); 7037 Style.PointerAlignment = FormatStyle::PAS_Left; 7038 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 7039 } 7040 7041 TEST_F(FormatTest, UnderstandsUnaryOperators) { 7042 verifyFormat("int a = -2;"); 7043 verifyFormat("f(-1, -2, -3);"); 7044 verifyFormat("a[-1] = 5;"); 7045 verifyFormat("int a = 5 + -2;"); 7046 verifyFormat("if (i == -1) {\n}"); 7047 verifyFormat("if (i != -1) {\n}"); 7048 verifyFormat("if (i > -1) {\n}"); 7049 verifyFormat("if (i < -1) {\n}"); 7050 verifyFormat("++(a->f());"); 7051 verifyFormat("--(a->f());"); 7052 verifyFormat("(a->f())++;"); 7053 verifyFormat("a[42]++;"); 7054 verifyFormat("if (!(a->f())) {\n}"); 7055 verifyFormat("if (!+i) {\n}"); 7056 verifyFormat("~&a;"); 7057 7058 verifyFormat("a-- > b;"); 7059 verifyFormat("b ? -a : c;"); 7060 verifyFormat("n * sizeof char16;"); 7061 verifyFormat("n * alignof char16;", getGoogleStyle()); 7062 verifyFormat("sizeof(char);"); 7063 verifyFormat("alignof(char);", getGoogleStyle()); 7064 7065 verifyFormat("return -1;"); 7066 verifyFormat("throw -1;"); 7067 verifyFormat("switch (a) {\n" 7068 "case -1:\n" 7069 " break;\n" 7070 "}"); 7071 verifyFormat("#define X -1"); 7072 verifyFormat("#define X -kConstant"); 7073 7074 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};"); 7075 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};"); 7076 7077 verifyFormat("int a = /* confusing comment */ -1;"); 7078 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 7079 verifyFormat("int a = i /* confusing comment */++;"); 7080 7081 verifyFormat("co_yield -1;"); 7082 verifyFormat("co_return -1;"); 7083 } 7084 7085 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) { 7086 verifyFormat("if (!aaaaaaaaaa( // break\n" 7087 " aaaaa)) {\n" 7088 "}"); 7089 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 7090 " aaaaa));"); 7091 verifyFormat("*aaa = aaaaaaa( // break\n" 7092 " bbbbbb);"); 7093 } 7094 7095 TEST_F(FormatTest, UnderstandsOverloadedOperators) { 7096 verifyFormat("bool operator<();"); 7097 verifyFormat("bool operator>();"); 7098 verifyFormat("bool operator=();"); 7099 verifyFormat("bool operator==();"); 7100 verifyFormat("bool operator!=();"); 7101 verifyFormat("int operator+();"); 7102 verifyFormat("int operator++();"); 7103 verifyFormat("int operator++(int) volatile noexcept;"); 7104 verifyFormat("bool operator,();"); 7105 verifyFormat("bool operator();"); 7106 verifyFormat("bool operator()();"); 7107 verifyFormat("bool operator[]();"); 7108 verifyFormat("operator bool();"); 7109 verifyFormat("operator int();"); 7110 verifyFormat("operator void *();"); 7111 verifyFormat("operator SomeType<int>();"); 7112 verifyFormat("operator SomeType<int, int>();"); 7113 verifyFormat("operator SomeType<SomeType<int>>();"); 7114 verifyFormat("void *operator new(std::size_t size);"); 7115 verifyFormat("void *operator new[](std::size_t size);"); 7116 verifyFormat("void operator delete(void *ptr);"); 7117 verifyFormat("void operator delete[](void *ptr);"); 7118 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 7119 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 7120 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n" 7121 " aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;"); 7122 7123 verifyFormat( 7124 "ostream &operator<<(ostream &OutputStream,\n" 7125 " SomeReallyLongType WithSomeReallyLongValue);"); 7126 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 7127 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 7128 " return left.group < right.group;\n" 7129 "}"); 7130 verifyFormat("SomeType &operator=(const SomeType &S);"); 7131 verifyFormat("f.template operator()<int>();"); 7132 7133 verifyGoogleFormat("operator void*();"); 7134 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 7135 verifyGoogleFormat("operator ::A();"); 7136 7137 verifyFormat("using A::operator+;"); 7138 verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n" 7139 "int i;"); 7140 } 7141 7142 TEST_F(FormatTest, UnderstandsFunctionRefQualification) { 7143 verifyFormat("Deleted &operator=(const Deleted &) & = default;"); 7144 verifyFormat("Deleted &operator=(const Deleted &) && = delete;"); 7145 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;"); 7146 verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;"); 7147 verifyFormat("Deleted &operator=(const Deleted &) &;"); 7148 verifyFormat("Deleted &operator=(const Deleted &) &&;"); 7149 verifyFormat("SomeType MemberFunction(const Deleted &) &;"); 7150 verifyFormat("SomeType MemberFunction(const Deleted &) &&;"); 7151 verifyFormat("SomeType MemberFunction(const Deleted &) && {}"); 7152 verifyFormat("SomeType MemberFunction(const Deleted &) && final {}"); 7153 verifyFormat("SomeType MemberFunction(const Deleted &) && override {}"); 7154 verifyFormat("void Fn(T const &) const &;"); 7155 verifyFormat("void Fn(T const volatile &&) const volatile &&;"); 7156 verifyFormat("template <typename T>\n" 7157 "void F(T) && = delete;", 7158 getGoogleStyle()); 7159 7160 FormatStyle AlignLeft = getLLVMStyle(); 7161 AlignLeft.PointerAlignment = FormatStyle::PAS_Left; 7162 verifyFormat("void A::b() && {}", AlignLeft); 7163 verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft); 7164 verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;", 7165 AlignLeft); 7166 verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft); 7167 verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft); 7168 verifyFormat("auto Function(T t) & -> void {}", AlignLeft); 7169 verifyFormat("auto Function(T... t) & -> void {}", AlignLeft); 7170 verifyFormat("auto Function(T) & -> void {}", AlignLeft); 7171 verifyFormat("auto Function(T) & -> void;", AlignLeft); 7172 verifyFormat("void Fn(T const&) const&;", AlignLeft); 7173 verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft); 7174 7175 FormatStyle Spaces = getLLVMStyle(); 7176 Spaces.SpacesInCStyleCastParentheses = true; 7177 verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces); 7178 verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces); 7179 verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces); 7180 verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces); 7181 7182 Spaces.SpacesInCStyleCastParentheses = false; 7183 Spaces.SpacesInParentheses = true; 7184 verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces); 7185 verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;", 7186 Spaces); 7187 verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces); 7188 verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces); 7189 7190 FormatStyle BreakTemplate = getLLVMStyle(); 7191 BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 7192 7193 verifyFormat("struct f {\n" 7194 " template <class T>\n" 7195 " int &foo(const std::string &str) &noexcept {}\n" 7196 "};", 7197 BreakTemplate); 7198 7199 verifyFormat("struct f {\n" 7200 " template <class T>\n" 7201 " int &foo(const std::string &str) &&noexcept {}\n" 7202 "};", 7203 BreakTemplate); 7204 7205 verifyFormat("struct f {\n" 7206 " template <class T>\n" 7207 " int &foo(const std::string &str) const &noexcept {}\n" 7208 "};", 7209 BreakTemplate); 7210 7211 verifyFormat("struct f {\n" 7212 " template <class T>\n" 7213 " int &foo(const std::string &str) const &noexcept {}\n" 7214 "};", 7215 BreakTemplate); 7216 7217 verifyFormat("struct f {\n" 7218 " template <class T>\n" 7219 " auto foo(const std::string &str) &&noexcept -> int & {}\n" 7220 "};", 7221 BreakTemplate); 7222 7223 FormatStyle AlignLeftBreakTemplate = getLLVMStyle(); 7224 AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations = 7225 FormatStyle::BTDS_Yes; 7226 AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left; 7227 7228 verifyFormat("struct f {\n" 7229 " template <class T>\n" 7230 " int& foo(const std::string& str) & noexcept {}\n" 7231 "};", 7232 AlignLeftBreakTemplate); 7233 7234 verifyFormat("struct f {\n" 7235 " template <class T>\n" 7236 " int& foo(const std::string& str) && noexcept {}\n" 7237 "};", 7238 AlignLeftBreakTemplate); 7239 7240 verifyFormat("struct f {\n" 7241 " template <class T>\n" 7242 " int& foo(const std::string& str) const& noexcept {}\n" 7243 "};", 7244 AlignLeftBreakTemplate); 7245 7246 verifyFormat("struct f {\n" 7247 " template <class T>\n" 7248 " int& foo(const std::string& str) const&& noexcept {}\n" 7249 "};", 7250 AlignLeftBreakTemplate); 7251 7252 verifyFormat("struct f {\n" 7253 " template <class T>\n" 7254 " auto foo(const std::string& str) && noexcept -> int& {}\n" 7255 "};", 7256 AlignLeftBreakTemplate); 7257 7258 // The `&` in `Type&` should not be confused with a trailing `&` of 7259 // DEPRECATED(reason) member function. 7260 verifyFormat("struct f {\n" 7261 " template <class T>\n" 7262 " DEPRECATED(reason)\n" 7263 " Type &foo(arguments) {}\n" 7264 "};", 7265 BreakTemplate); 7266 7267 verifyFormat("struct f {\n" 7268 " template <class T>\n" 7269 " DEPRECATED(reason)\n" 7270 " Type& foo(arguments) {}\n" 7271 "};", 7272 AlignLeftBreakTemplate); 7273 7274 verifyFormat("void (*foopt)(int) = &func;"); 7275 } 7276 7277 TEST_F(FormatTest, UnderstandsNewAndDelete) { 7278 verifyFormat("void f() {\n" 7279 " A *a = new A;\n" 7280 " A *a = new (placement) A;\n" 7281 " delete a;\n" 7282 " delete (A *)a;\n" 7283 "}"); 7284 verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7285 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7286 verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7287 " new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n" 7288 " typename aaaaaaaaaaaaaaaaaaaaaaaa();"); 7289 verifyFormat("delete[] h->p;"); 7290 } 7291 7292 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 7293 verifyFormat("int *f(int *a) {}"); 7294 verifyFormat("int main(int argc, char **argv) {}"); 7295 verifyFormat("Test::Test(int b) : a(b * b) {}"); 7296 verifyIndependentOfContext("f(a, *a);"); 7297 verifyFormat("void g() { f(*a); }"); 7298 verifyIndependentOfContext("int a = b * 10;"); 7299 verifyIndependentOfContext("int a = 10 * b;"); 7300 verifyIndependentOfContext("int a = b * c;"); 7301 verifyIndependentOfContext("int a += b * c;"); 7302 verifyIndependentOfContext("int a -= b * c;"); 7303 verifyIndependentOfContext("int a *= b * c;"); 7304 verifyIndependentOfContext("int a /= b * c;"); 7305 verifyIndependentOfContext("int a = *b;"); 7306 verifyIndependentOfContext("int a = *b * c;"); 7307 verifyIndependentOfContext("int a = b * *c;"); 7308 verifyIndependentOfContext("int a = b * (10);"); 7309 verifyIndependentOfContext("S << b * (10);"); 7310 verifyIndependentOfContext("return 10 * b;"); 7311 verifyIndependentOfContext("return *b * *c;"); 7312 verifyIndependentOfContext("return a & ~b;"); 7313 verifyIndependentOfContext("f(b ? *c : *d);"); 7314 verifyIndependentOfContext("int a = b ? *c : *d;"); 7315 verifyIndependentOfContext("*b = a;"); 7316 verifyIndependentOfContext("a * ~b;"); 7317 verifyIndependentOfContext("a * !b;"); 7318 verifyIndependentOfContext("a * +b;"); 7319 verifyIndependentOfContext("a * -b;"); 7320 verifyIndependentOfContext("a * ++b;"); 7321 verifyIndependentOfContext("a * --b;"); 7322 verifyIndependentOfContext("a[4] * b;"); 7323 verifyIndependentOfContext("a[a * a] = 1;"); 7324 verifyIndependentOfContext("f() * b;"); 7325 verifyIndependentOfContext("a * [self dostuff];"); 7326 verifyIndependentOfContext("int x = a * (a + b);"); 7327 verifyIndependentOfContext("(a *)(a + b);"); 7328 verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;"); 7329 verifyIndependentOfContext("int *pa = (int *)&a;"); 7330 verifyIndependentOfContext("return sizeof(int **);"); 7331 verifyIndependentOfContext("return sizeof(int ******);"); 7332 verifyIndependentOfContext("return (int **&)a;"); 7333 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 7334 verifyFormat("void f(Type (*parameter)[10]) {}"); 7335 verifyFormat("void f(Type (¶meter)[10]) {}"); 7336 verifyGoogleFormat("return sizeof(int**);"); 7337 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 7338 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 7339 verifyFormat("auto a = [](int **&, int ***) {};"); 7340 verifyFormat("auto PointerBinding = [](const char *S) {};"); 7341 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 7342 verifyFormat("[](const decltype(*a) &value) {}"); 7343 verifyFormat("decltype(a * b) F();"); 7344 verifyFormat("#define MACRO() [](A *a) { return 1; }"); 7345 verifyFormat("Constructor() : member([](A *a, B *b) {}) {}"); 7346 verifyIndependentOfContext("typedef void (*f)(int *a);"); 7347 verifyIndependentOfContext("int i{a * b};"); 7348 verifyIndependentOfContext("aaa && aaa->f();"); 7349 verifyIndependentOfContext("int x = ~*p;"); 7350 verifyFormat("Constructor() : a(a), area(width * height) {}"); 7351 verifyFormat("Constructor() : a(a), area(a, width * height) {}"); 7352 verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}"); 7353 verifyFormat("void f() { f(a, c * d); }"); 7354 verifyFormat("void f() { f(new a(), c * d); }"); 7355 verifyFormat("void f(const MyOverride &override);"); 7356 verifyFormat("void f(const MyFinal &final);"); 7357 verifyIndependentOfContext("bool a = f() && override.f();"); 7358 verifyIndependentOfContext("bool a = f() && final.f();"); 7359 7360 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 7361 7362 verifyIndependentOfContext("A<int *> a;"); 7363 verifyIndependentOfContext("A<int **> a;"); 7364 verifyIndependentOfContext("A<int *, int *> a;"); 7365 verifyIndependentOfContext("A<int *[]> a;"); 7366 verifyIndependentOfContext( 7367 "const char *const p = reinterpret_cast<const char *const>(q);"); 7368 verifyIndependentOfContext("A<int **, int **> a;"); 7369 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 7370 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 7371 verifyFormat("for (; a && b;) {\n}"); 7372 verifyFormat("bool foo = true && [] { return false; }();"); 7373 7374 verifyFormat( 7375 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7376 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7377 7378 verifyGoogleFormat("int const* a = &b;"); 7379 verifyGoogleFormat("**outparam = 1;"); 7380 verifyGoogleFormat("*outparam = a * b;"); 7381 verifyGoogleFormat("int main(int argc, char** argv) {}"); 7382 verifyGoogleFormat("A<int*> a;"); 7383 verifyGoogleFormat("A<int**> a;"); 7384 verifyGoogleFormat("A<int*, int*> a;"); 7385 verifyGoogleFormat("A<int**, int**> a;"); 7386 verifyGoogleFormat("f(b ? *c : *d);"); 7387 verifyGoogleFormat("int a = b ? *c : *d;"); 7388 verifyGoogleFormat("Type* t = **x;"); 7389 verifyGoogleFormat("Type* t = *++*x;"); 7390 verifyGoogleFormat("*++*x;"); 7391 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 7392 verifyGoogleFormat("Type* t = x++ * y;"); 7393 verifyGoogleFormat( 7394 "const char* const p = reinterpret_cast<const char* const>(q);"); 7395 verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);"); 7396 verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);"); 7397 verifyGoogleFormat("template <typename T>\n" 7398 "void f(int i = 0, SomeType** temps = NULL);"); 7399 7400 FormatStyle Left = getLLVMStyle(); 7401 Left.PointerAlignment = FormatStyle::PAS_Left; 7402 verifyFormat("x = *a(x) = *a(y);", Left); 7403 verifyFormat("for (;; *a = b) {\n}", Left); 7404 verifyFormat("return *this += 1;", Left); 7405 verifyFormat("throw *x;", Left); 7406 verifyFormat("delete *x;", Left); 7407 verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left); 7408 verifyFormat("[](const decltype(*a)* ptr) {}", Left); 7409 verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left); 7410 verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left); 7411 verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left); 7412 verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left); 7413 7414 verifyIndependentOfContext("a = *(x + y);"); 7415 verifyIndependentOfContext("a = &(x + y);"); 7416 verifyIndependentOfContext("*(x + y).call();"); 7417 verifyIndependentOfContext("&(x + y)->call();"); 7418 verifyFormat("void f() { &(*I).first; }"); 7419 7420 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 7421 verifyFormat( 7422 "int *MyValues = {\n" 7423 " *A, // Operator detection might be confused by the '{'\n" 7424 " *BB // Operator detection might be confused by previous comment\n" 7425 "};"); 7426 7427 verifyIndependentOfContext("if (int *a = &b)"); 7428 verifyIndependentOfContext("if (int &a = *b)"); 7429 verifyIndependentOfContext("if (a & b[i])"); 7430 verifyIndependentOfContext("if constexpr (a & b[i])"); 7431 verifyIndependentOfContext("if CONSTEXPR (a & b[i])"); 7432 verifyIndependentOfContext("if (a * (b * c))"); 7433 verifyIndependentOfContext("if constexpr (a * (b * c))"); 7434 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))"); 7435 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 7436 verifyIndependentOfContext("if (*b[i])"); 7437 verifyIndependentOfContext("if (int *a = (&b))"); 7438 verifyIndependentOfContext("while (int *a = &b)"); 7439 verifyIndependentOfContext("while (a * (b * c))"); 7440 verifyIndependentOfContext("size = sizeof *a;"); 7441 verifyIndependentOfContext("if (a && (b = c))"); 7442 verifyFormat("void f() {\n" 7443 " for (const int &v : Values) {\n" 7444 " }\n" 7445 "}"); 7446 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 7447 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 7448 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 7449 7450 verifyFormat("#define A (!a * b)"); 7451 verifyFormat("#define MACRO \\\n" 7452 " int *i = a * b; \\\n" 7453 " void f(a *b);", 7454 getLLVMStyleWithColumns(19)); 7455 7456 verifyIndependentOfContext("A = new SomeType *[Length];"); 7457 verifyIndependentOfContext("A = new SomeType *[Length]();"); 7458 verifyIndependentOfContext("T **t = new T *;"); 7459 verifyIndependentOfContext("T **t = new T *();"); 7460 verifyGoogleFormat("A = new SomeType*[Length]();"); 7461 verifyGoogleFormat("A = new SomeType*[Length];"); 7462 verifyGoogleFormat("T** t = new T*;"); 7463 verifyGoogleFormat("T** t = new T*();"); 7464 7465 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 7466 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 7467 verifyFormat("template <bool a, bool b> " 7468 "typename t::if<x && y>::type f() {}"); 7469 verifyFormat("template <int *y> f() {}"); 7470 verifyFormat("vector<int *> v;"); 7471 verifyFormat("vector<int *const> v;"); 7472 verifyFormat("vector<int *const **const *> v;"); 7473 verifyFormat("vector<int *volatile> v;"); 7474 verifyFormat("vector<a * b> v;"); 7475 verifyFormat("foo<b && false>();"); 7476 verifyFormat("foo<b & 1>();"); 7477 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 7478 verifyFormat( 7479 "template <class T, class = typename std::enable_if<\n" 7480 " std::is_integral<T>::value &&\n" 7481 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 7482 "void F();", 7483 getLLVMStyleWithColumns(70)); 7484 verifyFormat("template <class T,\n" 7485 " class = typename std::enable_if<\n" 7486 " std::is_integral<T>::value &&\n" 7487 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 7488 " class U>\n" 7489 "void F();", 7490 getLLVMStyleWithColumns(70)); 7491 verifyFormat( 7492 "template <class T,\n" 7493 " class = typename ::std::enable_if<\n" 7494 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 7495 "void F();", 7496 getGoogleStyleWithColumns(68)); 7497 7498 verifyIndependentOfContext("MACRO(int *i);"); 7499 verifyIndependentOfContext("MACRO(auto *a);"); 7500 verifyIndependentOfContext("MACRO(const A *a);"); 7501 verifyIndependentOfContext("MACRO(A *const a);"); 7502 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 7503 verifyFormat("void f() { f(float{1}, a * a); }"); 7504 // FIXME: Is there a way to make this work? 7505 // verifyIndependentOfContext("MACRO(A *a);"); 7506 7507 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 7508 verifyFormat("return options != nullptr && operator==(*options);"); 7509 7510 EXPECT_EQ("#define OP(x) \\\n" 7511 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7512 " return s << a.DebugString(); \\\n" 7513 " }", 7514 format("#define OP(x) \\\n" 7515 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7516 " return s << a.DebugString(); \\\n" 7517 " }", 7518 getLLVMStyleWithColumns(50))); 7519 7520 // FIXME: We cannot handle this case yet; we might be able to figure out that 7521 // foo<x> d > v; doesn't make sense. 7522 verifyFormat("foo<a<b && c> d> v;"); 7523 7524 FormatStyle PointerMiddle = getLLVMStyle(); 7525 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7526 verifyFormat("delete *x;", PointerMiddle); 7527 verifyFormat("int * x;", PointerMiddle); 7528 verifyFormat("int *[] x;", PointerMiddle); 7529 verifyFormat("template <int * y> f() {}", PointerMiddle); 7530 verifyFormat("int * f(int * a) {}", PointerMiddle); 7531 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7532 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7533 verifyFormat("A<int *> a;", PointerMiddle); 7534 verifyFormat("A<int **> a;", PointerMiddle); 7535 verifyFormat("A<int *, int *> a;", PointerMiddle); 7536 verifyFormat("A<int *[]> a;", PointerMiddle); 7537 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7538 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7539 verifyFormat("T ** t = new T *;", PointerMiddle); 7540 7541 // Member function reference qualifiers aren't binary operators. 7542 verifyFormat("string // break\n" 7543 "operator()() & {}"); 7544 verifyFormat("string // break\n" 7545 "operator()() && {}"); 7546 verifyGoogleFormat("template <typename T>\n" 7547 "auto x() & -> int {}"); 7548 } 7549 7550 TEST_F(FormatTest, UnderstandsAttributes) { 7551 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7552 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7553 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7554 FormatStyle AfterType = getLLVMStyle(); 7555 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7556 verifyFormat("__attribute__((nodebug)) void\n" 7557 "foo() {}\n", 7558 AfterType); 7559 } 7560 7561 TEST_F(FormatTest, UnderstandsSquareAttributes) { 7562 verifyFormat("SomeType s [[unused]] (InitValue);"); 7563 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 7564 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 7565 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 7566 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 7567 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7568 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7569 7570 // Make sure we do not mistake attributes for array subscripts. 7571 verifyFormat("int a() {}\n" 7572 "[[unused]] int b() {}\n"); 7573 verifyFormat("NSArray *arr;\n" 7574 "arr[[Foo() bar]];"); 7575 7576 // On the other hand, we still need to correctly find array subscripts. 7577 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 7578 7579 // Make sure that we do not mistake Objective-C method inside array literals 7580 // as attributes, even if those method names are also keywords. 7581 verifyFormat("@[ [foo bar] ];"); 7582 verifyFormat("@[ [NSArray class] ];"); 7583 verifyFormat("@[ [foo enum] ];"); 7584 7585 // Make sure we do not parse attributes as lambda introducers. 7586 FormatStyle MultiLineFunctions = getLLVMStyle(); 7587 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7588 verifyFormat("[[unused]] int b() {\n" 7589 " return 42;\n" 7590 "}\n", 7591 MultiLineFunctions); 7592 } 7593 7594 TEST_F(FormatTest, UnderstandsEllipsis) { 7595 verifyFormat("int printf(const char *fmt, ...);"); 7596 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 7597 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 7598 7599 FormatStyle PointersLeft = getLLVMStyle(); 7600 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 7601 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 7602 } 7603 7604 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 7605 EXPECT_EQ("int *a;\n" 7606 "int *a;\n" 7607 "int *a;", 7608 format("int *a;\n" 7609 "int* a;\n" 7610 "int *a;", 7611 getGoogleStyle())); 7612 EXPECT_EQ("int* a;\n" 7613 "int* a;\n" 7614 "int* a;", 7615 format("int* a;\n" 7616 "int* a;\n" 7617 "int *a;", 7618 getGoogleStyle())); 7619 EXPECT_EQ("int *a;\n" 7620 "int *a;\n" 7621 "int *a;", 7622 format("int *a;\n" 7623 "int * a;\n" 7624 "int * a;", 7625 getGoogleStyle())); 7626 EXPECT_EQ("auto x = [] {\n" 7627 " int *a;\n" 7628 " int *a;\n" 7629 " int *a;\n" 7630 "};", 7631 format("auto x=[]{int *a;\n" 7632 "int * a;\n" 7633 "int * a;};", 7634 getGoogleStyle())); 7635 } 7636 7637 TEST_F(FormatTest, UnderstandsRvalueReferences) { 7638 verifyFormat("int f(int &&a) {}"); 7639 verifyFormat("int f(int a, char &&b) {}"); 7640 verifyFormat("void f() { int &&a = b; }"); 7641 verifyGoogleFormat("int f(int a, char&& b) {}"); 7642 verifyGoogleFormat("void f() { int&& a = b; }"); 7643 7644 verifyIndependentOfContext("A<int &&> a;"); 7645 verifyIndependentOfContext("A<int &&, int &&> a;"); 7646 verifyGoogleFormat("A<int&&> a;"); 7647 verifyGoogleFormat("A<int&&, int&&> a;"); 7648 7649 // Not rvalue references: 7650 verifyFormat("template <bool B, bool C> class A {\n" 7651 " static_assert(B && C, \"Something is wrong\");\n" 7652 "};"); 7653 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 7654 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 7655 verifyFormat("#define A(a, b) (a && b)"); 7656 } 7657 7658 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 7659 verifyFormat("void f() {\n" 7660 " x[aaaaaaaaa -\n" 7661 " b] = 23;\n" 7662 "}", 7663 getLLVMStyleWithColumns(15)); 7664 } 7665 7666 TEST_F(FormatTest, FormatsCasts) { 7667 verifyFormat("Type *A = static_cast<Type *>(P);"); 7668 verifyFormat("Type *A = (Type *)P;"); 7669 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7670 verifyFormat("int a = (int)(2.0f);"); 7671 verifyFormat("int a = (int)2.0f;"); 7672 verifyFormat("x[(int32)y];"); 7673 verifyFormat("x = (int32)y;"); 7674 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7675 verifyFormat("int a = (int)*b;"); 7676 verifyFormat("int a = (int)2.0f;"); 7677 verifyFormat("int a = (int)~0;"); 7678 verifyFormat("int a = (int)++a;"); 7679 verifyFormat("int a = (int)sizeof(int);"); 7680 verifyFormat("int a = (int)+2;"); 7681 verifyFormat("my_int a = (my_int)2.0f;"); 7682 verifyFormat("my_int a = (my_int)sizeof(int);"); 7683 verifyFormat("return (my_int)aaa;"); 7684 verifyFormat("#define x ((int)-1)"); 7685 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7686 verifyFormat("#define p(q) ((int *)&q)"); 7687 verifyFormat("fn(a)(b) + 1;"); 7688 7689 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7690 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7691 verifyFormat("my_int a = (my_int)~0;"); 7692 verifyFormat("my_int a = (my_int)++a;"); 7693 verifyFormat("my_int a = (my_int)-2;"); 7694 verifyFormat("my_int a = (my_int)1;"); 7695 verifyFormat("my_int a = (my_int *)1;"); 7696 verifyFormat("my_int a = (const my_int)-1;"); 7697 verifyFormat("my_int a = (const my_int *)-1;"); 7698 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7699 verifyFormat("my_int a = (ns::my_int)-2;"); 7700 verifyFormat("case (my_int)ONE:"); 7701 verifyFormat("auto x = (X)this;"); 7702 // Casts in Obj-C style calls used to not be recognized as such. 7703 verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle()); 7704 7705 // FIXME: single value wrapped with paren will be treated as cast. 7706 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7707 7708 verifyFormat("{ (void)F; }"); 7709 7710 // Don't break after a cast's 7711 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7712 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7713 " bbbbbbbbbbbbbbbbbbbbbb);"); 7714 7715 // These are not casts. 7716 verifyFormat("void f(int *) {}"); 7717 verifyFormat("f(foo)->b;"); 7718 verifyFormat("f(foo).b;"); 7719 verifyFormat("f(foo)(b);"); 7720 verifyFormat("f(foo)[b];"); 7721 verifyFormat("[](foo) { return 4; }(bar);"); 7722 verifyFormat("(*funptr)(foo)[4];"); 7723 verifyFormat("funptrs[4](foo)[4];"); 7724 verifyFormat("void f(int *);"); 7725 verifyFormat("void f(int *) = 0;"); 7726 verifyFormat("void f(SmallVector<int>) {}"); 7727 verifyFormat("void f(SmallVector<int>);"); 7728 verifyFormat("void f(SmallVector<int>) = 0;"); 7729 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7730 verifyFormat("int a = sizeof(int) * b;"); 7731 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7732 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7733 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7734 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7735 7736 // These are not casts, but at some point were confused with casts. 7737 verifyFormat("virtual void foo(int *) override;"); 7738 verifyFormat("virtual void foo(char &) const;"); 7739 verifyFormat("virtual void foo(int *a, char *) const;"); 7740 verifyFormat("int a = sizeof(int *) + b;"); 7741 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7742 verifyFormat("bool b = f(g<int>) && c;"); 7743 verifyFormat("typedef void (*f)(int i) func;"); 7744 verifyFormat("void operator++(int) noexcept;"); 7745 verifyFormat("void operator++(int &) noexcept;"); 7746 verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t " 7747 "&) noexcept;"); 7748 verifyFormat( 7749 "void operator delete(std::size_t, const std::nothrow_t &) noexcept;"); 7750 verifyFormat("void operator delete(const std::nothrow_t &) noexcept;"); 7751 verifyFormat("void operator delete(std::nothrow_t &) noexcept;"); 7752 verifyFormat("void operator delete(nothrow_t &) noexcept;"); 7753 verifyFormat("void operator delete(foo &) noexcept;"); 7754 verifyFormat("void operator delete(foo) noexcept;"); 7755 verifyFormat("void operator delete(int) noexcept;"); 7756 verifyFormat("void operator delete(int &) noexcept;"); 7757 verifyFormat("void operator delete(int &) volatile noexcept;"); 7758 verifyFormat("void operator delete(int &) const"); 7759 verifyFormat("void operator delete(int &) = default"); 7760 verifyFormat("void operator delete(int &) = delete"); 7761 verifyFormat("void operator delete(int &) [[noreturn]]"); 7762 verifyFormat("void operator delete(int &) throw();"); 7763 verifyFormat("void operator delete(int &) throw(int);"); 7764 verifyFormat("auto operator delete(int &) -> int;"); 7765 verifyFormat("auto operator delete(int &) override"); 7766 verifyFormat("auto operator delete(int &) final"); 7767 7768 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7769 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7770 // FIXME: The indentation here is not ideal. 7771 verifyFormat( 7772 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7773 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7774 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7775 } 7776 7777 TEST_F(FormatTest, FormatsFunctionTypes) { 7778 verifyFormat("A<bool()> a;"); 7779 verifyFormat("A<SomeType()> a;"); 7780 verifyFormat("A<void (*)(int, std::string)> a;"); 7781 verifyFormat("A<void *(int)>;"); 7782 verifyFormat("void *(*a)(int *, SomeType *);"); 7783 verifyFormat("int (*func)(void *);"); 7784 verifyFormat("void f() { int (*func)(void *); }"); 7785 verifyFormat("template <class CallbackClass>\n" 7786 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7787 7788 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7789 verifyGoogleFormat("void* (*a)(int);"); 7790 verifyGoogleFormat( 7791 "template <class CallbackClass>\n" 7792 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7793 7794 // Other constructs can look somewhat like function types: 7795 verifyFormat("A<sizeof(*x)> a;"); 7796 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7797 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7798 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7799 verifyFormat("int x = f(&h)();"); 7800 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7801 verifyFormat("std::function<\n" 7802 " LooooooooooongTemplatedType<\n" 7803 " SomeType>*(\n" 7804 " LooooooooooooooooongType type)>\n" 7805 " function;", 7806 getGoogleStyleWithColumns(40)); 7807 } 7808 7809 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7810 verifyFormat("A (*foo_)[6];"); 7811 verifyFormat("vector<int> (*foo_)[6];"); 7812 } 7813 7814 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7815 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7816 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7817 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7818 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7819 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7820 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7821 7822 // Different ways of ()-initializiation. 7823 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7824 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7825 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7826 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7827 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7828 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7829 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7830 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7831 7832 // Lambdas should not confuse the variable declaration heuristic. 7833 verifyFormat("LooooooooooooooooongType\n" 7834 " variable(nullptr, [](A *a) {});", 7835 getLLVMStyleWithColumns(40)); 7836 } 7837 7838 TEST_F(FormatTest, BreaksLongDeclarations) { 7839 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7840 " AnotherNameForTheLongType;"); 7841 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7842 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7843 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7844 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7845 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7846 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7847 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7848 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7849 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7850 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7851 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7852 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7853 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7854 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7855 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7856 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7857 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7858 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7859 FormatStyle Indented = getLLVMStyle(); 7860 Indented.IndentWrappedFunctionNames = true; 7861 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7862 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7863 Indented); 7864 verifyFormat( 7865 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7866 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7867 Indented); 7868 verifyFormat( 7869 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7870 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7871 Indented); 7872 verifyFormat( 7873 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7874 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7875 Indented); 7876 7877 // FIXME: Without the comment, this breaks after "(". 7878 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7879 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7880 getGoogleStyle()); 7881 7882 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7883 " int LoooooooooooooooooooongParam2) {}"); 7884 verifyFormat( 7885 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7886 " SourceLocation L, IdentifierIn *II,\n" 7887 " Type *T) {}"); 7888 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7889 "ReallyReaaallyLongFunctionName(\n" 7890 " const std::string &SomeParameter,\n" 7891 " const SomeType<string, SomeOtherTemplateParameter>\n" 7892 " &ReallyReallyLongParameterName,\n" 7893 " const SomeType<string, SomeOtherTemplateParameter>\n" 7894 " &AnotherLongParameterName) {}"); 7895 verifyFormat("template <typename A>\n" 7896 "SomeLoooooooooooooooooooooongType<\n" 7897 " typename some_namespace::SomeOtherType<A>::Type>\n" 7898 "Function() {}"); 7899 7900 verifyGoogleFormat( 7901 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7902 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7903 verifyGoogleFormat( 7904 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7905 " SourceLocation L) {}"); 7906 verifyGoogleFormat( 7907 "some_namespace::LongReturnType\n" 7908 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7909 " int first_long_parameter, int second_parameter) {}"); 7910 7911 verifyGoogleFormat("template <typename T>\n" 7912 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7913 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7914 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7915 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7916 7917 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7918 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7919 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7920 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7921 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7922 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 7923 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7924 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 7925 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 7926 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7927 7928 verifyFormat("template <typename T> // Templates on own line.\n" 7929 "static int // Some comment.\n" 7930 "MyFunction(int a);", 7931 getLLVMStyle()); 7932 } 7933 7934 TEST_F(FormatTest, FormatsArrays) { 7935 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7936 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 7937 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 7938 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 7939 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 7940 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 7941 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7942 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7943 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7944 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 7945 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7946 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7947 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7948 verifyFormat( 7949 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 7950 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7951 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 7952 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 7953 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7954 7955 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 7956 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 7957 verifyFormat( 7958 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 7959 " .aaaaaaa[0]\n" 7960 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7961 verifyFormat("a[::b::c];"); 7962 7963 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 7964 7965 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 7966 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 7967 } 7968 7969 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 7970 verifyFormat("(a)->b();"); 7971 verifyFormat("--a;"); 7972 } 7973 7974 TEST_F(FormatTest, HandlesIncludeDirectives) { 7975 verifyFormat("#include <string>\n" 7976 "#include <a/b/c.h>\n" 7977 "#include \"a/b/string\"\n" 7978 "#include \"string.h\"\n" 7979 "#include \"string.h\"\n" 7980 "#include <a-a>\n" 7981 "#include < path with space >\n" 7982 "#include_next <test.h>" 7983 "#include \"abc.h\" // this is included for ABC\n" 7984 "#include \"some long include\" // with a comment\n" 7985 "#include \"some very long include path\"\n" 7986 "#include <some/very/long/include/path>\n", 7987 getLLVMStyleWithColumns(35)); 7988 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 7989 EXPECT_EQ("#include <a>", format("#include<a>")); 7990 7991 verifyFormat("#import <string>"); 7992 verifyFormat("#import <a/b/c.h>"); 7993 verifyFormat("#import \"a/b/string\""); 7994 verifyFormat("#import \"string.h\""); 7995 verifyFormat("#import \"string.h\""); 7996 verifyFormat("#if __has_include(<strstream>)\n" 7997 "#include <strstream>\n" 7998 "#endif"); 7999 8000 verifyFormat("#define MY_IMPORT <a/b>"); 8001 8002 verifyFormat("#if __has_include(<a/b>)"); 8003 verifyFormat("#if __has_include_next(<a/b>)"); 8004 verifyFormat("#define F __has_include(<a/b>)"); 8005 verifyFormat("#define F __has_include_next(<a/b>)"); 8006 8007 // Protocol buffer definition or missing "#". 8008 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 8009 getLLVMStyleWithColumns(30)); 8010 8011 FormatStyle Style = getLLVMStyle(); 8012 Style.AlwaysBreakBeforeMultilineStrings = true; 8013 Style.ColumnLimit = 0; 8014 verifyFormat("#import \"abc.h\"", Style); 8015 8016 // But 'import' might also be a regular C++ namespace. 8017 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8018 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 8019 } 8020 8021 //===----------------------------------------------------------------------===// 8022 // Error recovery tests. 8023 //===----------------------------------------------------------------------===// 8024 8025 TEST_F(FormatTest, IncompleteParameterLists) { 8026 FormatStyle NoBinPacking = getLLVMStyle(); 8027 NoBinPacking.BinPackParameters = false; 8028 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 8029 " double *min_x,\n" 8030 " double *max_x,\n" 8031 " double *min_y,\n" 8032 " double *max_y,\n" 8033 " double *min_z,\n" 8034 " double *max_z, ) {}", 8035 NoBinPacking); 8036 } 8037 8038 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 8039 verifyFormat("void f() { return; }\n42"); 8040 verifyFormat("void f() {\n" 8041 " if (0)\n" 8042 " return;\n" 8043 "}\n" 8044 "42"); 8045 verifyFormat("void f() { return }\n42"); 8046 verifyFormat("void f() {\n" 8047 " if (0)\n" 8048 " return\n" 8049 "}\n" 8050 "42"); 8051 } 8052 8053 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 8054 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 8055 EXPECT_EQ("void f() {\n" 8056 " if (a)\n" 8057 " return\n" 8058 "}", 8059 format("void f ( ) { if ( a ) return }")); 8060 EXPECT_EQ("namespace N {\n" 8061 "void f()\n" 8062 "}", 8063 format("namespace N { void f() }")); 8064 EXPECT_EQ("namespace N {\n" 8065 "void f() {}\n" 8066 "void g()\n" 8067 "} // namespace N", 8068 format("namespace N { void f( ) { } void g( ) }")); 8069 } 8070 8071 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 8072 verifyFormat("int aaaaaaaa =\n" 8073 " // Overlylongcomment\n" 8074 " b;", 8075 getLLVMStyleWithColumns(20)); 8076 verifyFormat("function(\n" 8077 " ShortArgument,\n" 8078 " LoooooooooooongArgument);\n", 8079 getLLVMStyleWithColumns(20)); 8080 } 8081 8082 TEST_F(FormatTest, IncorrectAccessSpecifier) { 8083 verifyFormat("public:"); 8084 verifyFormat("class A {\n" 8085 "public\n" 8086 " void f() {}\n" 8087 "};"); 8088 verifyFormat("public\n" 8089 "int qwerty;"); 8090 verifyFormat("public\n" 8091 "B {}"); 8092 verifyFormat("public\n" 8093 "{}"); 8094 verifyFormat("public\n" 8095 "B { int x; }"); 8096 } 8097 8098 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 8099 verifyFormat("{"); 8100 verifyFormat("#})"); 8101 verifyNoCrash("(/**/[:!] ?[)."); 8102 } 8103 8104 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 8105 // Found by oss-fuzz: 8106 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 8107 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 8108 Style.ColumnLimit = 60; 8109 verifyNoCrash( 8110 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 8111 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 8112 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 8113 Style); 8114 } 8115 8116 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 8117 verifyFormat("do {\n}"); 8118 verifyFormat("do {\n}\n" 8119 "f();"); 8120 verifyFormat("do {\n}\n" 8121 "wheeee(fun);"); 8122 verifyFormat("do {\n" 8123 " f();\n" 8124 "}"); 8125 } 8126 8127 TEST_F(FormatTest, IncorrectCodeMissingParens) { 8128 verifyFormat("if {\n foo;\n foo();\n}"); 8129 verifyFormat("switch {\n foo;\n foo();\n}"); 8130 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 8131 verifyFormat("while {\n foo;\n foo();\n}"); 8132 verifyFormat("do {\n foo;\n foo();\n} while;"); 8133 } 8134 8135 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 8136 verifyIncompleteFormat("namespace {\n" 8137 "class Foo { Foo (\n" 8138 "};\n" 8139 "} // namespace"); 8140 } 8141 8142 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 8143 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 8144 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 8145 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 8146 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 8147 8148 EXPECT_EQ("{\n" 8149 " {\n" 8150 " breakme(\n" 8151 " qwe);\n" 8152 " }\n", 8153 format("{\n" 8154 " {\n" 8155 " breakme(qwe);\n" 8156 "}\n", 8157 getLLVMStyleWithColumns(10))); 8158 } 8159 8160 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 8161 verifyFormat("int x = {\n" 8162 " avariable,\n" 8163 " b(alongervariable)};", 8164 getLLVMStyleWithColumns(25)); 8165 } 8166 8167 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 8168 verifyFormat("return (a)(b){1, 2, 3};"); 8169 } 8170 8171 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 8172 verifyFormat("vector<int> x{1, 2, 3, 4};"); 8173 verifyFormat("vector<int> x{\n" 8174 " 1,\n" 8175 " 2,\n" 8176 " 3,\n" 8177 " 4,\n" 8178 "};"); 8179 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 8180 verifyFormat("f({1, 2});"); 8181 verifyFormat("auto v = Foo{-1};"); 8182 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 8183 verifyFormat("Class::Class : member{1, 2, 3} {}"); 8184 verifyFormat("new vector<int>{1, 2, 3};"); 8185 verifyFormat("new int[3]{1, 2, 3};"); 8186 verifyFormat("new int{1};"); 8187 verifyFormat("return {arg1, arg2};"); 8188 verifyFormat("return {arg1, SomeType{parameter}};"); 8189 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 8190 verifyFormat("new T{arg1, arg2};"); 8191 verifyFormat("f(MyMap[{composite, key}]);"); 8192 verifyFormat("class Class {\n" 8193 " T member = {arg1, arg2};\n" 8194 "};"); 8195 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 8196 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 8197 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 8198 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 8199 verifyFormat("int a = std::is_integral<int>{} + 0;"); 8200 8201 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8202 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8203 verifyFormat("auto i = decltype(x){};"); 8204 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 8205 verifyFormat("Node n{1, Node{1000}, //\n" 8206 " 2};"); 8207 verifyFormat("Aaaa aaaaaaa{\n" 8208 " {\n" 8209 " aaaa,\n" 8210 " },\n" 8211 "};"); 8212 verifyFormat("class C : public D {\n" 8213 " SomeClass SC{2};\n" 8214 "};"); 8215 verifyFormat("class C : public A {\n" 8216 " class D : public B {\n" 8217 " void f() { int i{2}; }\n" 8218 " };\n" 8219 "};"); 8220 verifyFormat("#define A {a, a},"); 8221 8222 // Avoid breaking between equal sign and opening brace 8223 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 8224 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 8225 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 8226 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 8227 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 8228 " {\"ccccccccccccccccccccc\", 2}};", 8229 AvoidBreakingFirstArgument); 8230 8231 // Binpacking only if there is no trailing comma 8232 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 8233 " cccccccccc, dddddddddd};", 8234 getLLVMStyleWithColumns(50)); 8235 verifyFormat("const Aaaaaa aaaaa = {\n" 8236 " aaaaaaaaaaa,\n" 8237 " bbbbbbbbbbb,\n" 8238 " ccccccccccc,\n" 8239 " ddddddddddd,\n" 8240 "};", 8241 getLLVMStyleWithColumns(50)); 8242 8243 // Cases where distinguising braced lists and blocks is hard. 8244 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 8245 verifyFormat("void f() {\n" 8246 " return; // comment\n" 8247 "}\n" 8248 "SomeType t;"); 8249 verifyFormat("void f() {\n" 8250 " if (a) {\n" 8251 " f();\n" 8252 " }\n" 8253 "}\n" 8254 "SomeType t;"); 8255 8256 // In combination with BinPackArguments = false. 8257 FormatStyle NoBinPacking = getLLVMStyle(); 8258 NoBinPacking.BinPackArguments = false; 8259 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 8260 " bbbbb,\n" 8261 " ccccc,\n" 8262 " ddddd,\n" 8263 " eeeee,\n" 8264 " ffffff,\n" 8265 " ggggg,\n" 8266 " hhhhhh,\n" 8267 " iiiiii,\n" 8268 " jjjjjj,\n" 8269 " kkkkkk};", 8270 NoBinPacking); 8271 verifyFormat("const Aaaaaa aaaaa = {\n" 8272 " aaaaa,\n" 8273 " bbbbb,\n" 8274 " ccccc,\n" 8275 " ddddd,\n" 8276 " eeeee,\n" 8277 " ffffff,\n" 8278 " ggggg,\n" 8279 " hhhhhh,\n" 8280 " iiiiii,\n" 8281 " jjjjjj,\n" 8282 " kkkkkk,\n" 8283 "};", 8284 NoBinPacking); 8285 verifyFormat( 8286 "const Aaaaaa aaaaa = {\n" 8287 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 8288 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 8289 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 8290 "};", 8291 NoBinPacking); 8292 8293 NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 8294 EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n" 8295 " CDDDP83848_BMCR_REGISTER,\n" 8296 " CDDDP83848_BMSR_REGISTER,\n" 8297 " CDDDP83848_RBR_REGISTER};", 8298 format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n" 8299 " CDDDP83848_BMSR_REGISTER,\n" 8300 " CDDDP83848_RBR_REGISTER};", 8301 NoBinPacking)); 8302 8303 // FIXME: The alignment of these trailing comments might be bad. Then again, 8304 // this might be utterly useless in real code. 8305 verifyFormat("Constructor::Constructor()\n" 8306 " : some_value{ //\n" 8307 " aaaaaaa, //\n" 8308 " bbbbbbb} {}"); 8309 8310 // In braced lists, the first comment is always assumed to belong to the 8311 // first element. Thus, it can be moved to the next or previous line as 8312 // appropriate. 8313 EXPECT_EQ("function({// First element:\n" 8314 " 1,\n" 8315 " // Second element:\n" 8316 " 2});", 8317 format("function({\n" 8318 " // First element:\n" 8319 " 1,\n" 8320 " // Second element:\n" 8321 " 2});")); 8322 EXPECT_EQ("std::vector<int> MyNumbers{\n" 8323 " // First element:\n" 8324 " 1,\n" 8325 " // Second element:\n" 8326 " 2};", 8327 format("std::vector<int> MyNumbers{// First element:\n" 8328 " 1,\n" 8329 " // Second element:\n" 8330 " 2};", 8331 getLLVMStyleWithColumns(30))); 8332 // A trailing comma should still lead to an enforced line break and no 8333 // binpacking. 8334 EXPECT_EQ("vector<int> SomeVector = {\n" 8335 " // aaa\n" 8336 " 1,\n" 8337 " 2,\n" 8338 "};", 8339 format("vector<int> SomeVector = { // aaa\n" 8340 " 1, 2, };")); 8341 8342 FormatStyle ExtraSpaces = getLLVMStyle(); 8343 ExtraSpaces.Cpp11BracedListStyle = false; 8344 ExtraSpaces.ColumnLimit = 75; 8345 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 8346 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 8347 verifyFormat("f({ 1, 2 });", ExtraSpaces); 8348 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 8349 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 8350 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 8351 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 8352 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 8353 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 8354 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 8355 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 8356 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 8357 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 8358 verifyFormat("class Class {\n" 8359 " T member = { arg1, arg2 };\n" 8360 "};", 8361 ExtraSpaces); 8362 verifyFormat( 8363 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8364 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 8365 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 8366 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 8367 ExtraSpaces); 8368 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 8369 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 8370 ExtraSpaces); 8371 verifyFormat( 8372 "someFunction(OtherParam,\n" 8373 " BracedList{ // comment 1 (Forcing interesting break)\n" 8374 " param1, param2,\n" 8375 " // comment 2\n" 8376 " param3, param4 });", 8377 ExtraSpaces); 8378 verifyFormat( 8379 "std::this_thread::sleep_for(\n" 8380 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 8381 ExtraSpaces); 8382 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 8383 " aaaaaaa,\n" 8384 " aaaaaaaaaa,\n" 8385 " aaaaa,\n" 8386 " aaaaaaaaaaaaaaa,\n" 8387 " aaa,\n" 8388 " aaaaaaaaaa,\n" 8389 " a,\n" 8390 " aaaaaaaaaaaaaaaaaaaaa,\n" 8391 " aaaaaaaaaaaa,\n" 8392 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 8393 " aaaaaaa,\n" 8394 " a};"); 8395 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 8396 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 8397 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 8398 8399 // Avoid breaking between initializer/equal sign and opening brace 8400 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 8401 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 8402 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8403 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8404 " { \"ccccccccccccccccccccc\", 2 }\n" 8405 "};", 8406 ExtraSpaces); 8407 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 8408 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8409 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8410 " { \"ccccccccccccccccccccc\", 2 }\n" 8411 "};", 8412 ExtraSpaces); 8413 8414 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 8415 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 8416 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 8417 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 8418 8419 FormatStyle SpaceBetweenBraces = getLLVMStyle(); 8420 SpaceBetweenBraces.SpacesInAngles = true; 8421 SpaceBetweenBraces.SpacesInParentheses = true; 8422 SpaceBetweenBraces.SpacesInSquareBrackets = true; 8423 verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces); 8424 verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces); 8425 verifyFormat("vector< int > x{ // comment 1\n" 8426 " 1, 2, 3, 4 };", 8427 SpaceBetweenBraces); 8428 SpaceBetweenBraces.ColumnLimit = 20; 8429 EXPECT_EQ("vector< int > x{\n" 8430 " 1, 2, 3, 4 };", 8431 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8432 SpaceBetweenBraces.ColumnLimit = 24; 8433 EXPECT_EQ("vector< int > x{ 1, 2,\n" 8434 " 3, 4 };", 8435 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8436 EXPECT_EQ("vector< int > x{\n" 8437 " 1,\n" 8438 " 2,\n" 8439 " 3,\n" 8440 " 4,\n" 8441 "};", 8442 format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces)); 8443 verifyFormat("vector< int > x{};", SpaceBetweenBraces); 8444 SpaceBetweenBraces.SpaceInEmptyParentheses = true; 8445 verifyFormat("vector< int > x{ };", SpaceBetweenBraces); 8446 } 8447 8448 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 8449 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8450 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8451 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8452 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8453 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8454 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8455 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 8456 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8457 " 1, 22, 333, 4444, 55555, //\n" 8458 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8459 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8460 verifyFormat( 8461 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8462 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8463 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 8464 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8465 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8466 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8467 " 7777777};"); 8468 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8469 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8470 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8471 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8472 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8473 " // Separating comment.\n" 8474 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8475 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8476 " // Leading comment\n" 8477 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8478 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8479 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8480 " 1, 1, 1, 1};", 8481 getLLVMStyleWithColumns(39)); 8482 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8483 " 1, 1, 1, 1};", 8484 getLLVMStyleWithColumns(38)); 8485 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 8486 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 8487 getLLVMStyleWithColumns(43)); 8488 verifyFormat( 8489 "static unsigned SomeValues[10][3] = {\n" 8490 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 8491 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 8492 verifyFormat("static auto fields = new vector<string>{\n" 8493 " \"aaaaaaaaaaaaa\",\n" 8494 " \"aaaaaaaaaaaaa\",\n" 8495 " \"aaaaaaaaaaaa\",\n" 8496 " \"aaaaaaaaaaaaaa\",\n" 8497 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8498 " \"aaaaaaaaaaaa\",\n" 8499 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8500 "};"); 8501 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 8502 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 8503 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 8504 " 3, cccccccccccccccccccccc};", 8505 getLLVMStyleWithColumns(60)); 8506 8507 // Trailing commas. 8508 verifyFormat("vector<int> x = {\n" 8509 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 8510 "};", 8511 getLLVMStyleWithColumns(39)); 8512 verifyFormat("vector<int> x = {\n" 8513 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 8514 "};", 8515 getLLVMStyleWithColumns(39)); 8516 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8517 " 1, 1, 1, 1,\n" 8518 " /**/ /**/};", 8519 getLLVMStyleWithColumns(39)); 8520 8521 // Trailing comment in the first line. 8522 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 8523 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 8524 " 111111111, 222222222, 3333333333, 444444444, //\n" 8525 " 11111111, 22222222, 333333333, 44444444};"); 8526 // Trailing comment in the last line. 8527 verifyFormat("int aaaaa[] = {\n" 8528 " 1, 2, 3, // comment\n" 8529 " 4, 5, 6 // comment\n" 8530 "};"); 8531 8532 // With nested lists, we should either format one item per line or all nested 8533 // lists one on line. 8534 // FIXME: For some nested lists, we can do better. 8535 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 8536 " {aaaaaaaaaaaaaaaaaaa},\n" 8537 " {aaaaaaaaaaaaaaaaaaaaa},\n" 8538 " {aaaaaaaaaaaaaaaaa}};", 8539 getLLVMStyleWithColumns(60)); 8540 verifyFormat( 8541 "SomeStruct my_struct_array = {\n" 8542 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 8543 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 8544 " {aaa, aaa},\n" 8545 " {aaa, aaa},\n" 8546 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 8547 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 8548 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 8549 8550 // No column layout should be used here. 8551 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 8552 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 8553 8554 verifyNoCrash("a<,"); 8555 8556 // No braced initializer here. 8557 verifyFormat("void f() {\n" 8558 " struct Dummy {};\n" 8559 " f(v);\n" 8560 "}"); 8561 8562 // Long lists should be formatted in columns even if they are nested. 8563 verifyFormat( 8564 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8565 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8566 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8567 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8568 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8569 " 1, 22, 333, 4444, 55555, 666666, 7777777});"); 8570 8571 // Allow "single-column" layout even if that violates the column limit. There 8572 // isn't going to be a better way. 8573 verifyFormat("std::vector<int> a = {\n" 8574 " aaaaaaaa,\n" 8575 " aaaaaaaa,\n" 8576 " aaaaaaaa,\n" 8577 " aaaaaaaa,\n" 8578 " aaaaaaaaaa,\n" 8579 " aaaaaaaa,\n" 8580 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 8581 getLLVMStyleWithColumns(30)); 8582 verifyFormat("vector<int> aaaa = {\n" 8583 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8584 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8585 " aaaaaa.aaaaaaa,\n" 8586 " aaaaaa.aaaaaaa,\n" 8587 " aaaaaa.aaaaaaa,\n" 8588 " aaaaaa.aaaaaaa,\n" 8589 "};"); 8590 8591 // Don't create hanging lists. 8592 verifyFormat("someFunction(Param, {List1, List2,\n" 8593 " List3});", 8594 getLLVMStyleWithColumns(35)); 8595 verifyFormat("someFunction(Param, Param,\n" 8596 " {List1, List2,\n" 8597 " List3});", 8598 getLLVMStyleWithColumns(35)); 8599 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 8600 " aaaaaaaaaaaaaaaaaaaaaaa);"); 8601 } 8602 8603 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 8604 FormatStyle DoNotMerge = getLLVMStyle(); 8605 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8606 8607 verifyFormat("void f() { return 42; }"); 8608 verifyFormat("void f() {\n" 8609 " return 42;\n" 8610 "}", 8611 DoNotMerge); 8612 verifyFormat("void f() {\n" 8613 " // Comment\n" 8614 "}"); 8615 verifyFormat("{\n" 8616 "#error {\n" 8617 " int a;\n" 8618 "}"); 8619 verifyFormat("{\n" 8620 " int a;\n" 8621 "#error {\n" 8622 "}"); 8623 verifyFormat("void f() {} // comment"); 8624 verifyFormat("void f() { int a; } // comment"); 8625 verifyFormat("void f() {\n" 8626 "} // comment", 8627 DoNotMerge); 8628 verifyFormat("void f() {\n" 8629 " int a;\n" 8630 "} // comment", 8631 DoNotMerge); 8632 verifyFormat("void f() {\n" 8633 "} // comment", 8634 getLLVMStyleWithColumns(15)); 8635 8636 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 8637 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 8638 8639 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 8640 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 8641 verifyFormat("class C {\n" 8642 " C()\n" 8643 " : iiiiiiii(nullptr),\n" 8644 " kkkkkkk(nullptr),\n" 8645 " mmmmmmm(nullptr),\n" 8646 " nnnnnnn(nullptr) {}\n" 8647 "};", 8648 getGoogleStyle()); 8649 8650 FormatStyle NoColumnLimit = getLLVMStyle(); 8651 NoColumnLimit.ColumnLimit = 0; 8652 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 8653 EXPECT_EQ("class C {\n" 8654 " A() : b(0) {}\n" 8655 "};", 8656 format("class C{A():b(0){}};", NoColumnLimit)); 8657 EXPECT_EQ("A()\n" 8658 " : b(0) {\n" 8659 "}", 8660 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 8661 8662 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 8663 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 8664 FormatStyle::SFS_None; 8665 EXPECT_EQ("A()\n" 8666 " : b(0) {\n" 8667 "}", 8668 format("A():b(0){}", DoNotMergeNoColumnLimit)); 8669 EXPECT_EQ("A()\n" 8670 " : b(0) {\n" 8671 "}", 8672 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 8673 8674 verifyFormat("#define A \\\n" 8675 " void f() { \\\n" 8676 " int i; \\\n" 8677 " }", 8678 getLLVMStyleWithColumns(20)); 8679 verifyFormat("#define A \\\n" 8680 " void f() { int i; }", 8681 getLLVMStyleWithColumns(21)); 8682 verifyFormat("#define A \\\n" 8683 " void f() { \\\n" 8684 " int i; \\\n" 8685 " } \\\n" 8686 " int j;", 8687 getLLVMStyleWithColumns(22)); 8688 verifyFormat("#define A \\\n" 8689 " void f() { int i; } \\\n" 8690 " int j;", 8691 getLLVMStyleWithColumns(23)); 8692 } 8693 8694 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 8695 FormatStyle MergeEmptyOnly = getLLVMStyle(); 8696 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8697 verifyFormat("class C {\n" 8698 " int f() {}\n" 8699 "};", 8700 MergeEmptyOnly); 8701 verifyFormat("class C {\n" 8702 " int f() {\n" 8703 " return 42;\n" 8704 " }\n" 8705 "};", 8706 MergeEmptyOnly); 8707 verifyFormat("int f() {}", MergeEmptyOnly); 8708 verifyFormat("int f() {\n" 8709 " return 42;\n" 8710 "}", 8711 MergeEmptyOnly); 8712 8713 // Also verify behavior when BraceWrapping.AfterFunction = true 8714 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8715 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 8716 verifyFormat("int f() {}", MergeEmptyOnly); 8717 verifyFormat("class C {\n" 8718 " int f() {}\n" 8719 "};", 8720 MergeEmptyOnly); 8721 } 8722 8723 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 8724 FormatStyle MergeInlineOnly = getLLVMStyle(); 8725 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8726 verifyFormat("class C {\n" 8727 " int f() { return 42; }\n" 8728 "};", 8729 MergeInlineOnly); 8730 verifyFormat("int f() {\n" 8731 " return 42;\n" 8732 "}", 8733 MergeInlineOnly); 8734 8735 // SFS_Inline implies SFS_Empty 8736 verifyFormat("class C {\n" 8737 " int f() {}\n" 8738 "};", 8739 MergeInlineOnly); 8740 verifyFormat("int f() {}", MergeInlineOnly); 8741 8742 // Also verify behavior when BraceWrapping.AfterFunction = true 8743 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8744 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8745 verifyFormat("class C {\n" 8746 " int f() { return 42; }\n" 8747 "};", 8748 MergeInlineOnly); 8749 verifyFormat("int f()\n" 8750 "{\n" 8751 " return 42;\n" 8752 "}", 8753 MergeInlineOnly); 8754 8755 // SFS_Inline implies SFS_Empty 8756 verifyFormat("int f() {}", MergeInlineOnly); 8757 verifyFormat("class C {\n" 8758 " int f() {}\n" 8759 "};", 8760 MergeInlineOnly); 8761 } 8762 8763 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8764 FormatStyle MergeInlineOnly = getLLVMStyle(); 8765 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8766 FormatStyle::SFS_InlineOnly; 8767 verifyFormat("class C {\n" 8768 " int f() { return 42; }\n" 8769 "};", 8770 MergeInlineOnly); 8771 verifyFormat("int f() {\n" 8772 " return 42;\n" 8773 "}", 8774 MergeInlineOnly); 8775 8776 // SFS_InlineOnly does not imply SFS_Empty 8777 verifyFormat("class C {\n" 8778 " int f() {}\n" 8779 "};", 8780 MergeInlineOnly); 8781 verifyFormat("int f() {\n" 8782 "}", 8783 MergeInlineOnly); 8784 8785 // Also verify behavior when BraceWrapping.AfterFunction = true 8786 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8787 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8788 verifyFormat("class C {\n" 8789 " int f() { return 42; }\n" 8790 "};", 8791 MergeInlineOnly); 8792 verifyFormat("int f()\n" 8793 "{\n" 8794 " return 42;\n" 8795 "}", 8796 MergeInlineOnly); 8797 8798 // SFS_InlineOnly does not imply SFS_Empty 8799 verifyFormat("int f()\n" 8800 "{\n" 8801 "}", 8802 MergeInlineOnly); 8803 verifyFormat("class C {\n" 8804 " int f() {}\n" 8805 "};", 8806 MergeInlineOnly); 8807 } 8808 8809 TEST_F(FormatTest, SplitEmptyFunction) { 8810 FormatStyle Style = getLLVMStyle(); 8811 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8812 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8813 Style.BraceWrapping.AfterFunction = true; 8814 Style.BraceWrapping.SplitEmptyFunction = false; 8815 Style.ColumnLimit = 40; 8816 8817 verifyFormat("int f()\n" 8818 "{}", 8819 Style); 8820 verifyFormat("int f()\n" 8821 "{\n" 8822 " return 42;\n" 8823 "}", 8824 Style); 8825 verifyFormat("int f()\n" 8826 "{\n" 8827 " // some comment\n" 8828 "}", 8829 Style); 8830 8831 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8832 verifyFormat("int f() {}", Style); 8833 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8834 "{}", 8835 Style); 8836 verifyFormat("int f()\n" 8837 "{\n" 8838 " return 0;\n" 8839 "}", 8840 Style); 8841 8842 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8843 verifyFormat("class Foo {\n" 8844 " int f() {}\n" 8845 "};\n", 8846 Style); 8847 verifyFormat("class Foo {\n" 8848 " int f() { return 0; }\n" 8849 "};\n", 8850 Style); 8851 verifyFormat("class Foo {\n" 8852 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8853 " {}\n" 8854 "};\n", 8855 Style); 8856 verifyFormat("class Foo {\n" 8857 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8858 " {\n" 8859 " return 0;\n" 8860 " }\n" 8861 "};\n", 8862 Style); 8863 8864 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8865 verifyFormat("int f() {}", Style); 8866 verifyFormat("int f() { return 0; }", Style); 8867 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8868 "{}", 8869 Style); 8870 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8871 "{\n" 8872 " return 0;\n" 8873 "}", 8874 Style); 8875 } 8876 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8877 FormatStyle Style = getLLVMStyle(); 8878 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8879 verifyFormat("#ifdef A\n" 8880 "int f() {}\n" 8881 "#else\n" 8882 "int g() {}\n" 8883 "#endif", 8884 Style); 8885 } 8886 8887 TEST_F(FormatTest, SplitEmptyClass) { 8888 FormatStyle Style = getLLVMStyle(); 8889 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8890 Style.BraceWrapping.AfterClass = true; 8891 Style.BraceWrapping.SplitEmptyRecord = false; 8892 8893 verifyFormat("class Foo\n" 8894 "{};", 8895 Style); 8896 verifyFormat("/* something */ class Foo\n" 8897 "{};", 8898 Style); 8899 verifyFormat("template <typename X> class Foo\n" 8900 "{};", 8901 Style); 8902 verifyFormat("class Foo\n" 8903 "{\n" 8904 " Foo();\n" 8905 "};", 8906 Style); 8907 verifyFormat("typedef class Foo\n" 8908 "{\n" 8909 "} Foo_t;", 8910 Style); 8911 } 8912 8913 TEST_F(FormatTest, SplitEmptyStruct) { 8914 FormatStyle Style = getLLVMStyle(); 8915 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8916 Style.BraceWrapping.AfterStruct = true; 8917 Style.BraceWrapping.SplitEmptyRecord = false; 8918 8919 verifyFormat("struct Foo\n" 8920 "{};", 8921 Style); 8922 verifyFormat("/* something */ struct Foo\n" 8923 "{};", 8924 Style); 8925 verifyFormat("template <typename X> struct Foo\n" 8926 "{};", 8927 Style); 8928 verifyFormat("struct Foo\n" 8929 "{\n" 8930 " Foo();\n" 8931 "};", 8932 Style); 8933 verifyFormat("typedef struct Foo\n" 8934 "{\n" 8935 "} Foo_t;", 8936 Style); 8937 // typedef struct Bar {} Bar_t; 8938 } 8939 8940 TEST_F(FormatTest, SplitEmptyUnion) { 8941 FormatStyle Style = getLLVMStyle(); 8942 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8943 Style.BraceWrapping.AfterUnion = true; 8944 Style.BraceWrapping.SplitEmptyRecord = false; 8945 8946 verifyFormat("union Foo\n" 8947 "{};", 8948 Style); 8949 verifyFormat("/* something */ union Foo\n" 8950 "{};", 8951 Style); 8952 verifyFormat("union Foo\n" 8953 "{\n" 8954 " A,\n" 8955 "};", 8956 Style); 8957 verifyFormat("typedef union Foo\n" 8958 "{\n" 8959 "} Foo_t;", 8960 Style); 8961 } 8962 8963 TEST_F(FormatTest, SplitEmptyNamespace) { 8964 FormatStyle Style = getLLVMStyle(); 8965 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8966 Style.BraceWrapping.AfterNamespace = true; 8967 Style.BraceWrapping.SplitEmptyNamespace = false; 8968 8969 verifyFormat("namespace Foo\n" 8970 "{};", 8971 Style); 8972 verifyFormat("/* something */ namespace Foo\n" 8973 "{};", 8974 Style); 8975 verifyFormat("inline namespace Foo\n" 8976 "{};", 8977 Style); 8978 verifyFormat("/* something */ inline namespace Foo\n" 8979 "{};", 8980 Style); 8981 verifyFormat("export namespace Foo\n" 8982 "{};", 8983 Style); 8984 verifyFormat("namespace Foo\n" 8985 "{\n" 8986 "void Bar();\n" 8987 "};", 8988 Style); 8989 } 8990 8991 TEST_F(FormatTest, NeverMergeShortRecords) { 8992 FormatStyle Style = getLLVMStyle(); 8993 8994 verifyFormat("class Foo {\n" 8995 " Foo();\n" 8996 "};", 8997 Style); 8998 verifyFormat("typedef class Foo {\n" 8999 " Foo();\n" 9000 "} Foo_t;", 9001 Style); 9002 verifyFormat("struct Foo {\n" 9003 " Foo();\n" 9004 "};", 9005 Style); 9006 verifyFormat("typedef struct Foo {\n" 9007 " Foo();\n" 9008 "} Foo_t;", 9009 Style); 9010 verifyFormat("union Foo {\n" 9011 " A,\n" 9012 "};", 9013 Style); 9014 verifyFormat("typedef union Foo {\n" 9015 " A,\n" 9016 "} Foo_t;", 9017 Style); 9018 verifyFormat("namespace Foo {\n" 9019 "void Bar();\n" 9020 "};", 9021 Style); 9022 9023 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9024 Style.BraceWrapping.AfterClass = true; 9025 Style.BraceWrapping.AfterStruct = true; 9026 Style.BraceWrapping.AfterUnion = true; 9027 Style.BraceWrapping.AfterNamespace = true; 9028 verifyFormat("class Foo\n" 9029 "{\n" 9030 " Foo();\n" 9031 "};", 9032 Style); 9033 verifyFormat("typedef class Foo\n" 9034 "{\n" 9035 " Foo();\n" 9036 "} Foo_t;", 9037 Style); 9038 verifyFormat("struct Foo\n" 9039 "{\n" 9040 " Foo();\n" 9041 "};", 9042 Style); 9043 verifyFormat("typedef struct Foo\n" 9044 "{\n" 9045 " Foo();\n" 9046 "} Foo_t;", 9047 Style); 9048 verifyFormat("union Foo\n" 9049 "{\n" 9050 " A,\n" 9051 "};", 9052 Style); 9053 verifyFormat("typedef union Foo\n" 9054 "{\n" 9055 " A,\n" 9056 "} Foo_t;", 9057 Style); 9058 verifyFormat("namespace Foo\n" 9059 "{\n" 9060 "void Bar();\n" 9061 "};", 9062 Style); 9063 } 9064 9065 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 9066 // Elaborate type variable declarations. 9067 verifyFormat("struct foo a = {bar};\nint n;"); 9068 verifyFormat("class foo a = {bar};\nint n;"); 9069 verifyFormat("union foo a = {bar};\nint n;"); 9070 9071 // Elaborate types inside function definitions. 9072 verifyFormat("struct foo f() {}\nint n;"); 9073 verifyFormat("class foo f() {}\nint n;"); 9074 verifyFormat("union foo f() {}\nint n;"); 9075 9076 // Templates. 9077 verifyFormat("template <class X> void f() {}\nint n;"); 9078 verifyFormat("template <struct X> void f() {}\nint n;"); 9079 verifyFormat("template <union X> void f() {}\nint n;"); 9080 9081 // Actual definitions... 9082 verifyFormat("struct {\n} n;"); 9083 verifyFormat( 9084 "template <template <class T, class Y>, class Z> class X {\n} n;"); 9085 verifyFormat("union Z {\n int n;\n} x;"); 9086 verifyFormat("class MACRO Z {\n} n;"); 9087 verifyFormat("class MACRO(X) Z {\n} n;"); 9088 verifyFormat("class __attribute__(X) Z {\n} n;"); 9089 verifyFormat("class __declspec(X) Z {\n} n;"); 9090 verifyFormat("class A##B##C {\n} n;"); 9091 verifyFormat("class alignas(16) Z {\n} n;"); 9092 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 9093 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 9094 9095 // Redefinition from nested context: 9096 verifyFormat("class A::B::C {\n} n;"); 9097 9098 // Template definitions. 9099 verifyFormat( 9100 "template <typename F>\n" 9101 "Matcher(const Matcher<F> &Other,\n" 9102 " typename enable_if_c<is_base_of<F, T>::value &&\n" 9103 " !is_same<F, T>::value>::type * = 0)\n" 9104 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 9105 9106 // FIXME: This is still incorrectly handled at the formatter side. 9107 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 9108 verifyFormat("int i = SomeFunction(a<b, a> b);"); 9109 9110 // FIXME: 9111 // This now gets parsed incorrectly as class definition. 9112 // verifyFormat("class A<int> f() {\n}\nint n;"); 9113 9114 // Elaborate types where incorrectly parsing the structural element would 9115 // break the indent. 9116 verifyFormat("if (true)\n" 9117 " class X x;\n" 9118 "else\n" 9119 " f();\n"); 9120 9121 // This is simply incomplete. Formatting is not important, but must not crash. 9122 verifyFormat("class A:"); 9123 } 9124 9125 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 9126 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 9127 format("#error Leave all white!!!!! space* alone!\n")); 9128 EXPECT_EQ( 9129 "#warning Leave all white!!!!! space* alone!\n", 9130 format("#warning Leave all white!!!!! space* alone!\n")); 9131 EXPECT_EQ("#error 1", format(" # error 1")); 9132 EXPECT_EQ("#warning 1", format(" # warning 1")); 9133 } 9134 9135 TEST_F(FormatTest, FormatHashIfExpressions) { 9136 verifyFormat("#if AAAA && BBBB"); 9137 verifyFormat("#if (AAAA && BBBB)"); 9138 verifyFormat("#elif (AAAA && BBBB)"); 9139 // FIXME: Come up with a better indentation for #elif. 9140 verifyFormat( 9141 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 9142 " defined(BBBBBBBB)\n" 9143 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 9144 " defined(BBBBBBBB)\n" 9145 "#endif", 9146 getLLVMStyleWithColumns(65)); 9147 } 9148 9149 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 9150 FormatStyle AllowsMergedIf = getGoogleStyle(); 9151 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 9152 FormatStyle::SIS_WithoutElse; 9153 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 9154 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 9155 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 9156 EXPECT_EQ("if (true) return 42;", 9157 format("if (true)\nreturn 42;", AllowsMergedIf)); 9158 FormatStyle ShortMergedIf = AllowsMergedIf; 9159 ShortMergedIf.ColumnLimit = 25; 9160 verifyFormat("#define A \\\n" 9161 " if (true) return 42;", 9162 ShortMergedIf); 9163 verifyFormat("#define A \\\n" 9164 " f(); \\\n" 9165 " if (true)\n" 9166 "#define B", 9167 ShortMergedIf); 9168 verifyFormat("#define A \\\n" 9169 " f(); \\\n" 9170 " if (true)\n" 9171 "g();", 9172 ShortMergedIf); 9173 verifyFormat("{\n" 9174 "#ifdef A\n" 9175 " // Comment\n" 9176 " if (true) continue;\n" 9177 "#endif\n" 9178 " // Comment\n" 9179 " if (true) continue;\n" 9180 "}", 9181 ShortMergedIf); 9182 ShortMergedIf.ColumnLimit = 33; 9183 verifyFormat("#define A \\\n" 9184 " if constexpr (true) return 42;", 9185 ShortMergedIf); 9186 verifyFormat("#define A \\\n" 9187 " if CONSTEXPR (true) return 42;", 9188 ShortMergedIf); 9189 ShortMergedIf.ColumnLimit = 29; 9190 verifyFormat("#define A \\\n" 9191 " if (aaaaaaaaaa) return 1; \\\n" 9192 " return 2;", 9193 ShortMergedIf); 9194 ShortMergedIf.ColumnLimit = 28; 9195 verifyFormat("#define A \\\n" 9196 " if (aaaaaaaaaa) \\\n" 9197 " return 1; \\\n" 9198 " return 2;", 9199 ShortMergedIf); 9200 verifyFormat("#define A \\\n" 9201 " if constexpr (aaaaaaa) \\\n" 9202 " return 1; \\\n" 9203 " return 2;", 9204 ShortMergedIf); 9205 verifyFormat("#define A \\\n" 9206 " if CONSTEXPR (aaaaaaa) \\\n" 9207 " return 1; \\\n" 9208 " return 2;", 9209 ShortMergedIf); 9210 } 9211 9212 TEST_F(FormatTest, FormatStarDependingOnContext) { 9213 verifyFormat("void f(int *a);"); 9214 verifyFormat("void f() { f(fint * b); }"); 9215 verifyFormat("class A {\n void f(int *a);\n};"); 9216 verifyFormat("class A {\n int *a;\n};"); 9217 verifyFormat("namespace a {\n" 9218 "namespace b {\n" 9219 "class A {\n" 9220 " void f() {}\n" 9221 " int *a;\n" 9222 "};\n" 9223 "} // namespace b\n" 9224 "} // namespace a"); 9225 } 9226 9227 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 9228 verifyFormat("while"); 9229 verifyFormat("operator"); 9230 } 9231 9232 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 9233 // This code would be painfully slow to format if we didn't skip it. 9234 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 9235 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9236 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9237 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9238 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9239 "A(1, 1)\n" 9240 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 9241 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9242 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9243 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9244 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9245 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9246 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9247 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9248 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9249 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n"); 9250 // Deeply nested part is untouched, rest is formatted. 9251 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 9252 format(std::string("int i;\n") + Code + "int j;\n", 9253 getLLVMStyle(), SC_ExpectIncomplete)); 9254 } 9255 9256 //===----------------------------------------------------------------------===// 9257 // Objective-C tests. 9258 //===----------------------------------------------------------------------===// 9259 9260 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 9261 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 9262 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 9263 format("-(NSUInteger)indexOfObject:(id)anObject;")); 9264 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 9265 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 9266 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 9267 format("-(NSInteger)Method3:(id)anObject;")); 9268 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 9269 format("-(NSInteger)Method4:(id)anObject;")); 9270 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 9271 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 9272 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 9273 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 9274 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9275 "forAllCells:(BOOL)flag;", 9276 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9277 "forAllCells:(BOOL)flag;")); 9278 9279 // Very long objectiveC method declaration. 9280 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 9281 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 9282 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 9283 " inRange:(NSRange)range\n" 9284 " outRange:(NSRange)out_range\n" 9285 " outRange1:(NSRange)out_range1\n" 9286 " outRange2:(NSRange)out_range2\n" 9287 " outRange3:(NSRange)out_range3\n" 9288 " outRange4:(NSRange)out_range4\n" 9289 " outRange5:(NSRange)out_range5\n" 9290 " outRange6:(NSRange)out_range6\n" 9291 " outRange7:(NSRange)out_range7\n" 9292 " outRange8:(NSRange)out_range8\n" 9293 " outRange9:(NSRange)out_range9;"); 9294 9295 // When the function name has to be wrapped. 9296 FormatStyle Style = getLLVMStyle(); 9297 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 9298 // and always indents instead. 9299 Style.IndentWrappedFunctionNames = false; 9300 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9301 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 9302 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 9303 "}", 9304 Style); 9305 Style.IndentWrappedFunctionNames = true; 9306 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9307 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 9308 " anotherName:(NSString)dddddddddddddd {\n" 9309 "}", 9310 Style); 9311 9312 verifyFormat("- (int)sum:(vector<int>)numbers;"); 9313 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 9314 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 9315 // protocol lists (but not for template classes): 9316 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 9317 9318 verifyFormat("- (int (*)())foo:(int (*)())f;"); 9319 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 9320 9321 // If there's no return type (very rare in practice!), LLVM and Google style 9322 // agree. 9323 verifyFormat("- foo;"); 9324 verifyFormat("- foo:(int)f;"); 9325 verifyGoogleFormat("- foo:(int)foo;"); 9326 } 9327 9328 TEST_F(FormatTest, BreaksStringLiterals) { 9329 EXPECT_EQ("\"some text \"\n" 9330 "\"other\";", 9331 format("\"some text other\";", getLLVMStyleWithColumns(12))); 9332 EXPECT_EQ("\"some text \"\n" 9333 "\"other\";", 9334 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 9335 EXPECT_EQ( 9336 "#define A \\\n" 9337 " \"some \" \\\n" 9338 " \"text \" \\\n" 9339 " \"other\";", 9340 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 9341 EXPECT_EQ( 9342 "#define A \\\n" 9343 " \"so \" \\\n" 9344 " \"text \" \\\n" 9345 " \"other\";", 9346 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 9347 9348 EXPECT_EQ("\"some text\"", 9349 format("\"some text\"", getLLVMStyleWithColumns(1))); 9350 EXPECT_EQ("\"some text\"", 9351 format("\"some text\"", getLLVMStyleWithColumns(11))); 9352 EXPECT_EQ("\"some \"\n" 9353 "\"text\"", 9354 format("\"some text\"", getLLVMStyleWithColumns(10))); 9355 EXPECT_EQ("\"some \"\n" 9356 "\"text\"", 9357 format("\"some text\"", getLLVMStyleWithColumns(7))); 9358 EXPECT_EQ("\"some\"\n" 9359 "\" tex\"\n" 9360 "\"t\"", 9361 format("\"some text\"", getLLVMStyleWithColumns(6))); 9362 EXPECT_EQ("\"some\"\n" 9363 "\" tex\"\n" 9364 "\" and\"", 9365 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 9366 EXPECT_EQ("\"some\"\n" 9367 "\"/tex\"\n" 9368 "\"/and\"", 9369 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 9370 9371 EXPECT_EQ("variable =\n" 9372 " \"long string \"\n" 9373 " \"literal\";", 9374 format("variable = \"long string literal\";", 9375 getLLVMStyleWithColumns(20))); 9376 9377 EXPECT_EQ("variable = f(\n" 9378 " \"long string \"\n" 9379 " \"literal\",\n" 9380 " short,\n" 9381 " loooooooooooooooooooong);", 9382 format("variable = f(\"long string literal\", short, " 9383 "loooooooooooooooooooong);", 9384 getLLVMStyleWithColumns(20))); 9385 9386 EXPECT_EQ( 9387 "f(g(\"long string \"\n" 9388 " \"literal\"),\n" 9389 " b);", 9390 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 9391 EXPECT_EQ("f(g(\"long string \"\n" 9392 " \"literal\",\n" 9393 " a),\n" 9394 " b);", 9395 format("f(g(\"long string literal\", a), b);", 9396 getLLVMStyleWithColumns(20))); 9397 EXPECT_EQ( 9398 "f(\"one two\".split(\n" 9399 " variable));", 9400 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 9401 EXPECT_EQ("f(\"one two three four five six \"\n" 9402 " \"seven\".split(\n" 9403 " really_looooong_variable));", 9404 format("f(\"one two three four five six seven\"." 9405 "split(really_looooong_variable));", 9406 getLLVMStyleWithColumns(33))); 9407 9408 EXPECT_EQ("f(\"some \"\n" 9409 " \"text\",\n" 9410 " other);", 9411 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 9412 9413 // Only break as a last resort. 9414 verifyFormat( 9415 "aaaaaaaaaaaaaaaaaaaa(\n" 9416 " aaaaaaaaaaaaaaaaaaaa,\n" 9417 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 9418 9419 EXPECT_EQ("\"splitmea\"\n" 9420 "\"trandomp\"\n" 9421 "\"oint\"", 9422 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 9423 9424 EXPECT_EQ("\"split/\"\n" 9425 "\"pathat/\"\n" 9426 "\"slashes\"", 9427 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9428 9429 EXPECT_EQ("\"split/\"\n" 9430 "\"pathat/\"\n" 9431 "\"slashes\"", 9432 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9433 EXPECT_EQ("\"split at \"\n" 9434 "\"spaces/at/\"\n" 9435 "\"slashes.at.any$\"\n" 9436 "\"non-alphanumeric%\"\n" 9437 "\"1111111111characte\"\n" 9438 "\"rs\"", 9439 format("\"split at " 9440 "spaces/at/" 9441 "slashes.at." 9442 "any$non-" 9443 "alphanumeric%" 9444 "1111111111characte" 9445 "rs\"", 9446 getLLVMStyleWithColumns(20))); 9447 9448 // Verify that splitting the strings understands 9449 // Style::AlwaysBreakBeforeMultilineStrings. 9450 EXPECT_EQ("aaaaaaaaaaaa(\n" 9451 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 9452 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 9453 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 9454 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9455 "aaaaaaaaaaaaaaaaaaaaaa\");", 9456 getGoogleStyle())); 9457 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9458 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 9459 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 9460 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9461 "aaaaaaaaaaaaaaaaaaaaaa\";", 9462 getGoogleStyle())); 9463 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9464 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9465 format("llvm::outs() << " 9466 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 9467 "aaaaaaaaaaaaaaaaaaa\";")); 9468 EXPECT_EQ("ffff(\n" 9469 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9470 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9471 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 9472 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9473 getGoogleStyle())); 9474 9475 FormatStyle Style = getLLVMStyleWithColumns(12); 9476 Style.BreakStringLiterals = false; 9477 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 9478 9479 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 9480 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9481 EXPECT_EQ("#define A \\\n" 9482 " \"some \" \\\n" 9483 " \"text \" \\\n" 9484 " \"other\";", 9485 format("#define A \"some text other\";", AlignLeft)); 9486 } 9487 9488 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 9489 EXPECT_EQ("C a = \"some more \"\n" 9490 " \"text\";", 9491 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 9492 } 9493 9494 TEST_F(FormatTest, FullyRemoveEmptyLines) { 9495 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 9496 NoEmptyLines.MaxEmptyLinesToKeep = 0; 9497 EXPECT_EQ("int i = a(b());", 9498 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 9499 } 9500 9501 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 9502 EXPECT_EQ( 9503 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9504 "(\n" 9505 " \"x\t\");", 9506 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9507 "aaaaaaa(" 9508 "\"x\t\");")); 9509 } 9510 9511 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 9512 EXPECT_EQ( 9513 "u8\"utf8 string \"\n" 9514 "u8\"literal\";", 9515 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 9516 EXPECT_EQ( 9517 "u\"utf16 string \"\n" 9518 "u\"literal\";", 9519 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 9520 EXPECT_EQ( 9521 "U\"utf32 string \"\n" 9522 "U\"literal\";", 9523 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 9524 EXPECT_EQ("L\"wide string \"\n" 9525 "L\"literal\";", 9526 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 9527 EXPECT_EQ("@\"NSString \"\n" 9528 "@\"literal\";", 9529 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 9530 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 9531 9532 // This input makes clang-format try to split the incomplete unicode escape 9533 // sequence, which used to lead to a crasher. 9534 verifyNoCrash( 9535 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 9536 getLLVMStyleWithColumns(60)); 9537 } 9538 9539 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 9540 FormatStyle Style = getGoogleStyleWithColumns(15); 9541 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 9542 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 9543 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 9544 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 9545 EXPECT_EQ("u8R\"x(raw literal)x\";", 9546 format("u8R\"x(raw literal)x\";", Style)); 9547 } 9548 9549 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 9550 FormatStyle Style = getLLVMStyleWithColumns(20); 9551 EXPECT_EQ( 9552 "_T(\"aaaaaaaaaaaaaa\")\n" 9553 "_T(\"aaaaaaaaaaaaaa\")\n" 9554 "_T(\"aaaaaaaaaaaa\")", 9555 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 9556 EXPECT_EQ("f(x,\n" 9557 " _T(\"aaaaaaaaaaaa\")\n" 9558 " _T(\"aaa\"),\n" 9559 " z);", 9560 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 9561 9562 // FIXME: Handle embedded spaces in one iteration. 9563 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 9564 // "_T(\"aaaaaaaaaaaaa\")\n" 9565 // "_T(\"aaaaaaaaaaaaa\")\n" 9566 // "_T(\"a\")", 9567 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9568 // getLLVMStyleWithColumns(20))); 9569 EXPECT_EQ( 9570 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9571 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 9572 EXPECT_EQ("f(\n" 9573 "#if !TEST\n" 9574 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9575 "#endif\n" 9576 ");", 9577 format("f(\n" 9578 "#if !TEST\n" 9579 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9580 "#endif\n" 9581 ");")); 9582 EXPECT_EQ("f(\n" 9583 "\n" 9584 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 9585 format("f(\n" 9586 "\n" 9587 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 9588 } 9589 9590 TEST_F(FormatTest, BreaksStringLiteralOperands) { 9591 // In a function call with two operands, the second can be broken with no line 9592 // break before it. 9593 EXPECT_EQ( 9594 "func(a, \"long long \"\n" 9595 " \"long long\");", 9596 format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24))); 9597 // In a function call with three operands, the second must be broken with a 9598 // line break before it. 9599 EXPECT_EQ("func(a,\n" 9600 " \"long long long \"\n" 9601 " \"long\",\n" 9602 " c);", 9603 format("func(a, \"long long long long\", c);", 9604 getLLVMStyleWithColumns(24))); 9605 // In a function call with three operands, the third must be broken with a 9606 // line break before it. 9607 EXPECT_EQ("func(a, b,\n" 9608 " \"long long long \"\n" 9609 " \"long\");", 9610 format("func(a, b, \"long long long long\");", 9611 getLLVMStyleWithColumns(24))); 9612 // In a function call with three operands, both the second and the third must 9613 // be broken with a line break before them. 9614 EXPECT_EQ("func(a,\n" 9615 " \"long long long \"\n" 9616 " \"long\",\n" 9617 " \"long long long \"\n" 9618 " \"long\");", 9619 format("func(a, \"long long long long\", \"long long long long\");", 9620 getLLVMStyleWithColumns(24))); 9621 // In a chain of << with two operands, the second can be broken with no line 9622 // break before it. 9623 EXPECT_EQ("a << \"line line \"\n" 9624 " \"line\";", 9625 format("a << \"line line line\";", getLLVMStyleWithColumns(20))); 9626 // In a chain of << with three operands, the second can be broken with no line 9627 // break before it. 9628 EXPECT_EQ( 9629 "abcde << \"line \"\n" 9630 " \"line line\"\n" 9631 " << c;", 9632 format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20))); 9633 // In a chain of << with three operands, the third must be broken with a line 9634 // break before it. 9635 EXPECT_EQ( 9636 "a << b\n" 9637 " << \"line line \"\n" 9638 " \"line\";", 9639 format("a << b << \"line line line\";", getLLVMStyleWithColumns(20))); 9640 // In a chain of << with three operands, the second can be broken with no line 9641 // break before it and the third must be broken with a line break before it. 9642 EXPECT_EQ("abcd << \"line line \"\n" 9643 " \"line\"\n" 9644 " << \"line line \"\n" 9645 " \"line\";", 9646 format("abcd << \"line line line\" << \"line line line\";", 9647 getLLVMStyleWithColumns(20))); 9648 // In a chain of binary operators with two operands, the second can be broken 9649 // with no line break before it. 9650 EXPECT_EQ( 9651 "abcd + \"line line \"\n" 9652 " \"line line\";", 9653 format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20))); 9654 // In a chain of binary operators with three operands, the second must be 9655 // broken with a line break before it. 9656 EXPECT_EQ("abcd +\n" 9657 " \"line line \"\n" 9658 " \"line line\" +\n" 9659 " e;", 9660 format("abcd + \"line line line line\" + e;", 9661 getLLVMStyleWithColumns(20))); 9662 // In a function call with two operands, with AlignAfterOpenBracket enabled, 9663 // the first must be broken with a line break before it. 9664 FormatStyle Style = getLLVMStyleWithColumns(25); 9665 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 9666 EXPECT_EQ("someFunction(\n" 9667 " \"long long long \"\n" 9668 " \"long\",\n" 9669 " a);", 9670 format("someFunction(\"long long long long\", a);", Style)); 9671 } 9672 9673 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 9674 EXPECT_EQ( 9675 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9676 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9677 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9678 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9679 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9680 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 9681 } 9682 9683 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 9684 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 9685 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 9686 EXPECT_EQ("fffffffffff(g(R\"x(\n" 9687 "multiline raw string literal xxxxxxxxxxxxxx\n" 9688 ")x\",\n" 9689 " a),\n" 9690 " b);", 9691 format("fffffffffff(g(R\"x(\n" 9692 "multiline raw string literal xxxxxxxxxxxxxx\n" 9693 ")x\", a), b);", 9694 getGoogleStyleWithColumns(20))); 9695 EXPECT_EQ("fffffffffff(\n" 9696 " g(R\"x(qqq\n" 9697 "multiline raw string literal xxxxxxxxxxxxxx\n" 9698 ")x\",\n" 9699 " a),\n" 9700 " b);", 9701 format("fffffffffff(g(R\"x(qqq\n" 9702 "multiline raw string literal xxxxxxxxxxxxxx\n" 9703 ")x\", a), b);", 9704 getGoogleStyleWithColumns(20))); 9705 9706 EXPECT_EQ("fffffffffff(R\"x(\n" 9707 "multiline raw string literal xxxxxxxxxxxxxx\n" 9708 ")x\");", 9709 format("fffffffffff(R\"x(\n" 9710 "multiline raw string literal xxxxxxxxxxxxxx\n" 9711 ")x\");", 9712 getGoogleStyleWithColumns(20))); 9713 EXPECT_EQ("fffffffffff(R\"x(\n" 9714 "multiline raw string literal xxxxxxxxxxxxxx\n" 9715 ")x\" + bbbbbb);", 9716 format("fffffffffff(R\"x(\n" 9717 "multiline raw string literal xxxxxxxxxxxxxx\n" 9718 ")x\" + bbbbbb);", 9719 getGoogleStyleWithColumns(20))); 9720 EXPECT_EQ("fffffffffff(\n" 9721 " R\"x(\n" 9722 "multiline raw string literal xxxxxxxxxxxxxx\n" 9723 ")x\" +\n" 9724 " bbbbbb);", 9725 format("fffffffffff(\n" 9726 " R\"x(\n" 9727 "multiline raw string literal xxxxxxxxxxxxxx\n" 9728 ")x\" + bbbbbb);", 9729 getGoogleStyleWithColumns(20))); 9730 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 9731 format("fffffffffff(\n" 9732 " R\"(single line raw string)\" + bbbbbb);")); 9733 } 9734 9735 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 9736 verifyFormat("string a = \"unterminated;"); 9737 EXPECT_EQ("function(\"unterminated,\n" 9738 " OtherParameter);", 9739 format("function( \"unterminated,\n" 9740 " OtherParameter);")); 9741 } 9742 9743 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9744 FormatStyle Style = getLLVMStyle(); 9745 Style.Standard = FormatStyle::LS_Cpp03; 9746 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9747 format("#define x(_a) printf(\"foo\"_a);", Style)); 9748 } 9749 9750 TEST_F(FormatTest, CppLexVersion) { 9751 FormatStyle Style = getLLVMStyle(); 9752 // Formatting of x * y differs if x is a type. 9753 verifyFormat("void foo() { MACRO(a * b); }", Style); 9754 verifyFormat("void foo() { MACRO(int *b); }", Style); 9755 9756 // LLVM style uses latest lexer. 9757 verifyFormat("void foo() { MACRO(char8_t *b); }", Style); 9758 Style.Standard = FormatStyle::LS_Cpp17; 9759 // But in c++17, char8_t isn't a keyword. 9760 verifyFormat("void foo() { MACRO(char8_t * b); }", Style); 9761 } 9762 9763 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9764 9765 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9766 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9767 " \"ddeeefff\");", 9768 format("someFunction(\"aaabbbcccdddeeefff\");", 9769 getLLVMStyleWithColumns(25))); 9770 EXPECT_EQ("someFunction1234567890(\n" 9771 " \"aaabbbcccdddeeefff\");", 9772 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9773 getLLVMStyleWithColumns(26))); 9774 EXPECT_EQ("someFunction1234567890(\n" 9775 " \"aaabbbcccdddeeeff\"\n" 9776 " \"f\");", 9777 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9778 getLLVMStyleWithColumns(25))); 9779 EXPECT_EQ("someFunction1234567890(\n" 9780 " \"aaabbbcccdddeeeff\"\n" 9781 " \"f\");", 9782 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9783 getLLVMStyleWithColumns(24))); 9784 EXPECT_EQ("someFunction(\n" 9785 " \"aaabbbcc ddde \"\n" 9786 " \"efff\");", 9787 format("someFunction(\"aaabbbcc ddde efff\");", 9788 getLLVMStyleWithColumns(25))); 9789 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9790 " \"ddeeefff\");", 9791 format("someFunction(\"aaabbbccc ddeeefff\");", 9792 getLLVMStyleWithColumns(25))); 9793 EXPECT_EQ("someFunction1234567890(\n" 9794 " \"aaabb \"\n" 9795 " \"cccdddeeefff\");", 9796 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9797 getLLVMStyleWithColumns(25))); 9798 EXPECT_EQ("#define A \\\n" 9799 " string s = \\\n" 9800 " \"123456789\" \\\n" 9801 " \"0\"; \\\n" 9802 " int i;", 9803 format("#define A string s = \"1234567890\"; int i;", 9804 getLLVMStyleWithColumns(20))); 9805 EXPECT_EQ("someFunction(\n" 9806 " \"aaabbbcc \"\n" 9807 " \"dddeeefff\");", 9808 format("someFunction(\"aaabbbcc dddeeefff\");", 9809 getLLVMStyleWithColumns(25))); 9810 } 9811 9812 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9813 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9814 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9815 EXPECT_EQ("\"test\"\n" 9816 "\"\\n\"", 9817 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9818 EXPECT_EQ("\"tes\\\\\"\n" 9819 "\"n\"", 9820 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9821 EXPECT_EQ("\"\\\\\\\\\"\n" 9822 "\"\\n\"", 9823 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9824 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9825 EXPECT_EQ("\"\\uff01\"\n" 9826 "\"test\"", 9827 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9828 EXPECT_EQ("\"\\Uff01ff02\"", 9829 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9830 EXPECT_EQ("\"\\x000000000001\"\n" 9831 "\"next\"", 9832 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9833 EXPECT_EQ("\"\\x000000000001next\"", 9834 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9835 EXPECT_EQ("\"\\x000000000001\"", 9836 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9837 EXPECT_EQ("\"test\"\n" 9838 "\"\\000000\"\n" 9839 "\"000001\"", 9840 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9841 EXPECT_EQ("\"test\\000\"\n" 9842 "\"00000000\"\n" 9843 "\"1\"", 9844 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9845 } 9846 9847 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9848 verifyFormat("void f() {\n" 9849 " return g() {}\n" 9850 " void h() {}"); 9851 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9852 "g();\n" 9853 "}"); 9854 } 9855 9856 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9857 verifyFormat( 9858 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9859 } 9860 9861 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9862 verifyFormat("class X {\n" 9863 " void f() {\n" 9864 " }\n" 9865 "};", 9866 getLLVMStyleWithColumns(12)); 9867 } 9868 9869 TEST_F(FormatTest, ConfigurableIndentWidth) { 9870 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9871 EightIndent.IndentWidth = 8; 9872 EightIndent.ContinuationIndentWidth = 8; 9873 verifyFormat("void f() {\n" 9874 " someFunction();\n" 9875 " if (true) {\n" 9876 " f();\n" 9877 " }\n" 9878 "}", 9879 EightIndent); 9880 verifyFormat("class X {\n" 9881 " void f() {\n" 9882 " }\n" 9883 "};", 9884 EightIndent); 9885 verifyFormat("int x[] = {\n" 9886 " call(),\n" 9887 " call()};", 9888 EightIndent); 9889 } 9890 9891 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9892 verifyFormat("double\n" 9893 "f();", 9894 getLLVMStyleWithColumns(8)); 9895 } 9896 9897 TEST_F(FormatTest, ConfigurableUseOfTab) { 9898 FormatStyle Tab = getLLVMStyleWithColumns(42); 9899 Tab.IndentWidth = 8; 9900 Tab.UseTab = FormatStyle::UT_Always; 9901 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9902 9903 EXPECT_EQ("if (aaaaaaaa && // q\n" 9904 " bb)\t\t// w\n" 9905 "\t;", 9906 format("if (aaaaaaaa &&// q\n" 9907 "bb)// w\n" 9908 ";", 9909 Tab)); 9910 EXPECT_EQ("if (aaa && bbb) // w\n" 9911 "\t;", 9912 format("if(aaa&&bbb)// w\n" 9913 ";", 9914 Tab)); 9915 9916 verifyFormat("class X {\n" 9917 "\tvoid f() {\n" 9918 "\t\tsomeFunction(parameter1,\n" 9919 "\t\t\t parameter2);\n" 9920 "\t}\n" 9921 "};", 9922 Tab); 9923 verifyFormat("#define A \\\n" 9924 "\tvoid f() { \\\n" 9925 "\t\tsomeFunction( \\\n" 9926 "\t\t parameter1, \\\n" 9927 "\t\t parameter2); \\\n" 9928 "\t}", 9929 Tab); 9930 verifyFormat("int a;\t // x\n" 9931 "int bbbbbbbb; // x\n", 9932 Tab); 9933 9934 Tab.TabWidth = 4; 9935 Tab.IndentWidth = 8; 9936 verifyFormat("class TabWidth4Indent8 {\n" 9937 "\t\tvoid f() {\n" 9938 "\t\t\t\tsomeFunction(parameter1,\n" 9939 "\t\t\t\t\t\t\t parameter2);\n" 9940 "\t\t}\n" 9941 "};", 9942 Tab); 9943 9944 Tab.TabWidth = 4; 9945 Tab.IndentWidth = 4; 9946 verifyFormat("class TabWidth4Indent4 {\n" 9947 "\tvoid f() {\n" 9948 "\t\tsomeFunction(parameter1,\n" 9949 "\t\t\t\t\t parameter2);\n" 9950 "\t}\n" 9951 "};", 9952 Tab); 9953 9954 Tab.TabWidth = 8; 9955 Tab.IndentWidth = 4; 9956 verifyFormat("class TabWidth8Indent4 {\n" 9957 " void f() {\n" 9958 "\tsomeFunction(parameter1,\n" 9959 "\t\t parameter2);\n" 9960 " }\n" 9961 "};", 9962 Tab); 9963 9964 Tab.TabWidth = 8; 9965 Tab.IndentWidth = 8; 9966 EXPECT_EQ("/*\n" 9967 "\t a\t\tcomment\n" 9968 "\t in multiple lines\n" 9969 " */", 9970 format(" /*\t \t \n" 9971 " \t \t a\t\tcomment\t \t\n" 9972 " \t \t in multiple lines\t\n" 9973 " \t */", 9974 Tab)); 9975 9976 Tab.UseTab = FormatStyle::UT_ForIndentation; 9977 verifyFormat("{\n" 9978 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9979 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9980 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9981 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9982 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9983 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9984 "};", 9985 Tab); 9986 verifyFormat("enum AA {\n" 9987 "\ta1, // Force multiple lines\n" 9988 "\ta2,\n" 9989 "\ta3\n" 9990 "};", 9991 Tab); 9992 EXPECT_EQ("if (aaaaaaaa && // q\n" 9993 " bb) // w\n" 9994 "\t;", 9995 format("if (aaaaaaaa &&// q\n" 9996 "bb)// w\n" 9997 ";", 9998 Tab)); 9999 verifyFormat("class X {\n" 10000 "\tvoid f() {\n" 10001 "\t\tsomeFunction(parameter1,\n" 10002 "\t\t parameter2);\n" 10003 "\t}\n" 10004 "};", 10005 Tab); 10006 verifyFormat("{\n" 10007 "\tQ(\n" 10008 "\t {\n" 10009 "\t\t int a;\n" 10010 "\t\t someFunction(aaaaaaaa,\n" 10011 "\t\t bbbbbbb);\n" 10012 "\t },\n" 10013 "\t p);\n" 10014 "}", 10015 Tab); 10016 EXPECT_EQ("{\n" 10017 "\t/* aaaa\n" 10018 "\t bbbb */\n" 10019 "}", 10020 format("{\n" 10021 "/* aaaa\n" 10022 " bbbb */\n" 10023 "}", 10024 Tab)); 10025 EXPECT_EQ("{\n" 10026 "\t/*\n" 10027 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10028 "\t bbbbbbbbbbbbb\n" 10029 "\t*/\n" 10030 "}", 10031 format("{\n" 10032 "/*\n" 10033 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10034 "*/\n" 10035 "}", 10036 Tab)); 10037 EXPECT_EQ("{\n" 10038 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10039 "\t// bbbbbbbbbbbbb\n" 10040 "}", 10041 format("{\n" 10042 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10043 "}", 10044 Tab)); 10045 EXPECT_EQ("{\n" 10046 "\t/*\n" 10047 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10048 "\t bbbbbbbbbbbbb\n" 10049 "\t*/\n" 10050 "}", 10051 format("{\n" 10052 "\t/*\n" 10053 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10054 "\t*/\n" 10055 "}", 10056 Tab)); 10057 EXPECT_EQ("{\n" 10058 "\t/*\n" 10059 "\n" 10060 "\t*/\n" 10061 "}", 10062 format("{\n" 10063 "\t/*\n" 10064 "\n" 10065 "\t*/\n" 10066 "}", 10067 Tab)); 10068 EXPECT_EQ("{\n" 10069 "\t/*\n" 10070 " asdf\n" 10071 "\t*/\n" 10072 "}", 10073 format("{\n" 10074 "\t/*\n" 10075 " asdf\n" 10076 "\t*/\n" 10077 "}", 10078 Tab)); 10079 10080 Tab.UseTab = FormatStyle::UT_Never; 10081 EXPECT_EQ("/*\n" 10082 " a\t\tcomment\n" 10083 " in multiple lines\n" 10084 " */", 10085 format(" /*\t \t \n" 10086 " \t \t a\t\tcomment\t \t\n" 10087 " \t \t in multiple lines\t\n" 10088 " \t */", 10089 Tab)); 10090 EXPECT_EQ("/* some\n" 10091 " comment */", 10092 format(" \t \t /* some\n" 10093 " \t \t comment */", 10094 Tab)); 10095 EXPECT_EQ("int a; /* some\n" 10096 " comment */", 10097 format(" \t \t int a; /* some\n" 10098 " \t \t comment */", 10099 Tab)); 10100 10101 EXPECT_EQ("int a; /* some\n" 10102 "comment */", 10103 format(" \t \t int\ta; /* some\n" 10104 " \t \t comment */", 10105 Tab)); 10106 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10107 " comment */", 10108 format(" \t \t f(\"\t\t\"); /* some\n" 10109 " \t \t comment */", 10110 Tab)); 10111 EXPECT_EQ("{\n" 10112 " /*\n" 10113 " * Comment\n" 10114 " */\n" 10115 " int i;\n" 10116 "}", 10117 format("{\n" 10118 "\t/*\n" 10119 "\t * Comment\n" 10120 "\t */\n" 10121 "\t int i;\n" 10122 "}")); 10123 10124 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10125 Tab.TabWidth = 8; 10126 Tab.IndentWidth = 8; 10127 EXPECT_EQ("if (aaaaaaaa && // q\n" 10128 " bb) // w\n" 10129 "\t;", 10130 format("if (aaaaaaaa &&// q\n" 10131 "bb)// w\n" 10132 ";", 10133 Tab)); 10134 EXPECT_EQ("if (aaa && bbb) // w\n" 10135 "\t;", 10136 format("if(aaa&&bbb)// w\n" 10137 ";", 10138 Tab)); 10139 verifyFormat("class X {\n" 10140 "\tvoid f() {\n" 10141 "\t\tsomeFunction(parameter1,\n" 10142 "\t\t\t parameter2);\n" 10143 "\t}\n" 10144 "};", 10145 Tab); 10146 verifyFormat("#define A \\\n" 10147 "\tvoid f() { \\\n" 10148 "\t\tsomeFunction( \\\n" 10149 "\t\t parameter1, \\\n" 10150 "\t\t parameter2); \\\n" 10151 "\t}", 10152 Tab); 10153 Tab.TabWidth = 4; 10154 Tab.IndentWidth = 8; 10155 verifyFormat("class TabWidth4Indent8 {\n" 10156 "\t\tvoid f() {\n" 10157 "\t\t\t\tsomeFunction(parameter1,\n" 10158 "\t\t\t\t\t\t\t parameter2);\n" 10159 "\t\t}\n" 10160 "};", 10161 Tab); 10162 Tab.TabWidth = 4; 10163 Tab.IndentWidth = 4; 10164 verifyFormat("class TabWidth4Indent4 {\n" 10165 "\tvoid f() {\n" 10166 "\t\tsomeFunction(parameter1,\n" 10167 "\t\t\t\t\t parameter2);\n" 10168 "\t}\n" 10169 "};", 10170 Tab); 10171 Tab.TabWidth = 8; 10172 Tab.IndentWidth = 4; 10173 verifyFormat("class TabWidth8Indent4 {\n" 10174 " void f() {\n" 10175 "\tsomeFunction(parameter1,\n" 10176 "\t\t parameter2);\n" 10177 " }\n" 10178 "};", 10179 Tab); 10180 Tab.TabWidth = 8; 10181 Tab.IndentWidth = 8; 10182 EXPECT_EQ("/*\n" 10183 "\t a\t\tcomment\n" 10184 "\t in multiple lines\n" 10185 " */", 10186 format(" /*\t \t \n" 10187 " \t \t a\t\tcomment\t \t\n" 10188 " \t \t in multiple lines\t\n" 10189 " \t */", 10190 Tab)); 10191 verifyFormat("{\n" 10192 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10193 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10194 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10195 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10196 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10197 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10198 "};", 10199 Tab); 10200 verifyFormat("enum AA {\n" 10201 "\ta1, // Force multiple lines\n" 10202 "\ta2,\n" 10203 "\ta3\n" 10204 "};", 10205 Tab); 10206 EXPECT_EQ("if (aaaaaaaa && // q\n" 10207 " bb) // w\n" 10208 "\t;", 10209 format("if (aaaaaaaa &&// q\n" 10210 "bb)// w\n" 10211 ";", 10212 Tab)); 10213 verifyFormat("class X {\n" 10214 "\tvoid f() {\n" 10215 "\t\tsomeFunction(parameter1,\n" 10216 "\t\t\t parameter2);\n" 10217 "\t}\n" 10218 "};", 10219 Tab); 10220 verifyFormat("{\n" 10221 "\tQ(\n" 10222 "\t {\n" 10223 "\t\t int a;\n" 10224 "\t\t someFunction(aaaaaaaa,\n" 10225 "\t\t\t\t bbbbbbb);\n" 10226 "\t },\n" 10227 "\t p);\n" 10228 "}", 10229 Tab); 10230 EXPECT_EQ("{\n" 10231 "\t/* aaaa\n" 10232 "\t bbbb */\n" 10233 "}", 10234 format("{\n" 10235 "/* aaaa\n" 10236 " bbbb */\n" 10237 "}", 10238 Tab)); 10239 EXPECT_EQ("{\n" 10240 "\t/*\n" 10241 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10242 "\t bbbbbbbbbbbbb\n" 10243 "\t*/\n" 10244 "}", 10245 format("{\n" 10246 "/*\n" 10247 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10248 "*/\n" 10249 "}", 10250 Tab)); 10251 EXPECT_EQ("{\n" 10252 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10253 "\t// bbbbbbbbbbbbb\n" 10254 "}", 10255 format("{\n" 10256 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10257 "}", 10258 Tab)); 10259 EXPECT_EQ("{\n" 10260 "\t/*\n" 10261 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10262 "\t bbbbbbbbbbbbb\n" 10263 "\t*/\n" 10264 "}", 10265 format("{\n" 10266 "\t/*\n" 10267 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10268 "\t*/\n" 10269 "}", 10270 Tab)); 10271 EXPECT_EQ("{\n" 10272 "\t/*\n" 10273 "\n" 10274 "\t*/\n" 10275 "}", 10276 format("{\n" 10277 "\t/*\n" 10278 "\n" 10279 "\t*/\n" 10280 "}", 10281 Tab)); 10282 EXPECT_EQ("{\n" 10283 "\t/*\n" 10284 " asdf\n" 10285 "\t*/\n" 10286 "}", 10287 format("{\n" 10288 "\t/*\n" 10289 " asdf\n" 10290 "\t*/\n" 10291 "}", 10292 Tab)); 10293 EXPECT_EQ("/*\n" 10294 "\t a\t\tcomment\n" 10295 "\t in multiple lines\n" 10296 " */", 10297 format(" /*\t \t \n" 10298 " \t \t a\t\tcomment\t \t\n" 10299 " \t \t in multiple lines\t\n" 10300 " \t */", 10301 Tab)); 10302 EXPECT_EQ("/* some\n" 10303 " comment */", 10304 format(" \t \t /* some\n" 10305 " \t \t comment */", 10306 Tab)); 10307 EXPECT_EQ("int a; /* some\n" 10308 " comment */", 10309 format(" \t \t int a; /* some\n" 10310 " \t \t comment */", 10311 Tab)); 10312 EXPECT_EQ("int a; /* some\n" 10313 "comment */", 10314 format(" \t \t int\ta; /* some\n" 10315 " \t \t comment */", 10316 Tab)); 10317 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10318 " comment */", 10319 format(" \t \t f(\"\t\t\"); /* some\n" 10320 " \t \t comment */", 10321 Tab)); 10322 EXPECT_EQ("{\n" 10323 " /*\n" 10324 " * Comment\n" 10325 " */\n" 10326 " int i;\n" 10327 "}", 10328 format("{\n" 10329 "\t/*\n" 10330 "\t * Comment\n" 10331 "\t */\n" 10332 "\t int i;\n" 10333 "}")); 10334 Tab.AlignConsecutiveAssignments = true; 10335 Tab.AlignConsecutiveDeclarations = true; 10336 Tab.TabWidth = 4; 10337 Tab.IndentWidth = 4; 10338 verifyFormat("class Assign {\n" 10339 "\tvoid f() {\n" 10340 "\t\tint x = 123;\n" 10341 "\t\tint random = 4;\n" 10342 "\t\tstd::string alphabet =\n" 10343 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 10344 "\t}\n" 10345 "};", 10346 Tab); 10347 } 10348 10349 TEST_F(FormatTest, ZeroTabWidth) { 10350 FormatStyle Tab = getLLVMStyleWithColumns(42); 10351 Tab.IndentWidth = 8; 10352 Tab.UseTab = FormatStyle::UT_Never; 10353 Tab.TabWidth = 0; 10354 EXPECT_EQ("void a(){\n" 10355 " // line starts with '\t'\n" 10356 "};", 10357 format("void a(){\n" 10358 "\t// line starts with '\t'\n" 10359 "};", 10360 Tab)); 10361 10362 EXPECT_EQ("void a(){\n" 10363 " // line starts with '\t'\n" 10364 "};", 10365 format("void a(){\n" 10366 "\t\t// line starts with '\t'\n" 10367 "};", 10368 Tab)); 10369 10370 Tab.UseTab = FormatStyle::UT_ForIndentation; 10371 EXPECT_EQ("void a(){\n" 10372 " // line starts with '\t'\n" 10373 "};", 10374 format("void a(){\n" 10375 "\t// line starts with '\t'\n" 10376 "};", 10377 Tab)); 10378 10379 EXPECT_EQ("void a(){\n" 10380 " // line starts with '\t'\n" 10381 "};", 10382 format("void a(){\n" 10383 "\t\t// line starts with '\t'\n" 10384 "};", 10385 Tab)); 10386 10387 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10388 EXPECT_EQ("void a(){\n" 10389 " // line starts with '\t'\n" 10390 "};", 10391 format("void a(){\n" 10392 "\t// line starts with '\t'\n" 10393 "};", 10394 Tab)); 10395 10396 EXPECT_EQ("void a(){\n" 10397 " // line starts with '\t'\n" 10398 "};", 10399 format("void a(){\n" 10400 "\t\t// line starts with '\t'\n" 10401 "};", 10402 Tab)); 10403 10404 Tab.UseTab = FormatStyle::UT_Always; 10405 EXPECT_EQ("void a(){\n" 10406 "// line starts with '\t'\n" 10407 "};", 10408 format("void a(){\n" 10409 "\t// line starts with '\t'\n" 10410 "};", 10411 Tab)); 10412 10413 EXPECT_EQ("void a(){\n" 10414 "// line starts with '\t'\n" 10415 "};", 10416 format("void a(){\n" 10417 "\t\t// line starts with '\t'\n" 10418 "};", 10419 Tab)); 10420 } 10421 10422 TEST_F(FormatTest, CalculatesOriginalColumn) { 10423 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10424 "q\"; /* some\n" 10425 " comment */", 10426 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10427 "q\"; /* some\n" 10428 " comment */", 10429 getLLVMStyle())); 10430 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10431 "/* some\n" 10432 " comment */", 10433 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10434 " /* some\n" 10435 " comment */", 10436 getLLVMStyle())); 10437 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10438 "qqq\n" 10439 "/* some\n" 10440 " comment */", 10441 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10442 "qqq\n" 10443 " /* some\n" 10444 " comment */", 10445 getLLVMStyle())); 10446 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10447 "wwww; /* some\n" 10448 " comment */", 10449 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10450 "wwww; /* some\n" 10451 " comment */", 10452 getLLVMStyle())); 10453 } 10454 10455 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 10456 FormatStyle NoSpace = getLLVMStyle(); 10457 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 10458 10459 verifyFormat("while(true)\n" 10460 " continue;", 10461 NoSpace); 10462 verifyFormat("for(;;)\n" 10463 " continue;", 10464 NoSpace); 10465 verifyFormat("if(true)\n" 10466 " f();\n" 10467 "else if(true)\n" 10468 " f();", 10469 NoSpace); 10470 verifyFormat("do {\n" 10471 " do_something();\n" 10472 "} while(something());", 10473 NoSpace); 10474 verifyFormat("switch(x) {\n" 10475 "default:\n" 10476 " break;\n" 10477 "}", 10478 NoSpace); 10479 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 10480 verifyFormat("size_t x = sizeof(x);", NoSpace); 10481 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 10482 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 10483 verifyFormat("alignas(128) char a[128];", NoSpace); 10484 verifyFormat("size_t x = alignof(MyType);", NoSpace); 10485 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 10486 verifyFormat("int f() throw(Deprecated);", NoSpace); 10487 verifyFormat("typedef void (*cb)(int);", NoSpace); 10488 verifyFormat("T A::operator()();", NoSpace); 10489 verifyFormat("X A::operator++(T);", NoSpace); 10490 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 10491 10492 FormatStyle Space = getLLVMStyle(); 10493 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 10494 10495 verifyFormat("int f ();", Space); 10496 verifyFormat("void f (int a, T b) {\n" 10497 " while (true)\n" 10498 " continue;\n" 10499 "}", 10500 Space); 10501 verifyFormat("if (true)\n" 10502 " f ();\n" 10503 "else if (true)\n" 10504 " f ();", 10505 Space); 10506 verifyFormat("do {\n" 10507 " do_something ();\n" 10508 "} while (something ());", 10509 Space); 10510 verifyFormat("switch (x) {\n" 10511 "default:\n" 10512 " break;\n" 10513 "}", 10514 Space); 10515 verifyFormat("A::A () : a (1) {}", Space); 10516 verifyFormat("void f () __attribute__ ((asdf));", Space); 10517 verifyFormat("*(&a + 1);\n" 10518 "&((&a)[1]);\n" 10519 "a[(b + c) * d];\n" 10520 "(((a + 1) * 2) + 3) * 4;", 10521 Space); 10522 verifyFormat("#define A(x) x", Space); 10523 verifyFormat("#define A (x) x", Space); 10524 verifyFormat("#if defined(x)\n" 10525 "#endif", 10526 Space); 10527 verifyFormat("auto i = std::make_unique<int> (5);", Space); 10528 verifyFormat("size_t x = sizeof (x);", Space); 10529 verifyFormat("auto f (int x) -> decltype (x);", Space); 10530 verifyFormat("int f (T x) noexcept (x.create ());", Space); 10531 verifyFormat("alignas (128) char a[128];", Space); 10532 verifyFormat("size_t x = alignof (MyType);", Space); 10533 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 10534 verifyFormat("int f () throw (Deprecated);", Space); 10535 verifyFormat("typedef void (*cb) (int);", Space); 10536 verifyFormat("T A::operator() ();", Space); 10537 verifyFormat("X A::operator++ (T);", Space); 10538 verifyFormat("auto lambda = [] () { return 0; };", Space); 10539 verifyFormat("int x = int (y);", Space); 10540 10541 FormatStyle SomeSpace = getLLVMStyle(); 10542 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 10543 10544 verifyFormat("[]() -> float {}", SomeSpace); 10545 verifyFormat("[] (auto foo) {}", SomeSpace); 10546 verifyFormat("[foo]() -> int {}", SomeSpace); 10547 verifyFormat("int f();", SomeSpace); 10548 verifyFormat("void f (int a, T b) {\n" 10549 " while (true)\n" 10550 " continue;\n" 10551 "}", 10552 SomeSpace); 10553 verifyFormat("if (true)\n" 10554 " f();\n" 10555 "else if (true)\n" 10556 " f();", 10557 SomeSpace); 10558 verifyFormat("do {\n" 10559 " do_something();\n" 10560 "} while (something());", 10561 SomeSpace); 10562 verifyFormat("switch (x) {\n" 10563 "default:\n" 10564 " break;\n" 10565 "}", 10566 SomeSpace); 10567 verifyFormat("A::A() : a (1) {}", SomeSpace); 10568 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 10569 verifyFormat("*(&a + 1);\n" 10570 "&((&a)[1]);\n" 10571 "a[(b + c) * d];\n" 10572 "(((a + 1) * 2) + 3) * 4;", 10573 SomeSpace); 10574 verifyFormat("#define A(x) x", SomeSpace); 10575 verifyFormat("#define A (x) x", SomeSpace); 10576 verifyFormat("#if defined(x)\n" 10577 "#endif", 10578 SomeSpace); 10579 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 10580 verifyFormat("size_t x = sizeof (x);", SomeSpace); 10581 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 10582 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 10583 verifyFormat("alignas (128) char a[128];", SomeSpace); 10584 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 10585 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 10586 SomeSpace); 10587 verifyFormat("int f() throw (Deprecated);", SomeSpace); 10588 verifyFormat("typedef void (*cb) (int);", SomeSpace); 10589 verifyFormat("T A::operator()();", SomeSpace); 10590 verifyFormat("X A::operator++ (T);", SomeSpace); 10591 verifyFormat("int x = int (y);", SomeSpace); 10592 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 10593 } 10594 10595 TEST_F(FormatTest, SpaceAfterLogicalNot) { 10596 FormatStyle Spaces = getLLVMStyle(); 10597 Spaces.SpaceAfterLogicalNot = true; 10598 10599 verifyFormat("bool x = ! y", Spaces); 10600 verifyFormat("if (! isFailure())", Spaces); 10601 verifyFormat("if (! (a && b))", Spaces); 10602 verifyFormat("\"Error!\"", Spaces); 10603 verifyFormat("! ! x", Spaces); 10604 } 10605 10606 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 10607 FormatStyle Spaces = getLLVMStyle(); 10608 10609 Spaces.SpacesInParentheses = true; 10610 verifyFormat("do_something( ::globalVar );", Spaces); 10611 verifyFormat("call( x, y, z );", Spaces); 10612 verifyFormat("call();", Spaces); 10613 verifyFormat("std::function<void( int, int )> callback;", Spaces); 10614 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 10615 Spaces); 10616 verifyFormat("while ( (bool)1 )\n" 10617 " continue;", 10618 Spaces); 10619 verifyFormat("for ( ;; )\n" 10620 " continue;", 10621 Spaces); 10622 verifyFormat("if ( true )\n" 10623 " f();\n" 10624 "else if ( true )\n" 10625 " f();", 10626 Spaces); 10627 verifyFormat("do {\n" 10628 " do_something( (int)i );\n" 10629 "} while ( something() );", 10630 Spaces); 10631 verifyFormat("switch ( x ) {\n" 10632 "default:\n" 10633 " break;\n" 10634 "}", 10635 Spaces); 10636 10637 Spaces.SpacesInParentheses = false; 10638 Spaces.SpacesInCStyleCastParentheses = true; 10639 verifyFormat("Type *A = ( Type * )P;", Spaces); 10640 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 10641 verifyFormat("x = ( int32 )y;", Spaces); 10642 verifyFormat("int a = ( int )(2.0f);", Spaces); 10643 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 10644 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 10645 verifyFormat("#define x (( int )-1)", Spaces); 10646 10647 // Run the first set of tests again with: 10648 Spaces.SpacesInParentheses = false; 10649 Spaces.SpaceInEmptyParentheses = true; 10650 Spaces.SpacesInCStyleCastParentheses = true; 10651 verifyFormat("call(x, y, z);", Spaces); 10652 verifyFormat("call( );", Spaces); 10653 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10654 verifyFormat("while (( bool )1)\n" 10655 " continue;", 10656 Spaces); 10657 verifyFormat("for (;;)\n" 10658 " continue;", 10659 Spaces); 10660 verifyFormat("if (true)\n" 10661 " f( );\n" 10662 "else if (true)\n" 10663 " f( );", 10664 Spaces); 10665 verifyFormat("do {\n" 10666 " do_something(( int )i);\n" 10667 "} while (something( ));", 10668 Spaces); 10669 verifyFormat("switch (x) {\n" 10670 "default:\n" 10671 " break;\n" 10672 "}", 10673 Spaces); 10674 10675 // Run the first set of tests again with: 10676 Spaces.SpaceAfterCStyleCast = true; 10677 verifyFormat("call(x, y, z);", Spaces); 10678 verifyFormat("call( );", Spaces); 10679 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10680 verifyFormat("while (( bool ) 1)\n" 10681 " continue;", 10682 Spaces); 10683 verifyFormat("for (;;)\n" 10684 " continue;", 10685 Spaces); 10686 verifyFormat("if (true)\n" 10687 " f( );\n" 10688 "else if (true)\n" 10689 " f( );", 10690 Spaces); 10691 verifyFormat("do {\n" 10692 " do_something(( int ) i);\n" 10693 "} while (something( ));", 10694 Spaces); 10695 verifyFormat("switch (x) {\n" 10696 "default:\n" 10697 " break;\n" 10698 "}", 10699 Spaces); 10700 10701 // Run subset of tests again with: 10702 Spaces.SpacesInCStyleCastParentheses = false; 10703 Spaces.SpaceAfterCStyleCast = true; 10704 verifyFormat("while ((bool) 1)\n" 10705 " continue;", 10706 Spaces); 10707 verifyFormat("do {\n" 10708 " do_something((int) i);\n" 10709 "} while (something( ));", 10710 Spaces); 10711 } 10712 10713 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 10714 verifyFormat("int a[5];"); 10715 verifyFormat("a[3] += 42;"); 10716 10717 FormatStyle Spaces = getLLVMStyle(); 10718 Spaces.SpacesInSquareBrackets = true; 10719 // Not lambdas. 10720 verifyFormat("int a[ 5 ];", Spaces); 10721 verifyFormat("a[ 3 ] += 42;", Spaces); 10722 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 10723 verifyFormat("double &operator[](int i) { return 0; }\n" 10724 "int i;", 10725 Spaces); 10726 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 10727 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 10728 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 10729 // Lambdas. 10730 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 10731 verifyFormat("return [ i, args... ] {};", Spaces); 10732 verifyFormat("int foo = [ &bar ]() {};", Spaces); 10733 verifyFormat("int foo = [ = ]() {};", Spaces); 10734 verifyFormat("int foo = [ & ]() {};", Spaces); 10735 verifyFormat("int foo = [ =, &bar ]() {};", Spaces); 10736 verifyFormat("int foo = [ &bar, = ]() {};", Spaces); 10737 } 10738 10739 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) { 10740 FormatStyle NoSpaceStyle = getLLVMStyle(); 10741 verifyFormat("int a[5];", NoSpaceStyle); 10742 verifyFormat("a[3] += 42;", NoSpaceStyle); 10743 10744 verifyFormat("int a[1];", NoSpaceStyle); 10745 verifyFormat("int 1 [a];", NoSpaceStyle); 10746 verifyFormat("int a[1][2];", NoSpaceStyle); 10747 verifyFormat("a[7] = 5;", NoSpaceStyle); 10748 verifyFormat("int a = (f())[23];", NoSpaceStyle); 10749 verifyFormat("f([] {})", NoSpaceStyle); 10750 10751 FormatStyle Space = getLLVMStyle(); 10752 Space.SpaceBeforeSquareBrackets = true; 10753 verifyFormat("int c = []() -> int { return 2; }();\n", Space); 10754 verifyFormat("return [i, args...] {};", Space); 10755 10756 verifyFormat("int a [5];", Space); 10757 verifyFormat("a [3] += 42;", Space); 10758 verifyFormat("constexpr char hello []{\"hello\"};", Space); 10759 verifyFormat("double &operator[](int i) { return 0; }\n" 10760 "int i;", 10761 Space); 10762 verifyFormat("std::unique_ptr<int []> foo() {}", Space); 10763 verifyFormat("int i = a [a][a]->f();", Space); 10764 verifyFormat("int i = (*b) [a]->f();", Space); 10765 10766 verifyFormat("int a [1];", Space); 10767 verifyFormat("int 1 [a];", Space); 10768 verifyFormat("int a [1][2];", Space); 10769 verifyFormat("a [7] = 5;", Space); 10770 verifyFormat("int a = (f()) [23];", Space); 10771 verifyFormat("f([] {})", Space); 10772 } 10773 10774 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 10775 verifyFormat("int a = 5;"); 10776 verifyFormat("a += 42;"); 10777 verifyFormat("a or_eq 8;"); 10778 10779 FormatStyle Spaces = getLLVMStyle(); 10780 Spaces.SpaceBeforeAssignmentOperators = false; 10781 verifyFormat("int a= 5;", Spaces); 10782 verifyFormat("a+= 42;", Spaces); 10783 verifyFormat("a or_eq 8;", Spaces); 10784 } 10785 10786 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 10787 verifyFormat("class Foo : public Bar {};"); 10788 verifyFormat("Foo::Foo() : foo(1) {}"); 10789 verifyFormat("for (auto a : b) {\n}"); 10790 verifyFormat("int x = a ? b : c;"); 10791 verifyFormat("{\n" 10792 "label0:\n" 10793 " int x = 0;\n" 10794 "}"); 10795 verifyFormat("switch (x) {\n" 10796 "case 1:\n" 10797 "default:\n" 10798 "}"); 10799 10800 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 10801 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 10802 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 10803 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 10804 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 10805 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 10806 verifyFormat("{\n" 10807 "label1:\n" 10808 " int x = 0;\n" 10809 "}", 10810 CtorInitializerStyle); 10811 verifyFormat("switch (x) {\n" 10812 "case 1:\n" 10813 "default:\n" 10814 "}", 10815 CtorInitializerStyle); 10816 CtorInitializerStyle.BreakConstructorInitializers = 10817 FormatStyle::BCIS_AfterColon; 10818 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 10819 " aaaaaaaaaaaaaaaa(1),\n" 10820 " bbbbbbbbbbbbbbbb(2) {}", 10821 CtorInitializerStyle); 10822 CtorInitializerStyle.BreakConstructorInitializers = 10823 FormatStyle::BCIS_BeforeComma; 10824 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10825 " : aaaaaaaaaaaaaaaa(1)\n" 10826 " , bbbbbbbbbbbbbbbb(2) {}", 10827 CtorInitializerStyle); 10828 CtorInitializerStyle.BreakConstructorInitializers = 10829 FormatStyle::BCIS_BeforeColon; 10830 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10831 " : aaaaaaaaaaaaaaaa(1),\n" 10832 " bbbbbbbbbbbbbbbb(2) {}", 10833 CtorInitializerStyle); 10834 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 10835 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10836 ": aaaaaaaaaaaaaaaa(1),\n" 10837 " bbbbbbbbbbbbbbbb(2) {}", 10838 CtorInitializerStyle); 10839 10840 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 10841 InheritanceStyle.SpaceBeforeInheritanceColon = false; 10842 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 10843 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 10844 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 10845 verifyFormat("int x = a ? b : c;", InheritanceStyle); 10846 verifyFormat("{\n" 10847 "label2:\n" 10848 " int x = 0;\n" 10849 "}", 10850 InheritanceStyle); 10851 verifyFormat("switch (x) {\n" 10852 "case 1:\n" 10853 "default:\n" 10854 "}", 10855 InheritanceStyle); 10856 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 10857 verifyFormat("class Foooooooooooooooooooooo:\n" 10858 " public aaaaaaaaaaaaaaaaaa,\n" 10859 " public bbbbbbbbbbbbbbbbbb {\n" 10860 "}", 10861 InheritanceStyle); 10862 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 10863 verifyFormat("class Foooooooooooooooooooooo\n" 10864 " : public aaaaaaaaaaaaaaaaaa\n" 10865 " , public bbbbbbbbbbbbbbbbbb {\n" 10866 "}", 10867 InheritanceStyle); 10868 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 10869 verifyFormat("class Foooooooooooooooooooooo\n" 10870 " : public aaaaaaaaaaaaaaaaaa,\n" 10871 " public bbbbbbbbbbbbbbbbbb {\n" 10872 "}", 10873 InheritanceStyle); 10874 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 10875 verifyFormat("class Foooooooooooooooooooooo\n" 10876 ": public aaaaaaaaaaaaaaaaaa,\n" 10877 " public bbbbbbbbbbbbbbbbbb {}", 10878 InheritanceStyle); 10879 10880 FormatStyle ForLoopStyle = getLLVMStyle(); 10881 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 10882 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 10883 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 10884 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 10885 verifyFormat("int x = a ? b : c;", ForLoopStyle); 10886 verifyFormat("{\n" 10887 "label2:\n" 10888 " int x = 0;\n" 10889 "}", 10890 ForLoopStyle); 10891 verifyFormat("switch (x) {\n" 10892 "case 1:\n" 10893 "default:\n" 10894 "}", 10895 ForLoopStyle); 10896 10897 FormatStyle NoSpaceStyle = getLLVMStyle(); 10898 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 10899 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 10900 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 10901 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 10902 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 10903 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 10904 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 10905 verifyFormat("{\n" 10906 "label3:\n" 10907 " int x = 0;\n" 10908 "}", 10909 NoSpaceStyle); 10910 verifyFormat("switch (x) {\n" 10911 "case 1:\n" 10912 "default:\n" 10913 "}", 10914 NoSpaceStyle); 10915 } 10916 10917 TEST_F(FormatTest, AlignConsecutiveMacros) { 10918 FormatStyle Style = getLLVMStyle(); 10919 Style.AlignConsecutiveAssignments = true; 10920 Style.AlignConsecutiveDeclarations = true; 10921 Style.AlignConsecutiveMacros = false; 10922 10923 verifyFormat("#define a 3\n" 10924 "#define bbbb 4\n" 10925 "#define ccc (5)", 10926 Style); 10927 10928 verifyFormat("#define f(x) (x * x)\n" 10929 "#define fff(x, y, z) (x * y + z)\n" 10930 "#define ffff(x, y) (x - y)", 10931 Style); 10932 10933 verifyFormat("#define foo(x, y) (x + y)\n" 10934 "#define bar (5, 6)(2 + 2)", 10935 Style); 10936 10937 verifyFormat("#define a 3\n" 10938 "#define bbbb 4\n" 10939 "#define ccc (5)\n" 10940 "#define f(x) (x * x)\n" 10941 "#define fff(x, y, z) (x * y + z)\n" 10942 "#define ffff(x, y) (x - y)", 10943 Style); 10944 10945 Style.AlignConsecutiveMacros = true; 10946 verifyFormat("#define a 3\n" 10947 "#define bbbb 4\n" 10948 "#define ccc (5)", 10949 Style); 10950 10951 verifyFormat("#define f(x) (x * x)\n" 10952 "#define fff(x, y, z) (x * y + z)\n" 10953 "#define ffff(x, y) (x - y)", 10954 Style); 10955 10956 verifyFormat("#define foo(x, y) (x + y)\n" 10957 "#define bar (5, 6)(2 + 2)", 10958 Style); 10959 10960 verifyFormat("#define a 3\n" 10961 "#define bbbb 4\n" 10962 "#define ccc (5)\n" 10963 "#define f(x) (x * x)\n" 10964 "#define fff(x, y, z) (x * y + z)\n" 10965 "#define ffff(x, y) (x - y)", 10966 Style); 10967 10968 verifyFormat("#define a 5\n" 10969 "#define foo(x, y) (x + y)\n" 10970 "#define CCC (6)\n" 10971 "auto lambda = []() {\n" 10972 " auto ii = 0;\n" 10973 " float j = 0;\n" 10974 " return 0;\n" 10975 "};\n" 10976 "int i = 0;\n" 10977 "float i2 = 0;\n" 10978 "auto v = type{\n" 10979 " i = 1, //\n" 10980 " (i = 2), //\n" 10981 " i = 3 //\n" 10982 "};", 10983 Style); 10984 10985 Style.AlignConsecutiveMacros = false; 10986 Style.ColumnLimit = 20; 10987 10988 verifyFormat("#define a \\\n" 10989 " \"aabbbbbbbbbbbb\"\n" 10990 "#define D \\\n" 10991 " \"aabbbbbbbbbbbb\" \\\n" 10992 " \"ccddeeeeeeeee\"\n" 10993 "#define B \\\n" 10994 " \"QQQQQQQQQQQQQ\" \\\n" 10995 " \"FFFFFFFFFFFFF\" \\\n" 10996 " \"LLLLLLLL\"\n", 10997 Style); 10998 10999 Style.AlignConsecutiveMacros = true; 11000 verifyFormat("#define a \\\n" 11001 " \"aabbbbbbbbbbbb\"\n" 11002 "#define D \\\n" 11003 " \"aabbbbbbbbbbbb\" \\\n" 11004 " \"ccddeeeeeeeee\"\n" 11005 "#define B \\\n" 11006 " \"QQQQQQQQQQQQQ\" \\\n" 11007 " \"FFFFFFFFFFFFF\" \\\n" 11008 " \"LLLLLLLL\"\n", 11009 Style); 11010 } 11011 11012 TEST_F(FormatTest, AlignConsecutiveAssignments) { 11013 FormatStyle Alignment = getLLVMStyle(); 11014 Alignment.AlignConsecutiveMacros = true; 11015 Alignment.AlignConsecutiveAssignments = false; 11016 verifyFormat("int a = 5;\n" 11017 "int oneTwoThree = 123;", 11018 Alignment); 11019 verifyFormat("int a = 5;\n" 11020 "int oneTwoThree = 123;", 11021 Alignment); 11022 11023 Alignment.AlignConsecutiveAssignments = true; 11024 verifyFormat("int a = 5;\n" 11025 "int oneTwoThree = 123;", 11026 Alignment); 11027 verifyFormat("int a = method();\n" 11028 "int oneTwoThree = 133;", 11029 Alignment); 11030 verifyFormat("a &= 5;\n" 11031 "bcd *= 5;\n" 11032 "ghtyf += 5;\n" 11033 "dvfvdb -= 5;\n" 11034 "a /= 5;\n" 11035 "vdsvsv %= 5;\n" 11036 "sfdbddfbdfbb ^= 5;\n" 11037 "dvsdsv |= 5;\n" 11038 "int dsvvdvsdvvv = 123;", 11039 Alignment); 11040 verifyFormat("int i = 1, j = 10;\n" 11041 "something = 2000;", 11042 Alignment); 11043 verifyFormat("something = 2000;\n" 11044 "int i = 1, j = 10;\n", 11045 Alignment); 11046 verifyFormat("something = 2000;\n" 11047 "another = 911;\n" 11048 "int i = 1, j = 10;\n" 11049 "oneMore = 1;\n" 11050 "i = 2;", 11051 Alignment); 11052 verifyFormat("int a = 5;\n" 11053 "int one = 1;\n" 11054 "method();\n" 11055 "int oneTwoThree = 123;\n" 11056 "int oneTwo = 12;", 11057 Alignment); 11058 verifyFormat("int oneTwoThree = 123;\n" 11059 "int oneTwo = 12;\n" 11060 "method();\n", 11061 Alignment); 11062 verifyFormat("int oneTwoThree = 123; // comment\n" 11063 "int oneTwo = 12; // comment", 11064 Alignment); 11065 EXPECT_EQ("int a = 5;\n" 11066 "\n" 11067 "int oneTwoThree = 123;", 11068 format("int a = 5;\n" 11069 "\n" 11070 "int oneTwoThree= 123;", 11071 Alignment)); 11072 EXPECT_EQ("int a = 5;\n" 11073 "int one = 1;\n" 11074 "\n" 11075 "int oneTwoThree = 123;", 11076 format("int a = 5;\n" 11077 "int one = 1;\n" 11078 "\n" 11079 "int oneTwoThree = 123;", 11080 Alignment)); 11081 EXPECT_EQ("int a = 5;\n" 11082 "int one = 1;\n" 11083 "\n" 11084 "int oneTwoThree = 123;\n" 11085 "int oneTwo = 12;", 11086 format("int a = 5;\n" 11087 "int one = 1;\n" 11088 "\n" 11089 "int oneTwoThree = 123;\n" 11090 "int oneTwo = 12;", 11091 Alignment)); 11092 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11093 verifyFormat("#define A \\\n" 11094 " int aaaa = 12; \\\n" 11095 " int b = 23; \\\n" 11096 " int ccc = 234; \\\n" 11097 " int dddddddddd = 2345;", 11098 Alignment); 11099 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11100 verifyFormat("#define A \\\n" 11101 " int aaaa = 12; \\\n" 11102 " int b = 23; \\\n" 11103 " int ccc = 234; \\\n" 11104 " int dddddddddd = 2345;", 11105 Alignment); 11106 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11107 verifyFormat("#define A " 11108 " \\\n" 11109 " int aaaa = 12; " 11110 " \\\n" 11111 " int b = 23; " 11112 " \\\n" 11113 " int ccc = 234; " 11114 " \\\n" 11115 " int dddddddddd = 2345;", 11116 Alignment); 11117 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11118 "k = 4, int l = 5,\n" 11119 " int m = 6) {\n" 11120 " int j = 10;\n" 11121 " otherThing = 1;\n" 11122 "}", 11123 Alignment); 11124 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11125 " int i = 1;\n" 11126 " int j = 2;\n" 11127 " int big = 10000;\n" 11128 "}", 11129 Alignment); 11130 verifyFormat("class C {\n" 11131 "public:\n" 11132 " int i = 1;\n" 11133 " virtual void f() = 0;\n" 11134 "};", 11135 Alignment); 11136 verifyFormat("int i = 1;\n" 11137 "if (SomeType t = getSomething()) {\n" 11138 "}\n" 11139 "int j = 2;\n" 11140 "int big = 10000;", 11141 Alignment); 11142 verifyFormat("int j = 7;\n" 11143 "for (int k = 0; k < N; ++k) {\n" 11144 "}\n" 11145 "int j = 2;\n" 11146 "int big = 10000;\n" 11147 "}", 11148 Alignment); 11149 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11150 verifyFormat("int i = 1;\n" 11151 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11152 " = someLooooooooooooooooongFunction();\n" 11153 "int j = 2;", 11154 Alignment); 11155 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11156 verifyFormat("int i = 1;\n" 11157 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11158 " someLooooooooooooooooongFunction();\n" 11159 "int j = 2;", 11160 Alignment); 11161 11162 verifyFormat("auto lambda = []() {\n" 11163 " auto i = 0;\n" 11164 " return 0;\n" 11165 "};\n" 11166 "int i = 0;\n" 11167 "auto v = type{\n" 11168 " i = 1, //\n" 11169 " (i = 2), //\n" 11170 " i = 3 //\n" 11171 "};", 11172 Alignment); 11173 11174 verifyFormat( 11175 "int i = 1;\n" 11176 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11177 " loooooooooooooooooooooongParameterB);\n" 11178 "int j = 2;", 11179 Alignment); 11180 11181 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 11182 " typename B = very_long_type_name_1,\n" 11183 " typename T_2 = very_long_type_name_2>\n" 11184 "auto foo() {}\n", 11185 Alignment); 11186 verifyFormat("int a, b = 1;\n" 11187 "int c = 2;\n" 11188 "int dd = 3;\n", 11189 Alignment); 11190 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11191 "float b[1][] = {{3.f}};\n", 11192 Alignment); 11193 verifyFormat("for (int i = 0; i < 1; i++)\n" 11194 " int x = 1;\n", 11195 Alignment); 11196 verifyFormat("for (i = 0; i < 1; i++)\n" 11197 " x = 1;\n" 11198 "y = 1;\n", 11199 Alignment); 11200 } 11201 11202 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 11203 FormatStyle Alignment = getLLVMStyle(); 11204 Alignment.AlignConsecutiveMacros = true; 11205 Alignment.AlignConsecutiveDeclarations = false; 11206 verifyFormat("float const a = 5;\n" 11207 "int oneTwoThree = 123;", 11208 Alignment); 11209 verifyFormat("int a = 5;\n" 11210 "float const oneTwoThree = 123;", 11211 Alignment); 11212 11213 Alignment.AlignConsecutiveDeclarations = true; 11214 verifyFormat("float const a = 5;\n" 11215 "int oneTwoThree = 123;", 11216 Alignment); 11217 verifyFormat("int a = method();\n" 11218 "float const oneTwoThree = 133;", 11219 Alignment); 11220 verifyFormat("int i = 1, j = 10;\n" 11221 "something = 2000;", 11222 Alignment); 11223 verifyFormat("something = 2000;\n" 11224 "int i = 1, j = 10;\n", 11225 Alignment); 11226 verifyFormat("float something = 2000;\n" 11227 "double another = 911;\n" 11228 "int i = 1, j = 10;\n" 11229 "const int *oneMore = 1;\n" 11230 "unsigned i = 2;", 11231 Alignment); 11232 verifyFormat("float a = 5;\n" 11233 "int one = 1;\n" 11234 "method();\n" 11235 "const double oneTwoThree = 123;\n" 11236 "const unsigned int oneTwo = 12;", 11237 Alignment); 11238 verifyFormat("int oneTwoThree{0}; // comment\n" 11239 "unsigned oneTwo; // comment", 11240 Alignment); 11241 EXPECT_EQ("float const a = 5;\n" 11242 "\n" 11243 "int oneTwoThree = 123;", 11244 format("float const a = 5;\n" 11245 "\n" 11246 "int oneTwoThree= 123;", 11247 Alignment)); 11248 EXPECT_EQ("float a = 5;\n" 11249 "int one = 1;\n" 11250 "\n" 11251 "unsigned oneTwoThree = 123;", 11252 format("float a = 5;\n" 11253 "int one = 1;\n" 11254 "\n" 11255 "unsigned oneTwoThree = 123;", 11256 Alignment)); 11257 EXPECT_EQ("float a = 5;\n" 11258 "int one = 1;\n" 11259 "\n" 11260 "unsigned oneTwoThree = 123;\n" 11261 "int oneTwo = 12;", 11262 format("float a = 5;\n" 11263 "int one = 1;\n" 11264 "\n" 11265 "unsigned oneTwoThree = 123;\n" 11266 "int oneTwo = 12;", 11267 Alignment)); 11268 // Function prototype alignment 11269 verifyFormat("int a();\n" 11270 "double b();", 11271 Alignment); 11272 verifyFormat("int a(int x);\n" 11273 "double b();", 11274 Alignment); 11275 unsigned OldColumnLimit = Alignment.ColumnLimit; 11276 // We need to set ColumnLimit to zero, in order to stress nested alignments, 11277 // otherwise the function parameters will be re-flowed onto a single line. 11278 Alignment.ColumnLimit = 0; 11279 EXPECT_EQ("int a(int x,\n" 11280 " float y);\n" 11281 "double b(int x,\n" 11282 " double y);", 11283 format("int a(int x,\n" 11284 " float y);\n" 11285 "double b(int x,\n" 11286 " double y);", 11287 Alignment)); 11288 // This ensures that function parameters of function declarations are 11289 // correctly indented when their owning functions are indented. 11290 // The failure case here is for 'double y' to not be indented enough. 11291 EXPECT_EQ("double a(int x);\n" 11292 "int b(int y,\n" 11293 " double z);", 11294 format("double a(int x);\n" 11295 "int b(int y,\n" 11296 " double z);", 11297 Alignment)); 11298 // Set ColumnLimit low so that we induce wrapping immediately after 11299 // the function name and opening paren. 11300 Alignment.ColumnLimit = 13; 11301 verifyFormat("int function(\n" 11302 " int x,\n" 11303 " bool y);", 11304 Alignment); 11305 Alignment.ColumnLimit = OldColumnLimit; 11306 // Ensure function pointers don't screw up recursive alignment 11307 verifyFormat("int a(int x, void (*fp)(int y));\n" 11308 "double b();", 11309 Alignment); 11310 Alignment.AlignConsecutiveAssignments = true; 11311 // Ensure recursive alignment is broken by function braces, so that the 11312 // "a = 1" does not align with subsequent assignments inside the function 11313 // body. 11314 verifyFormat("int func(int a = 1) {\n" 11315 " int b = 2;\n" 11316 " int cc = 3;\n" 11317 "}", 11318 Alignment); 11319 verifyFormat("float something = 2000;\n" 11320 "double another = 911;\n" 11321 "int i = 1, j = 10;\n" 11322 "const int *oneMore = 1;\n" 11323 "unsigned i = 2;", 11324 Alignment); 11325 verifyFormat("int oneTwoThree = {0}; // comment\n" 11326 "unsigned oneTwo = 0; // comment", 11327 Alignment); 11328 // Make sure that scope is correctly tracked, in the absence of braces 11329 verifyFormat("for (int i = 0; i < n; i++)\n" 11330 " j = i;\n" 11331 "double x = 1;\n", 11332 Alignment); 11333 verifyFormat("if (int i = 0)\n" 11334 " j = i;\n" 11335 "double x = 1;\n", 11336 Alignment); 11337 // Ensure operator[] and operator() are comprehended 11338 verifyFormat("struct test {\n" 11339 " long long int foo();\n" 11340 " int operator[](int a);\n" 11341 " double bar();\n" 11342 "};\n", 11343 Alignment); 11344 verifyFormat("struct test {\n" 11345 " long long int foo();\n" 11346 " int operator()(int a);\n" 11347 " double bar();\n" 11348 "};\n", 11349 Alignment); 11350 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 11351 " int const i = 1;\n" 11352 " int * j = 2;\n" 11353 " int big = 10000;\n" 11354 "\n" 11355 " unsigned oneTwoThree = 123;\n" 11356 " int oneTwo = 12;\n" 11357 " method();\n" 11358 " float k = 2;\n" 11359 " int ll = 10000;\n" 11360 "}", 11361 format("void SomeFunction(int parameter= 0) {\n" 11362 " int const i= 1;\n" 11363 " int *j=2;\n" 11364 " int big = 10000;\n" 11365 "\n" 11366 "unsigned oneTwoThree =123;\n" 11367 "int oneTwo = 12;\n" 11368 " method();\n" 11369 "float k= 2;\n" 11370 "int ll=10000;\n" 11371 "}", 11372 Alignment)); 11373 Alignment.AlignConsecutiveAssignments = false; 11374 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11375 verifyFormat("#define A \\\n" 11376 " int aaaa = 12; \\\n" 11377 " float b = 23; \\\n" 11378 " const int ccc = 234; \\\n" 11379 " unsigned dddddddddd = 2345;", 11380 Alignment); 11381 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11382 verifyFormat("#define A \\\n" 11383 " int aaaa = 12; \\\n" 11384 " float b = 23; \\\n" 11385 " const int ccc = 234; \\\n" 11386 " unsigned dddddddddd = 2345;", 11387 Alignment); 11388 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11389 Alignment.ColumnLimit = 30; 11390 verifyFormat("#define A \\\n" 11391 " int aaaa = 12; \\\n" 11392 " float b = 23; \\\n" 11393 " const int ccc = 234; \\\n" 11394 " int dddddddddd = 2345;", 11395 Alignment); 11396 Alignment.ColumnLimit = 80; 11397 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11398 "k = 4, int l = 5,\n" 11399 " int m = 6) {\n" 11400 " const int j = 10;\n" 11401 " otherThing = 1;\n" 11402 "}", 11403 Alignment); 11404 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11405 " int const i = 1;\n" 11406 " int * j = 2;\n" 11407 " int big = 10000;\n" 11408 "}", 11409 Alignment); 11410 verifyFormat("class C {\n" 11411 "public:\n" 11412 " int i = 1;\n" 11413 " virtual void f() = 0;\n" 11414 "};", 11415 Alignment); 11416 verifyFormat("float i = 1;\n" 11417 "if (SomeType t = getSomething()) {\n" 11418 "}\n" 11419 "const unsigned j = 2;\n" 11420 "int big = 10000;", 11421 Alignment); 11422 verifyFormat("float j = 7;\n" 11423 "for (int k = 0; k < N; ++k) {\n" 11424 "}\n" 11425 "unsigned j = 2;\n" 11426 "int big = 10000;\n" 11427 "}", 11428 Alignment); 11429 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11430 verifyFormat("float i = 1;\n" 11431 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11432 " = someLooooooooooooooooongFunction();\n" 11433 "int j = 2;", 11434 Alignment); 11435 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11436 verifyFormat("int i = 1;\n" 11437 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11438 " someLooooooooooooooooongFunction();\n" 11439 "int j = 2;", 11440 Alignment); 11441 11442 Alignment.AlignConsecutiveAssignments = true; 11443 verifyFormat("auto lambda = []() {\n" 11444 " auto ii = 0;\n" 11445 " float j = 0;\n" 11446 " return 0;\n" 11447 "};\n" 11448 "int i = 0;\n" 11449 "float i2 = 0;\n" 11450 "auto v = type{\n" 11451 " i = 1, //\n" 11452 " (i = 2), //\n" 11453 " i = 3 //\n" 11454 "};", 11455 Alignment); 11456 Alignment.AlignConsecutiveAssignments = false; 11457 11458 verifyFormat( 11459 "int i = 1;\n" 11460 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11461 " loooooooooooooooooooooongParameterB);\n" 11462 "int j = 2;", 11463 Alignment); 11464 11465 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 11466 // We expect declarations and assignments to align, as long as it doesn't 11467 // exceed the column limit, starting a new alignment sequence whenever it 11468 // happens. 11469 Alignment.AlignConsecutiveAssignments = true; 11470 Alignment.ColumnLimit = 30; 11471 verifyFormat("float ii = 1;\n" 11472 "unsigned j = 2;\n" 11473 "int someVerylongVariable = 1;\n" 11474 "AnotherLongType ll = 123456;\n" 11475 "VeryVeryLongType k = 2;\n" 11476 "int myvar = 1;", 11477 Alignment); 11478 Alignment.ColumnLimit = 80; 11479 Alignment.AlignConsecutiveAssignments = false; 11480 11481 verifyFormat( 11482 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 11483 " typename LongType, typename B>\n" 11484 "auto foo() {}\n", 11485 Alignment); 11486 verifyFormat("float a, b = 1;\n" 11487 "int c = 2;\n" 11488 "int dd = 3;\n", 11489 Alignment); 11490 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11491 "float b[1][] = {{3.f}};\n", 11492 Alignment); 11493 Alignment.AlignConsecutiveAssignments = true; 11494 verifyFormat("float a, b = 1;\n" 11495 "int c = 2;\n" 11496 "int dd = 3;\n", 11497 Alignment); 11498 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11499 "float b[1][] = {{3.f}};\n", 11500 Alignment); 11501 Alignment.AlignConsecutiveAssignments = false; 11502 11503 Alignment.ColumnLimit = 30; 11504 Alignment.BinPackParameters = false; 11505 verifyFormat("void foo(float a,\n" 11506 " float b,\n" 11507 " int c,\n" 11508 " uint32_t *d) {\n" 11509 " int * e = 0;\n" 11510 " float f = 0;\n" 11511 " double g = 0;\n" 11512 "}\n" 11513 "void bar(ino_t a,\n" 11514 " int b,\n" 11515 " uint32_t *c,\n" 11516 " bool d) {}\n", 11517 Alignment); 11518 Alignment.BinPackParameters = true; 11519 Alignment.ColumnLimit = 80; 11520 11521 // Bug 33507 11522 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 11523 verifyFormat( 11524 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 11525 " static const Version verVs2017;\n" 11526 " return true;\n" 11527 "});\n", 11528 Alignment); 11529 Alignment.PointerAlignment = FormatStyle::PAS_Right; 11530 11531 // See llvm.org/PR35641 11532 Alignment.AlignConsecutiveDeclarations = true; 11533 verifyFormat("int func() { //\n" 11534 " int b;\n" 11535 " unsigned c;\n" 11536 "}", 11537 Alignment); 11538 11539 // See PR37175 11540 FormatStyle Style = getMozillaStyle(); 11541 Style.AlignConsecutiveDeclarations = true; 11542 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 11543 "foo(int a);", 11544 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 11545 } 11546 11547 TEST_F(FormatTest, LinuxBraceBreaking) { 11548 FormatStyle LinuxBraceStyle = getLLVMStyle(); 11549 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 11550 verifyFormat("namespace a\n" 11551 "{\n" 11552 "class A\n" 11553 "{\n" 11554 " void f()\n" 11555 " {\n" 11556 " if (true) {\n" 11557 " a();\n" 11558 " b();\n" 11559 " } else {\n" 11560 " a();\n" 11561 " }\n" 11562 " }\n" 11563 " void g() { return; }\n" 11564 "};\n" 11565 "struct B {\n" 11566 " int x;\n" 11567 "};\n" 11568 "} // namespace a\n", 11569 LinuxBraceStyle); 11570 verifyFormat("enum X {\n" 11571 " Y = 0,\n" 11572 "}\n", 11573 LinuxBraceStyle); 11574 verifyFormat("struct S {\n" 11575 " int Type;\n" 11576 " union {\n" 11577 " int x;\n" 11578 " double y;\n" 11579 " } Value;\n" 11580 " class C\n" 11581 " {\n" 11582 " MyFavoriteType Value;\n" 11583 " } Class;\n" 11584 "}\n", 11585 LinuxBraceStyle); 11586 } 11587 11588 TEST_F(FormatTest, MozillaBraceBreaking) { 11589 FormatStyle MozillaBraceStyle = getLLVMStyle(); 11590 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 11591 MozillaBraceStyle.FixNamespaceComments = false; 11592 verifyFormat("namespace a {\n" 11593 "class A\n" 11594 "{\n" 11595 " void f()\n" 11596 " {\n" 11597 " if (true) {\n" 11598 " a();\n" 11599 " b();\n" 11600 " }\n" 11601 " }\n" 11602 " void g() { return; }\n" 11603 "};\n" 11604 "enum E\n" 11605 "{\n" 11606 " A,\n" 11607 " // foo\n" 11608 " B,\n" 11609 " C\n" 11610 "};\n" 11611 "struct B\n" 11612 "{\n" 11613 " int x;\n" 11614 "};\n" 11615 "}\n", 11616 MozillaBraceStyle); 11617 verifyFormat("struct S\n" 11618 "{\n" 11619 " int Type;\n" 11620 " union\n" 11621 " {\n" 11622 " int x;\n" 11623 " double y;\n" 11624 " } Value;\n" 11625 " class C\n" 11626 " {\n" 11627 " MyFavoriteType Value;\n" 11628 " } Class;\n" 11629 "}\n", 11630 MozillaBraceStyle); 11631 } 11632 11633 TEST_F(FormatTest, StroustrupBraceBreaking) { 11634 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 11635 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11636 verifyFormat("namespace a {\n" 11637 "class A {\n" 11638 " void f()\n" 11639 " {\n" 11640 " if (true) {\n" 11641 " a();\n" 11642 " b();\n" 11643 " }\n" 11644 " }\n" 11645 " void g() { return; }\n" 11646 "};\n" 11647 "struct B {\n" 11648 " int x;\n" 11649 "};\n" 11650 "} // namespace a\n", 11651 StroustrupBraceStyle); 11652 11653 verifyFormat("void foo()\n" 11654 "{\n" 11655 " if (a) {\n" 11656 " a();\n" 11657 " }\n" 11658 " else {\n" 11659 " b();\n" 11660 " }\n" 11661 "}\n", 11662 StroustrupBraceStyle); 11663 11664 verifyFormat("#ifdef _DEBUG\n" 11665 "int foo(int i = 0)\n" 11666 "#else\n" 11667 "int foo(int i = 5)\n" 11668 "#endif\n" 11669 "{\n" 11670 " return i;\n" 11671 "}", 11672 StroustrupBraceStyle); 11673 11674 verifyFormat("void foo() {}\n" 11675 "void bar()\n" 11676 "#ifdef _DEBUG\n" 11677 "{\n" 11678 " foo();\n" 11679 "}\n" 11680 "#else\n" 11681 "{\n" 11682 "}\n" 11683 "#endif", 11684 StroustrupBraceStyle); 11685 11686 verifyFormat("void foobar() { int i = 5; }\n" 11687 "#ifdef _DEBUG\n" 11688 "void bar() {}\n" 11689 "#else\n" 11690 "void bar() { foobar(); }\n" 11691 "#endif", 11692 StroustrupBraceStyle); 11693 } 11694 11695 TEST_F(FormatTest, AllmanBraceBreaking) { 11696 FormatStyle AllmanBraceStyle = getLLVMStyle(); 11697 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 11698 11699 EXPECT_EQ("namespace a\n" 11700 "{\n" 11701 "void f();\n" 11702 "void g();\n" 11703 "} // namespace a\n", 11704 format("namespace a\n" 11705 "{\n" 11706 "void f();\n" 11707 "void g();\n" 11708 "}\n", 11709 AllmanBraceStyle)); 11710 11711 verifyFormat("namespace a\n" 11712 "{\n" 11713 "class A\n" 11714 "{\n" 11715 " void f()\n" 11716 " {\n" 11717 " if (true)\n" 11718 " {\n" 11719 " a();\n" 11720 " b();\n" 11721 " }\n" 11722 " }\n" 11723 " void g() { return; }\n" 11724 "};\n" 11725 "struct B\n" 11726 "{\n" 11727 " int x;\n" 11728 "};\n" 11729 "union C\n" 11730 "{\n" 11731 "};\n" 11732 "} // namespace a", 11733 AllmanBraceStyle); 11734 11735 verifyFormat("void f()\n" 11736 "{\n" 11737 " if (true)\n" 11738 " {\n" 11739 " a();\n" 11740 " }\n" 11741 " else if (false)\n" 11742 " {\n" 11743 " b();\n" 11744 " }\n" 11745 " else\n" 11746 " {\n" 11747 " c();\n" 11748 " }\n" 11749 "}\n", 11750 AllmanBraceStyle); 11751 11752 verifyFormat("void f()\n" 11753 "{\n" 11754 " for (int i = 0; i < 10; ++i)\n" 11755 " {\n" 11756 " a();\n" 11757 " }\n" 11758 " while (false)\n" 11759 " {\n" 11760 " b();\n" 11761 " }\n" 11762 " do\n" 11763 " {\n" 11764 " c();\n" 11765 " } while (false)\n" 11766 "}\n", 11767 AllmanBraceStyle); 11768 11769 verifyFormat("void f(int a)\n" 11770 "{\n" 11771 " switch (a)\n" 11772 " {\n" 11773 " case 0:\n" 11774 " break;\n" 11775 " case 1:\n" 11776 " {\n" 11777 " break;\n" 11778 " }\n" 11779 " case 2:\n" 11780 " {\n" 11781 " }\n" 11782 " break;\n" 11783 " default:\n" 11784 " break;\n" 11785 " }\n" 11786 "}\n", 11787 AllmanBraceStyle); 11788 11789 verifyFormat("enum X\n" 11790 "{\n" 11791 " Y = 0,\n" 11792 "}\n", 11793 AllmanBraceStyle); 11794 verifyFormat("enum X\n" 11795 "{\n" 11796 " Y = 0\n" 11797 "}\n", 11798 AllmanBraceStyle); 11799 11800 verifyFormat("@interface BSApplicationController ()\n" 11801 "{\n" 11802 "@private\n" 11803 " id _extraIvar;\n" 11804 "}\n" 11805 "@end\n", 11806 AllmanBraceStyle); 11807 11808 verifyFormat("#ifdef _DEBUG\n" 11809 "int foo(int i = 0)\n" 11810 "#else\n" 11811 "int foo(int i = 5)\n" 11812 "#endif\n" 11813 "{\n" 11814 " return i;\n" 11815 "}", 11816 AllmanBraceStyle); 11817 11818 verifyFormat("void foo() {}\n" 11819 "void bar()\n" 11820 "#ifdef _DEBUG\n" 11821 "{\n" 11822 " foo();\n" 11823 "}\n" 11824 "#else\n" 11825 "{\n" 11826 "}\n" 11827 "#endif", 11828 AllmanBraceStyle); 11829 11830 verifyFormat("void foobar() { int i = 5; }\n" 11831 "#ifdef _DEBUG\n" 11832 "void bar() {}\n" 11833 "#else\n" 11834 "void bar() { foobar(); }\n" 11835 "#endif", 11836 AllmanBraceStyle); 11837 11838 // This shouldn't affect ObjC blocks.. 11839 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 11840 " // ...\n" 11841 " int i;\n" 11842 "}];", 11843 AllmanBraceStyle); 11844 verifyFormat("void (^block)(void) = ^{\n" 11845 " // ...\n" 11846 " int i;\n" 11847 "};", 11848 AllmanBraceStyle); 11849 // .. or dict literals. 11850 verifyFormat("void f()\n" 11851 "{\n" 11852 " // ...\n" 11853 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 11854 "}", 11855 AllmanBraceStyle); 11856 verifyFormat("void f()\n" 11857 "{\n" 11858 " // ...\n" 11859 " [object someMethod:@{a : @\"b\"}];\n" 11860 "}", 11861 AllmanBraceStyle); 11862 verifyFormat("int f()\n" 11863 "{ // comment\n" 11864 " return 42;\n" 11865 "}", 11866 AllmanBraceStyle); 11867 11868 AllmanBraceStyle.ColumnLimit = 19; 11869 verifyFormat("void f() { int i; }", AllmanBraceStyle); 11870 AllmanBraceStyle.ColumnLimit = 18; 11871 verifyFormat("void f()\n" 11872 "{\n" 11873 " int i;\n" 11874 "}", 11875 AllmanBraceStyle); 11876 AllmanBraceStyle.ColumnLimit = 80; 11877 11878 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 11879 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 11880 FormatStyle::SIS_WithoutElse; 11881 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 11882 verifyFormat("void f(bool b)\n" 11883 "{\n" 11884 " if (b)\n" 11885 " {\n" 11886 " return;\n" 11887 " }\n" 11888 "}\n", 11889 BreakBeforeBraceShortIfs); 11890 verifyFormat("void f(bool b)\n" 11891 "{\n" 11892 " if constexpr (b)\n" 11893 " {\n" 11894 " return;\n" 11895 " }\n" 11896 "}\n", 11897 BreakBeforeBraceShortIfs); 11898 verifyFormat("void f(bool b)\n" 11899 "{\n" 11900 " if CONSTEXPR (b)\n" 11901 " {\n" 11902 " return;\n" 11903 " }\n" 11904 "}\n", 11905 BreakBeforeBraceShortIfs); 11906 verifyFormat("void f(bool b)\n" 11907 "{\n" 11908 " if (b) return;\n" 11909 "}\n", 11910 BreakBeforeBraceShortIfs); 11911 verifyFormat("void f(bool b)\n" 11912 "{\n" 11913 " if constexpr (b) return;\n" 11914 "}\n", 11915 BreakBeforeBraceShortIfs); 11916 verifyFormat("void f(bool b)\n" 11917 "{\n" 11918 " if CONSTEXPR (b) return;\n" 11919 "}\n", 11920 BreakBeforeBraceShortIfs); 11921 verifyFormat("void f(bool b)\n" 11922 "{\n" 11923 " while (b)\n" 11924 " {\n" 11925 " return;\n" 11926 " }\n" 11927 "}\n", 11928 BreakBeforeBraceShortIfs); 11929 } 11930 11931 TEST_F(FormatTest, WhitesmithsBraceBreaking) { 11932 FormatStyle WhitesmithsBraceStyle = getLLVMStyle(); 11933 WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 11934 11935 // Make a few changes to the style for testing purposes 11936 WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine = 11937 FormatStyle::SFS_Empty; 11938 WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 11939 WhitesmithsBraceStyle.ColumnLimit = 0; 11940 11941 // FIXME: this test case can't decide whether there should be a blank line 11942 // after the ~D() line or not. It adds one if one doesn't exist in the test 11943 // and it removes the line if one exists. 11944 /* 11945 verifyFormat("class A;\n" 11946 "namespace B\n" 11947 " {\n" 11948 "class C;\n" 11949 "// Comment\n" 11950 "class D\n" 11951 " {\n" 11952 "public:\n" 11953 " D();\n" 11954 " ~D() {}\n" 11955 "private:\n" 11956 " enum E\n" 11957 " {\n" 11958 " F\n" 11959 " }\n" 11960 " };\n" 11961 " } // namespace B\n", 11962 WhitesmithsBraceStyle); 11963 */ 11964 11965 verifyFormat("namespace a\n" 11966 " {\n" 11967 "class A\n" 11968 " {\n" 11969 " void f()\n" 11970 " {\n" 11971 " if (true)\n" 11972 " {\n" 11973 " a();\n" 11974 " b();\n" 11975 " }\n" 11976 " }\n" 11977 " void g()\n" 11978 " {\n" 11979 " return;\n" 11980 " }\n" 11981 " };\n" 11982 "struct B\n" 11983 " {\n" 11984 " int x;\n" 11985 " };\n" 11986 " } // namespace a", 11987 WhitesmithsBraceStyle); 11988 11989 verifyFormat("void f()\n" 11990 " {\n" 11991 " if (true)\n" 11992 " {\n" 11993 " a();\n" 11994 " }\n" 11995 " else if (false)\n" 11996 " {\n" 11997 " b();\n" 11998 " }\n" 11999 " else\n" 12000 " {\n" 12001 " c();\n" 12002 " }\n" 12003 " }\n", 12004 WhitesmithsBraceStyle); 12005 12006 verifyFormat("void f()\n" 12007 " {\n" 12008 " for (int i = 0; i < 10; ++i)\n" 12009 " {\n" 12010 " a();\n" 12011 " }\n" 12012 " while (false)\n" 12013 " {\n" 12014 " b();\n" 12015 " }\n" 12016 " do\n" 12017 " {\n" 12018 " c();\n" 12019 " } while (false)\n" 12020 " }\n", 12021 WhitesmithsBraceStyle); 12022 12023 // FIXME: the block and the break under case 2 in this test don't get indented 12024 // correctly 12025 /* 12026 verifyFormat("void switchTest1(int a)\n" 12027 " {\n" 12028 " switch (a)\n" 12029 " {\n" 12030 " case 2:\n" 12031 " {\n" 12032 " }\n" 12033 " break;\n" 12034 " }\n" 12035 " }\n", 12036 WhitesmithsBraceStyle); 12037 */ 12038 12039 // FIXME: the block and the break under case 2 in this test don't get indented 12040 // correctly 12041 /* 12042 verifyFormat("void switchTest2(int a)\n" 12043 " {\n" 12044 " switch (a)\n" 12045 " {\n" 12046 " case 0:\n" 12047 " break;\n" 12048 " case 1:\n" 12049 " {\n" 12050 " break;\n" 12051 " }\n" 12052 " case 2:\n" 12053 " {\n" 12054 " }\n" 12055 " break;\n" 12056 " default:\n" 12057 " break;\n" 12058 " }\n" 12059 " }\n", 12060 WhitesmithsBraceStyle); 12061 */ 12062 12063 verifyFormat("enum X\n" 12064 " {\n" 12065 " Y = 0, // testing\n" 12066 " }\n", 12067 WhitesmithsBraceStyle); 12068 12069 verifyFormat("enum X\n" 12070 " {\n" 12071 " Y = 0\n" 12072 " }\n", 12073 WhitesmithsBraceStyle); 12074 verifyFormat("enum X\n" 12075 " {\n" 12076 " Y = 0,\n" 12077 " Z = 1\n" 12078 " };\n", 12079 WhitesmithsBraceStyle); 12080 12081 verifyFormat("@interface BSApplicationController ()\n" 12082 " {\n" 12083 "@private\n" 12084 " id _extraIvar;\n" 12085 " }\n" 12086 "@end\n", 12087 WhitesmithsBraceStyle); 12088 12089 verifyFormat("#ifdef _DEBUG\n" 12090 "int foo(int i = 0)\n" 12091 "#else\n" 12092 "int foo(int i = 5)\n" 12093 "#endif\n" 12094 " {\n" 12095 " return i;\n" 12096 " }", 12097 WhitesmithsBraceStyle); 12098 12099 verifyFormat("void foo() {}\n" 12100 "void bar()\n" 12101 "#ifdef _DEBUG\n" 12102 " {\n" 12103 " foo();\n" 12104 " }\n" 12105 "#else\n" 12106 " {\n" 12107 " }\n" 12108 "#endif", 12109 WhitesmithsBraceStyle); 12110 12111 verifyFormat("void foobar()\n" 12112 " {\n" 12113 " int i = 5;\n" 12114 " }\n" 12115 "#ifdef _DEBUG\n" 12116 "void bar()\n" 12117 " {\n" 12118 " }\n" 12119 "#else\n" 12120 "void bar()\n" 12121 " {\n" 12122 " foobar();\n" 12123 " }\n" 12124 "#endif", 12125 WhitesmithsBraceStyle); 12126 12127 // This shouldn't affect ObjC blocks.. 12128 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 12129 " // ...\n" 12130 " int i;\n" 12131 "}];", 12132 WhitesmithsBraceStyle); 12133 verifyFormat("void (^block)(void) = ^{\n" 12134 " // ...\n" 12135 " int i;\n" 12136 "};", 12137 WhitesmithsBraceStyle); 12138 // .. or dict literals. 12139 verifyFormat("void f()\n" 12140 " {\n" 12141 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 12142 " }", 12143 WhitesmithsBraceStyle); 12144 12145 verifyFormat("int f()\n" 12146 " { // comment\n" 12147 " return 42;\n" 12148 " }", 12149 WhitesmithsBraceStyle); 12150 12151 FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle; 12152 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 12153 FormatStyle::SIS_Always; 12154 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 12155 verifyFormat("void f(bool b)\n" 12156 " {\n" 12157 " if (b)\n" 12158 " {\n" 12159 " return;\n" 12160 " }\n" 12161 " }\n", 12162 BreakBeforeBraceShortIfs); 12163 verifyFormat("void f(bool b)\n" 12164 " {\n" 12165 " if (b) return;\n" 12166 " }\n", 12167 BreakBeforeBraceShortIfs); 12168 verifyFormat("void f(bool b)\n" 12169 " {\n" 12170 " while (b)\n" 12171 " {\n" 12172 " return;\n" 12173 " }\n" 12174 " }\n", 12175 BreakBeforeBraceShortIfs); 12176 } 12177 12178 TEST_F(FormatTest, GNUBraceBreaking) { 12179 FormatStyle GNUBraceStyle = getLLVMStyle(); 12180 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 12181 verifyFormat("namespace a\n" 12182 "{\n" 12183 "class A\n" 12184 "{\n" 12185 " void f()\n" 12186 " {\n" 12187 " int a;\n" 12188 " {\n" 12189 " int b;\n" 12190 " }\n" 12191 " if (true)\n" 12192 " {\n" 12193 " a();\n" 12194 " b();\n" 12195 " }\n" 12196 " }\n" 12197 " void g() { return; }\n" 12198 "}\n" 12199 "} // namespace a", 12200 GNUBraceStyle); 12201 12202 verifyFormat("void f()\n" 12203 "{\n" 12204 " if (true)\n" 12205 " {\n" 12206 " a();\n" 12207 " }\n" 12208 " else if (false)\n" 12209 " {\n" 12210 " b();\n" 12211 " }\n" 12212 " else\n" 12213 " {\n" 12214 " c();\n" 12215 " }\n" 12216 "}\n", 12217 GNUBraceStyle); 12218 12219 verifyFormat("void f()\n" 12220 "{\n" 12221 " for (int i = 0; i < 10; ++i)\n" 12222 " {\n" 12223 " a();\n" 12224 " }\n" 12225 " while (false)\n" 12226 " {\n" 12227 " b();\n" 12228 " }\n" 12229 " do\n" 12230 " {\n" 12231 " c();\n" 12232 " }\n" 12233 " while (false);\n" 12234 "}\n", 12235 GNUBraceStyle); 12236 12237 verifyFormat("void f(int a)\n" 12238 "{\n" 12239 " switch (a)\n" 12240 " {\n" 12241 " case 0:\n" 12242 " break;\n" 12243 " case 1:\n" 12244 " {\n" 12245 " break;\n" 12246 " }\n" 12247 " case 2:\n" 12248 " {\n" 12249 " }\n" 12250 " break;\n" 12251 " default:\n" 12252 " break;\n" 12253 " }\n" 12254 "}\n", 12255 GNUBraceStyle); 12256 12257 verifyFormat("enum X\n" 12258 "{\n" 12259 " Y = 0,\n" 12260 "}\n", 12261 GNUBraceStyle); 12262 12263 verifyFormat("@interface BSApplicationController ()\n" 12264 "{\n" 12265 "@private\n" 12266 " id _extraIvar;\n" 12267 "}\n" 12268 "@end\n", 12269 GNUBraceStyle); 12270 12271 verifyFormat("#ifdef _DEBUG\n" 12272 "int foo(int i = 0)\n" 12273 "#else\n" 12274 "int foo(int i = 5)\n" 12275 "#endif\n" 12276 "{\n" 12277 " return i;\n" 12278 "}", 12279 GNUBraceStyle); 12280 12281 verifyFormat("void foo() {}\n" 12282 "void bar()\n" 12283 "#ifdef _DEBUG\n" 12284 "{\n" 12285 " foo();\n" 12286 "}\n" 12287 "#else\n" 12288 "{\n" 12289 "}\n" 12290 "#endif", 12291 GNUBraceStyle); 12292 12293 verifyFormat("void foobar() { int i = 5; }\n" 12294 "#ifdef _DEBUG\n" 12295 "void bar() {}\n" 12296 "#else\n" 12297 "void bar() { foobar(); }\n" 12298 "#endif", 12299 GNUBraceStyle); 12300 } 12301 12302 TEST_F(FormatTest, WebKitBraceBreaking) { 12303 FormatStyle WebKitBraceStyle = getLLVMStyle(); 12304 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 12305 WebKitBraceStyle.FixNamespaceComments = false; 12306 verifyFormat("namespace a {\n" 12307 "class A {\n" 12308 " void f()\n" 12309 " {\n" 12310 " if (true) {\n" 12311 " a();\n" 12312 " b();\n" 12313 " }\n" 12314 " }\n" 12315 " void g() { return; }\n" 12316 "};\n" 12317 "enum E {\n" 12318 " A,\n" 12319 " // foo\n" 12320 " B,\n" 12321 " C\n" 12322 "};\n" 12323 "struct B {\n" 12324 " int x;\n" 12325 "};\n" 12326 "}\n", 12327 WebKitBraceStyle); 12328 verifyFormat("struct S {\n" 12329 " int Type;\n" 12330 " union {\n" 12331 " int x;\n" 12332 " double y;\n" 12333 " } Value;\n" 12334 " class C {\n" 12335 " MyFavoriteType Value;\n" 12336 " } Class;\n" 12337 "};\n", 12338 WebKitBraceStyle); 12339 } 12340 12341 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 12342 verifyFormat("void f() {\n" 12343 " try {\n" 12344 " } catch (const Exception &e) {\n" 12345 " }\n" 12346 "}\n", 12347 getLLVMStyle()); 12348 } 12349 12350 TEST_F(FormatTest, UnderstandsPragmas) { 12351 verifyFormat("#pragma omp reduction(| : var)"); 12352 verifyFormat("#pragma omp reduction(+ : var)"); 12353 12354 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 12355 "(including parentheses).", 12356 format("#pragma mark Any non-hyphenated or hyphenated string " 12357 "(including parentheses).")); 12358 } 12359 12360 TEST_F(FormatTest, UnderstandPragmaOption) { 12361 verifyFormat("#pragma option -C -A"); 12362 12363 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 12364 } 12365 12366 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 12367 FormatStyle Style = getLLVMStyle(); 12368 Style.ColumnLimit = 20; 12369 12370 // See PR41213 12371 EXPECT_EQ("/*\n" 12372 " *\t9012345\n" 12373 " * /8901\n" 12374 " */", 12375 format("/*\n" 12376 " *\t9012345 /8901\n" 12377 " */", 12378 Style)); 12379 EXPECT_EQ("/*\n" 12380 " *345678\n" 12381 " *\t/8901\n" 12382 " */", 12383 format("/*\n" 12384 " *345678\t/8901\n" 12385 " */", 12386 Style)); 12387 12388 verifyFormat("int a; // the\n" 12389 " // comment", 12390 Style); 12391 EXPECT_EQ("int a; /* first line\n" 12392 " * second\n" 12393 " * line third\n" 12394 " * line\n" 12395 " */", 12396 format("int a; /* first line\n" 12397 " * second\n" 12398 " * line third\n" 12399 " * line\n" 12400 " */", 12401 Style)); 12402 EXPECT_EQ("int a; // first line\n" 12403 " // second\n" 12404 " // line third\n" 12405 " // line", 12406 format("int a; // first line\n" 12407 " // second line\n" 12408 " // third line", 12409 Style)); 12410 12411 Style.PenaltyExcessCharacter = 90; 12412 verifyFormat("int a; // the comment", Style); 12413 EXPECT_EQ("int a; // the comment\n" 12414 " // aaa", 12415 format("int a; // the comment aaa", Style)); 12416 EXPECT_EQ("int a; /* first line\n" 12417 " * second line\n" 12418 " * third line\n" 12419 " */", 12420 format("int a; /* first line\n" 12421 " * second line\n" 12422 " * third line\n" 12423 " */", 12424 Style)); 12425 EXPECT_EQ("int a; // first line\n" 12426 " // second line\n" 12427 " // third line", 12428 format("int a; // first line\n" 12429 " // second line\n" 12430 " // third line", 12431 Style)); 12432 // FIXME: Investigate why this is not getting the same layout as the test 12433 // above. 12434 EXPECT_EQ("int a; /* first line\n" 12435 " * second line\n" 12436 " * third line\n" 12437 " */", 12438 format("int a; /* first line second line third line" 12439 "\n*/", 12440 Style)); 12441 12442 EXPECT_EQ("// foo bar baz bazfoo\n" 12443 "// foo bar foo bar\n", 12444 format("// foo bar baz bazfoo\n" 12445 "// foo bar foo bar\n", 12446 Style)); 12447 EXPECT_EQ("// foo bar baz bazfoo\n" 12448 "// foo bar foo bar\n", 12449 format("// foo bar baz bazfoo\n" 12450 "// foo bar foo bar\n", 12451 Style)); 12452 12453 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 12454 // next one. 12455 EXPECT_EQ("// foo bar baz bazfoo\n" 12456 "// bar foo bar\n", 12457 format("// foo bar baz bazfoo bar\n" 12458 "// foo bar\n", 12459 Style)); 12460 12461 EXPECT_EQ("// foo bar baz bazfoo\n" 12462 "// foo bar baz bazfoo\n" 12463 "// bar foo bar\n", 12464 format("// foo bar baz bazfoo\n" 12465 "// foo bar baz bazfoo bar\n" 12466 "// foo bar\n", 12467 Style)); 12468 12469 EXPECT_EQ("// foo bar baz bazfoo\n" 12470 "// foo bar baz bazfoo\n" 12471 "// bar foo bar\n", 12472 format("// foo bar baz bazfoo\n" 12473 "// foo bar baz bazfoo bar\n" 12474 "// foo bar\n", 12475 Style)); 12476 12477 // Make sure we do not keep protruding characters if strict mode reflow is 12478 // cheaper than keeping protruding characters. 12479 Style.ColumnLimit = 21; 12480 EXPECT_EQ( 12481 "// foo foo foo foo\n" 12482 "// foo foo foo foo\n" 12483 "// foo foo foo foo\n", 12484 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style)); 12485 12486 EXPECT_EQ("int a = /* long block\n" 12487 " comment */\n" 12488 " 42;", 12489 format("int a = /* long block comment */ 42;", Style)); 12490 } 12491 12492 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 12493 for (size_t i = 1; i < Styles.size(); ++i) \ 12494 EXPECT_EQ(Styles[0], Styles[i]) \ 12495 << "Style #" << i << " of " << Styles.size() << " differs from Style #0" 12496 12497 TEST_F(FormatTest, GetsPredefinedStyleByName) { 12498 SmallVector<FormatStyle, 3> Styles; 12499 Styles.resize(3); 12500 12501 Styles[0] = getLLVMStyle(); 12502 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 12503 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 12504 EXPECT_ALL_STYLES_EQUAL(Styles); 12505 12506 Styles[0] = getGoogleStyle(); 12507 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 12508 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 12509 EXPECT_ALL_STYLES_EQUAL(Styles); 12510 12511 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12512 EXPECT_TRUE( 12513 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 12514 EXPECT_TRUE( 12515 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 12516 EXPECT_ALL_STYLES_EQUAL(Styles); 12517 12518 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 12519 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 12520 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 12521 EXPECT_ALL_STYLES_EQUAL(Styles); 12522 12523 Styles[0] = getMozillaStyle(); 12524 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 12525 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 12526 EXPECT_ALL_STYLES_EQUAL(Styles); 12527 12528 Styles[0] = getWebKitStyle(); 12529 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 12530 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 12531 EXPECT_ALL_STYLES_EQUAL(Styles); 12532 12533 Styles[0] = getGNUStyle(); 12534 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 12535 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 12536 EXPECT_ALL_STYLES_EQUAL(Styles); 12537 12538 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 12539 } 12540 12541 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 12542 SmallVector<FormatStyle, 8> Styles; 12543 Styles.resize(2); 12544 12545 Styles[0] = getGoogleStyle(); 12546 Styles[1] = getLLVMStyle(); 12547 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12548 EXPECT_ALL_STYLES_EQUAL(Styles); 12549 12550 Styles.resize(5); 12551 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12552 Styles[1] = getLLVMStyle(); 12553 Styles[1].Language = FormatStyle::LK_JavaScript; 12554 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12555 12556 Styles[2] = getLLVMStyle(); 12557 Styles[2].Language = FormatStyle::LK_JavaScript; 12558 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 12559 "BasedOnStyle: Google", 12560 &Styles[2]) 12561 .value()); 12562 12563 Styles[3] = getLLVMStyle(); 12564 Styles[3].Language = FormatStyle::LK_JavaScript; 12565 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 12566 "Language: JavaScript", 12567 &Styles[3]) 12568 .value()); 12569 12570 Styles[4] = getLLVMStyle(); 12571 Styles[4].Language = FormatStyle::LK_JavaScript; 12572 EXPECT_EQ(0, parseConfiguration("---\n" 12573 "BasedOnStyle: LLVM\n" 12574 "IndentWidth: 123\n" 12575 "---\n" 12576 "BasedOnStyle: Google\n" 12577 "Language: JavaScript", 12578 &Styles[4]) 12579 .value()); 12580 EXPECT_ALL_STYLES_EQUAL(Styles); 12581 } 12582 12583 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 12584 Style.FIELD = false; \ 12585 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 12586 EXPECT_TRUE(Style.FIELD); \ 12587 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 12588 EXPECT_FALSE(Style.FIELD); 12589 12590 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 12591 12592 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 12593 Style.STRUCT.FIELD = false; \ 12594 EXPECT_EQ(0, \ 12595 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 12596 .value()); \ 12597 EXPECT_TRUE(Style.STRUCT.FIELD); \ 12598 EXPECT_EQ(0, \ 12599 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 12600 .value()); \ 12601 EXPECT_FALSE(Style.STRUCT.FIELD); 12602 12603 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 12604 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 12605 12606 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 12607 EXPECT_NE(VALUE, Style.FIELD); \ 12608 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 12609 EXPECT_EQ(VALUE, Style.FIELD) 12610 12611 TEST_F(FormatTest, ParsesConfigurationBools) { 12612 FormatStyle Style = {}; 12613 Style.Language = FormatStyle::LK_Cpp; 12614 CHECK_PARSE_BOOL(AlignOperands); 12615 CHECK_PARSE_BOOL(AlignTrailingComments); 12616 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 12617 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 12618 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 12619 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 12620 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 12621 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 12622 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 12623 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 12624 CHECK_PARSE_BOOL(BinPackArguments); 12625 CHECK_PARSE_BOOL(BinPackParameters); 12626 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 12627 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 12628 CHECK_PARSE_BOOL(BreakStringLiterals); 12629 CHECK_PARSE_BOOL(CompactNamespaces); 12630 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 12631 CHECK_PARSE_BOOL(DeriveLineEnding); 12632 CHECK_PARSE_BOOL(DerivePointerAlignment); 12633 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 12634 CHECK_PARSE_BOOL(DisableFormat); 12635 CHECK_PARSE_BOOL(IndentCaseLabels); 12636 CHECK_PARSE_BOOL(IndentCaseBlocks); 12637 CHECK_PARSE_BOOL(IndentGotoLabels); 12638 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 12639 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 12640 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 12641 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 12642 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 12643 CHECK_PARSE_BOOL(ReflowComments); 12644 CHECK_PARSE_BOOL(SortIncludes); 12645 CHECK_PARSE_BOOL(SortUsingDeclarations); 12646 CHECK_PARSE_BOOL(SpacesInParentheses); 12647 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 12648 CHECK_PARSE_BOOL(SpacesInAngles); 12649 CHECK_PARSE_BOOL(SpacesInConditionalStatement); 12650 CHECK_PARSE_BOOL(SpaceInEmptyBlock); 12651 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 12652 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 12653 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 12654 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 12655 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 12656 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 12657 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 12658 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 12659 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 12660 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 12661 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 12662 CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets); 12663 CHECK_PARSE_BOOL(UseCRLF); 12664 12665 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 12666 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 12667 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 12668 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 12669 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 12670 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 12671 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 12672 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 12673 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 12674 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 12675 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 12676 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 12677 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 12678 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 12679 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 12680 } 12681 12682 #undef CHECK_PARSE_BOOL 12683 12684 TEST_F(FormatTest, ParsesConfiguration) { 12685 FormatStyle Style = {}; 12686 Style.Language = FormatStyle::LK_Cpp; 12687 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 12688 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 12689 ConstructorInitializerIndentWidth, 1234u); 12690 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 12691 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 12692 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 12693 CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u); 12694 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 12695 PenaltyBreakBeforeFirstCallParameter, 1234u); 12696 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 12697 PenaltyBreakTemplateDeclaration, 1234u); 12698 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 12699 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 12700 PenaltyReturnTypeOnItsOwnLine, 1234u); 12701 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 12702 SpacesBeforeTrailingComments, 1234u); 12703 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 12704 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 12705 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 12706 12707 Style.PointerAlignment = FormatStyle::PAS_Middle; 12708 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 12709 FormatStyle::PAS_Left); 12710 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 12711 FormatStyle::PAS_Right); 12712 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 12713 FormatStyle::PAS_Middle); 12714 // For backward compatibility: 12715 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 12716 FormatStyle::PAS_Left); 12717 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 12718 FormatStyle::PAS_Right); 12719 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 12720 FormatStyle::PAS_Middle); 12721 12722 Style.Standard = FormatStyle::LS_Auto; 12723 CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03); 12724 CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11); 12725 CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14); 12726 CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17); 12727 CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20); 12728 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 12729 CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest); 12730 // Legacy aliases: 12731 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 12732 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest); 12733 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 12734 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 12735 12736 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 12737 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 12738 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 12739 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 12740 FormatStyle::BOS_None); 12741 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 12742 FormatStyle::BOS_All); 12743 // For backward compatibility: 12744 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 12745 FormatStyle::BOS_None); 12746 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 12747 FormatStyle::BOS_All); 12748 12749 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 12750 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 12751 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 12752 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 12753 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 12754 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 12755 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 12756 // For backward compatibility: 12757 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 12758 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 12759 12760 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 12761 CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList, 12762 FormatStyle::BILS_BeforeComma); 12763 CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList, 12764 FormatStyle::BILS_AfterColon); 12765 CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList, 12766 FormatStyle::BILS_BeforeColon); 12767 // For backward compatibility: 12768 CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList, 12769 FormatStyle::BILS_BeforeComma); 12770 12771 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 12772 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 12773 FormatStyle::BAS_Align); 12774 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 12775 FormatStyle::BAS_DontAlign); 12776 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 12777 FormatStyle::BAS_AlwaysBreak); 12778 // For backward compatibility: 12779 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 12780 FormatStyle::BAS_DontAlign); 12781 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 12782 FormatStyle::BAS_Align); 12783 12784 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 12785 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 12786 FormatStyle::ENAS_DontAlign); 12787 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 12788 FormatStyle::ENAS_Left); 12789 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 12790 FormatStyle::ENAS_Right); 12791 // For backward compatibility: 12792 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 12793 FormatStyle::ENAS_Left); 12794 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 12795 FormatStyle::ENAS_Right); 12796 12797 Style.UseTab = FormatStyle::UT_ForIndentation; 12798 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 12799 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 12800 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 12801 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 12802 FormatStyle::UT_ForContinuationAndIndentation); 12803 // For backward compatibility: 12804 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 12805 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 12806 12807 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 12808 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never", 12809 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12810 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty", 12811 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty); 12812 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always", 12813 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12814 // For backward compatibility: 12815 CHECK_PARSE("AllowShortBlocksOnASingleLine: false", 12816 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12817 CHECK_PARSE("AllowShortBlocksOnASingleLine: true", 12818 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12819 12820 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 12821 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 12822 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12823 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 12824 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 12825 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 12826 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 12827 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 12828 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12829 // For backward compatibility: 12830 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 12831 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12832 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 12833 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12834 12835 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 12836 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 12837 FormatStyle::SBPO_Never); 12838 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 12839 FormatStyle::SBPO_Always); 12840 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 12841 FormatStyle::SBPO_ControlStatements); 12842 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 12843 FormatStyle::SBPO_NonEmptyParentheses); 12844 // For backward compatibility: 12845 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 12846 FormatStyle::SBPO_Never); 12847 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 12848 FormatStyle::SBPO_ControlStatements); 12849 12850 Style.ColumnLimit = 123; 12851 FormatStyle BaseStyle = getLLVMStyle(); 12852 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 12853 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 12854 12855 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 12856 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 12857 FormatStyle::BS_Attach); 12858 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 12859 FormatStyle::BS_Linux); 12860 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 12861 FormatStyle::BS_Mozilla); 12862 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 12863 FormatStyle::BS_Stroustrup); 12864 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 12865 FormatStyle::BS_Allman); 12866 CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces, 12867 FormatStyle::BS_Whitesmiths); 12868 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 12869 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 12870 FormatStyle::BS_WebKit); 12871 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 12872 FormatStyle::BS_Custom); 12873 12874 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never; 12875 CHECK_PARSE("BraceWrapping:\n" 12876 " AfterControlStatement: MultiLine", 12877 BraceWrapping.AfterControlStatement, 12878 FormatStyle::BWACS_MultiLine); 12879 CHECK_PARSE("BraceWrapping:\n" 12880 " AfterControlStatement: Always", 12881 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 12882 CHECK_PARSE("BraceWrapping:\n" 12883 " AfterControlStatement: Never", 12884 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 12885 // For backward compatibility: 12886 CHECK_PARSE("BraceWrapping:\n" 12887 " AfterControlStatement: true", 12888 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 12889 CHECK_PARSE("BraceWrapping:\n" 12890 " AfterControlStatement: false", 12891 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 12892 12893 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 12894 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 12895 FormatStyle::RTBS_None); 12896 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 12897 FormatStyle::RTBS_All); 12898 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 12899 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 12900 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 12901 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 12902 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 12903 AlwaysBreakAfterReturnType, 12904 FormatStyle::RTBS_TopLevelDefinitions); 12905 12906 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 12907 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", 12908 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No); 12909 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", 12910 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 12911 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", 12912 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 12913 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", 12914 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 12915 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", 12916 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 12917 12918 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 12919 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 12920 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 12921 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 12922 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 12923 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 12924 AlwaysBreakAfterDefinitionReturnType, 12925 FormatStyle::DRTBS_TopLevel); 12926 12927 Style.NamespaceIndentation = FormatStyle::NI_All; 12928 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 12929 FormatStyle::NI_None); 12930 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 12931 FormatStyle::NI_Inner); 12932 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 12933 FormatStyle::NI_All); 12934 12935 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 12936 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 12937 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12938 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 12939 AllowShortIfStatementsOnASingleLine, 12940 FormatStyle::SIS_WithoutElse); 12941 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 12942 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 12943 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 12944 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12945 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 12946 AllowShortIfStatementsOnASingleLine, 12947 FormatStyle::SIS_WithoutElse); 12948 12949 // FIXME: This is required because parsing a configuration simply overwrites 12950 // the first N elements of the list instead of resetting it. 12951 Style.ForEachMacros.clear(); 12952 std::vector<std::string> BoostForeach; 12953 BoostForeach.push_back("BOOST_FOREACH"); 12954 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 12955 std::vector<std::string> BoostAndQForeach; 12956 BoostAndQForeach.push_back("BOOST_FOREACH"); 12957 BoostAndQForeach.push_back("Q_FOREACH"); 12958 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 12959 BoostAndQForeach); 12960 12961 Style.StatementMacros.clear(); 12962 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 12963 std::vector<std::string>{"QUNUSED"}); 12964 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 12965 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 12966 12967 Style.NamespaceMacros.clear(); 12968 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 12969 std::vector<std::string>{"TESTSUITE"}); 12970 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 12971 std::vector<std::string>({"TESTSUITE", "SUITE"})); 12972 12973 Style.IncludeStyle.IncludeCategories.clear(); 12974 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 12975 {"abc/.*", 2, 0}, {".*", 1, 0}}; 12976 CHECK_PARSE("IncludeCategories:\n" 12977 " - Regex: abc/.*\n" 12978 " Priority: 2\n" 12979 " - Regex: .*\n" 12980 " Priority: 1", 12981 IncludeStyle.IncludeCategories, ExpectedCategories); 12982 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 12983 "abc$"); 12984 CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'", 12985 IncludeStyle.IncludeIsMainSourceRegex, "abc$"); 12986 12987 Style.RawStringFormats.clear(); 12988 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 12989 { 12990 FormatStyle::LK_TextProto, 12991 {"pb", "proto"}, 12992 {"PARSE_TEXT_PROTO"}, 12993 /*CanonicalDelimiter=*/"", 12994 "llvm", 12995 }, 12996 { 12997 FormatStyle::LK_Cpp, 12998 {"cc", "cpp"}, 12999 {"C_CODEBLOCK", "CPPEVAL"}, 13000 /*CanonicalDelimiter=*/"cc", 13001 /*BasedOnStyle=*/"", 13002 }, 13003 }; 13004 13005 CHECK_PARSE("RawStringFormats:\n" 13006 " - Language: TextProto\n" 13007 " Delimiters:\n" 13008 " - 'pb'\n" 13009 " - 'proto'\n" 13010 " EnclosingFunctions:\n" 13011 " - 'PARSE_TEXT_PROTO'\n" 13012 " BasedOnStyle: llvm\n" 13013 " - Language: Cpp\n" 13014 " Delimiters:\n" 13015 " - 'cc'\n" 13016 " - 'cpp'\n" 13017 " EnclosingFunctions:\n" 13018 " - 'C_CODEBLOCK'\n" 13019 " - 'CPPEVAL'\n" 13020 " CanonicalDelimiter: 'cc'", 13021 RawStringFormats, ExpectedRawStringFormats); 13022 } 13023 13024 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 13025 FormatStyle Style = {}; 13026 Style.Language = FormatStyle::LK_Cpp; 13027 CHECK_PARSE("Language: Cpp\n" 13028 "IndentWidth: 12", 13029 IndentWidth, 12u); 13030 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 13031 "IndentWidth: 34", 13032 &Style), 13033 ParseError::Unsuitable); 13034 FormatStyle BinPackedTCS = {}; 13035 BinPackedTCS.Language = FormatStyle::LK_JavaScript; 13036 EXPECT_EQ(parseConfiguration("BinPackArguments: true\n" 13037 "InsertTrailingCommas: Wrapped", 13038 &BinPackedTCS), 13039 ParseError::BinPackTrailingCommaConflict); 13040 EXPECT_EQ(12u, Style.IndentWidth); 13041 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 13042 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 13043 13044 Style.Language = FormatStyle::LK_JavaScript; 13045 CHECK_PARSE("Language: JavaScript\n" 13046 "IndentWidth: 12", 13047 IndentWidth, 12u); 13048 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 13049 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 13050 "IndentWidth: 34", 13051 &Style), 13052 ParseError::Unsuitable); 13053 EXPECT_EQ(23u, Style.IndentWidth); 13054 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 13055 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 13056 13057 CHECK_PARSE("BasedOnStyle: LLVM\n" 13058 "IndentWidth: 67", 13059 IndentWidth, 67u); 13060 13061 CHECK_PARSE("---\n" 13062 "Language: JavaScript\n" 13063 "IndentWidth: 12\n" 13064 "---\n" 13065 "Language: Cpp\n" 13066 "IndentWidth: 34\n" 13067 "...\n", 13068 IndentWidth, 12u); 13069 13070 Style.Language = FormatStyle::LK_Cpp; 13071 CHECK_PARSE("---\n" 13072 "Language: JavaScript\n" 13073 "IndentWidth: 12\n" 13074 "---\n" 13075 "Language: Cpp\n" 13076 "IndentWidth: 34\n" 13077 "...\n", 13078 IndentWidth, 34u); 13079 CHECK_PARSE("---\n" 13080 "IndentWidth: 78\n" 13081 "---\n" 13082 "Language: JavaScript\n" 13083 "IndentWidth: 56\n" 13084 "...\n", 13085 IndentWidth, 78u); 13086 13087 Style.ColumnLimit = 123; 13088 Style.IndentWidth = 234; 13089 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 13090 Style.TabWidth = 345; 13091 EXPECT_FALSE(parseConfiguration("---\n" 13092 "IndentWidth: 456\n" 13093 "BreakBeforeBraces: Allman\n" 13094 "---\n" 13095 "Language: JavaScript\n" 13096 "IndentWidth: 111\n" 13097 "TabWidth: 111\n" 13098 "---\n" 13099 "Language: Cpp\n" 13100 "BreakBeforeBraces: Stroustrup\n" 13101 "TabWidth: 789\n" 13102 "...\n", 13103 &Style)); 13104 EXPECT_EQ(123u, Style.ColumnLimit); 13105 EXPECT_EQ(456u, Style.IndentWidth); 13106 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 13107 EXPECT_EQ(789u, Style.TabWidth); 13108 13109 EXPECT_EQ(parseConfiguration("---\n" 13110 "Language: JavaScript\n" 13111 "IndentWidth: 56\n" 13112 "---\n" 13113 "IndentWidth: 78\n" 13114 "...\n", 13115 &Style), 13116 ParseError::Error); 13117 EXPECT_EQ(parseConfiguration("---\n" 13118 "Language: JavaScript\n" 13119 "IndentWidth: 56\n" 13120 "---\n" 13121 "Language: JavaScript\n" 13122 "IndentWidth: 78\n" 13123 "...\n", 13124 &Style), 13125 ParseError::Error); 13126 13127 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 13128 } 13129 13130 #undef CHECK_PARSE 13131 13132 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 13133 FormatStyle Style = {}; 13134 Style.Language = FormatStyle::LK_JavaScript; 13135 Style.BreakBeforeTernaryOperators = true; 13136 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 13137 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 13138 13139 Style.BreakBeforeTernaryOperators = true; 13140 EXPECT_EQ(0, parseConfiguration("---\n" 13141 "BasedOnStyle: Google\n" 13142 "---\n" 13143 "Language: JavaScript\n" 13144 "IndentWidth: 76\n" 13145 "...\n", 13146 &Style) 13147 .value()); 13148 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 13149 EXPECT_EQ(76u, Style.IndentWidth); 13150 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 13151 } 13152 13153 TEST_F(FormatTest, ConfigurationRoundTripTest) { 13154 FormatStyle Style = getLLVMStyle(); 13155 std::string YAML = configurationAsText(Style); 13156 FormatStyle ParsedStyle = {}; 13157 ParsedStyle.Language = FormatStyle::LK_Cpp; 13158 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 13159 EXPECT_EQ(Style, ParsedStyle); 13160 } 13161 13162 TEST_F(FormatTest, WorksFor8bitEncodings) { 13163 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 13164 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 13165 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 13166 "\"\xef\xee\xf0\xf3...\"", 13167 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 13168 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 13169 "\xef\xee\xf0\xf3...\"", 13170 getLLVMStyleWithColumns(12))); 13171 } 13172 13173 TEST_F(FormatTest, HandlesUTF8BOM) { 13174 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 13175 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 13176 format("\xef\xbb\xbf#include <iostream>")); 13177 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 13178 format("\xef\xbb\xbf\n#include <iostream>")); 13179 } 13180 13181 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 13182 #if !defined(_MSC_VER) 13183 13184 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 13185 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 13186 getLLVMStyleWithColumns(35)); 13187 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 13188 getLLVMStyleWithColumns(31)); 13189 verifyFormat("// Однажды в студёную зимнюю пору...", 13190 getLLVMStyleWithColumns(36)); 13191 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 13192 verifyFormat("/* Однажды в студёную зимнюю пору... */", 13193 getLLVMStyleWithColumns(39)); 13194 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 13195 getLLVMStyleWithColumns(35)); 13196 } 13197 13198 TEST_F(FormatTest, SplitsUTF8Strings) { 13199 // Non-printable characters' width is currently considered to be the length in 13200 // bytes in UTF8. The characters can be displayed in very different manner 13201 // (zero-width, single width with a substitution glyph, expanded to their code 13202 // (e.g. "<8d>"), so there's no single correct way to handle them. 13203 EXPECT_EQ("\"aaaaÄ\"\n" 13204 "\"\xc2\x8d\";", 13205 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13206 EXPECT_EQ("\"aaaaaaaÄ\"\n" 13207 "\"\xc2\x8d\";", 13208 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13209 EXPECT_EQ("\"Однажды, в \"\n" 13210 "\"студёную \"\n" 13211 "\"зимнюю \"\n" 13212 "\"пору,\"", 13213 format("\"Однажды, в студёную зимнюю пору,\"", 13214 getLLVMStyleWithColumns(13))); 13215 EXPECT_EQ( 13216 "\"一 二 三 \"\n" 13217 "\"四 五六 \"\n" 13218 "\"七 八 九 \"\n" 13219 "\"十\"", 13220 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 13221 EXPECT_EQ("\"一\t\"\n" 13222 "\"二 \t\"\n" 13223 "\"三 四 \"\n" 13224 "\"五\t\"\n" 13225 "\"六 \t\"\n" 13226 "\"七 \"\n" 13227 "\"八九十\tqq\"", 13228 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 13229 getLLVMStyleWithColumns(11))); 13230 13231 // UTF8 character in an escape sequence. 13232 EXPECT_EQ("\"aaaaaa\"\n" 13233 "\"\\\xC2\x8D\"", 13234 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 13235 } 13236 13237 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 13238 EXPECT_EQ("const char *sssss =\n" 13239 " \"一二三四五六七八\\\n" 13240 " 九 十\";", 13241 format("const char *sssss = \"一二三四五六七八\\\n" 13242 " 九 十\";", 13243 getLLVMStyleWithColumns(30))); 13244 } 13245 13246 TEST_F(FormatTest, SplitsUTF8LineComments) { 13247 EXPECT_EQ("// aaaaÄ\xc2\x8d", 13248 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 13249 EXPECT_EQ("// Я из лесу\n" 13250 "// вышел; был\n" 13251 "// сильный\n" 13252 "// мороз.", 13253 format("// Я из лесу вышел; был сильный мороз.", 13254 getLLVMStyleWithColumns(13))); 13255 EXPECT_EQ("// 一二三\n" 13256 "// 四五六七\n" 13257 "// 八 九\n" 13258 "// 十", 13259 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 13260 } 13261 13262 TEST_F(FormatTest, SplitsUTF8BlockComments) { 13263 EXPECT_EQ("/* Гляжу,\n" 13264 " * поднимается\n" 13265 " * медленно в\n" 13266 " * гору\n" 13267 " * Лошадка,\n" 13268 " * везущая\n" 13269 " * хворосту\n" 13270 " * воз. */", 13271 format("/* Гляжу, поднимается медленно в гору\n" 13272 " * Лошадка, везущая хворосту воз. */", 13273 getLLVMStyleWithColumns(13))); 13274 EXPECT_EQ( 13275 "/* 一二三\n" 13276 " * 四五六七\n" 13277 " * 八 九\n" 13278 " * 十 */", 13279 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 13280 EXPECT_EQ("/* �������� ��������\n" 13281 " * ��������\n" 13282 " * ������-�� */", 13283 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 13284 } 13285 13286 #endif // _MSC_VER 13287 13288 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 13289 FormatStyle Style = getLLVMStyle(); 13290 13291 Style.ConstructorInitializerIndentWidth = 4; 13292 verifyFormat( 13293 "SomeClass::Constructor()\n" 13294 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13295 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13296 Style); 13297 13298 Style.ConstructorInitializerIndentWidth = 2; 13299 verifyFormat( 13300 "SomeClass::Constructor()\n" 13301 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13302 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13303 Style); 13304 13305 Style.ConstructorInitializerIndentWidth = 0; 13306 verifyFormat( 13307 "SomeClass::Constructor()\n" 13308 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13309 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13310 Style); 13311 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 13312 verifyFormat( 13313 "SomeLongTemplateVariableName<\n" 13314 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 13315 Style); 13316 verifyFormat("bool smaller = 1 < " 13317 "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 13318 " " 13319 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 13320 Style); 13321 13322 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 13323 verifyFormat("SomeClass::Constructor() :\n" 13324 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 13325 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 13326 Style); 13327 } 13328 13329 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 13330 FormatStyle Style = getLLVMStyle(); 13331 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 13332 Style.ConstructorInitializerIndentWidth = 4; 13333 verifyFormat("SomeClass::Constructor()\n" 13334 " : a(a)\n" 13335 " , b(b)\n" 13336 " , c(c) {}", 13337 Style); 13338 verifyFormat("SomeClass::Constructor()\n" 13339 " : a(a) {}", 13340 Style); 13341 13342 Style.ColumnLimit = 0; 13343 verifyFormat("SomeClass::Constructor()\n" 13344 " : a(a) {}", 13345 Style); 13346 verifyFormat("SomeClass::Constructor() noexcept\n" 13347 " : a(a) {}", 13348 Style); 13349 verifyFormat("SomeClass::Constructor()\n" 13350 " : a(a)\n" 13351 " , b(b)\n" 13352 " , c(c) {}", 13353 Style); 13354 verifyFormat("SomeClass::Constructor()\n" 13355 " : a(a) {\n" 13356 " foo();\n" 13357 " bar();\n" 13358 "}", 13359 Style); 13360 13361 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 13362 verifyFormat("SomeClass::Constructor()\n" 13363 " : a(a)\n" 13364 " , b(b)\n" 13365 " , c(c) {\n}", 13366 Style); 13367 verifyFormat("SomeClass::Constructor()\n" 13368 " : a(a) {\n}", 13369 Style); 13370 13371 Style.ColumnLimit = 80; 13372 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 13373 Style.ConstructorInitializerIndentWidth = 2; 13374 verifyFormat("SomeClass::Constructor()\n" 13375 " : a(a)\n" 13376 " , b(b)\n" 13377 " , c(c) {}", 13378 Style); 13379 13380 Style.ConstructorInitializerIndentWidth = 0; 13381 verifyFormat("SomeClass::Constructor()\n" 13382 ": a(a)\n" 13383 ", b(b)\n" 13384 ", c(c) {}", 13385 Style); 13386 13387 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 13388 Style.ConstructorInitializerIndentWidth = 4; 13389 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 13390 verifyFormat( 13391 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 13392 Style); 13393 verifyFormat( 13394 "SomeClass::Constructor()\n" 13395 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 13396 Style); 13397 Style.ConstructorInitializerIndentWidth = 4; 13398 Style.ColumnLimit = 60; 13399 verifyFormat("SomeClass::Constructor()\n" 13400 " : aaaaaaaa(aaaaaaaa)\n" 13401 " , aaaaaaaa(aaaaaaaa)\n" 13402 " , aaaaaaaa(aaaaaaaa) {}", 13403 Style); 13404 } 13405 13406 TEST_F(FormatTest, Destructors) { 13407 verifyFormat("void F(int &i) { i.~int(); }"); 13408 verifyFormat("void F(int &i) { i->~int(); }"); 13409 } 13410 13411 TEST_F(FormatTest, FormatsWithWebKitStyle) { 13412 FormatStyle Style = getWebKitStyle(); 13413 13414 // Don't indent in outer namespaces. 13415 verifyFormat("namespace outer {\n" 13416 "int i;\n" 13417 "namespace inner {\n" 13418 " int i;\n" 13419 "} // namespace inner\n" 13420 "} // namespace outer\n" 13421 "namespace other_outer {\n" 13422 "int i;\n" 13423 "}", 13424 Style); 13425 13426 // Don't indent case labels. 13427 verifyFormat("switch (variable) {\n" 13428 "case 1:\n" 13429 "case 2:\n" 13430 " doSomething();\n" 13431 " break;\n" 13432 "default:\n" 13433 " ++variable;\n" 13434 "}", 13435 Style); 13436 13437 // Wrap before binary operators. 13438 EXPECT_EQ("void f()\n" 13439 "{\n" 13440 " if (aaaaaaaaaaaaaaaa\n" 13441 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 13442 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13443 " return;\n" 13444 "}", 13445 format("void f() {\n" 13446 "if (aaaaaaaaaaaaaaaa\n" 13447 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 13448 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13449 "return;\n" 13450 "}", 13451 Style)); 13452 13453 // Allow functions on a single line. 13454 verifyFormat("void f() { return; }", Style); 13455 13456 // Allow empty blocks on a single line and insert a space in empty blocks. 13457 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 13458 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 13459 // However, don't merge non-empty short loops. 13460 EXPECT_EQ("while (true) {\n" 13461 " continue;\n" 13462 "}", 13463 format("while (true) { continue; }", Style)); 13464 13465 // Constructor initializers are formatted one per line with the "," on the 13466 // new line. 13467 verifyFormat("Constructor()\n" 13468 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 13469 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 13470 " aaaaaaaaaaaaaa)\n" 13471 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 13472 "{\n" 13473 "}", 13474 Style); 13475 verifyFormat("SomeClass::Constructor()\n" 13476 " : a(a)\n" 13477 "{\n" 13478 "}", 13479 Style); 13480 EXPECT_EQ("SomeClass::Constructor()\n" 13481 " : a(a)\n" 13482 "{\n" 13483 "}", 13484 format("SomeClass::Constructor():a(a){}", Style)); 13485 verifyFormat("SomeClass::Constructor()\n" 13486 " : a(a)\n" 13487 " , b(b)\n" 13488 " , c(c)\n" 13489 "{\n" 13490 "}", 13491 Style); 13492 verifyFormat("SomeClass::Constructor()\n" 13493 " : a(a)\n" 13494 "{\n" 13495 " foo();\n" 13496 " bar();\n" 13497 "}", 13498 Style); 13499 13500 // Access specifiers should be aligned left. 13501 verifyFormat("class C {\n" 13502 "public:\n" 13503 " int i;\n" 13504 "};", 13505 Style); 13506 13507 // Do not align comments. 13508 verifyFormat("int a; // Do not\n" 13509 "double b; // align comments.", 13510 Style); 13511 13512 // Do not align operands. 13513 EXPECT_EQ("ASSERT(aaaa\n" 13514 " || bbbb);", 13515 format("ASSERT ( aaaa\n||bbbb);", Style)); 13516 13517 // Accept input's line breaks. 13518 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 13519 " || bbbbbbbbbbbbbbb) {\n" 13520 " i++;\n" 13521 "}", 13522 format("if (aaaaaaaaaaaaaaa\n" 13523 "|| bbbbbbbbbbbbbbb) { i++; }", 13524 Style)); 13525 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 13526 " i++;\n" 13527 "}", 13528 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 13529 13530 // Don't automatically break all macro definitions (llvm.org/PR17842). 13531 verifyFormat("#define aNumber 10", Style); 13532 // However, generally keep the line breaks that the user authored. 13533 EXPECT_EQ("#define aNumber \\\n" 13534 " 10", 13535 format("#define aNumber \\\n" 13536 " 10", 13537 Style)); 13538 13539 // Keep empty and one-element array literals on a single line. 13540 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 13541 " copyItems:YES];", 13542 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 13543 "copyItems:YES];", 13544 Style)); 13545 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 13546 " copyItems:YES];", 13547 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 13548 " copyItems:YES];", 13549 Style)); 13550 // FIXME: This does not seem right, there should be more indentation before 13551 // the array literal's entries. Nested blocks have the same problem. 13552 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13553 " @\"a\",\n" 13554 " @\"a\"\n" 13555 "]\n" 13556 " copyItems:YES];", 13557 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13558 " @\"a\",\n" 13559 " @\"a\"\n" 13560 " ]\n" 13561 " copyItems:YES];", 13562 Style)); 13563 EXPECT_EQ( 13564 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13565 " copyItems:YES];", 13566 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13567 " copyItems:YES];", 13568 Style)); 13569 13570 verifyFormat("[self.a b:c c:d];", Style); 13571 EXPECT_EQ("[self.a b:c\n" 13572 " c:d];", 13573 format("[self.a b:c\n" 13574 "c:d];", 13575 Style)); 13576 } 13577 13578 TEST_F(FormatTest, FormatsLambdas) { 13579 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 13580 verifyFormat( 13581 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 13582 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 13583 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 13584 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 13585 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 13586 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 13587 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 13588 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 13589 verifyFormat("int x = f(*+[] {});"); 13590 verifyFormat("void f() {\n" 13591 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 13592 "}\n"); 13593 verifyFormat("void f() {\n" 13594 " other(x.begin(), //\n" 13595 " x.end(), //\n" 13596 " [&](int, int) { return 1; });\n" 13597 "}\n"); 13598 verifyFormat("void f() {\n" 13599 " other.other.other.other.other(\n" 13600 " x.begin(), x.end(),\n" 13601 " [something, rather](int, int, int, int, int, int, int) { " 13602 "return 1; });\n" 13603 "}\n"); 13604 verifyFormat( 13605 "void f() {\n" 13606 " other.other.other.other.other(\n" 13607 " x.begin(), x.end(),\n" 13608 " [something, rather](int, int, int, int, int, int, int) {\n" 13609 " //\n" 13610 " });\n" 13611 "}\n"); 13612 verifyFormat("SomeFunction([]() { // A cool function...\n" 13613 " return 43;\n" 13614 "});"); 13615 EXPECT_EQ("SomeFunction([]() {\n" 13616 "#define A a\n" 13617 " return 43;\n" 13618 "});", 13619 format("SomeFunction([](){\n" 13620 "#define A a\n" 13621 "return 43;\n" 13622 "});")); 13623 verifyFormat("void f() {\n" 13624 " SomeFunction([](decltype(x), A *a) {});\n" 13625 "}"); 13626 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13627 " [](const aaaaaaaaaa &a) { return a; });"); 13628 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 13629 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 13630 "});"); 13631 verifyFormat("Constructor()\n" 13632 " : Field([] { // comment\n" 13633 " int i;\n" 13634 " }) {}"); 13635 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 13636 " return some_parameter.size();\n" 13637 "};"); 13638 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 13639 " [](const string &s) { return s; };"); 13640 verifyFormat("int i = aaaaaa ? 1 //\n" 13641 " : [] {\n" 13642 " return 2; //\n" 13643 " }();"); 13644 verifyFormat("llvm::errs() << \"number of twos is \"\n" 13645 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 13646 " return x == 2; // force break\n" 13647 " });"); 13648 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13649 " [=](int iiiiiiiiiiii) {\n" 13650 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 13651 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 13652 " });", 13653 getLLVMStyleWithColumns(60)); 13654 verifyFormat("SomeFunction({[&] {\n" 13655 " // comment\n" 13656 " },\n" 13657 " [&] {\n" 13658 " // comment\n" 13659 " }});"); 13660 verifyFormat("SomeFunction({[&] {\n" 13661 " // comment\n" 13662 "}});"); 13663 verifyFormat( 13664 "virtual aaaaaaaaaaaaaaaa(\n" 13665 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 13666 " aaaaa aaaaaaaaa);"); 13667 13668 // Lambdas with return types. 13669 verifyFormat("int c = []() -> int { return 2; }();\n"); 13670 verifyFormat("int c = []() -> int * { return 2; }();\n"); 13671 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 13672 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 13673 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 13674 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 13675 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 13676 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 13677 verifyFormat("[a, a]() -> a<1> {};"); 13678 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 13679 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 13680 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 13681 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 13682 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 13683 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 13684 verifyFormat("[]() -> foo<!5> { return {}; };"); 13685 verifyFormat("[]() -> foo<~5> { return {}; };"); 13686 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 13687 verifyFormat("[]() -> foo<5 || 2> { return {}; };"); 13688 verifyFormat("[]() -> foo<5 & 2> { return {}; };"); 13689 verifyFormat("[]() -> foo<5 && 2> { return {}; };"); 13690 verifyFormat("[]() -> foo<5 == 2> { return {}; };"); 13691 verifyFormat("[]() -> foo<5 != 2> { return {}; };"); 13692 verifyFormat("[]() -> foo<5 >= 2> { return {}; };"); 13693 verifyFormat("[]() -> foo<5 <= 2> { return {}; };"); 13694 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 13695 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 13696 verifyFormat("namespace bar {\n" 13697 "// broken:\n" 13698 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 13699 "} // namespace bar"); 13700 verifyFormat("namespace bar {\n" 13701 "// broken:\n" 13702 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 13703 "} // namespace bar"); 13704 verifyFormat("namespace bar {\n" 13705 "// broken:\n" 13706 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 13707 "} // namespace bar"); 13708 verifyFormat("namespace bar {\n" 13709 "// broken:\n" 13710 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 13711 "} // namespace bar"); 13712 verifyFormat("namespace bar {\n" 13713 "// broken:\n" 13714 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 13715 "} // namespace bar"); 13716 verifyFormat("namespace bar {\n" 13717 "// broken:\n" 13718 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 13719 "} // namespace bar"); 13720 verifyFormat("namespace bar {\n" 13721 "// broken:\n" 13722 "auto foo{[]() -> foo<!5> { return {}; }};\n" 13723 "} // namespace bar"); 13724 verifyFormat("namespace bar {\n" 13725 "// broken:\n" 13726 "auto foo{[]() -> foo<~5> { return {}; }};\n" 13727 "} // namespace bar"); 13728 verifyFormat("namespace bar {\n" 13729 "// broken:\n" 13730 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 13731 "} // namespace bar"); 13732 verifyFormat("namespace bar {\n" 13733 "// broken:\n" 13734 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 13735 "} // namespace bar"); 13736 verifyFormat("namespace bar {\n" 13737 "// broken:\n" 13738 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 13739 "} // namespace bar"); 13740 verifyFormat("namespace bar {\n" 13741 "// broken:\n" 13742 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 13743 "} // namespace bar"); 13744 verifyFormat("namespace bar {\n" 13745 "// broken:\n" 13746 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 13747 "} // namespace bar"); 13748 verifyFormat("namespace bar {\n" 13749 "// broken:\n" 13750 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 13751 "} // namespace bar"); 13752 verifyFormat("namespace bar {\n" 13753 "// broken:\n" 13754 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 13755 "} // namespace bar"); 13756 verifyFormat("namespace bar {\n" 13757 "// broken:\n" 13758 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 13759 "} // namespace bar"); 13760 verifyFormat("namespace bar {\n" 13761 "// broken:\n" 13762 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 13763 "} // namespace bar"); 13764 verifyFormat("namespace bar {\n" 13765 "// broken:\n" 13766 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 13767 "} // namespace bar"); 13768 verifyFormat("[]() -> a<1> {};"); 13769 verifyFormat("[]() -> a<1> { ; };"); 13770 verifyFormat("[]() -> a<1> { ; }();"); 13771 verifyFormat("[a, a]() -> a<true> {};"); 13772 verifyFormat("[]() -> a<true> {};"); 13773 verifyFormat("[]() -> a<true> { ; };"); 13774 verifyFormat("[]() -> a<true> { ; }();"); 13775 verifyFormat("[a, a]() -> a<false> {};"); 13776 verifyFormat("[]() -> a<false> {};"); 13777 verifyFormat("[]() -> a<false> { ; };"); 13778 verifyFormat("[]() -> a<false> { ; }();"); 13779 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 13780 verifyFormat("namespace bar {\n" 13781 "auto foo{[]() -> foo<false> { ; }};\n" 13782 "} // namespace bar"); 13783 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 13784 " int j) -> int {\n" 13785 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 13786 "};"); 13787 verifyFormat( 13788 "aaaaaaaaaaaaaaaaaaaaaa(\n" 13789 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 13790 " return aaaaaaaaaaaaaaaaa;\n" 13791 " });", 13792 getLLVMStyleWithColumns(70)); 13793 verifyFormat("[]() //\n" 13794 " -> int {\n" 13795 " return 1; //\n" 13796 "};"); 13797 13798 // Lambdas with explicit template argument lists. 13799 verifyFormat( 13800 "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n"); 13801 13802 // Multiple lambdas in the same parentheses change indentation rules. These 13803 // lambdas are forced to start on new lines. 13804 verifyFormat("SomeFunction(\n" 13805 " []() {\n" 13806 " //\n" 13807 " },\n" 13808 " []() {\n" 13809 " //\n" 13810 " });"); 13811 13812 // A lambda passed as arg0 is always pushed to the next line. 13813 verifyFormat("SomeFunction(\n" 13814 " [this] {\n" 13815 " //\n" 13816 " },\n" 13817 " 1);\n"); 13818 13819 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like 13820 // the arg0 case above. 13821 auto Style = getGoogleStyle(); 13822 Style.BinPackArguments = false; 13823 verifyFormat("SomeFunction(\n" 13824 " a,\n" 13825 " [this] {\n" 13826 " //\n" 13827 " },\n" 13828 " b);\n", 13829 Style); 13830 verifyFormat("SomeFunction(\n" 13831 " a,\n" 13832 " [this] {\n" 13833 " //\n" 13834 " },\n" 13835 " b);\n"); 13836 13837 // A lambda with a very long line forces arg0 to be pushed out irrespective of 13838 // the BinPackArguments value (as long as the code is wide enough). 13839 verifyFormat( 13840 "something->SomeFunction(\n" 13841 " a,\n" 13842 " [this] {\n" 13843 " " 13844 "D0000000000000000000000000000000000000000000000000000000000001();\n" 13845 " },\n" 13846 " b);\n"); 13847 13848 // A multi-line lambda is pulled up as long as the introducer fits on the 13849 // previous line and there are no further args. 13850 verifyFormat("function(1, [this, that] {\n" 13851 " //\n" 13852 "});\n"); 13853 verifyFormat("function([this, that] {\n" 13854 " //\n" 13855 "});\n"); 13856 // FIXME: this format is not ideal and we should consider forcing the first 13857 // arg onto its own line. 13858 verifyFormat("function(a, b, c, //\n" 13859 " d, [this, that] {\n" 13860 " //\n" 13861 " });\n"); 13862 13863 // Multiple lambdas are treated correctly even when there is a short arg0. 13864 verifyFormat("SomeFunction(\n" 13865 " 1,\n" 13866 " [this] {\n" 13867 " //\n" 13868 " },\n" 13869 " [this] {\n" 13870 " //\n" 13871 " },\n" 13872 " 1);\n"); 13873 13874 // More complex introducers. 13875 verifyFormat("return [i, args...] {};"); 13876 13877 // Not lambdas. 13878 verifyFormat("constexpr char hello[]{\"hello\"};"); 13879 verifyFormat("double &operator[](int i) { return 0; }\n" 13880 "int i;"); 13881 verifyFormat("std::unique_ptr<int[]> foo() {}"); 13882 verifyFormat("int i = a[a][a]->f();"); 13883 verifyFormat("int i = (*b)[a]->f();"); 13884 13885 // Other corner cases. 13886 verifyFormat("void f() {\n" 13887 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 13888 " );\n" 13889 "}"); 13890 13891 // Lambdas created through weird macros. 13892 verifyFormat("void f() {\n" 13893 " MACRO((const AA &a) { return 1; });\n" 13894 " MACRO((AA &a) { return 1; });\n" 13895 "}"); 13896 13897 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 13898 " doo_dah();\n" 13899 " doo_dah();\n" 13900 " })) {\n" 13901 "}"); 13902 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 13903 " doo_dah();\n" 13904 " doo_dah();\n" 13905 " })) {\n" 13906 "}"); 13907 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n" 13908 " doo_dah();\n" 13909 " doo_dah();\n" 13910 " })) {\n" 13911 "}"); 13912 verifyFormat("auto lambda = []() {\n" 13913 " int a = 2\n" 13914 "#if A\n" 13915 " + 2\n" 13916 "#endif\n" 13917 " ;\n" 13918 "};"); 13919 13920 // Lambdas with complex multiline introducers. 13921 verifyFormat( 13922 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13923 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 13924 " -> ::std::unordered_set<\n" 13925 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 13926 " //\n" 13927 " });"); 13928 13929 FormatStyle DoNotMerge = getLLVMStyle(); 13930 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 13931 verifyFormat("auto c = []() {\n" 13932 " return b;\n" 13933 "};", 13934 "auto c = []() { return b; };", DoNotMerge); 13935 verifyFormat("auto c = []() {\n" 13936 "};", 13937 " auto c = []() {};", DoNotMerge); 13938 13939 FormatStyle MergeEmptyOnly = getLLVMStyle(); 13940 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 13941 verifyFormat("auto c = []() {\n" 13942 " return b;\n" 13943 "};", 13944 "auto c = []() {\n" 13945 " return b;\n" 13946 " };", 13947 MergeEmptyOnly); 13948 verifyFormat("auto c = []() {};", 13949 "auto c = []() {\n" 13950 "};", 13951 MergeEmptyOnly); 13952 13953 FormatStyle MergeInline = getLLVMStyle(); 13954 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 13955 verifyFormat("auto c = []() {\n" 13956 " return b;\n" 13957 "};", 13958 "auto c = []() { return b; };", MergeInline); 13959 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 13960 MergeInline); 13961 verifyFormat("function([]() { return b; }, a)", 13962 "function([]() { return b; }, a)", MergeInline); 13963 verifyFormat("function(a, []() { return b; })", 13964 "function(a, []() { return b; })", MergeInline); 13965 } 13966 13967 TEST_F(FormatTest, EmptyLinesInLambdas) { 13968 verifyFormat("auto lambda = []() {\n" 13969 " x(); //\n" 13970 "};", 13971 "auto lambda = []() {\n" 13972 "\n" 13973 " x(); //\n" 13974 "\n" 13975 "};"); 13976 } 13977 13978 TEST_F(FormatTest, FormatsBlocks) { 13979 FormatStyle ShortBlocks = getLLVMStyle(); 13980 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13981 verifyFormat("int (^Block)(int, int);", ShortBlocks); 13982 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 13983 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 13984 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 13985 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 13986 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 13987 13988 verifyFormat("foo(^{ bar(); });", ShortBlocks); 13989 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 13990 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 13991 13992 verifyFormat("[operation setCompletionBlock:^{\n" 13993 " [self onOperationDone];\n" 13994 "}];"); 13995 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 13996 " [self onOperationDone];\n" 13997 "}]};"); 13998 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 13999 " f();\n" 14000 "}];"); 14001 verifyFormat("int a = [operation block:^int(int *i) {\n" 14002 " return 1;\n" 14003 "}];"); 14004 verifyFormat("[myObject doSomethingWith:arg1\n" 14005 " aaa:^int(int *a) {\n" 14006 " return 1;\n" 14007 " }\n" 14008 " bbb:f(a * bbbbbbbb)];"); 14009 14010 verifyFormat("[operation setCompletionBlock:^{\n" 14011 " [self.delegate newDataAvailable];\n" 14012 "}];", 14013 getLLVMStyleWithColumns(60)); 14014 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 14015 " NSString *path = [self sessionFilePath];\n" 14016 " if (path) {\n" 14017 " // ...\n" 14018 " }\n" 14019 "});"); 14020 verifyFormat("[[SessionService sharedService]\n" 14021 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14022 " if (window) {\n" 14023 " [self windowDidLoad:window];\n" 14024 " } else {\n" 14025 " [self errorLoadingWindow];\n" 14026 " }\n" 14027 " }];"); 14028 verifyFormat("void (^largeBlock)(void) = ^{\n" 14029 " // ...\n" 14030 "};\n", 14031 getLLVMStyleWithColumns(40)); 14032 verifyFormat("[[SessionService sharedService]\n" 14033 " loadWindowWithCompletionBlock: //\n" 14034 " ^(SessionWindow *window) {\n" 14035 " if (window) {\n" 14036 " [self windowDidLoad:window];\n" 14037 " } else {\n" 14038 " [self errorLoadingWindow];\n" 14039 " }\n" 14040 " }];", 14041 getLLVMStyleWithColumns(60)); 14042 verifyFormat("[myObject doSomethingWith:arg1\n" 14043 " firstBlock:^(Foo *a) {\n" 14044 " // ...\n" 14045 " int i;\n" 14046 " }\n" 14047 " secondBlock:^(Bar *b) {\n" 14048 " // ...\n" 14049 " int i;\n" 14050 " }\n" 14051 " thirdBlock:^Foo(Bar *b) {\n" 14052 " // ...\n" 14053 " int i;\n" 14054 " }];"); 14055 verifyFormat("[myObject doSomethingWith:arg1\n" 14056 " firstBlock:-1\n" 14057 " secondBlock:^(Bar *b) {\n" 14058 " // ...\n" 14059 " int i;\n" 14060 " }];"); 14061 14062 verifyFormat("f(^{\n" 14063 " @autoreleasepool {\n" 14064 " if (a) {\n" 14065 " g();\n" 14066 " }\n" 14067 " }\n" 14068 "});"); 14069 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 14070 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 14071 "};"); 14072 14073 FormatStyle FourIndent = getLLVMStyle(); 14074 FourIndent.ObjCBlockIndentWidth = 4; 14075 verifyFormat("[operation setCompletionBlock:^{\n" 14076 " [self onOperationDone];\n" 14077 "}];", 14078 FourIndent); 14079 } 14080 14081 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 14082 FormatStyle ZeroColumn = getLLVMStyle(); 14083 ZeroColumn.ColumnLimit = 0; 14084 14085 verifyFormat("[[SessionService sharedService] " 14086 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14087 " if (window) {\n" 14088 " [self windowDidLoad:window];\n" 14089 " } else {\n" 14090 " [self errorLoadingWindow];\n" 14091 " }\n" 14092 "}];", 14093 ZeroColumn); 14094 EXPECT_EQ("[[SessionService sharedService]\n" 14095 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14096 " if (window) {\n" 14097 " [self windowDidLoad:window];\n" 14098 " } else {\n" 14099 " [self errorLoadingWindow];\n" 14100 " }\n" 14101 " }];", 14102 format("[[SessionService sharedService]\n" 14103 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14104 " if (window) {\n" 14105 " [self windowDidLoad:window];\n" 14106 " } else {\n" 14107 " [self errorLoadingWindow];\n" 14108 " }\n" 14109 "}];", 14110 ZeroColumn)); 14111 verifyFormat("[myObject doSomethingWith:arg1\n" 14112 " firstBlock:^(Foo *a) {\n" 14113 " // ...\n" 14114 " int i;\n" 14115 " }\n" 14116 " secondBlock:^(Bar *b) {\n" 14117 " // ...\n" 14118 " int i;\n" 14119 " }\n" 14120 " thirdBlock:^Foo(Bar *b) {\n" 14121 " // ...\n" 14122 " int i;\n" 14123 " }];", 14124 ZeroColumn); 14125 verifyFormat("f(^{\n" 14126 " @autoreleasepool {\n" 14127 " if (a) {\n" 14128 " g();\n" 14129 " }\n" 14130 " }\n" 14131 "});", 14132 ZeroColumn); 14133 verifyFormat("void (^largeBlock)(void) = ^{\n" 14134 " // ...\n" 14135 "};", 14136 ZeroColumn); 14137 14138 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 14139 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 14140 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 14141 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 14142 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 14143 " int i;\n" 14144 "};", 14145 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 14146 } 14147 14148 TEST_F(FormatTest, SupportsCRLF) { 14149 EXPECT_EQ("int a;\r\n" 14150 "int b;\r\n" 14151 "int c;\r\n", 14152 format("int a;\r\n" 14153 " int b;\r\n" 14154 " int c;\r\n", 14155 getLLVMStyle())); 14156 EXPECT_EQ("int a;\r\n" 14157 "int b;\r\n" 14158 "int c;\r\n", 14159 format("int a;\r\n" 14160 " int b;\n" 14161 " int c;\r\n", 14162 getLLVMStyle())); 14163 EXPECT_EQ("int a;\n" 14164 "int b;\n" 14165 "int c;\n", 14166 format("int a;\r\n" 14167 " int b;\n" 14168 " int c;\n", 14169 getLLVMStyle())); 14170 EXPECT_EQ("\"aaaaaaa \"\r\n" 14171 "\"bbbbbbb\";\r\n", 14172 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 14173 EXPECT_EQ("#define A \\\r\n" 14174 " b; \\\r\n" 14175 " c; \\\r\n" 14176 " d;\r\n", 14177 format("#define A \\\r\n" 14178 " b; \\\r\n" 14179 " c; d; \r\n", 14180 getGoogleStyle())); 14181 14182 EXPECT_EQ("/*\r\n" 14183 "multi line block comments\r\n" 14184 "should not introduce\r\n" 14185 "an extra carriage return\r\n" 14186 "*/\r\n", 14187 format("/*\r\n" 14188 "multi line block comments\r\n" 14189 "should not introduce\r\n" 14190 "an extra carriage return\r\n" 14191 "*/\r\n")); 14192 EXPECT_EQ("/*\r\n" 14193 "\r\n" 14194 "*/", 14195 format("/*\r\n" 14196 " \r\r\r\n" 14197 "*/")); 14198 14199 FormatStyle style = getLLVMStyle(); 14200 14201 style.DeriveLineEnding = true; 14202 style.UseCRLF = false; 14203 EXPECT_EQ("union FooBarBazQux {\n" 14204 " int foo;\n" 14205 " int bar;\n" 14206 " int baz;\n" 14207 "};", 14208 format("union FooBarBazQux {\r\n" 14209 " int foo;\n" 14210 " int bar;\r\n" 14211 " int baz;\n" 14212 "};", 14213 style)); 14214 style.UseCRLF = true; 14215 EXPECT_EQ("union FooBarBazQux {\r\n" 14216 " int foo;\r\n" 14217 " int bar;\r\n" 14218 " int baz;\r\n" 14219 "};", 14220 format("union FooBarBazQux {\r\n" 14221 " int foo;\n" 14222 " int bar;\r\n" 14223 " int baz;\n" 14224 "};", 14225 style)); 14226 14227 style.DeriveLineEnding = false; 14228 style.UseCRLF = false; 14229 EXPECT_EQ("union FooBarBazQux {\n" 14230 " int foo;\n" 14231 " int bar;\n" 14232 " int baz;\n" 14233 " int qux;\n" 14234 "};", 14235 format("union FooBarBazQux {\r\n" 14236 " int foo;\n" 14237 " int bar;\r\n" 14238 " int baz;\n" 14239 " int qux;\r\n" 14240 "};", 14241 style)); 14242 style.UseCRLF = true; 14243 EXPECT_EQ("union FooBarBazQux {\r\n" 14244 " int foo;\r\n" 14245 " int bar;\r\n" 14246 " int baz;\r\n" 14247 " int qux;\r\n" 14248 "};", 14249 format("union FooBarBazQux {\r\n" 14250 " int foo;\n" 14251 " int bar;\r\n" 14252 " int baz;\n" 14253 " int qux;\n" 14254 "};", 14255 style)); 14256 14257 style.DeriveLineEnding = true; 14258 style.UseCRLF = false; 14259 EXPECT_EQ("union FooBarBazQux {\r\n" 14260 " int foo;\r\n" 14261 " int bar;\r\n" 14262 " int baz;\r\n" 14263 " int qux;\r\n" 14264 "};", 14265 format("union FooBarBazQux {\r\n" 14266 " int foo;\n" 14267 " int bar;\r\n" 14268 " int baz;\n" 14269 " int qux;\r\n" 14270 "};", 14271 style)); 14272 style.UseCRLF = true; 14273 EXPECT_EQ("union FooBarBazQux {\n" 14274 " int foo;\n" 14275 " int bar;\n" 14276 " int baz;\n" 14277 " int qux;\n" 14278 "};", 14279 format("union FooBarBazQux {\r\n" 14280 " int foo;\n" 14281 " int bar;\r\n" 14282 " int baz;\n" 14283 " int qux;\n" 14284 "};", 14285 style)); 14286 } 14287 14288 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 14289 verifyFormat("MY_CLASS(C) {\n" 14290 " int i;\n" 14291 " int j;\n" 14292 "};"); 14293 } 14294 14295 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 14296 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 14297 TwoIndent.ContinuationIndentWidth = 2; 14298 14299 EXPECT_EQ("int i =\n" 14300 " longFunction(\n" 14301 " arg);", 14302 format("int i = longFunction(arg);", TwoIndent)); 14303 14304 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 14305 SixIndent.ContinuationIndentWidth = 6; 14306 14307 EXPECT_EQ("int i =\n" 14308 " longFunction(\n" 14309 " arg);", 14310 format("int i = longFunction(arg);", SixIndent)); 14311 } 14312 14313 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 14314 FormatStyle Style = getLLVMStyle(); 14315 verifyFormat("int Foo::getter(\n" 14316 " //\n" 14317 ") const {\n" 14318 " return foo;\n" 14319 "}", 14320 Style); 14321 verifyFormat("void Foo::setter(\n" 14322 " //\n" 14323 ") {\n" 14324 " foo = 1;\n" 14325 "}", 14326 Style); 14327 } 14328 14329 TEST_F(FormatTest, SpacesInAngles) { 14330 FormatStyle Spaces = getLLVMStyle(); 14331 Spaces.SpacesInAngles = true; 14332 14333 verifyFormat("static_cast< int >(arg);", Spaces); 14334 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 14335 verifyFormat("f< int, float >();", Spaces); 14336 verifyFormat("template <> g() {}", Spaces); 14337 verifyFormat("template < std::vector< int > > f() {}", Spaces); 14338 verifyFormat("std::function< void(int, int) > fct;", Spaces); 14339 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 14340 Spaces); 14341 14342 Spaces.Standard = FormatStyle::LS_Cpp03; 14343 Spaces.SpacesInAngles = true; 14344 verifyFormat("A< A< int > >();", Spaces); 14345 14346 Spaces.SpacesInAngles = false; 14347 verifyFormat("A<A<int> >();", Spaces); 14348 14349 Spaces.Standard = FormatStyle::LS_Cpp11; 14350 Spaces.SpacesInAngles = true; 14351 verifyFormat("A< A< int > >();", Spaces); 14352 14353 Spaces.SpacesInAngles = false; 14354 verifyFormat("A<A<int>>();", Spaces); 14355 } 14356 14357 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 14358 FormatStyle Style = getLLVMStyle(); 14359 Style.SpaceAfterTemplateKeyword = false; 14360 verifyFormat("template<int> void foo();", Style); 14361 } 14362 14363 TEST_F(FormatTest, TripleAngleBrackets) { 14364 verifyFormat("f<<<1, 1>>>();"); 14365 verifyFormat("f<<<1, 1, 1, s>>>();"); 14366 verifyFormat("f<<<a, b, c, d>>>();"); 14367 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 14368 verifyFormat("f<param><<<1, 1>>>();"); 14369 verifyFormat("f<1><<<1, 1>>>();"); 14370 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 14371 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14372 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 14373 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 14374 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 14375 } 14376 14377 TEST_F(FormatTest, MergeLessLessAtEnd) { 14378 verifyFormat("<<"); 14379 EXPECT_EQ("< < <", format("\\\n<<<")); 14380 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14381 "aaallvm::outs() <<"); 14382 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14383 "aaaallvm::outs()\n <<"); 14384 } 14385 14386 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 14387 std::string code = "#if A\n" 14388 "#if B\n" 14389 "a.\n" 14390 "#endif\n" 14391 " a = 1;\n" 14392 "#else\n" 14393 "#endif\n" 14394 "#if C\n" 14395 "#else\n" 14396 "#endif\n"; 14397 EXPECT_EQ(code, format(code)); 14398 } 14399 14400 TEST_F(FormatTest, HandleConflictMarkers) { 14401 // Git/SVN conflict markers. 14402 EXPECT_EQ("int a;\n" 14403 "void f() {\n" 14404 " callme(some(parameter1,\n" 14405 "<<<<<<< text by the vcs\n" 14406 " parameter2),\n" 14407 "||||||| text by the vcs\n" 14408 " parameter2),\n" 14409 " parameter3,\n" 14410 "======= text by the vcs\n" 14411 " parameter2, parameter3),\n" 14412 ">>>>>>> text by the vcs\n" 14413 " otherparameter);\n", 14414 format("int a;\n" 14415 "void f() {\n" 14416 " callme(some(parameter1,\n" 14417 "<<<<<<< text by the vcs\n" 14418 " parameter2),\n" 14419 "||||||| text by the vcs\n" 14420 " parameter2),\n" 14421 " parameter3,\n" 14422 "======= text by the vcs\n" 14423 " parameter2,\n" 14424 " parameter3),\n" 14425 ">>>>>>> text by the vcs\n" 14426 " otherparameter);\n")); 14427 14428 // Perforce markers. 14429 EXPECT_EQ("void f() {\n" 14430 " function(\n" 14431 ">>>> text by the vcs\n" 14432 " parameter,\n" 14433 "==== text by the vcs\n" 14434 " parameter,\n" 14435 "==== text by the vcs\n" 14436 " parameter,\n" 14437 "<<<< text by the vcs\n" 14438 " parameter);\n", 14439 format("void f() {\n" 14440 " function(\n" 14441 ">>>> text by the vcs\n" 14442 " parameter,\n" 14443 "==== text by the vcs\n" 14444 " parameter,\n" 14445 "==== text by the vcs\n" 14446 " parameter,\n" 14447 "<<<< text by the vcs\n" 14448 " parameter);\n")); 14449 14450 EXPECT_EQ("<<<<<<<\n" 14451 "|||||||\n" 14452 "=======\n" 14453 ">>>>>>>", 14454 format("<<<<<<<\n" 14455 "|||||||\n" 14456 "=======\n" 14457 ">>>>>>>")); 14458 14459 EXPECT_EQ("<<<<<<<\n" 14460 "|||||||\n" 14461 "int i;\n" 14462 "=======\n" 14463 ">>>>>>>", 14464 format("<<<<<<<\n" 14465 "|||||||\n" 14466 "int i;\n" 14467 "=======\n" 14468 ">>>>>>>")); 14469 14470 // FIXME: Handle parsing of macros around conflict markers correctly: 14471 EXPECT_EQ("#define Macro \\\n" 14472 "<<<<<<<\n" 14473 "Something \\\n" 14474 "|||||||\n" 14475 "Else \\\n" 14476 "=======\n" 14477 "Other \\\n" 14478 ">>>>>>>\n" 14479 " End int i;\n", 14480 format("#define Macro \\\n" 14481 "<<<<<<<\n" 14482 " Something \\\n" 14483 "|||||||\n" 14484 " Else \\\n" 14485 "=======\n" 14486 " Other \\\n" 14487 ">>>>>>>\n" 14488 " End\n" 14489 "int i;\n")); 14490 } 14491 14492 TEST_F(FormatTest, DisableRegions) { 14493 EXPECT_EQ("int i;\n" 14494 "// clang-format off\n" 14495 " int j;\n" 14496 "// clang-format on\n" 14497 "int k;", 14498 format(" int i;\n" 14499 " // clang-format off\n" 14500 " int j;\n" 14501 " // clang-format on\n" 14502 " int k;")); 14503 EXPECT_EQ("int i;\n" 14504 "/* clang-format off */\n" 14505 " int j;\n" 14506 "/* clang-format on */\n" 14507 "int k;", 14508 format(" int i;\n" 14509 " /* clang-format off */\n" 14510 " int j;\n" 14511 " /* clang-format on */\n" 14512 " int k;")); 14513 14514 // Don't reflow comments within disabled regions. 14515 EXPECT_EQ("// clang-format off\n" 14516 "// long long long long long long line\n" 14517 "/* clang-format on */\n" 14518 "/* long long long\n" 14519 " * long long long\n" 14520 " * line */\n" 14521 "int i;\n" 14522 "/* clang-format off */\n" 14523 "/* long long long long long long line */\n", 14524 format("// clang-format off\n" 14525 "// long long long long long long line\n" 14526 "/* clang-format on */\n" 14527 "/* long long long long long long line */\n" 14528 "int i;\n" 14529 "/* clang-format off */\n" 14530 "/* long long long long long long line */\n", 14531 getLLVMStyleWithColumns(20))); 14532 } 14533 14534 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 14535 format("? ) ="); 14536 verifyNoCrash("#define a\\\n /**/}"); 14537 } 14538 14539 TEST_F(FormatTest, FormatsTableGenCode) { 14540 FormatStyle Style = getLLVMStyle(); 14541 Style.Language = FormatStyle::LK_TableGen; 14542 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 14543 } 14544 14545 TEST_F(FormatTest, ArrayOfTemplates) { 14546 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 14547 format("auto a = new unique_ptr<int > [ 10];")); 14548 14549 FormatStyle Spaces = getLLVMStyle(); 14550 Spaces.SpacesInSquareBrackets = true; 14551 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 14552 format("auto a = new unique_ptr<int > [10];", Spaces)); 14553 } 14554 14555 TEST_F(FormatTest, ArrayAsTemplateType) { 14556 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 14557 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 14558 14559 FormatStyle Spaces = getLLVMStyle(); 14560 Spaces.SpacesInSquareBrackets = true; 14561 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 14562 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 14563 } 14564 14565 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); } 14566 14567 TEST(FormatStyle, GetStyleWithEmptyFileName) { 14568 llvm::vfs::InMemoryFileSystem FS; 14569 auto Style1 = getStyle("file", "", "Google", "", &FS); 14570 ASSERT_TRUE((bool)Style1); 14571 ASSERT_EQ(*Style1, getGoogleStyle()); 14572 } 14573 14574 TEST(FormatStyle, GetStyleOfFile) { 14575 llvm::vfs::InMemoryFileSystem FS; 14576 // Test 1: format file in the same directory. 14577 ASSERT_TRUE( 14578 FS.addFile("/a/.clang-format", 0, 14579 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 14580 ASSERT_TRUE( 14581 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14582 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 14583 ASSERT_TRUE((bool)Style1); 14584 ASSERT_EQ(*Style1, getLLVMStyle()); 14585 14586 // Test 2.1: fallback to default. 14587 ASSERT_TRUE( 14588 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14589 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 14590 ASSERT_TRUE((bool)Style2); 14591 ASSERT_EQ(*Style2, getMozillaStyle()); 14592 14593 // Test 2.2: no format on 'none' fallback style. 14594 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 14595 ASSERT_TRUE((bool)Style2); 14596 ASSERT_EQ(*Style2, getNoStyle()); 14597 14598 // Test 2.3: format if config is found with no based style while fallback is 14599 // 'none'. 14600 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 14601 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 14602 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 14603 ASSERT_TRUE((bool)Style2); 14604 ASSERT_EQ(*Style2, getLLVMStyle()); 14605 14606 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 14607 Style2 = getStyle("{}", "a.h", "none", "", &FS); 14608 ASSERT_TRUE((bool)Style2); 14609 ASSERT_EQ(*Style2, getLLVMStyle()); 14610 14611 // Test 3: format file in parent directory. 14612 ASSERT_TRUE( 14613 FS.addFile("/c/.clang-format", 0, 14614 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 14615 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 14616 llvm::MemoryBuffer::getMemBuffer("int i;"))); 14617 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 14618 ASSERT_TRUE((bool)Style3); 14619 ASSERT_EQ(*Style3, getGoogleStyle()); 14620 14621 // Test 4: error on invalid fallback style 14622 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 14623 ASSERT_FALSE((bool)Style4); 14624 llvm::consumeError(Style4.takeError()); 14625 14626 // Test 5: error on invalid yaml on command line 14627 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 14628 ASSERT_FALSE((bool)Style5); 14629 llvm::consumeError(Style5.takeError()); 14630 14631 // Test 6: error on invalid style 14632 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 14633 ASSERT_FALSE((bool)Style6); 14634 llvm::consumeError(Style6.takeError()); 14635 14636 // Test 7: found config file, error on parsing it 14637 ASSERT_TRUE( 14638 FS.addFile("/d/.clang-format", 0, 14639 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 14640 "InvalidKey: InvalidValue"))); 14641 ASSERT_TRUE( 14642 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14643 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 14644 ASSERT_FALSE((bool)Style7); 14645 llvm::consumeError(Style7.takeError()); 14646 14647 // Test 8: inferred per-language defaults apply. 14648 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 14649 ASSERT_TRUE((bool)StyleTd); 14650 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 14651 } 14652 14653 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 14654 // Column limit is 20. 14655 std::string Code = "Type *a =\n" 14656 " new Type();\n" 14657 "g(iiiii, 0, jjjjj,\n" 14658 " 0, kkkkk, 0, mm);\n" 14659 "int bad = format ;"; 14660 std::string Expected = "auto a = new Type();\n" 14661 "g(iiiii, nullptr,\n" 14662 " jjjjj, nullptr,\n" 14663 " kkkkk, nullptr,\n" 14664 " mm);\n" 14665 "int bad = format ;"; 14666 FileID ID = Context.createInMemoryFile("format.cpp", Code); 14667 tooling::Replacements Replaces = toReplacements( 14668 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 14669 "auto "), 14670 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 14671 "nullptr"), 14672 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 14673 "nullptr"), 14674 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 14675 "nullptr")}); 14676 14677 format::FormatStyle Style = format::getLLVMStyle(); 14678 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 14679 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 14680 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 14681 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 14682 auto Result = applyAllReplacements(Code, *FormattedReplaces); 14683 EXPECT_TRUE(static_cast<bool>(Result)); 14684 EXPECT_EQ(Expected, *Result); 14685 } 14686 14687 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 14688 std::string Code = "#include \"a.h\"\n" 14689 "#include \"c.h\"\n" 14690 "\n" 14691 "int main() {\n" 14692 " return 0;\n" 14693 "}"; 14694 std::string Expected = "#include \"a.h\"\n" 14695 "#include \"b.h\"\n" 14696 "#include \"c.h\"\n" 14697 "\n" 14698 "int main() {\n" 14699 " return 0;\n" 14700 "}"; 14701 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 14702 tooling::Replacements Replaces = toReplacements( 14703 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 14704 "#include \"b.h\"\n")}); 14705 14706 format::FormatStyle Style = format::getLLVMStyle(); 14707 Style.SortIncludes = true; 14708 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 14709 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 14710 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 14711 auto Result = applyAllReplacements(Code, *FormattedReplaces); 14712 EXPECT_TRUE(static_cast<bool>(Result)); 14713 EXPECT_EQ(Expected, *Result); 14714 } 14715 14716 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 14717 EXPECT_EQ("using std::cin;\n" 14718 "using std::cout;", 14719 format("using std::cout;\n" 14720 "using std::cin;", 14721 getGoogleStyle())); 14722 } 14723 14724 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 14725 format::FormatStyle Style = format::getLLVMStyle(); 14726 Style.Standard = FormatStyle::LS_Cpp03; 14727 // cpp03 recognize this string as identifier u8 and literal character 'a' 14728 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 14729 } 14730 14731 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 14732 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 14733 // all modes, including C++11, C++14 and C++17 14734 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 14735 } 14736 14737 TEST_F(FormatTest, DoNotFormatLikelyXml) { 14738 EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle())); 14739 EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle())); 14740 } 14741 14742 TEST_F(FormatTest, StructuredBindings) { 14743 // Structured bindings is a C++17 feature. 14744 // all modes, including C++11, C++14 and C++17 14745 verifyFormat("auto [a, b] = f();"); 14746 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 14747 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 14748 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 14749 EXPECT_EQ("auto const volatile [a, b] = f();", 14750 format("auto const volatile[a, b] = f();")); 14751 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 14752 EXPECT_EQ("auto &[a, b, c] = f();", 14753 format("auto &[ a , b,c ] = f();")); 14754 EXPECT_EQ("auto &&[a, b, c] = f();", 14755 format("auto &&[ a , b,c ] = f();")); 14756 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 14757 EXPECT_EQ("auto const volatile &&[a, b] = f();", 14758 format("auto const volatile &&[a, b] = f();")); 14759 EXPECT_EQ("auto const &&[a, b] = f();", 14760 format("auto const && [a, b] = f();")); 14761 EXPECT_EQ("const auto &[a, b] = f();", 14762 format("const auto & [a, b] = f();")); 14763 EXPECT_EQ("const auto volatile &&[a, b] = f();", 14764 format("const auto volatile &&[a, b] = f();")); 14765 EXPECT_EQ("volatile const auto &&[a, b] = f();", 14766 format("volatile const auto &&[a, b] = f();")); 14767 EXPECT_EQ("const auto &&[a, b] = f();", 14768 format("const auto && [a, b] = f();")); 14769 14770 // Make sure we don't mistake structured bindings for lambdas. 14771 FormatStyle PointerMiddle = getLLVMStyle(); 14772 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 14773 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 14774 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 14775 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 14776 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 14777 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 14778 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 14779 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 14780 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 14781 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 14782 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 14783 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 14784 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 14785 14786 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 14787 format("for (const auto && [a, b] : some_range) {\n}")); 14788 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 14789 format("for (const auto & [a, b] : some_range) {\n}")); 14790 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 14791 format("for (const auto[a, b] : some_range) {\n}")); 14792 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 14793 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 14794 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 14795 EXPECT_EQ("auto const &[x, y](expr);", 14796 format("auto const & [x,y] (expr);")); 14797 EXPECT_EQ("auto const &&[x, y](expr);", 14798 format("auto const && [x,y] (expr);")); 14799 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 14800 EXPECT_EQ("auto const &[x, y]{expr};", 14801 format("auto const & [x,y] {expr};")); 14802 EXPECT_EQ("auto const &&[x, y]{expr};", 14803 format("auto const && [x,y] {expr};")); 14804 14805 format::FormatStyle Spaces = format::getLLVMStyle(); 14806 Spaces.SpacesInSquareBrackets = true; 14807 verifyFormat("auto [ a, b ] = f();", Spaces); 14808 verifyFormat("auto &&[ a, b ] = f();", Spaces); 14809 verifyFormat("auto &[ a, b ] = f();", Spaces); 14810 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 14811 verifyFormat("auto const &[ a, b ] = f();", Spaces); 14812 } 14813 14814 TEST_F(FormatTest, FileAndCode) { 14815 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 14816 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 14817 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 14818 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 14819 EXPECT_EQ(FormatStyle::LK_ObjC, 14820 guessLanguage("foo.h", "@interface Foo\n@end\n")); 14821 EXPECT_EQ( 14822 FormatStyle::LK_ObjC, 14823 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 14824 EXPECT_EQ(FormatStyle::LK_ObjC, 14825 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 14826 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 14827 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 14828 EXPECT_EQ(FormatStyle::LK_ObjC, 14829 guessLanguage("foo", "@interface Foo\n@end\n")); 14830 EXPECT_EQ(FormatStyle::LK_ObjC, 14831 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 14832 EXPECT_EQ( 14833 FormatStyle::LK_ObjC, 14834 guessLanguage("foo.h", 14835 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 14836 EXPECT_EQ( 14837 FormatStyle::LK_Cpp, 14838 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 14839 } 14840 14841 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 14842 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 14843 EXPECT_EQ(FormatStyle::LK_ObjC, 14844 guessLanguage("foo.h", "array[[calculator getIndex]];")); 14845 EXPECT_EQ(FormatStyle::LK_Cpp, 14846 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 14847 EXPECT_EQ( 14848 FormatStyle::LK_Cpp, 14849 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 14850 EXPECT_EQ(FormatStyle::LK_ObjC, 14851 guessLanguage("foo.h", "[[noreturn foo] bar];")); 14852 EXPECT_EQ(FormatStyle::LK_Cpp, 14853 guessLanguage("foo.h", "[[clang::fallthrough]];")); 14854 EXPECT_EQ(FormatStyle::LK_ObjC, 14855 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 14856 EXPECT_EQ(FormatStyle::LK_Cpp, 14857 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 14858 EXPECT_EQ(FormatStyle::LK_Cpp, 14859 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 14860 EXPECT_EQ(FormatStyle::LK_ObjC, 14861 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 14862 EXPECT_EQ(FormatStyle::LK_Cpp, 14863 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 14864 EXPECT_EQ( 14865 FormatStyle::LK_Cpp, 14866 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 14867 EXPECT_EQ( 14868 FormatStyle::LK_Cpp, 14869 guessLanguage("foo.h", 14870 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 14871 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 14872 } 14873 14874 TEST_F(FormatTest, GuessLanguageWithCaret) { 14875 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 14876 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 14877 EXPECT_EQ(FormatStyle::LK_ObjC, 14878 guessLanguage("foo.h", "int(^)(char, float);")); 14879 EXPECT_EQ(FormatStyle::LK_ObjC, 14880 guessLanguage("foo.h", "int(^foo)(char, float);")); 14881 EXPECT_EQ(FormatStyle::LK_ObjC, 14882 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 14883 EXPECT_EQ(FormatStyle::LK_ObjC, 14884 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 14885 EXPECT_EQ( 14886 FormatStyle::LK_ObjC, 14887 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 14888 } 14889 14890 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 14891 EXPECT_EQ(FormatStyle::LK_Cpp, 14892 guessLanguage("foo.h", "void f() {\n" 14893 " asm (\"mov %[e], %[d]\"\n" 14894 " : [d] \"=rm\" (d)\n" 14895 " [e] \"rm\" (*e));\n" 14896 "}")); 14897 EXPECT_EQ(FormatStyle::LK_Cpp, 14898 guessLanguage("foo.h", "void f() {\n" 14899 " _asm (\"mov %[e], %[d]\"\n" 14900 " : [d] \"=rm\" (d)\n" 14901 " [e] \"rm\" (*e));\n" 14902 "}")); 14903 EXPECT_EQ(FormatStyle::LK_Cpp, 14904 guessLanguage("foo.h", "void f() {\n" 14905 " __asm (\"mov %[e], %[d]\"\n" 14906 " : [d] \"=rm\" (d)\n" 14907 " [e] \"rm\" (*e));\n" 14908 "}")); 14909 EXPECT_EQ(FormatStyle::LK_Cpp, 14910 guessLanguage("foo.h", "void f() {\n" 14911 " __asm__ (\"mov %[e], %[d]\"\n" 14912 " : [d] \"=rm\" (d)\n" 14913 " [e] \"rm\" (*e));\n" 14914 "}")); 14915 EXPECT_EQ(FormatStyle::LK_Cpp, 14916 guessLanguage("foo.h", "void f() {\n" 14917 " asm (\"mov %[e], %[d]\"\n" 14918 " : [d] \"=rm\" (d),\n" 14919 " [e] \"rm\" (*e));\n" 14920 "}")); 14921 EXPECT_EQ(FormatStyle::LK_Cpp, 14922 guessLanguage("foo.h", "void f() {\n" 14923 " asm volatile (\"mov %[e], %[d]\"\n" 14924 " : [d] \"=rm\" (d)\n" 14925 " [e] \"rm\" (*e));\n" 14926 "}")); 14927 } 14928 14929 TEST_F(FormatTest, GuessLanguageWithChildLines) { 14930 EXPECT_EQ(FormatStyle::LK_Cpp, 14931 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 14932 EXPECT_EQ(FormatStyle::LK_ObjC, 14933 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 14934 EXPECT_EQ( 14935 FormatStyle::LK_Cpp, 14936 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 14937 EXPECT_EQ( 14938 FormatStyle::LK_ObjC, 14939 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 14940 } 14941 14942 TEST_F(FormatTest, TypenameMacros) { 14943 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 14944 14945 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 14946 FormatStyle Google = getGoogleStyleWithColumns(0); 14947 Google.TypenameMacros = TypenameMacros; 14948 verifyFormat("struct foo {\n" 14949 " int bar;\n" 14950 " TAILQ_ENTRY(a) bleh;\n" 14951 "};", 14952 Google); 14953 14954 FormatStyle Macros = getLLVMStyle(); 14955 Macros.TypenameMacros = TypenameMacros; 14956 14957 verifyFormat("STACK_OF(int) a;", Macros); 14958 verifyFormat("STACK_OF(int) *a;", Macros); 14959 verifyFormat("STACK_OF(int const *) *a;", Macros); 14960 verifyFormat("STACK_OF(int *const) *a;", Macros); 14961 verifyFormat("STACK_OF(int, string) a;", Macros); 14962 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 14963 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 14964 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 14965 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 14966 14967 Macros.PointerAlignment = FormatStyle::PAS_Left; 14968 verifyFormat("STACK_OF(int)* a;", Macros); 14969 verifyFormat("STACK_OF(int*)* a;", Macros); 14970 } 14971 14972 TEST_F(FormatTest, AmbersandInLamda) { 14973 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899 14974 FormatStyle AlignStyle = getLLVMStyle(); 14975 AlignStyle.PointerAlignment = FormatStyle::PAS_Left; 14976 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 14977 AlignStyle.PointerAlignment = FormatStyle::PAS_Right; 14978 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 14979 } 14980 14981 TEST_F(FormatTest, SpacesInConditionalStatement) { 14982 FormatStyle Spaces = getLLVMStyle(); 14983 Spaces.SpacesInConditionalStatement = true; 14984 verifyFormat("for ( int i = 0; i; i++ )\n continue;", Spaces); 14985 verifyFormat("if ( !a )\n return;", Spaces); 14986 verifyFormat("if ( a )\n return;", Spaces); 14987 verifyFormat("if constexpr ( a )\n return;", Spaces); 14988 verifyFormat("switch ( a )\ncase 1:\n return;", Spaces); 14989 verifyFormat("while ( a )\n return;", Spaces); 14990 verifyFormat("while ( (a && b) )\n return;", Spaces); 14991 verifyFormat("do {\n} while ( 1 != 0 );", Spaces); 14992 verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces); 14993 // Check that space on the left of "::" is inserted as expected at beginning 14994 // of condition. 14995 verifyFormat("while ( ::func() )\n return;", Spaces); 14996 } 14997 14998 TEST_F(FormatTest, AlternativeOperators) { 14999 // Test case for ensuring alternate operators are not 15000 // combined with their right most neighbour. 15001 verifyFormat("int a and b;"); 15002 verifyFormat("int a and_eq b;"); 15003 verifyFormat("int a bitand b;"); 15004 verifyFormat("int a bitor b;"); 15005 verifyFormat("int a compl b;"); 15006 verifyFormat("int a not b;"); 15007 verifyFormat("int a not_eq b;"); 15008 verifyFormat("int a or b;"); 15009 verifyFormat("int a xor b;"); 15010 verifyFormat("int a xor_eq b;"); 15011 verifyFormat("return this not_eq bitand other;"); 15012 verifyFormat("bool operator not_eq(const X bitand other)"); 15013 15014 verifyFormat("int a and 5;"); 15015 verifyFormat("int a and_eq 5;"); 15016 verifyFormat("int a bitand 5;"); 15017 verifyFormat("int a bitor 5;"); 15018 verifyFormat("int a compl 5;"); 15019 verifyFormat("int a not 5;"); 15020 verifyFormat("int a not_eq 5;"); 15021 verifyFormat("int a or 5;"); 15022 verifyFormat("int a xor 5;"); 15023 verifyFormat("int a xor_eq 5;"); 15024 15025 verifyFormat("int a compl(5);"); 15026 verifyFormat("int a not(5);"); 15027 15028 /* FIXME handle alternate tokens 15029 * https://en.cppreference.com/w/cpp/language/operator_alternative 15030 // alternative tokens 15031 verifyFormat("compl foo();"); // ~foo(); 15032 verifyFormat("foo() <%%>;"); // foo(); 15033 verifyFormat("void foo() <%%>;"); // void foo(){} 15034 verifyFormat("int a <:1:>;"); // int a[1];[ 15035 verifyFormat("%:define ABC abc"); // #define ABC abc 15036 verifyFormat("%:%:"); // ## 15037 */ 15038 } 15039 15040 TEST_F(FormatTest, STLWhileNotDefineChed) { 15041 verifyFormat("#if defined(while)\n" 15042 "#define while EMIT WARNING C4005\n" 15043 "#endif // while"); 15044 } 15045 15046 TEST_F(FormatTest, OperatorSpacing) { 15047 FormatStyle Style = getLLVMStyle(); 15048 Style.PointerAlignment = FormatStyle::PAS_Right; 15049 verifyFormat("Foo::operator*();", Style); 15050 verifyFormat("Foo::operator void *();", Style); 15051 verifyFormat("Foo::operator()(void *);", Style); 15052 verifyFormat("Foo::operator*(void *);", Style); 15053 verifyFormat("Foo::operator*();", Style); 15054 verifyFormat("operator*(int (*)(), class Foo);", Style); 15055 15056 verifyFormat("Foo::operator&();", Style); 15057 verifyFormat("Foo::operator void &();", Style); 15058 verifyFormat("Foo::operator()(void &);", Style); 15059 verifyFormat("Foo::operator&(void &);", Style); 15060 verifyFormat("Foo::operator&();", Style); 15061 verifyFormat("operator&(int (&)(), class Foo);", Style); 15062 15063 verifyFormat("Foo::operator&&();", Style); 15064 verifyFormat("Foo::operator void &&();", Style); 15065 verifyFormat("Foo::operator()(void &&);", Style); 15066 verifyFormat("Foo::operator&&(void &&);", Style); 15067 verifyFormat("Foo::operator&&();", Style); 15068 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15069 15070 Style.PointerAlignment = FormatStyle::PAS_Left; 15071 verifyFormat("Foo::operator*();", Style); 15072 verifyFormat("Foo::operator void*();", Style); 15073 verifyFormat("Foo::operator/*comment*/ void*();", Style); 15074 verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style); 15075 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style); 15076 verifyFormat("Foo::operator()(void*);", Style); 15077 verifyFormat("Foo::operator*(void*);", Style); 15078 verifyFormat("Foo::operator*();", Style); 15079 verifyFormat("operator*(int (*)(), class Foo);", Style); 15080 15081 verifyFormat("Foo::operator&();", Style); 15082 verifyFormat("Foo::operator void&();", Style); 15083 verifyFormat("Foo::operator/*comment*/ void&();", Style); 15084 verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style); 15085 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style); 15086 verifyFormat("Foo::operator()(void&);", Style); 15087 verifyFormat("Foo::operator&(void&);", Style); 15088 verifyFormat("Foo::operator&();", Style); 15089 verifyFormat("operator&(int (&)(), class Foo);", Style); 15090 15091 verifyFormat("Foo::operator&&();", Style); 15092 verifyFormat("Foo::operator void&&();", Style); 15093 verifyFormat("Foo::operator/*comment*/ void&&();", Style); 15094 verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style); 15095 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style); 15096 verifyFormat("Foo::operator()(void&&);", Style); 15097 verifyFormat("Foo::operator&&(void&&);", Style); 15098 verifyFormat("Foo::operator&&();", Style); 15099 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15100 15101 Style.PointerAlignment = FormatStyle::PAS_Middle; 15102 verifyFormat("Foo::operator*();", Style); 15103 verifyFormat("Foo::operator void *();", Style); 15104 verifyFormat("Foo::operator()(void *);", Style); 15105 verifyFormat("Foo::operator*(void *);", Style); 15106 verifyFormat("Foo::operator*();", Style); 15107 verifyFormat("operator*(int (*)(), class Foo);", Style); 15108 15109 verifyFormat("Foo::operator&();", Style); 15110 verifyFormat("Foo::operator void &();", Style); 15111 verifyFormat("Foo::operator()(void &);", Style); 15112 verifyFormat("Foo::operator&(void &);", Style); 15113 verifyFormat("Foo::operator&();", Style); 15114 verifyFormat("operator&(int (&)(), class Foo);", Style); 15115 15116 verifyFormat("Foo::operator&&();", Style); 15117 verifyFormat("Foo::operator void &&();", Style); 15118 verifyFormat("Foo::operator()(void &&);", Style); 15119 verifyFormat("Foo::operator&&(void &&);", Style); 15120 verifyFormat("Foo::operator&&();", Style); 15121 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15122 } 15123 15124 } // namespace 15125 } // namespace format 15126 } // namespace clang 15127