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