1 //===- unittest/Format/FormatTestComments.cpp - Formatting unit tests -----===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "clang/Format/Format.h" 10 11 #include "../Tooling/ReplacementTest.h" 12 #include "FormatTestUtils.h" 13 14 #include "llvm/Support/Debug.h" 15 #include "llvm/Support/MemoryBuffer.h" 16 #include "gtest/gtest.h" 17 18 #define DEBUG_TYPE "format-test" 19 20 using clang::tooling::ReplacementTest; 21 22 namespace clang { 23 namespace format { 24 namespace { 25 26 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); } 27 28 class FormatTestComments : public ::testing::Test { 29 protected: 30 enum StatusCheck { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck }; 31 32 std::string format(llvm::StringRef Code, 33 const FormatStyle &Style = getLLVMStyle(), 34 StatusCheck CheckComplete = SC_ExpectComplete) { 35 LLVM_DEBUG(llvm::errs() << "---\n"); 36 LLVM_DEBUG(llvm::errs() << Code << "\n\n"); 37 std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size())); 38 FormattingAttemptStatus Status; 39 tooling::Replacements Replaces = 40 reformat(Style, Code, Ranges, "<stdin>", &Status); 41 if (CheckComplete != SC_DoNotCheck) { 42 bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete; 43 EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete) 44 << Code << "\n\n"; 45 } 46 ReplacementCount = Replaces.size(); 47 auto Result = applyAllReplacements(Code, Replaces); 48 EXPECT_TRUE(static_cast<bool>(Result)); 49 LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n"); 50 return *Result; 51 } 52 53 FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { 54 FormatStyle Style = getLLVMStyle(); 55 Style.ColumnLimit = ColumnLimit; 56 return Style; 57 } 58 59 FormatStyle getTextProtoStyleWithColumns(unsigned ColumnLimit) { 60 FormatStyle Style = getGoogleStyle(FormatStyle::FormatStyle::LK_TextProto); 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(Code, Style)) << "Expected code is not stable"; 68 EXPECT_EQ(Code.str(), format(test::messUp(Code), Style)); 69 } 70 71 void verifyGoogleFormat(llvm::StringRef Code) { 72 verifyFormat(Code, getGoogleStyle()); 73 } 74 75 /// \brief Verify that clang-format does not crash on the given input. 76 void verifyNoCrash(llvm::StringRef Code, 77 const FormatStyle &Style = getLLVMStyle()) { 78 format(Code, Style, SC_DoNotCheck); 79 } 80 81 int ReplacementCount; 82 }; 83 84 //===----------------------------------------------------------------------===// 85 // Tests for comments. 86 //===----------------------------------------------------------------------===// 87 88 TEST_F(FormatTestComments, UnderstandsSingleLineComments) { 89 verifyFormat("//* */"); 90 verifyFormat("// line 1\n" 91 "// line 2\n" 92 "void f() {}\n"); 93 94 EXPECT_EQ("// comment\n", format("//comment\n")); 95 EXPECT_EQ("// #comment\n", format("//#comment\n")); 96 97 EXPECT_EQ("// comment\n" 98 "// clang-format on\n", 99 format("//comment\n" 100 "// clang-format on\n")); 101 102 verifyFormat("void f() {\n" 103 " // Doesn't do anything\n" 104 "}"); 105 verifyFormat("SomeObject\n" 106 " // Calling someFunction on SomeObject\n" 107 " .someFunction();"); 108 verifyFormat("auto result = SomeObject\n" 109 " // Calling someFunction on SomeObject\n" 110 " .someFunction();"); 111 verifyFormat("void f(int i, // some comment (probably for i)\n" 112 " int j, // some comment (probably for j)\n" 113 " int k); // some comment (probably for k)"); 114 verifyFormat("void f(int i,\n" 115 " // some comment (probably for j)\n" 116 " int j,\n" 117 " // some comment (probably for k)\n" 118 " int k);"); 119 120 verifyFormat("int i // This is a fancy variable\n" 121 " = 5; // with nicely aligned comment."); 122 123 verifyFormat("// Leading comment.\n" 124 "int a; // Trailing comment."); 125 verifyFormat("int a; // Trailing comment\n" 126 " // on 2\n" 127 " // or 3 lines.\n" 128 "int b;"); 129 verifyFormat("int a; // Trailing comment\n" 130 "\n" 131 "// Leading comment.\n" 132 "int b;"); 133 verifyFormat("int a; // Comment.\n" 134 " // More details.\n" 135 "int bbbb; // Another comment."); 136 verifyFormat( 137 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; // comment\n" 138 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // comment\n" 139 "int cccccccccccccccccccccccccccccc; // comment\n" 140 "int ddd; // looooooooooooooooooooooooong comment\n" 141 "int aaaaaaaaaaaaaaaaaaaaaaa; // comment\n" 142 "int bbbbbbbbbbbbbbbbbbbbb; // comment\n" 143 "int ccccccccccccccccccc; // comment"); 144 145 verifyFormat("#include \"a\" // comment\n" 146 "#include \"a/b/c\" // comment"); 147 verifyFormat("#include <a> // comment\n" 148 "#include <a/b/c> // comment"); 149 EXPECT_EQ("#include \"a\" // comment\n" 150 "#include \"a/b/c\" // comment", 151 format("#include \\\n" 152 " \"a\" // comment\n" 153 "#include \"a/b/c\" // comment")); 154 155 verifyFormat("enum E {\n" 156 " // comment\n" 157 " VAL_A, // comment\n" 158 " VAL_B\n" 159 "};"); 160 161 EXPECT_EQ("enum A {\n" 162 " // line a\n" 163 " a,\n" 164 " b, // line b\n" 165 "\n" 166 " // line c\n" 167 " c\n" 168 "};", 169 format("enum A {\n" 170 " // line a\n" 171 " a,\n" 172 " b, // line b\n" 173 "\n" 174 " // line c\n" 175 " c\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 "};", 191 format("enum A {\n" 192 " a, // line 1\n" 193 " // line 2\n" 194 "};", 195 getLLVMStyleWithColumns(20))); 196 EXPECT_EQ("enum A {\n" 197 " a, // line 1\n" 198 " // line 2\n" 199 " b\n" 200 "};", 201 format("enum A {\n" 202 " a, // line 1\n" 203 " // line 2\n" 204 " b\n" 205 "};", 206 getLLVMStyleWithColumns(20))); 207 EXPECT_EQ("enum A {\n" 208 " a, // line 1\n" 209 " // line 2\n" 210 " b\n" 211 "};", 212 format("enum A {\n" 213 " a, // line 1\n" 214 " // line 2\n" 215 " b\n" 216 "};", 217 getLLVMStyleWithColumns(20))); 218 verifyFormat( 219 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 220 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // Trailing comment"); 221 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 222 " // Comment inside a statement.\n" 223 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); 224 verifyFormat("SomeFunction(a,\n" 225 " // comment\n" 226 " b + x);"); 227 verifyFormat("SomeFunction(a, a,\n" 228 " // comment\n" 229 " b + x);"); 230 verifyFormat( 231 "bool aaaaaaaaaaaaa = // comment\n" 232 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 233 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 234 235 verifyFormat("int aaaa; // aaaaa\n" 236 "int aa; // aaaaaaa", 237 getLLVMStyleWithColumns(20)); 238 239 EXPECT_EQ("void f() { // This does something ..\n" 240 "}\n" 241 "int a; // This is unrelated", 242 format("void f() { // This does something ..\n" 243 " }\n" 244 "int a; // This is unrelated")); 245 EXPECT_EQ("class C {\n" 246 " void f() { // This does something ..\n" 247 " } // awesome..\n" 248 "\n" 249 " int a; // This is unrelated\n" 250 "};", 251 format("class C{void f() { // This does something ..\n" 252 " } // awesome..\n" 253 " \n" 254 "int a; // This is unrelated\n" 255 "};")); 256 257 EXPECT_EQ("int i; // single line trailing comment", 258 format("int i;\\\n// single line trailing comment")); 259 260 verifyGoogleFormat("int a; // Trailing comment."); 261 262 verifyFormat("someFunction(anotherFunction( // Force break.\n" 263 " parameter));"); 264 265 verifyGoogleFormat("#endif // HEADER_GUARD"); 266 267 verifyFormat("const char *test[] = {\n" 268 " // A\n" 269 " \"aaaa\",\n" 270 " // B\n" 271 " \"aaaaa\"};"); 272 verifyGoogleFormat( 273 "aaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 274 " aaaaaaaaaaaaaaaaaaaaaa); // 81_cols_with_this_comment"); 275 EXPECT_EQ("D(a, {\n" 276 " // test\n" 277 " int a;\n" 278 "});", 279 format("D(a, {\n" 280 "// test\n" 281 "int a;\n" 282 "});")); 283 284 EXPECT_EQ("lineWith(); // comment\n" 285 "// at start\n" 286 "otherLine();", 287 format("lineWith(); // comment\n" 288 "// at start\n" 289 "otherLine();")); 290 EXPECT_EQ("lineWith(); // comment\n" 291 "/*\n" 292 " * at start */\n" 293 "otherLine();", 294 format("lineWith(); // comment\n" 295 "/*\n" 296 " * at start */\n" 297 "otherLine();")); 298 EXPECT_EQ("lineWith(); // comment\n" 299 " // at start\n" 300 "otherLine();", 301 format("lineWith(); // comment\n" 302 " // at start\n" 303 "otherLine();")); 304 305 EXPECT_EQ("lineWith(); // comment\n" 306 "// at start\n" 307 "otherLine(); // comment", 308 format("lineWith(); // comment\n" 309 "// at start\n" 310 "otherLine(); // comment")); 311 EXPECT_EQ("lineWith();\n" 312 "// at start\n" 313 "otherLine(); // comment", 314 format("lineWith();\n" 315 " // at start\n" 316 "otherLine(); // comment")); 317 EXPECT_EQ("// first\n" 318 "// at start\n" 319 "otherLine(); // comment", 320 format("// first\n" 321 " // at start\n" 322 "otherLine(); // comment")); 323 EXPECT_EQ("f();\n" 324 "// first\n" 325 "// at start\n" 326 "otherLine(); // comment", 327 format("f();\n" 328 "// first\n" 329 " // at start\n" 330 "otherLine(); // comment")); 331 verifyFormat("f(); // comment\n" 332 "// first\n" 333 "// at start\n" 334 "otherLine();"); 335 EXPECT_EQ("f(); // comment\n" 336 "// first\n" 337 "// at start\n" 338 "otherLine();", 339 format("f(); // comment\n" 340 "// first\n" 341 " // at start\n" 342 "otherLine();")); 343 EXPECT_EQ("f(); // comment\n" 344 " // first\n" 345 "// at start\n" 346 "otherLine();", 347 format("f(); // comment\n" 348 " // first\n" 349 "// at start\n" 350 "otherLine();")); 351 EXPECT_EQ("void f() {\n" 352 " lineWith(); // comment\n" 353 " // at start\n" 354 "}", 355 format("void f() {\n" 356 " lineWith(); // comment\n" 357 " // at start\n" 358 "}")); 359 EXPECT_EQ("int xy; // a\n" 360 "int z; // b", 361 format("int xy; // a\n" 362 "int z; //b")); 363 EXPECT_EQ("int xy; // a\n" 364 "int z; // bb", 365 format("int xy; // a\n" 366 "int z; //bb", 367 getLLVMStyleWithColumns(12))); 368 369 verifyFormat("#define A \\\n" 370 " int i; /* iiiiiiiiiiiiiiiiiiiii */ \\\n" 371 " int jjjjjjjjjjjjjjjjjjjjjjjj; /* */", 372 getLLVMStyleWithColumns(60)); 373 verifyFormat( 374 "#define A \\\n" 375 " int i; /* iiiiiiiiiiiiiiiiiiiii */ \\\n" 376 " int jjjjjjjjjjjjjjjjjjjjjjjj; /* */", 377 getLLVMStyleWithColumns(61)); 378 379 verifyFormat("if ( // This is some comment\n" 380 " x + 3) {\n" 381 "}"); 382 EXPECT_EQ("if ( // This is some comment\n" 383 " // spanning two lines\n" 384 " x + 3) {\n" 385 "}", 386 format("if( // This is some comment\n" 387 " // spanning two lines\n" 388 " x + 3) {\n" 389 "}")); 390 391 verifyNoCrash("/\\\n/"); 392 verifyNoCrash("/\\\n* */"); 393 // The 0-character somehow makes the lexer return a proper comment. 394 verifyNoCrash(StringRef("/*\\\0\n/", 6)); 395 } 396 397 TEST_F(FormatTestComments, KeepsParameterWithTrailingCommentsOnTheirOwnLine) { 398 EXPECT_EQ("SomeFunction(a,\n" 399 " b, // comment\n" 400 " c);", 401 format("SomeFunction(a,\n" 402 " b, // comment\n" 403 " c);")); 404 EXPECT_EQ("SomeFunction(a, b,\n" 405 " // comment\n" 406 " c);", 407 format("SomeFunction(a,\n" 408 " b,\n" 409 " // comment\n" 410 " c);")); 411 EXPECT_EQ("SomeFunction(a, b, // comment (unclear relation)\n" 412 " c);", 413 format("SomeFunction(a, b, // comment (unclear relation)\n" 414 " c);")); 415 EXPECT_EQ("SomeFunction(a, // comment\n" 416 " b,\n" 417 " c); // comment", 418 format("SomeFunction(a, // comment\n" 419 " b,\n" 420 " c); // comment")); 421 EXPECT_EQ("aaaaaaaaaa(aaaa(aaaa,\n" 422 " aaaa), //\n" 423 " aaaa, bbbbb);", 424 format("aaaaaaaaaa(aaaa(aaaa,\n" 425 "aaaa), //\n" 426 "aaaa, bbbbb);")); 427 } 428 429 TEST_F(FormatTestComments, RemovesTrailingWhitespaceOfComments) { 430 EXPECT_EQ("// comment", format("// comment ")); 431 EXPECT_EQ("int aaaaaaa, bbbbbbb; // comment", 432 format("int aaaaaaa, bbbbbbb; // comment ", 433 getLLVMStyleWithColumns(33))); 434 EXPECT_EQ("// comment\\\n", format("// comment\\\n \t \v \f ")); 435 EXPECT_EQ("// comment \\\n", format("// comment \\\n \t \v \f ")); 436 } 437 438 TEST_F(FormatTestComments, UnderstandsBlockComments) { 439 verifyFormat("f(/*noSpaceAfterParameterNamingComment=*/true);"); 440 verifyFormat("void f() { g(/*aaa=*/x, /*bbb=*/!y, /*c=*/::c); }"); 441 EXPECT_EQ("f(aaaaaaaaaaaaaaaaaaaaaaaaa, /* Trailing comment for aa... */\n" 442 " bbbbbbbbbbbbbbbbbbbbbbbbb);", 443 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \\\n" 444 "/* Trailing comment for aa... */\n" 445 " bbbbbbbbbbbbbbbbbbbbbbbbb);")); 446 EXPECT_EQ( 447 "f(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" 448 " /* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);", 449 format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \n" 450 "/* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);")); 451 EXPECT_EQ( 452 "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 453 " aaaaaaaaaaaaaaaaaa,\n" 454 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n" 455 "}", 456 format("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 457 " aaaaaaaaaaaaaaaaaa ,\n" 458 " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n" 459 "}")); 460 verifyFormat("f(/* aaaaaaaaaaaaaaaaaa = */\n" 461 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 462 463 FormatStyle NoBinPacking = getLLVMStyle(); 464 NoBinPacking.BinPackParameters = false; 465 verifyFormat("aaaaaaaa(/* parameter 1 */ aaaaaa,\n" 466 " /* parameter 2 */ aaaaaa,\n" 467 " /* parameter 3 */ aaaaaa,\n" 468 " /* parameter 4 */ aaaaaa);", 469 NoBinPacking); 470 471 // Aligning block comments in macros. 472 verifyGoogleFormat("#define A \\\n" 473 " int i; /*a*/ \\\n" 474 " int jjj; /*b*/"); 475 } 476 477 TEST_F(FormatTestComments, AlignsBlockComments) { 478 EXPECT_EQ("/*\n" 479 " * Really multi-line\n" 480 " * comment.\n" 481 " */\n" 482 "void f() {}", 483 format(" /*\n" 484 " * Really multi-line\n" 485 " * comment.\n" 486 " */\n" 487 " void f() {}")); 488 EXPECT_EQ("class C {\n" 489 " /*\n" 490 " * Another multi-line\n" 491 " * comment.\n" 492 " */\n" 493 " void f() {}\n" 494 "};", 495 format("class C {\n" 496 "/*\n" 497 " * Another multi-line\n" 498 " * comment.\n" 499 " */\n" 500 "void f() {}\n" 501 "};")); 502 EXPECT_EQ("/*\n" 503 " 1. This is a comment with non-trivial formatting.\n" 504 " 1.1. We have to indent/outdent all lines equally\n" 505 " 1.1.1. to keep the formatting.\n" 506 " */", 507 format(" /*\n" 508 " 1. This is a comment with non-trivial formatting.\n" 509 " 1.1. We have to indent/outdent all lines equally\n" 510 " 1.1.1. to keep the formatting.\n" 511 " */")); 512 EXPECT_EQ("/*\n" 513 "Don't try to outdent if there's not enough indentation.\n" 514 "*/", 515 format(" /*\n" 516 " Don't try to outdent if there's not enough indentation.\n" 517 " */")); 518 519 EXPECT_EQ("int i; /* Comment with empty...\n" 520 " *\n" 521 " * line. */", 522 format("int i; /* Comment with empty...\n" 523 " *\n" 524 " * line. */")); 525 EXPECT_EQ("int foobar = 0; /* comment */\n" 526 "int bar = 0; /* multiline\n" 527 " comment 1 */\n" 528 "int baz = 0; /* multiline\n" 529 " comment 2 */\n" 530 "int bzz = 0; /* multiline\n" 531 " comment 3 */", 532 format("int foobar = 0; /* comment */\n" 533 "int bar = 0; /* multiline\n" 534 " comment 1 */\n" 535 "int baz = 0; /* multiline\n" 536 " comment 2 */\n" 537 "int bzz = 0; /* multiline\n" 538 " comment 3 */")); 539 EXPECT_EQ("int foobar = 0; /* comment */\n" 540 "int bar = 0; /* multiline\n" 541 " comment */\n" 542 "int baz = 0; /* multiline\n" 543 "comment */", 544 format("int foobar = 0; /* comment */\n" 545 "int bar = 0; /* multiline\n" 546 "comment */\n" 547 "int baz = 0; /* multiline\n" 548 "comment */")); 549 } 550 551 TEST_F(FormatTestComments, CommentReflowingCanBeTurnedOff) { 552 FormatStyle Style = getLLVMStyleWithColumns(20); 553 Style.ReflowComments = false; 554 verifyFormat("// aaaaaaaaa aaaaaaaaaa aaaaaaaaaa", Style); 555 verifyFormat("/* aaaaaaaaa aaaaaaaaaa aaaaaaaaaa */", Style); 556 } 557 558 TEST_F(FormatTestComments, CorrectlyHandlesLengthOfBlockComments) { 559 EXPECT_EQ("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 560 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */", 561 format("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" 562 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */")); 563 EXPECT_EQ( 564 "void ffffffffffff(\n" 565 " int aaaaaaaa, int bbbbbbbb,\n" 566 " int cccccccccccc) { /*\n" 567 " aaaaaaaaaa\n" 568 " aaaaaaaaaaaaa\n" 569 " bbbbbbbbbbbbbb\n" 570 " bbbbbbbbbb\n" 571 " */\n" 572 "}", 573 format("void ffffffffffff(int aaaaaaaa, int bbbbbbbb, int cccccccccccc)\n" 574 "{ /*\n" 575 " aaaaaaaaaa aaaaaaaaaaaaa\n" 576 " bbbbbbbbbbbbbb bbbbbbbbbb\n" 577 " */\n" 578 "}", 579 getLLVMStyleWithColumns(40))); 580 } 581 582 TEST_F(FormatTestComments, DontBreakNonTrailingBlockComments) { 583 EXPECT_EQ("void ffffffffff(\n" 584 " int aaaaa /* test */);", 585 format("void ffffffffff(int aaaaa /* test */);", 586 getLLVMStyleWithColumns(35))); 587 } 588 589 TEST_F(FormatTestComments, SplitsLongCxxComments) { 590 EXPECT_EQ("// A comment that\n" 591 "// doesn't fit on\n" 592 "// one line", 593 format("// A comment that doesn't fit on one line", 594 getLLVMStyleWithColumns(20))); 595 EXPECT_EQ("/// A comment that\n" 596 "/// doesn't fit on\n" 597 "/// one line", 598 format("/// A comment that doesn't fit on one line", 599 getLLVMStyleWithColumns(20))); 600 EXPECT_EQ("//! A comment that\n" 601 "//! doesn't fit on\n" 602 "//! one line", 603 format("//! A comment that doesn't fit on one line", 604 getLLVMStyleWithColumns(20))); 605 EXPECT_EQ("// a b c d\n" 606 "// e f g\n" 607 "// h i j k", 608 format("// a b c d e f g h i j k", getLLVMStyleWithColumns(10))); 609 EXPECT_EQ( 610 "// a b c d\n" 611 "// e f g\n" 612 "// h i j k", 613 format("\\\n// a b c d e f g h i j k", getLLVMStyleWithColumns(10))); 614 EXPECT_EQ("if (true) // A comment that\n" 615 " // doesn't fit on\n" 616 " // one line", 617 format("if (true) // A comment that doesn't fit on one line ", 618 getLLVMStyleWithColumns(30))); 619 EXPECT_EQ("// Don't_touch_leading_whitespace", 620 format("// Don't_touch_leading_whitespace", 621 getLLVMStyleWithColumns(20))); 622 EXPECT_EQ("// Add leading\n" 623 "// whitespace", 624 format("//Add leading whitespace", getLLVMStyleWithColumns(20))); 625 EXPECT_EQ("/// Add leading\n" 626 "/// whitespace", 627 format("///Add leading whitespace", getLLVMStyleWithColumns(20))); 628 EXPECT_EQ("//! Add leading\n" 629 "//! whitespace", 630 format("//!Add leading whitespace", getLLVMStyleWithColumns(20))); 631 EXPECT_EQ("// whitespace", format("//whitespace", getLLVMStyle())); 632 EXPECT_EQ("// Even if it makes the line exceed the column\n" 633 "// limit", 634 format("//Even if it makes the line exceed the column limit", 635 getLLVMStyleWithColumns(51))); 636 EXPECT_EQ("//--But not here", format("//--But not here", getLLVMStyle())); 637 EXPECT_EQ("/// line 1\n" 638 "// add leading whitespace", 639 format("/// line 1\n" 640 "//add leading whitespace", 641 getLLVMStyleWithColumns(30))); 642 EXPECT_EQ("/// line 1\n" 643 "/// line 2\n" 644 "//! line 3\n" 645 "//! line 4\n" 646 "//! line 5\n" 647 "// line 6\n" 648 "// line 7", 649 format("///line 1\n" 650 "///line 2\n" 651 "//! line 3\n" 652 "//!line 4\n" 653 "//!line 5\n" 654 "// line 6\n" 655 "//line 7", 656 getLLVMStyleWithColumns(20))); 657 658 EXPECT_EQ("// aa bb cc dd", 659 format("// aa bb cc dd ", 660 getLLVMStyleWithColumns(15))); 661 662 EXPECT_EQ("// A comment before\n" 663 "// a macro\n" 664 "// definition\n" 665 "#define a b", 666 format("// A comment before a macro definition\n" 667 "#define a b", 668 getLLVMStyleWithColumns(20))); 669 EXPECT_EQ("void ffffff(\n" 670 " int aaaaaaaaa, // wwww\n" 671 " int bbbbbbbbbb, // xxxxxxx\n" 672 " // yyyyyyyyyy\n" 673 " int c, int d, int e) {}", 674 format("void ffffff(\n" 675 " int aaaaaaaaa, // wwww\n" 676 " int bbbbbbbbbb, // xxxxxxx yyyyyyyyyy\n" 677 " int c, int d, int e) {}", 678 getLLVMStyleWithColumns(40))); 679 EXPECT_EQ("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 680 format("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 681 getLLVMStyleWithColumns(20))); 682 EXPECT_EQ( 683 "#define XXX // a b c d\n" 684 " // e f g h", 685 format("#define XXX // a b c d e f g h", getLLVMStyleWithColumns(22))); 686 EXPECT_EQ( 687 "#define XXX // q w e r\n" 688 " // t y u i", 689 format("#define XXX //q w e r t y u i", getLLVMStyleWithColumns(22))); 690 EXPECT_EQ("{\n" 691 " //\n" 692 " //\\\n" 693 " // long 1 2 3 4 5\n" 694 "}", 695 format("{\n" 696 " //\n" 697 " //\\\n" 698 " // long 1 2 3 4 5\n" 699 "}", 700 getLLVMStyleWithColumns(20))); 701 EXPECT_EQ("{\n" 702 " //\n" 703 " //\\\n" 704 " // long 1 2 3 4 5\n" 705 " // 6\n" 706 "}", 707 format("{\n" 708 " //\n" 709 " //\\\n" 710 " // long 1 2 3 4 5 6\n" 711 "}", 712 getLLVMStyleWithColumns(20))); 713 714 EXPECT_EQ("//: A comment that\n" 715 "//: doesn't fit on\n" 716 "//: one line", 717 format("//: A comment that doesn't fit on one line", 718 getLLVMStyleWithColumns(20))); 719 } 720 721 TEST_F(FormatTestComments, PreservesHangingIndentInCxxComments) { 722 EXPECT_EQ("// A comment\n" 723 "// that doesn't\n" 724 "// fit on one\n" 725 "// line", 726 format("// A comment that doesn't fit on one line", 727 getLLVMStyleWithColumns(20))); 728 EXPECT_EQ("/// A comment\n" 729 "/// that doesn't\n" 730 "/// fit on one\n" 731 "/// line", 732 format("/// A comment that doesn't fit on one line", 733 getLLVMStyleWithColumns(20))); 734 } 735 736 TEST_F(FormatTestComments, DontSplitLineCommentsWithEscapedNewlines) { 737 EXPECT_EQ("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 738 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 739 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", 740 format("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 741 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" 742 "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")); 743 EXPECT_EQ("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 744 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 745 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 746 format("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 747 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 748 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 749 getLLVMStyleWithColumns(50))); 750 // FIXME: One day we might want to implement adjustment of leading whitespace 751 // of the consecutive lines in this kind of comment: 752 EXPECT_EQ("double\n" 753 " a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 754 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 755 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 756 format("double a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 757 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" 758 " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 759 getLLVMStyleWithColumns(49))); 760 } 761 762 TEST_F(FormatTestComments, DontIntroduceMultilineComments) { 763 // Avoid introducing a multiline comment by breaking after `\`. 764 for (int ColumnLimit = 15; ColumnLimit <= 17; ++ColumnLimit) { 765 EXPECT_EQ( 766 "// aaaaaaaaaa\n" 767 "// \\ bb", 768 format("// aaaaaaaaaa \\ bb", getLLVMStyleWithColumns(ColumnLimit))); 769 EXPECT_EQ( 770 "// aaaaaaaaa\n" 771 "// \\ bb", 772 format("// aaaaaaaaa \\ bb", getLLVMStyleWithColumns(ColumnLimit))); 773 EXPECT_EQ( 774 "// aaaaaaaaa\n" 775 "// \\ \\ bb", 776 format("// aaaaaaaaa \\ \\ bb", getLLVMStyleWithColumns(ColumnLimit))); 777 } 778 } 779 780 TEST_F(FormatTestComments, DontSplitLineCommentsWithPragmas) { 781 FormatStyle Pragmas = getLLVMStyleWithColumns(30); 782 Pragmas.CommentPragmas = "^ IWYU pragma:"; 783 EXPECT_EQ( 784 "// IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb", 785 format("// IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb", Pragmas)); 786 EXPECT_EQ( 787 "/* IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb */", 788 format("/* IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb */", Pragmas)); 789 } 790 791 TEST_F(FormatTestComments, PriorityOfCommentBreaking) { 792 EXPECT_EQ("if (xxx ==\n" 793 " yyy && // aaaaaaaaaaaa bbbbbbbbb\n" 794 " zzz)\n" 795 " q();", 796 format("if (xxx == yyy && // aaaaaaaaaaaa bbbbbbbbb\n" 797 " zzz) q();", 798 getLLVMStyleWithColumns(40))); 799 EXPECT_EQ("if (xxxxxxxxxx ==\n" 800 " yyy && // aaaaaa bbbbbbbb cccc\n" 801 " zzz)\n" 802 " q();", 803 format("if (xxxxxxxxxx == yyy && // aaaaaa bbbbbbbb cccc\n" 804 " zzz) q();", 805 getLLVMStyleWithColumns(40))); 806 EXPECT_EQ("if (xxxxxxxxxx &&\n" 807 " yyy || // aaaaaa bbbbbbbb cccc\n" 808 " zzz)\n" 809 " q();", 810 format("if (xxxxxxxxxx && yyy || // aaaaaa bbbbbbbb cccc\n" 811 " zzz) q();", 812 getLLVMStyleWithColumns(40))); 813 EXPECT_EQ("fffffffff(\n" 814 " &xxx, // aaaaaaaaaaaa bbbbbbbbbbb\n" 815 " zzz);", 816 format("fffffffff(&xxx, // aaaaaaaaaaaa bbbbbbbbbbb\n" 817 " zzz);", 818 getLLVMStyleWithColumns(40))); 819 } 820 821 TEST_F(FormatTestComments, MultiLineCommentsInDefines) { 822 EXPECT_EQ("#define A(x) /* \\\n" 823 " a comment \\\n" 824 " inside */ \\\n" 825 " f();", 826 format("#define A(x) /* \\\n" 827 " a comment \\\n" 828 " inside */ \\\n" 829 " f();", 830 getLLVMStyleWithColumns(17))); 831 EXPECT_EQ("#define A( \\\n" 832 " x) /* \\\n" 833 " a comment \\\n" 834 " inside */ \\\n" 835 " f();", 836 format("#define A( \\\n" 837 " x) /* \\\n" 838 " a comment \\\n" 839 " inside */ \\\n" 840 " f();", 841 getLLVMStyleWithColumns(17))); 842 } 843 844 TEST_F(FormatTestComments, ParsesCommentsAdjacentToPPDirectives) { 845 EXPECT_EQ("namespace {}\n// Test\n#define A", 846 format("namespace {}\n // Test\n#define A")); 847 EXPECT_EQ("namespace {}\n/* Test */\n#define A", 848 format("namespace {}\n /* Test */\n#define A")); 849 EXPECT_EQ("namespace {}\n/* Test */ #define A", 850 format("namespace {}\n /* Test */ #define A")); 851 } 852 853 TEST_F(FormatTestComments, KeepsLevelOfCommentBeforePPDirective) { 854 // Keep the current level if the comment was originally not aligned with 855 // the preprocessor directive. 856 EXPECT_EQ("void f() {\n" 857 " int i;\n" 858 " /* comment */\n" 859 "#ifdef A\n" 860 " int j;\n" 861 "}", 862 format("void f() {\n" 863 " int i;\n" 864 " /* comment */\n" 865 "#ifdef A\n" 866 " int j;\n" 867 "}")); 868 869 EXPECT_EQ("void f() {\n" 870 " int i;\n" 871 " /* comment */\n" 872 "\n" 873 "#ifdef A\n" 874 " int j;\n" 875 "}", 876 format("void f() {\n" 877 " int i;\n" 878 " /* comment */\n" 879 "\n" 880 "#ifdef A\n" 881 " int j;\n" 882 "}")); 883 884 EXPECT_EQ("int f(int i) {\n" 885 " if (true) {\n" 886 " ++i;\n" 887 " }\n" 888 " // comment\n" 889 "#ifdef A\n" 890 " int j;\n" 891 "#endif\n" 892 "}", 893 format("int f(int i) {\n" 894 " if (true) {\n" 895 " ++i;\n" 896 " }\n" 897 " // comment\n" 898 "#ifdef A\n" 899 "int j;\n" 900 "#endif\n" 901 "}")); 902 903 EXPECT_EQ("int f(int i) {\n" 904 " if (true) {\n" 905 " i++;\n" 906 " } else {\n" 907 " // comment in else\n" 908 "#ifdef A\n" 909 " j++;\n" 910 "#endif\n" 911 " }\n" 912 "}", 913 format("int f(int i) {\n" 914 " if (true) {\n" 915 " i++;\n" 916 " } else {\n" 917 " // comment in else\n" 918 "#ifdef A\n" 919 " j++;\n" 920 "#endif\n" 921 " }\n" 922 "}")); 923 924 EXPECT_EQ("int f(int i) {\n" 925 " if (true) {\n" 926 " i++;\n" 927 " } else {\n" 928 " /* comment in else */\n" 929 "#ifdef A\n" 930 " j++;\n" 931 "#endif\n" 932 " }\n" 933 "}", 934 format("int f(int i) {\n" 935 " if (true) {\n" 936 " i++;\n" 937 " } else {\n" 938 " /* comment in else */\n" 939 "#ifdef A\n" 940 " j++;\n" 941 "#endif\n" 942 " }\n" 943 "}")); 944 945 // Keep the current level if there is an empty line between the comment and 946 // the preprocessor directive. 947 EXPECT_EQ("void f() {\n" 948 " int i;\n" 949 " /* comment */\n" 950 "\n" 951 "#ifdef A\n" 952 " int j;\n" 953 "}", 954 format("void f() {\n" 955 " int i;\n" 956 "/* comment */\n" 957 "\n" 958 "#ifdef A\n" 959 " int j;\n" 960 "}")); 961 962 EXPECT_EQ("void f() {\n" 963 " int i;\n" 964 " return i;\n" 965 "}\n" 966 "// comment\n" 967 "\n" 968 "#ifdef A\n" 969 "int i;\n" 970 "#endif // A", 971 format("void f() {\n" 972 " int i;\n" 973 " return i;\n" 974 "}\n" 975 "// comment\n" 976 "\n" 977 "#ifdef A\n" 978 "int i;\n" 979 "#endif // A")); 980 981 EXPECT_EQ("int f(int i) {\n" 982 " if (true) {\n" 983 " ++i;\n" 984 " }\n" 985 " // comment\n" 986 "\n" 987 "#ifdef A\n" 988 " int j;\n" 989 "#endif\n" 990 "}", 991 format("int f(int i) {\n" 992 " if (true) {\n" 993 " ++i;\n" 994 " }\n" 995 " // comment\n" 996 "\n" 997 "#ifdef A\n" 998 " int j;\n" 999 "#endif\n" 1000 "}")); 1001 1002 EXPECT_EQ("int f(int i) {\n" 1003 " if (true) {\n" 1004 " i++;\n" 1005 " } else {\n" 1006 " // comment in else\n" 1007 "\n" 1008 "#ifdef A\n" 1009 " j++;\n" 1010 "#endif\n" 1011 " }\n" 1012 "}", 1013 format("int f(int i) {\n" 1014 " if (true) {\n" 1015 " i++;\n" 1016 " } else {\n" 1017 "// comment in else\n" 1018 "\n" 1019 "#ifdef A\n" 1020 " j++;\n" 1021 "#endif\n" 1022 " }\n" 1023 "}")); 1024 1025 EXPECT_EQ("int f(int i) {\n" 1026 " if (true) {\n" 1027 " i++;\n" 1028 " } else {\n" 1029 " /* comment in else */\n" 1030 "\n" 1031 "#ifdef A\n" 1032 " j++;\n" 1033 "#endif\n" 1034 " }\n" 1035 "}", 1036 format("int f(int i) {\n" 1037 " if (true) {\n" 1038 " i++;\n" 1039 " } else {\n" 1040 "/* comment in else */\n" 1041 "\n" 1042 "#ifdef A\n" 1043 " j++;\n" 1044 "#endif\n" 1045 " }\n" 1046 "}")); 1047 1048 // Align with the preprocessor directive if the comment was originally aligned 1049 // with the preprocessor directive and there is no newline between the comment 1050 // and the preprocessor directive. 1051 EXPECT_EQ("void f() {\n" 1052 " int i;\n" 1053 "/* comment */\n" 1054 "#ifdef A\n" 1055 " int j;\n" 1056 "}", 1057 format("void f() {\n" 1058 " int i;\n" 1059 "/* comment */\n" 1060 "#ifdef A\n" 1061 " int j;\n" 1062 "}")); 1063 1064 EXPECT_EQ("int f(int i) {\n" 1065 " if (true) {\n" 1066 " ++i;\n" 1067 " }\n" 1068 "// comment\n" 1069 "#ifdef A\n" 1070 " int j;\n" 1071 "#endif\n" 1072 "}", 1073 format("int f(int i) {\n" 1074 " if (true) {\n" 1075 " ++i;\n" 1076 " }\n" 1077 "// comment\n" 1078 "#ifdef A\n" 1079 " int j;\n" 1080 "#endif\n" 1081 "}")); 1082 1083 EXPECT_EQ("int f(int i) {\n" 1084 " if (true) {\n" 1085 " i++;\n" 1086 " } else {\n" 1087 "// comment in else\n" 1088 "#ifdef A\n" 1089 " j++;\n" 1090 "#endif\n" 1091 " }\n" 1092 "}", 1093 format("int f(int i) {\n" 1094 " if (true) {\n" 1095 " i++;\n" 1096 " } else {\n" 1097 " // comment in else\n" 1098 " #ifdef A\n" 1099 " j++;\n" 1100 "#endif\n" 1101 " }\n" 1102 "}")); 1103 1104 EXPECT_EQ("int f(int i) {\n" 1105 " if (true) {\n" 1106 " i++;\n" 1107 " } else {\n" 1108 "/* comment in else */\n" 1109 "#ifdef A\n" 1110 " j++;\n" 1111 "#endif\n" 1112 " }\n" 1113 "}", 1114 format("int f(int i) {\n" 1115 " if (true) {\n" 1116 " i++;\n" 1117 " } else {\n" 1118 " /* comment in else */\n" 1119 " #ifdef A\n" 1120 " j++;\n" 1121 "#endif\n" 1122 " }\n" 1123 "}")); 1124 } 1125 1126 TEST_F(FormatTestComments, SplitsLongLinesInComments) { 1127 // FIXME: Do we need to fix up the " */" at the end? 1128 // It doesn't look like any of our current logic triggers this. 1129 EXPECT_EQ("/* This is a long\n" 1130 " * comment that\n" 1131 " * doesn't fit on\n" 1132 " * one line. */", 1133 format("/* " 1134 "This is a long " 1135 "comment that " 1136 "doesn't " 1137 "fit on one line. */", 1138 getLLVMStyleWithColumns(20))); 1139 EXPECT_EQ( 1140 "/* a b c d\n" 1141 " * e f g\n" 1142 " * h i j k\n" 1143 " */", 1144 format("/* a b c d e f g h i j k */", getLLVMStyleWithColumns(10))); 1145 EXPECT_EQ( 1146 "/* a b c d\n" 1147 " * e f g\n" 1148 " * h i j k\n" 1149 " */", 1150 format("\\\n/* a b c d e f g h i j k */", getLLVMStyleWithColumns(10))); 1151 EXPECT_EQ("/*\n" 1152 "This is a long\n" 1153 "comment that doesn't\n" 1154 "fit on one line.\n" 1155 "*/", 1156 format("/*\n" 1157 "This is a long " 1158 "comment that doesn't " 1159 "fit on one line. \n" 1160 "*/", 1161 getLLVMStyleWithColumns(20))); 1162 EXPECT_EQ("/*\n" 1163 " * This is a long\n" 1164 " * comment that\n" 1165 " * doesn't fit on\n" 1166 " * one line.\n" 1167 " */", 1168 format("/* \n" 1169 " * This is a long " 1170 " comment that " 1171 " doesn't fit on " 1172 " one line. \n" 1173 " */", 1174 getLLVMStyleWithColumns(20))); 1175 EXPECT_EQ("/*\n" 1176 " * This_is_a_comment_with_words_that_dont_fit_on_one_line\n" 1177 " * so_it_should_be_broken\n" 1178 " * wherever_a_space_occurs\n" 1179 " */", 1180 format("/*\n" 1181 " * This_is_a_comment_with_words_that_dont_fit_on_one_line " 1182 " so_it_should_be_broken " 1183 " wherever_a_space_occurs \n" 1184 " */", 1185 getLLVMStyleWithColumns(20))); 1186 EXPECT_EQ("/*\n" 1187 " * This_comment_can_not_be_broken_into_lines\n" 1188 " */", 1189 format("/*\n" 1190 " * This_comment_can_not_be_broken_into_lines\n" 1191 " */", 1192 getLLVMStyleWithColumns(20))); 1193 EXPECT_EQ("{\n" 1194 " /*\n" 1195 " This is another\n" 1196 " long comment that\n" 1197 " doesn't fit on one\n" 1198 " line 1234567890\n" 1199 " */\n" 1200 "}", 1201 format("{\n" 1202 "/*\n" 1203 "This is another " 1204 " long comment that " 1205 " doesn't fit on one" 1206 " line 1234567890\n" 1207 "*/\n" 1208 "}", 1209 getLLVMStyleWithColumns(20))); 1210 EXPECT_EQ("{\n" 1211 " /*\n" 1212 " * This i s\n" 1213 " * another comment\n" 1214 " * t hat doesn' t\n" 1215 " * fit on one l i\n" 1216 " * n e\n" 1217 " */\n" 1218 "}", 1219 format("{\n" 1220 "/*\n" 1221 " * This i s" 1222 " another comment" 1223 " t hat doesn' t" 1224 " fit on one l i" 1225 " n e\n" 1226 " */\n" 1227 "}", 1228 getLLVMStyleWithColumns(20))); 1229 EXPECT_EQ("/*\n" 1230 " * This is a long\n" 1231 " * comment that\n" 1232 " * doesn't fit on\n" 1233 " * one line\n" 1234 " */", 1235 format(" /*\n" 1236 " * This is a long comment that doesn't fit on one line\n" 1237 " */", 1238 getLLVMStyleWithColumns(20))); 1239 EXPECT_EQ("{\n" 1240 " if (something) /* This is a\n" 1241 " long\n" 1242 " comment */\n" 1243 " ;\n" 1244 "}", 1245 format("{\n" 1246 " if (something) /* This is a long comment */\n" 1247 " ;\n" 1248 "}", 1249 getLLVMStyleWithColumns(30))); 1250 1251 EXPECT_EQ("/* A comment before\n" 1252 " * a macro\n" 1253 " * definition */\n" 1254 "#define a b", 1255 format("/* A comment before a macro definition */\n" 1256 "#define a b", 1257 getLLVMStyleWithColumns(20))); 1258 1259 EXPECT_EQ("/* some comment\n" 1260 " * a comment that\n" 1261 " * we break another\n" 1262 " * comment we have\n" 1263 " * to break a left\n" 1264 " * comment\n" 1265 " */", 1266 format(" /* some comment\n" 1267 " * a comment that we break\n" 1268 " * another comment we have to break\n" 1269 "* a left comment\n" 1270 " */", 1271 getLLVMStyleWithColumns(20))); 1272 1273 EXPECT_EQ("/**\n" 1274 " * multiline block\n" 1275 " * comment\n" 1276 " *\n" 1277 " */", 1278 format("/**\n" 1279 " * multiline block comment\n" 1280 " *\n" 1281 " */", 1282 getLLVMStyleWithColumns(20))); 1283 1284 // This reproduces a crashing bug where both adaptStartOfLine and 1285 // getCommentSplit were trying to wrap after the "/**". 1286 EXPECT_EQ("/** multilineblockcommentwithnowrapopportunity */", 1287 format("/** multilineblockcommentwithnowrapopportunity */", 1288 getLLVMStyleWithColumns(20))); 1289 1290 EXPECT_EQ("/*\n" 1291 "\n" 1292 "\n" 1293 " */\n", 1294 format(" /* \n" 1295 " \n" 1296 " \n" 1297 " */\n")); 1298 1299 EXPECT_EQ("/* a a */", 1300 format("/* a a */", getLLVMStyleWithColumns(15))); 1301 EXPECT_EQ("/* a a bc */", 1302 format("/* a a bc */", getLLVMStyleWithColumns(15))); 1303 EXPECT_EQ("/* aaa aaa\n" 1304 " * aaaaa */", 1305 format("/* aaa aaa aaaaa */", getLLVMStyleWithColumns(15))); 1306 EXPECT_EQ("/* aaa aaa\n" 1307 " * aaaaa */", 1308 format("/* aaa aaa aaaaa */", getLLVMStyleWithColumns(15))); 1309 } 1310 1311 TEST_F(FormatTestComments, SplitsLongLinesInCommentsInPreprocessor) { 1312 EXPECT_EQ("#define X \\\n" 1313 " /* \\\n" 1314 " Test \\\n" 1315 " Macro comment \\\n" 1316 " with a long \\\n" 1317 " line \\\n" 1318 " */ \\\n" 1319 " A + B", 1320 format("#define X \\\n" 1321 " /*\n" 1322 " Test\n" 1323 " Macro comment with a long line\n" 1324 " */ \\\n" 1325 " A + B", 1326 getLLVMStyleWithColumns(20))); 1327 EXPECT_EQ("#define X \\\n" 1328 " /* Macro comment \\\n" 1329 " with a long \\\n" 1330 " line */ \\\n" 1331 " A + B", 1332 format("#define X \\\n" 1333 " /* Macro comment with a long\n" 1334 " line */ \\\n" 1335 " A + B", 1336 getLLVMStyleWithColumns(20))); 1337 EXPECT_EQ("#define X \\\n" 1338 " /* Macro comment \\\n" 1339 " * with a long \\\n" 1340 " * line */ \\\n" 1341 " A + B", 1342 format("#define X \\\n" 1343 " /* Macro comment with a long line */ \\\n" 1344 " A + B", 1345 getLLVMStyleWithColumns(20))); 1346 } 1347 1348 TEST_F(FormatTestComments, KeepsTrailingPPCommentsAndSectionCommentsSeparate) { 1349 verifyFormat("#ifdef A // line about A\n" 1350 "// section comment\n" 1351 "#endif", 1352 getLLVMStyleWithColumns(80)); 1353 verifyFormat("#ifdef A // line 1 about A\n" 1354 " // line 2 about A\n" 1355 "// section comment\n" 1356 "#endif", 1357 getLLVMStyleWithColumns(80)); 1358 EXPECT_EQ("#ifdef A // line 1 about A\n" 1359 " // line 2 about A\n" 1360 "// section comment\n" 1361 "#endif", 1362 format("#ifdef A // line 1 about A\n" 1363 " // line 2 about A\n" 1364 "// section comment\n" 1365 "#endif", 1366 getLLVMStyleWithColumns(80))); 1367 verifyFormat("int f() {\n" 1368 " int i;\n" 1369 "#ifdef A // comment about A\n" 1370 " // section comment 1\n" 1371 " // section comment 2\n" 1372 " i = 2;\n" 1373 "#else // comment about #else\n" 1374 " // section comment 3\n" 1375 " i = 4;\n" 1376 "#endif\n" 1377 "}", 1378 getLLVMStyleWithColumns(80)); 1379 } 1380 1381 TEST_F(FormatTestComments, AlignsPPElseEndifComments) { 1382 verifyFormat("#if A\n" 1383 "#else // A\n" 1384 "int iiii;\n" 1385 "#endif // B", 1386 getLLVMStyleWithColumns(20)); 1387 verifyFormat("#if A\n" 1388 "#else // A\n" 1389 "int iiii; // CC\n" 1390 "#endif // B", 1391 getLLVMStyleWithColumns(20)); 1392 EXPECT_EQ("#if A\n" 1393 "#else // A1\n" 1394 " // A2\n" 1395 "int ii;\n" 1396 "#endif // B", 1397 format("#if A\n" 1398 "#else // A1\n" 1399 " // A2\n" 1400 "int ii;\n" 1401 "#endif // B", 1402 getLLVMStyleWithColumns(20))); 1403 } 1404 1405 TEST_F(FormatTestComments, CommentsInStaticInitializers) { 1406 EXPECT_EQ( 1407 "static SomeType type = {aaaaaaaaaaaaaaaaaaaa, /* comment */\n" 1408 " aaaaaaaaaaaaaaaaaaaa /* comment */,\n" 1409 " /* comment */ aaaaaaaaaaaaaaaaaaaa,\n" 1410 " aaaaaaaaaaaaaaaaaaaa, // comment\n" 1411 " aaaaaaaaaaaaaaaaaaaa};", 1412 format("static SomeType type = { aaaaaaaaaaaaaaaaaaaa , /* comment */\n" 1413 " aaaaaaaaaaaaaaaaaaaa /* comment */ ,\n" 1414 " /* comment */ aaaaaaaaaaaaaaaaaaaa ,\n" 1415 " aaaaaaaaaaaaaaaaaaaa , // comment\n" 1416 " aaaaaaaaaaaaaaaaaaaa };")); 1417 verifyFormat("static SomeType type = {aaaaaaaaaaa, // comment for aa...\n" 1418 " bbbbbbbbbbb, ccccccccccc};"); 1419 verifyFormat("static SomeType type = {aaaaaaaaaaa,\n" 1420 " // comment for bb....\n" 1421 " bbbbbbbbbbb, ccccccccccc};"); 1422 verifyGoogleFormat( 1423 "static SomeType type = {aaaaaaaaaaa, // comment for aa...\n" 1424 " bbbbbbbbbbb, ccccccccccc};"); 1425 verifyGoogleFormat("static SomeType type = {aaaaaaaaaaa,\n" 1426 " // comment for bb....\n" 1427 " bbbbbbbbbbb, ccccccccccc};"); 1428 1429 verifyFormat("S s = {{a, b, c}, // Group #1\n" 1430 " {d, e, f}, // Group #2\n" 1431 " {g, h, i}}; // Group #3"); 1432 verifyFormat("S s = {{// Group #1\n" 1433 " a, b, c},\n" 1434 " {// Group #2\n" 1435 " d, e, f},\n" 1436 " {// Group #3\n" 1437 " g, h, i}};"); 1438 1439 EXPECT_EQ("S s = {\n" 1440 " // Some comment\n" 1441 " a,\n" 1442 "\n" 1443 " // Comment after empty line\n" 1444 " b}", 1445 format("S s = {\n" 1446 " // Some comment\n" 1447 " a,\n" 1448 " \n" 1449 " // Comment after empty line\n" 1450 " b\n" 1451 "}")); 1452 EXPECT_EQ("S s = {\n" 1453 " /* Some comment */\n" 1454 " a,\n" 1455 "\n" 1456 " /* Comment after empty line */\n" 1457 " b}", 1458 format("S s = {\n" 1459 " /* Some comment */\n" 1460 " a,\n" 1461 " \n" 1462 " /* Comment after empty line */\n" 1463 " b\n" 1464 "}")); 1465 verifyFormat("const uint8_t aaaaaaaaaaaaaaaaaaaaaa[0] = {\n" 1466 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n" 1467 " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n" 1468 " 0x00, 0x00, 0x00, 0x00}; // comment\n"); 1469 } 1470 1471 TEST_F(FormatTestComments, LineCommentsAfterRightBrace) { 1472 EXPECT_EQ("if (true) { // comment about branch\n" 1473 " // comment about f\n" 1474 " f();\n" 1475 "}", 1476 format("if (true) { // comment about branch\n" 1477 " // comment about f\n" 1478 " f();\n" 1479 "}", 1480 getLLVMStyleWithColumns(80))); 1481 EXPECT_EQ("if (1) { // if line 1\n" 1482 " // if line 2\n" 1483 " // if line 3\n" 1484 " // f line 1\n" 1485 " // f line 2\n" 1486 " f();\n" 1487 "} else { // else line 1\n" 1488 " // else line 2\n" 1489 " // else line 3\n" 1490 " // g line 1\n" 1491 " g();\n" 1492 "}", 1493 format("if (1) { // if line 1\n" 1494 " // if line 2\n" 1495 " // if line 3\n" 1496 " // f line 1\n" 1497 " // f line 2\n" 1498 " f();\n" 1499 "} else { // else line 1\n" 1500 " // else line 2\n" 1501 " // else line 3\n" 1502 " // g line 1\n" 1503 " g();\n" 1504 "}")); 1505 EXPECT_EQ("do { // line 1\n" 1506 " // line 2\n" 1507 " // line 3\n" 1508 " f();\n" 1509 "} while (true);", 1510 format("do { // line 1\n" 1511 " // line 2\n" 1512 " // line 3\n" 1513 " f();\n" 1514 "} while (true);", 1515 getLLVMStyleWithColumns(80))); 1516 EXPECT_EQ("while (a < b) { // line 1\n" 1517 " // line 2\n" 1518 " // line 3\n" 1519 " f();\n" 1520 "}", 1521 format("while (a < b) {// line 1\n" 1522 " // line 2\n" 1523 " // line 3\n" 1524 " f();\n" 1525 "}", 1526 getLLVMStyleWithColumns(80))); 1527 } 1528 1529 TEST_F(FormatTestComments, ReflowsComments) { 1530 // Break a long line and reflow with the full next line. 1531 EXPECT_EQ("// long long long\n" 1532 "// long long", 1533 format("// long long long long\n" 1534 "// long", 1535 getLLVMStyleWithColumns(20))); 1536 1537 // Keep the trailing newline while reflowing. 1538 EXPECT_EQ("// long long long\n" 1539 "// long long\n", 1540 format("// long long long long\n" 1541 "// long\n", 1542 getLLVMStyleWithColumns(20))); 1543 1544 // Break a long line and reflow with a part of the next line. 1545 EXPECT_EQ("// long long long\n" 1546 "// long long\n" 1547 "// long_long", 1548 format("// long long long long\n" 1549 "// long long_long", 1550 getLLVMStyleWithColumns(20))); 1551 1552 // Break but do not reflow if the first word from the next line is too long. 1553 EXPECT_EQ("// long long long\n" 1554 "// long\n" 1555 "// long_long_long\n", 1556 format("// long long long long\n" 1557 "// long_long_long\n", 1558 getLLVMStyleWithColumns(20))); 1559 1560 // Don't break or reflow short lines. 1561 verifyFormat("// long\n" 1562 "// long long long lo\n" 1563 "// long long long lo\n" 1564 "// long", 1565 getLLVMStyleWithColumns(20)); 1566 1567 // Keep prefixes and decorations while reflowing. 1568 EXPECT_EQ("/// long long long\n" 1569 "/// long long\n", 1570 format("/// long long long long\n" 1571 "/// long\n", 1572 getLLVMStyleWithColumns(20))); 1573 EXPECT_EQ("//! long long long\n" 1574 "//! long long\n", 1575 format("//! long long long long\n" 1576 "//! long\n", 1577 getLLVMStyleWithColumns(20))); 1578 EXPECT_EQ("/* long long long\n" 1579 " * long long */", 1580 format("/* long long long long\n" 1581 " * long */", 1582 getLLVMStyleWithColumns(20))); 1583 EXPECT_EQ("///< long long long\n" 1584 "///< long long\n", 1585 format("///< long long long long\n" 1586 "///< long\n", 1587 getLLVMStyleWithColumns(20))); 1588 EXPECT_EQ("//!< long long long\n" 1589 "//!< long long\n", 1590 format("//!< long long long long\n" 1591 "//!< long\n", 1592 getLLVMStyleWithColumns(20))); 1593 1594 // Don't bring leading whitespace up while reflowing. 1595 EXPECT_EQ("/* long long long\n" 1596 " * long long long\n" 1597 " */", 1598 format("/* long long long long\n" 1599 " * long long\n" 1600 " */", 1601 getLLVMStyleWithColumns(20))); 1602 1603 // Reflow the last line of a block comment with its trailing '*/'. 1604 EXPECT_EQ("/* long long long\n" 1605 " long long */", 1606 format("/* long long long long\n" 1607 " long */", 1608 getLLVMStyleWithColumns(20))); 1609 1610 // Reflow two short lines; keep the postfix of the last one. 1611 EXPECT_EQ("/* long long long\n" 1612 " * long long long */", 1613 format("/* long long long long\n" 1614 " * long\n" 1615 " * long */", 1616 getLLVMStyleWithColumns(20))); 1617 1618 // Put the postfix of the last short reflow line on a newline if it doesn't 1619 // fit. 1620 EXPECT_EQ("/* long long long\n" 1621 " * long long longg\n" 1622 " */", 1623 format("/* long long long long\n" 1624 " * long\n" 1625 " * longg */", 1626 getLLVMStyleWithColumns(20))); 1627 1628 // Reflow lines with leading whitespace. 1629 EXPECT_EQ("{\n" 1630 " /*\n" 1631 " * long long long\n" 1632 " * long long long\n" 1633 " * long long long\n" 1634 " */\n" 1635 "}", 1636 format("{\n" 1637 "/*\n" 1638 " * long long long long\n" 1639 " * long\n" 1640 " * long long long long\n" 1641 " */\n" 1642 "}", 1643 getLLVMStyleWithColumns(20))); 1644 1645 // Break single line block comments that are first in the line with ' *' 1646 // decoration. 1647 EXPECT_EQ("/* long long long\n" 1648 " * long */", 1649 format("/* long long long long */", getLLVMStyleWithColumns(20))); 1650 1651 // Break single line block comment that are not first in the line with ' ' 1652 // decoration. 1653 EXPECT_EQ("int i; /* long long\n" 1654 " long */", 1655 format("int i; /* long long long */", getLLVMStyleWithColumns(20))); 1656 1657 // Reflow a line that goes just over the column limit. 1658 EXPECT_EQ("// long long long\n" 1659 "// lon long", 1660 format("// long long long lon\n" 1661 "// long", 1662 getLLVMStyleWithColumns(20))); 1663 1664 // Stop reflowing if the next line has a different indentation than the 1665 // previous line. 1666 EXPECT_EQ("// long long long\n" 1667 "// long\n" 1668 "// long long\n" 1669 "// long", 1670 format("// long long long long\n" 1671 "// long long\n" 1672 "// long", 1673 getLLVMStyleWithColumns(20))); 1674 1675 // Reflow into the last part of a really long line that has been broken into 1676 // multiple lines. 1677 EXPECT_EQ("// long long long\n" 1678 "// long long long\n" 1679 "// long long long\n", 1680 format("// long long long long long long long long\n" 1681 "// long\n", 1682 getLLVMStyleWithColumns(20))); 1683 1684 // Break the first line, then reflow the beginning of the second and third 1685 // line up. 1686 EXPECT_EQ("// long long long\n" 1687 "// lon1 lon2 lon2\n" 1688 "// lon2 lon3 lon3", 1689 format("// long long long lon1\n" 1690 "// lon2 lon2 lon2\n" 1691 "// lon3 lon3", 1692 getLLVMStyleWithColumns(20))); 1693 1694 // Reflow the beginning of the second line, then break the rest. 1695 EXPECT_EQ("// long long long\n" 1696 "// lon1 lon2 lon2\n" 1697 "// lon2 lon2 lon2\n" 1698 "// lon3", 1699 format("// long long long lon1\n" 1700 "// lon2 lon2 lon2 lon2 lon2 lon3", 1701 getLLVMStyleWithColumns(20))); 1702 1703 // Shrink the first line, then reflow the second line up. 1704 EXPECT_EQ("// long long long", format("// long long\n" 1705 "// long", 1706 getLLVMStyleWithColumns(20))); 1707 1708 // Don't shrink leading whitespace. 1709 EXPECT_EQ("int i; /// a", 1710 format("int i; /// a", getLLVMStyleWithColumns(20))); 1711 1712 // Shrink trailing whitespace if there is no postfix and reflow. 1713 EXPECT_EQ("// long long long\n" 1714 "// long long", 1715 format("// long long long long \n" 1716 "// long", 1717 getLLVMStyleWithColumns(20))); 1718 1719 // Shrink trailing whitespace to a single one if there is postfix. 1720 EXPECT_EQ("/* long long long */", 1721 format("/* long long long */", getLLVMStyleWithColumns(20))); 1722 1723 // Break a block comment postfix if exceeding the line limit. 1724 EXPECT_EQ("/* long\n" 1725 " */", 1726 format("/* long */", getLLVMStyleWithColumns(20))); 1727 1728 // Reflow indented comments. 1729 EXPECT_EQ("{\n" 1730 " // long long long\n" 1731 " // long long\n" 1732 " int i; /* long lon\n" 1733 " g long\n" 1734 " */\n" 1735 "}", 1736 format("{\n" 1737 " // long long long long\n" 1738 " // long\n" 1739 " int i; /* long lon g\n" 1740 " long */\n" 1741 "}", 1742 getLLVMStyleWithColumns(20))); 1743 1744 // Don't realign trailing comments after reflow has happened. 1745 EXPECT_EQ("// long long long\n" 1746 "// long long\n" 1747 "long i; // long", 1748 format("// long long long long\n" 1749 "// long\n" 1750 "long i; // long", 1751 getLLVMStyleWithColumns(20))); 1752 EXPECT_EQ("// long long long\n" 1753 "// longng long long\n" 1754 "// long lo", 1755 format("// long long long longng\n" 1756 "// long long long\n" 1757 "// lo", 1758 getLLVMStyleWithColumns(20))); 1759 1760 // Reflow lines after a broken line. 1761 EXPECT_EQ("int a; // Trailing\n" 1762 " // comment on\n" 1763 " // 2 or 3\n" 1764 " // lines.\n", 1765 format("int a; // Trailing comment\n" 1766 " // on 2\n" 1767 " // or 3\n" 1768 " // lines.\n", 1769 getLLVMStyleWithColumns(20))); 1770 EXPECT_EQ("/// This long line\n" 1771 "/// gets reflown.\n", 1772 format("/// This long line gets\n" 1773 "/// reflown.\n", 1774 getLLVMStyleWithColumns(20))); 1775 EXPECT_EQ("//! This long line\n" 1776 "//! gets reflown.\n", 1777 format(" //! This long line gets\n" 1778 " //! reflown.\n", 1779 getLLVMStyleWithColumns(20))); 1780 EXPECT_EQ("/* This long line\n" 1781 " * gets reflown.\n" 1782 " */\n", 1783 format("/* This long line gets\n" 1784 " * reflown.\n" 1785 " */\n", 1786 getLLVMStyleWithColumns(20))); 1787 1788 // Reflow after indentation makes a line too long. 1789 EXPECT_EQ("{\n" 1790 " // long long long\n" 1791 " // lo long\n" 1792 "}\n", 1793 format("{\n" 1794 "// long long long lo\n" 1795 "// long\n" 1796 "}\n", 1797 getLLVMStyleWithColumns(20))); 1798 1799 // Break and reflow multiple lines. 1800 EXPECT_EQ("/*\n" 1801 " * Reflow the end of\n" 1802 " * line by 11 22 33\n" 1803 " * 4.\n" 1804 " */\n", 1805 format("/*\n" 1806 " * Reflow the end of line\n" 1807 " * by\n" 1808 " * 11\n" 1809 " * 22\n" 1810 " * 33\n" 1811 " * 4.\n" 1812 " */\n", 1813 getLLVMStyleWithColumns(20))); 1814 EXPECT_EQ("/// First line gets\n" 1815 "/// broken. Second\n" 1816 "/// line gets\n" 1817 "/// reflown and\n" 1818 "/// broken. Third\n" 1819 "/// gets reflown.\n", 1820 format("/// First line gets broken.\n" 1821 "/// Second line gets reflown and broken.\n" 1822 "/// Third gets reflown.\n", 1823 getLLVMStyleWithColumns(20))); 1824 EXPECT_EQ("int i; // first long\n" 1825 " // long snd\n" 1826 " // long.\n", 1827 format("int i; // first long long\n" 1828 " // snd long.\n", 1829 getLLVMStyleWithColumns(20))); 1830 EXPECT_EQ("{\n" 1831 " // first long line\n" 1832 " // line second\n" 1833 " // long line line\n" 1834 " // third long line\n" 1835 " // line\n" 1836 "}\n", 1837 format("{\n" 1838 " // first long line line\n" 1839 " // second long line line\n" 1840 " // third long line line\n" 1841 "}\n", 1842 getLLVMStyleWithColumns(20))); 1843 EXPECT_EQ("int i; /* first line\n" 1844 " * second\n" 1845 " * line third\n" 1846 " * line\n" 1847 " */", 1848 format("int i; /* first line\n" 1849 " * second line\n" 1850 " * third line\n" 1851 " */", 1852 getLLVMStyleWithColumns(20))); 1853 1854 // Reflow the last two lines of a section that starts with a line having 1855 // different indentation. 1856 EXPECT_EQ("// long\n" 1857 "// long long long\n" 1858 "// long long", 1859 format("// long\n" 1860 "// long long long long\n" 1861 "// long", 1862 getLLVMStyleWithColumns(20))); 1863 1864 // Keep the block comment endling '*/' while reflowing. 1865 EXPECT_EQ("/* Long long long\n" 1866 " * line short */\n", 1867 format("/* Long long long line\n" 1868 " * short */\n", 1869 getLLVMStyleWithColumns(20))); 1870 1871 // Don't reflow between separate blocks of comments. 1872 EXPECT_EQ("/* First comment\n" 1873 " * block will */\n" 1874 "/* Snd\n" 1875 " */\n", 1876 format("/* First comment block\n" 1877 " * will */\n" 1878 "/* Snd\n" 1879 " */\n", 1880 getLLVMStyleWithColumns(20))); 1881 1882 // Don't reflow across blank comment lines. 1883 EXPECT_EQ("int i; // This long\n" 1884 " // line gets\n" 1885 " // broken.\n" 1886 " //\n" 1887 " // keep.\n", 1888 format("int i; // This long line gets broken.\n" 1889 " // \n" 1890 " // keep.\n", 1891 getLLVMStyleWithColumns(20))); 1892 EXPECT_EQ("{\n" 1893 " /// long long long\n" 1894 " /// long long\n" 1895 " ///\n" 1896 " /// long\n" 1897 "}", 1898 format("{\n" 1899 " /// long long long long\n" 1900 " /// long\n" 1901 " ///\n" 1902 " /// long\n" 1903 "}", 1904 getLLVMStyleWithColumns(20))); 1905 EXPECT_EQ("//! long long long\n" 1906 "//! long\n" 1907 "\n" 1908 "//! long", 1909 format("//! long long long long\n" 1910 "\n" 1911 "//! long", 1912 getLLVMStyleWithColumns(20))); 1913 EXPECT_EQ("/* long long long\n" 1914 " long\n" 1915 "\n" 1916 " long */", 1917 format("/* long long long long\n" 1918 "\n" 1919 " long */", 1920 getLLVMStyleWithColumns(20))); 1921 EXPECT_EQ("/* long long long\n" 1922 " * long\n" 1923 " *\n" 1924 " * long */", 1925 format("/* long long long long\n" 1926 " *\n" 1927 " * long */", 1928 getLLVMStyleWithColumns(20))); 1929 1930 // Don't reflow lines having content that is a single character. 1931 EXPECT_EQ("// long long long\n" 1932 "// long\n" 1933 "// l", 1934 format("// long long long long\n" 1935 "// l", 1936 getLLVMStyleWithColumns(20))); 1937 1938 // Don't reflow lines starting with two punctuation characters. 1939 EXPECT_EQ("// long long long\n" 1940 "// long\n" 1941 "// ... --- ...", 1942 format("// long long long long\n" 1943 "// ... --- ...", 1944 getLLVMStyleWithColumns(20))); 1945 1946 // Don't reflow lines starting with '@'. 1947 EXPECT_EQ("// long long long\n" 1948 "// long\n" 1949 "// @param arg", 1950 format("// long long long long\n" 1951 "// @param arg", 1952 getLLVMStyleWithColumns(20))); 1953 1954 // Don't reflow lines starting with 'TODO'. 1955 EXPECT_EQ("// long long long\n" 1956 "// long\n" 1957 "// TODO: long", 1958 format("// long long long long\n" 1959 "// TODO: long", 1960 getLLVMStyleWithColumns(20))); 1961 1962 // Don't reflow lines starting with 'FIXME'. 1963 EXPECT_EQ("// long long long\n" 1964 "// long\n" 1965 "// FIXME: long", 1966 format("// long long long long\n" 1967 "// FIXME: long", 1968 getLLVMStyleWithColumns(20))); 1969 1970 // Don't reflow lines starting with 'XXX'. 1971 EXPECT_EQ("// long long long\n" 1972 "// long\n" 1973 "// XXX: long", 1974 format("// long long long long\n" 1975 "// XXX: long", 1976 getLLVMStyleWithColumns(20))); 1977 1978 // Don't reflow comment pragmas. 1979 EXPECT_EQ("// long long long\n" 1980 "// long\n" 1981 "// IWYU pragma:", 1982 format("// long long long long\n" 1983 "// IWYU pragma:", 1984 getLLVMStyleWithColumns(20))); 1985 EXPECT_EQ("/* long long long\n" 1986 " * long\n" 1987 " * IWYU pragma:\n" 1988 " */", 1989 format("/* long long long long\n" 1990 " * IWYU pragma:\n" 1991 " */", 1992 getLLVMStyleWithColumns(20))); 1993 1994 // Reflow lines that have a non-punctuation character among their first 2 1995 // characters. 1996 EXPECT_EQ("// long long long\n" 1997 "// long 'long'", 1998 format("// long long long long\n" 1999 "// 'long'", 2000 getLLVMStyleWithColumns(20))); 2001 2002 // Don't reflow between separate blocks of comments. 2003 EXPECT_EQ("/* First comment\n" 2004 " * block will */\n" 2005 "/* Snd\n" 2006 " */\n", 2007 format("/* First comment block\n" 2008 " * will */\n" 2009 "/* Snd\n" 2010 " */\n", 2011 getLLVMStyleWithColumns(20))); 2012 2013 // Don't reflow lines having different indentation. 2014 EXPECT_EQ("// long long long\n" 2015 "// long\n" 2016 "// long", 2017 format("// long long long long\n" 2018 "// long", 2019 getLLVMStyleWithColumns(20))); 2020 2021 // Don't reflow separate bullets in list 2022 EXPECT_EQ("// - long long long\n" 2023 "// long\n" 2024 "// - long", 2025 format("// - long long long long\n" 2026 "// - long", 2027 getLLVMStyleWithColumns(20))); 2028 EXPECT_EQ("// * long long long\n" 2029 "// long\n" 2030 "// * long", 2031 format("// * long long long long\n" 2032 "// * long", 2033 getLLVMStyleWithColumns(20))); 2034 EXPECT_EQ("// + long long long\n" 2035 "// long\n" 2036 "// + long", 2037 format("// + long long long long\n" 2038 "// + long", 2039 getLLVMStyleWithColumns(20))); 2040 EXPECT_EQ("// 1. long long long\n" 2041 "// long\n" 2042 "// 2. long", 2043 format("// 1. long long long long\n" 2044 "// 2. long", 2045 getLLVMStyleWithColumns(20))); 2046 EXPECT_EQ("// -# long long long\n" 2047 "// long\n" 2048 "// -# long", 2049 format("// -# long long long long\n" 2050 "// -# long", 2051 getLLVMStyleWithColumns(20))); 2052 2053 EXPECT_EQ("// - long long long\n" 2054 "// long long long\n" 2055 "// - long", 2056 format("// - long long long long\n" 2057 "// long long\n" 2058 "// - long", 2059 getLLVMStyleWithColumns(20))); 2060 EXPECT_EQ("// - long long long\n" 2061 "// long long long\n" 2062 "// long\n" 2063 "// - long", 2064 format("// - long long long long\n" 2065 "// long long long\n" 2066 "// - long", 2067 getLLVMStyleWithColumns(20))); 2068 2069 // Large number (>2 digits) are not list items 2070 EXPECT_EQ("// long long long\n" 2071 "// long 1024. long.", 2072 format("// long long long long\n" 2073 "// 1024. long.", 2074 getLLVMStyleWithColumns(20))); 2075 2076 // Do not break before number, to avoid introducing a non-reflowable doxygen 2077 // list item. 2078 EXPECT_EQ("// long long\n" 2079 "// long 10. long.", 2080 format("// long long long 10.\n" 2081 "// long.", 2082 getLLVMStyleWithColumns(20))); 2083 2084 // Don't break or reflow after implicit string literals. 2085 verifyFormat("#include <t> // l l l\n" 2086 " // l", 2087 getLLVMStyleWithColumns(20)); 2088 2089 // Don't break or reflow comments on import lines. 2090 EXPECT_EQ("#include \"t\" /* l l l\n" 2091 " * l */", 2092 format("#include \"t\" /* l l l\n" 2093 " * l */", 2094 getLLVMStyleWithColumns(20))); 2095 2096 // Don't reflow between different trailing comment sections. 2097 EXPECT_EQ("int i; // long long\n" 2098 " // long\n" 2099 "int j; // long long\n" 2100 " // long\n", 2101 format("int i; // long long long\n" 2102 "int j; // long long long\n", 2103 getLLVMStyleWithColumns(20))); 2104 2105 // Don't reflow if the first word on the next line is longer than the 2106 // available space at current line. 2107 EXPECT_EQ("int i; // trigger\n" 2108 " // reflow\n" 2109 " // longsec\n", 2110 format("int i; // trigger reflow\n" 2111 " // longsec\n", 2112 getLLVMStyleWithColumns(20))); 2113 2114 // Simple case that correctly handles reflow in parameter lists. 2115 EXPECT_EQ("a = f(/* looooooooong\n" 2116 " * long long\n" 2117 " */\n" 2118 " a);", 2119 format("a = f(/* looooooooong long\n* long\n*/ a);", 2120 getLLVMStyleWithColumns(22))); 2121 // Tricky case that has fewer lines if we reflow the comment, ending up with 2122 // fewer lines. 2123 EXPECT_EQ("a = f(/* loooooong\n" 2124 " * long long\n" 2125 " */\n" 2126 " a);", 2127 format("a = f(/* loooooong long\n* long\n*/ a);", 2128 getLLVMStyleWithColumns(22))); 2129 2130 // Keep empty comment lines. 2131 EXPECT_EQ("/**/", format(" /**/", getLLVMStyleWithColumns(20))); 2132 EXPECT_EQ("/* */", format(" /* */", getLLVMStyleWithColumns(20))); 2133 EXPECT_EQ("/* */", format(" /* */", getLLVMStyleWithColumns(20))); 2134 EXPECT_EQ("//", format(" // ", getLLVMStyleWithColumns(20))); 2135 EXPECT_EQ("///", format(" /// ", getLLVMStyleWithColumns(20))); 2136 } 2137 2138 TEST_F(FormatTestComments, ReflowsCommentsPrecise) { 2139 // FIXME: This assumes we do not continue compressing whitespace once we are 2140 // in reflow mode. Consider compressing whitespace. 2141 2142 // Test that we stop reflowing precisely at the column limit. 2143 // After reflowing, "// reflows into foo" does not fit the column limit, 2144 // so we compress the whitespace. 2145 EXPECT_EQ("// some text that\n" 2146 "// reflows into foo\n", 2147 format("// some text that reflows\n" 2148 "// into foo\n", 2149 getLLVMStyleWithColumns(20))); 2150 // Given one more column, "// reflows into foo" does fit the limit, so we 2151 // do not compress the whitespace. 2152 EXPECT_EQ("// some text that\n" 2153 "// reflows into foo\n", 2154 format("// some text that reflows\n" 2155 "// into foo\n", 2156 getLLVMStyleWithColumns(21))); 2157 2158 // Make sure that we correctly account for the space added in the reflow case 2159 // when making the reflowing decision. 2160 // First, when the next line ends precisely one column over the limit, do not 2161 // reflow. 2162 EXPECT_EQ("// some text that\n" 2163 "// reflows\n" 2164 "// into1234567\n", 2165 format("// some text that reflows\n" 2166 "// into1234567\n", 2167 getLLVMStyleWithColumns(21))); 2168 // Secondly, when the next line ends later, but the first word in that line 2169 // is precisely one column over the limit, do not reflow. 2170 EXPECT_EQ("// some text that\n" 2171 "// reflows\n" 2172 "// into1234567 f\n", 2173 format("// some text that reflows\n" 2174 "// into1234567 f\n", 2175 getLLVMStyleWithColumns(21))); 2176 } 2177 2178 TEST_F(FormatTestComments, ReflowsCommentsWithExtraWhitespace) { 2179 // Baseline. 2180 EXPECT_EQ("// some text\n" 2181 "// that re flows\n", 2182 format("// some text that\n" 2183 "// re flows\n", 2184 getLLVMStyleWithColumns(16))); 2185 EXPECT_EQ("// some text\n" 2186 "// that re flows\n", 2187 format("// some text that\n" 2188 "// re flows\n", 2189 getLLVMStyleWithColumns(16))); 2190 EXPECT_EQ("/* some text\n" 2191 " * that re flows\n" 2192 " */\n", 2193 format("/* some text that\n" 2194 "* re flows\n" 2195 "*/\n", 2196 getLLVMStyleWithColumns(16))); 2197 // FIXME: We do not reflow if the indent of two subsequent lines differs; 2198 // given that this is different behavior from block comments, do we want 2199 // to keep this? 2200 EXPECT_EQ("// some text\n" 2201 "// that\n" 2202 "// re flows\n", 2203 format("// some text that\n" 2204 "// re flows\n", 2205 getLLVMStyleWithColumns(16))); 2206 // Space within parts of a line that fit. 2207 // FIXME: Use the earliest possible split while reflowing to compress the 2208 // whitespace within the line. 2209 EXPECT_EQ("// some text that\n" 2210 "// does re flow\n" 2211 "// more here\n", 2212 format("// some text that does\n" 2213 "// re flow more here\n", 2214 getLLVMStyleWithColumns(21))); 2215 } 2216 2217 TEST_F(FormatTestComments, IgnoresIf0Contents) { 2218 EXPECT_EQ("#if 0\n" 2219 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 2220 "#endif\n" 2221 "void f() {}", 2222 format("#if 0\n" 2223 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 2224 "#endif\n" 2225 "void f( ) { }")); 2226 EXPECT_EQ("#if false\n" 2227 "void f( ) { }\n" 2228 "#endif\n" 2229 "void g() {}\n", 2230 format("#if false\n" 2231 "void f( ) { }\n" 2232 "#endif\n" 2233 "void g( ) { }\n")); 2234 EXPECT_EQ("enum E {\n" 2235 " One,\n" 2236 " Two,\n" 2237 "#if 0\n" 2238 "Three,\n" 2239 " Four,\n" 2240 "#endif\n" 2241 " Five\n" 2242 "};", 2243 format("enum E {\n" 2244 " One,Two,\n" 2245 "#if 0\n" 2246 "Three,\n" 2247 " Four,\n" 2248 "#endif\n" 2249 " Five};")); 2250 EXPECT_EQ("enum F {\n" 2251 " One,\n" 2252 "#if 1\n" 2253 " Two,\n" 2254 "#if 0\n" 2255 "Three,\n" 2256 " Four,\n" 2257 "#endif\n" 2258 " Five\n" 2259 "#endif\n" 2260 "};", 2261 format("enum F {\n" 2262 "One,\n" 2263 "#if 1\n" 2264 "Two,\n" 2265 "#if 0\n" 2266 "Three,\n" 2267 " Four,\n" 2268 "#endif\n" 2269 "Five\n" 2270 "#endif\n" 2271 "};")); 2272 EXPECT_EQ("enum G {\n" 2273 " One,\n" 2274 "#if 0\n" 2275 "Two,\n" 2276 "#else\n" 2277 " Three,\n" 2278 "#endif\n" 2279 " Four\n" 2280 "};", 2281 format("enum G {\n" 2282 "One,\n" 2283 "#if 0\n" 2284 "Two,\n" 2285 "#else\n" 2286 "Three,\n" 2287 "#endif\n" 2288 "Four\n" 2289 "};")); 2290 EXPECT_EQ("enum H {\n" 2291 " One,\n" 2292 "#if 0\n" 2293 "#ifdef Q\n" 2294 "Two,\n" 2295 "#else\n" 2296 "Three,\n" 2297 "#endif\n" 2298 "#endif\n" 2299 " Four\n" 2300 "};", 2301 format("enum H {\n" 2302 "One,\n" 2303 "#if 0\n" 2304 "#ifdef Q\n" 2305 "Two,\n" 2306 "#else\n" 2307 "Three,\n" 2308 "#endif\n" 2309 "#endif\n" 2310 "Four\n" 2311 "};")); 2312 EXPECT_EQ("enum I {\n" 2313 " One,\n" 2314 "#if /* test */ 0 || 1\n" 2315 "Two,\n" 2316 "Three,\n" 2317 "#endif\n" 2318 " Four\n" 2319 "};", 2320 format("enum I {\n" 2321 "One,\n" 2322 "#if /* test */ 0 || 1\n" 2323 "Two,\n" 2324 "Three,\n" 2325 "#endif\n" 2326 "Four\n" 2327 "};")); 2328 EXPECT_EQ("enum J {\n" 2329 " One,\n" 2330 "#if 0\n" 2331 "#if 0\n" 2332 "Two,\n" 2333 "#else\n" 2334 "Three,\n" 2335 "#endif\n" 2336 "Four,\n" 2337 "#endif\n" 2338 " Five\n" 2339 "};", 2340 format("enum J {\n" 2341 "One,\n" 2342 "#if 0\n" 2343 "#if 0\n" 2344 "Two,\n" 2345 "#else\n" 2346 "Three,\n" 2347 "#endif\n" 2348 "Four,\n" 2349 "#endif\n" 2350 "Five\n" 2351 "};")); 2352 2353 // Ignore stuff in SWIG-blocks. 2354 EXPECT_EQ("#ifdef SWIG\n" 2355 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 2356 "#endif\n" 2357 "void f() {}", 2358 format("#ifdef SWIG\n" 2359 "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" 2360 "#endif\n" 2361 "void f( ) { }")); 2362 EXPECT_EQ("#ifndef SWIG\n" 2363 "void f() {}\n" 2364 "#endif", 2365 format("#ifndef SWIG\n" 2366 "void f( ) { }\n" 2367 "#endif")); 2368 } 2369 2370 TEST_F(FormatTestComments, DontCrashOnBlockComments) { 2371 EXPECT_EQ( 2372 "int xxxxxxxxx; /* " 2373 "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy\n" 2374 "zzzzzz\n" 2375 "0*/", 2376 format("int xxxxxxxxx; /* " 2377 "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy zzzzzz\n" 2378 "0*/")); 2379 } 2380 2381 TEST_F(FormatTestComments, BlockCommentsInControlLoops) { 2382 verifyFormat("if (0) /* a comment in a strange place */ {\n" 2383 " f();\n" 2384 "}"); 2385 verifyFormat("if (0) /* a comment in a strange place */ {\n" 2386 " f();\n" 2387 "} /* another comment */ else /* comment #3 */ {\n" 2388 " g();\n" 2389 "}"); 2390 verifyFormat("while (0) /* a comment in a strange place */ {\n" 2391 " f();\n" 2392 "}"); 2393 verifyFormat("for (;;) /* a comment in a strange place */ {\n" 2394 " f();\n" 2395 "}"); 2396 verifyFormat("do /* a comment in a strange place */ {\n" 2397 " f();\n" 2398 "} /* another comment */ while (0);"); 2399 } 2400 2401 TEST_F(FormatTestComments, BlockComments) { 2402 EXPECT_EQ("/* */ /* */ /* */\n/* */ /* */ /* */", 2403 format("/* *//* */ /* */\n/* *//* */ /* */")); 2404 EXPECT_EQ("/* */ a /* */ b;", format(" /* */ a/* */ b;")); 2405 EXPECT_EQ("#define A /*123*/ \\\n" 2406 " b\n" 2407 "/* */\n" 2408 "someCall(\n" 2409 " parameter);", 2410 format("#define A /*123*/ b\n" 2411 "/* */\n" 2412 "someCall(parameter);", 2413 getLLVMStyleWithColumns(15))); 2414 2415 EXPECT_EQ("#define A\n" 2416 "/* */ someCall(\n" 2417 " parameter);", 2418 format("#define A\n" 2419 "/* */someCall(parameter);", 2420 getLLVMStyleWithColumns(15))); 2421 EXPECT_EQ("/*\n**\n*/", format("/*\n**\n*/")); 2422 EXPECT_EQ("/*\n" 2423 " *\n" 2424 " * aaaaaa\n" 2425 " * aaaaaa\n" 2426 " */", 2427 format("/*\n" 2428 "*\n" 2429 " * aaaaaa aaaaaa\n" 2430 "*/", 2431 getLLVMStyleWithColumns(10))); 2432 EXPECT_EQ("/*\n" 2433 "**\n" 2434 "* aaaaaa\n" 2435 "*aaaaaa\n" 2436 "*/", 2437 format("/*\n" 2438 "**\n" 2439 "* aaaaaa aaaaaa\n" 2440 "*/", 2441 getLLVMStyleWithColumns(10))); 2442 EXPECT_EQ("int aaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 2443 " /* line 1\n" 2444 " bbbbbbbbbbbb */\n" 2445 " bbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 2446 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" 2447 " /* line 1\n" 2448 " bbbbbbbbbbbb */ bbbbbbbbbbbbbbbbbbbbbbbbbbbb;", 2449 getLLVMStyleWithColumns(50))); 2450 2451 FormatStyle NoBinPacking = getLLVMStyle(); 2452 NoBinPacking.BinPackParameters = false; 2453 EXPECT_EQ("someFunction(1, /* comment 1 */\n" 2454 " 2, /* comment 2 */\n" 2455 " 3, /* comment 3 */\n" 2456 " aaaa,\n" 2457 " bbbb);", 2458 format("someFunction (1, /* comment 1 */\n" 2459 " 2, /* comment 2 */ \n" 2460 " 3, /* comment 3 */\n" 2461 "aaaa, bbbb );", 2462 NoBinPacking)); 2463 verifyFormat( 2464 "bool aaaaaaaaaaaaa = /* comment: */ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2465 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); 2466 EXPECT_EQ( 2467 "bool aaaaaaaaaaaaa = /* trailing comment */\n" 2468 " aaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2469 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;", 2470 format( 2471 "bool aaaaaaaaaaaaa = /* trailing comment */\n" 2472 " aaaaaaaaaaaaaaaaaaaaaaaaaaa||aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2473 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaa;")); 2474 EXPECT_EQ( 2475 "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n" 2476 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n" 2477 "int cccccccccccccccccccccccccccccc; /* comment */\n", 2478 format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; /* comment */\n" 2479 "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; /* comment */\n" 2480 "int cccccccccccccccccccccccccccccc; /* comment */\n")); 2481 2482 verifyFormat("void f(int * /* unused */) {}"); 2483 2484 EXPECT_EQ("/*\n" 2485 " **\n" 2486 " */", 2487 format("/*\n" 2488 " **\n" 2489 " */")); 2490 EXPECT_EQ("/*\n" 2491 " *q\n" 2492 " */", 2493 format("/*\n" 2494 " *q\n" 2495 " */")); 2496 EXPECT_EQ("/*\n" 2497 " * q\n" 2498 " */", 2499 format("/*\n" 2500 " * q\n" 2501 " */")); 2502 EXPECT_EQ("/*\n" 2503 " **/", 2504 format("/*\n" 2505 " **/")); 2506 EXPECT_EQ("/*\n" 2507 " ***/", 2508 format("/*\n" 2509 " ***/")); 2510 } 2511 2512 TEST_F(FormatTestComments, BlockCommentsInMacros) { 2513 EXPECT_EQ("#define A \\\n" 2514 " { \\\n" 2515 " /* one line */ \\\n" 2516 " someCall();", 2517 format("#define A { \\\n" 2518 " /* one line */ \\\n" 2519 " someCall();", 2520 getLLVMStyleWithColumns(20))); 2521 EXPECT_EQ("#define A \\\n" 2522 " { \\\n" 2523 " /* previous */ \\\n" 2524 " /* one line */ \\\n" 2525 " someCall();", 2526 format("#define A { \\\n" 2527 " /* previous */ \\\n" 2528 " /* one line */ \\\n" 2529 " someCall();", 2530 getLLVMStyleWithColumns(20))); 2531 } 2532 2533 TEST_F(FormatTestComments, BlockCommentsAtEndOfLine) { 2534 EXPECT_EQ("a = {\n" 2535 " 1111 /* */\n" 2536 "};", 2537 format("a = {1111 /* */\n" 2538 "};", 2539 getLLVMStyleWithColumns(15))); 2540 EXPECT_EQ("a = {\n" 2541 " 1111 /* */\n" 2542 "};", 2543 format("a = {1111 /* */\n" 2544 "};", 2545 getLLVMStyleWithColumns(15))); 2546 EXPECT_EQ("a = {\n" 2547 " 1111 /* a\n" 2548 " */\n" 2549 "};", 2550 format("a = {1111 /* a */\n" 2551 "};", 2552 getLLVMStyleWithColumns(15))); 2553 } 2554 2555 TEST_F(FormatTestComments, BreaksAfterMultilineBlockCommentsInParamLists) { 2556 EXPECT_EQ("a = f(/* long\n" 2557 " long */\n" 2558 " a);", 2559 format("a = f(/* long long */ a);", getLLVMStyleWithColumns(16))); 2560 EXPECT_EQ("a = f(\n" 2561 " /* long\n" 2562 " long */\n" 2563 " a);", 2564 format("a = f(/* long long */ a);", getLLVMStyleWithColumns(15))); 2565 2566 EXPECT_EQ("a = f(/* long\n" 2567 " long\n" 2568 " */\n" 2569 " a);", 2570 format("a = f(/* long\n" 2571 " long\n" 2572 " */a);", 2573 getLLVMStyleWithColumns(16))); 2574 2575 EXPECT_EQ("a = f(/* long\n" 2576 " long\n" 2577 " */\n" 2578 " a);", 2579 format("a = f(/* long\n" 2580 " long\n" 2581 " */ a);", 2582 getLLVMStyleWithColumns(16))); 2583 2584 EXPECT_EQ("a = f(/* long\n" 2585 " long\n" 2586 " */\n" 2587 " (1 + 1));", 2588 format("a = f(/* long\n" 2589 " long\n" 2590 " */ (1 + 1));", 2591 getLLVMStyleWithColumns(16))); 2592 2593 EXPECT_EQ( 2594 "a = f(a,\n" 2595 " /* long\n" 2596 " long */\n" 2597 " b);", 2598 format("a = f(a, /* long long */ b);", getLLVMStyleWithColumns(16))); 2599 2600 EXPECT_EQ( 2601 "a = f(\n" 2602 " a,\n" 2603 " /* long\n" 2604 " long */\n" 2605 " b);", 2606 format("a = f(a, /* long long */ b);", getLLVMStyleWithColumns(15))); 2607 2608 EXPECT_EQ("a = f(a,\n" 2609 " /* long\n" 2610 " long */\n" 2611 " (1 + 1));", 2612 format("a = f(a, /* long long */ (1 + 1));", 2613 getLLVMStyleWithColumns(16))); 2614 EXPECT_EQ("a = f(\n" 2615 " a,\n" 2616 " /* long\n" 2617 " long */\n" 2618 " (1 + 1));", 2619 format("a = f(a, /* long long */ (1 + 1));", 2620 getLLVMStyleWithColumns(15))); 2621 } 2622 2623 TEST_F(FormatTestComments, IndentLineCommentsInStartOfBlockAtEndOfFile) { 2624 verifyFormat("{\n" 2625 " // a\n" 2626 " // b"); 2627 } 2628 2629 TEST_F(FormatTestComments, AlignTrailingComments) { 2630 EXPECT_EQ("#define MACRO(V) \\\n" 2631 " V(Rt2) /* one more char */ \\\n" 2632 " V(Rs) /* than here */ \\\n" 2633 "/* comment 3 */\n", 2634 format("#define MACRO(V)\\\n" 2635 "V(Rt2) /* one more char */ \\\n" 2636 "V(Rs) /* than here */ \\\n" 2637 "/* comment 3 */\n", 2638 getLLVMStyleWithColumns(40))); 2639 EXPECT_EQ("int i = f(abc, // line 1\n" 2640 " d, // line 2\n" 2641 " // line 3\n" 2642 " b);", 2643 format("int i = f(abc, // line 1\n" 2644 " d, // line 2\n" 2645 " // line 3\n" 2646 " b);", 2647 getLLVMStyleWithColumns(40))); 2648 2649 // Align newly broken trailing comments. 2650 EXPECT_EQ("int ab; // line\n" 2651 "int a; // long\n" 2652 " // long\n", 2653 format("int ab; // line\n" 2654 "int a; // long long\n", 2655 getLLVMStyleWithColumns(15))); 2656 EXPECT_EQ("int ab; // line\n" 2657 "int a; // long\n" 2658 " // long\n" 2659 " // long", 2660 format("int ab; // line\n" 2661 "int a; // long long\n" 2662 " // long", 2663 getLLVMStyleWithColumns(15))); 2664 EXPECT_EQ("int ab; // line\n" 2665 "int a; // long\n" 2666 " // long\n" 2667 "pt c; // long", 2668 format("int ab; // line\n" 2669 "int a; // long long\n" 2670 "pt c; // long", 2671 getLLVMStyleWithColumns(15))); 2672 EXPECT_EQ("int ab; // line\n" 2673 "int a; // long\n" 2674 " // long\n" 2675 "\n" 2676 "// long", 2677 format("int ab; // line\n" 2678 "int a; // long long\n" 2679 "\n" 2680 "// long", 2681 getLLVMStyleWithColumns(15))); 2682 2683 // Don't align newly broken trailing comments if that would put them over the 2684 // column limit. 2685 EXPECT_EQ("int i, j; // line 1\n" 2686 "int k; // line longg\n" 2687 " // long", 2688 format("int i, j; // line 1\n" 2689 "int k; // line longg long", 2690 getLLVMStyleWithColumns(20))); 2691 2692 // Always align if ColumnLimit = 0 2693 EXPECT_EQ("int i, j; // line 1\n" 2694 "int k; // line longg long", 2695 format("int i, j; // line 1\n" 2696 "int k; // line longg long", 2697 getLLVMStyleWithColumns(0))); 2698 2699 // Align comment line sections aligned with the next token with the next 2700 // token. 2701 EXPECT_EQ("class A {\n" 2702 "public: // public comment\n" 2703 " // comment about a\n" 2704 " int a;\n" 2705 "};", 2706 format("class A {\n" 2707 "public: // public comment\n" 2708 " // comment about a\n" 2709 " int a;\n" 2710 "};", 2711 getLLVMStyleWithColumns(40))); 2712 EXPECT_EQ("class A {\n" 2713 "public: // public comment 1\n" 2714 " // public comment 2\n" 2715 " // comment 1 about a\n" 2716 " // comment 2 about a\n" 2717 " int a;\n" 2718 "};", 2719 format("class A {\n" 2720 "public: // public comment 1\n" 2721 " // public comment 2\n" 2722 " // comment 1 about a\n" 2723 " // comment 2 about a\n" 2724 " int a;\n" 2725 "};", 2726 getLLVMStyleWithColumns(40))); 2727 EXPECT_EQ("int f(int n) { // comment line 1 on f\n" 2728 " // comment line 2 on f\n" 2729 " // comment line 1 before return\n" 2730 " // comment line 2 before return\n" 2731 " return n; // comment line 1 on return\n" 2732 " // comment line 2 on return\n" 2733 " // comment line 1 after return\n" 2734 "}", 2735 format("int f(int n) { // comment line 1 on f\n" 2736 " // comment line 2 on f\n" 2737 " // comment line 1 before return\n" 2738 " // comment line 2 before return\n" 2739 " return n; // comment line 1 on return\n" 2740 " // comment line 2 on return\n" 2741 " // comment line 1 after return\n" 2742 "}", 2743 getLLVMStyleWithColumns(40))); 2744 EXPECT_EQ("int f(int n) {\n" 2745 " switch (n) { // comment line 1 on switch\n" 2746 " // comment line 2 on switch\n" 2747 " // comment line 1 before case 1\n" 2748 " // comment line 2 before case 1\n" 2749 " case 1: // comment line 1 on case 1\n" 2750 " // comment line 2 on case 1\n" 2751 " // comment line 1 before return 1\n" 2752 " // comment line 2 before return 1\n" 2753 " return 1; // comment line 1 on return 1\n" 2754 " // comment line 2 on return 1\n" 2755 " // comment line 1 before default\n" 2756 " // comment line 2 before default\n" 2757 " default: // comment line 1 on default\n" 2758 " // comment line 2 on default\n" 2759 " // comment line 1 before return 2\n" 2760 " return 2 * f(n - 1); // comment line 1 on return 2\n" 2761 " // comment line 2 on return 2\n" 2762 " // comment line 1 after return\n" 2763 " // comment line 2 after return\n" 2764 " }\n" 2765 "}", 2766 format("int f(int n) {\n" 2767 " switch (n) { // comment line 1 on switch\n" 2768 " // comment line 2 on switch\n" 2769 " // comment line 1 before case 1\n" 2770 " // comment line 2 before case 1\n" 2771 " case 1: // comment line 1 on case 1\n" 2772 " // comment line 2 on case 1\n" 2773 " // comment line 1 before return 1\n" 2774 " // comment line 2 before return 1\n" 2775 " return 1; // comment line 1 on return 1\n" 2776 " // comment line 2 on return 1\n" 2777 " // comment line 1 before default\n" 2778 " // comment line 2 before default\n" 2779 " default: // comment line 1 on default\n" 2780 " // comment line 2 on default\n" 2781 " // comment line 1 before return 2\n" 2782 " return 2 * f(n - 1); // comment line 1 on return 2\n" 2783 " // comment line 2 on return 2\n" 2784 " // comment line 1 after return\n" 2785 " // comment line 2 after return\n" 2786 " }\n" 2787 "}", 2788 getLLVMStyleWithColumns(80))); 2789 2790 // If all the lines in a sequence of line comments are aligned with the next 2791 // token, the first line belongs to the previous token and the other lines 2792 // belong to the next token. 2793 EXPECT_EQ("int a; // line about a\n" 2794 "long b;", 2795 format("int a; // line about a\n" 2796 " long b;", 2797 getLLVMStyleWithColumns(80))); 2798 EXPECT_EQ("int a; // line about a\n" 2799 "// line about b\n" 2800 "long b;", 2801 format("int a; // line about a\n" 2802 " // line about b\n" 2803 " long b;", 2804 getLLVMStyleWithColumns(80))); 2805 EXPECT_EQ("int a; // line about a\n" 2806 "// line 1 about b\n" 2807 "// line 2 about b\n" 2808 "long b;", 2809 format("int a; // line about a\n" 2810 " // line 1 about b\n" 2811 " // line 2 about b\n" 2812 " long b;", 2813 getLLVMStyleWithColumns(80))); 2814 2815 // Checks an edge case in preprocessor handling. 2816 // These comments should *not* be aligned 2817 EXPECT_NE( // change for EQ when fixed 2818 "#if FOO\n" 2819 "#else\n" 2820 "long a; // Line about a\n" 2821 "#endif\n" 2822 "#if BAR\n" 2823 "#else\n" 2824 "long b_long_name; // Line about b\n" 2825 "#endif\n", 2826 format("#if FOO\n" 2827 "#else\n" 2828 "long a; // Line about a\n" // Previous (bad) behavior 2829 "#endif\n" 2830 "#if BAR\n" 2831 "#else\n" 2832 "long b_long_name; // Line about b\n" 2833 "#endif\n", 2834 getLLVMStyleWithColumns(80))); 2835 2836 // bug 47589 2837 EXPECT_EQ( 2838 "namespace m {\n\n" 2839 "#define FOO_GLOBAL 0 // Global scope.\n" 2840 "#define FOO_LINKLOCAL 1 // Link-local scope.\n" 2841 "#define FOO_SITELOCAL 2 // Site-local scope (deprecated).\n" 2842 "#define FOO_UNIQUELOCAL 3 // Unique local\n" 2843 "#define FOO_NODELOCAL 4 // Loopback\n\n" 2844 "} // namespace m\n", 2845 format("namespace m {\n\n" 2846 "#define FOO_GLOBAL 0 // Global scope.\n" 2847 "#define FOO_LINKLOCAL 1 // Link-local scope.\n" 2848 "#define FOO_SITELOCAL 2 // Site-local scope (deprecated).\n" 2849 "#define FOO_UNIQUELOCAL 3 // Unique local\n" 2850 "#define FOO_NODELOCAL 4 // Loopback\n\n" 2851 "} // namespace m\n", 2852 getLLVMStyleWithColumns(80))); 2853 2854 // https://llvm.org/PR53441 2855 verifyFormat("/* */ //\n" 2856 "int a; //\n"); 2857 verifyFormat("/**/ //\n" 2858 "int a; //\n"); 2859 } 2860 2861 TEST_F(FormatTestComments, AlignsBlockCommentDecorations) { 2862 EXPECT_EQ("/*\n" 2863 " */", 2864 format("/*\n" 2865 "*/", 2866 getLLVMStyle())); 2867 EXPECT_EQ("/*\n" 2868 " */", 2869 format("/*\n" 2870 " */", 2871 getLLVMStyle())); 2872 EXPECT_EQ("/*\n" 2873 " */", 2874 format("/*\n" 2875 " */", 2876 getLLVMStyle())); 2877 2878 // Align a single line. 2879 EXPECT_EQ("/*\n" 2880 " * line */", 2881 format("/*\n" 2882 "* line */", 2883 getLLVMStyle())); 2884 EXPECT_EQ("/*\n" 2885 " * line */", 2886 format("/*\n" 2887 " * line */", 2888 getLLVMStyle())); 2889 EXPECT_EQ("/*\n" 2890 " * line */", 2891 format("/*\n" 2892 " * line */", 2893 getLLVMStyle())); 2894 EXPECT_EQ("/*\n" 2895 " * line */", 2896 format("/*\n" 2897 " * line */", 2898 getLLVMStyle())); 2899 EXPECT_EQ("/**\n" 2900 " * line */", 2901 format("/**\n" 2902 "* line */", 2903 getLLVMStyle())); 2904 EXPECT_EQ("/**\n" 2905 " * line */", 2906 format("/**\n" 2907 " * line */", 2908 getLLVMStyle())); 2909 EXPECT_EQ("/**\n" 2910 " * line */", 2911 format("/**\n" 2912 " * line */", 2913 getLLVMStyle())); 2914 EXPECT_EQ("/**\n" 2915 " * line */", 2916 format("/**\n" 2917 " * line */", 2918 getLLVMStyle())); 2919 EXPECT_EQ("/**\n" 2920 " * line */", 2921 format("/**\n" 2922 " * line */", 2923 getLLVMStyle())); 2924 2925 // Align the end '*/' after a line. 2926 EXPECT_EQ("/*\n" 2927 " * line\n" 2928 " */", 2929 format("/*\n" 2930 "* line\n" 2931 "*/", 2932 getLLVMStyle())); 2933 EXPECT_EQ("/*\n" 2934 " * line\n" 2935 " */", 2936 format("/*\n" 2937 " * line\n" 2938 " */", 2939 getLLVMStyle())); 2940 EXPECT_EQ("/*\n" 2941 " * line\n" 2942 " */", 2943 format("/*\n" 2944 " * line\n" 2945 " */", 2946 getLLVMStyle())); 2947 2948 // Align two lines. 2949 EXPECT_EQ("/* line 1\n" 2950 " * line 2 */", 2951 format("/* line 1\n" 2952 " * line 2 */", 2953 getLLVMStyle())); 2954 EXPECT_EQ("/* line 1\n" 2955 " * line 2 */", 2956 format("/* line 1\n" 2957 "* line 2 */", 2958 getLLVMStyle())); 2959 EXPECT_EQ("/* line 1\n" 2960 " * line 2 */", 2961 format("/* line 1\n" 2962 " * line 2 */", 2963 getLLVMStyle())); 2964 EXPECT_EQ("/* line 1\n" 2965 " * line 2 */", 2966 format("/* line 1\n" 2967 " * line 2 */", 2968 getLLVMStyle())); 2969 EXPECT_EQ("/* line 1\n" 2970 " * line 2 */", 2971 format("/* line 1\n" 2972 " * line 2 */", 2973 getLLVMStyle())); 2974 EXPECT_EQ("int i; /* line 1\n" 2975 " * line 2 */", 2976 format("int i; /* line 1\n" 2977 "* line 2 */", 2978 getLLVMStyle())); 2979 EXPECT_EQ("int i; /* line 1\n" 2980 " * line 2 */", 2981 format("int i; /* line 1\n" 2982 " * line 2 */", 2983 getLLVMStyle())); 2984 EXPECT_EQ("int i; /* line 1\n" 2985 " * line 2 */", 2986 format("int i; /* line 1\n" 2987 " * line 2 */", 2988 getLLVMStyle())); 2989 2990 // Align several lines. 2991 EXPECT_EQ("/* line 1\n" 2992 " * line 2\n" 2993 " * line 3 */", 2994 format("/* line 1\n" 2995 " * line 2\n" 2996 "* line 3 */", 2997 getLLVMStyle())); 2998 EXPECT_EQ("/* line 1\n" 2999 " * line 2\n" 3000 " * line 3 */", 3001 format("/* line 1\n" 3002 " * line 2\n" 3003 "* line 3 */", 3004 getLLVMStyle())); 3005 EXPECT_EQ("/*\n" 3006 "** line 1\n" 3007 "** line 2\n" 3008 "*/", 3009 format("/*\n" 3010 "** line 1\n" 3011 " ** line 2\n" 3012 "*/", 3013 getLLVMStyle())); 3014 3015 // Align with different indent after the decorations. 3016 EXPECT_EQ("/*\n" 3017 " * line 1\n" 3018 " * line 2\n" 3019 " * line 3\n" 3020 " * line 4\n" 3021 " */", 3022 format("/*\n" 3023 "* line 1\n" 3024 " * line 2\n" 3025 " * line 3\n" 3026 "* line 4\n" 3027 "*/", 3028 getLLVMStyle())); 3029 3030 // Align empty or blank lines. 3031 EXPECT_EQ("/**\n" 3032 " *\n" 3033 " *\n" 3034 " *\n" 3035 " */", 3036 format("/**\n" 3037 "* \n" 3038 " * \n" 3039 " *\n" 3040 "*/", 3041 getLLVMStyle())); 3042 3043 // Align while breaking and reflowing. 3044 EXPECT_EQ("/*\n" 3045 " * long long long\n" 3046 " * long long\n" 3047 " *\n" 3048 " * long */", 3049 format("/*\n" 3050 " * long long long long\n" 3051 " * long\n" 3052 " *\n" 3053 "* long */", 3054 getLLVMStyleWithColumns(20))); 3055 } 3056 3057 TEST_F(FormatTestComments, NoCrash_Bug34236) { 3058 // This is a test case from a crasher reported in: 3059 // https://bugs.llvm.org/show_bug.cgi?id=34236 3060 // Temporarily disable formatting for readability. 3061 // clang-format off 3062 EXPECT_EQ( 3063 "/* */ /*\n" 3064 " * a\n" 3065 " * b c d*/", 3066 format( 3067 "/* */ /*\n" 3068 " * a b\n" 3069 " * c d*/", 3070 getLLVMStyleWithColumns(80))); 3071 // clang-format on 3072 } 3073 3074 TEST_F(FormatTestComments, NonTrailingBlockComments) { 3075 verifyFormat("const /** comment comment */ A = B;", 3076 getLLVMStyleWithColumns(40)); 3077 3078 verifyFormat("const /** comment comment comment */ A =\n" 3079 " B;", 3080 getLLVMStyleWithColumns(40)); 3081 3082 EXPECT_EQ("const /** comment comment comment\n" 3083 " comment */\n" 3084 " A = B;", 3085 format("const /** comment comment comment comment */\n" 3086 " A = B;", 3087 getLLVMStyleWithColumns(40))); 3088 } 3089 3090 TEST_F(FormatTestComments, PythonStyleComments) { 3091 // Keeps a space after '#'. 3092 EXPECT_EQ("# comment\n" 3093 "key: value", 3094 format("#comment\n" 3095 "key:value", 3096 getTextProtoStyleWithColumns(20))); 3097 EXPECT_EQ("# comment\n" 3098 "key: value", 3099 format("# comment\n" 3100 "key:value", 3101 getTextProtoStyleWithColumns(20))); 3102 // Breaks long comment. 3103 EXPECT_EQ("# comment comment\n" 3104 "# comment\n" 3105 "key: value", 3106 format("# comment comment comment\n" 3107 "key:value", 3108 getTextProtoStyleWithColumns(20))); 3109 // Indents comments. 3110 EXPECT_EQ("data {\n" 3111 " # comment comment\n" 3112 " # comment\n" 3113 " key: value\n" 3114 "}", 3115 format("data {\n" 3116 "# comment comment comment\n" 3117 "key: value}", 3118 getTextProtoStyleWithColumns(20))); 3119 EXPECT_EQ("data {\n" 3120 " # comment comment\n" 3121 " # comment\n" 3122 " key: value\n" 3123 "}", 3124 format("data {# comment comment comment\n" 3125 "key: value}", 3126 getTextProtoStyleWithColumns(20))); 3127 // Reflows long comments. 3128 EXPECT_EQ("# comment comment\n" 3129 "# comment comment\n" 3130 "key: value", 3131 format("# comment comment comment\n" 3132 "# comment\n" 3133 "key:value", 3134 getTextProtoStyleWithColumns(20))); 3135 // Breaks trailing comments. 3136 EXPECT_EQ("k: val # comment\n" 3137 " # comment\n" 3138 "a: 1", 3139 format("k:val#comment comment\n" 3140 "a:1", 3141 getTextProtoStyleWithColumns(20))); 3142 EXPECT_EQ("id {\n" 3143 " k: val # comment\n" 3144 " # comment\n" 3145 " # line line\n" 3146 " a: 1\n" 3147 "}", 3148 format("id {k:val#comment comment\n" 3149 "# line line\n" 3150 "a:1}", 3151 getTextProtoStyleWithColumns(20))); 3152 // Aligns trailing comments. 3153 EXPECT_EQ("k: val # commen1\n" 3154 " # commen2\n" 3155 " # commen3\n" 3156 "# commen4\n" 3157 "a: 1 # commen5\n" 3158 " # commen6\n" 3159 " # commen7", 3160 format("k:val#commen1 commen2\n" 3161 " #commen3\n" 3162 "# commen4\n" 3163 "a:1#commen5 commen6\n" 3164 " #commen7", 3165 getTextProtoStyleWithColumns(20))); 3166 } 3167 3168 TEST_F(FormatTestComments, BreaksBeforeTrailingUnbreakableSequence) { 3169 // The end of /* trail */ is exactly at 80 columns, but the unbreakable 3170 // trailing sequence ); after it exceeds the column limit. Make sure we 3171 // correctly break the line in that case. 3172 verifyFormat("int a =\n" 3173 " foo(/* trail */);", 3174 getLLVMStyleWithColumns(23)); 3175 } 3176 3177 TEST_F(FormatTestComments, ReflowBackslashCrash) { 3178 // clang-format off 3179 EXPECT_EQ( 3180 "// How to run:\n" 3181 "// bbbbb run \\\n" 3182 "// rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr\n" 3183 "// \\ <log_file> -- --output_directory=\"<output_directory>\"", 3184 format( 3185 "// How to run:\n" 3186 "// bbbbb run \\\n" 3187 "// rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr \\\n" 3188 "// <log_file> -- --output_directory=\"<output_directory>\"")); 3189 // clang-format on 3190 } 3191 3192 TEST_F(FormatTestComments, IndentsLongJavadocAnnotatedLines) { 3193 FormatStyle Style = getGoogleStyle(FormatStyle::LK_Java); 3194 Style.ColumnLimit = 60; 3195 FormatStyle Style20 = getGoogleStyle(FormatStyle::LK_Java); 3196 Style20.ColumnLimit = 20; 3197 EXPECT_EQ( 3198 "/**\n" 3199 " * @param x long long long long long long long long long\n" 3200 " * long\n" 3201 " */\n", 3202 format("/**\n" 3203 " * @param x long long long long long long long long long long\n" 3204 " */\n", 3205 Style)); 3206 EXPECT_EQ("/**\n" 3207 " * @param x long long long long long long long long long\n" 3208 " * long long long long long long long long long long\n" 3209 " */\n", 3210 format("/**\n" 3211 " * @param x long long long long long long long long long " 3212 "long long long long long long long long long long\n" 3213 " */\n", 3214 Style)); 3215 EXPECT_EQ("/**\n" 3216 " * @param x long long long long long long long long long\n" 3217 " * long long long long long long long long long long\n" 3218 " * long\n" 3219 " */\n", 3220 format("/**\n" 3221 " * @param x long long long long long long long long long " 3222 "long long long long long long long long long long long\n" 3223 " */\n", 3224 Style)); 3225 EXPECT_EQ("/**\n" 3226 " * Sentence that\n" 3227 " * should be broken.\n" 3228 " * @param short\n" 3229 " * keep indentation\n" 3230 " */\n", 3231 format("/**\n" 3232 " * Sentence that should be broken.\n" 3233 " * @param short\n" 3234 " * keep indentation\n" 3235 " */\n", 3236 Style20)); 3237 3238 EXPECT_EQ("/**\n" 3239 " * @param l1 long1\n" 3240 " * to break\n" 3241 " * @param l2 long2\n" 3242 " * to break\n" 3243 " */\n", 3244 format("/**\n" 3245 " * @param l1 long1 to break\n" 3246 " * @param l2 long2 to break\n" 3247 " */\n", 3248 Style20)); 3249 3250 EXPECT_EQ("/**\n" 3251 " * @param xx to\n" 3252 " * break\n" 3253 " * no reflow\n" 3254 " */\n", 3255 format("/**\n" 3256 " * @param xx to break\n" 3257 " * no reflow\n" 3258 " */\n", 3259 Style20)); 3260 3261 EXPECT_EQ("/**\n" 3262 " * @param xx to\n" 3263 " * break yes\n" 3264 " * reflow\n" 3265 " */\n", 3266 format("/**\n" 3267 " * @param xx to break\n" 3268 " * yes reflow\n" 3269 " */\n", 3270 Style20)); 3271 3272 FormatStyle JSStyle20 = getGoogleStyle(FormatStyle::LK_JavaScript); 3273 JSStyle20.ColumnLimit = 20; 3274 EXPECT_EQ("/**\n" 3275 " * @param l1 long1\n" 3276 " * to break\n" 3277 " */\n", 3278 format("/**\n" 3279 " * @param l1 long1 to break\n" 3280 " */\n", 3281 JSStyle20)); 3282 EXPECT_EQ("/**\n" 3283 " * @param {l1 long1\n" 3284 " * to break}\n" 3285 " */\n", 3286 format("/**\n" 3287 " * @param {l1 long1 to break}\n" 3288 " */\n", 3289 JSStyle20)); 3290 } 3291 3292 TEST_F(FormatTestComments, SpaceAtLineCommentBegin) { 3293 FormatStyle Style = getLLVMStyle(); 3294 StringRef NoTextInComment = " // \n" 3295 "\n" 3296 "void foo() {// \n" 3297 "// \n" 3298 "}"; 3299 3300 EXPECT_EQ("//\n" 3301 "\n" 3302 "void foo() { //\n" 3303 " //\n" 3304 "}", 3305 format(NoTextInComment, Style)); 3306 3307 Style.SpacesInLineCommentPrefix.Minimum = 0; 3308 EXPECT_EQ("//#comment", format("//#comment", Style)); 3309 EXPECT_EQ("//\n" 3310 "\n" 3311 "void foo() { //\n" 3312 " //\n" 3313 "}", 3314 format(NoTextInComment, Style)); 3315 3316 Style.SpacesInLineCommentPrefix.Minimum = 5; 3317 EXPECT_EQ("// #comment", format("//#comment", Style)); 3318 EXPECT_EQ("//\n" 3319 "\n" 3320 "void foo() { //\n" 3321 " //\n" 3322 "}", 3323 format(NoTextInComment, Style)); 3324 3325 Style = getLLVMStyle(); 3326 StringRef Code = 3327 "//Free comment without space\n" 3328 "\n" 3329 "// Free comment with 3 spaces\n" 3330 "\n" 3331 "///Free Doxygen without space\n" 3332 "\n" 3333 "/// Free Doxygen with 3 spaces\n" 3334 "\n" 3335 "//�� A nice dragon\n" 3336 "\n" 3337 "//\t abccba\n" 3338 "\n" 3339 "//\\t deffed\n" 3340 "\n" 3341 "// �� Another nice dragon\n" 3342 "\n" 3343 "// \t Three leading spaces following tab\n" 3344 "\n" 3345 "// \\t Three leading spaces following backslash\n" 3346 "\n" 3347 "/// A Doxygen Comment with a nested list:\n" 3348 "/// - Foo\n" 3349 "/// - Bar\n" 3350 "/// - Baz\n" 3351 "/// - End\n" 3352 "/// of the inner list\n" 3353 "/// .\n" 3354 "/// .\n" 3355 "\n" 3356 "namespace Foo {\n" 3357 "bool bar(bool b) {\n" 3358 " bool ret1 = true; ///<Doxygenstyle without space\n" 3359 " bool ret2 = true; ///< Doxygenstyle with 3 spaces\n" 3360 " if (b) {\n" 3361 " //Foo\n" 3362 "\n" 3363 " // In function comment\n" 3364 " ret2 = false;\n" 3365 " } // End of if\n" 3366 "\n" 3367 "// if (ret1) {\n" // Commented out at the beginning of the line 3368 "// return ret2;\n" 3369 "// }\n" 3370 "\n" 3371 " //if (ret1) {\n" // Commtented out at the beginning of the content 3372 " // return ret2;\n" 3373 " //}\n" 3374 "\n" 3375 " return ret1 && ret2;\n" 3376 "}\n" 3377 "}\n" 3378 "\n" 3379 "namespace Bar {\n" 3380 "int foo();\n" 3381 "} // namespace Bar\n" 3382 "//@Nothing added because of the non ascii char\n" 3383 "\n" 3384 "//@ Nothing removed because of the non ascii char\n" 3385 "\n" 3386 "// Comment to move to the left\n" 3387 "//But not this?\n" 3388 "// @but this\n" 3389 "\n" 3390 "//Comment to move to the right\n" 3391 "//@ this stays\n" 3392 "\n" 3393 "//} will not move\n" 3394 "\n" 3395 "//vv will only move\n" 3396 "//} if the line above does\n"; 3397 3398 EXPECT_EQ("// Free comment without space\n" 3399 "\n" 3400 "// Free comment with 3 spaces\n" 3401 "\n" 3402 "/// Free Doxygen without space\n" 3403 "\n" 3404 "/// Free Doxygen with 3 spaces\n" 3405 "\n" 3406 "// �� A nice dragon\n" 3407 "\n" 3408 "//\t abccba\n" 3409 "\n" 3410 "//\\t deffed\n" 3411 "\n" 3412 "// �� Another nice dragon\n" 3413 "\n" 3414 "// \t Three leading spaces following tab\n" 3415 "\n" 3416 "// \\t Three leading spaces following backslash\n" 3417 "\n" 3418 "/// A Doxygen Comment with a nested list:\n" 3419 "/// - Foo\n" 3420 "/// - Bar\n" 3421 "/// - Baz\n" 3422 "/// - End\n" 3423 "/// of the inner list\n" 3424 "/// .\n" 3425 "/// .\n" 3426 "\n" 3427 "namespace Foo {\n" 3428 "bool bar(bool b) {\n" 3429 " bool ret1 = true; ///< Doxygenstyle without space\n" 3430 " bool ret2 = true; ///< Doxygenstyle with 3 spaces\n" 3431 " if (b) {\n" 3432 " // Foo\n" 3433 "\n" 3434 " // In function comment\n" 3435 " ret2 = false;\n" 3436 " } // End of if\n" 3437 "\n" 3438 " // if (ret1) {\n" 3439 " // return ret2;\n" 3440 " // }\n" 3441 "\n" 3442 " // if (ret1) {\n" 3443 " // return ret2;\n" 3444 " // }\n" 3445 "\n" 3446 " return ret1 && ret2;\n" 3447 "}\n" 3448 "} // namespace Foo\n" 3449 "\n" 3450 "namespace Bar {\n" 3451 "int foo();\n" 3452 "} // namespace Bar\n" 3453 "//@Nothing added because of the non ascii char\n" 3454 "\n" 3455 "//@ Nothing removed because of the non ascii char\n" 3456 "\n" 3457 "// Comment to move to the left\n" 3458 "// But not this?\n" 3459 "// @but this\n" 3460 "\n" 3461 "// Comment to move to the right\n" 3462 "//@ this stays\n" 3463 "\n" 3464 "//} will not move\n" 3465 "\n" 3466 "// vv will only move\n" 3467 "// } if the line above does\n", 3468 format(Code, Style)); 3469 3470 Style.SpacesInLineCommentPrefix = {0, 0}; 3471 EXPECT_EQ("//#comment", format("// #comment", Style)); 3472 EXPECT_EQ("//Free comment without space\n" 3473 "\n" 3474 "//Free comment with 3 spaces\n" 3475 "\n" 3476 "///Free Doxygen without space\n" 3477 "\n" 3478 "///Free Doxygen with 3 spaces\n" 3479 "\n" 3480 "//�� A nice dragon\n" 3481 "\n" 3482 "//\t abccba\n" 3483 "\n" 3484 "//\\t deffed\n" 3485 "\n" 3486 "//�� Another nice dragon\n" 3487 "\n" 3488 "//\t Three leading spaces following tab\n" 3489 "\n" 3490 "//\\t Three leading spaces following backslash\n" 3491 "\n" 3492 "///A Doxygen Comment with a nested list:\n" 3493 "///- Foo\n" 3494 "///- Bar\n" 3495 "/// - Baz\n" // Here we keep the relative indentation 3496 "/// - End\n" 3497 "/// of the inner list\n" 3498 "/// .\n" 3499 "///.\n" 3500 "\n" 3501 "namespace Foo {\n" 3502 "bool bar(bool b) {\n" 3503 " bool ret1 = true; ///<Doxygenstyle without space\n" 3504 " bool ret2 = true; ///<Doxygenstyle with 3 spaces\n" 3505 " if (b) {\n" 3506 " //Foo\n" 3507 "\n" 3508 " //In function comment\n" 3509 " ret2 = false;\n" 3510 " } //End of if\n" 3511 "\n" 3512 " //if (ret1) {\n" 3513 " // return ret2;\n" 3514 " //}\n" 3515 "\n" 3516 " //if (ret1) {\n" 3517 " // return ret2;\n" 3518 " //}\n" 3519 "\n" 3520 " return ret1 && ret2;\n" 3521 "}\n" 3522 "} //namespace Foo\n" 3523 "\n" 3524 "namespace Bar {\n" 3525 "int foo();\n" 3526 "} //namespace Bar\n" 3527 "//@Nothing added because of the non ascii char\n" 3528 "\n" 3529 "//@ Nothing removed because of the non ascii char\n" 3530 "\n" 3531 "//Comment to move to the left\n" 3532 "//But not this?\n" 3533 "//@but this\n" 3534 "\n" 3535 "//Comment to move to the right\n" 3536 "//@ this stays\n" 3537 "\n" 3538 "//} will not move\n" 3539 "\n" 3540 "//vv will only move\n" 3541 "//} if the line above does\n", 3542 format(Code, Style)); 3543 3544 Style.SpacesInLineCommentPrefix = {2, -1u}; 3545 EXPECT_EQ("// Free comment without space\n" 3546 "\n" 3547 "// Free comment with 3 spaces\n" 3548 "\n" 3549 "/// Free Doxygen without space\n" 3550 "\n" 3551 "/// Free Doxygen with 3 spaces\n" 3552 "\n" 3553 "// �� A nice dragon\n" 3554 "\n" 3555 "//\t abccba\n" 3556 "\n" 3557 "//\\t deffed\n" 3558 "\n" 3559 "// �� Another nice dragon\n" 3560 "\n" 3561 "// \t Three leading spaces following tab\n" 3562 "\n" 3563 "// \\t Three leading spaces following backslash\n" 3564 "\n" 3565 "/// A Doxygen Comment with a nested list:\n" 3566 "/// - Foo\n" 3567 "/// - Bar\n" 3568 "/// - Baz\n" 3569 "/// - End\n" 3570 "/// of the inner list\n" 3571 "/// .\n" 3572 "/// .\n" 3573 "\n" 3574 "namespace Foo {\n" 3575 "bool bar(bool b) {\n" 3576 " bool ret1 = true; ///< Doxygenstyle without space\n" 3577 " bool ret2 = true; ///< Doxygenstyle with 3 spaces\n" 3578 " if (b) {\n" 3579 " // Foo\n" 3580 "\n" 3581 " // In function comment\n" 3582 " ret2 = false;\n" 3583 " } // End of if\n" 3584 "\n" 3585 " // if (ret1) {\n" 3586 " // return ret2;\n" 3587 " // }\n" 3588 "\n" 3589 " // if (ret1) {\n" 3590 " // return ret2;\n" 3591 " // }\n" 3592 "\n" 3593 " return ret1 && ret2;\n" 3594 "}\n" 3595 "} // namespace Foo\n" 3596 "\n" 3597 "namespace Bar {\n" 3598 "int foo();\n" 3599 "} // namespace Bar\n" 3600 "//@Nothing added because of the non ascii char\n" 3601 "\n" 3602 "//@ Nothing removed because of the non ascii char\n" 3603 "\n" 3604 "// Comment to move to the left\n" 3605 "// But not this?\n" 3606 "// @but this\n" 3607 "\n" 3608 "// Comment to move to the right\n" 3609 "//@ this stays\n" 3610 "\n" 3611 "//} will not move\n" 3612 "\n" 3613 "// vv will only move\n" 3614 "// } if the line above does\n", 3615 format(Code, Style)); 3616 3617 Style = getLLVMStyleWithColumns(20); 3618 StringRef WrapCode = "//Lorem ipsum dolor sit amet\n" 3619 "\n" 3620 "// Lorem ipsum dolor sit amet\n" 3621 "\n" 3622 "void f() {//Hello World\n" 3623 "}"; 3624 3625 EXPECT_EQ("// Lorem ipsum dolor\n" 3626 "// sit amet\n" 3627 "\n" 3628 "// Lorem ipsum\n" 3629 "// dolor sit amet\n" 3630 "\n" 3631 "void f() { // Hello\n" 3632 " // World\n" 3633 "}", 3634 format(WrapCode, Style)); 3635 3636 Style.SpacesInLineCommentPrefix = {0, 0}; 3637 EXPECT_EQ("//Lorem ipsum dolor\n" 3638 "//sit amet\n" 3639 "\n" 3640 "//Lorem ipsum\n" 3641 "//dolor sit amet\n" 3642 "\n" 3643 "void f() { //Hello\n" 3644 " //World\n" 3645 "}", 3646 format(WrapCode, Style)); 3647 3648 Style.SpacesInLineCommentPrefix = {1, 1}; 3649 EXPECT_EQ("// Lorem ipsum dolor\n" 3650 "// sit amet\n" 3651 "\n" 3652 "// Lorem ipsum\n" 3653 "// dolor sit amet\n" 3654 "\n" 3655 "void f() { // Hello\n" 3656 " // World\n" 3657 "}", 3658 format(WrapCode, Style)); 3659 EXPECT_EQ("// x\n" 3660 "// y", 3661 format("// x\n" 3662 "// y", 3663 Style)); 3664 EXPECT_EQ( 3665 "// loooooooooooooooooooooooooooooong\n" 3666 "// commentcomments\n" 3667 "// normal comments", 3668 format("// loooooooooooooooooooooooooooooong commentcomments\n" 3669 "// normal comments", 3670 Style)); 3671 3672 Style.SpacesInLineCommentPrefix = {3, 3}; 3673 EXPECT_EQ("// Lorem ipsum\n" 3674 "// dolor sit amet\n" 3675 "\n" 3676 "// Lorem ipsum\n" 3677 "// dolor sit\n" 3678 "// amet\n" 3679 "\n" 3680 "void f() { // Hello\n" 3681 " // World\n" 3682 "}", 3683 format(WrapCode, Style)); 3684 3685 Style = getLLVMStyleWithColumns(20); 3686 StringRef LotsOfSpaces = "// This are more spaces " 3687 "than the ColumnLimit, what now?\n" 3688 "\n" 3689 "// Comment\n" 3690 "\n" 3691 "// This is a text to split in multiple " 3692 "lines, please. Thank you very much!\n" 3693 "\n" 3694 "// A comment with\n" 3695 "// some indentation that has to be split.\n" 3696 "// And now without"; 3697 EXPECT_EQ("// This are more spaces " 3698 "than the ColumnLimit, what now?\n" 3699 "\n" 3700 "// Comment\n" 3701 "\n" 3702 "// This is a text to\n" 3703 "// split in multiple\n" 3704 "// lines, please.\n" 3705 "// Thank you very\n" 3706 "// much!\n" 3707 "\n" 3708 "// A comment with\n" 3709 "// some\n" 3710 "// indentation\n" 3711 "// that has to be\n" 3712 "// split.\n" 3713 "// And now without", 3714 format(LotsOfSpaces, Style)); 3715 3716 Style.SpacesInLineCommentPrefix = {0, 0}; 3717 EXPECT_EQ("//This are more\n" 3718 "//spaces than the\n" 3719 "//ColumnLimit, what\n" 3720 "//now?\n" 3721 "\n" 3722 "//Comment\n" 3723 "\n" 3724 "//This is a text to\n" 3725 "//split in multiple\n" 3726 "//lines, please.\n" 3727 "//Thank you very\n" 3728 "//much!\n" 3729 "\n" 3730 "//A comment with\n" 3731 "// some indentation\n" 3732 "// that has to be\n" 3733 "// split.\n" 3734 "//And now without", 3735 format(LotsOfSpaces, Style)); 3736 3737 Style.SpacesInLineCommentPrefix = {3, 3}; 3738 EXPECT_EQ("// This are more\n" 3739 "// spaces than the\n" 3740 "// ColumnLimit,\n" 3741 "// what now?\n" 3742 "\n" 3743 "// Comment\n" 3744 "\n" 3745 "// This is a text\n" 3746 "// to split in\n" 3747 "// multiple lines,\n" 3748 "// please. Thank\n" 3749 "// you very much!\n" 3750 "\n" 3751 "// A comment with\n" 3752 "// some\n" 3753 "// indentation\n" 3754 "// that has to\n" 3755 "// be split.\n" 3756 "// And now without", 3757 format(LotsOfSpaces, Style)); 3758 3759 Style.SpacesInLineCommentPrefix = {30, -1u}; 3760 EXPECT_EQ("// This are more spaces than the " 3761 "ColumnLimit, what now?\n" 3762 "\n" 3763 "// Comment\n" 3764 "\n" 3765 "// This is a text to split in " 3766 "multiple lines, please. Thank you very much!\n" 3767 "\n" 3768 "// A comment with\n" 3769 "// some indentation that has to be " 3770 "split.\n" 3771 "// And now without", 3772 format(LotsOfSpaces, Style)); 3773 3774 Style.SpacesInLineCommentPrefix = {2, 4}; 3775 EXPECT_EQ("// A Comment to be\n" 3776 "// moved\n" 3777 "// with indent\n" 3778 "\n" 3779 "// A Comment to be\n" 3780 "// moved\n" 3781 "// with indent\n" 3782 "\n" 3783 "// A Comment to be\n" 3784 "// moved\n" 3785 "// with indent\n" 3786 "\n" 3787 "// A Comment to be\n" 3788 "// moved\n" 3789 "// with indent\n" 3790 "\n" 3791 "// A Comment to\n" 3792 "// be moved\n" 3793 "// with indent\n" 3794 "\n" 3795 "// A Comment to\n" 3796 "// be moved\n" 3797 "// with indent\n" 3798 "\n" 3799 "// A Comment to\n" 3800 "// be moved\n" 3801 "// with indent\n", 3802 format("//A Comment to be moved\n" 3803 "// with indent\n" 3804 "\n" 3805 "// A Comment to be moved\n" 3806 "// with indent\n" 3807 "\n" 3808 "// A Comment to be moved\n" 3809 "// with indent\n" 3810 "\n" 3811 "// A Comment to be moved\n" 3812 "// with indent\n" 3813 "\n" 3814 "// A Comment to be moved\n" 3815 "// with indent\n" 3816 "\n" 3817 "// A Comment to be moved\n" 3818 "// with indent\n" 3819 "\n" 3820 "// A Comment to be moved\n" 3821 "// with indent\n", 3822 Style)); 3823 3824 Style.ColumnLimit = 30; 3825 EXPECT_EQ("int i; // A Comment to be\n" 3826 " // moved\n" 3827 " // with indent\n" 3828 "\n" 3829 "int i; // A Comment to be\n" 3830 " // moved\n" 3831 " // with indent\n" 3832 "\n" 3833 "int i; // A Comment to be\n" 3834 " // moved\n" 3835 " // with indent\n" 3836 "\n" 3837 "int i; // A Comment to be\n" 3838 " // moved\n" 3839 " // with indent\n" 3840 "\n" 3841 "int i; // A Comment to be\n" 3842 " // moved\n" 3843 " // with indent\n" 3844 "\n" 3845 "int i; // A Comment to be\n" 3846 " // moved\n" 3847 " // with indent\n" 3848 "\n" 3849 "int i; // A Comment to be\n" 3850 " // moved\n" 3851 " // with indent\n", 3852 format("int i;//A Comment to be moved\n" 3853 " // with indent\n" 3854 "\n" 3855 "int i;// A Comment to be moved\n" 3856 " // with indent\n" 3857 "\n" 3858 "int i;// A Comment to be moved\n" 3859 " // with indent\n" 3860 "\n" 3861 "int i;// A Comment to be moved\n" 3862 " // with indent\n" 3863 "\n" 3864 "int i;// A Comment to be moved\n" 3865 " // with indent\n" 3866 "\n" 3867 "int i;// A Comment to be moved\n" 3868 " // with indent\n" 3869 "\n" 3870 "int i;// A Comment to be moved\n" 3871 " // with indent\n", 3872 Style)); 3873 3874 Style = getLLVMStyleWithColumns(0); 3875 EXPECT_EQ("// Free comment without space\n" 3876 "\n" 3877 "// Free comment with 3 spaces\n" 3878 "\n" 3879 "/// Free Doxygen without space\n" 3880 "\n" 3881 "/// Free Doxygen with 3 spaces\n" 3882 "\n" 3883 "// �� A nice dragon\n" 3884 "\n" 3885 "//\t abccba\n" 3886 "\n" 3887 "//\\t deffed\n" 3888 "\n" 3889 "// �� Another nice dragon\n" 3890 "\n" 3891 "// \t Three leading spaces following tab\n" 3892 "\n" 3893 "// \\t Three leading spaces following backslash\n" 3894 "\n" 3895 "/// A Doxygen Comment with a nested list:\n" 3896 "/// - Foo\n" 3897 "/// - Bar\n" 3898 "/// - Baz\n" 3899 "/// - End\n" 3900 "/// of the inner list\n" 3901 "/// .\n" 3902 "/// .\n" 3903 "\n" 3904 "namespace Foo {\n" 3905 "bool bar(bool b) {\n" 3906 " bool ret1 = true; ///< Doxygenstyle without space\n" 3907 " bool ret2 = true; ///< Doxygenstyle with 3 spaces\n" 3908 " if (b) {\n" 3909 " // Foo\n" 3910 "\n" 3911 " // In function comment\n" 3912 " ret2 = false;\n" 3913 " } // End of if\n" 3914 "\n" 3915 " // if (ret1) {\n" 3916 " // return ret2;\n" 3917 " // }\n" 3918 "\n" 3919 " // if (ret1) {\n" 3920 " // return ret2;\n" 3921 " // }\n" 3922 "\n" 3923 " return ret1 && ret2;\n" 3924 "}\n" 3925 "} // namespace Foo\n" 3926 "\n" 3927 "namespace Bar {\n" 3928 "int foo();\n" 3929 "} // namespace Bar\n" 3930 "//@Nothing added because of the non ascii char\n" 3931 "\n" 3932 "//@ Nothing removed because of the non ascii char\n" 3933 "\n" 3934 "// Comment to move to the left\n" 3935 "// But not this?\n" 3936 "// @but this\n" 3937 "\n" 3938 "// Comment to move to the right\n" 3939 "//@ this stays\n" 3940 "\n" 3941 "//} will not move\n" 3942 "\n" 3943 "// vv will only move\n" 3944 "// } if the line above does\n", 3945 format(Code, Style)); 3946 3947 Style.SpacesInLineCommentPrefix = {0, 0}; 3948 EXPECT_EQ("//Free comment without space\n" 3949 "\n" 3950 "//Free comment with 3 spaces\n" 3951 "\n" 3952 "///Free Doxygen without space\n" 3953 "\n" 3954 "///Free Doxygen with 3 spaces\n" 3955 "\n" 3956 "//�� A nice dragon\n" 3957 "\n" 3958 "//\t abccba\n" 3959 "\n" 3960 "//\\t deffed\n" 3961 "\n" 3962 "//�� Another nice dragon\n" 3963 "\n" 3964 "//\t Three leading spaces following tab\n" 3965 "\n" 3966 "//\\t Three leading spaces following backslash\n" 3967 "\n" 3968 "///A Doxygen Comment with a nested list:\n" 3969 "///- Foo\n" 3970 "///- Bar\n" 3971 "/// - Baz\n" // Here we keep the relative indentation 3972 "/// - End\n" 3973 "/// of the inner list\n" 3974 "/// .\n" 3975 "///.\n" 3976 "\n" 3977 "namespace Foo {\n" 3978 "bool bar(bool b) {\n" 3979 " bool ret1 = true; ///<Doxygenstyle without space\n" 3980 " bool ret2 = true; ///<Doxygenstyle with 3 spaces\n" 3981 " if (b) {\n" 3982 " //Foo\n" 3983 "\n" 3984 " //In function comment\n" 3985 " ret2 = false;\n" 3986 " } //End of if\n" 3987 "\n" 3988 " //if (ret1) {\n" 3989 " // return ret2;\n" 3990 " //}\n" 3991 "\n" 3992 " //if (ret1) {\n" 3993 " // return ret2;\n" 3994 " //}\n" 3995 "\n" 3996 " return ret1 && ret2;\n" 3997 "}\n" 3998 "} //namespace Foo\n" 3999 "\n" 4000 "namespace Bar {\n" 4001 "int foo();\n" 4002 "} //namespace Bar\n" 4003 "//@Nothing added because of the non ascii char\n" 4004 "\n" 4005 "//@ Nothing removed because of the non ascii char\n" 4006 "\n" 4007 "//Comment to move to the left\n" 4008 "//But not this?\n" 4009 "//@but this\n" 4010 "\n" 4011 "//Comment to move to the right\n" 4012 "//@ this stays\n" 4013 "\n" 4014 "//} will not move\n" 4015 "\n" 4016 "//vv will only move\n" 4017 "//} if the line above does\n", 4018 format(Code, Style)); 4019 4020 Style.SpacesInLineCommentPrefix = {2, -1u}; 4021 EXPECT_EQ("// Free comment without space\n" 4022 "\n" 4023 "// Free comment with 3 spaces\n" 4024 "\n" 4025 "/// Free Doxygen without space\n" 4026 "\n" 4027 "/// Free Doxygen with 3 spaces\n" 4028 "\n" 4029 "// �� A nice dragon\n" 4030 "\n" 4031 "//\t abccba\n" 4032 "\n" 4033 "//\\t deffed\n" 4034 "\n" 4035 "// �� Another nice dragon\n" 4036 "\n" 4037 "// \t Three leading spaces following tab\n" 4038 "\n" 4039 "// \\t Three leading spaces following backslash\n" 4040 "\n" 4041 "/// A Doxygen Comment with a nested list:\n" 4042 "/// - Foo\n" 4043 "/// - Bar\n" 4044 "/// - Baz\n" 4045 "/// - End\n" 4046 "/// of the inner list\n" 4047 "/// .\n" 4048 "/// .\n" 4049 "\n" 4050 "namespace Foo {\n" 4051 "bool bar(bool b) {\n" 4052 " bool ret1 = true; ///< Doxygenstyle without space\n" 4053 " bool ret2 = true; ///< Doxygenstyle with 3 spaces\n" 4054 " if (b) {\n" 4055 " // Foo\n" 4056 "\n" 4057 " // In function comment\n" 4058 " ret2 = false;\n" 4059 " } // End of if\n" 4060 "\n" 4061 " // if (ret1) {\n" 4062 " // return ret2;\n" 4063 " // }\n" 4064 "\n" 4065 " // if (ret1) {\n" 4066 " // return ret2;\n" 4067 " // }\n" 4068 "\n" 4069 " return ret1 && ret2;\n" 4070 "}\n" 4071 "} // namespace Foo\n" 4072 "\n" 4073 "namespace Bar {\n" 4074 "int foo();\n" 4075 "} // namespace Bar\n" 4076 "//@Nothing added because of the non ascii char\n" 4077 "\n" 4078 "//@ Nothing removed because of the non ascii char\n" 4079 "\n" 4080 "// Comment to move to the left\n" 4081 "// But not this?\n" 4082 "// @but this\n" 4083 "\n" 4084 "// Comment to move to the right\n" 4085 "//@ this stays\n" 4086 "\n" 4087 "//} will not move\n" 4088 "\n" 4089 "// vv will only move\n" 4090 "// } if the line above does\n", 4091 format(Code, Style)); 4092 } 4093 4094 TEST_F(FormatTestComments, SplitCommentIntroducers) { 4095 EXPECT_EQ(R"(// 4096 /\ 4097 / 4098 )", 4099 format(R"(// 4100 /\ 4101 / 4102 )", 4103 getLLVMStyleWithColumns(10))); 4104 } 4105 4106 } // end namespace 4107 } // end namespace format 4108 } // end namespace clang 4109