1 //===- unittest/Format/SortIncludesTest.cpp - Include sort 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 "FormatTestBase.h" 10 #include "clang/Format/Format.h" 11 #include "llvm/ADT/StringRef.h" 12 #include "llvm/Support/Debug.h" 13 #include "gtest/gtest.h" 14 15 #define DEBUG_TYPE "sort-includes-test" 16 17 namespace clang { 18 namespace format { 19 namespace { 20 21 class SortIncludesTest : public test::FormatTestBase { 22 protected: 23 std::vector<tooling::Range> GetCodeRange(StringRef Code) { 24 return std::vector<tooling::Range>(1, tooling::Range(0, Code.size())); 25 } 26 27 std::string sort(StringRef Code, std::vector<tooling::Range> Ranges, 28 StringRef FileName = "input.cc", 29 unsigned ExpectedNumRanges = 1) { 30 auto Replaces = sortIncludes(FmtStyle, Code, Ranges, FileName); 31 Ranges = tooling::calculateRangesAfterReplacements(Replaces, Ranges); 32 EXPECT_EQ(ExpectedNumRanges, Replaces.size()); 33 auto Sorted = applyAllReplacements(Code, Replaces); 34 EXPECT_TRUE(static_cast<bool>(Sorted)); 35 auto Result = applyAllReplacements( 36 *Sorted, reformat(FmtStyle, *Sorted, Ranges, FileName)); 37 EXPECT_TRUE(static_cast<bool>(Result)); 38 return *Result; 39 } 40 41 std::string sort(StringRef Code, StringRef FileName = "input.cpp", 42 unsigned ExpectedNumRanges = 1) { 43 return sort(Code, GetCodeRange(Code), FileName, ExpectedNumRanges); 44 } 45 46 unsigned newCursor(llvm::StringRef Code, unsigned Cursor) { 47 sortIncludes(FmtStyle, Code, GetCodeRange(Code), "input.cpp", &Cursor); 48 return Cursor; 49 } 50 51 FormatStyle FmtStyle = getLLVMStyle(); 52 tooling::IncludeStyle &Style = FmtStyle.IncludeStyle; 53 }; 54 55 TEST_F(SortIncludesTest, BasicSorting) { 56 verifyFormat("#include \"a.h\"\n" 57 "#include \"b.h\"\n" 58 "#include \"c.h\"", 59 sort("#include \"a.h\"\n" 60 "#include \"c.h\"\n" 61 "#include \"b.h\"")); 62 63 verifyFormat("// comment\n" 64 "#include <a>\n" 65 "#include <b>", 66 sort("// comment\n" 67 "#include <b>\n" 68 "#include <a>", 69 {tooling::Range(25, 1)})); 70 } 71 72 TEST_F(SortIncludesTest, TrailingComments) { 73 verifyFormat("#include \"a.h\"\n" 74 "#include \"b.h\" /* long\n" 75 " * long\n" 76 " * comment*/\n" 77 "#include \"c.h\"\n" 78 "#include \"d.h\"", 79 sort("#include \"a.h\"\n" 80 "#include \"c.h\"\n" 81 "#include \"b.h\" /* long\n" 82 " * long\n" 83 " * comment*/\n" 84 "#include \"d.h\"")); 85 } 86 87 TEST_F(SortIncludesTest, SortedIncludesUsingSortPriorityAttribute) { 88 FmtStyle.IncludeStyle.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup; 89 FmtStyle.IncludeStyle.IncludeCategories = { 90 {"^<sys/param\\.h>", 1, 0, false}, 91 {"^<sys/types\\.h>", 1, 1, false}, 92 {"^<sys.*/", 1, 2, false}, 93 {"^<uvm/", 2, 3, false}, 94 {"^<machine/", 3, 4, false}, 95 {"^<dev/", 4, 5, false}, 96 {"^<net.*/", 5, 6, false}, 97 {"^<protocols/", 5, 7, false}, 98 {"^<(fs|miscfs|msdosfs|nfs|ntfs|ufs)/", 6, 8, false}, 99 {"^<(x86|amd64|i386|xen)/", 7, 8, false}, 100 {"<path", 9, 11, false}, 101 {"^<[^/].*\\.h>", 8, 10, false}, 102 {"^\".*\\.h\"", 10, 12, false}}; 103 verifyFormat("#include <sys/param.h>\n" 104 "#include <sys/types.h>\n" 105 "#include <sys/ioctl.h>\n" 106 "#include <sys/socket.h>\n" 107 "#include <sys/stat.h>\n" 108 "#include <sys/wait.h>\n" 109 "\n" 110 "#include <net/if.h>\n" 111 "#include <net/if_dl.h>\n" 112 "#include <net/route.h>\n" 113 "#include <netinet/in.h>\n" 114 "#include <protocols/rwhod.h>\n" 115 "\n" 116 "#include <assert.h>\n" 117 "#include <errno.h>\n" 118 "#include <inttypes.h>\n" 119 "#include <stdio.h>\n" 120 "#include <stdlib.h>\n" 121 "\n" 122 "#include <paths.h>\n" 123 "\n" 124 "#include \"pathnames.h\"", 125 sort("#include <sys/param.h>\n" 126 "#include <sys/types.h>\n" 127 "#include <sys/ioctl.h>\n" 128 "#include <net/if_dl.h>\n" 129 "#include <net/route.h>\n" 130 "#include <netinet/in.h>\n" 131 "#include <sys/socket.h>\n" 132 "#include <sys/stat.h>\n" 133 "#include <sys/wait.h>\n" 134 "#include <net/if.h>\n" 135 "#include <protocols/rwhod.h>\n" 136 "#include <assert.h>\n" 137 "#include <paths.h>\n" 138 "#include \"pathnames.h\"\n" 139 "#include <errno.h>\n" 140 "#include <inttypes.h>\n" 141 "#include <stdio.h>\n" 142 "#include <stdlib.h>")); 143 } 144 TEST_F(SortIncludesTest, SortPriorityNotDefined) { 145 FmtStyle = getLLVMStyle(); 146 verifyFormat("#include \"FormatTestUtils.h\"\n" 147 "#include \"clang/Format/Format.h\"\n" 148 "#include \"llvm/ADT/None.h\"\n" 149 "#include \"llvm/Support/Debug.h\"\n" 150 "#include \"gtest/gtest.h\"", 151 sort("#include \"clang/Format/Format.h\"\n" 152 "#include \"llvm/ADT/None.h\"\n" 153 "#include \"FormatTestUtils.h\"\n" 154 "#include \"gtest/gtest.h\"\n" 155 "#include \"llvm/Support/Debug.h\"")); 156 } 157 158 TEST_F(SortIncludesTest, NoReplacementsForValidIncludes) { 159 // Identical #includes have led to a failure with an unstable sort. 160 StringRef Code = "#include <a>\n" 161 "#include <b>\n" 162 "#include <c>\n" 163 "#include <d>\n" 164 "#include <e>\n" 165 "#include <f>\n"; 166 EXPECT_TRUE(sortIncludes(FmtStyle, Code, GetCodeRange(Code), "a.cc").empty()); 167 } 168 169 TEST_F(SortIncludesTest, MainFileHeader) { 170 StringRef Code = "#include <string>\n" 171 "\n" 172 "#include \"a/extra_action.proto.h\"\n"; 173 FmtStyle = getGoogleStyle(FormatStyle::LK_Cpp); 174 EXPECT_TRUE( 175 sortIncludes(FmtStyle, Code, GetCodeRange(Code), "a/extra_action.cc") 176 .empty()); 177 178 verifyFormat("#include \"foo.bar.h\"\n" 179 "\n" 180 "#include \"a.h\"", 181 sort("#include \"a.h\"\n" 182 "#include \"foo.bar.h\"", 183 "foo.bar.cc")); 184 } 185 186 TEST_F(SortIncludesTest, SortedIncludesInMultipleBlocksAreMerged) { 187 Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge; 188 verifyFormat("#include \"a.h\"\n" 189 "#include \"b.h\"\n" 190 "#include \"c.h\"", 191 sort("#include \"a.h\"\n" 192 "#include \"c.h\"\n" 193 "\n" 194 "\n" 195 "#include \"b.h\"")); 196 197 Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup; 198 verifyFormat("#include \"a.h\"\n" 199 "#include \"b.h\"\n" 200 "#include \"c.h\"", 201 sort("#include \"a.h\"\n" 202 "#include \"c.h\"\n" 203 "\n" 204 "\n" 205 "#include \"b.h\"")); 206 } 207 208 TEST_F(SortIncludesTest, SupportClangFormatOff) { 209 verifyFormat("#include <a>\n" 210 "#include <b>\n" 211 "#include <c>\n" 212 "// clang-format off\n" 213 "#include <b>\n" 214 "#include <a>\n" 215 "#include <c>\n" 216 "// clang-format on", 217 sort("#include <b>\n" 218 "#include <a>\n" 219 "#include <c>\n" 220 "// clang-format off\n" 221 "#include <b>\n" 222 "#include <a>\n" 223 "#include <c>\n" 224 "// clang-format on")); 225 226 Style.IncludeBlocks = Style.IBS_Merge; 227 StringRef Code = "// clang-format off\r\n" 228 "#include \"d.h\"\r\n" 229 "#include \"b.h\"\r\n" 230 "// clang-format on\r\n" 231 "\r\n" 232 "#include \"c.h\"\r\n" 233 "#include \"a.h\"\r\n" 234 "#include \"e.h\"\r\n"; 235 236 StringRef Expected = "// clang-format off\r\n" 237 "#include \"d.h\"\r\n" 238 "#include \"b.h\"\r\n" 239 "// clang-format on\r\n" 240 "\r\n" 241 "#include \"e.h\"\r\n" 242 "#include \"a.h\"\r\n" 243 "#include \"c.h\"\r\n"; 244 245 verifyFormat(Expected, sort(Code, "e.cpp", 1)); 246 } 247 248 TEST_F(SortIncludesTest, SupportClangFormatOffCStyle) { 249 verifyFormat("#include <a>\n" 250 "#include <b>\n" 251 "#include <c>\n" 252 "/* clang-format off */\n" 253 "#include <b>\n" 254 "#include <a>\n" 255 "#include <c>\n" 256 "/* clang-format on */", 257 sort("#include <b>\n" 258 "#include <a>\n" 259 "#include <c>\n" 260 "/* clang-format off */\n" 261 "#include <b>\n" 262 "#include <a>\n" 263 "#include <c>\n" 264 "/* clang-format on */")); 265 266 // Not really turning it off 267 verifyFormat("#include <a>\n" 268 "#include <b>\n" 269 "#include <c>\n" 270 "/* clang-format offically */\n" 271 "#include <a>\n" 272 "#include <b>\n" 273 "#include <c>\n" 274 "/* clang-format onwards */", 275 sort("#include <b>\n" 276 "#include <a>\n" 277 "#include <c>\n" 278 "/* clang-format offically */\n" 279 "#include <b>\n" 280 "#include <a>\n" 281 "#include <c>\n" 282 "/* clang-format onwards */", 283 "input.h", 2)); 284 } 285 286 TEST_F(SortIncludesTest, IncludeSortingCanBeDisabled) { 287 FmtStyle.SortIncludes = FormatStyle::SI_Never; 288 verifyFormat("#include \"a.h\"\n" 289 "#include \"c.h\"\n" 290 "#include \"b.h\"", 291 sort("#include \"a.h\"\n" 292 "#include \"c.h\"\n" 293 "#include \"b.h\"", 294 "input.h", 0)); 295 } 296 297 TEST_F(SortIncludesTest, MixIncludeAndImport) { 298 verifyFormat("#include \"a.h\"\n" 299 "#import \"b.h\"\n" 300 "#include \"c.h\"", 301 sort("#include \"a.h\"\n" 302 "#include \"c.h\"\n" 303 "#import \"b.h\"")); 304 } 305 306 TEST_F(SortIncludesTest, FixTrailingComments) { 307 verifyFormat("#include \"a.h\" // comment\n" 308 "#include \"bb.h\" // comment\n" 309 "#include \"ccc.h\"", 310 sort("#include \"a.h\" // comment\n" 311 "#include \"ccc.h\"\n" 312 "#include \"bb.h\" // comment")); 313 } 314 315 TEST_F(SortIncludesTest, LeadingWhitespace) { 316 verifyFormat("#include \"a.h\"\n" 317 "#include \"b.h\"\n" 318 "#include \"c.h\"", 319 sort(" #include \"a.h\"\n" 320 " #include \"c.h\"\n" 321 " #include \"b.h\"")); 322 verifyFormat("#include \"a.h\"\n" 323 "#include \"b.h\"\n" 324 "#include \"c.h\"", 325 sort("# include \"a.h\"\n" 326 "# include \"c.h\"\n" 327 "# include \"b.h\"")); 328 verifyFormat("#include \"a.h\"", sort("#include \"a.h\"\n" 329 " #include \"a.h\"")); 330 } 331 332 TEST_F(SortIncludesTest, TrailingWhitespace) { 333 verifyFormat("#include \"a.h\"\n" 334 "#include \"b.h\"\n" 335 "#include \"c.h\"", 336 sort("#include \"a.h\" \n" 337 "#include \"c.h\" \n" 338 "#include \"b.h\" ")); 339 verifyFormat("#include \"a.h\"", sort("#include \"a.h\"\n" 340 "#include \"a.h\" ")); 341 } 342 343 TEST_F(SortIncludesTest, GreaterInComment) { 344 verifyFormat("#include \"a.h\"\n" 345 "#include \"b.h\" // >\n" 346 "#include \"c.h\"", 347 sort("#include \"a.h\"\n" 348 "#include \"c.h\"\n" 349 "#include \"b.h\" // >")); 350 } 351 352 TEST_F(SortIncludesTest, SortsLocallyInEachBlock) { 353 verifyFormat("#include \"a.h\"\n" 354 "#include \"c.h\"\n" 355 "\n" 356 "#include \"b.h\"", 357 sort("#include \"a.h\"\n" 358 "#include \"c.h\"\n" 359 "\n" 360 "#include \"b.h\"", 361 "input.h", 0)); 362 } 363 364 TEST_F(SortIncludesTest, SortsAllBlocksWhenMerging) { 365 Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge; 366 verifyFormat("#include \"a.h\"\n" 367 "#include \"b.h\"\n" 368 "#include \"c.h\"", 369 sort("#include \"a.h\"\n" 370 "#include \"c.h\"\n" 371 "\n" 372 "#include \"b.h\"")); 373 } 374 375 TEST_F(SortIncludesTest, CommentsAlwaysSeparateGroups) { 376 verifyFormat("#include \"a.h\"\n" 377 "#include \"c.h\"\n" 378 "// comment\n" 379 "#include \"b.h\"", 380 sort("#include \"c.h\"\n" 381 "#include \"a.h\"\n" 382 "// comment\n" 383 "#include \"b.h\"")); 384 385 Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge; 386 verifyFormat("#include \"a.h\"\n" 387 "#include \"c.h\"\n" 388 "// comment\n" 389 "#include \"b.h\"", 390 sort("#include \"c.h\"\n" 391 "#include \"a.h\"\n" 392 "// comment\n" 393 "#include \"b.h\"")); 394 395 Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup; 396 verifyFormat("#include \"a.h\"\n" 397 "#include \"c.h\"\n" 398 "// comment\n" 399 "#include \"b.h\"", 400 sort("#include \"c.h\"\n" 401 "#include \"a.h\"\n" 402 "// comment\n" 403 "#include \"b.h\"")); 404 } 405 406 TEST_F(SortIncludesTest, HandlesAngledIncludesAsSeparateBlocks) { 407 verifyFormat("#include \"a.h\"\n" 408 "#include \"c.h\"\n" 409 "#include <array>\n" 410 "#include <b.h>\n" 411 "#include <d.h>\n" 412 "#include <vector>", 413 sort("#include <vector>\n" 414 "#include <d.h>\n" 415 "#include <array>\n" 416 "#include <b.h>\n" 417 "#include \"c.h\"\n" 418 "#include \"a.h\"")); 419 420 FmtStyle = getGoogleStyle(FormatStyle::LK_Cpp); 421 verifyFormat("#include <b.h>\n" 422 "#include <d.h>\n" 423 "\n" 424 "#include <array>\n" 425 "#include <vector>\n" 426 "\n" 427 "#include \"a.h\"\n" 428 "#include \"c.h\"", 429 sort("#include <vector>\n" 430 "#include <d.h>\n" 431 "#include <array>\n" 432 "#include <b.h>\n" 433 "#include \"c.h\"\n" 434 "#include \"a.h\"")); 435 } 436 437 TEST_F(SortIncludesTest, RegroupsAngledIncludesInSeparateBlocks) { 438 Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup; 439 verifyFormat("#include \"a.h\"\n" 440 "#include \"c.h\"\n" 441 "\n" 442 "#include <b.h>\n" 443 "#include <d.h>", 444 sort("#include <d.h>\n" 445 "#include <b.h>\n" 446 "#include \"c.h\"\n" 447 "#include \"a.h\"")); 448 } 449 450 TEST_F(SortIncludesTest, HandlesMultilineIncludes) { 451 verifyFormat("#include \"a.h\"\n" 452 "#include \"b.h\"\n" 453 "#include \"c.h\"", 454 sort("#include \"a.h\"\n" 455 "#include \\\n" 456 "\"c.h\"\n" 457 "#include \"b.h\"")); 458 } 459 460 TEST_F(SortIncludesTest, HandlesTrailingCommentsWithAngleBrackets) { 461 // Regression test from the discussion at https://reviews.llvm.org/D121370. 462 verifyFormat("#include <cstdint>\n" 463 "\n" 464 "#include \"util/bar.h\"\n" 465 "#include \"util/foo/foo.h\" // foo<T>", 466 sort("#include <cstdint>\n" 467 "\n" 468 "#include \"util/bar.h\"\n" 469 "#include \"util/foo/foo.h\" // foo<T>", 470 /*FileName=*/"input.cc", 471 /*ExpectedNumRanges=*/0)); 472 } 473 474 TEST_F(SortIncludesTest, LeavesMainHeaderFirst) { 475 Style.IncludeIsMainRegex = "([-_](test|unittest))?$"; 476 verifyFormat("#include \"llvm/a.h\"\n" 477 "#include \"b.h\"\n" 478 "#include \"c.h\"", 479 sort("#include \"llvm/a.h\"\n" 480 "#include \"c.h\"\n" 481 "#include \"b.h\"", 482 "a.cc")); 483 verifyFormat("#include \"llvm/a.h\"\n" 484 "#include \"b.h\"\n" 485 "#include \"c.h\"", 486 sort("#include \"llvm/a.h\"\n" 487 "#include \"c.h\"\n" 488 "#include \"b.h\"", 489 "a_test.cc")); 490 verifyFormat("#include \"llvm/input.h\"\n" 491 "#include \"b.h\"\n" 492 "#include \"c.h\"", 493 sort("#include \"llvm/input.h\"\n" 494 "#include \"c.h\"\n" 495 "#include \"b.h\"", 496 "input.mm")); 497 498 // Don't allow prefixes. 499 verifyFormat("#include \"b.h\"\n" 500 "#include \"c.h\"\n" 501 "#include \"llvm/not_a.h\"", 502 sort("#include \"llvm/not_a.h\"\n" 503 "#include \"c.h\"\n" 504 "#include \"b.h\"", 505 "a.cc")); 506 507 // Don't do this for _main and other suffixes. 508 verifyFormat("#include \"b.h\"\n" 509 "#include \"c.h\"\n" 510 "#include \"llvm/a.h\"", 511 sort("#include \"llvm/a.h\"\n" 512 "#include \"c.h\"\n" 513 "#include \"b.h\"", 514 "a_main.cc")); 515 516 // Don't do this in headers. 517 verifyFormat("#include \"b.h\"\n" 518 "#include \"c.h\"\n" 519 "#include \"llvm/a.h\"", 520 sort("#include \"llvm/a.h\"\n" 521 "#include \"c.h\"\n" 522 "#include \"b.h\"", 523 "a.h")); 524 525 // Only do this in the first #include block. 526 verifyFormat("#include <a>\n" 527 "\n" 528 "#include \"b.h\"\n" 529 "#include \"c.h\"\n" 530 "#include \"llvm/a.h\"", 531 sort("#include <a>\n" 532 "\n" 533 "#include \"llvm/a.h\"\n" 534 "#include \"c.h\"\n" 535 "#include \"b.h\"", 536 "a.cc")); 537 538 // Only recognize the first #include with a matching basename as main include. 539 verifyFormat("#include \"a.h\"\n" 540 "#include \"b.h\"\n" 541 "#include \"c.h\"\n" 542 "#include \"llvm/a.h\"", 543 sort("#include \"b.h\"\n" 544 "#include \"a.h\"\n" 545 "#include \"c.h\"\n" 546 "#include \"llvm/a.h\"", 547 "a.cc")); 548 } 549 550 TEST_F(SortIncludesTest, LeavesMainHeaderFirstInAdditionalExtensions) { 551 Style.IncludeIsMainRegex = "([-_](test|unittest))?|(Impl)?$"; 552 verifyFormat("#include \"b.h\"\n" 553 "#include \"c.h\"\n" 554 "#include \"llvm/a.h\"", 555 sort("#include \"llvm/a.h\"\n" 556 "#include \"c.h\"\n" 557 "#include \"b.h\"", 558 "a_test.xxx")); 559 verifyFormat("#include \"b.h\"\n" 560 "#include \"c.h\"\n" 561 "#include \"llvm/a.h\"", 562 sort("#include \"llvm/a.h\"\n" 563 "#include \"c.h\"\n" 564 "#include \"b.h\"", 565 "aImpl.hpp")); 566 567 // .cpp extension is considered "main" by default 568 verifyFormat("#include \"llvm/a.h\"\n" 569 "#include \"b.h\"\n" 570 "#include \"c.h\"", 571 sort("#include \"llvm/a.h\"\n" 572 "#include \"c.h\"\n" 573 "#include \"b.h\"", 574 "aImpl.cpp")); 575 verifyFormat("#include \"llvm/a.h\"\n" 576 "#include \"b.h\"\n" 577 "#include \"c.h\"", 578 sort("#include \"llvm/a.h\"\n" 579 "#include \"c.h\"\n" 580 "#include \"b.h\"", 581 "a_test.cpp")); 582 583 // Allow additional filenames / extensions 584 Style.IncludeIsMainSourceRegex = "(Impl\\.hpp)|(\\.xxx)$"; 585 verifyFormat("#include \"llvm/a.h\"\n" 586 "#include \"b.h\"\n" 587 "#include \"c.h\"", 588 sort("#include \"llvm/a.h\"\n" 589 "#include \"c.h\"\n" 590 "#include \"b.h\"", 591 "a_test.xxx")); 592 verifyFormat("#include \"llvm/a.h\"\n" 593 "#include \"b.h\"\n" 594 "#include \"c.h\"", 595 sort("#include \"llvm/a.h\"\n" 596 "#include \"c.h\"\n" 597 "#include \"b.h\"", 598 "aImpl.hpp")); 599 } 600 601 TEST_F(SortIncludesTest, RecognizeMainHeaderInAllGroups) { 602 Style.IncludeIsMainRegex = "([-_](test|unittest))?$"; 603 Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge; 604 605 verifyFormat("#include \"c.h\"\n" 606 "#include \"a.h\"\n" 607 "#include \"b.h\"", 608 sort("#include \"b.h\"\n" 609 "\n" 610 "#include \"a.h\"\n" 611 "#include \"c.h\"", 612 "c.cc")); 613 } 614 615 TEST_F(SortIncludesTest, MainHeaderIsSeparatedWhenRegroupping) { 616 Style.IncludeIsMainRegex = "([-_](test|unittest))?$"; 617 Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup; 618 619 verifyFormat("#include \"a.h\"\n" 620 "\n" 621 "#include \"b.h\"\n" 622 "#include \"c.h\"", 623 sort("#include \"b.h\"\n" 624 "\n" 625 "#include \"a.h\"\n" 626 "#include \"c.h\"", 627 "a.cc")); 628 } 629 630 TEST_F(SortIncludesTest, SupportOptionalCaseSensitiveSorting) { 631 EXPECT_FALSE(FmtStyle.SortIncludes == FormatStyle::SI_CaseInsensitive); 632 633 FmtStyle.SortIncludes = FormatStyle::SI_CaseInsensitive; 634 635 verifyFormat("#include \"A/B.h\"\n" 636 "#include \"A/b.h\"\n" 637 "#include \"a/b.h\"\n" 638 "#include \"B/A.h\"\n" 639 "#include \"B/a.h\"", 640 sort("#include \"B/a.h\"\n" 641 "#include \"B/A.h\"\n" 642 "#include \"A/B.h\"\n" 643 "#include \"a/b.h\"\n" 644 "#include \"A/b.h\"", 645 "a.h")); 646 647 Style.IncludeBlocks = clang::tooling::IncludeStyle::IBS_Regroup; 648 Style.IncludeCategories = { 649 {"^\"", 1, 0, false}, {"^<.*\\.h>$", 2, 0, false}, {"^<", 3, 0, false}}; 650 651 StringRef UnsortedCode = "#include \"qt.h\"\n" 652 "#include <algorithm>\n" 653 "#include <qtwhatever.h>\n" 654 "#include <Qtwhatever.h>\n" 655 "#include <Algorithm>\n" 656 "#include \"vlib.h\"\n" 657 "#include \"Vlib.h\"\n" 658 "#include \"AST.h\""; 659 660 verifyFormat("#include \"AST.h\"\n" 661 "#include \"qt.h\"\n" 662 "#include \"Vlib.h\"\n" 663 "#include \"vlib.h\"\n" 664 "\n" 665 "#include <Qtwhatever.h>\n" 666 "#include <qtwhatever.h>\n" 667 "\n" 668 "#include <Algorithm>\n" 669 "#include <algorithm>", 670 sort(UnsortedCode)); 671 } 672 673 TEST_F(SortIncludesTest, SupportCaseInsensitiveMatching) { 674 // Setup an regex for main includes so we can cover those as well. 675 Style.IncludeIsMainRegex = "([-_](test|unittest))?$"; 676 677 // Ensure both main header detection and grouping work in a case insensitive 678 // manner. 679 verifyFormat("#include \"llvm/A.h\"\n" 680 "#include \"b.h\"\n" 681 "#include \"c.h\"\n" 682 "#include \"LLVM/z.h\"\n" 683 "#include \"llvm/X.h\"\n" 684 "#include \"GTest/GTest.h\"\n" 685 "#include \"gmock/gmock.h\"", 686 sort("#include \"c.h\"\n" 687 "#include \"b.h\"\n" 688 "#include \"GTest/GTest.h\"\n" 689 "#include \"llvm/A.h\"\n" 690 "#include \"gmock/gmock.h\"\n" 691 "#include \"llvm/X.h\"\n" 692 "#include \"LLVM/z.h\"", 693 "a_TEST.cc")); 694 } 695 696 TEST_F(SortIncludesTest, SupportOptionalCaseSensitiveMachting) { 697 Style.IncludeBlocks = clang::tooling::IncludeStyle::IBS_Regroup; 698 Style.IncludeCategories = {{"^\"", 1, 0, false}, 699 {"^<.*\\.h>$", 2, 0, false}, 700 {"^<Q[A-Z][^\\.]*>", 3, 0, false}, 701 {"^<Qt[^\\.]*>", 4, 0, false}, 702 {"^<", 5, 0, false}}; 703 704 StringRef UnsortedCode = "#include <QWidget>\n" 705 "#include \"qt.h\"\n" 706 "#include <algorithm>\n" 707 "#include <windows.h>\n" 708 "#include <QLabel>\n" 709 "#include \"qa.h\"\n" 710 "#include <queue>\n" 711 "#include <qtwhatever.h>\n" 712 "#include <QtGlobal>"; 713 714 verifyFormat("#include \"qa.h\"\n" 715 "#include \"qt.h\"\n" 716 "\n" 717 "#include <qtwhatever.h>\n" 718 "#include <windows.h>\n" 719 "\n" 720 "#include <QLabel>\n" 721 "#include <QWidget>\n" 722 "#include <QtGlobal>\n" 723 "#include <queue>\n" 724 "\n" 725 "#include <algorithm>", 726 sort(UnsortedCode)); 727 728 Style.IncludeCategories[2].RegexIsCaseSensitive = true; 729 Style.IncludeCategories[3].RegexIsCaseSensitive = true; 730 verifyFormat("#include \"qa.h\"\n" 731 "#include \"qt.h\"\n" 732 "\n" 733 "#include <qtwhatever.h>\n" 734 "#include <windows.h>\n" 735 "\n" 736 "#include <QLabel>\n" 737 "#include <QWidget>\n" 738 "\n" 739 "#include <QtGlobal>\n" 740 "\n" 741 "#include <algorithm>\n" 742 "#include <queue>", 743 sort(UnsortedCode)); 744 } 745 746 TEST_F(SortIncludesTest, NegativePriorities) { 747 Style.IncludeCategories = {{".*important_os_header.*", -1, 0, false}, 748 {".*", 1, 0, false}}; 749 verifyFormat("#include \"important_os_header.h\"\n" 750 "#include \"c_main.h\"\n" 751 "#include \"a_other.h\"", 752 sort("#include \"c_main.h\"\n" 753 "#include \"a_other.h\"\n" 754 "#include \"important_os_header.h\"", 755 "c_main.cc")); 756 757 // check stable when re-run 758 verifyFormat("#include \"important_os_header.h\"\n" 759 "#include \"c_main.h\"\n" 760 "#include \"a_other.h\"", 761 sort("#include \"important_os_header.h\"\n" 762 "#include \"c_main.h\"\n" 763 "#include \"a_other.h\"", 764 "c_main.cc", 0)); 765 } 766 767 TEST_F(SortIncludesTest, PriorityGroupsAreSeparatedWhenRegroupping) { 768 Style.IncludeCategories = {{".*important_os_header.*", -1, 0, false}, 769 {".*", 1, 0, false}}; 770 Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup; 771 772 verifyFormat("#include \"important_os_header.h\"\n" 773 "\n" 774 "#include \"c_main.h\"\n" 775 "\n" 776 "#include \"a_other.h\"", 777 sort("#include \"c_main.h\"\n" 778 "#include \"a_other.h\"\n" 779 "#include \"important_os_header.h\"", 780 "c_main.cc")); 781 782 // check stable when re-run 783 verifyFormat("#include \"important_os_header.h\"\n" 784 "\n" 785 "#include \"c_main.h\"\n" 786 "\n" 787 "#include \"a_other.h\"", 788 sort("#include \"important_os_header.h\"\n" 789 "\n" 790 "#include \"c_main.h\"\n" 791 "\n" 792 "#include \"a_other.h\"", 793 "c_main.cc", 0)); 794 } 795 796 TEST_F(SortIncludesTest, CalculatesCorrectCursorPosition) { 797 StringRef Code = "#include <ccc>\n" // Start of line: 0 798 "#include <bbbbbb>\n" // Start of line: 15 799 "#include <a>\n"; // Start of line: 33 800 EXPECT_EQ(31u, newCursor(Code, 0)); 801 EXPECT_EQ(13u, newCursor(Code, 15)); 802 EXPECT_EQ(0u, newCursor(Code, 33)); 803 804 EXPECT_EQ(41u, newCursor(Code, 10)); 805 EXPECT_EQ(23u, newCursor(Code, 25)); 806 EXPECT_EQ(10u, newCursor(Code, 43)); 807 } 808 809 TEST_F(SortIncludesTest, CalculatesCorrectCursorPositionWithRegrouping) { 810 Style.IncludeBlocks = Style.IBS_Regroup; 811 StringRef Code = "#include \"b\"\n" // Start of line: 0 812 "\n" // Start of line: 13 813 "#include \"aa\"\n" // Start of line: 14 814 "int i;"; // Start of line: 28 815 StringRef Expected = "#include \"aa\"\n" // Start of line: 0 816 "#include \"b\"\n" // Start of line: 14 817 "int i;"; // Start of line: 27 818 verifyFormat(Expected, sort(Code)); 819 EXPECT_EQ(12u, newCursor(Code, 26)); // Closing quote of "aa" 820 EXPECT_EQ(26u, newCursor(Code, 27)); // Newline after "aa" 821 EXPECT_EQ(27u, newCursor(Code, 28)); // Start of last line 822 } 823 824 TEST_F(SortIncludesTest, 825 CalculatesCorrectCursorPositionWhenNoReplacementsWithRegroupingAndCRLF) { 826 Style.IncludeBlocks = Style.IBS_Regroup; 827 FmtStyle.LineEnding = FormatStyle::LE_CRLF; 828 Style.IncludeCategories = { 829 {"^\"a\"", 0, 0, false}, {"^\"b\"", 1, 1, false}, {".*", 2, 2, false}}; 830 StringRef Code = "#include \"a\"\r\n" // Start of line: 0 831 "\r\n" // Start of line: 14 832 "#include \"b\"\r\n" // Start of line: 16 833 "\r\n" // Start of line: 30 834 "#include \"c\"\r\n" // Start of line: 32 835 "\r\n" // Start of line: 46 836 "int i;"; // Start of line: 48 837 verifyFormat(Code); 838 EXPECT_EQ(0u, newCursor(Code, 0)); 839 EXPECT_EQ(14u, newCursor(Code, 14)); 840 EXPECT_EQ(16u, newCursor(Code, 16)); 841 EXPECT_EQ(30u, newCursor(Code, 30)); 842 EXPECT_EQ(32u, newCursor(Code, 32)); 843 EXPECT_EQ(46u, newCursor(Code, 46)); 844 EXPECT_EQ(48u, newCursor(Code, 48)); 845 } 846 847 TEST_F( 848 SortIncludesTest, 849 CalculatesCorrectCursorPositionWhenRemoveLinesReplacementsWithRegroupingAndCRLF) { 850 Style.IncludeBlocks = Style.IBS_Regroup; 851 FmtStyle.LineEnding = FormatStyle::LE_CRLF; 852 Style.IncludeCategories = {{".*", 0, 0, false}}; 853 StringRef Code = "#include \"a\"\r\n" // Start of line: 0 854 "\r\n" // Start of line: 14 855 "#include \"b\"\r\n" // Start of line: 16 856 "\r\n" // Start of line: 30 857 "#include \"c\"\r\n" // Start of line: 32 858 "\r\n" // Start of line: 46 859 "int i;"; // Start of line: 48 860 StringRef Expected = "#include \"a\"\r\n" // Start of line: 0 861 "#include \"b\"\r\n" // Start of line: 14 862 "#include \"c\"\r\n" // Start of line: 28 863 "\r\n" // Start of line: 42 864 "int i;"; // Start of line: 44 865 verifyFormat(Expected, sort(Code)); 866 EXPECT_EQ(0u, newCursor(Code, 0)); 867 EXPECT_EQ( 868 14u, 869 newCursor(Code, 14)); // cursor on empty line in include block is ignored 870 EXPECT_EQ(14u, newCursor(Code, 16)); 871 EXPECT_EQ( 872 30u, 873 newCursor(Code, 30)); // cursor on empty line in include block is ignored 874 EXPECT_EQ(28u, newCursor(Code, 32)); 875 EXPECT_EQ(42u, newCursor(Code, 46)); 876 EXPECT_EQ(44u, newCursor(Code, 48)); 877 } 878 879 // FIXME: the tests below should pass. 880 #if 0 881 TEST_F( 882 SortIncludesTest, 883 CalculatesCorrectCursorPositionWhenNewLineReplacementsWithRegroupingAndCRLF) { 884 Style.IncludeBlocks = Style.IBS_Regroup; 885 FmtStyle.LineEnding = FormatStyle::LE_CRLF; 886 Style.IncludeCategories = { 887 {"^\"a\"", 0, 0, false}, {"^\"b\"", 1, 1, false}, {".*", 2, 2, false}}; 888 StringRef Code = "#include \"a\"\r\n" // Start of line: 0 889 "#include \"b\"\r\n" // Start of line: 14 890 "#include \"c\"\r\n" // Start of line: 28 891 "\r\n" // Start of line: 42 892 "int i;"; // Start of line: 44 893 StringRef Expected = "#include \"a\"\r\n" // Start of line: 0 894 "\r\n" // Start of line: 14 895 "#include \"b\"\r\n" // Start of line: 16 896 "\r\n" // Start of line: 30 897 "#include \"c\"\r\n" // Start of line: 32 898 "\r\n" // Start of line: 46 899 "int i;"; // Start of line: 48 900 verifyFormat(Expected, sort(Code)); 901 EXPECT_EQ(0u, newCursor(Code, 0)); 902 EXPECT_EQ(15u, newCursor(Code, 16)); 903 EXPECT_EQ(30u, newCursor(Code, 32)); 904 EXPECT_EQ(44u, newCursor(Code, 46)); 905 EXPECT_EQ(46u, newCursor(Code, 48)); 906 } 907 908 TEST_F( 909 SortIncludesTest, 910 CalculatesCorrectCursorPositionWhenNoNewLineReplacementsWithRegroupingAndCRLF) { 911 Style.IncludeBlocks = Style.IBS_Regroup; 912 FmtStyle.LineEnding = FormatStyle::LE_CRLF; 913 Style.IncludeCategories = { 914 {"^\"a\"", 0, 0, false}, {"^\"b\"", 1, 1, false}, {".*", 2, 2, false}}; 915 StringRef Code = "#include \"a\"\r\n" // Start of line: 0 916 "\r\n" // Start of line: 14 917 "#include \"c\"\r\n" // Start of line: 16 918 "\r\n" // Start of line: 30 919 "#include \"b\"\r\n" // Start of line: 32 920 "\r\n" // Start of line: 46 921 "int i;"; // Start of line: 48 922 StringRef Expected = "#include \"a\"\r\n" // Start of line: 0 923 "\r\n" // Start of line: 14 924 "#include \"b\"\r\n" // Start of line: 16 925 "\r\n" // Start of line: 30 926 "#include \"c\"\r\n" // Start of line: 32 927 "\r\n" // Start of line: 46 928 "int i;"; // Start of line: 48 929 verifyFormat(Expected, sort(Code)); 930 EXPECT_EQ(0u, newCursor(Code, 0)); 931 EXPECT_EQ(14u, newCursor(Code, 14)); 932 EXPECT_EQ(30u, newCursor(Code, 32)); 933 EXPECT_EQ(30u, newCursor(Code, 30)); 934 EXPECT_EQ(15u, newCursor(Code, 15)); 935 EXPECT_EQ(44u, newCursor(Code, 46)); 936 EXPECT_EQ(46u, newCursor(Code, 48)); 937 } 938 #endif 939 940 TEST_F(SortIncludesTest, DeduplicateIncludes) { 941 verifyFormat("#include <a>\n" 942 "#include <b>\n" 943 "#include <c>", 944 sort("#include <a>\n" 945 "#include <b>\n" 946 "#include <b>\n" 947 "#include <b>\n" 948 "#include <b>\n" 949 "#include <c>")); 950 951 Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge; 952 verifyFormat("#include <a>\n" 953 "#include <b>\n" 954 "#include <c>", 955 sort("#include <a>\n" 956 "#include <b>\n" 957 "\n" 958 "#include <b>\n" 959 "\n" 960 "#include <b>\n" 961 "#include <c>")); 962 963 Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup; 964 verifyFormat("#include <a>\n" 965 "#include <b>\n" 966 "#include <c>", 967 sort("#include <a>\n" 968 "#include <b>\n" 969 "\n" 970 "#include <b>\n" 971 "\n" 972 "#include <b>\n" 973 "#include <c>")); 974 } 975 976 TEST_F(SortIncludesTest, SortAndDeduplicateIncludes) { 977 verifyFormat("#include <a>\n" 978 "#include <b>\n" 979 "#include <c>", 980 sort("#include <b>\n" 981 "#include <a>\n" 982 "#include <b>\n" 983 "#include <b>\n" 984 "#include <c>\n" 985 "#include <b>")); 986 987 Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge; 988 verifyFormat("#include <a>\n" 989 "#include <b>\n" 990 "#include <c>", 991 sort("#include <b>\n" 992 "#include <a>\n" 993 "\n" 994 "#include <b>\n" 995 "\n" 996 "#include <c>\n" 997 "#include <b>")); 998 999 Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup; 1000 verifyFormat("#include <a>\n" 1001 "#include <b>\n" 1002 "#include <c>", 1003 sort("#include <b>\n" 1004 "#include <a>\n" 1005 "\n" 1006 "#include <b>\n" 1007 "\n" 1008 "#include <c>\n" 1009 "#include <b>")); 1010 } 1011 1012 TEST_F(SortIncludesTest, CalculatesCorrectCursorPositionAfterDeduplicate) { 1013 StringRef Code = "#include <b>\n" // Start of line: 0 1014 "#include <a>\n" // Start of line: 13 1015 "#include <b>\n" // Start of line: 26 1016 "#include <b>\n" // Start of line: 39 1017 "#include <c>\n" // Start of line: 52 1018 "#include <b>\n"; // Start of line: 65 1019 StringRef Expected = "#include <a>\n" // Start of line: 0 1020 "#include <b>\n" // Start of line: 13 1021 "#include <c>\n"; // Start of line: 26 1022 verifyFormat(Expected, sort(Code)); 1023 // Cursor on 'i' in "#include <a>". 1024 EXPECT_EQ(1u, newCursor(Code, 14)); 1025 // Cursor on 'b' in "#include <b>". 1026 EXPECT_EQ(23u, newCursor(Code, 10)); 1027 EXPECT_EQ(23u, newCursor(Code, 36)); 1028 EXPECT_EQ(23u, newCursor(Code, 49)); 1029 EXPECT_EQ(23u, newCursor(Code, 36)); 1030 EXPECT_EQ(23u, newCursor(Code, 75)); 1031 // Cursor on '#' in "#include <c>". 1032 EXPECT_EQ(26u, newCursor(Code, 52)); 1033 } 1034 1035 TEST_F(SortIncludesTest, DeduplicateLocallyInEachBlock) { 1036 verifyFormat("#include <a>\n" 1037 "#include <b>\n" 1038 "\n" 1039 "#include <b>\n" 1040 "#include <c>", 1041 sort("#include <a>\n" 1042 "#include <b>\n" 1043 "\n" 1044 "#include <c>\n" 1045 "#include <b>\n" 1046 "#include <b>")); 1047 } 1048 1049 TEST_F(SortIncludesTest, ValidAffactedRangesAfterDeduplicatingIncludes) { 1050 StringRef Code = "#include <a>\n" 1051 "#include <b>\n" 1052 "#include <a>\n" 1053 "#include <a>\n" 1054 "\n" 1055 " int x ;"; 1056 std::vector<tooling::Range> Ranges = {tooling::Range(0, 52)}; 1057 auto Replaces = sortIncludes(FmtStyle, Code, Ranges, "input.cpp"); 1058 Ranges = tooling::calculateRangesAfterReplacements(Replaces, Ranges); 1059 EXPECT_EQ(1u, Ranges.size()); 1060 EXPECT_EQ(0u, Ranges[0].getOffset()); 1061 EXPECT_EQ(26u, Ranges[0].getLength()); 1062 } 1063 1064 TEST_F(SortIncludesTest, DoNotSortLikelyXml) { 1065 verifyFormat("<!--;\n" 1066 "#include <b>\n" 1067 "#include <a>\n" 1068 "-->", 1069 sort("<!--;\n" 1070 "#include <b>\n" 1071 "#include <a>\n" 1072 "-->", 1073 "input.h", 0)); 1074 } 1075 1076 TEST_F(SortIncludesTest, DoNotOutputReplacementsForSortedBlocksWithRegrouping) { 1077 Style.IncludeBlocks = Style.IBS_Regroup; 1078 StringRef Code = "#include \"b.h\"\n" 1079 "\n" 1080 "#include <a.h>"; 1081 verifyFormat(Code, sort(Code, "input.h", 0)); 1082 } 1083 1084 TEST_F(SortIncludesTest, 1085 DoNotOutputReplacementsForSortedBlocksWithRegroupingWindows) { 1086 Style.IncludeBlocks = Style.IBS_Regroup; 1087 StringRef Code = "#include \"b.h\"\r\n" 1088 "\r\n" 1089 "#include <a.h>\r\n"; 1090 verifyFormat(Code, sort(Code, "input.h", 0)); 1091 } 1092 1093 TEST_F(SortIncludesTest, MainIncludeChar) { 1094 StringRef Code = "#include <a>\n" 1095 "#include \"quote/input.h\"\n" 1096 "#include <angle-bracket/input.h>\n"; 1097 1098 // Default behavior 1099 verifyFormat("#include \"quote/input.h\"\n" 1100 "#include <a>\n" 1101 "#include <angle-bracket/input.h>\n", 1102 sort(Code, "input.cc", 1)); 1103 1104 Style.MainIncludeChar = tooling::IncludeStyle::MICD_Quote; 1105 verifyFormat("#include \"quote/input.h\"\n" 1106 "#include <a>\n" 1107 "#include <angle-bracket/input.h>\n", 1108 sort(Code, "input.cc", 1)); 1109 1110 Style.MainIncludeChar = tooling::IncludeStyle::MICD_AngleBracket; 1111 verifyFormat("#include <angle-bracket/input.h>\n" 1112 "#include \"quote/input.h\"\n" 1113 "#include <a>\n", 1114 sort(Code, "input.cc", 1)); 1115 } 1116 1117 TEST_F(SortIncludesTest, MainIncludeCharAnyPickQuote) { 1118 Style.MainIncludeChar = tooling::IncludeStyle::MICD_Any; 1119 verifyFormat("#include \"input.h\"\n" 1120 "#include <a>\n" 1121 "#include <b>\n", 1122 sort("#include <a>\n" 1123 "#include \"input.h\"\n" 1124 "#include <b>\n", 1125 "input.cc", 1)); 1126 } 1127 1128 TEST_F(SortIncludesTest, MainIncludeCharAnyPickAngleBracket) { 1129 Style.MainIncludeChar = tooling::IncludeStyle::MICD_Any; 1130 verifyFormat("#include <input.h>\n" 1131 "#include <a>\n" 1132 "#include <b>\n", 1133 sort("#include <a>\n" 1134 "#include <input.h>\n" 1135 "#include <b>\n", 1136 "input.cc", 1)); 1137 } 1138 1139 TEST_F(SortIncludesTest, MainIncludeCharQuoteAndRegroup) { 1140 Style.IncludeCategories = { 1141 {"lib-a", 1, 0, false}, {"lib-b", 2, 0, false}, {"lib-c", 3, 0, false}}; 1142 Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup; 1143 Style.MainIncludeChar = tooling::IncludeStyle::MICD_Quote; 1144 1145 verifyFormat("#include \"lib-b/input.h\"\n" 1146 "\n" 1147 "#include <lib-a/h-1.h>\n" 1148 "#include <lib-a/h-3.h>\n" 1149 "#include <lib-a/input.h>\n" 1150 "\n" 1151 "#include <lib-b/h-1.h>\n" 1152 "#include <lib-b/h-3.h>\n" 1153 "\n" 1154 "#include <lib-c/h-1.h>\n" 1155 "#include <lib-c/h-2.h>\n" 1156 "#include <lib-c/h-3.h>\n", 1157 sort("#include <lib-c/h-1.h>\n" 1158 "#include <lib-c/h-2.h>\n" 1159 "#include <lib-c/h-3.h>\n" 1160 "#include <lib-b/h-1.h>\n" 1161 "#include \"lib-b/input.h\"\n" 1162 "#include <lib-b/h-3.h>\n" 1163 "#include <lib-a/h-1.h>\n" 1164 "#include <lib-a/input.h>\n" 1165 "#include <lib-a/h-3.h>\n", 1166 "input.cc")); 1167 } 1168 1169 TEST_F(SortIncludesTest, MainIncludeCharAngleBracketAndRegroup) { 1170 Style.IncludeCategories = { 1171 {"lib-a", 1, 0, false}, {"lib-b", 2, 0, false}, {"lib-c", 3, 0, false}}; 1172 Style.IncludeBlocks = tooling::IncludeStyle::IBS_Regroup; 1173 Style.MainIncludeChar = tooling::IncludeStyle::MICD_AngleBracket; 1174 1175 verifyFormat("#include <lib-a/input.h>\n" 1176 "\n" 1177 "#include <lib-a/h-1.h>\n" 1178 "#include <lib-a/h-3.h>\n" 1179 "\n" 1180 "#include \"lib-b/input.h\"\n" 1181 "#include <lib-b/h-1.h>\n" 1182 "#include <lib-b/h-3.h>\n" 1183 "\n" 1184 "#include <lib-c/h-1.h>\n" 1185 "#include <lib-c/h-2.h>\n" 1186 "#include <lib-c/h-3.h>\n", 1187 sort("#include <lib-c/h-1.h>\n" 1188 "#include <lib-c/h-2.h>\n" 1189 "#include <lib-c/h-3.h>\n" 1190 "#include <lib-b/h-1.h>\n" 1191 "#include \"lib-b/input.h\"\n" 1192 "#include <lib-b/h-3.h>\n" 1193 "#include <lib-a/h-1.h>\n" 1194 "#include <lib-a/input.h>\n" 1195 "#include <lib-a/h-3.h>\n", 1196 "input.cc")); 1197 } 1198 1199 TEST_F(SortIncludesTest, DoNotRegroupGroupsInGoogleObjCStyle) { 1200 FmtStyle = getGoogleStyle(FormatStyle::LK_ObjC); 1201 1202 verifyFormat("#include <a.h>\n" 1203 "#include <b.h>\n" 1204 "#include \"a.h\"", 1205 sort("#include <b.h>\n" 1206 "#include <a.h>\n" 1207 "#include \"a.h\"")); 1208 } 1209 1210 TEST_F(SortIncludesTest, DoNotTreatPrecompiledHeadersAsFirstBlock) { 1211 Style.IncludeBlocks = Style.IBS_Merge; 1212 StringRef Code = "#include \"d.h\"\r\n" 1213 "#include \"b.h\"\r\n" 1214 "#pragma hdrstop\r\n" 1215 "\r\n" 1216 "#include \"c.h\"\r\n" 1217 "#include \"a.h\"\r\n" 1218 "#include \"e.h\"\r\n"; 1219 1220 StringRef Expected = "#include \"b.h\"\r\n" 1221 "#include \"d.h\"\r\n" 1222 "#pragma hdrstop\r\n" 1223 "\r\n" 1224 "#include \"e.h\"\r\n" 1225 "#include \"a.h\"\r\n" 1226 "#include \"c.h\"\r\n"; 1227 1228 verifyFormat(Expected, sort(Code, "e.cpp", 2)); 1229 1230 Code = "#include \"d.h\"\n" 1231 "#include \"b.h\"\n" 1232 "#pragma hdrstop( \"c:\\projects\\include\\myinc.pch\" )\n" 1233 "\n" 1234 "#include \"c.h\"\n" 1235 "#include \"a.h\"\n" 1236 "#include \"e.h\"\n"; 1237 1238 Expected = "#include \"b.h\"\n" 1239 "#include \"d.h\"\n" 1240 "#pragma hdrstop(\"c:\\projects\\include\\myinc.pch\")\n" 1241 "\n" 1242 "#include \"e.h\"\n" 1243 "#include \"a.h\"\n" 1244 "#include \"c.h\"\n"; 1245 1246 verifyFormat(Expected, sort(Code, "e.cpp", 2)); 1247 } 1248 1249 TEST_F(SortIncludesTest, skipUTF8ByteOrderMarkMerge) { 1250 Style.IncludeBlocks = Style.IBS_Merge; 1251 StringRef Code = "\xEF\xBB\xBF#include \"d.h\"\r\n" 1252 "#include \"b.h\"\r\n" 1253 "\r\n" 1254 "#include \"c.h\"\r\n" 1255 "#include \"a.h\"\r\n" 1256 "#include \"e.h\"\r\n"; 1257 1258 StringRef Expected = "\xEF\xBB\xBF#include \"e.h\"\r\n" 1259 "#include \"a.h\"\r\n" 1260 "#include \"b.h\"\r\n" 1261 "#include \"c.h\"\r\n" 1262 "#include \"d.h\"\r\n"; 1263 1264 verifyFormat(Expected, sort(Code, "e.cpp", 1)); 1265 } 1266 1267 TEST_F(SortIncludesTest, skipUTF8ByteOrderMarkPreserve) { 1268 Style.IncludeBlocks = Style.IBS_Preserve; 1269 StringRef Code = "\xEF\xBB\xBF#include \"d.h\"\r\n" 1270 "#include \"b.h\"\r\n" 1271 "\r\n" 1272 "#include \"c.h\"\r\n" 1273 "#include \"a.h\"\r\n" 1274 "#include \"e.h\"\r\n"; 1275 1276 StringRef Expected = "\xEF\xBB\xBF#include \"b.h\"\r\n" 1277 "#include \"d.h\"\r\n" 1278 "\r\n" 1279 "#include \"a.h\"\r\n" 1280 "#include \"c.h\"\r\n" 1281 "#include \"e.h\"\r\n"; 1282 1283 verifyFormat(Expected, sort(Code, "e.cpp", 2)); 1284 } 1285 1286 TEST_F(SortIncludesTest, MergeLines) { 1287 Style.IncludeBlocks = Style.IBS_Merge; 1288 StringRef Code = "#include \"c.h\"\r\n" 1289 "#include \"b\\\r\n" 1290 ".h\"\r\n" 1291 "#include \"a.h\"\r\n"; 1292 1293 StringRef Expected = "#include \"a.h\"\r\n" 1294 "#include \"b\\\r\n" 1295 ".h\"\r\n" 1296 "#include \"c.h\"\r\n"; 1297 1298 verifyFormat(Expected, sort(Code, "a.cpp", 1)); 1299 } 1300 1301 TEST_F(SortIncludesTest, DisableFormatDisablesIncludeSorting) { 1302 StringRef Sorted = "#include <a.h>\n" 1303 "#include <b.h>\n"; 1304 StringRef Unsorted = "#include <b.h>\n" 1305 "#include <a.h>\n"; 1306 verifyFormat(Sorted, sort(Unsorted)); 1307 FmtStyle.DisableFormat = true; 1308 verifyFormat(Unsorted, sort(Unsorted, "input.cpp", 0)); 1309 } 1310 1311 TEST_F(SortIncludesTest, DisableRawStringLiteralSorting) { 1312 1313 verifyFormat("const char *t = R\"(\n" 1314 "#include <b.h>\n" 1315 "#include <a.h>\n" 1316 ")\";", 1317 sort("const char *t = R\"(\n" 1318 "#include <b.h>\n" 1319 "#include <a.h>\n" 1320 ")\";", 1321 "test.cxx", 0)); 1322 verifyFormat("const char *t = R\"x(\n" 1323 "#include <b.h>\n" 1324 "#include <a.h>\n" 1325 ")x\";", 1326 sort("const char *t = R\"x(\n" 1327 "#include <b.h>\n" 1328 "#include <a.h>\n" 1329 ")x\";", 1330 "test.cxx", 0)); 1331 verifyFormat("const char *t = R\"xyz(\n" 1332 "#include <b.h>\n" 1333 "#include <a.h>\n" 1334 ")xyz\";", 1335 sort("const char *t = R\"xyz(\n" 1336 "#include <b.h>\n" 1337 "#include <a.h>\n" 1338 ")xyz\";", 1339 "test.cxx", 0)); 1340 1341 verifyFormat("#include <a.h>\n" 1342 "#include <b.h>\n" 1343 "const char *t = R\"(\n" 1344 "#include <b.h>\n" 1345 "#include <a.h>\n" 1346 ")\";\n" 1347 "#include <c.h>\n" 1348 "#include <d.h>\n" 1349 "const char *t = R\"x(\n" 1350 "#include <f.h>\n" 1351 "#include <e.h>\n" 1352 ")x\";\n" 1353 "#include <g.h>\n" 1354 "#include <h.h>\n" 1355 "const char *t = R\"xyz(\n" 1356 "#include <j.h>\n" 1357 "#include <i.h>\n" 1358 ")xyz\";\n" 1359 "#include <k.h>\n" 1360 "#include <l.h>", 1361 sort("#include <b.h>\n" 1362 "#include <a.h>\n" 1363 "const char *t = R\"(\n" 1364 "#include <b.h>\n" 1365 "#include <a.h>\n" 1366 ")\";\n" 1367 "#include <d.h>\n" 1368 "#include <c.h>\n" 1369 "const char *t = R\"x(\n" 1370 "#include <f.h>\n" 1371 "#include <e.h>\n" 1372 ")x\";\n" 1373 "#include <h.h>\n" 1374 "#include <g.h>\n" 1375 "const char *t = R\"xyz(\n" 1376 "#include <j.h>\n" 1377 "#include <i.h>\n" 1378 ")xyz\";\n" 1379 "#include <l.h>\n" 1380 "#include <k.h>", 1381 "test.cc", 4)); 1382 1383 verifyFormat("const char *t = R\"AMZ029amz(\n" 1384 "#include <b.h>\n" 1385 "#include <a.h>\n" 1386 ")AMZ029amz\";", 1387 sort("const char *t = R\"AMZ029amz(\n" 1388 "#include <b.h>\n" 1389 "#include <a.h>\n" 1390 ")AMZ029amz\";", 1391 "test.cxx", 0)); 1392 1393 verifyFormat("const char *t = R\"-AMZ029amz(\n" 1394 "#include <b.h>\n" 1395 "#include <a.h>\n" 1396 ")-AMZ029amz\";", 1397 sort("const char *t = R\"-AMZ029amz(\n" 1398 "#include <b.h>\n" 1399 "#include <a.h>\n" 1400 ")-AMZ029amz\";", 1401 "test.cxx", 0)); 1402 1403 verifyFormat("const char *t = R\"AMZ029amz-(\n" 1404 "#include <b.h>\n" 1405 "#include <a.h>\n" 1406 ")AMZ029amz-\";", 1407 sort("const char *t = R\"AMZ029amz-(\n" 1408 "#include <b.h>\n" 1409 "#include <a.h>\n" 1410 ")AMZ029amz-\";", 1411 "test.cxx", 0)); 1412 1413 verifyFormat("const char *t = R\"AM|029amz-(\n" 1414 "#include <b.h>\n" 1415 "#include <a.h>\n" 1416 ")AM|029amz-\";", 1417 sort("const char *t = R\"AM|029amz-(\n" 1418 "#include <b.h>\n" 1419 "#include <a.h>\n" 1420 ")AM|029amz-\";", 1421 "test.cxx", 0)); 1422 1423 verifyFormat("const char *t = R\"AM[029amz-(\n" 1424 "#include <b.h>\n" 1425 "#include <a.h>\n" 1426 ")AM[029amz-\";", 1427 sort("const char *t = R\"AM[029amz-(\n" 1428 "#include <b.h>\n" 1429 "#include <a.h>\n" 1430 ")AM[029amz-\";", 1431 "test.cxx", 0)); 1432 1433 verifyFormat("const char *t = R\"AM]029amz-(\n" 1434 "#include <b.h>\n" 1435 "#include <a.h>\n" 1436 ")AM]029amz-\";", 1437 sort("const char *t = R\"AM]029amz-(\n" 1438 "#include <b.h>\n" 1439 "#include <a.h>\n" 1440 ")AM]029amz-\";", 1441 "test.cxx", 0)); 1442 1443 #define X "AMZ029amz{}+!%*=_:;',.<>|/?#~-$" 1444 1445 verifyFormat("const char *t = R\"" X "(\n" 1446 "#include <b.h>\n" 1447 "#include <a.h>\n" 1448 ")" X "\";", 1449 sort("const char *t = R\"" X "(\n" 1450 "#include <b.h>\n" 1451 "#include <a.h>\n" 1452 ")" X "\";", 1453 "test.cxx", 0)); 1454 1455 #undef X 1456 } 1457 1458 } // end namespace 1459 } // end namespace format 1460 } // end namespace clang 1461