FormatTest.cpp revision 3499ddac3f075cbda6347067190fcc7a972dcaca
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 "../Tooling/RewriterTestContext.h" 14#include "clang/Lex/Lexer.h" 15#include "llvm/Support/Debug.h" 16#include "gtest/gtest.h" 17 18// Uncomment to get debug output from tests: 19// #define DEBUG_WITH_TYPE(T, X) do { X; } while(0) 20 21namespace clang { 22namespace format { 23 24class FormatTest : public ::testing::Test { 25protected: 26 std::string format(llvm::StringRef Code, unsigned Offset, unsigned Length, 27 const FormatStyle &Style) { 28 DEBUG(llvm::errs() << "---\n"); 29 RewriterTestContext Context; 30 FileID ID = Context.createInMemoryFile("input.cc", Code); 31 SourceLocation Start = 32 Context.Sources.getLocForStartOfFile(ID).getLocWithOffset(Offset); 33 std::vector<CharSourceRange> Ranges( 34 1, 35 CharSourceRange::getCharRange(Start, Start.getLocWithOffset(Length))); 36 Lexer Lex(ID, Context.Sources.getBuffer(ID), Context.Sources, 37 getFormattingLangOpts()); 38 tooling::Replacements Replace = reformat(Style, Lex, Context.Sources, 39 Ranges, 40 new IgnoringDiagConsumer()); 41 EXPECT_TRUE(applyAllReplacements(Replace, Context.Rewrite)); 42 DEBUG(llvm::errs() << "\n" << Context.getRewrittenText(ID) << "\n\n"); 43 return Context.getRewrittenText(ID); 44 } 45 46 std::string format(llvm::StringRef Code, 47 const FormatStyle &Style = getLLVMStyle()) { 48 return format(Code, 0, Code.size(), Style); 49 } 50 51 std::string messUp(llvm::StringRef Code) { 52 std::string MessedUp(Code.str()); 53 bool InComment = false; 54 bool InPreprocessorDirective = false; 55 bool JustReplacedNewline = false; 56 for (unsigned i = 0, e = MessedUp.size() - 1; i != e; ++i) { 57 if (MessedUp[i] == '/' && MessedUp[i + 1] == '/') { 58 if (JustReplacedNewline) 59 MessedUp[i - 1] = '\n'; 60 InComment = true; 61 } else if (MessedUp[i] == '#' && (JustReplacedNewline || i == 0)) { 62 if (i != 0) MessedUp[i - 1] = '\n'; 63 InPreprocessorDirective = true; 64 } else if (MessedUp[i] == '\\' && MessedUp[i + 1] == '\n') { 65 MessedUp[i] = ' '; 66 MessedUp[i + 1] = ' '; 67 } else if (MessedUp[i] == '\n') { 68 if (InComment) { 69 InComment = false; 70 } else if (InPreprocessorDirective) { 71 InPreprocessorDirective = false; 72 } else { 73 JustReplacedNewline = true; 74 MessedUp[i] = ' '; 75 } 76 } else if (MessedUp[i] != ' ') { 77 JustReplacedNewline = false; 78 } 79 } 80 return MessedUp; 81 } 82 83 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 84 FormatStyle Style = getLLVMStyle(); 85 Style.ColumnLimit = ColumnLimit; 86 return Style; 87 } 88 89 FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) { 90 FormatStyle Style = getGoogleStyle(); 91 Style.ColumnLimit = ColumnLimit; 92 return Style; 93 } 94 95 void verifyFormat(llvm::StringRef Code, 96 const FormatStyle &Style = getLLVMStyle()) { 97 EXPECT_EQ(Code.str(), format(messUp(Code), Style)); 98 } 99 100 void verifyGoogleFormat(llvm::StringRef Code) { 101 verifyFormat(Code, getGoogleStyle()); 102 } 103 104 void verifyIndependentOfContext(llvm::StringRef text) { 105 verifyFormat(text); 106 verifyFormat(llvm::Twine("void f() { " + text + " }").str()); 107 } 108}; 109 110TEST_F(FormatTest, MessUp) { 111 EXPECT_EQ("1 2 3", messUp("1 2 3")); 112 EXPECT_EQ("1 2 3\n", messUp("1\n2\n3\n")); 113 EXPECT_EQ("a\n//b\nc", messUp("a\n//b\nc")); 114 EXPECT_EQ("a\n#b\nc", messUp("a\n#b\nc")); 115 EXPECT_EQ("a\n#b c d\ne", messUp("a\n#b\\\nc\\\nd\ne")); 116} 117 118//===----------------------------------------------------------------------===// 119// Basic function tests. 120//===----------------------------------------------------------------------===// 121 122TEST_F(FormatTest, DoesNotChangeCorrectlyFormatedCode) { 123 EXPECT_EQ(";", format(";")); 124} 125 126TEST_F(FormatTest, FormatsGlobalStatementsAt0) { 127 EXPECT_EQ("int i;", format(" int i;")); 128 EXPECT_EQ("\nint i;", format(" \n\t \r int i;")); 129 EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); 130 EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); 131} 132 133TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { 134 EXPECT_EQ("int i;", format("int\ni;")); 135} 136 137TEST_F(FormatTest, FormatsNestedBlockStatements) { 138 EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}")); 139} 140 141TEST_F(FormatTest, FormatsNestedCall) { 142 verifyFormat("Method(f1, f2(f3));"); 143 verifyFormat("Method(f1(f2, f3()));"); 144 verifyFormat("Method(f1(f2, (f3())));"); 145} 146 147TEST_F(FormatTest, ImportantSpaces) { 148 verifyFormat("vector< ::Type> v;"); 149} 150 151//===----------------------------------------------------------------------===// 152// Tests for control statements. 153//===----------------------------------------------------------------------===// 154 155TEST_F(FormatTest, FormatIfWithoutCompountStatement) { 156 verifyFormat("if (true)\n f();\ng();"); 157 verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();"); 158 verifyFormat("if (a)\n if (b) {\n f();\n }\ng();"); 159 160 FormatStyle AllowsMergedIf = getGoogleStyle(); 161 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true; 162 verifyFormat("if (a)\n" 163 " // comment\n" 164 " f();", AllowsMergedIf); 165 166 verifyFormat("if (a) // Can't merge this\n" 167 " f();\n", AllowsMergedIf); 168 verifyFormat("if (a) /* still don't merge */\n" 169 " f();", AllowsMergedIf); 170 verifyFormat("if (a) { // Never merge this\n" 171 " f();\n" 172 "}", AllowsMergedIf); 173 verifyFormat("if (a) { /* Never merge this */\n" 174 " f();\n" 175 "}", AllowsMergedIf); 176 177 AllowsMergedIf.ColumnLimit = 14; 178 verifyFormat("if (a) return;", AllowsMergedIf); 179 verifyFormat("if (aaaaaaaaa)\n" 180 " return;", AllowsMergedIf); 181 182 AllowsMergedIf.ColumnLimit = 13; 183 verifyFormat("if (a)\n return;", AllowsMergedIf); 184} 185 186TEST_F(FormatTest, ParseIfElse) { 187 verifyFormat("if (true)\n" 188 " if (true)\n" 189 " if (true)\n" 190 " f();\n" 191 " else\n" 192 " g();\n" 193 " else\n" 194 " h();\n" 195 "else\n" 196 " i();"); 197 verifyFormat("if (true)\n" 198 " if (true)\n" 199 " if (true) {\n" 200 " if (true)\n" 201 " f();\n" 202 " } else {\n" 203 " g();\n" 204 " }\n" 205 " else\n" 206 " h();\n" 207 "else {\n" 208 " i();\n" 209 "}"); 210} 211 212TEST_F(FormatTest, ElseIf) { 213 verifyFormat("if (a) {\n} else if (b) {\n}"); 214 verifyFormat("if (a)\n" 215 " f();\n" 216 "else if (b)\n" 217 " g();\n" 218 "else\n" 219 " h();"); 220} 221 222TEST_F(FormatTest, FormatsForLoop) { 223 verifyFormat( 224 "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" 225 " ++VeryVeryLongLoopVariable)\n" 226 " ;"); 227 verifyFormat("for (;;)\n" 228 " f();"); 229 verifyFormat("for (;;) {\n}"); 230 verifyFormat("for (;;) {\n" 231 " f();\n" 232 "}"); 233 234 verifyFormat( 235 "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n" 236 " E = UnwrappedLines.end();\n" 237 " I != E; ++I) {\n}"); 238 239 verifyFormat( 240 "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" 241 " ++IIIII) {\n}"); 242} 243 244TEST_F(FormatTest, FormatsWhileLoop) { 245 verifyFormat("while (true) {\n}"); 246 verifyFormat("while (true)\n" 247 " f();"); 248 verifyFormat("while () {\n}"); 249 verifyFormat("while () {\n" 250 " f();\n" 251 "}"); 252} 253 254TEST_F(FormatTest, FormatsDoWhile) { 255 verifyFormat("do {\n" 256 " do_something();\n" 257 "} while (something());"); 258 verifyFormat("do\n" 259 " do_something();\n" 260 "while (something());"); 261} 262 263TEST_F(FormatTest, FormatsSwitchStatement) { 264 verifyFormat("switch (x) {\n" 265 "case 1:\n" 266 " f();\n" 267 " break;\n" 268 "case kFoo:\n" 269 "case ns::kBar:\n" 270 "case kBaz:\n" 271 " break;\n" 272 "default:\n" 273 " g();\n" 274 " break;\n" 275 "}"); 276 verifyFormat("switch (x) {\n" 277 "case 1: {\n" 278 " f();\n" 279 " break;\n" 280 "}\n" 281 "}"); 282 verifyFormat("switch (x) {\n" 283 "case 1: {\n" 284 " f();\n" 285 " {\n" 286 " g();\n" 287 " h();\n" 288 " }\n" 289 " break;\n" 290 "}\n" 291 "}"); 292 verifyFormat("switch (x) {\n" 293 "case 1: {\n" 294 " f();\n" 295 " if (foo) {\n" 296 " g();\n" 297 " h();\n" 298 " }\n" 299 " break;\n" 300 "}\n" 301 "}"); 302 verifyFormat("switch (x) {\n" 303 "case 1: {\n" 304 " f();\n" 305 " g();\n" 306 "} break;\n" 307 "}"); 308 verifyFormat("switch (test)\n" 309 " ;"); 310 verifyGoogleFormat("switch (x) {\n" 311 " case 1:\n" 312 " f();\n" 313 " break;\n" 314 " case kFoo:\n" 315 " case ns::kBar:\n" 316 " case kBaz:\n" 317 " break;\n" 318 " default:\n" 319 " g();\n" 320 " break;\n" 321 "}"); 322 verifyGoogleFormat("switch (x) {\n" 323 " case 1: {\n" 324 " f();\n" 325 " break;\n" 326 " }\n" 327 "}"); 328 verifyGoogleFormat("switch (test)\n" 329 " ;"); 330} 331 332TEST_F(FormatTest, FormatsLabels) { 333 verifyFormat("void f() {\n" 334 " some_code();\n" 335 "test_label:\n" 336 " some_other_code();\n" 337 " {\n" 338 " some_more_code();\n" 339 " another_label:\n" 340 " some_more_code();\n" 341 " }\n" 342 "}"); 343 verifyFormat("some_code();\n" 344 "test_label:\n" 345 "some_other_code();"); 346} 347 348//===----------------------------------------------------------------------===// 349// Tests for comments. 350//===----------------------------------------------------------------------===// 351 352TEST_F(FormatTest, UnderstandsSingleLineComments) { 353 verifyFormat("// line 1\n" 354 "// line 2\n" 355 "void f() {}\n"); 356 357 verifyFormat("void f() {\n" 358 " // Doesn't do anything\n" 359 "}"); 360 verifyFormat("void f(int i, // some comment (probably for i)\n" 361 " int j, // some comment (probably for j)\n" 362 " int k); // some comment (probably for k)"); 363 verifyFormat("void f(int i,\n" 364 " // some comment (probably for j)\n" 365 " int j,\n" 366 " // some comment (probably for k)\n" 367 " int k);"); 368 369 verifyFormat("int i // This is a fancy variable\n" 370 " = 5; // with nicely aligned comment."); 371 372 verifyFormat("// Leading comment.\n" 373 "int a; // Trailing comment."); 374 verifyFormat("int a; // Trailing comment\n" 375 " // on 2\n" 376 " // or 3 lines.\n" 377 "int b;"); 378 verifyFormat("int a; // Trailing comment\n" 379 "\n" 380 "// Leading comment.\n" 381 "int b;"); 382 verifyFormat("int a; // Comment.\n" 383 " // More details.\n" 384 "int bbbb; // Another comment."); 385 verifyFormat( 386 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; // comment\n" 387 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // comment\n" 388 "int cccccccccccccccccccccccccccccc; // comment\n" 389 "int ddd; // looooooooooooooooooooooooong comment\n" 390 "int aaaaaaaaaaaaaaaaaaaaaaa; // comment\n" 391 "int bbbbbbbbbbbbbbbbbbbbb; // comment\n" 392 "int ccccccccccccccccccc; // comment"); 393 394 verifyFormat("#include \"a\" // comment\n" 395 "#include \"a/b/c\" // comment"); 396 verifyFormat("#include <a> // comment\n" 397 "#include <a/b/c> // comment"); 398 399 verifyFormat("enum E {\n" 400 " // comment\n" 401 " VAL_A, // comment\n" 402 " VAL_B\n" 403 "};"); 404 405 verifyFormat( 406 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 407 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // Trailing comment"); 408 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 409 " // Comment inside a statement.\n" 410 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 411 412 EXPECT_EQ("void f() { // This does something ..\n" 413 "}\n" 414 "int a; // This is unrelated", 415 format("void f() { // This does something ..\n" 416 " }\n" 417 "int a; // This is unrelated")); 418 EXPECT_EQ("void f() { // This does something ..\n" 419 "} // awesome..\n" 420 "\n" 421 "int a; // This is unrelated", 422 format("void f() { // This does something ..\n" 423 " } // awesome..\n" 424 " \n" 425 "int a; // This is unrelated")); 426 427 EXPECT_EQ("int i; // single line trailing comment", 428 format("int i;\\\n// single line trailing comment")); 429 430 verifyGoogleFormat("int a; // Trailing comment."); 431} 432 433TEST_F(FormatTest, UnderstandsMultiLineComments) { 434 verifyFormat("f(/*test=*/ true);"); 435 EXPECT_EQ( 436 "f(aaaaaaaaaaaaaaaaaaaaaaaaa, /* Trailing comment for aa... */\n" 437 " bbbbbbbbbbbbbbbbbbbbbbbbb);", 438 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , /* Trailing comment for aa... */\n" 439 " bbbbbbbbbbbbbbbbbbbbbbbbb);")); 440 EXPECT_EQ( 441 "f(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 442 " /* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);", 443 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \n" 444 "/* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);")); 445} 446 447TEST_F(FormatTest, CommentsInStaticInitializers) { 448 EXPECT_EQ( 449 "static SomeType type = { aaaaaaaaaaaaaaaaaaaa, /* comment */\n" 450 " aaaaaaaaaaaaaaaaaaaa /* comment */,\n" 451 " /* comment */ aaaaaaaaaaaaaaaaaaaa,\n" 452 " aaaaaaaaaaaaaaaaaaaa, // comment\n" 453 " aaaaaaaaaaaaaaaaaaaa };", 454 format("static SomeType type = { aaaaaaaaaaaaaaaaaaaa , /* comment */\n" 455 " aaaaaaaaaaaaaaaaaaaa /* comment */ ,\n" 456 " /* comment */ aaaaaaaaaaaaaaaaaaaa ,\n" 457 " aaaaaaaaaaaaaaaaaaaa , // comment\n" 458 " aaaaaaaaaaaaaaaaaaaa };")); 459 verifyFormat("static SomeType type = { aaaaaaaaaaa, // comment for aa...\n" 460 " bbbbbbbbbbb, ccccccccccc };"); 461 verifyFormat("static SomeType type = { aaaaaaaaaaa,\n" 462 " // comment for bb....\n" 463 " bbbbbbbbbbb, ccccccccccc };"); 464 verifyGoogleFormat( 465 "static SomeType type = { aaaaaaaaaaa, // comment for aa...\n" 466 " bbbbbbbbbbb,\n" 467 " ccccccccccc };"); 468 verifyGoogleFormat("static SomeType type = { aaaaaaaaaaa,\n" 469 " // comment for bb....\n" 470 " bbbbbbbbbbb,\n" 471 " ccccccccccc };"); 472 473} 474 475//===----------------------------------------------------------------------===// 476// Tests for classes, namespaces, etc. 477//===----------------------------------------------------------------------===// 478 479TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { 480 verifyFormat("class A {\n};"); 481} 482 483TEST_F(FormatTest, UnderstandsAccessSpecifiers) { 484 verifyFormat("class A {\n" 485 "public:\n" 486 "protected:\n" 487 "private:\n" 488 " void f() {}\n" 489 "};"); 490 verifyGoogleFormat("class A {\n" 491 " public:\n" 492 " protected:\n" 493 " private:\n" 494 " void f() {}\n" 495 "};"); 496} 497 498TEST_F(FormatTest, FormatsDerivedClass) { 499 verifyFormat("class A : public B {\n};"); 500 verifyFormat("class A : public ::B {\n};"); 501} 502 503TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { 504 verifyFormat("class A {\n} a, b;"); 505 verifyFormat("struct A {\n} a, b;"); 506 verifyFormat("union A {\n} a;"); 507} 508 509TEST_F(FormatTest, FormatsEnum) { 510 verifyFormat("enum {\n" 511 " Zero,\n" 512 " One = 1,\n" 513 " Two = One + 1,\n" 514 " Three = (One + Two),\n" 515 " Four = (Zero && (One ^ Two)) | (One << Two),\n" 516 " Five = (One, Two, Three, Four, 5)\n" 517 "};"); 518 verifyFormat("enum Enum {\n" 519 "};"); 520 verifyFormat("enum {\n" 521 "};"); 522 verifyFormat("enum X E {\n} d;"); 523 verifyFormat("enum __attribute__((...)) E {\n} d;"); 524 verifyFormat("enum __declspec__((...)) E {\n} d;"); 525 verifyFormat("enum X f() {\n a();\n return 42;\n}"); 526} 527 528TEST_F(FormatTest, FormatsBitfields) { 529 verifyFormat("struct Bitfields {\n" 530 " unsigned sClass : 8;\n" 531 " unsigned ValueKind : 2;\n" 532 "};"); 533} 534 535TEST_F(FormatTest, FormatsNamespaces) { 536 verifyFormat("namespace some_namespace {\n" 537 "class A {\n};\n" 538 "void f() { f(); }\n" 539 "}"); 540 verifyFormat("namespace {\n" 541 "class A {\n};\n" 542 "void f() { f(); }\n" 543 "}"); 544 verifyFormat("inline namespace X {\n" 545 "class A {\n};\n" 546 "void f() { f(); }\n" 547 "}"); 548 verifyFormat("using namespace some_namespace;\n" 549 "class A {\n};\n" 550 "void f() { f(); }"); 551} 552 553TEST_F(FormatTest, FormatsExternC) { 554 verifyFormat("extern \"C\" {\nint a;"); 555} 556 557TEST_F(FormatTest, FormatTryCatch) { 558 // FIXME: Handle try-catch explicitly in the UnwrappedLineParser, then we'll 559 // also not create single-line-blocks. 560 verifyFormat("try {\n" 561 " throw a * b;\n" 562 "}\n" 563 "catch (int a) {\n" 564 " // Do nothing.\n" 565 "}\n" 566 "catch (...) {\n" 567 " exit(42);\n" 568 "}"); 569 570 // Function-level try statements. 571 verifyFormat("int f() try { return 4; }\n" 572 "catch (...) {\n" 573 " return 5;\n" 574 "}"); 575 verifyFormat("class A {\n" 576 " int a;\n" 577 " A() try : a(0) {}\n" 578 " catch (...) {\n" 579 " throw;\n" 580 " }\n" 581 "};\n"); 582} 583 584TEST_F(FormatTest, FormatObjCTryCatch) { 585 verifyFormat("@try {\n" 586 " f();\n" 587 "}\n" 588 "@catch (NSException e) {\n" 589 " @throw;\n" 590 "}\n" 591 "@finally {\n" 592 " exit(42);\n" 593 "}"); 594} 595 596TEST_F(FormatTest, StaticInitializers) { 597 verifyFormat("static SomeClass SC = { 1, 'a' };"); 598 599 // FIXME: Format like enums if the static initializer does not fit on a line. 600 verifyFormat( 601 "static SomeClass WithALoooooooooooooooooooongName = {\n" 602 " 100000000, \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 603 "};"); 604 605 verifyFormat( 606 "static SomeClass = { a, b, c, d, e, f, g, h, i, j,\n" 607 " looooooooooooooooooooooooooooooooooongname,\n" 608 " looooooooooooooooooooooooooooooong };"); 609} 610 611TEST_F(FormatTest, NestedStaticInitializers) { 612 verifyFormat("static A x = { { {} } };\n"); 613 verifyFormat( 614 "static A x = { { { init1, init2, init3, init4 },\n" 615 " { init1, init2, init3, init4 } } };"); 616 617 // FIXME: Fix this in general and verify that it works in LLVM style again. 618 verifyGoogleFormat( 619 "somes Status::global_reps[3] = {\n" 620 " { kGlobalRef, OK_CODE, NULL, NULL, NULL },\n" 621 " { kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL },\n" 622 " { kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL }\n" 623 "};"); 624 verifyFormat( 625 "CGRect cg_rect = { { rect.fLeft, rect.fTop },\n" 626 " { rect.fRight - rect.fLeft, rect.fBottom - rect.fTop" 627 " } };"); 628 629 // FIXME: We might at some point want to handle this similar to parameter 630 // lists, where we have an option to put each on a single line. 631 verifyFormat("struct {\n" 632 " unsigned bit;\n" 633 " const char *const name;\n" 634 "} kBitsToOs[] = { { kOsMac, \"Mac\" }, { kOsWin, \"Windows\" },\n" 635 " { kOsLinux, \"Linux\" }, { kOsCrOS, \"Chrome OS\" } };"); 636} 637 638TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { 639 verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 640 " \\\n" 641 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); 642} 643 644TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { 645 verifyFormat("virtual void write(ELFWriter *writerrr,\n" 646 " OwningPtr<FileOutputBuffer> &buffer) = 0;"); 647} 648 649TEST_F(FormatTest, BreaksOnHashWhenDirectiveIsInvalid) { 650 EXPECT_EQ("#\n;", format("#;")); 651 verifyFormat("#\n;\n;\n;"); 652} 653 654TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { 655 EXPECT_EQ("#line 42 \"test\"\n", 656 format("# \\\n line \\\n 42 \\\n \"test\"\n")); 657 EXPECT_EQ("#define A B\n", 658 format("# \\\n define \\\n A \\\n B\n", 659 getLLVMStyleWithColumns(12))); 660} 661 662TEST_F(FormatTest, EndOfFileEndsPPDirective) { 663 EXPECT_EQ("#line 42 \"test\"", 664 format("# \\\n line \\\n 42 \\\n \"test\"")); 665 EXPECT_EQ("#define A B", 666 format("# \\\n define \\\n A \\\n B")); 667} 668 669TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { 670 // If the macro fits in one line, we still do not get the full 671 // line, as only the next line decides whether we need an escaped newline and 672 // thus use the last column. 673 verifyFormat("#define A(B)", getLLVMStyleWithColumns(13)); 674 675 verifyFormat("#define A( \\\n B)", getLLVMStyleWithColumns(12)); 676 verifyFormat("#define AA(\\\n B)", getLLVMStyleWithColumns(12)); 677 verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); 678 679 verifyFormat("#define A A\n#define A A"); 680 verifyFormat("#define A(X) A\n#define A A"); 681 682 verifyFormat("#define Something Other", getLLVMStyleWithColumns(24)); 683 verifyFormat("#define Something \\\n" 684 " Other", getLLVMStyleWithColumns(23)); 685} 686 687TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { 688 EXPECT_EQ("// some comment\n" 689 "#include \"a.h\"\n" 690 "#define A(A,\\\n" 691 " B)\n" 692 "#include \"b.h\"\n" 693 "// some comment\n", 694 format(" // some comment\n" 695 " #include \"a.h\"\n" 696 "#define A(A,\\\n" 697 " B)\n" 698 " #include \"b.h\"\n" 699 " // some comment\n", getLLVMStyleWithColumns(13))); 700} 701 702TEST_F(FormatTest, LayoutSingleHash) { 703 EXPECT_EQ("#\na;", format("#\na;")); 704} 705 706TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { 707 EXPECT_EQ("#define A \\\n" 708 " c; \\\n" 709 " e;\n" 710 "f;", format("#define A c; e;\n" 711 "f;", getLLVMStyleWithColumns(14))); 712} 713 714TEST_F(FormatTest, LayoutRemainingTokens) { 715 EXPECT_EQ("{}", format("{}")); 716} 717 718TEST_F(FormatTest, LayoutSingleUnwrappedLineInMacro) { 719 EXPECT_EQ("# define A\\\n b;", 720 format("# define A b;", 11, 2, getLLVMStyleWithColumns(11))); 721} 722 723TEST_F(FormatTest, MacroDefinitionInsideStatement) { 724 EXPECT_EQ("int x,\n" 725 "#define A\n" 726 " y;", format("int x,\n#define A\ny;")); 727} 728 729TEST_F(FormatTest, HashInMacroDefinition) { 730 verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); 731 verifyFormat("#define A \\\n" 732 " { \\\n" 733 " f(#c);\\\n" 734 " }", getLLVMStyleWithColumns(11)); 735 736 verifyFormat("#define A(X) \\\n" 737 " void function##X()", getLLVMStyleWithColumns(22)); 738 739 verifyFormat("#define A(a, b, c) \\\n" 740 " void a##b##c()", getLLVMStyleWithColumns(22)); 741 742 verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); 743} 744 745TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { 746 verifyFormat("#define A (1)"); 747} 748 749TEST_F(FormatTest, IndentPreprocessorDirectivesAtZero) { 750 EXPECT_EQ("{\n {\n#define A\n }\n}", format("{{\n#define A\n}}")); 751} 752 753TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { 754 verifyFormat("{\n { a #c; }\n}"); 755} 756 757TEST_F(FormatTest, FormatUnbalancedStructuralElements) { 758 EXPECT_EQ("#define A \\\n { \\\n {\nint i;", 759 format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); 760 EXPECT_EQ("#define A \\\n } \\\n }\nint i;", 761 format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); 762} 763 764TEST_F(FormatTest, EscapedNewlineAtStartOfTokenInMacroDefinition) { 765 EXPECT_EQ( 766 "#define A \\\n int i; \\\n int j;", 767 format("#define A \\\nint i;\\\n int j;", getLLVMStyleWithColumns(11))); 768} 769 770TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { 771 verifyFormat("#define A \\\n" 772 " int v( \\\n" 773 " a); \\\n" 774 " int i;", getLLVMStyleWithColumns(11)); 775} 776 777TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { 778 EXPECT_EQ( 779 "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" 780 " \\\n" 781 " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 782 "\n" 783 "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 784 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", 785 format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" 786 "\\\n" 787 "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" 788 " \n" 789 " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" 790 " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); 791} 792 793TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { 794 EXPECT_EQ("int\n" 795 "#define A\n" 796 " a;", 797 format("int\n#define A\na;")); 798 verifyFormat( 799 "functionCallTo(someOtherFunction(\n" 800 " withSomeParameters, whichInSequence,\n" 801 " areLongerThanALine(andAnotherCall,\n" 802 "#define A B\n" 803 " withMoreParamters,\n" 804 " whichStronglyInfluenceTheLayout),\n" 805 " andMoreParameters), trailing);", getLLVMStyleWithColumns(69)); 806} 807 808TEST_F(FormatTest, LayoutBlockInsideParens) { 809 EXPECT_EQ("functionCall({\n" 810 " int i;\n" 811 "});", format(" functionCall ( {int i;} );")); 812} 813 814TEST_F(FormatTest, LayoutBlockInsideStatement) { 815 EXPECT_EQ("SOME_MACRO { int i; }\n" 816 "int i;", format(" SOME_MACRO {int i;} int i;")); 817} 818 819TEST_F(FormatTest, LayoutNestedBlocks) { 820 verifyFormat("void AddOsStrings(unsigned bitmask) {\n" 821 " struct s {\n" 822 " int i;\n" 823 " };\n" 824 " s kBitsToOs[] = { { 10 } };\n" 825 " for (int i = 0; i < 10; ++i)\n" 826 " return;\n" 827 "}"); 828} 829 830TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { 831 EXPECT_EQ("{}", format("{}")); 832 833 // Negative test for enum. 834 verifyFormat("enum E {\n};"); 835 836 // Note that when there's a missing ';', we still join... 837 verifyFormat("enum E {}"); 838} 839 840//===----------------------------------------------------------------------===// 841// Line break tests. 842//===----------------------------------------------------------------------===// 843 844TEST_F(FormatTest, FormatsFunctionDefinition) { 845 verifyFormat("void f(int a, int b, int c, int d, int e, int f, int g," 846 " int h, int j, int f,\n" 847 " int c, int ddddddddddddd) {\n}"); 848} 849 850TEST_F(FormatTest, FormatsAwesomeMethodCall) { 851 verifyFormat( 852 "SomeLongMethodName(SomeReallyLongMethod(\n" 853 " CallOtherReallyLongMethod(parameter, parameter, parameter)),\n" 854 " SecondLongCall(parameter));"); 855} 856 857TEST_F(FormatTest, ConstructorInitializers) { 858 verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); 859 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", 860 getLLVMStyleWithColumns(45)); 861 verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {\n}", 862 getLLVMStyleWithColumns(44)); 863 verifyFormat("Constructor()\n" 864 " : Inttializer(FitsOnTheLine) {\n}", 865 getLLVMStyleWithColumns(43)); 866 867 verifyFormat( 868 "SomeClass::Constructor()\n" 869 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {\n}"); 870 871 verifyFormat( 872 "SomeClass::Constructor()\n" 873 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 874 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {\n}"); 875 verifyGoogleFormat( 876 "SomeClass::Constructor()\n" 877 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 878 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 879 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {\n}"); 880 verifyGoogleFormat( 881 "SomeClass::Constructor()\n" 882 " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" 883 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" 884 " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {\n}"); 885 886 verifyFormat( 887 "SomeClass::Constructor()\n" 888 " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 889 " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {\n}"); 890 891 verifyFormat("Constructor()\n" 892 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 893 " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 894 " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" 895 " aaaaaaaaaaaaaaaaaaaaaaa() {\n}"); 896 897 // Here a line could be saved by splitting the second initializer onto two 898 // lines, but that is not desireable. 899 verifyFormat( 900 "Constructor()\n" 901 " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" 902 " aaaaaaaaaaa(aaaaaaaaaaa),\n" 903 " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 904 905 verifyGoogleFormat("MyClass::MyClass(int var)\n" 906 " : some_var_(var), // 4 space indent\n" 907 " some_other_var_(var + 1) { // lined up\n" 908 "}"); 909 910 // This test takes VERY long when memoization is broken. 911 std::string input = "Constructor()\n" 912 " : aaaa(a,\n"; 913 for (unsigned i = 0, e = 80; i != e; ++i) { 914 input += " a,\n"; 915 } 916 input += " a) {\n}"; 917 verifyGoogleFormat(input); 918} 919 920TEST_F(FormatTest, BreaksAsHighAsPossible) { 921 verifyFormat( 922 "if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" 923 " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" 924 " f();"); 925} 926 927TEST_F(FormatTest, BreaksDesireably) { 928 verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 929 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" 930 " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); 931 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 932 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" 933 "}"); 934 935 verifyFormat( 936 "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 937 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 938 939 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 940 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 941 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 942 943 verifyFormat( 944 "aaaaaaaa(aaaaaaaaaaaaa, aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 945 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 946 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 947 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 948 949 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 950 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 951 952 verifyFormat( 953 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 954 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 955 verifyFormat( 956 "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 957 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 958 verifyFormat( 959 "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 960 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); 961 962 // This test case breaks on an incorrect memoization, i.e. an optimization not 963 // taking into account the StopAt value. 964 verifyFormat( 965 "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 966 " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 967 " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" 968 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 969 970 verifyFormat("{\n {\n {\n" 971 " Annotation.SpaceRequiredBefore =\n" 972 " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" 973 " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" 974 " }\n }\n}"); 975} 976 977TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 978 verifyGoogleFormat( 979 "aaaaaaaa(aaaaaaaaaaaaa,\n" 980 " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 981 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" 982 " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 983 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); 984 verifyGoogleFormat( 985 "aaaaaaaaaaaaaaa(\n" 986 " aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa).aaaaaaaaaaaaaaaaaa();"); 987 verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 988 " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);"); 989 990 verifyGoogleFormat( 991 "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 992 " aaaaaaaaaaaa,\n" 993 " aaaaaaaaaaaa);"); 994 verifyGoogleFormat( 995 "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" 996 " ddddddddddddddddddddddddddddd),\n" 997 " test);"); 998 999 verifyGoogleFormat( 1000 "std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n" 1001 " aaaaaaaaaaaaaaaaaaaaaaa,\n" 1002 " aaaaaaaaaaaaaaaaaaaaaaa> aaaaaaaaaaaaaaaaaa;"); 1003 verifyGoogleFormat("a(\"a\"\n" 1004 " \"a\",\n" 1005 " a);"); 1006 1007 FormatStyle Style = getGoogleStyle(); 1008 Style.AllowAllParametersOnNextLine = false; 1009 verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa,\n" 1010 " aaaaaaaaa,\n" 1011 " aaaaaaaaaaaaaaaaaaaaa).aaaaaaaaaaaaaaaaaa();", 1012 Style); 1013} 1014 1015TEST_F(FormatTest, FormatsBuilderPattern) { 1016 verifyFormat( 1017 "return llvm::StringSwitch<Reference::Kind>(name)\n" 1018 " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" 1019 " .StartsWith(\".eh_frame\", ORDER_EH_FRAME).StartsWith(\".init\", ORDER_INIT)\n" 1020 " .StartsWith(\".fini\", ORDER_FINI).StartsWith(\".hash\", ORDER_HASH)\n" 1021 " .Default(ORDER_TEXT);\n"); 1022} 1023 1024TEST_F(FormatTest, DoesNotBreakTrailingAnnotation) { 1025 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 1026 " GUARDED_BY(aaaaaaaaaaaaa);"); 1027 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 1028 " GUARDED_BY(aaaaaaaaaaaaa);"); 1029 verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" 1030 " GUARDED_BY(aaaaaaaaaaaaa) {\n}"); 1031} 1032 1033TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { 1034 verifyFormat( 1035 "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 1036 " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); 1037 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 1038 " ccccccccccccccccccccccccc) {\n}"); 1039 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" 1040 " ccccccccccccccccccccccccc) {\n}"); 1041 verifyFormat( 1042 "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" 1043 " ccccccccccccccccccccccccc) {\n}"); 1044} 1045 1046TEST_F(FormatTest, BreaksAfterAssignments) { 1047 verifyFormat( 1048 "unsigned Cost =\n" 1049 " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" 1050 " SI->getPointerAddressSpaceee());\n"); 1051 verifyFormat( 1052 "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" 1053 " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); 1054 1055 verifyFormat( 1056 "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa()\n" 1057 " .aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); 1058} 1059 1060TEST_F(FormatTest, AlignsAfterAssignments) { 1061 verifyFormat( 1062 "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 1063 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 1064 verifyFormat( 1065 "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 1066 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 1067 verifyFormat( 1068 "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 1069 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 1070 verifyFormat( 1071 "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 1072 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 1073 verifyFormat( 1074 "double LooooooooooooooooooooooooongResult =\n" 1075 " aaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaa +\n" 1076 " aaaaaaaaaaaaaaaaaaaaaaaa;"); 1077} 1078 1079TEST_F(FormatTest, AlignsAfterReturn) { 1080 verifyFormat( 1081 "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 1082 " aaaaaaaaaaaaaaaaaaaaaaaaa;"); 1083 verifyFormat( 1084 "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" 1085 " aaaaaaaaaaaaaaaaaaaaaaaaa);"); 1086} 1087 1088TEST_F(FormatTest, BreaksConditionalExpressions) { 1089 verifyFormat( 1090 "aaaa(aaaaaaaaaaaaaaaaaaaa,\n" 1091 " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" 1092 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 1093 verifyFormat("aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" 1094 " aaaaaaaaaaaaaaaaaaaaaaa : aaaaaaaaaaaaaaaaaaaaa);"); 1095 verifyFormat( 1096 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" 1097 " aaaaaaaaaaaaa);"); 1098} 1099 1100TEST_F(FormatTest, ConditionalExpressionsInBrackets) { 1101 verifyFormat("arr[foo ? bar : baz];"); 1102 verifyFormat("f()[foo ? bar : baz];"); 1103 verifyFormat("(a + b)[foo ? bar : baz];"); 1104 verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); 1105} 1106 1107TEST_F(FormatTest, AlignsStringLiterals) { 1108 verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" 1109 " \"short literal\");"); 1110 verifyFormat( 1111 "looooooooooooooooooooooooongFunction(\n" 1112 " \"short literal\"\n" 1113 " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); 1114} 1115 1116TEST_F(FormatTest, AlignsPipes) { 1117 verifyFormat( 1118 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 1119 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 1120 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 1121 verifyFormat( 1122 "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" 1123 " << aaaaaaaaaaaaaaaaaaaa;"); 1124 verifyFormat( 1125 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 1126 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 1127 verifyFormat( 1128 "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" 1129 " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" 1130 " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); 1131 verifyFormat( 1132 "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 1133 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" 1134 " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 1135} 1136 1137TEST_F(FormatTest, UnderstandsEquals) { 1138 verifyFormat( 1139 "aaaaaaaaaaaaaaaaa =\n" 1140 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 1141 verifyFormat( 1142 "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 1143 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 1144 verifyFormat( 1145 "if (a) {\n" 1146 " f();\n" 1147 "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 1148 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" 1149 "}"); 1150 1151 verifyFormat( 1152 "if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 1153 " 100000000 + 10000000) {\n}"); 1154} 1155 1156TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { 1157 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 1158 " .looooooooooooooooooooooooooooooooooooooongFunction();"); 1159 1160 verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" 1161 " ->looooooooooooooooooooooooooooooooooooooongFunction();"); 1162 1163 verifyFormat( 1164 "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" 1165 " Parameter2);"); 1166 1167 verifyFormat( 1168 "ShortObject->shortFunction(\n" 1169 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" 1170 " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); 1171 1172 verifyFormat("loooooooooooooongFunction(\n" 1173 " LoooooooooooooongObject->looooooooooooooooongFunction());"); 1174 1175 verifyFormat( 1176 "function(LoooooooooooooooooooooooooooooooooooongObject\n" 1177 " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); 1178 1179 // Here, it is not necessary to wrap at "." or "->". 1180 verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" 1181 " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); 1182 verifyFormat( 1183 "aaaaaaaaaaa->aaaaaaaaa(\n" 1184 " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 1185 " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); 1186} 1187 1188TEST_F(FormatTest, WrapsTemplateDeclarations) { 1189 verifyFormat("template <typename T>\n" 1190 "virtual void loooooooooooongFunction(int Param1, int Param2);"); 1191 verifyFormat( 1192 "template <typename T>\n" 1193 "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" 1194 " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); 1195 verifyFormat( 1196 "template <typename T>\n" 1197 "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" 1198 " int Paaaaaaaaaaaaaaaaaaaaram2);"); 1199 verifyFormat( 1200 "template <typename T>\n" 1201 "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" 1202 " aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n" 1203 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 1204 verifyFormat("template <typename T>\n" 1205 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 1206 " int aaaaaaaaaaaaaaaaa);"); 1207 verifyFormat( 1208 "template <typename T1, typename T2 = char, typename T3 = char,\n" 1209 " typename T4 = char>\n" 1210 "void f();"); 1211 verifyFormat( 1212 "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n" 1213 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 1214} 1215 1216TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) { 1217 verifyFormat( 1218 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 1219 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 1220 verifyFormat( 1221 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 1222 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 1223 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); 1224 1225 // FIXME: Should we have an extra indent after the second break? 1226 verifyFormat( 1227 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 1228 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n" 1229 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 1230 1231 // FIXME: Look into whether we should indent 4 from the start or 4 from 1232 // "bbbbb..." here instead of what we are doing now. 1233 verifyFormat( 1234 "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n" 1235 " cccccccccccccccccccccccccccccccccccccccccccccccccc());"); 1236 1237 // Breaking at nested name specifiers is generally not desirable. 1238 verifyFormat( 1239 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 1240 " aaaaaaaaaaaaaaaaaaaaaaa);"); 1241} 1242 1243TEST_F(FormatTest, UnderstandsTemplateParameters) { 1244 verifyFormat("A<int> a;"); 1245 verifyFormat("A<A<A<int> > > a;"); 1246 verifyFormat("A<A<A<int, 2>, 3>, 4> a;"); 1247 verifyFormat("bool x = a < 1 || 2 > a;"); 1248 verifyFormat("bool x = 5 < f<int>();"); 1249 verifyFormat("bool x = f<int>() > 5;"); 1250 verifyFormat("bool x = 5 < a<int>::x;"); 1251 verifyFormat("bool x = a < 4 ? a > 2 : false;"); 1252 verifyFormat("bool x = f() ? a < 2 : a > 2;"); 1253 1254 verifyGoogleFormat("A<A<int>> a;"); 1255 verifyGoogleFormat("A<A<A<int>>> a;"); 1256 verifyGoogleFormat("A<A<A<A<int>>>> a;"); 1257 1258 verifyFormat("test >> a >> b;"); 1259 verifyFormat("test << a >> b;"); 1260 1261 verifyFormat("f<int>();"); 1262 verifyFormat("template <typename T> void f() {}"); 1263} 1264 1265TEST_F(FormatTest, UnderstandsUnaryOperators) { 1266 verifyFormat("int a = -2;"); 1267 verifyFormat("f(-1, -2, -3);"); 1268 verifyFormat("a[-1] = 5;"); 1269 verifyFormat("int a = 5 + -2;"); 1270 verifyFormat("if (i == -1) {\n}"); 1271 verifyFormat("if (i != -1) {\n}"); 1272 verifyFormat("if (i > -1) {\n}"); 1273 verifyFormat("if (i < -1) {\n}"); 1274 verifyFormat("++(a->f());"); 1275 verifyFormat("--(a->f());"); 1276 verifyFormat("(a->f())++;"); 1277 verifyFormat("a[42]++;"); 1278 verifyFormat("if (!(a->f())) {\n}"); 1279 1280 verifyFormat("a-- > b;"); 1281 verifyFormat("b ? -a : c;"); 1282 verifyFormat("n * sizeof char16;"); 1283 verifyFormat("n * alignof char16;"); 1284 verifyFormat("sizeof(char);"); 1285 verifyFormat("alignof(char);"); 1286 1287 verifyFormat("return -1;"); 1288 verifyFormat("switch (a) {\n" 1289 "case -1:\n" 1290 " break;\n" 1291 "}"); 1292 1293 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = { -5, +3 };"); 1294 verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = { +5, -3 };"); 1295 1296 verifyFormat("int a = /* confusing comment */ -1;"); 1297 // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case. 1298 verifyFormat("int a = i /* confusing comment */++;"); 1299} 1300 1301TEST_F(FormatTest, UndestandsOverloadedOperators) { 1302 verifyFormat("bool operator<();"); 1303 verifyFormat("bool operator>();"); 1304 verifyFormat("bool operator=();"); 1305 verifyFormat("bool operator==();"); 1306 verifyFormat("bool operator!=();"); 1307 verifyFormat("int operator+();"); 1308 verifyFormat("int operator++();"); 1309 verifyFormat("bool operator();"); 1310 verifyFormat("bool operator()();"); 1311 verifyFormat("bool operator[]();"); 1312 verifyFormat("operator bool();"); 1313 verifyFormat("operator SomeType<int>();"); 1314 verifyFormat("void *operator new(std::size_t size);"); 1315 verifyFormat("void *operator new[](std::size_t size);"); 1316 verifyFormat("void operator delete(void *ptr);"); 1317 verifyFormat("void operator delete[](void *ptr);"); 1318} 1319 1320TEST_F(FormatTest, UnderstandsNewAndDelete) { 1321 verifyFormat("A *a = new A;"); 1322 verifyFormat("A *a = new (placement) A;"); 1323 verifyFormat("delete a;"); 1324 verifyFormat("delete (A *)a;"); 1325} 1326 1327TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) { 1328 verifyFormat("int *f(int *a) {}"); 1329 verifyFormat("int main(int argc, char **argv) {}"); 1330 verifyIndependentOfContext("f(a, *a);"); 1331 verifyIndependentOfContext("f(*a);"); 1332 verifyIndependentOfContext("int a = b * 10;"); 1333 verifyIndependentOfContext("int a = 10 * b;"); 1334 verifyIndependentOfContext("int a = b * c;"); 1335 verifyIndependentOfContext("int a += b * c;"); 1336 verifyIndependentOfContext("int a -= b * c;"); 1337 verifyIndependentOfContext("int a *= b * c;"); 1338 verifyIndependentOfContext("int a /= b * c;"); 1339 verifyIndependentOfContext("int a = *b;"); 1340 verifyIndependentOfContext("int a = *b * c;"); 1341 verifyIndependentOfContext("int a = b * *c;"); 1342 verifyIndependentOfContext("return 10 * b;"); 1343 verifyIndependentOfContext("return *b * *c;"); 1344 verifyIndependentOfContext("return a & ~b;"); 1345 verifyIndependentOfContext("f(b ? *c : *d);"); 1346 verifyIndependentOfContext("int a = b ? *c : *d;"); 1347 verifyIndependentOfContext("*b = a;"); 1348 verifyIndependentOfContext("a * ~b;"); 1349 verifyIndependentOfContext("a * !b;"); 1350 verifyIndependentOfContext("a * +b;"); 1351 verifyIndependentOfContext("a * -b;"); 1352 verifyIndependentOfContext("a * ++b;"); 1353 verifyIndependentOfContext("a * --b;"); 1354 verifyIndependentOfContext("a[4] * b;"); 1355 verifyIndependentOfContext("f() * b;"); 1356 verifyIndependentOfContext("a * [self dostuff];"); 1357 verifyIndependentOfContext("a * (a + b);"); 1358 verifyIndependentOfContext("(a *)(a + b);"); 1359 verifyIndependentOfContext("int *pa = (int *)&a;"); 1360 1361 verifyIndependentOfContext("InvalidRegions[*R] = 0;"); 1362 1363 verifyIndependentOfContext("A<int *> a;"); 1364 verifyIndependentOfContext("A<int **> a;"); 1365 verifyIndependentOfContext("A<int *, int *> a;"); 1366 verifyIndependentOfContext("A<int **, int **> a;"); 1367 1368 verifyFormat( 1369 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 1370 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 1371 1372 verifyGoogleFormat("int main(int argc, char** argv) {}"); 1373 verifyGoogleFormat("A<int*> a;"); 1374 verifyGoogleFormat("A<int**> a;"); 1375 verifyGoogleFormat("A<int*, int*> a;"); 1376 verifyGoogleFormat("A<int**, int**> a;"); 1377 verifyGoogleFormat("f(b ? *c : *d);"); 1378 verifyGoogleFormat("int a = b ? *c : *d;"); 1379 verifyGoogleFormat("Type* t = **x;"); 1380 verifyGoogleFormat("Type* t = *++*x;"); 1381 verifyGoogleFormat("*++*x;"); 1382 verifyGoogleFormat("Type* t = const_cast<T*>(&*x);"); 1383 verifyGoogleFormat("Type* t = x++ * y;"); 1384 1385 verifyIndependentOfContext("a = *(x + y);"); 1386 verifyIndependentOfContext("a = &(x + y);"); 1387 verifyIndependentOfContext("*(x + y).call();"); 1388 verifyIndependentOfContext("&(x + y)->call();"); 1389 verifyIndependentOfContext("&(*I).first"); 1390 1391 verifyIndependentOfContext("f(b * /* confusing comment */ ++c);"); 1392 verifyFormat( 1393 "int *MyValues = {\n" 1394 " *A, // Operator detection might be confused by the '{'\n" 1395 " *BB // Operator detection might be confused by previous comment\n" 1396 "};"); 1397 1398 verifyIndependentOfContext("if (int *a = &b)"); 1399 verifyIndependentOfContext("if (int &a = *b)"); 1400 verifyIndependentOfContext("if (a & b[i])"); 1401 verifyIndependentOfContext("if (a::b::c::d & b[i])"); 1402 verifyIndependentOfContext("if (*b[i])"); 1403 verifyIndependentOfContext("if (int *a = (&b))"); 1404 verifyIndependentOfContext("while (int *a = &b)"); 1405 verifyFormat("void f() {\n" 1406 " for (const int &v : Values) {\n" 1407 " }\n" 1408 "}"); 1409 1410 verifyIndependentOfContext("A = new SomeType *[Length]();"); 1411 verifyGoogleFormat("A = new SomeType* [Length]();"); 1412} 1413 1414TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) { 1415 verifyFormat("void f() {\n" 1416 " x[aaaaaaaaa -\n" 1417 " b] = 23;\n" 1418 "}", getLLVMStyleWithColumns(15)); 1419} 1420 1421TEST_F(FormatTest, FormatsCasts) { 1422 verifyFormat("Type *A = static_cast<Type *>(P);"); 1423 verifyFormat("Type *A = (Type *)P;"); 1424 verifyFormat("Type *A = (vector<Type *, int *>)P;"); 1425 verifyFormat("int a = (int)(2.0f);"); 1426 1427 // FIXME: These also need to be identified. 1428 verifyFormat("int a = (int) 2.0f;"); 1429 verifyFormat("int a = (int) * b;"); 1430 1431 // These are not casts. 1432 verifyFormat("void f(int *) {}"); 1433 verifyFormat("void f(int *);"); 1434 verifyFormat("void f(int *) = 0;"); 1435 verifyFormat("void f(SmallVector<int>) {}"); 1436 verifyFormat("void f(SmallVector<int>);"); 1437 verifyFormat("void f(SmallVector<int>) = 0;"); 1438} 1439 1440TEST_F(FormatTest, FormatsFunctionTypes) { 1441 // FIXME: Determine the cases that need a space after the return type and fix. 1442 verifyFormat("A<bool()> a;"); 1443 verifyFormat("A<SomeType()> a;"); 1444 verifyFormat("A<void(*)(int, std::string)> a;"); 1445 1446 verifyFormat("int(*func)(void *);"); 1447} 1448 1449TEST_F(FormatTest, DoesNotBreakBeforePointerOrReference) { 1450 verifyFormat("int *someFunction(int LoooooooooooooooongParam1,\n" 1451 " int LoooooooooooooooongParam2) {\n}"); 1452 verifyFormat( 1453 "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n" 1454 " SourceLocation L, IdentifierIn *II,\n" 1455 " Type *T) {\n}"); 1456} 1457 1458TEST_F(FormatTest, LineStartsWithSpecialCharacter) { 1459 verifyFormat("(a)->b();"); 1460 verifyFormat("--a;"); 1461} 1462 1463TEST_F(FormatTest, HandlesIncludeDirectives) { 1464 verifyFormat("#include <string>\n" 1465 "#include <a/b/c.h>\n" 1466 "#include \"a/b/string\"\n" 1467 "#include \"string.h\"\n" 1468 "#include \"string.h\"\n" 1469 "#include <a-a>\n" 1470 "#include < path with space >\n"); 1471 1472 verifyFormat("#import <string>"); 1473 verifyFormat("#import <a/b/c.h>"); 1474 verifyFormat("#import \"a/b/string\""); 1475 verifyFormat("#import \"string.h\""); 1476 verifyFormat("#import \"string.h\""); 1477} 1478 1479//===----------------------------------------------------------------------===// 1480// Error recovery tests. 1481//===----------------------------------------------------------------------===// 1482 1483TEST_F(FormatTest, IncorrectCodeTrailingStuff) { 1484 verifyFormat("void f() { return; }\n42"); 1485 verifyFormat("void f() {\n" 1486 " if (0)\n" 1487 " return;\n" 1488 "}\n" 1489 "42"); 1490 verifyFormat("void f() { return }\n42"); 1491 verifyFormat("void f() {\n" 1492 " if (0)\n" 1493 " return\n" 1494 "}\n" 1495 "42"); 1496} 1497 1498TEST_F(FormatTest, IncorrectCodeMissingSemicolon) { 1499 EXPECT_EQ("void f() { return }", format("void f ( ) { return }")); 1500 EXPECT_EQ("void f() {\n" 1501 " if (a)\n" 1502 " return\n" 1503 "}", format("void f ( ) { if ( a ) return }")); 1504 EXPECT_EQ("namespace N { void f() }", format("namespace N { void f() }")); 1505 EXPECT_EQ("namespace N {\n" 1506 "void f() {}\n" 1507 "void g()\n" 1508 "}", format("namespace N { void f( ) { } void g( ) }")); 1509} 1510 1511TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) { 1512 verifyFormat("int aaaaaaaa =\n" 1513 " // Overly long comment\n" 1514 " b;", getLLVMStyleWithColumns(20)); 1515 verifyFormat("function(\n" 1516 " ShortArgument,\n" 1517 " LoooooooooooongArgument);\n", getLLVMStyleWithColumns(20)); 1518} 1519 1520TEST_F(FormatTest, IncorrectAccessSpecifier) { 1521 verifyFormat("public:"); 1522 verifyFormat("class A {\n" 1523 "public\n" 1524 " void f() {}\n" 1525 "};"); 1526 verifyFormat("public\n" 1527 "int qwerty;"); 1528 verifyFormat("public\n" 1529 "B {}"); 1530 verifyFormat("public\n" 1531 "{}"); 1532 verifyFormat("public\n" 1533 "B { int x; }"); 1534} 1535 1536TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) { 1537 verifyFormat("{"); 1538} 1539 1540TEST_F(FormatTest, IncorrectCodeDoNoWhile) { 1541 verifyFormat("do {\n}"); 1542 verifyFormat("do {\n}\n" 1543 "f();"); 1544 verifyFormat("do {\n}\n" 1545 "wheeee(fun);"); 1546 verifyFormat("do {\n" 1547 " f();\n" 1548 "}"); 1549} 1550 1551TEST_F(FormatTest, IncorrectCodeMissingParens) { 1552 verifyFormat("if {\n foo;\n foo();\n}"); 1553 verifyFormat("switch {\n foo;\n foo();\n}"); 1554 verifyFormat("for {\n foo;\n foo();\n}"); 1555 verifyFormat("while {\n foo;\n foo();\n}"); 1556 verifyFormat("do {\n foo;\n foo();\n} while;"); 1557} 1558 1559TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) { 1560 verifyFormat("namespace {\n" 1561 "class Foo { Foo ( }; } // comment"); 1562} 1563 1564TEST_F(FormatTest, IncorrectCodeErrorDetection) { 1565 EXPECT_EQ("{\n{}\n", format("{\n{\n}\n")); 1566 EXPECT_EQ("{\n {}\n", format("{\n {\n}\n")); 1567 EXPECT_EQ("{\n {}\n", format("{\n {\n }\n")); 1568 EXPECT_EQ("{\n {}\n }\n}\n", format("{\n {\n }\n }\n}\n")); 1569 1570 EXPECT_EQ("{\n" 1571 " {\n" 1572 " breakme(\n" 1573 " qwe);\n" 1574 "}\n", format("{\n" 1575 " {\n" 1576 " breakme(qwe);\n" 1577 "}\n", getLLVMStyleWithColumns(10))); 1578} 1579 1580TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) { 1581 verifyFormat( 1582 "int x = {\n" 1583 " avariable,\n" 1584 " b(alongervariable)\n" 1585 "};", getLLVMStyleWithColumns(25)); 1586} 1587 1588TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) { 1589 verifyFormat("return (a)(b) { 1, 2, 3 };"); 1590} 1591 1592TEST_F(FormatTest, LayoutTokensFollowingBlockInParentheses) { 1593 verifyFormat( 1594 "Aaa({\n" 1595 " int i;\n" 1596 "}, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" 1597 " ccccccccccccccccc));"); 1598} 1599 1600TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) { 1601 verifyFormat("void f() { return 42; }"); 1602 verifyFormat("void f() {\n" 1603 " // Comment\n" 1604 "}"); 1605 verifyFormat("{\n" 1606 "#error {\n" 1607 " int a;\n" 1608 "}"); 1609 verifyFormat("{\n" 1610 " int a;\n" 1611 "#error {\n" 1612 "}"); 1613 1614 verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23)); 1615 verifyFormat("void f() {\n return 42;\n}", getLLVMStyleWithColumns(22)); 1616 1617 verifyFormat("void f() {}", getLLVMStyleWithColumns(11)); 1618 verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10)); 1619} 1620 1621TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) { 1622 // Elaborate type variable declarations. 1623 verifyFormat("struct foo a = { bar };\nint n;"); 1624 verifyFormat("class foo a = { bar };\nint n;"); 1625 verifyFormat("union foo a = { bar };\nint n;"); 1626 1627 // Elaborate types inside function definitions. 1628 verifyFormat("struct foo f() {}\nint n;"); 1629 verifyFormat("class foo f() {}\nint n;"); 1630 verifyFormat("union foo f() {}\nint n;"); 1631 1632 // Templates. 1633 verifyFormat("template <class X> void f() {}\nint n;"); 1634 verifyFormat("template <struct X> void f() {}\nint n;"); 1635 verifyFormat("template <union X> void f() {}\nint n;"); 1636 1637 // Actual definitions... 1638 verifyFormat("struct {\n} n;"); 1639 verifyFormat( 1640 "template <template <class T, class Y>, class Z> class X {\n} n;"); 1641 verifyFormat("union Z {\n int n;\n} x;"); 1642 verifyFormat("class MACRO Z {\n} n;"); 1643 verifyFormat("class MACRO(X) Z {\n} n;"); 1644 verifyFormat("class __attribute__(X) Z {\n} n;"); 1645 verifyFormat("class __declspec(X) Z {\n} n;"); 1646 1647 // Redefinition from nested context: 1648 verifyFormat("class A::B::C {\n} n;"); 1649 1650 // Template definitions. 1651 // FIXME: This is still incorrectly handled at the formatter side. 1652 verifyFormat("template <> struct X < 15, i < 3 && 42 < 50 && 33<28> {\n};"); 1653 1654 // FIXME: 1655 // This now gets parsed incorrectly as class definition. 1656 // verifyFormat("class A<int> f() {\n}\nint n;"); 1657 1658 // Elaborate types where incorrectly parsing the structural element would 1659 // break the indent. 1660 verifyFormat("if (true)\n" 1661 " class X x;\n" 1662 "else\n" 1663 " f();\n"); 1664} 1665 1666TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) { 1667 verifyFormat("#error Leave all white!!!!! space* alone!\n"); 1668 verifyFormat("#warning Leave all white!!!!! space* alone!\n"); 1669 EXPECT_EQ("#error 1", format(" # error 1")); 1670 EXPECT_EQ("#warning 1", format(" # warning 1")); 1671} 1672 1673TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) { 1674 FormatStyle AllowsMergedIf = getGoogleStyle(); 1675 AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true; 1676 verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf); 1677 verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf); 1678 verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf); 1679 EXPECT_EQ("if (true) return 42;", 1680 format("if (true)\nreturn 42;", AllowsMergedIf)); 1681 FormatStyle ShortMergedIf = AllowsMergedIf; 1682 ShortMergedIf.ColumnLimit = 25; 1683 verifyFormat("#define A \\\n" 1684 " if (true) return 42;", ShortMergedIf); 1685 verifyFormat("#define A \\\n" 1686 " f(); \\\n" 1687 " if (true)\n" 1688 "#define B", ShortMergedIf); 1689 verifyFormat("#define A \\\n" 1690 " f(); \\\n" 1691 " if (true)\n" 1692 "g();", ShortMergedIf); 1693 verifyFormat("{\n" 1694 "#ifdef A\n" 1695 " // Comment\n" 1696 " if (true) continue;\n" 1697 "#endif\n" 1698 " // Comment\n" 1699 " if (true) continue;", ShortMergedIf); 1700} 1701 1702TEST_F(FormatTest, BlockCommentsInControlLoops) { 1703 verifyFormat("if (0) /* a comment in a strange place */ {\n" 1704 " f();\n" 1705 "}"); 1706 verifyFormat("if (0) /* a comment in a strange place */ {\n" 1707 " f();\n" 1708 "} /* another comment */ else /* comment #3 */ {\n" 1709 " g();\n" 1710 "}"); 1711 verifyFormat("while (0) /* a comment in a strange place */ {\n" 1712 " f();\n" 1713 "}"); 1714 verifyFormat("for (;;) /* a comment in a strange place */ {\n" 1715 " f();\n" 1716 "}"); 1717 verifyFormat("do /* a comment in a strange place */ {\n" 1718 " f();\n" 1719 "} /* another comment */ while (0);"); 1720} 1721 1722TEST_F(FormatTest, BlockComments) { 1723 EXPECT_EQ("/* */ /* */ /* */\n/* */ /* */ /* */", 1724 format("/* *//* */ /* */\n/* *//* */ /* */")); 1725 EXPECT_EQ("/* */ a /* */ b;", 1726 format(" /* */ a/* */ b;")); 1727 EXPECT_EQ("#define A /* */\\\n" 1728 " b\n" 1729 "/* */\n" 1730 "someCall(\n" 1731 " parameter);", 1732 format("#define A /* */ b\n" 1733 "/* */\n" 1734 "someCall(parameter);", getLLVMStyleWithColumns(15))); 1735 1736 EXPECT_EQ("#define A\n" 1737 "/* */ someCall(\n" 1738 " parameter);", 1739 format("#define A\n" 1740 "/* */someCall(parameter);", getLLVMStyleWithColumns(15))); 1741} 1742 1743TEST_F(FormatTest, FormatStarDependingOnContext) { 1744 verifyFormat("void f(int *a);"); 1745 verifyFormat("void f() { f(fint * b); }"); 1746 verifyFormat("class A {\n void f(int *a);\n};"); 1747 verifyFormat("class A {\n int *a;\n};"); 1748 verifyFormat("namespace a {\n" 1749 "namespace b {\n" 1750 "class A {\n" 1751 " void f() {}\n" 1752 " int *a;\n" 1753 "};\n" 1754 "}\n" 1755 "}"); 1756} 1757 1758TEST_F(FormatTest, SpecialTokensAtEndOfLine) { 1759 verifyFormat("while"); 1760 verifyFormat("operator"); 1761} 1762 1763//===----------------------------------------------------------------------===// 1764// Objective-C tests. 1765//===----------------------------------------------------------------------===// 1766 1767TEST_F(FormatTest, FormatForObjectiveCMethodDecls) { 1768 verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;"); 1769 EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;", 1770 format("-(NSUInteger)indexOfObject:(id)anObject;")); 1771 EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;")); 1772 EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;")); 1773 EXPECT_EQ("- (NSInteger)Method3:(id)anObject;", 1774 format("-(NSInteger)Method3:(id)anObject;")); 1775 EXPECT_EQ("- (NSInteger)Method4:(id)anObject;", 1776 format("-(NSInteger)Method4:(id)anObject;")); 1777 EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;", 1778 format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;")); 1779 EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;", 1780 format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;")); 1781 EXPECT_EQ( 1782 "- (void)sendAction:(SEL)aSelector to:(id)anObject forAllCells:(BOOL)flag;", 1783 format("- (void)sendAction:(SEL)aSelector to:(id)anObject forAllCells:(BOOL)flag;")); 1784 1785 // Very long objectiveC method declaration. 1786 EXPECT_EQ( 1787 "- (NSUInteger)indexOfObject:(id)anObject inRange:(NSRange)range\n " 1788 "outRange:(NSRange)out_range outRange1:(NSRange)out_range1\n " 1789 "outRange2:(NSRange)out_range2 outRange3:(NSRange)out_range3\n " 1790 "outRange4:(NSRange)out_range4 outRange5:(NSRange)out_range5\n " 1791 "outRange6:(NSRange)out_range6 outRange7:(NSRange)out_range7\n " 1792 "outRange8:(NSRange)out_range8 outRange9:(NSRange)out_range9;", 1793 format( 1794 "- (NSUInteger)indexOfObject:(id)anObject inRange:(NSRange)range " 1795 "outRange:(NSRange) out_range outRange1:(NSRange) out_range1 " 1796 "outRange2:(NSRange) out_range2 outRange3:(NSRange) out_range3 " 1797 "outRange4:(NSRange) out_range4 outRange5:(NSRange) out_range5 " 1798 "outRange6:(NSRange) out_range6 outRange7:(NSRange) out_range7 " 1799 "outRange8:(NSRange) out_range8 outRange9:(NSRange) out_range9;")); 1800 1801 verifyFormat("- (int)sum:(vector<int>)numbers;"); 1802 verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;"); 1803 // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC 1804 // protocol lists (but not for template classes): 1805 //verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;"); 1806 1807 verifyFormat("- (int(*)())foo:(int(*)())f;"); 1808 verifyGoogleFormat("- (int(*)())foo:(int(*)())foo;"); 1809 1810 // If there's no return type (very rare in practice!), LLVM and Google style 1811 // agree. 1812 verifyFormat("- foo:(int)f;"); 1813 verifyGoogleFormat("- foo:(int)foo;"); 1814} 1815 1816TEST_F(FormatTest, FormatObjCBlocks) { 1817 verifyFormat("int (^Block)(int, int);"); 1818 verifyFormat("int (^Block1)(int, int) = ^(int i, int j)"); 1819} 1820 1821TEST_F(FormatTest, FormatObjCInterface) { 1822 verifyFormat("@interface Foo : NSObject <NSSomeDelegate> {\n" 1823 "@public\n" 1824 " int field1;\n" 1825 "@protected\n" 1826 " int field2;\n" 1827 "@private\n" 1828 " int field3;\n" 1829 "@package\n" 1830 " int field4;\n" 1831 "}\n" 1832 "+ (id)init;\n" 1833 "@end"); 1834 1835 verifyGoogleFormat("@interface Foo : NSObject<NSSomeDelegate> {\n" 1836 " @public\n" 1837 " int field1;\n" 1838 " @protected\n" 1839 " int field2;\n" 1840 " @private\n" 1841 " int field3;\n" 1842 " @package\n" 1843 " int field4;\n" 1844 "}\n" 1845 "+ (id)init;\n" 1846 "@end"); 1847 1848 verifyFormat("@interface /* wait for it */ Foo\n" 1849 "+ (id)init;\n" 1850 "// Look, a comment!\n" 1851 "- (int)answerWith:(int)i;\n" 1852 "@end"); 1853 1854 verifyFormat("@interface Foo\n" 1855 "@end\n" 1856 "@interface Bar\n" 1857 "@end"); 1858 1859 verifyFormat("@interface Foo : Bar\n" 1860 "+ (id)init;\n" 1861 "@end"); 1862 1863 verifyFormat("@interface Foo : /**/ Bar /**/ <Baz, /**/ Quux>\n" 1864 "+ (id)init;\n" 1865 "@end"); 1866 1867 verifyGoogleFormat("@interface Foo : Bar<Baz, Quux>\n" 1868 "+ (id)init;\n" 1869 "@end"); 1870 1871 verifyFormat("@interface Foo (HackStuff)\n" 1872 "+ (id)init;\n" 1873 "@end"); 1874 1875 verifyFormat("@interface Foo ()\n" 1876 "+ (id)init;\n" 1877 "@end"); 1878 1879 verifyFormat("@interface Foo (HackStuff) <MyProtocol>\n" 1880 "+ (id)init;\n" 1881 "@end"); 1882 1883 verifyGoogleFormat("@interface Foo (HackStuff)<MyProtocol>\n" 1884 "+ (id)init;\n" 1885 "@end"); 1886 1887 verifyFormat("@interface Foo {\n" 1888 " int _i;\n" 1889 "}\n" 1890 "+ (id)init;\n" 1891 "@end"); 1892 1893 verifyFormat("@interface Foo : Bar {\n" 1894 " int _i;\n" 1895 "}\n" 1896 "+ (id)init;\n" 1897 "@end"); 1898 1899 verifyFormat("@interface Foo : Bar <Baz, Quux> {\n" 1900 " int _i;\n" 1901 "}\n" 1902 "+ (id)init;\n" 1903 "@end"); 1904 1905 verifyFormat("@interface Foo (HackStuff) {\n" 1906 " int _i;\n" 1907 "}\n" 1908 "+ (id)init;\n" 1909 "@end"); 1910 1911 verifyFormat("@interface Foo () {\n" 1912 " int _i;\n" 1913 "}\n" 1914 "+ (id)init;\n" 1915 "@end"); 1916 1917 verifyFormat("@interface Foo (HackStuff) <MyProtocol> {\n" 1918 " int _i;\n" 1919 "}\n" 1920 "+ (id)init;\n" 1921 "@end"); 1922} 1923 1924TEST_F(FormatTest, FormatObjCImplementation) { 1925 verifyFormat("@implementation Foo : NSObject {\n" 1926 "@public\n" 1927 " int field1;\n" 1928 "@protected\n" 1929 " int field2;\n" 1930 "@private\n" 1931 " int field3;\n" 1932 "@package\n" 1933 " int field4;\n" 1934 "}\n" 1935 "+ (id)init {\n}\n" 1936 "@end"); 1937 1938 verifyGoogleFormat("@implementation Foo : NSObject {\n" 1939 " @public\n" 1940 " int field1;\n" 1941 " @protected\n" 1942 " int field2;\n" 1943 " @private\n" 1944 " int field3;\n" 1945 " @package\n" 1946 " int field4;\n" 1947 "}\n" 1948 "+ (id)init {\n}\n" 1949 "@end"); 1950 1951 verifyFormat("@implementation Foo\n" 1952 "+ (id)init {\n" 1953 " if (true)\n" 1954 " return nil;\n" 1955 "}\n" 1956 "// Look, a comment!\n" 1957 "- (int)answerWith:(int)i {\n" 1958 " return i;\n" 1959 "}\n" 1960 "+ (int)answerWith:(int)i {\n" 1961 " return i;\n" 1962 "}\n" 1963 "@end"); 1964 1965 verifyFormat("@implementation Foo\n" 1966 "@end\n" 1967 "@implementation Bar\n" 1968 "@end"); 1969 1970 verifyFormat("@implementation Foo : Bar\n" 1971 "+ (id)init {\n}\n" 1972 "- (void)foo {\n}\n" 1973 "@end"); 1974 1975 verifyFormat("@implementation Foo {\n" 1976 " int _i;\n" 1977 "}\n" 1978 "+ (id)init {\n}\n" 1979 "@end"); 1980 1981 verifyFormat("@implementation Foo : Bar {\n" 1982 " int _i;\n" 1983 "}\n" 1984 "+ (id)init {\n}\n" 1985 "@end"); 1986 1987 verifyFormat("@implementation Foo (HackStuff)\n" 1988 "+ (id)init {\n}\n" 1989 "@end"); 1990} 1991 1992TEST_F(FormatTest, FormatObjCProtocol) { 1993 verifyFormat("@protocol Foo\n" 1994 "@property(weak) id delegate;\n" 1995 "- (NSUInteger)numberOfThings;\n" 1996 "@end"); 1997 1998 verifyFormat("@protocol MyProtocol <NSObject>\n" 1999 "- (NSUInteger)numberOfThings;\n" 2000 "@end"); 2001 2002 verifyGoogleFormat("@protocol MyProtocol<NSObject>\n" 2003 "- (NSUInteger)numberOfThings;\n" 2004 "@end"); 2005 2006 verifyFormat("@protocol Foo;\n" 2007 "@protocol Bar;\n"); 2008 2009 verifyFormat("@protocol Foo\n" 2010 "@end\n" 2011 "@protocol Bar\n" 2012 "@end"); 2013 2014 verifyFormat("@protocol myProtocol\n" 2015 "- (void)mandatoryWithInt:(int)i;\n" 2016 "@optional\n" 2017 "- (void)optional;\n" 2018 "@required\n" 2019 "- (void)required;\n" 2020 "@optional\n" 2021 "@property(assign) int madProp;\n" 2022 "@end\n"); 2023} 2024 2025TEST_F(FormatTest, FormatObjCMethodExpr) { 2026 verifyFormat("[foo bar:baz];"); 2027 verifyFormat("return [foo bar:baz];"); 2028 verifyFormat("f([foo bar:baz]);"); 2029 verifyFormat("f(2, [foo bar:baz]);"); 2030 verifyFormat("f(2, a ? b : c);"); 2031 verifyFormat("[[self initWithInt:4] bar:[baz quux:arrrr]];"); 2032 2033 verifyFormat("[foo bar:baz], [foo bar:baz];"); 2034 verifyFormat("[foo bar:baz] = [foo bar:baz];"); 2035 verifyFormat("[foo bar:baz] *= [foo bar:baz];"); 2036 verifyFormat("[foo bar:baz] /= [foo bar:baz];"); 2037 verifyFormat("[foo bar:baz] %= [foo bar:baz];"); 2038 verifyFormat("[foo bar:baz] += [foo bar:baz];"); 2039 verifyFormat("[foo bar:baz] -= [foo bar:baz];"); 2040 verifyFormat("[foo bar:baz] <<= [foo bar:baz];"); 2041 verifyFormat("[foo bar:baz] >>= [foo bar:baz];"); 2042 verifyFormat("[foo bar:baz] &= [foo bar:baz];"); 2043 verifyFormat("[foo bar:baz] ^= [foo bar:baz];"); 2044 verifyFormat("[foo bar:baz] |= [foo bar:baz];"); 2045 verifyFormat("[foo bar:baz] ? [foo bar:baz] : [foo bar:baz];"); 2046 verifyFormat("[foo bar:baz] || [foo bar:baz];"); 2047 verifyFormat("[foo bar:baz] && [foo bar:baz];"); 2048 verifyFormat("[foo bar:baz] | [foo bar:baz];"); 2049 verifyFormat("[foo bar:baz] ^ [foo bar:baz];"); 2050 verifyFormat("[foo bar:baz] & [foo bar:baz];"); 2051 verifyFormat("[foo bar:baz] == [foo bar:baz];"); 2052 verifyFormat("[foo bar:baz] != [foo bar:baz];"); 2053 verifyFormat("[foo bar:baz] >= [foo bar:baz];"); 2054 verifyFormat("[foo bar:baz] <= [foo bar:baz];"); 2055 verifyFormat("[foo bar:baz] > [foo bar:baz];"); 2056 verifyFormat("[foo bar:baz] < [foo bar:baz];"); 2057 verifyFormat("[foo bar:baz] >> [foo bar:baz];"); 2058 verifyFormat("[foo bar:baz] << [foo bar:baz];"); 2059 verifyFormat("[foo bar:baz] - [foo bar:baz];"); 2060 verifyFormat("[foo bar:baz] + [foo bar:baz];"); 2061 verifyFormat("[foo bar:baz] * [foo bar:baz];"); 2062 verifyFormat("[foo bar:baz] / [foo bar:baz];"); 2063 verifyFormat("[foo bar:baz] % [foo bar:baz];"); 2064 // Whew! 2065 2066 verifyFormat("[self stuffWithInt:(4 + 2) float:4.5];"); 2067 verifyFormat("[self stuffWithInt:a ? b : c float:4.5];"); 2068 verifyFormat("[self stuffWithInt:a ? [self foo:bar] : c];"); 2069 verifyFormat("[self stuffWithInt:a ? (e ? f : g) : c];"); 2070 verifyFormat("[cond ? obj1 : obj2 methodWithParam:param]"); 2071 verifyFormat("[button setAction:@selector(zoomOut:)];"); 2072 verifyFormat("[color getRed:&r green:&g blue:&b alpha:&a];"); 2073 2074 verifyFormat("arr[[self indexForFoo:a]];"); 2075 verifyFormat("throw [self errorFor:a];"); 2076 verifyFormat("@throw [self errorFor:a];"); 2077 2078 // This tests that the formatter doesn't break after "backing" but before ":", 2079 // which would be at 80 columns. 2080 verifyFormat( 2081 "void f() {\n" 2082 " if ((self = [super initWithContentRect:contentRect styleMask:styleMask\n" 2083 " backing:NSBackingStoreBuffered defer:YES]))"); 2084 2085 verifyFormat("[foo checkThatBreakingAfterColonWorksOk:\n" 2086 " [bar ifItDoes:reduceOverallLineLengthLikeInThisCase]];"); 2087 2088} 2089 2090TEST_F(FormatTest, ObjCAt) { 2091 verifyFormat("@autoreleasepool"); 2092 verifyFormat("@catch"); 2093 verifyFormat("@class"); 2094 verifyFormat("@compatibility_alias"); 2095 verifyFormat("@defs"); 2096 verifyFormat("@dynamic"); 2097 verifyFormat("@encode"); 2098 verifyFormat("@end"); 2099 verifyFormat("@finally"); 2100 verifyFormat("@implementation"); 2101 verifyFormat("@import"); 2102 verifyFormat("@interface"); 2103 verifyFormat("@optional"); 2104 verifyFormat("@package"); 2105 verifyFormat("@private"); 2106 verifyFormat("@property"); 2107 verifyFormat("@protected"); 2108 verifyFormat("@protocol"); 2109 verifyFormat("@public"); 2110 verifyFormat("@required"); 2111 verifyFormat("@selector"); 2112 verifyFormat("@synchronized"); 2113 verifyFormat("@synthesize"); 2114 verifyFormat("@throw"); 2115 verifyFormat("@try"); 2116 2117 verifyFormat("@\"String\""); 2118 verifyFormat("@1"); 2119 verifyFormat("@+4.8"); 2120 verifyFormat("@-4"); 2121 verifyFormat("@1LL"); 2122 verifyFormat("@.5"); 2123 verifyFormat("@'c'"); 2124 verifyFormat("@true"); 2125 verifyFormat("NSNumber *smallestInt = @(-INT_MAX - 1);"); 2126 // FIXME: Array and dictionary literals need more work. 2127 verifyFormat("@["); 2128 verifyFormat("@{"); 2129 2130 EXPECT_EQ("@interface", format("@ interface")); 2131 2132 // The precise formatting of this doesn't matter, nobody writes code like 2133 // this. 2134 verifyFormat("@ /*foo*/ interface"); 2135} 2136 2137TEST_F(FormatTest, ObjCSnippets) { 2138 verifyFormat("@autoreleasepool {\n" 2139 " foo();\n" 2140 "}"); 2141 verifyFormat("@class Foo, Bar;"); 2142 verifyFormat("@compatibility_alias AliasName ExistingClass;"); 2143 verifyFormat("@dynamic textColor;"); 2144 verifyFormat("char *buf1 = @encode(int *);"); 2145 verifyFormat("char *buf1 = @encode(typeof(4 * 5));"); 2146 // FIXME: Enable once PR14884 is fixed: 2147 //verifyFormat("char *buf1 = @encode(int **);"); 2148 verifyFormat("Protocol *proto = @protocol(p1);"); 2149 verifyFormat("SEL s = @selector(foo:);"); 2150 verifyFormat("@synchronized(self) {\n" 2151 " f();\n" 2152 "}"); 2153 2154 verifyFormat("@synthesize dropArrowPosition = dropArrowPosition_;"); 2155 verifyGoogleFormat("@synthesize dropArrowPosition = dropArrowPosition_;"); 2156 2157 verifyFormat("@property(assign, nonatomic) CGFloat hoverAlpha;"); 2158 verifyFormat("@property(assign, getter=isEditable) BOOL editable;"); 2159 verifyGoogleFormat("@property(assign, getter=isEditable) BOOL editable;"); 2160} 2161 2162} // end namespace tooling 2163} // end namespace clang 2164