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, SplitsLongLinesInComments) { 809 EXPECT_EQ("/* This is a long\n" 810 " * comment that\n" 811 " * doesn't\n" 812 " * fit on one line.\n" 813 " */", 814 format("/* " 815 "This is a long " 816 "comment that " 817 "doesn't " 818 "fit on one line. */", 819 getLLVMStyleWithColumns(20))); 820 EXPECT_EQ( 821 "/* a b c d\n" 822 " * e f g\n" 823 " * h i j k\n" 824 " */", 825 format("/* a b c d e f g h i j k */", getLLVMStyleWithColumns(10))); 826 EXPECT_EQ( 827 "/* a b c d\n" 828 " * e f g\n" 829 " * h i j k\n" 830 " */", 831 format("\\\n/* a b c d e f g h i j k */", getLLVMStyleWithColumns(10))); 832 EXPECT_EQ("/*\n" 833 "This is a long\n" 834 "comment that doesn't\n" 835 "fit on one line.\n" 836 "*/", 837 format("/*\n" 838 "This is a long " 839 "comment that doesn't " 840 "fit on one line. \n" 841 "*/", 842 getLLVMStyleWithColumns(20))); 843 EXPECT_EQ("/*\n" 844 " * This is a long\n" 845 " * comment that\n" 846 " * doesn't fit on\n" 847 " * one line.\n" 848 " */", 849 format("/* \n" 850 " * This is a long " 851 " comment that " 852 " doesn't fit on " 853 " one line. \n" 854 " */", 855 getLLVMStyleWithColumns(20))); 856 EXPECT_EQ("/*\n" 857 " * This_is_a_comment_with_words_that_dont_fit_on_one_line\n" 858 " * so_it_should_be_broken\n" 859 " * wherever_a_space_occurs\n" 860 " */", 861 format("/*\n" 862 " * This_is_a_comment_with_words_that_dont_fit_on_one_line " 863 " so_it_should_be_broken " 864 " wherever_a_space_occurs \n" 865 " */", 866 getLLVMStyleWithColumns(20))); 867 EXPECT_EQ("/*\n" 868 " * This_comment_can_not_be_broken_into_lines\n" 869 " */", 870 format("/*\n" 871 " * This_comment_can_not_be_broken_into_lines\n" 872 " */", 873 getLLVMStyleWithColumns(20))); 874 EXPECT_EQ("{\n" 875 " /*\n" 876 " This is another\n" 877 " long comment that\n" 878 " doesn't fit on one\n" 879 " line 1234567890\n" 880 " */\n" 881 "}", 882 format("{\n" 883 "/*\n" 884 "This is another " 885 " long comment that " 886 " doesn't fit on one" 887 " line 1234567890\n" 888 "*/\n" 889 "}", 890 getLLVMStyleWithColumns(20))); 891 EXPECT_EQ("{\n" 892 " /*\n" 893 " * This i s\n" 894 " * another comment\n" 895 " * t hat doesn' t\n" 896 " * fit on one l i\n" 897 " * n e\n" 898 " */\n" 899 "}", 900 format("{\n" 901 "/*\n" 902 " * This i s" 903 " another comment" 904 " t hat doesn' t" 905 " fit on one l i" 906 " n e\n" 907 " */\n" 908 "}", 909 getLLVMStyleWithColumns(20))); 910 EXPECT_EQ("/*\n" 911 " * This is a long\n" 912 " * comment that\n" 913 " * doesn't fit on\n" 914 " * one line\n" 915 " */", 916 format(" /*\n" 917 " * This is a long comment that doesn't fit on one line\n" 918 " */", 919 getLLVMStyleWithColumns(20))); 920 EXPECT_EQ("{\n" 921 " if (something) /* This is a\n" 922 " long\n" 923 " comment */\n" 924 " ;\n" 925 "}", 926 format("{\n" 927 " if (something) /* This is a long comment */\n" 928 " ;\n" 929 "}", 930 getLLVMStyleWithColumns(30))); 931 932 EXPECT_EQ("/* A comment before\n" 933 " * a macro\n" 934 " * definition */\n" 935 "#define a b", 936 format("/* A comment before a macro definition */\n" 937 "#define a b", 938 getLLVMStyleWithColumns(20))); 939 940 EXPECT_EQ("/* some comment\n" 941 " * a comment that\n" 942 " * we break another\n" 943 " * comment we have\n" 944 " * to break a left\n" 945 " * comment\n" 946 " */", 947 format(" /* some comment\n" 948 " * a comment that we break\n" 949 " * another comment we have to break\n" 950 "* a left comment\n" 951 " */", 952 getLLVMStyleWithColumns(20))); 953 954 EXPECT_EQ("/**\n" 955 " * multiline block\n" 956 " * comment\n" 957 " *\n" 958 " */", 959 format("/**\n" 960 " * multiline block comment\n" 961 " *\n" 962 " */", 963 getLLVMStyleWithColumns(20))); 964 965 EXPECT_EQ("/*\n" 966 "\n" 967 "\n" 968 " */\n", 969 format(" /* \n" 970 " \n" 971 " \n" 972 " */\n")); 973 974 EXPECT_EQ("/* a a */", 975 format("/* a a */", getLLVMStyleWithColumns(15))); 976 EXPECT_EQ("/* a a bc */", 977 format("/* a a bc */", getLLVMStyleWithColumns(15))); 978 EXPECT_EQ("/* aaa aaa\n" 979 " * aaaaa */", 980 format("/* aaa aaa aaaaa */", getLLVMStyleWithColumns(15))); 981 EXPECT_EQ("/* aaa aaa\n" 982 " * aaaaa */", 983 format("/* aaa aaa aaaaa */", getLLVMStyleWithColumns(15))); 984 } 985 986 TEST_F(FormatTestComments, SplitsLongLinesInCommentsInPreprocessor) { 987 EXPECT_EQ("#define X \\\n" 988 " /* \\\n" 989 " Test \\\n" 990 " Macro comment \\\n" 991 " with a long \\\n" 992 " line \\\n" 993 " */ \\\n" 994 " A + B", 995 format("#define X \\\n" 996 " /*\n" 997 " Test\n" 998 " Macro comment with a long line\n" 999 " */ \\\n" 1000 " A + B", 1001 getLLVMStyleWithColumns(20))); 1002 EXPECT_EQ("#define X \\\n" 1003 " /* Macro comment \\\n" 1004 " with a long \\\n" 1005 " line */ \\\n" 1006 " A + B", 1007 format("#define X \\\n" 1008 " /* Macro comment with a long\n" 1009 " line */ \\\n" 1010 " A + B", 1011 getLLVMStyleWithColumns(20))); 1012 EXPECT_EQ("#define X \\\n" 1013 " /* Macro comment \\\n" 1014 " * with a long \\\n" 1015 " * line */ \\\n" 1016 " A + B", 1017 format("#define X \\\n" 1018 " /* Macro comment with a long line */ \\\n" 1019 " A + B", 1020 getLLVMStyleWithColumns(20))); 1021 } 1022 1023 TEST_F(FormatTestComments, KeepsTrailingPPCommentsAndSectionCommentsSeparate) { 1024 verifyFormat("#ifdef A // line about A\n" 1025 "// section comment\n" 1026 "#endif", 1027 getLLVMStyleWithColumns(80)); 1028 verifyFormat("#ifdef A // line 1 about A\n" 1029 " // line 2 about A\n" 1030 "// section comment\n" 1031 "#endif", 1032 getLLVMStyleWithColumns(80)); 1033 EXPECT_EQ("#ifdef A // line 1 about A\n" 1034 " // line 2 about A\n" 1035 "// section comment\n" 1036 "#endif", 1037 format("#ifdef A // line 1 about A\n" 1038 " // line 2 about A\n" 1039 "// section comment\n" 1040 "#endif", 1041 getLLVMStyleWithColumns(80))); 1042 verifyFormat("int f() {\n" 1043 " int i;\n" 1044 "#ifdef A // comment about A\n" 1045 " // section comment 1\n" 1046 " // section comment 2\n" 1047 " i = 2;\n" 1048 "#else // comment about #else\n" 1049 " // section comment 3\n" 1050 " i = 4;\n" 1051 "#endif\n" 1052 "}", getLLVMStyleWithColumns(80)); 1053 } 1054 1055 TEST_F(FormatTestComments, CommentsInStaticInitializers) { 1056 EXPECT_EQ( 1057 "static SomeType type = {aaaaaaaaaaaaaaaaaaaa, /* comment */\n" 1058 " aaaaaaaaaaaaaaaaaaaa /* comment */,\n" 1059 " /* comment */ aaaaaaaaaaaaaaaaaaaa,\n" 1060 " aaaaaaaaaaaaaaaaaaaa, // comment\n" 1061 " aaaaaaaaaaaaaaaaaaaa};", 1062 format("static SomeType type = { aaaaaaaaaaaaaaaaaaaa , /* comment */\n" 1063 " aaaaaaaaaaaaaaaaaaaa /* comment */ ,\n" 1064 " /* comment */ aaaaaaaaaaaaaaaaaaaa ,\n" 1065 " aaaaaaaaaaaaaaaaaaaa , // comment\n" 1066 " aaaaaaaaaaaaaaaaaaaa };")); 1067 verifyFormat("static SomeType type = {aaaaaaaaaaa, // comment for aa...\n" 1068 " bbbbbbbbbbb, ccccccccccc};"); 1069 verifyFormat("static SomeType type = {aaaaaaaaaaa,\n" 1070 " // comment for bb....\n" 1071 " bbbbbbbbbbb, ccccccccccc};"); 1072 verifyGoogleFormat( 1073 "static SomeType type = {aaaaaaaaaaa, // comment for aa...\n" 1074 " bbbbbbbbbbb, ccccccccccc};"); 1075 verifyGoogleFormat("static SomeType type = {aaaaaaaaaaa,\n" 1076 " // comment for bb....\n" 1077 " bbbbbbbbbbb, ccccccccccc};"); 1078 1079 verifyFormat("S s = {{a, b, c}, // Group #1\n" 1080 " {d, e, f}, // Group #2\n" 1081 " {g, h, i}}; // Group #3"); 1082 verifyFormat("S s = {{// Group #1\n" 1083 " a, b, c},\n" 1084 " {// Group #2\n" 1085 " d, e, f},\n" 1086 " {// Group #3\n" 1087 " g, h, i}};"); 1088 1089 EXPECT_EQ("S s = {\n" 1090 " // Some comment\n" 1091 " a,\n" 1092 "\n" 1093 " // Comment after empty line\n" 1094 " b}", 1095 format("S s = {\n" 1096 " // Some comment\n" 1097 " a,\n" 1098 " \n" 1099 " // Comment after empty line\n" 1100 " b\n" 1101 "}")); 1102 EXPECT_EQ("S s = {\n" 1103 " /* Some comment */\n" 1104 " a,\n" 1105 "\n" 1106 " /* Comment after empty line */\n" 1107 " b}", 1108 format("S s = {\n" 1109 " /* Some comment */\n" 1110 " a,\n" 1111 " \n" 1112 " /* Comment after empty line */\n" 1113 " b\n" 1114 "}")); 1115 verifyFormat("const uint8_t aaaaaaaaaaaaaaaaaaaaaa[0] = {\n" 1116 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n" 1117 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n" 1118 " 0x00, 0x00, 0x00, 0x00}; // comment\n"); 1119 } 1120 1121 TEST_F(FormatTestComments, LineCommentsAfterRightBrace) { 1122 EXPECT_EQ("if (true) { // comment about branch\n" 1123 " // comment about f\n" 1124 " f();\n" 1125 "}", 1126 format("if (true) { // comment about branch\n" 1127 " // comment about f\n" 1128 " f();\n" 1129 "}", 1130 getLLVMStyleWithColumns(80))); 1131 EXPECT_EQ("if (1) { // if line 1\n" 1132 " // if line 2\n" 1133 " // if line 3\n" 1134 " // f line 1\n" 1135 " // f line 2\n" 1136 " f();\n" 1137 "} else { // else line 1\n" 1138 " // else line 2\n" 1139 " // else line 3\n" 1140 " // g line 1\n" 1141 " g();\n" 1142 "}", 1143 format("if (1) { // if line 1\n" 1144 " // if line 2\n" 1145 " // if line 3\n" 1146 " // f line 1\n" 1147 " // f line 2\n" 1148 " f();\n" 1149 "} else { // else line 1\n" 1150 " // else line 2\n" 1151 " // else line 3\n" 1152 " // g line 1\n" 1153 " g();\n" 1154 "}")); 1155 EXPECT_EQ("do { // line 1\n" 1156 " // line 2\n" 1157 " // line 3\n" 1158 " f();\n" 1159 "} while (true);", 1160 format("do { // line 1\n" 1161 " // line 2\n" 1162 " // line 3\n" 1163 " f();\n" 1164 "} while (true);", 1165 getLLVMStyleWithColumns(80))); 1166 EXPECT_EQ("while (a < b) { // line 1\n" 1167 " // line 2\n" 1168 " // line 3\n" 1169 " f();\n" 1170 "}", 1171 format("while (a < b) {// line 1\n" 1172 " // line 2\n" 1173 " // line 3\n" 1174 " f();\n" 1175 "}", 1176 getLLVMStyleWithColumns(80))); 1177 } 1178 1179 TEST_F(FormatTestComments, ReflowsComments) { 1180 // Break a long line and reflow with the full next line. 1181 EXPECT_EQ("// long long long\n" 1182 "// long long", 1183 format("// long long long long\n" 1184 "// long", 1185 getLLVMStyleWithColumns(20))); 1186 1187 // Keep the trailing newline while reflowing. 1188 EXPECT_EQ("// long long long\n" 1189 "// long long\n", 1190 format("// long long long long\n" 1191 "// long\n", 1192 getLLVMStyleWithColumns(20))); 1193 1194 // Break a long line and reflow with a part of the next line. 1195 EXPECT_EQ("// long long long\n" 1196 "// long long\n" 1197 "// long_long", 1198 format("// long long long long\n" 1199 "// long long_long", 1200 getLLVMStyleWithColumns(20))); 1201 1202 // Break but do not reflow if the first word from the next line is too long. 1203 EXPECT_EQ("// long long long\n" 1204 "// long\n" 1205 "// long_long_long\n", 1206 format("// long long long long\n" 1207 "// long_long_long\n", 1208 getLLVMStyleWithColumns(20))); 1209 1210 // Don't break or reflow short lines. 1211 verifyFormat("// long\n" 1212 "// long long long lo\n" 1213 "// long long long lo\n" 1214 "// long", 1215 getLLVMStyleWithColumns(20)); 1216 1217 // Keep prefixes and decorations while reflowing. 1218 EXPECT_EQ("/// long long long\n" 1219 "/// long long\n", 1220 format("/// long long long long\n" 1221 "/// long\n", 1222 getLLVMStyleWithColumns(20))); 1223 EXPECT_EQ("//! long long long\n" 1224 "//! long long\n", 1225 format("//! long long long long\n" 1226 "//! long\n", 1227 getLLVMStyleWithColumns(20))); 1228 EXPECT_EQ("/* long long long\n" 1229 " * long long */", 1230 format("/* long long long long\n" 1231 " * long */", 1232 getLLVMStyleWithColumns(20))); 1233 EXPECT_EQ("///< long long long\n" 1234 "///< long long\n", 1235 format("///< long long long long\n" 1236 "///< long\n", 1237 getLLVMStyleWithColumns(20))); 1238 EXPECT_EQ("//!< long long long\n" 1239 "//!< long long\n", 1240 format("//!< long long long long\n" 1241 "//!< long\n", 1242 getLLVMStyleWithColumns(20))); 1243 1244 // Don't bring leading whitespace up while reflowing. 1245 EXPECT_EQ("/* long long long\n" 1246 " * long long long\n" 1247 " */", 1248 format("/* long long long long\n" 1249 " * long long\n" 1250 " */", 1251 getLLVMStyleWithColumns(20))); 1252 1253 // Reflow the last line of a block comment with its trailing '*/'. 1254 EXPECT_EQ("/* long long long\n" 1255 " long long */", 1256 format("/* long long long long\n" 1257 " long */", 1258 getLLVMStyleWithColumns(20))); 1259 1260 // Reflow two short lines; keep the postfix of the last one. 1261 EXPECT_EQ("/* long long long\n" 1262 " * long long long */", 1263 format("/* long long long long\n" 1264 " * long\n" 1265 " * long */", 1266 getLLVMStyleWithColumns(20))); 1267 1268 // Put the postfix of the last short reflow line on a newline if it doesn't 1269 // fit. 1270 EXPECT_EQ("/* long long long\n" 1271 " * long long longg\n" 1272 " */", 1273 format("/* long long long long\n" 1274 " * long\n" 1275 " * longg */", 1276 getLLVMStyleWithColumns(20))); 1277 1278 // Reflow lines with leading whitespace. 1279 EXPECT_EQ("{\n" 1280 " /*\n" 1281 " * long long long\n" 1282 " * long long long\n" 1283 " * long long long\n" 1284 " */\n" 1285 "}", 1286 format("{\n" 1287 "/*\n" 1288 " * long long long long\n" 1289 " * long\n" 1290 " * long long long long\n" 1291 " */\n" 1292 "}", 1293 getLLVMStyleWithColumns(20))); 1294 1295 // Break single line block comments that are first in the line with ' *' 1296 // decoration. 1297 EXPECT_EQ("/* long long long\n" 1298 " * long */", 1299 format("/* long long long long */", getLLVMStyleWithColumns(20))); 1300 1301 // Break single line block comment that are not first in the line with ' ' 1302 // decoration. 1303 EXPECT_EQ("int i; /* long long\n" 1304 " long */", 1305 format("int i; /* long long long */", getLLVMStyleWithColumns(20))); 1306 1307 // Reflow a line that goes just over the column limit. 1308 EXPECT_EQ("// long long long\n" 1309 "// lon long", 1310 format("// long long long lon\n" 1311 "// long", 1312 getLLVMStyleWithColumns(20))); 1313 1314 // Stop reflowing if the next line has a different indentation than the 1315 // previous line. 1316 EXPECT_EQ("// long long long\n" 1317 "// long\n" 1318 "// long long\n" 1319 "// long", 1320 format("// long long long long\n" 1321 "// long long\n" 1322 "// long", 1323 getLLVMStyleWithColumns(20))); 1324 1325 // Reflow into the last part of a really long line that has been broken into 1326 // multiple lines. 1327 EXPECT_EQ("// long long long\n" 1328 "// long long long\n" 1329 "// long long long\n", 1330 format("// long long long long long long long long\n" 1331 "// long\n", 1332 getLLVMStyleWithColumns(20))); 1333 1334 // Break the first line, then reflow the beginning of the second and third 1335 // line up. 1336 EXPECT_EQ("// long long long\n" 1337 "// lon1 lon2 lon2\n" 1338 "// lon2 lon3 lon3", 1339 format("// long long long lon1\n" 1340 "// lon2 lon2 lon2\n" 1341 "// lon3 lon3", 1342 getLLVMStyleWithColumns(20))); 1343 1344 // Reflow the beginning of the second line, then break the rest. 1345 EXPECT_EQ("// long long long\n" 1346 "// lon1 lon2 lon2\n" 1347 "// lon2 lon2 lon2\n" 1348 "// lon3", 1349 format("// long long long lon1\n" 1350 "// lon2 lon2 lon2 lon2 lon2 lon3", 1351 getLLVMStyleWithColumns(20))); 1352 1353 // Shrink the first line, then reflow the second line up. 1354 EXPECT_EQ("// long long long", format("// long long\n" 1355 "// long", 1356 getLLVMStyleWithColumns(20))); 1357 1358 // Don't shrink leading whitespace. 1359 EXPECT_EQ("int i; /// a", 1360 format("int i; /// a", getLLVMStyleWithColumns(20))); 1361 1362 // Shrink trailing whitespace if there is no postfix and reflow. 1363 EXPECT_EQ("// long long long\n" 1364 "// long long", 1365 format("// long long long long \n" 1366 "// long", 1367 getLLVMStyleWithColumns(20))); 1368 1369 // Shrink trailing whitespace to a single one if there is postfix. 1370 EXPECT_EQ("/* long long long */", 1371 format("/* long long long */", getLLVMStyleWithColumns(20))); 1372 1373 // Break a block comment postfix if exceeding the line limit. 1374 EXPECT_EQ("/* long\n" 1375 " */", 1376 format("/* long */", getLLVMStyleWithColumns(20))); 1377 1378 // Reflow indented comments. 1379 EXPECT_EQ("{\n" 1380 " // long long long\n" 1381 " // long long\n" 1382 " int i; /* long lon\n" 1383 " g long\n" 1384 " */\n" 1385 "}", 1386 format("{\n" 1387 " // long long long long\n" 1388 " // long\n" 1389 " int i; /* long lon g\n" 1390 " long */\n" 1391 "}", 1392 getLLVMStyleWithColumns(20))); 1393 1394 // Don't realign trailing comments after reflow has happened. 1395 EXPECT_EQ("// long long long\n" 1396 "// long long\n" 1397 "long i; // long", 1398 format("// long long long long\n" 1399 "// long\n" 1400 "long i; // long", 1401 getLLVMStyleWithColumns(20))); 1402 EXPECT_EQ("// long long long\n" 1403 "// longng long long\n" 1404 "// long lo", 1405 format("// long long long longng\n" 1406 "// long long long\n" 1407 "// lo", 1408 getLLVMStyleWithColumns(20))); 1409 1410 // Reflow lines after a broken line. 1411 EXPECT_EQ("int a; // Trailing\n" 1412 " // comment on\n" 1413 " // 2 or 3\n" 1414 " // lines.\n", 1415 format("int a; // Trailing comment\n" 1416 " // on 2\n" 1417 " // or 3\n" 1418 " // lines.\n", 1419 getLLVMStyleWithColumns(20))); 1420 EXPECT_EQ("/// This long line\n" 1421 "/// gets reflown.\n", 1422 format("/// This long line gets\n" 1423 "/// reflown.\n", 1424 getLLVMStyleWithColumns(20))); 1425 EXPECT_EQ("//! This long line\n" 1426 "//! gets reflown.\n", 1427 format(" //! This long line gets\n" 1428 " //! reflown.\n", 1429 getLLVMStyleWithColumns(20))); 1430 EXPECT_EQ("/* This long line\n" 1431 " * gets reflown.\n" 1432 " */\n", 1433 format("/* This long line gets\n" 1434 " * reflown.\n" 1435 " */\n", 1436 getLLVMStyleWithColumns(20))); 1437 1438 // Reflow after indentation makes a line too long. 1439 EXPECT_EQ("{\n" 1440 " // long long long\n" 1441 " // lo long\n" 1442 "}\n", 1443 format("{\n" 1444 "// long long long lo\n" 1445 "// long\n" 1446 "}\n", 1447 getLLVMStyleWithColumns(20))); 1448 1449 // Break and reflow multiple lines. 1450 EXPECT_EQ("/*\n" 1451 " * Reflow the end of\n" 1452 " * line by 11 22 33\n" 1453 " * 4.\n" 1454 " */\n", 1455 format("/*\n" 1456 " * Reflow the end of line\n" 1457 " * by\n" 1458 " * 11\n" 1459 " * 22\n" 1460 " * 33\n" 1461 " * 4.\n" 1462 " */\n", 1463 getLLVMStyleWithColumns(20))); 1464 EXPECT_EQ("/// First line gets\n" 1465 "/// broken. Second\n" 1466 "/// line gets\n" 1467 "/// reflown and\n" 1468 "/// broken. Third\n" 1469 "/// gets reflown.\n", 1470 format("/// First line gets broken.\n" 1471 "/// Second line gets reflown and broken.\n" 1472 "/// Third gets reflown.\n", 1473 getLLVMStyleWithColumns(20))); 1474 EXPECT_EQ("int i; // first long\n" 1475 " // long snd\n" 1476 " // long.\n", 1477 format("int i; // first long long\n" 1478 " // snd long.\n", 1479 getLLVMStyleWithColumns(20))); 1480 EXPECT_EQ("{\n" 1481 " // first long line\n" 1482 " // line second\n" 1483 " // long line line\n" 1484 " // third long line\n" 1485 " // line\n" 1486 "}\n", 1487 format("{\n" 1488 " // first long line line\n" 1489 " // second long line line\n" 1490 " // third long line line\n" 1491 "}\n", 1492 getLLVMStyleWithColumns(20))); 1493 EXPECT_EQ("int i; /* first line\n" 1494 " * second\n" 1495 " * line third\n" 1496 " * line\n" 1497 " */", 1498 format("int i; /* first line\n" 1499 " * second line\n" 1500 " * third line\n" 1501 " */", 1502 getLLVMStyleWithColumns(20))); 1503 1504 // Reflow the last two lines of a section that starts with a line having 1505 // different indentation. 1506 EXPECT_EQ( 1507 "// long\n" 1508 "// long long long\n" 1509 "// long long", 1510 format("// long\n" 1511 "// long long long long\n" 1512 "// long", 1513 getLLVMStyleWithColumns(20))); 1514 1515 // Keep the block comment endling '*/' while reflowing. 1516 EXPECT_EQ("/* Long long long\n" 1517 " * line short */\n", 1518 format("/* Long long long line\n" 1519 " * short */\n", 1520 getLLVMStyleWithColumns(20))); 1521 1522 // Don't reflow between separate blocks of comments. 1523 EXPECT_EQ("/* First comment\n" 1524 " * block will */\n" 1525 "/* Snd\n" 1526 " */\n", 1527 format("/* First comment block\n" 1528 " * will */\n" 1529 "/* Snd\n" 1530 " */\n", 1531 getLLVMStyleWithColumns(20))); 1532 1533 // Don't reflow across blank comment lines. 1534 EXPECT_EQ("int i; // This long\n" 1535 " // line gets\n" 1536 " // broken.\n" 1537 " //\n" 1538 " // keep.\n", 1539 format("int i; // This long line gets broken.\n" 1540 " // \n" 1541 " // keep.\n", 1542 getLLVMStyleWithColumns(20))); 1543 EXPECT_EQ("{\n" 1544 " /// long long long\n" 1545 " /// long long\n" 1546 " ///\n" 1547 " /// long\n" 1548 "}", 1549 format("{\n" 1550 " /// long long long long\n" 1551 " /// long\n" 1552 " ///\n" 1553 " /// long\n" 1554 "}", 1555 getLLVMStyleWithColumns(20))); 1556 EXPECT_EQ("//! long long long\n" 1557 "//! long\n" 1558 "\n" 1559 "//! long", 1560 format("//! long long long long\n" 1561 "\n" 1562 "//! long", 1563 getLLVMStyleWithColumns(20))); 1564 EXPECT_EQ("/* long long long\n" 1565 " long\n" 1566 "\n" 1567 " long */", 1568 format("/* long long long long\n" 1569 "\n" 1570 " long */", 1571 getLLVMStyleWithColumns(20))); 1572 EXPECT_EQ("/* long long long\n" 1573 " * long\n" 1574 " *\n" 1575 " * long */", 1576 format("/* long long long long\n" 1577 " *\n" 1578 " * long */", 1579 getLLVMStyleWithColumns(20))); 1580 1581 // Don't reflow lines having content that is a single character. 1582 EXPECT_EQ("// long long long\n" 1583 "// long\n" 1584 "// l", 1585 format("// long long long long\n" 1586 "// l", 1587 getLLVMStyleWithColumns(20))); 1588 1589 // Don't reflow lines starting with two punctuation characters. 1590 EXPECT_EQ("// long long long\n" 1591 "// long\n" 1592 "// ... --- ...", 1593 format( 1594 "// long long long long\n" 1595 "// ... --- ...", 1596 getLLVMStyleWithColumns(20))); 1597 1598 // Don't reflow lines starting with '@'. 1599 EXPECT_EQ("// long long long\n" 1600 "// long\n" 1601 "// @param arg", 1602 format("// long long long long\n" 1603 "// @param arg", 1604 getLLVMStyleWithColumns(20))); 1605 1606 // Don't reflow lines starting with 'TODO'. 1607 EXPECT_EQ("// long long long\n" 1608 "// long\n" 1609 "// TODO: long", 1610 format("// long long long long\n" 1611 "// TODO: long", 1612 getLLVMStyleWithColumns(20))); 1613 1614 // Don't reflow lines starting with 'FIXME'. 1615 EXPECT_EQ("// long long long\n" 1616 "// long\n" 1617 "// FIXME: long", 1618 format("// long long long long\n" 1619 "// FIXME: long", 1620 getLLVMStyleWithColumns(20))); 1621 1622 // Don't reflow lines starting with 'XXX'. 1623 EXPECT_EQ("// long long long\n" 1624 "// long\n" 1625 "// XXX: long", 1626 format("// long long long long\n" 1627 "// XXX: long", 1628 getLLVMStyleWithColumns(20))); 1629 1630 // Don't reflow comment pragmas. 1631 EXPECT_EQ("// long long long\n" 1632 "// long\n" 1633 "// IWYU pragma:", 1634 format("// long long long long\n" 1635 "// IWYU pragma:", 1636 getLLVMStyleWithColumns(20))); 1637 EXPECT_EQ("/* long long long\n" 1638 " * long\n" 1639 " * IWYU pragma:\n" 1640 " */", 1641 format("/* long long long long\n" 1642 " * IWYU pragma:\n" 1643 " */", 1644 getLLVMStyleWithColumns(20))); 1645 1646 // Reflow lines that have a non-punctuation character among their first 2 1647 // characters. 1648 EXPECT_EQ("// long long long\n" 1649 "// long 'long'", 1650 format( 1651 "// long long long long\n" 1652 "// 'long'", 1653 getLLVMStyleWithColumns(20))); 1654 1655 // Don't reflow between separate blocks of comments. 1656 EXPECT_EQ("/* First comment\n" 1657 " * block will */\n" 1658 "/* Snd\n" 1659 " */\n", 1660 format("/* First comment block\n" 1661 " * will */\n" 1662 "/* Snd\n" 1663 " */\n", 1664 getLLVMStyleWithColumns(20))); 1665 1666 // Don't reflow lines having different indentation. 1667 EXPECT_EQ("// long long long\n" 1668 "// long\n" 1669 "// long", 1670 format("// long long long long\n" 1671 "// long", 1672 getLLVMStyleWithColumns(20))); 1673 1674 // Don't reflow separate bullets in list 1675 EXPECT_EQ("// - long long long\n" 1676 "// long\n" 1677 "// - long", 1678 format("// - long long long long\n" 1679 "// - long", 1680 getLLVMStyleWithColumns(20))); 1681 EXPECT_EQ("// * long long long\n" 1682 "// long\n" 1683 "// * long", 1684 format("// * long long long long\n" 1685 "// * long", 1686 getLLVMStyleWithColumns(20))); 1687 EXPECT_EQ("// + long long long\n" 1688 "// long\n" 1689 "// + long", 1690 format("// + long long long long\n" 1691 "// + long", 1692 getLLVMStyleWithColumns(20))); 1693 EXPECT_EQ("// 1. long long long\n" 1694 "// long\n" 1695 "// 2. long", 1696 format("// 1. long long long long\n" 1697 "// 2. long", 1698 getLLVMStyleWithColumns(20))); 1699 EXPECT_EQ("// -# long long long\n" 1700 "// long\n" 1701 "// -# long", 1702 format("// -# long long long long\n" 1703 "// -# long", 1704 getLLVMStyleWithColumns(20))); 1705 1706 EXPECT_EQ("// - long long long\n" 1707 "// long long long\n" 1708 "// - long", 1709 format("// - long long long long\n" 1710 "// long long\n" 1711 "// - long", 1712 getLLVMStyleWithColumns(20))); 1713 EXPECT_EQ("// - long long long\n" 1714 "// long long long\n" 1715 "// long\n" 1716 "// - long", 1717 format("// - long long long long\n" 1718 "// long long long\n" 1719 "// - long", 1720 getLLVMStyleWithColumns(20))); 1721 1722 // Large number (>2 digits) are not list items 1723 EXPECT_EQ("// long long long\n" 1724 "// long 1024. long.", 1725 format("// long long long long\n" 1726 "// 1024. long.", 1727 getLLVMStyleWithColumns(20))); 1728 1729 // Do not break before number, to avoid introducing a non-reflowable doxygen 1730 // list item. 1731 EXPECT_EQ("// long long\n" 1732 "// long 10. long.", 1733 format("// long long long 10.\n" 1734 "// long.", 1735 getLLVMStyleWithColumns(20))); 1736 1737 // Don't break or reflow after implicit string literals. 1738 verifyFormat("#include <t> // l l l\n" 1739 " // l", 1740 getLLVMStyleWithColumns(20)); 1741 1742 // Don't break or reflow comments on import lines. 1743 EXPECT_EQ("#include \"t\" /* l l l\n" 1744 " * l */", 1745 format("#include \"t\" /* l l l\n" 1746 " * l */", 1747 getLLVMStyleWithColumns(20))); 1748 1749 // Don't reflow between different trailing comment sections. 1750 EXPECT_EQ("int i; // long long\n" 1751 " // long\n" 1752 "int j; // long long\n" 1753 " // long\n", 1754 format("int i; // long long long\n" 1755 "int j; // long long long\n", 1756 getLLVMStyleWithColumns(20))); 1757 1758 // Don't reflow if the first word on the next line is longer than the 1759 // available space at current line. 1760 EXPECT_EQ("int i; // trigger\n" 1761 " // reflow\n" 1762 " // longsec\n", 1763 format("int i; // trigger reflow\n" 1764 " // longsec\n", 1765 getLLVMStyleWithColumns(20))); 1766 1767 // Keep empty comment lines. 1768 EXPECT_EQ("/**/", format(" /**/", getLLVMStyleWithColumns(20))); 1769 EXPECT_EQ("/* */", format(" /* */", getLLVMStyleWithColumns(20))); 1770 EXPECT_EQ("/* */", format(" /* */", getLLVMStyleWithColumns(20))); 1771 EXPECT_EQ("//", format(" // ", getLLVMStyleWithColumns(20))); 1772 EXPECT_EQ("///", format(" /// ", getLLVMStyleWithColumns(20))); 1773 } 1774 1775 TEST_F(FormatTestComments, IgnoresIf0Contents) { 1776 EXPECT_EQ("#if 0\n" 1777 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 1778 "#endif\n" 1779 "void f() {}", 1780 format("#if 0\n" 1781 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 1782 "#endif\n" 1783 "void f( ) { }")); 1784 EXPECT_EQ("#if false\n" 1785 "void f( ) { }\n" 1786 "#endif\n" 1787 "void g() {}\n", 1788 format("#if false\n" 1789 "void f( ) { }\n" 1790 "#endif\n" 1791 "void g( ) { }\n")); 1792 EXPECT_EQ("enum E {\n" 1793 " One,\n" 1794 " Two,\n" 1795 "#if 0\n" 1796 "Three,\n" 1797 " Four,\n" 1798 "#endif\n" 1799 " Five\n" 1800 "};", 1801 format("enum E {\n" 1802 " One,Two,\n" 1803 "#if 0\n" 1804 "Three,\n" 1805 " Four,\n" 1806 "#endif\n" 1807 " Five};")); 1808 EXPECT_EQ("enum F {\n" 1809 " One,\n" 1810 "#if 1\n" 1811 " Two,\n" 1812 "#if 0\n" 1813 "Three,\n" 1814 " Four,\n" 1815 "#endif\n" 1816 " Five\n" 1817 "#endif\n" 1818 "};", 1819 format("enum F {\n" 1820 "One,\n" 1821 "#if 1\n" 1822 "Two,\n" 1823 "#if 0\n" 1824 "Three,\n" 1825 " Four,\n" 1826 "#endif\n" 1827 "Five\n" 1828 "#endif\n" 1829 "};")); 1830 EXPECT_EQ("enum G {\n" 1831 " One,\n" 1832 "#if 0\n" 1833 "Two,\n" 1834 "#else\n" 1835 " Three,\n" 1836 "#endif\n" 1837 " Four\n" 1838 "};", 1839 format("enum G {\n" 1840 "One,\n" 1841 "#if 0\n" 1842 "Two,\n" 1843 "#else\n" 1844 "Three,\n" 1845 "#endif\n" 1846 "Four\n" 1847 "};")); 1848 EXPECT_EQ("enum H {\n" 1849 " One,\n" 1850 "#if 0\n" 1851 "#ifdef Q\n" 1852 "Two,\n" 1853 "#else\n" 1854 "Three,\n" 1855 "#endif\n" 1856 "#endif\n" 1857 " Four\n" 1858 "};", 1859 format("enum H {\n" 1860 "One,\n" 1861 "#if 0\n" 1862 "#ifdef Q\n" 1863 "Two,\n" 1864 "#else\n" 1865 "Three,\n" 1866 "#endif\n" 1867 "#endif\n" 1868 "Four\n" 1869 "};")); 1870 EXPECT_EQ("enum I {\n" 1871 " One,\n" 1872 "#if /* test */ 0 || 1\n" 1873 "Two,\n" 1874 "Three,\n" 1875 "#endif\n" 1876 " Four\n" 1877 "};", 1878 format("enum I {\n" 1879 "One,\n" 1880 "#if /* test */ 0 || 1\n" 1881 "Two,\n" 1882 "Three,\n" 1883 "#endif\n" 1884 "Four\n" 1885 "};")); 1886 EXPECT_EQ("enum J {\n" 1887 " One,\n" 1888 "#if 0\n" 1889 "#if 0\n" 1890 "Two,\n" 1891 "#else\n" 1892 "Three,\n" 1893 "#endif\n" 1894 "Four,\n" 1895 "#endif\n" 1896 " Five\n" 1897 "};", 1898 format("enum J {\n" 1899 "One,\n" 1900 "#if 0\n" 1901 "#if 0\n" 1902 "Two,\n" 1903 "#else\n" 1904 "Three,\n" 1905 "#endif\n" 1906 "Four,\n" 1907 "#endif\n" 1908 "Five\n" 1909 "};")); 1910 1911 // Ignore stuff in SWIG-blocks. 1912 EXPECT_EQ("#ifdef SWIG\n" 1913 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 1914 "#endif\n" 1915 "void f() {}", 1916 format("#ifdef SWIG\n" 1917 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 1918 "#endif\n" 1919 "void f( ) { }")); 1920 EXPECT_EQ("#ifndef SWIG\n" 1921 "void f() {}\n" 1922 "#endif", 1923 format("#ifndef SWIG\n" 1924 "void f( ) { }\n" 1925 "#endif")); 1926 } 1927 1928 TEST_F(FormatTestComments, DontCrashOnBlockComments) { 1929 EXPECT_EQ( 1930 "int xxxxxxxxx; /* " 1931 "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy\n" 1932 "zzzzzz\n" 1933 "0*/", 1934 format("int xxxxxxxxx; /* " 1935 "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy zzzzzz\n" 1936 "0*/")); 1937 } 1938 1939 TEST_F(FormatTestComments, BlockCommentsInControlLoops) { 1940 verifyFormat("if (0) /* a comment in a strange place */ {\n" 1941 " f();\n" 1942 "}"); 1943 verifyFormat("if (0) /* a comment in a strange place */ {\n" 1944 " f();\n" 1945 "} /* another comment */ else /* comment #3 */ {\n" 1946 " g();\n" 1947 "}"); 1948 verifyFormat("while (0) /* a comment in a strange place */ {\n" 1949 " f();\n" 1950 "}"); 1951 verifyFormat("for (;;) /* a comment in a strange place */ {\n" 1952 " f();\n" 1953 "}"); 1954 verifyFormat("do /* a comment in a strange place */ {\n" 1955 " f();\n" 1956 "} /* another comment */ while (0);"); 1957 } 1958 1959 TEST_F(FormatTestComments, BlockComments) { 1960 EXPECT_EQ("/* */ /* */ /* */\n/* */ /* */ /* */", 1961 format("/* *//* */ /* */\n/* *//* */ /* */")); 1962 EXPECT_EQ("/* */ a /* */ b;", format(" /* */ a/* */ b;")); 1963 EXPECT_EQ("#define A /*123*/ \\\n" 1964 " b\n" 1965 "/* */\n" 1966 "someCall(\n" 1967 " parameter);", 1968 format("#define A /*123*/ b\n" 1969 "/* */\n" 1970 "someCall(parameter);", 1971 getLLVMStyleWithColumns(15))); 1972 1973 EXPECT_EQ("#define A\n" 1974 "/* */ someCall(\n" 1975 " parameter);", 1976 format("#define A\n" 1977 "/* */someCall(parameter);", 1978 getLLVMStyleWithColumns(15))); 1979 EXPECT_EQ("/*\n**\n*/", format("/*\n**\n*/")); 1980 EXPECT_EQ("/*\n" 1981 " *\n" 1982 " * aaaaaa\n" 1983 " * aaaaaa\n" 1984 " */", 1985 format("/*\n" 1986 "*\n" 1987 " * aaaaaa aaaaaa\n" 1988 "*/", 1989 getLLVMStyleWithColumns(10))); 1990 EXPECT_EQ("/*\n" 1991 "**\n" 1992 "* aaaaaa\n" 1993 "*aaaaaa\n" 1994 "*/", 1995 format("/*\n" 1996 "**\n" 1997 "* aaaaaa aaaaaa\n" 1998 "*/", 1999 getLLVMStyleWithColumns(10))); 2000 EXPECT_EQ("int aaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 2001 " /* line 1\n" 2002 " bbbbbbbbbbbb */\n" 2003 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 2004 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 2005 " /* line 1\n" 2006 " bbbbbbbbbbbb */ bbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 2007 getLLVMStyleWithColumns(50))); 2008 2009 FormatStyle NoBinPacking = getLLVMStyle(); 2010 NoBinPacking.BinPackParameters = false; 2011 EXPECT_EQ("someFunction(1, /* comment 1 */\n" 2012 " 2, /* comment 2 */\n" 2013 " 3, /* comment 3 */\n" 2014 " aaaa,\n" 2015 " bbbb);", 2016 format("someFunction (1, /* comment 1 */\n" 2017 " 2, /* comment 2 */ \n" 2018 " 3, /* comment 3 */\n" 2019 "aaaa, bbbb );", 2020 NoBinPacking)); 2021 verifyFormat( 2022 "bool aaaaaaaaaaaaa = /* comment: */ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2023 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 2024 EXPECT_EQ( 2025 "bool aaaaaaaaaaaaa = /* trailing comment */\n" 2026 " aaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2027 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;", 2028 format( 2029 "bool aaaaaaaaaaaaa = /* trailing comment */\n" 2030 " aaaaaaaaaaaaaaaaaaaaaaaaaaa||aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2031 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;")); 2032 EXPECT_EQ( 2033 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n" 2034 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n" 2035 "int cccccccccccccccccccccccccccccc; /* comment */\n", 2036 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n" 2037 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n" 2038 "int cccccccccccccccccccccccccccccc; /* comment */\n")); 2039 2040 verifyFormat("void f(int * /* unused */) {}"); 2041 2042 EXPECT_EQ("/*\n" 2043 " **\n" 2044 " */", 2045 format("/*\n" 2046 " **\n" 2047 " */")); 2048 EXPECT_EQ("/*\n" 2049 " *q\n" 2050 " */", 2051 format("/*\n" 2052 " *q\n" 2053 " */")); 2054 EXPECT_EQ("/*\n" 2055 " * q\n" 2056 " */", 2057 format("/*\n" 2058 " * q\n" 2059 " */")); 2060 EXPECT_EQ("/*\n" 2061 " **/", 2062 format("/*\n" 2063 " **/")); 2064 EXPECT_EQ("/*\n" 2065 " ***/", 2066 format("/*\n" 2067 " ***/")); 2068 } 2069 2070 TEST_F(FormatTestComments, BlockCommentsInMacros) { 2071 EXPECT_EQ("#define A \\\n" 2072 " { \\\n" 2073 " /* one line */ \\\n" 2074 " someCall();", 2075 format("#define A { \\\n" 2076 " /* one line */ \\\n" 2077 " someCall();", 2078 getLLVMStyleWithColumns(20))); 2079 EXPECT_EQ("#define A \\\n" 2080 " { \\\n" 2081 " /* previous */ \\\n" 2082 " /* one line */ \\\n" 2083 " someCall();", 2084 format("#define A { \\\n" 2085 " /* previous */ \\\n" 2086 " /* one line */ \\\n" 2087 " someCall();", 2088 getLLVMStyleWithColumns(20))); 2089 } 2090 2091 TEST_F(FormatTestComments, BlockCommentsAtEndOfLine) { 2092 EXPECT_EQ("a = {\n" 2093 " 1111 /* */\n" 2094 "};", 2095 format("a = {1111 /* */\n" 2096 "};", 2097 getLLVMStyleWithColumns(15))); 2098 EXPECT_EQ("a = {\n" 2099 " 1111 /* */\n" 2100 "};", 2101 format("a = {1111 /* */\n" 2102 "};", 2103 getLLVMStyleWithColumns(15))); 2104 EXPECT_EQ("a = {\n" 2105 " 1111 /* a\n" 2106 " */\n" 2107 "};", 2108 format("a = {1111 /* a */\n" 2109 "};", 2110 getLLVMStyleWithColumns(15))); 2111 } 2112 2113 TEST_F(FormatTestComments, IndentLineCommentsInStartOfBlockAtEndOfFile) { 2114 verifyFormat("{\n" 2115 " // a\n" 2116 " // b"); 2117 } 2118 2119 TEST_F(FormatTestComments, AlignTrailingComments) { 2120 EXPECT_EQ("#define MACRO(V) \\\n" 2121 " V(Rt2) /* one more char */ \\\n" 2122 " V(Rs) /* than here */ \\\n" 2123 "/* comment 3 */\n", 2124 format("#define MACRO(V)\\\n" 2125 "V(Rt2) /* one more char */ \\\n" 2126 "V(Rs) /* than here */ \\\n" 2127 "/* comment 3 */\n", 2128 getLLVMStyleWithColumns(40))); 2129 EXPECT_EQ("int i = f(abc, // line 1\n" 2130 " d, // line 2\n" 2131 " // line 3\n" 2132 " b);", 2133 format("int i = f(abc, // line 1\n" 2134 " d, // line 2\n" 2135 " // line 3\n" 2136 " b);", 2137 getLLVMStyleWithColumns(40))); 2138 2139 // Align newly broken trailing comments. 2140 EXPECT_EQ("int ab; // line\n" 2141 "int a; // long\n" 2142 " // long\n", 2143 format("int ab; // line\n" 2144 "int a; // long long\n", 2145 getLLVMStyleWithColumns(15))); 2146 EXPECT_EQ("int ab; // line\n" 2147 "int a; // long\n" 2148 " // long\n" 2149 " // long", 2150 format("int ab; // line\n" 2151 "int a; // long long\n" 2152 " // long", 2153 getLLVMStyleWithColumns(15))); 2154 EXPECT_EQ("int ab; // line\n" 2155 "int a; // long\n" 2156 " // long\n" 2157 "pt c; // long", 2158 format("int ab; // line\n" 2159 "int a; // long long\n" 2160 "pt c; // long", 2161 getLLVMStyleWithColumns(15))); 2162 EXPECT_EQ("int ab; // line\n" 2163 "int a; // long\n" 2164 " // long\n" 2165 "\n" 2166 "// long", 2167 format("int ab; // line\n" 2168 "int a; // long long\n" 2169 "\n" 2170 "// long", 2171 getLLVMStyleWithColumns(15))); 2172 2173 // Align comment line sections aligned with the next token with the next 2174 // token. 2175 EXPECT_EQ("class A {\n" 2176 "public: // public comment\n" 2177 " // comment about a\n" 2178 " int a;\n" 2179 "};", 2180 format("class A {\n" 2181 "public: // public comment\n" 2182 " // comment about a\n" 2183 " int a;\n" 2184 "};", 2185 getLLVMStyleWithColumns(40))); 2186 EXPECT_EQ("class A {\n" 2187 "public: // public comment 1\n" 2188 " // public comment 2\n" 2189 " // comment 1 about a\n" 2190 " // comment 2 about a\n" 2191 " int a;\n" 2192 "};", 2193 format("class A {\n" 2194 "public: // public comment 1\n" 2195 " // public comment 2\n" 2196 " // comment 1 about a\n" 2197 " // comment 2 about a\n" 2198 " int a;\n" 2199 "};", 2200 getLLVMStyleWithColumns(40))); 2201 EXPECT_EQ("int f(int n) { // comment line 1 on f\n" 2202 " // comment line 2 on f\n" 2203 " // comment line 1 before return\n" 2204 " // comment line 2 before return\n" 2205 " return n; // comment line 1 on return\n" 2206 " // comment line 2 on return\n" 2207 " // comment line 1 after return\n" 2208 "}", 2209 format("int f(int n) { // comment line 1 on f\n" 2210 " // comment line 2 on f\n" 2211 " // comment line 1 before return\n" 2212 " // comment line 2 before return\n" 2213 " return n; // comment line 1 on return\n" 2214 " // comment line 2 on return\n" 2215 " // comment line 1 after return\n" 2216 "}", 2217 getLLVMStyleWithColumns(40))); 2218 EXPECT_EQ("int f(int n) {\n" 2219 " switch (n) { // comment line 1 on switch\n" 2220 " // comment line 2 on switch\n" 2221 " // comment line 1 before case 1\n" 2222 " // comment line 2 before case 1\n" 2223 " case 1: // comment line 1 on case 1\n" 2224 " // comment line 2 on case 1\n" 2225 " // comment line 1 before return 1\n" 2226 " // comment line 2 before return 1\n" 2227 " return 1; // comment line 1 on return 1\n" 2228 " // comment line 2 on return 1\n" 2229 " // comment line 1 before default\n" 2230 " // comment line 2 before default\n" 2231 " default: // comment line 1 on default\n" 2232 " // comment line 2 on default\n" 2233 " // comment line 1 before return 2\n" 2234 " return 2 * f(n - 1); // comment line 1 on return 2\n" 2235 " // comment line 2 on return 2\n" 2236 " // comment line 1 after return\n" 2237 " // comment line 2 after return\n" 2238 " }\n" 2239 "}", 2240 format("int f(int n) {\n" 2241 " switch (n) { // comment line 1 on switch\n" 2242 " // comment line 2 on switch\n" 2243 " // comment line 1 before case 1\n" 2244 " // comment line 2 before case 1\n" 2245 " case 1: // comment line 1 on case 1\n" 2246 " // comment line 2 on case 1\n" 2247 " // comment line 1 before return 1\n" 2248 " // comment line 2 before return 1\n" 2249 " return 1; // comment line 1 on return 1\n" 2250 " // comment line 2 on return 1\n" 2251 " // comment line 1 before default\n" 2252 " // comment line 2 before default\n" 2253 " default: // comment line 1 on default\n" 2254 " // comment line 2 on default\n" 2255 " // comment line 1 before return 2\n" 2256 " return 2 * f(n - 1); // comment line 1 on return 2\n" 2257 " // comment line 2 on return 2\n" 2258 " // comment line 1 after return\n" 2259 " // comment line 2 after return\n" 2260 " }\n" 2261 "}", 2262 getLLVMStyleWithColumns(80))); 2263 2264 // If all the lines in a sequence of line comments are aligned with the next 2265 // token, the first line belongs to the previous token and the other lines 2266 // belong to the next token. 2267 EXPECT_EQ("int a; // line about a\n" 2268 "long b;", 2269 format("int a; // line about a\n" 2270 " long b;", 2271 getLLVMStyleWithColumns(80))); 2272 EXPECT_EQ("int a; // line about a\n" 2273 "// line about b\n" 2274 "long b;", 2275 format("int a; // line about a\n" 2276 " // line about b\n" 2277 " long b;", 2278 getLLVMStyleWithColumns(80))); 2279 EXPECT_EQ("int a; // line about a\n" 2280 "// line 1 about b\n" 2281 "// line 2 about b\n" 2282 "long b;", 2283 format("int a; // line about a\n" 2284 " // line 1 about b\n" 2285 " // line 2 about b\n" 2286 " long b;", 2287 getLLVMStyleWithColumns(80))); 2288 } 2289 2290 TEST_F(FormatTestComments, AlignsBlockCommentDecorations) { 2291 EXPECT_EQ("/*\n" 2292 " */", 2293 format("/*\n" 2294 "*/", getLLVMStyle())); 2295 EXPECT_EQ("/*\n" 2296 " */", 2297 format("/*\n" 2298 " */", getLLVMStyle())); 2299 EXPECT_EQ("/*\n" 2300 " */", 2301 format("/*\n" 2302 " */", getLLVMStyle())); 2303 2304 // Align a single line. 2305 EXPECT_EQ("/*\n" 2306 " * line */", 2307 format("/*\n" 2308 "* line */", 2309 getLLVMStyle())); 2310 EXPECT_EQ("/*\n" 2311 " * line */", 2312 format("/*\n" 2313 " * line */", 2314 getLLVMStyle())); 2315 EXPECT_EQ("/*\n" 2316 " * line */", 2317 format("/*\n" 2318 " * line */", 2319 getLLVMStyle())); 2320 EXPECT_EQ("/*\n" 2321 " * line */", 2322 format("/*\n" 2323 " * line */", 2324 getLLVMStyle())); 2325 EXPECT_EQ("/**\n" 2326 " * line */", 2327 format("/**\n" 2328 "* line */", 2329 getLLVMStyle())); 2330 EXPECT_EQ("/**\n" 2331 " * line */", 2332 format("/**\n" 2333 " * line */", 2334 getLLVMStyle())); 2335 EXPECT_EQ("/**\n" 2336 " * line */", 2337 format("/**\n" 2338 " * line */", 2339 getLLVMStyle())); 2340 EXPECT_EQ("/**\n" 2341 " * line */", 2342 format("/**\n" 2343 " * line */", 2344 getLLVMStyle())); 2345 EXPECT_EQ("/**\n" 2346 " * line */", 2347 format("/**\n" 2348 " * line */", 2349 getLLVMStyle())); 2350 2351 // Align the end '*/' after a line. 2352 EXPECT_EQ("/*\n" 2353 " * line\n" 2354 " */", 2355 format("/*\n" 2356 "* line\n" 2357 "*/", getLLVMStyle())); 2358 EXPECT_EQ("/*\n" 2359 " * line\n" 2360 " */", 2361 format("/*\n" 2362 " * line\n" 2363 " */", getLLVMStyle())); 2364 EXPECT_EQ("/*\n" 2365 " * line\n" 2366 " */", 2367 format("/*\n" 2368 " * line\n" 2369 " */", getLLVMStyle())); 2370 2371 // Align two lines. 2372 EXPECT_EQ("/* line 1\n" 2373 " * line 2 */", 2374 format("/* line 1\n" 2375 " * line 2 */", 2376 getLLVMStyle())); 2377 EXPECT_EQ("/* line 1\n" 2378 " * line 2 */", 2379 format("/* line 1\n" 2380 "* line 2 */", 2381 getLLVMStyle())); 2382 EXPECT_EQ("/* line 1\n" 2383 " * line 2 */", 2384 format("/* line 1\n" 2385 " * line 2 */", 2386 getLLVMStyle())); 2387 EXPECT_EQ("/* line 1\n" 2388 " * line 2 */", 2389 format("/* line 1\n" 2390 " * line 2 */", 2391 getLLVMStyle())); 2392 EXPECT_EQ("/* line 1\n" 2393 " * line 2 */", 2394 format("/* line 1\n" 2395 " * line 2 */", 2396 getLLVMStyle())); 2397 EXPECT_EQ("int i; /* line 1\n" 2398 " * line 2 */", 2399 format("int i; /* line 1\n" 2400 "* line 2 */", 2401 getLLVMStyle())); 2402 EXPECT_EQ("int i; /* line 1\n" 2403 " * line 2 */", 2404 format("int i; /* line 1\n" 2405 " * line 2 */", 2406 getLLVMStyle())); 2407 EXPECT_EQ("int i; /* line 1\n" 2408 " * line 2 */", 2409 format("int i; /* line 1\n" 2410 " * line 2 */", 2411 getLLVMStyle())); 2412 2413 // Align several lines. 2414 EXPECT_EQ("/* line 1\n" 2415 " * line 2\n" 2416 " * line 3 */", 2417 format("/* line 1\n" 2418 " * line 2\n" 2419 "* line 3 */", 2420 getLLVMStyle())); 2421 EXPECT_EQ("/* line 1\n" 2422 " * line 2\n" 2423 " * line 3 */", 2424 format("/* line 1\n" 2425 " * line 2\n" 2426 "* line 3 */", 2427 getLLVMStyle())); 2428 EXPECT_EQ("/*\n" 2429 "** line 1\n" 2430 "** line 2\n" 2431 "*/", 2432 format("/*\n" 2433 "** line 1\n" 2434 " ** line 2\n" 2435 "*/", 2436 getLLVMStyle())); 2437 2438 // Align with different indent after the decorations. 2439 EXPECT_EQ("/*\n" 2440 " * line 1\n" 2441 " * line 2\n" 2442 " * line 3\n" 2443 " * line 4\n" 2444 " */", 2445 format("/*\n" 2446 "* line 1\n" 2447 " * line 2\n" 2448 " * line 3\n" 2449 "* line 4\n" 2450 "*/", getLLVMStyle())); 2451 2452 // Align empty or blank lines. 2453 EXPECT_EQ("/**\n" 2454 " *\n" 2455 " *\n" 2456 " *\n" 2457 " */", 2458 format("/**\n" 2459 "* \n" 2460 " * \n" 2461 " *\n" 2462 "*/", getLLVMStyle())); 2463 2464 // Align while breaking and reflowing. 2465 EXPECT_EQ("/*\n" 2466 " * long long long\n" 2467 " * long long\n" 2468 " *\n" 2469 " * long */", 2470 format("/*\n" 2471 " * long long long long\n" 2472 " * long\n" 2473 " *\n" 2474 "* long */", 2475 getLLVMStyleWithColumns(20))); 2476 } 2477 } // end namespace 2478 } // end namespace format 2479 } // end namespace clang 2480