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 LLVM_DEBUG(llvm::errs() << "---\n"); 42 LLVM_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 LLVM_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 FormatStyle getTextProtoStyleWithColumns(unsigned ColumnLimit) { 66 FormatStyle Style = getGoogleStyle(FormatStyle::FormatStyle::LK_TextProto); 67 Style.ColumnLimit = ColumnLimit; 68 return Style; 69 } 70 71 void verifyFormat(llvm::StringRef Code, 72 const FormatStyle &Style = getLLVMStyle()) { 73 EXPECT_EQ(Code.str(), format(Code, Style)) << "Expected code is not stable"; 74 EXPECT_EQ(Code.str(), format(test::messUp(Code), Style)); 75 } 76 77 void verifyGoogleFormat(llvm::StringRef Code) { 78 verifyFormat(Code, getGoogleStyle()); 79 } 80 81 /// \brief Verify that clang-format does not crash on the given input. 82 void verifyNoCrash(llvm::StringRef Code, 83 const FormatStyle &Style = getLLVMStyle()) { 84 format(Code, Style, SC_DoNotCheck); 85 } 86 87 int ReplacementCount; 88 }; 89 90 //===----------------------------------------------------------------------===// 91 // Tests for comments. 92 //===----------------------------------------------------------------------===// 93 94 TEST_F(FormatTestComments, UnderstandsSingleLineComments) { 95 verifyFormat("//* */"); 96 verifyFormat("// line 1\n" 97 "// line 2\n" 98 "void f() {}\n"); 99 100 verifyFormat("void f() {\n" 101 " // Doesn't do anything\n" 102 "}"); 103 verifyFormat("SomeObject\n" 104 " // Calling someFunction on SomeObject\n" 105 " .someFunction();"); 106 verifyFormat("auto result = SomeObject\n" 107 " // Calling someFunction on SomeObject\n" 108 " .someFunction();"); 109 verifyFormat("void f(int i, // some comment (probably for i)\n" 110 " int j, // some comment (probably for j)\n" 111 " int k); // some comment (probably for k)"); 112 verifyFormat("void f(int i,\n" 113 " // some comment (probably for j)\n" 114 " int j,\n" 115 " // some comment (probably for k)\n" 116 " int k);"); 117 118 verifyFormat("int i // This is a fancy variable\n" 119 " = 5; // with nicely aligned comment."); 120 121 verifyFormat("// Leading comment.\n" 122 "int a; // Trailing comment."); 123 verifyFormat("int a; // Trailing comment\n" 124 " // on 2\n" 125 " // or 3 lines.\n" 126 "int b;"); 127 verifyFormat("int a; // Trailing comment\n" 128 "\n" 129 "// Leading comment.\n" 130 "int b;"); 131 verifyFormat("int a; // Comment.\n" 132 " // More details.\n" 133 "int bbbb; // Another comment."); 134 verifyFormat( 135 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; // comment\n" 136 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // comment\n" 137 "int cccccccccccccccccccccccccccccc; // comment\n" 138 "int ddd; // looooooooooooooooooooooooong comment\n" 139 "int aaaaaaaaaaaaaaaaaaaaaaa; // comment\n" 140 "int bbbbbbbbbbbbbbbbbbbbb; // comment\n" 141 "int ccccccccccccccccccc; // comment"); 142 143 verifyFormat("#include \"a\" // comment\n" 144 "#include \"a/b/c\" // comment"); 145 verifyFormat("#include <a> // comment\n" 146 "#include <a/b/c> // comment"); 147 EXPECT_EQ("#include \"a\" // comment\n" 148 "#include \"a/b/c\" // comment", 149 format("#include \\\n" 150 " \"a\" // comment\n" 151 "#include \"a/b/c\" // comment")); 152 153 verifyFormat("enum E {\n" 154 " // comment\n" 155 " VAL_A, // comment\n" 156 " VAL_B\n" 157 "};"); 158 159 EXPECT_EQ("enum A {\n" 160 " // line a\n" 161 " a,\n" 162 " b, // line b\n" 163 "\n" 164 " // line c\n" 165 " c\n" 166 "};", 167 format("enum A {\n" 168 " // line a\n" 169 " a,\n" 170 " b, // line b\n" 171 "\n" 172 " // line c\n" 173 " c\n" 174 "};", 175 getLLVMStyleWithColumns(20))); 176 EXPECT_EQ("enum A {\n" 177 " a, // line 1\n" 178 " // line 2\n" 179 "};", 180 format("enum A {\n" 181 " a, // line 1\n" 182 " // line 2\n" 183 "};", 184 getLLVMStyleWithColumns(20))); 185 EXPECT_EQ("enum A {\n" 186 " a, // line 1\n" 187 " // line 2\n" 188 "};", 189 format("enum A {\n" 190 " a, // line 1\n" 191 " // line 2\n" 192 "};", 193 getLLVMStyleWithColumns(20))); 194 EXPECT_EQ("enum A {\n" 195 " a, // line 1\n" 196 " // line 2\n" 197 " b\n" 198 "};", 199 format("enum A {\n" 200 " a, // line 1\n" 201 " // line 2\n" 202 " b\n" 203 "};", 204 getLLVMStyleWithColumns(20))); 205 EXPECT_EQ("enum A {\n" 206 " a, // line 1\n" 207 " // line 2\n" 208 " b\n" 209 "};", 210 format("enum A {\n" 211 " a, // line 1\n" 212 " // line 2\n" 213 " b\n" 214 "};", 215 getLLVMStyleWithColumns(20))); 216 verifyFormat( 217 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 218 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // Trailing comment"); 219 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 220 " // Comment inside a statement.\n" 221 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 222 verifyFormat("SomeFunction(a,\n" 223 " // comment\n" 224 " b + x);"); 225 verifyFormat("SomeFunction(a, a,\n" 226 " // comment\n" 227 " b + x);"); 228 verifyFormat( 229 "bool aaaaaaaaaaaaa = // comment\n" 230 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 231 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 232 233 verifyFormat("int aaaa; // aaaaa\n" 234 "int aa; // aaaaaaa", 235 getLLVMStyleWithColumns(20)); 236 237 EXPECT_EQ("void f() { // This does something ..\n" 238 "}\n" 239 "int a; // This is unrelated", 240 format("void f() { // This does something ..\n" 241 " }\n" 242 "int a; // This is unrelated")); 243 EXPECT_EQ("class C {\n" 244 " void f() { // This does something ..\n" 245 " } // awesome..\n" 246 "\n" 247 " int a; // This is unrelated\n" 248 "};", 249 format("class C{void f() { // This does something ..\n" 250 " } // awesome..\n" 251 " \n" 252 "int a; // This is unrelated\n" 253 "};")); 254 255 EXPECT_EQ("int i; // single line trailing comment", 256 format("int i;\\\n// single line trailing comment")); 257 258 verifyGoogleFormat("int a; // Trailing comment."); 259 260 verifyFormat("someFunction(anotherFunction( // Force break.\n" 261 " parameter));"); 262 263 verifyGoogleFormat("#endif // HEADER_GUARD"); 264 265 verifyFormat("const char *test[] = {\n" 266 " // A\n" 267 " \"aaaa\",\n" 268 " // B\n" 269 " \"aaaaa\"};"); 270 verifyGoogleFormat( 271 "aaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 272 " aaaaaaaaaaaaaaaaaaaaaa); // 81_cols_with_this_comment"); 273 EXPECT_EQ("D(a, {\n" 274 " // test\n" 275 " int a;\n" 276 "});", 277 format("D(a, {\n" 278 "// test\n" 279 "int a;\n" 280 "});")); 281 282 EXPECT_EQ("lineWith(); // comment\n" 283 "// at start\n" 284 "otherLine();", 285 format("lineWith(); // comment\n" 286 "// at start\n" 287 "otherLine();")); 288 EXPECT_EQ("lineWith(); // comment\n" 289 "/*\n" 290 " * at start */\n" 291 "otherLine();", 292 format("lineWith(); // comment\n" 293 "/*\n" 294 " * at start */\n" 295 "otherLine();")); 296 EXPECT_EQ("lineWith(); // comment\n" 297 " // at start\n" 298 "otherLine();", 299 format("lineWith(); // comment\n" 300 " // at start\n" 301 "otherLine();")); 302 303 EXPECT_EQ("lineWith(); // comment\n" 304 "// at start\n" 305 "otherLine(); // comment", 306 format("lineWith(); // comment\n" 307 "// at start\n" 308 "otherLine(); // comment")); 309 EXPECT_EQ("lineWith();\n" 310 "// at start\n" 311 "otherLine(); // comment", 312 format("lineWith();\n" 313 " // at start\n" 314 "otherLine(); // comment")); 315 EXPECT_EQ("// first\n" 316 "// at start\n" 317 "otherLine(); // comment", 318 format("// first\n" 319 " // at start\n" 320 "otherLine(); // comment")); 321 EXPECT_EQ("f();\n" 322 "// first\n" 323 "// at start\n" 324 "otherLine(); // comment", 325 format("f();\n" 326 "// first\n" 327 " // at start\n" 328 "otherLine(); // comment")); 329 verifyFormat("f(); // comment\n" 330 "// first\n" 331 "// at start\n" 332 "otherLine();"); 333 EXPECT_EQ("f(); // comment\n" 334 "// first\n" 335 "// at start\n" 336 "otherLine();", 337 format("f(); // comment\n" 338 "// first\n" 339 " // at start\n" 340 "otherLine();")); 341 EXPECT_EQ("f(); // comment\n" 342 " // first\n" 343 "// at start\n" 344 "otherLine();", 345 format("f(); // comment\n" 346 " // first\n" 347 "// at start\n" 348 "otherLine();")); 349 EXPECT_EQ("void f() {\n" 350 " lineWith(); // comment\n" 351 " // at start\n" 352 "}", 353 format("void f() {\n" 354 " lineWith(); // comment\n" 355 " // at start\n" 356 "}")); 357 EXPECT_EQ("int xy; // a\n" 358 "int z; // b", 359 format("int xy; // a\n" 360 "int z; //b")); 361 EXPECT_EQ("int xy; // a\n" 362 "int z; // bb", 363 format("int xy; // a\n" 364 "int z; //bb", 365 getLLVMStyleWithColumns(12))); 366 367 verifyFormat("#define A \\\n" 368 " int i; /* iiiiiiiiiiiiiiiiiiiii */ \\\n" 369 " int jjjjjjjjjjjjjjjjjjjjjjjj; /* */", 370 getLLVMStyleWithColumns(60)); 371 verifyFormat( 372 "#define A \\\n" 373 " int i; /* iiiiiiiiiiiiiiiiiiiii */ \\\n" 374 " int jjjjjjjjjjjjjjjjjjjjjjjj; /* */", 375 getLLVMStyleWithColumns(61)); 376 377 verifyFormat("if ( // This is some comment\n" 378 " x + 3) {\n" 379 "}"); 380 EXPECT_EQ("if ( // This is some comment\n" 381 " // spanning two lines\n" 382 " x + 3) {\n" 383 "}", 384 format("if( // This is some comment\n" 385 " // spanning two lines\n" 386 " x + 3) {\n" 387 "}")); 388 389 verifyNoCrash("/\\\n/"); 390 verifyNoCrash("/\\\n* */"); 391 // The 0-character somehow makes the lexer return a proper comment. 392 verifyNoCrash(StringRef("/*\\\0\n/", 6)); 393 } 394 395 TEST_F(FormatTestComments, KeepsParameterWithTrailingCommentsOnTheirOwnLine) { 396 EXPECT_EQ("SomeFunction(a,\n" 397 " b, // comment\n" 398 " c);", 399 format("SomeFunction(a,\n" 400 " b, // comment\n" 401 " c);")); 402 EXPECT_EQ("SomeFunction(a, b,\n" 403 " // comment\n" 404 " c);", 405 format("SomeFunction(a,\n" 406 " b,\n" 407 " // comment\n" 408 " c);")); 409 EXPECT_EQ("SomeFunction(a, b, // comment (unclear relation)\n" 410 " c);", 411 format("SomeFunction(a, b, // comment (unclear relation)\n" 412 " c);")); 413 EXPECT_EQ("SomeFunction(a, // comment\n" 414 " b,\n" 415 " c); // comment", 416 format("SomeFunction(a, // comment\n" 417 " b,\n" 418 " c); // comment")); 419 EXPECT_EQ("aaaaaaaaaa(aaaa(aaaa,\n" 420 " aaaa), //\n" 421 " aaaa, bbbbb);", 422 format("aaaaaaaaaa(aaaa(aaaa,\n" 423 "aaaa), //\n" 424 "aaaa, bbbbb);")); 425 } 426 427 TEST_F(FormatTestComments, RemovesTrailingWhitespaceOfComments) { 428 EXPECT_EQ("// comment", format("// comment ")); 429 EXPECT_EQ("int aaaaaaa, bbbbbbb; // comment", 430 format("int aaaaaaa, bbbbbbb; // comment ", 431 getLLVMStyleWithColumns(33))); 432 EXPECT_EQ("// comment\\\n", format("// comment\\\n \t \v \f ")); 433 EXPECT_EQ("// comment \\\n", format("// comment \\\n \t \v \f ")); 434 } 435 436 TEST_F(FormatTestComments, UnderstandsBlockComments) { 437 verifyFormat("f(/*noSpaceAfterParameterNamingComment=*/true);"); 438 verifyFormat("void f() { g(/*aaa=*/x, /*bbb=*/!y, /*c=*/::c); }"); 439 EXPECT_EQ("f(aaaaaaaaaaaaaaaaaaaaaaaaa, /* Trailing comment for aa... */\n" 440 " bbbbbbbbbbbbbbbbbbbbbbbbb);", 441 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \\\n" 442 "/* Trailing comment for aa... */\n" 443 " bbbbbbbbbbbbbbbbbbbbbbbbb);")); 444 EXPECT_EQ( 445 "f(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 446 " /* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);", 447 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \n" 448 "/* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);")); 449 EXPECT_EQ( 450 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 451 " aaaaaaaaaaaaaaaaaa,\n" 452 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n" 453 "}", 454 format("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 455 " aaaaaaaaaaaaaaaaaa ,\n" 456 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n" 457 "}")); 458 verifyFormat("f(/* aaaaaaaaaaaaaaaaaa = */\n" 459 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 460 461 FormatStyle NoBinPacking = getLLVMStyle(); 462 NoBinPacking.BinPackParameters = false; 463 verifyFormat("aaaaaaaa(/* parameter 1 */ aaaaaa,\n" 464 " /* parameter 2 */ aaaaaa,\n" 465 " /* parameter 3 */ aaaaaa,\n" 466 " /* parameter 4 */ aaaaaa);", 467 NoBinPacking); 468 469 // Aligning block comments in macros. 470 verifyGoogleFormat("#define A \\\n" 471 " int i; /*a*/ \\\n" 472 " int jjj; /*b*/"); 473 } 474 475 TEST_F(FormatTestComments, AlignsBlockComments) { 476 EXPECT_EQ("/*\n" 477 " * Really multi-line\n" 478 " * comment.\n" 479 " */\n" 480 "void f() {}", 481 format(" /*\n" 482 " * Really multi-line\n" 483 " * comment.\n" 484 " */\n" 485 " void f() {}")); 486 EXPECT_EQ("class C {\n" 487 " /*\n" 488 " * Another multi-line\n" 489 " * comment.\n" 490 " */\n" 491 " void f() {}\n" 492 "};", 493 format("class C {\n" 494 "/*\n" 495 " * Another multi-line\n" 496 " * comment.\n" 497 " */\n" 498 "void f() {}\n" 499 "};")); 500 EXPECT_EQ("/*\n" 501 " 1. This is a comment with non-trivial formatting.\n" 502 " 1.1. We have to indent/outdent all lines equally\n" 503 " 1.1.1. to keep the formatting.\n" 504 " */", 505 format(" /*\n" 506 " 1. This is a comment with non-trivial formatting.\n" 507 " 1.1. We have to indent/outdent all lines equally\n" 508 " 1.1.1. to keep the formatting.\n" 509 " */")); 510 EXPECT_EQ("/*\n" 511 "Don't try to outdent if there's not enough indentation.\n" 512 "*/", 513 format(" /*\n" 514 " Don't try to outdent if there's not enough indentation.\n" 515 " */")); 516 517 EXPECT_EQ("int i; /* Comment with empty...\n" 518 " *\n" 519 " * line. */", 520 format("int i; /* Comment with empty...\n" 521 " *\n" 522 " * line. */")); 523 EXPECT_EQ("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 format("int foobar = 0; /* comment */\n" 531 "int bar = 0; /* multiline\n" 532 " comment 1 */\n" 533 "int baz = 0; /* multiline\n" 534 " comment 2 */\n" 535 "int bzz = 0; /* multiline\n" 536 " comment 3 */")); 537 EXPECT_EQ("int foobar = 0; /* comment */\n" 538 "int bar = 0; /* multiline\n" 539 " comment */\n" 540 "int baz = 0; /* multiline\n" 541 "comment */", 542 format("int foobar = 0; /* comment */\n" 543 "int bar = 0; /* multiline\n" 544 "comment */\n" 545 "int baz = 0; /* multiline\n" 546 "comment */")); 547 } 548 549 TEST_F(FormatTestComments, CommentReflowingCanBeTurnedOff) { 550 FormatStyle Style = getLLVMStyleWithColumns(20); 551 Style.ReflowComments = false; 552 verifyFormat("// aaaaaaaaa aaaaaaaaaa aaaaaaaaaa", Style); 553 verifyFormat("/* aaaaaaaaa aaaaaaaaaa aaaaaaaaaa */", Style); 554 } 555 556 TEST_F(FormatTestComments, CorrectlyHandlesLengthOfBlockComments) { 557 EXPECT_EQ("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 558 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */", 559 format("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 560 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */")); 561 EXPECT_EQ( 562 "void ffffffffffff(\n" 563 " int aaaaaaaa, int bbbbbbbb,\n" 564 " int cccccccccccc) { /*\n" 565 " aaaaaaaaaa\n" 566 " aaaaaaaaaaaaa\n" 567 " bbbbbbbbbbbbbb\n" 568 " bbbbbbbbbb\n" 569 " */\n" 570 "}", 571 format("void ffffffffffff(int aaaaaaaa, int bbbbbbbb, int cccccccccccc)\n" 572 "{ /*\n" 573 " aaaaaaaaaa aaaaaaaaaaaaa\n" 574 " bbbbbbbbbbbbbb bbbbbbbbbb\n" 575 " */\n" 576 "}", 577 getLLVMStyleWithColumns(40))); 578 } 579 580 TEST_F(FormatTestComments, DontBreakNonTrailingBlockComments) { 581 EXPECT_EQ("void ffffffffff(\n" 582 " int aaaaa /* test */);", 583 format("void ffffffffff(int aaaaa /* test */);", 584 getLLVMStyleWithColumns(35))); 585 } 586 587 TEST_F(FormatTestComments, SplitsLongCxxComments) { 588 EXPECT_EQ("// A comment that\n" 589 "// doesn't fit on\n" 590 "// one line", 591 format("// A comment that doesn't fit on one line", 592 getLLVMStyleWithColumns(20))); 593 EXPECT_EQ("/// A comment that\n" 594 "/// doesn't fit on\n" 595 "/// one line", 596 format("/// A comment that doesn't fit on one line", 597 getLLVMStyleWithColumns(20))); 598 EXPECT_EQ("//! A comment that\n" 599 "//! doesn't fit on\n" 600 "//! one line", 601 format("//! A comment that doesn't fit on one line", 602 getLLVMStyleWithColumns(20))); 603 EXPECT_EQ("// a b c d\n" 604 "// e f g\n" 605 "// h i j k", 606 format("// a b c d e f g h i j k", getLLVMStyleWithColumns(10))); 607 EXPECT_EQ( 608 "// a b c d\n" 609 "// e f g\n" 610 "// h i j k", 611 format("\\\n// a b c d e f g h i j k", getLLVMStyleWithColumns(10))); 612 EXPECT_EQ("if (true) // A comment that\n" 613 " // doesn't fit on\n" 614 " // one line", 615 format("if (true) // A comment that doesn't fit on one line ", 616 getLLVMStyleWithColumns(30))); 617 EXPECT_EQ("// Don't_touch_leading_whitespace", 618 format("// Don't_touch_leading_whitespace", 619 getLLVMStyleWithColumns(20))); 620 EXPECT_EQ("// Add leading\n" 621 "// whitespace", 622 format("//Add leading whitespace", getLLVMStyleWithColumns(20))); 623 EXPECT_EQ("/// Add leading\n" 624 "/// whitespace", 625 format("///Add leading whitespace", getLLVMStyleWithColumns(20))); 626 EXPECT_EQ("//! Add leading\n" 627 "//! whitespace", 628 format("//!Add leading whitespace", getLLVMStyleWithColumns(20))); 629 EXPECT_EQ("// whitespace", format("//whitespace", getLLVMStyle())); 630 EXPECT_EQ("// Even if it makes the line exceed the column\n" 631 "// limit", 632 format("//Even if it makes the line exceed the column limit", 633 getLLVMStyleWithColumns(51))); 634 EXPECT_EQ("//--But not here", format("//--But not here", getLLVMStyle())); 635 EXPECT_EQ("/// line 1\n" 636 "// add leading whitespace", 637 format("/// line 1\n" 638 "//add leading whitespace", 639 getLLVMStyleWithColumns(30))); 640 EXPECT_EQ("/// 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", 647 format("///line 1\n" 648 "///line 2\n" 649 "//! line 3\n" 650 "//!line 4\n" 651 "//!line 5\n" 652 "// line 6\n" 653 "//line 7", getLLVMStyleWithColumns(20))); 654 655 EXPECT_EQ("// aa bb cc dd", 656 format("// aa bb cc dd ", 657 getLLVMStyleWithColumns(15))); 658 659 EXPECT_EQ("// A comment before\n" 660 "// a macro\n" 661 "// definition\n" 662 "#define a b", 663 format("// A comment before a macro definition\n" 664 "#define a b", 665 getLLVMStyleWithColumns(20))); 666 EXPECT_EQ("void ffffff(\n" 667 " int aaaaaaaaa, // wwww\n" 668 " int bbbbbbbbbb, // xxxxxxx\n" 669 " // yyyyyyyyyy\n" 670 " int c, int d, int e) {}", 671 format("void ffffff(\n" 672 " int aaaaaaaaa, // wwww\n" 673 " int bbbbbbbbbb, // xxxxxxx yyyyyyyyyy\n" 674 " int c, int d, int e) {}", 675 getLLVMStyleWithColumns(40))); 676 EXPECT_EQ("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 677 format("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 678 getLLVMStyleWithColumns(20))); 679 EXPECT_EQ( 680 "#define XXX // a b c d\n" 681 " // e f g h", 682 format("#define XXX // a b c d e f g h", getLLVMStyleWithColumns(22))); 683 EXPECT_EQ( 684 "#define XXX // q w e r\n" 685 " // t y u i", 686 format("#define XXX //q w e r t y u i", getLLVMStyleWithColumns(22))); 687 EXPECT_EQ("{\n" 688 " //\n" 689 " //\\\n" 690 " // long 1 2 3 4 5\n" 691 "}", 692 format("{\n" 693 " //\n" 694 " //\\\n" 695 " // long 1 2 3 4 5\n" 696 "}", 697 getLLVMStyleWithColumns(20))); 698 EXPECT_EQ("{\n" 699 " //\n" 700 " //\\\n" 701 " // long 1 2 3 4 5\n" 702 " // 6\n" 703 "}", 704 format("{\n" 705 " //\n" 706 " //\\\n" 707 " // long 1 2 3 4 5 6\n" 708 "}", 709 getLLVMStyleWithColumns(20))); 710 } 711 712 TEST_F(FormatTestComments, PreservesHangingIndentInCxxComments) { 713 EXPECT_EQ("// A comment\n" 714 "// that doesn't\n" 715 "// fit on one\n" 716 "// line", 717 format("// A comment that doesn't fit on one line", 718 getLLVMStyleWithColumns(20))); 719 EXPECT_EQ("/// A comment\n" 720 "/// that doesn't\n" 721 "/// fit on one\n" 722 "/// line", 723 format("/// A comment that doesn't fit on one line", 724 getLLVMStyleWithColumns(20))); 725 } 726 727 TEST_F(FormatTestComments, DontSplitLineCommentsWithEscapedNewlines) { 728 EXPECT_EQ("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 729 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 730 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 731 format("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 732 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 733 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")); 734 EXPECT_EQ("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 735 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 736 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 737 format("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 738 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 739 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 740 getLLVMStyleWithColumns(50))); 741 // FIXME: One day we might want to implement adjustment of leading whitespace 742 // of the consecutive lines in this kind of comment: 743 EXPECT_EQ("double\n" 744 " a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 745 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 746 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 747 format("double a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 748 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 749 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 750 getLLVMStyleWithColumns(49))); 751 } 752 753 TEST_F(FormatTestComments, DontSplitLineCommentsWithPragmas) { 754 FormatStyle Pragmas = getLLVMStyleWithColumns(30); 755 Pragmas.CommentPragmas = "^ IWYU pragma:"; 756 EXPECT_EQ( 757 "// IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb", 758 format("// IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb", Pragmas)); 759 EXPECT_EQ( 760 "/* IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb */", 761 format("/* IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb */", Pragmas)); 762 } 763 764 TEST_F(FormatTestComments, PriorityOfCommentBreaking) { 765 EXPECT_EQ("if (xxx ==\n" 766 " yyy && // aaaaaaaaaaaa bbbbbbbbb\n" 767 " zzz)\n" 768 " q();", 769 format("if (xxx == yyy && // aaaaaaaaaaaa bbbbbbbbb\n" 770 " zzz) q();", 771 getLLVMStyleWithColumns(40))); 772 EXPECT_EQ("if (xxxxxxxxxx ==\n" 773 " yyy && // aaaaaa bbbbbbbb cccc\n" 774 " zzz)\n" 775 " q();", 776 format("if (xxxxxxxxxx == yyy && // aaaaaa bbbbbbbb cccc\n" 777 " zzz) q();", 778 getLLVMStyleWithColumns(40))); 779 EXPECT_EQ("if (xxxxxxxxxx &&\n" 780 " yyy || // aaaaaa bbbbbbbb cccc\n" 781 " zzz)\n" 782 " q();", 783 format("if (xxxxxxxxxx && yyy || // aaaaaa bbbbbbbb cccc\n" 784 " zzz) q();", 785 getLLVMStyleWithColumns(40))); 786 EXPECT_EQ("fffffffff(\n" 787 " &xxx, // aaaaaaaaaaaa bbbbbbbbbbb\n" 788 " zzz);", 789 format("fffffffff(&xxx, // aaaaaaaaaaaa bbbbbbbbbbb\n" 790 " zzz);", 791 getLLVMStyleWithColumns(40))); 792 } 793 794 TEST_F(FormatTestComments, MultiLineCommentsInDefines) { 795 EXPECT_EQ("#define A(x) /* \\\n" 796 " a comment \\\n" 797 " inside */ \\\n" 798 " f();", 799 format("#define A(x) /* \\\n" 800 " a comment \\\n" 801 " inside */ \\\n" 802 " f();", 803 getLLVMStyleWithColumns(17))); 804 EXPECT_EQ("#define A( \\\n" 805 " x) /* \\\n" 806 " a comment \\\n" 807 " inside */ \\\n" 808 " f();", 809 format("#define A( \\\n" 810 " x) /* \\\n" 811 " a comment \\\n" 812 " inside */ \\\n" 813 " f();", 814 getLLVMStyleWithColumns(17))); 815 } 816 817 TEST_F(FormatTestComments, ParsesCommentsAdjacentToPPDirectives) { 818 EXPECT_EQ("namespace {}\n// Test\n#define A", 819 format("namespace {}\n // Test\n#define A")); 820 EXPECT_EQ("namespace {}\n/* Test */\n#define A", 821 format("namespace {}\n /* Test */\n#define A")); 822 EXPECT_EQ("namespace {}\n/* Test */ #define A", 823 format("namespace {}\n /* Test */ #define A")); 824 } 825 826 TEST_F(FormatTestComments, KeepsLevelOfCommentBeforePPDirective) { 827 // Keep the current level if the comment was originally not aligned with 828 // the preprocessor directive. 829 EXPECT_EQ("void f() {\n" 830 " int i;\n" 831 " /* comment */\n" 832 "#ifdef A\n" 833 " int j;\n" 834 "}", 835 format("void f() {\n" 836 " int i;\n" 837 " /* comment */\n" 838 "#ifdef A\n" 839 " int j;\n" 840 "}")); 841 842 EXPECT_EQ("void f() {\n" 843 " int i;\n" 844 " /* comment */\n" 845 "\n" 846 "#ifdef A\n" 847 " int j;\n" 848 "}", 849 format("void f() {\n" 850 " int i;\n" 851 " /* comment */\n" 852 "\n" 853 "#ifdef A\n" 854 " int j;\n" 855 "}")); 856 857 EXPECT_EQ("int f(int i) {\n" 858 " if (true) {\n" 859 " ++i;\n" 860 " }\n" 861 " // comment\n" 862 "#ifdef A\n" 863 " int j;\n" 864 "#endif\n" 865 "}", 866 format("int f(int i) {\n" 867 " if (true) {\n" 868 " ++i;\n" 869 " }\n" 870 " // comment\n" 871 "#ifdef A\n" 872 "int j;\n" 873 "#endif\n" 874 "}")); 875 876 EXPECT_EQ("int f(int i) {\n" 877 " if (true) {\n" 878 " i++;\n" 879 " } else {\n" 880 " // comment in else\n" 881 "#ifdef A\n" 882 " j++;\n" 883 "#endif\n" 884 " }\n" 885 "}", 886 format("int f(int i) {\n" 887 " if (true) {\n" 888 " i++;\n" 889 " } else {\n" 890 " // comment in else\n" 891 "#ifdef A\n" 892 " j++;\n" 893 "#endif\n" 894 " }\n" 895 "}")); 896 897 EXPECT_EQ("int f(int i) {\n" 898 " if (true) {\n" 899 " i++;\n" 900 " } else {\n" 901 " /* comment in else */\n" 902 "#ifdef A\n" 903 " j++;\n" 904 "#endif\n" 905 " }\n" 906 "}", 907 format("int f(int i) {\n" 908 " if (true) {\n" 909 " i++;\n" 910 " } else {\n" 911 " /* comment in else */\n" 912 "#ifdef A\n" 913 " j++;\n" 914 "#endif\n" 915 " }\n" 916 "}")); 917 918 // Keep the current level if there is an empty line between the comment and 919 // the preprocessor directive. 920 EXPECT_EQ("void f() {\n" 921 " int i;\n" 922 " /* comment */\n" 923 "\n" 924 "#ifdef A\n" 925 " int j;\n" 926 "}", 927 format("void f() {\n" 928 " int i;\n" 929 "/* comment */\n" 930 "\n" 931 "#ifdef A\n" 932 " int j;\n" 933 "}")); 934 935 EXPECT_EQ("void f() {\n" 936 " int i;\n" 937 " return i;\n" 938 "}\n" 939 "// comment\n" 940 "\n" 941 "#ifdef A\n" 942 "int i;\n" 943 "#endif // A", 944 format("void f() {\n" 945 " int i;\n" 946 " return i;\n" 947 "}\n" 948 "// comment\n" 949 "\n" 950 "#ifdef A\n" 951 "int i;\n" 952 "#endif // A")); 953 954 EXPECT_EQ("int f(int i) {\n" 955 " if (true) {\n" 956 " ++i;\n" 957 " }\n" 958 " // comment\n" 959 "\n" 960 "#ifdef A\n" 961 " int j;\n" 962 "#endif\n" 963 "}", 964 format("int f(int i) {\n" 965 " if (true) {\n" 966 " ++i;\n" 967 " }\n" 968 " // comment\n" 969 "\n" 970 "#ifdef A\n" 971 " int j;\n" 972 "#endif\n" 973 "}")); 974 975 EXPECT_EQ("int f(int i) {\n" 976 " if (true) {\n" 977 " i++;\n" 978 " } else {\n" 979 " // comment in else\n" 980 "\n" 981 "#ifdef A\n" 982 " j++;\n" 983 "#endif\n" 984 " }\n" 985 "}", 986 format("int f(int i) {\n" 987 " if (true) {\n" 988 " i++;\n" 989 " } else {\n" 990 "// comment in else\n" 991 "\n" 992 "#ifdef A\n" 993 " j++;\n" 994 "#endif\n" 995 " }\n" 996 "}")); 997 998 EXPECT_EQ("int f(int i) {\n" 999 " if (true) {\n" 1000 " i++;\n" 1001 " } else {\n" 1002 " /* comment in else */\n" 1003 "\n" 1004 "#ifdef A\n" 1005 " j++;\n" 1006 "#endif\n" 1007 " }\n" 1008 "}", 1009 format("int f(int i) {\n" 1010 " if (true) {\n" 1011 " i++;\n" 1012 " } else {\n" 1013 "/* comment in else */\n" 1014 "\n" 1015 "#ifdef A\n" 1016 " j++;\n" 1017 "#endif\n" 1018 " }\n" 1019 "}")); 1020 1021 // Align with the preprocessor directive if the comment was originally aligned 1022 // with the preprocessor directive and there is no newline between the comment 1023 // and the preprocessor directive. 1024 EXPECT_EQ("void f() {\n" 1025 " int i;\n" 1026 "/* comment */\n" 1027 "#ifdef A\n" 1028 " int j;\n" 1029 "}", 1030 format("void f() {\n" 1031 " int i;\n" 1032 "/* comment */\n" 1033 "#ifdef A\n" 1034 " int j;\n" 1035 "}")); 1036 1037 EXPECT_EQ("int f(int i) {\n" 1038 " if (true) {\n" 1039 " ++i;\n" 1040 " }\n" 1041 "// comment\n" 1042 "#ifdef A\n" 1043 " int j;\n" 1044 "#endif\n" 1045 "}", 1046 format("int f(int i) {\n" 1047 " if (true) {\n" 1048 " ++i;\n" 1049 " }\n" 1050 "// comment\n" 1051 "#ifdef A\n" 1052 " int j;\n" 1053 "#endif\n" 1054 "}")); 1055 1056 EXPECT_EQ("int f(int i) {\n" 1057 " if (true) {\n" 1058 " i++;\n" 1059 " } else {\n" 1060 "// comment in else\n" 1061 "#ifdef A\n" 1062 " j++;\n" 1063 "#endif\n" 1064 " }\n" 1065 "}", 1066 format("int f(int i) {\n" 1067 " if (true) {\n" 1068 " i++;\n" 1069 " } else {\n" 1070 " // comment in else\n" 1071 " #ifdef A\n" 1072 " j++;\n" 1073 "#endif\n" 1074 " }\n" 1075 "}")); 1076 1077 EXPECT_EQ("int f(int i) {\n" 1078 " if (true) {\n" 1079 " i++;\n" 1080 " } else {\n" 1081 "/* comment in else */\n" 1082 "#ifdef A\n" 1083 " j++;\n" 1084 "#endif\n" 1085 " }\n" 1086 "}", 1087 format("int f(int i) {\n" 1088 " if (true) {\n" 1089 " i++;\n" 1090 " } else {\n" 1091 " /* comment in else */\n" 1092 " #ifdef A\n" 1093 " j++;\n" 1094 "#endif\n" 1095 " }\n" 1096 "}")); 1097 } 1098 1099 TEST_F(FormatTestComments, SplitsLongLinesInComments) { 1100 // FIXME: Do we need to fix up the " */" at the end? 1101 // It doesn't look like any of our current logic triggers this. 1102 EXPECT_EQ("/* This is a long\n" 1103 " * comment that\n" 1104 " * doesn't fit on\n" 1105 " * one line. */", 1106 format("/* " 1107 "This is a long " 1108 "comment that " 1109 "doesn't " 1110 "fit on one line. */", 1111 getLLVMStyleWithColumns(20))); 1112 EXPECT_EQ( 1113 "/* a b c d\n" 1114 " * e f g\n" 1115 " * h i j k\n" 1116 " */", 1117 format("/* a b c d e f g h i j k */", getLLVMStyleWithColumns(10))); 1118 EXPECT_EQ( 1119 "/* a b c d\n" 1120 " * e f g\n" 1121 " * h i j k\n" 1122 " */", 1123 format("\\\n/* a b c d e f g h i j k */", getLLVMStyleWithColumns(10))); 1124 EXPECT_EQ("/*\n" 1125 "This is a long\n" 1126 "comment that doesn't\n" 1127 "fit on one line.\n" 1128 "*/", 1129 format("/*\n" 1130 "This is a long " 1131 "comment that doesn't " 1132 "fit on one line. \n" 1133 "*/", 1134 getLLVMStyleWithColumns(20))); 1135 EXPECT_EQ("/*\n" 1136 " * This is a long\n" 1137 " * comment that\n" 1138 " * doesn't fit on\n" 1139 " * one line.\n" 1140 " */", 1141 format("/* \n" 1142 " * This is a long " 1143 " comment that " 1144 " doesn't fit on " 1145 " one line. \n" 1146 " */", 1147 getLLVMStyleWithColumns(20))); 1148 EXPECT_EQ("/*\n" 1149 " * This_is_a_comment_with_words_that_dont_fit_on_one_line\n" 1150 " * so_it_should_be_broken\n" 1151 " * wherever_a_space_occurs\n" 1152 " */", 1153 format("/*\n" 1154 " * This_is_a_comment_with_words_that_dont_fit_on_one_line " 1155 " so_it_should_be_broken " 1156 " wherever_a_space_occurs \n" 1157 " */", 1158 getLLVMStyleWithColumns(20))); 1159 EXPECT_EQ("/*\n" 1160 " * This_comment_can_not_be_broken_into_lines\n" 1161 " */", 1162 format("/*\n" 1163 " * This_comment_can_not_be_broken_into_lines\n" 1164 " */", 1165 getLLVMStyleWithColumns(20))); 1166 EXPECT_EQ("{\n" 1167 " /*\n" 1168 " This is another\n" 1169 " long comment that\n" 1170 " doesn't fit on one\n" 1171 " line 1234567890\n" 1172 " */\n" 1173 "}", 1174 format("{\n" 1175 "/*\n" 1176 "This is another " 1177 " long comment that " 1178 " doesn't fit on one" 1179 " line 1234567890\n" 1180 "*/\n" 1181 "}", 1182 getLLVMStyleWithColumns(20))); 1183 EXPECT_EQ("{\n" 1184 " /*\n" 1185 " * This i s\n" 1186 " * another comment\n" 1187 " * t hat doesn' t\n" 1188 " * fit on one l i\n" 1189 " * n e\n" 1190 " */\n" 1191 "}", 1192 format("{\n" 1193 "/*\n" 1194 " * This i s" 1195 " another comment" 1196 " t hat doesn' t" 1197 " fit on one l i" 1198 " n e\n" 1199 " */\n" 1200 "}", 1201 getLLVMStyleWithColumns(20))); 1202 EXPECT_EQ("/*\n" 1203 " * This is a long\n" 1204 " * comment that\n" 1205 " * doesn't fit on\n" 1206 " * one line\n" 1207 " */", 1208 format(" /*\n" 1209 " * This is a long comment that doesn't fit on one line\n" 1210 " */", 1211 getLLVMStyleWithColumns(20))); 1212 EXPECT_EQ("{\n" 1213 " if (something) /* This is a\n" 1214 " long\n" 1215 " comment */\n" 1216 " ;\n" 1217 "}", 1218 format("{\n" 1219 " if (something) /* This is a long comment */\n" 1220 " ;\n" 1221 "}", 1222 getLLVMStyleWithColumns(30))); 1223 1224 EXPECT_EQ("/* A comment before\n" 1225 " * a macro\n" 1226 " * definition */\n" 1227 "#define a b", 1228 format("/* A comment before a macro definition */\n" 1229 "#define a b", 1230 getLLVMStyleWithColumns(20))); 1231 1232 EXPECT_EQ("/* some comment\n" 1233 " * a comment that\n" 1234 " * we break another\n" 1235 " * comment we have\n" 1236 " * to break a left\n" 1237 " * comment\n" 1238 " */", 1239 format(" /* some comment\n" 1240 " * a comment that we break\n" 1241 " * another comment we have to break\n" 1242 "* a left comment\n" 1243 " */", 1244 getLLVMStyleWithColumns(20))); 1245 1246 EXPECT_EQ("/**\n" 1247 " * multiline block\n" 1248 " * comment\n" 1249 " *\n" 1250 " */", 1251 format("/**\n" 1252 " * multiline block comment\n" 1253 " *\n" 1254 " */", 1255 getLLVMStyleWithColumns(20))); 1256 1257 // This reproduces a crashing bug where both adaptStartOfLine and 1258 // getCommentSplit were trying to wrap after the "/**". 1259 EXPECT_EQ("/** multilineblockcommentwithnowrapopportunity */", 1260 format("/** multilineblockcommentwithnowrapopportunity */", 1261 getLLVMStyleWithColumns(20))); 1262 1263 EXPECT_EQ("/*\n" 1264 "\n" 1265 "\n" 1266 " */\n", 1267 format(" /* \n" 1268 " \n" 1269 " \n" 1270 " */\n")); 1271 1272 EXPECT_EQ("/* a a */", 1273 format("/* a a */", getLLVMStyleWithColumns(15))); 1274 EXPECT_EQ("/* a a bc */", 1275 format("/* a a bc */", getLLVMStyleWithColumns(15))); 1276 EXPECT_EQ("/* aaa aaa\n" 1277 " * aaaaa */", 1278 format("/* aaa aaa aaaaa */", getLLVMStyleWithColumns(15))); 1279 EXPECT_EQ("/* aaa aaa\n" 1280 " * aaaaa */", 1281 format("/* aaa aaa aaaaa */", getLLVMStyleWithColumns(15))); 1282 } 1283 1284 TEST_F(FormatTestComments, SplitsLongLinesInCommentsInPreprocessor) { 1285 EXPECT_EQ("#define X \\\n" 1286 " /* \\\n" 1287 " Test \\\n" 1288 " Macro comment \\\n" 1289 " with a long \\\n" 1290 " line \\\n" 1291 " */ \\\n" 1292 " A + B", 1293 format("#define X \\\n" 1294 " /*\n" 1295 " Test\n" 1296 " Macro comment with a long line\n" 1297 " */ \\\n" 1298 " A + B", 1299 getLLVMStyleWithColumns(20))); 1300 EXPECT_EQ("#define X \\\n" 1301 " /* Macro comment \\\n" 1302 " with a long \\\n" 1303 " line */ \\\n" 1304 " A + B", 1305 format("#define X \\\n" 1306 " /* Macro comment with a long\n" 1307 " line */ \\\n" 1308 " A + B", 1309 getLLVMStyleWithColumns(20))); 1310 EXPECT_EQ("#define X \\\n" 1311 " /* Macro comment \\\n" 1312 " * with a long \\\n" 1313 " * line */ \\\n" 1314 " A + B", 1315 format("#define X \\\n" 1316 " /* Macro comment with a long line */ \\\n" 1317 " A + B", 1318 getLLVMStyleWithColumns(20))); 1319 } 1320 1321 TEST_F(FormatTestComments, KeepsTrailingPPCommentsAndSectionCommentsSeparate) { 1322 verifyFormat("#ifdef A // line about A\n" 1323 "// section comment\n" 1324 "#endif", 1325 getLLVMStyleWithColumns(80)); 1326 verifyFormat("#ifdef A // line 1 about A\n" 1327 " // line 2 about A\n" 1328 "// section comment\n" 1329 "#endif", 1330 getLLVMStyleWithColumns(80)); 1331 EXPECT_EQ("#ifdef A // line 1 about A\n" 1332 " // line 2 about A\n" 1333 "// section comment\n" 1334 "#endif", 1335 format("#ifdef A // line 1 about A\n" 1336 " // line 2 about A\n" 1337 "// section comment\n" 1338 "#endif", 1339 getLLVMStyleWithColumns(80))); 1340 verifyFormat("int f() {\n" 1341 " int i;\n" 1342 "#ifdef A // comment about A\n" 1343 " // section comment 1\n" 1344 " // section comment 2\n" 1345 " i = 2;\n" 1346 "#else // comment about #else\n" 1347 " // section comment 3\n" 1348 " i = 4;\n" 1349 "#endif\n" 1350 "}", getLLVMStyleWithColumns(80)); 1351 } 1352 1353 TEST_F(FormatTestComments, AlignsPPElseEndifComments) { 1354 verifyFormat("#if A\n" 1355 "#else // A\n" 1356 "int iiii;\n" 1357 "#endif // B", 1358 getLLVMStyleWithColumns(20)); 1359 verifyFormat("#if A\n" 1360 "#else // A\n" 1361 "int iiii; // CC\n" 1362 "#endif // B", 1363 getLLVMStyleWithColumns(20)); 1364 EXPECT_EQ("#if A\n" 1365 "#else // A1\n" 1366 " // A2\n" 1367 "int ii;\n" 1368 "#endif // B", 1369 format("#if A\n" 1370 "#else // A1\n" 1371 " // A2\n" 1372 "int ii;\n" 1373 "#endif // B", 1374 getLLVMStyleWithColumns(20))); 1375 } 1376 1377 TEST_F(FormatTestComments, CommentsInStaticInitializers) { 1378 EXPECT_EQ( 1379 "static SomeType type = {aaaaaaaaaaaaaaaaaaaa, /* comment */\n" 1380 " aaaaaaaaaaaaaaaaaaaa /* comment */,\n" 1381 " /* comment */ aaaaaaaaaaaaaaaaaaaa,\n" 1382 " aaaaaaaaaaaaaaaaaaaa, // comment\n" 1383 " aaaaaaaaaaaaaaaaaaaa};", 1384 format("static SomeType type = { aaaaaaaaaaaaaaaaaaaa , /* comment */\n" 1385 " aaaaaaaaaaaaaaaaaaaa /* comment */ ,\n" 1386 " /* comment */ aaaaaaaaaaaaaaaaaaaa ,\n" 1387 " aaaaaaaaaaaaaaaaaaaa , // comment\n" 1388 " aaaaaaaaaaaaaaaaaaaa };")); 1389 verifyFormat("static SomeType type = {aaaaaaaaaaa, // comment for aa...\n" 1390 " bbbbbbbbbbb, ccccccccccc};"); 1391 verifyFormat("static SomeType type = {aaaaaaaaaaa,\n" 1392 " // comment for bb....\n" 1393 " bbbbbbbbbbb, ccccccccccc};"); 1394 verifyGoogleFormat( 1395 "static SomeType type = {aaaaaaaaaaa, // comment for aa...\n" 1396 " bbbbbbbbbbb, ccccccccccc};"); 1397 verifyGoogleFormat("static SomeType type = {aaaaaaaaaaa,\n" 1398 " // comment for bb....\n" 1399 " bbbbbbbbbbb, ccccccccccc};"); 1400 1401 verifyFormat("S s = {{a, b, c}, // Group #1\n" 1402 " {d, e, f}, // Group #2\n" 1403 " {g, h, i}}; // Group #3"); 1404 verifyFormat("S s = {{// Group #1\n" 1405 " a, b, c},\n" 1406 " {// Group #2\n" 1407 " d, e, f},\n" 1408 " {// Group #3\n" 1409 " g, h, i}};"); 1410 1411 EXPECT_EQ("S s = {\n" 1412 " // Some comment\n" 1413 " a,\n" 1414 "\n" 1415 " // Comment after empty line\n" 1416 " b}", 1417 format("S s = {\n" 1418 " // Some comment\n" 1419 " a,\n" 1420 " \n" 1421 " // Comment after empty line\n" 1422 " b\n" 1423 "}")); 1424 EXPECT_EQ("S s = {\n" 1425 " /* Some comment */\n" 1426 " a,\n" 1427 "\n" 1428 " /* Comment after empty line */\n" 1429 " b}", 1430 format("S s = {\n" 1431 " /* Some comment */\n" 1432 " a,\n" 1433 " \n" 1434 " /* Comment after empty line */\n" 1435 " b\n" 1436 "}")); 1437 verifyFormat("const uint8_t aaaaaaaaaaaaaaaaaaaaaa[0] = {\n" 1438 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n" 1439 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n" 1440 " 0x00, 0x00, 0x00, 0x00}; // comment\n"); 1441 } 1442 1443 TEST_F(FormatTestComments, LineCommentsAfterRightBrace) { 1444 EXPECT_EQ("if (true) { // comment about branch\n" 1445 " // comment about f\n" 1446 " f();\n" 1447 "}", 1448 format("if (true) { // comment about branch\n" 1449 " // comment about f\n" 1450 " f();\n" 1451 "}", 1452 getLLVMStyleWithColumns(80))); 1453 EXPECT_EQ("if (1) { // if line 1\n" 1454 " // if line 2\n" 1455 " // if line 3\n" 1456 " // f line 1\n" 1457 " // f line 2\n" 1458 " f();\n" 1459 "} else { // else line 1\n" 1460 " // else line 2\n" 1461 " // else line 3\n" 1462 " // g line 1\n" 1463 " g();\n" 1464 "}", 1465 format("if (1) { // if line 1\n" 1466 " // if line 2\n" 1467 " // if line 3\n" 1468 " // f line 1\n" 1469 " // f line 2\n" 1470 " f();\n" 1471 "} else { // else line 1\n" 1472 " // else line 2\n" 1473 " // else line 3\n" 1474 " // g line 1\n" 1475 " g();\n" 1476 "}")); 1477 EXPECT_EQ("do { // line 1\n" 1478 " // line 2\n" 1479 " // line 3\n" 1480 " f();\n" 1481 "} while (true);", 1482 format("do { // line 1\n" 1483 " // line 2\n" 1484 " // line 3\n" 1485 " f();\n" 1486 "} while (true);", 1487 getLLVMStyleWithColumns(80))); 1488 EXPECT_EQ("while (a < b) { // line 1\n" 1489 " // line 2\n" 1490 " // line 3\n" 1491 " f();\n" 1492 "}", 1493 format("while (a < b) {// line 1\n" 1494 " // line 2\n" 1495 " // line 3\n" 1496 " f();\n" 1497 "}", 1498 getLLVMStyleWithColumns(80))); 1499 } 1500 1501 TEST_F(FormatTestComments, ReflowsComments) { 1502 // Break a long line and reflow with the full next line. 1503 EXPECT_EQ("// long long long\n" 1504 "// long long", 1505 format("// long long long long\n" 1506 "// long", 1507 getLLVMStyleWithColumns(20))); 1508 1509 // Keep the trailing newline while reflowing. 1510 EXPECT_EQ("// long long long\n" 1511 "// long long\n", 1512 format("// long long long long\n" 1513 "// long\n", 1514 getLLVMStyleWithColumns(20))); 1515 1516 // Break a long line and reflow with a part of the next line. 1517 EXPECT_EQ("// long long long\n" 1518 "// long long\n" 1519 "// long_long", 1520 format("// long long long long\n" 1521 "// long long_long", 1522 getLLVMStyleWithColumns(20))); 1523 1524 // Break but do not reflow if the first word from the next line is too long. 1525 EXPECT_EQ("// long long long\n" 1526 "// long\n" 1527 "// long_long_long\n", 1528 format("// long long long long\n" 1529 "// long_long_long\n", 1530 getLLVMStyleWithColumns(20))); 1531 1532 // Don't break or reflow short lines. 1533 verifyFormat("// long\n" 1534 "// long long long lo\n" 1535 "// long long long lo\n" 1536 "// long", 1537 getLLVMStyleWithColumns(20)); 1538 1539 // Keep prefixes and decorations while reflowing. 1540 EXPECT_EQ("/// long long long\n" 1541 "/// long long\n", 1542 format("/// long long long long\n" 1543 "/// long\n", 1544 getLLVMStyleWithColumns(20))); 1545 EXPECT_EQ("//! long long long\n" 1546 "//! long long\n", 1547 format("//! long long long long\n" 1548 "//! long\n", 1549 getLLVMStyleWithColumns(20))); 1550 EXPECT_EQ("/* long long long\n" 1551 " * long long */", 1552 format("/* long long long long\n" 1553 " * long */", 1554 getLLVMStyleWithColumns(20))); 1555 EXPECT_EQ("///< long long long\n" 1556 "///< long long\n", 1557 format("///< long long long long\n" 1558 "///< long\n", 1559 getLLVMStyleWithColumns(20))); 1560 EXPECT_EQ("//!< long long long\n" 1561 "//!< long long\n", 1562 format("//!< long long long long\n" 1563 "//!< long\n", 1564 getLLVMStyleWithColumns(20))); 1565 1566 // Don't bring leading whitespace up while reflowing. 1567 EXPECT_EQ("/* long long long\n" 1568 " * long long long\n" 1569 " */", 1570 format("/* long long long long\n" 1571 " * long long\n" 1572 " */", 1573 getLLVMStyleWithColumns(20))); 1574 1575 // Reflow the last line of a block comment with its trailing '*/'. 1576 EXPECT_EQ("/* long long long\n" 1577 " long long */", 1578 format("/* long long long long\n" 1579 " long */", 1580 getLLVMStyleWithColumns(20))); 1581 1582 // Reflow two short lines; keep the postfix of the last one. 1583 EXPECT_EQ("/* long long long\n" 1584 " * long long long */", 1585 format("/* long long long long\n" 1586 " * long\n" 1587 " * long */", 1588 getLLVMStyleWithColumns(20))); 1589 1590 // Put the postfix of the last short reflow line on a newline if it doesn't 1591 // fit. 1592 EXPECT_EQ("/* long long long\n" 1593 " * long long longg\n" 1594 " */", 1595 format("/* long long long long\n" 1596 " * long\n" 1597 " * longg */", 1598 getLLVMStyleWithColumns(20))); 1599 1600 // Reflow lines with leading whitespace. 1601 EXPECT_EQ("{\n" 1602 " /*\n" 1603 " * long long long\n" 1604 " * long long long\n" 1605 " * long long long\n" 1606 " */\n" 1607 "}", 1608 format("{\n" 1609 "/*\n" 1610 " * long long long long\n" 1611 " * long\n" 1612 " * long long long long\n" 1613 " */\n" 1614 "}", 1615 getLLVMStyleWithColumns(20))); 1616 1617 // Break single line block comments that are first in the line with ' *' 1618 // decoration. 1619 EXPECT_EQ("/* long long long\n" 1620 " * long */", 1621 format("/* long long long long */", getLLVMStyleWithColumns(20))); 1622 1623 // Break single line block comment that are not first in the line with ' ' 1624 // decoration. 1625 EXPECT_EQ("int i; /* long long\n" 1626 " long */", 1627 format("int i; /* long long long */", getLLVMStyleWithColumns(20))); 1628 1629 // Reflow a line that goes just over the column limit. 1630 EXPECT_EQ("// long long long\n" 1631 "// lon long", 1632 format("// long long long lon\n" 1633 "// long", 1634 getLLVMStyleWithColumns(20))); 1635 1636 // Stop reflowing if the next line has a different indentation than the 1637 // previous line. 1638 EXPECT_EQ("// long long long\n" 1639 "// long\n" 1640 "// long long\n" 1641 "// long", 1642 format("// long long long long\n" 1643 "// long long\n" 1644 "// long", 1645 getLLVMStyleWithColumns(20))); 1646 1647 // Reflow into the last part of a really long line that has been broken into 1648 // multiple lines. 1649 EXPECT_EQ("// long long long\n" 1650 "// long long long\n" 1651 "// long long long\n", 1652 format("// long long long long long long long long\n" 1653 "// long\n", 1654 getLLVMStyleWithColumns(20))); 1655 1656 // Break the first line, then reflow the beginning of the second and third 1657 // line up. 1658 EXPECT_EQ("// long long long\n" 1659 "// lon1 lon2 lon2\n" 1660 "// lon2 lon3 lon3", 1661 format("// long long long lon1\n" 1662 "// lon2 lon2 lon2\n" 1663 "// lon3 lon3", 1664 getLLVMStyleWithColumns(20))); 1665 1666 // Reflow the beginning of the second line, then break the rest. 1667 EXPECT_EQ("// long long long\n" 1668 "// lon1 lon2 lon2\n" 1669 "// lon2 lon2 lon2\n" 1670 "// lon3", 1671 format("// long long long lon1\n" 1672 "// lon2 lon2 lon2 lon2 lon2 lon3", 1673 getLLVMStyleWithColumns(20))); 1674 1675 // Shrink the first line, then reflow the second line up. 1676 EXPECT_EQ("// long long long", format("// long long\n" 1677 "// long", 1678 getLLVMStyleWithColumns(20))); 1679 1680 // Don't shrink leading whitespace. 1681 EXPECT_EQ("int i; /// a", 1682 format("int i; /// a", getLLVMStyleWithColumns(20))); 1683 1684 // Shrink trailing whitespace if there is no postfix and reflow. 1685 EXPECT_EQ("// long long long\n" 1686 "// long long", 1687 format("// long long long long \n" 1688 "// long", 1689 getLLVMStyleWithColumns(20))); 1690 1691 // Shrink trailing whitespace to a single one if there is postfix. 1692 EXPECT_EQ("/* long long long */", 1693 format("/* long long long */", getLLVMStyleWithColumns(20))); 1694 1695 // Break a block comment postfix if exceeding the line limit. 1696 EXPECT_EQ("/* long\n" 1697 " */", 1698 format("/* long */", getLLVMStyleWithColumns(20))); 1699 1700 // Reflow indented comments. 1701 EXPECT_EQ("{\n" 1702 " // long long long\n" 1703 " // long long\n" 1704 " int i; /* long lon\n" 1705 " g long\n" 1706 " */\n" 1707 "}", 1708 format("{\n" 1709 " // long long long long\n" 1710 " // long\n" 1711 " int i; /* long lon g\n" 1712 " long */\n" 1713 "}", 1714 getLLVMStyleWithColumns(20))); 1715 1716 // Don't realign trailing comments after reflow has happened. 1717 EXPECT_EQ("// long long long\n" 1718 "// long long\n" 1719 "long i; // long", 1720 format("// long long long long\n" 1721 "// long\n" 1722 "long i; // long", 1723 getLLVMStyleWithColumns(20))); 1724 EXPECT_EQ("// long long long\n" 1725 "// longng long long\n" 1726 "// long lo", 1727 format("// long long long longng\n" 1728 "// long long long\n" 1729 "// lo", 1730 getLLVMStyleWithColumns(20))); 1731 1732 // Reflow lines after a broken line. 1733 EXPECT_EQ("int a; // Trailing\n" 1734 " // comment on\n" 1735 " // 2 or 3\n" 1736 " // lines.\n", 1737 format("int a; // Trailing comment\n" 1738 " // on 2\n" 1739 " // or 3\n" 1740 " // lines.\n", 1741 getLLVMStyleWithColumns(20))); 1742 EXPECT_EQ("/// This long line\n" 1743 "/// gets reflown.\n", 1744 format("/// This long line gets\n" 1745 "/// reflown.\n", 1746 getLLVMStyleWithColumns(20))); 1747 EXPECT_EQ("//! This long line\n" 1748 "//! gets reflown.\n", 1749 format(" //! This long line gets\n" 1750 " //! reflown.\n", 1751 getLLVMStyleWithColumns(20))); 1752 EXPECT_EQ("/* This long line\n" 1753 " * gets reflown.\n" 1754 " */\n", 1755 format("/* This long line gets\n" 1756 " * reflown.\n" 1757 " */\n", 1758 getLLVMStyleWithColumns(20))); 1759 1760 // Reflow after indentation makes a line too long. 1761 EXPECT_EQ("{\n" 1762 " // long long long\n" 1763 " // lo long\n" 1764 "}\n", 1765 format("{\n" 1766 "// long long long lo\n" 1767 "// long\n" 1768 "}\n", 1769 getLLVMStyleWithColumns(20))); 1770 1771 // Break and reflow multiple lines. 1772 EXPECT_EQ("/*\n" 1773 " * Reflow the end of\n" 1774 " * line by 11 22 33\n" 1775 " * 4.\n" 1776 " */\n", 1777 format("/*\n" 1778 " * Reflow the end of line\n" 1779 " * by\n" 1780 " * 11\n" 1781 " * 22\n" 1782 " * 33\n" 1783 " * 4.\n" 1784 " */\n", 1785 getLLVMStyleWithColumns(20))); 1786 EXPECT_EQ("/// First line gets\n" 1787 "/// broken. Second\n" 1788 "/// line gets\n" 1789 "/// reflown and\n" 1790 "/// broken. Third\n" 1791 "/// gets reflown.\n", 1792 format("/// First line gets broken.\n" 1793 "/// Second line gets reflown and broken.\n" 1794 "/// Third gets reflown.\n", 1795 getLLVMStyleWithColumns(20))); 1796 EXPECT_EQ("int i; // first long\n" 1797 " // long snd\n" 1798 " // long.\n", 1799 format("int i; // first long long\n" 1800 " // snd long.\n", 1801 getLLVMStyleWithColumns(20))); 1802 EXPECT_EQ("{\n" 1803 " // first long line\n" 1804 " // line second\n" 1805 " // long line line\n" 1806 " // third long line\n" 1807 " // line\n" 1808 "}\n", 1809 format("{\n" 1810 " // first long line line\n" 1811 " // second long line line\n" 1812 " // third long line line\n" 1813 "}\n", 1814 getLLVMStyleWithColumns(20))); 1815 EXPECT_EQ("int i; /* first line\n" 1816 " * second\n" 1817 " * line third\n" 1818 " * line\n" 1819 " */", 1820 format("int i; /* first line\n" 1821 " * second line\n" 1822 " * third line\n" 1823 " */", 1824 getLLVMStyleWithColumns(20))); 1825 1826 // Reflow the last two lines of a section that starts with a line having 1827 // different indentation. 1828 EXPECT_EQ( 1829 "// long\n" 1830 "// long long long\n" 1831 "// long long", 1832 format("// long\n" 1833 "// long long long long\n" 1834 "// long", 1835 getLLVMStyleWithColumns(20))); 1836 1837 // Keep the block comment endling '*/' while reflowing. 1838 EXPECT_EQ("/* Long long long\n" 1839 " * line short */\n", 1840 format("/* Long long long line\n" 1841 " * short */\n", 1842 getLLVMStyleWithColumns(20))); 1843 1844 // Don't reflow between separate blocks of comments. 1845 EXPECT_EQ("/* First comment\n" 1846 " * block will */\n" 1847 "/* Snd\n" 1848 " */\n", 1849 format("/* First comment block\n" 1850 " * will */\n" 1851 "/* Snd\n" 1852 " */\n", 1853 getLLVMStyleWithColumns(20))); 1854 1855 // Don't reflow across blank comment lines. 1856 EXPECT_EQ("int i; // This long\n" 1857 " // line gets\n" 1858 " // broken.\n" 1859 " //\n" 1860 " // keep.\n", 1861 format("int i; // This long line gets broken.\n" 1862 " // \n" 1863 " // keep.\n", 1864 getLLVMStyleWithColumns(20))); 1865 EXPECT_EQ("{\n" 1866 " /// long long long\n" 1867 " /// long long\n" 1868 " ///\n" 1869 " /// long\n" 1870 "}", 1871 format("{\n" 1872 " /// long long long long\n" 1873 " /// long\n" 1874 " ///\n" 1875 " /// long\n" 1876 "}", 1877 getLLVMStyleWithColumns(20))); 1878 EXPECT_EQ("//! long long long\n" 1879 "//! long\n" 1880 "\n" 1881 "//! long", 1882 format("//! long long long long\n" 1883 "\n" 1884 "//! long", 1885 getLLVMStyleWithColumns(20))); 1886 EXPECT_EQ("/* long long long\n" 1887 " long\n" 1888 "\n" 1889 " long */", 1890 format("/* long long long long\n" 1891 "\n" 1892 " long */", 1893 getLLVMStyleWithColumns(20))); 1894 EXPECT_EQ("/* long long long\n" 1895 " * long\n" 1896 " *\n" 1897 " * long */", 1898 format("/* long long long long\n" 1899 " *\n" 1900 " * long */", 1901 getLLVMStyleWithColumns(20))); 1902 1903 // Don't reflow lines having content that is a single character. 1904 EXPECT_EQ("// long long long\n" 1905 "// long\n" 1906 "// l", 1907 format("// long long long long\n" 1908 "// l", 1909 getLLVMStyleWithColumns(20))); 1910 1911 // Don't reflow lines starting with two punctuation characters. 1912 EXPECT_EQ("// long long long\n" 1913 "// long\n" 1914 "// ... --- ...", 1915 format( 1916 "// long long long long\n" 1917 "// ... --- ...", 1918 getLLVMStyleWithColumns(20))); 1919 1920 // Don't reflow lines starting with '@'. 1921 EXPECT_EQ("// long long long\n" 1922 "// long\n" 1923 "// @param arg", 1924 format("// long long long long\n" 1925 "// @param arg", 1926 getLLVMStyleWithColumns(20))); 1927 1928 // Don't reflow lines starting with 'TODO'. 1929 EXPECT_EQ("// long long long\n" 1930 "// long\n" 1931 "// TODO: long", 1932 format("// long long long long\n" 1933 "// TODO: long", 1934 getLLVMStyleWithColumns(20))); 1935 1936 // Don't reflow lines starting with 'FIXME'. 1937 EXPECT_EQ("// long long long\n" 1938 "// long\n" 1939 "// FIXME: long", 1940 format("// long long long long\n" 1941 "// FIXME: long", 1942 getLLVMStyleWithColumns(20))); 1943 1944 // Don't reflow lines starting with 'XXX'. 1945 EXPECT_EQ("// long long long\n" 1946 "// long\n" 1947 "// XXX: long", 1948 format("// long long long long\n" 1949 "// XXX: long", 1950 getLLVMStyleWithColumns(20))); 1951 1952 // Don't reflow comment pragmas. 1953 EXPECT_EQ("// long long long\n" 1954 "// long\n" 1955 "// IWYU pragma:", 1956 format("// long long long long\n" 1957 "// IWYU pragma:", 1958 getLLVMStyleWithColumns(20))); 1959 EXPECT_EQ("/* long long long\n" 1960 " * long\n" 1961 " * IWYU pragma:\n" 1962 " */", 1963 format("/* long long long long\n" 1964 " * IWYU pragma:\n" 1965 " */", 1966 getLLVMStyleWithColumns(20))); 1967 1968 // Reflow lines that have a non-punctuation character among their first 2 1969 // characters. 1970 EXPECT_EQ("// long long long\n" 1971 "// long 'long'", 1972 format( 1973 "// long long long long\n" 1974 "// 'long'", 1975 getLLVMStyleWithColumns(20))); 1976 1977 // Don't reflow between separate blocks of comments. 1978 EXPECT_EQ("/* First comment\n" 1979 " * block will */\n" 1980 "/* Snd\n" 1981 " */\n", 1982 format("/* First comment block\n" 1983 " * will */\n" 1984 "/* Snd\n" 1985 " */\n", 1986 getLLVMStyleWithColumns(20))); 1987 1988 // Don't reflow lines having different indentation. 1989 EXPECT_EQ("// long long long\n" 1990 "// long\n" 1991 "// long", 1992 format("// long long long long\n" 1993 "// long", 1994 getLLVMStyleWithColumns(20))); 1995 1996 // Don't reflow separate bullets in list 1997 EXPECT_EQ("// - long long long\n" 1998 "// long\n" 1999 "// - long", 2000 format("// - long long long long\n" 2001 "// - long", 2002 getLLVMStyleWithColumns(20))); 2003 EXPECT_EQ("// * long long long\n" 2004 "// long\n" 2005 "// * long", 2006 format("// * long long long long\n" 2007 "// * long", 2008 getLLVMStyleWithColumns(20))); 2009 EXPECT_EQ("// + long long long\n" 2010 "// long\n" 2011 "// + long", 2012 format("// + long long long long\n" 2013 "// + long", 2014 getLLVMStyleWithColumns(20))); 2015 EXPECT_EQ("// 1. long long long\n" 2016 "// long\n" 2017 "// 2. long", 2018 format("// 1. long long long long\n" 2019 "// 2. long", 2020 getLLVMStyleWithColumns(20))); 2021 EXPECT_EQ("// -# long long long\n" 2022 "// long\n" 2023 "// -# long", 2024 format("// -# long long long long\n" 2025 "// -# long", 2026 getLLVMStyleWithColumns(20))); 2027 2028 EXPECT_EQ("// - long long long\n" 2029 "// long long long\n" 2030 "// - long", 2031 format("// - long long long long\n" 2032 "// long long\n" 2033 "// - long", 2034 getLLVMStyleWithColumns(20))); 2035 EXPECT_EQ("// - long long long\n" 2036 "// long long long\n" 2037 "// long\n" 2038 "// - long", 2039 format("// - long long long long\n" 2040 "// long long long\n" 2041 "// - long", 2042 getLLVMStyleWithColumns(20))); 2043 2044 // Large number (>2 digits) are not list items 2045 EXPECT_EQ("// long long long\n" 2046 "// long 1024. long.", 2047 format("// long long long long\n" 2048 "// 1024. long.", 2049 getLLVMStyleWithColumns(20))); 2050 2051 // Do not break before number, to avoid introducing a non-reflowable doxygen 2052 // list item. 2053 EXPECT_EQ("// long long\n" 2054 "// long 10. long.", 2055 format("// long long long 10.\n" 2056 "// long.", 2057 getLLVMStyleWithColumns(20))); 2058 2059 // Don't break or reflow after implicit string literals. 2060 verifyFormat("#include <t> // l l l\n" 2061 " // l", 2062 getLLVMStyleWithColumns(20)); 2063 2064 // Don't break or reflow comments on import lines. 2065 EXPECT_EQ("#include \"t\" /* l l l\n" 2066 " * l */", 2067 format("#include \"t\" /* l l l\n" 2068 " * l */", 2069 getLLVMStyleWithColumns(20))); 2070 2071 // Don't reflow between different trailing comment sections. 2072 EXPECT_EQ("int i; // long long\n" 2073 " // long\n" 2074 "int j; // long long\n" 2075 " // long\n", 2076 format("int i; // long long long\n" 2077 "int j; // long long long\n", 2078 getLLVMStyleWithColumns(20))); 2079 2080 // Don't reflow if the first word on the next line is longer than the 2081 // available space at current line. 2082 EXPECT_EQ("int i; // trigger\n" 2083 " // reflow\n" 2084 " // longsec\n", 2085 format("int i; // trigger reflow\n" 2086 " // longsec\n", 2087 getLLVMStyleWithColumns(20))); 2088 2089 // Simple case that correctly handles reflow in parameter lists. 2090 EXPECT_EQ("a = f(/* looooooooong\n" 2091 " * long long\n" 2092 " */\n" 2093 " a);", 2094 format("a = f(/* looooooooong long\n* long\n*/ a);", 2095 getLLVMStyleWithColumns(22))); 2096 // Tricky case that has fewer lines if we reflow the comment, ending up with 2097 // fewer lines. 2098 EXPECT_EQ("a = f(/* loooooong\n" 2099 " * long long\n" 2100 " */\n" 2101 " a);", 2102 format("a = f(/* loooooong long\n* long\n*/ a);", 2103 getLLVMStyleWithColumns(22))); 2104 2105 // Keep empty comment lines. 2106 EXPECT_EQ("/**/", format(" /**/", getLLVMStyleWithColumns(20))); 2107 EXPECT_EQ("/* */", format(" /* */", getLLVMStyleWithColumns(20))); 2108 EXPECT_EQ("/* */", format(" /* */", getLLVMStyleWithColumns(20))); 2109 EXPECT_EQ("//", format(" // ", getLLVMStyleWithColumns(20))); 2110 EXPECT_EQ("///", format(" /// ", getLLVMStyleWithColumns(20))); 2111 } 2112 2113 TEST_F(FormatTestComments, ReflowsCommentsPrecise) { 2114 // FIXME: This assumes we do not continue compressing whitespace once we are 2115 // in reflow mode. Consider compressing whitespace. 2116 2117 // Test that we stop reflowing precisely at the column limit. 2118 // After reflowing, "// reflows into foo" does not fit the column limit, 2119 // so we compress the whitespace. 2120 EXPECT_EQ("// some text that\n" 2121 "// reflows into foo\n", 2122 format("// some text that reflows\n" 2123 "// into foo\n", 2124 getLLVMStyleWithColumns(20))); 2125 // Given one more column, "// reflows into foo" does fit the limit, so we 2126 // do not compress the whitespace. 2127 EXPECT_EQ("// some text that\n" 2128 "// reflows into foo\n", 2129 format("// some text that reflows\n" 2130 "// into foo\n", 2131 getLLVMStyleWithColumns(21))); 2132 2133 // Make sure that we correctly account for the space added in the reflow case 2134 // when making the reflowing decision. 2135 // First, when the next line ends precisely one column over the limit, do not 2136 // reflow. 2137 EXPECT_EQ("// some text that\n" 2138 "// reflows\n" 2139 "// into1234567\n", 2140 format("// some text that reflows\n" 2141 "// into1234567\n", 2142 getLLVMStyleWithColumns(21))); 2143 // Secondly, when the next line ends later, but the first word in that line 2144 // is precisely one column over the limit, do not reflow. 2145 EXPECT_EQ("// some text that\n" 2146 "// reflows\n" 2147 "// into1234567 f\n", 2148 format("// some text that reflows\n" 2149 "// into1234567 f\n", 2150 getLLVMStyleWithColumns(21))); 2151 } 2152 2153 TEST_F(FormatTestComments, ReflowsCommentsWithExtraWhitespace) { 2154 // Baseline. 2155 EXPECT_EQ("// some text\n" 2156 "// that re flows\n", 2157 format("// some text that\n" 2158 "// re flows\n", 2159 getLLVMStyleWithColumns(16))); 2160 EXPECT_EQ("// some text\n" 2161 "// that re flows\n", 2162 format("// some text that\n" 2163 "// re flows\n", 2164 getLLVMStyleWithColumns(16))); 2165 EXPECT_EQ("/* some text\n" 2166 " * that re flows\n" 2167 " */\n", 2168 format("/* some text that\n" 2169 "* re flows\n" 2170 "*/\n", 2171 getLLVMStyleWithColumns(16))); 2172 // FIXME: We do not reflow if the indent of two subsequent lines differs; 2173 // given that this is different behavior from block comments, do we want 2174 // to keep this? 2175 EXPECT_EQ("// some text\n" 2176 "// that\n" 2177 "// re flows\n", 2178 format("// some text that\n" 2179 "// re flows\n", 2180 getLLVMStyleWithColumns(16))); 2181 // Space within parts of a line that fit. 2182 // FIXME: Use the earliest possible split while reflowing to compress the 2183 // whitespace within the line. 2184 EXPECT_EQ("// some text that\n" 2185 "// does re flow\n" 2186 "// more here\n", 2187 format("// some text that does\n" 2188 "// re flow more here\n", 2189 getLLVMStyleWithColumns(21))); 2190 } 2191 2192 TEST_F(FormatTestComments, IgnoresIf0Contents) { 2193 EXPECT_EQ("#if 0\n" 2194 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 2195 "#endif\n" 2196 "void f() {}", 2197 format("#if 0\n" 2198 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 2199 "#endif\n" 2200 "void f( ) { }")); 2201 EXPECT_EQ("#if false\n" 2202 "void f( ) { }\n" 2203 "#endif\n" 2204 "void g() {}\n", 2205 format("#if false\n" 2206 "void f( ) { }\n" 2207 "#endif\n" 2208 "void g( ) { }\n")); 2209 EXPECT_EQ("enum E {\n" 2210 " One,\n" 2211 " Two,\n" 2212 "#if 0\n" 2213 "Three,\n" 2214 " Four,\n" 2215 "#endif\n" 2216 " Five\n" 2217 "};", 2218 format("enum E {\n" 2219 " One,Two,\n" 2220 "#if 0\n" 2221 "Three,\n" 2222 " Four,\n" 2223 "#endif\n" 2224 " Five};")); 2225 EXPECT_EQ("enum F {\n" 2226 " One,\n" 2227 "#if 1\n" 2228 " Two,\n" 2229 "#if 0\n" 2230 "Three,\n" 2231 " Four,\n" 2232 "#endif\n" 2233 " Five\n" 2234 "#endif\n" 2235 "};", 2236 format("enum F {\n" 2237 "One,\n" 2238 "#if 1\n" 2239 "Two,\n" 2240 "#if 0\n" 2241 "Three,\n" 2242 " Four,\n" 2243 "#endif\n" 2244 "Five\n" 2245 "#endif\n" 2246 "};")); 2247 EXPECT_EQ("enum G {\n" 2248 " One,\n" 2249 "#if 0\n" 2250 "Two,\n" 2251 "#else\n" 2252 " Three,\n" 2253 "#endif\n" 2254 " Four\n" 2255 "};", 2256 format("enum G {\n" 2257 "One,\n" 2258 "#if 0\n" 2259 "Two,\n" 2260 "#else\n" 2261 "Three,\n" 2262 "#endif\n" 2263 "Four\n" 2264 "};")); 2265 EXPECT_EQ("enum H {\n" 2266 " One,\n" 2267 "#if 0\n" 2268 "#ifdef Q\n" 2269 "Two,\n" 2270 "#else\n" 2271 "Three,\n" 2272 "#endif\n" 2273 "#endif\n" 2274 " Four\n" 2275 "};", 2276 format("enum H {\n" 2277 "One,\n" 2278 "#if 0\n" 2279 "#ifdef Q\n" 2280 "Two,\n" 2281 "#else\n" 2282 "Three,\n" 2283 "#endif\n" 2284 "#endif\n" 2285 "Four\n" 2286 "};")); 2287 EXPECT_EQ("enum I {\n" 2288 " One,\n" 2289 "#if /* test */ 0 || 1\n" 2290 "Two,\n" 2291 "Three,\n" 2292 "#endif\n" 2293 " Four\n" 2294 "};", 2295 format("enum I {\n" 2296 "One,\n" 2297 "#if /* test */ 0 || 1\n" 2298 "Two,\n" 2299 "Three,\n" 2300 "#endif\n" 2301 "Four\n" 2302 "};")); 2303 EXPECT_EQ("enum J {\n" 2304 " One,\n" 2305 "#if 0\n" 2306 "#if 0\n" 2307 "Two,\n" 2308 "#else\n" 2309 "Three,\n" 2310 "#endif\n" 2311 "Four,\n" 2312 "#endif\n" 2313 " Five\n" 2314 "};", 2315 format("enum J {\n" 2316 "One,\n" 2317 "#if 0\n" 2318 "#if 0\n" 2319 "Two,\n" 2320 "#else\n" 2321 "Three,\n" 2322 "#endif\n" 2323 "Four,\n" 2324 "#endif\n" 2325 "Five\n" 2326 "};")); 2327 2328 // Ignore stuff in SWIG-blocks. 2329 EXPECT_EQ("#ifdef SWIG\n" 2330 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 2331 "#endif\n" 2332 "void f() {}", 2333 format("#ifdef SWIG\n" 2334 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 2335 "#endif\n" 2336 "void f( ) { }")); 2337 EXPECT_EQ("#ifndef SWIG\n" 2338 "void f() {}\n" 2339 "#endif", 2340 format("#ifndef SWIG\n" 2341 "void f( ) { }\n" 2342 "#endif")); 2343 } 2344 2345 TEST_F(FormatTestComments, DontCrashOnBlockComments) { 2346 EXPECT_EQ( 2347 "int xxxxxxxxx; /* " 2348 "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy\n" 2349 "zzzzzz\n" 2350 "0*/", 2351 format("int xxxxxxxxx; /* " 2352 "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy zzzzzz\n" 2353 "0*/")); 2354 } 2355 2356 TEST_F(FormatTestComments, BlockCommentsInControlLoops) { 2357 verifyFormat("if (0) /* a comment in a strange place */ {\n" 2358 " f();\n" 2359 "}"); 2360 verifyFormat("if (0) /* a comment in a strange place */ {\n" 2361 " f();\n" 2362 "} /* another comment */ else /* comment #3 */ {\n" 2363 " g();\n" 2364 "}"); 2365 verifyFormat("while (0) /* a comment in a strange place */ {\n" 2366 " f();\n" 2367 "}"); 2368 verifyFormat("for (;;) /* a comment in a strange place */ {\n" 2369 " f();\n" 2370 "}"); 2371 verifyFormat("do /* a comment in a strange place */ {\n" 2372 " f();\n" 2373 "} /* another comment */ while (0);"); 2374 } 2375 2376 TEST_F(FormatTestComments, BlockComments) { 2377 EXPECT_EQ("/* */ /* */ /* */\n/* */ /* */ /* */", 2378 format("/* *//* */ /* */\n/* *//* */ /* */")); 2379 EXPECT_EQ("/* */ a /* */ b;", format(" /* */ a/* */ b;")); 2380 EXPECT_EQ("#define A /*123*/ \\\n" 2381 " b\n" 2382 "/* */\n" 2383 "someCall(\n" 2384 " parameter);", 2385 format("#define A /*123*/ b\n" 2386 "/* */\n" 2387 "someCall(parameter);", 2388 getLLVMStyleWithColumns(15))); 2389 2390 EXPECT_EQ("#define A\n" 2391 "/* */ someCall(\n" 2392 " parameter);", 2393 format("#define A\n" 2394 "/* */someCall(parameter);", 2395 getLLVMStyleWithColumns(15))); 2396 EXPECT_EQ("/*\n**\n*/", format("/*\n**\n*/")); 2397 EXPECT_EQ("/*\n" 2398 " *\n" 2399 " * aaaaaa\n" 2400 " * aaaaaa\n" 2401 " */", 2402 format("/*\n" 2403 "*\n" 2404 " * aaaaaa aaaaaa\n" 2405 "*/", 2406 getLLVMStyleWithColumns(10))); 2407 EXPECT_EQ("/*\n" 2408 "**\n" 2409 "* aaaaaa\n" 2410 "*aaaaaa\n" 2411 "*/", 2412 format("/*\n" 2413 "**\n" 2414 "* aaaaaa aaaaaa\n" 2415 "*/", 2416 getLLVMStyleWithColumns(10))); 2417 EXPECT_EQ("int aaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 2418 " /* line 1\n" 2419 " bbbbbbbbbbbb */\n" 2420 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 2421 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 2422 " /* line 1\n" 2423 " bbbbbbbbbbbb */ bbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 2424 getLLVMStyleWithColumns(50))); 2425 2426 FormatStyle NoBinPacking = getLLVMStyle(); 2427 NoBinPacking.BinPackParameters = false; 2428 EXPECT_EQ("someFunction(1, /* comment 1 */\n" 2429 " 2, /* comment 2 */\n" 2430 " 3, /* comment 3 */\n" 2431 " aaaa,\n" 2432 " bbbb);", 2433 format("someFunction (1, /* comment 1 */\n" 2434 " 2, /* comment 2 */ \n" 2435 " 3, /* comment 3 */\n" 2436 "aaaa, bbbb );", 2437 NoBinPacking)); 2438 verifyFormat( 2439 "bool aaaaaaaaaaaaa = /* comment: */ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2440 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 2441 EXPECT_EQ( 2442 "bool aaaaaaaaaaaaa = /* trailing comment */\n" 2443 " aaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2444 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;", 2445 format( 2446 "bool aaaaaaaaaaaaa = /* trailing comment */\n" 2447 " aaaaaaaaaaaaaaaaaaaaaaaaaaa||aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2448 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;")); 2449 EXPECT_EQ( 2450 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n" 2451 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n" 2452 "int cccccccccccccccccccccccccccccc; /* comment */\n", 2453 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n" 2454 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n" 2455 "int cccccccccccccccccccccccccccccc; /* comment */\n")); 2456 2457 verifyFormat("void f(int * /* unused */) {}"); 2458 2459 EXPECT_EQ("/*\n" 2460 " **\n" 2461 " */", 2462 format("/*\n" 2463 " **\n" 2464 " */")); 2465 EXPECT_EQ("/*\n" 2466 " *q\n" 2467 " */", 2468 format("/*\n" 2469 " *q\n" 2470 " */")); 2471 EXPECT_EQ("/*\n" 2472 " * q\n" 2473 " */", 2474 format("/*\n" 2475 " * q\n" 2476 " */")); 2477 EXPECT_EQ("/*\n" 2478 " **/", 2479 format("/*\n" 2480 " **/")); 2481 EXPECT_EQ("/*\n" 2482 " ***/", 2483 format("/*\n" 2484 " ***/")); 2485 } 2486 2487 TEST_F(FormatTestComments, BlockCommentsInMacros) { 2488 EXPECT_EQ("#define A \\\n" 2489 " { \\\n" 2490 " /* one line */ \\\n" 2491 " someCall();", 2492 format("#define A { \\\n" 2493 " /* one line */ \\\n" 2494 " someCall();", 2495 getLLVMStyleWithColumns(20))); 2496 EXPECT_EQ("#define A \\\n" 2497 " { \\\n" 2498 " /* previous */ \\\n" 2499 " /* one line */ \\\n" 2500 " someCall();", 2501 format("#define A { \\\n" 2502 " /* previous */ \\\n" 2503 " /* one line */ \\\n" 2504 " someCall();", 2505 getLLVMStyleWithColumns(20))); 2506 } 2507 2508 TEST_F(FormatTestComments, BlockCommentsAtEndOfLine) { 2509 EXPECT_EQ("a = {\n" 2510 " 1111 /* */\n" 2511 "};", 2512 format("a = {1111 /* */\n" 2513 "};", 2514 getLLVMStyleWithColumns(15))); 2515 EXPECT_EQ("a = {\n" 2516 " 1111 /* */\n" 2517 "};", 2518 format("a = {1111 /* */\n" 2519 "};", 2520 getLLVMStyleWithColumns(15))); 2521 EXPECT_EQ("a = {\n" 2522 " 1111 /* a\n" 2523 " */\n" 2524 "};", 2525 format("a = {1111 /* a */\n" 2526 "};", 2527 getLLVMStyleWithColumns(15))); 2528 } 2529 2530 TEST_F(FormatTestComments, BreaksAfterMultilineBlockCommentsInParamLists) { 2531 EXPECT_EQ("a = f(/* long\n" 2532 " long */\n" 2533 " a);", 2534 format("a = f(/* long long */ a);", getLLVMStyleWithColumns(16))); 2535 EXPECT_EQ("a = f(\n" 2536 " /* long\n" 2537 " long */\n" 2538 " a);", 2539 format("a = f(/* long long */ a);", getLLVMStyleWithColumns(15))); 2540 2541 EXPECT_EQ("a = f(/* long\n" 2542 " long\n" 2543 " */\n" 2544 " a);", 2545 format("a = f(/* long\n" 2546 " long\n" 2547 " */a);", 2548 getLLVMStyleWithColumns(16))); 2549 2550 EXPECT_EQ("a = f(/* long\n" 2551 " long\n" 2552 " */\n" 2553 " a);", 2554 format("a = f(/* long\n" 2555 " long\n" 2556 " */ a);", 2557 getLLVMStyleWithColumns(16))); 2558 2559 EXPECT_EQ("a = f(/* long\n" 2560 " long\n" 2561 " */\n" 2562 " (1 + 1));", 2563 format("a = f(/* long\n" 2564 " long\n" 2565 " */ (1 + 1));", 2566 getLLVMStyleWithColumns(16))); 2567 2568 EXPECT_EQ( 2569 "a = f(a,\n" 2570 " /* long\n" 2571 " long */\n" 2572 " b);", 2573 format("a = f(a, /* long long */ b);", getLLVMStyleWithColumns(16))); 2574 2575 EXPECT_EQ( 2576 "a = f(\n" 2577 " a,\n" 2578 " /* long\n" 2579 " long */\n" 2580 " b);", 2581 format("a = f(a, /* long long */ b);", getLLVMStyleWithColumns(15))); 2582 2583 EXPECT_EQ("a = f(a,\n" 2584 " /* long\n" 2585 " long */\n" 2586 " (1 + 1));", 2587 format("a = f(a, /* long long */ (1 + 1));", 2588 getLLVMStyleWithColumns(16))); 2589 EXPECT_EQ("a = f(\n" 2590 " a,\n" 2591 " /* long\n" 2592 " long */\n" 2593 " (1 + 1));", 2594 format("a = f(a, /* long long */ (1 + 1));", 2595 getLLVMStyleWithColumns(15))); 2596 } 2597 2598 TEST_F(FormatTestComments, IndentLineCommentsInStartOfBlockAtEndOfFile) { 2599 verifyFormat("{\n" 2600 " // a\n" 2601 " // b"); 2602 } 2603 2604 TEST_F(FormatTestComments, AlignTrailingComments) { 2605 EXPECT_EQ("#define MACRO(V) \\\n" 2606 " V(Rt2) /* one more char */ \\\n" 2607 " V(Rs) /* than here */ \\\n" 2608 "/* comment 3 */\n", 2609 format("#define MACRO(V)\\\n" 2610 "V(Rt2) /* one more char */ \\\n" 2611 "V(Rs) /* than here */ \\\n" 2612 "/* comment 3 */\n", 2613 getLLVMStyleWithColumns(40))); 2614 EXPECT_EQ("int i = f(abc, // line 1\n" 2615 " d, // line 2\n" 2616 " // line 3\n" 2617 " b);", 2618 format("int i = f(abc, // line 1\n" 2619 " d, // line 2\n" 2620 " // line 3\n" 2621 " b);", 2622 getLLVMStyleWithColumns(40))); 2623 2624 // Align newly broken trailing comments. 2625 EXPECT_EQ("int ab; // line\n" 2626 "int a; // long\n" 2627 " // long\n", 2628 format("int ab; // line\n" 2629 "int a; // long long\n", 2630 getLLVMStyleWithColumns(15))); 2631 EXPECT_EQ("int ab; // line\n" 2632 "int a; // long\n" 2633 " // long\n" 2634 " // long", 2635 format("int ab; // line\n" 2636 "int a; // long long\n" 2637 " // long", 2638 getLLVMStyleWithColumns(15))); 2639 EXPECT_EQ("int ab; // line\n" 2640 "int a; // long\n" 2641 " // long\n" 2642 "pt c; // long", 2643 format("int ab; // line\n" 2644 "int a; // long long\n" 2645 "pt c; // long", 2646 getLLVMStyleWithColumns(15))); 2647 EXPECT_EQ("int ab; // line\n" 2648 "int a; // long\n" 2649 " // long\n" 2650 "\n" 2651 "// long", 2652 format("int ab; // line\n" 2653 "int a; // long long\n" 2654 "\n" 2655 "// long", 2656 getLLVMStyleWithColumns(15))); 2657 2658 // Don't align newly broken trailing comments if that would put them over the 2659 // column limit. 2660 EXPECT_EQ("int i, j; // line 1\n" 2661 "int k; // line longg\n" 2662 " // long", 2663 format("int i, j; // line 1\n" 2664 "int k; // line longg long", 2665 getLLVMStyleWithColumns(20))); 2666 2667 // Always align if ColumnLimit = 0 2668 EXPECT_EQ("int i, j; // line 1\n" 2669 "int k; // line longg long", 2670 format("int i, j; // line 1\n" 2671 "int k; // line longg long", 2672 getLLVMStyleWithColumns(0))); 2673 2674 // Align comment line sections aligned with the next token with the next 2675 // token. 2676 EXPECT_EQ("class A {\n" 2677 "public: // public comment\n" 2678 " // comment about a\n" 2679 " int a;\n" 2680 "};", 2681 format("class A {\n" 2682 "public: // public comment\n" 2683 " // comment about a\n" 2684 " int a;\n" 2685 "};", 2686 getLLVMStyleWithColumns(40))); 2687 EXPECT_EQ("class A {\n" 2688 "public: // public comment 1\n" 2689 " // public comment 2\n" 2690 " // comment 1 about a\n" 2691 " // comment 2 about a\n" 2692 " int a;\n" 2693 "};", 2694 format("class A {\n" 2695 "public: // public comment 1\n" 2696 " // public comment 2\n" 2697 " // comment 1 about a\n" 2698 " // comment 2 about a\n" 2699 " int a;\n" 2700 "};", 2701 getLLVMStyleWithColumns(40))); 2702 EXPECT_EQ("int f(int n) { // comment line 1 on f\n" 2703 " // comment line 2 on f\n" 2704 " // comment line 1 before return\n" 2705 " // comment line 2 before return\n" 2706 " return n; // comment line 1 on return\n" 2707 " // comment line 2 on return\n" 2708 " // comment line 1 after return\n" 2709 "}", 2710 format("int f(int n) { // comment line 1 on f\n" 2711 " // comment line 2 on f\n" 2712 " // comment line 1 before return\n" 2713 " // comment line 2 before return\n" 2714 " return n; // comment line 1 on return\n" 2715 " // comment line 2 on return\n" 2716 " // comment line 1 after return\n" 2717 "}", 2718 getLLVMStyleWithColumns(40))); 2719 EXPECT_EQ("int f(int n) {\n" 2720 " switch (n) { // comment line 1 on switch\n" 2721 " // comment line 2 on switch\n" 2722 " // comment line 1 before case 1\n" 2723 " // comment line 2 before case 1\n" 2724 " case 1: // comment line 1 on case 1\n" 2725 " // comment line 2 on case 1\n" 2726 " // comment line 1 before return 1\n" 2727 " // comment line 2 before return 1\n" 2728 " return 1; // comment line 1 on return 1\n" 2729 " // comment line 2 on return 1\n" 2730 " // comment line 1 before default\n" 2731 " // comment line 2 before default\n" 2732 " default: // comment line 1 on default\n" 2733 " // comment line 2 on default\n" 2734 " // comment line 1 before return 2\n" 2735 " return 2 * f(n - 1); // comment line 1 on return 2\n" 2736 " // comment line 2 on return 2\n" 2737 " // comment line 1 after return\n" 2738 " // comment line 2 after return\n" 2739 " }\n" 2740 "}", 2741 format("int f(int n) {\n" 2742 " switch (n) { // comment line 1 on switch\n" 2743 " // comment line 2 on switch\n" 2744 " // comment line 1 before case 1\n" 2745 " // comment line 2 before case 1\n" 2746 " case 1: // comment line 1 on case 1\n" 2747 " // comment line 2 on case 1\n" 2748 " // comment line 1 before return 1\n" 2749 " // comment line 2 before return 1\n" 2750 " return 1; // comment line 1 on return 1\n" 2751 " // comment line 2 on return 1\n" 2752 " // comment line 1 before default\n" 2753 " // comment line 2 before default\n" 2754 " default: // comment line 1 on default\n" 2755 " // comment line 2 on default\n" 2756 " // comment line 1 before return 2\n" 2757 " return 2 * f(n - 1); // comment line 1 on return 2\n" 2758 " // comment line 2 on return 2\n" 2759 " // comment line 1 after return\n" 2760 " // comment line 2 after return\n" 2761 " }\n" 2762 "}", 2763 getLLVMStyleWithColumns(80))); 2764 2765 // If all the lines in a sequence of line comments are aligned with the next 2766 // token, the first line belongs to the previous token and the other lines 2767 // belong to the next token. 2768 EXPECT_EQ("int a; // line about a\n" 2769 "long b;", 2770 format("int a; // line about a\n" 2771 " long b;", 2772 getLLVMStyleWithColumns(80))); 2773 EXPECT_EQ("int a; // line about a\n" 2774 "// line about b\n" 2775 "long b;", 2776 format("int a; // line about a\n" 2777 " // line about b\n" 2778 " long b;", 2779 getLLVMStyleWithColumns(80))); 2780 EXPECT_EQ("int a; // line about a\n" 2781 "// line 1 about b\n" 2782 "// line 2 about b\n" 2783 "long b;", 2784 format("int a; // line about a\n" 2785 " // line 1 about b\n" 2786 " // line 2 about b\n" 2787 " long b;", 2788 getLLVMStyleWithColumns(80))); 2789 } 2790 2791 TEST_F(FormatTestComments, AlignsBlockCommentDecorations) { 2792 EXPECT_EQ("/*\n" 2793 " */", 2794 format("/*\n" 2795 "*/", getLLVMStyle())); 2796 EXPECT_EQ("/*\n" 2797 " */", 2798 format("/*\n" 2799 " */", getLLVMStyle())); 2800 EXPECT_EQ("/*\n" 2801 " */", 2802 format("/*\n" 2803 " */", getLLVMStyle())); 2804 2805 // Align a single line. 2806 EXPECT_EQ("/*\n" 2807 " * line */", 2808 format("/*\n" 2809 "* line */", 2810 getLLVMStyle())); 2811 EXPECT_EQ("/*\n" 2812 " * line */", 2813 format("/*\n" 2814 " * line */", 2815 getLLVMStyle())); 2816 EXPECT_EQ("/*\n" 2817 " * line */", 2818 format("/*\n" 2819 " * line */", 2820 getLLVMStyle())); 2821 EXPECT_EQ("/*\n" 2822 " * line */", 2823 format("/*\n" 2824 " * line */", 2825 getLLVMStyle())); 2826 EXPECT_EQ("/**\n" 2827 " * line */", 2828 format("/**\n" 2829 "* line */", 2830 getLLVMStyle())); 2831 EXPECT_EQ("/**\n" 2832 " * line */", 2833 format("/**\n" 2834 " * line */", 2835 getLLVMStyle())); 2836 EXPECT_EQ("/**\n" 2837 " * line */", 2838 format("/**\n" 2839 " * line */", 2840 getLLVMStyle())); 2841 EXPECT_EQ("/**\n" 2842 " * line */", 2843 format("/**\n" 2844 " * line */", 2845 getLLVMStyle())); 2846 EXPECT_EQ("/**\n" 2847 " * line */", 2848 format("/**\n" 2849 " * line */", 2850 getLLVMStyle())); 2851 2852 // Align the end '*/' after a line. 2853 EXPECT_EQ("/*\n" 2854 " * line\n" 2855 " */", 2856 format("/*\n" 2857 "* line\n" 2858 "*/", getLLVMStyle())); 2859 EXPECT_EQ("/*\n" 2860 " * line\n" 2861 " */", 2862 format("/*\n" 2863 " * line\n" 2864 " */", getLLVMStyle())); 2865 EXPECT_EQ("/*\n" 2866 " * line\n" 2867 " */", 2868 format("/*\n" 2869 " * line\n" 2870 " */", getLLVMStyle())); 2871 2872 // Align two lines. 2873 EXPECT_EQ("/* line 1\n" 2874 " * line 2 */", 2875 format("/* line 1\n" 2876 " * line 2 */", 2877 getLLVMStyle())); 2878 EXPECT_EQ("/* line 1\n" 2879 " * line 2 */", 2880 format("/* line 1\n" 2881 "* line 2 */", 2882 getLLVMStyle())); 2883 EXPECT_EQ("/* line 1\n" 2884 " * line 2 */", 2885 format("/* line 1\n" 2886 " * line 2 */", 2887 getLLVMStyle())); 2888 EXPECT_EQ("/* line 1\n" 2889 " * line 2 */", 2890 format("/* line 1\n" 2891 " * line 2 */", 2892 getLLVMStyle())); 2893 EXPECT_EQ("/* line 1\n" 2894 " * line 2 */", 2895 format("/* line 1\n" 2896 " * line 2 */", 2897 getLLVMStyle())); 2898 EXPECT_EQ("int i; /* line 1\n" 2899 " * line 2 */", 2900 format("int i; /* line 1\n" 2901 "* line 2 */", 2902 getLLVMStyle())); 2903 EXPECT_EQ("int i; /* line 1\n" 2904 " * line 2 */", 2905 format("int i; /* line 1\n" 2906 " * line 2 */", 2907 getLLVMStyle())); 2908 EXPECT_EQ("int i; /* line 1\n" 2909 " * line 2 */", 2910 format("int i; /* line 1\n" 2911 " * line 2 */", 2912 getLLVMStyle())); 2913 2914 // Align several lines. 2915 EXPECT_EQ("/* line 1\n" 2916 " * line 2\n" 2917 " * line 3 */", 2918 format("/* line 1\n" 2919 " * line 2\n" 2920 "* line 3 */", 2921 getLLVMStyle())); 2922 EXPECT_EQ("/* line 1\n" 2923 " * line 2\n" 2924 " * line 3 */", 2925 format("/* line 1\n" 2926 " * line 2\n" 2927 "* line 3 */", 2928 getLLVMStyle())); 2929 EXPECT_EQ("/*\n" 2930 "** line 1\n" 2931 "** line 2\n" 2932 "*/", 2933 format("/*\n" 2934 "** line 1\n" 2935 " ** line 2\n" 2936 "*/", 2937 getLLVMStyle())); 2938 2939 // Align with different indent after the decorations. 2940 EXPECT_EQ("/*\n" 2941 " * line 1\n" 2942 " * line 2\n" 2943 " * line 3\n" 2944 " * line 4\n" 2945 " */", 2946 format("/*\n" 2947 "* line 1\n" 2948 " * line 2\n" 2949 " * line 3\n" 2950 "* line 4\n" 2951 "*/", getLLVMStyle())); 2952 2953 // Align empty or blank lines. 2954 EXPECT_EQ("/**\n" 2955 " *\n" 2956 " *\n" 2957 " *\n" 2958 " */", 2959 format("/**\n" 2960 "* \n" 2961 " * \n" 2962 " *\n" 2963 "*/", getLLVMStyle())); 2964 2965 // Align while breaking and reflowing. 2966 EXPECT_EQ("/*\n" 2967 " * long long long\n" 2968 " * long long\n" 2969 " *\n" 2970 " * long */", 2971 format("/*\n" 2972 " * long long long long\n" 2973 " * long\n" 2974 " *\n" 2975 "* long */", 2976 getLLVMStyleWithColumns(20))); 2977 } 2978 2979 TEST_F(FormatTestComments, NoCrash_Bug34236) { 2980 // This is a test case from a crasher reported in: 2981 // https://bugs.llvm.org/show_bug.cgi?id=34236 2982 // Temporarily disable formatting for readability. 2983 // clang-format off 2984 EXPECT_EQ( 2985 "/* */ /*\n" 2986 " * a\n" 2987 " * b c d*/", 2988 format( 2989 "/* */ /*\n" 2990 " * a b\n" 2991 " * c d*/", 2992 getLLVMStyleWithColumns(80))); 2993 // clang-format on 2994 } 2995 2996 TEST_F(FormatTestComments, NonTrailingBlockComments) { 2997 verifyFormat("const /** comment comment */ A = B;", 2998 getLLVMStyleWithColumns(40)); 2999 3000 verifyFormat("const /** comment comment comment */ A =\n" 3001 " B;", 3002 getLLVMStyleWithColumns(40)); 3003 3004 EXPECT_EQ("const /** comment comment comment\n" 3005 " comment */\n" 3006 " A = B;", 3007 format("const /** comment comment comment comment */\n" 3008 " A = B;", 3009 getLLVMStyleWithColumns(40))); 3010 } 3011 3012 TEST_F(FormatTestComments, PythonStyleComments) { 3013 // Keeps a space after '#'. 3014 EXPECT_EQ("# comment\n" 3015 "key: value", 3016 format("#comment\n" 3017 "key:value", 3018 getTextProtoStyleWithColumns(20))); 3019 EXPECT_EQ("# comment\n" 3020 "key: value", 3021 format("# comment\n" 3022 "key:value", 3023 getTextProtoStyleWithColumns(20))); 3024 // Breaks long comment. 3025 EXPECT_EQ("# comment comment\n" 3026 "# comment\n" 3027 "key: value", 3028 format("# comment comment comment\n" 3029 "key:value", 3030 getTextProtoStyleWithColumns(20))); 3031 // Indents comments. 3032 EXPECT_EQ("data {\n" 3033 " # comment comment\n" 3034 " # comment\n" 3035 " key: value\n" 3036 "}", 3037 format("data {\n" 3038 "# comment comment comment\n" 3039 "key: value}", 3040 getTextProtoStyleWithColumns(20))); 3041 EXPECT_EQ("data {\n" 3042 " # comment comment\n" 3043 " # comment\n" 3044 " key: value\n" 3045 "}", 3046 format("data {# comment comment comment\n" 3047 "key: value}", 3048 getTextProtoStyleWithColumns(20))); 3049 // Reflows long comments. 3050 EXPECT_EQ("# comment comment\n" 3051 "# comment comment\n" 3052 "key: value", 3053 format("# comment comment comment\n" 3054 "# comment\n" 3055 "key:value", 3056 getTextProtoStyleWithColumns(20))); 3057 // Breaks trailing comments. 3058 EXPECT_EQ("k: val # comment\n" 3059 " # comment\n" 3060 "a: 1", 3061 format("k:val#comment comment\n" 3062 "a:1", 3063 getTextProtoStyleWithColumns(20))); 3064 EXPECT_EQ("id {\n" 3065 " k: val # comment\n" 3066 " # comment\n" 3067 " # line line\n" 3068 " a: 1\n" 3069 "}", 3070 format("id {k:val#comment comment\n" 3071 "# line line\n" 3072 "a:1}", 3073 getTextProtoStyleWithColumns(20))); 3074 // Aligns trailing comments. 3075 EXPECT_EQ("k: val # commen1\n" 3076 " # commen2\n" 3077 " # commen3\n" 3078 "# commen4\n" 3079 "a: 1 # commen5\n" 3080 " # commen6\n" 3081 " # commen7", 3082 format("k:val#commen1 commen2\n" 3083 " # commen3\n" 3084 "# commen4\n" 3085 "a:1#commen5 commen6\n" 3086 " #commen7", 3087 getTextProtoStyleWithColumns(20))); 3088 } 3089 3090 TEST_F(FormatTestComments, BreaksBeforeTrailingUnbreakableSequence) { 3091 // The end of /* trail */ is exactly at 80 columns, but the unbreakable 3092 // trailing sequence ); after it exceeds the column limit. Make sure we 3093 // correctly break the line in that case. 3094 verifyFormat("int a =\n" 3095 " foo(/* trail */);", 3096 getLLVMStyleWithColumns(23)); 3097 } 3098 3099 TEST_F(FormatTestComments, ReflowBackslashCrash) { 3100 // clang-format off 3101 EXPECT_EQ( 3102 "// How to run:\n" 3103 "// bbbbb run \\\n" 3104 "// rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr\n" 3105 "// \\ <log_file> -- --output_directory=\"<output_directory>\"", 3106 format( 3107 "// How to run:\n" 3108 "// bbbbb run \\\n" 3109 "// rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr \\\n" 3110 "// <log_file> -- --output_directory=\"<output_directory>\"")); 3111 // clang-format on 3112 } 3113 3114 TEST_F(FormatTestComments, IndentsLongJavadocAnnotatedLines) { 3115 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Java); 3116 Style.ColumnLimit = 60; 3117 FormatStyle Style20 = getGoogleStyle(FormatStyle::LK_Java); 3118 Style20.ColumnLimit = 20; 3119 EXPECT_EQ( 3120 "/**\n" 3121 " * @param x long long long long long long long long long\n" 3122 " * long\n" 3123 " */\n", 3124 format("/**\n" 3125 " * @param x long long long long long long long long long long\n" 3126 " */\n", 3127 Style)); 3128 EXPECT_EQ("/**\n" 3129 " * @param x long long long long long long long long long\n" 3130 " * long long long long long long long long long long\n" 3131 " */\n", 3132 format("/**\n" 3133 " * @param x long long long long long long long long long " 3134 "long long long long long long long long long long\n" 3135 " */\n", 3136 Style)); 3137 EXPECT_EQ("/**\n" 3138 " * @param x long long long long long long long long long\n" 3139 " * long long long long long long long long long long\n" 3140 " * long\n" 3141 " */\n", 3142 format("/**\n" 3143 " * @param x long long long long long long long long long " 3144 "long long long long long long long long long long long\n" 3145 " */\n", 3146 Style)); 3147 EXPECT_EQ( 3148 "/**\n" 3149 " * Sentence that\n" 3150 " * should be broken.\n" 3151 " * @param short\n" 3152 " * keep indentation\n" 3153 " */\n", format( 3154 "/**\n" 3155 " * Sentence that should be broken.\n" 3156 " * @param short\n" 3157 " * keep indentation\n" 3158 " */\n", Style20)); 3159 3160 EXPECT_EQ("/**\n" 3161 " * @param l1 long1\n" 3162 " * to break\n" 3163 " * @param l2 long2\n" 3164 " * to break\n" 3165 " */\n", 3166 format("/**\n" 3167 " * @param l1 long1 to break\n" 3168 " * @param l2 long2 to break\n" 3169 " */\n", 3170 Style20)); 3171 3172 EXPECT_EQ("/**\n" 3173 " * @param xx to\n" 3174 " * break\n" 3175 " * no reflow\n" 3176 " */\n", 3177 format("/**\n" 3178 " * @param xx to break\n" 3179 " * no reflow\n" 3180 " */\n", 3181 Style20)); 3182 3183 EXPECT_EQ("/**\n" 3184 " * @param xx to\n" 3185 " * break yes\n" 3186 " * reflow\n" 3187 " */\n", 3188 format("/**\n" 3189 " * @param xx to break\n" 3190 " * yes reflow\n" 3191 " */\n", 3192 Style20)); 3193 3194 FormatStyle JSStyle20 = getGoogleStyle(FormatStyle::LK_JavaScript); 3195 JSStyle20.ColumnLimit = 20; 3196 EXPECT_EQ("/**\n" 3197 " * @param l1 long1\n" 3198 " * to break\n" 3199 " */\n", 3200 format("/**\n" 3201 " * @param l1 long1 to break\n" 3202 " */\n", 3203 JSStyle20)); 3204 EXPECT_EQ("/**\n" 3205 " * @param {l1 long1\n" 3206 " * to break}\n" 3207 " */\n", 3208 format("/**\n" 3209 " * @param {l1 long1 to break}\n" 3210 " */\n", 3211 JSStyle20)); 3212 } 3213 3214 } // end namespace 3215 } // end namespace format 3216 } // end namespace clang 3217