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