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 7411 verifyIndependentOfContext("a = *(x + y);"); 7412 verifyIndependentOfContext("a = &(x + y);"); 7413 verifyIndependentOfContext("*(x + y).call();"); 7414 verifyIndependentOfContext("&(x + y)->call();"); 7415 verifyFormat("void f() { &(*I).first; }"); 7416 7417 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 7418 verifyFormat( 7419 "int *MyValues = {\n" 7420 " *A, // Operator detection might be confused by the '{'\n" 7421 " *BB // Operator detection might be confused by previous comment\n" 7422 "};"); 7423 7424 verifyIndependentOfContext("if (int *a = &b)"); 7425 verifyIndependentOfContext("if (int &a = *b)"); 7426 verifyIndependentOfContext("if (a & b[i])"); 7427 verifyIndependentOfContext("if constexpr (a & b[i])"); 7428 verifyIndependentOfContext("if CONSTEXPR (a & b[i])"); 7429 verifyIndependentOfContext("if (a * (b * c))"); 7430 verifyIndependentOfContext("if constexpr (a * (b * c))"); 7431 verifyIndependentOfContext("if CONSTEXPR (a * (b * c))"); 7432 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 7433 verifyIndependentOfContext("if (*b[i])"); 7434 verifyIndependentOfContext("if (int *a = (&b))"); 7435 verifyIndependentOfContext("while (int *a = &b)"); 7436 verifyIndependentOfContext("while (a * (b * c))"); 7437 verifyIndependentOfContext("size = sizeof *a;"); 7438 verifyIndependentOfContext("if (a && (b = c))"); 7439 verifyFormat("void f() {\n" 7440 " for (const int &v : Values) {\n" 7441 " }\n" 7442 "}"); 7443 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 7444 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 7445 verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}"); 7446 7447 verifyFormat("#define A (!a * b)"); 7448 verifyFormat("#define MACRO \\\n" 7449 " int *i = a * b; \\\n" 7450 " void f(a *b);", 7451 getLLVMStyleWithColumns(19)); 7452 7453 verifyIndependentOfContext("A = new SomeType *[Length];"); 7454 verifyIndependentOfContext("A = new SomeType *[Length]();"); 7455 verifyIndependentOfContext("T **t = new T *;"); 7456 verifyIndependentOfContext("T **t = new T *();"); 7457 verifyGoogleFormat("A = new SomeType*[Length]();"); 7458 verifyGoogleFormat("A = new SomeType*[Length];"); 7459 verifyGoogleFormat("T** t = new T*;"); 7460 verifyGoogleFormat("T** t = new T*();"); 7461 7462 verifyFormat("STATIC_ASSERT((a & b) == 0);"); 7463 verifyFormat("STATIC_ASSERT(0 == (a & b));"); 7464 verifyFormat("template <bool a, bool b> " 7465 "typename t::if<x && y>::type f() {}"); 7466 verifyFormat("template <int *y> f() {}"); 7467 verifyFormat("vector<int *> v;"); 7468 verifyFormat("vector<int *const> v;"); 7469 verifyFormat("vector<int *const **const *> v;"); 7470 verifyFormat("vector<int *volatile> v;"); 7471 verifyFormat("vector<a * b> v;"); 7472 verifyFormat("foo<b && false>();"); 7473 verifyFormat("foo<b & 1>();"); 7474 verifyFormat("decltype(*::std::declval<const T &>()) void F();"); 7475 verifyFormat( 7476 "template <class T, class = typename std::enable_if<\n" 7477 " std::is_integral<T>::value &&\n" 7478 " (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n" 7479 "void F();", 7480 getLLVMStyleWithColumns(70)); 7481 verifyFormat("template <class T,\n" 7482 " class = typename std::enable_if<\n" 7483 " std::is_integral<T>::value &&\n" 7484 " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n" 7485 " class U>\n" 7486 "void F();", 7487 getLLVMStyleWithColumns(70)); 7488 verifyFormat( 7489 "template <class T,\n" 7490 " class = typename ::std::enable_if<\n" 7491 " ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n" 7492 "void F();", 7493 getGoogleStyleWithColumns(68)); 7494 7495 verifyIndependentOfContext("MACRO(int *i);"); 7496 verifyIndependentOfContext("MACRO(auto *a);"); 7497 verifyIndependentOfContext("MACRO(const A *a);"); 7498 verifyIndependentOfContext("MACRO(A *const a);"); 7499 verifyIndependentOfContext("MACRO('0' <= c && c <= '9');"); 7500 verifyFormat("void f() { f(float{1}, a * a); }"); 7501 // FIXME: Is there a way to make this work? 7502 // verifyIndependentOfContext("MACRO(A *a);"); 7503 7504 verifyFormat("DatumHandle const *operator->() const { return input_; }"); 7505 verifyFormat("return options != nullptr && operator==(*options);"); 7506 7507 EXPECT_EQ("#define OP(x) \\\n" 7508 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7509 " return s << a.DebugString(); \\\n" 7510 " }", 7511 format("#define OP(x) \\\n" 7512 " ostream &operator<<(ostream &s, const A &a) { \\\n" 7513 " return s << a.DebugString(); \\\n" 7514 " }", 7515 getLLVMStyleWithColumns(50))); 7516 7517 // FIXME: We cannot handle this case yet; we might be able to figure out that 7518 // foo<x> d > v; doesn't make sense. 7519 verifyFormat("foo<a<b && c> d> v;"); 7520 7521 FormatStyle PointerMiddle = getLLVMStyle(); 7522 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 7523 verifyFormat("delete *x;", PointerMiddle); 7524 verifyFormat("int * x;", PointerMiddle); 7525 verifyFormat("int *[] x;", PointerMiddle); 7526 verifyFormat("template <int * y> f() {}", PointerMiddle); 7527 verifyFormat("int * f(int * a) {}", PointerMiddle); 7528 verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle); 7529 verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle); 7530 verifyFormat("A<int *> a;", PointerMiddle); 7531 verifyFormat("A<int **> a;", PointerMiddle); 7532 verifyFormat("A<int *, int *> a;", PointerMiddle); 7533 verifyFormat("A<int *[]> a;", PointerMiddle); 7534 verifyFormat("A = new SomeType *[Length]();", PointerMiddle); 7535 verifyFormat("A = new SomeType *[Length];", PointerMiddle); 7536 verifyFormat("T ** t = new T *;", PointerMiddle); 7537 7538 // Member function reference qualifiers aren't binary operators. 7539 verifyFormat("string // break\n" 7540 "operator()() & {}"); 7541 verifyFormat("string // break\n" 7542 "operator()() && {}"); 7543 verifyGoogleFormat("template <typename T>\n" 7544 "auto x() & -> int {}"); 7545 } 7546 7547 TEST_F(FormatTest, UnderstandsAttributes) { 7548 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 7549 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n" 7550 "aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7551 FormatStyle AfterType = getLLVMStyle(); 7552 AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; 7553 verifyFormat("__attribute__((nodebug)) void\n" 7554 "foo() {}\n", 7555 AfterType); 7556 } 7557 7558 TEST_F(FormatTest, UnderstandsSquareAttributes) { 7559 verifyFormat("SomeType s [[unused]] (InitValue);"); 7560 verifyFormat("SomeType s [[gnu::unused]] (InitValue);"); 7561 verifyFormat("SomeType s [[using gnu: unused]] (InitValue);"); 7562 verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}"); 7563 verifyFormat("void f() [[deprecated(\"so sorry\")]];"); 7564 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7565 " [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);"); 7566 7567 // Make sure we do not mistake attributes for array subscripts. 7568 verifyFormat("int a() {}\n" 7569 "[[unused]] int b() {}\n"); 7570 verifyFormat("NSArray *arr;\n" 7571 "arr[[Foo() bar]];"); 7572 7573 // On the other hand, we still need to correctly find array subscripts. 7574 verifyFormat("int a = std::vector<int>{1, 2, 3}[0];"); 7575 7576 // Make sure that we do not mistake Objective-C method inside array literals 7577 // as attributes, even if those method names are also keywords. 7578 verifyFormat("@[ [foo bar] ];"); 7579 verifyFormat("@[ [NSArray class] ];"); 7580 verifyFormat("@[ [foo enum] ];"); 7581 7582 // Make sure we do not parse attributes as lambda introducers. 7583 FormatStyle MultiLineFunctions = getLLVMStyle(); 7584 MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 7585 verifyFormat("[[unused]] int b() {\n" 7586 " return 42;\n" 7587 "}\n", 7588 MultiLineFunctions); 7589 } 7590 7591 TEST_F(FormatTest, UnderstandsEllipsis) { 7592 verifyFormat("int printf(const char *fmt, ...);"); 7593 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 7594 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 7595 7596 FormatStyle PointersLeft = getLLVMStyle(); 7597 PointersLeft.PointerAlignment = FormatStyle::PAS_Left; 7598 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 7599 } 7600 7601 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 7602 EXPECT_EQ("int *a;\n" 7603 "int *a;\n" 7604 "int *a;", 7605 format("int *a;\n" 7606 "int* a;\n" 7607 "int *a;", 7608 getGoogleStyle())); 7609 EXPECT_EQ("int* a;\n" 7610 "int* a;\n" 7611 "int* a;", 7612 format("int* a;\n" 7613 "int* a;\n" 7614 "int *a;", 7615 getGoogleStyle())); 7616 EXPECT_EQ("int *a;\n" 7617 "int *a;\n" 7618 "int *a;", 7619 format("int *a;\n" 7620 "int * a;\n" 7621 "int * a;", 7622 getGoogleStyle())); 7623 EXPECT_EQ("auto x = [] {\n" 7624 " int *a;\n" 7625 " int *a;\n" 7626 " int *a;\n" 7627 "};", 7628 format("auto x=[]{int *a;\n" 7629 "int * a;\n" 7630 "int * a;};", 7631 getGoogleStyle())); 7632 } 7633 7634 TEST_F(FormatTest, UnderstandsRvalueReferences) { 7635 verifyFormat("int f(int &&a) {}"); 7636 verifyFormat("int f(int a, char &&b) {}"); 7637 verifyFormat("void f() { int &&a = b; }"); 7638 verifyGoogleFormat("int f(int a, char&& b) {}"); 7639 verifyGoogleFormat("void f() { int&& a = b; }"); 7640 7641 verifyIndependentOfContext("A<int &&> a;"); 7642 verifyIndependentOfContext("A<int &&, int &&> a;"); 7643 verifyGoogleFormat("A<int&&> a;"); 7644 verifyGoogleFormat("A<int&&, int&&> a;"); 7645 7646 // Not rvalue references: 7647 verifyFormat("template <bool B, bool C> class A {\n" 7648 " static_assert(B && C, \"Something is wrong\");\n" 7649 "};"); 7650 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 7651 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 7652 verifyFormat("#define A(a, b) (a && b)"); 7653 } 7654 7655 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 7656 verifyFormat("void f() {\n" 7657 " x[aaaaaaaaa -\n" 7658 " b] = 23;\n" 7659 "}", 7660 getLLVMStyleWithColumns(15)); 7661 } 7662 7663 TEST_F(FormatTest, FormatsCasts) { 7664 verifyFormat("Type *A = static_cast<Type *>(P);"); 7665 verifyFormat("Type *A = (Type *)P;"); 7666 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 7667 verifyFormat("int a = (int)(2.0f);"); 7668 verifyFormat("int a = (int)2.0f;"); 7669 verifyFormat("x[(int32)y];"); 7670 verifyFormat("x = (int32)y;"); 7671 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 7672 verifyFormat("int a = (int)*b;"); 7673 verifyFormat("int a = (int)2.0f;"); 7674 verifyFormat("int a = (int)~0;"); 7675 verifyFormat("int a = (int)++a;"); 7676 verifyFormat("int a = (int)sizeof(int);"); 7677 verifyFormat("int a = (int)+2;"); 7678 verifyFormat("my_int a = (my_int)2.0f;"); 7679 verifyFormat("my_int a = (my_int)sizeof(int);"); 7680 verifyFormat("return (my_int)aaa;"); 7681 verifyFormat("#define x ((int)-1)"); 7682 verifyFormat("#define LENGTH(x, y) (x) - (y) + 1"); 7683 verifyFormat("#define p(q) ((int *)&q)"); 7684 verifyFormat("fn(a)(b) + 1;"); 7685 7686 verifyFormat("void f() { my_int a = (my_int)*b; }"); 7687 verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }"); 7688 verifyFormat("my_int a = (my_int)~0;"); 7689 verifyFormat("my_int a = (my_int)++a;"); 7690 verifyFormat("my_int a = (my_int)-2;"); 7691 verifyFormat("my_int a = (my_int)1;"); 7692 verifyFormat("my_int a = (my_int *)1;"); 7693 verifyFormat("my_int a = (const my_int)-1;"); 7694 verifyFormat("my_int a = (const my_int *)-1;"); 7695 verifyFormat("my_int a = (my_int)(my_int)-1;"); 7696 verifyFormat("my_int a = (ns::my_int)-2;"); 7697 verifyFormat("case (my_int)ONE:"); 7698 verifyFormat("auto x = (X)this;"); 7699 // Casts in Obj-C style calls used to not be recognized as such. 7700 verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle()); 7701 7702 // FIXME: single value wrapped with paren will be treated as cast. 7703 verifyFormat("void f(int i = (kValue)*kMask) {}"); 7704 7705 verifyFormat("{ (void)F; }"); 7706 7707 // Don't break after a cast's 7708 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 7709 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 7710 " bbbbbbbbbbbbbbbbbbbbbb);"); 7711 7712 // These are not casts. 7713 verifyFormat("void f(int *) {}"); 7714 verifyFormat("f(foo)->b;"); 7715 verifyFormat("f(foo).b;"); 7716 verifyFormat("f(foo)(b);"); 7717 verifyFormat("f(foo)[b];"); 7718 verifyFormat("[](foo) { return 4; }(bar);"); 7719 verifyFormat("(*funptr)(foo)[4];"); 7720 verifyFormat("funptrs[4](foo)[4];"); 7721 verifyFormat("void f(int *);"); 7722 verifyFormat("void f(int *) = 0;"); 7723 verifyFormat("void f(SmallVector<int>) {}"); 7724 verifyFormat("void f(SmallVector<int>);"); 7725 verifyFormat("void f(SmallVector<int>) = 0;"); 7726 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 7727 verifyFormat("int a = sizeof(int) * b;"); 7728 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 7729 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 7730 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 7731 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 7732 7733 // These are not casts, but at some point were confused with casts. 7734 verifyFormat("virtual void foo(int *) override;"); 7735 verifyFormat("virtual void foo(char &) const;"); 7736 verifyFormat("virtual void foo(int *a, char *) const;"); 7737 verifyFormat("int a = sizeof(int *) + b;"); 7738 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 7739 verifyFormat("bool b = f(g<int>) && c;"); 7740 verifyFormat("typedef void (*f)(int i) func;"); 7741 verifyFormat("void operator++(int) noexcept;"); 7742 verifyFormat("void operator++(int &) noexcept;"); 7743 verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t " 7744 "&) noexcept;"); 7745 verifyFormat( 7746 "void operator delete(std::size_t, const std::nothrow_t &) noexcept;"); 7747 verifyFormat("void operator delete(const std::nothrow_t &) noexcept;"); 7748 verifyFormat("void operator delete(std::nothrow_t &) noexcept;"); 7749 verifyFormat("void operator delete(nothrow_t &) noexcept;"); 7750 verifyFormat("void operator delete(foo &) noexcept;"); 7751 verifyFormat("void operator delete(foo) noexcept;"); 7752 verifyFormat("void operator delete(int) noexcept;"); 7753 verifyFormat("void operator delete(int &) noexcept;"); 7754 verifyFormat("void operator delete(int &) volatile noexcept;"); 7755 verifyFormat("void operator delete(int &) const"); 7756 verifyFormat("void operator delete(int &) = default"); 7757 verifyFormat("void operator delete(int &) = delete"); 7758 verifyFormat("void operator delete(int &) [[noreturn]]"); 7759 verifyFormat("void operator delete(int &) throw();"); 7760 verifyFormat("void operator delete(int &) throw(int);"); 7761 verifyFormat("auto operator delete(int &) -> int;"); 7762 verifyFormat("auto operator delete(int &) override"); 7763 verifyFormat("auto operator delete(int &) final"); 7764 7765 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 7766 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 7767 // FIXME: The indentation here is not ideal. 7768 verifyFormat( 7769 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7770 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 7771 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 7772 } 7773 7774 TEST_F(FormatTest, FormatsFunctionTypes) { 7775 verifyFormat("A<bool()> a;"); 7776 verifyFormat("A<SomeType()> a;"); 7777 verifyFormat("A<void (*)(int, std::string)> a;"); 7778 verifyFormat("A<void *(int)>;"); 7779 verifyFormat("void *(*a)(int *, SomeType *);"); 7780 verifyFormat("int (*func)(void *);"); 7781 verifyFormat("void f() { int (*func)(void *); }"); 7782 verifyFormat("template <class CallbackClass>\n" 7783 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 7784 7785 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 7786 verifyGoogleFormat("void* (*a)(int);"); 7787 verifyGoogleFormat( 7788 "template <class CallbackClass>\n" 7789 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 7790 7791 // Other constructs can look somewhat like function types: 7792 verifyFormat("A<sizeof(*x)> a;"); 7793 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 7794 verifyFormat("some_var = function(*some_pointer_var)[0];"); 7795 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 7796 verifyFormat("int x = f(&h)();"); 7797 verifyFormat("returnsFunction(¶m1, ¶m2)(param);"); 7798 verifyFormat("std::function<\n" 7799 " LooooooooooongTemplatedType<\n" 7800 " SomeType>*(\n" 7801 " LooooooooooooooooongType type)>\n" 7802 " function;", 7803 getGoogleStyleWithColumns(40)); 7804 } 7805 7806 TEST_F(FormatTest, FormatsPointersToArrayTypes) { 7807 verifyFormat("A (*foo_)[6];"); 7808 verifyFormat("vector<int> (*foo_)[6];"); 7809 } 7810 7811 TEST_F(FormatTest, BreaksLongVariableDeclarations) { 7812 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7813 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7814 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 7815 " LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7816 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7817 " *LoooooooooooooooooooooooooooooooooooooooongVariable;"); 7818 7819 // Different ways of ()-initializiation. 7820 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7821 " LoooooooooooooooooooooooooooooooooooooooongVariable(1);"); 7822 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7823 " LoooooooooooooooooooooooooooooooooooooooongVariable(a);"); 7824 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7825 " LoooooooooooooooooooooooooooooooooooooooongVariable({});"); 7826 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 7827 " LoooooooooooooooooooooooooooooooooooooongVariable([A a]);"); 7828 7829 // Lambdas should not confuse the variable declaration heuristic. 7830 verifyFormat("LooooooooooooooooongType\n" 7831 " variable(nullptr, [](A *a) {});", 7832 getLLVMStyleWithColumns(40)); 7833 } 7834 7835 TEST_F(FormatTest, BreaksLongDeclarations) { 7836 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 7837 " AnotherNameForTheLongType;"); 7838 verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n" 7839 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 7840 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7841 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7842 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n" 7843 "LoooooooooooooooooooooooooooooooongFunctionDeclaration();"); 7844 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7845 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7846 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n" 7847 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7848 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7849 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7850 verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7851 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 7852 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7853 "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);"); 7854 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7855 "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}"); 7856 FormatStyle Indented = getLLVMStyle(); 7857 Indented.IndentWrappedFunctionNames = true; 7858 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7859 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 7860 Indented); 7861 verifyFormat( 7862 "LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 7863 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7864 Indented); 7865 verifyFormat( 7866 "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 7867 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7868 Indented); 7869 verifyFormat( 7870 "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n" 7871 " LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}", 7872 Indented); 7873 7874 // FIXME: Without the comment, this breaks after "(". 7875 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 7876 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 7877 getGoogleStyle()); 7878 7879 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 7880 " int LoooooooooooooooooooongParam2) {}"); 7881 verifyFormat( 7882 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 7883 " SourceLocation L, IdentifierIn *II,\n" 7884 " Type *T) {}"); 7885 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 7886 "ReallyReaaallyLongFunctionName(\n" 7887 " const std::string &SomeParameter,\n" 7888 " const SomeType<string, SomeOtherTemplateParameter>\n" 7889 " &ReallyReallyLongParameterName,\n" 7890 " const SomeType<string, SomeOtherTemplateParameter>\n" 7891 " &AnotherLongParameterName) {}"); 7892 verifyFormat("template <typename A>\n" 7893 "SomeLoooooooooooooooooooooongType<\n" 7894 " typename some_namespace::SomeOtherType<A>::Type>\n" 7895 "Function() {}"); 7896 7897 verifyGoogleFormat( 7898 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 7899 " aaaaaaaaaaaaaaaaaaaaaaa;"); 7900 verifyGoogleFormat( 7901 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 7902 " SourceLocation L) {}"); 7903 verifyGoogleFormat( 7904 "some_namespace::LongReturnType\n" 7905 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 7906 " int first_long_parameter, int second_parameter) {}"); 7907 7908 verifyGoogleFormat("template <typename T>\n" 7909 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7910 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 7911 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 7912 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 7913 7914 verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 7915 " const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7916 " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7917 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7918 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n" 7919 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 7920 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 7921 " vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 7922 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n" 7923 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 7924 7925 verifyFormat("template <typename T> // Templates on own line.\n" 7926 "static int // Some comment.\n" 7927 "MyFunction(int a);", 7928 getLLVMStyle()); 7929 } 7930 7931 TEST_F(FormatTest, FormatsArrays) { 7932 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7933 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 7934 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n" 7935 " [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;"); 7936 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n" 7937 " aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}"); 7938 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7939 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7940 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7941 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 7942 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 7943 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7944 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 7945 verifyFormat( 7946 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 7947 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 7948 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 7949 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n" 7950 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7951 7952 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n" 7953 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];"); 7954 verifyFormat( 7955 "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n" 7956 " .aaaaaaa[0]\n" 7957 " .aaaaaaaaaaaaaaaaaaaaaa();"); 7958 verifyFormat("a[::b::c];"); 7959 7960 verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10)); 7961 7962 FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0); 7963 verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit); 7964 } 7965 7966 TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 7967 verifyFormat("(a)->b();"); 7968 verifyFormat("--a;"); 7969 } 7970 7971 TEST_F(FormatTest, HandlesIncludeDirectives) { 7972 verifyFormat("#include <string>\n" 7973 "#include <a/b/c.h>\n" 7974 "#include \"a/b/string\"\n" 7975 "#include \"string.h\"\n" 7976 "#include \"string.h\"\n" 7977 "#include <a-a>\n" 7978 "#include < path with space >\n" 7979 "#include_next <test.h>" 7980 "#include \"abc.h\" // this is included for ABC\n" 7981 "#include \"some long include\" // with a comment\n" 7982 "#include \"some very long include path\"\n" 7983 "#include <some/very/long/include/path>\n", 7984 getLLVMStyleWithColumns(35)); 7985 EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\"")); 7986 EXPECT_EQ("#include <a>", format("#include<a>")); 7987 7988 verifyFormat("#import <string>"); 7989 verifyFormat("#import <a/b/c.h>"); 7990 verifyFormat("#import \"a/b/string\""); 7991 verifyFormat("#import \"string.h\""); 7992 verifyFormat("#import \"string.h\""); 7993 verifyFormat("#if __has_include(<strstream>)\n" 7994 "#include <strstream>\n" 7995 "#endif"); 7996 7997 verifyFormat("#define MY_IMPORT <a/b>"); 7998 7999 verifyFormat("#if __has_include(<a/b>)"); 8000 verifyFormat("#if __has_include_next(<a/b>)"); 8001 verifyFormat("#define F __has_include(<a/b>)"); 8002 verifyFormat("#define F __has_include_next(<a/b>)"); 8003 8004 // Protocol buffer definition or missing "#". 8005 verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";", 8006 getLLVMStyleWithColumns(30)); 8007 8008 FormatStyle Style = getLLVMStyle(); 8009 Style.AlwaysBreakBeforeMultilineStrings = true; 8010 Style.ColumnLimit = 0; 8011 verifyFormat("#import \"abc.h\"", Style); 8012 8013 // But 'import' might also be a regular C++ namespace. 8014 verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8015 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 8016 } 8017 8018 //===----------------------------------------------------------------------===// 8019 // Error recovery tests. 8020 //===----------------------------------------------------------------------===// 8021 8022 TEST_F(FormatTest, IncompleteParameterLists) { 8023 FormatStyle NoBinPacking = getLLVMStyle(); 8024 NoBinPacking.BinPackParameters = false; 8025 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 8026 " double *min_x,\n" 8027 " double *max_x,\n" 8028 " double *min_y,\n" 8029 " double *max_y,\n" 8030 " double *min_z,\n" 8031 " double *max_z, ) {}", 8032 NoBinPacking); 8033 } 8034 8035 TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 8036 verifyFormat("void f() { return; }\n42"); 8037 verifyFormat("void f() {\n" 8038 " if (0)\n" 8039 " return;\n" 8040 "}\n" 8041 "42"); 8042 verifyFormat("void f() { return }\n42"); 8043 verifyFormat("void f() {\n" 8044 " if (0)\n" 8045 " return\n" 8046 "}\n" 8047 "42"); 8048 } 8049 8050 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 8051 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 8052 EXPECT_EQ("void f() {\n" 8053 " if (a)\n" 8054 " return\n" 8055 "}", 8056 format("void f ( ) { if ( a ) return }")); 8057 EXPECT_EQ("namespace N {\n" 8058 "void f()\n" 8059 "}", 8060 format("namespace N { void f() }")); 8061 EXPECT_EQ("namespace N {\n" 8062 "void f() {}\n" 8063 "void g()\n" 8064 "} // namespace N", 8065 format("namespace N { void f( ) { } void g( ) }")); 8066 } 8067 8068 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 8069 verifyFormat("int aaaaaaaa =\n" 8070 " // Overlylongcomment\n" 8071 " b;", 8072 getLLVMStyleWithColumns(20)); 8073 verifyFormat("function(\n" 8074 " ShortArgument,\n" 8075 " LoooooooooooongArgument);\n", 8076 getLLVMStyleWithColumns(20)); 8077 } 8078 8079 TEST_F(FormatTest, IncorrectAccessSpecifier) { 8080 verifyFormat("public:"); 8081 verifyFormat("class A {\n" 8082 "public\n" 8083 " void f() {}\n" 8084 "};"); 8085 verifyFormat("public\n" 8086 "int qwerty;"); 8087 verifyFormat("public\n" 8088 "B {}"); 8089 verifyFormat("public\n" 8090 "{}"); 8091 verifyFormat("public\n" 8092 "B { int x; }"); 8093 } 8094 8095 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 8096 verifyFormat("{"); 8097 verifyFormat("#})"); 8098 verifyNoCrash("(/**/[:!] ?[)."); 8099 } 8100 8101 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) { 8102 // Found by oss-fuzz: 8103 // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212 8104 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp); 8105 Style.ColumnLimit = 60; 8106 verifyNoCrash( 8107 "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20" 8108 "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20" 8109 "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a", 8110 Style); 8111 } 8112 8113 TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 8114 verifyFormat("do {\n}"); 8115 verifyFormat("do {\n}\n" 8116 "f();"); 8117 verifyFormat("do {\n}\n" 8118 "wheeee(fun);"); 8119 verifyFormat("do {\n" 8120 " f();\n" 8121 "}"); 8122 } 8123 8124 TEST_F(FormatTest, IncorrectCodeMissingParens) { 8125 verifyFormat("if {\n foo;\n foo();\n}"); 8126 verifyFormat("switch {\n foo;\n foo();\n}"); 8127 verifyIncompleteFormat("for {\n foo;\n foo();\n}"); 8128 verifyFormat("while {\n foo;\n foo();\n}"); 8129 verifyFormat("do {\n foo;\n foo();\n} while;"); 8130 } 8131 8132 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 8133 verifyIncompleteFormat("namespace {\n" 8134 "class Foo { Foo (\n" 8135 "};\n" 8136 "} // namespace"); 8137 } 8138 8139 TEST_F(FormatTest, IncorrectCodeErrorDetection) { 8140 EXPECT_EQ("{\n {}\n", format("{\n{\n}\n")); 8141 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 8142 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 8143 EXPECT_EQ("{\n {}\n}\n}\n", format("{\n {\n }\n }\n}\n")); 8144 8145 EXPECT_EQ("{\n" 8146 " {\n" 8147 " breakme(\n" 8148 " qwe);\n" 8149 " }\n", 8150 format("{\n" 8151 " {\n" 8152 " breakme(qwe);\n" 8153 "}\n", 8154 getLLVMStyleWithColumns(10))); 8155 } 8156 8157 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 8158 verifyFormat("int x = {\n" 8159 " avariable,\n" 8160 " b(alongervariable)};", 8161 getLLVMStyleWithColumns(25)); 8162 } 8163 8164 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 8165 verifyFormat("return (a)(b){1, 2, 3};"); 8166 } 8167 8168 TEST_F(FormatTest, LayoutCxx11BraceInitializers) { 8169 verifyFormat("vector<int> x{1, 2, 3, 4};"); 8170 verifyFormat("vector<int> x{\n" 8171 " 1,\n" 8172 " 2,\n" 8173 " 3,\n" 8174 " 4,\n" 8175 "};"); 8176 verifyFormat("vector<T> x{{}, {}, {}, {}};"); 8177 verifyFormat("f({1, 2});"); 8178 verifyFormat("auto v = Foo{-1};"); 8179 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});"); 8180 verifyFormat("Class::Class : member{1, 2, 3} {}"); 8181 verifyFormat("new vector<int>{1, 2, 3};"); 8182 verifyFormat("new int[3]{1, 2, 3};"); 8183 verifyFormat("new int{1};"); 8184 verifyFormat("return {arg1, arg2};"); 8185 verifyFormat("return {arg1, SomeType{parameter}};"); 8186 verifyFormat("int count = set<int>{f(), g(), h()}.size();"); 8187 verifyFormat("new T{arg1, arg2};"); 8188 verifyFormat("f(MyMap[{composite, key}]);"); 8189 verifyFormat("class Class {\n" 8190 " T member = {arg1, arg2};\n" 8191 "};"); 8192 verifyFormat("vector<int> foo = {::SomeGlobalFunction()};"); 8193 verifyFormat("const struct A a = {.a = 1, .b = 2};"); 8194 verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); 8195 verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");"); 8196 verifyFormat("int a = std::is_integral<int>{} + 0;"); 8197 8198 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8199 verifyFormat("int foo(int i) { return fo1{}(i); }"); 8200 verifyFormat("auto i = decltype(x){};"); 8201 verifyFormat("std::vector<int> v = {1, 0 /* comment */};"); 8202 verifyFormat("Node n{1, Node{1000}, //\n" 8203 " 2};"); 8204 verifyFormat("Aaaa aaaaaaa{\n" 8205 " {\n" 8206 " aaaa,\n" 8207 " },\n" 8208 "};"); 8209 verifyFormat("class C : public D {\n" 8210 " SomeClass SC{2};\n" 8211 "};"); 8212 verifyFormat("class C : public A {\n" 8213 " class D : public B {\n" 8214 " void f() { int i{2}; }\n" 8215 " };\n" 8216 "};"); 8217 verifyFormat("#define A {a, a},"); 8218 8219 // Avoid breaking between equal sign and opening brace 8220 FormatStyle AvoidBreakingFirstArgument = getLLVMStyle(); 8221 AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200; 8222 verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n" 8223 " {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n" 8224 " {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n" 8225 " {\"ccccccccccccccccccccc\", 2}};", 8226 AvoidBreakingFirstArgument); 8227 8228 // Binpacking only if there is no trailing comma 8229 verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n" 8230 " cccccccccc, dddddddddd};", 8231 getLLVMStyleWithColumns(50)); 8232 verifyFormat("const Aaaaaa aaaaa = {\n" 8233 " aaaaaaaaaaa,\n" 8234 " bbbbbbbbbbb,\n" 8235 " ccccccccccc,\n" 8236 " ddddddddddd,\n" 8237 "};", 8238 getLLVMStyleWithColumns(50)); 8239 8240 // Cases where distinguising braced lists and blocks is hard. 8241 verifyFormat("vector<int> v{12} GUARDED_BY(mutex);"); 8242 verifyFormat("void f() {\n" 8243 " return; // comment\n" 8244 "}\n" 8245 "SomeType t;"); 8246 verifyFormat("void f() {\n" 8247 " if (a) {\n" 8248 " f();\n" 8249 " }\n" 8250 "}\n" 8251 "SomeType t;"); 8252 8253 // In combination with BinPackArguments = false. 8254 FormatStyle NoBinPacking = getLLVMStyle(); 8255 NoBinPacking.BinPackArguments = false; 8256 verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n" 8257 " bbbbb,\n" 8258 " ccccc,\n" 8259 " ddddd,\n" 8260 " eeeee,\n" 8261 " ffffff,\n" 8262 " ggggg,\n" 8263 " hhhhhh,\n" 8264 " iiiiii,\n" 8265 " jjjjjj,\n" 8266 " kkkkkk};", 8267 NoBinPacking); 8268 verifyFormat("const Aaaaaa aaaaa = {\n" 8269 " aaaaa,\n" 8270 " bbbbb,\n" 8271 " ccccc,\n" 8272 " ddddd,\n" 8273 " eeeee,\n" 8274 " ffffff,\n" 8275 " ggggg,\n" 8276 " hhhhhh,\n" 8277 " iiiiii,\n" 8278 " jjjjjj,\n" 8279 " kkkkkk,\n" 8280 "};", 8281 NoBinPacking); 8282 verifyFormat( 8283 "const Aaaaaa aaaaa = {\n" 8284 " aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n" 8285 " iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n" 8286 " ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n" 8287 "};", 8288 NoBinPacking); 8289 8290 NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 8291 EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n" 8292 " CDDDP83848_BMCR_REGISTER,\n" 8293 " CDDDP83848_BMSR_REGISTER,\n" 8294 " CDDDP83848_RBR_REGISTER};", 8295 format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n" 8296 " CDDDP83848_BMSR_REGISTER,\n" 8297 " CDDDP83848_RBR_REGISTER};", 8298 NoBinPacking)); 8299 8300 // FIXME: The alignment of these trailing comments might be bad. Then again, 8301 // this might be utterly useless in real code. 8302 verifyFormat("Constructor::Constructor()\n" 8303 " : some_value{ //\n" 8304 " aaaaaaa, //\n" 8305 " bbbbbbb} {}"); 8306 8307 // In braced lists, the first comment is always assumed to belong to the 8308 // first element. Thus, it can be moved to the next or previous line as 8309 // appropriate. 8310 EXPECT_EQ("function({// First element:\n" 8311 " 1,\n" 8312 " // Second element:\n" 8313 " 2});", 8314 format("function({\n" 8315 " // First element:\n" 8316 " 1,\n" 8317 " // Second element:\n" 8318 " 2});")); 8319 EXPECT_EQ("std::vector<int> MyNumbers{\n" 8320 " // First element:\n" 8321 " 1,\n" 8322 " // Second element:\n" 8323 " 2};", 8324 format("std::vector<int> MyNumbers{// First element:\n" 8325 " 1,\n" 8326 " // Second element:\n" 8327 " 2};", 8328 getLLVMStyleWithColumns(30))); 8329 // A trailing comma should still lead to an enforced line break and no 8330 // binpacking. 8331 EXPECT_EQ("vector<int> SomeVector = {\n" 8332 " // aaa\n" 8333 " 1,\n" 8334 " 2,\n" 8335 "};", 8336 format("vector<int> SomeVector = { // aaa\n" 8337 " 1, 2, };")); 8338 8339 FormatStyle ExtraSpaces = getLLVMStyle(); 8340 ExtraSpaces.Cpp11BracedListStyle = false; 8341 ExtraSpaces.ColumnLimit = 75; 8342 verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces); 8343 verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces); 8344 verifyFormat("f({ 1, 2 });", ExtraSpaces); 8345 verifyFormat("auto v = Foo{ 1 };", ExtraSpaces); 8346 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces); 8347 verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces); 8348 verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces); 8349 verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces); 8350 verifyFormat("return { arg1, arg2 };", ExtraSpaces); 8351 verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces); 8352 verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces); 8353 verifyFormat("new T{ arg1, arg2 };", ExtraSpaces); 8354 verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces); 8355 verifyFormat("class Class {\n" 8356 " T member = { arg1, arg2 };\n" 8357 "};", 8358 ExtraSpaces); 8359 verifyFormat( 8360 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8361 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 8362 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 8363 " bbbbbbbbbbbbbbbbbbbb, bbbbb };", 8364 ExtraSpaces); 8365 verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces); 8366 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });", 8367 ExtraSpaces); 8368 verifyFormat( 8369 "someFunction(OtherParam,\n" 8370 " BracedList{ // comment 1 (Forcing interesting break)\n" 8371 " param1, param2,\n" 8372 " // comment 2\n" 8373 " param3, param4 });", 8374 ExtraSpaces); 8375 verifyFormat( 8376 "std::this_thread::sleep_for(\n" 8377 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);", 8378 ExtraSpaces); 8379 verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n" 8380 " aaaaaaa,\n" 8381 " aaaaaaaaaa,\n" 8382 " aaaaa,\n" 8383 " aaaaaaaaaaaaaaa,\n" 8384 " aaa,\n" 8385 " aaaaaaaaaa,\n" 8386 " a,\n" 8387 " aaaaaaaaaaaaaaaaaaaaa,\n" 8388 " aaaaaaaaaaaa,\n" 8389 " aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n" 8390 " aaaaaaa,\n" 8391 " a};"); 8392 verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces); 8393 verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces); 8394 verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces); 8395 8396 // Avoid breaking between initializer/equal sign and opening brace 8397 ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200; 8398 verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n" 8399 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8400 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8401 " { \"ccccccccccccccccccccc\", 2 }\n" 8402 "};", 8403 ExtraSpaces); 8404 verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n" 8405 " { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n" 8406 " { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n" 8407 " { \"ccccccccccccccccccccc\", 2 }\n" 8408 "};", 8409 ExtraSpaces); 8410 8411 FormatStyle SpaceBeforeBrace = getLLVMStyle(); 8412 SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true; 8413 verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace); 8414 verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace); 8415 8416 FormatStyle SpaceBetweenBraces = getLLVMStyle(); 8417 SpaceBetweenBraces.SpacesInAngles = true; 8418 SpaceBetweenBraces.SpacesInParentheses = true; 8419 SpaceBetweenBraces.SpacesInSquareBrackets = true; 8420 verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces); 8421 verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces); 8422 verifyFormat("vector< int > x{ // comment 1\n" 8423 " 1, 2, 3, 4 };", 8424 SpaceBetweenBraces); 8425 SpaceBetweenBraces.ColumnLimit = 20; 8426 EXPECT_EQ("vector< int > x{\n" 8427 " 1, 2, 3, 4 };", 8428 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8429 SpaceBetweenBraces.ColumnLimit = 24; 8430 EXPECT_EQ("vector< int > x{ 1, 2,\n" 8431 " 3, 4 };", 8432 format("vector<int>x{1,2,3,4};", SpaceBetweenBraces)); 8433 EXPECT_EQ("vector< int > x{\n" 8434 " 1,\n" 8435 " 2,\n" 8436 " 3,\n" 8437 " 4,\n" 8438 "};", 8439 format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces)); 8440 verifyFormat("vector< int > x{};", SpaceBetweenBraces); 8441 SpaceBetweenBraces.SpaceInEmptyParentheses = true; 8442 verifyFormat("vector< int > x{ };", SpaceBetweenBraces); 8443 } 8444 8445 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) { 8446 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8447 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8448 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8449 " 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};"); 8452 verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n" 8453 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8454 " 1, 22, 333, 4444, 55555, //\n" 8455 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8456 " 1, 22, 333, 4444, 55555, 666666, 7777777};"); 8457 verifyFormat( 8458 "vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8459 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8460 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 8461 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8462 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8463 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 8464 " 7777777};"); 8465 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8466 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8467 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8468 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8469 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8470 " // Separating comment.\n" 8471 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8472 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 8473 " // Leading comment\n" 8474 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 8475 " X86::R8, X86::R9, X86::R10, X86::R11, 0};"); 8476 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8477 " 1, 1, 1, 1};", 8478 getLLVMStyleWithColumns(39)); 8479 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8480 " 1, 1, 1, 1};", 8481 getLLVMStyleWithColumns(38)); 8482 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 8483 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};", 8484 getLLVMStyleWithColumns(43)); 8485 verifyFormat( 8486 "static unsigned SomeValues[10][3] = {\n" 8487 " {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4}, {1, 8, 4},\n" 8488 " {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};"); 8489 verifyFormat("static auto fields = new vector<string>{\n" 8490 " \"aaaaaaaaaaaaa\",\n" 8491 " \"aaaaaaaaaaaaa\",\n" 8492 " \"aaaaaaaaaaaa\",\n" 8493 " \"aaaaaaaaaaaaaa\",\n" 8494 " \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8495 " \"aaaaaaaaaaaa\",\n" 8496 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n" 8497 "};"); 8498 verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};"); 8499 verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n" 8500 " 2, bbbbbbbbbbbbbbbbbbbbbb,\n" 8501 " 3, cccccccccccccccccccccc};", 8502 getLLVMStyleWithColumns(60)); 8503 8504 // Trailing commas. 8505 verifyFormat("vector<int> x = {\n" 8506 " 1, 1, 1, 1, 1, 1, 1, 1,\n" 8507 "};", 8508 getLLVMStyleWithColumns(39)); 8509 verifyFormat("vector<int> x = {\n" 8510 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 8511 "};", 8512 getLLVMStyleWithColumns(39)); 8513 verifyFormat("vector<int> x = {1, 1, 1, 1,\n" 8514 " 1, 1, 1, 1,\n" 8515 " /**/ /**/};", 8516 getLLVMStyleWithColumns(39)); 8517 8518 // Trailing comment in the first line. 8519 verifyFormat("vector<int> iiiiiiiiiiiiiii = { //\n" 8520 " 1111111111, 2222222222, 33333333333, 4444444444, //\n" 8521 " 111111111, 222222222, 3333333333, 444444444, //\n" 8522 " 11111111, 22222222, 333333333, 44444444};"); 8523 // Trailing comment in the last line. 8524 verifyFormat("int aaaaa[] = {\n" 8525 " 1, 2, 3, // comment\n" 8526 " 4, 5, 6 // comment\n" 8527 "};"); 8528 8529 // With nested lists, we should either format one item per line or all nested 8530 // lists one on line. 8531 // FIXME: For some nested lists, we can do better. 8532 verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n" 8533 " {aaaaaaaaaaaaaaaaaaa},\n" 8534 " {aaaaaaaaaaaaaaaaaaaaa},\n" 8535 " {aaaaaaaaaaaaaaaaa}};", 8536 getLLVMStyleWithColumns(60)); 8537 verifyFormat( 8538 "SomeStruct my_struct_array = {\n" 8539 " {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n" 8540 " aaaaaaaaaaaaa, aaaaaaa, aaa},\n" 8541 " {aaa, aaa},\n" 8542 " {aaa, aaa},\n" 8543 " {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n" 8544 " {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n" 8545 " aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};"); 8546 8547 // No column layout should be used here. 8548 verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n" 8549 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};"); 8550 8551 verifyNoCrash("a<,"); 8552 8553 // No braced initializer here. 8554 verifyFormat("void f() {\n" 8555 " struct Dummy {};\n" 8556 " f(v);\n" 8557 "}"); 8558 8559 // Long lists should be formatted in columns even if they are nested. 8560 verifyFormat( 8561 "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8562 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8563 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 8564 " 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});"); 8567 8568 // Allow "single-column" layout even if that violates the column limit. There 8569 // isn't going to be a better way. 8570 verifyFormat("std::vector<int> a = {\n" 8571 " aaaaaaaa,\n" 8572 " aaaaaaaa,\n" 8573 " aaaaaaaa,\n" 8574 " aaaaaaaa,\n" 8575 " aaaaaaaaaa,\n" 8576 " aaaaaaaa,\n" 8577 " aaaaaaaaaaaaaaaaaaaaaaaaaaa};", 8578 getLLVMStyleWithColumns(30)); 8579 verifyFormat("vector<int> aaaa = {\n" 8580 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8581 " aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 8582 " aaaaaa.aaaaaaa,\n" 8583 " aaaaaa.aaaaaaa,\n" 8584 " aaaaaa.aaaaaaa,\n" 8585 " aaaaaa.aaaaaaa,\n" 8586 "};"); 8587 8588 // Don't create hanging lists. 8589 verifyFormat("someFunction(Param, {List1, List2,\n" 8590 " List3});", 8591 getLLVMStyleWithColumns(35)); 8592 verifyFormat("someFunction(Param, Param,\n" 8593 " {List1, List2,\n" 8594 " List3});", 8595 getLLVMStyleWithColumns(35)); 8596 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n" 8597 " aaaaaaaaaaaaaaaaaaaaaaa);"); 8598 } 8599 8600 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 8601 FormatStyle DoNotMerge = getLLVMStyle(); 8602 DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8603 8604 verifyFormat("void f() { return 42; }"); 8605 verifyFormat("void f() {\n" 8606 " return 42;\n" 8607 "}", 8608 DoNotMerge); 8609 verifyFormat("void f() {\n" 8610 " // Comment\n" 8611 "}"); 8612 verifyFormat("{\n" 8613 "#error {\n" 8614 " int a;\n" 8615 "}"); 8616 verifyFormat("{\n" 8617 " int a;\n" 8618 "#error {\n" 8619 "}"); 8620 verifyFormat("void f() {} // comment"); 8621 verifyFormat("void f() { int a; } // comment"); 8622 verifyFormat("void f() {\n" 8623 "} // comment", 8624 DoNotMerge); 8625 verifyFormat("void f() {\n" 8626 " int a;\n" 8627 "} // comment", 8628 DoNotMerge); 8629 verifyFormat("void f() {\n" 8630 "} // comment", 8631 getLLVMStyleWithColumns(15)); 8632 8633 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 8634 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 8635 8636 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 8637 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 8638 verifyFormat("class C {\n" 8639 " C()\n" 8640 " : iiiiiiii(nullptr),\n" 8641 " kkkkkkk(nullptr),\n" 8642 " mmmmmmm(nullptr),\n" 8643 " nnnnnnn(nullptr) {}\n" 8644 "};", 8645 getGoogleStyle()); 8646 8647 FormatStyle NoColumnLimit = getLLVMStyle(); 8648 NoColumnLimit.ColumnLimit = 0; 8649 EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit)); 8650 EXPECT_EQ("class C {\n" 8651 " A() : b(0) {}\n" 8652 "};", 8653 format("class C{A():b(0){}};", NoColumnLimit)); 8654 EXPECT_EQ("A()\n" 8655 " : b(0) {\n" 8656 "}", 8657 format("A()\n:b(0)\n{\n}", NoColumnLimit)); 8658 8659 FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit; 8660 DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine = 8661 FormatStyle::SFS_None; 8662 EXPECT_EQ("A()\n" 8663 " : b(0) {\n" 8664 "}", 8665 format("A():b(0){}", DoNotMergeNoColumnLimit)); 8666 EXPECT_EQ("A()\n" 8667 " : b(0) {\n" 8668 "}", 8669 format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit)); 8670 8671 verifyFormat("#define A \\\n" 8672 " void f() { \\\n" 8673 " int i; \\\n" 8674 " }", 8675 getLLVMStyleWithColumns(20)); 8676 verifyFormat("#define A \\\n" 8677 " void f() { int i; }", 8678 getLLVMStyleWithColumns(21)); 8679 verifyFormat("#define A \\\n" 8680 " void f() { \\\n" 8681 " int i; \\\n" 8682 " } \\\n" 8683 " int j;", 8684 getLLVMStyleWithColumns(22)); 8685 verifyFormat("#define A \\\n" 8686 " void f() { int i; } \\\n" 8687 " int j;", 8688 getLLVMStyleWithColumns(23)); 8689 } 8690 8691 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) { 8692 FormatStyle MergeEmptyOnly = getLLVMStyle(); 8693 MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8694 verifyFormat("class C {\n" 8695 " int f() {}\n" 8696 "};", 8697 MergeEmptyOnly); 8698 verifyFormat("class C {\n" 8699 " int f() {\n" 8700 " return 42;\n" 8701 " }\n" 8702 "};", 8703 MergeEmptyOnly); 8704 verifyFormat("int f() {}", MergeEmptyOnly); 8705 verifyFormat("int f() {\n" 8706 " return 42;\n" 8707 "}", 8708 MergeEmptyOnly); 8709 8710 // Also verify behavior when BraceWrapping.AfterFunction = true 8711 MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8712 MergeEmptyOnly.BraceWrapping.AfterFunction = true; 8713 verifyFormat("int f() {}", MergeEmptyOnly); 8714 verifyFormat("class C {\n" 8715 " int f() {}\n" 8716 "};", 8717 MergeEmptyOnly); 8718 } 8719 8720 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) { 8721 FormatStyle MergeInlineOnly = getLLVMStyle(); 8722 MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8723 verifyFormat("class C {\n" 8724 " int f() { return 42; }\n" 8725 "};", 8726 MergeInlineOnly); 8727 verifyFormat("int f() {\n" 8728 " return 42;\n" 8729 "}", 8730 MergeInlineOnly); 8731 8732 // SFS_Inline implies SFS_Empty 8733 verifyFormat("class C {\n" 8734 " int f() {}\n" 8735 "};", 8736 MergeInlineOnly); 8737 verifyFormat("int f() {}", MergeInlineOnly); 8738 8739 // Also verify behavior when BraceWrapping.AfterFunction = true 8740 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8741 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8742 verifyFormat("class C {\n" 8743 " int f() { return 42; }\n" 8744 "};", 8745 MergeInlineOnly); 8746 verifyFormat("int f()\n" 8747 "{\n" 8748 " return 42;\n" 8749 "}", 8750 MergeInlineOnly); 8751 8752 // SFS_Inline implies SFS_Empty 8753 verifyFormat("int f() {}", MergeInlineOnly); 8754 verifyFormat("class C {\n" 8755 " int f() {}\n" 8756 "};", 8757 MergeInlineOnly); 8758 } 8759 8760 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) { 8761 FormatStyle MergeInlineOnly = getLLVMStyle(); 8762 MergeInlineOnly.AllowShortFunctionsOnASingleLine = 8763 FormatStyle::SFS_InlineOnly; 8764 verifyFormat("class C {\n" 8765 " int f() { return 42; }\n" 8766 "};", 8767 MergeInlineOnly); 8768 verifyFormat("int f() {\n" 8769 " return 42;\n" 8770 "}", 8771 MergeInlineOnly); 8772 8773 // SFS_InlineOnly does not imply SFS_Empty 8774 verifyFormat("class C {\n" 8775 " int f() {}\n" 8776 "};", 8777 MergeInlineOnly); 8778 verifyFormat("int f() {\n" 8779 "}", 8780 MergeInlineOnly); 8781 8782 // Also verify behavior when BraceWrapping.AfterFunction = true 8783 MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom; 8784 MergeInlineOnly.BraceWrapping.AfterFunction = true; 8785 verifyFormat("class C {\n" 8786 " int f() { return 42; }\n" 8787 "};", 8788 MergeInlineOnly); 8789 verifyFormat("int f()\n" 8790 "{\n" 8791 " return 42;\n" 8792 "}", 8793 MergeInlineOnly); 8794 8795 // SFS_InlineOnly does not imply SFS_Empty 8796 verifyFormat("int f()\n" 8797 "{\n" 8798 "}", 8799 MergeInlineOnly); 8800 verifyFormat("class C {\n" 8801 " int f() {}\n" 8802 "};", 8803 MergeInlineOnly); 8804 } 8805 8806 TEST_F(FormatTest, SplitEmptyFunction) { 8807 FormatStyle Style = getLLVMStyle(); 8808 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 8809 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8810 Style.BraceWrapping.AfterFunction = true; 8811 Style.BraceWrapping.SplitEmptyFunction = false; 8812 Style.ColumnLimit = 40; 8813 8814 verifyFormat("int f()\n" 8815 "{}", 8816 Style); 8817 verifyFormat("int f()\n" 8818 "{\n" 8819 " return 42;\n" 8820 "}", 8821 Style); 8822 verifyFormat("int f()\n" 8823 "{\n" 8824 " // some comment\n" 8825 "}", 8826 Style); 8827 8828 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty; 8829 verifyFormat("int f() {}", Style); 8830 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8831 "{}", 8832 Style); 8833 verifyFormat("int f()\n" 8834 "{\n" 8835 " return 0;\n" 8836 "}", 8837 Style); 8838 8839 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 8840 verifyFormat("class Foo {\n" 8841 " int f() {}\n" 8842 "};\n", 8843 Style); 8844 verifyFormat("class Foo {\n" 8845 " int f() { return 0; }\n" 8846 "};\n", 8847 Style); 8848 verifyFormat("class Foo {\n" 8849 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8850 " {}\n" 8851 "};\n", 8852 Style); 8853 verifyFormat("class Foo {\n" 8854 " int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8855 " {\n" 8856 " return 0;\n" 8857 " }\n" 8858 "};\n", 8859 Style); 8860 8861 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8862 verifyFormat("int f() {}", Style); 8863 verifyFormat("int f() { return 0; }", Style); 8864 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8865 "{}", 8866 Style); 8867 verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n" 8868 "{\n" 8869 " return 0;\n" 8870 "}", 8871 Style); 8872 } 8873 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) { 8874 FormatStyle Style = getLLVMStyle(); 8875 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 8876 verifyFormat("#ifdef A\n" 8877 "int f() {}\n" 8878 "#else\n" 8879 "int g() {}\n" 8880 "#endif", 8881 Style); 8882 } 8883 8884 TEST_F(FormatTest, SplitEmptyClass) { 8885 FormatStyle Style = getLLVMStyle(); 8886 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8887 Style.BraceWrapping.AfterClass = true; 8888 Style.BraceWrapping.SplitEmptyRecord = false; 8889 8890 verifyFormat("class Foo\n" 8891 "{};", 8892 Style); 8893 verifyFormat("/* something */ class Foo\n" 8894 "{};", 8895 Style); 8896 verifyFormat("template <typename X> class Foo\n" 8897 "{};", 8898 Style); 8899 verifyFormat("class Foo\n" 8900 "{\n" 8901 " Foo();\n" 8902 "};", 8903 Style); 8904 verifyFormat("typedef class Foo\n" 8905 "{\n" 8906 "} Foo_t;", 8907 Style); 8908 } 8909 8910 TEST_F(FormatTest, SplitEmptyStruct) { 8911 FormatStyle Style = getLLVMStyle(); 8912 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8913 Style.BraceWrapping.AfterStruct = true; 8914 Style.BraceWrapping.SplitEmptyRecord = false; 8915 8916 verifyFormat("struct Foo\n" 8917 "{};", 8918 Style); 8919 verifyFormat("/* something */ struct Foo\n" 8920 "{};", 8921 Style); 8922 verifyFormat("template <typename X> struct Foo\n" 8923 "{};", 8924 Style); 8925 verifyFormat("struct Foo\n" 8926 "{\n" 8927 " Foo();\n" 8928 "};", 8929 Style); 8930 verifyFormat("typedef struct Foo\n" 8931 "{\n" 8932 "} Foo_t;", 8933 Style); 8934 // typedef struct Bar {} Bar_t; 8935 } 8936 8937 TEST_F(FormatTest, SplitEmptyUnion) { 8938 FormatStyle Style = getLLVMStyle(); 8939 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8940 Style.BraceWrapping.AfterUnion = true; 8941 Style.BraceWrapping.SplitEmptyRecord = false; 8942 8943 verifyFormat("union Foo\n" 8944 "{};", 8945 Style); 8946 verifyFormat("/* something */ union Foo\n" 8947 "{};", 8948 Style); 8949 verifyFormat("union Foo\n" 8950 "{\n" 8951 " A,\n" 8952 "};", 8953 Style); 8954 verifyFormat("typedef union Foo\n" 8955 "{\n" 8956 "} Foo_t;", 8957 Style); 8958 } 8959 8960 TEST_F(FormatTest, SplitEmptyNamespace) { 8961 FormatStyle Style = getLLVMStyle(); 8962 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 8963 Style.BraceWrapping.AfterNamespace = true; 8964 Style.BraceWrapping.SplitEmptyNamespace = false; 8965 8966 verifyFormat("namespace Foo\n" 8967 "{};", 8968 Style); 8969 verifyFormat("/* something */ namespace Foo\n" 8970 "{};", 8971 Style); 8972 verifyFormat("inline namespace Foo\n" 8973 "{};", 8974 Style); 8975 verifyFormat("/* something */ inline namespace Foo\n" 8976 "{};", 8977 Style); 8978 verifyFormat("export namespace Foo\n" 8979 "{};", 8980 Style); 8981 verifyFormat("namespace Foo\n" 8982 "{\n" 8983 "void Bar();\n" 8984 "};", 8985 Style); 8986 } 8987 8988 TEST_F(FormatTest, NeverMergeShortRecords) { 8989 FormatStyle Style = getLLVMStyle(); 8990 8991 verifyFormat("class Foo {\n" 8992 " Foo();\n" 8993 "};", 8994 Style); 8995 verifyFormat("typedef class Foo {\n" 8996 " Foo();\n" 8997 "} Foo_t;", 8998 Style); 8999 verifyFormat("struct Foo {\n" 9000 " Foo();\n" 9001 "};", 9002 Style); 9003 verifyFormat("typedef struct Foo {\n" 9004 " Foo();\n" 9005 "} Foo_t;", 9006 Style); 9007 verifyFormat("union Foo {\n" 9008 " A,\n" 9009 "};", 9010 Style); 9011 verifyFormat("typedef union Foo {\n" 9012 " A,\n" 9013 "} Foo_t;", 9014 Style); 9015 verifyFormat("namespace Foo {\n" 9016 "void Bar();\n" 9017 "};", 9018 Style); 9019 9020 Style.BreakBeforeBraces = FormatStyle::BS_Custom; 9021 Style.BraceWrapping.AfterClass = true; 9022 Style.BraceWrapping.AfterStruct = true; 9023 Style.BraceWrapping.AfterUnion = true; 9024 Style.BraceWrapping.AfterNamespace = true; 9025 verifyFormat("class Foo\n" 9026 "{\n" 9027 " Foo();\n" 9028 "};", 9029 Style); 9030 verifyFormat("typedef class Foo\n" 9031 "{\n" 9032 " Foo();\n" 9033 "} Foo_t;", 9034 Style); 9035 verifyFormat("struct Foo\n" 9036 "{\n" 9037 " Foo();\n" 9038 "};", 9039 Style); 9040 verifyFormat("typedef struct Foo\n" 9041 "{\n" 9042 " Foo();\n" 9043 "} Foo_t;", 9044 Style); 9045 verifyFormat("union Foo\n" 9046 "{\n" 9047 " A,\n" 9048 "};", 9049 Style); 9050 verifyFormat("typedef union Foo\n" 9051 "{\n" 9052 " A,\n" 9053 "} Foo_t;", 9054 Style); 9055 verifyFormat("namespace Foo\n" 9056 "{\n" 9057 "void Bar();\n" 9058 "};", 9059 Style); 9060 } 9061 9062 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 9063 // Elaborate type variable declarations. 9064 verifyFormat("struct foo a = {bar};\nint n;"); 9065 verifyFormat("class foo a = {bar};\nint n;"); 9066 verifyFormat("union foo a = {bar};\nint n;"); 9067 9068 // Elaborate types inside function definitions. 9069 verifyFormat("struct foo f() {}\nint n;"); 9070 verifyFormat("class foo f() {}\nint n;"); 9071 verifyFormat("union foo f() {}\nint n;"); 9072 9073 // Templates. 9074 verifyFormat("template <class X> void f() {}\nint n;"); 9075 verifyFormat("template <struct X> void f() {}\nint n;"); 9076 verifyFormat("template <union X> void f() {}\nint n;"); 9077 9078 // Actual definitions... 9079 verifyFormat("struct {\n} n;"); 9080 verifyFormat( 9081 "template <template <class T, class Y>, class Z> class X {\n} n;"); 9082 verifyFormat("union Z {\n int n;\n} x;"); 9083 verifyFormat("class MACRO Z {\n} n;"); 9084 verifyFormat("class MACRO(X) Z {\n} n;"); 9085 verifyFormat("class __attribute__(X) Z {\n} n;"); 9086 verifyFormat("class __declspec(X) Z {\n} n;"); 9087 verifyFormat("class A##B##C {\n} n;"); 9088 verifyFormat("class alignas(16) Z {\n} n;"); 9089 verifyFormat("class MACRO(X) alignas(16) Z {\n} n;"); 9090 verifyFormat("class MACROA MACRO(X) Z {\n} n;"); 9091 9092 // Redefinition from nested context: 9093 verifyFormat("class A::B::C {\n} n;"); 9094 9095 // Template definitions. 9096 verifyFormat( 9097 "template <typename F>\n" 9098 "Matcher(const Matcher<F> &Other,\n" 9099 " typename enable_if_c<is_base_of<F, T>::value &&\n" 9100 " !is_same<F, T>::value>::type * = 0)\n" 9101 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 9102 9103 // FIXME: This is still incorrectly handled at the formatter side. 9104 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 9105 verifyFormat("int i = SomeFunction(a<b, a> b);"); 9106 9107 // FIXME: 9108 // This now gets parsed incorrectly as class definition. 9109 // verifyFormat("class A<int> f() {\n}\nint n;"); 9110 9111 // Elaborate types where incorrectly parsing the structural element would 9112 // break the indent. 9113 verifyFormat("if (true)\n" 9114 " class X x;\n" 9115 "else\n" 9116 " f();\n"); 9117 9118 // This is simply incomplete. Formatting is not important, but must not crash. 9119 verifyFormat("class A:"); 9120 } 9121 9122 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 9123 EXPECT_EQ("#error Leave all white!!!!! space* alone!\n", 9124 format("#error Leave all white!!!!! space* alone!\n")); 9125 EXPECT_EQ( 9126 "#warning Leave all white!!!!! space* alone!\n", 9127 format("#warning Leave all white!!!!! space* alone!\n")); 9128 EXPECT_EQ("#error 1", format(" # error 1")); 9129 EXPECT_EQ("#warning 1", format(" # warning 1")); 9130 } 9131 9132 TEST_F(FormatTest, FormatHashIfExpressions) { 9133 verifyFormat("#if AAAA && BBBB"); 9134 verifyFormat("#if (AAAA && BBBB)"); 9135 verifyFormat("#elif (AAAA && BBBB)"); 9136 // FIXME: Come up with a better indentation for #elif. 9137 verifyFormat( 9138 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 9139 " defined(BBBBBBBB)\n" 9140 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 9141 " defined(BBBBBBBB)\n" 9142 "#endif", 9143 getLLVMStyleWithColumns(65)); 9144 } 9145 9146 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 9147 FormatStyle AllowsMergedIf = getGoogleStyle(); 9148 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = 9149 FormatStyle::SIS_WithoutElse; 9150 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 9151 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 9152 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 9153 EXPECT_EQ("if (true) return 42;", 9154 format("if (true)\nreturn 42;", AllowsMergedIf)); 9155 FormatStyle ShortMergedIf = AllowsMergedIf; 9156 ShortMergedIf.ColumnLimit = 25; 9157 verifyFormat("#define A \\\n" 9158 " if (true) return 42;", 9159 ShortMergedIf); 9160 verifyFormat("#define A \\\n" 9161 " f(); \\\n" 9162 " if (true)\n" 9163 "#define B", 9164 ShortMergedIf); 9165 verifyFormat("#define A \\\n" 9166 " f(); \\\n" 9167 " if (true)\n" 9168 "g();", 9169 ShortMergedIf); 9170 verifyFormat("{\n" 9171 "#ifdef A\n" 9172 " // Comment\n" 9173 " if (true) continue;\n" 9174 "#endif\n" 9175 " // Comment\n" 9176 " if (true) continue;\n" 9177 "}", 9178 ShortMergedIf); 9179 ShortMergedIf.ColumnLimit = 33; 9180 verifyFormat("#define A \\\n" 9181 " if constexpr (true) return 42;", 9182 ShortMergedIf); 9183 verifyFormat("#define A \\\n" 9184 " if CONSTEXPR (true) return 42;", 9185 ShortMergedIf); 9186 ShortMergedIf.ColumnLimit = 29; 9187 verifyFormat("#define A \\\n" 9188 " if (aaaaaaaaaa) return 1; \\\n" 9189 " return 2;", 9190 ShortMergedIf); 9191 ShortMergedIf.ColumnLimit = 28; 9192 verifyFormat("#define A \\\n" 9193 " if (aaaaaaaaaa) \\\n" 9194 " return 1; \\\n" 9195 " return 2;", 9196 ShortMergedIf); 9197 verifyFormat("#define A \\\n" 9198 " if constexpr (aaaaaaa) \\\n" 9199 " return 1; \\\n" 9200 " return 2;", 9201 ShortMergedIf); 9202 verifyFormat("#define A \\\n" 9203 " if CONSTEXPR (aaaaaaa) \\\n" 9204 " return 1; \\\n" 9205 " return 2;", 9206 ShortMergedIf); 9207 } 9208 9209 TEST_F(FormatTest, FormatStarDependingOnContext) { 9210 verifyFormat("void f(int *a);"); 9211 verifyFormat("void f() { f(fint * b); }"); 9212 verifyFormat("class A {\n void f(int *a);\n};"); 9213 verifyFormat("class A {\n int *a;\n};"); 9214 verifyFormat("namespace a {\n" 9215 "namespace b {\n" 9216 "class A {\n" 9217 " void f() {}\n" 9218 " int *a;\n" 9219 "};\n" 9220 "} // namespace b\n" 9221 "} // namespace a"); 9222 } 9223 9224 TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 9225 verifyFormat("while"); 9226 verifyFormat("operator"); 9227 } 9228 9229 TEST_F(FormatTest, SkipsDeeplyNestedLines) { 9230 // This code would be painfully slow to format if we didn't skip it. 9231 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 9232 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9233 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9234 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9235 "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" 9236 "A(1, 1)\n" 9237 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x 9238 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9239 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 9240 ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" 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 // Deeply nested part is untouched, rest is formatted. 9248 EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n", 9249 format(std::string("int i;\n") + Code + "int j;\n", 9250 getLLVMStyle(), SC_ExpectIncomplete)); 9251 } 9252 9253 //===----------------------------------------------------------------------===// 9254 // Objective-C tests. 9255 //===----------------------------------------------------------------------===// 9256 9257 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 9258 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 9259 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 9260 format("-(NSUInteger)indexOfObject:(id)anObject;")); 9261 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 9262 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 9263 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 9264 format("-(NSInteger)Method3:(id)anObject;")); 9265 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 9266 format("-(NSInteger)Method4:(id)anObject;")); 9267 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 9268 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 9269 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 9270 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 9271 EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9272 "forAllCells:(BOOL)flag;", 9273 format("- (void)sendAction:(SEL)aSelector to:(id)anObject " 9274 "forAllCells:(BOOL)flag;")); 9275 9276 // Very long objectiveC method declaration. 9277 verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n" 9278 " (SoooooooooooooooooooooomeType *)bbbbbbbbbb;"); 9279 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 9280 " inRange:(NSRange)range\n" 9281 " outRange:(NSRange)out_range\n" 9282 " outRange1:(NSRange)out_range1\n" 9283 " outRange2:(NSRange)out_range2\n" 9284 " outRange3:(NSRange)out_range3\n" 9285 " outRange4:(NSRange)out_range4\n" 9286 " outRange5:(NSRange)out_range5\n" 9287 " outRange6:(NSRange)out_range6\n" 9288 " outRange7:(NSRange)out_range7\n" 9289 " outRange8:(NSRange)out_range8\n" 9290 " outRange9:(NSRange)out_range9;"); 9291 9292 // When the function name has to be wrapped. 9293 FormatStyle Style = getLLVMStyle(); 9294 // ObjC ignores IndentWrappedFunctionNames when wrapping methods 9295 // and always indents instead. 9296 Style.IndentWrappedFunctionNames = false; 9297 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9298 " veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n" 9299 " anotherName:(NSString)bbbbbbbbbbbbbb {\n" 9300 "}", 9301 Style); 9302 Style.IndentWrappedFunctionNames = true; 9303 verifyFormat("- (SomeLooooooooooooooooooooongType *)\n" 9304 " veryLooooooooooongName:(NSString)cccccccccccccc\n" 9305 " anotherName:(NSString)dddddddddddddd {\n" 9306 "}", 9307 Style); 9308 9309 verifyFormat("- (int)sum:(vector<int>)numbers;"); 9310 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 9311 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 9312 // protocol lists (but not for template classes): 9313 // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 9314 9315 verifyFormat("- (int (*)())foo:(int (*)())f;"); 9316 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 9317 9318 // If there's no return type (very rare in practice!), LLVM and Google style 9319 // agree. 9320 verifyFormat("- foo;"); 9321 verifyFormat("- foo:(int)f;"); 9322 verifyGoogleFormat("- foo:(int)foo;"); 9323 } 9324 9325 TEST_F(FormatTest, BreaksStringLiterals) { 9326 EXPECT_EQ("\"some text \"\n" 9327 "\"other\";", 9328 format("\"some text other\";", getLLVMStyleWithColumns(12))); 9329 EXPECT_EQ("\"some text \"\n" 9330 "\"other\";", 9331 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 9332 EXPECT_EQ( 9333 "#define A \\\n" 9334 " \"some \" \\\n" 9335 " \"text \" \\\n" 9336 " \"other\";", 9337 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 9338 EXPECT_EQ( 9339 "#define A \\\n" 9340 " \"so \" \\\n" 9341 " \"text \" \\\n" 9342 " \"other\";", 9343 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 9344 9345 EXPECT_EQ("\"some text\"", 9346 format("\"some text\"", getLLVMStyleWithColumns(1))); 9347 EXPECT_EQ("\"some text\"", 9348 format("\"some text\"", getLLVMStyleWithColumns(11))); 9349 EXPECT_EQ("\"some \"\n" 9350 "\"text\"", 9351 format("\"some text\"", getLLVMStyleWithColumns(10))); 9352 EXPECT_EQ("\"some \"\n" 9353 "\"text\"", 9354 format("\"some text\"", getLLVMStyleWithColumns(7))); 9355 EXPECT_EQ("\"some\"\n" 9356 "\" tex\"\n" 9357 "\"t\"", 9358 format("\"some text\"", getLLVMStyleWithColumns(6))); 9359 EXPECT_EQ("\"some\"\n" 9360 "\" tex\"\n" 9361 "\" and\"", 9362 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 9363 EXPECT_EQ("\"some\"\n" 9364 "\"/tex\"\n" 9365 "\"/and\"", 9366 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 9367 9368 EXPECT_EQ("variable =\n" 9369 " \"long string \"\n" 9370 " \"literal\";", 9371 format("variable = \"long string literal\";", 9372 getLLVMStyleWithColumns(20))); 9373 9374 EXPECT_EQ("variable = f(\n" 9375 " \"long string \"\n" 9376 " \"literal\",\n" 9377 " short,\n" 9378 " loooooooooooooooooooong);", 9379 format("variable = f(\"long string literal\", short, " 9380 "loooooooooooooooooooong);", 9381 getLLVMStyleWithColumns(20))); 9382 9383 EXPECT_EQ( 9384 "f(g(\"long string \"\n" 9385 " \"literal\"),\n" 9386 " b);", 9387 format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20))); 9388 EXPECT_EQ("f(g(\"long string \"\n" 9389 " \"literal\",\n" 9390 " a),\n" 9391 " b);", 9392 format("f(g(\"long string literal\", a), b);", 9393 getLLVMStyleWithColumns(20))); 9394 EXPECT_EQ( 9395 "f(\"one two\".split(\n" 9396 " variable));", 9397 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 9398 EXPECT_EQ("f(\"one two three four five six \"\n" 9399 " \"seven\".split(\n" 9400 " really_looooong_variable));", 9401 format("f(\"one two three four five six seven\"." 9402 "split(really_looooong_variable));", 9403 getLLVMStyleWithColumns(33))); 9404 9405 EXPECT_EQ("f(\"some \"\n" 9406 " \"text\",\n" 9407 " other);", 9408 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 9409 9410 // Only break as a last resort. 9411 verifyFormat( 9412 "aaaaaaaaaaaaaaaaaaaa(\n" 9413 " aaaaaaaaaaaaaaaaaaaa,\n" 9414 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 9415 9416 EXPECT_EQ("\"splitmea\"\n" 9417 "\"trandomp\"\n" 9418 "\"oint\"", 9419 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 9420 9421 EXPECT_EQ("\"split/\"\n" 9422 "\"pathat/\"\n" 9423 "\"slashes\"", 9424 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9425 9426 EXPECT_EQ("\"split/\"\n" 9427 "\"pathat/\"\n" 9428 "\"slashes\"", 9429 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 9430 EXPECT_EQ("\"split at \"\n" 9431 "\"spaces/at/\"\n" 9432 "\"slashes.at.any$\"\n" 9433 "\"non-alphanumeric%\"\n" 9434 "\"1111111111characte\"\n" 9435 "\"rs\"", 9436 format("\"split at " 9437 "spaces/at/" 9438 "slashes.at." 9439 "any$non-" 9440 "alphanumeric%" 9441 "1111111111characte" 9442 "rs\"", 9443 getLLVMStyleWithColumns(20))); 9444 9445 // Verify that splitting the strings understands 9446 // Style::AlwaysBreakBeforeMultilineStrings. 9447 EXPECT_EQ("aaaaaaaaaaaa(\n" 9448 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 9449 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 9450 format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa " 9451 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9452 "aaaaaaaaaaaaaaaaaaaaaa\");", 9453 getGoogleStyle())); 9454 EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9455 " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";", 9456 format("return \"aaaaaaaaaaaaaaaaaaaaaa " 9457 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa " 9458 "aaaaaaaaaaaaaaaaaaaaaa\";", 9459 getGoogleStyle())); 9460 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9461 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9462 format("llvm::outs() << " 9463 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 9464 "aaaaaaaaaaaaaaaaaaa\";")); 9465 EXPECT_EQ("ffff(\n" 9466 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 9467 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9468 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 9469 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 9470 getGoogleStyle())); 9471 9472 FormatStyle Style = getLLVMStyleWithColumns(12); 9473 Style.BreakStringLiterals = false; 9474 EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style)); 9475 9476 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 9477 AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9478 EXPECT_EQ("#define A \\\n" 9479 " \"some \" \\\n" 9480 " \"text \" \\\n" 9481 " \"other\";", 9482 format("#define A \"some text other\";", AlignLeft)); 9483 } 9484 9485 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) { 9486 EXPECT_EQ("C a = \"some more \"\n" 9487 " \"text\";", 9488 format("C a = \"some more text\";", getLLVMStyleWithColumns(18))); 9489 } 9490 9491 TEST_F(FormatTest, FullyRemoveEmptyLines) { 9492 FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80); 9493 NoEmptyLines.MaxEmptyLinesToKeep = 0; 9494 EXPECT_EQ("int i = a(b());", 9495 format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines)); 9496 } 9497 9498 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) { 9499 EXPECT_EQ( 9500 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9501 "(\n" 9502 " \"x\t\");", 9503 format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 9504 "aaaaaaa(" 9505 "\"x\t\");")); 9506 } 9507 9508 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) { 9509 EXPECT_EQ( 9510 "u8\"utf8 string \"\n" 9511 "u8\"literal\";", 9512 format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16))); 9513 EXPECT_EQ( 9514 "u\"utf16 string \"\n" 9515 "u\"literal\";", 9516 format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16))); 9517 EXPECT_EQ( 9518 "U\"utf32 string \"\n" 9519 "U\"literal\";", 9520 format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16))); 9521 EXPECT_EQ("L\"wide string \"\n" 9522 "L\"literal\";", 9523 format("L\"wide string literal\";", getGoogleStyleWithColumns(16))); 9524 EXPECT_EQ("@\"NSString \"\n" 9525 "@\"literal\";", 9526 format("@\"NSString literal\";", getGoogleStyleWithColumns(19))); 9527 verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26)); 9528 9529 // This input makes clang-format try to split the incomplete unicode escape 9530 // sequence, which used to lead to a crasher. 9531 verifyNoCrash( 9532 "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 9533 getLLVMStyleWithColumns(60)); 9534 } 9535 9536 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) { 9537 FormatStyle Style = getGoogleStyleWithColumns(15); 9538 EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style)); 9539 EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style)); 9540 EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style)); 9541 EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style)); 9542 EXPECT_EQ("u8R\"x(raw literal)x\";", 9543 format("u8R\"x(raw literal)x\";", Style)); 9544 } 9545 9546 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) { 9547 FormatStyle Style = getLLVMStyleWithColumns(20); 9548 EXPECT_EQ( 9549 "_T(\"aaaaaaaaaaaaaa\")\n" 9550 "_T(\"aaaaaaaaaaaaaa\")\n" 9551 "_T(\"aaaaaaaaaaaa\")", 9552 format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style)); 9553 EXPECT_EQ("f(x,\n" 9554 " _T(\"aaaaaaaaaaaa\")\n" 9555 " _T(\"aaa\"),\n" 9556 " z);", 9557 format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style)); 9558 9559 // FIXME: Handle embedded spaces in one iteration. 9560 // EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n" 9561 // "_T(\"aaaaaaaaaaaaa\")\n" 9562 // "_T(\"aaaaaaaaaaaaa\")\n" 9563 // "_T(\"a\")", 9564 // format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9565 // getLLVMStyleWithColumns(20))); 9566 EXPECT_EQ( 9567 "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", 9568 format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style)); 9569 EXPECT_EQ("f(\n" 9570 "#if !TEST\n" 9571 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9572 "#endif\n" 9573 ");", 9574 format("f(\n" 9575 "#if !TEST\n" 9576 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n" 9577 "#endif\n" 9578 ");")); 9579 EXPECT_EQ("f(\n" 9580 "\n" 9581 " _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));", 9582 format("f(\n" 9583 "\n" 9584 "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));")); 9585 } 9586 9587 TEST_F(FormatTest, BreaksStringLiteralOperands) { 9588 // In a function call with two operands, the second can be broken with no line 9589 // break before it. 9590 EXPECT_EQ( 9591 "func(a, \"long long \"\n" 9592 " \"long long\");", 9593 format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24))); 9594 // In a function call with three operands, the second must be broken with a 9595 // line break before it. 9596 EXPECT_EQ("func(a,\n" 9597 " \"long long long \"\n" 9598 " \"long\",\n" 9599 " c);", 9600 format("func(a, \"long long long long\", c);", 9601 getLLVMStyleWithColumns(24))); 9602 // In a function call with three operands, the third must be broken with a 9603 // line break before it. 9604 EXPECT_EQ("func(a, b,\n" 9605 " \"long long long \"\n" 9606 " \"long\");", 9607 format("func(a, b, \"long long long long\");", 9608 getLLVMStyleWithColumns(24))); 9609 // In a function call with three operands, both the second and the third must 9610 // be broken with a line break before them. 9611 EXPECT_EQ("func(a,\n" 9612 " \"long long long \"\n" 9613 " \"long\",\n" 9614 " \"long long long \"\n" 9615 " \"long\");", 9616 format("func(a, \"long long long long\", \"long long long long\");", 9617 getLLVMStyleWithColumns(24))); 9618 // In a chain of << with two operands, the second can be broken with no line 9619 // break before it. 9620 EXPECT_EQ("a << \"line line \"\n" 9621 " \"line\";", 9622 format("a << \"line line line\";", getLLVMStyleWithColumns(20))); 9623 // In a chain of << with three operands, the second can be broken with no line 9624 // break before it. 9625 EXPECT_EQ( 9626 "abcde << \"line \"\n" 9627 " \"line line\"\n" 9628 " << c;", 9629 format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20))); 9630 // In a chain of << with three operands, the third must be broken with a line 9631 // break before it. 9632 EXPECT_EQ( 9633 "a << b\n" 9634 " << \"line line \"\n" 9635 " \"line\";", 9636 format("a << b << \"line line line\";", getLLVMStyleWithColumns(20))); 9637 // In a chain of << with three operands, the second can be broken with no line 9638 // break before it and the third must be broken with a line break before it. 9639 EXPECT_EQ("abcd << \"line line \"\n" 9640 " \"line\"\n" 9641 " << \"line line \"\n" 9642 " \"line\";", 9643 format("abcd << \"line line line\" << \"line line line\";", 9644 getLLVMStyleWithColumns(20))); 9645 // In a chain of binary operators with two operands, the second can be broken 9646 // with no line break before it. 9647 EXPECT_EQ( 9648 "abcd + \"line line \"\n" 9649 " \"line line\";", 9650 format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20))); 9651 // In a chain of binary operators with three operands, the second must be 9652 // broken with a line break before it. 9653 EXPECT_EQ("abcd +\n" 9654 " \"line line \"\n" 9655 " \"line line\" +\n" 9656 " e;", 9657 format("abcd + \"line line line line\" + e;", 9658 getLLVMStyleWithColumns(20))); 9659 // In a function call with two operands, with AlignAfterOpenBracket enabled, 9660 // the first must be broken with a line break before it. 9661 FormatStyle Style = getLLVMStyleWithColumns(25); 9662 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 9663 EXPECT_EQ("someFunction(\n" 9664 " \"long long long \"\n" 9665 " \"long\",\n" 9666 " a);", 9667 format("someFunction(\"long long long long\", a);", Style)); 9668 } 9669 9670 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 9671 EXPECT_EQ( 9672 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9673 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9674 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 9675 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9676 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 9677 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 9678 } 9679 9680 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 9681 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 9682 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 9683 EXPECT_EQ("fffffffffff(g(R\"x(\n" 9684 "multiline raw string literal xxxxxxxxxxxxxx\n" 9685 ")x\",\n" 9686 " a),\n" 9687 " b);", 9688 format("fffffffffff(g(R\"x(\n" 9689 "multiline raw string literal xxxxxxxxxxxxxx\n" 9690 ")x\", a), b);", 9691 getGoogleStyleWithColumns(20))); 9692 EXPECT_EQ("fffffffffff(\n" 9693 " g(R\"x(qqq\n" 9694 "multiline raw string literal xxxxxxxxxxxxxx\n" 9695 ")x\",\n" 9696 " a),\n" 9697 " b);", 9698 format("fffffffffff(g(R\"x(qqq\n" 9699 "multiline raw string literal xxxxxxxxxxxxxx\n" 9700 ")x\", a), b);", 9701 getGoogleStyleWithColumns(20))); 9702 9703 EXPECT_EQ("fffffffffff(R\"x(\n" 9704 "multiline raw string literal xxxxxxxxxxxxxx\n" 9705 ")x\");", 9706 format("fffffffffff(R\"x(\n" 9707 "multiline raw string literal xxxxxxxxxxxxxx\n" 9708 ")x\");", 9709 getGoogleStyleWithColumns(20))); 9710 EXPECT_EQ("fffffffffff(R\"x(\n" 9711 "multiline raw string literal xxxxxxxxxxxxxx\n" 9712 ")x\" + bbbbbb);", 9713 format("fffffffffff(R\"x(\n" 9714 "multiline raw string literal xxxxxxxxxxxxxx\n" 9715 ")x\" + bbbbbb);", 9716 getGoogleStyleWithColumns(20))); 9717 EXPECT_EQ("fffffffffff(\n" 9718 " R\"x(\n" 9719 "multiline raw string literal xxxxxxxxxxxxxx\n" 9720 ")x\" +\n" 9721 " bbbbbb);", 9722 format("fffffffffff(\n" 9723 " R\"x(\n" 9724 "multiline raw string literal xxxxxxxxxxxxxx\n" 9725 ")x\" + bbbbbb);", 9726 getGoogleStyleWithColumns(20))); 9727 EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);", 9728 format("fffffffffff(\n" 9729 " R\"(single line raw string)\" + bbbbbb);")); 9730 } 9731 9732 TEST_F(FormatTest, SkipsUnknownStringLiterals) { 9733 verifyFormat("string a = \"unterminated;"); 9734 EXPECT_EQ("function(\"unterminated,\n" 9735 " OtherParameter);", 9736 format("function( \"unterminated,\n" 9737 " OtherParameter);")); 9738 } 9739 9740 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 9741 FormatStyle Style = getLLVMStyle(); 9742 Style.Standard = FormatStyle::LS_Cpp03; 9743 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 9744 format("#define x(_a) printf(\"foo\"_a);", Style)); 9745 } 9746 9747 TEST_F(FormatTest, CppLexVersion) { 9748 FormatStyle Style = getLLVMStyle(); 9749 // Formatting of x * y differs if x is a type. 9750 verifyFormat("void foo() { MACRO(a * b); }", Style); 9751 verifyFormat("void foo() { MACRO(int *b); }", Style); 9752 9753 // LLVM style uses latest lexer. 9754 verifyFormat("void foo() { MACRO(char8_t *b); }", Style); 9755 Style.Standard = FormatStyle::LS_Cpp17; 9756 // But in c++17, char8_t isn't a keyword. 9757 verifyFormat("void foo() { MACRO(char8_t * b); }", Style); 9758 } 9759 9760 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); } 9761 9762 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 9763 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 9764 " \"ddeeefff\");", 9765 format("someFunction(\"aaabbbcccdddeeefff\");", 9766 getLLVMStyleWithColumns(25))); 9767 EXPECT_EQ("someFunction1234567890(\n" 9768 " \"aaabbbcccdddeeefff\");", 9769 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9770 getLLVMStyleWithColumns(26))); 9771 EXPECT_EQ("someFunction1234567890(\n" 9772 " \"aaabbbcccdddeeeff\"\n" 9773 " \"f\");", 9774 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9775 getLLVMStyleWithColumns(25))); 9776 EXPECT_EQ("someFunction1234567890(\n" 9777 " \"aaabbbcccdddeeeff\"\n" 9778 " \"f\");", 9779 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 9780 getLLVMStyleWithColumns(24))); 9781 EXPECT_EQ("someFunction(\n" 9782 " \"aaabbbcc ddde \"\n" 9783 " \"efff\");", 9784 format("someFunction(\"aaabbbcc ddde efff\");", 9785 getLLVMStyleWithColumns(25))); 9786 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 9787 " \"ddeeefff\");", 9788 format("someFunction(\"aaabbbccc ddeeefff\");", 9789 getLLVMStyleWithColumns(25))); 9790 EXPECT_EQ("someFunction1234567890(\n" 9791 " \"aaabb \"\n" 9792 " \"cccdddeeefff\");", 9793 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 9794 getLLVMStyleWithColumns(25))); 9795 EXPECT_EQ("#define A \\\n" 9796 " string s = \\\n" 9797 " \"123456789\" \\\n" 9798 " \"0\"; \\\n" 9799 " int i;", 9800 format("#define A string s = \"1234567890\"; int i;", 9801 getLLVMStyleWithColumns(20))); 9802 EXPECT_EQ("someFunction(\n" 9803 " \"aaabbbcc \"\n" 9804 " \"dddeeefff\");", 9805 format("someFunction(\"aaabbbcc dddeeefff\");", 9806 getLLVMStyleWithColumns(25))); 9807 } 9808 9809 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 9810 EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3))); 9811 EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2))); 9812 EXPECT_EQ("\"test\"\n" 9813 "\"\\n\"", 9814 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 9815 EXPECT_EQ("\"tes\\\\\"\n" 9816 "\"n\"", 9817 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 9818 EXPECT_EQ("\"\\\\\\\\\"\n" 9819 "\"\\n\"", 9820 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 9821 EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 9822 EXPECT_EQ("\"\\uff01\"\n" 9823 "\"test\"", 9824 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 9825 EXPECT_EQ("\"\\Uff01ff02\"", 9826 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 9827 EXPECT_EQ("\"\\x000000000001\"\n" 9828 "\"next\"", 9829 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 9830 EXPECT_EQ("\"\\x000000000001next\"", 9831 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 9832 EXPECT_EQ("\"\\x000000000001\"", 9833 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 9834 EXPECT_EQ("\"test\"\n" 9835 "\"\\000000\"\n" 9836 "\"000001\"", 9837 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 9838 EXPECT_EQ("\"test\\000\"\n" 9839 "\"00000000\"\n" 9840 "\"1\"", 9841 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 9842 } 9843 9844 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 9845 verifyFormat("void f() {\n" 9846 " return g() {}\n" 9847 " void h() {}"); 9848 verifyFormat("int a[] = {void forgot_closing_brace(){f();\n" 9849 "g();\n" 9850 "}"); 9851 } 9852 9853 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) { 9854 verifyFormat( 9855 "void f() { return C{param1, param2}.SomeCall(param1, param2); }"); 9856 } 9857 9858 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 9859 verifyFormat("class X {\n" 9860 " void f() {\n" 9861 " }\n" 9862 "};", 9863 getLLVMStyleWithColumns(12)); 9864 } 9865 9866 TEST_F(FormatTest, ConfigurableIndentWidth) { 9867 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 9868 EightIndent.IndentWidth = 8; 9869 EightIndent.ContinuationIndentWidth = 8; 9870 verifyFormat("void f() {\n" 9871 " someFunction();\n" 9872 " if (true) {\n" 9873 " f();\n" 9874 " }\n" 9875 "}", 9876 EightIndent); 9877 verifyFormat("class X {\n" 9878 " void f() {\n" 9879 " }\n" 9880 "};", 9881 EightIndent); 9882 verifyFormat("int x[] = {\n" 9883 " call(),\n" 9884 " call()};", 9885 EightIndent); 9886 } 9887 9888 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 9889 verifyFormat("double\n" 9890 "f();", 9891 getLLVMStyleWithColumns(8)); 9892 } 9893 9894 TEST_F(FormatTest, ConfigurableUseOfTab) { 9895 FormatStyle Tab = getLLVMStyleWithColumns(42); 9896 Tab.IndentWidth = 8; 9897 Tab.UseTab = FormatStyle::UT_Always; 9898 Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left; 9899 9900 EXPECT_EQ("if (aaaaaaaa && // q\n" 9901 " bb)\t\t// w\n" 9902 "\t;", 9903 format("if (aaaaaaaa &&// q\n" 9904 "bb)// w\n" 9905 ";", 9906 Tab)); 9907 EXPECT_EQ("if (aaa && bbb) // w\n" 9908 "\t;", 9909 format("if(aaa&&bbb)// w\n" 9910 ";", 9911 Tab)); 9912 9913 verifyFormat("class X {\n" 9914 "\tvoid f() {\n" 9915 "\t\tsomeFunction(parameter1,\n" 9916 "\t\t\t parameter2);\n" 9917 "\t}\n" 9918 "};", 9919 Tab); 9920 verifyFormat("#define A \\\n" 9921 "\tvoid f() { \\\n" 9922 "\t\tsomeFunction( \\\n" 9923 "\t\t parameter1, \\\n" 9924 "\t\t parameter2); \\\n" 9925 "\t}", 9926 Tab); 9927 verifyFormat("int a;\t // x\n" 9928 "int bbbbbbbb; // x\n", 9929 Tab); 9930 9931 Tab.TabWidth = 4; 9932 Tab.IndentWidth = 8; 9933 verifyFormat("class TabWidth4Indent8 {\n" 9934 "\t\tvoid f() {\n" 9935 "\t\t\t\tsomeFunction(parameter1,\n" 9936 "\t\t\t\t\t\t\t parameter2);\n" 9937 "\t\t}\n" 9938 "};", 9939 Tab); 9940 9941 Tab.TabWidth = 4; 9942 Tab.IndentWidth = 4; 9943 verifyFormat("class TabWidth4Indent4 {\n" 9944 "\tvoid f() {\n" 9945 "\t\tsomeFunction(parameter1,\n" 9946 "\t\t\t\t\t parameter2);\n" 9947 "\t}\n" 9948 "};", 9949 Tab); 9950 9951 Tab.TabWidth = 8; 9952 Tab.IndentWidth = 4; 9953 verifyFormat("class TabWidth8Indent4 {\n" 9954 " void f() {\n" 9955 "\tsomeFunction(parameter1,\n" 9956 "\t\t parameter2);\n" 9957 " }\n" 9958 "};", 9959 Tab); 9960 9961 Tab.TabWidth = 8; 9962 Tab.IndentWidth = 8; 9963 EXPECT_EQ("/*\n" 9964 "\t a\t\tcomment\n" 9965 "\t in multiple lines\n" 9966 " */", 9967 format(" /*\t \t \n" 9968 " \t \t a\t\tcomment\t \t\n" 9969 " \t \t in multiple lines\t\n" 9970 " \t */", 9971 Tab)); 9972 9973 Tab.UseTab = FormatStyle::UT_ForIndentation; 9974 verifyFormat("{\n" 9975 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9976 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9977 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9978 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9979 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9980 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 9981 "};", 9982 Tab); 9983 verifyFormat("enum AA {\n" 9984 "\ta1, // Force multiple lines\n" 9985 "\ta2,\n" 9986 "\ta3\n" 9987 "};", 9988 Tab); 9989 EXPECT_EQ("if (aaaaaaaa && // q\n" 9990 " bb) // w\n" 9991 "\t;", 9992 format("if (aaaaaaaa &&// q\n" 9993 "bb)// w\n" 9994 ";", 9995 Tab)); 9996 verifyFormat("class X {\n" 9997 "\tvoid f() {\n" 9998 "\t\tsomeFunction(parameter1,\n" 9999 "\t\t parameter2);\n" 10000 "\t}\n" 10001 "};", 10002 Tab); 10003 verifyFormat("{\n" 10004 "\tQ(\n" 10005 "\t {\n" 10006 "\t\t int a;\n" 10007 "\t\t someFunction(aaaaaaaa,\n" 10008 "\t\t bbbbbbb);\n" 10009 "\t },\n" 10010 "\t p);\n" 10011 "}", 10012 Tab); 10013 EXPECT_EQ("{\n" 10014 "\t/* aaaa\n" 10015 "\t bbbb */\n" 10016 "}", 10017 format("{\n" 10018 "/* aaaa\n" 10019 " bbbb */\n" 10020 "}", 10021 Tab)); 10022 EXPECT_EQ("{\n" 10023 "\t/*\n" 10024 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10025 "\t bbbbbbbbbbbbb\n" 10026 "\t*/\n" 10027 "}", 10028 format("{\n" 10029 "/*\n" 10030 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10031 "*/\n" 10032 "}", 10033 Tab)); 10034 EXPECT_EQ("{\n" 10035 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10036 "\t// bbbbbbbbbbbbb\n" 10037 "}", 10038 format("{\n" 10039 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10040 "}", 10041 Tab)); 10042 EXPECT_EQ("{\n" 10043 "\t/*\n" 10044 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10045 "\t bbbbbbbbbbbbb\n" 10046 "\t*/\n" 10047 "}", 10048 format("{\n" 10049 "\t/*\n" 10050 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10051 "\t*/\n" 10052 "}", 10053 Tab)); 10054 EXPECT_EQ("{\n" 10055 "\t/*\n" 10056 "\n" 10057 "\t*/\n" 10058 "}", 10059 format("{\n" 10060 "\t/*\n" 10061 "\n" 10062 "\t*/\n" 10063 "}", 10064 Tab)); 10065 EXPECT_EQ("{\n" 10066 "\t/*\n" 10067 " asdf\n" 10068 "\t*/\n" 10069 "}", 10070 format("{\n" 10071 "\t/*\n" 10072 " asdf\n" 10073 "\t*/\n" 10074 "}", 10075 Tab)); 10076 10077 Tab.UseTab = FormatStyle::UT_Never; 10078 EXPECT_EQ("/*\n" 10079 " a\t\tcomment\n" 10080 " in multiple lines\n" 10081 " */", 10082 format(" /*\t \t \n" 10083 " \t \t a\t\tcomment\t \t\n" 10084 " \t \t in multiple lines\t\n" 10085 " \t */", 10086 Tab)); 10087 EXPECT_EQ("/* some\n" 10088 " comment */", 10089 format(" \t \t /* some\n" 10090 " \t \t comment */", 10091 Tab)); 10092 EXPECT_EQ("int a; /* some\n" 10093 " comment */", 10094 format(" \t \t int a; /* some\n" 10095 " \t \t comment */", 10096 Tab)); 10097 10098 EXPECT_EQ("int a; /* some\n" 10099 "comment */", 10100 format(" \t \t int\ta; /* some\n" 10101 " \t \t comment */", 10102 Tab)); 10103 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10104 " comment */", 10105 format(" \t \t f(\"\t\t\"); /* some\n" 10106 " \t \t comment */", 10107 Tab)); 10108 EXPECT_EQ("{\n" 10109 " /*\n" 10110 " * Comment\n" 10111 " */\n" 10112 " int i;\n" 10113 "}", 10114 format("{\n" 10115 "\t/*\n" 10116 "\t * Comment\n" 10117 "\t */\n" 10118 "\t int i;\n" 10119 "}")); 10120 10121 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10122 Tab.TabWidth = 8; 10123 Tab.IndentWidth = 8; 10124 EXPECT_EQ("if (aaaaaaaa && // q\n" 10125 " bb) // w\n" 10126 "\t;", 10127 format("if (aaaaaaaa &&// q\n" 10128 "bb)// w\n" 10129 ";", 10130 Tab)); 10131 EXPECT_EQ("if (aaa && bbb) // w\n" 10132 "\t;", 10133 format("if(aaa&&bbb)// w\n" 10134 ";", 10135 Tab)); 10136 verifyFormat("class X {\n" 10137 "\tvoid f() {\n" 10138 "\t\tsomeFunction(parameter1,\n" 10139 "\t\t\t parameter2);\n" 10140 "\t}\n" 10141 "};", 10142 Tab); 10143 verifyFormat("#define A \\\n" 10144 "\tvoid f() { \\\n" 10145 "\t\tsomeFunction( \\\n" 10146 "\t\t parameter1, \\\n" 10147 "\t\t parameter2); \\\n" 10148 "\t}", 10149 Tab); 10150 Tab.TabWidth = 4; 10151 Tab.IndentWidth = 8; 10152 verifyFormat("class TabWidth4Indent8 {\n" 10153 "\t\tvoid f() {\n" 10154 "\t\t\t\tsomeFunction(parameter1,\n" 10155 "\t\t\t\t\t\t\t parameter2);\n" 10156 "\t\t}\n" 10157 "};", 10158 Tab); 10159 Tab.TabWidth = 4; 10160 Tab.IndentWidth = 4; 10161 verifyFormat("class TabWidth4Indent4 {\n" 10162 "\tvoid f() {\n" 10163 "\t\tsomeFunction(parameter1,\n" 10164 "\t\t\t\t\t parameter2);\n" 10165 "\t}\n" 10166 "};", 10167 Tab); 10168 Tab.TabWidth = 8; 10169 Tab.IndentWidth = 4; 10170 verifyFormat("class TabWidth8Indent4 {\n" 10171 " void f() {\n" 10172 "\tsomeFunction(parameter1,\n" 10173 "\t\t parameter2);\n" 10174 " }\n" 10175 "};", 10176 Tab); 10177 Tab.TabWidth = 8; 10178 Tab.IndentWidth = 8; 10179 EXPECT_EQ("/*\n" 10180 "\t a\t\tcomment\n" 10181 "\t in multiple lines\n" 10182 " */", 10183 format(" /*\t \t \n" 10184 " \t \t a\t\tcomment\t \t\n" 10185 " \t \t in multiple lines\t\n" 10186 " \t */", 10187 Tab)); 10188 verifyFormat("{\n" 10189 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10190 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10191 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10192 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10193 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10194 "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n" 10195 "};", 10196 Tab); 10197 verifyFormat("enum AA {\n" 10198 "\ta1, // Force multiple lines\n" 10199 "\ta2,\n" 10200 "\ta3\n" 10201 "};", 10202 Tab); 10203 EXPECT_EQ("if (aaaaaaaa && // q\n" 10204 " bb) // w\n" 10205 "\t;", 10206 format("if (aaaaaaaa &&// q\n" 10207 "bb)// w\n" 10208 ";", 10209 Tab)); 10210 verifyFormat("class X {\n" 10211 "\tvoid f() {\n" 10212 "\t\tsomeFunction(parameter1,\n" 10213 "\t\t\t parameter2);\n" 10214 "\t}\n" 10215 "};", 10216 Tab); 10217 verifyFormat("{\n" 10218 "\tQ(\n" 10219 "\t {\n" 10220 "\t\t int a;\n" 10221 "\t\t someFunction(aaaaaaaa,\n" 10222 "\t\t\t\t bbbbbbb);\n" 10223 "\t },\n" 10224 "\t p);\n" 10225 "}", 10226 Tab); 10227 EXPECT_EQ("{\n" 10228 "\t/* aaaa\n" 10229 "\t bbbb */\n" 10230 "}", 10231 format("{\n" 10232 "/* aaaa\n" 10233 " bbbb */\n" 10234 "}", 10235 Tab)); 10236 EXPECT_EQ("{\n" 10237 "\t/*\n" 10238 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10239 "\t bbbbbbbbbbbbb\n" 10240 "\t*/\n" 10241 "}", 10242 format("{\n" 10243 "/*\n" 10244 " aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10245 "*/\n" 10246 "}", 10247 Tab)); 10248 EXPECT_EQ("{\n" 10249 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10250 "\t// bbbbbbbbbbbbb\n" 10251 "}", 10252 format("{\n" 10253 "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10254 "}", 10255 Tab)); 10256 EXPECT_EQ("{\n" 10257 "\t/*\n" 10258 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 10259 "\t bbbbbbbbbbbbb\n" 10260 "\t*/\n" 10261 "}", 10262 format("{\n" 10263 "\t/*\n" 10264 "\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n" 10265 "\t*/\n" 10266 "}", 10267 Tab)); 10268 EXPECT_EQ("{\n" 10269 "\t/*\n" 10270 "\n" 10271 "\t*/\n" 10272 "}", 10273 format("{\n" 10274 "\t/*\n" 10275 "\n" 10276 "\t*/\n" 10277 "}", 10278 Tab)); 10279 EXPECT_EQ("{\n" 10280 "\t/*\n" 10281 " asdf\n" 10282 "\t*/\n" 10283 "}", 10284 format("{\n" 10285 "\t/*\n" 10286 " asdf\n" 10287 "\t*/\n" 10288 "}", 10289 Tab)); 10290 EXPECT_EQ("/*\n" 10291 "\t a\t\tcomment\n" 10292 "\t in multiple lines\n" 10293 " */", 10294 format(" /*\t \t \n" 10295 " \t \t a\t\tcomment\t \t\n" 10296 " \t \t in multiple lines\t\n" 10297 " \t */", 10298 Tab)); 10299 EXPECT_EQ("/* some\n" 10300 " comment */", 10301 format(" \t \t /* some\n" 10302 " \t \t comment */", 10303 Tab)); 10304 EXPECT_EQ("int a; /* some\n" 10305 " comment */", 10306 format(" \t \t int a; /* some\n" 10307 " \t \t comment */", 10308 Tab)); 10309 EXPECT_EQ("int a; /* some\n" 10310 "comment */", 10311 format(" \t \t int\ta; /* some\n" 10312 " \t \t comment */", 10313 Tab)); 10314 EXPECT_EQ("f(\"\t\t\"); /* some\n" 10315 " comment */", 10316 format(" \t \t f(\"\t\t\"); /* some\n" 10317 " \t \t comment */", 10318 Tab)); 10319 EXPECT_EQ("{\n" 10320 " /*\n" 10321 " * Comment\n" 10322 " */\n" 10323 " int i;\n" 10324 "}", 10325 format("{\n" 10326 "\t/*\n" 10327 "\t * Comment\n" 10328 "\t */\n" 10329 "\t int i;\n" 10330 "}")); 10331 Tab.AlignConsecutiveAssignments = true; 10332 Tab.AlignConsecutiveDeclarations = true; 10333 Tab.TabWidth = 4; 10334 Tab.IndentWidth = 4; 10335 verifyFormat("class Assign {\n" 10336 "\tvoid f() {\n" 10337 "\t\tint x = 123;\n" 10338 "\t\tint random = 4;\n" 10339 "\t\tstd::string alphabet =\n" 10340 "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n" 10341 "\t}\n" 10342 "};", 10343 Tab); 10344 } 10345 10346 TEST_F(FormatTest, ZeroTabWidth) { 10347 FormatStyle Tab = getLLVMStyleWithColumns(42); 10348 Tab.IndentWidth = 8; 10349 Tab.UseTab = FormatStyle::UT_Never; 10350 Tab.TabWidth = 0; 10351 EXPECT_EQ("void a(){\n" 10352 " // line starts with '\t'\n" 10353 "};", 10354 format("void a(){\n" 10355 "\t// line starts with '\t'\n" 10356 "};", 10357 Tab)); 10358 10359 EXPECT_EQ("void a(){\n" 10360 " // line starts with '\t'\n" 10361 "};", 10362 format("void a(){\n" 10363 "\t\t// line starts with '\t'\n" 10364 "};", 10365 Tab)); 10366 10367 Tab.UseTab = FormatStyle::UT_ForIndentation; 10368 EXPECT_EQ("void a(){\n" 10369 " // line starts with '\t'\n" 10370 "};", 10371 format("void a(){\n" 10372 "\t// line starts with '\t'\n" 10373 "};", 10374 Tab)); 10375 10376 EXPECT_EQ("void a(){\n" 10377 " // line starts with '\t'\n" 10378 "};", 10379 format("void a(){\n" 10380 "\t\t// line starts with '\t'\n" 10381 "};", 10382 Tab)); 10383 10384 Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation; 10385 EXPECT_EQ("void a(){\n" 10386 " // line starts with '\t'\n" 10387 "};", 10388 format("void a(){\n" 10389 "\t// line starts with '\t'\n" 10390 "};", 10391 Tab)); 10392 10393 EXPECT_EQ("void a(){\n" 10394 " // line starts with '\t'\n" 10395 "};", 10396 format("void a(){\n" 10397 "\t\t// line starts with '\t'\n" 10398 "};", 10399 Tab)); 10400 10401 Tab.UseTab = FormatStyle::UT_Always; 10402 EXPECT_EQ("void a(){\n" 10403 "// line starts with '\t'\n" 10404 "};", 10405 format("void a(){\n" 10406 "\t// line starts with '\t'\n" 10407 "};", 10408 Tab)); 10409 10410 EXPECT_EQ("void a(){\n" 10411 "// line starts with '\t'\n" 10412 "};", 10413 format("void a(){\n" 10414 "\t\t// line starts with '\t'\n" 10415 "};", 10416 Tab)); 10417 } 10418 10419 TEST_F(FormatTest, CalculatesOriginalColumn) { 10420 EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10421 "q\"; /* some\n" 10422 " comment */", 10423 format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10424 "q\"; /* some\n" 10425 " comment */", 10426 getLLVMStyle())); 10427 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10428 "/* some\n" 10429 " comment */", 10430 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n" 10431 " /* some\n" 10432 " comment */", 10433 getLLVMStyle())); 10434 EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10435 "qqq\n" 10436 "/* some\n" 10437 " comment */", 10438 format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10439 "qqq\n" 10440 " /* some\n" 10441 " comment */", 10442 getLLVMStyle())); 10443 EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10444 "wwww; /* some\n" 10445 " comment */", 10446 format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" 10447 "wwww; /* some\n" 10448 " comment */", 10449 getLLVMStyle())); 10450 } 10451 10452 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) { 10453 FormatStyle NoSpace = getLLVMStyle(); 10454 NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never; 10455 10456 verifyFormat("while(true)\n" 10457 " continue;", 10458 NoSpace); 10459 verifyFormat("for(;;)\n" 10460 " continue;", 10461 NoSpace); 10462 verifyFormat("if(true)\n" 10463 " f();\n" 10464 "else if(true)\n" 10465 " f();", 10466 NoSpace); 10467 verifyFormat("do {\n" 10468 " do_something();\n" 10469 "} while(something());", 10470 NoSpace); 10471 verifyFormat("switch(x) {\n" 10472 "default:\n" 10473 " break;\n" 10474 "}", 10475 NoSpace); 10476 verifyFormat("auto i = std::make_unique<int>(5);", NoSpace); 10477 verifyFormat("size_t x = sizeof(x);", NoSpace); 10478 verifyFormat("auto f(int x) -> decltype(x);", NoSpace); 10479 verifyFormat("int f(T x) noexcept(x.create());", NoSpace); 10480 verifyFormat("alignas(128) char a[128];", NoSpace); 10481 verifyFormat("size_t x = alignof(MyType);", NoSpace); 10482 verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace); 10483 verifyFormat("int f() throw(Deprecated);", NoSpace); 10484 verifyFormat("typedef void (*cb)(int);", NoSpace); 10485 verifyFormat("T A::operator()();", NoSpace); 10486 verifyFormat("X A::operator++(T);", NoSpace); 10487 verifyFormat("auto lambda = []() { return 0; };", NoSpace); 10488 10489 FormatStyle Space = getLLVMStyle(); 10490 Space.SpaceBeforeParens = FormatStyle::SBPO_Always; 10491 10492 verifyFormat("int f ();", Space); 10493 verifyFormat("void f (int a, T b) {\n" 10494 " while (true)\n" 10495 " continue;\n" 10496 "}", 10497 Space); 10498 verifyFormat("if (true)\n" 10499 " f ();\n" 10500 "else if (true)\n" 10501 " f ();", 10502 Space); 10503 verifyFormat("do {\n" 10504 " do_something ();\n" 10505 "} while (something ());", 10506 Space); 10507 verifyFormat("switch (x) {\n" 10508 "default:\n" 10509 " break;\n" 10510 "}", 10511 Space); 10512 verifyFormat("A::A () : a (1) {}", Space); 10513 verifyFormat("void f () __attribute__ ((asdf));", Space); 10514 verifyFormat("*(&a + 1);\n" 10515 "&((&a)[1]);\n" 10516 "a[(b + c) * d];\n" 10517 "(((a + 1) * 2) + 3) * 4;", 10518 Space); 10519 verifyFormat("#define A(x) x", Space); 10520 verifyFormat("#define A (x) x", Space); 10521 verifyFormat("#if defined(x)\n" 10522 "#endif", 10523 Space); 10524 verifyFormat("auto i = std::make_unique<int> (5);", Space); 10525 verifyFormat("size_t x = sizeof (x);", Space); 10526 verifyFormat("auto f (int x) -> decltype (x);", Space); 10527 verifyFormat("int f (T x) noexcept (x.create ());", Space); 10528 verifyFormat("alignas (128) char a[128];", Space); 10529 verifyFormat("size_t x = alignof (MyType);", Space); 10530 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space); 10531 verifyFormat("int f () throw (Deprecated);", Space); 10532 verifyFormat("typedef void (*cb) (int);", Space); 10533 verifyFormat("T A::operator() ();", Space); 10534 verifyFormat("X A::operator++ (T);", Space); 10535 verifyFormat("auto lambda = [] () { return 0; };", Space); 10536 verifyFormat("int x = int (y);", Space); 10537 10538 FormatStyle SomeSpace = getLLVMStyle(); 10539 SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses; 10540 10541 verifyFormat("[]() -> float {}", SomeSpace); 10542 verifyFormat("[] (auto foo) {}", SomeSpace); 10543 verifyFormat("[foo]() -> int {}", SomeSpace); 10544 verifyFormat("int f();", SomeSpace); 10545 verifyFormat("void f (int a, T b) {\n" 10546 " while (true)\n" 10547 " continue;\n" 10548 "}", 10549 SomeSpace); 10550 verifyFormat("if (true)\n" 10551 " f();\n" 10552 "else if (true)\n" 10553 " f();", 10554 SomeSpace); 10555 verifyFormat("do {\n" 10556 " do_something();\n" 10557 "} while (something());", 10558 SomeSpace); 10559 verifyFormat("switch (x) {\n" 10560 "default:\n" 10561 " break;\n" 10562 "}", 10563 SomeSpace); 10564 verifyFormat("A::A() : a (1) {}", SomeSpace); 10565 verifyFormat("void f() __attribute__ ((asdf));", SomeSpace); 10566 verifyFormat("*(&a + 1);\n" 10567 "&((&a)[1]);\n" 10568 "a[(b + c) * d];\n" 10569 "(((a + 1) * 2) + 3) * 4;", 10570 SomeSpace); 10571 verifyFormat("#define A(x) x", SomeSpace); 10572 verifyFormat("#define A (x) x", SomeSpace); 10573 verifyFormat("#if defined(x)\n" 10574 "#endif", 10575 SomeSpace); 10576 verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace); 10577 verifyFormat("size_t x = sizeof (x);", SomeSpace); 10578 verifyFormat("auto f (int x) -> decltype (x);", SomeSpace); 10579 verifyFormat("int f (T x) noexcept (x.create());", SomeSpace); 10580 verifyFormat("alignas (128) char a[128];", SomeSpace); 10581 verifyFormat("size_t x = alignof (MyType);", SomeSpace); 10582 verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", 10583 SomeSpace); 10584 verifyFormat("int f() throw (Deprecated);", SomeSpace); 10585 verifyFormat("typedef void (*cb) (int);", SomeSpace); 10586 verifyFormat("T A::operator()();", SomeSpace); 10587 verifyFormat("X A::operator++ (T);", SomeSpace); 10588 verifyFormat("int x = int (y);", SomeSpace); 10589 verifyFormat("auto lambda = []() { return 0; };", SomeSpace); 10590 } 10591 10592 TEST_F(FormatTest, SpaceAfterLogicalNot) { 10593 FormatStyle Spaces = getLLVMStyle(); 10594 Spaces.SpaceAfterLogicalNot = true; 10595 10596 verifyFormat("bool x = ! y", Spaces); 10597 verifyFormat("if (! isFailure())", Spaces); 10598 verifyFormat("if (! (a && b))", Spaces); 10599 verifyFormat("\"Error!\"", Spaces); 10600 verifyFormat("! ! x", Spaces); 10601 } 10602 10603 TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 10604 FormatStyle Spaces = getLLVMStyle(); 10605 10606 Spaces.SpacesInParentheses = true; 10607 verifyFormat("do_something( ::globalVar );", Spaces); 10608 verifyFormat("call( x, y, z );", Spaces); 10609 verifyFormat("call();", Spaces); 10610 verifyFormat("std::function<void( int, int )> callback;", Spaces); 10611 verifyFormat("void inFunction() { std::function<void( int, int )> fct; }", 10612 Spaces); 10613 verifyFormat("while ( (bool)1 )\n" 10614 " continue;", 10615 Spaces); 10616 verifyFormat("for ( ;; )\n" 10617 " continue;", 10618 Spaces); 10619 verifyFormat("if ( true )\n" 10620 " f();\n" 10621 "else if ( true )\n" 10622 " f();", 10623 Spaces); 10624 verifyFormat("do {\n" 10625 " do_something( (int)i );\n" 10626 "} while ( something() );", 10627 Spaces); 10628 verifyFormat("switch ( x ) {\n" 10629 "default:\n" 10630 " break;\n" 10631 "}", 10632 Spaces); 10633 10634 Spaces.SpacesInParentheses = false; 10635 Spaces.SpacesInCStyleCastParentheses = true; 10636 verifyFormat("Type *A = ( Type * )P;", Spaces); 10637 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 10638 verifyFormat("x = ( int32 )y;", Spaces); 10639 verifyFormat("int a = ( int )(2.0f);", Spaces); 10640 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 10641 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 10642 verifyFormat("#define x (( int )-1)", Spaces); 10643 10644 // Run the first set of tests again with: 10645 Spaces.SpacesInParentheses = false; 10646 Spaces.SpaceInEmptyParentheses = true; 10647 Spaces.SpacesInCStyleCastParentheses = true; 10648 verifyFormat("call(x, y, z);", Spaces); 10649 verifyFormat("call( );", Spaces); 10650 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10651 verifyFormat("while (( bool )1)\n" 10652 " continue;", 10653 Spaces); 10654 verifyFormat("for (;;)\n" 10655 " continue;", 10656 Spaces); 10657 verifyFormat("if (true)\n" 10658 " f( );\n" 10659 "else if (true)\n" 10660 " f( );", 10661 Spaces); 10662 verifyFormat("do {\n" 10663 " do_something(( int )i);\n" 10664 "} while (something( ));", 10665 Spaces); 10666 verifyFormat("switch (x) {\n" 10667 "default:\n" 10668 " break;\n" 10669 "}", 10670 Spaces); 10671 10672 // Run the first set of tests again with: 10673 Spaces.SpaceAfterCStyleCast = true; 10674 verifyFormat("call(x, y, z);", Spaces); 10675 verifyFormat("call( );", Spaces); 10676 verifyFormat("std::function<void(int, int)> callback;", Spaces); 10677 verifyFormat("while (( bool ) 1)\n" 10678 " continue;", 10679 Spaces); 10680 verifyFormat("for (;;)\n" 10681 " continue;", 10682 Spaces); 10683 verifyFormat("if (true)\n" 10684 " f( );\n" 10685 "else if (true)\n" 10686 " f( );", 10687 Spaces); 10688 verifyFormat("do {\n" 10689 " do_something(( int ) i);\n" 10690 "} while (something( ));", 10691 Spaces); 10692 verifyFormat("switch (x) {\n" 10693 "default:\n" 10694 " break;\n" 10695 "}", 10696 Spaces); 10697 10698 // Run subset of tests again with: 10699 Spaces.SpacesInCStyleCastParentheses = false; 10700 Spaces.SpaceAfterCStyleCast = true; 10701 verifyFormat("while ((bool) 1)\n" 10702 " continue;", 10703 Spaces); 10704 verifyFormat("do {\n" 10705 " do_something((int) i);\n" 10706 "} while (something( ));", 10707 Spaces); 10708 } 10709 10710 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) { 10711 verifyFormat("int a[5];"); 10712 verifyFormat("a[3] += 42;"); 10713 10714 FormatStyle Spaces = getLLVMStyle(); 10715 Spaces.SpacesInSquareBrackets = true; 10716 // Not lambdas. 10717 verifyFormat("int a[ 5 ];", Spaces); 10718 verifyFormat("a[ 3 ] += 42;", Spaces); 10719 verifyFormat("constexpr char hello[]{\"hello\"};", Spaces); 10720 verifyFormat("double &operator[](int i) { return 0; }\n" 10721 "int i;", 10722 Spaces); 10723 verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces); 10724 verifyFormat("int i = a[ a ][ a ]->f();", Spaces); 10725 verifyFormat("int i = (*b)[ a ]->f();", Spaces); 10726 // Lambdas. 10727 verifyFormat("int c = []() -> int { return 2; }();\n", Spaces); 10728 verifyFormat("return [ i, args... ] {};", Spaces); 10729 verifyFormat("int foo = [ &bar ]() {};", Spaces); 10730 verifyFormat("int foo = [ = ]() {};", Spaces); 10731 verifyFormat("int foo = [ & ]() {};", Spaces); 10732 verifyFormat("int foo = [ =, &bar ]() {};", Spaces); 10733 verifyFormat("int foo = [ &bar, = ]() {};", Spaces); 10734 } 10735 10736 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) { 10737 FormatStyle NoSpaceStyle = getLLVMStyle(); 10738 verifyFormat("int a[5];", NoSpaceStyle); 10739 verifyFormat("a[3] += 42;", NoSpaceStyle); 10740 10741 verifyFormat("int a[1];", NoSpaceStyle); 10742 verifyFormat("int 1 [a];", NoSpaceStyle); 10743 verifyFormat("int a[1][2];", NoSpaceStyle); 10744 verifyFormat("a[7] = 5;", NoSpaceStyle); 10745 verifyFormat("int a = (f())[23];", NoSpaceStyle); 10746 verifyFormat("f([] {})", NoSpaceStyle); 10747 10748 FormatStyle Space = getLLVMStyle(); 10749 Space.SpaceBeforeSquareBrackets = true; 10750 verifyFormat("int c = []() -> int { return 2; }();\n", Space); 10751 verifyFormat("return [i, args...] {};", Space); 10752 10753 verifyFormat("int a [5];", Space); 10754 verifyFormat("a [3] += 42;", Space); 10755 verifyFormat("constexpr char hello []{\"hello\"};", Space); 10756 verifyFormat("double &operator[](int i) { return 0; }\n" 10757 "int i;", 10758 Space); 10759 verifyFormat("std::unique_ptr<int []> foo() {}", Space); 10760 verifyFormat("int i = a [a][a]->f();", Space); 10761 verifyFormat("int i = (*b) [a]->f();", Space); 10762 10763 verifyFormat("int a [1];", Space); 10764 verifyFormat("int 1 [a];", Space); 10765 verifyFormat("int a [1][2];", Space); 10766 verifyFormat("a [7] = 5;", Space); 10767 verifyFormat("int a = (f()) [23];", Space); 10768 verifyFormat("f([] {})", Space); 10769 } 10770 10771 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) { 10772 verifyFormat("int a = 5;"); 10773 verifyFormat("a += 42;"); 10774 verifyFormat("a or_eq 8;"); 10775 10776 FormatStyle Spaces = getLLVMStyle(); 10777 Spaces.SpaceBeforeAssignmentOperators = false; 10778 verifyFormat("int a= 5;", Spaces); 10779 verifyFormat("a+= 42;", Spaces); 10780 verifyFormat("a or_eq 8;", Spaces); 10781 } 10782 10783 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) { 10784 verifyFormat("class Foo : public Bar {};"); 10785 verifyFormat("Foo::Foo() : foo(1) {}"); 10786 verifyFormat("for (auto a : b) {\n}"); 10787 verifyFormat("int x = a ? b : c;"); 10788 verifyFormat("{\n" 10789 "label0:\n" 10790 " int x = 0;\n" 10791 "}"); 10792 verifyFormat("switch (x) {\n" 10793 "case 1:\n" 10794 "default:\n" 10795 "}"); 10796 10797 FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30); 10798 CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false; 10799 verifyFormat("class Foo : public Bar {};", CtorInitializerStyle); 10800 verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle); 10801 verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle); 10802 verifyFormat("int x = a ? b : c;", CtorInitializerStyle); 10803 verifyFormat("{\n" 10804 "label1:\n" 10805 " int x = 0;\n" 10806 "}", 10807 CtorInitializerStyle); 10808 verifyFormat("switch (x) {\n" 10809 "case 1:\n" 10810 "default:\n" 10811 "}", 10812 CtorInitializerStyle); 10813 CtorInitializerStyle.BreakConstructorInitializers = 10814 FormatStyle::BCIS_AfterColon; 10815 verifyFormat("Fooooooooooo::Fooooooooooo():\n" 10816 " aaaaaaaaaaaaaaaa(1),\n" 10817 " bbbbbbbbbbbbbbbb(2) {}", 10818 CtorInitializerStyle); 10819 CtorInitializerStyle.BreakConstructorInitializers = 10820 FormatStyle::BCIS_BeforeComma; 10821 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10822 " : aaaaaaaaaaaaaaaa(1)\n" 10823 " , bbbbbbbbbbbbbbbb(2) {}", 10824 CtorInitializerStyle); 10825 CtorInitializerStyle.BreakConstructorInitializers = 10826 FormatStyle::BCIS_BeforeColon; 10827 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10828 " : aaaaaaaaaaaaaaaa(1),\n" 10829 " bbbbbbbbbbbbbbbb(2) {}", 10830 CtorInitializerStyle); 10831 CtorInitializerStyle.ConstructorInitializerIndentWidth = 0; 10832 verifyFormat("Fooooooooooo::Fooooooooooo()\n" 10833 ": aaaaaaaaaaaaaaaa(1),\n" 10834 " bbbbbbbbbbbbbbbb(2) {}", 10835 CtorInitializerStyle); 10836 10837 FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30); 10838 InheritanceStyle.SpaceBeforeInheritanceColon = false; 10839 verifyFormat("class Foo: public Bar {};", InheritanceStyle); 10840 verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle); 10841 verifyFormat("for (auto a : b) {\n}", InheritanceStyle); 10842 verifyFormat("int x = a ? b : c;", InheritanceStyle); 10843 verifyFormat("{\n" 10844 "label2:\n" 10845 " int x = 0;\n" 10846 "}", 10847 InheritanceStyle); 10848 verifyFormat("switch (x) {\n" 10849 "case 1:\n" 10850 "default:\n" 10851 "}", 10852 InheritanceStyle); 10853 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon; 10854 verifyFormat("class Foooooooooooooooooooooo:\n" 10855 " public aaaaaaaaaaaaaaaaaa,\n" 10856 " public bbbbbbbbbbbbbbbbbb {\n" 10857 "}", 10858 InheritanceStyle); 10859 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma; 10860 verifyFormat("class Foooooooooooooooooooooo\n" 10861 " : public aaaaaaaaaaaaaaaaaa\n" 10862 " , public bbbbbbbbbbbbbbbbbb {\n" 10863 "}", 10864 InheritanceStyle); 10865 InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 10866 verifyFormat("class Foooooooooooooooooooooo\n" 10867 " : public aaaaaaaaaaaaaaaaaa,\n" 10868 " public bbbbbbbbbbbbbbbbbb {\n" 10869 "}", 10870 InheritanceStyle); 10871 InheritanceStyle.ConstructorInitializerIndentWidth = 0; 10872 verifyFormat("class Foooooooooooooooooooooo\n" 10873 ": public aaaaaaaaaaaaaaaaaa,\n" 10874 " public bbbbbbbbbbbbbbbbbb {}", 10875 InheritanceStyle); 10876 10877 FormatStyle ForLoopStyle = getLLVMStyle(); 10878 ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false; 10879 verifyFormat("class Foo : public Bar {};", ForLoopStyle); 10880 verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle); 10881 verifyFormat("for (auto a: b) {\n}", ForLoopStyle); 10882 verifyFormat("int x = a ? b : c;", ForLoopStyle); 10883 verifyFormat("{\n" 10884 "label2:\n" 10885 " int x = 0;\n" 10886 "}", 10887 ForLoopStyle); 10888 verifyFormat("switch (x) {\n" 10889 "case 1:\n" 10890 "default:\n" 10891 "}", 10892 ForLoopStyle); 10893 10894 FormatStyle NoSpaceStyle = getLLVMStyle(); 10895 NoSpaceStyle.SpaceBeforeCtorInitializerColon = false; 10896 NoSpaceStyle.SpaceBeforeInheritanceColon = false; 10897 NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false; 10898 verifyFormat("class Foo: public Bar {};", NoSpaceStyle); 10899 verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle); 10900 verifyFormat("for (auto a: b) {\n}", NoSpaceStyle); 10901 verifyFormat("int x = a ? b : c;", NoSpaceStyle); 10902 verifyFormat("{\n" 10903 "label3:\n" 10904 " int x = 0;\n" 10905 "}", 10906 NoSpaceStyle); 10907 verifyFormat("switch (x) {\n" 10908 "case 1:\n" 10909 "default:\n" 10910 "}", 10911 NoSpaceStyle); 10912 } 10913 10914 TEST_F(FormatTest, AlignConsecutiveMacros) { 10915 FormatStyle Style = getLLVMStyle(); 10916 Style.AlignConsecutiveAssignments = true; 10917 Style.AlignConsecutiveDeclarations = true; 10918 Style.AlignConsecutiveMacros = false; 10919 10920 verifyFormat("#define a 3\n" 10921 "#define bbbb 4\n" 10922 "#define ccc (5)", 10923 Style); 10924 10925 verifyFormat("#define f(x) (x * x)\n" 10926 "#define fff(x, y, z) (x * y + z)\n" 10927 "#define ffff(x, y) (x - y)", 10928 Style); 10929 10930 verifyFormat("#define foo(x, y) (x + y)\n" 10931 "#define bar (5, 6)(2 + 2)", 10932 Style); 10933 10934 verifyFormat("#define a 3\n" 10935 "#define bbbb 4\n" 10936 "#define ccc (5)\n" 10937 "#define f(x) (x * x)\n" 10938 "#define fff(x, y, z) (x * y + z)\n" 10939 "#define ffff(x, y) (x - y)", 10940 Style); 10941 10942 Style.AlignConsecutiveMacros = true; 10943 verifyFormat("#define a 3\n" 10944 "#define bbbb 4\n" 10945 "#define ccc (5)", 10946 Style); 10947 10948 verifyFormat("#define f(x) (x * x)\n" 10949 "#define fff(x, y, z) (x * y + z)\n" 10950 "#define ffff(x, y) (x - y)", 10951 Style); 10952 10953 verifyFormat("#define foo(x, y) (x + y)\n" 10954 "#define bar (5, 6)(2 + 2)", 10955 Style); 10956 10957 verifyFormat("#define a 3\n" 10958 "#define bbbb 4\n" 10959 "#define ccc (5)\n" 10960 "#define f(x) (x * x)\n" 10961 "#define fff(x, y, z) (x * y + z)\n" 10962 "#define ffff(x, y) (x - y)", 10963 Style); 10964 10965 verifyFormat("#define a 5\n" 10966 "#define foo(x, y) (x + y)\n" 10967 "#define CCC (6)\n" 10968 "auto lambda = []() {\n" 10969 " auto ii = 0;\n" 10970 " float j = 0;\n" 10971 " return 0;\n" 10972 "};\n" 10973 "int i = 0;\n" 10974 "float i2 = 0;\n" 10975 "auto v = type{\n" 10976 " i = 1, //\n" 10977 " (i = 2), //\n" 10978 " i = 3 //\n" 10979 "};", 10980 Style); 10981 10982 Style.AlignConsecutiveMacros = false; 10983 Style.ColumnLimit = 20; 10984 10985 verifyFormat("#define a \\\n" 10986 " \"aabbbbbbbbbbbb\"\n" 10987 "#define D \\\n" 10988 " \"aabbbbbbbbbbbb\" \\\n" 10989 " \"ccddeeeeeeeee\"\n" 10990 "#define B \\\n" 10991 " \"QQQQQQQQQQQQQ\" \\\n" 10992 " \"FFFFFFFFFFFFF\" \\\n" 10993 " \"LLLLLLLL\"\n", 10994 Style); 10995 10996 Style.AlignConsecutiveMacros = true; 10997 verifyFormat("#define a \\\n" 10998 " \"aabbbbbbbbbbbb\"\n" 10999 "#define D \\\n" 11000 " \"aabbbbbbbbbbbb\" \\\n" 11001 " \"ccddeeeeeeeee\"\n" 11002 "#define B \\\n" 11003 " \"QQQQQQQQQQQQQ\" \\\n" 11004 " \"FFFFFFFFFFFFF\" \\\n" 11005 " \"LLLLLLLL\"\n", 11006 Style); 11007 } 11008 11009 TEST_F(FormatTest, AlignConsecutiveAssignments) { 11010 FormatStyle Alignment = getLLVMStyle(); 11011 Alignment.AlignConsecutiveMacros = true; 11012 Alignment.AlignConsecutiveAssignments = false; 11013 verifyFormat("int a = 5;\n" 11014 "int oneTwoThree = 123;", 11015 Alignment); 11016 verifyFormat("int a = 5;\n" 11017 "int oneTwoThree = 123;", 11018 Alignment); 11019 11020 Alignment.AlignConsecutiveAssignments = true; 11021 verifyFormat("int a = 5;\n" 11022 "int oneTwoThree = 123;", 11023 Alignment); 11024 verifyFormat("int a = method();\n" 11025 "int oneTwoThree = 133;", 11026 Alignment); 11027 verifyFormat("a &= 5;\n" 11028 "bcd *= 5;\n" 11029 "ghtyf += 5;\n" 11030 "dvfvdb -= 5;\n" 11031 "a /= 5;\n" 11032 "vdsvsv %= 5;\n" 11033 "sfdbddfbdfbb ^= 5;\n" 11034 "dvsdsv |= 5;\n" 11035 "int dsvvdvsdvvv = 123;", 11036 Alignment); 11037 verifyFormat("int i = 1, j = 10;\n" 11038 "something = 2000;", 11039 Alignment); 11040 verifyFormat("something = 2000;\n" 11041 "int i = 1, j = 10;\n", 11042 Alignment); 11043 verifyFormat("something = 2000;\n" 11044 "another = 911;\n" 11045 "int i = 1, j = 10;\n" 11046 "oneMore = 1;\n" 11047 "i = 2;", 11048 Alignment); 11049 verifyFormat("int a = 5;\n" 11050 "int one = 1;\n" 11051 "method();\n" 11052 "int oneTwoThree = 123;\n" 11053 "int oneTwo = 12;", 11054 Alignment); 11055 verifyFormat("int oneTwoThree = 123;\n" 11056 "int oneTwo = 12;\n" 11057 "method();\n", 11058 Alignment); 11059 verifyFormat("int oneTwoThree = 123; // comment\n" 11060 "int oneTwo = 12; // comment", 11061 Alignment); 11062 EXPECT_EQ("int a = 5;\n" 11063 "\n" 11064 "int oneTwoThree = 123;", 11065 format("int a = 5;\n" 11066 "\n" 11067 "int oneTwoThree= 123;", 11068 Alignment)); 11069 EXPECT_EQ("int a = 5;\n" 11070 "int one = 1;\n" 11071 "\n" 11072 "int oneTwoThree = 123;", 11073 format("int a = 5;\n" 11074 "int one = 1;\n" 11075 "\n" 11076 "int oneTwoThree = 123;", 11077 Alignment)); 11078 EXPECT_EQ("int a = 5;\n" 11079 "int one = 1;\n" 11080 "\n" 11081 "int oneTwoThree = 123;\n" 11082 "int oneTwo = 12;", 11083 format("int a = 5;\n" 11084 "int one = 1;\n" 11085 "\n" 11086 "int oneTwoThree = 123;\n" 11087 "int oneTwo = 12;", 11088 Alignment)); 11089 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11090 verifyFormat("#define A \\\n" 11091 " int aaaa = 12; \\\n" 11092 " int b = 23; \\\n" 11093 " int ccc = 234; \\\n" 11094 " int dddddddddd = 2345;", 11095 Alignment); 11096 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11097 verifyFormat("#define A \\\n" 11098 " int aaaa = 12; \\\n" 11099 " int b = 23; \\\n" 11100 " int ccc = 234; \\\n" 11101 " int dddddddddd = 2345;", 11102 Alignment); 11103 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11104 verifyFormat("#define A " 11105 " \\\n" 11106 " int aaaa = 12; " 11107 " \\\n" 11108 " int b = 23; " 11109 " \\\n" 11110 " int ccc = 234; " 11111 " \\\n" 11112 " int dddddddddd = 2345;", 11113 Alignment); 11114 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11115 "k = 4, int l = 5,\n" 11116 " int m = 6) {\n" 11117 " int j = 10;\n" 11118 " otherThing = 1;\n" 11119 "}", 11120 Alignment); 11121 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11122 " int i = 1;\n" 11123 " int j = 2;\n" 11124 " int big = 10000;\n" 11125 "}", 11126 Alignment); 11127 verifyFormat("class C {\n" 11128 "public:\n" 11129 " int i = 1;\n" 11130 " virtual void f() = 0;\n" 11131 "};", 11132 Alignment); 11133 verifyFormat("int i = 1;\n" 11134 "if (SomeType t = getSomething()) {\n" 11135 "}\n" 11136 "int j = 2;\n" 11137 "int big = 10000;", 11138 Alignment); 11139 verifyFormat("int j = 7;\n" 11140 "for (int k = 0; k < N; ++k) {\n" 11141 "}\n" 11142 "int j = 2;\n" 11143 "int big = 10000;\n" 11144 "}", 11145 Alignment); 11146 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11147 verifyFormat("int i = 1;\n" 11148 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11149 " = someLooooooooooooooooongFunction();\n" 11150 "int j = 2;", 11151 Alignment); 11152 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11153 verifyFormat("int i = 1;\n" 11154 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11155 " someLooooooooooooooooongFunction();\n" 11156 "int j = 2;", 11157 Alignment); 11158 11159 verifyFormat("auto lambda = []() {\n" 11160 " auto i = 0;\n" 11161 " return 0;\n" 11162 "};\n" 11163 "int i = 0;\n" 11164 "auto v = type{\n" 11165 " i = 1, //\n" 11166 " (i = 2), //\n" 11167 " i = 3 //\n" 11168 "};", 11169 Alignment); 11170 11171 verifyFormat( 11172 "int i = 1;\n" 11173 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11174 " loooooooooooooooooooooongParameterB);\n" 11175 "int j = 2;", 11176 Alignment); 11177 11178 verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n" 11179 " typename B = very_long_type_name_1,\n" 11180 " typename T_2 = very_long_type_name_2>\n" 11181 "auto foo() {}\n", 11182 Alignment); 11183 verifyFormat("int a, b = 1;\n" 11184 "int c = 2;\n" 11185 "int dd = 3;\n", 11186 Alignment); 11187 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11188 "float b[1][] = {{3.f}};\n", 11189 Alignment); 11190 verifyFormat("for (int i = 0; i < 1; i++)\n" 11191 " int x = 1;\n", 11192 Alignment); 11193 verifyFormat("for (i = 0; i < 1; i++)\n" 11194 " x = 1;\n" 11195 "y = 1;\n", 11196 Alignment); 11197 } 11198 11199 TEST_F(FormatTest, AlignConsecutiveDeclarations) { 11200 FormatStyle Alignment = getLLVMStyle(); 11201 Alignment.AlignConsecutiveMacros = true; 11202 Alignment.AlignConsecutiveDeclarations = false; 11203 verifyFormat("float const a = 5;\n" 11204 "int oneTwoThree = 123;", 11205 Alignment); 11206 verifyFormat("int a = 5;\n" 11207 "float const oneTwoThree = 123;", 11208 Alignment); 11209 11210 Alignment.AlignConsecutiveDeclarations = true; 11211 verifyFormat("float const a = 5;\n" 11212 "int oneTwoThree = 123;", 11213 Alignment); 11214 verifyFormat("int a = method();\n" 11215 "float const oneTwoThree = 133;", 11216 Alignment); 11217 verifyFormat("int i = 1, j = 10;\n" 11218 "something = 2000;", 11219 Alignment); 11220 verifyFormat("something = 2000;\n" 11221 "int i = 1, j = 10;\n", 11222 Alignment); 11223 verifyFormat("float something = 2000;\n" 11224 "double another = 911;\n" 11225 "int i = 1, j = 10;\n" 11226 "const int *oneMore = 1;\n" 11227 "unsigned i = 2;", 11228 Alignment); 11229 verifyFormat("float a = 5;\n" 11230 "int one = 1;\n" 11231 "method();\n" 11232 "const double oneTwoThree = 123;\n" 11233 "const unsigned int oneTwo = 12;", 11234 Alignment); 11235 verifyFormat("int oneTwoThree{0}; // comment\n" 11236 "unsigned oneTwo; // comment", 11237 Alignment); 11238 EXPECT_EQ("float const a = 5;\n" 11239 "\n" 11240 "int oneTwoThree = 123;", 11241 format("float const a = 5;\n" 11242 "\n" 11243 "int oneTwoThree= 123;", 11244 Alignment)); 11245 EXPECT_EQ("float a = 5;\n" 11246 "int one = 1;\n" 11247 "\n" 11248 "unsigned oneTwoThree = 123;", 11249 format("float a = 5;\n" 11250 "int one = 1;\n" 11251 "\n" 11252 "unsigned oneTwoThree = 123;", 11253 Alignment)); 11254 EXPECT_EQ("float a = 5;\n" 11255 "int one = 1;\n" 11256 "\n" 11257 "unsigned oneTwoThree = 123;\n" 11258 "int oneTwo = 12;", 11259 format("float a = 5;\n" 11260 "int one = 1;\n" 11261 "\n" 11262 "unsigned oneTwoThree = 123;\n" 11263 "int oneTwo = 12;", 11264 Alignment)); 11265 // Function prototype alignment 11266 verifyFormat("int a();\n" 11267 "double b();", 11268 Alignment); 11269 verifyFormat("int a(int x);\n" 11270 "double b();", 11271 Alignment); 11272 unsigned OldColumnLimit = Alignment.ColumnLimit; 11273 // We need to set ColumnLimit to zero, in order to stress nested alignments, 11274 // otherwise the function parameters will be re-flowed onto a single line. 11275 Alignment.ColumnLimit = 0; 11276 EXPECT_EQ("int a(int x,\n" 11277 " float y);\n" 11278 "double b(int x,\n" 11279 " double y);", 11280 format("int a(int x,\n" 11281 " float y);\n" 11282 "double b(int x,\n" 11283 " double y);", 11284 Alignment)); 11285 // This ensures that function parameters of function declarations are 11286 // correctly indented when their owning functions are indented. 11287 // The failure case here is for 'double y' to not be indented enough. 11288 EXPECT_EQ("double a(int x);\n" 11289 "int b(int y,\n" 11290 " double z);", 11291 format("double a(int x);\n" 11292 "int b(int y,\n" 11293 " double z);", 11294 Alignment)); 11295 // Set ColumnLimit low so that we induce wrapping immediately after 11296 // the function name and opening paren. 11297 Alignment.ColumnLimit = 13; 11298 verifyFormat("int function(\n" 11299 " int x,\n" 11300 " bool y);", 11301 Alignment); 11302 Alignment.ColumnLimit = OldColumnLimit; 11303 // Ensure function pointers don't screw up recursive alignment 11304 verifyFormat("int a(int x, void (*fp)(int y));\n" 11305 "double b();", 11306 Alignment); 11307 Alignment.AlignConsecutiveAssignments = true; 11308 // Ensure recursive alignment is broken by function braces, so that the 11309 // "a = 1" does not align with subsequent assignments inside the function 11310 // body. 11311 verifyFormat("int func(int a = 1) {\n" 11312 " int b = 2;\n" 11313 " int cc = 3;\n" 11314 "}", 11315 Alignment); 11316 verifyFormat("float something = 2000;\n" 11317 "double another = 911;\n" 11318 "int i = 1, j = 10;\n" 11319 "const int *oneMore = 1;\n" 11320 "unsigned i = 2;", 11321 Alignment); 11322 verifyFormat("int oneTwoThree = {0}; // comment\n" 11323 "unsigned oneTwo = 0; // comment", 11324 Alignment); 11325 // Make sure that scope is correctly tracked, in the absence of braces 11326 verifyFormat("for (int i = 0; i < n; i++)\n" 11327 " j = i;\n" 11328 "double x = 1;\n", 11329 Alignment); 11330 verifyFormat("if (int i = 0)\n" 11331 " j = i;\n" 11332 "double x = 1;\n", 11333 Alignment); 11334 // Ensure operator[] and operator() are comprehended 11335 verifyFormat("struct test {\n" 11336 " long long int foo();\n" 11337 " int operator[](int a);\n" 11338 " double bar();\n" 11339 "};\n", 11340 Alignment); 11341 verifyFormat("struct test {\n" 11342 " long long int foo();\n" 11343 " int operator()(int a);\n" 11344 " double bar();\n" 11345 "};\n", 11346 Alignment); 11347 EXPECT_EQ("void SomeFunction(int parameter = 0) {\n" 11348 " int const i = 1;\n" 11349 " int * j = 2;\n" 11350 " int big = 10000;\n" 11351 "\n" 11352 " unsigned oneTwoThree = 123;\n" 11353 " int oneTwo = 12;\n" 11354 " method();\n" 11355 " float k = 2;\n" 11356 " int ll = 10000;\n" 11357 "}", 11358 format("void SomeFunction(int parameter= 0) {\n" 11359 " int const i= 1;\n" 11360 " int *j=2;\n" 11361 " int big = 10000;\n" 11362 "\n" 11363 "unsigned oneTwoThree =123;\n" 11364 "int oneTwo = 12;\n" 11365 " method();\n" 11366 "float k= 2;\n" 11367 "int ll=10000;\n" 11368 "}", 11369 Alignment)); 11370 Alignment.AlignConsecutiveAssignments = false; 11371 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; 11372 verifyFormat("#define A \\\n" 11373 " int aaaa = 12; \\\n" 11374 " float b = 23; \\\n" 11375 " const int ccc = 234; \\\n" 11376 " unsigned dddddddddd = 2345;", 11377 Alignment); 11378 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left; 11379 verifyFormat("#define A \\\n" 11380 " int aaaa = 12; \\\n" 11381 " float b = 23; \\\n" 11382 " const int ccc = 234; \\\n" 11383 " unsigned dddddddddd = 2345;", 11384 Alignment); 11385 Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right; 11386 Alignment.ColumnLimit = 30; 11387 verifyFormat("#define A \\\n" 11388 " int aaaa = 12; \\\n" 11389 " float b = 23; \\\n" 11390 " const int ccc = 234; \\\n" 11391 " int dddddddddd = 2345;", 11392 Alignment); 11393 Alignment.ColumnLimit = 80; 11394 verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int " 11395 "k = 4, int l = 5,\n" 11396 " int m = 6) {\n" 11397 " const int j = 10;\n" 11398 " otherThing = 1;\n" 11399 "}", 11400 Alignment); 11401 verifyFormat("void SomeFunction(int parameter = 0) {\n" 11402 " int const i = 1;\n" 11403 " int * j = 2;\n" 11404 " int big = 10000;\n" 11405 "}", 11406 Alignment); 11407 verifyFormat("class C {\n" 11408 "public:\n" 11409 " int i = 1;\n" 11410 " virtual void f() = 0;\n" 11411 "};", 11412 Alignment); 11413 verifyFormat("float i = 1;\n" 11414 "if (SomeType t = getSomething()) {\n" 11415 "}\n" 11416 "const unsigned j = 2;\n" 11417 "int big = 10000;", 11418 Alignment); 11419 verifyFormat("float j = 7;\n" 11420 "for (int k = 0; k < N; ++k) {\n" 11421 "}\n" 11422 "unsigned j = 2;\n" 11423 "int big = 10000;\n" 11424 "}", 11425 Alignment); 11426 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 11427 verifyFormat("float i = 1;\n" 11428 "LooooooooooongType loooooooooooooooooooooongVariable\n" 11429 " = someLooooooooooooooooongFunction();\n" 11430 "int j = 2;", 11431 Alignment); 11432 Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 11433 verifyFormat("int i = 1;\n" 11434 "LooooooooooongType loooooooooooooooooooooongVariable =\n" 11435 " someLooooooooooooooooongFunction();\n" 11436 "int j = 2;", 11437 Alignment); 11438 11439 Alignment.AlignConsecutiveAssignments = true; 11440 verifyFormat("auto lambda = []() {\n" 11441 " auto ii = 0;\n" 11442 " float j = 0;\n" 11443 " return 0;\n" 11444 "};\n" 11445 "int i = 0;\n" 11446 "float i2 = 0;\n" 11447 "auto v = type{\n" 11448 " i = 1, //\n" 11449 " (i = 2), //\n" 11450 " i = 3 //\n" 11451 "};", 11452 Alignment); 11453 Alignment.AlignConsecutiveAssignments = false; 11454 11455 verifyFormat( 11456 "int i = 1;\n" 11457 "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n" 11458 " loooooooooooooooooooooongParameterB);\n" 11459 "int j = 2;", 11460 Alignment); 11461 11462 // Test interactions with ColumnLimit and AlignConsecutiveAssignments: 11463 // We expect declarations and assignments to align, as long as it doesn't 11464 // exceed the column limit, starting a new alignment sequence whenever it 11465 // happens. 11466 Alignment.AlignConsecutiveAssignments = true; 11467 Alignment.ColumnLimit = 30; 11468 verifyFormat("float ii = 1;\n" 11469 "unsigned j = 2;\n" 11470 "int someVerylongVariable = 1;\n" 11471 "AnotherLongType ll = 123456;\n" 11472 "VeryVeryLongType k = 2;\n" 11473 "int myvar = 1;", 11474 Alignment); 11475 Alignment.ColumnLimit = 80; 11476 Alignment.AlignConsecutiveAssignments = false; 11477 11478 verifyFormat( 11479 "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n" 11480 " typename LongType, typename B>\n" 11481 "auto foo() {}\n", 11482 Alignment); 11483 verifyFormat("float a, b = 1;\n" 11484 "int c = 2;\n" 11485 "int dd = 3;\n", 11486 Alignment); 11487 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11488 "float b[1][] = {{3.f}};\n", 11489 Alignment); 11490 Alignment.AlignConsecutiveAssignments = true; 11491 verifyFormat("float a, b = 1;\n" 11492 "int c = 2;\n" 11493 "int dd = 3;\n", 11494 Alignment); 11495 verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n" 11496 "float b[1][] = {{3.f}};\n", 11497 Alignment); 11498 Alignment.AlignConsecutiveAssignments = false; 11499 11500 Alignment.ColumnLimit = 30; 11501 Alignment.BinPackParameters = false; 11502 verifyFormat("void foo(float a,\n" 11503 " float b,\n" 11504 " int c,\n" 11505 " uint32_t *d) {\n" 11506 " int * e = 0;\n" 11507 " float f = 0;\n" 11508 " double g = 0;\n" 11509 "}\n" 11510 "void bar(ino_t a,\n" 11511 " int b,\n" 11512 " uint32_t *c,\n" 11513 " bool d) {}\n", 11514 Alignment); 11515 Alignment.BinPackParameters = true; 11516 Alignment.ColumnLimit = 80; 11517 11518 // Bug 33507 11519 Alignment.PointerAlignment = FormatStyle::PAS_Middle; 11520 verifyFormat( 11521 "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n" 11522 " static const Version verVs2017;\n" 11523 " return true;\n" 11524 "});\n", 11525 Alignment); 11526 Alignment.PointerAlignment = FormatStyle::PAS_Right; 11527 11528 // See llvm.org/PR35641 11529 Alignment.AlignConsecutiveDeclarations = true; 11530 verifyFormat("int func() { //\n" 11531 " int b;\n" 11532 " unsigned c;\n" 11533 "}", 11534 Alignment); 11535 11536 // See PR37175 11537 FormatStyle Style = getMozillaStyle(); 11538 Style.AlignConsecutiveDeclarations = true; 11539 EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n" 11540 "foo(int a);", 11541 format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style)); 11542 } 11543 11544 TEST_F(FormatTest, LinuxBraceBreaking) { 11545 FormatStyle LinuxBraceStyle = getLLVMStyle(); 11546 LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux; 11547 verifyFormat("namespace a\n" 11548 "{\n" 11549 "class A\n" 11550 "{\n" 11551 " void f()\n" 11552 " {\n" 11553 " if (true) {\n" 11554 " a();\n" 11555 " b();\n" 11556 " } else {\n" 11557 " a();\n" 11558 " }\n" 11559 " }\n" 11560 " void g() { return; }\n" 11561 "};\n" 11562 "struct B {\n" 11563 " int x;\n" 11564 "};\n" 11565 "} // namespace a\n", 11566 LinuxBraceStyle); 11567 verifyFormat("enum X {\n" 11568 " Y = 0,\n" 11569 "}\n", 11570 LinuxBraceStyle); 11571 verifyFormat("struct S {\n" 11572 " int Type;\n" 11573 " union {\n" 11574 " int x;\n" 11575 " double y;\n" 11576 " } Value;\n" 11577 " class C\n" 11578 " {\n" 11579 " MyFavoriteType Value;\n" 11580 " } Class;\n" 11581 "}\n", 11582 LinuxBraceStyle); 11583 } 11584 11585 TEST_F(FormatTest, MozillaBraceBreaking) { 11586 FormatStyle MozillaBraceStyle = getLLVMStyle(); 11587 MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla; 11588 MozillaBraceStyle.FixNamespaceComments = false; 11589 verifyFormat("namespace a {\n" 11590 "class A\n" 11591 "{\n" 11592 " void f()\n" 11593 " {\n" 11594 " if (true) {\n" 11595 " a();\n" 11596 " b();\n" 11597 " }\n" 11598 " }\n" 11599 " void g() { return; }\n" 11600 "};\n" 11601 "enum E\n" 11602 "{\n" 11603 " A,\n" 11604 " // foo\n" 11605 " B,\n" 11606 " C\n" 11607 "};\n" 11608 "struct B\n" 11609 "{\n" 11610 " int x;\n" 11611 "};\n" 11612 "}\n", 11613 MozillaBraceStyle); 11614 verifyFormat("struct S\n" 11615 "{\n" 11616 " int Type;\n" 11617 " union\n" 11618 " {\n" 11619 " int x;\n" 11620 " double y;\n" 11621 " } Value;\n" 11622 " class C\n" 11623 " {\n" 11624 " MyFavoriteType Value;\n" 11625 " } Class;\n" 11626 "}\n", 11627 MozillaBraceStyle); 11628 } 11629 11630 TEST_F(FormatTest, StroustrupBraceBreaking) { 11631 FormatStyle StroustrupBraceStyle = getLLVMStyle(); 11632 StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 11633 verifyFormat("namespace a {\n" 11634 "class A {\n" 11635 " void f()\n" 11636 " {\n" 11637 " if (true) {\n" 11638 " a();\n" 11639 " b();\n" 11640 " }\n" 11641 " }\n" 11642 " void g() { return; }\n" 11643 "};\n" 11644 "struct B {\n" 11645 " int x;\n" 11646 "};\n" 11647 "} // namespace a\n", 11648 StroustrupBraceStyle); 11649 11650 verifyFormat("void foo()\n" 11651 "{\n" 11652 " if (a) {\n" 11653 " a();\n" 11654 " }\n" 11655 " else {\n" 11656 " b();\n" 11657 " }\n" 11658 "}\n", 11659 StroustrupBraceStyle); 11660 11661 verifyFormat("#ifdef _DEBUG\n" 11662 "int foo(int i = 0)\n" 11663 "#else\n" 11664 "int foo(int i = 5)\n" 11665 "#endif\n" 11666 "{\n" 11667 " return i;\n" 11668 "}", 11669 StroustrupBraceStyle); 11670 11671 verifyFormat("void foo() {}\n" 11672 "void bar()\n" 11673 "#ifdef _DEBUG\n" 11674 "{\n" 11675 " foo();\n" 11676 "}\n" 11677 "#else\n" 11678 "{\n" 11679 "}\n" 11680 "#endif", 11681 StroustrupBraceStyle); 11682 11683 verifyFormat("void foobar() { int i = 5; }\n" 11684 "#ifdef _DEBUG\n" 11685 "void bar() {}\n" 11686 "#else\n" 11687 "void bar() { foobar(); }\n" 11688 "#endif", 11689 StroustrupBraceStyle); 11690 } 11691 11692 TEST_F(FormatTest, AllmanBraceBreaking) { 11693 FormatStyle AllmanBraceStyle = getLLVMStyle(); 11694 AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman; 11695 11696 EXPECT_EQ("namespace a\n" 11697 "{\n" 11698 "void f();\n" 11699 "void g();\n" 11700 "} // namespace a\n", 11701 format("namespace a\n" 11702 "{\n" 11703 "void f();\n" 11704 "void g();\n" 11705 "}\n", 11706 AllmanBraceStyle)); 11707 11708 verifyFormat("namespace a\n" 11709 "{\n" 11710 "class A\n" 11711 "{\n" 11712 " void f()\n" 11713 " {\n" 11714 " if (true)\n" 11715 " {\n" 11716 " a();\n" 11717 " b();\n" 11718 " }\n" 11719 " }\n" 11720 " void g() { return; }\n" 11721 "};\n" 11722 "struct B\n" 11723 "{\n" 11724 " int x;\n" 11725 "};\n" 11726 "union C\n" 11727 "{\n" 11728 "};\n" 11729 "} // namespace a", 11730 AllmanBraceStyle); 11731 11732 verifyFormat("void f()\n" 11733 "{\n" 11734 " if (true)\n" 11735 " {\n" 11736 " a();\n" 11737 " }\n" 11738 " else if (false)\n" 11739 " {\n" 11740 " b();\n" 11741 " }\n" 11742 " else\n" 11743 " {\n" 11744 " c();\n" 11745 " }\n" 11746 "}\n", 11747 AllmanBraceStyle); 11748 11749 verifyFormat("void f()\n" 11750 "{\n" 11751 " for (int i = 0; i < 10; ++i)\n" 11752 " {\n" 11753 " a();\n" 11754 " }\n" 11755 " while (false)\n" 11756 " {\n" 11757 " b();\n" 11758 " }\n" 11759 " do\n" 11760 " {\n" 11761 " c();\n" 11762 " } while (false)\n" 11763 "}\n", 11764 AllmanBraceStyle); 11765 11766 verifyFormat("void f(int a)\n" 11767 "{\n" 11768 " switch (a)\n" 11769 " {\n" 11770 " case 0:\n" 11771 " break;\n" 11772 " case 1:\n" 11773 " {\n" 11774 " break;\n" 11775 " }\n" 11776 " case 2:\n" 11777 " {\n" 11778 " }\n" 11779 " break;\n" 11780 " default:\n" 11781 " break;\n" 11782 " }\n" 11783 "}\n", 11784 AllmanBraceStyle); 11785 11786 verifyFormat("enum X\n" 11787 "{\n" 11788 " Y = 0,\n" 11789 "}\n", 11790 AllmanBraceStyle); 11791 verifyFormat("enum X\n" 11792 "{\n" 11793 " Y = 0\n" 11794 "}\n", 11795 AllmanBraceStyle); 11796 11797 verifyFormat("@interface BSApplicationController ()\n" 11798 "{\n" 11799 "@private\n" 11800 " id _extraIvar;\n" 11801 "}\n" 11802 "@end\n", 11803 AllmanBraceStyle); 11804 11805 verifyFormat("#ifdef _DEBUG\n" 11806 "int foo(int i = 0)\n" 11807 "#else\n" 11808 "int foo(int i = 5)\n" 11809 "#endif\n" 11810 "{\n" 11811 " return i;\n" 11812 "}", 11813 AllmanBraceStyle); 11814 11815 verifyFormat("void foo() {}\n" 11816 "void bar()\n" 11817 "#ifdef _DEBUG\n" 11818 "{\n" 11819 " foo();\n" 11820 "}\n" 11821 "#else\n" 11822 "{\n" 11823 "}\n" 11824 "#endif", 11825 AllmanBraceStyle); 11826 11827 verifyFormat("void foobar() { int i = 5; }\n" 11828 "#ifdef _DEBUG\n" 11829 "void bar() {}\n" 11830 "#else\n" 11831 "void bar() { foobar(); }\n" 11832 "#endif", 11833 AllmanBraceStyle); 11834 11835 // This shouldn't affect ObjC blocks.. 11836 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 11837 " // ...\n" 11838 " int i;\n" 11839 "}];", 11840 AllmanBraceStyle); 11841 verifyFormat("void (^block)(void) = ^{\n" 11842 " // ...\n" 11843 " int i;\n" 11844 "};", 11845 AllmanBraceStyle); 11846 // .. or dict literals. 11847 verifyFormat("void f()\n" 11848 "{\n" 11849 " // ...\n" 11850 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 11851 "}", 11852 AllmanBraceStyle); 11853 verifyFormat("void f()\n" 11854 "{\n" 11855 " // ...\n" 11856 " [object someMethod:@{a : @\"b\"}];\n" 11857 "}", 11858 AllmanBraceStyle); 11859 verifyFormat("int f()\n" 11860 "{ // comment\n" 11861 " return 42;\n" 11862 "}", 11863 AllmanBraceStyle); 11864 11865 AllmanBraceStyle.ColumnLimit = 19; 11866 verifyFormat("void f() { int i; }", AllmanBraceStyle); 11867 AllmanBraceStyle.ColumnLimit = 18; 11868 verifyFormat("void f()\n" 11869 "{\n" 11870 " int i;\n" 11871 "}", 11872 AllmanBraceStyle); 11873 AllmanBraceStyle.ColumnLimit = 80; 11874 11875 FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle; 11876 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 11877 FormatStyle::SIS_WithoutElse; 11878 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 11879 verifyFormat("void f(bool b)\n" 11880 "{\n" 11881 " if (b)\n" 11882 " {\n" 11883 " return;\n" 11884 " }\n" 11885 "}\n", 11886 BreakBeforeBraceShortIfs); 11887 verifyFormat("void f(bool b)\n" 11888 "{\n" 11889 " if constexpr (b)\n" 11890 " {\n" 11891 " return;\n" 11892 " }\n" 11893 "}\n", 11894 BreakBeforeBraceShortIfs); 11895 verifyFormat("void f(bool b)\n" 11896 "{\n" 11897 " if CONSTEXPR (b)\n" 11898 " {\n" 11899 " return;\n" 11900 " }\n" 11901 "}\n", 11902 BreakBeforeBraceShortIfs); 11903 verifyFormat("void f(bool b)\n" 11904 "{\n" 11905 " if (b) return;\n" 11906 "}\n", 11907 BreakBeforeBraceShortIfs); 11908 verifyFormat("void f(bool b)\n" 11909 "{\n" 11910 " if constexpr (b) return;\n" 11911 "}\n", 11912 BreakBeforeBraceShortIfs); 11913 verifyFormat("void f(bool b)\n" 11914 "{\n" 11915 " if CONSTEXPR (b) return;\n" 11916 "}\n", 11917 BreakBeforeBraceShortIfs); 11918 verifyFormat("void f(bool b)\n" 11919 "{\n" 11920 " while (b)\n" 11921 " {\n" 11922 " return;\n" 11923 " }\n" 11924 "}\n", 11925 BreakBeforeBraceShortIfs); 11926 } 11927 11928 TEST_F(FormatTest, WhitesmithsBraceBreaking) { 11929 FormatStyle WhitesmithsBraceStyle = getLLVMStyle(); 11930 WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; 11931 11932 // Make a few changes to the style for testing purposes 11933 WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine = 11934 FormatStyle::SFS_Empty; 11935 WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 11936 WhitesmithsBraceStyle.ColumnLimit = 0; 11937 11938 // FIXME: this test case can't decide whether there should be a blank line 11939 // after the ~D() line or not. It adds one if one doesn't exist in the test 11940 // and it removes the line if one exists. 11941 /* 11942 verifyFormat("class A;\n" 11943 "namespace B\n" 11944 " {\n" 11945 "class C;\n" 11946 "// Comment\n" 11947 "class D\n" 11948 " {\n" 11949 "public:\n" 11950 " D();\n" 11951 " ~D() {}\n" 11952 "private:\n" 11953 " enum E\n" 11954 " {\n" 11955 " F\n" 11956 " }\n" 11957 " };\n" 11958 " } // namespace B\n", 11959 WhitesmithsBraceStyle); 11960 */ 11961 11962 verifyFormat("namespace a\n" 11963 " {\n" 11964 "class A\n" 11965 " {\n" 11966 " void f()\n" 11967 " {\n" 11968 " if (true)\n" 11969 " {\n" 11970 " a();\n" 11971 " b();\n" 11972 " }\n" 11973 " }\n" 11974 " void g()\n" 11975 " {\n" 11976 " return;\n" 11977 " }\n" 11978 " };\n" 11979 "struct B\n" 11980 " {\n" 11981 " int x;\n" 11982 " };\n" 11983 " } // namespace a", 11984 WhitesmithsBraceStyle); 11985 11986 verifyFormat("void f()\n" 11987 " {\n" 11988 " if (true)\n" 11989 " {\n" 11990 " a();\n" 11991 " }\n" 11992 " else if (false)\n" 11993 " {\n" 11994 " b();\n" 11995 " }\n" 11996 " else\n" 11997 " {\n" 11998 " c();\n" 11999 " }\n" 12000 " }\n", 12001 WhitesmithsBraceStyle); 12002 12003 verifyFormat("void f()\n" 12004 " {\n" 12005 " for (int i = 0; i < 10; ++i)\n" 12006 " {\n" 12007 " a();\n" 12008 " }\n" 12009 " while (false)\n" 12010 " {\n" 12011 " b();\n" 12012 " }\n" 12013 " do\n" 12014 " {\n" 12015 " c();\n" 12016 " } while (false)\n" 12017 " }\n", 12018 WhitesmithsBraceStyle); 12019 12020 // FIXME: the block and the break under case 2 in this test don't get indented 12021 // correctly 12022 /* 12023 verifyFormat("void switchTest1(int a)\n" 12024 " {\n" 12025 " switch (a)\n" 12026 " {\n" 12027 " case 2:\n" 12028 " {\n" 12029 " }\n" 12030 " break;\n" 12031 " }\n" 12032 " }\n", 12033 WhitesmithsBraceStyle); 12034 */ 12035 12036 // FIXME: the block and the break under case 2 in this test don't get indented 12037 // correctly 12038 /* 12039 verifyFormat("void switchTest2(int a)\n" 12040 " {\n" 12041 " switch (a)\n" 12042 " {\n" 12043 " case 0:\n" 12044 " break;\n" 12045 " case 1:\n" 12046 " {\n" 12047 " break;\n" 12048 " }\n" 12049 " case 2:\n" 12050 " {\n" 12051 " }\n" 12052 " break;\n" 12053 " default:\n" 12054 " break;\n" 12055 " }\n" 12056 " }\n", 12057 WhitesmithsBraceStyle); 12058 */ 12059 12060 verifyFormat("enum X\n" 12061 " {\n" 12062 " Y = 0, // testing\n" 12063 " }\n", 12064 WhitesmithsBraceStyle); 12065 12066 verifyFormat("enum X\n" 12067 " {\n" 12068 " Y = 0\n" 12069 " }\n", 12070 WhitesmithsBraceStyle); 12071 verifyFormat("enum X\n" 12072 " {\n" 12073 " Y = 0,\n" 12074 " Z = 1\n" 12075 " };\n", 12076 WhitesmithsBraceStyle); 12077 12078 verifyFormat("@interface BSApplicationController ()\n" 12079 " {\n" 12080 "@private\n" 12081 " id _extraIvar;\n" 12082 " }\n" 12083 "@end\n", 12084 WhitesmithsBraceStyle); 12085 12086 verifyFormat("#ifdef _DEBUG\n" 12087 "int foo(int i = 0)\n" 12088 "#else\n" 12089 "int foo(int i = 5)\n" 12090 "#endif\n" 12091 " {\n" 12092 " return i;\n" 12093 " }", 12094 WhitesmithsBraceStyle); 12095 12096 verifyFormat("void foo() {}\n" 12097 "void bar()\n" 12098 "#ifdef _DEBUG\n" 12099 " {\n" 12100 " foo();\n" 12101 " }\n" 12102 "#else\n" 12103 " {\n" 12104 " }\n" 12105 "#endif", 12106 WhitesmithsBraceStyle); 12107 12108 verifyFormat("void foobar()\n" 12109 " {\n" 12110 " int i = 5;\n" 12111 " }\n" 12112 "#ifdef _DEBUG\n" 12113 "void bar()\n" 12114 " {\n" 12115 " }\n" 12116 "#else\n" 12117 "void bar()\n" 12118 " {\n" 12119 " foobar();\n" 12120 " }\n" 12121 "#endif", 12122 WhitesmithsBraceStyle); 12123 12124 // This shouldn't affect ObjC blocks.. 12125 verifyFormat("[self doSomeThingWithACompletionHandler:^{\n" 12126 " // ...\n" 12127 " int i;\n" 12128 "}];", 12129 WhitesmithsBraceStyle); 12130 verifyFormat("void (^block)(void) = ^{\n" 12131 " // ...\n" 12132 " int i;\n" 12133 "};", 12134 WhitesmithsBraceStyle); 12135 // .. or dict literals. 12136 verifyFormat("void f()\n" 12137 " {\n" 12138 " [object someMethod:@{@\"a\" : @\"b\"}];\n" 12139 " }", 12140 WhitesmithsBraceStyle); 12141 12142 verifyFormat("int f()\n" 12143 " { // comment\n" 12144 " return 42;\n" 12145 " }", 12146 WhitesmithsBraceStyle); 12147 12148 FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle; 12149 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = 12150 FormatStyle::SIS_Always; 12151 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 12152 verifyFormat("void f(bool b)\n" 12153 " {\n" 12154 " if (b)\n" 12155 " {\n" 12156 " return;\n" 12157 " }\n" 12158 " }\n", 12159 BreakBeforeBraceShortIfs); 12160 verifyFormat("void f(bool b)\n" 12161 " {\n" 12162 " if (b) return;\n" 12163 " }\n", 12164 BreakBeforeBraceShortIfs); 12165 verifyFormat("void f(bool b)\n" 12166 " {\n" 12167 " while (b)\n" 12168 " {\n" 12169 " return;\n" 12170 " }\n" 12171 " }\n", 12172 BreakBeforeBraceShortIfs); 12173 } 12174 12175 TEST_F(FormatTest, GNUBraceBreaking) { 12176 FormatStyle GNUBraceStyle = getLLVMStyle(); 12177 GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU; 12178 verifyFormat("namespace a\n" 12179 "{\n" 12180 "class A\n" 12181 "{\n" 12182 " void f()\n" 12183 " {\n" 12184 " int a;\n" 12185 " {\n" 12186 " int b;\n" 12187 " }\n" 12188 " if (true)\n" 12189 " {\n" 12190 " a();\n" 12191 " b();\n" 12192 " }\n" 12193 " }\n" 12194 " void g() { return; }\n" 12195 "}\n" 12196 "} // namespace a", 12197 GNUBraceStyle); 12198 12199 verifyFormat("void f()\n" 12200 "{\n" 12201 " if (true)\n" 12202 " {\n" 12203 " a();\n" 12204 " }\n" 12205 " else if (false)\n" 12206 " {\n" 12207 " b();\n" 12208 " }\n" 12209 " else\n" 12210 " {\n" 12211 " c();\n" 12212 " }\n" 12213 "}\n", 12214 GNUBraceStyle); 12215 12216 verifyFormat("void f()\n" 12217 "{\n" 12218 " for (int i = 0; i < 10; ++i)\n" 12219 " {\n" 12220 " a();\n" 12221 " }\n" 12222 " while (false)\n" 12223 " {\n" 12224 " b();\n" 12225 " }\n" 12226 " do\n" 12227 " {\n" 12228 " c();\n" 12229 " }\n" 12230 " while (false);\n" 12231 "}\n", 12232 GNUBraceStyle); 12233 12234 verifyFormat("void f(int a)\n" 12235 "{\n" 12236 " switch (a)\n" 12237 " {\n" 12238 " case 0:\n" 12239 " break;\n" 12240 " case 1:\n" 12241 " {\n" 12242 " break;\n" 12243 " }\n" 12244 " case 2:\n" 12245 " {\n" 12246 " }\n" 12247 " break;\n" 12248 " default:\n" 12249 " break;\n" 12250 " }\n" 12251 "}\n", 12252 GNUBraceStyle); 12253 12254 verifyFormat("enum X\n" 12255 "{\n" 12256 " Y = 0,\n" 12257 "}\n", 12258 GNUBraceStyle); 12259 12260 verifyFormat("@interface BSApplicationController ()\n" 12261 "{\n" 12262 "@private\n" 12263 " id _extraIvar;\n" 12264 "}\n" 12265 "@end\n", 12266 GNUBraceStyle); 12267 12268 verifyFormat("#ifdef _DEBUG\n" 12269 "int foo(int i = 0)\n" 12270 "#else\n" 12271 "int foo(int i = 5)\n" 12272 "#endif\n" 12273 "{\n" 12274 " return i;\n" 12275 "}", 12276 GNUBraceStyle); 12277 12278 verifyFormat("void foo() {}\n" 12279 "void bar()\n" 12280 "#ifdef _DEBUG\n" 12281 "{\n" 12282 " foo();\n" 12283 "}\n" 12284 "#else\n" 12285 "{\n" 12286 "}\n" 12287 "#endif", 12288 GNUBraceStyle); 12289 12290 verifyFormat("void foobar() { int i = 5; }\n" 12291 "#ifdef _DEBUG\n" 12292 "void bar() {}\n" 12293 "#else\n" 12294 "void bar() { foobar(); }\n" 12295 "#endif", 12296 GNUBraceStyle); 12297 } 12298 12299 TEST_F(FormatTest, WebKitBraceBreaking) { 12300 FormatStyle WebKitBraceStyle = getLLVMStyle(); 12301 WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit; 12302 WebKitBraceStyle.FixNamespaceComments = false; 12303 verifyFormat("namespace a {\n" 12304 "class A {\n" 12305 " void f()\n" 12306 " {\n" 12307 " if (true) {\n" 12308 " a();\n" 12309 " b();\n" 12310 " }\n" 12311 " }\n" 12312 " void g() { return; }\n" 12313 "};\n" 12314 "enum E {\n" 12315 " A,\n" 12316 " // foo\n" 12317 " B,\n" 12318 " C\n" 12319 "};\n" 12320 "struct B {\n" 12321 " int x;\n" 12322 "};\n" 12323 "}\n", 12324 WebKitBraceStyle); 12325 verifyFormat("struct S {\n" 12326 " int Type;\n" 12327 " union {\n" 12328 " int x;\n" 12329 " double y;\n" 12330 " } Value;\n" 12331 " class C {\n" 12332 " MyFavoriteType Value;\n" 12333 " } Class;\n" 12334 "};\n", 12335 WebKitBraceStyle); 12336 } 12337 12338 TEST_F(FormatTest, CatchExceptionReferenceBinding) { 12339 verifyFormat("void f() {\n" 12340 " try {\n" 12341 " } catch (const Exception &e) {\n" 12342 " }\n" 12343 "}\n", 12344 getLLVMStyle()); 12345 } 12346 12347 TEST_F(FormatTest, UnderstandsPragmas) { 12348 verifyFormat("#pragma omp reduction(| : var)"); 12349 verifyFormat("#pragma omp reduction(+ : var)"); 12350 12351 EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string " 12352 "(including parentheses).", 12353 format("#pragma mark Any non-hyphenated or hyphenated string " 12354 "(including parentheses).")); 12355 } 12356 12357 TEST_F(FormatTest, UnderstandPragmaOption) { 12358 verifyFormat("#pragma option -C -A"); 12359 12360 EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A")); 12361 } 12362 12363 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) { 12364 FormatStyle Style = getLLVMStyle(); 12365 Style.ColumnLimit = 20; 12366 12367 // See PR41213 12368 EXPECT_EQ("/*\n" 12369 " *\t9012345\n" 12370 " * /8901\n" 12371 " */", 12372 format("/*\n" 12373 " *\t9012345 /8901\n" 12374 " */", 12375 Style)); 12376 EXPECT_EQ("/*\n" 12377 " *345678\n" 12378 " *\t/8901\n" 12379 " */", 12380 format("/*\n" 12381 " *345678\t/8901\n" 12382 " */", 12383 Style)); 12384 12385 verifyFormat("int a; // the\n" 12386 " // comment", 12387 Style); 12388 EXPECT_EQ("int a; /* first line\n" 12389 " * second\n" 12390 " * line third\n" 12391 " * line\n" 12392 " */", 12393 format("int a; /* first line\n" 12394 " * second\n" 12395 " * line third\n" 12396 " * line\n" 12397 " */", 12398 Style)); 12399 EXPECT_EQ("int a; // first line\n" 12400 " // second\n" 12401 " // line third\n" 12402 " // line", 12403 format("int a; // first line\n" 12404 " // second line\n" 12405 " // third line", 12406 Style)); 12407 12408 Style.PenaltyExcessCharacter = 90; 12409 verifyFormat("int a; // the comment", Style); 12410 EXPECT_EQ("int a; // the comment\n" 12411 " // aaa", 12412 format("int a; // the comment aaa", Style)); 12413 EXPECT_EQ("int a; /* first line\n" 12414 " * second line\n" 12415 " * third line\n" 12416 " */", 12417 format("int a; /* first line\n" 12418 " * second line\n" 12419 " * third line\n" 12420 " */", 12421 Style)); 12422 EXPECT_EQ("int a; // first line\n" 12423 " // second line\n" 12424 " // third line", 12425 format("int a; // first line\n" 12426 " // second line\n" 12427 " // third line", 12428 Style)); 12429 // FIXME: Investigate why this is not getting the same layout as the test 12430 // above. 12431 EXPECT_EQ("int a; /* first line\n" 12432 " * second line\n" 12433 " * third line\n" 12434 " */", 12435 format("int a; /* first line second line third line" 12436 "\n*/", 12437 Style)); 12438 12439 EXPECT_EQ("// foo bar baz bazfoo\n" 12440 "// foo bar foo bar\n", 12441 format("// foo bar baz bazfoo\n" 12442 "// foo bar foo bar\n", 12443 Style)); 12444 EXPECT_EQ("// foo bar baz bazfoo\n" 12445 "// foo bar foo bar\n", 12446 format("// foo bar baz bazfoo\n" 12447 "// foo bar foo bar\n", 12448 Style)); 12449 12450 // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the 12451 // next one. 12452 EXPECT_EQ("// foo bar baz bazfoo\n" 12453 "// bar foo bar\n", 12454 format("// foo bar baz bazfoo bar\n" 12455 "// foo bar\n", 12456 Style)); 12457 12458 EXPECT_EQ("// foo bar baz bazfoo\n" 12459 "// foo bar baz bazfoo\n" 12460 "// bar foo bar\n", 12461 format("// foo bar baz bazfoo\n" 12462 "// foo bar baz bazfoo bar\n" 12463 "// foo bar\n", 12464 Style)); 12465 12466 EXPECT_EQ("// foo bar baz bazfoo\n" 12467 "// foo bar baz bazfoo\n" 12468 "// bar foo bar\n", 12469 format("// foo bar baz bazfoo\n" 12470 "// foo bar baz bazfoo bar\n" 12471 "// foo bar\n", 12472 Style)); 12473 12474 // Make sure we do not keep protruding characters if strict mode reflow is 12475 // cheaper than keeping protruding characters. 12476 Style.ColumnLimit = 21; 12477 EXPECT_EQ( 12478 "// foo foo foo foo\n" 12479 "// foo foo foo foo\n" 12480 "// foo foo foo foo\n", 12481 format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style)); 12482 12483 EXPECT_EQ("int a = /* long block\n" 12484 " comment */\n" 12485 " 42;", 12486 format("int a = /* long block comment */ 42;", Style)); 12487 } 12488 12489 #define EXPECT_ALL_STYLES_EQUAL(Styles) \ 12490 for (size_t i = 1; i < Styles.size(); ++i) \ 12491 EXPECT_EQ(Styles[0], Styles[i]) \ 12492 << "Style #" << i << " of " << Styles.size() << " differs from Style #0" 12493 12494 TEST_F(FormatTest, GetsPredefinedStyleByName) { 12495 SmallVector<FormatStyle, 3> Styles; 12496 Styles.resize(3); 12497 12498 Styles[0] = getLLVMStyle(); 12499 EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1])); 12500 EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2])); 12501 EXPECT_ALL_STYLES_EQUAL(Styles); 12502 12503 Styles[0] = getGoogleStyle(); 12504 EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1])); 12505 EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2])); 12506 EXPECT_ALL_STYLES_EQUAL(Styles); 12507 12508 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12509 EXPECT_TRUE( 12510 getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1])); 12511 EXPECT_TRUE( 12512 getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2])); 12513 EXPECT_ALL_STYLES_EQUAL(Styles); 12514 12515 Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp); 12516 EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1])); 12517 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2])); 12518 EXPECT_ALL_STYLES_EQUAL(Styles); 12519 12520 Styles[0] = getMozillaStyle(); 12521 EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1])); 12522 EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2])); 12523 EXPECT_ALL_STYLES_EQUAL(Styles); 12524 12525 Styles[0] = getWebKitStyle(); 12526 EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1])); 12527 EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2])); 12528 EXPECT_ALL_STYLES_EQUAL(Styles); 12529 12530 Styles[0] = getGNUStyle(); 12531 EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1])); 12532 EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2])); 12533 EXPECT_ALL_STYLES_EQUAL(Styles); 12534 12535 EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0])); 12536 } 12537 12538 TEST_F(FormatTest, GetsCorrectBasedOnStyle) { 12539 SmallVector<FormatStyle, 8> Styles; 12540 Styles.resize(2); 12541 12542 Styles[0] = getGoogleStyle(); 12543 Styles[1] = getLLVMStyle(); 12544 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12545 EXPECT_ALL_STYLES_EQUAL(Styles); 12546 12547 Styles.resize(5); 12548 Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript); 12549 Styles[1] = getLLVMStyle(); 12550 Styles[1].Language = FormatStyle::LK_JavaScript; 12551 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value()); 12552 12553 Styles[2] = getLLVMStyle(); 12554 Styles[2].Language = FormatStyle::LK_JavaScript; 12555 EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n" 12556 "BasedOnStyle: Google", 12557 &Styles[2]) 12558 .value()); 12559 12560 Styles[3] = getLLVMStyle(); 12561 Styles[3].Language = FormatStyle::LK_JavaScript; 12562 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n" 12563 "Language: JavaScript", 12564 &Styles[3]) 12565 .value()); 12566 12567 Styles[4] = getLLVMStyle(); 12568 Styles[4].Language = FormatStyle::LK_JavaScript; 12569 EXPECT_EQ(0, parseConfiguration("---\n" 12570 "BasedOnStyle: LLVM\n" 12571 "IndentWidth: 123\n" 12572 "---\n" 12573 "BasedOnStyle: Google\n" 12574 "Language: JavaScript", 12575 &Styles[4]) 12576 .value()); 12577 EXPECT_ALL_STYLES_EQUAL(Styles); 12578 } 12579 12580 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME) \ 12581 Style.FIELD = false; \ 12582 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value()); \ 12583 EXPECT_TRUE(Style.FIELD); \ 12584 EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value()); \ 12585 EXPECT_FALSE(Style.FIELD); 12586 12587 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD) 12588 12589 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME) \ 12590 Style.STRUCT.FIELD = false; \ 12591 EXPECT_EQ(0, \ 12592 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": true", &Style) \ 12593 .value()); \ 12594 EXPECT_TRUE(Style.STRUCT.FIELD); \ 12595 EXPECT_EQ(0, \ 12596 parseConfiguration(#STRUCT ":\n " CONFIG_NAME ": false", &Style) \ 12597 .value()); \ 12598 EXPECT_FALSE(Style.STRUCT.FIELD); 12599 12600 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD) \ 12601 CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD) 12602 12603 #define CHECK_PARSE(TEXT, FIELD, VALUE) \ 12604 EXPECT_NE(VALUE, Style.FIELD); \ 12605 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 12606 EXPECT_EQ(VALUE, Style.FIELD) 12607 12608 TEST_F(FormatTest, ParsesConfigurationBools) { 12609 FormatStyle Style = {}; 12610 Style.Language = FormatStyle::LK_Cpp; 12611 CHECK_PARSE_BOOL(AlignOperands); 12612 CHECK_PARSE_BOOL(AlignTrailingComments); 12613 CHECK_PARSE_BOOL(AlignConsecutiveAssignments); 12614 CHECK_PARSE_BOOL(AlignConsecutiveDeclarations); 12615 CHECK_PARSE_BOOL(AlignConsecutiveMacros); 12616 CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine); 12617 CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine); 12618 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 12619 CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine); 12620 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 12621 CHECK_PARSE_BOOL(BinPackArguments); 12622 CHECK_PARSE_BOOL(BinPackParameters); 12623 CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations); 12624 CHECK_PARSE_BOOL(BreakBeforeTernaryOperators); 12625 CHECK_PARSE_BOOL(BreakStringLiterals); 12626 CHECK_PARSE_BOOL(CompactNamespaces); 12627 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 12628 CHECK_PARSE_BOOL(DeriveLineEnding); 12629 CHECK_PARSE_BOOL(DerivePointerAlignment); 12630 CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding"); 12631 CHECK_PARSE_BOOL(DisableFormat); 12632 CHECK_PARSE_BOOL(IndentCaseLabels); 12633 CHECK_PARSE_BOOL(IndentCaseBlocks); 12634 CHECK_PARSE_BOOL(IndentGotoLabels); 12635 CHECK_PARSE_BOOL(IndentWrappedFunctionNames); 12636 CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks); 12637 CHECK_PARSE_BOOL(ObjCSpaceAfterProperty); 12638 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 12639 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 12640 CHECK_PARSE_BOOL(ReflowComments); 12641 CHECK_PARSE_BOOL(SortIncludes); 12642 CHECK_PARSE_BOOL(SortUsingDeclarations); 12643 CHECK_PARSE_BOOL(SpacesInParentheses); 12644 CHECK_PARSE_BOOL(SpacesInSquareBrackets); 12645 CHECK_PARSE_BOOL(SpacesInAngles); 12646 CHECK_PARSE_BOOL(SpacesInConditionalStatement); 12647 CHECK_PARSE_BOOL(SpaceInEmptyBlock); 12648 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 12649 CHECK_PARSE_BOOL(SpacesInContainerLiterals); 12650 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 12651 CHECK_PARSE_BOOL(SpaceAfterCStyleCast); 12652 CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword); 12653 CHECK_PARSE_BOOL(SpaceAfterLogicalNot); 12654 CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators); 12655 CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList); 12656 CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon); 12657 CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon); 12658 CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon); 12659 CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets); 12660 CHECK_PARSE_BOOL(UseCRLF); 12661 12662 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel); 12663 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass); 12664 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum); 12665 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction); 12666 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace); 12667 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration); 12668 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct); 12669 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion); 12670 CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock); 12671 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch); 12672 CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse); 12673 CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces); 12674 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction); 12675 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord); 12676 CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace); 12677 } 12678 12679 #undef CHECK_PARSE_BOOL 12680 12681 TEST_F(FormatTest, ParsesConfiguration) { 12682 FormatStyle Style = {}; 12683 Style.Language = FormatStyle::LK_Cpp; 12684 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 12685 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 12686 ConstructorInitializerIndentWidth, 1234u); 12687 CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u); 12688 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 12689 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 12690 CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u); 12691 CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234", 12692 PenaltyBreakBeforeFirstCallParameter, 1234u); 12693 CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234", 12694 PenaltyBreakTemplateDeclaration, 1234u); 12695 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 12696 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 12697 PenaltyReturnTypeOnItsOwnLine, 1234u); 12698 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 12699 SpacesBeforeTrailingComments, 1234u); 12700 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 12701 CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u); 12702 CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$"); 12703 12704 Style.PointerAlignment = FormatStyle::PAS_Middle; 12705 CHECK_PARSE("PointerAlignment: Left", PointerAlignment, 12706 FormatStyle::PAS_Left); 12707 CHECK_PARSE("PointerAlignment: Right", PointerAlignment, 12708 FormatStyle::PAS_Right); 12709 CHECK_PARSE("PointerAlignment: Middle", PointerAlignment, 12710 FormatStyle::PAS_Middle); 12711 // For backward compatibility: 12712 CHECK_PARSE("PointerBindsToType: Left", PointerAlignment, 12713 FormatStyle::PAS_Left); 12714 CHECK_PARSE("PointerBindsToType: Right", PointerAlignment, 12715 FormatStyle::PAS_Right); 12716 CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment, 12717 FormatStyle::PAS_Middle); 12718 12719 Style.Standard = FormatStyle::LS_Auto; 12720 CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03); 12721 CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11); 12722 CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14); 12723 CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17); 12724 CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20); 12725 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 12726 CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest); 12727 // Legacy aliases: 12728 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 12729 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest); 12730 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 12731 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 12732 12733 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; 12734 CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment", 12735 BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment); 12736 CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators, 12737 FormatStyle::BOS_None); 12738 CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators, 12739 FormatStyle::BOS_All); 12740 // For backward compatibility: 12741 CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators, 12742 FormatStyle::BOS_None); 12743 CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators, 12744 FormatStyle::BOS_All); 12745 12746 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; 12747 CHECK_PARSE("BreakConstructorInitializers: BeforeComma", 12748 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 12749 CHECK_PARSE("BreakConstructorInitializers: AfterColon", 12750 BreakConstructorInitializers, FormatStyle::BCIS_AfterColon); 12751 CHECK_PARSE("BreakConstructorInitializers: BeforeColon", 12752 BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon); 12753 // For backward compatibility: 12754 CHECK_PARSE("BreakConstructorInitializersBeforeComma: true", 12755 BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma); 12756 12757 Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; 12758 CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList, 12759 FormatStyle::BILS_BeforeComma); 12760 CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList, 12761 FormatStyle::BILS_AfterColon); 12762 CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList, 12763 FormatStyle::BILS_BeforeColon); 12764 // For backward compatibility: 12765 CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList, 12766 FormatStyle::BILS_BeforeComma); 12767 12768 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 12769 CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket, 12770 FormatStyle::BAS_Align); 12771 CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket, 12772 FormatStyle::BAS_DontAlign); 12773 CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket, 12774 FormatStyle::BAS_AlwaysBreak); 12775 // For backward compatibility: 12776 CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket, 12777 FormatStyle::BAS_DontAlign); 12778 CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, 12779 FormatStyle::BAS_Align); 12780 12781 Style.AlignEscapedNewlines = FormatStyle::ENAS_Left; 12782 CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines, 12783 FormatStyle::ENAS_DontAlign); 12784 CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines, 12785 FormatStyle::ENAS_Left); 12786 CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines, 12787 FormatStyle::ENAS_Right); 12788 // For backward compatibility: 12789 CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines, 12790 FormatStyle::ENAS_Left); 12791 CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines, 12792 FormatStyle::ENAS_Right); 12793 12794 Style.UseTab = FormatStyle::UT_ForIndentation; 12795 CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); 12796 CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); 12797 CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); 12798 CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab, 12799 FormatStyle::UT_ForContinuationAndIndentation); 12800 // For backward compatibility: 12801 CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); 12802 CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); 12803 12804 Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; 12805 CHECK_PARSE("AllowShortBlocksOnASingleLine: Never", 12806 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12807 CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty", 12808 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty); 12809 CHECK_PARSE("AllowShortBlocksOnASingleLine: Always", 12810 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12811 // For backward compatibility: 12812 CHECK_PARSE("AllowShortBlocksOnASingleLine: false", 12813 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); 12814 CHECK_PARSE("AllowShortBlocksOnASingleLine: true", 12815 AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always); 12816 12817 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; 12818 CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", 12819 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12820 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", 12821 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline); 12822 CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty", 12823 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty); 12824 CHECK_PARSE("AllowShortFunctionsOnASingleLine: All", 12825 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12826 // For backward compatibility: 12827 CHECK_PARSE("AllowShortFunctionsOnASingleLine: false", 12828 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); 12829 CHECK_PARSE("AllowShortFunctionsOnASingleLine: true", 12830 AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All); 12831 12832 Style.SpaceBeforeParens = FormatStyle::SBPO_Always; 12833 CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens, 12834 FormatStyle::SBPO_Never); 12835 CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens, 12836 FormatStyle::SBPO_Always); 12837 CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens, 12838 FormatStyle::SBPO_ControlStatements); 12839 CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens, 12840 FormatStyle::SBPO_NonEmptyParentheses); 12841 // For backward compatibility: 12842 CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens, 12843 FormatStyle::SBPO_Never); 12844 CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens, 12845 FormatStyle::SBPO_ControlStatements); 12846 12847 Style.ColumnLimit = 123; 12848 FormatStyle BaseStyle = getLLVMStyle(); 12849 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 12850 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 12851 12852 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 12853 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 12854 FormatStyle::BS_Attach); 12855 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 12856 FormatStyle::BS_Linux); 12857 CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces, 12858 FormatStyle::BS_Mozilla); 12859 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 12860 FormatStyle::BS_Stroustrup); 12861 CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces, 12862 FormatStyle::BS_Allman); 12863 CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces, 12864 FormatStyle::BS_Whitesmiths); 12865 CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU); 12866 CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces, 12867 FormatStyle::BS_WebKit); 12868 CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces, 12869 FormatStyle::BS_Custom); 12870 12871 Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never; 12872 CHECK_PARSE("BraceWrapping:\n" 12873 " AfterControlStatement: MultiLine", 12874 BraceWrapping.AfterControlStatement, 12875 FormatStyle::BWACS_MultiLine); 12876 CHECK_PARSE("BraceWrapping:\n" 12877 " AfterControlStatement: Always", 12878 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 12879 CHECK_PARSE("BraceWrapping:\n" 12880 " AfterControlStatement: Never", 12881 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 12882 // For backward compatibility: 12883 CHECK_PARSE("BraceWrapping:\n" 12884 " AfterControlStatement: true", 12885 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always); 12886 CHECK_PARSE("BraceWrapping:\n" 12887 " AfterControlStatement: false", 12888 BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never); 12889 12890 Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All; 12891 CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType, 12892 FormatStyle::RTBS_None); 12893 CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType, 12894 FormatStyle::RTBS_All); 12895 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel", 12896 AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel); 12897 CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions", 12898 AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions); 12899 CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions", 12900 AlwaysBreakAfterReturnType, 12901 FormatStyle::RTBS_TopLevelDefinitions); 12902 12903 Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes; 12904 CHECK_PARSE("AlwaysBreakTemplateDeclarations: No", 12905 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No); 12906 CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine", 12907 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 12908 CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes", 12909 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 12910 CHECK_PARSE("AlwaysBreakTemplateDeclarations: false", 12911 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine); 12912 CHECK_PARSE("AlwaysBreakTemplateDeclarations: true", 12913 AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes); 12914 12915 Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All; 12916 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None", 12917 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None); 12918 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All", 12919 AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All); 12920 CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel", 12921 AlwaysBreakAfterDefinitionReturnType, 12922 FormatStyle::DRTBS_TopLevel); 12923 12924 Style.NamespaceIndentation = FormatStyle::NI_All; 12925 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 12926 FormatStyle::NI_None); 12927 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 12928 FormatStyle::NI_Inner); 12929 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 12930 FormatStyle::NI_All); 12931 12932 Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always; 12933 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never", 12934 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12935 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse", 12936 AllowShortIfStatementsOnASingleLine, 12937 FormatStyle::SIS_WithoutElse); 12938 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always", 12939 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always); 12940 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false", 12941 AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); 12942 CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true", 12943 AllowShortIfStatementsOnASingleLine, 12944 FormatStyle::SIS_WithoutElse); 12945 12946 // FIXME: This is required because parsing a configuration simply overwrites 12947 // the first N elements of the list instead of resetting it. 12948 Style.ForEachMacros.clear(); 12949 std::vector<std::string> BoostForeach; 12950 BoostForeach.push_back("BOOST_FOREACH"); 12951 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach); 12952 std::vector<std::string> BoostAndQForeach; 12953 BoostAndQForeach.push_back("BOOST_FOREACH"); 12954 BoostAndQForeach.push_back("Q_FOREACH"); 12955 CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros, 12956 BoostAndQForeach); 12957 12958 Style.StatementMacros.clear(); 12959 CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros, 12960 std::vector<std::string>{"QUNUSED"}); 12961 CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros, 12962 std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"})); 12963 12964 Style.NamespaceMacros.clear(); 12965 CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros, 12966 std::vector<std::string>{"TESTSUITE"}); 12967 CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros, 12968 std::vector<std::string>({"TESTSUITE", "SUITE"})); 12969 12970 Style.IncludeStyle.IncludeCategories.clear(); 12971 std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = { 12972 {"abc/.*", 2, 0}, {".*", 1, 0}}; 12973 CHECK_PARSE("IncludeCategories:\n" 12974 " - Regex: abc/.*\n" 12975 " Priority: 2\n" 12976 " - Regex: .*\n" 12977 " Priority: 1", 12978 IncludeStyle.IncludeCategories, ExpectedCategories); 12979 CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex, 12980 "abc$"); 12981 CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'", 12982 IncludeStyle.IncludeIsMainSourceRegex, "abc$"); 12983 12984 Style.RawStringFormats.clear(); 12985 std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = { 12986 { 12987 FormatStyle::LK_TextProto, 12988 {"pb", "proto"}, 12989 {"PARSE_TEXT_PROTO"}, 12990 /*CanonicalDelimiter=*/"", 12991 "llvm", 12992 }, 12993 { 12994 FormatStyle::LK_Cpp, 12995 {"cc", "cpp"}, 12996 {"C_CODEBLOCK", "CPPEVAL"}, 12997 /*CanonicalDelimiter=*/"cc", 12998 /*BasedOnStyle=*/"", 12999 }, 13000 }; 13001 13002 CHECK_PARSE("RawStringFormats:\n" 13003 " - Language: TextProto\n" 13004 " Delimiters:\n" 13005 " - 'pb'\n" 13006 " - 'proto'\n" 13007 " EnclosingFunctions:\n" 13008 " - 'PARSE_TEXT_PROTO'\n" 13009 " BasedOnStyle: llvm\n" 13010 " - Language: Cpp\n" 13011 " Delimiters:\n" 13012 " - 'cc'\n" 13013 " - 'cpp'\n" 13014 " EnclosingFunctions:\n" 13015 " - 'C_CODEBLOCK'\n" 13016 " - 'CPPEVAL'\n" 13017 " CanonicalDelimiter: 'cc'", 13018 RawStringFormats, ExpectedRawStringFormats); 13019 } 13020 13021 TEST_F(FormatTest, ParsesConfigurationWithLanguages) { 13022 FormatStyle Style = {}; 13023 Style.Language = FormatStyle::LK_Cpp; 13024 CHECK_PARSE("Language: Cpp\n" 13025 "IndentWidth: 12", 13026 IndentWidth, 12u); 13027 EXPECT_EQ(parseConfiguration("Language: JavaScript\n" 13028 "IndentWidth: 34", 13029 &Style), 13030 ParseError::Unsuitable); 13031 EXPECT_EQ(12u, Style.IndentWidth); 13032 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 13033 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 13034 13035 Style.Language = FormatStyle::LK_JavaScript; 13036 CHECK_PARSE("Language: JavaScript\n" 13037 "IndentWidth: 12", 13038 IndentWidth, 12u); 13039 CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u); 13040 EXPECT_EQ(parseConfiguration("Language: Cpp\n" 13041 "IndentWidth: 34", 13042 &Style), 13043 ParseError::Unsuitable); 13044 EXPECT_EQ(23u, Style.IndentWidth); 13045 CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u); 13046 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 13047 13048 CHECK_PARSE("BasedOnStyle: LLVM\n" 13049 "IndentWidth: 67", 13050 IndentWidth, 67u); 13051 13052 CHECK_PARSE("---\n" 13053 "Language: JavaScript\n" 13054 "IndentWidth: 12\n" 13055 "---\n" 13056 "Language: Cpp\n" 13057 "IndentWidth: 34\n" 13058 "...\n", 13059 IndentWidth, 12u); 13060 13061 Style.Language = FormatStyle::LK_Cpp; 13062 CHECK_PARSE("---\n" 13063 "Language: JavaScript\n" 13064 "IndentWidth: 12\n" 13065 "---\n" 13066 "Language: Cpp\n" 13067 "IndentWidth: 34\n" 13068 "...\n", 13069 IndentWidth, 34u); 13070 CHECK_PARSE("---\n" 13071 "IndentWidth: 78\n" 13072 "---\n" 13073 "Language: JavaScript\n" 13074 "IndentWidth: 56\n" 13075 "...\n", 13076 IndentWidth, 78u); 13077 13078 Style.ColumnLimit = 123; 13079 Style.IndentWidth = 234; 13080 Style.BreakBeforeBraces = FormatStyle::BS_Linux; 13081 Style.TabWidth = 345; 13082 EXPECT_FALSE(parseConfiguration("---\n" 13083 "IndentWidth: 456\n" 13084 "BreakBeforeBraces: Allman\n" 13085 "---\n" 13086 "Language: JavaScript\n" 13087 "IndentWidth: 111\n" 13088 "TabWidth: 111\n" 13089 "---\n" 13090 "Language: Cpp\n" 13091 "BreakBeforeBraces: Stroustrup\n" 13092 "TabWidth: 789\n" 13093 "...\n", 13094 &Style)); 13095 EXPECT_EQ(123u, Style.ColumnLimit); 13096 EXPECT_EQ(456u, Style.IndentWidth); 13097 EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces); 13098 EXPECT_EQ(789u, Style.TabWidth); 13099 13100 EXPECT_EQ(parseConfiguration("---\n" 13101 "Language: JavaScript\n" 13102 "IndentWidth: 56\n" 13103 "---\n" 13104 "IndentWidth: 78\n" 13105 "...\n", 13106 &Style), 13107 ParseError::Error); 13108 EXPECT_EQ(parseConfiguration("---\n" 13109 "Language: JavaScript\n" 13110 "IndentWidth: 56\n" 13111 "---\n" 13112 "Language: JavaScript\n" 13113 "IndentWidth: 78\n" 13114 "...\n", 13115 &Style), 13116 ParseError::Error); 13117 13118 EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language); 13119 } 13120 13121 #undef CHECK_PARSE 13122 13123 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) { 13124 FormatStyle Style = {}; 13125 Style.Language = FormatStyle::LK_JavaScript; 13126 Style.BreakBeforeTernaryOperators = true; 13127 EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value()); 13128 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 13129 13130 Style.BreakBeforeTernaryOperators = true; 13131 EXPECT_EQ(0, parseConfiguration("---\n" 13132 "BasedOnStyle: Google\n" 13133 "---\n" 13134 "Language: JavaScript\n" 13135 "IndentWidth: 76\n" 13136 "...\n", 13137 &Style) 13138 .value()); 13139 EXPECT_FALSE(Style.BreakBeforeTernaryOperators); 13140 EXPECT_EQ(76u, Style.IndentWidth); 13141 EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language); 13142 } 13143 13144 TEST_F(FormatTest, ConfigurationRoundTripTest) { 13145 FormatStyle Style = getLLVMStyle(); 13146 std::string YAML = configurationAsText(Style); 13147 FormatStyle ParsedStyle = {}; 13148 ParsedStyle.Language = FormatStyle::LK_Cpp; 13149 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 13150 EXPECT_EQ(Style, ParsedStyle); 13151 } 13152 13153 TEST_F(FormatTest, WorksFor8bitEncodings) { 13154 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 13155 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 13156 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 13157 "\"\xef\xee\xf0\xf3...\"", 13158 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 13159 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 13160 "\xef\xee\xf0\xf3...\"", 13161 getLLVMStyleWithColumns(12))); 13162 } 13163 13164 TEST_F(FormatTest, HandlesUTF8BOM) { 13165 EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf")); 13166 EXPECT_EQ("\xef\xbb\xbf#include <iostream>", 13167 format("\xef\xbb\xbf#include <iostream>")); 13168 EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>", 13169 format("\xef\xbb\xbf\n#include <iostream>")); 13170 } 13171 13172 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 13173 #if !defined(_MSC_VER) 13174 13175 TEST_F(FormatTest, CountsUTF8CharactersProperly) { 13176 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 13177 getLLVMStyleWithColumns(35)); 13178 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 13179 getLLVMStyleWithColumns(31)); 13180 verifyFormat("// Однажды в студёную зимнюю пору...", 13181 getLLVMStyleWithColumns(36)); 13182 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32)); 13183 verifyFormat("/* Однажды в студёную зимнюю пору... */", 13184 getLLVMStyleWithColumns(39)); 13185 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 13186 getLLVMStyleWithColumns(35)); 13187 } 13188 13189 TEST_F(FormatTest, SplitsUTF8Strings) { 13190 // Non-printable characters' width is currently considered to be the length in 13191 // bytes in UTF8. The characters can be displayed in very different manner 13192 // (zero-width, single width with a substitution glyph, expanded to their code 13193 // (e.g. "<8d>"), so there's no single correct way to handle them. 13194 EXPECT_EQ("\"aaaaÄ\"\n" 13195 "\"\xc2\x8d\";", 13196 format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13197 EXPECT_EQ("\"aaaaaaaÄ\"\n" 13198 "\"\xc2\x8d\";", 13199 format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10))); 13200 EXPECT_EQ("\"Однажды, в \"\n" 13201 "\"студёную \"\n" 13202 "\"зимнюю \"\n" 13203 "\"пору,\"", 13204 format("\"Однажды, в студёную зимнюю пору,\"", 13205 getLLVMStyleWithColumns(13))); 13206 EXPECT_EQ( 13207 "\"一 二 三 \"\n" 13208 "\"四 五六 \"\n" 13209 "\"七 八 九 \"\n" 13210 "\"十\"", 13211 format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11))); 13212 EXPECT_EQ("\"一\t\"\n" 13213 "\"二 \t\"\n" 13214 "\"三 四 \"\n" 13215 "\"五\t\"\n" 13216 "\"六 \t\"\n" 13217 "\"七 \"\n" 13218 "\"八九十\tqq\"", 13219 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 13220 getLLVMStyleWithColumns(11))); 13221 13222 // UTF8 character in an escape sequence. 13223 EXPECT_EQ("\"aaaaaa\"\n" 13224 "\"\\\xC2\x8D\"", 13225 format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10))); 13226 } 13227 13228 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 13229 EXPECT_EQ("const char *sssss =\n" 13230 " \"一二三四五六七八\\\n" 13231 " 九 十\";", 13232 format("const char *sssss = \"一二三四五六七八\\\n" 13233 " 九 十\";", 13234 getLLVMStyleWithColumns(30))); 13235 } 13236 13237 TEST_F(FormatTest, SplitsUTF8LineComments) { 13238 EXPECT_EQ("// aaaaÄ\xc2\x8d", 13239 format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10))); 13240 EXPECT_EQ("// Я из лесу\n" 13241 "// вышел; был\n" 13242 "// сильный\n" 13243 "// мороз.", 13244 format("// Я из лесу вышел; был сильный мороз.", 13245 getLLVMStyleWithColumns(13))); 13246 EXPECT_EQ("// 一二三\n" 13247 "// 四五六七\n" 13248 "// 八 九\n" 13249 "// 十", 13250 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 13251 } 13252 13253 TEST_F(FormatTest, SplitsUTF8BlockComments) { 13254 EXPECT_EQ("/* Гляжу,\n" 13255 " * поднимается\n" 13256 " * медленно в\n" 13257 " * гору\n" 13258 " * Лошадка,\n" 13259 " * везущая\n" 13260 " * хворосту\n" 13261 " * воз. */", 13262 format("/* Гляжу, поднимается медленно в гору\n" 13263 " * Лошадка, везущая хворосту воз. */", 13264 getLLVMStyleWithColumns(13))); 13265 EXPECT_EQ( 13266 "/* 一二三\n" 13267 " * 四五六七\n" 13268 " * 八 九\n" 13269 " * 十 */", 13270 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 13271 EXPECT_EQ("/* �������� ��������\n" 13272 " * ��������\n" 13273 " * ������-�� */", 13274 format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12))); 13275 } 13276 13277 #endif // _MSC_VER 13278 13279 TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 13280 FormatStyle Style = getLLVMStyle(); 13281 13282 Style.ConstructorInitializerIndentWidth = 4; 13283 verifyFormat( 13284 "SomeClass::Constructor()\n" 13285 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13286 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13287 Style); 13288 13289 Style.ConstructorInitializerIndentWidth = 2; 13290 verifyFormat( 13291 "SomeClass::Constructor()\n" 13292 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13293 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13294 Style); 13295 13296 Style.ConstructorInitializerIndentWidth = 0; 13297 verifyFormat( 13298 "SomeClass::Constructor()\n" 13299 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 13300 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 13301 Style); 13302 Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; 13303 verifyFormat( 13304 "SomeLongTemplateVariableName<\n" 13305 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>", 13306 Style); 13307 verifyFormat("bool smaller = 1 < " 13308 "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 13309 " " 13310 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 13311 Style); 13312 13313 Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; 13314 verifyFormat("SomeClass::Constructor() :\n" 13315 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n" 13316 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}", 13317 Style); 13318 } 13319 13320 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) { 13321 FormatStyle Style = getLLVMStyle(); 13322 Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; 13323 Style.ConstructorInitializerIndentWidth = 4; 13324 verifyFormat("SomeClass::Constructor()\n" 13325 " : a(a)\n" 13326 " , b(b)\n" 13327 " , c(c) {}", 13328 Style); 13329 verifyFormat("SomeClass::Constructor()\n" 13330 " : a(a) {}", 13331 Style); 13332 13333 Style.ColumnLimit = 0; 13334 verifyFormat("SomeClass::Constructor()\n" 13335 " : a(a) {}", 13336 Style); 13337 verifyFormat("SomeClass::Constructor() noexcept\n" 13338 " : a(a) {}", 13339 Style); 13340 verifyFormat("SomeClass::Constructor()\n" 13341 " : a(a)\n" 13342 " , b(b)\n" 13343 " , c(c) {}", 13344 Style); 13345 verifyFormat("SomeClass::Constructor()\n" 13346 " : a(a) {\n" 13347 " foo();\n" 13348 " bar();\n" 13349 "}", 13350 Style); 13351 13352 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; 13353 verifyFormat("SomeClass::Constructor()\n" 13354 " : a(a)\n" 13355 " , b(b)\n" 13356 " , c(c) {\n}", 13357 Style); 13358 verifyFormat("SomeClass::Constructor()\n" 13359 " : a(a) {\n}", 13360 Style); 13361 13362 Style.ColumnLimit = 80; 13363 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; 13364 Style.ConstructorInitializerIndentWidth = 2; 13365 verifyFormat("SomeClass::Constructor()\n" 13366 " : a(a)\n" 13367 " , b(b)\n" 13368 " , c(c) {}", 13369 Style); 13370 13371 Style.ConstructorInitializerIndentWidth = 0; 13372 verifyFormat("SomeClass::Constructor()\n" 13373 ": a(a)\n" 13374 ", b(b)\n" 13375 ", c(c) {}", 13376 Style); 13377 13378 Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 13379 Style.ConstructorInitializerIndentWidth = 4; 13380 verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style); 13381 verifyFormat( 13382 "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n", 13383 Style); 13384 verifyFormat( 13385 "SomeClass::Constructor()\n" 13386 " : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}", 13387 Style); 13388 Style.ConstructorInitializerIndentWidth = 4; 13389 Style.ColumnLimit = 60; 13390 verifyFormat("SomeClass::Constructor()\n" 13391 " : aaaaaaaa(aaaaaaaa)\n" 13392 " , aaaaaaaa(aaaaaaaa)\n" 13393 " , aaaaaaaa(aaaaaaaa) {}", 13394 Style); 13395 } 13396 13397 TEST_F(FormatTest, Destructors) { 13398 verifyFormat("void F(int &i) { i.~int(); }"); 13399 verifyFormat("void F(int &i) { i->~int(); }"); 13400 } 13401 13402 TEST_F(FormatTest, FormatsWithWebKitStyle) { 13403 FormatStyle Style = getWebKitStyle(); 13404 13405 // Don't indent in outer namespaces. 13406 verifyFormat("namespace outer {\n" 13407 "int i;\n" 13408 "namespace inner {\n" 13409 " int i;\n" 13410 "} // namespace inner\n" 13411 "} // namespace outer\n" 13412 "namespace other_outer {\n" 13413 "int i;\n" 13414 "}", 13415 Style); 13416 13417 // Don't indent case labels. 13418 verifyFormat("switch (variable) {\n" 13419 "case 1:\n" 13420 "case 2:\n" 13421 " doSomething();\n" 13422 " break;\n" 13423 "default:\n" 13424 " ++variable;\n" 13425 "}", 13426 Style); 13427 13428 // Wrap before binary operators. 13429 EXPECT_EQ("void f()\n" 13430 "{\n" 13431 " if (aaaaaaaaaaaaaaaa\n" 13432 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 13433 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13434 " return;\n" 13435 "}", 13436 format("void f() {\n" 13437 "if (aaaaaaaaaaaaaaaa\n" 13438 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 13439 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 13440 "return;\n" 13441 "}", 13442 Style)); 13443 13444 // Allow functions on a single line. 13445 verifyFormat("void f() { return; }", Style); 13446 13447 // Allow empty blocks on a single line and insert a space in empty blocks. 13448 EXPECT_EQ("void f() { }", format("void f() {}", Style)); 13449 EXPECT_EQ("while (true) { }", format("while (true) {}", Style)); 13450 // However, don't merge non-empty short loops. 13451 EXPECT_EQ("while (true) {\n" 13452 " continue;\n" 13453 "}", 13454 format("while (true) { continue; }", Style)); 13455 13456 // Constructor initializers are formatted one per line with the "," on the 13457 // new line. 13458 verifyFormat("Constructor()\n" 13459 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 13460 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 13461 " aaaaaaaaaaaaaa)\n" 13462 " , aaaaaaaaaaaaaaaaaaaaaaa()\n" 13463 "{\n" 13464 "}", 13465 Style); 13466 verifyFormat("SomeClass::Constructor()\n" 13467 " : a(a)\n" 13468 "{\n" 13469 "}", 13470 Style); 13471 EXPECT_EQ("SomeClass::Constructor()\n" 13472 " : a(a)\n" 13473 "{\n" 13474 "}", 13475 format("SomeClass::Constructor():a(a){}", Style)); 13476 verifyFormat("SomeClass::Constructor()\n" 13477 " : a(a)\n" 13478 " , b(b)\n" 13479 " , c(c)\n" 13480 "{\n" 13481 "}", 13482 Style); 13483 verifyFormat("SomeClass::Constructor()\n" 13484 " : a(a)\n" 13485 "{\n" 13486 " foo();\n" 13487 " bar();\n" 13488 "}", 13489 Style); 13490 13491 // Access specifiers should be aligned left. 13492 verifyFormat("class C {\n" 13493 "public:\n" 13494 " int i;\n" 13495 "};", 13496 Style); 13497 13498 // Do not align comments. 13499 verifyFormat("int a; // Do not\n" 13500 "double b; // align comments.", 13501 Style); 13502 13503 // Do not align operands. 13504 EXPECT_EQ("ASSERT(aaaa\n" 13505 " || bbbb);", 13506 format("ASSERT ( aaaa\n||bbbb);", Style)); 13507 13508 // Accept input's line breaks. 13509 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 13510 " || bbbbbbbbbbbbbbb) {\n" 13511 " i++;\n" 13512 "}", 13513 format("if (aaaaaaaaaaaaaaa\n" 13514 "|| bbbbbbbbbbbbbbb) { i++; }", 13515 Style)); 13516 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 13517 " i++;\n" 13518 "}", 13519 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 13520 13521 // Don't automatically break all macro definitions (llvm.org/PR17842). 13522 verifyFormat("#define aNumber 10", Style); 13523 // However, generally keep the line breaks that the user authored. 13524 EXPECT_EQ("#define aNumber \\\n" 13525 " 10", 13526 format("#define aNumber \\\n" 13527 " 10", 13528 Style)); 13529 13530 // Keep empty and one-element array literals on a single line. 13531 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n" 13532 " copyItems:YES];", 13533 format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n" 13534 "copyItems:YES];", 13535 Style)); 13536 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n" 13537 " copyItems:YES];", 13538 format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n" 13539 " copyItems:YES];", 13540 Style)); 13541 // FIXME: This does not seem right, there should be more indentation before 13542 // the array literal's entries. Nested blocks have the same problem. 13543 EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13544 " @\"a\",\n" 13545 " @\"a\"\n" 13546 "]\n" 13547 " copyItems:YES];", 13548 format("NSArray* a = [[NSArray alloc] initWithArray:@[\n" 13549 " @\"a\",\n" 13550 " @\"a\"\n" 13551 " ]\n" 13552 " copyItems:YES];", 13553 Style)); 13554 EXPECT_EQ( 13555 "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13556 " copyItems:YES];", 13557 format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n" 13558 " copyItems:YES];", 13559 Style)); 13560 13561 verifyFormat("[self.a b:c c:d];", Style); 13562 EXPECT_EQ("[self.a b:c\n" 13563 " c:d];", 13564 format("[self.a b:c\n" 13565 "c:d];", 13566 Style)); 13567 } 13568 13569 TEST_F(FormatTest, FormatsLambdas) { 13570 verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n"); 13571 verifyFormat( 13572 "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n"); 13573 verifyFormat("int c = [&] { [=] { return b++; }(); }();\n"); 13574 verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n"); 13575 verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n"); 13576 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n"); 13577 verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n"); 13578 verifyFormat("auto c = [a = [b = 42] {}] {};\n"); 13579 verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n"); 13580 verifyFormat("int x = f(*+[] {});"); 13581 verifyFormat("void f() {\n" 13582 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 13583 "}\n"); 13584 verifyFormat("void f() {\n" 13585 " other(x.begin(), //\n" 13586 " x.end(), //\n" 13587 " [&](int, int) { return 1; });\n" 13588 "}\n"); 13589 verifyFormat("void f() {\n" 13590 " other.other.other.other.other(\n" 13591 " x.begin(), x.end(),\n" 13592 " [something, rather](int, int, int, int, int, int, int) { " 13593 "return 1; });\n" 13594 "}\n"); 13595 verifyFormat( 13596 "void f() {\n" 13597 " other.other.other.other.other(\n" 13598 " x.begin(), x.end(),\n" 13599 " [something, rather](int, int, int, int, int, int, int) {\n" 13600 " //\n" 13601 " });\n" 13602 "}\n"); 13603 verifyFormat("SomeFunction([]() { // A cool function...\n" 13604 " return 43;\n" 13605 "});"); 13606 EXPECT_EQ("SomeFunction([]() {\n" 13607 "#define A a\n" 13608 " return 43;\n" 13609 "});", 13610 format("SomeFunction([](){\n" 13611 "#define A a\n" 13612 "return 43;\n" 13613 "});")); 13614 verifyFormat("void f() {\n" 13615 " SomeFunction([](decltype(x), A *a) {});\n" 13616 "}"); 13617 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13618 " [](const aaaaaaaaaa &a) { return a; });"); 13619 verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n" 13620 " SomeOtherFunctioooooooooooooooooooooooooon();\n" 13621 "});"); 13622 verifyFormat("Constructor()\n" 13623 " : Field([] { // comment\n" 13624 " int i;\n" 13625 " }) {}"); 13626 verifyFormat("auto my_lambda = [](const string &some_parameter) {\n" 13627 " return some_parameter.size();\n" 13628 "};"); 13629 verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n" 13630 " [](const string &s) { return s; };"); 13631 verifyFormat("int i = aaaaaa ? 1 //\n" 13632 " : [] {\n" 13633 " return 2; //\n" 13634 " }();"); 13635 verifyFormat("llvm::errs() << \"number of twos is \"\n" 13636 " << std::count_if(v.begin(), v.end(), [](int x) {\n" 13637 " return x == 2; // force break\n" 13638 " });"); 13639 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13640 " [=](int iiiiiiiiiiii) {\n" 13641 " return aaaaaaaaaaaaaaaaaaaaaaa !=\n" 13642 " aaaaaaaaaaaaaaaaaaaaaaa;\n" 13643 " });", 13644 getLLVMStyleWithColumns(60)); 13645 verifyFormat("SomeFunction({[&] {\n" 13646 " // comment\n" 13647 " },\n" 13648 " [&] {\n" 13649 " // comment\n" 13650 " }});"); 13651 verifyFormat("SomeFunction({[&] {\n" 13652 " // comment\n" 13653 "}});"); 13654 verifyFormat( 13655 "virtual aaaaaaaaaaaaaaaa(\n" 13656 " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n" 13657 " aaaaa aaaaaaaaa);"); 13658 13659 // Lambdas with return types. 13660 verifyFormat("int c = []() -> int { return 2; }();\n"); 13661 verifyFormat("int c = []() -> int * { return 2; }();\n"); 13662 verifyFormat("int c = []() -> vector<int> { return {2}; }();\n"); 13663 verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());"); 13664 verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};"); 13665 verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};"); 13666 verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};"); 13667 verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};"); 13668 verifyFormat("[a, a]() -> a<1> {};"); 13669 verifyFormat("[]() -> foo<5 + 2> { return {}; };"); 13670 verifyFormat("[]() -> foo<5 - 2> { return {}; };"); 13671 verifyFormat("[]() -> foo<5 / 2> { return {}; };"); 13672 verifyFormat("[]() -> foo<5 * 2> { return {}; };"); 13673 verifyFormat("[]() -> foo<5 % 2> { return {}; };"); 13674 verifyFormat("[]() -> foo<5 << 2> { return {}; };"); 13675 verifyFormat("[]() -> foo<!5> { return {}; };"); 13676 verifyFormat("[]() -> foo<~5> { return {}; };"); 13677 verifyFormat("[]() -> foo<5 | 2> { return {}; };"); 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 <= 2> { return {}; };"); 13685 verifyFormat("[]() -> foo<5 < 2> { return {}; };"); 13686 verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };"); 13687 verifyFormat("namespace bar {\n" 13688 "// broken:\n" 13689 "auto foo{[]() -> foo<5 + 2> { return {}; }};\n" 13690 "} // namespace bar"); 13691 verifyFormat("namespace bar {\n" 13692 "// broken:\n" 13693 "auto foo{[]() -> foo<5 - 2> { return {}; }};\n" 13694 "} // namespace bar"); 13695 verifyFormat("namespace bar {\n" 13696 "// broken:\n" 13697 "auto foo{[]() -> foo<5 / 2> { return {}; }};\n" 13698 "} // namespace bar"); 13699 verifyFormat("namespace bar {\n" 13700 "// broken:\n" 13701 "auto foo{[]() -> foo<5 * 2> { return {}; }};\n" 13702 "} // namespace bar"); 13703 verifyFormat("namespace bar {\n" 13704 "// broken:\n" 13705 "auto foo{[]() -> foo<5 % 2> { return {}; }};\n" 13706 "} // namespace bar"); 13707 verifyFormat("namespace bar {\n" 13708 "// broken:\n" 13709 "auto foo{[]() -> foo<5 << 2> { return {}; }};\n" 13710 "} // namespace bar"); 13711 verifyFormat("namespace bar {\n" 13712 "// broken:\n" 13713 "auto foo{[]() -> foo<!5> { return {}; }};\n" 13714 "} // namespace bar"); 13715 verifyFormat("namespace bar {\n" 13716 "// broken:\n" 13717 "auto foo{[]() -> foo<~5> { return {}; }};\n" 13718 "} // namespace bar"); 13719 verifyFormat("namespace bar {\n" 13720 "// broken:\n" 13721 "auto foo{[]() -> foo<5 | 2> { return {}; }};\n" 13722 "} // namespace bar"); 13723 verifyFormat("namespace bar {\n" 13724 "// broken:\n" 13725 "auto foo{[]() -> foo<5 || 2> { return {}; }};\n" 13726 "} // namespace bar"); 13727 verifyFormat("namespace bar {\n" 13728 "// broken:\n" 13729 "auto foo{[]() -> foo<5 & 2> { return {}; }};\n" 13730 "} // namespace bar"); 13731 verifyFormat("namespace bar {\n" 13732 "// broken:\n" 13733 "auto foo{[]() -> foo<5 && 2> { return {}; }};\n" 13734 "} // namespace bar"); 13735 verifyFormat("namespace bar {\n" 13736 "// broken:\n" 13737 "auto foo{[]() -> foo<5 == 2> { return {}; }};\n" 13738 "} // namespace bar"); 13739 verifyFormat("namespace bar {\n" 13740 "// broken:\n" 13741 "auto foo{[]() -> foo<5 != 2> { return {}; }};\n" 13742 "} // namespace bar"); 13743 verifyFormat("namespace bar {\n" 13744 "// broken:\n" 13745 "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n" 13746 "} // namespace bar"); 13747 verifyFormat("namespace bar {\n" 13748 "// broken:\n" 13749 "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n" 13750 "} // namespace bar"); 13751 verifyFormat("namespace bar {\n" 13752 "// broken:\n" 13753 "auto foo{[]() -> foo<5 < 2> { return {}; }};\n" 13754 "} // namespace bar"); 13755 verifyFormat("namespace bar {\n" 13756 "// broken:\n" 13757 "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n" 13758 "} // namespace bar"); 13759 verifyFormat("[]() -> a<1> {};"); 13760 verifyFormat("[]() -> a<1> { ; };"); 13761 verifyFormat("[]() -> a<1> { ; }();"); 13762 verifyFormat("[a, a]() -> a<true> {};"); 13763 verifyFormat("[]() -> a<true> {};"); 13764 verifyFormat("[]() -> a<true> { ; };"); 13765 verifyFormat("[]() -> a<true> { ; }();"); 13766 verifyFormat("[a, a]() -> a<false> {};"); 13767 verifyFormat("[]() -> a<false> {};"); 13768 verifyFormat("[]() -> a<false> { ; };"); 13769 verifyFormat("[]() -> a<false> { ; }();"); 13770 verifyFormat("auto foo{[]() -> foo<false> { ; }};"); 13771 verifyFormat("namespace bar {\n" 13772 "auto foo{[]() -> foo<false> { ; }};\n" 13773 "} // namespace bar"); 13774 verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n" 13775 " int j) -> int {\n" 13776 " return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n" 13777 "};"); 13778 verifyFormat( 13779 "aaaaaaaaaaaaaaaaaaaaaa(\n" 13780 " [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n" 13781 " return aaaaaaaaaaaaaaaaa;\n" 13782 " });", 13783 getLLVMStyleWithColumns(70)); 13784 verifyFormat("[]() //\n" 13785 " -> int {\n" 13786 " return 1; //\n" 13787 "};"); 13788 13789 // Lambdas with explicit template argument lists. 13790 verifyFormat( 13791 "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n"); 13792 13793 // Multiple lambdas in the same parentheses change indentation rules. These 13794 // lambdas are forced to start on new lines. 13795 verifyFormat("SomeFunction(\n" 13796 " []() {\n" 13797 " //\n" 13798 " },\n" 13799 " []() {\n" 13800 " //\n" 13801 " });"); 13802 13803 // A lambda passed as arg0 is always pushed to the next line. 13804 verifyFormat("SomeFunction(\n" 13805 " [this] {\n" 13806 " //\n" 13807 " },\n" 13808 " 1);\n"); 13809 13810 // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like 13811 // the arg0 case above. 13812 auto Style = getGoogleStyle(); 13813 Style.BinPackArguments = false; 13814 verifyFormat("SomeFunction(\n" 13815 " a,\n" 13816 " [this] {\n" 13817 " //\n" 13818 " },\n" 13819 " b);\n", 13820 Style); 13821 verifyFormat("SomeFunction(\n" 13822 " a,\n" 13823 " [this] {\n" 13824 " //\n" 13825 " },\n" 13826 " b);\n"); 13827 13828 // A lambda with a very long line forces arg0 to be pushed out irrespective of 13829 // the BinPackArguments value (as long as the code is wide enough). 13830 verifyFormat( 13831 "something->SomeFunction(\n" 13832 " a,\n" 13833 " [this] {\n" 13834 " " 13835 "D0000000000000000000000000000000000000000000000000000000000001();\n" 13836 " },\n" 13837 " b);\n"); 13838 13839 // A multi-line lambda is pulled up as long as the introducer fits on the 13840 // previous line and there are no further args. 13841 verifyFormat("function(1, [this, that] {\n" 13842 " //\n" 13843 "});\n"); 13844 verifyFormat("function([this, that] {\n" 13845 " //\n" 13846 "});\n"); 13847 // FIXME: this format is not ideal and we should consider forcing the first 13848 // arg onto its own line. 13849 verifyFormat("function(a, b, c, //\n" 13850 " d, [this, that] {\n" 13851 " //\n" 13852 " });\n"); 13853 13854 // Multiple lambdas are treated correctly even when there is a short arg0. 13855 verifyFormat("SomeFunction(\n" 13856 " 1,\n" 13857 " [this] {\n" 13858 " //\n" 13859 " },\n" 13860 " [this] {\n" 13861 " //\n" 13862 " },\n" 13863 " 1);\n"); 13864 13865 // More complex introducers. 13866 verifyFormat("return [i, args...] {};"); 13867 13868 // Not lambdas. 13869 verifyFormat("constexpr char hello[]{\"hello\"};"); 13870 verifyFormat("double &operator[](int i) { return 0; }\n" 13871 "int i;"); 13872 verifyFormat("std::unique_ptr<int[]> foo() {}"); 13873 verifyFormat("int i = a[a][a]->f();"); 13874 verifyFormat("int i = (*b)[a]->f();"); 13875 13876 // Other corner cases. 13877 verifyFormat("void f() {\n" 13878 " bar([]() {} // Did not respect SpacesBeforeTrailingComments\n" 13879 " );\n" 13880 "}"); 13881 13882 // Lambdas created through weird macros. 13883 verifyFormat("void f() {\n" 13884 " MACRO((const AA &a) { return 1; });\n" 13885 " MACRO((AA &a) { return 1; });\n" 13886 "}"); 13887 13888 verifyFormat("if (blah_blah(whatever, whatever, [] {\n" 13889 " doo_dah();\n" 13890 " doo_dah();\n" 13891 " })) {\n" 13892 "}"); 13893 verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n" 13894 " doo_dah();\n" 13895 " doo_dah();\n" 13896 " })) {\n" 13897 "}"); 13898 verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n" 13899 " doo_dah();\n" 13900 " doo_dah();\n" 13901 " })) {\n" 13902 "}"); 13903 verifyFormat("auto lambda = []() {\n" 13904 " int a = 2\n" 13905 "#if A\n" 13906 " + 2\n" 13907 "#endif\n" 13908 " ;\n" 13909 "};"); 13910 13911 // Lambdas with complex multiline introducers. 13912 verifyFormat( 13913 "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 13914 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n" 13915 " -> ::std::unordered_set<\n" 13916 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n" 13917 " //\n" 13918 " });"); 13919 13920 FormatStyle DoNotMerge = getLLVMStyle(); 13921 DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; 13922 verifyFormat("auto c = []() {\n" 13923 " return b;\n" 13924 "};", 13925 "auto c = []() { return b; };", DoNotMerge); 13926 verifyFormat("auto c = []() {\n" 13927 "};", 13928 " auto c = []() {};", DoNotMerge); 13929 13930 FormatStyle MergeEmptyOnly = getLLVMStyle(); 13931 MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty; 13932 verifyFormat("auto c = []() {\n" 13933 " return b;\n" 13934 "};", 13935 "auto c = []() {\n" 13936 " return b;\n" 13937 " };", 13938 MergeEmptyOnly); 13939 verifyFormat("auto c = []() {};", 13940 "auto c = []() {\n" 13941 "};", 13942 MergeEmptyOnly); 13943 13944 FormatStyle MergeInline = getLLVMStyle(); 13945 MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline; 13946 verifyFormat("auto c = []() {\n" 13947 " return b;\n" 13948 "};", 13949 "auto c = []() { return b; };", MergeInline); 13950 verifyFormat("function([]() { return b; })", "function([]() { return b; })", 13951 MergeInline); 13952 verifyFormat("function([]() { return b; }, a)", 13953 "function([]() { return b; }, a)", MergeInline); 13954 verifyFormat("function(a, []() { return b; })", 13955 "function(a, []() { return b; })", MergeInline); 13956 } 13957 13958 TEST_F(FormatTest, EmptyLinesInLambdas) { 13959 verifyFormat("auto lambda = []() {\n" 13960 " x(); //\n" 13961 "};", 13962 "auto lambda = []() {\n" 13963 "\n" 13964 " x(); //\n" 13965 "\n" 13966 "};"); 13967 } 13968 13969 TEST_F(FormatTest, FormatsBlocks) { 13970 FormatStyle ShortBlocks = getLLVMStyle(); 13971 ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 13972 verifyFormat("int (^Block)(int, int);", ShortBlocks); 13973 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks); 13974 verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks); 13975 verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks); 13976 verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks); 13977 verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks); 13978 13979 verifyFormat("foo(^{ bar(); });", ShortBlocks); 13980 verifyFormat("foo(a, ^{ bar(); });", ShortBlocks); 13981 verifyFormat("{ void (^block)(Object *x); }", ShortBlocks); 13982 13983 verifyFormat("[operation setCompletionBlock:^{\n" 13984 " [self onOperationDone];\n" 13985 "}];"); 13986 verifyFormat("int i = {[operation setCompletionBlock:^{\n" 13987 " [self onOperationDone];\n" 13988 "}]};"); 13989 verifyFormat("[operation setCompletionBlock:^(int *i) {\n" 13990 " f();\n" 13991 "}];"); 13992 verifyFormat("int a = [operation block:^int(int *i) {\n" 13993 " return 1;\n" 13994 "}];"); 13995 verifyFormat("[myObject doSomethingWith:arg1\n" 13996 " aaa:^int(int *a) {\n" 13997 " return 1;\n" 13998 " }\n" 13999 " bbb:f(a * bbbbbbbb)];"); 14000 14001 verifyFormat("[operation setCompletionBlock:^{\n" 14002 " [self.delegate newDataAvailable];\n" 14003 "}];", 14004 getLLVMStyleWithColumns(60)); 14005 verifyFormat("dispatch_async(_fileIOQueue, ^{\n" 14006 " NSString *path = [self sessionFilePath];\n" 14007 " if (path) {\n" 14008 " // ...\n" 14009 " }\n" 14010 "});"); 14011 verifyFormat("[[SessionService sharedService]\n" 14012 " loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14013 " if (window) {\n" 14014 " [self windowDidLoad:window];\n" 14015 " } else {\n" 14016 " [self errorLoadingWindow];\n" 14017 " }\n" 14018 " }];"); 14019 verifyFormat("void (^largeBlock)(void) = ^{\n" 14020 " // ...\n" 14021 "};\n", 14022 getLLVMStyleWithColumns(40)); 14023 verifyFormat("[[SessionService sharedService]\n" 14024 " loadWindowWithCompletionBlock: //\n" 14025 " ^(SessionWindow *window) {\n" 14026 " if (window) {\n" 14027 " [self windowDidLoad:window];\n" 14028 " } else {\n" 14029 " [self errorLoadingWindow];\n" 14030 " }\n" 14031 " }];", 14032 getLLVMStyleWithColumns(60)); 14033 verifyFormat("[myObject doSomethingWith:arg1\n" 14034 " firstBlock:^(Foo *a) {\n" 14035 " // ...\n" 14036 " int i;\n" 14037 " }\n" 14038 " secondBlock:^(Bar *b) {\n" 14039 " // ...\n" 14040 " int i;\n" 14041 " }\n" 14042 " thirdBlock:^Foo(Bar *b) {\n" 14043 " // ...\n" 14044 " int i;\n" 14045 " }];"); 14046 verifyFormat("[myObject doSomethingWith:arg1\n" 14047 " firstBlock:-1\n" 14048 " secondBlock:^(Bar *b) {\n" 14049 " // ...\n" 14050 " int i;\n" 14051 " }];"); 14052 14053 verifyFormat("f(^{\n" 14054 " @autoreleasepool {\n" 14055 " if (a) {\n" 14056 " g();\n" 14057 " }\n" 14058 " }\n" 14059 "});"); 14060 verifyFormat("Block b = ^int *(A *a, B *b) {}"); 14061 verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n" 14062 "};"); 14063 14064 FormatStyle FourIndent = getLLVMStyle(); 14065 FourIndent.ObjCBlockIndentWidth = 4; 14066 verifyFormat("[operation setCompletionBlock:^{\n" 14067 " [self onOperationDone];\n" 14068 "}];", 14069 FourIndent); 14070 } 14071 14072 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) { 14073 FormatStyle ZeroColumn = getLLVMStyle(); 14074 ZeroColumn.ColumnLimit = 0; 14075 14076 verifyFormat("[[SessionService sharedService] " 14077 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14078 " if (window) {\n" 14079 " [self windowDidLoad:window];\n" 14080 " } else {\n" 14081 " [self errorLoadingWindow];\n" 14082 " }\n" 14083 "}];", 14084 ZeroColumn); 14085 EXPECT_EQ("[[SessionService sharedService]\n" 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 format("[[SessionService sharedService]\n" 14094 "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n" 14095 " if (window) {\n" 14096 " [self windowDidLoad:window];\n" 14097 " } else {\n" 14098 " [self errorLoadingWindow];\n" 14099 " }\n" 14100 "}];", 14101 ZeroColumn)); 14102 verifyFormat("[myObject doSomethingWith:arg1\n" 14103 " firstBlock:^(Foo *a) {\n" 14104 " // ...\n" 14105 " int i;\n" 14106 " }\n" 14107 " secondBlock:^(Bar *b) {\n" 14108 " // ...\n" 14109 " int i;\n" 14110 " }\n" 14111 " thirdBlock:^Foo(Bar *b) {\n" 14112 " // ...\n" 14113 " int i;\n" 14114 " }];", 14115 ZeroColumn); 14116 verifyFormat("f(^{\n" 14117 " @autoreleasepool {\n" 14118 " if (a) {\n" 14119 " g();\n" 14120 " }\n" 14121 " }\n" 14122 "});", 14123 ZeroColumn); 14124 verifyFormat("void (^largeBlock)(void) = ^{\n" 14125 " // ...\n" 14126 "};", 14127 ZeroColumn); 14128 14129 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; 14130 EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };", 14131 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 14132 ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; 14133 EXPECT_EQ("void (^largeBlock)(void) = ^{\n" 14134 " int i;\n" 14135 "};", 14136 format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn)); 14137 } 14138 14139 TEST_F(FormatTest, SupportsCRLF) { 14140 EXPECT_EQ("int a;\r\n" 14141 "int b;\r\n" 14142 "int c;\r\n", 14143 format("int a;\r\n" 14144 " int b;\r\n" 14145 " int c;\r\n", 14146 getLLVMStyle())); 14147 EXPECT_EQ("int a;\r\n" 14148 "int b;\r\n" 14149 "int c;\r\n", 14150 format("int a;\r\n" 14151 " int b;\n" 14152 " int c;\r\n", 14153 getLLVMStyle())); 14154 EXPECT_EQ("int a;\n" 14155 "int b;\n" 14156 "int c;\n", 14157 format("int a;\r\n" 14158 " int b;\n" 14159 " int c;\n", 14160 getLLVMStyle())); 14161 EXPECT_EQ("\"aaaaaaa \"\r\n" 14162 "\"bbbbbbb\";\r\n", 14163 format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10))); 14164 EXPECT_EQ("#define A \\\r\n" 14165 " b; \\\r\n" 14166 " c; \\\r\n" 14167 " d;\r\n", 14168 format("#define A \\\r\n" 14169 " b; \\\r\n" 14170 " c; d; \r\n", 14171 getGoogleStyle())); 14172 14173 EXPECT_EQ("/*\r\n" 14174 "multi line block comments\r\n" 14175 "should not introduce\r\n" 14176 "an extra carriage return\r\n" 14177 "*/\r\n", 14178 format("/*\r\n" 14179 "multi line block comments\r\n" 14180 "should not introduce\r\n" 14181 "an extra carriage return\r\n" 14182 "*/\r\n")); 14183 EXPECT_EQ("/*\r\n" 14184 "\r\n" 14185 "*/", 14186 format("/*\r\n" 14187 " \r\r\r\n" 14188 "*/")); 14189 14190 FormatStyle style = getLLVMStyle(); 14191 14192 style.DeriveLineEnding = true; 14193 style.UseCRLF = false; 14194 EXPECT_EQ("union FooBarBazQux {\n" 14195 " int foo;\n" 14196 " int bar;\n" 14197 " int baz;\n" 14198 "};", 14199 format("union FooBarBazQux {\r\n" 14200 " int foo;\n" 14201 " int bar;\r\n" 14202 " int baz;\n" 14203 "};", 14204 style)); 14205 style.UseCRLF = true; 14206 EXPECT_EQ("union FooBarBazQux {\r\n" 14207 " int foo;\r\n" 14208 " int bar;\r\n" 14209 " int baz;\r\n" 14210 "};", 14211 format("union FooBarBazQux {\r\n" 14212 " int foo;\n" 14213 " int bar;\r\n" 14214 " int baz;\n" 14215 "};", 14216 style)); 14217 14218 style.DeriveLineEnding = false; 14219 style.UseCRLF = false; 14220 EXPECT_EQ("union FooBarBazQux {\n" 14221 " int foo;\n" 14222 " int bar;\n" 14223 " int baz;\n" 14224 " int qux;\n" 14225 "};", 14226 format("union FooBarBazQux {\r\n" 14227 " int foo;\n" 14228 " int bar;\r\n" 14229 " int baz;\n" 14230 " int qux;\r\n" 14231 "};", 14232 style)); 14233 style.UseCRLF = true; 14234 EXPECT_EQ("union FooBarBazQux {\r\n" 14235 " int foo;\r\n" 14236 " int bar;\r\n" 14237 " int baz;\r\n" 14238 " int qux;\r\n" 14239 "};", 14240 format("union FooBarBazQux {\r\n" 14241 " int foo;\n" 14242 " int bar;\r\n" 14243 " int baz;\n" 14244 " int qux;\n" 14245 "};", 14246 style)); 14247 14248 style.DeriveLineEnding = true; 14249 style.UseCRLF = false; 14250 EXPECT_EQ("union FooBarBazQux {\r\n" 14251 " int foo;\r\n" 14252 " int bar;\r\n" 14253 " int baz;\r\n" 14254 " int qux;\r\n" 14255 "};", 14256 format("union FooBarBazQux {\r\n" 14257 " int foo;\n" 14258 " int bar;\r\n" 14259 " int baz;\n" 14260 " int qux;\r\n" 14261 "};", 14262 style)); 14263 style.UseCRLF = true; 14264 EXPECT_EQ("union FooBarBazQux {\n" 14265 " int foo;\n" 14266 " int bar;\n" 14267 " int baz;\n" 14268 " int qux;\n" 14269 "};", 14270 format("union FooBarBazQux {\r\n" 14271 " int foo;\n" 14272 " int bar;\r\n" 14273 " int baz;\n" 14274 " int qux;\n" 14275 "};", 14276 style)); 14277 } 14278 14279 TEST_F(FormatTest, MunchSemicolonAfterBlocks) { 14280 verifyFormat("MY_CLASS(C) {\n" 14281 " int i;\n" 14282 " int j;\n" 14283 "};"); 14284 } 14285 14286 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) { 14287 FormatStyle TwoIndent = getLLVMStyleWithColumns(15); 14288 TwoIndent.ContinuationIndentWidth = 2; 14289 14290 EXPECT_EQ("int i =\n" 14291 " longFunction(\n" 14292 " arg);", 14293 format("int i = longFunction(arg);", TwoIndent)); 14294 14295 FormatStyle SixIndent = getLLVMStyleWithColumns(20); 14296 SixIndent.ContinuationIndentWidth = 6; 14297 14298 EXPECT_EQ("int i =\n" 14299 " longFunction(\n" 14300 " arg);", 14301 format("int i = longFunction(arg);", SixIndent)); 14302 } 14303 14304 TEST_F(FormatTest, WrappedClosingParenthesisIndent) { 14305 FormatStyle Style = getLLVMStyle(); 14306 verifyFormat("int Foo::getter(\n" 14307 " //\n" 14308 ") const {\n" 14309 " return foo;\n" 14310 "}", 14311 Style); 14312 verifyFormat("void Foo::setter(\n" 14313 " //\n" 14314 ") {\n" 14315 " foo = 1;\n" 14316 "}", 14317 Style); 14318 } 14319 14320 TEST_F(FormatTest, SpacesInAngles) { 14321 FormatStyle Spaces = getLLVMStyle(); 14322 Spaces.SpacesInAngles = true; 14323 14324 verifyFormat("static_cast< int >(arg);", Spaces); 14325 verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces); 14326 verifyFormat("f< int, float >();", Spaces); 14327 verifyFormat("template <> g() {}", Spaces); 14328 verifyFormat("template < std::vector< int > > f() {}", Spaces); 14329 verifyFormat("std::function< void(int, int) > fct;", Spaces); 14330 verifyFormat("void inFunction() { std::function< void(int, int) > fct; }", 14331 Spaces); 14332 14333 Spaces.Standard = FormatStyle::LS_Cpp03; 14334 Spaces.SpacesInAngles = true; 14335 verifyFormat("A< A< int > >();", Spaces); 14336 14337 Spaces.SpacesInAngles = false; 14338 verifyFormat("A<A<int> >();", Spaces); 14339 14340 Spaces.Standard = FormatStyle::LS_Cpp11; 14341 Spaces.SpacesInAngles = true; 14342 verifyFormat("A< A< int > >();", Spaces); 14343 14344 Spaces.SpacesInAngles = false; 14345 verifyFormat("A<A<int>>();", Spaces); 14346 } 14347 14348 TEST_F(FormatTest, SpaceAfterTemplateKeyword) { 14349 FormatStyle Style = getLLVMStyle(); 14350 Style.SpaceAfterTemplateKeyword = false; 14351 verifyFormat("template<int> void foo();", Style); 14352 } 14353 14354 TEST_F(FormatTest, TripleAngleBrackets) { 14355 verifyFormat("f<<<1, 1>>>();"); 14356 verifyFormat("f<<<1, 1, 1, s>>>();"); 14357 verifyFormat("f<<<a, b, c, d>>>();"); 14358 EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();")); 14359 verifyFormat("f<param><<<1, 1>>>();"); 14360 verifyFormat("f<1><<<1, 1>>>();"); 14361 EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();")); 14362 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14363 "aaaaaaaaaaa<<<\n 1, 1>>>();"); 14364 verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n" 14365 " <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();"); 14366 } 14367 14368 TEST_F(FormatTest, MergeLessLessAtEnd) { 14369 verifyFormat("<<"); 14370 EXPECT_EQ("< < <", format("\\\n<<<")); 14371 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14372 "aaallvm::outs() <<"); 14373 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" 14374 "aaaallvm::outs()\n <<"); 14375 } 14376 14377 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) { 14378 std::string code = "#if A\n" 14379 "#if B\n" 14380 "a.\n" 14381 "#endif\n" 14382 " a = 1;\n" 14383 "#else\n" 14384 "#endif\n" 14385 "#if C\n" 14386 "#else\n" 14387 "#endif\n"; 14388 EXPECT_EQ(code, format(code)); 14389 } 14390 14391 TEST_F(FormatTest, HandleConflictMarkers) { 14392 // Git/SVN conflict markers. 14393 EXPECT_EQ("int a;\n" 14394 "void f() {\n" 14395 " callme(some(parameter1,\n" 14396 "<<<<<<< text by the vcs\n" 14397 " parameter2),\n" 14398 "||||||| text by the vcs\n" 14399 " parameter2),\n" 14400 " parameter3,\n" 14401 "======= text by the vcs\n" 14402 " parameter2, parameter3),\n" 14403 ">>>>>>> text by the vcs\n" 14404 " otherparameter);\n", 14405 format("int a;\n" 14406 "void f() {\n" 14407 " callme(some(parameter1,\n" 14408 "<<<<<<< text by the vcs\n" 14409 " parameter2),\n" 14410 "||||||| text by the vcs\n" 14411 " parameter2),\n" 14412 " parameter3,\n" 14413 "======= text by the vcs\n" 14414 " parameter2,\n" 14415 " parameter3),\n" 14416 ">>>>>>> text by the vcs\n" 14417 " otherparameter);\n")); 14418 14419 // Perforce markers. 14420 EXPECT_EQ("void f() {\n" 14421 " function(\n" 14422 ">>>> text by the vcs\n" 14423 " parameter,\n" 14424 "==== text by the vcs\n" 14425 " parameter,\n" 14426 "==== text by the vcs\n" 14427 " parameter,\n" 14428 "<<<< text by the vcs\n" 14429 " parameter);\n", 14430 format("void f() {\n" 14431 " function(\n" 14432 ">>>> text by the vcs\n" 14433 " parameter,\n" 14434 "==== text by the vcs\n" 14435 " parameter,\n" 14436 "==== text by the vcs\n" 14437 " parameter,\n" 14438 "<<<< text by the vcs\n" 14439 " parameter);\n")); 14440 14441 EXPECT_EQ("<<<<<<<\n" 14442 "|||||||\n" 14443 "=======\n" 14444 ">>>>>>>", 14445 format("<<<<<<<\n" 14446 "|||||||\n" 14447 "=======\n" 14448 ">>>>>>>")); 14449 14450 EXPECT_EQ("<<<<<<<\n" 14451 "|||||||\n" 14452 "int i;\n" 14453 "=======\n" 14454 ">>>>>>>", 14455 format("<<<<<<<\n" 14456 "|||||||\n" 14457 "int i;\n" 14458 "=======\n" 14459 ">>>>>>>")); 14460 14461 // FIXME: Handle parsing of macros around conflict markers correctly: 14462 EXPECT_EQ("#define Macro \\\n" 14463 "<<<<<<<\n" 14464 "Something \\\n" 14465 "|||||||\n" 14466 "Else \\\n" 14467 "=======\n" 14468 "Other \\\n" 14469 ">>>>>>>\n" 14470 " End int i;\n", 14471 format("#define Macro \\\n" 14472 "<<<<<<<\n" 14473 " Something \\\n" 14474 "|||||||\n" 14475 " Else \\\n" 14476 "=======\n" 14477 " Other \\\n" 14478 ">>>>>>>\n" 14479 " End\n" 14480 "int i;\n")); 14481 } 14482 14483 TEST_F(FormatTest, DisableRegions) { 14484 EXPECT_EQ("int i;\n" 14485 "// clang-format off\n" 14486 " int j;\n" 14487 "// clang-format on\n" 14488 "int k;", 14489 format(" int i;\n" 14490 " // clang-format off\n" 14491 " int j;\n" 14492 " // clang-format on\n" 14493 " int k;")); 14494 EXPECT_EQ("int i;\n" 14495 "/* clang-format off */\n" 14496 " int j;\n" 14497 "/* clang-format on */\n" 14498 "int k;", 14499 format(" int i;\n" 14500 " /* clang-format off */\n" 14501 " int j;\n" 14502 " /* clang-format on */\n" 14503 " int k;")); 14504 14505 // Don't reflow comments within disabled regions. 14506 EXPECT_EQ("// clang-format off\n" 14507 "// long long long long long long line\n" 14508 "/* clang-format on */\n" 14509 "/* long long long\n" 14510 " * long long long\n" 14511 " * line */\n" 14512 "int i;\n" 14513 "/* clang-format off */\n" 14514 "/* long long long long long long line */\n", 14515 format("// clang-format off\n" 14516 "// long long long long long long line\n" 14517 "/* clang-format on */\n" 14518 "/* long long long long long long line */\n" 14519 "int i;\n" 14520 "/* clang-format off */\n" 14521 "/* long long long long long long line */\n", 14522 getLLVMStyleWithColumns(20))); 14523 } 14524 14525 TEST_F(FormatTest, DoNotCrashOnInvalidInput) { 14526 format("? ) ="); 14527 verifyNoCrash("#define a\\\n /**/}"); 14528 } 14529 14530 TEST_F(FormatTest, FormatsTableGenCode) { 14531 FormatStyle Style = getLLVMStyle(); 14532 Style.Language = FormatStyle::LK_TableGen; 14533 verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style); 14534 } 14535 14536 TEST_F(FormatTest, ArrayOfTemplates) { 14537 EXPECT_EQ("auto a = new unique_ptr<int>[10];", 14538 format("auto a = new unique_ptr<int > [ 10];")); 14539 14540 FormatStyle Spaces = getLLVMStyle(); 14541 Spaces.SpacesInSquareBrackets = true; 14542 EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];", 14543 format("auto a = new unique_ptr<int > [10];", Spaces)); 14544 } 14545 14546 TEST_F(FormatTest, ArrayAsTemplateType) { 14547 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;", 14548 format("auto a = unique_ptr < Foo < Bar>[ 10]> ;")); 14549 14550 FormatStyle Spaces = getLLVMStyle(); 14551 Spaces.SpacesInSquareBrackets = true; 14552 EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;", 14553 format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces)); 14554 } 14555 14556 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); } 14557 14558 TEST(FormatStyle, GetStyleWithEmptyFileName) { 14559 llvm::vfs::InMemoryFileSystem FS; 14560 auto Style1 = getStyle("file", "", "Google", "", &FS); 14561 ASSERT_TRUE((bool)Style1); 14562 ASSERT_EQ(*Style1, getGoogleStyle()); 14563 } 14564 14565 TEST(FormatStyle, GetStyleOfFile) { 14566 llvm::vfs::InMemoryFileSystem FS; 14567 // Test 1: format file in the same directory. 14568 ASSERT_TRUE( 14569 FS.addFile("/a/.clang-format", 0, 14570 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM"))); 14571 ASSERT_TRUE( 14572 FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14573 auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS); 14574 ASSERT_TRUE((bool)Style1); 14575 ASSERT_EQ(*Style1, getLLVMStyle()); 14576 14577 // Test 2.1: fallback to default. 14578 ASSERT_TRUE( 14579 FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14580 auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS); 14581 ASSERT_TRUE((bool)Style2); 14582 ASSERT_EQ(*Style2, getMozillaStyle()); 14583 14584 // Test 2.2: no format on 'none' fallback style. 14585 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 14586 ASSERT_TRUE((bool)Style2); 14587 ASSERT_EQ(*Style2, getNoStyle()); 14588 14589 // Test 2.3: format if config is found with no based style while fallback is 14590 // 'none'. 14591 ASSERT_TRUE(FS.addFile("/b/.clang-format", 0, 14592 llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2"))); 14593 Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS); 14594 ASSERT_TRUE((bool)Style2); 14595 ASSERT_EQ(*Style2, getLLVMStyle()); 14596 14597 // Test 2.4: format if yaml with no based style, while fallback is 'none'. 14598 Style2 = getStyle("{}", "a.h", "none", "", &FS); 14599 ASSERT_TRUE((bool)Style2); 14600 ASSERT_EQ(*Style2, getLLVMStyle()); 14601 14602 // Test 3: format file in parent directory. 14603 ASSERT_TRUE( 14604 FS.addFile("/c/.clang-format", 0, 14605 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google"))); 14606 ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0, 14607 llvm::MemoryBuffer::getMemBuffer("int i;"))); 14608 auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS); 14609 ASSERT_TRUE((bool)Style3); 14610 ASSERT_EQ(*Style3, getGoogleStyle()); 14611 14612 // Test 4: error on invalid fallback style 14613 auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS); 14614 ASSERT_FALSE((bool)Style4); 14615 llvm::consumeError(Style4.takeError()); 14616 14617 // Test 5: error on invalid yaml on command line 14618 auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS); 14619 ASSERT_FALSE((bool)Style5); 14620 llvm::consumeError(Style5.takeError()); 14621 14622 // Test 6: error on invalid style 14623 auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS); 14624 ASSERT_FALSE((bool)Style6); 14625 llvm::consumeError(Style6.takeError()); 14626 14627 // Test 7: found config file, error on parsing it 14628 ASSERT_TRUE( 14629 FS.addFile("/d/.clang-format", 0, 14630 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n" 14631 "InvalidKey: InvalidValue"))); 14632 ASSERT_TRUE( 14633 FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;"))); 14634 auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS); 14635 ASSERT_FALSE((bool)Style7); 14636 llvm::consumeError(Style7.takeError()); 14637 14638 // Test 8: inferred per-language defaults apply. 14639 auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS); 14640 ASSERT_TRUE((bool)StyleTd); 14641 ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen)); 14642 } 14643 14644 TEST_F(ReplacementTest, FormatCodeAfterReplacements) { 14645 // Column limit is 20. 14646 std::string Code = "Type *a =\n" 14647 " new Type();\n" 14648 "g(iiiii, 0, jjjjj,\n" 14649 " 0, kkkkk, 0, mm);\n" 14650 "int bad = format ;"; 14651 std::string Expected = "auto a = new Type();\n" 14652 "g(iiiii, nullptr,\n" 14653 " jjjjj, nullptr,\n" 14654 " kkkkk, nullptr,\n" 14655 " mm);\n" 14656 "int bad = format ;"; 14657 FileID ID = Context.createInMemoryFile("format.cpp", Code); 14658 tooling::Replacements Replaces = toReplacements( 14659 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6, 14660 "auto "), 14661 tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1, 14662 "nullptr"), 14663 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1, 14664 "nullptr"), 14665 tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1, 14666 "nullptr")}); 14667 14668 format::FormatStyle Style = format::getLLVMStyle(); 14669 Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility. 14670 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 14671 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 14672 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 14673 auto Result = applyAllReplacements(Code, *FormattedReplaces); 14674 EXPECT_TRUE(static_cast<bool>(Result)); 14675 EXPECT_EQ(Expected, *Result); 14676 } 14677 14678 TEST_F(ReplacementTest, SortIncludesAfterReplacement) { 14679 std::string Code = "#include \"a.h\"\n" 14680 "#include \"c.h\"\n" 14681 "\n" 14682 "int main() {\n" 14683 " return 0;\n" 14684 "}"; 14685 std::string Expected = "#include \"a.h\"\n" 14686 "#include \"b.h\"\n" 14687 "#include \"c.h\"\n" 14688 "\n" 14689 "int main() {\n" 14690 " return 0;\n" 14691 "}"; 14692 FileID ID = Context.createInMemoryFile("fix.cpp", Code); 14693 tooling::Replacements Replaces = toReplacements( 14694 {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0, 14695 "#include \"b.h\"\n")}); 14696 14697 format::FormatStyle Style = format::getLLVMStyle(); 14698 Style.SortIncludes = true; 14699 auto FormattedReplaces = formatReplacements(Code, Replaces, Style); 14700 EXPECT_TRUE(static_cast<bool>(FormattedReplaces)) 14701 << llvm::toString(FormattedReplaces.takeError()) << "\n"; 14702 auto Result = applyAllReplacements(Code, *FormattedReplaces); 14703 EXPECT_TRUE(static_cast<bool>(Result)); 14704 EXPECT_EQ(Expected, *Result); 14705 } 14706 14707 TEST_F(FormatTest, FormatSortsUsingDeclarations) { 14708 EXPECT_EQ("using std::cin;\n" 14709 "using std::cout;", 14710 format("using std::cout;\n" 14711 "using std::cin;", 14712 getGoogleStyle())); 14713 } 14714 14715 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) { 14716 format::FormatStyle Style = format::getLLVMStyle(); 14717 Style.Standard = FormatStyle::LS_Cpp03; 14718 // cpp03 recognize this string as identifier u8 and literal character 'a' 14719 EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style)); 14720 } 14721 14722 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) { 14723 // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers 14724 // all modes, including C++11, C++14 and C++17 14725 EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';")); 14726 } 14727 14728 TEST_F(FormatTest, DoNotFormatLikelyXml) { 14729 EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle())); 14730 EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle())); 14731 } 14732 14733 TEST_F(FormatTest, StructuredBindings) { 14734 // Structured bindings is a C++17 feature. 14735 // all modes, including C++11, C++14 and C++17 14736 verifyFormat("auto [a, b] = f();"); 14737 EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();")); 14738 EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();")); 14739 EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();")); 14740 EXPECT_EQ("auto const volatile [a, b] = f();", 14741 format("auto const volatile[a, b] = f();")); 14742 EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();")); 14743 EXPECT_EQ("auto &[a, b, c] = f();", 14744 format("auto &[ a , b,c ] = f();")); 14745 EXPECT_EQ("auto &&[a, b, c] = f();", 14746 format("auto &&[ a , b,c ] = f();")); 14747 EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();")); 14748 EXPECT_EQ("auto const volatile &&[a, b] = f();", 14749 format("auto const volatile &&[a, b] = f();")); 14750 EXPECT_EQ("auto const &&[a, b] = f();", 14751 format("auto const && [a, b] = f();")); 14752 EXPECT_EQ("const auto &[a, b] = f();", 14753 format("const auto & [a, b] = f();")); 14754 EXPECT_EQ("const auto volatile &&[a, b] = f();", 14755 format("const auto volatile &&[a, b] = f();")); 14756 EXPECT_EQ("volatile const auto &&[a, b] = f();", 14757 format("volatile const auto &&[a, b] = f();")); 14758 EXPECT_EQ("const auto &&[a, b] = f();", 14759 format("const auto && [a, b] = f();")); 14760 14761 // Make sure we don't mistake structured bindings for lambdas. 14762 FormatStyle PointerMiddle = getLLVMStyle(); 14763 PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle; 14764 verifyFormat("auto [a1, b]{A * i};", getGoogleStyle()); 14765 verifyFormat("auto [a2, b]{A * i};", getLLVMStyle()); 14766 verifyFormat("auto [a3, b]{A * i};", PointerMiddle); 14767 verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle()); 14768 verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle()); 14769 verifyFormat("auto const [a3, b]{A * i};", PointerMiddle); 14770 verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle()); 14771 verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle()); 14772 verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle); 14773 verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle()); 14774 verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle()); 14775 verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle); 14776 14777 EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}", 14778 format("for (const auto && [a, b] : some_range) {\n}")); 14779 EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}", 14780 format("for (const auto & [a, b] : some_range) {\n}")); 14781 EXPECT_EQ("for (const auto [a, b] : some_range) {\n}", 14782 format("for (const auto[a, b] : some_range) {\n}")); 14783 EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);")); 14784 EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);")); 14785 EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);")); 14786 EXPECT_EQ("auto const &[x, y](expr);", 14787 format("auto const & [x,y] (expr);")); 14788 EXPECT_EQ("auto const &&[x, y](expr);", 14789 format("auto const && [x,y] (expr);")); 14790 EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};")); 14791 EXPECT_EQ("auto const &[x, y]{expr};", 14792 format("auto const & [x,y] {expr};")); 14793 EXPECT_EQ("auto const &&[x, y]{expr};", 14794 format("auto const && [x,y] {expr};")); 14795 14796 format::FormatStyle Spaces = format::getLLVMStyle(); 14797 Spaces.SpacesInSquareBrackets = true; 14798 verifyFormat("auto [ a, b ] = f();", Spaces); 14799 verifyFormat("auto &&[ a, b ] = f();", Spaces); 14800 verifyFormat("auto &[ a, b ] = f();", Spaces); 14801 verifyFormat("auto const &&[ a, b ] = f();", Spaces); 14802 verifyFormat("auto const &[ a, b ] = f();", Spaces); 14803 } 14804 14805 TEST_F(FormatTest, FileAndCode) { 14806 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", "")); 14807 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", "")); 14808 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", "")); 14809 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "")); 14810 EXPECT_EQ(FormatStyle::LK_ObjC, 14811 guessLanguage("foo.h", "@interface Foo\n@end\n")); 14812 EXPECT_EQ( 14813 FormatStyle::LK_ObjC, 14814 guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }")); 14815 EXPECT_EQ(FormatStyle::LK_ObjC, 14816 guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))")); 14817 EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;")); 14818 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", "")); 14819 EXPECT_EQ(FormatStyle::LK_ObjC, 14820 guessLanguage("foo", "@interface Foo\n@end\n")); 14821 EXPECT_EQ(FormatStyle::LK_ObjC, 14822 guessLanguage("foo.h", "int DoStuff(CGRect rect);\n")); 14823 EXPECT_EQ( 14824 FormatStyle::LK_ObjC, 14825 guessLanguage("foo.h", 14826 "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n")); 14827 EXPECT_EQ( 14828 FormatStyle::LK_Cpp, 14829 guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;")); 14830 } 14831 14832 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) { 14833 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];")); 14834 EXPECT_EQ(FormatStyle::LK_ObjC, 14835 guessLanguage("foo.h", "array[[calculator getIndex]];")); 14836 EXPECT_EQ(FormatStyle::LK_Cpp, 14837 guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];")); 14838 EXPECT_EQ( 14839 FormatStyle::LK_Cpp, 14840 guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];")); 14841 EXPECT_EQ(FormatStyle::LK_ObjC, 14842 guessLanguage("foo.h", "[[noreturn foo] bar];")); 14843 EXPECT_EQ(FormatStyle::LK_Cpp, 14844 guessLanguage("foo.h", "[[clang::fallthrough]];")); 14845 EXPECT_EQ(FormatStyle::LK_ObjC, 14846 guessLanguage("foo.h", "[[clang:fallthrough] foo];")); 14847 EXPECT_EQ(FormatStyle::LK_Cpp, 14848 guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];")); 14849 EXPECT_EQ(FormatStyle::LK_Cpp, 14850 guessLanguage("foo.h", "[[using clang: fallthrough]];")); 14851 EXPECT_EQ(FormatStyle::LK_ObjC, 14852 guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];")); 14853 EXPECT_EQ(FormatStyle::LK_Cpp, 14854 guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];")); 14855 EXPECT_EQ( 14856 FormatStyle::LK_Cpp, 14857 guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)")); 14858 EXPECT_EQ( 14859 FormatStyle::LK_Cpp, 14860 guessLanguage("foo.h", 14861 "[[clang::callable_when(\"unconsumed\", \"unknown\")]]")); 14862 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]")); 14863 } 14864 14865 TEST_F(FormatTest, GuessLanguageWithCaret) { 14866 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);")); 14867 EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);")); 14868 EXPECT_EQ(FormatStyle::LK_ObjC, 14869 guessLanguage("foo.h", "int(^)(char, float);")); 14870 EXPECT_EQ(FormatStyle::LK_ObjC, 14871 guessLanguage("foo.h", "int(^foo)(char, float);")); 14872 EXPECT_EQ(FormatStyle::LK_ObjC, 14873 guessLanguage("foo.h", "int(^foo[10])(char, float);")); 14874 EXPECT_EQ(FormatStyle::LK_ObjC, 14875 guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);")); 14876 EXPECT_EQ( 14877 FormatStyle::LK_ObjC, 14878 guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);")); 14879 } 14880 14881 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) { 14882 EXPECT_EQ(FormatStyle::LK_Cpp, 14883 guessLanguage("foo.h", "void f() {\n" 14884 " asm (\"mov %[e], %[d]\"\n" 14885 " : [d] \"=rm\" (d)\n" 14886 " [e] \"rm\" (*e));\n" 14887 "}")); 14888 EXPECT_EQ(FormatStyle::LK_Cpp, 14889 guessLanguage("foo.h", "void f() {\n" 14890 " _asm (\"mov %[e], %[d]\"\n" 14891 " : [d] \"=rm\" (d)\n" 14892 " [e] \"rm\" (*e));\n" 14893 "}")); 14894 EXPECT_EQ(FormatStyle::LK_Cpp, 14895 guessLanguage("foo.h", "void f() {\n" 14896 " __asm (\"mov %[e], %[d]\"\n" 14897 " : [d] \"=rm\" (d)\n" 14898 " [e] \"rm\" (*e));\n" 14899 "}")); 14900 EXPECT_EQ(FormatStyle::LK_Cpp, 14901 guessLanguage("foo.h", "void f() {\n" 14902 " __asm__ (\"mov %[e], %[d]\"\n" 14903 " : [d] \"=rm\" (d)\n" 14904 " [e] \"rm\" (*e));\n" 14905 "}")); 14906 EXPECT_EQ(FormatStyle::LK_Cpp, 14907 guessLanguage("foo.h", "void f() {\n" 14908 " asm (\"mov %[e], %[d]\"\n" 14909 " : [d] \"=rm\" (d),\n" 14910 " [e] \"rm\" (*e));\n" 14911 "}")); 14912 EXPECT_EQ(FormatStyle::LK_Cpp, 14913 guessLanguage("foo.h", "void f() {\n" 14914 " asm volatile (\"mov %[e], %[d]\"\n" 14915 " : [d] \"=rm\" (d)\n" 14916 " [e] \"rm\" (*e));\n" 14917 "}")); 14918 } 14919 14920 TEST_F(FormatTest, GuessLanguageWithChildLines) { 14921 EXPECT_EQ(FormatStyle::LK_Cpp, 14922 guessLanguage("foo.h", "#define FOO ({ std::string s; })")); 14923 EXPECT_EQ(FormatStyle::LK_ObjC, 14924 guessLanguage("foo.h", "#define FOO ({ NSString *s; })")); 14925 EXPECT_EQ( 14926 FormatStyle::LK_Cpp, 14927 guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })")); 14928 EXPECT_EQ( 14929 FormatStyle::LK_ObjC, 14930 guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })")); 14931 } 14932 14933 TEST_F(FormatTest, TypenameMacros) { 14934 std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"}; 14935 14936 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353 14937 FormatStyle Google = getGoogleStyleWithColumns(0); 14938 Google.TypenameMacros = TypenameMacros; 14939 verifyFormat("struct foo {\n" 14940 " int bar;\n" 14941 " TAILQ_ENTRY(a) bleh;\n" 14942 "};", 14943 Google); 14944 14945 FormatStyle Macros = getLLVMStyle(); 14946 Macros.TypenameMacros = TypenameMacros; 14947 14948 verifyFormat("STACK_OF(int) a;", Macros); 14949 verifyFormat("STACK_OF(int) *a;", Macros); 14950 verifyFormat("STACK_OF(int const *) *a;", Macros); 14951 verifyFormat("STACK_OF(int *const) *a;", Macros); 14952 verifyFormat("STACK_OF(int, string) a;", Macros); 14953 verifyFormat("STACK_OF(LIST(int)) a;", Macros); 14954 verifyFormat("STACK_OF(LIST(int)) a, b;", Macros); 14955 verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros); 14956 verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros); 14957 14958 Macros.PointerAlignment = FormatStyle::PAS_Left; 14959 verifyFormat("STACK_OF(int)* a;", Macros); 14960 verifyFormat("STACK_OF(int*)* a;", Macros); 14961 } 14962 14963 TEST_F(FormatTest, AmbersandInLamda) { 14964 // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899 14965 FormatStyle AlignStyle = getLLVMStyle(); 14966 AlignStyle.PointerAlignment = FormatStyle::PAS_Left; 14967 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 14968 AlignStyle.PointerAlignment = FormatStyle::PAS_Right; 14969 verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle); 14970 } 14971 14972 TEST_F(FormatTest, SpacesInConditionalStatement) { 14973 FormatStyle Spaces = getLLVMStyle(); 14974 Spaces.SpacesInConditionalStatement = true; 14975 verifyFormat("for ( int i = 0; i; i++ )\n continue;", Spaces); 14976 verifyFormat("if ( !a )\n return;", Spaces); 14977 verifyFormat("if ( a )\n return;", Spaces); 14978 verifyFormat("if constexpr ( a )\n return;", Spaces); 14979 verifyFormat("switch ( a )\ncase 1:\n return;", Spaces); 14980 verifyFormat("while ( a )\n return;", Spaces); 14981 verifyFormat("while ( (a && b) )\n return;", Spaces); 14982 verifyFormat("do {\n} while ( 1 != 0 );", Spaces); 14983 verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces); 14984 // Check that space on the left of "::" is inserted as expected at beginning 14985 // of condition. 14986 verifyFormat("while ( ::func() )\n return;", Spaces); 14987 } 14988 14989 TEST_F(FormatTest, AlternativeOperators) { 14990 // Test case for ensuring alternate operators are not 14991 // combined with their right most neighbour. 14992 verifyFormat("int a and b;"); 14993 verifyFormat("int a and_eq b;"); 14994 verifyFormat("int a bitand b;"); 14995 verifyFormat("int a bitor b;"); 14996 verifyFormat("int a compl b;"); 14997 verifyFormat("int a not b;"); 14998 verifyFormat("int a not_eq b;"); 14999 verifyFormat("int a or b;"); 15000 verifyFormat("int a xor b;"); 15001 verifyFormat("int a xor_eq b;"); 15002 verifyFormat("return this not_eq bitand other;"); 15003 verifyFormat("bool operator not_eq(const X bitand other)"); 15004 15005 verifyFormat("int a and 5;"); 15006 verifyFormat("int a and_eq 5;"); 15007 verifyFormat("int a bitand 5;"); 15008 verifyFormat("int a bitor 5;"); 15009 verifyFormat("int a compl 5;"); 15010 verifyFormat("int a not 5;"); 15011 verifyFormat("int a not_eq 5;"); 15012 verifyFormat("int a or 5;"); 15013 verifyFormat("int a xor 5;"); 15014 verifyFormat("int a xor_eq 5;"); 15015 15016 verifyFormat("int a compl(5);"); 15017 verifyFormat("int a not(5);"); 15018 15019 /* FIXME handle alternate tokens 15020 * https://en.cppreference.com/w/cpp/language/operator_alternative 15021 // alternative tokens 15022 verifyFormat("compl foo();"); // ~foo(); 15023 verifyFormat("foo() <%%>;"); // foo(); 15024 verifyFormat("void foo() <%%>;"); // void foo(){} 15025 verifyFormat("int a <:1:>;"); // int a[1];[ 15026 verifyFormat("%:define ABC abc"); // #define ABC abc 15027 verifyFormat("%:%:"); // ## 15028 */ 15029 } 15030 15031 TEST_F(FormatTest, STLWhileNotDefineChed) { 15032 verifyFormat("#if defined(while)\n" 15033 "#define while EMIT WARNING C4005\n" 15034 "#endif // while"); 15035 } 15036 15037 TEST_F(FormatTest, OperatorSpacing) { 15038 FormatStyle Style = getLLVMStyle(); 15039 Style.PointerAlignment = FormatStyle::PAS_Right; 15040 verifyFormat("Foo::operator*();", Style); 15041 verifyFormat("Foo::operator void *();", Style); 15042 verifyFormat("Foo::operator()(void *);", Style); 15043 verifyFormat("Foo::operator*(void *);", Style); 15044 verifyFormat("Foo::operator*();", Style); 15045 verifyFormat("operator*(int (*)(), class Foo);", Style); 15046 15047 verifyFormat("Foo::operator&();", Style); 15048 verifyFormat("Foo::operator void &();", Style); 15049 verifyFormat("Foo::operator()(void &);", Style); 15050 verifyFormat("Foo::operator&(void &);", Style); 15051 verifyFormat("Foo::operator&();", Style); 15052 verifyFormat("operator&(int (&)(), class Foo);", Style); 15053 15054 verifyFormat("Foo::operator&&();", Style); 15055 verifyFormat("Foo::operator void &&();", Style); 15056 verifyFormat("Foo::operator()(void &&);", Style); 15057 verifyFormat("Foo::operator&&(void &&);", Style); 15058 verifyFormat("Foo::operator&&();", Style); 15059 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15060 15061 Style.PointerAlignment = FormatStyle::PAS_Left; 15062 verifyFormat("Foo::operator*();", Style); 15063 verifyFormat("Foo::operator void*();", Style); 15064 verifyFormat("Foo::operator/*comment*/ void*();", Style); 15065 verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style); 15066 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style); 15067 verifyFormat("Foo::operator()(void*);", Style); 15068 verifyFormat("Foo::operator*(void*);", Style); 15069 verifyFormat("Foo::operator*();", Style); 15070 verifyFormat("operator*(int (*)(), class Foo);", Style); 15071 15072 verifyFormat("Foo::operator&();", Style); 15073 verifyFormat("Foo::operator void&();", Style); 15074 verifyFormat("Foo::operator/*comment*/ void&();", Style); 15075 verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style); 15076 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style); 15077 verifyFormat("Foo::operator()(void&);", Style); 15078 verifyFormat("Foo::operator&(void&);", Style); 15079 verifyFormat("Foo::operator&();", Style); 15080 verifyFormat("operator&(int (&)(), class Foo);", Style); 15081 15082 verifyFormat("Foo::operator&&();", Style); 15083 verifyFormat("Foo::operator void&&();", Style); 15084 verifyFormat("Foo::operator/*comment*/ void&&();", Style); 15085 verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style); 15086 verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style); 15087 verifyFormat("Foo::operator()(void&&);", Style); 15088 verifyFormat("Foo::operator&&(void&&);", Style); 15089 verifyFormat("Foo::operator&&();", Style); 15090 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15091 15092 Style.PointerAlignment = FormatStyle::PAS_Middle; 15093 verifyFormat("Foo::operator*();", Style); 15094 verifyFormat("Foo::operator void *();", Style); 15095 verifyFormat("Foo::operator()(void *);", Style); 15096 verifyFormat("Foo::operator*(void *);", Style); 15097 verifyFormat("Foo::operator*();", Style); 15098 verifyFormat("operator*(int (*)(), class Foo);", Style); 15099 15100 verifyFormat("Foo::operator&();", Style); 15101 verifyFormat("Foo::operator void &();", Style); 15102 verifyFormat("Foo::operator()(void &);", Style); 15103 verifyFormat("Foo::operator&(void &);", Style); 15104 verifyFormat("Foo::operator&();", Style); 15105 verifyFormat("operator&(int (&)(), class Foo);", Style); 15106 15107 verifyFormat("Foo::operator&&();", Style); 15108 verifyFormat("Foo::operator void &&();", Style); 15109 verifyFormat("Foo::operator()(void &&);", Style); 15110 verifyFormat("Foo::operator&&(void &&);", Style); 15111 verifyFormat("Foo::operator&&();", Style); 15112 verifyFormat("operator&&(int(&&)(), class Foo);", Style); 15113 } 15114 15115 } // namespace 15116 } // namespace format 15117 } // namespace clang 15118