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, KeepsTrailingPPCommentsAndSectionCommentsSeparate) { 1024 verifyFormat("#ifdef A // line about A\n" 1025 "// section comment\n" 1026 "#endif", 1027 getLLVMStyleWithColumns(80)); 1028 verifyFormat("#ifdef A // line 1 about A\n" 1029 " // line 2 about A\n" 1030 "// section comment\n" 1031 "#endif", 1032 getLLVMStyleWithColumns(80)); 1033 EXPECT_EQ("#ifdef A // line 1 about A\n" 1034 " // line 2 about A\n" 1035 "// section comment\n" 1036 "#endif", 1037 format("#ifdef A // line 1 about A\n" 1038 " // line 2 about A\n" 1039 "// section comment\n" 1040 "#endif", 1041 getLLVMStyleWithColumns(80))); 1042 verifyFormat("int f() {\n" 1043 " int i;\n" 1044 "#ifdef A // comment about A\n" 1045 " // section comment 1\n" 1046 " // section comment 2\n" 1047 " i = 2;\n" 1048 "#else // comment about #else\n" 1049 " // section comment 3\n" 1050 " i = 4;\n" 1051 "#endif\n" 1052 "}", getLLVMStyleWithColumns(80)); 1053 } 1054 1055 TEST_F(FormatTestComments, AlignsPPElseEndifComments) { 1056 verifyFormat("#if A\n" 1057 "#else // A\n" 1058 "int iiii;\n" 1059 "#endif // B", 1060 getLLVMStyleWithColumns(20)); 1061 verifyFormat("#if A\n" 1062 "#else // A\n" 1063 "int iiii; // CC\n" 1064 "#endif // B", 1065 getLLVMStyleWithColumns(20)); 1066 EXPECT_EQ("#if A\n" 1067 "#else // A1\n" 1068 " // A2\n" 1069 "int ii;\n" 1070 "#endif // B", 1071 format("#if A\n" 1072 "#else // A1\n" 1073 " // A2\n" 1074 "int ii;\n" 1075 "#endif // B", 1076 getLLVMStyleWithColumns(20))); 1077 } 1078 1079 TEST_F(FormatTestComments, CommentsInStaticInitializers) { 1080 EXPECT_EQ( 1081 "static SomeType type = {aaaaaaaaaaaaaaaaaaaa, /* comment */\n" 1082 " aaaaaaaaaaaaaaaaaaaa /* comment */,\n" 1083 " /* comment */ aaaaaaaaaaaaaaaaaaaa,\n" 1084 " aaaaaaaaaaaaaaaaaaaa, // comment\n" 1085 " aaaaaaaaaaaaaaaaaaaa};", 1086 format("static SomeType type = { aaaaaaaaaaaaaaaaaaaa , /* comment */\n" 1087 " aaaaaaaaaaaaaaaaaaaa /* comment */ ,\n" 1088 " /* comment */ aaaaaaaaaaaaaaaaaaaa ,\n" 1089 " aaaaaaaaaaaaaaaaaaaa , // comment\n" 1090 " aaaaaaaaaaaaaaaaaaaa };")); 1091 verifyFormat("static SomeType type = {aaaaaaaaaaa, // comment for aa...\n" 1092 " bbbbbbbbbbb, ccccccccccc};"); 1093 verifyFormat("static SomeType type = {aaaaaaaaaaa,\n" 1094 " // comment for bb....\n" 1095 " bbbbbbbbbbb, ccccccccccc};"); 1096 verifyGoogleFormat( 1097 "static SomeType type = {aaaaaaaaaaa, // comment for aa...\n" 1098 " bbbbbbbbbbb, ccccccccccc};"); 1099 verifyGoogleFormat("static SomeType type = {aaaaaaaaaaa,\n" 1100 " // comment for bb....\n" 1101 " bbbbbbbbbbb, ccccccccccc};"); 1102 1103 verifyFormat("S s = {{a, b, c}, // Group #1\n" 1104 " {d, e, f}, // Group #2\n" 1105 " {g, h, i}}; // Group #3"); 1106 verifyFormat("S s = {{// Group #1\n" 1107 " a, b, c},\n" 1108 " {// Group #2\n" 1109 " d, e, f},\n" 1110 " {// Group #3\n" 1111 " g, h, i}};"); 1112 1113 EXPECT_EQ("S s = {\n" 1114 " // Some comment\n" 1115 " a,\n" 1116 "\n" 1117 " // Comment after empty line\n" 1118 " b}", 1119 format("S s = {\n" 1120 " // Some comment\n" 1121 " a,\n" 1122 " \n" 1123 " // Comment after empty line\n" 1124 " b\n" 1125 "}")); 1126 EXPECT_EQ("S s = {\n" 1127 " /* Some comment */\n" 1128 " a,\n" 1129 "\n" 1130 " /* Comment after empty line */\n" 1131 " b}", 1132 format("S s = {\n" 1133 " /* Some comment */\n" 1134 " a,\n" 1135 " \n" 1136 " /* Comment after empty line */\n" 1137 " b\n" 1138 "}")); 1139 verifyFormat("const uint8_t aaaaaaaaaaaaaaaaaaaaaa[0] = {\n" 1140 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n" 1141 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n" 1142 " 0x00, 0x00, 0x00, 0x00}; // comment\n"); 1143 } 1144 1145 TEST_F(FormatTestComments, LineCommentsAfterRightBrace) { 1146 EXPECT_EQ("if (true) { // comment about branch\n" 1147 " // comment about f\n" 1148 " f();\n" 1149 "}", 1150 format("if (true) { // comment about branch\n" 1151 " // comment about f\n" 1152 " f();\n" 1153 "}", 1154 getLLVMStyleWithColumns(80))); 1155 EXPECT_EQ("if (1) { // if line 1\n" 1156 " // if line 2\n" 1157 " // if line 3\n" 1158 " // f line 1\n" 1159 " // f line 2\n" 1160 " f();\n" 1161 "} else { // else line 1\n" 1162 " // else line 2\n" 1163 " // else line 3\n" 1164 " // g line 1\n" 1165 " g();\n" 1166 "}", 1167 format("if (1) { // if line 1\n" 1168 " // if line 2\n" 1169 " // if line 3\n" 1170 " // f line 1\n" 1171 " // f line 2\n" 1172 " f();\n" 1173 "} else { // else line 1\n" 1174 " // else line 2\n" 1175 " // else line 3\n" 1176 " // g line 1\n" 1177 " g();\n" 1178 "}")); 1179 EXPECT_EQ("do { // line 1\n" 1180 " // line 2\n" 1181 " // line 3\n" 1182 " f();\n" 1183 "} while (true);", 1184 format("do { // line 1\n" 1185 " // line 2\n" 1186 " // line 3\n" 1187 " f();\n" 1188 "} while (true);", 1189 getLLVMStyleWithColumns(80))); 1190 EXPECT_EQ("while (a < b) { // line 1\n" 1191 " // line 2\n" 1192 " // line 3\n" 1193 " f();\n" 1194 "}", 1195 format("while (a < b) {// line 1\n" 1196 " // line 2\n" 1197 " // line 3\n" 1198 " f();\n" 1199 "}", 1200 getLLVMStyleWithColumns(80))); 1201 } 1202 1203 TEST_F(FormatTestComments, ReflowsComments) { 1204 // Break a long line and reflow with the full next line. 1205 EXPECT_EQ("// long long long\n" 1206 "// long long", 1207 format("// long long long long\n" 1208 "// long", 1209 getLLVMStyleWithColumns(20))); 1210 1211 // Keep the trailing newline while reflowing. 1212 EXPECT_EQ("// long long long\n" 1213 "// long long\n", 1214 format("// long long long long\n" 1215 "// long\n", 1216 getLLVMStyleWithColumns(20))); 1217 1218 // Break a long line and reflow with a part of the next line. 1219 EXPECT_EQ("// long long long\n" 1220 "// long long\n" 1221 "// long_long", 1222 format("// long long long long\n" 1223 "// long long_long", 1224 getLLVMStyleWithColumns(20))); 1225 1226 // Break but do not reflow if the first word from the next line is too long. 1227 EXPECT_EQ("// long long long\n" 1228 "// long\n" 1229 "// long_long_long\n", 1230 format("// long long long long\n" 1231 "// long_long_long\n", 1232 getLLVMStyleWithColumns(20))); 1233 1234 // Don't break or reflow short lines. 1235 verifyFormat("// long\n" 1236 "// long long long lo\n" 1237 "// long long long lo\n" 1238 "// long", 1239 getLLVMStyleWithColumns(20)); 1240 1241 // Keep prefixes and decorations while reflowing. 1242 EXPECT_EQ("/// long long long\n" 1243 "/// long long\n", 1244 format("/// long long long long\n" 1245 "/// long\n", 1246 getLLVMStyleWithColumns(20))); 1247 EXPECT_EQ("//! long long long\n" 1248 "//! long long\n", 1249 format("//! long long long long\n" 1250 "//! long\n", 1251 getLLVMStyleWithColumns(20))); 1252 EXPECT_EQ("/* long long long\n" 1253 " * long long */", 1254 format("/* long long long long\n" 1255 " * long */", 1256 getLLVMStyleWithColumns(20))); 1257 EXPECT_EQ("///< long long long\n" 1258 "///< long long\n", 1259 format("///< long long long long\n" 1260 "///< long\n", 1261 getLLVMStyleWithColumns(20))); 1262 EXPECT_EQ("//!< long long long\n" 1263 "//!< long long\n", 1264 format("//!< long long long long\n" 1265 "//!< long\n", 1266 getLLVMStyleWithColumns(20))); 1267 1268 // Don't bring leading whitespace up while reflowing. 1269 EXPECT_EQ("/* long long long\n" 1270 " * long long long\n" 1271 " */", 1272 format("/* long long long long\n" 1273 " * long long\n" 1274 " */", 1275 getLLVMStyleWithColumns(20))); 1276 1277 // Reflow the last line of a block comment with its trailing '*/'. 1278 EXPECT_EQ("/* long long long\n" 1279 " long long */", 1280 format("/* long long long long\n" 1281 " long */", 1282 getLLVMStyleWithColumns(20))); 1283 1284 // Reflow two short lines; keep the postfix of the last one. 1285 EXPECT_EQ("/* long long long\n" 1286 " * long long long */", 1287 format("/* long long long long\n" 1288 " * long\n" 1289 " * long */", 1290 getLLVMStyleWithColumns(20))); 1291 1292 // Put the postfix of the last short reflow line on a newline if it doesn't 1293 // fit. 1294 EXPECT_EQ("/* long long long\n" 1295 " * long long longg\n" 1296 " */", 1297 format("/* long long long long\n" 1298 " * long\n" 1299 " * longg */", 1300 getLLVMStyleWithColumns(20))); 1301 1302 // Reflow lines with leading whitespace. 1303 EXPECT_EQ("{\n" 1304 " /*\n" 1305 " * long long long\n" 1306 " * long long long\n" 1307 " * long long long\n" 1308 " */\n" 1309 "}", 1310 format("{\n" 1311 "/*\n" 1312 " * long long long long\n" 1313 " * long\n" 1314 " * long long long long\n" 1315 " */\n" 1316 "}", 1317 getLLVMStyleWithColumns(20))); 1318 1319 // Break single line block comments that are first in the line with ' *' 1320 // decoration. 1321 EXPECT_EQ("/* long long long\n" 1322 " * long */", 1323 format("/* long long long long */", getLLVMStyleWithColumns(20))); 1324 1325 // Break single line block comment that are not first in the line with ' ' 1326 // decoration. 1327 EXPECT_EQ("int i; /* long long\n" 1328 " long */", 1329 format("int i; /* long long long */", getLLVMStyleWithColumns(20))); 1330 1331 // Reflow a line that goes just over the column limit. 1332 EXPECT_EQ("// long long long\n" 1333 "// lon long", 1334 format("// long long long lon\n" 1335 "// long", 1336 getLLVMStyleWithColumns(20))); 1337 1338 // Stop reflowing if the next line has a different indentation than the 1339 // previous line. 1340 EXPECT_EQ("// long long long\n" 1341 "// long\n" 1342 "// long long\n" 1343 "// long", 1344 format("// long long long long\n" 1345 "// long long\n" 1346 "// long", 1347 getLLVMStyleWithColumns(20))); 1348 1349 // Reflow into the last part of a really long line that has been broken into 1350 // multiple lines. 1351 EXPECT_EQ("// long long long\n" 1352 "// long long long\n" 1353 "// long long long\n", 1354 format("// long long long long long long long long\n" 1355 "// long\n", 1356 getLLVMStyleWithColumns(20))); 1357 1358 // Break the first line, then reflow the beginning of the second and third 1359 // line up. 1360 EXPECT_EQ("// long long long\n" 1361 "// lon1 lon2 lon2\n" 1362 "// lon2 lon3 lon3", 1363 format("// long long long lon1\n" 1364 "// lon2 lon2 lon2\n" 1365 "// lon3 lon3", 1366 getLLVMStyleWithColumns(20))); 1367 1368 // Reflow the beginning of the second line, then break the rest. 1369 EXPECT_EQ("// long long long\n" 1370 "// lon1 lon2 lon2\n" 1371 "// lon2 lon2 lon2\n" 1372 "// lon3", 1373 format("// long long long lon1\n" 1374 "// lon2 lon2 lon2 lon2 lon2 lon3", 1375 getLLVMStyleWithColumns(20))); 1376 1377 // Shrink the first line, then reflow the second line up. 1378 EXPECT_EQ("// long long long", format("// long long\n" 1379 "// long", 1380 getLLVMStyleWithColumns(20))); 1381 1382 // Don't shrink leading whitespace. 1383 EXPECT_EQ("int i; /// a", 1384 format("int i; /// a", getLLVMStyleWithColumns(20))); 1385 1386 // Shrink trailing whitespace if there is no postfix and reflow. 1387 EXPECT_EQ("// long long long\n" 1388 "// long long", 1389 format("// long long long long \n" 1390 "// long", 1391 getLLVMStyleWithColumns(20))); 1392 1393 // Shrink trailing whitespace to a single one if there is postfix. 1394 EXPECT_EQ("/* long long long */", 1395 format("/* long long long */", getLLVMStyleWithColumns(20))); 1396 1397 // Break a block comment postfix if exceeding the line limit. 1398 EXPECT_EQ("/* long\n" 1399 " */", 1400 format("/* long */", getLLVMStyleWithColumns(20))); 1401 1402 // Reflow indented comments. 1403 EXPECT_EQ("{\n" 1404 " // long long long\n" 1405 " // long long\n" 1406 " int i; /* long lon\n" 1407 " g long\n" 1408 " */\n" 1409 "}", 1410 format("{\n" 1411 " // long long long long\n" 1412 " // long\n" 1413 " int i; /* long lon g\n" 1414 " long */\n" 1415 "}", 1416 getLLVMStyleWithColumns(20))); 1417 1418 // Don't realign trailing comments after reflow has happened. 1419 EXPECT_EQ("// long long long\n" 1420 "// long long\n" 1421 "long i; // long", 1422 format("// long long long long\n" 1423 "// long\n" 1424 "long i; // long", 1425 getLLVMStyleWithColumns(20))); 1426 EXPECT_EQ("// long long long\n" 1427 "// longng long long\n" 1428 "// long lo", 1429 format("// long long long longng\n" 1430 "// long long long\n" 1431 "// lo", 1432 getLLVMStyleWithColumns(20))); 1433 1434 // Reflow lines after a broken line. 1435 EXPECT_EQ("int a; // Trailing\n" 1436 " // comment on\n" 1437 " // 2 or 3\n" 1438 " // lines.\n", 1439 format("int a; // Trailing comment\n" 1440 " // on 2\n" 1441 " // or 3\n" 1442 " // lines.\n", 1443 getLLVMStyleWithColumns(20))); 1444 EXPECT_EQ("/// This long line\n" 1445 "/// gets reflown.\n", 1446 format("/// This long line gets\n" 1447 "/// reflown.\n", 1448 getLLVMStyleWithColumns(20))); 1449 EXPECT_EQ("//! This long line\n" 1450 "//! gets reflown.\n", 1451 format(" //! This long line gets\n" 1452 " //! reflown.\n", 1453 getLLVMStyleWithColumns(20))); 1454 EXPECT_EQ("/* This long line\n" 1455 " * gets reflown.\n" 1456 " */\n", 1457 format("/* This long line gets\n" 1458 " * reflown.\n" 1459 " */\n", 1460 getLLVMStyleWithColumns(20))); 1461 1462 // Reflow after indentation makes a line too long. 1463 EXPECT_EQ("{\n" 1464 " // long long long\n" 1465 " // lo long\n" 1466 "}\n", 1467 format("{\n" 1468 "// long long long lo\n" 1469 "// long\n" 1470 "}\n", 1471 getLLVMStyleWithColumns(20))); 1472 1473 // Break and reflow multiple lines. 1474 EXPECT_EQ("/*\n" 1475 " * Reflow the end of\n" 1476 " * line by 11 22 33\n" 1477 " * 4.\n" 1478 " */\n", 1479 format("/*\n" 1480 " * Reflow the end of line\n" 1481 " * by\n" 1482 " * 11\n" 1483 " * 22\n" 1484 " * 33\n" 1485 " * 4.\n" 1486 " */\n", 1487 getLLVMStyleWithColumns(20))); 1488 EXPECT_EQ("/// First line gets\n" 1489 "/// broken. Second\n" 1490 "/// line gets\n" 1491 "/// reflown and\n" 1492 "/// broken. Third\n" 1493 "/// gets reflown.\n", 1494 format("/// First line gets broken.\n" 1495 "/// Second line gets reflown and broken.\n" 1496 "/// Third gets reflown.\n", 1497 getLLVMStyleWithColumns(20))); 1498 EXPECT_EQ("int i; // first long\n" 1499 " // long snd\n" 1500 " // long.\n", 1501 format("int i; // first long long\n" 1502 " // snd long.\n", 1503 getLLVMStyleWithColumns(20))); 1504 EXPECT_EQ("{\n" 1505 " // first long line\n" 1506 " // line second\n" 1507 " // long line line\n" 1508 " // third long line\n" 1509 " // line\n" 1510 "}\n", 1511 format("{\n" 1512 " // first long line line\n" 1513 " // second long line line\n" 1514 " // third long line line\n" 1515 "}\n", 1516 getLLVMStyleWithColumns(20))); 1517 EXPECT_EQ("int i; /* first line\n" 1518 " * second\n" 1519 " * line third\n" 1520 " * line\n" 1521 " */", 1522 format("int i; /* first line\n" 1523 " * second line\n" 1524 " * third line\n" 1525 " */", 1526 getLLVMStyleWithColumns(20))); 1527 1528 // Reflow the last two lines of a section that starts with a line having 1529 // different indentation. 1530 EXPECT_EQ( 1531 "// long\n" 1532 "// long long long\n" 1533 "// long long", 1534 format("// long\n" 1535 "// long long long long\n" 1536 "// long", 1537 getLLVMStyleWithColumns(20))); 1538 1539 // Keep the block comment endling '*/' while reflowing. 1540 EXPECT_EQ("/* Long long long\n" 1541 " * line short */\n", 1542 format("/* Long long long line\n" 1543 " * short */\n", 1544 getLLVMStyleWithColumns(20))); 1545 1546 // Don't reflow between separate blocks of comments. 1547 EXPECT_EQ("/* First comment\n" 1548 " * block will */\n" 1549 "/* Snd\n" 1550 " */\n", 1551 format("/* First comment block\n" 1552 " * will */\n" 1553 "/* Snd\n" 1554 " */\n", 1555 getLLVMStyleWithColumns(20))); 1556 1557 // Don't reflow across blank comment lines. 1558 EXPECT_EQ("int i; // This long\n" 1559 " // line gets\n" 1560 " // broken.\n" 1561 " //\n" 1562 " // keep.\n", 1563 format("int i; // This long line gets broken.\n" 1564 " // \n" 1565 " // keep.\n", 1566 getLLVMStyleWithColumns(20))); 1567 EXPECT_EQ("{\n" 1568 " /// long long long\n" 1569 " /// long long\n" 1570 " ///\n" 1571 " /// long\n" 1572 "}", 1573 format("{\n" 1574 " /// long long long long\n" 1575 " /// long\n" 1576 " ///\n" 1577 " /// long\n" 1578 "}", 1579 getLLVMStyleWithColumns(20))); 1580 EXPECT_EQ("//! long long long\n" 1581 "//! long\n" 1582 "\n" 1583 "//! long", 1584 format("//! long long long long\n" 1585 "\n" 1586 "//! long", 1587 getLLVMStyleWithColumns(20))); 1588 EXPECT_EQ("/* long long long\n" 1589 " long\n" 1590 "\n" 1591 " long */", 1592 format("/* long long long long\n" 1593 "\n" 1594 " long */", 1595 getLLVMStyleWithColumns(20))); 1596 EXPECT_EQ("/* long long long\n" 1597 " * long\n" 1598 " *\n" 1599 " * long */", 1600 format("/* long long long long\n" 1601 " *\n" 1602 " * long */", 1603 getLLVMStyleWithColumns(20))); 1604 1605 // Don't reflow lines having content that is a single character. 1606 EXPECT_EQ("// long long long\n" 1607 "// long\n" 1608 "// l", 1609 format("// long long long long\n" 1610 "// l", 1611 getLLVMStyleWithColumns(20))); 1612 1613 // Don't reflow lines starting with two punctuation characters. 1614 EXPECT_EQ("// long long long\n" 1615 "// long\n" 1616 "// ... --- ...", 1617 format( 1618 "// long long long long\n" 1619 "// ... --- ...", 1620 getLLVMStyleWithColumns(20))); 1621 1622 // Don't reflow lines starting with '@'. 1623 EXPECT_EQ("// long long long\n" 1624 "// long\n" 1625 "// @param arg", 1626 format("// long long long long\n" 1627 "// @param arg", 1628 getLLVMStyleWithColumns(20))); 1629 1630 // Don't reflow lines starting with 'TODO'. 1631 EXPECT_EQ("// long long long\n" 1632 "// long\n" 1633 "// TODO: long", 1634 format("// long long long long\n" 1635 "// TODO: long", 1636 getLLVMStyleWithColumns(20))); 1637 1638 // Don't reflow lines starting with 'FIXME'. 1639 EXPECT_EQ("// long long long\n" 1640 "// long\n" 1641 "// FIXME: long", 1642 format("// long long long long\n" 1643 "// FIXME: long", 1644 getLLVMStyleWithColumns(20))); 1645 1646 // Don't reflow lines starting with 'XXX'. 1647 EXPECT_EQ("// long long long\n" 1648 "// long\n" 1649 "// XXX: long", 1650 format("// long long long long\n" 1651 "// XXX: long", 1652 getLLVMStyleWithColumns(20))); 1653 1654 // Don't reflow comment pragmas. 1655 EXPECT_EQ("// long long long\n" 1656 "// long\n" 1657 "// IWYU pragma:", 1658 format("// long long long long\n" 1659 "// IWYU pragma:", 1660 getLLVMStyleWithColumns(20))); 1661 EXPECT_EQ("/* long long long\n" 1662 " * long\n" 1663 " * IWYU pragma:\n" 1664 " */", 1665 format("/* long long long long\n" 1666 " * IWYU pragma:\n" 1667 " */", 1668 getLLVMStyleWithColumns(20))); 1669 1670 // Reflow lines that have a non-punctuation character among their first 2 1671 // characters. 1672 EXPECT_EQ("// long long long\n" 1673 "// long 'long'", 1674 format( 1675 "// long long long long\n" 1676 "// 'long'", 1677 getLLVMStyleWithColumns(20))); 1678 1679 // Don't reflow between separate blocks of comments. 1680 EXPECT_EQ("/* First comment\n" 1681 " * block will */\n" 1682 "/* Snd\n" 1683 " */\n", 1684 format("/* First comment block\n" 1685 " * will */\n" 1686 "/* Snd\n" 1687 " */\n", 1688 getLLVMStyleWithColumns(20))); 1689 1690 // Don't reflow lines having different indentation. 1691 EXPECT_EQ("// long long long\n" 1692 "// long\n" 1693 "// long", 1694 format("// long long long long\n" 1695 "// long", 1696 getLLVMStyleWithColumns(20))); 1697 1698 // Don't reflow separate bullets in list 1699 EXPECT_EQ("// - long long long\n" 1700 "// long\n" 1701 "// - long", 1702 format("// - long long long long\n" 1703 "// - long", 1704 getLLVMStyleWithColumns(20))); 1705 EXPECT_EQ("// * long long long\n" 1706 "// long\n" 1707 "// * long", 1708 format("// * long long long long\n" 1709 "// * long", 1710 getLLVMStyleWithColumns(20))); 1711 EXPECT_EQ("// + long long long\n" 1712 "// long\n" 1713 "// + long", 1714 format("// + long long long long\n" 1715 "// + long", 1716 getLLVMStyleWithColumns(20))); 1717 EXPECT_EQ("// 1. long long long\n" 1718 "// long\n" 1719 "// 2. long", 1720 format("// 1. long long long long\n" 1721 "// 2. long", 1722 getLLVMStyleWithColumns(20))); 1723 EXPECT_EQ("// -# long long long\n" 1724 "// long\n" 1725 "// -# long", 1726 format("// -# long long long long\n" 1727 "// -# long", 1728 getLLVMStyleWithColumns(20))); 1729 1730 EXPECT_EQ("// - long long long\n" 1731 "// long long long\n" 1732 "// - long", 1733 format("// - long long long long\n" 1734 "// long long\n" 1735 "// - long", 1736 getLLVMStyleWithColumns(20))); 1737 EXPECT_EQ("// - long long long\n" 1738 "// long long long\n" 1739 "// long\n" 1740 "// - long", 1741 format("// - long long long long\n" 1742 "// long long long\n" 1743 "// - long", 1744 getLLVMStyleWithColumns(20))); 1745 1746 // Large number (>2 digits) are not list items 1747 EXPECT_EQ("// long long long\n" 1748 "// long 1024. long.", 1749 format("// long long long long\n" 1750 "// 1024. long.", 1751 getLLVMStyleWithColumns(20))); 1752 1753 // Do not break before number, to avoid introducing a non-reflowable doxygen 1754 // list item. 1755 EXPECT_EQ("// long long\n" 1756 "// long 10. long.", 1757 format("// long long long 10.\n" 1758 "// long.", 1759 getLLVMStyleWithColumns(20))); 1760 1761 // Don't break or reflow after implicit string literals. 1762 verifyFormat("#include <t> // l l l\n" 1763 " // l", 1764 getLLVMStyleWithColumns(20)); 1765 1766 // Don't break or reflow comments on import lines. 1767 EXPECT_EQ("#include \"t\" /* l l l\n" 1768 " * l */", 1769 format("#include \"t\" /* l l l\n" 1770 " * l */", 1771 getLLVMStyleWithColumns(20))); 1772 1773 // Don't reflow between different trailing comment sections. 1774 EXPECT_EQ("int i; // long long\n" 1775 " // long\n" 1776 "int j; // long long\n" 1777 " // long\n", 1778 format("int i; // long long long\n" 1779 "int j; // long long long\n", 1780 getLLVMStyleWithColumns(20))); 1781 1782 // Don't reflow if the first word on the next line is longer than the 1783 // available space at current line. 1784 EXPECT_EQ("int i; // trigger\n" 1785 " // reflow\n" 1786 " // longsec\n", 1787 format("int i; // trigger reflow\n" 1788 " // longsec\n", 1789 getLLVMStyleWithColumns(20))); 1790 1791 // Keep empty comment lines. 1792 EXPECT_EQ("/**/", format(" /**/", getLLVMStyleWithColumns(20))); 1793 EXPECT_EQ("/* */", format(" /* */", getLLVMStyleWithColumns(20))); 1794 EXPECT_EQ("/* */", format(" /* */", getLLVMStyleWithColumns(20))); 1795 EXPECT_EQ("//", format(" // ", getLLVMStyleWithColumns(20))); 1796 EXPECT_EQ("///", format(" /// ", getLLVMStyleWithColumns(20))); 1797 } 1798 1799 TEST_F(FormatTestComments, IgnoresIf0Contents) { 1800 EXPECT_EQ("#if 0\n" 1801 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 1802 "#endif\n" 1803 "void f() {}", 1804 format("#if 0\n" 1805 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 1806 "#endif\n" 1807 "void f( ) { }")); 1808 EXPECT_EQ("#if false\n" 1809 "void f( ) { }\n" 1810 "#endif\n" 1811 "void g() {}\n", 1812 format("#if false\n" 1813 "void f( ) { }\n" 1814 "#endif\n" 1815 "void g( ) { }\n")); 1816 EXPECT_EQ("enum E {\n" 1817 " One,\n" 1818 " Two,\n" 1819 "#if 0\n" 1820 "Three,\n" 1821 " Four,\n" 1822 "#endif\n" 1823 " Five\n" 1824 "};", 1825 format("enum E {\n" 1826 " One,Two,\n" 1827 "#if 0\n" 1828 "Three,\n" 1829 " Four,\n" 1830 "#endif\n" 1831 " Five};")); 1832 EXPECT_EQ("enum F {\n" 1833 " One,\n" 1834 "#if 1\n" 1835 " Two,\n" 1836 "#if 0\n" 1837 "Three,\n" 1838 " Four,\n" 1839 "#endif\n" 1840 " Five\n" 1841 "#endif\n" 1842 "};", 1843 format("enum F {\n" 1844 "One,\n" 1845 "#if 1\n" 1846 "Two,\n" 1847 "#if 0\n" 1848 "Three,\n" 1849 " Four,\n" 1850 "#endif\n" 1851 "Five\n" 1852 "#endif\n" 1853 "};")); 1854 EXPECT_EQ("enum G {\n" 1855 " One,\n" 1856 "#if 0\n" 1857 "Two,\n" 1858 "#else\n" 1859 " Three,\n" 1860 "#endif\n" 1861 " Four\n" 1862 "};", 1863 format("enum G {\n" 1864 "One,\n" 1865 "#if 0\n" 1866 "Two,\n" 1867 "#else\n" 1868 "Three,\n" 1869 "#endif\n" 1870 "Four\n" 1871 "};")); 1872 EXPECT_EQ("enum H {\n" 1873 " One,\n" 1874 "#if 0\n" 1875 "#ifdef Q\n" 1876 "Two,\n" 1877 "#else\n" 1878 "Three,\n" 1879 "#endif\n" 1880 "#endif\n" 1881 " Four\n" 1882 "};", 1883 format("enum H {\n" 1884 "One,\n" 1885 "#if 0\n" 1886 "#ifdef Q\n" 1887 "Two,\n" 1888 "#else\n" 1889 "Three,\n" 1890 "#endif\n" 1891 "#endif\n" 1892 "Four\n" 1893 "};")); 1894 EXPECT_EQ("enum I {\n" 1895 " One,\n" 1896 "#if /* test */ 0 || 1\n" 1897 "Two,\n" 1898 "Three,\n" 1899 "#endif\n" 1900 " Four\n" 1901 "};", 1902 format("enum I {\n" 1903 "One,\n" 1904 "#if /* test */ 0 || 1\n" 1905 "Two,\n" 1906 "Three,\n" 1907 "#endif\n" 1908 "Four\n" 1909 "};")); 1910 EXPECT_EQ("enum J {\n" 1911 " One,\n" 1912 "#if 0\n" 1913 "#if 0\n" 1914 "Two,\n" 1915 "#else\n" 1916 "Three,\n" 1917 "#endif\n" 1918 "Four,\n" 1919 "#endif\n" 1920 " Five\n" 1921 "};", 1922 format("enum J {\n" 1923 "One,\n" 1924 "#if 0\n" 1925 "#if 0\n" 1926 "Two,\n" 1927 "#else\n" 1928 "Three,\n" 1929 "#endif\n" 1930 "Four,\n" 1931 "#endif\n" 1932 "Five\n" 1933 "};")); 1934 1935 // Ignore stuff in SWIG-blocks. 1936 EXPECT_EQ("#ifdef SWIG\n" 1937 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 1938 "#endif\n" 1939 "void f() {}", 1940 format("#ifdef SWIG\n" 1941 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 1942 "#endif\n" 1943 "void f( ) { }")); 1944 EXPECT_EQ("#ifndef SWIG\n" 1945 "void f() {}\n" 1946 "#endif", 1947 format("#ifndef SWIG\n" 1948 "void f( ) { }\n" 1949 "#endif")); 1950 } 1951 1952 TEST_F(FormatTestComments, DontCrashOnBlockComments) { 1953 EXPECT_EQ( 1954 "int xxxxxxxxx; /* " 1955 "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy\n" 1956 "zzzzzz\n" 1957 "0*/", 1958 format("int xxxxxxxxx; /* " 1959 "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy zzzzzz\n" 1960 "0*/")); 1961 } 1962 1963 TEST_F(FormatTestComments, BlockCommentsInControlLoops) { 1964 verifyFormat("if (0) /* a comment in a strange place */ {\n" 1965 " f();\n" 1966 "}"); 1967 verifyFormat("if (0) /* a comment in a strange place */ {\n" 1968 " f();\n" 1969 "} /* another comment */ else /* comment #3 */ {\n" 1970 " g();\n" 1971 "}"); 1972 verifyFormat("while (0) /* a comment in a strange place */ {\n" 1973 " f();\n" 1974 "}"); 1975 verifyFormat("for (;;) /* a comment in a strange place */ {\n" 1976 " f();\n" 1977 "}"); 1978 verifyFormat("do /* a comment in a strange place */ {\n" 1979 " f();\n" 1980 "} /* another comment */ while (0);"); 1981 } 1982 1983 TEST_F(FormatTestComments, BlockComments) { 1984 EXPECT_EQ("/* */ /* */ /* */\n/* */ /* */ /* */", 1985 format("/* *//* */ /* */\n/* *//* */ /* */")); 1986 EXPECT_EQ("/* */ a /* */ b;", format(" /* */ a/* */ b;")); 1987 EXPECT_EQ("#define A /*123*/ \\\n" 1988 " b\n" 1989 "/* */\n" 1990 "someCall(\n" 1991 " parameter);", 1992 format("#define A /*123*/ b\n" 1993 "/* */\n" 1994 "someCall(parameter);", 1995 getLLVMStyleWithColumns(15))); 1996 1997 EXPECT_EQ("#define A\n" 1998 "/* */ someCall(\n" 1999 " parameter);", 2000 format("#define A\n" 2001 "/* */someCall(parameter);", 2002 getLLVMStyleWithColumns(15))); 2003 EXPECT_EQ("/*\n**\n*/", format("/*\n**\n*/")); 2004 EXPECT_EQ("/*\n" 2005 " *\n" 2006 " * aaaaaa\n" 2007 " * aaaaaa\n" 2008 " */", 2009 format("/*\n" 2010 "*\n" 2011 " * aaaaaa aaaaaa\n" 2012 "*/", 2013 getLLVMStyleWithColumns(10))); 2014 EXPECT_EQ("/*\n" 2015 "**\n" 2016 "* aaaaaa\n" 2017 "*aaaaaa\n" 2018 "*/", 2019 format("/*\n" 2020 "**\n" 2021 "* aaaaaa aaaaaa\n" 2022 "*/", 2023 getLLVMStyleWithColumns(10))); 2024 EXPECT_EQ("int aaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 2025 " /* line 1\n" 2026 " bbbbbbbbbbbb */\n" 2027 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 2028 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 2029 " /* line 1\n" 2030 " bbbbbbbbbbbb */ bbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 2031 getLLVMStyleWithColumns(50))); 2032 2033 FormatStyle NoBinPacking = getLLVMStyle(); 2034 NoBinPacking.BinPackParameters = false; 2035 EXPECT_EQ("someFunction(1, /* comment 1 */\n" 2036 " 2, /* comment 2 */\n" 2037 " 3, /* comment 3 */\n" 2038 " aaaa,\n" 2039 " bbbb);", 2040 format("someFunction (1, /* comment 1 */\n" 2041 " 2, /* comment 2 */ \n" 2042 " 3, /* comment 3 */\n" 2043 "aaaa, bbbb );", 2044 NoBinPacking)); 2045 verifyFormat( 2046 "bool aaaaaaaaaaaaa = /* comment: */ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2047 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 2048 EXPECT_EQ( 2049 "bool aaaaaaaaaaaaa = /* trailing comment */\n" 2050 " aaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2051 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;", 2052 format( 2053 "bool aaaaaaaaaaaaa = /* trailing comment */\n" 2054 " aaaaaaaaaaaaaaaaaaaaaaaaaaa||aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2055 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;")); 2056 EXPECT_EQ( 2057 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n" 2058 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n" 2059 "int cccccccccccccccccccccccccccccc; /* comment */\n", 2060 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n" 2061 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n" 2062 "int cccccccccccccccccccccccccccccc; /* comment */\n")); 2063 2064 verifyFormat("void f(int * /* unused */) {}"); 2065 2066 EXPECT_EQ("/*\n" 2067 " **\n" 2068 " */", 2069 format("/*\n" 2070 " **\n" 2071 " */")); 2072 EXPECT_EQ("/*\n" 2073 " *q\n" 2074 " */", 2075 format("/*\n" 2076 " *q\n" 2077 " */")); 2078 EXPECT_EQ("/*\n" 2079 " * q\n" 2080 " */", 2081 format("/*\n" 2082 " * q\n" 2083 " */")); 2084 EXPECT_EQ("/*\n" 2085 " **/", 2086 format("/*\n" 2087 " **/")); 2088 EXPECT_EQ("/*\n" 2089 " ***/", 2090 format("/*\n" 2091 " ***/")); 2092 } 2093 2094 TEST_F(FormatTestComments, BlockCommentsInMacros) { 2095 EXPECT_EQ("#define A \\\n" 2096 " { \\\n" 2097 " /* one line */ \\\n" 2098 " someCall();", 2099 format("#define A { \\\n" 2100 " /* one line */ \\\n" 2101 " someCall();", 2102 getLLVMStyleWithColumns(20))); 2103 EXPECT_EQ("#define A \\\n" 2104 " { \\\n" 2105 " /* previous */ \\\n" 2106 " /* one line */ \\\n" 2107 " someCall();", 2108 format("#define A { \\\n" 2109 " /* previous */ \\\n" 2110 " /* one line */ \\\n" 2111 " someCall();", 2112 getLLVMStyleWithColumns(20))); 2113 } 2114 2115 TEST_F(FormatTestComments, BlockCommentsAtEndOfLine) { 2116 EXPECT_EQ("a = {\n" 2117 " 1111 /* */\n" 2118 "};", 2119 format("a = {1111 /* */\n" 2120 "};", 2121 getLLVMStyleWithColumns(15))); 2122 EXPECT_EQ("a = {\n" 2123 " 1111 /* */\n" 2124 "};", 2125 format("a = {1111 /* */\n" 2126 "};", 2127 getLLVMStyleWithColumns(15))); 2128 EXPECT_EQ("a = {\n" 2129 " 1111 /* a\n" 2130 " */\n" 2131 "};", 2132 format("a = {1111 /* a */\n" 2133 "};", 2134 getLLVMStyleWithColumns(15))); 2135 } 2136 2137 TEST_F(FormatTestComments, IndentLineCommentsInStartOfBlockAtEndOfFile) { 2138 verifyFormat("{\n" 2139 " // a\n" 2140 " // b"); 2141 } 2142 2143 TEST_F(FormatTestComments, AlignTrailingComments) { 2144 EXPECT_EQ("#define MACRO(V) \\\n" 2145 " V(Rt2) /* one more char */ \\\n" 2146 " V(Rs) /* than here */ \\\n" 2147 "/* comment 3 */\n", 2148 format("#define MACRO(V)\\\n" 2149 "V(Rt2) /* one more char */ \\\n" 2150 "V(Rs) /* than here */ \\\n" 2151 "/* comment 3 */\n", 2152 getLLVMStyleWithColumns(40))); 2153 EXPECT_EQ("int i = f(abc, // line 1\n" 2154 " d, // line 2\n" 2155 " // line 3\n" 2156 " b);", 2157 format("int i = f(abc, // line 1\n" 2158 " d, // line 2\n" 2159 " // line 3\n" 2160 " b);", 2161 getLLVMStyleWithColumns(40))); 2162 2163 // Align newly broken trailing comments. 2164 EXPECT_EQ("int ab; // line\n" 2165 "int a; // long\n" 2166 " // long\n", 2167 format("int ab; // line\n" 2168 "int a; // long long\n", 2169 getLLVMStyleWithColumns(15))); 2170 EXPECT_EQ("int ab; // line\n" 2171 "int a; // long\n" 2172 " // long\n" 2173 " // long", 2174 format("int ab; // line\n" 2175 "int a; // long long\n" 2176 " // long", 2177 getLLVMStyleWithColumns(15))); 2178 EXPECT_EQ("int ab; // line\n" 2179 "int a; // long\n" 2180 " // long\n" 2181 "pt c; // long", 2182 format("int ab; // line\n" 2183 "int a; // long long\n" 2184 "pt c; // long", 2185 getLLVMStyleWithColumns(15))); 2186 EXPECT_EQ("int ab; // line\n" 2187 "int a; // long\n" 2188 " // long\n" 2189 "\n" 2190 "// long", 2191 format("int ab; // line\n" 2192 "int a; // long long\n" 2193 "\n" 2194 "// long", 2195 getLLVMStyleWithColumns(15))); 2196 2197 // Don't align newly broken trailing comments if that would put them over the 2198 // column limit. 2199 EXPECT_EQ("int i, j; // line 1\n" 2200 "int k; // line longg\n" 2201 " // long", 2202 format("int i, j; // line 1\n" 2203 "int k; // line longg long", 2204 getLLVMStyleWithColumns(20))); 2205 2206 // Align comment line sections aligned with the next token with the next 2207 // token. 2208 EXPECT_EQ("class A {\n" 2209 "public: // public comment\n" 2210 " // comment about a\n" 2211 " int a;\n" 2212 "};", 2213 format("class A {\n" 2214 "public: // public comment\n" 2215 " // comment about a\n" 2216 " int a;\n" 2217 "};", 2218 getLLVMStyleWithColumns(40))); 2219 EXPECT_EQ("class A {\n" 2220 "public: // public comment 1\n" 2221 " // public comment 2\n" 2222 " // comment 1 about a\n" 2223 " // comment 2 about a\n" 2224 " int a;\n" 2225 "};", 2226 format("class A {\n" 2227 "public: // public comment 1\n" 2228 " // public comment 2\n" 2229 " // comment 1 about a\n" 2230 " // comment 2 about a\n" 2231 " int a;\n" 2232 "};", 2233 getLLVMStyleWithColumns(40))); 2234 EXPECT_EQ("int f(int n) { // comment line 1 on f\n" 2235 " // comment line 2 on f\n" 2236 " // comment line 1 before return\n" 2237 " // comment line 2 before return\n" 2238 " return n; // comment line 1 on return\n" 2239 " // comment line 2 on return\n" 2240 " // comment line 1 after return\n" 2241 "}", 2242 format("int f(int n) { // comment line 1 on f\n" 2243 " // comment line 2 on f\n" 2244 " // comment line 1 before return\n" 2245 " // comment line 2 before return\n" 2246 " return n; // comment line 1 on return\n" 2247 " // comment line 2 on return\n" 2248 " // comment line 1 after return\n" 2249 "}", 2250 getLLVMStyleWithColumns(40))); 2251 EXPECT_EQ("int f(int n) {\n" 2252 " switch (n) { // comment line 1 on switch\n" 2253 " // comment line 2 on switch\n" 2254 " // comment line 1 before case 1\n" 2255 " // comment line 2 before case 1\n" 2256 " case 1: // comment line 1 on case 1\n" 2257 " // comment line 2 on case 1\n" 2258 " // comment line 1 before return 1\n" 2259 " // comment line 2 before return 1\n" 2260 " return 1; // comment line 1 on return 1\n" 2261 " // comment line 2 on return 1\n" 2262 " // comment line 1 before default\n" 2263 " // comment line 2 before default\n" 2264 " default: // comment line 1 on default\n" 2265 " // comment line 2 on default\n" 2266 " // comment line 1 before return 2\n" 2267 " return 2 * f(n - 1); // comment line 1 on return 2\n" 2268 " // comment line 2 on return 2\n" 2269 " // comment line 1 after return\n" 2270 " // comment line 2 after return\n" 2271 " }\n" 2272 "}", 2273 format("int f(int n) {\n" 2274 " switch (n) { // comment line 1 on switch\n" 2275 " // comment line 2 on switch\n" 2276 " // comment line 1 before case 1\n" 2277 " // comment line 2 before case 1\n" 2278 " case 1: // comment line 1 on case 1\n" 2279 " // comment line 2 on case 1\n" 2280 " // comment line 1 before return 1\n" 2281 " // comment line 2 before return 1\n" 2282 " return 1; // comment line 1 on return 1\n" 2283 " // comment line 2 on return 1\n" 2284 " // comment line 1 before default\n" 2285 " // comment line 2 before default\n" 2286 " default: // comment line 1 on default\n" 2287 " // comment line 2 on default\n" 2288 " // comment line 1 before return 2\n" 2289 " return 2 * f(n - 1); // comment line 1 on return 2\n" 2290 " // comment line 2 on return 2\n" 2291 " // comment line 1 after return\n" 2292 " // comment line 2 after return\n" 2293 " }\n" 2294 "}", 2295 getLLVMStyleWithColumns(80))); 2296 2297 // If all the lines in a sequence of line comments are aligned with the next 2298 // token, the first line belongs to the previous token and the other lines 2299 // belong to the next token. 2300 EXPECT_EQ("int a; // line about a\n" 2301 "long b;", 2302 format("int a; // line about a\n" 2303 " long b;", 2304 getLLVMStyleWithColumns(80))); 2305 EXPECT_EQ("int a; // line about a\n" 2306 "// line about b\n" 2307 "long b;", 2308 format("int a; // line about a\n" 2309 " // line about b\n" 2310 " long b;", 2311 getLLVMStyleWithColumns(80))); 2312 EXPECT_EQ("int a; // line about a\n" 2313 "// line 1 about b\n" 2314 "// line 2 about b\n" 2315 "long b;", 2316 format("int a; // line about a\n" 2317 " // line 1 about b\n" 2318 " // line 2 about b\n" 2319 " long b;", 2320 getLLVMStyleWithColumns(80))); 2321 } 2322 2323 TEST_F(FormatTestComments, AlignsBlockCommentDecorations) { 2324 EXPECT_EQ("/*\n" 2325 " */", 2326 format("/*\n" 2327 "*/", getLLVMStyle())); 2328 EXPECT_EQ("/*\n" 2329 " */", 2330 format("/*\n" 2331 " */", getLLVMStyle())); 2332 EXPECT_EQ("/*\n" 2333 " */", 2334 format("/*\n" 2335 " */", getLLVMStyle())); 2336 2337 // Align a single line. 2338 EXPECT_EQ("/*\n" 2339 " * line */", 2340 format("/*\n" 2341 "* line */", 2342 getLLVMStyle())); 2343 EXPECT_EQ("/*\n" 2344 " * line */", 2345 format("/*\n" 2346 " * line */", 2347 getLLVMStyle())); 2348 EXPECT_EQ("/*\n" 2349 " * line */", 2350 format("/*\n" 2351 " * line */", 2352 getLLVMStyle())); 2353 EXPECT_EQ("/*\n" 2354 " * line */", 2355 format("/*\n" 2356 " * line */", 2357 getLLVMStyle())); 2358 EXPECT_EQ("/**\n" 2359 " * line */", 2360 format("/**\n" 2361 "* line */", 2362 getLLVMStyle())); 2363 EXPECT_EQ("/**\n" 2364 " * line */", 2365 format("/**\n" 2366 " * line */", 2367 getLLVMStyle())); 2368 EXPECT_EQ("/**\n" 2369 " * line */", 2370 format("/**\n" 2371 " * line */", 2372 getLLVMStyle())); 2373 EXPECT_EQ("/**\n" 2374 " * line */", 2375 format("/**\n" 2376 " * line */", 2377 getLLVMStyle())); 2378 EXPECT_EQ("/**\n" 2379 " * line */", 2380 format("/**\n" 2381 " * line */", 2382 getLLVMStyle())); 2383 2384 // Align the end '*/' after a line. 2385 EXPECT_EQ("/*\n" 2386 " * line\n" 2387 " */", 2388 format("/*\n" 2389 "* line\n" 2390 "*/", getLLVMStyle())); 2391 EXPECT_EQ("/*\n" 2392 " * line\n" 2393 " */", 2394 format("/*\n" 2395 " * line\n" 2396 " */", getLLVMStyle())); 2397 EXPECT_EQ("/*\n" 2398 " * line\n" 2399 " */", 2400 format("/*\n" 2401 " * line\n" 2402 " */", getLLVMStyle())); 2403 2404 // Align two lines. 2405 EXPECT_EQ("/* line 1\n" 2406 " * line 2 */", 2407 format("/* line 1\n" 2408 " * line 2 */", 2409 getLLVMStyle())); 2410 EXPECT_EQ("/* line 1\n" 2411 " * line 2 */", 2412 format("/* line 1\n" 2413 "* line 2 */", 2414 getLLVMStyle())); 2415 EXPECT_EQ("/* line 1\n" 2416 " * line 2 */", 2417 format("/* line 1\n" 2418 " * line 2 */", 2419 getLLVMStyle())); 2420 EXPECT_EQ("/* line 1\n" 2421 " * line 2 */", 2422 format("/* line 1\n" 2423 " * line 2 */", 2424 getLLVMStyle())); 2425 EXPECT_EQ("/* line 1\n" 2426 " * line 2 */", 2427 format("/* line 1\n" 2428 " * line 2 */", 2429 getLLVMStyle())); 2430 EXPECT_EQ("int i; /* line 1\n" 2431 " * line 2 */", 2432 format("int i; /* line 1\n" 2433 "* line 2 */", 2434 getLLVMStyle())); 2435 EXPECT_EQ("int i; /* line 1\n" 2436 " * line 2 */", 2437 format("int i; /* line 1\n" 2438 " * line 2 */", 2439 getLLVMStyle())); 2440 EXPECT_EQ("int i; /* line 1\n" 2441 " * line 2 */", 2442 format("int i; /* line 1\n" 2443 " * line 2 */", 2444 getLLVMStyle())); 2445 2446 // Align several lines. 2447 EXPECT_EQ("/* line 1\n" 2448 " * line 2\n" 2449 " * line 3 */", 2450 format("/* line 1\n" 2451 " * line 2\n" 2452 "* line 3 */", 2453 getLLVMStyle())); 2454 EXPECT_EQ("/* line 1\n" 2455 " * line 2\n" 2456 " * line 3 */", 2457 format("/* line 1\n" 2458 " * line 2\n" 2459 "* line 3 */", 2460 getLLVMStyle())); 2461 EXPECT_EQ("/*\n" 2462 "** line 1\n" 2463 "** line 2\n" 2464 "*/", 2465 format("/*\n" 2466 "** line 1\n" 2467 " ** line 2\n" 2468 "*/", 2469 getLLVMStyle())); 2470 2471 // Align with different indent after the decorations. 2472 EXPECT_EQ("/*\n" 2473 " * line 1\n" 2474 " * line 2\n" 2475 " * line 3\n" 2476 " * line 4\n" 2477 " */", 2478 format("/*\n" 2479 "* line 1\n" 2480 " * line 2\n" 2481 " * line 3\n" 2482 "* line 4\n" 2483 "*/", getLLVMStyle())); 2484 2485 // Align empty or blank lines. 2486 EXPECT_EQ("/**\n" 2487 " *\n" 2488 " *\n" 2489 " *\n" 2490 " */", 2491 format("/**\n" 2492 "* \n" 2493 " * \n" 2494 " *\n" 2495 "*/", getLLVMStyle())); 2496 2497 // Align while breaking and reflowing. 2498 EXPECT_EQ("/*\n" 2499 " * long long long\n" 2500 " * long long\n" 2501 " *\n" 2502 " * long */", 2503 format("/*\n" 2504 " * long long long long\n" 2505 " * long\n" 2506 " *\n" 2507 "* long */", 2508 getLLVMStyleWithColumns(20))); 2509 } 2510 } // end namespace 2511 } // end namespace format 2512 } // end namespace clang 2513