//===- unittest/Tooling/CleanupTest.cpp - Include insertion/deletion tests ===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "clang/Tooling/Inclusions/HeaderIncludes.h"
#include "clang/Format/Format.h"
#include "clang/Tooling/Core/Replacement.h"
#include "llvm/ADT/StringRef.h"

#include "gtest/gtest.h"
#include <cassert>

namespace clang {
namespace tooling {
namespace {

class HeaderIncludesTest : public ::testing::Test {
protected:
  std::string insert(llvm::StringRef Code, llvm::StringRef Header,
                     IncludeDirective Directive = IncludeDirective::Include) {
    HeaderIncludes Includes(FileName, Code, Style);
    assert(Header.starts_with("\"") || Header.starts_with("<"));
    auto R = Includes.insert(Header.trim("\"<>"), Header.starts_with("<"),
                             Directive);
    if (!R)
      return std::string(Code);
    auto Result = applyAllReplacements(Code, Replacements(*R));
    EXPECT_TRUE(static_cast<bool>(Result));
    return *Result;
  }

  std::string remove(llvm::StringRef Code, llvm::StringRef Header) {
    HeaderIncludes Includes(FileName, Code, Style);
    assert(Header.starts_with("\"") || Header.starts_with("<"));
    auto Replaces =
        Includes.remove(Header.trim("\"<>"), Header.starts_with("<"));
    auto Result = applyAllReplacements(Code, Replaces);
    EXPECT_TRUE(static_cast<bool>(Result));
    return *Result;
  }

  std::string
  insertBatch(llvm::StringRef Code,
              llvm::ArrayRef<HeaderIncludes::HeaderToInsert> Headers) {
    HeaderIncludes Includes(FileName, Code, Style);
    auto Replaces = Includes.insert(Headers);
    auto Result = applyAllReplacements(Code, Replaces);
    EXPECT_TRUE(static_cast<bool>(Result));
    return *Result;
  }

  std::string FileName = "fix.cpp";
  IncludeStyle Style = format::getLLVMStyle().IncludeStyle;
};

TEST_F(HeaderIncludesTest, NoExistingIncludeWithoutDefine) {
  std::string Code = "int main() {}";
  std::string Expected = "#include \"a.h\"\n"
                         "int main() {}";
  EXPECT_EQ(Expected, insert(Code, "\"a.h\""));
}

TEST_F(HeaderIncludesTest, RepeatedIncludes) {
  std::string Code;
  for (int i = 0; i < 100; ++i) {
    Code += "#include \"a.h\"\n";
  }
  std::string Expected = Code + "#include \"a2.h\"\n";
  EXPECT_EQ(Expected, insert(Code, "\"a2.h\""));
}

TEST_F(HeaderIncludesTest, InsertImportWithSameInclude) {
  std::string Code = "#include \"a.h\"\n";
  std::string Expected = "#import \"a.h\"\n";
  EXPECT_EQ(Expected, insert(Code, "\"a.h\"", IncludeDirective::Import));
}

TEST_F(HeaderIncludesTest, DontInsertAlreadyImported) {
  std::string Code = "#import \"a.h\"\n";
  EXPECT_EQ(Code, insert(Code, "\"a.h\"", IncludeDirective::Import));
}

TEST_F(HeaderIncludesTest, DeleteImportAndSameInclude) {
  std::string Code = R"cpp(
#include <abc.h>
#import <abc.h>
int x;)cpp";
  EXPECT_EQ("\nint x;", remove(Code, "<abc.h>"));
}

TEST_F(HeaderIncludesTest, DeleteMixedImportAndIncludeQuoted) {
  std::string Code = R"cpp(
#include "a.h"
#import "a.h"
int x;)cpp";
  EXPECT_EQ("\nint x;", remove(Code, "\"a.h\""));
}

TEST_F(HeaderIncludesTest, ImportWithSpacesAndTabs) {
  std::string Code = "int x;\n";
  // The parser should detect these as existing imports if we had them,
  // but here we are testing insertion/detection integration.
  // Let's verify that a file with weird spacing is parsed correctly.
  std::string CodeWithSpaces =
      "#  import   \"a.h\"\n#\tinclude\t\"b.h\"\nint x;\n";

  // Try inserting "a.h" again as import - should be blocked by the existing one
  // if the regex captures it correctly.
  EXPECT_EQ(CodeWithSpaces,
            insert(CodeWithSpaces, "\"a.h\"", IncludeDirective::Import));

  // Try inserting "b.h" again as include - should be blocked.
  EXPECT_EQ(CodeWithSpaces,
            insert(CodeWithSpaces, "\"b.h\"", IncludeDirective::Include));

  // Try inserting "b.h" again as import - should replace.
  std::string ExpectedAfterBImport =
      "#  import   \"a.h\"\n#import \"b.h\"\nint x;\n";
  EXPECT_EQ(ExpectedAfterBImport,
            insert(CodeWithSpaces, "\"b.h\"", IncludeDirective::Import));
}

TEST_F(HeaderIncludesTest, InsertIncludeWhenImportExists) {
  std::string Code = "#import \"a.h\"\n";
  EXPECT_EQ(Code, insert(Code, "\"a.h\"", IncludeDirective::Include));
}

TEST_F(HeaderIncludesTest, InsertImportWhenIncludeExistsAngled) {
  std::string Code = "#include <a.h>\n";
  std::string Expected = "#import <a.h>\n";
  // Replaces #include with #import.
  EXPECT_EQ(Expected, insert(Code, "<a.h>", IncludeDirective::Import));
}

TEST_F(HeaderIncludesTest, InsertImportAngledWhenIncludeQuotedExists) {
  std::string Code = "#include \"a.h\"\n";
  std::string Expected = Code + "#import <a.h>\n";
  // Different quotation, so it should insert alongside, not replace.
  EXPECT_EQ(Expected, insert(Code, "<a.h>", IncludeDirective::Import));
}

TEST_F(HeaderIncludesTest, InsertImportQuotedWhenIncludeAngledExists) {
  std::string Code = "#include <a.h>\n";
  std::string Expected = "#import \"a.h\"\n#include <a.h>\n";
  // Different quotation, so it should insert alongside, not replace.
  // " comes before < in ASCII, so it is inserted before.
  EXPECT_EQ(Expected, insert(Code, "\"a.h\"", IncludeDirective::Import));
}

TEST_F(HeaderIncludesTest, NoExistingIncludeWithDefine) {
  std::string Code = "#ifndef A_H\n"
                     "#define A_H\n"
                     "class A {};\n"
                     "#define MMM 123\n"
                     "#endif";
  std::string Expected = "#ifndef A_H\n"
                         "#define A_H\n"
                         "#include \"b.h\"\n"
                         "class A {};\n"
                         "#define MMM 123\n"
                         "#endif";

  EXPECT_EQ(Expected, insert(Code, "\"b.h\""));
}

TEST_F(HeaderIncludesTest, InsertBeforeCategoryWithLowerPriority) {
  std::string Code = "#ifndef A_H\n"
                     "#define A_H\n"
                     "\n"
                     "\n"
                     "\n"
                     "#include <vector>\n"
                     "class A {};\n"
                     "#define MMM 123\n"
                     "#endif";
  std::string Expected = "#ifndef A_H\n"
                         "#define A_H\n"
                         "\n"
                         "\n"
                         "\n"
                         "#include \"a.h\"\n"
                         "#include <vector>\n"
                         "class A {};\n"
                         "#define MMM 123\n"
                         "#endif";

  EXPECT_EQ(Expected, insert(Code, "\"a.h\""));
}

TEST_F(HeaderIncludesTest, InsertAfterMainHeader) {
  std::string Code = "#include \"fix.h\"\n"
                     "\n"
                     "int main() {}";
  std::string Expected = "#include \"fix.h\"\n"
                         "#include <a>\n"
                         "\n"
                         "int main() {}";
  Style = format::getGoogleStyle(format::FormatStyle::LanguageKind::LK_Cpp)
              .IncludeStyle;
  EXPECT_EQ(Expected, insert(Code, "<a>"));

  FileName = "fix.cu.cpp";
  EXPECT_EQ(Expected, insert(Code, "<a>"));

  FileName = "fix_test.cu.cpp";
  EXPECT_EQ(Expected, insert(Code, "<a>"));

  FileName = "bar.cpp";
  EXPECT_NE(Expected, insert(Code, "<a>")) << "Not main header";
}

TEST_F(HeaderIncludesTest, InsertAfterMainHeaderWithSpecialChars) {
  std::string Code = "#include \"fix+bar.h\"\n"
                     "\n"
                     "int main() {}";
  std::string Expected = "#include \"fix+bar.h\"\n"
                         "#include <a>\n"
                         "\n"
                         "int main() {}";
  Style = format::getGoogleStyle(format::FormatStyle::LanguageKind::LK_Cpp)
              .IncludeStyle;
  FileName = "fix+bar.cpp";
  EXPECT_EQ(Expected, insert(Code, "<a>"));
}

TEST_F(HeaderIncludesTest, InsertMainHeader) {
  Style = format::getGoogleStyle(format::FormatStyle::LanguageKind::LK_Cpp)
              .IncludeStyle;
  FileName = "fix.cpp";
  EXPECT_EQ(R"cpp(#include "fix.h"
#include "a.h")cpp", insert("#include \"a.h\"", "\"fix.h\""));

  // Respect the original main-file header.
  EXPECT_EQ(R"cpp(#include "z/fix.h"
#include "a/fix.h"
)cpp", insert("#include \"z/fix.h\"", "\"a/fix.h\""));
}

TEST_F(HeaderIncludesTest, InsertBeforeSystemHeaderLLVM) {
  std::string Code = "#include <memory>\n"
                     "\n"
                     "int main() {}";
  std::string Expected = "#include \"z.h\"\n"
                         "#include <memory>\n"
                         "\n"
                         "int main() {}";
  EXPECT_EQ(Expected, insert(Code, "\"z.h\""));
}

TEST_F(HeaderIncludesTest, InsertAfterSystemHeaderGoogle) {
  std::string Code = "#include <memory>\n"
                     "\n"
                     "int main() {}";
  std::string Expected = "#include <memory>\n"
                         "#include \"z.h\"\n"
                         "\n"
                         "int main() {}";
  Style = format::getGoogleStyle(format::FormatStyle::LanguageKind::LK_Cpp)
              .IncludeStyle;
  EXPECT_EQ(Expected, insert(Code, "\"z.h\""));
}

TEST_F(HeaderIncludesTest, InsertOneIncludeLLVMStyle) {
  std::string Code = "#include \"x/fix.h\"\n"
                     "#include \"a.h\"\n"
                     "#include \"b.h\"\n"
                     "#include \"clang/Format/Format.h\"\n"
                     "#include <memory>\n";
  std::string Expected = "#include \"x/fix.h\"\n"
                         "#include \"a.h\"\n"
                         "#include \"b.h\"\n"
                         "#include \"clang/Format/Format.h\"\n"
                         "#include \"llvm/x/y.h\"\n"
                         "#include <memory>\n";
  EXPECT_EQ(Expected, insert(Code, "\"llvm/x/y.h\""));
}

TEST_F(HeaderIncludesTest, InsertIntoBlockSorted) {
  std::string Code = "#include \"x/fix.h\"\n"
                     "#include \"a.h\"\n"
                     "#include \"c.h\"\n"
                     "#include <memory>\n";
  std::string Expected = "#include \"x/fix.h\"\n"
                         "#include \"a.h\"\n"
                         "#include \"b.h\"\n"
                         "#include \"c.h\"\n"
                         "#include <memory>\n";
  EXPECT_EQ(Expected, insert(Code, "\"b.h\""));
}

TEST_F(HeaderIncludesTest, InsertIntoFirstBlockOfSameKind) {
  std::string Code = "#include \"x/fix.h\"\n"
                     "#include \"c.h\"\n"
                     "#include \"e.h\"\n"
                     "#include \"f.h\"\n"
                     "#include <memory>\n"
                     "#include <vector>\n"
                     "#include \"m.h\"\n"
                     "#include \"n.h\"\n";
  std::string Expected = "#include \"x/fix.h\"\n"
                         "#include \"c.h\"\n"
                         "#include \"d.h\"\n"
                         "#include \"e.h\"\n"
                         "#include \"f.h\"\n"
                         "#include <memory>\n"
                         "#include <vector>\n"
                         "#include \"m.h\"\n"
                         "#include \"n.h\"\n";
  EXPECT_EQ(Expected, insert(Code, "\"d.h\""));
}

TEST_F(HeaderIncludesTest, InsertIntoSystemBlockSorted) {
  std::string Code = "#include \"x/fix.h\"\n"
                     "#include \"a.h\"\n"
                     "#include \"c.h\"\n"
                     "#include <a>\n"
                     "#include <z>\n";
  std::string Expected = "#include \"x/fix.h\"\n"
                         "#include \"a.h\"\n"
                         "#include \"c.h\"\n"
                         "#include <a>\n"
                         "#include <vector>\n"
                         "#include <z>\n";
  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, InsertNewSystemIncludeGoogleStyle) {
  std::string Code = "#include \"x/fix.h\"\n"
                     "\n"
                     "#include \"y/a.h\"\n"
                     "#include \"z/b.h\"\n";
  // FIXME: inserting after the empty line following the main header might be
  // preferred.
  std::string Expected = "#include \"x/fix.h\"\n"
                         "#include <vector>\n"
                         "\n"
                         "#include \"y/a.h\"\n"
                         "#include \"z/b.h\"\n";
  Style = format::getGoogleStyle(format::FormatStyle::LanguageKind::LK_Cpp)
              .IncludeStyle;
  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, NotConfusedByDefine) {
  std::string Code = "void f() {}\n"
                     "#define A \\\n"
                     "  int i;";
  std::string Expected = "#include <vector>\n"
                         "void f() {}\n"
                         "#define A \\\n"
                         "  int i;";
  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, SkippedTopComment) {
  std::string Code = "// comment\n"
                     "\n"
                     "   // comment\n";
  std::string Expected = "// comment\n"
                         "\n"
                         "   // comment\n"
                         "#include <vector>\n";
  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, SkippedMixedComments) {
  std::string Code = "// comment\n"
                     "// comment \\\n"
                     " comment continued\n"
                     "/*\n"
                     "* comment\n"
                     "*/\n";
  std::string Expected = "// comment\n"
                         "// comment \\\n"
                         " comment continued\n"
                         "/*\n"
                         "* comment\n"
                         "*/\n"
                         "#include <vector>\n";
  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, MultipleBlockCommentsInOneLine) {
  std::string Code = "/*\n"
                     "* comment\n"
                     "*/ /* comment\n"
                     "*/\n"
                     "\n\n"
                     "/* c1 */ /*c2 */\n";
  std::string Expected = "/*\n"
                         "* comment\n"
                         "*/ /* comment\n"
                         "*/\n"
                         "\n\n"
                         "/* c1 */ /*c2 */\n"
                         "#include <vector>\n";
  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, CodeAfterComments) {
  std::string Code = "/*\n"
                     "* comment\n"
                     "*/ /* comment\n"
                     "*/\n"
                     "\n\n"
                     "/* c1 */ /*c2 */\n"
                     "\n"
                     "int x;\n";
  std::string Expected = "/*\n"
                         "* comment\n"
                         "*/ /* comment\n"
                         "*/\n"
                         "\n\n"
                         "/* c1 */ /*c2 */\n"
                         "\n"
                         "#include <vector>\n"
                         "int x;\n";
  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, FakeHeaderGuardIfDef) {
  std::string Code = "// comment \n"
                     "#ifdef X\n"
                     "#define X\n";
  std::string Expected = "// comment \n"
                         "#include <vector>\n"
                         "#ifdef X\n"
                         "#define X\n";
  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, RealHeaderGuardAfterComments) {
  std::string Code = "// comment \n"
                     "#ifndef X\n"
                     "#define X\n"
                     "int x;\n"
                     "#define Y 1\n";
  std::string Expected = "// comment \n"
                         "#ifndef X\n"
                         "#define X\n"
                         "#include <vector>\n"
                         "int x;\n"
                         "#define Y 1\n";
  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, PragmaOnce) {
  std::string Code = "// comment \n"
                     "#pragma once\n"
                     "int x;\n";
  std::string Expected = "// comment \n"
                         "#pragma once\n"
                         "#include <vector>\n"
                         "int x;\n";
  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, IfNDefWithNoDefine) {
  std::string Code = "// comment \n"
                     "#ifndef X\n"
                     "int x;\n"
                     "#define Y 1\n";
  std::string Expected = "// comment \n"
                         "#include <vector>\n"
                         "#ifndef X\n"
                         "int x;\n"
                         "#define Y 1\n";
  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, FakeHeaderGuard) {
  std::string Code = "// comment \n"
                     "#ifndef X\n"
                     "#define 1\n";
  std::string Expected = "// comment \n"
                         "#include <vector>\n"
                         "#ifndef X\n"
                         "#define 1\n";
  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, FakeHeaderGuardIfnDef) {
  std::string Code = "#ifndef A_H\n"
                     "#define A_H 1\n"
                     "#endif";
  std::string Expected = "#include \"b.h\"\n"
                         "#ifndef A_H\n"
                         "#define A_H 1\n"
                         "#endif";

  EXPECT_EQ(Expected, insert(Code, "\"b.h\""));
}

TEST_F(HeaderIncludesTest, HeaderGuardWithComment) {
  std::string Code = "// comment \n"
                     "#ifndef X // comment\n"
                     "// comment\n"
                     "/* comment\n"
                     "*/\n"
                     "/* comment */ #define X\n"
                     "int x;\n"
                     "#define Y 1\n";
  std::string Expected = "// comment \n"
                         "#ifndef X // comment\n"
                         "// comment\n"
                         "/* comment\n"
                         "*/\n"
                         "/* comment */ #define X\n"
                         "#include <vector>\n"
                         "int x;\n"
                         "#define Y 1\n";
  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, EmptyCode) {
  std::string Code = "";
  std::string Expected = "#include <vector>\n";
  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, NoNewLineAtTheEndOfCode) {
  std::string Code = "#include <map>";
  std::string Expected = "#include <map>\n#include <vector>\n";
  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, SkipExistingHeaders) {
  std::string Code = "#include \"a.h\"\n"
                     "#include <vector>\n";
  std::string Expected = "#include \"a.h\"\n"
                         "#include <vector>\n";
  EXPECT_EQ(Expected, insert(Code, "<vector>"));
  EXPECT_EQ(Expected, insert(Code, "\"a.h\""));
}

TEST_F(HeaderIncludesTest, AddIncludesWithDifferentForms) {
  std::string Code = "#include <vector>\n";
  // FIXME: this might not be the best behavior.
  std::string Expected = "#include \"vector\"\n"
                         "#include <vector>\n";
  EXPECT_EQ(Expected, insert(Code, "\"vector\""));
}

TEST_F(HeaderIncludesTest, NoInsertionAfterCode) {
  std::string Code = "#include \"a.h\"\n"
                     "void f() {}\n"
                     "#include \"b.h\"\n";
  std::string Expected = "#include \"a.h\"\n"
                         "#include \"c.h\"\n"
                         "void f() {}\n"
                         "#include \"b.h\"\n";
  EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
}

TEST_F(HeaderIncludesTest, NoInsertionInStringLiteral) {
  std::string Code = "#include \"a.h\"\n"
                     "const char[] = R\"(\n"
                     "#include \"b.h\"\n"
                     ")\";\n";
  std::string Expected = "#include \"a.h\"\n"
                         "#include \"c.h\"\n"
                         "const char[] = R\"(\n"
                         "#include \"b.h\"\n"
                         ")\";\n";
  EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
}

TEST_F(HeaderIncludesTest, NoInsertionAfterOtherDirective) {
  std::string Code = "#include \"a.h\"\n"
                     "#ifdef X\n"
                     "#include \"b.h\"\n"
                     "#endif\n";
  std::string Expected = "#include \"a.h\"\n"
                         "#include \"c.h\"\n"
                         "#ifdef X\n"
                         "#include \"b.h\"\n"
                         "#endif\n";
  EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
}

TEST_F(HeaderIncludesTest, CanInsertAfterLongSystemInclude) {
  std::string Code = "#include \"a.h\"\n"
                     "// comment\n\n"
                     "#include <a/b/c/d/e.h>\n";
  std::string Expected = "#include \"a.h\"\n"
                         "// comment\n\n"
                         "#include <a/b/c/d/e.h>\n"
                         "#include <x.h>\n";
  EXPECT_EQ(Expected, insert(Code, "<x.h>"));
}

TEST_F(HeaderIncludesTest, CanInsertAfterComment) {
  std::string Code = "#include \"a.h\"\n"
                     "// Comment\n"
                     "\n"
                     "/* Comment */\n"
                     "// Comment\n"
                     "\n"
                     "#include \"b.h\"\n";
  std::string Expected = "#include \"a.h\"\n"
                         "// Comment\n"
                         "\n"
                         "/* Comment */\n"
                         "// Comment\n"
                         "\n"
                         "#include \"b.h\"\n"
                         "#include \"c.h\"\n";
  EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
}

TEST_F(HeaderIncludesTest, LongCommentsInTheBeginningOfFile) {
  std::string Code = "// Loooooooooooooooooooooooooong comment\n"
                     "// Loooooooooooooooooooooooooong comment\n"
                     "// Loooooooooooooooooooooooooong comment\n"
                     "#include <string>\n"
                     "#include <vector>\n"
                     "\n"
                     "#include \"a.h\"\n"
                     "#include \"b.h\"\n";
  std::string Expected = "// Loooooooooooooooooooooooooong comment\n"
                         "// Loooooooooooooooooooooooooong comment\n"
                         "// Loooooooooooooooooooooooooong comment\n"
                         "#include <string>\n"
                         "#include <vector>\n"
                         "\n"
                         "#include \"a.h\"\n"
                         "#include \"b.h\"\n"
                         "#include \"third.h\"\n";
  Style = format::getGoogleStyle(format::FormatStyle::LanguageKind::LK_Cpp)
              .IncludeStyle;
  EXPECT_EQ(Expected, insert(Code, "\"third.h\""));
}

TEST_F(HeaderIncludesTest, SimpleDeleteInclude) {
  std::string Code = "#include \"abc.h\"\n"
                     "#include \"xyz.h\" // comment\n"
                     "int x;\n";
  std::string Expected = "#include \"abc.h\"\n"
                         "int x;\n";
  EXPECT_EQ(Expected, remove(Code, "\"xyz.h\""));
}

TEST_F(HeaderIncludesTest, DeleteQuotedOnly) {
  std::string Code = "#include \"abc.h\"\n"
                     "#include <abc.h>\n"
                     "int x;\n";
  std::string Expected = "#include <abc.h>\n"
                         "int x;\n";
  EXPECT_EQ(Expected, remove(Code, "\"abc.h\""));
}

TEST_F(HeaderIncludesTest, DeleteAllCode) {
  std::string Code = "#include \"xyz.h\"\n";
  std::string Expected = "";
  EXPECT_EQ(Expected, remove(Code, "\"xyz.h\""));
}

TEST_F(HeaderIncludesTest, DeleteOnlyIncludesWithSameQuote) {
  std::string Code = "#include \"xyz.h\"\n"
                     "#include \"xyz\"\n"
                     "#include <xyz.h>\n";
  std::string Expected = "#include \"xyz.h\"\n"
                         "#include \"xyz\"\n";
  EXPECT_EQ(Expected, remove(Code, "<xyz.h>"));
}

TEST_F(HeaderIncludesTest, CanDeleteAfterCode) {
  std::string Code = "#include \"a.h\"\n"
                     "void f() {}\n"
                     "#include \"b.h\"\n";
  std::string Expected = "#include \"a.h\"\n"
                         "void f() {}\n";
  EXPECT_EQ(Expected, remove(Code, "\"b.h\""));
}

TEST_F(HeaderIncludesTest, InsertGlobalModuleFragmentDeclInterfaceUnit) {
  // Ensure the header insertion comes with a global module fragment decl (i.e.
  // a 'module;' line) when:
  //     - the input file is an module interface unit, and
  //     - no tokens excluding comments and whitespaces exist before the module
  //       declaration.
  std::string Code = R"cpp(// comments

// more comments

export module foo;

void test() {
    std::vector<int> ints {};
})cpp";
  std::string Expected = R"cpp(// comments

// more comments

module;
#include <vector>
export module foo;

void test() {
    std::vector<int> ints {};
})cpp";

  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, InsertGlobalModuleFragmentDeclImplUnit) {
  // Ensure the header insertion comes with a global module fragment decl (i.e.
  // a 'module;' line) when:
  //     - the input file is an module implementation unit, and
  //     - no tokens excluding comments and whitespaces exist before the module
  //       declaration.
  std::string Code = R"cpp(// comments

// more comments

module foo;

void test() {
    std::vector<int> ints {};
})cpp";
  std::string Expected = R"cpp(// comments

// more comments

module;
#include <vector>
module foo;

void test() {
    std::vector<int> ints {};
})cpp";

  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, InsertInGlobalModuleFragment) {
  // Ensure header insertions go only in the global module fragment
  std::string Code = R"cpp(// comments

// more comments

module;
export module foo;

int main() {
    std::vector<int> ints {};
})cpp";
  std::string Expected = R"cpp(// comments

// more comments

module;
#include <vector>
export module foo;

int main() {
    std::vector<int> ints {};
})cpp";

  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, InsertInGlobalModuleFragmentWithPP) {
  // Ensure header insertions go only in the global module fragment
  std::string Code = R"cpp(// comments

// more comments

// some more comments

module;

#ifndef MACRO_NAME
#define MACRO_NAME
#endif

// comment

#ifndef MACRO_NAME
#define MACRO_NAME
#endif

// more comment

int main() {
    std::vector<int> ints {};
})cpp";
  std::string Expected = R"cpp(// comments

// more comments

// some more comments

module;

#include <vector>
#ifndef MACRO_NAME
#define MACRO_NAME
#endif

// comment

#ifndef MACRO_NAME
#define MACRO_NAME
#endif

// more comment

int main() {
    std::vector<int> ints {};
})cpp";

  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, InsertInGlobalModuleFragmentWithPPIncludes) {
  // Ensure header insertions go only in the global module fragment
  std::string Code = R"cpp(// comments

// more comments

// some more comments

module;

#include "header.h"

#include <string>

#ifndef MACRO_NAME
#define MACRO_NAME
#endif

// comment

#ifndef MACRO_NAME
#define MACRO_NAME
#endif

// more comment

int main() {
    std::vector<int> ints {};
})cpp";
  std::string Expected = R"cpp(// comments

// more comments

// some more comments

module;

#include "header.h"

#include <string>
#include <vector>

#ifndef MACRO_NAME
#define MACRO_NAME
#endif

// comment

#ifndef MACRO_NAME
#define MACRO_NAME
#endif

// more comment

int main() {
    std::vector<int> ints {};
})cpp";

  EXPECT_EQ(Expected, insert(Code, "<vector>"));
}

TEST_F(HeaderIncludesTest, BatchInsertSortingAndGrouping) {
  std::string Code = R"cpp(
void test();
)cpp";
  std::string Expected =
      "\n#include \"a.h\"\n#include \"b.h\"\n#include <foo>\nvoid test();\n";

  EXPECT_EQ(Expected,
            insertBatch(Code, {HeaderIncludes::HeaderToInsert("\"b.h\""),
                               HeaderIncludes::HeaderToInsert("\"a.h\""),
                               HeaderIncludes::HeaderToInsert("<foo>")}));
}

TEST_F(HeaderIncludesTest, BatchInsertMainHeader) {
  FileName = "foo.cc";
  Style.IncludeIsMainRegex = "$";
  std::string Code = R"cpp(
void test();
)cpp";
  std::string Expected = "\n#include \"foo.h\"\n#include \"a.h\"\n#include "
                         "\"b.h\"\n#include <vector>\nvoid test();\n";

  EXPECT_EQ(Expected,
            insertBatch(Code, {HeaderIncludes::HeaderToInsert("\"b.h\""),
                               HeaderIncludes::HeaderToInsert("\"foo.h\""),
                               HeaderIncludes::HeaderToInsert("\"a.h\""),
                               HeaderIncludes::HeaderToInsert("<vector>")}));
}

TEST_F(HeaderIncludesTest, BatchInsertDuplicateHeadersSameQuotes) {
  std::string Code = R"cpp(
void test();
)cpp";
  std::string Expected = "\n#include \"a.h\"\n#include <foo>\nvoid test();\n";

  EXPECT_EQ(Expected,
            insertBatch(Code, {HeaderIncludes::HeaderToInsert("\"a.h\""),
                               HeaderIncludes::HeaderToInsert("\"a.h\""),
                               HeaderIncludes::HeaderToInsert("<foo>")}));
}

TEST_F(HeaderIncludesTest, BatchInsertDuplicateHeadersMixedQuotes) {
  std::string Code = R"cpp(
void test();
)cpp";
  std::string Expected = "\n#include \"a.h\"\n#include <a.h>\nvoid test();\n";

  EXPECT_EQ(Expected,
            insertBatch(Code, {HeaderIncludes::HeaderToInsert("\"a.h\""),
                               HeaderIncludes::HeaderToInsert("<a.h>")}));
}

TEST_F(HeaderIncludesTest, BatchInsertDuplicateHeadersMixedDirectives) {
  std::string Code = R"cpp(
void test();
)cpp";
  std::string Expected = "\n#import \"a.h\"\n#include <foo>\nvoid test();\n";

  EXPECT_EQ(
      Expected,
      insertBatch(
          Code,
          {HeaderIncludes::HeaderToInsert("\"a.h\"", IncludeDirective::Include),
           HeaderIncludes::HeaderToInsert("\"a.h\"", IncludeDirective::Import),
           HeaderIncludes::HeaderToInsert("<foo>")}));
}

TEST_F(HeaderIncludesTest, BatchInsertIntoExistingIncludes) {
  std::string Code = R"cpp(#include "b.h"

void test();
)cpp";
  std::string Expected = R"cpp(#include "a.h"
#include "b.h"
#include "c.h"
#include <vector>

void test();
)cpp";

  EXPECT_EQ(Expected,
            insertBatch(Code, {HeaderIncludes::HeaderToInsert("\"c.h\""),
                               HeaderIncludes::HeaderToInsert("\"a.h\""),
                               HeaderIncludes::HeaderToInsert("<vector>")}));
}

TEST_F(HeaderIncludesTest, BatchInsertEmptyFile) {
  std::string Code = "";
  std::string Expected = "#include \"a.h\"\n#include <foo>\n";

  EXPECT_EQ(Expected,
            insertBatch(Code, {HeaderIncludes::HeaderToInsert("<foo>"),
                               HeaderIncludes::HeaderToInsert("\"a.h\"")}));
}

TEST_F(HeaderIncludesTest, BatchInsertImportsAlongsideIncludes) {
  std::string Code = R"objc(
void test();
)objc";
  std::string Expected =
      "\n#import \"a.h\"\n#include \"b.h\"\n#import <foo>\nvoid test();\n";

  EXPECT_EQ(
      Expected,
      insertBatch(
          Code,
          {HeaderIncludes::HeaderToInsert("\"b.h\"", IncludeDirective::Include),
           HeaderIncludes::HeaderToInsert("\"a.h\"", IncludeDirective::Import),
           HeaderIncludes::HeaderToInsert("<foo>", IncludeDirective::Import)}));
}

} // namespace
} // namespace tooling
} // namespace clang