1 //===- unittest/Format/FormatTestComments.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 #include "clang/Format/Format.h" 11 12 #include "../Tooling/ReplacementTest.h" 13 #include "FormatTestUtils.h" 14 15 #include "clang/Frontend/TextDiagnosticPrinter.h" 16 #include "llvm/Support/Debug.h" 17 #include "llvm/Support/MemoryBuffer.h" 18 #include "gtest/gtest.h" 19 20 #define DEBUG_TYPE "format-test" 21 22 using clang::tooling::ReplacementTest; 23 24 namespace clang { 25 namespace format { 26 namespace { 27 28 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); } 29 30 class FormatTestComments : public ::testing::Test { 31 protected: 32 enum StatusCheck { 33 SC_ExpectComplete, 34 SC_ExpectIncomplete, 35 SC_DoNotCheck 36 }; 37 38 std::string format(llvm::StringRef Code, 39 const FormatStyle &Style = getLLVMStyle(), 40 StatusCheck CheckComplete = SC_ExpectComplete) { 41 DEBUG(llvm::errs() << "---\n"); 42 DEBUG(llvm::errs() << Code << "\n\n"); 43 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size())); 44 FormattingAttemptStatus Status; 45 tooling::Replacements Replaces = 46 reformat(Style, Code, Ranges, "<stdin>", &Status); 47 if (CheckComplete != SC_DoNotCheck) { 48 bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete; 49 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete) 50 << Code << "\n\n"; 51 } 52 ReplacementCount = Replaces.size(); 53 auto Result = applyAllReplacements(Code, Replaces); 54 EXPECT_TRUE(static_cast<bool>(Result)); 55 DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); 56 return *Result; 57 } 58 59 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 60 FormatStyle Style = getLLVMStyle(); 61 Style.ColumnLimit = ColumnLimit; 62 return Style; 63 } 64 65 void verifyFormat(llvm::StringRef Code, 66 const FormatStyle &Style = getLLVMStyle()) { 67 EXPECT_EQ(Code.str(), format(test::messUp(Code), Style)); 68 } 69 70 void verifyGoogleFormat(llvm::StringRef Code) { 71 verifyFormat(Code, getGoogleStyle()); 72 } 73 74 /// \brief Verify that clang-format does not crash on the given input. 75 void verifyNoCrash(llvm::StringRef Code, 76 const FormatStyle &Style = getLLVMStyle()) { 77 format(Code, Style, SC_DoNotCheck); 78 } 79 80 int ReplacementCount; 81 }; 82 83 //===----------------------------------------------------------------------===// 84 // Tests for comments. 85 //===----------------------------------------------------------------------===// 86 87 TEST_F(FormatTestComments, UnderstandsSingleLineComments) { 88 verifyFormat("//* */"); 89 verifyFormat("// line 1\n" 90 "// line 2\n" 91 "void f() {}\n"); 92 93 verifyFormat("void f() {\n" 94 " // Doesn't do anything\n" 95 "}"); 96 verifyFormat("SomeObject\n" 97 " // Calling someFunction on SomeObject\n" 98 " .someFunction();"); 99 verifyFormat("auto result = SomeObject\n" 100 " // Calling someFunction on SomeObject\n" 101 " .someFunction();"); 102 verifyFormat("void f(int i, // some comment (probably for i)\n" 103 " int j, // some comment (probably for j)\n" 104 " int k); // some comment (probably for k)"); 105 verifyFormat("void f(int i,\n" 106 " // some comment (probably for j)\n" 107 " int j,\n" 108 " // some comment (probably for k)\n" 109 " int k);"); 110 111 verifyFormat("int i // This is a fancy variable\n" 112 " = 5; // with nicely aligned comment."); 113 114 verifyFormat("// Leading comment.\n" 115 "int a; // Trailing comment."); 116 verifyFormat("int a; // Trailing comment\n" 117 " // on 2\n" 118 " // or 3 lines.\n" 119 "int b;"); 120 verifyFormat("int a; // Trailing comment\n" 121 "\n" 122 "// Leading comment.\n" 123 "int b;"); 124 verifyFormat("int a; // Comment.\n" 125 " // More details.\n" 126 "int bbbb; // Another comment."); 127 verifyFormat( 128 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; // comment\n" 129 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // comment\n" 130 "int cccccccccccccccccccccccccccccc; // comment\n" 131 "int ddd; // looooooooooooooooooooooooong comment\n" 132 "int aaaaaaaaaaaaaaaaaaaaaaa; // comment\n" 133 "int bbbbbbbbbbbbbbbbbbbbb; // comment\n" 134 "int ccccccccccccccccccc; // comment"); 135 136 verifyFormat("#include \"a\" // comment\n" 137 "#include \"a/b/c\" // comment"); 138 verifyFormat("#include <a> // comment\n" 139 "#include <a/b/c> // comment"); 140 EXPECT_EQ("#include \"a\" // comment\n" 141 "#include \"a/b/c\" // comment", 142 format("#include \\\n" 143 " \"a\" // comment\n" 144 "#include \"a/b/c\" // comment")); 145 146 verifyFormat("enum E {\n" 147 " // comment\n" 148 " VAL_A, // comment\n" 149 " VAL_B\n" 150 "};"); 151 152 EXPECT_EQ("enum A {\n" 153 " // line a\n" 154 " a,\n" 155 " b, // line b\n" 156 "\n" 157 " // line c\n" 158 " c\n" 159 "};", 160 format("enum A {\n" 161 " // line a\n" 162 " a,\n" 163 " b, // line b\n" 164 "\n" 165 " // line c\n" 166 " c\n" 167 "};", 168 getLLVMStyleWithColumns(20))); 169 EXPECT_EQ("enum A {\n" 170 " a, // line 1\n" 171 " // line 2\n" 172 "};", 173 format("enum A {\n" 174 " a, // line 1\n" 175 " // line 2\n" 176 "};", 177 getLLVMStyleWithColumns(20))); 178 EXPECT_EQ("enum A {\n" 179 " a, // line 1\n" 180 " // line 2\n" 181 "};", 182 format("enum A {\n" 183 " a, // line 1\n" 184 " // line 2\n" 185 "};", 186 getLLVMStyleWithColumns(20))); 187 EXPECT_EQ("enum A {\n" 188 " a, // line 1\n" 189 " // line 2\n" 190 " b\n" 191 "};", 192 format("enum A {\n" 193 " a, // line 1\n" 194 " // line 2\n" 195 " b\n" 196 "};", 197 getLLVMStyleWithColumns(20))); 198 EXPECT_EQ("enum A {\n" 199 " a, // line 1\n" 200 " // line 2\n" 201 " b\n" 202 "};", 203 format("enum A {\n" 204 " a, // line 1\n" 205 " // line 2\n" 206 " b\n" 207 "};", 208 getLLVMStyleWithColumns(20))); 209 verifyFormat( 210 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 211 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // Trailing comment"); 212 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 213 " // Comment inside a statement.\n" 214 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 215 verifyFormat("SomeFunction(a,\n" 216 " // comment\n" 217 " b + x);"); 218 verifyFormat("SomeFunction(a, a,\n" 219 " // comment\n" 220 " b + x);"); 221 verifyFormat( 222 "bool aaaaaaaaaaaaa = // comment\n" 223 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 224 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 225 226 verifyFormat("int aaaa; // aaaaa\n" 227 "int aa; // aaaaaaa", 228 getLLVMStyleWithColumns(20)); 229 230 EXPECT_EQ("void f() { // This does something ..\n" 231 "}\n" 232 "int a; // This is unrelated", 233 format("void f() { // This does something ..\n" 234 " }\n" 235 "int a; // This is unrelated")); 236 EXPECT_EQ("class C {\n" 237 " void f() { // This does something ..\n" 238 " } // awesome..\n" 239 "\n" 240 " int a; // This is unrelated\n" 241 "};", 242 format("class C{void f() { // This does something ..\n" 243 " } // awesome..\n" 244 " \n" 245 "int a; // This is unrelated\n" 246 "};")); 247 248 EXPECT_EQ("int i; // single line trailing comment", 249 format("int i;\\\n// single line trailing comment")); 250 251 verifyGoogleFormat("int a; // Trailing comment."); 252 253 verifyFormat("someFunction(anotherFunction( // Force break.\n" 254 " parameter));"); 255 256 verifyGoogleFormat("#endif // HEADER_GUARD"); 257 258 verifyFormat("const char *test[] = {\n" 259 " // A\n" 260 " \"aaaa\",\n" 261 " // B\n" 262 " \"aaaaa\"};"); 263 verifyGoogleFormat( 264 "aaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 265 " aaaaaaaaaaaaaaaaaaaaaa); // 81_cols_with_this_comment"); 266 EXPECT_EQ("D(a, {\n" 267 " // test\n" 268 " int a;\n" 269 "});", 270 format("D(a, {\n" 271 "// test\n" 272 "int a;\n" 273 "});")); 274 275 EXPECT_EQ("lineWith(); // comment\n" 276 "// at start\n" 277 "otherLine();", 278 format("lineWith(); // comment\n" 279 "// at start\n" 280 "otherLine();")); 281 EXPECT_EQ("lineWith(); // comment\n" 282 "/*\n" 283 " * at start */\n" 284 "otherLine();", 285 format("lineWith(); // comment\n" 286 "/*\n" 287 " * at start */\n" 288 "otherLine();")); 289 EXPECT_EQ("lineWith(); // comment\n" 290 " // at start\n" 291 "otherLine();", 292 format("lineWith(); // comment\n" 293 " // at start\n" 294 "otherLine();")); 295 296 EXPECT_EQ("lineWith(); // comment\n" 297 "// at start\n" 298 "otherLine(); // comment", 299 format("lineWith(); // comment\n" 300 "// at start\n" 301 "otherLine(); // comment")); 302 EXPECT_EQ("lineWith();\n" 303 "// at start\n" 304 "otherLine(); // comment", 305 format("lineWith();\n" 306 " // at start\n" 307 "otherLine(); // comment")); 308 EXPECT_EQ("// first\n" 309 "// at start\n" 310 "otherLine(); // comment", 311 format("// first\n" 312 " // at start\n" 313 "otherLine(); // comment")); 314 EXPECT_EQ("f();\n" 315 "// first\n" 316 "// at start\n" 317 "otherLine(); // comment", 318 format("f();\n" 319 "// first\n" 320 " // at start\n" 321 "otherLine(); // comment")); 322 verifyFormat("f(); // comment\n" 323 "// first\n" 324 "// at start\n" 325 "otherLine();"); 326 EXPECT_EQ("f(); // comment\n" 327 "// first\n" 328 "// at start\n" 329 "otherLine();", 330 format("f(); // comment\n" 331 "// first\n" 332 " // at start\n" 333 "otherLine();")); 334 EXPECT_EQ("f(); // comment\n" 335 " // first\n" 336 "// at start\n" 337 "otherLine();", 338 format("f(); // comment\n" 339 " // first\n" 340 "// at start\n" 341 "otherLine();")); 342 EXPECT_EQ("void f() {\n" 343 " lineWith(); // comment\n" 344 " // at start\n" 345 "}", 346 format("void f() {\n" 347 " lineWith(); // comment\n" 348 " // at start\n" 349 "}")); 350 EXPECT_EQ("int xy; // a\n" 351 "int z; // b", 352 format("int xy; // a\n" 353 "int z; //b")); 354 EXPECT_EQ("int xy; // a\n" 355 "int z; // bb", 356 format("int xy; // a\n" 357 "int z; //bb", 358 getLLVMStyleWithColumns(12))); 359 360 verifyFormat("#define A \\\n" 361 " int i; /* iiiiiiiiiiiiiiiiiiiii */ \\\n" 362 " int jjjjjjjjjjjjjjjjjjjjjjjj; /* */", 363 getLLVMStyleWithColumns(60)); 364 verifyFormat( 365 "#define A \\\n" 366 " int i; /* iiiiiiiiiiiiiiiiiiiii */ \\\n" 367 " int jjjjjjjjjjjjjjjjjjjjjjjj; /* */", 368 getLLVMStyleWithColumns(61)); 369 370 verifyFormat("if ( // This is some comment\n" 371 " x + 3) {\n" 372 "}"); 373 EXPECT_EQ("if ( // This is some comment\n" 374 " // spanning two lines\n" 375 " x + 3) {\n" 376 "}", 377 format("if( // This is some comment\n" 378 " // spanning two lines\n" 379 " x + 3) {\n" 380 "}")); 381 382 verifyNoCrash("/\\\n/"); 383 verifyNoCrash("/\\\n* */"); 384 // The 0-character somehow makes the lexer return a proper comment. 385 verifyNoCrash(StringRef("/*\\\0\n/", 6)); 386 } 387 388 TEST_F(FormatTestComments, KeepsParameterWithTrailingCommentsOnTheirOwnLine) { 389 EXPECT_EQ("SomeFunction(a,\n" 390 " b, // comment\n" 391 " c);", 392 format("SomeFunction(a,\n" 393 " b, // comment\n" 394 " c);")); 395 EXPECT_EQ("SomeFunction(a, b,\n" 396 " // comment\n" 397 " c);", 398 format("SomeFunction(a,\n" 399 " b,\n" 400 " // comment\n" 401 " c);")); 402 EXPECT_EQ("SomeFunction(a, b, // comment (unclear relation)\n" 403 " c);", 404 format("SomeFunction(a, b, // comment (unclear relation)\n" 405 " c);")); 406 EXPECT_EQ("SomeFunction(a, // comment\n" 407 " b,\n" 408 " c); // comment", 409 format("SomeFunction(a, // comment\n" 410 " b,\n" 411 " c); // comment")); 412 EXPECT_EQ("aaaaaaaaaa(aaaa(aaaa,\n" 413 " aaaa), //\n" 414 " aaaa, bbbbb);", 415 format("aaaaaaaaaa(aaaa(aaaa,\n" 416 "aaaa), //\n" 417 "aaaa, bbbbb);")); 418 } 419 420 TEST_F(FormatTestComments, RemovesTrailingWhitespaceOfComments) { 421 EXPECT_EQ("// comment", format("// comment ")); 422 EXPECT_EQ("int aaaaaaa, bbbbbbb; // comment", 423 format("int aaaaaaa, bbbbbbb; // comment ", 424 getLLVMStyleWithColumns(33))); 425 EXPECT_EQ("// comment\\\n", format("// comment\\\n \t \v \f ")); 426 EXPECT_EQ("// comment \\\n", format("// comment \\\n \t \v \f ")); 427 } 428 429 TEST_F(FormatTestComments, UnderstandsBlockComments) { 430 verifyFormat("f(/*noSpaceAfterParameterNamingComment=*/true);"); 431 verifyFormat("void f() { g(/*aaa=*/x, /*bbb=*/!y, /*c=*/::c); }"); 432 EXPECT_EQ("f(aaaaaaaaaaaaaaaaaaaaaaaaa, /* Trailing comment for aa... */\n" 433 " bbbbbbbbbbbbbbbbbbbbbbbbb);", 434 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \\\n" 435 "/* Trailing comment for aa... */\n" 436 " bbbbbbbbbbbbbbbbbbbbbbbbb);")); 437 EXPECT_EQ( 438 "f(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 439 " /* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);", 440 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \n" 441 "/* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);")); 442 EXPECT_EQ( 443 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 444 " aaaaaaaaaaaaaaaaaa,\n" 445 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n" 446 "}", 447 format("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 448 " aaaaaaaaaaaaaaaaaa ,\n" 449 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n" 450 "}")); 451 verifyFormat("f(/* aaaaaaaaaaaaaaaaaa = */\n" 452 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 453 454 FormatStyle NoBinPacking = getLLVMStyle(); 455 NoBinPacking.BinPackParameters = false; 456 verifyFormat("aaaaaaaa(/* parameter 1 */ aaaaaa,\n" 457 " /* parameter 2 */ aaaaaa,\n" 458 " /* parameter 3 */ aaaaaa,\n" 459 " /* parameter 4 */ aaaaaa);", 460 NoBinPacking); 461 462 // Aligning block comments in macros. 463 verifyGoogleFormat("#define A \\\n" 464 " int i; /*a*/ \\\n" 465 " int jjj; /*b*/"); 466 } 467 468 TEST_F(FormatTestComments, AlignsBlockComments) { 469 EXPECT_EQ("/*\n" 470 " * Really multi-line\n" 471 " * comment.\n" 472 " */\n" 473 "void f() {}", 474 format(" /*\n" 475 " * Really multi-line\n" 476 " * comment.\n" 477 " */\n" 478 " void f() {}")); 479 EXPECT_EQ("class C {\n" 480 " /*\n" 481 " * Another multi-line\n" 482 " * comment.\n" 483 " */\n" 484 " void f() {}\n" 485 "};", 486 format("class C {\n" 487 "/*\n" 488 " * Another multi-line\n" 489 " * comment.\n" 490 " */\n" 491 "void f() {}\n" 492 "};")); 493 EXPECT_EQ("/*\n" 494 " 1. This is a comment with non-trivial formatting.\n" 495 " 1.1. We have to indent/outdent all lines equally\n" 496 " 1.1.1. to keep the formatting.\n" 497 " */", 498 format(" /*\n" 499 " 1. This is a comment with non-trivial formatting.\n" 500 " 1.1. We have to indent/outdent all lines equally\n" 501 " 1.1.1. to keep the formatting.\n" 502 " */")); 503 EXPECT_EQ("/*\n" 504 "Don't try to outdent if there's not enough indentation.\n" 505 "*/", 506 format(" /*\n" 507 " Don't try to outdent if there's not enough indentation.\n" 508 " */")); 509 510 EXPECT_EQ("int i; /* Comment with empty...\n" 511 " *\n" 512 " * line. */", 513 format("int i; /* Comment with empty...\n" 514 " *\n" 515 " * line. */")); 516 EXPECT_EQ("int foobar = 0; /* comment */\n" 517 "int bar = 0; /* multiline\n" 518 " comment 1 */\n" 519 "int baz = 0; /* multiline\n" 520 " comment 2 */\n" 521 "int bzz = 0; /* multiline\n" 522 " comment 3 */", 523 format("int foobar = 0; /* comment */\n" 524 "int bar = 0; /* multiline\n" 525 " comment 1 */\n" 526 "int baz = 0; /* multiline\n" 527 " comment 2 */\n" 528 "int bzz = 0; /* multiline\n" 529 " comment 3 */")); 530 EXPECT_EQ("int foobar = 0; /* comment */\n" 531 "int bar = 0; /* multiline\n" 532 " comment */\n" 533 "int baz = 0; /* multiline\n" 534 "comment */", 535 format("int foobar = 0; /* comment */\n" 536 "int bar = 0; /* multiline\n" 537 "comment */\n" 538 "int baz = 0; /* multiline\n" 539 "comment */")); 540 } 541 542 TEST_F(FormatTestComments, CommentReflowingCanBeTurnedOff) { 543 FormatStyle Style = getLLVMStyleWithColumns(20); 544 Style.ReflowComments = false; 545 verifyFormat("// aaaaaaaaa aaaaaaaaaa aaaaaaaaaa", Style); 546 verifyFormat("/* aaaaaaaaa aaaaaaaaaa aaaaaaaaaa */", Style); 547 } 548 549 TEST_F(FormatTestComments, CorrectlyHandlesLengthOfBlockComments) { 550 EXPECT_EQ("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 551 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */", 552 format("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 553 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */")); 554 EXPECT_EQ( 555 "void ffffffffffff(\n" 556 " int aaaaaaaa, int bbbbbbbb,\n" 557 " int cccccccccccc) { /*\n" 558 " aaaaaaaaaa\n" 559 " aaaaaaaaaaaaa\n" 560 " bbbbbbbbbbbbbb\n" 561 " bbbbbbbbbb\n" 562 " */\n" 563 "}", 564 format("void ffffffffffff(int aaaaaaaa, int bbbbbbbb, int cccccccccccc)\n" 565 "{ /*\n" 566 " aaaaaaaaaa aaaaaaaaaaaaa\n" 567 " bbbbbbbbbbbbbb bbbbbbbbbb\n" 568 " */\n" 569 "}", 570 getLLVMStyleWithColumns(40))); 571 } 572 573 TEST_F(FormatTestComments, DontBreakNonTrailingBlockComments) { 574 EXPECT_EQ("void ffffffffff(\n" 575 " int aaaaa /* test */);", 576 format("void ffffffffff(int aaaaa /* test */);", 577 getLLVMStyleWithColumns(35))); 578 } 579 580 TEST_F(FormatTestComments, SplitsLongCxxComments) { 581 EXPECT_EQ("// A comment that\n" 582 "// doesn't fit on\n" 583 "// one line", 584 format("// A comment that doesn't fit on one line", 585 getLLVMStyleWithColumns(20))); 586 EXPECT_EQ("/// A comment that\n" 587 "/// doesn't fit on\n" 588 "/// one line", 589 format("/// A comment that doesn't fit on one line", 590 getLLVMStyleWithColumns(20))); 591 EXPECT_EQ("//! A comment that\n" 592 "//! doesn't fit on\n" 593 "//! one line", 594 format("//! A comment that doesn't fit on one line", 595 getLLVMStyleWithColumns(20))); 596 EXPECT_EQ("// a b c d\n" 597 "// e f g\n" 598 "// h i j k", 599 format("// a b c d e f g h i j k", getLLVMStyleWithColumns(10))); 600 EXPECT_EQ( 601 "// a b c d\n" 602 "// e f g\n" 603 "// h i j k", 604 format("\\\n// a b c d e f g h i j k", getLLVMStyleWithColumns(10))); 605 EXPECT_EQ("if (true) // A comment that\n" 606 " // doesn't fit on\n" 607 " // one line", 608 format("if (true) // A comment that doesn't fit on one line ", 609 getLLVMStyleWithColumns(30))); 610 EXPECT_EQ("// Don't_touch_leading_whitespace", 611 format("// Don't_touch_leading_whitespace", 612 getLLVMStyleWithColumns(20))); 613 EXPECT_EQ("// Add leading\n" 614 "// whitespace", 615 format("//Add leading whitespace", getLLVMStyleWithColumns(20))); 616 EXPECT_EQ("/// Add leading\n" 617 "/// whitespace", 618 format("///Add leading whitespace", getLLVMStyleWithColumns(20))); 619 EXPECT_EQ("//! Add leading\n" 620 "//! whitespace", 621 format("//!Add leading whitespace", getLLVMStyleWithColumns(20))); 622 EXPECT_EQ("// whitespace", format("//whitespace", getLLVMStyle())); 623 EXPECT_EQ("// Even if it makes the line exceed the column\n" 624 "// limit", 625 format("//Even if it makes the line exceed the column limit", 626 getLLVMStyleWithColumns(51))); 627 EXPECT_EQ("//--But not here", format("//--But not here", getLLVMStyle())); 628 EXPECT_EQ("/// line 1\n" 629 "// add leading whitespace", 630 format("/// line 1\n" 631 "//add leading whitespace", 632 getLLVMStyleWithColumns(30))); 633 EXPECT_EQ("/// line 1\n" 634 "/// line 2\n" 635 "//! line 3\n" 636 "//! line 4\n" 637 "//! line 5\n" 638 "// line 6\n" 639 "// line 7", 640 format("///line 1\n" 641 "///line 2\n" 642 "//! line 3\n" 643 "//!line 4\n" 644 "//!line 5\n" 645 "// line 6\n" 646 "//line 7", getLLVMStyleWithColumns(20))); 647 648 EXPECT_EQ("// aa bb cc dd", 649 format("// aa bb cc dd ", 650 getLLVMStyleWithColumns(15))); 651 652 EXPECT_EQ("// A comment before\n" 653 "// a macro\n" 654 "// definition\n" 655 "#define a b", 656 format("// A comment before a macro definition\n" 657 "#define a b", 658 getLLVMStyleWithColumns(20))); 659 EXPECT_EQ("void ffffff(\n" 660 " int aaaaaaaaa, // wwww\n" 661 " int bbbbbbbbbb, // xxxxxxx\n" 662 " // yyyyyyyyyy\n" 663 " int c, int d, int e) {}", 664 format("void ffffff(\n" 665 " int aaaaaaaaa, // wwww\n" 666 " int bbbbbbbbbb, // xxxxxxx yyyyyyyyyy\n" 667 " int c, int d, int e) {}", 668 getLLVMStyleWithColumns(40))); 669 EXPECT_EQ("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 670 format("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 671 getLLVMStyleWithColumns(20))); 672 EXPECT_EQ( 673 "#define XXX // a b c d\n" 674 " // e f g h", 675 format("#define XXX // a b c d e f g h", getLLVMStyleWithColumns(22))); 676 EXPECT_EQ( 677 "#define XXX // q w e r\n" 678 " // t y u i", 679 format("#define XXX //q w e r t y u i", getLLVMStyleWithColumns(22))); 680 EXPECT_EQ("{\n" 681 " //\n" 682 " //\\\n" 683 " // long 1 2 3 4\n" 684 " // 5\n" 685 "}", 686 format("{\n" 687 " //\n" 688 " //\\\n" 689 " // long 1 2 3 4 5\n" 690 "}", 691 getLLVMStyleWithColumns(20))); 692 } 693 694 TEST_F(FormatTestComments, PreservesHangingIndentInCxxComments) { 695 EXPECT_EQ("// A comment\n" 696 "// that doesn't\n" 697 "// fit on one\n" 698 "// line", 699 format("// A comment that doesn't fit on one line", 700 getLLVMStyleWithColumns(20))); 701 EXPECT_EQ("/// A comment\n" 702 "/// that doesn't\n" 703 "/// fit on one\n" 704 "/// line", 705 format("/// A comment that doesn't fit on one line", 706 getLLVMStyleWithColumns(20))); 707 } 708 709 TEST_F(FormatTestComments, DontSplitLineCommentsWithEscapedNewlines) { 710 EXPECT_EQ("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 711 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 712 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 713 format("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 714 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 715 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")); 716 EXPECT_EQ("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 717 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 718 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 719 format("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 720 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 721 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 722 getLLVMStyleWithColumns(50))); 723 // FIXME: One day we might want to implement adjustment of leading whitespace 724 // of the consecutive lines in this kind of comment: 725 EXPECT_EQ("double\n" 726 " a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 727 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 728 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 729 format("double a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 730 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 731 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 732 getLLVMStyleWithColumns(49))); 733 } 734 735 TEST_F(FormatTestComments, DontSplitLineCommentsWithPragmas) { 736 FormatStyle Pragmas = getLLVMStyleWithColumns(30); 737 Pragmas.CommentPragmas = "^ IWYU pragma:"; 738 EXPECT_EQ( 739 "// IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb", 740 format("// IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb", Pragmas)); 741 EXPECT_EQ( 742 "/* IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb */", 743 format("/* IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb */", Pragmas)); 744 } 745 746 TEST_F(FormatTestComments, PriorityOfCommentBreaking) { 747 EXPECT_EQ("if (xxx ==\n" 748 " yyy && // aaaaaaaaaaaa bbbbbbbbb\n" 749 " zzz)\n" 750 " q();", 751 format("if (xxx == yyy && // aaaaaaaaaaaa bbbbbbbbb\n" 752 " zzz) q();", 753 getLLVMStyleWithColumns(40))); 754 EXPECT_EQ("if (xxxxxxxxxx ==\n" 755 " yyy && // aaaaaa bbbbbbbb cccc\n" 756 " zzz)\n" 757 " q();", 758 format("if (xxxxxxxxxx == yyy && // aaaaaa bbbbbbbb cccc\n" 759 " zzz) q();", 760 getLLVMStyleWithColumns(40))); 761 EXPECT_EQ("if (xxxxxxxxxx &&\n" 762 " yyy || // aaaaaa bbbbbbbb cccc\n" 763 " zzz)\n" 764 " q();", 765 format("if (xxxxxxxxxx && yyy || // aaaaaa bbbbbbbb cccc\n" 766 " zzz) q();", 767 getLLVMStyleWithColumns(40))); 768 EXPECT_EQ("fffffffff(\n" 769 " &xxx, // aaaaaaaaaaaa bbbbbbbbbbb\n" 770 " zzz);", 771 format("fffffffff(&xxx, // aaaaaaaaaaaa bbbbbbbbbbb\n" 772 " zzz);", 773 getLLVMStyleWithColumns(40))); 774 } 775 776 TEST_F(FormatTestComments, MultiLineCommentsInDefines) { 777 EXPECT_EQ("#define A(x) /* \\\n" 778 " a comment \\\n" 779 " inside */ \\\n" 780 " f();", 781 format("#define A(x) /* \\\n" 782 " a comment \\\n" 783 " inside */ \\\n" 784 " f();", 785 getLLVMStyleWithColumns(17))); 786 EXPECT_EQ("#define A( \\\n" 787 " x) /* \\\n" 788 " a comment \\\n" 789 " inside */ \\\n" 790 " f();", 791 format("#define A( \\\n" 792 " x) /* \\\n" 793 " a comment \\\n" 794 " inside */ \\\n" 795 " f();", 796 getLLVMStyleWithColumns(17))); 797 } 798 799 TEST_F(FormatTestComments, ParsesCommentsAdjacentToPPDirectives) { 800 EXPECT_EQ("namespace {}\n// Test\n#define A", 801 format("namespace {}\n // Test\n#define A")); 802 EXPECT_EQ("namespace {}\n/* Test */\n#define A", 803 format("namespace {}\n /* Test */\n#define A")); 804 EXPECT_EQ("namespace {}\n/* Test */ #define A", 805 format("namespace {}\n /* Test */ #define A")); 806 } 807 808 TEST_F(FormatTestComments, KeepsLevelOfCommentBeforePPDirective) { 809 // Keep the current level if the comment was originally not aligned with 810 // the preprocessor directive. 811 EXPECT_EQ("void f() {\n" 812 " int i;\n" 813 " /* comment */\n" 814 "#ifdef A\n" 815 " int j;\n" 816 "}", 817 format("void f() {\n" 818 " int i;\n" 819 " /* comment */\n" 820 "#ifdef A\n" 821 " int j;\n" 822 "}")); 823 824 EXPECT_EQ("void f() {\n" 825 " int i;\n" 826 " /* comment */\n" 827 "\n" 828 "#ifdef A\n" 829 " int j;\n" 830 "}", 831 format("void f() {\n" 832 " int i;\n" 833 " /* comment */\n" 834 "\n" 835 "#ifdef A\n" 836 " int j;\n" 837 "}")); 838 839 // Keep the current level if there is an empty line between the comment and 840 // the preprocessor directive. 841 EXPECT_EQ("void f() {\n" 842 " int i;\n" 843 " /* comment */\n" 844 "\n" 845 "#ifdef A\n" 846 " int j;\n" 847 "}", 848 format("void f() {\n" 849 " int i;\n" 850 "/* comment */\n" 851 "\n" 852 "#ifdef A\n" 853 " int j;\n" 854 "}")); 855 856 // Align with the preprocessor directive if the comment was originally aligned 857 // with the preprocessor directive. 858 EXPECT_EQ("void f() {\n" 859 " int i;\n" 860 "/* comment */\n" 861 "#ifdef A\n" 862 " int j;\n" 863 "}", 864 format("void f() {\n" 865 " int i;\n" 866 "/* comment */\n" 867 "#ifdef A\n" 868 " int j;\n" 869 "}")); 870 } 871 872 TEST_F(FormatTestComments, SplitsLongLinesInComments) { 873 EXPECT_EQ("/* This is a long\n" 874 " * comment that\n" 875 " * doesn't\n" 876 " * fit on one line.\n" 877 " */", 878 format("/* " 879 "This is a long " 880 "comment that " 881 "doesn't " 882 "fit on one line. */", 883 getLLVMStyleWithColumns(20))); 884 EXPECT_EQ( 885 "/* a b c d\n" 886 " * e f g\n" 887 " * h i j k\n" 888 " */", 889 format("/* a b c d e f g h i j k */", getLLVMStyleWithColumns(10))); 890 EXPECT_EQ( 891 "/* a b c d\n" 892 " * e f g\n" 893 " * h i j k\n" 894 " */", 895 format("\\\n/* a b c d e f g h i j k */", getLLVMStyleWithColumns(10))); 896 EXPECT_EQ("/*\n" 897 "This is a long\n" 898 "comment that doesn't\n" 899 "fit on one line.\n" 900 "*/", 901 format("/*\n" 902 "This is a long " 903 "comment that doesn't " 904 "fit on one line. \n" 905 "*/", 906 getLLVMStyleWithColumns(20))); 907 EXPECT_EQ("/*\n" 908 " * This is a long\n" 909 " * comment that\n" 910 " * doesn't fit on\n" 911 " * one line.\n" 912 " */", 913 format("/* \n" 914 " * This is a long " 915 " comment that " 916 " doesn't fit on " 917 " one line. \n" 918 " */", 919 getLLVMStyleWithColumns(20))); 920 EXPECT_EQ("/*\n" 921 " * This_is_a_comment_with_words_that_dont_fit_on_one_line\n" 922 " * so_it_should_be_broken\n" 923 " * wherever_a_space_occurs\n" 924 " */", 925 format("/*\n" 926 " * This_is_a_comment_with_words_that_dont_fit_on_one_line " 927 " so_it_should_be_broken " 928 " wherever_a_space_occurs \n" 929 " */", 930 getLLVMStyleWithColumns(20))); 931 EXPECT_EQ("/*\n" 932 " * This_comment_can_not_be_broken_into_lines\n" 933 " */", 934 format("/*\n" 935 " * This_comment_can_not_be_broken_into_lines\n" 936 " */", 937 getLLVMStyleWithColumns(20))); 938 EXPECT_EQ("{\n" 939 " /*\n" 940 " This is another\n" 941 " long comment that\n" 942 " doesn't fit on one\n" 943 " line 1234567890\n" 944 " */\n" 945 "}", 946 format("{\n" 947 "/*\n" 948 "This is another " 949 " long comment that " 950 " doesn't fit on one" 951 " line 1234567890\n" 952 "*/\n" 953 "}", 954 getLLVMStyleWithColumns(20))); 955 EXPECT_EQ("{\n" 956 " /*\n" 957 " * This i s\n" 958 " * another comment\n" 959 " * t hat doesn' t\n" 960 " * fit on one l i\n" 961 " * n e\n" 962 " */\n" 963 "}", 964 format("{\n" 965 "/*\n" 966 " * This i s" 967 " another comment" 968 " t hat doesn' t" 969 " fit on one l i" 970 " n e\n" 971 " */\n" 972 "}", 973 getLLVMStyleWithColumns(20))); 974 EXPECT_EQ("/*\n" 975 " * This is a long\n" 976 " * comment that\n" 977 " * doesn't fit on\n" 978 " * one line\n" 979 " */", 980 format(" /*\n" 981 " * This is a long comment that doesn't fit on one line\n" 982 " */", 983 getLLVMStyleWithColumns(20))); 984 EXPECT_EQ("{\n" 985 " if (something) /* This is a\n" 986 " long\n" 987 " comment */\n" 988 " ;\n" 989 "}", 990 format("{\n" 991 " if (something) /* This is a long comment */\n" 992 " ;\n" 993 "}", 994 getLLVMStyleWithColumns(30))); 995 996 EXPECT_EQ("/* A comment before\n" 997 " * a macro\n" 998 " * definition */\n" 999 "#define a b", 1000 format("/* A comment before a macro definition */\n" 1001 "#define a b", 1002 getLLVMStyleWithColumns(20))); 1003 1004 EXPECT_EQ("/* some comment\n" 1005 " * a comment that\n" 1006 " * we break another\n" 1007 " * comment we have\n" 1008 " * to break a left\n" 1009 " * comment\n" 1010 " */", 1011 format(" /* some comment\n" 1012 " * a comment that we break\n" 1013 " * another comment we have to break\n" 1014 "* a left comment\n" 1015 " */", 1016 getLLVMStyleWithColumns(20))); 1017 1018 EXPECT_EQ("/**\n" 1019 " * multiline block\n" 1020 " * comment\n" 1021 " *\n" 1022 " */", 1023 format("/**\n" 1024 " * multiline block comment\n" 1025 " *\n" 1026 " */", 1027 getLLVMStyleWithColumns(20))); 1028 1029 EXPECT_EQ("/*\n" 1030 "\n" 1031 "\n" 1032 " */\n", 1033 format(" /* \n" 1034 " \n" 1035 " \n" 1036 " */\n")); 1037 1038 EXPECT_EQ("/* a a */", 1039 format("/* a a */", getLLVMStyleWithColumns(15))); 1040 EXPECT_EQ("/* a a bc */", 1041 format("/* a a bc */", getLLVMStyleWithColumns(15))); 1042 EXPECT_EQ("/* aaa aaa\n" 1043 " * aaaaa */", 1044 format("/* aaa aaa aaaaa */", getLLVMStyleWithColumns(15))); 1045 EXPECT_EQ("/* aaa aaa\n" 1046 " * aaaaa */", 1047 format("/* aaa aaa aaaaa */", getLLVMStyleWithColumns(15))); 1048 } 1049 1050 TEST_F(FormatTestComments, SplitsLongLinesInCommentsInPreprocessor) { 1051 EXPECT_EQ("#define X \\\n" 1052 " /* \\\n" 1053 " Test \\\n" 1054 " Macro comment \\\n" 1055 " with a long \\\n" 1056 " line \\\n" 1057 " */ \\\n" 1058 " A + B", 1059 format("#define X \\\n" 1060 " /*\n" 1061 " Test\n" 1062 " Macro comment with a long line\n" 1063 " */ \\\n" 1064 " A + B", 1065 getLLVMStyleWithColumns(20))); 1066 EXPECT_EQ("#define X \\\n" 1067 " /* Macro comment \\\n" 1068 " with a long \\\n" 1069 " line */ \\\n" 1070 " A + B", 1071 format("#define X \\\n" 1072 " /* Macro comment with a long\n" 1073 " line */ \\\n" 1074 " A + B", 1075 getLLVMStyleWithColumns(20))); 1076 EXPECT_EQ("#define X \\\n" 1077 " /* Macro comment \\\n" 1078 " * with a long \\\n" 1079 " * line */ \\\n" 1080 " A + B", 1081 format("#define X \\\n" 1082 " /* Macro comment with a long line */ \\\n" 1083 " A + B", 1084 getLLVMStyleWithColumns(20))); 1085 } 1086 1087 TEST_F(FormatTestComments, KeepsTrailingPPCommentsAndSectionCommentsSeparate) { 1088 verifyFormat("#ifdef A // line about A\n" 1089 "// section comment\n" 1090 "#endif", 1091 getLLVMStyleWithColumns(80)); 1092 verifyFormat("#ifdef A // line 1 about A\n" 1093 " // line 2 about A\n" 1094 "// section comment\n" 1095 "#endif", 1096 getLLVMStyleWithColumns(80)); 1097 EXPECT_EQ("#ifdef A // line 1 about A\n" 1098 " // line 2 about A\n" 1099 "// section comment\n" 1100 "#endif", 1101 format("#ifdef A // line 1 about A\n" 1102 " // line 2 about A\n" 1103 "// section comment\n" 1104 "#endif", 1105 getLLVMStyleWithColumns(80))); 1106 verifyFormat("int f() {\n" 1107 " int i;\n" 1108 "#ifdef A // comment about A\n" 1109 " // section comment 1\n" 1110 " // section comment 2\n" 1111 " i = 2;\n" 1112 "#else // comment about #else\n" 1113 " // section comment 3\n" 1114 " i = 4;\n" 1115 "#endif\n" 1116 "}", getLLVMStyleWithColumns(80)); 1117 } 1118 1119 TEST_F(FormatTestComments, AlignsPPElseEndifComments) { 1120 verifyFormat("#if A\n" 1121 "#else // A\n" 1122 "int iiii;\n" 1123 "#endif // B", 1124 getLLVMStyleWithColumns(20)); 1125 verifyFormat("#if A\n" 1126 "#else // A\n" 1127 "int iiii; // CC\n" 1128 "#endif // B", 1129 getLLVMStyleWithColumns(20)); 1130 EXPECT_EQ("#if A\n" 1131 "#else // A1\n" 1132 " // A2\n" 1133 "int ii;\n" 1134 "#endif // B", 1135 format("#if A\n" 1136 "#else // A1\n" 1137 " // A2\n" 1138 "int ii;\n" 1139 "#endif // B", 1140 getLLVMStyleWithColumns(20))); 1141 } 1142 1143 TEST_F(FormatTestComments, CommentsInStaticInitializers) { 1144 EXPECT_EQ( 1145 "static SomeType type = {aaaaaaaaaaaaaaaaaaaa, /* comment */\n" 1146 " aaaaaaaaaaaaaaaaaaaa /* comment */,\n" 1147 " /* comment */ aaaaaaaaaaaaaaaaaaaa,\n" 1148 " aaaaaaaaaaaaaaaaaaaa, // comment\n" 1149 " aaaaaaaaaaaaaaaaaaaa};", 1150 format("static SomeType type = { aaaaaaaaaaaaaaaaaaaa , /* comment */\n" 1151 " aaaaaaaaaaaaaaaaaaaa /* comment */ ,\n" 1152 " /* comment */ aaaaaaaaaaaaaaaaaaaa ,\n" 1153 " aaaaaaaaaaaaaaaaaaaa , // comment\n" 1154 " aaaaaaaaaaaaaaaaaaaa };")); 1155 verifyFormat("static SomeType type = {aaaaaaaaaaa, // comment for aa...\n" 1156 " bbbbbbbbbbb, ccccccccccc};"); 1157 verifyFormat("static SomeType type = {aaaaaaaaaaa,\n" 1158 " // comment for bb....\n" 1159 " bbbbbbbbbbb, ccccccccccc};"); 1160 verifyGoogleFormat( 1161 "static SomeType type = {aaaaaaaaaaa, // comment for aa...\n" 1162 " bbbbbbbbbbb, ccccccccccc};"); 1163 verifyGoogleFormat("static SomeType type = {aaaaaaaaaaa,\n" 1164 " // comment for bb....\n" 1165 " bbbbbbbbbbb, ccccccccccc};"); 1166 1167 verifyFormat("S s = {{a, b, c}, // Group #1\n" 1168 " {d, e, f}, // Group #2\n" 1169 " {g, h, i}}; // Group #3"); 1170 verifyFormat("S s = {{// Group #1\n" 1171 " a, b, c},\n" 1172 " {// Group #2\n" 1173 " d, e, f},\n" 1174 " {// Group #3\n" 1175 " g, h, i}};"); 1176 1177 EXPECT_EQ("S s = {\n" 1178 " // Some comment\n" 1179 " a,\n" 1180 "\n" 1181 " // Comment after empty line\n" 1182 " b}", 1183 format("S s = {\n" 1184 " // Some comment\n" 1185 " a,\n" 1186 " \n" 1187 " // Comment after empty line\n" 1188 " b\n" 1189 "}")); 1190 EXPECT_EQ("S s = {\n" 1191 " /* Some comment */\n" 1192 " a,\n" 1193 "\n" 1194 " /* Comment after empty line */\n" 1195 " b}", 1196 format("S s = {\n" 1197 " /* Some comment */\n" 1198 " a,\n" 1199 " \n" 1200 " /* Comment after empty line */\n" 1201 " b\n" 1202 "}")); 1203 verifyFormat("const uint8_t aaaaaaaaaaaaaaaaaaaaaa[0] = {\n" 1204 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n" 1205 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n" 1206 " 0x00, 0x00, 0x00, 0x00}; // comment\n"); 1207 } 1208 1209 TEST_F(FormatTestComments, LineCommentsAfterRightBrace) { 1210 EXPECT_EQ("if (true) { // comment about branch\n" 1211 " // comment about f\n" 1212 " f();\n" 1213 "}", 1214 format("if (true) { // comment about branch\n" 1215 " // comment about f\n" 1216 " f();\n" 1217 "}", 1218 getLLVMStyleWithColumns(80))); 1219 EXPECT_EQ("if (1) { // if line 1\n" 1220 " // if line 2\n" 1221 " // if line 3\n" 1222 " // f line 1\n" 1223 " // f line 2\n" 1224 " f();\n" 1225 "} else { // else line 1\n" 1226 " // else line 2\n" 1227 " // else line 3\n" 1228 " // g line 1\n" 1229 " g();\n" 1230 "}", 1231 format("if (1) { // if line 1\n" 1232 " // if line 2\n" 1233 " // if line 3\n" 1234 " // f line 1\n" 1235 " // f line 2\n" 1236 " f();\n" 1237 "} else { // else line 1\n" 1238 " // else line 2\n" 1239 " // else line 3\n" 1240 " // g line 1\n" 1241 " g();\n" 1242 "}")); 1243 EXPECT_EQ("do { // line 1\n" 1244 " // line 2\n" 1245 " // line 3\n" 1246 " f();\n" 1247 "} while (true);", 1248 format("do { // line 1\n" 1249 " // line 2\n" 1250 " // line 3\n" 1251 " f();\n" 1252 "} while (true);", 1253 getLLVMStyleWithColumns(80))); 1254 EXPECT_EQ("while (a < b) { // line 1\n" 1255 " // line 2\n" 1256 " // line 3\n" 1257 " f();\n" 1258 "}", 1259 format("while (a < b) {// line 1\n" 1260 " // line 2\n" 1261 " // line 3\n" 1262 " f();\n" 1263 "}", 1264 getLLVMStyleWithColumns(80))); 1265 } 1266 1267 TEST_F(FormatTestComments, ReflowsComments) { 1268 // Break a long line and reflow with the full next line. 1269 EXPECT_EQ("// long long long\n" 1270 "// long long", 1271 format("// long long long long\n" 1272 "// long", 1273 getLLVMStyleWithColumns(20))); 1274 1275 // Keep the trailing newline while reflowing. 1276 EXPECT_EQ("// long long long\n" 1277 "// long long\n", 1278 format("// long long long long\n" 1279 "// long\n", 1280 getLLVMStyleWithColumns(20))); 1281 1282 // Break a long line and reflow with a part of the next line. 1283 EXPECT_EQ("// long long long\n" 1284 "// long long\n" 1285 "// long_long", 1286 format("// long long long long\n" 1287 "// long long_long", 1288 getLLVMStyleWithColumns(20))); 1289 1290 // Break but do not reflow if the first word from the next line is too long. 1291 EXPECT_EQ("// long long long\n" 1292 "// long\n" 1293 "// long_long_long\n", 1294 format("// long long long long\n" 1295 "// long_long_long\n", 1296 getLLVMStyleWithColumns(20))); 1297 1298 // Don't break or reflow short lines. 1299 verifyFormat("// long\n" 1300 "// long long long lo\n" 1301 "// long long long lo\n" 1302 "// long", 1303 getLLVMStyleWithColumns(20)); 1304 1305 // Keep prefixes and decorations while reflowing. 1306 EXPECT_EQ("/// long long long\n" 1307 "/// long long\n", 1308 format("/// long long long long\n" 1309 "/// long\n", 1310 getLLVMStyleWithColumns(20))); 1311 EXPECT_EQ("//! long long long\n" 1312 "//! long long\n", 1313 format("//! long long long long\n" 1314 "//! long\n", 1315 getLLVMStyleWithColumns(20))); 1316 EXPECT_EQ("/* long long long\n" 1317 " * long long */", 1318 format("/* long long long long\n" 1319 " * long */", 1320 getLLVMStyleWithColumns(20))); 1321 EXPECT_EQ("///< long long long\n" 1322 "///< long long\n", 1323 format("///< long long long long\n" 1324 "///< long\n", 1325 getLLVMStyleWithColumns(20))); 1326 EXPECT_EQ("//!< long long long\n" 1327 "//!< long long\n", 1328 format("//!< long long long long\n" 1329 "//!< long\n", 1330 getLLVMStyleWithColumns(20))); 1331 1332 // Don't bring leading whitespace up while reflowing. 1333 EXPECT_EQ("/* long long long\n" 1334 " * long long long\n" 1335 " */", 1336 format("/* long long long long\n" 1337 " * long long\n" 1338 " */", 1339 getLLVMStyleWithColumns(20))); 1340 1341 // Reflow the last line of a block comment with its trailing '*/'. 1342 EXPECT_EQ("/* long long long\n" 1343 " long long */", 1344 format("/* long long long long\n" 1345 " long */", 1346 getLLVMStyleWithColumns(20))); 1347 1348 // Reflow two short lines; keep the postfix of the last one. 1349 EXPECT_EQ("/* long long long\n" 1350 " * long long long */", 1351 format("/* long long long long\n" 1352 " * long\n" 1353 " * long */", 1354 getLLVMStyleWithColumns(20))); 1355 1356 // Put the postfix of the last short reflow line on a newline if it doesn't 1357 // fit. 1358 EXPECT_EQ("/* long long long\n" 1359 " * long long longg\n" 1360 " */", 1361 format("/* long long long long\n" 1362 " * long\n" 1363 " * longg */", 1364 getLLVMStyleWithColumns(20))); 1365 1366 // Reflow lines with leading whitespace. 1367 EXPECT_EQ("{\n" 1368 " /*\n" 1369 " * long long long\n" 1370 " * long long long\n" 1371 " * long long long\n" 1372 " */\n" 1373 "}", 1374 format("{\n" 1375 "/*\n" 1376 " * long long long long\n" 1377 " * long\n" 1378 " * long long long long\n" 1379 " */\n" 1380 "}", 1381 getLLVMStyleWithColumns(20))); 1382 1383 // Break single line block comments that are first in the line with ' *' 1384 // decoration. 1385 EXPECT_EQ("/* long long long\n" 1386 " * long */", 1387 format("/* long long long long */", getLLVMStyleWithColumns(20))); 1388 1389 // Break single line block comment that are not first in the line with ' ' 1390 // decoration. 1391 EXPECT_EQ("int i; /* long long\n" 1392 " long */", 1393 format("int i; /* long long long */", getLLVMStyleWithColumns(20))); 1394 1395 // Reflow a line that goes just over the column limit. 1396 EXPECT_EQ("// long long long\n" 1397 "// lon long", 1398 format("// long long long lon\n" 1399 "// long", 1400 getLLVMStyleWithColumns(20))); 1401 1402 // Stop reflowing if the next line has a different indentation than the 1403 // previous line. 1404 EXPECT_EQ("// long long long\n" 1405 "// long\n" 1406 "// long long\n" 1407 "// long", 1408 format("// long long long long\n" 1409 "// long long\n" 1410 "// long", 1411 getLLVMStyleWithColumns(20))); 1412 1413 // Reflow into the last part of a really long line that has been broken into 1414 // multiple lines. 1415 EXPECT_EQ("// long long long\n" 1416 "// long long long\n" 1417 "// long long long\n", 1418 format("// long long long long long long long long\n" 1419 "// long\n", 1420 getLLVMStyleWithColumns(20))); 1421 1422 // Break the first line, then reflow the beginning of the second and third 1423 // line up. 1424 EXPECT_EQ("// long long long\n" 1425 "// lon1 lon2 lon2\n" 1426 "// lon2 lon3 lon3", 1427 format("// long long long lon1\n" 1428 "// lon2 lon2 lon2\n" 1429 "// lon3 lon3", 1430 getLLVMStyleWithColumns(20))); 1431 1432 // Reflow the beginning of the second line, then break the rest. 1433 EXPECT_EQ("// long long long\n" 1434 "// lon1 lon2 lon2\n" 1435 "// lon2 lon2 lon2\n" 1436 "// lon3", 1437 format("// long long long lon1\n" 1438 "// lon2 lon2 lon2 lon2 lon2 lon3", 1439 getLLVMStyleWithColumns(20))); 1440 1441 // Shrink the first line, then reflow the second line up. 1442 EXPECT_EQ("// long long long", format("// long long\n" 1443 "// long", 1444 getLLVMStyleWithColumns(20))); 1445 1446 // Don't shrink leading whitespace. 1447 EXPECT_EQ("int i; /// a", 1448 format("int i; /// a", getLLVMStyleWithColumns(20))); 1449 1450 // Shrink trailing whitespace if there is no postfix and reflow. 1451 EXPECT_EQ("// long long long\n" 1452 "// long long", 1453 format("// long long long long \n" 1454 "// long", 1455 getLLVMStyleWithColumns(20))); 1456 1457 // Shrink trailing whitespace to a single one if there is postfix. 1458 EXPECT_EQ("/* long long long */", 1459 format("/* long long long */", getLLVMStyleWithColumns(20))); 1460 1461 // Break a block comment postfix if exceeding the line limit. 1462 EXPECT_EQ("/* long\n" 1463 " */", 1464 format("/* long */", getLLVMStyleWithColumns(20))); 1465 1466 // Reflow indented comments. 1467 EXPECT_EQ("{\n" 1468 " // long long long\n" 1469 " // long long\n" 1470 " int i; /* long lon\n" 1471 " g long\n" 1472 " */\n" 1473 "}", 1474 format("{\n" 1475 " // long long long long\n" 1476 " // long\n" 1477 " int i; /* long lon g\n" 1478 " long */\n" 1479 "}", 1480 getLLVMStyleWithColumns(20))); 1481 1482 // Don't realign trailing comments after reflow has happened. 1483 EXPECT_EQ("// long long long\n" 1484 "// long long\n" 1485 "long i; // long", 1486 format("// long long long long\n" 1487 "// long\n" 1488 "long i; // long", 1489 getLLVMStyleWithColumns(20))); 1490 EXPECT_EQ("// long long long\n" 1491 "// longng long long\n" 1492 "// long lo", 1493 format("// long long long longng\n" 1494 "// long long long\n" 1495 "// lo", 1496 getLLVMStyleWithColumns(20))); 1497 1498 // Reflow lines after a broken line. 1499 EXPECT_EQ("int a; // Trailing\n" 1500 " // comment on\n" 1501 " // 2 or 3\n" 1502 " // lines.\n", 1503 format("int a; // Trailing comment\n" 1504 " // on 2\n" 1505 " // or 3\n" 1506 " // lines.\n", 1507 getLLVMStyleWithColumns(20))); 1508 EXPECT_EQ("/// This long line\n" 1509 "/// gets reflown.\n", 1510 format("/// This long line gets\n" 1511 "/// reflown.\n", 1512 getLLVMStyleWithColumns(20))); 1513 EXPECT_EQ("//! This long line\n" 1514 "//! gets reflown.\n", 1515 format(" //! This long line gets\n" 1516 " //! reflown.\n", 1517 getLLVMStyleWithColumns(20))); 1518 EXPECT_EQ("/* This long line\n" 1519 " * gets reflown.\n" 1520 " */\n", 1521 format("/* This long line gets\n" 1522 " * reflown.\n" 1523 " */\n", 1524 getLLVMStyleWithColumns(20))); 1525 1526 // Reflow after indentation makes a line too long. 1527 EXPECT_EQ("{\n" 1528 " // long long long\n" 1529 " // lo long\n" 1530 "}\n", 1531 format("{\n" 1532 "// long long long lo\n" 1533 "// long\n" 1534 "}\n", 1535 getLLVMStyleWithColumns(20))); 1536 1537 // Break and reflow multiple lines. 1538 EXPECT_EQ("/*\n" 1539 " * Reflow the end of\n" 1540 " * line by 11 22 33\n" 1541 " * 4.\n" 1542 " */\n", 1543 format("/*\n" 1544 " * Reflow the end of line\n" 1545 " * by\n" 1546 " * 11\n" 1547 " * 22\n" 1548 " * 33\n" 1549 " * 4.\n" 1550 " */\n", 1551 getLLVMStyleWithColumns(20))); 1552 EXPECT_EQ("/// First line gets\n" 1553 "/// broken. Second\n" 1554 "/// line gets\n" 1555 "/// reflown and\n" 1556 "/// broken. Third\n" 1557 "/// gets reflown.\n", 1558 format("/// First line gets broken.\n" 1559 "/// Second line gets reflown and broken.\n" 1560 "/// Third gets reflown.\n", 1561 getLLVMStyleWithColumns(20))); 1562 EXPECT_EQ("int i; // first long\n" 1563 " // long snd\n" 1564 " // long.\n", 1565 format("int i; // first long long\n" 1566 " // snd long.\n", 1567 getLLVMStyleWithColumns(20))); 1568 EXPECT_EQ("{\n" 1569 " // first long line\n" 1570 " // line second\n" 1571 " // long line line\n" 1572 " // third long line\n" 1573 " // line\n" 1574 "}\n", 1575 format("{\n" 1576 " // first long line line\n" 1577 " // second long line line\n" 1578 " // third long line line\n" 1579 "}\n", 1580 getLLVMStyleWithColumns(20))); 1581 EXPECT_EQ("int i; /* first line\n" 1582 " * second\n" 1583 " * line third\n" 1584 " * line\n" 1585 " */", 1586 format("int i; /* first line\n" 1587 " * second line\n" 1588 " * third line\n" 1589 " */", 1590 getLLVMStyleWithColumns(20))); 1591 1592 // Reflow the last two lines of a section that starts with a line having 1593 // different indentation. 1594 EXPECT_EQ( 1595 "// long\n" 1596 "// long long long\n" 1597 "// long long", 1598 format("// long\n" 1599 "// long long long long\n" 1600 "// long", 1601 getLLVMStyleWithColumns(20))); 1602 1603 // Keep the block comment endling '*/' while reflowing. 1604 EXPECT_EQ("/* Long long long\n" 1605 " * line short */\n", 1606 format("/* Long long long line\n" 1607 " * short */\n", 1608 getLLVMStyleWithColumns(20))); 1609 1610 // Don't reflow between separate blocks of comments. 1611 EXPECT_EQ("/* First comment\n" 1612 " * block will */\n" 1613 "/* Snd\n" 1614 " */\n", 1615 format("/* First comment block\n" 1616 " * will */\n" 1617 "/* Snd\n" 1618 " */\n", 1619 getLLVMStyleWithColumns(20))); 1620 1621 // Don't reflow across blank comment lines. 1622 EXPECT_EQ("int i; // This long\n" 1623 " // line gets\n" 1624 " // broken.\n" 1625 " //\n" 1626 " // keep.\n", 1627 format("int i; // This long line gets broken.\n" 1628 " // \n" 1629 " // keep.\n", 1630 getLLVMStyleWithColumns(20))); 1631 EXPECT_EQ("{\n" 1632 " /// long long long\n" 1633 " /// long long\n" 1634 " ///\n" 1635 " /// long\n" 1636 "}", 1637 format("{\n" 1638 " /// long long long long\n" 1639 " /// long\n" 1640 " ///\n" 1641 " /// long\n" 1642 "}", 1643 getLLVMStyleWithColumns(20))); 1644 EXPECT_EQ("//! long long long\n" 1645 "//! long\n" 1646 "\n" 1647 "//! long", 1648 format("//! long long long long\n" 1649 "\n" 1650 "//! long", 1651 getLLVMStyleWithColumns(20))); 1652 EXPECT_EQ("/* long long long\n" 1653 " long\n" 1654 "\n" 1655 " long */", 1656 format("/* long long long long\n" 1657 "\n" 1658 " long */", 1659 getLLVMStyleWithColumns(20))); 1660 EXPECT_EQ("/* long long long\n" 1661 " * long\n" 1662 " *\n" 1663 " * long */", 1664 format("/* long long long long\n" 1665 " *\n" 1666 " * long */", 1667 getLLVMStyleWithColumns(20))); 1668 1669 // Don't reflow lines having content that is a single character. 1670 EXPECT_EQ("// long long long\n" 1671 "// long\n" 1672 "// l", 1673 format("// long long long long\n" 1674 "// l", 1675 getLLVMStyleWithColumns(20))); 1676 1677 // Don't reflow lines starting with two punctuation characters. 1678 EXPECT_EQ("// long long long\n" 1679 "// long\n" 1680 "// ... --- ...", 1681 format( 1682 "// long long long long\n" 1683 "// ... --- ...", 1684 getLLVMStyleWithColumns(20))); 1685 1686 // Don't reflow lines starting with '@'. 1687 EXPECT_EQ("// long long long\n" 1688 "// long\n" 1689 "// @param arg", 1690 format("// long long long long\n" 1691 "// @param arg", 1692 getLLVMStyleWithColumns(20))); 1693 1694 // Don't reflow lines starting with 'TODO'. 1695 EXPECT_EQ("// long long long\n" 1696 "// long\n" 1697 "// TODO: long", 1698 format("// long long long long\n" 1699 "// TODO: long", 1700 getLLVMStyleWithColumns(20))); 1701 1702 // Don't reflow lines starting with 'FIXME'. 1703 EXPECT_EQ("// long long long\n" 1704 "// long\n" 1705 "// FIXME: long", 1706 format("// long long long long\n" 1707 "// FIXME: long", 1708 getLLVMStyleWithColumns(20))); 1709 1710 // Don't reflow lines starting with 'XXX'. 1711 EXPECT_EQ("// long long long\n" 1712 "// long\n" 1713 "// XXX: long", 1714 format("// long long long long\n" 1715 "// XXX: long", 1716 getLLVMStyleWithColumns(20))); 1717 1718 // Don't reflow comment pragmas. 1719 EXPECT_EQ("// long long long\n" 1720 "// long\n" 1721 "// IWYU pragma:", 1722 format("// long long long long\n" 1723 "// IWYU pragma:", 1724 getLLVMStyleWithColumns(20))); 1725 EXPECT_EQ("/* long long long\n" 1726 " * long\n" 1727 " * IWYU pragma:\n" 1728 " */", 1729 format("/* long long long long\n" 1730 " * IWYU pragma:\n" 1731 " */", 1732 getLLVMStyleWithColumns(20))); 1733 1734 // Reflow lines that have a non-punctuation character among their first 2 1735 // characters. 1736 EXPECT_EQ("// long long long\n" 1737 "// long 'long'", 1738 format( 1739 "// long long long long\n" 1740 "// 'long'", 1741 getLLVMStyleWithColumns(20))); 1742 1743 // Don't reflow between separate blocks of comments. 1744 EXPECT_EQ("/* First comment\n" 1745 " * block will */\n" 1746 "/* Snd\n" 1747 " */\n", 1748 format("/* First comment block\n" 1749 " * will */\n" 1750 "/* Snd\n" 1751 " */\n", 1752 getLLVMStyleWithColumns(20))); 1753 1754 // Don't reflow lines having different indentation. 1755 EXPECT_EQ("// long long long\n" 1756 "// long\n" 1757 "// long", 1758 format("// long long long long\n" 1759 "// long", 1760 getLLVMStyleWithColumns(20))); 1761 1762 // Don't reflow separate bullets in list 1763 EXPECT_EQ("// - long long long\n" 1764 "// long\n" 1765 "// - long", 1766 format("// - long long long long\n" 1767 "// - long", 1768 getLLVMStyleWithColumns(20))); 1769 EXPECT_EQ("// * long long long\n" 1770 "// long\n" 1771 "// * long", 1772 format("// * long long long long\n" 1773 "// * long", 1774 getLLVMStyleWithColumns(20))); 1775 EXPECT_EQ("// + long long long\n" 1776 "// long\n" 1777 "// + long", 1778 format("// + long long long long\n" 1779 "// + long", 1780 getLLVMStyleWithColumns(20))); 1781 EXPECT_EQ("// 1. long long long\n" 1782 "// long\n" 1783 "// 2. long", 1784 format("// 1. long long long long\n" 1785 "// 2. long", 1786 getLLVMStyleWithColumns(20))); 1787 EXPECT_EQ("// -# long long long\n" 1788 "// long\n" 1789 "// -# long", 1790 format("// -# long long long long\n" 1791 "// -# long", 1792 getLLVMStyleWithColumns(20))); 1793 1794 EXPECT_EQ("// - long long long\n" 1795 "// long long long\n" 1796 "// - long", 1797 format("// - long long long long\n" 1798 "// long long\n" 1799 "// - long", 1800 getLLVMStyleWithColumns(20))); 1801 EXPECT_EQ("// - long long long\n" 1802 "// long long long\n" 1803 "// long\n" 1804 "// - long", 1805 format("// - long long long long\n" 1806 "// long long long\n" 1807 "// - long", 1808 getLLVMStyleWithColumns(20))); 1809 1810 // Large number (>2 digits) are not list items 1811 EXPECT_EQ("// long long long\n" 1812 "// long 1024. long.", 1813 format("// long long long long\n" 1814 "// 1024. long.", 1815 getLLVMStyleWithColumns(20))); 1816 1817 // Do not break before number, to avoid introducing a non-reflowable doxygen 1818 // list item. 1819 EXPECT_EQ("// long long\n" 1820 "// long 10. long.", 1821 format("// long long long 10.\n" 1822 "// long.", 1823 getLLVMStyleWithColumns(20))); 1824 1825 // Don't break or reflow after implicit string literals. 1826 verifyFormat("#include <t> // l l l\n" 1827 " // l", 1828 getLLVMStyleWithColumns(20)); 1829 1830 // Don't break or reflow comments on import lines. 1831 EXPECT_EQ("#include \"t\" /* l l l\n" 1832 " * l */", 1833 format("#include \"t\" /* l l l\n" 1834 " * l */", 1835 getLLVMStyleWithColumns(20))); 1836 1837 // Don't reflow between different trailing comment sections. 1838 EXPECT_EQ("int i; // long long\n" 1839 " // long\n" 1840 "int j; // long long\n" 1841 " // long\n", 1842 format("int i; // long long long\n" 1843 "int j; // long long long\n", 1844 getLLVMStyleWithColumns(20))); 1845 1846 // Don't reflow if the first word on the next line is longer than the 1847 // available space at current line. 1848 EXPECT_EQ("int i; // trigger\n" 1849 " // reflow\n" 1850 " // longsec\n", 1851 format("int i; // trigger reflow\n" 1852 " // longsec\n", 1853 getLLVMStyleWithColumns(20))); 1854 1855 // Keep empty comment lines. 1856 EXPECT_EQ("/**/", format(" /**/", getLLVMStyleWithColumns(20))); 1857 EXPECT_EQ("/* */", format(" /* */", getLLVMStyleWithColumns(20))); 1858 EXPECT_EQ("/* */", format(" /* */", getLLVMStyleWithColumns(20))); 1859 EXPECT_EQ("//", format(" // ", getLLVMStyleWithColumns(20))); 1860 EXPECT_EQ("///", format(" /// ", getLLVMStyleWithColumns(20))); 1861 } 1862 1863 TEST_F(FormatTestComments, IgnoresIf0Contents) { 1864 EXPECT_EQ("#if 0\n" 1865 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 1866 "#endif\n" 1867 "void f() {}", 1868 format("#if 0\n" 1869 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 1870 "#endif\n" 1871 "void f( ) { }")); 1872 EXPECT_EQ("#if false\n" 1873 "void f( ) { }\n" 1874 "#endif\n" 1875 "void g() {}\n", 1876 format("#if false\n" 1877 "void f( ) { }\n" 1878 "#endif\n" 1879 "void g( ) { }\n")); 1880 EXPECT_EQ("enum E {\n" 1881 " One,\n" 1882 " Two,\n" 1883 "#if 0\n" 1884 "Three,\n" 1885 " Four,\n" 1886 "#endif\n" 1887 " Five\n" 1888 "};", 1889 format("enum E {\n" 1890 " One,Two,\n" 1891 "#if 0\n" 1892 "Three,\n" 1893 " Four,\n" 1894 "#endif\n" 1895 " Five};")); 1896 EXPECT_EQ("enum F {\n" 1897 " One,\n" 1898 "#if 1\n" 1899 " Two,\n" 1900 "#if 0\n" 1901 "Three,\n" 1902 " Four,\n" 1903 "#endif\n" 1904 " Five\n" 1905 "#endif\n" 1906 "};", 1907 format("enum F {\n" 1908 "One,\n" 1909 "#if 1\n" 1910 "Two,\n" 1911 "#if 0\n" 1912 "Three,\n" 1913 " Four,\n" 1914 "#endif\n" 1915 "Five\n" 1916 "#endif\n" 1917 "};")); 1918 EXPECT_EQ("enum G {\n" 1919 " One,\n" 1920 "#if 0\n" 1921 "Two,\n" 1922 "#else\n" 1923 " Three,\n" 1924 "#endif\n" 1925 " Four\n" 1926 "};", 1927 format("enum G {\n" 1928 "One,\n" 1929 "#if 0\n" 1930 "Two,\n" 1931 "#else\n" 1932 "Three,\n" 1933 "#endif\n" 1934 "Four\n" 1935 "};")); 1936 EXPECT_EQ("enum H {\n" 1937 " One,\n" 1938 "#if 0\n" 1939 "#ifdef Q\n" 1940 "Two,\n" 1941 "#else\n" 1942 "Three,\n" 1943 "#endif\n" 1944 "#endif\n" 1945 " Four\n" 1946 "};", 1947 format("enum H {\n" 1948 "One,\n" 1949 "#if 0\n" 1950 "#ifdef Q\n" 1951 "Two,\n" 1952 "#else\n" 1953 "Three,\n" 1954 "#endif\n" 1955 "#endif\n" 1956 "Four\n" 1957 "};")); 1958 EXPECT_EQ("enum I {\n" 1959 " One,\n" 1960 "#if /* test */ 0 || 1\n" 1961 "Two,\n" 1962 "Three,\n" 1963 "#endif\n" 1964 " Four\n" 1965 "};", 1966 format("enum I {\n" 1967 "One,\n" 1968 "#if /* test */ 0 || 1\n" 1969 "Two,\n" 1970 "Three,\n" 1971 "#endif\n" 1972 "Four\n" 1973 "};")); 1974 EXPECT_EQ("enum J {\n" 1975 " One,\n" 1976 "#if 0\n" 1977 "#if 0\n" 1978 "Two,\n" 1979 "#else\n" 1980 "Three,\n" 1981 "#endif\n" 1982 "Four,\n" 1983 "#endif\n" 1984 " Five\n" 1985 "};", 1986 format("enum J {\n" 1987 "One,\n" 1988 "#if 0\n" 1989 "#if 0\n" 1990 "Two,\n" 1991 "#else\n" 1992 "Three,\n" 1993 "#endif\n" 1994 "Four,\n" 1995 "#endif\n" 1996 "Five\n" 1997 "};")); 1998 1999 // Ignore stuff in SWIG-blocks. 2000 EXPECT_EQ("#ifdef SWIG\n" 2001 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 2002 "#endif\n" 2003 "void f() {}", 2004 format("#ifdef SWIG\n" 2005 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 2006 "#endif\n" 2007 "void f( ) { }")); 2008 EXPECT_EQ("#ifndef SWIG\n" 2009 "void f() {}\n" 2010 "#endif", 2011 format("#ifndef SWIG\n" 2012 "void f( ) { }\n" 2013 "#endif")); 2014 } 2015 2016 TEST_F(FormatTestComments, DontCrashOnBlockComments) { 2017 EXPECT_EQ( 2018 "int xxxxxxxxx; /* " 2019 "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy\n" 2020 "zzzzzz\n" 2021 "0*/", 2022 format("int xxxxxxxxx; /* " 2023 "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy zzzzzz\n" 2024 "0*/")); 2025 } 2026 2027 TEST_F(FormatTestComments, BlockCommentsInControlLoops) { 2028 verifyFormat("if (0) /* a comment in a strange place */ {\n" 2029 " f();\n" 2030 "}"); 2031 verifyFormat("if (0) /* a comment in a strange place */ {\n" 2032 " f();\n" 2033 "} /* another comment */ else /* comment #3 */ {\n" 2034 " g();\n" 2035 "}"); 2036 verifyFormat("while (0) /* a comment in a strange place */ {\n" 2037 " f();\n" 2038 "}"); 2039 verifyFormat("for (;;) /* a comment in a strange place */ {\n" 2040 " f();\n" 2041 "}"); 2042 verifyFormat("do /* a comment in a strange place */ {\n" 2043 " f();\n" 2044 "} /* another comment */ while (0);"); 2045 } 2046 2047 TEST_F(FormatTestComments, BlockComments) { 2048 EXPECT_EQ("/* */ /* */ /* */\n/* */ /* */ /* */", 2049 format("/* *//* */ /* */\n/* *//* */ /* */")); 2050 EXPECT_EQ("/* */ a /* */ b;", format(" /* */ a/* */ b;")); 2051 EXPECT_EQ("#define A /*123*/ \\\n" 2052 " b\n" 2053 "/* */\n" 2054 "someCall(\n" 2055 " parameter);", 2056 format("#define A /*123*/ b\n" 2057 "/* */\n" 2058 "someCall(parameter);", 2059 getLLVMStyleWithColumns(15))); 2060 2061 EXPECT_EQ("#define A\n" 2062 "/* */ someCall(\n" 2063 " parameter);", 2064 format("#define A\n" 2065 "/* */someCall(parameter);", 2066 getLLVMStyleWithColumns(15))); 2067 EXPECT_EQ("/*\n**\n*/", format("/*\n**\n*/")); 2068 EXPECT_EQ("/*\n" 2069 " *\n" 2070 " * aaaaaa\n" 2071 " * aaaaaa\n" 2072 " */", 2073 format("/*\n" 2074 "*\n" 2075 " * aaaaaa aaaaaa\n" 2076 "*/", 2077 getLLVMStyleWithColumns(10))); 2078 EXPECT_EQ("/*\n" 2079 "**\n" 2080 "* aaaaaa\n" 2081 "*aaaaaa\n" 2082 "*/", 2083 format("/*\n" 2084 "**\n" 2085 "* aaaaaa aaaaaa\n" 2086 "*/", 2087 getLLVMStyleWithColumns(10))); 2088 EXPECT_EQ("int aaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 2089 " /* line 1\n" 2090 " bbbbbbbbbbbb */\n" 2091 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 2092 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 2093 " /* line 1\n" 2094 " bbbbbbbbbbbb */ bbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 2095 getLLVMStyleWithColumns(50))); 2096 2097 FormatStyle NoBinPacking = getLLVMStyle(); 2098 NoBinPacking.BinPackParameters = false; 2099 EXPECT_EQ("someFunction(1, /* comment 1 */\n" 2100 " 2, /* comment 2 */\n" 2101 " 3, /* comment 3 */\n" 2102 " aaaa,\n" 2103 " bbbb);", 2104 format("someFunction (1, /* comment 1 */\n" 2105 " 2, /* comment 2 */ \n" 2106 " 3, /* comment 3 */\n" 2107 "aaaa, bbbb );", 2108 NoBinPacking)); 2109 verifyFormat( 2110 "bool aaaaaaaaaaaaa = /* comment: */ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2111 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 2112 EXPECT_EQ( 2113 "bool aaaaaaaaaaaaa = /* trailing comment */\n" 2114 " aaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2115 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;", 2116 format( 2117 "bool aaaaaaaaaaaaa = /* trailing comment */\n" 2118 " aaaaaaaaaaaaaaaaaaaaaaaaaaa||aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2119 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;")); 2120 EXPECT_EQ( 2121 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n" 2122 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n" 2123 "int cccccccccccccccccccccccccccccc; /* comment */\n", 2124 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n" 2125 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n" 2126 "int cccccccccccccccccccccccccccccc; /* comment */\n")); 2127 2128 verifyFormat("void f(int * /* unused */) {}"); 2129 2130 EXPECT_EQ("/*\n" 2131 " **\n" 2132 " */", 2133 format("/*\n" 2134 " **\n" 2135 " */")); 2136 EXPECT_EQ("/*\n" 2137 " *q\n" 2138 " */", 2139 format("/*\n" 2140 " *q\n" 2141 " */")); 2142 EXPECT_EQ("/*\n" 2143 " * q\n" 2144 " */", 2145 format("/*\n" 2146 " * q\n" 2147 " */")); 2148 EXPECT_EQ("/*\n" 2149 " **/", 2150 format("/*\n" 2151 " **/")); 2152 EXPECT_EQ("/*\n" 2153 " ***/", 2154 format("/*\n" 2155 " ***/")); 2156 } 2157 2158 TEST_F(FormatTestComments, BlockCommentsInMacros) { 2159 EXPECT_EQ("#define A \\\n" 2160 " { \\\n" 2161 " /* one line */ \\\n" 2162 " someCall();", 2163 format("#define A { \\\n" 2164 " /* one line */ \\\n" 2165 " someCall();", 2166 getLLVMStyleWithColumns(20))); 2167 EXPECT_EQ("#define A \\\n" 2168 " { \\\n" 2169 " /* previous */ \\\n" 2170 " /* one line */ \\\n" 2171 " someCall();", 2172 format("#define A { \\\n" 2173 " /* previous */ \\\n" 2174 " /* one line */ \\\n" 2175 " someCall();", 2176 getLLVMStyleWithColumns(20))); 2177 } 2178 2179 TEST_F(FormatTestComments, BlockCommentsAtEndOfLine) { 2180 EXPECT_EQ("a = {\n" 2181 " 1111 /* */\n" 2182 "};", 2183 format("a = {1111 /* */\n" 2184 "};", 2185 getLLVMStyleWithColumns(15))); 2186 EXPECT_EQ("a = {\n" 2187 " 1111 /* */\n" 2188 "};", 2189 format("a = {1111 /* */\n" 2190 "};", 2191 getLLVMStyleWithColumns(15))); 2192 EXPECT_EQ("a = {\n" 2193 " 1111 /* a\n" 2194 " */\n" 2195 "};", 2196 format("a = {1111 /* a */\n" 2197 "};", 2198 getLLVMStyleWithColumns(15))); 2199 } 2200 2201 TEST_F(FormatTestComments, IndentLineCommentsInStartOfBlockAtEndOfFile) { 2202 verifyFormat("{\n" 2203 " // a\n" 2204 " // b"); 2205 } 2206 2207 TEST_F(FormatTestComments, AlignTrailingComments) { 2208 EXPECT_EQ("#define MACRO(V) \\\n" 2209 " V(Rt2) /* one more char */ \\\n" 2210 " V(Rs) /* than here */ \\\n" 2211 "/* comment 3 */\n", 2212 format("#define MACRO(V)\\\n" 2213 "V(Rt2) /* one more char */ \\\n" 2214 "V(Rs) /* than here */ \\\n" 2215 "/* comment 3 */\n", 2216 getLLVMStyleWithColumns(40))); 2217 EXPECT_EQ("int i = f(abc, // line 1\n" 2218 " d, // line 2\n" 2219 " // line 3\n" 2220 " b);", 2221 format("int i = f(abc, // line 1\n" 2222 " d, // line 2\n" 2223 " // line 3\n" 2224 " b);", 2225 getLLVMStyleWithColumns(40))); 2226 2227 // Align newly broken trailing comments. 2228 EXPECT_EQ("int ab; // line\n" 2229 "int a; // long\n" 2230 " // long\n", 2231 format("int ab; // line\n" 2232 "int a; // long long\n", 2233 getLLVMStyleWithColumns(15))); 2234 EXPECT_EQ("int ab; // line\n" 2235 "int a; // long\n" 2236 " // long\n" 2237 " // long", 2238 format("int ab; // line\n" 2239 "int a; // long long\n" 2240 " // long", 2241 getLLVMStyleWithColumns(15))); 2242 EXPECT_EQ("int ab; // line\n" 2243 "int a; // long\n" 2244 " // long\n" 2245 "pt c; // long", 2246 format("int ab; // line\n" 2247 "int a; // long long\n" 2248 "pt c; // long", 2249 getLLVMStyleWithColumns(15))); 2250 EXPECT_EQ("int ab; // line\n" 2251 "int a; // long\n" 2252 " // long\n" 2253 "\n" 2254 "// long", 2255 format("int ab; // line\n" 2256 "int a; // long long\n" 2257 "\n" 2258 "// long", 2259 getLLVMStyleWithColumns(15))); 2260 2261 // Don't align newly broken trailing comments if that would put them over the 2262 // column limit. 2263 EXPECT_EQ("int i, j; // line 1\n" 2264 "int k; // line longg\n" 2265 " // long", 2266 format("int i, j; // line 1\n" 2267 "int k; // line longg long", 2268 getLLVMStyleWithColumns(20))); 2269 2270 // Align comment line sections aligned with the next token with the next 2271 // token. 2272 EXPECT_EQ("class A {\n" 2273 "public: // public comment\n" 2274 " // comment about a\n" 2275 " int a;\n" 2276 "};", 2277 format("class A {\n" 2278 "public: // public comment\n" 2279 " // comment about a\n" 2280 " int a;\n" 2281 "};", 2282 getLLVMStyleWithColumns(40))); 2283 EXPECT_EQ("class A {\n" 2284 "public: // public comment 1\n" 2285 " // public comment 2\n" 2286 " // comment 1 about a\n" 2287 " // comment 2 about a\n" 2288 " int a;\n" 2289 "};", 2290 format("class A {\n" 2291 "public: // public comment 1\n" 2292 " // public comment 2\n" 2293 " // comment 1 about a\n" 2294 " // comment 2 about a\n" 2295 " int a;\n" 2296 "};", 2297 getLLVMStyleWithColumns(40))); 2298 EXPECT_EQ("int f(int n) { // comment line 1 on f\n" 2299 " // comment line 2 on f\n" 2300 " // comment line 1 before return\n" 2301 " // comment line 2 before return\n" 2302 " return n; // comment line 1 on return\n" 2303 " // comment line 2 on return\n" 2304 " // comment line 1 after return\n" 2305 "}", 2306 format("int f(int n) { // comment line 1 on f\n" 2307 " // comment line 2 on f\n" 2308 " // comment line 1 before return\n" 2309 " // comment line 2 before return\n" 2310 " return n; // comment line 1 on return\n" 2311 " // comment line 2 on return\n" 2312 " // comment line 1 after return\n" 2313 "}", 2314 getLLVMStyleWithColumns(40))); 2315 EXPECT_EQ("int f(int n) {\n" 2316 " switch (n) { // comment line 1 on switch\n" 2317 " // comment line 2 on switch\n" 2318 " // comment line 1 before case 1\n" 2319 " // comment line 2 before case 1\n" 2320 " case 1: // comment line 1 on case 1\n" 2321 " // comment line 2 on case 1\n" 2322 " // comment line 1 before return 1\n" 2323 " // comment line 2 before return 1\n" 2324 " return 1; // comment line 1 on return 1\n" 2325 " // comment line 2 on return 1\n" 2326 " // comment line 1 before default\n" 2327 " // comment line 2 before default\n" 2328 " default: // comment line 1 on default\n" 2329 " // comment line 2 on default\n" 2330 " // comment line 1 before return 2\n" 2331 " return 2 * f(n - 1); // comment line 1 on return 2\n" 2332 " // comment line 2 on return 2\n" 2333 " // comment line 1 after return\n" 2334 " // comment line 2 after return\n" 2335 " }\n" 2336 "}", 2337 format("int f(int n) {\n" 2338 " switch (n) { // comment line 1 on switch\n" 2339 " // comment line 2 on switch\n" 2340 " // comment line 1 before case 1\n" 2341 " // comment line 2 before case 1\n" 2342 " case 1: // comment line 1 on case 1\n" 2343 " // comment line 2 on case 1\n" 2344 " // comment line 1 before return 1\n" 2345 " // comment line 2 before return 1\n" 2346 " return 1; // comment line 1 on return 1\n" 2347 " // comment line 2 on return 1\n" 2348 " // comment line 1 before default\n" 2349 " // comment line 2 before default\n" 2350 " default: // comment line 1 on default\n" 2351 " // comment line 2 on default\n" 2352 " // comment line 1 before return 2\n" 2353 " return 2 * f(n - 1); // comment line 1 on return 2\n" 2354 " // comment line 2 on return 2\n" 2355 " // comment line 1 after return\n" 2356 " // comment line 2 after return\n" 2357 " }\n" 2358 "}", 2359 getLLVMStyleWithColumns(80))); 2360 2361 // If all the lines in a sequence of line comments are aligned with the next 2362 // token, the first line belongs to the previous token and the other lines 2363 // belong to the next token. 2364 EXPECT_EQ("int a; // line about a\n" 2365 "long b;", 2366 format("int a; // line about a\n" 2367 " long b;", 2368 getLLVMStyleWithColumns(80))); 2369 EXPECT_EQ("int a; // line about a\n" 2370 "// line about b\n" 2371 "long b;", 2372 format("int a; // line about a\n" 2373 " // line about b\n" 2374 " long b;", 2375 getLLVMStyleWithColumns(80))); 2376 EXPECT_EQ("int a; // line about a\n" 2377 "// line 1 about b\n" 2378 "// line 2 about b\n" 2379 "long b;", 2380 format("int a; // line about a\n" 2381 " // line 1 about b\n" 2382 " // line 2 about b\n" 2383 " long b;", 2384 getLLVMStyleWithColumns(80))); 2385 } 2386 2387 TEST_F(FormatTestComments, AlignsBlockCommentDecorations) { 2388 EXPECT_EQ("/*\n" 2389 " */", 2390 format("/*\n" 2391 "*/", getLLVMStyle())); 2392 EXPECT_EQ("/*\n" 2393 " */", 2394 format("/*\n" 2395 " */", getLLVMStyle())); 2396 EXPECT_EQ("/*\n" 2397 " */", 2398 format("/*\n" 2399 " */", getLLVMStyle())); 2400 2401 // Align a single line. 2402 EXPECT_EQ("/*\n" 2403 " * line */", 2404 format("/*\n" 2405 "* line */", 2406 getLLVMStyle())); 2407 EXPECT_EQ("/*\n" 2408 " * line */", 2409 format("/*\n" 2410 " * line */", 2411 getLLVMStyle())); 2412 EXPECT_EQ("/*\n" 2413 " * line */", 2414 format("/*\n" 2415 " * line */", 2416 getLLVMStyle())); 2417 EXPECT_EQ("/*\n" 2418 " * line */", 2419 format("/*\n" 2420 " * line */", 2421 getLLVMStyle())); 2422 EXPECT_EQ("/**\n" 2423 " * line */", 2424 format("/**\n" 2425 "* line */", 2426 getLLVMStyle())); 2427 EXPECT_EQ("/**\n" 2428 " * line */", 2429 format("/**\n" 2430 " * line */", 2431 getLLVMStyle())); 2432 EXPECT_EQ("/**\n" 2433 " * line */", 2434 format("/**\n" 2435 " * line */", 2436 getLLVMStyle())); 2437 EXPECT_EQ("/**\n" 2438 " * line */", 2439 format("/**\n" 2440 " * line */", 2441 getLLVMStyle())); 2442 EXPECT_EQ("/**\n" 2443 " * line */", 2444 format("/**\n" 2445 " * line */", 2446 getLLVMStyle())); 2447 2448 // Align the end '*/' after a line. 2449 EXPECT_EQ("/*\n" 2450 " * line\n" 2451 " */", 2452 format("/*\n" 2453 "* line\n" 2454 "*/", getLLVMStyle())); 2455 EXPECT_EQ("/*\n" 2456 " * line\n" 2457 " */", 2458 format("/*\n" 2459 " * line\n" 2460 " */", getLLVMStyle())); 2461 EXPECT_EQ("/*\n" 2462 " * line\n" 2463 " */", 2464 format("/*\n" 2465 " * line\n" 2466 " */", getLLVMStyle())); 2467 2468 // Align two lines. 2469 EXPECT_EQ("/* line 1\n" 2470 " * line 2 */", 2471 format("/* line 1\n" 2472 " * line 2 */", 2473 getLLVMStyle())); 2474 EXPECT_EQ("/* line 1\n" 2475 " * line 2 */", 2476 format("/* line 1\n" 2477 "* line 2 */", 2478 getLLVMStyle())); 2479 EXPECT_EQ("/* line 1\n" 2480 " * line 2 */", 2481 format("/* line 1\n" 2482 " * line 2 */", 2483 getLLVMStyle())); 2484 EXPECT_EQ("/* line 1\n" 2485 " * line 2 */", 2486 format("/* line 1\n" 2487 " * line 2 */", 2488 getLLVMStyle())); 2489 EXPECT_EQ("/* line 1\n" 2490 " * line 2 */", 2491 format("/* line 1\n" 2492 " * line 2 */", 2493 getLLVMStyle())); 2494 EXPECT_EQ("int i; /* line 1\n" 2495 " * line 2 */", 2496 format("int i; /* line 1\n" 2497 "* line 2 */", 2498 getLLVMStyle())); 2499 EXPECT_EQ("int i; /* line 1\n" 2500 " * line 2 */", 2501 format("int i; /* line 1\n" 2502 " * line 2 */", 2503 getLLVMStyle())); 2504 EXPECT_EQ("int i; /* line 1\n" 2505 " * line 2 */", 2506 format("int i; /* line 1\n" 2507 " * line 2 */", 2508 getLLVMStyle())); 2509 2510 // Align several lines. 2511 EXPECT_EQ("/* line 1\n" 2512 " * line 2\n" 2513 " * line 3 */", 2514 format("/* line 1\n" 2515 " * line 2\n" 2516 "* line 3 */", 2517 getLLVMStyle())); 2518 EXPECT_EQ("/* line 1\n" 2519 " * line 2\n" 2520 " * line 3 */", 2521 format("/* line 1\n" 2522 " * line 2\n" 2523 "* line 3 */", 2524 getLLVMStyle())); 2525 EXPECT_EQ("/*\n" 2526 "** line 1\n" 2527 "** line 2\n" 2528 "*/", 2529 format("/*\n" 2530 "** line 1\n" 2531 " ** line 2\n" 2532 "*/", 2533 getLLVMStyle())); 2534 2535 // Align with different indent after the decorations. 2536 EXPECT_EQ("/*\n" 2537 " * line 1\n" 2538 " * line 2\n" 2539 " * line 3\n" 2540 " * line 4\n" 2541 " */", 2542 format("/*\n" 2543 "* line 1\n" 2544 " * line 2\n" 2545 " * line 3\n" 2546 "* line 4\n" 2547 "*/", getLLVMStyle())); 2548 2549 // Align empty or blank lines. 2550 EXPECT_EQ("/**\n" 2551 " *\n" 2552 " *\n" 2553 " *\n" 2554 " */", 2555 format("/**\n" 2556 "* \n" 2557 " * \n" 2558 " *\n" 2559 "*/", getLLVMStyle())); 2560 2561 // Align while breaking and reflowing. 2562 EXPECT_EQ("/*\n" 2563 " * long long long\n" 2564 " * long long\n" 2565 " *\n" 2566 " * long */", 2567 format("/*\n" 2568 " * long long long long\n" 2569 " * long\n" 2570 " *\n" 2571 "* long */", 2572 getLLVMStyleWithColumns(20))); 2573 } 2574 } // end namespace 2575 } // end namespace format 2576 } // end namespace clang 2577