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