FormatTest.cpp revision db8afe424991b34884afb13ecf97ac458e41da9e
1//===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#define DEBUG_TYPE "format-test" 11 12#include "clang/Format/Format.h" 13#include "clang/Lex/Lexer.h" 14#include "llvm/Support/Debug.h" 15#include "gtest/gtest.h" 16 17namespace clang { 18namespace format { 19 20class FormatTest : public ::testing::Test { 21protected: 22 std::string format(llvm::StringRef Code, unsigned Offset, unsigned Length, 23 const FormatStyle &Style) { 24 DEBUG(llvm::errs() << "---\n"); 25 std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length)); 26 tooling::Replacements Replaces = reformat(Style, Code, Ranges); 27 ReplacementCount = Replaces.size(); 28 std::string Result = applyAllReplacements(Code, Replaces); 29 EXPECT_NE("", Result); 30 DEBUG(llvm::errs() << "\n" << Result << "\n\n"); 31 return Result; 32 } 33 34 std::string 35 format(llvm::StringRef Code, const FormatStyle &Style = getLLVMStyle()) { 36 return format(Code, 0, Code.size(), Style); 37 } 38 39 std::string messUp(llvm::StringRef Code) { 40 std::string MessedUp(Code.str()); 41 bool InComment = false; 42 bool InPreprocessorDirective = false; 43 bool JustReplacedNewline = false; 44 for (unsigned i = 0, e = MessedUp.size() - 1; i != e; ++i) { 45 if (MessedUp[i] == '/' && MessedUp[i + 1] == '/') { 46 if (JustReplacedNewline) 47 MessedUp[i - 1] = '\n'; 48 InComment = true; 49 } else if (MessedUp[i] == '#' && (JustReplacedNewline || i == 0)) { 50 if (i != 0) 51 MessedUp[i - 1] = '\n'; 52 InPreprocessorDirective = true; 53 } else if (MessedUp[i] == '\\' && MessedUp[i + 1] == '\n') { 54 MessedUp[i] = ' '; 55 MessedUp[i + 1] = ' '; 56 } else if (MessedUp[i] == '\n') { 57 if (InComment) { 58 InComment = false; 59 } else if (InPreprocessorDirective) { 60 InPreprocessorDirective = false; 61 } else { 62 JustReplacedNewline = true; 63 MessedUp[i] = ' '; 64 } 65 } else if (MessedUp[i] != ' ') { 66 JustReplacedNewline = false; 67 } 68 } 69 return MessedUp; 70 } 71 72 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 73 FormatStyle Style = getLLVMStyle(); 74 Style.ColumnLimit = ColumnLimit; 75 return Style; 76 } 77 78 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) { 79 FormatStyle Style = getGoogleStyle(); 80 Style.ColumnLimit = ColumnLimit; 81 return Style; 82 } 83 84 void verifyFormat(llvm::StringRef Code, 85 const FormatStyle &Style = getLLVMStyle()) { 86 EXPECT_EQ(Code.str(), format(messUp(Code), Style)); 87 } 88 89 void verifyGoogleFormat(llvm::StringRef Code) { 90 verifyFormat(Code, getGoogleStyle()); 91 } 92 93 void verifyIndependentOfContext(llvm::StringRef text) { 94 verifyFormat(text); 95 verifyFormat(llvm::Twine("void f() { " + text + " }").str()); 96 } 97 98 int ReplacementCount; 99}; 100 101TEST_F(FormatTest, MessUp) { 102 EXPECT_EQ("1 2 3", messUp("1 2 3")); 103 EXPECT_EQ("1 2 3\n", messUp("1\n2\n3\n")); 104 EXPECT_EQ("a\n//b\nc", messUp("a\n//b\nc")); 105 EXPECT_EQ("a\n#b\nc", messUp("a\n#b\nc")); 106 EXPECT_EQ("a\n#b c d\ne", messUp("a\n#b\\\nc\\\nd\ne")); 107} 108 109//===----------------------------------------------------------------------===// 110// Basic function tests. 111//===----------------------------------------------------------------------===// 112 113TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { 114 EXPECT_EQ(";", format(";")); 115} 116 117TEST_F(FormatTest, FormatsGlobalStatementsAt0) { 118 EXPECT_EQ("int i;", format(" int i;")); 119 EXPECT_EQ("\nint i;", format(" \n\t \r int i;")); 120 EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); 121 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); 122} 123 124TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { 125 EXPECT_EQ("int i;", format("int\ni;")); 126} 127 128TEST_F(FormatTest, FormatsNestedBlockStatements) { 129 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}")); 130} 131 132TEST_F(FormatTest, FormatsNestedCall) { 133 verifyFormat("Method(f1, f2(f3));"); 134 verifyFormat("Method(f1(f2, f3()));"); 135 verifyFormat("Method(f1(f2, (f3())));"); 136} 137 138TEST_F(FormatTest, NestedNameSpecifiers) { 139 verifyFormat("vector< ::Type> v;"); 140 verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())"); 141 verifyFormat("static constexpr bool Bar = decltype(bar())::value;"); 142} 143 144TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { 145 EXPECT_EQ("if (a) {\n" 146 " f();\n" 147 "}", 148 format("if(a){f();}")); 149 EXPECT_EQ(4, ReplacementCount); 150 EXPECT_EQ("if (a) {\n" 151 " f();\n" 152 "}", 153 format("if (a) {\n" 154 " f();\n" 155 "}")); 156 EXPECT_EQ(0, ReplacementCount); 157} 158 159TEST_F(FormatTest, RemovesTrailingWhitespaceOfFormattedLine) { 160 EXPECT_EQ("int a;\nint b;", format("int a; \nint b;", 0, 0, getLLVMStyle())); 161 EXPECT_EQ("int a;", format("int a; ")); 162 EXPECT_EQ("int a;\n", format("int a; \n \n \n ")); 163 EXPECT_EQ("int a;\nint b; ", 164 format("int a; \nint b; ", 0, 0, getLLVMStyle())); 165} 166 167TEST_F(FormatTest, FormatsCorrectRegionForLeadingWhitespace) { 168 EXPECT_EQ("int b;\nint a;", 169 format("int b;\n int a;", 7, 0, getLLVMStyle())); 170 EXPECT_EQ("int b;\n int a;", 171 format("int b;\n int a;", 6, 0, getLLVMStyle())); 172 173 EXPECT_EQ("#define A \\\n" 174 " int a; \\\n" 175 " int b;", 176 format("#define A \\\n" 177 " int a; \\\n" 178 " int b;", 179 26, 0, getLLVMStyleWithColumns(12))); 180 EXPECT_EQ("#define A \\\n" 181 " int a; \\\n" 182 " int b;", 183 format("#define A \\\n" 184 " int a; \\\n" 185 " int b;", 186 25, 0, getLLVMStyleWithColumns(12))); 187} 188 189TEST_F(FormatTest, RemovesWhitespaceWhenTriggeredOnEmptyLine) { 190 EXPECT_EQ("int a;\n\n int b;", 191 format("int a;\n \n\n int b;", 7, 0, getLLVMStyle())); 192 EXPECT_EQ("int a;\n\n int b;", 193 format("int a;\n \n\n int b;", 9, 0, getLLVMStyle())); 194} 195 196TEST_F(FormatTest, RemovesEmptyLines) { 197 EXPECT_EQ("class C {\n" 198 " int i;\n" 199 "};", 200 format("class C {\n" 201 " int i;\n" 202 "\n" 203 "};")); 204 205 // Don't remove empty lines in more complex control statements. 206 EXPECT_EQ("void f() {\n" 207 " if (a) {\n" 208 " f();\n" 209 "\n" 210 " } else if (b) {\n" 211 " f();\n" 212 " }\n" 213 "}", 214 format("void f() {\n" 215 " if (a) {\n" 216 " f();\n" 217 "\n" 218 " } else if (b) {\n" 219 " f();\n" 220 "\n" 221 " }\n" 222 "\n" 223 "}")); 224 225 // FIXME: This is slightly inconsistent. 226 EXPECT_EQ("namespace {\n" 227 "int i;\n" 228 "}", 229 format("namespace {\n" 230 "int i;\n" 231 "\n" 232 "}")); 233 EXPECT_EQ("namespace {\n" 234 "int i;\n" 235 "\n" 236 "} // namespace", 237 format("namespace {\n" 238 "int i;\n" 239 "\n" 240 "} // namespace")); 241} 242 243TEST_F(FormatTest, ReformatsMovedLines) { 244 EXPECT_EQ( 245 "template <typename T> T *getFETokenInfo() const {\n" 246 " return static_cast<T *>(FETokenInfo);\n" 247 "}\n" 248 " int a; // <- Should not be formatted", 249 format( 250 "template<typename T>\n" 251 "T *getFETokenInfo() const { return static_cast<T*>(FETokenInfo); }\n" 252 " int a; // <- Should not be formatted", 253 9, 5, getLLVMStyle())); 254} 255 256//===----------------------------------------------------------------------===// 257// Tests for control statements. 258//===----------------------------------------------------------------------===// 259 260TEST_F(FormatTest, FormatIfWithoutCompoundStatement) { 261 verifyFormat("if (true)\n f();\ng();"); 262 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();"); 263 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();"); 264 265 FormatStyle AllowsMergedIf = getLLVMStyle(); 266 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true; 267 verifyFormat("if (a)\n" 268 " // comment\n" 269 " f();", 270 AllowsMergedIf); 271 verifyFormat("if (a)\n" 272 " ;", 273 AllowsMergedIf); 274 verifyFormat("if (a)\n" 275 " if (b) return;", 276 AllowsMergedIf); 277 278 verifyFormat("if (a) // Can't merge this\n" 279 " f();\n", 280 AllowsMergedIf); 281 verifyFormat("if (a) /* still don't merge */\n" 282 " f();", 283 AllowsMergedIf); 284 verifyFormat("if (a) { // Never merge this\n" 285 " f();\n" 286 "}", 287 AllowsMergedIf); 288 verifyFormat("if (a) { /* Never merge this */\n" 289 " f();\n" 290 "}", 291 AllowsMergedIf); 292 293 EXPECT_EQ("if (a) return;", format("if(a)\nreturn;", 7, 1, AllowsMergedIf)); 294 EXPECT_EQ("if (a) return; // comment", 295 format("if(a)\nreturn; // comment", 20, 1, AllowsMergedIf)); 296 297 AllowsMergedIf.ColumnLimit = 14; 298 verifyFormat("if (a) return;", AllowsMergedIf); 299 verifyFormat("if (aaaaaaaaa)\n" 300 " return;", 301 AllowsMergedIf); 302 303 AllowsMergedIf.ColumnLimit = 13; 304 verifyFormat("if (a)\n return;", AllowsMergedIf); 305} 306 307TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) { 308 FormatStyle AllowsMergedLoops = getLLVMStyle(); 309 AllowsMergedLoops.AllowShortLoopsOnASingleLine = true; 310 verifyFormat("while (true) continue;", AllowsMergedLoops); 311 verifyFormat("for (;;) continue;", AllowsMergedLoops); 312 verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops); 313 verifyFormat("while (true)\n" 314 " ;", 315 AllowsMergedLoops); 316 verifyFormat("for (;;)\n" 317 " ;", 318 AllowsMergedLoops); 319 verifyFormat("for (;;)\n" 320 " for (;;) continue;", 321 AllowsMergedLoops); 322 verifyFormat("for (;;) // Can't merge this\n" 323 " continue;", 324 AllowsMergedLoops); 325 verifyFormat("for (;;) /* still don't merge */\n" 326 " continue;", 327 AllowsMergedLoops); 328} 329 330TEST_F(FormatTest, ParseIfElse) { 331 verifyFormat("if (true)\n" 332 " if (true)\n" 333 " if (true)\n" 334 " f();\n" 335 " else\n" 336 " g();\n" 337 " else\n" 338 " h();\n" 339 "else\n" 340 " i();"); 341 verifyFormat("if (true)\n" 342 " if (true)\n" 343 " if (true) {\n" 344 " if (true)\n" 345 " f();\n" 346 " } else {\n" 347 " g();\n" 348 " }\n" 349 " else\n" 350 " h();\n" 351 "else {\n" 352 " i();\n" 353 "}"); 354} 355 356TEST_F(FormatTest, ElseIf) { 357 verifyFormat("if (a) {\n} else if (b) {\n}"); 358 verifyFormat("if (a)\n" 359 " f();\n" 360 "else if (b)\n" 361 " g();\n" 362 "else\n" 363 " h();"); 364} 365 366TEST_F(FormatTest, FormatsForLoop) { 367 verifyFormat( 368 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 369 " ++VeryVeryLongLoopVariable)\n" 370 " ;"); 371 verifyFormat("for (;;)\n" 372 " f();"); 373 verifyFormat("for (;;) {\n}"); 374 verifyFormat("for (;;) {\n" 375 " f();\n" 376 "}"); 377 verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); 378 379 verifyFormat( 380 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 381 " E = UnwrappedLines.end();\n" 382 " I != E; ++I) {\n}"); 383 384 verifyFormat( 385 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 386 " ++IIIII) {\n}"); 387 verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" 388 " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" 389 " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); 390 verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n" 391 " I = FD->getDeclsInPrototypeScope().begin(),\n" 392 " E = FD->getDeclsInPrototypeScope().end();\n" 393 " I != E; ++I) {\n}"); 394 395 // FIXME: Not sure whether we want extra identation in line 3 here: 396 verifyFormat( 397 "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" 398 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" 399 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 400 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 401 " ++aaaaaaaaaaa) {\n}"); 402 verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" 403 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 404 "}"); 405 verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" 406 " aaaaaaaaaa);\n" 407 " iter; ++iter) {\n" 408 "}"); 409 410 FormatStyle NoBinPacking = getLLVMStyle(); 411 NoBinPacking.BinPackParameters = false; 412 verifyFormat("for (int aaaaaaaaaaa = 1;\n" 413 " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" 414 " aaaaaaaaaaaaaaaa,\n" 415 " aaaaaaaaaaaaaaaa,\n" 416 " aaaaaaaaaaaaaaaa);\n" 417 " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" 418 "}", 419 NoBinPacking); 420 verifyFormat( 421 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 422 " E = UnwrappedLines.end();\n" 423 " I != E;\n" 424 " ++I) {\n}", 425 NoBinPacking); 426} 427 428TEST_F(FormatTest, RangeBasedForLoops) { 429 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 430 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 431 verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" 432 " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); 433 verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" 434 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 435} 436 437TEST_F(FormatTest, FormatsWhileLoop) { 438 verifyFormat("while (true) {\n}"); 439 verifyFormat("while (true)\n" 440 " f();"); 441 verifyFormat("while () {\n}"); 442 verifyFormat("while () {\n" 443 " f();\n" 444 "}"); 445} 446 447TEST_F(FormatTest, FormatsDoWhile) { 448 verifyFormat("do {\n" 449 " do_something();\n" 450 "} while (something());"); 451 verifyFormat("do\n" 452 " do_something();\n" 453 "while (something());"); 454} 455 456TEST_F(FormatTest, FormatsSwitchStatement) { 457 verifyFormat("switch (x) {\n" 458 "case 1:\n" 459 " f();\n" 460 " break;\n" 461 "case kFoo:\n" 462 "case ns::kBar:\n" 463 "case kBaz:\n" 464 " break;\n" 465 "default:\n" 466 " g();\n" 467 " break;\n" 468 "}"); 469 verifyFormat("switch (x) {\n" 470 "case 1: {\n" 471 " f();\n" 472 " break;\n" 473 "}\n" 474 "}"); 475 verifyFormat("switch (x) {\n" 476 "case 1: {\n" 477 " f();\n" 478 " {\n" 479 " g();\n" 480 " h();\n" 481 " }\n" 482 " break;\n" 483 "}\n" 484 "}"); 485 verifyFormat("switch (x) {\n" 486 "case 1: {\n" 487 " f();\n" 488 " if (foo) {\n" 489 " g();\n" 490 " h();\n" 491 " }\n" 492 " break;\n" 493 "}\n" 494 "}"); 495 verifyFormat("switch (x) {\n" 496 "case 1: {\n" 497 " f();\n" 498 " g();\n" 499 "} break;\n" 500 "}"); 501 verifyFormat("switch (test)\n" 502 " ;"); 503 verifyFormat("switch (x) {\n" 504 "default: {\n" 505 " // Do nothing.\n" 506 "}\n" 507 "}"); 508 verifyFormat("switch (x) {\n" 509 "// comment\n" 510 "// if 1, do f()\n" 511 "case 1:\n" 512 " f();\n" 513 "}"); 514 verifyFormat("switch (x) {\n" 515 "case 1:\n" 516 " // Do amazing stuff\n" 517 " {\n" 518 " f();\n" 519 " g();\n" 520 " }\n" 521 " break;\n" 522 "}"); 523 verifyFormat("#define A \\\n" 524 " switch (x) { \\\n" 525 " case a: \\\n" 526 " foo = b; \\\n" 527 " }", getLLVMStyleWithColumns(20)); 528 verifyFormat("#define OPERATION_CASE(name) \\\n" 529 " case OP_name: \\\n" 530 " return operations::Operation##name\n", 531 getLLVMStyleWithColumns(40)); 532 533 verifyGoogleFormat("switch (x) {\n" 534 " case 1:\n" 535 " f();\n" 536 " break;\n" 537 " case kFoo:\n" 538 " case ns::kBar:\n" 539 " case kBaz:\n" 540 " break;\n" 541 " default:\n" 542 " g();\n" 543 " break;\n" 544 "}"); 545 verifyGoogleFormat("switch (x) {\n" 546 " case 1: {\n" 547 " f();\n" 548 " break;\n" 549 " }\n" 550 "}"); 551 verifyGoogleFormat("switch (test)\n" 552 " ;"); 553 554 verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" 555 " case OP_name: \\\n" 556 " return operations::Operation##name\n"); 557 verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" 558 " // Get the correction operation class.\n" 559 " switch (OpCode) {\n" 560 " CASE(Add);\n" 561 " CASE(Subtract);\n" 562 " default:\n" 563 " return operations::Unknown;\n" 564 " }\n" 565 "#undef OPERATION_CASE\n" 566 "}"); 567 verifyFormat("DEBUG({\n" 568 " switch (x) {\n" 569 " case A:\n" 570 " f();\n" 571 " break;\n" 572 " // On B:\n" 573 " case B:\n" 574 " g();\n" 575 " break;\n" 576 " }\n" 577 "});"); 578} 579 580TEST_F(FormatTest, FormatsLabels) { 581 verifyFormat("void f() {\n" 582 " some_code();\n" 583 "test_label:\n" 584 " some_other_code();\n" 585 " {\n" 586 " some_more_code();\n" 587 " another_label:\n" 588 " some_more_code();\n" 589 " }\n" 590 "}"); 591 verifyFormat("some_code();\n" 592 "test_label:\n" 593 "some_other_code();"); 594} 595 596//===----------------------------------------------------------------------===// 597// Tests for comments. 598//===----------------------------------------------------------------------===// 599 600TEST_F(FormatTest, UnderstandsSingleLineComments) { 601 verifyFormat("//* */"); 602 verifyFormat("// line 1\n" 603 "// line 2\n" 604 "void f() {}\n"); 605 606 verifyFormat("void f() {\n" 607 " // Doesn't do anything\n" 608 "}"); 609 verifyFormat("SomeObject\n" 610 " // Calling someFunction on SomeObject\n" 611 " .someFunction();"); 612 verifyFormat("void f(int i, // some comment (probably for i)\n" 613 " int j, // some comment (probably for j)\n" 614 " int k); // some comment (probably for k)"); 615 verifyFormat("void f(int i,\n" 616 " // some comment (probably for j)\n" 617 " int j,\n" 618 " // some comment (probably for k)\n" 619 " int k);"); 620 621 verifyFormat("int i // This is a fancy variable\n" 622 " = 5; // with nicely aligned comment."); 623 624 verifyFormat("// Leading comment.\n" 625 "int a; // Trailing comment."); 626 verifyFormat("int a; // Trailing comment\n" 627 " // on 2\n" 628 " // or 3 lines.\n" 629 "int b;"); 630 verifyFormat("int a; // Trailing comment\n" 631 "\n" 632 "// Leading comment.\n" 633 "int b;"); 634 verifyFormat("int a; // Comment.\n" 635 " // More details.\n" 636 "int bbbb; // Another comment."); 637 verifyFormat( 638 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; // comment\n" 639 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // comment\n" 640 "int cccccccccccccccccccccccccccccc; // comment\n" 641 "int ddd; // looooooooooooooooooooooooong comment\n" 642 "int aaaaaaaaaaaaaaaaaaaaaaa; // comment\n" 643 "int bbbbbbbbbbbbbbbbbbbbb; // comment\n" 644 "int ccccccccccccccccccc; // comment"); 645 646 verifyFormat("#include \"a\" // comment\n" 647 "#include \"a/b/c\" // comment"); 648 verifyFormat("#include <a> // comment\n" 649 "#include <a/b/c> // comment"); 650 EXPECT_EQ("#include \\\n" 651 " \"a\" // comment\n" 652 "#include \"a/b/c\" // comment", 653 format("#include \\\n" 654 " \"a\" // comment\n" 655 "#include \"a/b/c\" // comment")); 656 657 verifyFormat("enum E {\n" 658 " // comment\n" 659 " VAL_A, // comment\n" 660 " VAL_B\n" 661 "};"); 662 663 verifyFormat( 664 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 665 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // Trailing comment"); 666 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 667 " // Comment inside a statement.\n" 668 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 669 verifyFormat( 670 "bool aaaaaaaaaaaaa = // comment\n" 671 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 672 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 673 674 verifyFormat("int aaaa; // aaaaa\n" 675 "int aa; // aaaaaaa", 676 getLLVMStyleWithColumns(20)); 677 678 EXPECT_EQ("void f() { // This does something ..\n" 679 "}\n" 680 "int a; // This is unrelated", 681 format("void f() { // This does something ..\n" 682 " }\n" 683 "int a; // This is unrelated")); 684 EXPECT_EQ("class C {\n" 685 " void f() { // This does something ..\n" 686 " } // awesome..\n" 687 "\n" 688 " int a; // This is unrelated\n" 689 "};", 690 format("class C{void f() { // This does something ..\n" 691 " } // awesome..\n" 692 " \n" 693 "int a; // This is unrelated\n" 694 "};")); 695 696 EXPECT_EQ("int i; // single line trailing comment", 697 format("int i;\\\n// single line trailing comment")); 698 699 verifyGoogleFormat("int a; // Trailing comment."); 700 701 verifyFormat("someFunction(anotherFunction( // Force break.\n" 702 " parameter));"); 703 704 verifyGoogleFormat("#endif // HEADER_GUARD"); 705 706 verifyFormat("const char *test[] = {\n" 707 " // A\n" 708 " \"aaaa\",\n" 709 " // B\n" 710 " \"aaaaa\",\n" 711 "};"); 712 verifyGoogleFormat( 713 "aaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 714 " aaaaaaaaaaaaaaaaaaaaaa); // 81_cols_with_this_comment"); 715 EXPECT_EQ("D(a, {\n" 716 " // test\n" 717 " int a;\n" 718 "});", 719 format("D(a, {\n" 720 "// test\n" 721 "int a;\n" 722 "});")); 723 724 EXPECT_EQ("lineWith(); // comment\n" 725 "// at start\n" 726 "otherLine();", 727 format("lineWith(); // comment\n" 728 "// at start\n" 729 "otherLine();")); 730 EXPECT_EQ("lineWith(); // comment\n" 731 " // at start\n" 732 "otherLine();", 733 format("lineWith(); // comment\n" 734 " // at start\n" 735 "otherLine();")); 736 737 EXPECT_EQ("lineWith(); // comment\n" 738 "// at start\n" 739 "otherLine(); // comment", 740 format("lineWith(); // comment\n" 741 "// at start\n" 742 "otherLine(); // comment")); 743 EXPECT_EQ("lineWith();\n" 744 "// at start\n" 745 "otherLine(); // comment", 746 format("lineWith();\n" 747 " // at start\n" 748 "otherLine(); // comment")); 749 EXPECT_EQ("// first\n" 750 "// at start\n" 751 "otherLine(); // comment", 752 format("// first\n" 753 " // at start\n" 754 "otherLine(); // comment")); 755 EXPECT_EQ("f();\n" 756 "// first\n" 757 "// at start\n" 758 "otherLine(); // comment", 759 format("f();\n" 760 "// first\n" 761 " // at start\n" 762 "otherLine(); // comment")); 763} 764 765TEST_F(FormatTest, CanFormatCommentsLocally) { 766 EXPECT_EQ("int a; // comment\n" 767 "int b; // comment", 768 format("int a; // comment\n" 769 "int b; // comment", 770 0, 0, getLLVMStyle())); 771 EXPECT_EQ("int a; // comment\n" 772 " // line 2\n" 773 "int b;", 774 format("int a; // comment\n" 775 " // line 2\n" 776 "int b;", 777 28, 0, getLLVMStyle())); 778 EXPECT_EQ("int aaaaaa; // comment\n" 779 "int b;\n" 780 "int c; // unrelated comment", 781 format("int aaaaaa; // comment\n" 782 "int b;\n" 783 "int c; // unrelated comment", 784 31, 0, getLLVMStyle())); 785} 786 787TEST_F(FormatTest, RemovesTrailingWhitespaceOfComments) { 788 EXPECT_EQ("// comment", format("// comment ")); 789 EXPECT_EQ("int aaaaaaa, bbbbbbb; // comment", 790 format("int aaaaaaa, bbbbbbb; // comment ", 791 getLLVMStyleWithColumns(33))); 792 EXPECT_EQ("// comment\\\n", format("// comment\\\n \t \v \f ")); 793 EXPECT_EQ("// comment \\\n", format("// comment \\\n \t \v \f ")); 794} 795 796TEST_F(FormatTest, UnderstandsBlockComments) { 797 verifyFormat("f(/*noSpaceAfterParameterNamingComment=*/true);"); 798 EXPECT_EQ( 799 "f(aaaaaaaaaaaaaaaaaaaaaaaaa, /* Trailing comment for aa... */\n" 800 " bbbbbbbbbbbbbbbbbbbbbbbbb);", 801 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \\\n/* Trailing comment for aa... */\n" 802 " bbbbbbbbbbbbbbbbbbbbbbbbb);")); 803 EXPECT_EQ( 804 "f(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 805 " /* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);", 806 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \n" 807 "/* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);")); 808 EXPECT_EQ( 809 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 810 " aaaaaaaaaaaaaaaaaa,\n" 811 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n" 812 "}", 813 format("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 814 " aaaaaaaaaaaaaaaaaa ,\n" 815 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n" 816 "}")); 817 818 FormatStyle NoBinPacking = getLLVMStyle(); 819 NoBinPacking.BinPackParameters = false; 820 verifyFormat("aaaaaaaa(/* parameter 1 */ aaaaaa,\n" 821 " /* parameter 2 */ aaaaaa,\n" 822 " /* parameter 3 */ aaaaaa,\n" 823 " /* parameter 4 */ aaaaaa);", 824 NoBinPacking); 825} 826 827TEST_F(FormatTest, AlignsBlockComments) { 828 EXPECT_EQ("/*\n" 829 " * Really multi-line\n" 830 " * comment.\n" 831 " */\n" 832 "void f() {}", 833 format(" /*\n" 834 " * Really multi-line\n" 835 " * comment.\n" 836 " */\n" 837 " void f() {}")); 838 EXPECT_EQ("class C {\n" 839 " /*\n" 840 " * Another multi-line\n" 841 " * comment.\n" 842 " */\n" 843 " void f() {}\n" 844 "};", 845 format("class C {\n" 846 "/*\n" 847 " * Another multi-line\n" 848 " * comment.\n" 849 " */\n" 850 "void f() {}\n" 851 "};")); 852 EXPECT_EQ("/*\n" 853 " 1. This is a comment with non-trivial formatting.\n" 854 " 1.1. We have to indent/outdent all lines equally\n" 855 " 1.1.1. to keep the formatting.\n" 856 " */", 857 format(" /*\n" 858 " 1. This is a comment with non-trivial formatting.\n" 859 " 1.1. We have to indent/outdent all lines equally\n" 860 " 1.1.1. to keep the formatting.\n" 861 " */")); 862 EXPECT_EQ("/*\n" 863 "Don't try to outdent if there's not enough indentation.\n" 864 "*/", 865 format(" /*\n" 866 " Don't try to outdent if there's not enough indentation.\n" 867 " */")); 868 869 EXPECT_EQ("int i; /* Comment with empty...\n" 870 " *\n" 871 " * line. */", 872 format("int i; /* Comment with empty...\n" 873 " *\n" 874 " * line. */")); 875} 876 877TEST_F(FormatTest, CorrectlyHandlesLengthOfBlockComments) { 878 EXPECT_EQ("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 879 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */", 880 format("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 881 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */")); 882 EXPECT_EQ( 883 "void ffffffffffff(\n" 884 " int aaaaaaaa, int bbbbbbbb,\n" 885 " int cccccccccccc) { /*\n" 886 " aaaaaaaaaa\n" 887 " aaaaaaaaaaaaa\n" 888 " bbbbbbbbbbbbbb\n" 889 " bbbbbbbbbb\n" 890 " */\n" 891 "}", 892 format("void ffffffffffff(int aaaaaaaa, int bbbbbbbb, int cccccccccccc)\n" 893 "{ /*\n" 894 " aaaaaaaaaa aaaaaaaaaaaaa\n" 895 " bbbbbbbbbbbbbb bbbbbbbbbb\n" 896 " */\n" 897 "}", 898 getLLVMStyleWithColumns(40))); 899} 900 901TEST_F(FormatTest, DontBreakNonTrailingBlockComments) { 902 EXPECT_EQ("void\n" 903 "ffffffffff(int aaaaa /* test */);", 904 format("void ffffffffff(int aaaaa /* test */);", 905 getLLVMStyleWithColumns(35))); 906} 907 908TEST_F(FormatTest, SplitsLongCxxComments) { 909 EXPECT_EQ("// A comment that\n" 910 "// doesn't fit on\n" 911 "// one line", 912 format("// A comment that doesn't fit on one line", 913 getLLVMStyleWithColumns(20))); 914 EXPECT_EQ("// a b c d\n" 915 "// e f g\n" 916 "// h i j k", 917 format("// a b c d e f g h i j k", 918 getLLVMStyleWithColumns(10))); 919 EXPECT_EQ("// a b c d\n" 920 "// e f g\n" 921 "// h i j k", 922 format("\\\n// a b c d e f g h i j k", 923 getLLVMStyleWithColumns(10))); 924 EXPECT_EQ("if (true) // A comment that\n" 925 " // doesn't fit on\n" 926 " // one line", 927 format("if (true) // A comment that doesn't fit on one line ", 928 getLLVMStyleWithColumns(30))); 929 EXPECT_EQ("// Don't_touch_leading_whitespace", 930 format("// Don't_touch_leading_whitespace", 931 getLLVMStyleWithColumns(20))); 932 EXPECT_EQ("// Add leading\n" 933 "// whitespace", 934 format("//Add leading whitespace", getLLVMStyleWithColumns(20))); 935 EXPECT_EQ("// whitespace", format("//whitespace", getLLVMStyle())); 936 EXPECT_EQ("// Even if it makes the line exceed the column\n" 937 "// limit", 938 format("//Even if it makes the line exceed the column limit", 939 getLLVMStyleWithColumns(51))); 940 EXPECT_EQ("//--But not here", format("//--But not here", getLLVMStyle())); 941 EXPECT_EQ("// A comment before\n" 942 "// a macro\n" 943 "// definition\n" 944 "#define a b", 945 format("// A comment before a macro definition\n" 946 "#define a b", 947 getLLVMStyleWithColumns(20))); 948 EXPECT_EQ("void ffffff(int aaaaaaaaa, // wwww\n" 949 " int a, int bbb, // xxxxxxx\n" 950 " // yyyyyyyyy\n" 951 " int c, int d, int e) {}", 952 format("void ffffff(\n" 953 " int aaaaaaaaa, // wwww\n" 954 " int a,\n" 955 " int bbb, // xxxxxxx yyyyyyyyy\n" 956 " int c, int d, int e) {}", 957 getLLVMStyleWithColumns(40))); 958 EXPECT_EQ("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 959 format("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 960 getLLVMStyleWithColumns(20))); 961} 962 963TEST_F(FormatTest, DontSplitLineCommentsWithEscapedNewlines) { 964 EXPECT_EQ("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 965 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 966 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 967 format("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 968 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 969 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")); 970 EXPECT_EQ("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 971 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 972 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 973 format("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 974 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 975 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 976 getLLVMStyleWithColumns(50))); 977 // FIXME: One day we might want to implement adjustment of leading whitespace 978 // of the consecutive lines in this kind of comment: 979 EXPECT_EQ("int\n" 980 "a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 981 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 982 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 983 format("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 984 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 985 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 986 getLLVMStyleWithColumns(49))); 987} 988 989TEST_F(FormatTest, PriorityOfCommentBreaking) { 990 EXPECT_EQ("if (xxx ==\n" 991 " yyy && // aaaaaaaaaaaa bbbbbbbbb\n" 992 " zzz)\n" 993 " q();", 994 format("if (xxx == yyy && // aaaaaaaaaaaa bbbbbbbbb\n" 995 " zzz) q();", 996 getLLVMStyleWithColumns(40))); 997 EXPECT_EQ("if (xxxxxxxxxx ==\n" 998 " yyy && // aaaaaa bbbbbbbb cccc\n" 999 " zzz)\n" 1000 " q();", 1001 format("if (xxxxxxxxxx == yyy && // aaaaaa bbbbbbbb cccc\n" 1002 " zzz) q();", 1003 getLLVMStyleWithColumns(40))); 1004 EXPECT_EQ("if (xxxxxxxxxx &&\n" 1005 " yyy || // aaaaaa bbbbbbbb cccc\n" 1006 " zzz)\n" 1007 " q();", 1008 format("if (xxxxxxxxxx && yyy || // aaaaaa bbbbbbbb cccc\n" 1009 " zzz) q();", 1010 getLLVMStyleWithColumns(40))); 1011 EXPECT_EQ("fffffffff(&xxx, // aaaaaaaaaaaa\n" 1012 " // bbbbbbbbbbb\n" 1013 " zzz);", 1014 format("fffffffff(&xxx, // aaaaaaaaaaaa bbbbbbbbbbb\n" 1015 " zzz);", 1016 getLLVMStyleWithColumns(40))); 1017} 1018 1019TEST_F(FormatTest, MultiLineCommentsInDefines) { 1020 EXPECT_EQ("#define A(x) /* \\\n" 1021 " a comment \\\n" 1022 " inside */ \\\n" 1023 " f();", 1024 format("#define A(x) /* \\\n" 1025 " a comment \\\n" 1026 " inside */ \\\n" 1027 " f();", 1028 getLLVMStyleWithColumns(17))); 1029 EXPECT_EQ("#define A( \\\n" 1030 " x) /* \\\n" 1031 " a comment \\\n" 1032 " inside */ \\\n" 1033 " f();", 1034 format("#define A( \\\n" 1035 " x) /* \\\n" 1036 " a comment \\\n" 1037 " inside */ \\\n" 1038 " f();", 1039 getLLVMStyleWithColumns(17))); 1040} 1041 1042TEST_F(FormatTest, ParsesCommentsAdjacentToPPDirectives) { 1043 EXPECT_EQ("namespace {}\n// Test\n#define A", 1044 format("namespace {}\n // Test\n#define A")); 1045 EXPECT_EQ("namespace {}\n/* Test */\n#define A", 1046 format("namespace {}\n /* Test */\n#define A")); 1047 EXPECT_EQ("namespace {}\n/* Test */ #define A", 1048 format("namespace {}\n /* Test */ #define A")); 1049} 1050 1051TEST_F(FormatTest, SplitsLongLinesInComments) { 1052 EXPECT_EQ("/* This is a long\n" 1053 " * comment that\n" 1054 " * doesn't\n" 1055 " * fit on one line.\n" 1056 " */", 1057 format("/* " 1058 "This is a long " 1059 "comment that " 1060 "doesn't " 1061 "fit on one line. */", 1062 getLLVMStyleWithColumns(20))); 1063 EXPECT_EQ("/* a b c d\n" 1064 " * e f g\n" 1065 " * h i j k\n" 1066 " */", 1067 format("/* a b c d e f g h i j k */", 1068 getLLVMStyleWithColumns(10))); 1069 EXPECT_EQ("/* a b c d\n" 1070 " * e f g\n" 1071 " * h i j k\n" 1072 " */", 1073 format("\\\n/* a b c d e f g h i j k */", 1074 getLLVMStyleWithColumns(10))); 1075 EXPECT_EQ("/*\n" 1076 "This is a long\n" 1077 "comment that doesn't\n" 1078 "fit on one line.\n" 1079 "*/", 1080 format("/*\n" 1081 "This is a long " 1082 "comment that doesn't " 1083 "fit on one line. \n" 1084 "*/", getLLVMStyleWithColumns(20))); 1085 EXPECT_EQ("/*\n" 1086 " * This is a long\n" 1087 " * comment that\n" 1088 " * doesn't fit on\n" 1089 " * one line.\n" 1090 " */", 1091 format("/* \n" 1092 " * This is a long " 1093 " comment that " 1094 " doesn't fit on " 1095 " one line. \n" 1096 " */", getLLVMStyleWithColumns(20))); 1097 EXPECT_EQ("/*\n" 1098 " * This_is_a_comment_with_words_that_dont_fit_on_one_line\n" 1099 " * so_it_should_be_broken\n" 1100 " * wherever_a_space_occurs\n" 1101 " */", 1102 format("/*\n" 1103 " * This_is_a_comment_with_words_that_dont_fit_on_one_line " 1104 " so_it_should_be_broken " 1105 " wherever_a_space_occurs \n" 1106 " */", 1107 getLLVMStyleWithColumns(20))); 1108 EXPECT_EQ("/*\n" 1109 " * This_comment_can_not_be_broken_into_lines\n" 1110 " */", 1111 format("/*\n" 1112 " * This_comment_can_not_be_broken_into_lines\n" 1113 " */", 1114 getLLVMStyleWithColumns(20))); 1115 EXPECT_EQ("{\n" 1116 " /*\n" 1117 " This is another\n" 1118 " long comment that\n" 1119 " doesn't fit on one\n" 1120 " line 1234567890\n" 1121 " */\n" 1122 "}", 1123 format("{\n" 1124 "/*\n" 1125 "This is another " 1126 " long comment that " 1127 " doesn't fit on one" 1128 " line 1234567890\n" 1129 "*/\n" 1130 "}", getLLVMStyleWithColumns(20))); 1131 EXPECT_EQ("{\n" 1132 " /*\n" 1133 " * This i s\n" 1134 " * another comment\n" 1135 " * t hat doesn' t\n" 1136 " * fit on one l i\n" 1137 " * n e\n" 1138 " */\n" 1139 "}", 1140 format("{\n" 1141 "/*\n" 1142 " * This i s" 1143 " another comment" 1144 " t hat doesn' t" 1145 " fit on one l i" 1146 " n e\n" 1147 " */\n" 1148 "}", getLLVMStyleWithColumns(20))); 1149 EXPECT_EQ("/*\n" 1150 " * This is a long\n" 1151 " * comment that\n" 1152 " * doesn't fit on\n" 1153 " * one line\n" 1154 " */", 1155 format(" /*\n" 1156 " * This is a long comment that doesn't fit on one line\n" 1157 " */", getLLVMStyleWithColumns(20))); 1158 EXPECT_EQ("{\n" 1159 " if (something) /* This is a\n" 1160 " long\n" 1161 " comment */\n" 1162 " ;\n" 1163 "}", 1164 format("{\n" 1165 " if (something) /* This is a long comment */\n" 1166 " ;\n" 1167 "}", 1168 getLLVMStyleWithColumns(30))); 1169 1170 EXPECT_EQ("/* A comment before\n" 1171 " * a macro\n" 1172 " * definition */\n" 1173 "#define a b", 1174 format("/* A comment before a macro definition */\n" 1175 "#define a b", 1176 getLLVMStyleWithColumns(20))); 1177 1178 EXPECT_EQ("/* some comment\n" 1179 " * a comment\n" 1180 "* that we break\n" 1181 " * another comment\n" 1182 "* we have to break\n" 1183 "* a left comment\n" 1184 " */", 1185 format(" /* some comment\n" 1186 " * a comment that we break\n" 1187 " * another comment we have to break\n" 1188 "* a left comment\n" 1189 " */", 1190 getLLVMStyleWithColumns(20))); 1191 1192 EXPECT_EQ("/*\n" 1193 "\n" 1194 "\n" 1195 " */\n", 1196 format(" /* \n" 1197 " \n" 1198 " \n" 1199 " */\n")); 1200} 1201 1202TEST_F(FormatTest, SplitsLongLinesInCommentsInPreprocessor) { 1203 EXPECT_EQ("#define X \\\n" 1204 " /* \\\n" 1205 " Test \\\n" 1206 " Macro comment \\\n" 1207 " with a long \\\n" 1208 " line \\\n" 1209 " */ \\\n" 1210 " A + B", 1211 format("#define X \\\n" 1212 " /*\n" 1213 " Test\n" 1214 " Macro comment with a long line\n" 1215 " */ \\\n" 1216 " A + B", 1217 getLLVMStyleWithColumns(20))); 1218 EXPECT_EQ("#define X \\\n" 1219 " /* Macro comment \\\n" 1220 " with a long \\\n" 1221 " line */ \\\n" 1222 " A + B", 1223 format("#define X \\\n" 1224 " /* Macro comment with a long\n" 1225 " line */ \\\n" 1226 " A + B", 1227 getLLVMStyleWithColumns(20))); 1228 EXPECT_EQ("#define X \\\n" 1229 " /* Macro comment \\\n" 1230 " * with a long \\\n" 1231 " * line */ \\\n" 1232 " A + B", 1233 format("#define X \\\n" 1234 " /* Macro comment with a long line */ \\\n" 1235 " A + B", 1236 getLLVMStyleWithColumns(20))); 1237} 1238 1239TEST_F(FormatTest, CommentsInStaticInitializers) { 1240 EXPECT_EQ( 1241 "static SomeType type = { aaaaaaaaaaaaaaaaaaaa, /* comment */\n" 1242 " aaaaaaaaaaaaaaaaaaaa /* comment */,\n" 1243 " /* comment */ aaaaaaaaaaaaaaaaaaaa,\n" 1244 " aaaaaaaaaaaaaaaaaaaa, // comment\n" 1245 " aaaaaaaaaaaaaaaaaaaa };", 1246 format("static SomeType type = { aaaaaaaaaaaaaaaaaaaa , /* comment */\n" 1247 " aaaaaaaaaaaaaaaaaaaa /* comment */ ,\n" 1248 " /* comment */ aaaaaaaaaaaaaaaaaaaa ,\n" 1249 " aaaaaaaaaaaaaaaaaaaa , // comment\n" 1250 " aaaaaaaaaaaaaaaaaaaa };")); 1251 verifyFormat("static SomeType type = { aaaaaaaaaaa, // comment for aa...\n" 1252 " bbbbbbbbbbb, ccccccccccc };"); 1253 verifyFormat("static SomeType type = { aaaaaaaaaaa,\n" 1254 " // comment for bb....\n" 1255 " bbbbbbbbbbb, ccccccccccc };"); 1256 verifyGoogleFormat( 1257 "static SomeType type = {aaaaaaaaaaa, // comment for aa...\n" 1258 " bbbbbbbbbbb, ccccccccccc};"); 1259 verifyGoogleFormat("static SomeType type = {aaaaaaaaaaa,\n" 1260 " // comment for bb....\n" 1261 " bbbbbbbbbbb, ccccccccccc};"); 1262 1263 verifyFormat("S s = { { a, b, c }, // Group #1\n" 1264 " { d, e, f }, // Group #2\n" 1265 " { g, h, i } }; // Group #3"); 1266 verifyFormat("S s = { { // Group #1\n" 1267 " a, b, c },\n" 1268 " { // Group #2\n" 1269 " d, e, f },\n" 1270 " { // Group #3\n" 1271 " g, h, i } };"); 1272 1273 EXPECT_EQ("S s = {\n" 1274 " // Some comment\n" 1275 " a,\n" 1276 "\n" 1277 " // Comment after empty line\n" 1278 " b\n" 1279 "}", 1280 format("S s = {\n" 1281 " // Some comment\n" 1282 " a,\n" 1283 " \n" 1284 " // Comment after empty line\n" 1285 " b\n" 1286 "}")); 1287 EXPECT_EQ("S s = {\n" 1288 " /* Some comment */\n" 1289 " a,\n" 1290 "\n" 1291 " /* Comment after empty line */\n" 1292 " b\n" 1293 "}", 1294 format("S s = {\n" 1295 " /* Some comment */\n" 1296 " a,\n" 1297 " \n" 1298 " /* Comment after empty line */\n" 1299 " b\n" 1300 "}")); 1301 verifyFormat("const uint8_t aaaaaaaaaaaaaaaaaaaaaa[0] = {\n" 1302 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n" 1303 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n" 1304 " 0x00, 0x00, 0x00, 0x00 // comment\n" 1305 "};"); 1306} 1307 1308TEST_F(FormatTest, IgnoresIf0Contents) { 1309 EXPECT_EQ("#if 0\n" 1310 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 1311 "#endif\n" 1312 "void f() {}", 1313 format("#if 0\n" 1314 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 1315 "#endif\n" 1316 "void f( ) { }")); 1317 EXPECT_EQ("#if false\n" 1318 "void f( ) { }\n" 1319 "#endif\n" 1320 "void g() {}\n", 1321 format("#if false\n" 1322 "void f( ) { }\n" 1323 "#endif\n" 1324 "void g( ) { }\n")); 1325 EXPECT_EQ("enum E {\n" 1326 " One,\n" 1327 " Two,\n" 1328 "#if 0\n" 1329 "Three,\n" 1330 " Four,\n" 1331 "#endif\n" 1332 " Five\n" 1333 "};", 1334 format("enum E {\n" 1335 " One,Two,\n" 1336 "#if 0\n" 1337 "Three,\n" 1338 " Four,\n" 1339 "#endif\n" 1340 " Five};")); 1341 EXPECT_EQ("enum F {\n" 1342 " One,\n" 1343 "#if 1\n" 1344 " Two,\n" 1345 "#if 0\n" 1346 "Three,\n" 1347 " Four,\n" 1348 "#endif\n" 1349 " Five\n" 1350 "#endif\n" 1351 "};", 1352 format("enum F {\n" 1353 "One,\n" 1354 "#if 1\n" 1355 "Two,\n" 1356 "#if 0\n" 1357 "Three,\n" 1358 " Four,\n" 1359 "#endif\n" 1360 "Five\n" 1361 "#endif\n" 1362 "};")); 1363 EXPECT_EQ("enum G {\n" 1364 " One,\n" 1365 "#if 0\n" 1366 "Two,\n" 1367 "#else\n" 1368 " Three,\n" 1369 "#endif\n" 1370 " Four\n" 1371 "};", 1372 format("enum G {\n" 1373 "One,\n" 1374 "#if 0\n" 1375 "Two,\n" 1376 "#else\n" 1377 "Three,\n" 1378 "#endif\n" 1379 "Four\n" 1380 "};")); 1381 EXPECT_EQ("enum H {\n" 1382 " One,\n" 1383 "#if 0\n" 1384 "#ifdef Q\n" 1385 "Two,\n" 1386 "#else\n" 1387 "Three,\n" 1388 "#endif\n" 1389 "#endif\n" 1390 " Four\n" 1391 "};", 1392 format("enum H {\n" 1393 "One,\n" 1394 "#if 0\n" 1395 "#ifdef Q\n" 1396 "Two,\n" 1397 "#else\n" 1398 "Three,\n" 1399 "#endif\n" 1400 "#endif\n" 1401 "Four\n" 1402 "};")); 1403 EXPECT_EQ("enum I {\n" 1404 " One,\n" 1405 "#if /* test */ 0 || 1\n" 1406 "Two,\n" 1407 "Three,\n" 1408 "#endif\n" 1409 " Four\n" 1410 "};", 1411 format("enum I {\n" 1412 "One,\n" 1413 "#if /* test */ 0 || 1\n" 1414 "Two,\n" 1415 "Three,\n" 1416 "#endif\n" 1417 "Four\n" 1418 "};")); 1419 EXPECT_EQ("enum J {\n" 1420 " One,\n" 1421 "#if 0\n" 1422 "#if 0\n" 1423 "Two,\n" 1424 "#else\n" 1425 "Three,\n" 1426 "#endif\n" 1427 "Four,\n" 1428 "#endif\n" 1429 " Five\n" 1430 "};", 1431 format("enum J {\n" 1432 "One,\n" 1433 "#if 0\n" 1434 "#if 0\n" 1435 "Two,\n" 1436 "#else\n" 1437 "Three,\n" 1438 "#endif\n" 1439 "Four,\n" 1440 "#endif\n" 1441 "Five\n" 1442 "};")); 1443 1444} 1445 1446//===----------------------------------------------------------------------===// 1447// Tests for classes, namespaces, etc. 1448//===----------------------------------------------------------------------===// 1449 1450TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 1451 verifyFormat("class A {};"); 1452} 1453 1454TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 1455 verifyFormat("class A {\n" 1456 "public:\n" 1457 "public: // comment\n" 1458 "protected:\n" 1459 "private:\n" 1460 " void f() {}\n" 1461 "};"); 1462 verifyGoogleFormat("class A {\n" 1463 " public:\n" 1464 " protected:\n" 1465 " private:\n" 1466 " void f() {}\n" 1467 "};"); 1468} 1469 1470TEST_F(FormatTest, SeparatesLogicalBlocks) { 1471 EXPECT_EQ("class A {\n" 1472 "public:\n" 1473 " void f();\n" 1474 "\n" 1475 "private:\n" 1476 " void g() {}\n" 1477 " // test\n" 1478 "protected:\n" 1479 " int h;\n" 1480 "};", 1481 format("class A {\n" 1482 "public:\n" 1483 "void f();\n" 1484 "private:\n" 1485 "void g() {}\n" 1486 "// test\n" 1487 "protected:\n" 1488 "int h;\n" 1489 "};")); 1490} 1491 1492TEST_F(FormatTest, FormatsClasses) { 1493 verifyFormat("class A : public B {};"); 1494 verifyFormat("class A : public ::B {};"); 1495 1496 verifyFormat( 1497 "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1498 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1499 verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" 1500 " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" 1501 " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); 1502 verifyFormat( 1503 "class A : public B, public C, public D, public E, public F {};"); 1504 verifyFormat("class AAAAAAAAAAAA : public B,\n" 1505 " public C,\n" 1506 " public D,\n" 1507 " public E,\n" 1508 " public F,\n" 1509 " public G {};"); 1510 1511 verifyFormat("class\n" 1512 " ReallyReallyLongClassName {\n" 1513 " int i;\n" 1514 "};", 1515 getLLVMStyleWithColumns(32)); 1516} 1517 1518TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 1519 verifyFormat("class A {\n} a, b;"); 1520 verifyFormat("struct A {\n} a, b;"); 1521 verifyFormat("union A {\n} a;"); 1522} 1523 1524TEST_F(FormatTest, FormatsEnum) { 1525 verifyFormat("enum {\n" 1526 " Zero,\n" 1527 " One = 1,\n" 1528 " Two = One + 1,\n" 1529 " Three = (One + Two),\n" 1530 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1531 " Five = (One, Two, Three, Four, 5)\n" 1532 "};"); 1533 verifyFormat("enum Enum {};"); 1534 verifyFormat("enum {};"); 1535 verifyFormat("enum X E {\n} d;"); 1536 verifyFormat("enum __attribute__((...)) E {\n} d;"); 1537 verifyFormat("enum __declspec__((...)) E {\n} d;"); 1538 verifyFormat("enum X f() {\n a();\n return 42;\n}"); 1539} 1540 1541TEST_F(FormatTest, FormatsEnumsWithErrors) { 1542 verifyFormat("enum Type {\n" 1543 " One = 0;\n" // These semicolons should be commas. 1544 " Two = 1;\n" 1545 "};"); 1546 verifyFormat("namespace n {\n" 1547 "enum Type {\n" 1548 " One,\n" 1549 " Two,\n" // missing }; 1550 " int i;\n" 1551 "}\n" 1552 "void g() {}"); 1553} 1554 1555TEST_F(FormatTest, FormatsEnumStruct) { 1556 verifyFormat("enum struct {\n" 1557 " Zero,\n" 1558 " One = 1,\n" 1559 " Two = One + 1,\n" 1560 " Three = (One + Two),\n" 1561 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1562 " Five = (One, Two, Three, Four, 5)\n" 1563 "};"); 1564 verifyFormat("enum struct Enum {};"); 1565 verifyFormat("enum struct {};"); 1566 verifyFormat("enum struct X E {\n} d;"); 1567 verifyFormat("enum struct __attribute__((...)) E {\n} d;"); 1568 verifyFormat("enum struct __declspec__((...)) E {\n} d;"); 1569 verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); 1570} 1571 1572TEST_F(FormatTest, FormatsEnumClass) { 1573 verifyFormat("enum class {\n" 1574 " Zero,\n" 1575 " One = 1,\n" 1576 " Two = One + 1,\n" 1577 " Three = (One + Two),\n" 1578 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 1579 " Five = (One, Two, Three, Four, 5)\n" 1580 "};"); 1581 verifyFormat("enum class Enum {};"); 1582 verifyFormat("enum class {};"); 1583 verifyFormat("enum class X E {\n} d;"); 1584 verifyFormat("enum class __attribute__((...)) E {\n} d;"); 1585 verifyFormat("enum class __declspec__((...)) E {\n} d;"); 1586 verifyFormat("enum class X f() {\n a();\n return 42;\n}"); 1587} 1588 1589TEST_F(FormatTest, FormatsEnumTypes) { 1590 verifyFormat("enum X : int {\n" 1591 " A,\n" 1592 " B\n" 1593 "};"); 1594 verifyFormat("enum X : std::uint32_t {\n" 1595 " A,\n" 1596 " B\n" 1597 "};"); 1598} 1599 1600TEST_F(FormatTest, FormatsBitfields) { 1601 verifyFormat("struct Bitfields {\n" 1602 " unsigned sClass : 8;\n" 1603 " unsigned ValueKind : 2;\n" 1604 "};"); 1605} 1606 1607TEST_F(FormatTest, FormatsNamespaces) { 1608 verifyFormat("namespace some_namespace {\n" 1609 "class A {};\n" 1610 "void f() { f(); }\n" 1611 "}"); 1612 verifyFormat("namespace {\n" 1613 "class A {};\n" 1614 "void f() { f(); }\n" 1615 "}"); 1616 verifyFormat("inline namespace X {\n" 1617 "class A {};\n" 1618 "void f() { f(); }\n" 1619 "}"); 1620 verifyFormat("using namespace some_namespace;\n" 1621 "class A {};\n" 1622 "void f() { f(); }"); 1623 1624 // This code is more common than we thought; if we 1625 // layout this correctly the semicolon will go into 1626 // its own line, which is undesireable. 1627 verifyFormat("namespace {};"); 1628 verifyFormat("namespace {\n" 1629 "class A {};\n" 1630 "};"); 1631 1632 verifyFormat("namespace {\n" 1633 "int SomeVariable = 0; // comment\n" 1634 "} // namespace"); 1635 EXPECT_EQ("#ifndef HEADER_GUARD\n" 1636 "#define HEADER_GUARD\n" 1637 "namespace my_namespace {\n" 1638 "int i;\n" 1639 "} // my_namespace\n" 1640 "#endif // HEADER_GUARD", 1641 format("#ifndef HEADER_GUARD\n" 1642 " #define HEADER_GUARD\n" 1643 " namespace my_namespace {\n" 1644 "int i;\n" 1645 "} // my_namespace\n" 1646 "#endif // HEADER_GUARD")); 1647 1648 FormatStyle Style = getLLVMStyle(); 1649 Style.NamespaceIndentation = FormatStyle::NI_All; 1650 EXPECT_EQ("namespace out {\n" 1651 " int i;\n" 1652 " namespace in {\n" 1653 " int i;\n" 1654 " } // namespace\n" 1655 "} // namespace", 1656 format("namespace out {\n" 1657 "int i;\n" 1658 "namespace in {\n" 1659 "int i;\n" 1660 "} // namespace\n" 1661 "} // namespace", 1662 Style)); 1663 1664 Style.NamespaceIndentation = FormatStyle::NI_Inner; 1665 EXPECT_EQ("namespace out {\n" 1666 "int i;\n" 1667 "namespace in {\n" 1668 " int i;\n" 1669 "} // namespace\n" 1670 "} // namespace", 1671 format("namespace out {\n" 1672 "int i;\n" 1673 "namespace in {\n" 1674 "int i;\n" 1675 "} // namespace\n" 1676 "} // namespace", 1677 Style)); 1678} 1679 1680TEST_F(FormatTest, FormatsExternC) { verifyFormat("extern \"C\" {\nint a;"); } 1681 1682TEST_F(FormatTest, FormatsInlineASM) { 1683 verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); 1684 verifyFormat( 1685 "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" 1686 " \"cpuid\\n\\t\"\n" 1687 " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" 1688 " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" 1689 " : \"a\"(value));"); 1690} 1691 1692TEST_F(FormatTest, FormatTryCatch) { 1693 // FIXME: Handle try-catch explicitly in the UnwrappedLineParser, then we'll 1694 // also not create single-line-blocks. 1695 verifyFormat("try {\n" 1696 " throw a * b;\n" 1697 "}\n" 1698 "catch (int a) {\n" 1699 " // Do nothing.\n" 1700 "}\n" 1701 "catch (...) {\n" 1702 " exit(42);\n" 1703 "}"); 1704 1705 // Function-level try statements. 1706 verifyFormat("int f() try { return 4; }\n" 1707 "catch (...) {\n" 1708 " return 5;\n" 1709 "}"); 1710 verifyFormat("class A {\n" 1711 " int a;\n" 1712 " A() try : a(0) {}\n" 1713 " catch (...) {\n" 1714 " throw;\n" 1715 " }\n" 1716 "};\n"); 1717} 1718 1719TEST_F(FormatTest, FormatObjCTryCatch) { 1720 verifyFormat("@try {\n" 1721 " f();\n" 1722 "}\n" 1723 "@catch (NSException e) {\n" 1724 " @throw;\n" 1725 "}\n" 1726 "@finally {\n" 1727 " exit(42);\n" 1728 "}"); 1729} 1730 1731TEST_F(FormatTest, StaticInitializers) { 1732 verifyFormat("static SomeClass SC = { 1, 'a' };"); 1733 1734 verifyFormat( 1735 "static SomeClass WithALoooooooooooooooooooongName = {\n" 1736 " 100000000, \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 1737 "};"); 1738 1739 // Here, everything other than the "}" would fit on a line. 1740 verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" 1741 " 100000000000000000000000\n" 1742 "};"); 1743 EXPECT_EQ("S s = { a, b };", format("S s = {\n" 1744 " a,\n" 1745 "\n" 1746 " b\n" 1747 "};")); 1748 1749 // FIXME: This would fit into the column limit if we'd fit "{ {" on the first 1750 // line. However, the formatting looks a bit off and this probably doesn't 1751 // happen often in practice. 1752 verifyFormat("static int Variable[1] = {\n" 1753 " { 1000000000000000000000000000000000000 }\n" 1754 "};", 1755 getLLVMStyleWithColumns(40)); 1756} 1757 1758TEST_F(FormatTest, DesignatedInitializers) { 1759 verifyFormat("const struct A a = { .a = 1, .b = 2 };"); 1760 verifyFormat("const struct A a = { .aaaaaaaaaa = 1,\n" 1761 " .bbbbbbbbbb = 2,\n" 1762 " .cccccccccc = 3,\n" 1763 " .dddddddddd = 4,\n" 1764 " .eeeeeeeeee = 5 };"); 1765 verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" 1766 " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" 1767 " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" 1768 " .ccccccccccccccccccccccccccc = 3,\n" 1769 " .ddddddddddddddddddddddddddd = 4,\n" 1770 " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5\n" 1771 "};"); 1772 1773 verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); 1774} 1775 1776TEST_F(FormatTest, NestedStaticInitializers) { 1777 verifyFormat("static A x = { { {} } };\n"); 1778 verifyFormat("static A x = { { { init1, init2, init3, init4 },\n" 1779 " { init1, init2, init3, init4 } } };"); 1780 1781 verifyFormat("somes Status::global_reps[3] = {\n" 1782 " { kGlobalRef, OK_CODE, NULL, NULL, NULL },\n" 1783 " { kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL },\n" 1784 " { kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL }\n" 1785 "};"); 1786 verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" 1787 " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" 1788 " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" 1789 " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); 1790 verifyFormat( 1791 "CGRect cg_rect = { { rect.fLeft, rect.fTop },\n" 1792 " { rect.fRight - rect.fLeft, rect.fBottom - rect.fTop" 1793 " } };"); 1794 1795 verifyFormat( 1796 "SomeArrayOfSomeType a = { { { 1, 2, 3 }, { 1, 2, 3 },\n" 1797 " { 111111111111111111111111111111,\n" 1798 " 222222222222222222222222222222,\n" 1799 " 333333333333333333333333333333 },\n" 1800 " { 1, 2, 3 }, { 1, 2, 3 } } };"); 1801 verifyFormat( 1802 "SomeArrayOfSomeType a = { { { 1, 2, 3 } }, { { 1, 2, 3 } },\n" 1803 " { { 111111111111111111111111111111,\n" 1804 " 222222222222222222222222222222,\n" 1805 " 333333333333333333333333333333 } },\n" 1806 " { { 1, 2, 3 } }, { { 1, 2, 3 } } };"); 1807 verifyGoogleFormat( 1808 "SomeArrayOfSomeType a = {\n" 1809 " {{1, 2, 3}}, {{1, 2, 3}},\n" 1810 " {{111111111111111111111111111111, 222222222222222222222222222222,\n" 1811 " 333333333333333333333333333333}},\n" 1812 " {{1, 2, 3}}, {{1, 2, 3}}};"); 1813 1814 // FIXME: We might at some point want to handle this similar to parameter 1815 // lists, where we have an option to put each on a single line. 1816 verifyFormat( 1817 "struct {\n" 1818 " unsigned bit;\n" 1819 " const char *const name;\n" 1820 "} kBitsToOs[] = { { kOsMac, \"Mac\" }, { kOsWin, \"Windows\" },\n" 1821 " { kOsLinux, \"Linux\" }, { kOsCrOS, \"Chrome OS\" } };"); 1822} 1823 1824TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 1825 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 1826 " \\\n" 1827 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 1828} 1829 1830TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 1831 verifyFormat( 1832 "virtual void write(ELFWriter *writerrr,\n" 1833 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 1834} 1835 1836TEST_F(FormatTest, LayoutUnknownPPDirective) { 1837 EXPECT_EQ("#123 \"A string literal\"", 1838 format(" # 123 \"A string literal\"")); 1839 EXPECT_EQ("#;", format("#;")); 1840 verifyFormat("#\n;\n;\n;"); 1841} 1842 1843TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 1844 EXPECT_EQ("#line 42 \"test\"\n", 1845 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 1846 EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", 1847 getLLVMStyleWithColumns(12))); 1848} 1849 1850TEST_F(FormatTest, EndOfFileEndsPPDirective) { 1851 EXPECT_EQ("#line 42 \"test\"", 1852 format("# \\\n line \\\n 42 \\\n \"test\"")); 1853 EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); 1854} 1855 1856TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 1857 verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); 1858 verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); 1859 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 1860 // FIXME: We never break before the macro name. 1861 verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); 1862 1863 verifyFormat("#define A A\n#define A A"); 1864 verifyFormat("#define A(X) A\n#define A A"); 1865 1866 verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); 1867 verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); 1868} 1869 1870TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 1871 EXPECT_EQ("// somecomment\n" 1872 "#include \"a.h\"\n" 1873 "#define A( \\\n" 1874 " A, B)\n" 1875 "#include \"b.h\"\n" 1876 "// somecomment\n", 1877 format(" // somecomment\n" 1878 " #include \"a.h\"\n" 1879 "#define A(A,\\\n" 1880 " B)\n" 1881 " #include \"b.h\"\n" 1882 " // somecomment\n", 1883 getLLVMStyleWithColumns(13))); 1884} 1885 1886TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } 1887 1888TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 1889 EXPECT_EQ("#define A \\\n" 1890 " c; \\\n" 1891 " e;\n" 1892 "f;", 1893 format("#define A c; e;\n" 1894 "f;", 1895 getLLVMStyleWithColumns(14))); 1896} 1897 1898TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 1899 1900TEST_F(FormatTest, AlwaysFormatsEntireMacroDefinitions) { 1901 EXPECT_EQ("int i;\n" 1902 "#define A \\\n" 1903 " int i; \\\n" 1904 " int j\n" 1905 "int k;", 1906 format("int i;\n" 1907 "#define A \\\n" 1908 " int i ; \\\n" 1909 " int j\n" 1910 "int k;", 1911 8, 0, getGoogleStyle())); // 8: position of "#define". 1912 EXPECT_EQ("int i;\n" 1913 "#define A \\\n" 1914 " int i; \\\n" 1915 " int j\n" 1916 "int k;", 1917 format("int i;\n" 1918 "#define A \\\n" 1919 " int i ; \\\n" 1920 " int j\n" 1921 "int k;", 1922 45, 0, getGoogleStyle())); // 45: position of "j". 1923} 1924 1925TEST_F(FormatTest, MacroDefinitionInsideStatement) { 1926 EXPECT_EQ("int x,\n" 1927 "#define A\n" 1928 " y;", 1929 format("int x,\n#define A\ny;")); 1930} 1931 1932TEST_F(FormatTest, HashInMacroDefinition) { 1933 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 1934 verifyFormat("#define A \\\n" 1935 " { \\\n" 1936 " f(#c); \\\n" 1937 " }", 1938 getLLVMStyleWithColumns(11)); 1939 1940 verifyFormat("#define A(X) \\\n" 1941 " void function##X()", 1942 getLLVMStyleWithColumns(22)); 1943 1944 verifyFormat("#define A(a, b, c) \\\n" 1945 " void a##b##c()", 1946 getLLVMStyleWithColumns(22)); 1947 1948 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 1949} 1950 1951TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 1952 verifyFormat("#define A (1)"); 1953} 1954 1955TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { 1956 EXPECT_EQ("#define A b;", format("#define A \\\n" 1957 " \\\n" 1958 " b;", 1959 getLLVMStyleWithColumns(25))); 1960 EXPECT_EQ("#define A \\\n" 1961 " \\\n" 1962 " a; \\\n" 1963 " b;", 1964 format("#define A \\\n" 1965 " \\\n" 1966 " a; \\\n" 1967 " b;", 1968 getLLVMStyleWithColumns(11))); 1969 EXPECT_EQ("#define A \\\n" 1970 " a; \\\n" 1971 " \\\n" 1972 " b;", 1973 format("#define A \\\n" 1974 " a; \\\n" 1975 " \\\n" 1976 " b;", 1977 getLLVMStyleWithColumns(11))); 1978} 1979 1980TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { 1981 verifyFormat("#define A :"); 1982 verifyFormat("#define SOMECASES \\\n" 1983 " case 1: \\\n" 1984 " case 2\n", 1985 getLLVMStyleWithColumns(20)); 1986 verifyFormat("#define A template <typename T>"); 1987 verifyFormat("#define STR(x) #x\n" 1988 "f(STR(this_is_a_string_literal{));"); 1989 verifyFormat("#pragma omp threadprivate( \\\n" 1990 " y)), // expected-warning", 1991 getLLVMStyleWithColumns(28)); 1992} 1993 1994TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { 1995 verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. 1996 EXPECT_EQ("class A : public QObject {\n" 1997 " Q_OBJECT\n" 1998 "\n" 1999 " A() {}\n" 2000 "};", 2001 format("class A : public QObject {\n" 2002 " Q_OBJECT\n" 2003 "\n" 2004 " A() {\n}\n" 2005 "} ;")); 2006 EXPECT_EQ("SOME_MACRO\n" 2007 "namespace {\n" 2008 "void f();\n" 2009 "}", 2010 format("SOME_MACRO\n" 2011 " namespace {\n" 2012 "void f( );\n" 2013 "}")); 2014 // Only if the identifier contains at least 5 characters. 2015 EXPECT_EQ("HTTP f();", 2016 format("HTTP\nf();")); 2017 EXPECT_EQ("MACRO\nf();", 2018 format("MACRO\nf();")); 2019 // Only if everything is upper case. 2020 EXPECT_EQ("class A : public QObject {\n" 2021 " Q_Object A() {}\n" 2022 "};", 2023 format("class A : public QObject {\n" 2024 " Q_Object\n" 2025 "\n" 2026 " A() {\n}\n" 2027 "} ;")); 2028} 2029 2030TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { 2031 EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2032 "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2033 "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2034 "class X {};\n" 2035 "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2036 "int *createScopDetectionPass() { return 0; }", 2037 format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" 2038 " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" 2039 " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" 2040 " class X {};\n" 2041 " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" 2042 " int *createScopDetectionPass() { return 0; }")); 2043 // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as 2044 // braces, so that inner block is indented one level more. 2045 EXPECT_EQ("int q() {\n" 2046 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2047 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2048 " IPC_END_MESSAGE_MAP()\n" 2049 "}", 2050 format("int q() {\n" 2051 " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" 2052 " IPC_MESSAGE_HANDLER(xxx, qqq)\n" 2053 " IPC_END_MESSAGE_MAP()\n" 2054 "}")); 2055 EXPECT_EQ("int q() {\n" 2056 " f(x);\n" 2057 " f(x) {}\n" 2058 " f(x)->g();\n" 2059 " f(x)->*g();\n" 2060 " f(x).g();\n" 2061 " f(x) = x;\n" 2062 " f(x) += x;\n" 2063 " f(x) -= x;\n" 2064 " f(x) *= x;\n" 2065 " f(x) /= x;\n" 2066 " f(x) %= x;\n" 2067 " f(x) &= x;\n" 2068 " f(x) |= x;\n" 2069 " f(x) ^= x;\n" 2070 " f(x) >>= x;\n" 2071 " f(x) <<= x;\n" 2072 " f(x)[y].z();\n" 2073 " LOG(INFO) << x;\n" 2074 " ifstream(x) >> x;\n" 2075 "}\n", 2076 format("int q() {\n" 2077 " f(x)\n;\n" 2078 " f(x)\n {}\n" 2079 " f(x)\n->g();\n" 2080 " f(x)\n->*g();\n" 2081 " f(x)\n.g();\n" 2082 " f(x)\n = x;\n" 2083 " f(x)\n += x;\n" 2084 " f(x)\n -= x;\n" 2085 " f(x)\n *= x;\n" 2086 " f(x)\n /= x;\n" 2087 " f(x)\n %= x;\n" 2088 " f(x)\n &= x;\n" 2089 " f(x)\n |= x;\n" 2090 " f(x)\n ^= x;\n" 2091 " f(x)\n >>= x;\n" 2092 " f(x)\n <<= x;\n" 2093 " f(x)\n[y].z();\n" 2094 " LOG(INFO)\n << x;\n" 2095 " ifstream(x)\n >> x;\n" 2096 "}\n")); 2097 EXPECT_EQ("int q() {\n" 2098 " f(x)\n" 2099 " if (1) {\n" 2100 " }\n" 2101 " f(x)\n" 2102 " while (1) {\n" 2103 " }\n" 2104 " f(x)\n" 2105 " g(x);\n" 2106 " f(x)\n" 2107 " try {\n" 2108 " q();\n" 2109 " }\n" 2110 " catch (...) {\n" 2111 " }\n" 2112 "}\n", 2113 format("int q() {\n" 2114 "f(x)\n" 2115 "if (1) {}\n" 2116 "f(x)\n" 2117 "while (1) {}\n" 2118 "f(x)\n" 2119 "g(x);\n" 2120 "f(x)\n" 2121 "try { q(); } catch (...) {}\n" 2122 "}\n")); 2123 EXPECT_EQ("class A {\n" 2124 " A() : t(0) {}\n" 2125 " A(X x)\n" // FIXME: function-level try blocks are broken. 2126 " try : t(0) {\n" 2127 " }\n" 2128 " catch (...) {\n" 2129 " }\n" 2130 "};", 2131 format("class A {\n" 2132 " A()\n : t(0) {}\n" 2133 " A(X x)\n" 2134 " try : t(0) {} catch (...) {}\n" 2135 "};")); 2136} 2137 2138TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { 2139 verifyFormat("#define A \\\n" 2140 " f({ \\\n" 2141 " g(); \\\n" 2142 " });", getLLVMStyleWithColumns(11)); 2143} 2144 2145TEST_F(FormatTest, IndentPreprocessorDirectivesAtZero) { 2146 EXPECT_EQ("{\n {\n#define A\n }\n}", format("{{\n#define A\n}}")); 2147} 2148 2149TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 2150 verifyFormat("{\n { a #c; }\n}"); 2151} 2152 2153TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 2154 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 2155 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 2156 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 2157 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 2158} 2159 2160TEST_F(FormatTest, EscapedNewlineAtStartOfToken) { 2161 EXPECT_EQ( 2162 "#define A \\\n int i; \\\n int j;", 2163 format("#define A \\\nint i;\\\n int j;", getLLVMStyleWithColumns(11))); 2164 EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();")); 2165} 2166 2167TEST_F(FormatTest, NoEscapedNewlineHandlingInBlockComments) { 2168 EXPECT_EQ("/* \\ \\ \\\n*/", format("\\\n/* \\ \\ \\\n*/")); 2169} 2170 2171TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 2172 verifyFormat("#define A \\\n" 2173 " int v( \\\n" 2174 " a); \\\n" 2175 " int i;", 2176 getLLVMStyleWithColumns(11)); 2177} 2178 2179TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 2180 EXPECT_EQ( 2181 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2182 " \\\n" 2183 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 2184 "\n" 2185 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 2186 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 2187 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 2188 "\\\n" 2189 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 2190 " \n" 2191 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 2192 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 2193} 2194 2195TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 2196 EXPECT_EQ("int\n" 2197 "#define A\n" 2198 " a;", 2199 format("int\n#define A\na;", getGoogleStyle())); 2200 verifyFormat("functionCallTo(\n" 2201 " someOtherFunction(\n" 2202 " withSomeParameters, whichInSequence,\n" 2203 " areLongerThanALine(andAnotherCall,\n" 2204 "#define A B\n" 2205 " withMoreParamters,\n" 2206 " whichStronglyInfluenceTheLayout),\n" 2207 " andMoreParameters),\n" 2208 " trailing);", 2209 getLLVMStyleWithColumns(69)); 2210} 2211 2212TEST_F(FormatTest, LayoutBlockInsideParens) { 2213 EXPECT_EQ("functionCall({ int i; });", format(" functionCall ( {int i;} );")); 2214 EXPECT_EQ("functionCall({\n" 2215 " int i;\n" 2216 " int j;\n" 2217 "});", 2218 format(" functionCall ( {int i;int j;} );")); 2219 EXPECT_EQ("functionCall({\n" 2220 " int i;\n" 2221 " int j;\n" 2222 " },\n" 2223 " aaaa, bbbb, cccc);", 2224 format(" functionCall ( {int i;int j;}, aaaa, bbbb, cccc);")); 2225 EXPECT_EQ("functionCall(aaaa, bbbb, { int i; });", 2226 format(" functionCall (aaaa, bbbb, {int i;});")); 2227 EXPECT_EQ("functionCall(aaaa, bbbb, {\n" 2228 " int i;\n" 2229 " int j;\n" 2230 "});", 2231 format(" functionCall (aaaa, bbbb, {int i;int j;});")); 2232 EXPECT_EQ("functionCall(aaaa, bbbb, { int i; });", 2233 format(" functionCall (aaaa, bbbb, {int i;});")); 2234 verifyFormat( 2235 "Aaa({\n" 2236 " int i; // break\n" 2237 " },\n" 2238 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 2239 " ccccccccccccccccc));"); 2240 verifyFormat("DEBUG({\n" 2241 " if (a)\n" 2242 " f();\n" 2243 "});"); 2244} 2245 2246TEST_F(FormatTest, LayoutBlockInsideStatement) { 2247 EXPECT_EQ("SOME_MACRO { int i; }\n" 2248 "int i;", 2249 format(" SOME_MACRO {int i;} int i;")); 2250} 2251 2252TEST_F(FormatTest, LayoutNestedBlocks) { 2253 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 2254 " struct s {\n" 2255 " int i;\n" 2256 " };\n" 2257 " s kBitsToOs[] = { { 10 } };\n" 2258 " for (int i = 0; i < 10; ++i)\n" 2259 " return;\n" 2260 "}"); 2261 verifyFormat("call(parameter, {\n" 2262 " something();\n" 2263 " // Comment using all columns.\n" 2264 " somethingelse();\n" 2265 "});", 2266 getLLVMStyleWithColumns(40)); 2267 EXPECT_EQ("call(parameter, {\n" 2268 " something();\n" 2269 " // Comment too\n" 2270 " // looooooooooong.\n" 2271 " somethingElse();\n" 2272 "});", 2273 format("call(parameter, {\n" 2274 " something();\n" 2275 " // Comment too looooooooooong.\n" 2276 " somethingElse();\n" 2277 "});", 2278 getLLVMStyleWithColumns(29))); 2279 EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); 2280 EXPECT_EQ("DEBUG({\n" 2281 " int i;\n" 2282 "\n" 2283 " // comment\n" 2284 " int j;\n" 2285 "});", 2286 format("DEBUG({\n" 2287 " int i;\n" 2288 "\n" 2289 " // comment\n" 2290 " int j;\n" 2291 "});")); 2292} 2293 2294TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 2295 EXPECT_EQ("{}", format("{}")); 2296 verifyFormat("enum E {};"); 2297 verifyFormat("enum E {}"); 2298} 2299 2300//===----------------------------------------------------------------------===// 2301// Line break tests. 2302//===----------------------------------------------------------------------===// 2303 2304TEST_F(FormatTest, PreventConfusingIndents) { 2305 verifyFormat( 2306 "SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" 2307 " parameter, parameter, parameter)),\n" 2308 " SecondLongCall(parameter));"); 2309 verifyFormat( 2310 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2311 " aaaaaaaaaaaaaaaaaaaaaaaa(\n" 2312 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 2313 " aaaaaaaaaaaaaaaaaaaaaaaa);"); 2314 verifyFormat( 2315 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2316 " [aaaaaaaaaaaaaaaaaaaaaaaa\n" 2317 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 2318 " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); 2319 verifyFormat( 2320 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" 2321 " aaaaaaaaaaaaaaaaaaaaaaaa<\n" 2322 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" 2323 " aaaaaaaaaaaaaaaaaaaaaaaa>;"); 2324 verifyFormat("int a = bbbb && ccc && fffff(\n" 2325 "#define A Just forcing a new line\n" 2326 " ddd);"); 2327} 2328 2329TEST_F(FormatTest, LineBreakingInBinaryExpressions) { 2330 verifyFormat( 2331 "bool aaaaaaa =\n" 2332 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" 2333 " bbbbbbbb();"); 2334 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" 2335 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" 2336 " ccccccccc == ddddddddddd;"); 2337 2338 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 2339 " aaaaaa) &&\n" 2340 " bbbbbb && cccccc;"); 2341 verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" 2342 " aaaaaa) >>\n" 2343 " bbbbbb;"); 2344 verifyFormat("Whitespaces.addUntouchableComment(\n" 2345 " SourceMgr.getSpellingColumnNumber(\n" 2346 " TheLine.Last->FormatTok.Tok.getLocation()) -\n" 2347 " 1);"); 2348 2349 verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2350 " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" 2351 " cccccc) {\n}"); 2352 2353 // If the LHS of a comparison is not a binary expression itself, the 2354 // additional linebreak confuses many people. 2355 verifyFormat( 2356 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2357 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" 2358 "}"); 2359 verifyFormat( 2360 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2361 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 2362 "}"); 2363 verifyFormat( 2364 "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" 2365 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 2366 "}"); 2367 // Even explicit parentheses stress the precedence enough to make the 2368 // additional break unnecessary. 2369 verifyFormat( 2370 "if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2371 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" 2372 "}"); 2373 // This cases is borderline, but with the indentation it is still readable. 2374 verifyFormat( 2375 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2376 " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2377 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 2378 "}", 2379 getLLVMStyleWithColumns(75)); 2380 2381 // If the LHS is a binary expression, we should still use the additional break 2382 // as otherwise the formatting hides the operator precedence. 2383 verifyFormat( 2384 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2385 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 2386 " 5) {\n" 2387 "}"); 2388 2389 FormatStyle OnePerLine = getLLVMStyle(); 2390 OnePerLine.BinPackParameters = false; 2391 verifyFormat( 2392 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2393 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2394 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", 2395 OnePerLine); 2396} 2397 2398TEST_F(FormatTest, ExpressionIndentation) { 2399 verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2400 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2401 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 2402 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 2403 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" 2404 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" 2405 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 2406 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" 2407 " ccccccccccccccccccccccccccccccccccccccccc;"); 2408 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 2409 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2410 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 2411 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 2412 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2413 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 2414 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 2415 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 2416 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" 2417 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" 2418 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" 2419 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 2420 verifyFormat("if () {\n" 2421 "} else if (aaaaa && bbbbb > // break\n" 2422 " ccccc) {\n" 2423 "}"); 2424 2425 // Presence of a trailing comment used to change indentation of b. 2426 verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" 2427 " b;\n" 2428 "return aaaaaaaaaaaaaaaaaaa +\n" 2429 " b; //", 2430 getLLVMStyleWithColumns(30)); 2431} 2432 2433TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { 2434 // Not sure what the best system is here. Like this, the LHS can be found 2435 // immediately above an operator (everything with the same or a higher 2436 // indent). The RHS is aligned right of the operator and so compasses 2437 // everything until something with the same indent as the operator is found. 2438 // FIXME: Is this a good system? 2439 FormatStyle Style = getLLVMStyle(); 2440 Style.BreakBeforeBinaryOperators = true; 2441 verifyFormat( 2442 "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2443 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2444 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2445 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2446 " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 2447 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 2448 " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2449 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2450 " > ccccccccccccccccccccccccccccccccccccccccc;", 2451 Style); 2452 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2453 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2454 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2455 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 2456 Style); 2457 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2458 " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2459 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2460 " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 2461 Style); 2462 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2463 " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2464 " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2465 " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", 2466 Style); 2467 verifyFormat("if () {\n" 2468 "} else if (aaaaa && bbbbb // break\n" 2469 " > ccccc) {\n" 2470 "}", 2471 Style); 2472} 2473 2474TEST_F(FormatTest, ConstructorInitializers) { 2475 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 2476 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 2477 getLLVMStyleWithColumns(45)); 2478 verifyFormat("Constructor()\n" 2479 " : Inttializer(FitsOnTheLine) {}", 2480 getLLVMStyleWithColumns(44)); 2481 verifyFormat("Constructor()\n" 2482 " : Inttializer(FitsOnTheLine) {}", 2483 getLLVMStyleWithColumns(43)); 2484 2485 verifyFormat( 2486 "SomeClass::Constructor()\n" 2487 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 2488 2489 verifyFormat( 2490 "SomeClass::Constructor()\n" 2491 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 2492 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); 2493 verifyFormat( 2494 "SomeClass::Constructor()\n" 2495 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 2496 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); 2497 2498 verifyFormat("Constructor()\n" 2499 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 2500 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2501 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 2502 " aaaaaaaaaaaaaaaaaaaaaaa() {}"); 2503 2504 verifyFormat("Constructor()\n" 2505 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2506 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 2507 2508 verifyFormat("Constructor(int Parameter = 0)\n" 2509 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" 2510 " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); 2511 verifyFormat("Constructor()\n" 2512 " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" 2513 "}", 2514 getLLVMStyleWithColumns(60)); 2515 2516 // Here a line could be saved by splitting the second initializer onto two 2517 // lines, but that is not desireable. 2518 verifyFormat("Constructor()\n" 2519 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 2520 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 2521 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 2522 2523 FormatStyle OnePerLine = getLLVMStyle(); 2524 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 2525 verifyFormat("SomeClass::Constructor()\n" 2526 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 2527 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 2528 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 2529 OnePerLine); 2530 verifyFormat("SomeClass::Constructor()\n" 2531 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 2532 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 2533 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 2534 OnePerLine); 2535 verifyFormat("MyClass::MyClass(int var)\n" 2536 " : some_var_(var), // 4 space indent\n" 2537 " some_other_var_(var + 1) { // lined up\n" 2538 "}", 2539 OnePerLine); 2540 verifyFormat("Constructor()\n" 2541 " : aaaaa(aaaaaa),\n" 2542 " aaaaa(aaaaaa),\n" 2543 " aaaaa(aaaaaa),\n" 2544 " aaaaa(aaaaaa),\n" 2545 " aaaaa(aaaaaa) {}", 2546 OnePerLine); 2547 verifyFormat("Constructor()\n" 2548 " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" 2549 " aaaaaaaaaaaaaaaaaaaaaa) {}", 2550 OnePerLine); 2551} 2552 2553TEST_F(FormatTest, MemoizationTests) { 2554 // This breaks if the memoization lookup does not take \c Indent and 2555 // \c LastSpace into account. 2556 verifyFormat( 2557 "extern CFRunLoopTimerRef\n" 2558 "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" 2559 " CFTimeInterval interval, CFOptionFlags flags,\n" 2560 " CFIndex order, CFRunLoopTimerCallBack callout,\n" 2561 " CFRunLoopTimerContext *context) {}"); 2562 2563 // Deep nesting somewhat works around our memoization. 2564 verifyFormat( 2565 "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 2566 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 2567 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 2568 " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" 2569 " aaaaa())))))))))))))))))))))))))))))))))))))));", 2570 getLLVMStyleWithColumns(65)); 2571 verifyFormat( 2572 "aaaaa(\n" 2573 " aaaaa,\n" 2574 " aaaaa(\n" 2575 " aaaaa,\n" 2576 " aaaaa(\n" 2577 " aaaaa,\n" 2578 " aaaaa(\n" 2579 " aaaaa,\n" 2580 " aaaaa(\n" 2581 " aaaaa,\n" 2582 " aaaaa(\n" 2583 " aaaaa,\n" 2584 " aaaaa(\n" 2585 " aaaaa,\n" 2586 " aaaaa(\n" 2587 " aaaaa,\n" 2588 " aaaaa(\n" 2589 " aaaaa,\n" 2590 " aaaaa(\n" 2591 " aaaaa,\n" 2592 " aaaaa(\n" 2593 " aaaaa,\n" 2594 " aaaaa(\n" 2595 " aaaaa,\n" 2596 " aaaaa))))))))))));", 2597 getLLVMStyleWithColumns(65)); 2598 verifyFormat( 2599 "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" 2600 " a),\n" 2601 " a),\n" 2602 " a),\n" 2603 " a),\n" 2604 " a),\n" 2605 " a),\n" 2606 " a),\n" 2607 " a),\n" 2608 " a),\n" 2609 " a),\n" 2610 " a),\n" 2611 " a),\n" 2612 " a),\n" 2613 " a),\n" 2614 " a),\n" 2615 " a),\n" 2616 " a)", 2617 getLLVMStyleWithColumns(65)); 2618 2619 // This test takes VERY long when memoization is broken. 2620 FormatStyle OnePerLine = getLLVMStyle(); 2621 OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; 2622 OnePerLine.BinPackParameters = false; 2623 std::string input = "Constructor()\n" 2624 " : aaaa(a,\n"; 2625 for (unsigned i = 0, e = 80; i != e; ++i) { 2626 input += " a,\n"; 2627 } 2628 input += " a) {}"; 2629 verifyFormat(input, OnePerLine); 2630} 2631 2632TEST_F(FormatTest, BreaksAsHighAsPossible) { 2633 verifyFormat( 2634 "void f() {\n" 2635 " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 2636 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 2637 " f();\n" 2638 "}"); 2639 verifyFormat("if (Intervals[i].getRange().getFirst() <\n" 2640 " Intervals[i - 1].getRange().getLast()) {\n}"); 2641} 2642 2643TEST_F(FormatTest, BreaksFunctionDeclarations) { 2644 // Principially, we break function declarations in a certain order: 2645 // 1) break amongst arguments. 2646 verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" 2647 " Cccccccccccccc cccccccccccccc);"); 2648 verifyFormat( 2649 "template <class TemplateIt>\n" 2650 "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" 2651 " TemplateIt *stop) {}"); 2652 2653 // 2) break after return type. 2654 verifyFormat( 2655 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2656 " bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", 2657 getGoogleStyle()); 2658 2659 // 3) break after (. 2660 verifyFormat( 2661 "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" 2662 " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", 2663 getGoogleStyle()); 2664 2665 // 4) break before after nested name specifiers. 2666 verifyFormat( 2667 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2668 " SomeClasssssssssssssssssssssssssssssssssssssss::\n" 2669 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", 2670 getGoogleStyle()); 2671 2672 // However, there are exceptions, if a sufficient amount of lines can be 2673 // saved. 2674 // FIXME: The precise cut-offs wrt. the number of saved lines might need some 2675 // more adjusting. 2676 verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 2677 " Cccccccccccccc cccccccccc,\n" 2678 " Cccccccccccccc cccccccccc,\n" 2679 " Cccccccccccccc cccccccccc,\n" 2680 " Cccccccccccccc cccccccccc);"); 2681 verifyFormat( 2682 "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2683 " bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 2684 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 2685 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", 2686 getGoogleStyle()); 2687 verifyFormat( 2688 "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" 2689 " Cccccccccccccc cccccccccc,\n" 2690 " Cccccccccccccc cccccccccc,\n" 2691 " Cccccccccccccc cccccccccc,\n" 2692 " Cccccccccccccc cccccccccc,\n" 2693 " Cccccccccccccc cccccccccc,\n" 2694 " Cccccccccccccc cccccccccc);"); 2695 verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 2696 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 2697 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 2698 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" 2699 " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 2700 2701 // Break after multi-line parameters. 2702 verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2703 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2704 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2705 " bbbb bbbb);"); 2706 2707 // Treat overloaded operators like other functions. 2708 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 2709 "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); 2710 verifyFormat("SomeLoooooooooooooooooooooooooogType\n" 2711 "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); 2712 verifyGoogleFormat( 2713 "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" 2714 " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); 2715} 2716 2717TEST_F(FormatTest, TrailingReturnType) { 2718 verifyFormat("auto foo() -> int;\n"); 2719 verifyFormat("struct S {\n" 2720 " auto bar() const -> int;\n" 2721 "};"); 2722 verifyFormat("template <size_t Order, typename T>\n" 2723 "auto load_img(const std::string &filename)\n" 2724 " -> alias::tensor<Order, T, mem::tag::cpu> {}"); 2725 2726 // Not trailing return types. 2727 verifyFormat("void f() { auto a = b->c(); }"); 2728} 2729 2730TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { 2731 // Avoid breaking before trailing 'const'. 2732 verifyFormat("void someLongFunction(\n" 2733 " int someLongParameter) const {}", 2734 getLLVMStyleWithColumns(46)); 2735 FormatStyle Style = getGoogleStyle(); 2736 Style.ColumnLimit = 47; 2737 verifyFormat("void\n" 2738 "someLongFunction(int someLongParameter) const {\n}", 2739 getLLVMStyleWithColumns(47)); 2740 verifyFormat("void someLongFunction(\n" 2741 " int someLongParameter) const {}", 2742 Style); 2743 verifyFormat("LoooooongReturnType\n" 2744 "someLoooooooongFunction() const {}", 2745 getLLVMStyleWithColumns(47)); 2746 verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" 2747 " const {}", 2748 Style); 2749 2750 // Avoid breaking before other trailing annotations, if they are not 2751 // function-like. 2752 verifyFormat("void SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2753 " aaaaaaaaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); 2754 2755 // Breaking before function-like trailing annotations is fine to keep them 2756 // close to their arguments. 2757 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 2758 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 2759 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 2760 " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); 2761 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 2762 " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); 2763 2764 verifyFormat( 2765 "void aaaaaaaaaaaaaaaaaa()\n" 2766 " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" 2767 " aaaaaaaaaaaaaaaaaaaaaaaaa));"); 2768 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2769 " __attribute__((unused));"); 2770 verifyFormat( 2771 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2772 " GUARDED_BY(aaaaaaaaaaaa);", 2773 getGoogleStyle()); 2774 verifyFormat( 2775 "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 2776 " GUARDED_BY(aaaaaaaaaaaa);", 2777 getGoogleStyle()); 2778} 2779 2780TEST_F(FormatTest, BreaksDesireably) { 2781 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 2782 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 2783 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 2784 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2785 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 2786 "}"); 2787 2788 verifyFormat( 2789 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2790 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 2791 2792 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2793 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2794 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 2795 2796 verifyFormat( 2797 "aaaaaaaa(aaaaaaaaaaaaa, aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2798 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 2799 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2800 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 2801 2802 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2803 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 2804 2805 verifyFormat( 2806 "void f() {\n" 2807 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 2808 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 2809 "}"); 2810 verifyFormat( 2811 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2812 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 2813 verifyFormat( 2814 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2815 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 2816 verifyFormat( 2817 "aaaaaaaaaaaaaaaaa(\n" 2818 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2819 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 2820 2821 // Indent consistently indenpendent of call expression. 2822 verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" 2823 " dddddddddddddddddddddddddddddd));\n" 2824 "aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" 2825 " dddddddddddddddddddddddddddddd));"); 2826 2827 // This test case breaks on an incorrect memoization, i.e. an optimization not 2828 // taking into account the StopAt value. 2829 verifyFormat( 2830 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 2831 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 2832 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 2833 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 2834 2835 verifyFormat("{\n {\n {\n" 2836 " Annotation.SpaceRequiredBefore =\n" 2837 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 2838 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 2839 " }\n }\n}"); 2840 2841 // Break on an outer level if there was a break on an inner level. 2842 EXPECT_EQ("f(g(h(a, // comment\n" 2843 " b, c),\n" 2844 " d, e),\n" 2845 " x, y);", 2846 format("f(g(h(a, // comment\n" 2847 " b, c), d, e), x, y);")); 2848 2849 // Prefer breaking similar line breaks. 2850 verifyFormat( 2851 "const int kTrackingOptions = NSTrackingMouseMoved |\n" 2852 " NSTrackingMouseEnteredAndExited |\n" 2853 " NSTrackingActiveAlways;"); 2854} 2855 2856TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 2857 FormatStyle NoBinPacking = getGoogleStyle(); 2858 NoBinPacking.BinPackParameters = false; 2859 verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" 2860 " aaaaaaaaaaaaaaaaaaaa,\n" 2861 " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", 2862 NoBinPacking); 2863 verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" 2864 " aaaaaaaaaaaaa,\n" 2865 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", 2866 NoBinPacking); 2867 verifyFormat( 2868 "aaaaaaaa(aaaaaaaaaaaaa,\n" 2869 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2870 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 2871 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2872 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", 2873 NoBinPacking); 2874 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 2875 " .aaaaaaaaaaaaaaaaaa();", 2876 NoBinPacking); 2877 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2878 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);", 2879 NoBinPacking); 2880 2881 verifyFormat( 2882 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 2883 " aaaaaaaaaaaa,\n" 2884 " aaaaaaaaaaaa);", 2885 NoBinPacking); 2886 verifyFormat( 2887 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 2888 " ddddddddddddddddddddddddddddd),\n" 2889 " test);", 2890 NoBinPacking); 2891 2892 verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 2893 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 2894 " aaaaaaaaaaaaaaaaaaaaaaa> aaaaaaaaaaaaaaaaaa;", 2895 NoBinPacking); 2896 verifyFormat("a(\"a\"\n" 2897 " \"a\",\n" 2898 " a);"); 2899 2900 NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; 2901 verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" 2902 " aaaaaaaaa,\n" 2903 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 2904 NoBinPacking); 2905 verifyFormat( 2906 "void f() {\n" 2907 " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" 2908 " .aaaaaaa();\n" 2909 "}", 2910 NoBinPacking); 2911 verifyFormat( 2912 "template <class SomeType, class SomeOtherType>\n" 2913 "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", 2914 NoBinPacking); 2915} 2916 2917TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { 2918 FormatStyle Style = getLLVMStyleWithColumns(15); 2919 Style.ExperimentalAutoDetectBinPacking = true; 2920 EXPECT_EQ("aaa(aaaa,\n" 2921 " aaaa,\n" 2922 " aaaa);\n" 2923 "aaa(aaaa,\n" 2924 " aaaa,\n" 2925 " aaaa);", 2926 format("aaa(aaaa,\n" // one-per-line 2927 " aaaa,\n" 2928 " aaaa );\n" 2929 "aaa(aaaa, aaaa, aaaa);", // inconclusive 2930 Style)); 2931 EXPECT_EQ("aaa(aaaa, aaaa,\n" 2932 " aaaa);\n" 2933 "aaa(aaaa, aaaa,\n" 2934 " aaaa);", 2935 format("aaa(aaaa, aaaa,\n" // bin-packed 2936 " aaaa );\n" 2937 "aaa(aaaa, aaaa, aaaa);", // inconclusive 2938 Style)); 2939} 2940 2941TEST_F(FormatTest, FormatsBuilderPattern) { 2942 verifyFormat( 2943 "return llvm::StringSwitch<Reference::Kind>(name)\n" 2944 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 2945 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" 2946 " .StartsWith(\".init\", ORDER_INIT)\n" 2947 " .StartsWith(\".fini\", ORDER_FINI)\n" 2948 " .StartsWith(\".hash\", ORDER_HASH)\n" 2949 " .Default(ORDER_TEXT);\n"); 2950 2951 verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" 2952 " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); 2953 verifyFormat( 2954 "aaaaaaa->aaaaaaa->aaaaaaaaaaaaaaaa(\n" 2955 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 2956 " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); 2957 verifyFormat( 2958 "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" 2959 " aaaaaaaaaaaaaa);"); 2960 verifyFormat( 2961 "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" 2962 " aaaaaa->aaaaaaaaaaaa()\n" 2963 " ->aaaaaaaaaaaaaaaa(\n" 2964 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 2965 " ->aaaaaaaaaaaaaaaaa();"); 2966 verifyFormat( 2967 "someobj->Add((new util::filetools::Handler(dir))\n" 2968 " ->OnEvent1(NewPermanentCallback(\n" 2969 " this, &HandlerHolderClass::EventHandlerCBA))\n" 2970 " ->OnEvent2(NewPermanentCallback(\n" 2971 " this, &HandlerHolderClass::EventHandlerCBB))\n" 2972 " ->OnEvent3(NewPermanentCallback(\n" 2973 " this, &HandlerHolderClass::EventHandlerCBC))\n" 2974 " ->OnEvent5(NewPermanentCallback(\n" 2975 " this, &HandlerHolderClass::EventHandlerCBD))\n" 2976 " ->OnEvent6(NewPermanentCallback(\n" 2977 " this, &HandlerHolderClass::EventHandlerCBE)));"); 2978 2979 verifyFormat( 2980 "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); 2981 verifyFormat("aaaaaaaaaaaaaaa()\n" 2982 " .aaaaaaaaaaaaaaa()\n" 2983 " .aaaaaaaaaaaaaaa()\n" 2984 " .aaaaaaaaaaaaaaa()\n" 2985 " .aaaaaaaaaaaaaaa();"); 2986 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 2987 " .aaaaaaaaaaaaaaa()\n" 2988 " .aaaaaaaaaaaaaaa()\n" 2989 " .aaaaaaaaaaaaaaa();"); 2990 verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 2991 " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" 2992 " .aaaaaaaaaaaaaaa();"); 2993 verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" 2994 " ->aaaaaaaaaaaaaae(0)\n" 2995 " ->aaaaaaaaaaaaaaa();"); 2996 2997 // Prefer not to break after empty parentheses. 2998 verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" 2999 " First->LastNewlineOffset);"); 3000} 3001 3002TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 3003 verifyFormat( 3004 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 3005 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 3006 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 3007 " ccccccccccccccccccccccccc) {\n}"); 3008 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 3009 " ccccccccccccccccccccccccc) {\n}"); 3010 verifyFormat( 3011 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 3012 " ccccccccccccccccccccccccc) {\n}"); 3013 verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" 3014 " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" 3015 " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" 3016 " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); 3017 verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" 3018 " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" 3019 " aaaaaaaaaaaaaaa != aa) {\n}"); 3020} 3021 3022TEST_F(FormatTest, BreaksAfterAssignments) { 3023 verifyFormat( 3024 "unsigned Cost =\n" 3025 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 3026 " SI->getPointerAddressSpaceee());\n"); 3027 verifyFormat( 3028 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 3029 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 3030 3031 verifyFormat( 3032 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" 3033 " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 3034 verifyFormat("unsigned OriginalStartColumn =\n" 3035 " SourceMgr.getSpellingColumnNumber(\n" 3036 " Current.FormatTok.getStartOfNonWhitespace()) -\n" 3037 " 1;"); 3038} 3039 3040TEST_F(FormatTest, AlignsAfterAssignments) { 3041 verifyFormat( 3042 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3043 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 3044 verifyFormat( 3045 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3046 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 3047 verifyFormat( 3048 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3049 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 3050 verifyFormat( 3051 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3052 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 3053 verifyFormat( 3054 "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" 3055 " aaaaaaaaaaaaaaaaaaaaaaaa +\n" 3056 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 3057} 3058 3059TEST_F(FormatTest, AlignsAfterReturn) { 3060 verifyFormat( 3061 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3062 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 3063 verifyFormat( 3064 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 3065 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 3066 verifyFormat( 3067 "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 3068 " aaaaaaaaaaaaaaaaaaaaaa();"); 3069 verifyFormat( 3070 "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" 3071 " aaaaaaaaaaaaaaaaaaaaaa());"); 3072 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3073 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3074 verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3075 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" 3076 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 3077} 3078 3079TEST_F(FormatTest, BreaksConditionalExpressions) { 3080 verifyFormat( 3081 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3082 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3083 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3084 verifyFormat( 3085 "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3086 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3087 verifyFormat( 3088 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" 3089 " : aaaaaaaaaaaaa);"); 3090 verifyFormat( 3091 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3092 " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3093 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3094 " aaaaaaaaaaaaa);"); 3095 verifyFormat( 3096 "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3097 " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3098 " aaaaaaaaaaaaa);"); 3099 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3100 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3101 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3102 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3103 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3104 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3105 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3106 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3107 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3108 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3109 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3110 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3111 verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3112 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3113 " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3114 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 3115 " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3116 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3117 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3118 " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 3119 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" 3120 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3121 " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3122 " : aaaaaaaaaaaaaaaa;"); 3123 verifyFormat( 3124 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3125 " ? aaaaaaaaaaaaaaa\n" 3126 " : aaaaaaaaaaaaaaa;"); 3127 verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" 3128 " aaaaaaaaa\n" 3129 " ? b\n" 3130 " : c);"); 3131 verifyFormat( 3132 "unsigned Indent =\n" 3133 " format(TheLine.First, IndentForLevel[TheLine.Level] >= 0\n" 3134 " ? IndentForLevel[TheLine.Level]\n" 3135 " : TheLine * 2,\n" 3136 " TheLine.InPPDirective, PreviousEndOfLineColumn);", 3137 getLLVMStyleWithColumns(70)); 3138 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 3139 " ? aaaaaaaaaaaaaaa\n" 3140 " : bbbbbbbbbbbbbbb //\n" 3141 " ? ccccccccccccccc\n" 3142 " : ddddddddddddddd;"); 3143 verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" 3144 " ? aaaaaaaaaaaaaaa\n" 3145 " : (bbbbbbbbbbbbbbb //\n" 3146 " ? ccccccccccccccc\n" 3147 " : ddddddddddddddd);"); 3148 3149 FormatStyle NoBinPacking = getLLVMStyle(); 3150 NoBinPacking.BinPackParameters = false; 3151 verifyFormat( 3152 "void f() {\n" 3153 " g(aaa,\n" 3154 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 3155 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3156 " ? aaaaaaaaaaaaaaa\n" 3157 " : aaaaaaaaaaaaaaa);\n" 3158 "}", 3159 NoBinPacking); 3160 verifyFormat( 3161 "void f() {\n" 3162 " g(aaa,\n" 3163 " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" 3164 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3165 " ?: aaaaaaaaaaaaaaa);\n" 3166 "}", 3167 NoBinPacking); 3168} 3169 3170TEST_F(FormatTest, DeclarationsOfMultipleVariables) { 3171 verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" 3172 " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); 3173 verifyFormat("bool a = true, b = false;"); 3174 3175 verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" 3176 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" 3177 " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" 3178 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); 3179 verifyFormat( 3180 "bool aaaaaaaaaaaaaaaaaaaaa =\n" 3181 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" 3182 " d = e && f;"); 3183 verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" 3184 " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); 3185 verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 3186 " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); 3187 verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" 3188 " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); 3189 // FIXME: If multiple variables are defined, the "*" needs to move to the new 3190 // line. Also fix indent for breaking after the type, this looks bad. 3191 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" 3192 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" 3193 " *b = bbbbbbbbbbbbbbbbbbb;", 3194 getGoogleStyle()); 3195 3196 // Not ideal, but pointer-with-type does not allow much here. 3197 verifyGoogleFormat( 3198 "aaaaaaaaa* a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" 3199 " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;"); 3200} 3201 3202TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 3203 verifyFormat("arr[foo ? bar : baz];"); 3204 verifyFormat("f()[foo ? bar : baz];"); 3205 verifyFormat("(a + b)[foo ? bar : baz];"); 3206 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 3207} 3208 3209TEST_F(FormatTest, AlignsStringLiterals) { 3210 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 3211 " \"short literal\");"); 3212 verifyFormat( 3213 "looooooooooooooooooooooooongFunction(\n" 3214 " \"short literal\"\n" 3215 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 3216 verifyFormat("someFunction(\"Always break between multi-line\"\n" 3217 " \" string literals\",\n" 3218 " and, other, parameters);"); 3219 EXPECT_EQ("fun + \"1243\" /* comment */\n" 3220 " \"5678\";", 3221 format("fun + \"1243\" /* comment */\n" 3222 " \"5678\";", 3223 getLLVMStyleWithColumns(28))); 3224 EXPECT_EQ( 3225 "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 3226 " \"aaaaaaaaaaaaaaaaaaaaa\"\n" 3227 " \"aaaaaaaaaaaaaaaa\";", 3228 format("aaaaaa =" 3229 "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " 3230 "aaaaaaaaaaaaaaaaaaaaa\" " 3231 "\"aaaaaaaaaaaaaaaa\";")); 3232 verifyFormat("a = a + \"a\"\n" 3233 " \"a\"\n" 3234 " \"a\";"); 3235 verifyFormat("f(\"a\", \"b\"\n" 3236 " \"c\");"); 3237 3238 verifyFormat( 3239 "#define LL_FORMAT \"ll\"\n" 3240 "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" 3241 " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); 3242 3243 verifyFormat("#define A(X) \\\n" 3244 " \"aaaaa\" #X \"bbbbbb\" \\\n" 3245 " \"ccccc\"", 3246 getLLVMStyleWithColumns(23)); 3247 verifyFormat("#define A \"def\"\n" 3248 "f(\"abc\" A \"ghi\"\n" 3249 " \"jkl\");"); 3250} 3251 3252TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { 3253 FormatStyle NoBreak = getLLVMStyle(); 3254 NoBreak.AlwaysBreakBeforeMultilineStrings = false; 3255 FormatStyle Break = getLLVMStyle(); 3256 Break.AlwaysBreakBeforeMultilineStrings = true; 3257 verifyFormat("aaaa = \"bbbb\"\n" 3258 " \"cccc\";", 3259 NoBreak); 3260 verifyFormat("aaaa =\n" 3261 " \"bbbb\"\n" 3262 " \"cccc\";", 3263 Break); 3264 verifyFormat("aaaa(\"bbbb\"\n" 3265 " \"cccc\");", 3266 NoBreak); 3267 verifyFormat("aaaa(\n" 3268 " \"bbbb\"\n" 3269 " \"cccc\");", 3270 Break); 3271 verifyFormat("aaaa(qqq, \"bbbb\"\n" 3272 " \"cccc\");", 3273 NoBreak); 3274 verifyFormat("aaaa(qqq,\n" 3275 " \"bbbb\"\n" 3276 " \"cccc\");", 3277 Break); 3278 3279 // Don't break if there is no column gain. 3280 verifyFormat("f(\"aaaa\"\n" 3281 " \"bbbb\");", 3282 Break); 3283 3284 // Treat literals with escaped newlines like multi-line string literals. 3285 EXPECT_EQ("x = \"a\\\n" 3286 "b\\\n" 3287 "c\";", 3288 format("x = \"a\\\n" 3289 "b\\\n" 3290 "c\";", 3291 NoBreak)); 3292 EXPECT_EQ("x =\n" 3293 " \"a\\\n" 3294 "b\\\n" 3295 "c\";", 3296 format("x = \"a\\\n" 3297 "b\\\n" 3298 "c\";", 3299 Break)); 3300} 3301 3302TEST_F(FormatTest, AlignsPipes) { 3303 verifyFormat( 3304 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3305 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3306 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 3307 verifyFormat( 3308 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 3309 " << aaaaaaaaaaaaaaaaaaaa;"); 3310 verifyFormat( 3311 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3312 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 3313 verifyFormat( 3314 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 3315 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 3316 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 3317 verifyFormat( 3318 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3319 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3320 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 3321 3322 verifyFormat("return out << \"somepacket = {\\n\"\n" 3323 " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" 3324 " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" 3325 " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" 3326 " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" 3327 " << \"}\";"); 3328 3329 verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 3330 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" 3331 " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); 3332 verifyFormat( 3333 "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" 3334 " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" 3335 " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" 3336 " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" 3337 " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); 3338 verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" 3339 " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 3340 verifyFormat( 3341 "void f() {\n" 3342 " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" 3343 " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" 3344 "}"); 3345 3346 // Breaking before the first "<<" is generally not desirable. 3347 verifyFormat( 3348 "llvm::errs()\n" 3349 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3350 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3351 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3352 " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 3353 getLLVMStyleWithColumns(70)); 3354 verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" 3355 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3356 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 3357 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3358 " << \"aaaaaaaaaaaaaaaaaaa: \"\n" 3359 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 3360 getLLVMStyleWithColumns(70)); 3361 3362 // But sometimes, breaking before the first "<<" is desirable. 3363 verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" 3364 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3365 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 3366 verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" 3367 " << BEF << IsTemplate << Description << E->getType();"); 3368 3369 verifyFormat( 3370 "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3371 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 3372} 3373 3374TEST_F(FormatTest, UnderstandsEquals) { 3375 verifyFormat( 3376 "aaaaaaaaaaaaaaaaa =\n" 3377 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 3378 verifyFormat( 3379 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 3380 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 3381 verifyFormat( 3382 "if (a) {\n" 3383 " f();\n" 3384 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 3385 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 3386 "}"); 3387 3388 verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 3389 " 100000000 + 10000000) {\n}"); 3390} 3391 3392TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 3393 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 3394 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 3395 3396 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 3397 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 3398 3399 verifyFormat( 3400 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 3401 " Parameter2);"); 3402 3403 verifyFormat( 3404 "ShortObject->shortFunction(\n" 3405 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 3406 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 3407 3408 verifyFormat("loooooooooooooongFunction(\n" 3409 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 3410 3411 verifyFormat( 3412 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 3413 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 3414 3415 verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" 3416 " .WillRepeatedly(Return(SomeValue));"); 3417 verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)]\n" 3418 " .insert(ccccccccccccccccccccccc);"); 3419 verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3420 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa).aaaaa(aaaaa),\n" 3421 " aaaaaaaaaaaaaaaaaaaaa);"); 3422 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3423 " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());"); 3424 verifyFormat( 3425 "aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3426 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 3427 " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3428 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3429 " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 3430 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3431 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3432 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3433 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" 3434 "}"); 3435 3436 // Here, it is not necessary to wrap at "." or "->". 3437 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 3438 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 3439 verifyFormat( 3440 "aaaaaaaaaaa->aaaaaaaaa(\n" 3441 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3442 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 3443 3444 verifyFormat( 3445 "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3446 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); 3447 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" 3448 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 3449 verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" 3450 " aaaaaaaaa()->aaaaaa()->aaaaa());"); 3451 3452 // FIXME: Should we break before .a()? 3453 verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3454 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa).a();"); 3455 3456 FormatStyle NoBinPacking = getLLVMStyle(); 3457 NoBinPacking.BinPackParameters = false; 3458 verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 3459 " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" 3460 " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" 3461 " aaaaaaaaaaaaaaaaaaa,\n" 3462 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", 3463 NoBinPacking); 3464 3465 // If there is a subsequent call, change to hanging indentation. 3466 verifyFormat( 3467 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3468 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" 3469 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 3470 verifyFormat( 3471 "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3472 " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); 3473} 3474 3475TEST_F(FormatTest, WrapsTemplateDeclarations) { 3476 verifyFormat("template <typename T>\n" 3477 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 3478 verifyFormat( 3479 "template <typename T>\n" 3480 "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;"); 3481 verifyFormat("template <typename T>\n" 3482 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 3483 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 3484 verifyFormat( 3485 "template <typename T>\n" 3486 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 3487 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 3488 verifyFormat( 3489 "template <typename T>\n" 3490 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 3491 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 3492 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3493 verifyFormat("template <typename T>\n" 3494 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3495 " int aaaaaaaaaaaaaaaaaaaaaa);"); 3496 verifyFormat( 3497 "template <typename T1, typename T2 = char, typename T3 = char,\n" 3498 " typename T4 = char>\n" 3499 "void f();"); 3500 verifyFormat( 3501 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 3502 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3503 3504 verifyFormat("a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n" 3505 " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));"); 3506 3507 verifyFormat("template <typename T> class C {};"); 3508 verifyFormat("template <typename T> void f();"); 3509 verifyFormat("template <typename T> void f() {}"); 3510 3511 FormatStyle AlwaysBreak = getLLVMStyle(); 3512 AlwaysBreak.AlwaysBreakTemplateDeclarations = true; 3513 verifyFormat("template <typename T>\nclass C {};", AlwaysBreak); 3514 verifyFormat("template <typename T>\nvoid f();", AlwaysBreak); 3515 verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak); 3516 verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3517 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n" 3518 " ccccccccccccccccccccccccccccccccccccccccccccccc);"); 3519 verifyFormat( 3520 "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 3521 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3522 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n" 3523 " new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n" 3524 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3525 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n" 3526 " bbbbbbbbbbbbbbbbbbbbbbbb);", 3527 getLLVMStyleWithColumns(72)); 3528} 3529 3530TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 3531 verifyFormat( 3532 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 3533 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 3534 verifyFormat( 3535 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 3536 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3537 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 3538 3539 // FIXME: Should we have the extra indent after the second break? 3540 verifyFormat( 3541 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 3542 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 3543 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 3544 3545 verifyFormat( 3546 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 3547 " cccccccccccccccccccccccccccccccccccccccccccccc());"); 3548 3549 // Breaking at nested name specifiers is generally not desirable. 3550 verifyFormat( 3551 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3552 " aaaaaaaaaaaaaaaaaaaaaaa);"); 3553 3554 verifyFormat( 3555 "aaaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 3556 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 3557 " aaaaaaaaaaaaaaaaaaaaa);", 3558 getLLVMStyleWithColumns(74)); 3559 3560 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 3561 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3562 " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 3563} 3564 3565TEST_F(FormatTest, UnderstandsTemplateParameters) { 3566 verifyFormat("A<int> a;"); 3567 verifyFormat("A<A<A<int> > > a;"); 3568 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 3569 verifyFormat("bool x = a < 1 || 2 > a;"); 3570 verifyFormat("bool x = 5 < f<int>();"); 3571 verifyFormat("bool x = f<int>() > 5;"); 3572 verifyFormat("bool x = 5 < a<int>::x;"); 3573 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 3574 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 3575 3576 verifyGoogleFormat("A<A<int>> a;"); 3577 verifyGoogleFormat("A<A<A<int>>> a;"); 3578 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 3579 verifyGoogleFormat("A<A<int> > a;"); 3580 verifyGoogleFormat("A<A<A<int> > > a;"); 3581 verifyGoogleFormat("A<A<A<A<int> > > > a;"); 3582 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle())); 3583 EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle())); 3584 3585 verifyFormat("test >> a >> b;"); 3586 verifyFormat("test << a >> b;"); 3587 3588 verifyFormat("f<int>();"); 3589 verifyFormat("template <typename T> void f() {}"); 3590 3591 // Not template parameters. 3592 verifyFormat("return a < b && c > d;"); 3593 verifyFormat("void f() {\n" 3594 " while (a < b && c > d) {\n" 3595 " }\n" 3596 "}"); 3597 verifyFormat("template <typename... Types>\n" 3598 "typename enable_if<0 < sizeof...(Types)>::type Foo() {}"); 3599} 3600 3601TEST_F(FormatTest, UnderstandsBinaryOperators) { 3602 verifyFormat("COMPARE(a, ==, b);"); 3603} 3604 3605TEST_F(FormatTest, UnderstandsPointersToMembers) { 3606 verifyFormat("int A::*x;"); 3607 verifyFormat("int (S::*func)(void *);"); 3608 verifyFormat("void f() { int (S::*func)(void *); }"); 3609 verifyFormat("typedef bool *(Class::*Member)() const;"); 3610 verifyFormat("void f() {\n" 3611 " (a->*f)();\n" 3612 " a->*x;\n" 3613 " (a.*f)();\n" 3614 " ((*a).*f)();\n" 3615 " a.*x;\n" 3616 "}"); 3617 verifyFormat("void f() {\n" 3618 " (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n" 3619 " aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n" 3620 "}"); 3621 FormatStyle Style = getLLVMStyle(); 3622 Style.PointerBindsToType = true; 3623 verifyFormat("typedef bool* (Class::*Member)() const;", Style); 3624} 3625 3626TEST_F(FormatTest, UnderstandsUnaryOperators) { 3627 verifyFormat("int a = -2;"); 3628 verifyFormat("f(-1, -2, -3);"); 3629 verifyFormat("a[-1] = 5;"); 3630 verifyFormat("int a = 5 + -2;"); 3631 verifyFormat("if (i == -1) {\n}"); 3632 verifyFormat("if (i != -1) {\n}"); 3633 verifyFormat("if (i > -1) {\n}"); 3634 verifyFormat("if (i < -1) {\n}"); 3635 verifyFormat("++(a->f());"); 3636 verifyFormat("--(a->f());"); 3637 verifyFormat("(a->f())++;"); 3638 verifyFormat("a[42]++;"); 3639 verifyFormat("if (!(a->f())) {\n}"); 3640 3641 verifyFormat("a-- > b;"); 3642 verifyFormat("b ? -a : c;"); 3643 verifyFormat("n * sizeof char16;"); 3644 verifyFormat("n * alignof char16;", getGoogleStyle()); 3645 verifyFormat("sizeof(char);"); 3646 verifyFormat("alignof(char);", getGoogleStyle()); 3647 3648 verifyFormat("return -1;"); 3649 verifyFormat("switch (a) {\n" 3650 "case -1:\n" 3651 " break;\n" 3652 "}"); 3653 verifyFormat("#define X -1"); 3654 verifyFormat("#define X -kConstant"); 3655 3656 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = { -5, +3 };"); 3657 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = { +5, -3 };"); 3658 3659 verifyFormat("int a = /* confusing comment */ -1;"); 3660 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 3661 verifyFormat("int a = i /* confusing comment */++;"); 3662} 3663 3664TEST_F(FormatTest, IndentsRelativeToUnaryOperators) { 3665 verifyFormat("if (!aaaaaaaaaa( // break\n" 3666 " aaaaa)) {\n" 3667 "}"); 3668 verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n" 3669 " aaaaa));"); 3670 3671 // Only indent relative to unary operators if the expression is nested. 3672 verifyFormat("*aaa = aaaaaaa( // break\n" 3673 " bbbbbb);"); 3674} 3675 3676TEST_F(FormatTest, UnderstandsOverloadedOperators) { 3677 verifyFormat("bool operator<();"); 3678 verifyFormat("bool operator>();"); 3679 verifyFormat("bool operator=();"); 3680 verifyFormat("bool operator==();"); 3681 verifyFormat("bool operator!=();"); 3682 verifyFormat("int operator+();"); 3683 verifyFormat("int operator++();"); 3684 verifyFormat("bool operator();"); 3685 verifyFormat("bool operator()();"); 3686 verifyFormat("bool operator[]();"); 3687 verifyFormat("operator bool();"); 3688 verifyFormat("operator int();"); 3689 verifyFormat("operator void *();"); 3690 verifyFormat("operator SomeType<int>();"); 3691 verifyFormat("operator SomeType<int, int>();"); 3692 verifyFormat("operator SomeType<SomeType<int> >();"); 3693 verifyFormat("void *operator new(std::size_t size);"); 3694 verifyFormat("void *operator new[](std::size_t size);"); 3695 verifyFormat("void operator delete(void *ptr);"); 3696 verifyFormat("void operator delete[](void *ptr);"); 3697 verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n" 3698 "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);"); 3699 3700 verifyFormat( 3701 "ostream &operator<<(ostream &OutputStream,\n" 3702 " SomeReallyLongType WithSomeReallyLongValue);"); 3703 verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n" 3704 " const aaaaaaaaaaaaaaaaaaaaa &right) {\n" 3705 " return left.group < right.group;\n" 3706 "}"); 3707 verifyFormat("SomeType &operator=(const SomeType &S);"); 3708 3709 verifyGoogleFormat("operator void*();"); 3710 verifyGoogleFormat("operator SomeType<SomeType<int>>();"); 3711 3712 verifyFormat("using A::operator+;"); 3713} 3714 3715TEST_F(FormatTest, UnderstandsNewAndDelete) { 3716 verifyFormat("void f() {\n" 3717 " A *a = new A;\n" 3718 " A *a = new (placement) A;\n" 3719 " delete a;\n" 3720 " delete (A *)a;\n" 3721 "}"); 3722} 3723 3724TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 3725 verifyFormat("int *f(int *a) {}"); 3726 verifyFormat("int main(int argc, char **argv) {}"); 3727 verifyFormat("Test::Test(int b) : a(b * b) {}"); 3728 verifyIndependentOfContext("f(a, *a);"); 3729 verifyFormat("void g() { f(*a); }"); 3730 verifyIndependentOfContext("int a = b * 10;"); 3731 verifyIndependentOfContext("int a = 10 * b;"); 3732 verifyIndependentOfContext("int a = b * c;"); 3733 verifyIndependentOfContext("int a += b * c;"); 3734 verifyIndependentOfContext("int a -= b * c;"); 3735 verifyIndependentOfContext("int a *= b * c;"); 3736 verifyIndependentOfContext("int a /= b * c;"); 3737 verifyIndependentOfContext("int a = *b;"); 3738 verifyIndependentOfContext("int a = *b * c;"); 3739 verifyIndependentOfContext("int a = b * *c;"); 3740 verifyIndependentOfContext("return 10 * b;"); 3741 verifyIndependentOfContext("return *b * *c;"); 3742 verifyIndependentOfContext("return a & ~b;"); 3743 verifyIndependentOfContext("f(b ? *c : *d);"); 3744 verifyIndependentOfContext("int a = b ? *c : *d;"); 3745 verifyIndependentOfContext("*b = a;"); 3746 verifyIndependentOfContext("a * ~b;"); 3747 verifyIndependentOfContext("a * !b;"); 3748 verifyIndependentOfContext("a * +b;"); 3749 verifyIndependentOfContext("a * -b;"); 3750 verifyIndependentOfContext("a * ++b;"); 3751 verifyIndependentOfContext("a * --b;"); 3752 verifyIndependentOfContext("a[4] * b;"); 3753 verifyIndependentOfContext("a[a * a] = 1;"); 3754 verifyIndependentOfContext("f() * b;"); 3755 verifyIndependentOfContext("a * [self dostuff];"); 3756 verifyIndependentOfContext("int x = a * (a + b);"); 3757 verifyIndependentOfContext("(a *)(a + b);"); 3758 verifyIndependentOfContext("int *pa = (int *)&a;"); 3759 verifyIndependentOfContext("return sizeof(int **);"); 3760 verifyIndependentOfContext("return sizeof(int ******);"); 3761 verifyIndependentOfContext("return (int **&)a;"); 3762 verifyIndependentOfContext("f((*PointerToArray)[10]);"); 3763 verifyFormat("void f(Type (*parameter)[10]) {}"); 3764 verifyGoogleFormat("return sizeof(int**);"); 3765 verifyIndependentOfContext("Type **A = static_cast<Type **>(P);"); 3766 verifyGoogleFormat("Type** A = static_cast<Type**>(P);"); 3767 verifyFormat("auto a = [](int **&, int ***) {};"); 3768 verifyFormat("typedef typeof(int(int, int)) *MyFunc;"); 3769 3770 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 3771 3772 verifyIndependentOfContext("A<int *> a;"); 3773 verifyIndependentOfContext("A<int **> a;"); 3774 verifyIndependentOfContext("A<int *, int *> a;"); 3775 verifyIndependentOfContext( 3776 "const char *const p = reinterpret_cast<const char *const>(q);"); 3777 verifyIndependentOfContext("A<int **, int **> a;"); 3778 verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);"); 3779 verifyFormat("for (char **a = b; *a; ++a) {\n}"); 3780 verifyFormat("for (; a && b;) {\n}"); 3781 3782 verifyFormat( 3783 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 3784 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 3785 3786 verifyGoogleFormat("int main(int argc, char** argv) {}"); 3787 verifyGoogleFormat("A<int*> a;"); 3788 verifyGoogleFormat("A<int**> a;"); 3789 verifyGoogleFormat("A<int*, int*> a;"); 3790 verifyGoogleFormat("A<int**, int**> a;"); 3791 verifyGoogleFormat("f(b ? *c : *d);"); 3792 verifyGoogleFormat("int a = b ? *c : *d;"); 3793 verifyGoogleFormat("Type* t = **x;"); 3794 verifyGoogleFormat("Type* t = *++*x;"); 3795 verifyGoogleFormat("*++*x;"); 3796 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 3797 verifyGoogleFormat("Type* t = x++ * y;"); 3798 verifyGoogleFormat( 3799 "const char* const p = reinterpret_cast<const char* const>(q);"); 3800 3801 verifyIndependentOfContext("a = *(x + y);"); 3802 verifyIndependentOfContext("a = &(x + y);"); 3803 verifyIndependentOfContext("*(x + y).call();"); 3804 verifyIndependentOfContext("&(x + y)->call();"); 3805 verifyFormat("void f() { &(*I).first; }"); 3806 3807 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 3808 verifyFormat( 3809 "int *MyValues = {\n" 3810 " *A, // Operator detection might be confused by the '{'\n" 3811 " *BB // Operator detection might be confused by previous comment\n" 3812 "};"); 3813 3814 verifyIndependentOfContext("if (int *a = &b)"); 3815 verifyIndependentOfContext("if (int &a = *b)"); 3816 verifyIndependentOfContext("if (a & b[i])"); 3817 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 3818 verifyIndependentOfContext("if (*b[i])"); 3819 verifyIndependentOfContext("if (int *a = (&b))"); 3820 verifyIndependentOfContext("while (int *a = &b)"); 3821 verifyFormat("void f() {\n" 3822 " for (const int &v : Values) {\n" 3823 " }\n" 3824 "}"); 3825 verifyFormat("for (int i = a * a; i < 10; ++i) {\n}"); 3826 verifyFormat("for (int i = 0; i < a * a; ++i) {\n}"); 3827 3828 verifyFormat("#define MACRO \\\n" 3829 " int *i = a * b; \\\n" 3830 " void f(a *b);", 3831 getLLVMStyleWithColumns(19)); 3832 3833 verifyIndependentOfContext("A = new SomeType *[Length];"); 3834 verifyIndependentOfContext("A = new SomeType *[Length]();"); 3835 verifyIndependentOfContext("T **t = new T *;"); 3836 verifyIndependentOfContext("T **t = new T *();"); 3837 verifyGoogleFormat("A = new SomeType* [Length]();"); 3838 verifyGoogleFormat("A = new SomeType* [Length];"); 3839 verifyGoogleFormat("T** t = new T*;"); 3840 verifyGoogleFormat("T** t = new T*();"); 3841 3842 FormatStyle PointerLeft = getLLVMStyle(); 3843 PointerLeft.PointerBindsToType = true; 3844 verifyFormat("delete *x;", PointerLeft); 3845} 3846 3847TEST_F(FormatTest, UnderstandsAttributes) { 3848 verifyFormat("SomeType s __attribute__((unused)) (InitValue);"); 3849} 3850 3851TEST_F(FormatTest, UnderstandsEllipsis) { 3852 verifyFormat("int printf(const char *fmt, ...);"); 3853 verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }"); 3854 verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}"); 3855 3856 FormatStyle PointersLeft = getLLVMStyle(); 3857 PointersLeft.PointerBindsToType = true; 3858 verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft); 3859} 3860 3861TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) { 3862 EXPECT_EQ("int *a;\n" 3863 "int *a;\n" 3864 "int *a;", 3865 format("int *a;\n" 3866 "int* a;\n" 3867 "int *a;", 3868 getGoogleStyle())); 3869 EXPECT_EQ("int* a;\n" 3870 "int* a;\n" 3871 "int* a;", 3872 format("int* a;\n" 3873 "int* a;\n" 3874 "int *a;", 3875 getGoogleStyle())); 3876 EXPECT_EQ("int *a;\n" 3877 "int *a;\n" 3878 "int *a;", 3879 format("int *a;\n" 3880 "int * a;\n" 3881 "int * a;", 3882 getGoogleStyle())); 3883} 3884 3885TEST_F(FormatTest, UnderstandsRvalueReferences) { 3886 verifyFormat("int f(int &&a) {}"); 3887 verifyFormat("int f(int a, char &&b) {}"); 3888 verifyFormat("void f() { int &&a = b; }"); 3889 verifyGoogleFormat("int f(int a, char&& b) {}"); 3890 verifyGoogleFormat("void f() { int&& a = b; }"); 3891 3892 verifyIndependentOfContext("A<int &&> a;"); 3893 verifyIndependentOfContext("A<int &&, int &&> a;"); 3894 verifyGoogleFormat("A<int&&> a;"); 3895 verifyGoogleFormat("A<int&&, int&&> a;"); 3896 3897 // Not rvalue references: 3898 verifyFormat("template <bool B, bool C> class A {\n" 3899 " static_assert(B && C, \"Something is wrong\");\n" 3900 "};"); 3901 verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))"); 3902 verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))"); 3903} 3904 3905TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 3906 verifyFormat("void f() {\n" 3907 " x[aaaaaaaaa -\n" 3908 " b] = 23;\n" 3909 "}", 3910 getLLVMStyleWithColumns(15)); 3911} 3912 3913TEST_F(FormatTest, FormatsCasts) { 3914 verifyFormat("Type *A = static_cast<Type *>(P);"); 3915 verifyFormat("Type *A = (Type *)P;"); 3916 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 3917 verifyFormat("int a = (int)(2.0f);"); 3918 verifyFormat("int a = (int)2.0f;"); 3919 verifyFormat("x[(int32)y];"); 3920 verifyFormat("x = (int32)y;"); 3921 verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)"); 3922 verifyFormat("int a = (int)*b;"); 3923 verifyFormat("int a = (int)2.0f;"); 3924 verifyFormat("int a = (int)~0;"); 3925 verifyFormat("int a = (int)++a;"); 3926 verifyFormat("int a = (int)sizeof(int);"); 3927 verifyFormat("int a = (int)+2;"); 3928 verifyFormat("my_int a = (my_int)2.0f;"); 3929 verifyFormat("my_int a = (my_int)sizeof(int);"); 3930 verifyFormat("return (my_int)aaa;"); 3931 verifyFormat("#define x ((int)-1)"); 3932 verifyFormat("#define p(q) ((int *)&q)"); 3933 3934 // FIXME: Without type knowledge, this can still fall apart miserably. 3935 verifyFormat("void f() { my_int a = (my_int) * b; }"); 3936 verifyFormat("void f() { return P ? (my_int) * P : (my_int)0; }"); 3937 verifyFormat("my_int a = (my_int) ~0;"); 3938 verifyFormat("my_int a = (my_int)++ a;"); 3939 verifyFormat("my_int a = (my_int) + 2;"); 3940 3941 // Don't break after a cast's 3942 verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 3943 " (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n" 3944 " bbbbbbbbbbbbbbbbbbbbbb);"); 3945 3946 // These are not casts. 3947 verifyFormat("void f(int *) {}"); 3948 verifyFormat("f(foo)->b;"); 3949 verifyFormat("f(foo).b;"); 3950 verifyFormat("f(foo)(b);"); 3951 verifyFormat("f(foo)[b];"); 3952 verifyFormat("[](foo) { return 4; }(bar);"); 3953 verifyFormat("(*funptr)(foo)[4];"); 3954 verifyFormat("funptrs[4](foo)[4];"); 3955 verifyFormat("void f(int *);"); 3956 verifyFormat("void f(int *) = 0;"); 3957 verifyFormat("void f(SmallVector<int>) {}"); 3958 verifyFormat("void f(SmallVector<int>);"); 3959 verifyFormat("void f(SmallVector<int>) = 0;"); 3960 verifyFormat("void f(int i = (kValue) * kMask) {}"); 3961 verifyFormat("void f(int i = (kA * kB) & kMask) {}"); 3962 verifyFormat("int a = sizeof(int) * b;"); 3963 verifyFormat("int a = alignof(int) * b;", getGoogleStyle()); 3964 verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;"); 3965 verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");"); 3966 verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;"); 3967 3968 // These are not casts, but at some point were confused with casts. 3969 verifyFormat("virtual void foo(int *) override;"); 3970 verifyFormat("virtual void foo(char &) const;"); 3971 verifyFormat("virtual void foo(int *a, char *) const;"); 3972 verifyFormat("int a = sizeof(int *) + b;"); 3973 verifyFormat("int a = alignof(int *) + b;", getGoogleStyle()); 3974 3975 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n" 3976 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 3977 // FIXME: The indentation here is not ideal. 3978 verifyFormat( 3979 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 3980 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n" 3981 " [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];"); 3982} 3983 3984TEST_F(FormatTest, FormatsFunctionTypes) { 3985 verifyFormat("A<bool()> a;"); 3986 verifyFormat("A<SomeType()> a;"); 3987 verifyFormat("A<void (*)(int, std::string)> a;"); 3988 verifyFormat("A<void *(int)>;"); 3989 verifyFormat("void *(*a)(int *, SomeType *);"); 3990 verifyFormat("int (*func)(void *);"); 3991 verifyFormat("void f() { int (*func)(void *); }"); 3992 verifyFormat("template <class CallbackClass>\n" 3993 "using MyCallback = void (CallbackClass::*)(SomeObject *Data);"); 3994 3995 verifyGoogleFormat("A<void*(int*, SomeType*)>;"); 3996 verifyGoogleFormat("void* (*a)(int);"); 3997 verifyGoogleFormat( 3998 "template <class CallbackClass>\n" 3999 "using MyCallback = void (CallbackClass::*)(SomeObject* Data);"); 4000 4001 // Other constructs can look somewhat like function types: 4002 verifyFormat("A<sizeof(*x)> a;"); 4003 verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)"); 4004 verifyFormat("some_var = function(*some_pointer_var)[0];"); 4005 verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }"); 4006} 4007 4008TEST_F(FormatTest, BreaksLongDeclarations) { 4009 verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n" 4010 " AnotherNameForTheLongType;", 4011 getGoogleStyle()); 4012 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n" 4013 " LoooooooooooooooooooooooooooooooooooooooongVariable;", 4014 getGoogleStyle()); 4015 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n" 4016 " LoooooooooooooooooooooooooooooooooooooooongVariable;", 4017 getGoogleStyle()); 4018 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 4019 " LoooooooooooooooooooooooooooooooongFunctionDeclaration();", 4020 getGoogleStyle()); 4021 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n" 4022 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 4023 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n" 4024 "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}"); 4025 4026 // FIXME: Without the comment, this breaks after "(". 4027 verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType // break\n" 4028 " (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();", 4029 getGoogleStyle()); 4030 4031 verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n" 4032 " int LoooooooooooooooooooongParam2) {}"); 4033 verifyFormat( 4034 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 4035 " SourceLocation L, IdentifierIn *II,\n" 4036 " Type *T) {}"); 4037 verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n" 4038 "ReallyReallyLongFunctionName(\n" 4039 " const std::string &SomeParameter,\n" 4040 " const SomeType<string, SomeOtherTemplateParameter> &\n" 4041 " ReallyReallyLongParameterName,\n" 4042 " const SomeType<string, SomeOtherTemplateParameter> &\n" 4043 " AnotherLongParameterName) {}"); 4044 verifyFormat("template <typename A>\n" 4045 "SomeLoooooooooooooooooooooongType<\n" 4046 " typename some_namespace::SomeOtherType<A>::Type>\n" 4047 "Function() {}"); 4048 4049 verifyGoogleFormat( 4050 "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n" 4051 " aaaaaaaaaaaaaaaaaaaaaaa;"); 4052 verifyGoogleFormat( 4053 "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n" 4054 " SourceLocation L) {}"); 4055 verifyGoogleFormat( 4056 "some_namespace::LongReturnType\n" 4057 "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n" 4058 " int first_long_parameter, int second_parameter) {}"); 4059 4060 verifyGoogleFormat("template <typename T>\n" 4061 "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n" 4062 "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}"); 4063 verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4064 " int aaaaaaaaaaaaaaaaaaaaaaa);"); 4065} 4066 4067TEST_F(FormatTest, FormatsArrays) { 4068 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 4069 " [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;"); 4070 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4071 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 4072 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4073 " [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;"); 4074 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 4075 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" 4076 " [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;"); 4077 verifyFormat( 4078 "llvm::outs() << \"aaaaaaaaaaaa: \"\n" 4079 " << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n" 4080 " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];"); 4081} 4082 4083TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 4084 verifyFormat("(a)->b();"); 4085 verifyFormat("--a;"); 4086} 4087 4088TEST_F(FormatTest, HandlesIncludeDirectives) { 4089 verifyFormat("#include <string>\n" 4090 "#include <a/b/c.h>\n" 4091 "#include \"a/b/string\"\n" 4092 "#include \"string.h\"\n" 4093 "#include \"string.h\"\n" 4094 "#include <a-a>\n" 4095 "#include < path with space >\n" 4096 "#include \"abc.h\" // this is included for ABC\n" 4097 "#include \"some long include\" // with a comment\n" 4098 "#include \"some very long include paaaaaaaaaaaaaaaaaaaaaaath\"", 4099 getLLVMStyleWithColumns(35)); 4100 4101 verifyFormat("#import <string>"); 4102 verifyFormat("#import <a/b/c.h>"); 4103 verifyFormat("#import \"a/b/string\""); 4104 verifyFormat("#import \"string.h\""); 4105 verifyFormat("#import \"string.h\""); 4106 verifyFormat("#if __has_include(<strstream>)\n" 4107 "#include <strstream>\n" 4108 "#endif"); 4109} 4110 4111//===----------------------------------------------------------------------===// 4112// Error recovery tests. 4113//===----------------------------------------------------------------------===// 4114 4115TEST_F(FormatTest, IncompleteParameterLists) { 4116 FormatStyle NoBinPacking = getLLVMStyle(); 4117 NoBinPacking.BinPackParameters = false; 4118 verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n" 4119 " double *min_x,\n" 4120 " double *max_x,\n" 4121 " double *min_y,\n" 4122 " double *max_y,\n" 4123 " double *min_z,\n" 4124 " double *max_z, ) {}", 4125 NoBinPacking); 4126} 4127 4128TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 4129 verifyFormat("void f() { return; }\n42"); 4130 verifyFormat("void f() {\n" 4131 " if (0)\n" 4132 " return;\n" 4133 "}\n" 4134 "42"); 4135 verifyFormat("void f() { return }\n42"); 4136 verifyFormat("void f() {\n" 4137 " if (0)\n" 4138 " return\n" 4139 "}\n" 4140 "42"); 4141} 4142 4143TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 4144 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 4145 EXPECT_EQ("void f() {\n" 4146 " if (a)\n" 4147 " return\n" 4148 "}", 4149 format("void f ( ) { if ( a ) return }")); 4150 EXPECT_EQ("namespace N {\n" 4151 "void f()\n" 4152 "}", 4153 format("namespace N { void f() }")); 4154 EXPECT_EQ("namespace N {\n" 4155 "void f() {}\n" 4156 "void g()\n" 4157 "}", 4158 format("namespace N { void f( ) { } void g( ) }")); 4159} 4160 4161TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 4162 verifyFormat("int aaaaaaaa =\n" 4163 " // Overlylongcomment\n" 4164 " b;", 4165 getLLVMStyleWithColumns(20)); 4166 verifyFormat("function(\n" 4167 " ShortArgument,\n" 4168 " LoooooooooooongArgument);\n", 4169 getLLVMStyleWithColumns(20)); 4170} 4171 4172TEST_F(FormatTest, IncorrectAccessSpecifier) { 4173 verifyFormat("public:"); 4174 verifyFormat("class A {\n" 4175 "public\n" 4176 " void f() {}\n" 4177 "};"); 4178 verifyFormat("public\n" 4179 "int qwerty;"); 4180 verifyFormat("public\n" 4181 "B {}"); 4182 verifyFormat("public\n" 4183 "{}"); 4184 verifyFormat("public\n" 4185 "B { int x; }"); 4186} 4187 4188TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 4189 verifyFormat("{"); 4190 verifyFormat("#})"); 4191} 4192 4193TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 4194 verifyFormat("do {\n}"); 4195 verifyFormat("do {\n}\n" 4196 "f();"); 4197 verifyFormat("do {\n}\n" 4198 "wheeee(fun);"); 4199 verifyFormat("do {\n" 4200 " f();\n" 4201 "}"); 4202} 4203 4204TEST_F(FormatTest, IncorrectCodeMissingParens) { 4205 verifyFormat("if {\n foo;\n foo();\n}"); 4206 verifyFormat("switch {\n foo;\n foo();\n}"); 4207 verifyFormat("for {\n foo;\n foo();\n}"); 4208 verifyFormat("while {\n foo;\n foo();\n}"); 4209 verifyFormat("do {\n foo;\n foo();\n} while;"); 4210} 4211 4212TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 4213 verifyFormat("namespace {\n" 4214 "class Foo { Foo (\n" 4215 "};\n" 4216 "} // comment"); 4217} 4218 4219TEST_F(FormatTest, IncorrectCodeErrorDetection) { 4220 EXPECT_EQ("{\n{}\n", format("{\n{\n}\n")); 4221 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 4222 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 4223 EXPECT_EQ("{\n {}\n }\n}\n", format("{\n {\n }\n }\n}\n")); 4224 4225 EXPECT_EQ("{\n" 4226 " {\n" 4227 " breakme(\n" 4228 " qwe);\n" 4229 "}\n", 4230 format("{\n" 4231 " {\n" 4232 " breakme(qwe);\n" 4233 "}\n", 4234 getLLVMStyleWithColumns(10))); 4235} 4236 4237TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 4238 verifyFormat("int x = {\n" 4239 " avariable,\n" 4240 " b(alongervariable)\n" 4241 "};", 4242 getLLVMStyleWithColumns(25)); 4243} 4244 4245TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 4246 verifyFormat("return (a)(b) { 1, 2, 3 };"); 4247} 4248 4249TEST_F(FormatTest, LayoutCxx11ConstructorBraceInitializers) { 4250 verifyFormat("vector<int> x{ 1, 2, 3, 4 };"); 4251 verifyFormat("vector<T> x{ {}, {}, {}, {} };"); 4252 verifyFormat("f({ 1, 2 });"); 4253 verifyFormat("auto v = Foo{ 1 };"); 4254 verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });"); 4255 verifyFormat("Class::Class : member{ 1, 2, 3 } {}"); 4256 verifyFormat("new vector<int>{ 1, 2, 3 };"); 4257 verifyFormat("new int[3]{ 1, 2, 3 };"); 4258 verifyFormat("return { arg1, arg2 };"); 4259 verifyFormat("return { arg1, SomeType{ parameter } };"); 4260 verifyFormat("new T{ arg1, arg2 };"); 4261 verifyFormat("class Class {\n" 4262 " T member = { arg1, arg2 };\n" 4263 "};"); 4264 verifyFormat( 4265 "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 4266 " aaaaaaaaaaaaaaaaaaaa, aaaaa }\n" 4267 " : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 4268 " bbbbbbbbbbbbbbbbbbbb, bbbbb };"); 4269 verifyFormat("DoSomethingWithVector({} /* No data */);"); 4270 verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });"); 4271 verifyFormat( 4272 "someFunction(OtherParam, BracedList{\n" 4273 " // comment 1 (Forcing interesting break)\n" 4274 " param1, param2,\n" 4275 " // comment 2\n" 4276 " param3, param4\n" 4277 " });"); 4278 verifyFormat( 4279 "std::this_thread::sleep_for(\n" 4280 " std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);"); 4281 4282 FormatStyle NoSpaces = getLLVMStyle(); 4283 NoSpaces.Cpp11BracedListStyle = true; 4284 verifyFormat("vector<int> x{1, 2, 3, 4};", NoSpaces); 4285 verifyFormat("vector<T> x{{}, {}, {}, {}};", NoSpaces); 4286 verifyFormat("f({1, 2});", NoSpaces); 4287 verifyFormat("auto v = Foo{-1};", NoSpaces); 4288 verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});", NoSpaces); 4289 verifyFormat("Class::Class : member{1, 2, 3} {}", NoSpaces); 4290 verifyFormat("new vector<int>{1, 2, 3};", NoSpaces); 4291 verifyFormat("new int[3]{1, 2, 3};", NoSpaces); 4292 verifyFormat("return {arg1, arg2};", NoSpaces); 4293 verifyFormat("return {arg1, SomeType{parameter}};", NoSpaces); 4294 verifyFormat("new T{arg1, arg2};", NoSpaces); 4295 verifyFormat("class Class {\n" 4296 " T member = {arg1, arg2};\n" 4297 "};", 4298 NoSpaces); 4299} 4300 4301TEST_F(FormatTest, FormatsBracedListsinColumnLayout) { 4302 verifyFormat("vector<int> x = { 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4303 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4304 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4305 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4306 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4307 " 1, 22, 333, 4444, 55555, 666666, 7777777 };"); 4308 verifyFormat("vector<int> x = { 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4309 " // line comment\n" 4310 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4311 " 1, 22, 333, 4444, 55555,\n" 4312 " // line comment\n" 4313 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4314 " 1, 22, 333, 4444, 55555, 666666, 7777777 };"); 4315 verifyFormat( 4316 "vector<int> x = { 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4317 " 1, 22, 333, 4444, 55555, 666666, 7777777,\n" 4318 " 1, 22, 333, 4444, 55555, 666666, // comment\n" 4319 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 4320 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 4321 " 7777777, 1, 22, 333, 4444, 55555, 666666,\n" 4322 " 7777777 };"); 4323 verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n" 4324 " X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n" 4325 " X86::R8, X86::R9, X86::R10, X86::R11, 0\n" 4326 "};"); 4327 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n" 4328 " 1, 1, 1, 1 };", 4329 getLLVMStyleWithColumns(39)); 4330 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n" 4331 " 1, 1, 1, 1 };", 4332 getLLVMStyleWithColumns(38)); 4333 verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n" 4334 " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1\n" 4335 "};", 4336 getLLVMStyleWithColumns(40)); 4337 4338 // Trailing commas. 4339 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n" 4340 " 1, 1, 1, 1, };", 4341 getLLVMStyleWithColumns(39)); 4342 verifyFormat("vector<int> x = {\n" 4343 " 1, 1, 1, 1, 1, 1, 1, 1, //\n" 4344 "};", 4345 getLLVMStyleWithColumns(39)); 4346 verifyFormat("vector<int> x = { 1, 1, 1, 1,\n" 4347 " 1, 1, 1, 1,\n" 4348 " /**/ /**/ };", 4349 getLLVMStyleWithColumns(39)); 4350 verifyFormat("return { { aaaaaaaaaaaaaaaaaaaaa }, { aaaaaaaaaaaaaaaaaaa },\n" 4351 " { aaaaaaaaaaaaaaaaaaaaa }, { aaaaaaaaaaaaaaaaa } };", 4352 getLLVMStyleWithColumns(60)); 4353} 4354 4355TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 4356 verifyFormat("void f() { return 42; }"); 4357 verifyFormat("void f() {\n" 4358 " // Comment\n" 4359 "}"); 4360 verifyFormat("{\n" 4361 "#error {\n" 4362 " int a;\n" 4363 "}"); 4364 verifyFormat("{\n" 4365 " int a;\n" 4366 "#error {\n" 4367 "}"); 4368 verifyFormat("void f() {} // comment"); 4369 verifyFormat("void f() { int a; } // comment"); 4370 verifyFormat("void f() {\n" 4371 "} // comment", 4372 getLLVMStyleWithColumns(15)); 4373 4374 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 4375 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 4376 4377 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 4378 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 4379} 4380 4381TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 4382 // Elaborate type variable declarations. 4383 verifyFormat("struct foo a = { bar };\nint n;"); 4384 verifyFormat("class foo a = { bar };\nint n;"); 4385 verifyFormat("union foo a = { bar };\nint n;"); 4386 4387 // Elaborate types inside function definitions. 4388 verifyFormat("struct foo f() {}\nint n;"); 4389 verifyFormat("class foo f() {}\nint n;"); 4390 verifyFormat("union foo f() {}\nint n;"); 4391 4392 // Templates. 4393 verifyFormat("template <class X> void f() {}\nint n;"); 4394 verifyFormat("template <struct X> void f() {}\nint n;"); 4395 verifyFormat("template <union X> void f() {}\nint n;"); 4396 4397 // Actual definitions... 4398 verifyFormat("struct {\n} n;"); 4399 verifyFormat( 4400 "template <template <class T, class Y>, class Z> class X {\n} n;"); 4401 verifyFormat("union Z {\n int n;\n} x;"); 4402 verifyFormat("class MACRO Z {\n} n;"); 4403 verifyFormat("class MACRO(X) Z {\n} n;"); 4404 verifyFormat("class __attribute__(X) Z {\n} n;"); 4405 verifyFormat("class __declspec(X) Z {\n} n;"); 4406 verifyFormat("class A##B##C {\n} n;"); 4407 4408 // Redefinition from nested context: 4409 verifyFormat("class A::B::C {\n} n;"); 4410 4411 // Template definitions. 4412 verifyFormat( 4413 "template <typename F>\n" 4414 "Matcher(const Matcher<F> &Other,\n" 4415 " typename enable_if_c<is_base_of<F, T>::value &&\n" 4416 " !is_same<F, T>::value>::type * = 0)\n" 4417 " : Implementation(new ImplicitCastMatcher<F>(Other)) {}"); 4418 4419 // FIXME: This is still incorrectly handled at the formatter side. 4420 verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};"); 4421 4422 // FIXME: 4423 // This now gets parsed incorrectly as class definition. 4424 // verifyFormat("class A<int> f() {\n}\nint n;"); 4425 4426 // Elaborate types where incorrectly parsing the structural element would 4427 // break the indent. 4428 verifyFormat("if (true)\n" 4429 " class X x;\n" 4430 "else\n" 4431 " f();\n"); 4432 4433 // This is simply incomplete. Formatting is not important, but must not crash. 4434 verifyFormat("class A:"); 4435} 4436 4437TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 4438 verifyFormat("#error Leave all white!!!!! space* alone!\n"); 4439 verifyFormat("#warning Leave all white!!!!! space* alone!\n"); 4440 EXPECT_EQ("#error 1", format(" # error 1")); 4441 EXPECT_EQ("#warning 1", format(" # warning 1")); 4442} 4443 4444TEST_F(FormatTest, FormatHashIfExpressions) { 4445 // FIXME: Come up with a better indentation for #elif. 4446 verifyFormat( 4447 "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n" 4448 " defined(BBBBBBBB)\n" 4449 "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n" 4450 " defined(BBBBBBBB)\n" 4451 "#endif", 4452 getLLVMStyleWithColumns(65)); 4453} 4454 4455TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 4456 FormatStyle AllowsMergedIf = getGoogleStyle(); 4457 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true; 4458 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 4459 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 4460 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 4461 EXPECT_EQ("if (true) return 42;", 4462 format("if (true)\nreturn 42;", AllowsMergedIf)); 4463 FormatStyle ShortMergedIf = AllowsMergedIf; 4464 ShortMergedIf.ColumnLimit = 25; 4465 verifyFormat("#define A \\\n" 4466 " if (true) return 42;", 4467 ShortMergedIf); 4468 verifyFormat("#define A \\\n" 4469 " f(); \\\n" 4470 " if (true)\n" 4471 "#define B", 4472 ShortMergedIf); 4473 verifyFormat("#define A \\\n" 4474 " f(); \\\n" 4475 " if (true)\n" 4476 "g();", 4477 ShortMergedIf); 4478 verifyFormat("{\n" 4479 "#ifdef A\n" 4480 " // Comment\n" 4481 " if (true) continue;\n" 4482 "#endif\n" 4483 " // Comment\n" 4484 " if (true) continue;", 4485 ShortMergedIf); 4486} 4487 4488TEST_F(FormatTest, BlockCommentsInControlLoops) { 4489 verifyFormat("if (0) /* a comment in a strange place */ {\n" 4490 " f();\n" 4491 "}"); 4492 verifyFormat("if (0) /* a comment in a strange place */ {\n" 4493 " f();\n" 4494 "} /* another comment */ else /* comment #3 */ {\n" 4495 " g();\n" 4496 "}"); 4497 verifyFormat("while (0) /* a comment in a strange place */ {\n" 4498 " f();\n" 4499 "}"); 4500 verifyFormat("for (;;) /* a comment in a strange place */ {\n" 4501 " f();\n" 4502 "}"); 4503 verifyFormat("do /* a comment in a strange place */ {\n" 4504 " f();\n" 4505 "} /* another comment */ while (0);"); 4506} 4507 4508TEST_F(FormatTest, BlockComments) { 4509 EXPECT_EQ("/* */ /* */ /* */\n/* */ /* */ /* */", 4510 format("/* *//* */ /* */\n/* *//* */ /* */")); 4511 EXPECT_EQ("/* */ a /* */ b;", format(" /* */ a/* */ b;")); 4512 EXPECT_EQ("#define A /*123*/ \\\n" 4513 " b\n" 4514 "/* */\n" 4515 "someCall(\n" 4516 " parameter);", 4517 format("#define A /*123*/ b\n" 4518 "/* */\n" 4519 "someCall(parameter);", 4520 getLLVMStyleWithColumns(15))); 4521 4522 EXPECT_EQ("#define A\n" 4523 "/* */ someCall(\n" 4524 " parameter);", 4525 format("#define A\n" 4526 "/* */someCall(parameter);", 4527 getLLVMStyleWithColumns(15))); 4528 EXPECT_EQ("/*\n**\n*/", format("/*\n**\n*/")); 4529 EXPECT_EQ("/*\n" 4530 "*\n" 4531 " * aaaaaa\n" 4532 "*aaaaaa\n" 4533 "*/", 4534 format("/*\n" 4535 "*\n" 4536 " * aaaaaa aaaaaa\n" 4537 "*/", 4538 getLLVMStyleWithColumns(10))); 4539 EXPECT_EQ("/*\n" 4540 "**\n" 4541 "* aaaaaa\n" 4542 "*aaaaaa\n" 4543 "*/", 4544 format("/*\n" 4545 "**\n" 4546 "* aaaaaa aaaaaa\n" 4547 "*/", 4548 getLLVMStyleWithColumns(10))); 4549 4550 FormatStyle NoBinPacking = getLLVMStyle(); 4551 NoBinPacking.BinPackParameters = false; 4552 EXPECT_EQ("someFunction(1, /* comment 1 */\n" 4553 " 2, /* comment 2 */\n" 4554 " 3, /* comment 3 */\n" 4555 " aaaa,\n" 4556 " bbbb);", 4557 format("someFunction (1, /* comment 1 */\n" 4558 " 2, /* comment 2 */ \n" 4559 " 3, /* comment 3 */\n" 4560 "aaaa, bbbb );", 4561 NoBinPacking)); 4562 verifyFormat( 4563 "bool aaaaaaaaaaaaa = /* comment: */ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4564 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 4565 EXPECT_EQ( 4566 "bool aaaaaaaaaaaaa = /* trailing comment */\n" 4567 " aaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4568 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;", 4569 format( 4570 "bool aaaaaaaaaaaaa = /* trailing comment */\n" 4571 " aaaaaaaaaaaaaaaaaaaaaaaaaaa||aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 4572 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;")); 4573 EXPECT_EQ( 4574 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n" 4575 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n" 4576 "int cccccccccccccccccccccccccccccc; /* comment */\n", 4577 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n" 4578 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n" 4579 "int cccccccccccccccccccccccccccccc; /* comment */\n")); 4580 4581 verifyFormat("void f(int * /* unused */) {}"); 4582 4583 EXPECT_EQ("/*\n" 4584 " **\n" 4585 " */", 4586 format("/*\n" 4587 " **\n" 4588 " */")); 4589 EXPECT_EQ("/*\n" 4590 " *q\n" 4591 " */", 4592 format("/*\n" 4593 " *q\n" 4594 " */")); 4595 EXPECT_EQ("/*\n" 4596 " * q\n" 4597 " */", 4598 format("/*\n" 4599 " * q\n" 4600 " */")); 4601 EXPECT_EQ("/*\n" 4602 " **/", 4603 format("/*\n" 4604 " **/")); 4605 EXPECT_EQ("/*\n" 4606 " ***/", 4607 format("/*\n" 4608 " ***/")); 4609} 4610 4611TEST_F(FormatTest, BlockCommentsInMacros) { 4612 EXPECT_EQ("#define A \\\n" 4613 " { \\\n" 4614 " /* one line */ \\\n" 4615 " someCall();", 4616 format("#define A { \\\n" 4617 " /* one line */ \\\n" 4618 " someCall();", 4619 getLLVMStyleWithColumns(20))); 4620 EXPECT_EQ("#define A \\\n" 4621 " { \\\n" 4622 " /* previous */ \\\n" 4623 " /* one line */ \\\n" 4624 " someCall();", 4625 format("#define A { \\\n" 4626 " /* previous */ \\\n" 4627 " /* one line */ \\\n" 4628 " someCall();", 4629 getLLVMStyleWithColumns(20))); 4630} 4631 4632TEST_F(FormatTest, BlockCommentsAtEndOfLine) { 4633 EXPECT_EQ("a = {\n" 4634 " 1111 /* */\n" 4635 "};", 4636 format("a = {1111 /* */\n" 4637 "};", 4638 getLLVMStyleWithColumns(15))); 4639 EXPECT_EQ("a = {\n" 4640 " 1111 /* */\n" 4641 "};", 4642 format("a = {1111 /* */\n" 4643 "};", 4644 getLLVMStyleWithColumns(15))); 4645 4646 // FIXME: The formatting is still wrong here. 4647 EXPECT_EQ("a = {\n" 4648 " 1111 /* a\n" 4649 " */\n" 4650 "};", 4651 format("a = {1111 /* a */\n" 4652 "};", 4653 getLLVMStyleWithColumns(15))); 4654} 4655 4656TEST_F(FormatTest, IndentLineCommentsInStartOfBlockAtEndOfFile) { 4657 // FIXME: This is not what we want... 4658 verifyFormat("{\n" 4659 "// a" 4660 "// b"); 4661} 4662 4663TEST_F(FormatTest, FormatStarDependingOnContext) { 4664 verifyFormat("void f(int *a);"); 4665 verifyFormat("void f() { f(fint * b); }"); 4666 verifyFormat("class A {\n void f(int *a);\n};"); 4667 verifyFormat("class A {\n int *a;\n};"); 4668 verifyFormat("namespace a {\n" 4669 "namespace b {\n" 4670 "class A {\n" 4671 " void f() {}\n" 4672 " int *a;\n" 4673 "};\n" 4674 "}\n" 4675 "}"); 4676} 4677 4678TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 4679 verifyFormat("while"); 4680 verifyFormat("operator"); 4681} 4682 4683//===----------------------------------------------------------------------===// 4684// Objective-C tests. 4685//===----------------------------------------------------------------------===// 4686 4687TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 4688 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 4689 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 4690 format("-(NSUInteger)indexOfObject:(id)anObject;")); 4691 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 4692 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 4693 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 4694 format("-(NSInteger)Method3:(id)anObject;")); 4695 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 4696 format("-(NSInteger)Method4:(id)anObject;")); 4697 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 4698 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 4699 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 4700 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 4701 EXPECT_EQ( 4702 "- (void)sendAction:(SEL)aSelector to:(id)anObject forAllCells:(BOOL)flag;", 4703 format( 4704 "- (void)sendAction:(SEL)aSelector to:(id)anObject forAllCells:(BOOL)flag;")); 4705 4706 // Very long objectiveC method declaration. 4707 verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n" 4708 " inRange:(NSRange)range\n" 4709 " outRange:(NSRange)out_range\n" 4710 " outRange1:(NSRange)out_range1\n" 4711 " outRange2:(NSRange)out_range2\n" 4712 " outRange3:(NSRange)out_range3\n" 4713 " outRange4:(NSRange)out_range4\n" 4714 " outRange5:(NSRange)out_range5\n" 4715 " outRange6:(NSRange)out_range6\n" 4716 " outRange7:(NSRange)out_range7\n" 4717 " outRange8:(NSRange)out_range8\n" 4718 " outRange9:(NSRange)out_range9;"); 4719 4720 verifyFormat("- (int)sum:(vector<int>)numbers;"); 4721 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 4722 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 4723 // protocol lists (but not for template classes): 4724 //verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 4725 4726 verifyFormat("- (int (*)())foo:(int (*)())f;"); 4727 verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;"); 4728 4729 // If there's no return type (very rare in practice!), LLVM and Google style 4730 // agree. 4731 verifyFormat("- foo;"); 4732 verifyFormat("- foo:(int)f;"); 4733 verifyGoogleFormat("- foo:(int)foo;"); 4734} 4735 4736TEST_F(FormatTest, FormatObjCBlocks) { 4737 verifyFormat("int (^Block)(int, int);"); 4738 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)"); 4739} 4740 4741TEST_F(FormatTest, FormatObjCInterface) { 4742 verifyFormat("@interface Foo : NSObject <NSSomeDelegate> {\n" 4743 "@public\n" 4744 " int field1;\n" 4745 "@protected\n" 4746 " int field2;\n" 4747 "@private\n" 4748 " int field3;\n" 4749 "@package\n" 4750 " int field4;\n" 4751 "}\n" 4752 "+ (id)init;\n" 4753 "@end"); 4754 4755 verifyGoogleFormat("@interface Foo : NSObject<NSSomeDelegate> {\n" 4756 " @public\n" 4757 " int field1;\n" 4758 " @protected\n" 4759 " int field2;\n" 4760 " @private\n" 4761 " int field3;\n" 4762 " @package\n" 4763 " int field4;\n" 4764 "}\n" 4765 "+ (id)init;\n" 4766 "@end"); 4767 4768 verifyFormat("@interface /* wait for it */ Foo\n" 4769 "+ (id)init;\n" 4770 "// Look, a comment!\n" 4771 "- (int)answerWith:(int)i;\n" 4772 "@end"); 4773 4774 verifyFormat("@interface Foo\n" 4775 "@end\n" 4776 "@interface Bar\n" 4777 "@end"); 4778 4779 verifyFormat("@interface Foo : Bar\n" 4780 "+ (id)init;\n" 4781 "@end"); 4782 4783 verifyFormat("@interface Foo : /**/ Bar /**/ <Baz, /**/ Quux>\n" 4784 "+ (id)init;\n" 4785 "@end"); 4786 4787 verifyGoogleFormat("@interface Foo : Bar<Baz, Quux>\n" 4788 "+ (id)init;\n" 4789 "@end"); 4790 4791 verifyFormat("@interface Foo (HackStuff)\n" 4792 "+ (id)init;\n" 4793 "@end"); 4794 4795 verifyFormat("@interface Foo ()\n" 4796 "+ (id)init;\n" 4797 "@end"); 4798 4799 verifyFormat("@interface Foo (HackStuff) <MyProtocol>\n" 4800 "+ (id)init;\n" 4801 "@end"); 4802 4803 verifyGoogleFormat("@interface Foo (HackStuff)<MyProtocol>\n" 4804 "+ (id)init;\n" 4805 "@end"); 4806 4807 verifyFormat("@interface Foo {\n" 4808 " int _i;\n" 4809 "}\n" 4810 "+ (id)init;\n" 4811 "@end"); 4812 4813 verifyFormat("@interface Foo : Bar {\n" 4814 " int _i;\n" 4815 "}\n" 4816 "+ (id)init;\n" 4817 "@end"); 4818 4819 verifyFormat("@interface Foo : Bar <Baz, Quux> {\n" 4820 " int _i;\n" 4821 "}\n" 4822 "+ (id)init;\n" 4823 "@end"); 4824 4825 verifyFormat("@interface Foo (HackStuff) {\n" 4826 " int _i;\n" 4827 "}\n" 4828 "+ (id)init;\n" 4829 "@end"); 4830 4831 verifyFormat("@interface Foo () {\n" 4832 " int _i;\n" 4833 "}\n" 4834 "+ (id)init;\n" 4835 "@end"); 4836 4837 verifyFormat("@interface Foo (HackStuff) <MyProtocol> {\n" 4838 " int _i;\n" 4839 "}\n" 4840 "+ (id)init;\n" 4841 "@end"); 4842} 4843 4844TEST_F(FormatTest, FormatObjCImplementation) { 4845 verifyFormat("@implementation Foo : NSObject {\n" 4846 "@public\n" 4847 " int field1;\n" 4848 "@protected\n" 4849 " int field2;\n" 4850 "@private\n" 4851 " int field3;\n" 4852 "@package\n" 4853 " int field4;\n" 4854 "}\n" 4855 "+ (id)init {\n}\n" 4856 "@end"); 4857 4858 verifyGoogleFormat("@implementation Foo : NSObject {\n" 4859 " @public\n" 4860 " int field1;\n" 4861 " @protected\n" 4862 " int field2;\n" 4863 " @private\n" 4864 " int field3;\n" 4865 " @package\n" 4866 " int field4;\n" 4867 "}\n" 4868 "+ (id)init {\n}\n" 4869 "@end"); 4870 4871 verifyFormat("@implementation Foo\n" 4872 "+ (id)init {\n" 4873 " if (true)\n" 4874 " return nil;\n" 4875 "}\n" 4876 "// Look, a comment!\n" 4877 "- (int)answerWith:(int)i {\n" 4878 " return i;\n" 4879 "}\n" 4880 "+ (int)answerWith:(int)i {\n" 4881 " return i;\n" 4882 "}\n" 4883 "@end"); 4884 4885 verifyFormat("@implementation Foo\n" 4886 "@end\n" 4887 "@implementation Bar\n" 4888 "@end"); 4889 4890 verifyFormat("@implementation Foo : Bar\n" 4891 "+ (id)init {\n}\n" 4892 "- (void)foo {\n}\n" 4893 "@end"); 4894 4895 verifyFormat("@implementation Foo {\n" 4896 " int _i;\n" 4897 "}\n" 4898 "+ (id)init {\n}\n" 4899 "@end"); 4900 4901 verifyFormat("@implementation Foo : Bar {\n" 4902 " int _i;\n" 4903 "}\n" 4904 "+ (id)init {\n}\n" 4905 "@end"); 4906 4907 verifyFormat("@implementation Foo (HackStuff)\n" 4908 "+ (id)init {\n}\n" 4909 "@end"); 4910 verifyFormat("@implementation ObjcClass\n" 4911 "- (void)method;\n" 4912 "{}\n" 4913 "@end"); 4914} 4915 4916TEST_F(FormatTest, FormatObjCProtocol) { 4917 verifyFormat("@protocol Foo\n" 4918 "@property(weak) id delegate;\n" 4919 "- (NSUInteger)numberOfThings;\n" 4920 "@end"); 4921 4922 verifyFormat("@protocol MyProtocol <NSObject>\n" 4923 "- (NSUInteger)numberOfThings;\n" 4924 "@end"); 4925 4926 verifyGoogleFormat("@protocol MyProtocol<NSObject>\n" 4927 "- (NSUInteger)numberOfThings;\n" 4928 "@end"); 4929 4930 verifyFormat("@protocol Foo;\n" 4931 "@protocol Bar;\n"); 4932 4933 verifyFormat("@protocol Foo\n" 4934 "@end\n" 4935 "@protocol Bar\n" 4936 "@end"); 4937 4938 verifyFormat("@protocol myProtocol\n" 4939 "- (void)mandatoryWithInt:(int)i;\n" 4940 "@optional\n" 4941 "- (void)optional;\n" 4942 "@required\n" 4943 "- (void)required;\n" 4944 "@optional\n" 4945 "@property(assign) int madProp;\n" 4946 "@end\n"); 4947 4948 verifyFormat("@property(nonatomic, assign, readonly)\n" 4949 " int *looooooooooooooooooooooooooooongNumber;\n" 4950 "@property(nonatomic, assign, readonly)\n" 4951 " NSString *looooooooooooooooooooooooooooongName;"); 4952} 4953 4954TEST_F(FormatTest, FormatObjCMethodDeclarations) { 4955 verifyFormat("- (void)doSomethingWith:(GTMFoo *)theFoo\n" 4956 " rect:(NSRect)theRect\n" 4957 " interval:(float)theInterval {\n" 4958 "}"); 4959 verifyFormat("- (void)shortf:(GTMFoo *)theFoo\n" 4960 " longKeyword:(NSRect)theRect\n" 4961 " evenLongerKeyword:(float)theInterval\n" 4962 " error:(NSError **)theError {\n" 4963 "}"); 4964} 4965 4966TEST_F(FormatTest, FormatObjCMethodExpr) { 4967 verifyFormat("[foo bar:baz];"); 4968 verifyFormat("return [foo bar:baz];"); 4969 verifyFormat("f([foo bar:baz]);"); 4970 verifyFormat("f(2, [foo bar:baz]);"); 4971 verifyFormat("f(2, a ? b : c);"); 4972 verifyFormat("[[self initWithInt:4] bar:[baz quux:arrrr]];"); 4973 4974 // Unary operators. 4975 verifyFormat("int a = +[foo bar:baz];"); 4976 verifyFormat("int a = -[foo bar:baz];"); 4977 verifyFormat("int a = ![foo bar:baz];"); 4978 verifyFormat("int a = ~[foo bar:baz];"); 4979 verifyFormat("int a = ++[foo bar:baz];"); 4980 verifyFormat("int a = --[foo bar:baz];"); 4981 verifyFormat("int a = sizeof [foo bar:baz];"); 4982 verifyFormat("int a = alignof [foo bar:baz];", getGoogleStyle()); 4983 verifyFormat("int a = &[foo bar:baz];"); 4984 verifyFormat("int a = *[foo bar:baz];"); 4985 // FIXME: Make casts work, without breaking f()[4]. 4986 //verifyFormat("int a = (int)[foo bar:baz];"); 4987 //verifyFormat("return (int)[foo bar:baz];"); 4988 //verifyFormat("(void)[foo bar:baz];"); 4989 verifyFormat("return (MyType *)[self.tableView cellForRowAtIndexPath:cell];"); 4990 4991 // Binary operators. 4992 verifyFormat("[foo bar:baz], [foo bar:baz];"); 4993 verifyFormat("[foo bar:baz] = [foo bar:baz];"); 4994 verifyFormat("[foo bar:baz] *= [foo bar:baz];"); 4995 verifyFormat("[foo bar:baz] /= [foo bar:baz];"); 4996 verifyFormat("[foo bar:baz] %= [foo bar:baz];"); 4997 verifyFormat("[foo bar:baz] += [foo bar:baz];"); 4998 verifyFormat("[foo bar:baz] -= [foo bar:baz];"); 4999 verifyFormat("[foo bar:baz] <<= [foo bar:baz];"); 5000 verifyFormat("[foo bar:baz] >>= [foo bar:baz];"); 5001 verifyFormat("[foo bar:baz] &= [foo bar:baz];"); 5002 verifyFormat("[foo bar:baz] ^= [foo bar:baz];"); 5003 verifyFormat("[foo bar:baz] |= [foo bar:baz];"); 5004 verifyFormat("[foo bar:baz] ? [foo bar:baz] : [foo bar:baz];"); 5005 verifyFormat("[foo bar:baz] || [foo bar:baz];"); 5006 verifyFormat("[foo bar:baz] && [foo bar:baz];"); 5007 verifyFormat("[foo bar:baz] | [foo bar:baz];"); 5008 verifyFormat("[foo bar:baz] ^ [foo bar:baz];"); 5009 verifyFormat("[foo bar:baz] & [foo bar:baz];"); 5010 verifyFormat("[foo bar:baz] == [foo bar:baz];"); 5011 verifyFormat("[foo bar:baz] != [foo bar:baz];"); 5012 verifyFormat("[foo bar:baz] >= [foo bar:baz];"); 5013 verifyFormat("[foo bar:baz] <= [foo bar:baz];"); 5014 verifyFormat("[foo bar:baz] > [foo bar:baz];"); 5015 verifyFormat("[foo bar:baz] < [foo bar:baz];"); 5016 verifyFormat("[foo bar:baz] >> [foo bar:baz];"); 5017 verifyFormat("[foo bar:baz] << [foo bar:baz];"); 5018 verifyFormat("[foo bar:baz] - [foo bar:baz];"); 5019 verifyFormat("[foo bar:baz] + [foo bar:baz];"); 5020 verifyFormat("[foo bar:baz] * [foo bar:baz];"); 5021 verifyFormat("[foo bar:baz] / [foo bar:baz];"); 5022 verifyFormat("[foo bar:baz] % [foo bar:baz];"); 5023 // Whew! 5024 5025 verifyFormat("return in[42];"); 5026 verifyFormat("for (id foo in [self getStuffFor:bla]) {\n" 5027 "}"); 5028 5029 verifyFormat("[self stuffWithInt:(4 + 2) float:4.5];"); 5030 verifyFormat("[self stuffWithInt:a ? b : c float:4.5];"); 5031 verifyFormat("[self stuffWithInt:a ? [self foo:bar] : c];"); 5032 verifyFormat("[self stuffWithInt:a ? (e ? f : g) : c];"); 5033 verifyFormat("[cond ? obj1 : obj2 methodWithParam:param]"); 5034 verifyFormat("[button setAction:@selector(zoomOut:)];"); 5035 verifyFormat("[color getRed:&r green:&g blue:&b alpha:&a];"); 5036 5037 verifyFormat("arr[[self indexForFoo:a]];"); 5038 verifyFormat("throw [self errorFor:a];"); 5039 verifyFormat("@throw [self errorFor:a];"); 5040 5041 verifyFormat("[(id)foo bar:(id)baz quux:(id)snorf];"); 5042 verifyFormat("[(id)foo bar:(id) ? baz : quux];"); 5043 verifyFormat("4 > 4 ? (id)a : (id)baz;"); 5044 5045 // This tests that the formatter doesn't break after "backing" but before ":", 5046 // which would be at 80 columns. 5047 verifyFormat( 5048 "void f() {\n" 5049 " if ((self = [super initWithContentRect:contentRect\n" 5050 " styleMask:styleMask ?: otherMask\n" 5051 " backing:NSBackingStoreBuffered\n" 5052 " defer:YES]))"); 5053 5054 verifyFormat( 5055 "[foo checkThatBreakingAfterColonWorksOk:\n" 5056 " [bar ifItDoes:reduceOverallLineLengthLikeInThisCase]];"); 5057 5058 verifyFormat("[myObj short:arg1 // Force line break\n" 5059 " longKeyword:arg2 != nil ? arg2 : @\"longKeyword\"\n" 5060 " evenLongerKeyword:arg3 ?: @\"evenLongerKeyword\"\n" 5061 " error:arg4];"); 5062 verifyFormat( 5063 "void f() {\n" 5064 " popup_window_.reset([[RenderWidgetPopupWindow alloc]\n" 5065 " initWithContentRect:NSMakeRect(origin_global.x, origin_global.y,\n" 5066 " pos.width(), pos.height())\n" 5067 " styleMask:NSBorderlessWindowMask\n" 5068 " backing:NSBackingStoreBuffered\n" 5069 " defer:NO]);\n" 5070 "}"); 5071 verifyFormat("[contentsContainer replaceSubview:[subviews objectAtIndex:0]\n" 5072 " with:contentsNativeView];"); 5073 5074 verifyFormat( 5075 "[pboard addTypes:[NSArray arrayWithObject:kBookmarkButtonDragType]\n" 5076 " owner:nillllll];"); 5077 5078 verifyFormat( 5079 "[pboard setData:[NSData dataWithBytes:&button length:sizeof(button)]\n" 5080 " forType:kBookmarkButtonDragType];"); 5081 5082 verifyFormat("[defaultCenter addObserver:self\n" 5083 " selector:@selector(willEnterFullscreen)\n" 5084 " name:kWillEnterFullscreenNotification\n" 5085 " object:nil];"); 5086 verifyFormat("[image_rep drawInRect:drawRect\n" 5087 " fromRect:NSZeroRect\n" 5088 " operation:NSCompositeCopy\n" 5089 " fraction:1.0\n" 5090 " respectFlipped:NO\n" 5091 " hints:nil];"); 5092 5093 verifyFormat( 5094 "scoped_nsobject<NSTextField> message(\n" 5095 " // The frame will be fixed up when |-setMessageText:| is called.\n" 5096 " [[NSTextField alloc] initWithFrame:NSMakeRect(0, 0, 0, 0)]);"); 5097 verifyFormat("[self aaaaaa:bbbbbbbbbbbbb\n" 5098 " aaaaaaaaaa:bbbbbbbbbbbbbbbbb\n" 5099 " aaaaa:bbbbbbbbbbb + bbbbbbbbbbbb\n" 5100 " aaaa:bbb];"); 5101} 5102 5103TEST_F(FormatTest, ObjCAt) { 5104 verifyFormat("@autoreleasepool"); 5105 verifyFormat("@catch"); 5106 verifyFormat("@class"); 5107 verifyFormat("@compatibility_alias"); 5108 verifyFormat("@defs"); 5109 verifyFormat("@dynamic"); 5110 verifyFormat("@encode"); 5111 verifyFormat("@end"); 5112 verifyFormat("@finally"); 5113 verifyFormat("@implementation"); 5114 verifyFormat("@import"); 5115 verifyFormat("@interface"); 5116 verifyFormat("@optional"); 5117 verifyFormat("@package"); 5118 verifyFormat("@private"); 5119 verifyFormat("@property"); 5120 verifyFormat("@protected"); 5121 verifyFormat("@protocol"); 5122 verifyFormat("@public"); 5123 verifyFormat("@required"); 5124 verifyFormat("@selector"); 5125 verifyFormat("@synchronized"); 5126 verifyFormat("@synthesize"); 5127 verifyFormat("@throw"); 5128 verifyFormat("@try"); 5129 5130 EXPECT_EQ("@interface", format("@ interface")); 5131 5132 // The precise formatting of this doesn't matter, nobody writes code like 5133 // this. 5134 verifyFormat("@ /*foo*/ interface"); 5135} 5136 5137TEST_F(FormatTest, ObjCSnippets) { 5138 verifyFormat("@autoreleasepool {\n" 5139 " foo();\n" 5140 "}"); 5141 verifyFormat("@class Foo, Bar;"); 5142 verifyFormat("@compatibility_alias AliasName ExistingClass;"); 5143 verifyFormat("@dynamic textColor;"); 5144 verifyFormat("char *buf1 = @encode(int *);"); 5145 verifyFormat("char *buf1 = @encode(typeof(4 * 5));"); 5146 verifyFormat("char *buf1 = @encode(int **);"); 5147 verifyFormat("Protocol *proto = @protocol(p1);"); 5148 verifyFormat("SEL s = @selector(foo:);"); 5149 verifyFormat("@synchronized(self) {\n" 5150 " f();\n" 5151 "}"); 5152 5153 verifyFormat("@synthesize dropArrowPosition = dropArrowPosition_;"); 5154 verifyGoogleFormat("@synthesize dropArrowPosition = dropArrowPosition_;"); 5155 5156 verifyFormat("@property(assign, nonatomic) CGFloat hoverAlpha;"); 5157 verifyFormat("@property(assign, getter=isEditable) BOOL editable;"); 5158 verifyGoogleFormat("@property(assign, getter=isEditable) BOOL editable;"); 5159 5160 verifyFormat("@import foo.bar;\n" 5161 "@import baz;"); 5162} 5163 5164TEST_F(FormatTest, ObjCLiterals) { 5165 verifyFormat("@\"String\""); 5166 verifyFormat("@1"); 5167 verifyFormat("@+4.8"); 5168 verifyFormat("@-4"); 5169 verifyFormat("@1LL"); 5170 verifyFormat("@.5"); 5171 verifyFormat("@'c'"); 5172 verifyFormat("@true"); 5173 5174 verifyFormat("NSNumber *smallestInt = @(-INT_MAX - 1);"); 5175 verifyFormat("NSNumber *piOverTwo = @(M_PI / 2);"); 5176 verifyFormat("NSNumber *favoriteColor = @(Green);"); 5177 verifyFormat("NSString *path = @(getenv(\"PATH\"));"); 5178 5179 verifyFormat("@["); 5180 verifyFormat("@[]"); 5181 verifyFormat( 5182 "NSArray *array = @[ @\" Hey \", NSApp, [NSNumber numberWithInt:42] ];"); 5183 verifyFormat("return @[ @3, @[], @[ @4, @5 ] ];"); 5184 5185 verifyFormat("@{"); 5186 verifyFormat("@{}"); 5187 verifyFormat("@{ @\"one\" : @1 }"); 5188 verifyFormat("return @{ @\"one\" : @1 };"); 5189 verifyFormat("@{ @\"one\" : @1, }"); 5190 5191 verifyFormat("@{ @\"one\" : @{ @2 : @1 } }"); 5192 verifyFormat("@{ @\"one\" : @{ @2 : @1 }, }"); 5193 5194 verifyFormat("@{ 1 > 2 ? @\"one\" : @\"two\" : 1 > 2 ? @1 : @2 }"); 5195 verifyFormat("[self setDict:@{}"); 5196 verifyFormat("[self setDict:@{ @1 : @2 }"); 5197 verifyFormat("NSLog(@\"%@\", @{ @1 : @2, @2 : @3 }[@1]);"); 5198 verifyFormat( 5199 "NSDictionary *masses = @{ @\"H\" : @1.0078, @\"He\" : @4.0026 };"); 5200 verifyFormat( 5201 "NSDictionary *settings = @{ AVEncoderKey : @(AVAudioQualityMax) };"); 5202 5203 // FIXME: Nested and multi-line array and dictionary literals need more work. 5204 verifyFormat( 5205 "NSDictionary *d = @{ @\"nam\" : NSUserNam(), @\"dte\" : [NSDate date],\n" 5206 " @\"processInfo\" : [NSProcessInfo processInfo] };"); 5207 verifyFormat( 5208 "@{ NSFontAttributeNameeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee :\n" 5209 " regularFont, };"); 5210 5211} 5212 5213TEST_F(FormatTest, ReformatRegionAdjustsIndent) { 5214 EXPECT_EQ("{\n" 5215 "{\n" 5216 "a;\n" 5217 "b;\n" 5218 "}\n" 5219 "}", 5220 format("{\n" 5221 "{\n" 5222 "a;\n" 5223 " b;\n" 5224 "}\n" 5225 "}", 5226 13, 2, getLLVMStyle())); 5227 EXPECT_EQ("{\n" 5228 "{\n" 5229 " a;\n" 5230 "b;\n" 5231 "}\n" 5232 "}", 5233 format("{\n" 5234 "{\n" 5235 " a;\n" 5236 "b;\n" 5237 "}\n" 5238 "}", 5239 9, 2, getLLVMStyle())); 5240 EXPECT_EQ("{\n" 5241 "{\n" 5242 "public:\n" 5243 " b;\n" 5244 "}\n" 5245 "}", 5246 format("{\n" 5247 "{\n" 5248 "public:\n" 5249 " b;\n" 5250 "}\n" 5251 "}", 5252 17, 2, getLLVMStyle())); 5253 EXPECT_EQ("{\n" 5254 "{\n" 5255 "a;\n" 5256 "}\n" 5257 "{\n" 5258 " b; //\n" 5259 "}\n" 5260 "}", 5261 format("{\n" 5262 "{\n" 5263 "a;\n" 5264 "}\n" 5265 "{\n" 5266 " b; //\n" 5267 "}\n" 5268 "}", 5269 22, 2, getLLVMStyle())); 5270 EXPECT_EQ(" {\n" 5271 " a; //\n" 5272 " }", 5273 format(" {\n" 5274 "a; //\n" 5275 " }", 5276 4, 2, getLLVMStyle())); 5277 EXPECT_EQ("void f() {}\n" 5278 "void g() {}", 5279 format("void f() {}\n" 5280 "void g() {}", 5281 13, 0, getLLVMStyle())); 5282 EXPECT_EQ("int a; // comment\n" 5283 " // line 2\n" 5284 "int b;", 5285 format("int a; // comment\n" 5286 " // line 2\n" 5287 " int b;", 5288 35, 0, getLLVMStyle())); 5289 EXPECT_EQ(" int a;\n" 5290 " void\n" 5291 " ffffff() {\n" 5292 " }", 5293 format(" int a;\n" 5294 "void ffffff() {}", 5295 11, 0, getLLVMStyleWithColumns(11))); 5296} 5297 5298TEST_F(FormatTest, BreakStringLiterals) { 5299 EXPECT_EQ("\"some text \"\n" 5300 "\"other\";", 5301 format("\"some text other\";", getLLVMStyleWithColumns(12))); 5302 EXPECT_EQ("\"some text \"\n" 5303 "\"other\";", 5304 format("\\\n\"some text other\";", getLLVMStyleWithColumns(12))); 5305 EXPECT_EQ( 5306 "#define A \\\n" 5307 " \"some \" \\\n" 5308 " \"text \" \\\n" 5309 " \"other\";", 5310 format("#define A \"some text other\";", getLLVMStyleWithColumns(12))); 5311 EXPECT_EQ( 5312 "#define A \\\n" 5313 " \"so \" \\\n" 5314 " \"text \" \\\n" 5315 " \"other\";", 5316 format("#define A \"so text other\";", getLLVMStyleWithColumns(12))); 5317 5318 EXPECT_EQ("\"some text\"", 5319 format("\"some text\"", getLLVMStyleWithColumns(1))); 5320 EXPECT_EQ("\"some text\"", 5321 format("\"some text\"", getLLVMStyleWithColumns(11))); 5322 EXPECT_EQ("\"some \"\n" 5323 "\"text\"", 5324 format("\"some text\"", getLLVMStyleWithColumns(10))); 5325 EXPECT_EQ("\"some \"\n" 5326 "\"text\"", 5327 format("\"some text\"", getLLVMStyleWithColumns(7))); 5328 EXPECT_EQ("\"some\"\n" 5329 "\" tex\"\n" 5330 "\"t\"", 5331 format("\"some text\"", getLLVMStyleWithColumns(6))); 5332 EXPECT_EQ("\"some\"\n" 5333 "\" tex\"\n" 5334 "\" and\"", 5335 format("\"some tex and\"", getLLVMStyleWithColumns(6))); 5336 EXPECT_EQ("\"some\"\n" 5337 "\"/tex\"\n" 5338 "\"/and\"", 5339 format("\"some/tex/and\"", getLLVMStyleWithColumns(6))); 5340 5341 EXPECT_EQ("variable =\n" 5342 " \"long string \"\n" 5343 " \"literal\";", 5344 format("variable = \"long string literal\";", 5345 getLLVMStyleWithColumns(20))); 5346 5347 EXPECT_EQ("variable = f(\n" 5348 " \"long string \"\n" 5349 " \"literal\",\n" 5350 " short,\n" 5351 " loooooooooooooooooooong);", 5352 format("variable = f(\"long string literal\", short, " 5353 "loooooooooooooooooooong);", 5354 getLLVMStyleWithColumns(20))); 5355 5356 EXPECT_EQ("f(g(\"long string \"\n" 5357 " \"literal\"),\n" 5358 " b);", 5359 format("f(g(\"long string literal\"), b);", 5360 getLLVMStyleWithColumns(20))); 5361 EXPECT_EQ("f(g(\"long string \"\n" 5362 " \"literal\",\n" 5363 " a),\n" 5364 " b);", 5365 format("f(g(\"long string literal\", a), b);", 5366 getLLVMStyleWithColumns(20))); 5367 EXPECT_EQ( 5368 "f(\"one two\".split(\n" 5369 " variable));", 5370 format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20))); 5371 EXPECT_EQ("f(\"one two three four five six \"\n" 5372 " \"seven\".split(\n" 5373 " really_looooong_variable));", 5374 format("f(\"one two three four five six seven\"." 5375 "split(really_looooong_variable));", 5376 getLLVMStyleWithColumns(33))); 5377 5378 EXPECT_EQ("f(\"some \"\n" 5379 " \"text\",\n" 5380 " other);", 5381 format("f(\"some text\", other);", getLLVMStyleWithColumns(10))); 5382 5383 // Only break as a last resort. 5384 verifyFormat( 5385 "aaaaaaaaaaaaaaaaaaaa(\n" 5386 " aaaaaaaaaaaaaaaaaaaa,\n" 5387 " aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));"); 5388 5389 EXPECT_EQ( 5390 "\"splitmea\"\n" 5391 "\"trandomp\"\n" 5392 "\"oint\"", 5393 format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10))); 5394 5395 EXPECT_EQ( 5396 "\"split/\"\n" 5397 "\"pathat/\"\n" 5398 "\"slashes\"", 5399 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 5400 5401 EXPECT_EQ( 5402 "\"split/\"\n" 5403 "\"pathat/\"\n" 5404 "\"slashes\"", 5405 format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10))); 5406 EXPECT_EQ("\"split at \"\n" 5407 "\"spaces/at/\"\n" 5408 "\"slashes.at.any$\"\n" 5409 "\"non-alphanumeric%\"\n" 5410 "\"1111111111characte\"\n" 5411 "\"rs\"", 5412 format("\"split at " 5413 "spaces/at/" 5414 "slashes.at." 5415 "any$non-" 5416 "alphanumeric%" 5417 "1111111111characte" 5418 "rs\"", 5419 getLLVMStyleWithColumns(20))); 5420 5421 // Verify that splitting the strings understands 5422 // Style::AlwaysBreakBeforeMultilineStrings. 5423 EXPECT_EQ("aaaaaaaaaaaa(aaaaaaaaaaaaa,\n" 5424 " \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n" 5425 " \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");", 5426 format("aaaaaaaaaaaa(aaaaaaaaaaaaa, \"aaaaaaaaaaaaaaaaaaaaaa " 5427 "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa " 5428 "aaaaaaaaaaaaaaaaaaaaaa\");", 5429 getGoogleStyle())); 5430 EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 5431 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 5432 format("llvm::outs() << " 5433 "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa" 5434 "aaaaaaaaaaaaaaaaaaa\";")); 5435 EXPECT_EQ("ffff(\n" 5436 " {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" 5437 " \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 5438 format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " 5439 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});", 5440 getGoogleStyle())); 5441 5442 FormatStyle AlignLeft = getLLVMStyleWithColumns(12); 5443 AlignLeft.AlignEscapedNewlinesLeft = true; 5444 EXPECT_EQ( 5445 "#define A \\\n" 5446 " \"some \" \\\n" 5447 " \"text \" \\\n" 5448 " \"other\";", 5449 format("#define A \"some text other\";", AlignLeft)); 5450} 5451 5452TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) { 5453 EXPECT_EQ( 5454 "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 5455 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 5456 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";", 5457 format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 5458 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 5459 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";")); 5460} 5461 5462TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) { 5463 EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);", 5464 format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle())); 5465 EXPECT_EQ("fffffffffff(g(R\"x(\n" 5466 "multiline raw string literal xxxxxxxxxxxxxx\n" 5467 ")x\",\n" 5468 " a),\n" 5469 " b);", 5470 format("fffffffffff(g(R\"x(\n" 5471 "multiline raw string literal xxxxxxxxxxxxxx\n" 5472 ")x\", a), b);", 5473 getGoogleStyleWithColumns(20))); 5474 EXPECT_EQ("fffffffffff(\n" 5475 " g(R\"x(qqq\n" 5476 "multiline raw string literal xxxxxxxxxxxxxx\n" 5477 ")x\",\n" 5478 " a),\n" 5479 " b);", 5480 format("fffffffffff(g(R\"x(qqq\n" 5481 "multiline raw string literal xxxxxxxxxxxxxx\n" 5482 ")x\", a), b);", 5483 getGoogleStyleWithColumns(20))); 5484 5485 EXPECT_EQ("fffffffffff(R\"x(\n" 5486 "multiline raw string literal xxxxxxxxxxxxxx\n" 5487 ")x\");", 5488 format("fffffffffff(R\"x(\n" 5489 "multiline raw string literal xxxxxxxxxxxxxx\n" 5490 ")x\");", 5491 getGoogleStyleWithColumns(20))); 5492 EXPECT_EQ("fffffffffff(R\"x(\n" 5493 "multiline raw string literal xxxxxxxxxxxxxx\n" 5494 ")x\" +\n" 5495 " bbbbbb);", 5496 format("fffffffffff(R\"x(\n" 5497 "multiline raw string literal xxxxxxxxxxxxxx\n" 5498 ")x\" + bbbbbb);", 5499 getGoogleStyleWithColumns(20))); 5500} 5501 5502TEST_F(FormatTest, SkipsUnknownStringLiterals) { 5503 EXPECT_EQ( 5504 "u8\"unsupported literal\";", 5505 format("u8\"unsupported literal\";", getGoogleStyleWithColumns(15))); 5506 EXPECT_EQ("u\"unsupported literal\";", 5507 format("u\"unsupported literal\";", getGoogleStyleWithColumns(15))); 5508 EXPECT_EQ("U\"unsupported literal\";", 5509 format("U\"unsupported literal\";", getGoogleStyleWithColumns(15))); 5510 EXPECT_EQ("L\"unsupported literal\";", 5511 format("L\"unsupported literal\";", getGoogleStyleWithColumns(15))); 5512 EXPECT_EQ("R\"x(raw literal)x\";", 5513 format("R\"x(raw literal)x\";", getGoogleStyleWithColumns(15))); 5514 verifyFormat("string a = \"unterminated;"); 5515 EXPECT_EQ("function(\"unterminated,\n" 5516 " OtherParameter);", 5517 format("function( \"unterminated,\n" 5518 " OtherParameter);")); 5519} 5520 5521TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) { 5522 EXPECT_EQ("#define x(_a) printf(\"foo\" _a);", 5523 format("#define x(_a) printf(\"foo\"_a);", getLLVMStyle())); 5524} 5525 5526TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) { 5527 EXPECT_EQ("someFunction(\"aaabbbcccd\"\n" 5528 " \"ddeeefff\");", 5529 format("someFunction(\"aaabbbcccdddeeefff\");", 5530 getLLVMStyleWithColumns(25))); 5531 EXPECT_EQ("someFunction1234567890(\n" 5532 " \"aaabbbcccdddeeefff\");", 5533 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 5534 getLLVMStyleWithColumns(26))); 5535 EXPECT_EQ("someFunction1234567890(\n" 5536 " \"aaabbbcccdddeeeff\"\n" 5537 " \"f\");", 5538 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 5539 getLLVMStyleWithColumns(25))); 5540 EXPECT_EQ("someFunction1234567890(\n" 5541 " \"aaabbbcccdddeeeff\"\n" 5542 " \"f\");", 5543 format("someFunction1234567890(\"aaabbbcccdddeeefff\");", 5544 getLLVMStyleWithColumns(24))); 5545 EXPECT_EQ("someFunction(\"aaabbbcc \"\n" 5546 " \"ddde \"\n" 5547 " \"efff\");", 5548 format("someFunction(\"aaabbbcc ddde efff\");", 5549 getLLVMStyleWithColumns(25))); 5550 EXPECT_EQ("someFunction(\"aaabbbccc \"\n" 5551 " \"ddeeefff\");", 5552 format("someFunction(\"aaabbbccc ddeeefff\");", 5553 getLLVMStyleWithColumns(25))); 5554 EXPECT_EQ("someFunction1234567890(\n" 5555 " \"aaabb \"\n" 5556 " \"cccdddeeefff\");", 5557 format("someFunction1234567890(\"aaabb cccdddeeefff\");", 5558 getLLVMStyleWithColumns(25))); 5559 EXPECT_EQ("#define A \\\n" 5560 " string s = \\\n" 5561 " \"123456789\" \\\n" 5562 " \"0\"; \\\n" 5563 " int i;", 5564 format("#define A string s = \"1234567890\"; int i;", 5565 getLLVMStyleWithColumns(20))); 5566 // FIXME: Put additional penalties on breaking at non-whitespace locations. 5567 EXPECT_EQ("someFunction(\"aaabbbcc \"\n" 5568 " \"dddeeeff\"\n" 5569 " \"f\");", 5570 format("someFunction(\"aaabbbcc dddeeefff\");", 5571 getLLVMStyleWithColumns(25))); 5572} 5573 5574TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) { 5575 EXPECT_EQ("\"\\a\"", 5576 format("\"\\a\"", getLLVMStyleWithColumns(3))); 5577 EXPECT_EQ("\"\\\"", 5578 format("\"\\\"", getLLVMStyleWithColumns(2))); 5579 EXPECT_EQ("\"test\"\n" 5580 "\"\\n\"", 5581 format("\"test\\n\"", getLLVMStyleWithColumns(7))); 5582 EXPECT_EQ("\"tes\\\\\"\n" 5583 "\"n\"", 5584 format("\"tes\\\\n\"", getLLVMStyleWithColumns(7))); 5585 EXPECT_EQ("\"\\\\\\\\\"\n" 5586 "\"\\n\"", 5587 format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7))); 5588 EXPECT_EQ("\"\\uff01\"", 5589 format("\"\\uff01\"", getLLVMStyleWithColumns(7))); 5590 EXPECT_EQ("\"\\uff01\"\n" 5591 "\"test\"", 5592 format("\"\\uff01test\"", getLLVMStyleWithColumns(8))); 5593 EXPECT_EQ("\"\\Uff01ff02\"", 5594 format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11))); 5595 EXPECT_EQ("\"\\x000000000001\"\n" 5596 "\"next\"", 5597 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16))); 5598 EXPECT_EQ("\"\\x000000000001next\"", 5599 format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15))); 5600 EXPECT_EQ("\"\\x000000000001\"", 5601 format("\"\\x000000000001\"", getLLVMStyleWithColumns(7))); 5602 EXPECT_EQ("\"test\"\n" 5603 "\"\\000000\"\n" 5604 "\"000001\"", 5605 format("\"test\\000000000001\"", getLLVMStyleWithColumns(9))); 5606 EXPECT_EQ("\"test\\000\"\n" 5607 "\"00000000\"\n" 5608 "\"1\"", 5609 format("\"test\\000000000001\"", getLLVMStyleWithColumns(10))); 5610 EXPECT_EQ("R\"(\\x\\x00)\"\n", 5611 format("R\"(\\x\\x00)\"\n", getGoogleStyleWithColumns(7))); 5612} 5613 5614TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) { 5615 verifyFormat("void f() {\n" 5616 " return g() {}\n" 5617 " void h() {}"); 5618 verifyFormat("if (foo)\n" 5619 " return { forgot_closing_brace();\n" 5620 "test();"); 5621 verifyFormat("int a[] = { void forgot_closing_brace() { f();\n" 5622 "g();\n" 5623 "}"); 5624} 5625 5626TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) { 5627 verifyFormat("class X {\n" 5628 " void f() {\n" 5629 " }\n" 5630 "};", 5631 getLLVMStyleWithColumns(12)); 5632} 5633 5634TEST_F(FormatTest, ConfigurableIndentWidth) { 5635 FormatStyle EightIndent = getLLVMStyleWithColumns(18); 5636 EightIndent.IndentWidth = 8; 5637 verifyFormat("void f() {\n" 5638 " someFunction();\n" 5639 " if (true) {\n" 5640 " f();\n" 5641 " }\n" 5642 "}", 5643 EightIndent); 5644 verifyFormat("class X {\n" 5645 " void f() {\n" 5646 " }\n" 5647 "};", 5648 EightIndent); 5649 verifyFormat("int x[] = {\n" 5650 " call(),\n" 5651 " call(),\n" 5652 "};", 5653 EightIndent); 5654} 5655 5656TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) { 5657 verifyFormat("void\n" 5658 "f();", 5659 getLLVMStyleWithColumns(8)); 5660} 5661 5662TEST_F(FormatTest, ConfigurableUseOfTab) { 5663 FormatStyle Tab = getLLVMStyleWithColumns(42); 5664 Tab.IndentWidth = 8; 5665 Tab.UseTab = true; 5666 Tab.AlignEscapedNewlinesLeft = true; 5667 verifyFormat("class X {\n" 5668 "\tvoid f() {\n" 5669 "\t\tsomeFunction(parameter1,\n" 5670 "\t\t\t parameter2);\n" 5671 "\t}\n" 5672 "};", 5673 Tab); 5674 verifyFormat("#define A \\\n" 5675 "\tvoid f() { \\\n" 5676 "\t\tsomeFunction( \\\n" 5677 "\t\t parameter1, \\\n" 5678 "\t\t parameter2); \\\n" 5679 "\t}", 5680 Tab); 5681 EXPECT_EQ("void f() {\n" 5682 "\tf();\n" 5683 "\tg();\n" 5684 "}", 5685 format("void f() {\n" 5686 "\tf();\n" 5687 "\tg();\n" 5688 "}", 5689 0, 0, Tab)); 5690 EXPECT_EQ("void f() {\n" 5691 "\tf();\n" 5692 "\tg();\n" 5693 "}", 5694 format("void f() {\n" 5695 "\tf();\n" 5696 "\tg();\n" 5697 "}", 5698 16, 0, Tab)); 5699 EXPECT_EQ("void f() {\n" 5700 " \tf();\n" 5701 "\tg();\n" 5702 "}", 5703 format("void f() {\n" 5704 " \tf();\n" 5705 " \tg();\n" 5706 "}", 5707 21, 0, Tab)); 5708 5709 Tab.TabWidth = 4; 5710 Tab.IndentWidth = 8; 5711 verifyFormat("class TabWidth4Indent8 {\n" 5712 "\t\tvoid f() {\n" 5713 "\t\t\t\tsomeFunction(parameter1,\n" 5714 "\t\t\t\t\t\t\t parameter2);\n" 5715 "\t\t}\n" 5716 "};", 5717 Tab); 5718 5719 Tab.TabWidth = 4; 5720 Tab.IndentWidth = 4; 5721 verifyFormat("class TabWidth4Indent4 {\n" 5722 "\tvoid f() {\n" 5723 "\t\tsomeFunction(parameter1,\n" 5724 "\t\t\t\t\t parameter2);\n" 5725 "\t}\n" 5726 "};", 5727 Tab); 5728 5729 Tab.TabWidth = 8; 5730 Tab.IndentWidth = 4; 5731 verifyFormat("class TabWidth8Indent4 {\n" 5732 " void f() {\n" 5733 "\tsomeFunction(parameter1,\n" 5734 "\t\t parameter2);\n" 5735 " }\n" 5736 "};", 5737 Tab); 5738 5739 // FIXME: To correctly count mixed whitespace we need to 5740 // also correctly count mixed whitespace in front of the comment. 5741 5742 Tab.TabWidth = 8; 5743 Tab.IndentWidth = 8; 5744 EXPECT_EQ("/*\n" 5745 "\t a\t\tcomment\n" 5746 "\t in multiple lines\n" 5747 " */", 5748 format(" /*\t \t \n" 5749 " \t \t a\t\tcomment\t \t\n" 5750 " \t \t in multiple lines\t\n" 5751 " \t */", 5752 Tab)); 5753 Tab.UseTab = false; 5754 EXPECT_EQ("/*\n" 5755 " a\t\tcomment\n" 5756 " in multiple lines\n" 5757 " */", 5758 format(" /*\t \t \n" 5759 " \t \t a\t\tcomment\t \t\n" 5760 " \t \t in multiple lines\t\n" 5761 " \t */", 5762 Tab)); 5763 EXPECT_EQ("/* some\n" 5764 " comment */", 5765 format(" \t \t /* some\n" 5766 " \t \t comment */", 5767 Tab)); 5768 EXPECT_EQ("int a; /* some\n" 5769 " comment */", 5770 format(" \t \t int a; /* some\n" 5771 " \t \t comment */", 5772 Tab)); 5773 5774 EXPECT_EQ("int a; /* some\n" 5775 "comment */", 5776 format(" \t \t int\ta; /* some\n" 5777 " \t \t comment */", 5778 Tab)); 5779 EXPECT_EQ("f(\"\t\t\"); /* some\n" 5780 " comment */", 5781 format(" \t \t f(\"\t\t\"); /* some\n" 5782 " \t \t comment */", 5783 Tab)); 5784 EXPECT_EQ("{\n" 5785 " /*\n" 5786 " * Comment\n" 5787 " */\n" 5788 " int i;\n" 5789 "}", 5790 format("{\n" 5791 "\t/*\n" 5792 "\t * Comment\n" 5793 "\t */\n" 5794 "\t int i;\n" 5795 "}")); 5796} 5797 5798TEST_F(FormatTest, ConfigurableSpaceAfterControlStatementKeyword) { 5799 FormatStyle NoSpace = getLLVMStyle(); 5800 NoSpace.SpaceAfterControlStatementKeyword = false; 5801 5802 verifyFormat("while(true)\n" 5803 " continue;", NoSpace); 5804 verifyFormat("for(;;)\n" 5805 " continue;", NoSpace); 5806 verifyFormat("if(true)\n" 5807 " f();\n" 5808 "else if(true)\n" 5809 " f();", NoSpace); 5810 verifyFormat("do {\n" 5811 " do_something();\n" 5812 "} while(something());", NoSpace); 5813 verifyFormat("switch(x) {\n" 5814 "default:\n" 5815 " break;\n" 5816 "}", NoSpace); 5817} 5818 5819TEST_F(FormatTest, ConfigurableSpacesInParentheses) { 5820 FormatStyle Spaces = getLLVMStyle(); 5821 5822 Spaces.SpacesInParentheses = true; 5823 verifyFormat("call( x, y, z );", Spaces); 5824 verifyFormat("while ( (bool)1 )\n" 5825 " continue;", Spaces); 5826 verifyFormat("for ( ;; )\n" 5827 " continue;", Spaces); 5828 verifyFormat("if ( true )\n" 5829 " f();\n" 5830 "else if ( true )\n" 5831 " f();", Spaces); 5832 verifyFormat("do {\n" 5833 " do_something( (int)i );\n" 5834 "} while ( something() );", Spaces); 5835 verifyFormat("switch ( x ) {\n" 5836 "default:\n" 5837 " break;\n" 5838 "}", Spaces); 5839 5840 Spaces.SpacesInParentheses = false; 5841 Spaces.SpacesInCStyleCastParentheses = true; 5842 verifyFormat("Type *A = ( Type * )P;", Spaces); 5843 verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces); 5844 verifyFormat("x = ( int32 )y;", Spaces); 5845 verifyFormat("int a = ( int )(2.0f);", Spaces); 5846 verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces); 5847 verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces); 5848 verifyFormat("#define x (( int )-1)", Spaces); 5849 5850 Spaces.SpacesInParentheses = false; 5851 Spaces.SpaceInEmptyParentheses = true; 5852 verifyFormat("call(x, y, z);", Spaces); 5853 verifyFormat("call( )", Spaces); 5854 5855 // Run the first set of tests again with 5856 // Spaces.SpacesInParentheses = false, 5857 // Spaces.SpaceInEmptyParentheses = true and 5858 // Spaces.SpacesInCStyleCastParentheses = true 5859 Spaces.SpacesInParentheses = false, 5860 Spaces.SpaceInEmptyParentheses = true; 5861 Spaces.SpacesInCStyleCastParentheses = true; 5862 verifyFormat("call(x, y, z);", Spaces); 5863 verifyFormat("while (( bool )1)\n" 5864 " continue;", Spaces); 5865 verifyFormat("for (;;)\n" 5866 " continue;", Spaces); 5867 verifyFormat("if (true)\n" 5868 " f( );\n" 5869 "else if (true)\n" 5870 " f( );", Spaces); 5871 verifyFormat("do {\n" 5872 " do_something(( int )i);\n" 5873 "} while (something( ));", Spaces); 5874 verifyFormat("switch (x) {\n" 5875 "default:\n" 5876 " break;\n" 5877 "}", Spaces); 5878} 5879 5880TEST_F(FormatTest, LinuxBraceBreaking) { 5881 FormatStyle BreakBeforeBrace = getLLVMStyle(); 5882 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Linux; 5883 verifyFormat("namespace a\n" 5884 "{\n" 5885 "class A\n" 5886 "{\n" 5887 " void f()\n" 5888 " {\n" 5889 " if (true) {\n" 5890 " a();\n" 5891 " b();\n" 5892 " }\n" 5893 " }\n" 5894 " void g()\n" 5895 " {\n" 5896 " return;\n" 5897 " }\n" 5898 "}\n" 5899 "}", 5900 BreakBeforeBrace); 5901} 5902 5903TEST_F(FormatTest, StroustrupBraceBreaking) { 5904 FormatStyle BreakBeforeBrace = getLLVMStyle(); 5905 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 5906 verifyFormat("namespace a {\n" 5907 "class A {\n" 5908 " void f()\n" 5909 " {\n" 5910 " if (true) {\n" 5911 " a();\n" 5912 " b();\n" 5913 " }\n" 5914 " }\n" 5915 " void g()\n" 5916 " {\n" 5917 " return;\n" 5918 " }\n" 5919 "}\n" 5920 "}", 5921 BreakBeforeBrace); 5922} 5923 5924TEST_F(FormatTest, AllmanBraceBreaking) { 5925 FormatStyle BreakBeforeBrace = getLLVMStyle(); 5926 BreakBeforeBrace.BreakBeforeBraces = FormatStyle::BS_Allman; 5927 verifyFormat("namespace a\n" 5928 "{\n" 5929 "class A\n" 5930 "{\n" 5931 " void f()\n" 5932 " {\n" 5933 " if (true)\n" 5934 " {\n" 5935 " a();\n" 5936 " b();\n" 5937 " }\n" 5938 " }\n" 5939 " void g()\n" 5940 " {\n" 5941 " return;\n" 5942 " }\n" 5943 "}\n" 5944 "}", 5945 BreakBeforeBrace); 5946 5947 verifyFormat("void f()\n" 5948 "{\n" 5949 " if (true)\n" 5950 " {\n" 5951 " a();\n" 5952 " }\n" 5953 " else if (false)\n" 5954 " {\n" 5955 " b();\n" 5956 " }\n" 5957 " else\n" 5958 " {\n" 5959 " c();\n" 5960 " }\n" 5961 "}\n", 5962 BreakBeforeBrace); 5963 5964 verifyFormat("void f()\n" 5965 "{\n" 5966 " for (int i = 0; i < 10; ++i)\n" 5967 " {\n" 5968 " a();\n" 5969 " }\n" 5970 " while (false)\n" 5971 " {\n" 5972 " b();\n" 5973 " }\n" 5974 " do\n" 5975 " {\n" 5976 " c();\n" 5977 " } while (false)\n" 5978 "}\n", 5979 BreakBeforeBrace); 5980 5981 verifyFormat("void f(int a)\n" 5982 "{\n" 5983 " switch (a)\n" 5984 " {\n" 5985 " case 0:\n" 5986 " break;\n" 5987 " case 1:\n" 5988 " {\n" 5989 " break;\n" 5990 " }\n" 5991 " case 2:\n" 5992 " {\n" 5993 " }\n" 5994 " break;\n" 5995 " default:\n" 5996 " break;\n" 5997 " }\n" 5998 "}\n", 5999 BreakBeforeBrace); 6000 6001 verifyFormat("enum X\n" 6002 "{\n" 6003 " Y = 0,\n" 6004 "}\n", 6005 BreakBeforeBrace); 6006 6007 FormatStyle BreakBeforeBraceShortIfs = BreakBeforeBrace; 6008 BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine = true; 6009 BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true; 6010 verifyFormat("void f(bool b)\n" 6011 "{\n" 6012 " if (b)\n" 6013 " {\n" 6014 " return;\n" 6015 " }\n" 6016 "}\n", 6017 BreakBeforeBraceShortIfs); 6018 verifyFormat("void f(bool b)\n" 6019 "{\n" 6020 " if (b) return;\n" 6021 "}\n", 6022 BreakBeforeBraceShortIfs); 6023 verifyFormat("void f(bool b)\n" 6024 "{\n" 6025 " while (b)\n" 6026 " {\n" 6027 " return;\n" 6028 " }\n" 6029 "}\n", 6030 BreakBeforeBraceShortIfs); 6031} 6032 6033TEST_F(FormatTest, CatchExceptionReferenceBinding) { 6034 verifyFormat("void f() {\n" 6035 " try {\n" 6036 " }\n" 6037 " catch (const Exception &e) {\n" 6038 " }\n" 6039 "}\n", 6040 getLLVMStyle()); 6041} 6042 6043TEST_F(FormatTest, UnderstandsPragmas) { 6044 verifyFormat("#pragma omp reduction(| : var)"); 6045 verifyFormat("#pragma omp reduction(+ : var)"); 6046} 6047 6048bool allStylesEqual(ArrayRef<FormatStyle> Styles) { 6049 for (size_t i = 1; i < Styles.size(); ++i) 6050 if (!(Styles[0] == Styles[i])) 6051 return false; 6052 return true; 6053} 6054 6055TEST_F(FormatTest, GetsPredefinedStyleByName) { 6056 FormatStyle Styles[3]; 6057 6058 Styles[0] = getLLVMStyle(); 6059 EXPECT_TRUE(getPredefinedStyle("LLVM", &Styles[1])); 6060 EXPECT_TRUE(getPredefinedStyle("lLvM", &Styles[2])); 6061 EXPECT_TRUE(allStylesEqual(Styles)); 6062 6063 Styles[0] = getGoogleStyle(); 6064 EXPECT_TRUE(getPredefinedStyle("Google", &Styles[1])); 6065 EXPECT_TRUE(getPredefinedStyle("gOOgle", &Styles[2])); 6066 EXPECT_TRUE(allStylesEqual(Styles)); 6067 6068 Styles[0] = getChromiumStyle(); 6069 EXPECT_TRUE(getPredefinedStyle("Chromium", &Styles[1])); 6070 EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", &Styles[2])); 6071 EXPECT_TRUE(allStylesEqual(Styles)); 6072 6073 Styles[0] = getMozillaStyle(); 6074 EXPECT_TRUE(getPredefinedStyle("Mozilla", &Styles[1])); 6075 EXPECT_TRUE(getPredefinedStyle("moZILla", &Styles[2])); 6076 EXPECT_TRUE(allStylesEqual(Styles)); 6077 6078 Styles[0] = getWebKitStyle(); 6079 EXPECT_TRUE(getPredefinedStyle("WebKit", &Styles[1])); 6080 EXPECT_TRUE(getPredefinedStyle("wEbKit", &Styles[2])); 6081 EXPECT_TRUE(allStylesEqual(Styles)); 6082 6083 EXPECT_FALSE(getPredefinedStyle("qwerty", &Styles[0])); 6084} 6085 6086TEST_F(FormatTest, ParsesConfiguration) { 6087 FormatStyle Style = {}; 6088#define CHECK_PARSE(TEXT, FIELD, VALUE) \ 6089 EXPECT_NE(VALUE, Style.FIELD); \ 6090 EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value()); \ 6091 EXPECT_EQ(VALUE, Style.FIELD) 6092 6093#define CHECK_PARSE_BOOL(FIELD) \ 6094 Style.FIELD = false; \ 6095 EXPECT_EQ(0, parseConfiguration(#FIELD ": true", &Style).value()); \ 6096 EXPECT_TRUE(Style.FIELD); \ 6097 EXPECT_EQ(0, parseConfiguration(#FIELD ": false", &Style).value()); \ 6098 EXPECT_FALSE(Style.FIELD); 6099 6100 CHECK_PARSE_BOOL(AlignEscapedNewlinesLeft); 6101 CHECK_PARSE_BOOL(AlignTrailingComments); 6102 CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine); 6103 CHECK_PARSE_BOOL(AllowShortIfStatementsOnASingleLine); 6104 CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine); 6105 CHECK_PARSE_BOOL(AlwaysBreakTemplateDeclarations); 6106 CHECK_PARSE_BOOL(BinPackParameters); 6107 CHECK_PARSE_BOOL(BreakBeforeBinaryOperators); 6108 CHECK_PARSE_BOOL(BreakConstructorInitializersBeforeComma); 6109 CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine); 6110 CHECK_PARSE_BOOL(DerivePointerBinding); 6111 CHECK_PARSE_BOOL(IndentCaseLabels); 6112 CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList); 6113 CHECK_PARSE_BOOL(PointerBindsToType); 6114 CHECK_PARSE_BOOL(Cpp11BracedListStyle); 6115 CHECK_PARSE_BOOL(UseTab); 6116 CHECK_PARSE_BOOL(IndentFunctionDeclarationAfterType); 6117 CHECK_PARSE_BOOL(SpacesInParentheses); 6118 CHECK_PARSE_BOOL(SpaceInEmptyParentheses); 6119 CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses); 6120 CHECK_PARSE_BOOL(SpaceAfterControlStatementKeyword); 6121 6122 CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234); 6123 CHECK_PARSE("ConstructorInitializerIndentWidth: 1234", 6124 ConstructorInitializerIndentWidth, 1234u); 6125 CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u); 6126 CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u); 6127 CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u); 6128 CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234", 6129 PenaltyReturnTypeOnItsOwnLine, 1234u); 6130 CHECK_PARSE("SpacesBeforeTrailingComments: 1234", 6131 SpacesBeforeTrailingComments, 1234u); 6132 CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u); 6133 6134 Style.Standard = FormatStyle::LS_Auto; 6135 CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03); 6136 CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Cpp11); 6137 CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03); 6138 CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11); 6139 CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto); 6140 6141 Style.ColumnLimit = 123; 6142 FormatStyle BaseStyle = getLLVMStyle(); 6143 CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit); 6144 CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u); 6145 6146 Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; 6147 CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces, 6148 FormatStyle::BS_Attach); 6149 CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces, 6150 FormatStyle::BS_Linux); 6151 CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces, 6152 FormatStyle::BS_Stroustrup); 6153 6154 Style.NamespaceIndentation = FormatStyle::NI_All; 6155 CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation, 6156 FormatStyle::NI_None); 6157 CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation, 6158 FormatStyle::NI_Inner); 6159 CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation, 6160 FormatStyle::NI_All); 6161 6162#undef CHECK_PARSE 6163#undef CHECK_PARSE_BOOL 6164} 6165 6166TEST_F(FormatTest, ConfigurationRoundTripTest) { 6167 FormatStyle Style = getLLVMStyle(); 6168 std::string YAML = configurationAsText(Style); 6169 FormatStyle ParsedStyle = {}; 6170 EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value()); 6171 EXPECT_EQ(Style, ParsedStyle); 6172} 6173 6174TEST_F(FormatTest, WorksFor8bitEncodings) { 6175 EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n" 6176 "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n" 6177 "\"\xe7\xe8\xec\xed\xfe\xfe \"\n" 6178 "\"\xef\xee\xf0\xf3...\"", 6179 format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 " 6180 "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe " 6181 "\xef\xee\xf0\xf3...\"", 6182 getLLVMStyleWithColumns(12))); 6183} 6184 6185// FIXME: Encode Cyrillic and CJK characters below to appease MS compilers. 6186#if !defined(_MSC_VER) 6187 6188TEST_F(FormatTest, CountsUTF8CharactersProperly) { 6189 verifyFormat("\"Однажды в студёную зимнюю пору...\"", 6190 getLLVMStyleWithColumns(35)); 6191 verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"", 6192 getLLVMStyleWithColumns(31)); 6193 verifyFormat("// Однажды в студёную зимнюю пору...", 6194 getLLVMStyleWithColumns(36)); 6195 verifyFormat("// 一 二 三 四 五 六 七 八 九 十", 6196 getLLVMStyleWithColumns(32)); 6197 verifyFormat("/* Однажды в студёную зимнюю пору... */", 6198 getLLVMStyleWithColumns(39)); 6199 verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */", 6200 getLLVMStyleWithColumns(35)); 6201} 6202 6203TEST_F(FormatTest, SplitsUTF8Strings) { 6204 EXPECT_EQ( 6205 "\"Однажды, в \"\n" 6206 "\"студёную \"\n" 6207 "\"зимнюю \"\n" 6208 "\"пору,\"", 6209 format("\"Однажды, в студёную зимнюю пору,\"", 6210 getLLVMStyleWithColumns(13))); 6211 EXPECT_EQ("\"一 二 三 \"\n" 6212 "\"四 五六 \"\n" 6213 "\"七 八 九 \"\n" 6214 "\"十\"", 6215 format("\"一 二 三 四 五六 七 八 九 十\"", 6216 getLLVMStyleWithColumns(11))); 6217 EXPECT_EQ("\"一\t二 \"\n" 6218 "\"\t三 \"\n" 6219 "\"四 五\t六 \"\n" 6220 "\"\t七 \"\n" 6221 "\"八九十\tqq\"", 6222 format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"", 6223 getLLVMStyleWithColumns(11))); 6224} 6225 6226 6227TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) { 6228 EXPECT_EQ("const char *sssss =\n" 6229 " \"一二三四五六七八\\\n" 6230 " 九 十\";", 6231 format("const char *sssss = \"一二三四五六七八\\\n" 6232 " 九 十\";", 6233 getLLVMStyleWithColumns(30))); 6234} 6235 6236TEST_F(FormatTest, SplitsUTF8LineComments) { 6237 EXPECT_EQ("// Я из лесу\n" 6238 "// вышел; был\n" 6239 "// сильный\n" 6240 "// мороз.", 6241 format("// Я из лесу вышел; был сильный мороз.", 6242 getLLVMStyleWithColumns(13))); 6243 EXPECT_EQ("// 一二三\n" 6244 "// 四五六七\n" 6245 "// 八 九\n" 6246 "// 十", 6247 format("// 一二三 四五六七 八 九 十", getLLVMStyleWithColumns(9))); 6248} 6249 6250TEST_F(FormatTest, SplitsUTF8BlockComments) { 6251 EXPECT_EQ("/* Гляжу,\n" 6252 " * поднимается\n" 6253 " * медленно в\n" 6254 " * гору\n" 6255 " * Лошадка,\n" 6256 " * везущая\n" 6257 " * хворосту\n" 6258 " * воз. */", 6259 format("/* Гляжу, поднимается медленно в гору\n" 6260 " * Лошадка, везущая хворосту воз. */", 6261 getLLVMStyleWithColumns(13))); 6262 EXPECT_EQ( 6263 "/* 一二三\n" 6264 " * 四五六七\n" 6265 " * 八 九\n" 6266 " * 十 */", 6267 format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9))); 6268 EXPECT_EQ("/* \n" 6269 " * \n" 6270 " * - */", 6271 format("/* - */", getLLVMStyleWithColumns(12))); 6272} 6273 6274#endif // _MSC_VER 6275 6276TEST_F(FormatTest, ConstructorInitializerIndentWidth) { 6277 FormatStyle Style = getLLVMStyle(); 6278 6279 Style.ConstructorInitializerIndentWidth = 4; 6280 verifyFormat( 6281 "SomeClass::Constructor()\n" 6282 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 6283 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 6284 Style); 6285 6286 Style.ConstructorInitializerIndentWidth = 2; 6287 verifyFormat( 6288 "SomeClass::Constructor()\n" 6289 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 6290 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 6291 Style); 6292 6293 Style.ConstructorInitializerIndentWidth = 0; 6294 verifyFormat( 6295 "SomeClass::Constructor()\n" 6296 ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 6297 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", 6298 Style); 6299 6300 Style.BreakConstructorInitializersBeforeComma = true; 6301 Style.ConstructorInitializerIndentWidth = 4; 6302 verifyFormat("SomeClass::Constructor()\n" 6303 " : a(a)\n" 6304 " , b(b)\n" 6305 " , c(c) {}", 6306 Style); 6307 6308 Style.ConstructorInitializerIndentWidth = 2; 6309 verifyFormat("SomeClass::Constructor()\n" 6310 " : a(a)\n" 6311 " , b(b)\n" 6312 " , c(c) {}", 6313 Style); 6314 6315 Style.ConstructorInitializerIndentWidth = 0; 6316 verifyFormat("SomeClass::Constructor()\n" 6317 ": a(a)\n" 6318 ", b(b)\n" 6319 ", c(c) {}", 6320 Style); 6321} 6322 6323TEST_F(FormatTest, FormatsWithWebKitStyle) { 6324 FormatStyle Style = getWebKitStyle(); 6325 6326 // Don't indent in outer namespaces. 6327 verifyFormat("namespace outer {\n" 6328 "int i;\n" 6329 "namespace inner {\n" 6330 " int i;\n" 6331 "} // namespace inner\n" 6332 "} // namespace outer\n" 6333 "namespace other_outer {\n" 6334 "int i;\n" 6335 "}", 6336 Style); 6337 6338 // Don't indent case labels. 6339 verifyFormat("switch (variable) {\n" 6340 "case 1:\n" 6341 "case 2:\n" 6342 " doSomething();\n" 6343 " break;\n" 6344 "default:\n" 6345 " ++variable;\n" 6346 "}", 6347 Style); 6348 6349 // Wrap before binary operators. 6350 EXPECT_EQ( 6351 "void f()\n" 6352 "{\n" 6353 " if (aaaaaaaaaaaaaaaa\n" 6354 " && bbbbbbbbbbbbbbbbbbbbbbbb\n" 6355 " && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 6356 " return;\n" 6357 "}", 6358 format( 6359 "void f() {\n" 6360 "if (aaaaaaaaaaaaaaaa\n" 6361 "&& bbbbbbbbbbbbbbbbbbbbbbbb\n" 6362 "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n" 6363 "return;\n" 6364 "}", 6365 Style)); 6366 6367 // Constructor initializers are formatted one per line with the "," on the 6368 // new line. 6369 verifyFormat("Constructor()\n" 6370 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 6371 " , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n" 6372 " aaaaaaaaaaaaaa)\n" 6373 " , aaaaaaaaaaaaaaaaaaaaaaa()\n{\n}", 6374 Style); 6375 6376 // Access specifiers should be aligned left. 6377 verifyFormat("class C {\n" 6378 "public:\n" 6379 " int i;\n" 6380 "};", 6381 Style); 6382 6383 // Do not align comments. 6384 verifyFormat("int a; // Do not\n" 6385 "double b; // align comments.", 6386 Style); 6387 6388 // Accept input's line breaks. 6389 EXPECT_EQ("if (aaaaaaaaaaaaaaa\n" 6390 " || bbbbbbbbbbbbbbb) {\n" 6391 " i++;\n" 6392 "}", 6393 format("if (aaaaaaaaaaaaaaa\n" 6394 "|| bbbbbbbbbbbbbbb) { i++; }", 6395 Style)); 6396 EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n" 6397 " i++;\n" 6398 "}", 6399 format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style)); 6400} 6401 6402TEST_F(FormatTest, FormatsProtocolBufferDefinitions) { 6403 // It seems that clang-format can format protocol buffer definitions 6404 // (see https://code.google.com/p/protobuf/). 6405 verifyFormat("message SomeMessage {\n" 6406 " required int32 field1 = 1;\n" 6407 " optional string field2 = 2 [default = \"2\"]\n" 6408 "}"); 6409} 6410 6411TEST_F(FormatTest, FormatsLambdas) { 6412 verifyFormat("int c = [b]() mutable {\n" 6413 " return [&b] { return b++; }();\n" 6414 "}();\n"); 6415 verifyFormat("int c = [&] {\n" 6416 " [=] { return b++; }();\n" 6417 "}();\n"); 6418 verifyFormat("int c = [&, &a, a] {\n" 6419 " [=, c, &d] { return b++; }();\n" 6420 "}();\n"); 6421 verifyFormat("int c = [&a, &a, a] {\n" 6422 " [=, a, b, &c] { return b++; }();\n" 6423 "}();\n"); 6424 verifyFormat("auto c = { [&a, &a, a] {\n" 6425 " [=, a, b, &c] { return b++; }();\n" 6426 "} }\n"); 6427 verifyFormat("auto c = { [&a, &a, a] { [=, a, b, &c] {}(); } }\n"); 6428 verifyFormat("void f() {\n" 6429 " other(x.begin(), x.end(), [&](int, int) { return 1; });\n" 6430 "}\n"); 6431 verifyFormat("void f() {\n" 6432 " other(x.begin(), //\n" 6433 " x.end(), //\n" 6434 " [&](int, int) { return 1; });\n" 6435 "}\n"); 6436 6437 // Not lambdas. 6438 verifyFormat("constexpr char hello[]{ \"hello\" };"); 6439 verifyFormat("double &operator[](int i) { return 0; }\n" 6440 "int i;"); 6441} 6442 6443TEST_F(FormatTest, FormatsBlocks) { 6444 // FIXME: Make whitespace formatting consistent. Ask a ObjC dev how 6445 // it would ideally look. 6446 verifyFormat("[operation setCompletionBlock:^{ [self onOperationDone]; }];"); 6447 verifyFormat("int i = {[operation setCompletionBlock : ^{ [self " 6448 "onOperationDone]; }] };"); 6449} 6450 6451} // end namespace tooling 6452} // end namespace clang 6453