clang/unittests/Tooling/HeaderIncludesTest.cpp

   1 //===- unittest/Tooling/CleanupTest.cpp - Include insertion/deletion 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/Tooling/Inclusions/HeaderIncludes.h"
  10 #include "../Tooling/ReplacementTest.h"
  11 #include "../Tooling/RewriterTestContext.h"
  12 #include "clang/Format/Format.h"
  13 #include "clang/Tooling/Core/Replacement.h"
  14
  15 #include "gtest/gtest.h"
  16
  17 namespace clang {
  18 namespace tooling {
  19 namespace {
  20
  21 class HeaderIncludesTest : public ::testing::Test {
  22 protected:
  23   std::string insert(llvm::StringRef Code, llvm::StringRef Header) {
  24     HeaderIncludes Includes(FileName, Code, Style);
  25     assert(Header.startswith("\"") || Header.startswith("<"));
  26     auto R = Includes.insert(Header.trim("\"<>"), Header.startswith("<"));
  27     if (!R)
  28       return std::string(Code);
  29     auto Result = applyAllReplacements(Code, Replacements(*R));
  30     EXPECT_TRUE(static_cast<bool>(Result));
  31     return *Result;
  32   }
  33
  34   std::string remove(llvm::StringRef Code, llvm::StringRef Header) {
  35     HeaderIncludes Includes(FileName, Code, Style);
  36     assert(Header.startswith("\"") || Header.startswith("<"));
  37     auto Replaces = Includes.remove(Header.trim("\"<>"), Header.startswith("<"));
  38     auto Result = applyAllReplacements(Code, Replaces);
  39     EXPECT_TRUE(static_cast<bool>(Result));
  40     return *Result;
  41   }
  42
  43   std::string FileName = "fix.cpp";
  44   IncludeStyle Style = format::getLLVMStyle().IncludeStyle;
  45 };
  46
  47 TEST_F(HeaderIncludesTest, NoExistingIncludeWithoutDefine) {
  48   std::string Code = "int main() {}";
  49   std::string Expected = "#include \"a.h\"\n"
  50                          "int main() {}";
  51   EXPECT_EQ(Expected, insert(Code, "\"a.h\""));
  52 }
  53
  54 TEST_F(HeaderIncludesTest, RepeatedIncludes) {
  55   std::string Code;
  56   for (int i = 0; i < 100; ++i) {
  57     Code += "#include \"a.h\"\n";
  58   }
  59   std::string Expected = Code + "#include \"a2.h\"\n";
  60   EXPECT_EQ(Expected, insert(Code, "\"a2.h\""));
  61 }
  62
  63 TEST_F(HeaderIncludesTest, NoExistingIncludeWithDefine) {
  64   std::string Code = "#ifndef A_H\n"
  65                      "#define A_H\n"
  66                      "class A {};\n"
  67                      "#define MMM 123\n"
  68                      "#endif";
  69   std::string Expected = "#ifndef A_H\n"
  70                          "#define A_H\n"
  71                          "#include \"b.h\"\n"
  72                          "class A {};\n"
  73                          "#define MMM 123\n"
  74                          "#endif";
  75
  76   EXPECT_EQ(Expected, insert(Code, "\"b.h\""));
  77 }
  78
  79 TEST_F(HeaderIncludesTest, InsertBeforeCategoryWithLowerPriority) {
  80   std::string Code = "#ifndef A_H\n"
  81                      "#define A_H\n"
  82                      "\n"
  83                      "\n"
  84                      "\n"
  85                      "#include <vector>\n"
  86                      "class A {};\n"
  87                      "#define MMM 123\n"
  88                      "#endif";
  89   std::string Expected = "#ifndef A_H\n"
  90                          "#define A_H\n"
  91                          "\n"
  92                          "\n"
  93                          "\n"
  94                          "#include \"a.h\"\n"
  95                          "#include <vector>\n"
  96                          "class A {};\n"
  97                          "#define MMM 123\n"
  98                          "#endif";
  99
 100   EXPECT_EQ(Expected, insert(Code, "\"a.h\""));
 101 }
 102
 103 TEST_F(HeaderIncludesTest, InsertAfterMainHeader) {
 104   std::string Code = "#include \"fix.h\"\n"
 105                      "\n"
 106                      "int main() {}";
 107   std::string Expected = "#include \"fix.h\"\n"
 108                          "#include <a>\n"
 109                          "\n"
 110                          "int main() {}";
 111   Style = format::getGoogleStyle(format::FormatStyle::LanguageKind::LK_Cpp)
 112               .IncludeStyle;
 113   EXPECT_EQ(Expected, insert(Code, "<a>"));
 114
 115   FileName = "fix.cu.cpp";
 116   EXPECT_EQ(Expected, insert(Code, "<a>"));
 117
 118   FileName = "fix_test.cu.cpp";
 119   EXPECT_EQ(Expected, insert(Code, "<a>"));
 120
 121   FileName = "bar.cpp";
 122   EXPECT_NE(Expected, insert(Code, "<a>")) << "Not main header";
 123 }
 124
 125 TEST_F(HeaderIncludesTest, InsertBeforeSystemHeaderLLVM) {
 126   std::string Code = "#include <memory>\n"
 127                      "\n"
 128                      "int main() {}";
 129   std::string Expected = "#include \"z.h\"\n"
 130                          "#include <memory>\n"
 131                          "\n"
 132                          "int main() {}";
 133   EXPECT_EQ(Expected, insert(Code, "\"z.h\""));
 134 }
 135
 136 TEST_F(HeaderIncludesTest, InsertAfterSystemHeaderGoogle) {
 137   std::string Code = "#include <memory>\n"
 138                      "\n"
 139                      "int main() {}";
 140   std::string Expected = "#include <memory>\n"
 141                          "#include \"z.h\"\n"
 142                          "\n"
 143                          "int main() {}";
 144   Style = format::getGoogleStyle(format::FormatStyle::LanguageKind::LK_Cpp)
 145               .IncludeStyle;
 146   EXPECT_EQ(Expected, insert(Code, "\"z.h\""));
 147 }
 148
 149 TEST_F(HeaderIncludesTest, InsertOneIncludeLLVMStyle) {
 150   std::string Code = "#include \"x/fix.h\"\n"
 151                      "#include \"a.h\"\n"
 152                      "#include \"b.h\"\n"
 153                      "#include \"clang/Format/Format.h\"\n"
 154                      "#include <memory>\n";
 155   std::string Expected = "#include \"x/fix.h\"\n"
 156                          "#include \"a.h\"\n"
 157                          "#include \"b.h\"\n"
 158                          "#include \"clang/Format/Format.h\"\n"
 159                          "#include \"llvm/x/y.h\"\n"
 160                          "#include <memory>\n";
 161   EXPECT_EQ(Expected, insert(Code, "\"llvm/x/y.h\""));
 162 }
 163
 164 TEST_F(HeaderIncludesTest, InsertIntoBlockSorted) {
 165   std::string Code = "#include \"x/fix.h\"\n"
 166                      "#include \"a.h\"\n"
 167                      "#include \"c.h\"\n"
 168                      "#include <memory>\n";
 169   std::string Expected = "#include \"x/fix.h\"\n"
 170                          "#include \"a.h\"\n"
 171                          "#include \"b.h\"\n"
 172                          "#include \"c.h\"\n"
 173                          "#include <memory>\n";
 174   EXPECT_EQ(Expected, insert(Code, "\"b.h\""));
 175 }
 176
 177 TEST_F(HeaderIncludesTest, InsertIntoFirstBlockOfSameKind) {
 178   std::string Code = "#include \"x/fix.h\"\n"
 179                      "#include \"c.h\"\n"
 180                      "#include \"e.h\"\n"
 181                      "#include \"f.h\"\n"
 182                      "#include <memory>\n"
 183                      "#include <vector>\n"
 184                      "#include \"m.h\"\n"
 185                      "#include \"n.h\"\n";
 186   std::string Expected = "#include \"x/fix.h\"\n"
 187                          "#include \"c.h\"\n"
 188                          "#include \"d.h\"\n"
 189                          "#include \"e.h\"\n"
 190                          "#include \"f.h\"\n"
 191                          "#include <memory>\n"
 192                          "#include <vector>\n"
 193                          "#include \"m.h\"\n"
 194                          "#include \"n.h\"\n";
 195   EXPECT_EQ(Expected, insert(Code, "\"d.h\""));
 196 }
 197
 198 TEST_F(HeaderIncludesTest, InsertIntoSystemBlockSorted) {
 199   std::string Code = "#include \"x/fix.h\"\n"
 200                      "#include \"a.h\"\n"
 201                      "#include \"c.h\"\n"
 202                      "#include <a>\n"
 203                      "#include <z>\n";
 204   std::string Expected = "#include \"x/fix.h\"\n"
 205                          "#include \"a.h\"\n"
 206                          "#include \"c.h\"\n"
 207                          "#include <a>\n"
 208                          "#include <vector>\n"
 209                          "#include <z>\n";
 210   EXPECT_EQ(Expected, insert(Code, "<vector>"));
 211 }
 212
 213 TEST_F(HeaderIncludesTest, InsertNewSystemIncludeGoogleStyle) {
 214   std::string Code = "#include \"x/fix.h\"\n"
 215                      "\n"
 216                      "#include \"y/a.h\"\n"
 217                      "#include \"z/b.h\"\n";
 218   // FIXME: inserting after the empty line following the main header might be
 219   // preferred.
 220   std::string Expected = "#include \"x/fix.h\"\n"
 221                          "#include <vector>\n"
 222                          "\n"
 223                          "#include \"y/a.h\"\n"
 224                          "#include \"z/b.h\"\n";
 225   Style = format::getGoogleStyle(format::FormatStyle::LanguageKind::LK_Cpp)
 226               .IncludeStyle;
 227   EXPECT_EQ(Expected, insert(Code, "<vector>"));
 228 }
 229
 230 TEST_F(HeaderIncludesTest, NotConfusedByDefine) {
 231   std::string Code = "void f() {}\n"
 232                      "#define A \\\n"
 233                      "  int i;";
 234   std::string Expected = "#include <vector>\n"
 235                          "void f() {}\n"
 236                          "#define A \\\n"
 237                          "  int i;";
 238   EXPECT_EQ(Expected, insert(Code, "<vector>"));
 239 }
 240
 241 TEST_F(HeaderIncludesTest, SkippedTopComment) {
 242   std::string Code = "// comment\n"
 243                      "\n"
 244                      "   // comment\n";
 245   std::string Expected = "// comment\n"
 246                          "\n"
 247                          "   // comment\n"
 248                          "#include <vector>\n";
 249   EXPECT_EQ(Expected, insert(Code, "<vector>"));
 250 }
 251
 252 TEST_F(HeaderIncludesTest, SkippedMixedComments) {
 253   std::string Code = "// comment\n"
 254                      "// comment \\\n"
 255                      " comment continued\n"
 256                      "/*\n"
 257                      "* comment\n"
 258                      "*/\n";
 259   std::string Expected = "// comment\n"
 260                          "// comment \\\n"
 261                          " comment continued\n"
 262                          "/*\n"
 263                          "* comment\n"
 264                          "*/\n"
 265                          "#include <vector>\n";
 266   EXPECT_EQ(Expected, insert(Code, "<vector>"));
 267 }
 268
 269 TEST_F(HeaderIncludesTest, MultipleBlockCommentsInOneLine) {
 270   std::string Code = "/*\n"
 271                      "* comment\n"
 272                      "*/ /* comment\n"
 273                      "*/\n"
 274                      "\n\n"
 275                      "/* c1 */ /*c2 */\n";
 276   std::string Expected = "/*\n"
 277                          "* comment\n"
 278                          "*/ /* comment\n"
 279                          "*/\n"
 280                          "\n\n"
 281                          "/* c1 */ /*c2 */\n"
 282                          "#include <vector>\n";
 283   EXPECT_EQ(Expected, insert(Code, "<vector>"));
 284 }
 285
 286 TEST_F(HeaderIncludesTest, CodeAfterComments) {
 287   std::string Code = "/*\n"
 288                      "* comment\n"
 289                      "*/ /* comment\n"
 290                      "*/\n"
 291                      "\n\n"
 292                      "/* c1 */ /*c2 */\n"
 293                      "\n"
 294                      "int x;\n";
 295   std::string Expected = "/*\n"
 296                          "* comment\n"
 297                          "*/ /* comment\n"
 298                          "*/\n"
 299                          "\n\n"
 300                          "/* c1 */ /*c2 */\n"
 301                          "\n"
 302                          "#include <vector>\n"
 303                          "int x;\n";
 304   EXPECT_EQ(Expected, insert(Code, "<vector>"));
 305 }
 306
 307 TEST_F(HeaderIncludesTest, FakeHeaderGuardIfDef) {
 308   std::string Code = "// comment \n"
 309                      "#ifdef X\n"
 310                      "#define X\n";
 311   std::string Expected = "// comment \n"
 312                          "#include <vector>\n"
 313                          "#ifdef X\n"
 314                          "#define X\n";
 315   EXPECT_EQ(Expected, insert(Code, "<vector>"));
 316 }
 317
 318 TEST_F(HeaderIncludesTest, RealHeaderGuardAfterComments) {
 319   std::string Code = "// comment \n"
 320                      "#ifndef X\n"
 321                      "#define X\n"
 322                      "int x;\n"
 323                      "#define Y 1\n";
 324   std::string Expected = "// comment \n"
 325                          "#ifndef X\n"
 326                          "#define X\n"
 327                          "#include <vector>\n"
 328                          "int x;\n"
 329                          "#define Y 1\n";
 330   EXPECT_EQ(Expected, insert(Code, "<vector>"));
 331 }
 332
 333 TEST_F(HeaderIncludesTest, PragmaOnce) {
 334   std::string Code = "// comment \n"
 335                      "#pragma once\n"
 336                      "int x;\n";
 337   std::string Expected = "// comment \n"
 338                          "#pragma once\n"
 339                          "#include <vector>\n"
 340                          "int x;\n";
 341   EXPECT_EQ(Expected, insert(Code, "<vector>"));
 342 }
 343
 344 TEST_F(HeaderIncludesTest, IfNDefWithNoDefine) {
 345   std::string Code = "// comment \n"
 346                      "#ifndef X\n"
 347                      "int x;\n"
 348                      "#define Y 1\n";
 349   std::string Expected = "// comment \n"
 350                          "#include <vector>\n"
 351                          "#ifndef X\n"
 352                          "int x;\n"
 353                          "#define Y 1\n";
 354   EXPECT_EQ(Expected, insert(Code, "<vector>"));
 355 }
 356
 357 TEST_F(HeaderIncludesTest, FakeHeaderGuard) {
 358   std::string Code = "// comment \n"
 359                      "#ifndef X\n"
 360                      "#define 1\n";
 361   std::string Expected = "// comment \n"
 362                          "#include <vector>\n"
 363                          "#ifndef X\n"
 364                          "#define 1\n";
 365   EXPECT_EQ(Expected, insert(Code, "<vector>"));
 366 }
 367
 368 TEST_F(HeaderIncludesTest, FakeHeaderGuardIfnDef) {
 369   std::string Code = "#ifndef A_H\n"
 370                      "#define A_H 1\n"
 371                      "#endif";
 372   std::string Expected = "#include \"b.h\"\n"
 373                          "#ifndef A_H\n"
 374                          "#define A_H 1\n"
 375                          "#endif";
 376
 377   EXPECT_EQ(Expected, insert(Code, "\"b.h\""));
 378 }
 379
 380 TEST_F(HeaderIncludesTest, HeaderGuardWithComment) {
 381   std::string Code = "// comment \n"
 382                      "#ifndef X // comment\n"
 383                      "// comment\n"
 384                      "/* comment\n"
 385                      "*/\n"
 386                      "/* comment */ #define X\n"
 387                      "int x;\n"
 388                      "#define Y 1\n";
 389   std::string Expected = "// comment \n"
 390                          "#ifndef X // comment\n"
 391                          "// comment\n"
 392                          "/* comment\n"
 393                          "*/\n"
 394                          "/* comment */ #define X\n"
 395                          "#include <vector>\n"
 396                          "int x;\n"
 397                          "#define Y 1\n";
 398   EXPECT_EQ(Expected, insert(Code, "<vector>"));
 399 }
 400
 401 TEST_F(HeaderIncludesTest, EmptyCode) {
 402   std::string Code = "";
 403   std::string Expected = "#include <vector>\n";
 404   EXPECT_EQ(Expected, insert(Code, "<vector>"));
 405 }
 406
 407 TEST_F(HeaderIncludesTest, NoNewLineAtTheEndOfCode) {
 408   std::string Code = "#include <map>";
 409   std::string Expected = "#include <map>\n#include <vector>\n";
 410   EXPECT_EQ(Expected, insert(Code, "<vector>"));
 411 }
 412
 413 TEST_F(HeaderIncludesTest, SkipExistingHeaders) {
 414   std::string Code = "#include \"a.h\"\n"
 415                      "#include <vector>\n";
 416   std::string Expected = "#include \"a.h\"\n"
 417                          "#include <vector>\n";
 418   EXPECT_EQ(Expected, insert(Code, "<vector>"));
 419   EXPECT_EQ(Expected, insert(Code, "\"a.h\""));
 420 }
 421
 422 TEST_F(HeaderIncludesTest, AddIncludesWithDifferentForms) {
 423   std::string Code = "#include <vector>\n";
 424   // FIXME: this might not be the best behavior.
 425   std::string Expected = "#include \"vector\"\n"
 426                          "#include <vector>\n";
 427   EXPECT_EQ(Expected, insert(Code, "\"vector\""));
 428 }
 429
 430 TEST_F(HeaderIncludesTest, NoInsertionAfterCode) {
 431   std::string Code = "#include \"a.h\"\n"
 432                      "void f() {}\n"
 433                      "#include \"b.h\"\n";
 434   std::string Expected = "#include \"a.h\"\n"
 435                          "#include \"c.h\"\n"
 436                          "void f() {}\n"
 437                          "#include \"b.h\"\n";
 438   EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
 439 }
 440
 441 TEST_F(HeaderIncludesTest, NoInsertionInStringLiteral) {
 442   std::string Code = "#include \"a.h\"\n"
 443                      "const char[] = R\"(\n"
 444                      "#include \"b.h\"\n"
 445                      ")\";\n";
 446   std::string Expected = "#include \"a.h\"\n"
 447                          "#include \"c.h\"\n"
 448                          "const char[] = R\"(\n"
 449                          "#include \"b.h\"\n"
 450                          ")\";\n";
 451   EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
 452 }
 453
 454 TEST_F(HeaderIncludesTest, NoInsertionAfterOtherDirective) {
 455   std::string Code = "#include \"a.h\"\n"
 456                      "#ifdef X\n"
 457                      "#include \"b.h\"\n"
 458                      "#endif\n";
 459   std::string Expected = "#include \"a.h\"\n"
 460                          "#include \"c.h\"\n"
 461                          "#ifdef X\n"
 462                          "#include \"b.h\"\n"
 463                          "#endif\n";
 464   EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
 465 }
 466
 467 TEST_F(HeaderIncludesTest, CanInsertAfterLongSystemInclude) {
 468   std::string Code = "#include \"a.h\"\n"
 469                      "// comment\n\n"
 470                      "#include <a/b/c/d/e.h>\n";
 471   std::string Expected = "#include \"a.h\"\n"
 472                          "// comment\n\n"
 473                          "#include <a/b/c/d/e.h>\n"
 474                          "#include <x.h>\n";
 475   EXPECT_EQ(Expected, insert(Code, "<x.h>"));
 476 }
 477
 478 TEST_F(HeaderIncludesTest, CanInsertAfterComment) {
 479   std::string Code = "#include \"a.h\"\n"
 480                      "// Comment\n"
 481                      "\n"
 482                      "/* Comment */\n"
 483                      "// Comment\n"
 484                      "\n"
 485                      "#include \"b.h\"\n";
 486   std::string Expected = "#include \"a.h\"\n"
 487                          "// Comment\n"
 488                          "\n"
 489                          "/* Comment */\n"
 490                          "// Comment\n"
 491                          "\n"
 492                          "#include \"b.h\"\n"
 493                          "#include \"c.h\"\n";
 494   EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
 495 }
 496
 497 TEST_F(HeaderIncludesTest, LongCommentsInTheBeginningOfFile) {
 498   std::string Code = "// Loooooooooooooooooooooooooong comment\n"
 499                      "// Loooooooooooooooooooooooooong comment\n"
 500                      "// Loooooooooooooooooooooooooong comment\n"
 501                      "#include <string>\n"
 502                      "#include <vector>\n"
 503                      "\n"
 504                      "#include \"a.h\"\n"
 505                      "#include \"b.h\"\n";
 506   std::string Expected = "// Loooooooooooooooooooooooooong comment\n"
 507                          "// Loooooooooooooooooooooooooong comment\n"
 508                          "// Loooooooooooooooooooooooooong comment\n"
 509                          "#include <string>\n"
 510                          "#include <vector>\n"
 511                          "\n"
 512                          "#include \"a.h\"\n"
 513                          "#include \"b.h\"\n"
 514                          "#include \"third.h\"\n";
 515   Style = format::getGoogleStyle(format::FormatStyle::LanguageKind::LK_Cpp)
 516               .IncludeStyle;
 517   EXPECT_EQ(Expected, insert(Code, "\"third.h\""));
 518 }
 519
 520 TEST_F(HeaderIncludesTest, SimpleDeleteInclude) {
 521   std::string Code = "#include \"abc.h\"\n"
 522                      "#include \"xyz.h\" // comment\n"
 523                      "int x;\n";
 524   std::string Expected = "#include \"abc.h\"\n"
 525                          "int x;\n";
 526   EXPECT_EQ(Expected, remove(Code, "\"xyz.h\""));
 527 }
 528
 529 TEST_F(HeaderIncludesTest, DeleteQuotedOnly) {
 530   std::string Code = "#include \"abc.h\"\n"
 531                      "#include <abc.h>\n"
 532                      "int x;\n";
 533   std::string Expected = "#include <abc.h>\n"
 534                          "int x;\n";
 535   EXPECT_EQ(Expected, remove(Code, "\"abc.h\""));
 536 }
 537
 538 TEST_F(HeaderIncludesTest, DeleteAllCode) {
 539   std::string Code = "#include \"xyz.h\"\n";
 540   std::string Expected = "";
 541   EXPECT_EQ(Expected, remove(Code, "\"xyz.h\""));
 542 }
 543
 544 TEST_F(HeaderIncludesTest, DeleteOnlyIncludesWithSameQuote) {
 545   std::string Code = "#include \"xyz.h\"\n"
 546                      "#include \"xyz\"\n"
 547                      "#include <xyz.h>\n";
 548   std::string Expected = "#include \"xyz.h\"\n"
 549                          "#include \"xyz\"\n";
 550   EXPECT_EQ(Expected, remove(Code, "<xyz.h>"));
 551 }
 552
 553 TEST_F(HeaderIncludesTest, CanDeleteAfterCode) {
 554   std::string Code = "#include \"a.h\"\n"
 555                      "void f() {}\n"
 556                      "#include \"b.h\"\n";
 557   std::string Expected = "#include \"a.h\"\n"
 558                          "void f() {}\n";
 559   EXPECT_EQ(Expected, remove(Code, "\"b.h\""));
 560 }
 561
 562 } // namespace
 563 } // namespace tooling
 564 } // namespace clang