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 // Ignore stuff in SWIG-blocks. 1806 EXPECT_EQ("#ifdef SWIG\n" 1807 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 1808 "#endif\n" 1809 "void f() {}", 1810 format("#ifdef SWIG\n" 1811 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 1812 "#endif\n" 1813 "void f( ) { }")); 1814 EXPECT_EQ("#ifndef SWIG\n" 1815 "void f() {}\n" 1816 "#endif", 1817 format("#ifndef SWIG\n" 1818 "void f( ) { }\n" 1819 "#endif")); 1820 } 1821 1822 TEST_F(FormatTestComments, DontCrashOnBlockComments) { 1823 EXPECT_EQ( 1824 "int xxxxxxxxx; /* " 1825 "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy\n" 1826 "zzzzzz\n" 1827 "0*/", 1828 format("int xxxxxxxxx; /* " 1829 "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy zzzzzz\n" 1830 "0*/")); 1831 } 1832 1833 TEST_F(FormatTestComments, BlockCommentsInControlLoops) { 1834 verifyFormat("if (0) /* a comment in a strange place */ {\n" 1835 " f();\n" 1836 "}"); 1837 verifyFormat("if (0) /* a comment in a strange place */ {\n" 1838 " f();\n" 1839 "} /* another comment */ else /* comment #3 */ {\n" 1840 " g();\n" 1841 "}"); 1842 verifyFormat("while (0) /* a comment in a strange place */ {\n" 1843 " f();\n" 1844 "}"); 1845 verifyFormat("for (;;) /* a comment in a strange place */ {\n" 1846 " f();\n" 1847 "}"); 1848 verifyFormat("do /* a comment in a strange place */ {\n" 1849 " f();\n" 1850 "} /* another comment */ while (0);"); 1851 } 1852 1853 TEST_F(FormatTestComments, BlockComments) { 1854 EXPECT_EQ("/* */ /* */ /* */\n/* */ /* */ /* */", 1855 format("/* *//* */ /* */\n/* *//* */ /* */")); 1856 EXPECT_EQ("/* */ a /* */ b;", format(" /* */ a/* */ b;")); 1857 EXPECT_EQ("#define A /*123*/ \\\n" 1858 " b\n" 1859 "/* */\n" 1860 "someCall(\n" 1861 " parameter);", 1862 format("#define A /*123*/ b\n" 1863 "/* */\n" 1864 "someCall(parameter);", 1865 getLLVMStyleWithColumns(15))); 1866 1867 EXPECT_EQ("#define A\n" 1868 "/* */ someCall(\n" 1869 " parameter);", 1870 format("#define A\n" 1871 "/* */someCall(parameter);", 1872 getLLVMStyleWithColumns(15))); 1873 EXPECT_EQ("/*\n**\n*/", format("/*\n**\n*/")); 1874 EXPECT_EQ("/*\n" 1875 " *\n" 1876 " * aaaaaa\n" 1877 " * aaaaaa\n" 1878 " */", 1879 format("/*\n" 1880 "*\n" 1881 " * aaaaaa aaaaaa\n" 1882 "*/", 1883 getLLVMStyleWithColumns(10))); 1884 EXPECT_EQ("/*\n" 1885 "**\n" 1886 "* aaaaaa\n" 1887 "*aaaaaa\n" 1888 "*/", 1889 format("/*\n" 1890 "**\n" 1891 "* aaaaaa aaaaaa\n" 1892 "*/", 1893 getLLVMStyleWithColumns(10))); 1894 EXPECT_EQ("int aaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 1895 " /* line 1\n" 1896 " bbbbbbbbbbbb */\n" 1897 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 1898 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 1899 " /* line 1\n" 1900 " bbbbbbbbbbbb */ bbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 1901 getLLVMStyleWithColumns(50))); 1902 1903 FormatStyle NoBinPacking = getLLVMStyle(); 1904 NoBinPacking.BinPackParameters = false; 1905 EXPECT_EQ("someFunction(1, /* comment 1 */\n" 1906 " 2, /* comment 2 */\n" 1907 " 3, /* comment 3 */\n" 1908 " aaaa,\n" 1909 " bbbb);", 1910 format("someFunction (1, /* comment 1 */\n" 1911 " 2, /* comment 2 */ \n" 1912 " 3, /* comment 3 */\n" 1913 "aaaa, bbbb );", 1914 NoBinPacking)); 1915 verifyFormat( 1916 "bool aaaaaaaaaaaaa = /* comment: */ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 1917 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 1918 EXPECT_EQ( 1919 "bool aaaaaaaaaaaaa = /* trailing comment */\n" 1920 " aaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 1921 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;", 1922 format( 1923 "bool aaaaaaaaaaaaa = /* trailing comment */\n" 1924 " aaaaaaaaaaaaaaaaaaaaaaaaaaa||aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 1925 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;")); 1926 EXPECT_EQ( 1927 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n" 1928 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n" 1929 "int cccccccccccccccccccccccccccccc; /* comment */\n", 1930 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n" 1931 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n" 1932 "int cccccccccccccccccccccccccccccc; /* comment */\n")); 1933 1934 verifyFormat("void f(int * /* unused */) {}"); 1935 1936 EXPECT_EQ("/*\n" 1937 " **\n" 1938 " */", 1939 format("/*\n" 1940 " **\n" 1941 " */")); 1942 EXPECT_EQ("/*\n" 1943 " *q\n" 1944 " */", 1945 format("/*\n" 1946 " *q\n" 1947 " */")); 1948 EXPECT_EQ("/*\n" 1949 " * q\n" 1950 " */", 1951 format("/*\n" 1952 " * q\n" 1953 " */")); 1954 EXPECT_EQ("/*\n" 1955 " **/", 1956 format("/*\n" 1957 " **/")); 1958 EXPECT_EQ("/*\n" 1959 " ***/", 1960 format("/*\n" 1961 " ***/")); 1962 } 1963 1964 TEST_F(FormatTestComments, BlockCommentsInMacros) { 1965 EXPECT_EQ("#define A \\\n" 1966 " { \\\n" 1967 " /* one line */ \\\n" 1968 " someCall();", 1969 format("#define A { \\\n" 1970 " /* one line */ \\\n" 1971 " someCall();", 1972 getLLVMStyleWithColumns(20))); 1973 EXPECT_EQ("#define A \\\n" 1974 " { \\\n" 1975 " /* previous */ \\\n" 1976 " /* one line */ \\\n" 1977 " someCall();", 1978 format("#define A { \\\n" 1979 " /* previous */ \\\n" 1980 " /* one line */ \\\n" 1981 " someCall();", 1982 getLLVMStyleWithColumns(20))); 1983 } 1984 1985 TEST_F(FormatTestComments, BlockCommentsAtEndOfLine) { 1986 EXPECT_EQ("a = {\n" 1987 " 1111 /* */\n" 1988 "};", 1989 format("a = {1111 /* */\n" 1990 "};", 1991 getLLVMStyleWithColumns(15))); 1992 EXPECT_EQ("a = {\n" 1993 " 1111 /* */\n" 1994 "};", 1995 format("a = {1111 /* */\n" 1996 "};", 1997 getLLVMStyleWithColumns(15))); 1998 EXPECT_EQ("a = {\n" 1999 " 1111 /* a\n" 2000 " */\n" 2001 "};", 2002 format("a = {1111 /* a */\n" 2003 "};", 2004 getLLVMStyleWithColumns(15))); 2005 } 2006 2007 TEST_F(FormatTestComments, IndentLineCommentsInStartOfBlockAtEndOfFile) { 2008 verifyFormat("{\n" 2009 " // a\n" 2010 " // b"); 2011 } 2012 2013 TEST_F(FormatTestComments, AlignTrailingComments) { 2014 EXPECT_EQ("#define MACRO(V) \\\n" 2015 " V(Rt2) /* one more char */ \\\n" 2016 " V(Rs) /* than here */ \\\n" 2017 "/* comment 3 */\n", 2018 format("#define MACRO(V)\\\n" 2019 "V(Rt2) /* one more char */ \\\n" 2020 "V(Rs) /* than here */ \\\n" 2021 "/* comment 3 */ \\\n", 2022 getLLVMStyleWithColumns(40))); 2023 EXPECT_EQ("int i = f(abc, // line 1\n" 2024 " d, // line 2\n" 2025 " // line 3\n" 2026 " b);", 2027 format("int i = f(abc, // line 1\n" 2028 " d, // line 2\n" 2029 " // line 3\n" 2030 " b);", 2031 getLLVMStyleWithColumns(40))); 2032 2033 // Align newly broken trailing comments. 2034 EXPECT_EQ("int ab; // line\n" 2035 "int a; // long\n" 2036 " // long\n", 2037 format("int ab; // line\n" 2038 "int a; // long long\n", 2039 getLLVMStyleWithColumns(15))); 2040 EXPECT_EQ("int ab; // line\n" 2041 "int a; // long\n" 2042 " // long\n" 2043 " // long", 2044 format("int ab; // line\n" 2045 "int a; // long long\n" 2046 " // long", 2047 getLLVMStyleWithColumns(15))); 2048 EXPECT_EQ("int ab; // line\n" 2049 "int a; // long\n" 2050 " // long\n" 2051 "pt c; // long", 2052 format("int ab; // line\n" 2053 "int a; // long long\n" 2054 "pt c; // long", 2055 getLLVMStyleWithColumns(15))); 2056 EXPECT_EQ("int ab; // line\n" 2057 "int a; // long\n" 2058 " // long\n" 2059 "\n" 2060 "// long", 2061 format("int ab; // line\n" 2062 "int a; // long long\n" 2063 "\n" 2064 "// long", 2065 getLLVMStyleWithColumns(15))); 2066 2067 // Align comment line sections aligned with the next token with the next 2068 // token. 2069 EXPECT_EQ("class A {\n" 2070 "public: // public comment\n" 2071 " // comment about a\n" 2072 " int a;\n" 2073 "};", 2074 format("class A {\n" 2075 "public: // public comment\n" 2076 " // comment about a\n" 2077 " int a;\n" 2078 "};", 2079 getLLVMStyleWithColumns(40))); 2080 EXPECT_EQ("class A {\n" 2081 "public: // public comment 1\n" 2082 " // public comment 2\n" 2083 " // comment 1 about a\n" 2084 " // comment 2 about a\n" 2085 " int a;\n" 2086 "};", 2087 format("class A {\n" 2088 "public: // public comment 1\n" 2089 " // public comment 2\n" 2090 " // comment 1 about a\n" 2091 " // comment 2 about a\n" 2092 " int a;\n" 2093 "};", 2094 getLLVMStyleWithColumns(40))); 2095 EXPECT_EQ("int f(int n) { // comment line 1 on f\n" 2096 " // comment line 2 on f\n" 2097 " // comment line 1 before return\n" 2098 " // comment line 2 before return\n" 2099 " return n; // comment line 1 on return\n" 2100 " // comment line 2 on return\n" 2101 " // comment line 1 after return\n" 2102 "}", 2103 format("int f(int n) { // comment line 1 on f\n" 2104 " // comment line 2 on f\n" 2105 " // comment line 1 before return\n" 2106 " // comment line 2 before return\n" 2107 " return n; // comment line 1 on return\n" 2108 " // comment line 2 on return\n" 2109 " // comment line 1 after return\n" 2110 "}", 2111 getLLVMStyleWithColumns(40))); 2112 EXPECT_EQ("int f(int n) {\n" 2113 " switch (n) { // comment line 1 on switch\n" 2114 " // comment line 2 on switch\n" 2115 " // comment line 1 before case 1\n" 2116 " // comment line 2 before case 1\n" 2117 " case 1: // comment line 1 on case 1\n" 2118 " // comment line 2 on case 1\n" 2119 " // comment line 1 before return 1\n" 2120 " // comment line 2 before return 1\n" 2121 " return 1; // comment line 1 on return 1\n" 2122 " // comment line 2 on return 1\n" 2123 " // comment line 1 before default\n" 2124 " // comment line 2 before default\n" 2125 " default: // comment line 1 on default\n" 2126 " // comment line 2 on default\n" 2127 " // comment line 1 before return 2\n" 2128 " return 2 * f(n - 1); // comment line 1 on return 2\n" 2129 " // comment line 2 on return 2\n" 2130 " // comment line 1 after return\n" 2131 " // comment line 2 after return\n" 2132 " }\n" 2133 "}", 2134 format("int f(int n) {\n" 2135 " switch (n) { // comment line 1 on switch\n" 2136 " // comment line 2 on switch\n" 2137 " // comment line 1 before case 1\n" 2138 " // comment line 2 before case 1\n" 2139 " case 1: // comment line 1 on case 1\n" 2140 " // comment line 2 on case 1\n" 2141 " // comment line 1 before return 1\n" 2142 " // comment line 2 before return 1\n" 2143 " return 1; // comment line 1 on return 1\n" 2144 " // comment line 2 on return 1\n" 2145 " // comment line 1 before default\n" 2146 " // comment line 2 before default\n" 2147 " default: // comment line 1 on default\n" 2148 " // comment line 2 on default\n" 2149 " // comment line 1 before return 2\n" 2150 " return 2 * f(n - 1); // comment line 1 on return 2\n" 2151 " // comment line 2 on return 2\n" 2152 " // comment line 1 after return\n" 2153 " // comment line 2 after return\n" 2154 " }\n" 2155 "}", 2156 getLLVMStyleWithColumns(80))); 2157 2158 // If all the lines in a sequence of line comments are aligned with the next 2159 // token, the first line belongs to the previous token and the other lines 2160 // belong to the next token. 2161 EXPECT_EQ("int a; // line about a\n" 2162 "long b;", 2163 format("int a; // line about a\n" 2164 " long b;", 2165 getLLVMStyleWithColumns(80))); 2166 EXPECT_EQ("int a; // line about a\n" 2167 "// line about b\n" 2168 "long b;", 2169 format("int a; // line about a\n" 2170 " // line about b\n" 2171 " long b;", 2172 getLLVMStyleWithColumns(80))); 2173 EXPECT_EQ("int a; // line about a\n" 2174 "// line 1 about b\n" 2175 "// line 2 about b\n" 2176 "long b;", 2177 format("int a; // line about a\n" 2178 " // line 1 about b\n" 2179 " // line 2 about b\n" 2180 " long b;", 2181 getLLVMStyleWithColumns(80))); 2182 } 2183 2184 TEST_F(FormatTestComments, AlignsBlockCommentDecorations) { 2185 EXPECT_EQ("/*\n" 2186 " */", 2187 format("/*\n" 2188 "*/", getLLVMStyle())); 2189 EXPECT_EQ("/*\n" 2190 " */", 2191 format("/*\n" 2192 " */", getLLVMStyle())); 2193 EXPECT_EQ("/*\n" 2194 " */", 2195 format("/*\n" 2196 " */", getLLVMStyle())); 2197 2198 // Align a single line. 2199 EXPECT_EQ("/*\n" 2200 " * line */", 2201 format("/*\n" 2202 "* line */", 2203 getLLVMStyle())); 2204 EXPECT_EQ("/*\n" 2205 " * line */", 2206 format("/*\n" 2207 " * line */", 2208 getLLVMStyle())); 2209 EXPECT_EQ("/*\n" 2210 " * line */", 2211 format("/*\n" 2212 " * line */", 2213 getLLVMStyle())); 2214 EXPECT_EQ("/*\n" 2215 " * line */", 2216 format("/*\n" 2217 " * line */", 2218 getLLVMStyle())); 2219 EXPECT_EQ("/**\n" 2220 " * line */", 2221 format("/**\n" 2222 "* line */", 2223 getLLVMStyle())); 2224 EXPECT_EQ("/**\n" 2225 " * line */", 2226 format("/**\n" 2227 " * line */", 2228 getLLVMStyle())); 2229 EXPECT_EQ("/**\n" 2230 " * line */", 2231 format("/**\n" 2232 " * line */", 2233 getLLVMStyle())); 2234 EXPECT_EQ("/**\n" 2235 " * line */", 2236 format("/**\n" 2237 " * line */", 2238 getLLVMStyle())); 2239 EXPECT_EQ("/**\n" 2240 " * line */", 2241 format("/**\n" 2242 " * line */", 2243 getLLVMStyle())); 2244 2245 // Align the end '*/' after a line. 2246 EXPECT_EQ("/*\n" 2247 " * line\n" 2248 " */", 2249 format("/*\n" 2250 "* line\n" 2251 "*/", getLLVMStyle())); 2252 EXPECT_EQ("/*\n" 2253 " * line\n" 2254 " */", 2255 format("/*\n" 2256 " * line\n" 2257 " */", getLLVMStyle())); 2258 EXPECT_EQ("/*\n" 2259 " * line\n" 2260 " */", 2261 format("/*\n" 2262 " * line\n" 2263 " */", getLLVMStyle())); 2264 2265 // Align two lines. 2266 EXPECT_EQ("/* line 1\n" 2267 " * line 2 */", 2268 format("/* line 1\n" 2269 " * line 2 */", 2270 getLLVMStyle())); 2271 EXPECT_EQ("/* line 1\n" 2272 " * line 2 */", 2273 format("/* line 1\n" 2274 "* line 2 */", 2275 getLLVMStyle())); 2276 EXPECT_EQ("/* line 1\n" 2277 " * line 2 */", 2278 format("/* line 1\n" 2279 " * line 2 */", 2280 getLLVMStyle())); 2281 EXPECT_EQ("/* line 1\n" 2282 " * line 2 */", 2283 format("/* line 1\n" 2284 " * line 2 */", 2285 getLLVMStyle())); 2286 EXPECT_EQ("/* line 1\n" 2287 " * line 2 */", 2288 format("/* line 1\n" 2289 " * line 2 */", 2290 getLLVMStyle())); 2291 EXPECT_EQ("int i; /* line 1\n" 2292 " * line 2 */", 2293 format("int i; /* line 1\n" 2294 "* line 2 */", 2295 getLLVMStyle())); 2296 EXPECT_EQ("int i; /* line 1\n" 2297 " * line 2 */", 2298 format("int i; /* line 1\n" 2299 " * line 2 */", 2300 getLLVMStyle())); 2301 EXPECT_EQ("int i; /* line 1\n" 2302 " * line 2 */", 2303 format("int i; /* line 1\n" 2304 " * line 2 */", 2305 getLLVMStyle())); 2306 2307 // Align several lines. 2308 EXPECT_EQ("/* line 1\n" 2309 " * line 2\n" 2310 " * line 3 */", 2311 format("/* line 1\n" 2312 " * line 2\n" 2313 "* line 3 */", 2314 getLLVMStyle())); 2315 EXPECT_EQ("/* line 1\n" 2316 " * line 2\n" 2317 " * line 3 */", 2318 format("/* line 1\n" 2319 " * line 2\n" 2320 "* line 3 */", 2321 getLLVMStyle())); 2322 EXPECT_EQ("/*\n" 2323 "** line 1\n" 2324 "** line 2\n" 2325 "*/", 2326 format("/*\n" 2327 "** line 1\n" 2328 " ** line 2\n" 2329 "*/", 2330 getLLVMStyle())); 2331 2332 // Align with different indent after the decorations. 2333 EXPECT_EQ("/*\n" 2334 " * line 1\n" 2335 " * line 2\n" 2336 " * line 3\n" 2337 " * line 4\n" 2338 " */", 2339 format("/*\n" 2340 "* line 1\n" 2341 " * line 2\n" 2342 " * line 3\n" 2343 "* line 4\n" 2344 "*/", getLLVMStyle())); 2345 2346 // Align empty or blank lines. 2347 EXPECT_EQ("/**\n" 2348 " *\n" 2349 " *\n" 2350 " *\n" 2351 " */", 2352 format("/**\n" 2353 "* \n" 2354 " * \n" 2355 " *\n" 2356 "*/", getLLVMStyle())); 2357 2358 // Align while breaking and reflowing. 2359 EXPECT_EQ("/*\n" 2360 " * long long long\n" 2361 " * long long\n" 2362 " *\n" 2363 " * long */", 2364 format("/*\n" 2365 " * long long long long\n" 2366 " * long\n" 2367 " *\n" 2368 "* long */", 2369 getLLVMStyleWithColumns(20))); 2370 } 2371 } // end namespace 2372 } // end namespace format 2373 } // end namespace clang 2374