//===- unittests/libclang/LibclangTest.cpp --- libclang 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 "TestUtils.h"
#include "clang-c/Index.h"
#include "clang-c/Rewrite.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/raw_ostream.h"
#include "gtest/gtest.h"
#include <cstring>
#include <fstream>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <set>
#define DEBUG_TYPE "libclang-test"

TEST(libclang, clang_parseTranslationUnit2_InvalidArgs) {
  EXPECT_EQ(CXError_InvalidArguments,
            clang_parseTranslationUnit2(nullptr, nullptr, nullptr, 0, nullptr,
                                        0, 0, nullptr));
}

TEST(libclang, clang_createTranslationUnit_InvalidArgs) {
  EXPECT_EQ(nullptr, clang_createTranslationUnit(nullptr, nullptr));
}

TEST(libclang, clang_createTranslationUnit2_InvalidArgs) {
  EXPECT_EQ(CXError_InvalidArguments,
            clang_createTranslationUnit2(nullptr, nullptr, nullptr));

  CXTranslationUnit TU = reinterpret_cast<CXTranslationUnit>(1);
  EXPECT_EQ(CXError_InvalidArguments,
            clang_createTranslationUnit2(nullptr, nullptr, &TU));
  EXPECT_EQ(nullptr, TU);
}

namespace {
struct TestVFO {
  const char *Contents;
  CXVirtualFileOverlay VFO;

  TestVFO(const char *Contents) : Contents(Contents) {
    VFO = clang_VirtualFileOverlay_create(0);
  }

  void map(const char *VPath, const char *RPath) {
    CXErrorCode Err = clang_VirtualFileOverlay_addFileMapping(VFO, VPath, RPath);
    EXPECT_EQ(Err, CXError_Success);
  }

  void mapError(const char *VPath, const char *RPath, CXErrorCode ExpErr) {
    CXErrorCode Err = clang_VirtualFileOverlay_addFileMapping(VFO, VPath, RPath);
    EXPECT_EQ(Err, ExpErr);
  }

  ~TestVFO() {
    if (Contents) {
      char *BufPtr;
      unsigned BufSize;
      clang_VirtualFileOverlay_writeToBuffer(VFO, 0, &BufPtr, &BufSize);
      std::string BufStr(BufPtr, BufSize);
      EXPECT_STREQ(Contents, BufStr.c_str());
      clang_free(BufPtr);
    }
    clang_VirtualFileOverlay_dispose(VFO);
  }
};
}

TEST(libclang, VirtualFileOverlay_Basic) {
  const char *contents =
      "{\n"
      "  'version': 0,\n"
      "  'roots': [\n"
      "    {\n"
      "      'type': 'directory',\n"
      "      'name': \"/path/virtual\",\n"
      "      'contents': [\n"
      "        {\n"
      "          'type': 'file',\n"
      "          'name': \"foo.h\",\n"
      "          'external-contents': \"/real/foo.h\"\n"
      "        }\n"
      "      ]\n"
      "    }\n"
      "  ]\n"
      "}\n";
  TestVFO T(contents);
  T.map("/path/virtual/foo.h", "/real/foo.h");
}

TEST(libclang, VirtualFileOverlay_Unicode) {
  const char *contents =
      "{\n"
      "  'version': 0,\n"
      "  'roots': [\n"
      "    {\n"
      "      'type': 'directory',\n"
      "      'name': \"/path/\\u266B\",\n"
      "      'contents': [\n"
      "        {\n"
      "          'type': 'file',\n"
      "          'name': \"\\u2602.h\",\n"
      "          'external-contents': \"/real/\\u2602.h\"\n"
      "        }\n"
      "      ]\n"
      "    }\n"
      "  ]\n"
      "}\n";
  TestVFO T(contents);
  T.map("/path/♫/☂.h", "/real/☂.h");
}

TEST(libclang, VirtualFileOverlay_InvalidArgs) {
  TestVFO T(nullptr);
  T.mapError("/path/./virtual/../foo.h", "/real/foo.h",
             CXError_InvalidArguments);
}

TEST(libclang, VirtualFileOverlay_RemapDirectories) {
  const char *contents =
      "{\n"
      "  'version': 0,\n"
      "  'roots': [\n"
      "    {\n"
      "      'type': 'directory',\n"
      "      'name': \"/another/dir\",\n"
      "      'contents': [\n"
      "        {\n"
      "          'type': 'file',\n"
      "          'name': \"foo2.h\",\n"
      "          'external-contents': \"/real/foo2.h\"\n"
      "        }\n"
      "      ]\n"
      "    },\n"
      "    {\n"
      "      'type': 'directory',\n"
      "      'name': \"/path/virtual/dir\",\n"
      "      'contents': [\n"
      "        {\n"
      "          'type': 'file',\n"
      "          'name': \"foo1.h\",\n"
      "          'external-contents': \"/real/foo1.h\"\n"
      "        },\n"
      "        {\n"
      "          'type': 'file',\n"
      "          'name': \"foo3.h\",\n"
      "          'external-contents': \"/real/foo3.h\"\n"
      "        },\n"
      "        {\n"
      "          'type': 'directory',\n"
      "          'name': \"in/subdir\",\n"
      "          'contents': [\n"
      "            {\n"
      "              'type': 'file',\n"
      "              'name': \"foo4.h\",\n"
      "              'external-contents': \"/real/foo4.h\"\n"
      "            }\n"
      "          ]\n"
      "        }\n"
      "      ]\n"
      "    }\n"
      "  ]\n"
      "}\n";
  TestVFO T(contents);
  T.map("/path/virtual/dir/foo1.h", "/real/foo1.h");
  T.map("/another/dir/foo2.h", "/real/foo2.h");
  T.map("/path/virtual/dir/foo3.h", "/real/foo3.h");
  T.map("/path/virtual/dir/in/subdir/foo4.h", "/real/foo4.h");
}

TEST(libclang, VirtualFileOverlay_CaseInsensitive) {
  const char *contents =
      "{\n"
      "  'version': 0,\n"
      "  'case-sensitive': 'false',\n"
      "  'roots': [\n"
      "    {\n"
      "      'type': 'directory',\n"
      "      'name': \"/path/virtual\",\n"
      "      'contents': [\n"
      "        {\n"
      "          'type': 'file',\n"
      "          'name': \"foo.h\",\n"
      "          'external-contents': \"/real/foo.h\"\n"
      "        }\n"
      "      ]\n"
      "    }\n"
      "  ]\n"
      "}\n";
  TestVFO T(contents);
  T.map("/path/virtual/foo.h", "/real/foo.h");
  clang_VirtualFileOverlay_setCaseSensitivity(T.VFO, false);
}

TEST(libclang, VirtualFileOverlay_SharedPrefix) {
  const char *contents =
      "{\n"
      "  'version': 0,\n"
      "  'roots': [\n"
      "    {\n"
      "      'type': 'directory',\n"
      "      'name': \"/path/foo\",\n"
      "      'contents': [\n"
      "        {\n"
      "          'type': 'file',\n"
      "          'name': \"bar\",\n"
      "          'external-contents': \"/real/bar\"\n"
      "        },\n"
      "        {\n"
      "          'type': 'file',\n"
      "          'name': \"bar.h\",\n"
      "          'external-contents': \"/real/bar.h\"\n"
      "        }\n"
      "      ]\n"
      "    },\n"
      "    {\n"
      "      'type': 'directory',\n"
      "      'name': \"/path/foobar\",\n"
      "      'contents': [\n"
      "        {\n"
      "          'type': 'file',\n"
      "          'name': \"baz.h\",\n"
      "          'external-contents': \"/real/baz.h\"\n"
      "        }\n"
      "      ]\n"
      "    },\n"
      "    {\n"
      "      'type': 'directory',\n"
      "      'name': \"/path\",\n"
      "      'contents': [\n"
      "        {\n"
      "          'type': 'file',\n"
      "          'name': \"foobarbaz.h\",\n"
      "          'external-contents': \"/real/foobarbaz.h\"\n"
      "        }\n"
      "      ]\n"
      "    }\n"
      "  ]\n"
      "}\n";
  TestVFO T(contents);
  T.map("/path/foo/bar.h", "/real/bar.h");
  T.map("/path/foo/bar", "/real/bar");
  T.map("/path/foobar/baz.h", "/real/baz.h");
  T.map("/path/foobarbaz.h", "/real/foobarbaz.h");
}

TEST(libclang, VirtualFileOverlay_AdjacentDirectory) {
  const char *contents =
      "{\n"
      "  'version': 0,\n"
      "  'roots': [\n"
      "    {\n"
      "      'type': 'directory',\n"
      "      'name': \"/path/dir1\",\n"
      "      'contents': [\n"
      "        {\n"
      "          'type': 'file',\n"
      "          'name': \"foo.h\",\n"
      "          'external-contents': \"/real/foo.h\"\n"
      "        },\n"
      "        {\n"
      "          'type': 'directory',\n"
      "          'name': \"subdir\",\n"
      "          'contents': [\n"
      "            {\n"
      "              'type': 'file',\n"
      "              'name': \"bar.h\",\n"
      "              'external-contents': \"/real/bar.h\"\n"
      "            }\n"
      "          ]\n"
      "        }\n"
      "      ]\n"
      "    },\n"
      "    {\n"
      "      'type': 'directory',\n"
      "      'name': \"/path/dir2\",\n"
      "      'contents': [\n"
      "        {\n"
      "          'type': 'file',\n"
      "          'name': \"baz.h\",\n"
      "          'external-contents': \"/real/baz.h\"\n"
      "        }\n"
      "      ]\n"
      "    }\n"
      "  ]\n"
      "}\n";
  TestVFO T(contents);
  T.map("/path/dir1/foo.h", "/real/foo.h");
  T.map("/path/dir1/subdir/bar.h", "/real/bar.h");
  T.map("/path/dir2/baz.h", "/real/baz.h");
}

TEST(libclang, VirtualFileOverlay_TopLevel) {
  const char *contents =
      "{\n"
      "  'version': 0,\n"
      "  'roots': [\n"
      "    {\n"
      "      'type': 'directory',\n"
      "      'name': \"/\",\n"
      "      'contents': [\n"
      "        {\n"
      "          'type': 'file',\n"
      "          'name': \"foo.h\",\n"
      "          'external-contents': \"/real/foo.h\"\n"
      "        }\n"
      "      ]\n"
      "    }\n"
      "  ]\n"
      "}\n";
  TestVFO T(contents);
  T.map("/foo.h", "/real/foo.h");
}

TEST(libclang, VirtualFileOverlay_Empty) {
  const char *contents =
      "{\n"
      "  'version': 0,\n"
      "  'roots': [\n"
      "  ]\n"
      "}\n";
  TestVFO T(contents);
}

TEST(libclang, ModuleMapDescriptor) {
  const char *Contents =
    "framework module TestFrame {\n"
    "  umbrella header \"TestFrame.h\"\n"
    "\n"
    "  export *\n"
    "  module * { export * }\n"
    "}\n";

  CXModuleMapDescriptor MMD = clang_ModuleMapDescriptor_create(0);

  clang_ModuleMapDescriptor_setFrameworkModuleName(MMD, "TestFrame");
  clang_ModuleMapDescriptor_setUmbrellaHeader(MMD, "TestFrame.h");

  char *BufPtr;
  unsigned BufSize;
  clang_ModuleMapDescriptor_writeToBuffer(MMD, 0, &BufPtr, &BufSize);
  std::string BufStr(BufPtr, BufSize);
  EXPECT_STREQ(Contents, BufStr.c_str());
  clang_free(BufPtr);
  clang_ModuleMapDescriptor_dispose(MMD);
}

TEST_F(LibclangParseTest, GlobalOptions) {
  EXPECT_EQ(clang_CXIndex_getGlobalOptions(Index), CXGlobalOpt_None);
}

class LibclangIndexOptionsTest : public LibclangParseTest {
  virtual void AdjustOptions(CXIndexOptions &Opts) {}

protected:
  void CreateIndex() override {
    CXIndexOptions Opts;
    memset(&Opts, 0, sizeof(Opts));
    Opts.Size = sizeof(CXIndexOptions);
    AdjustOptions(Opts);
    Index = clang_createIndexWithOptions(&Opts);
    ASSERT_TRUE(Index);
  }
};

TEST_F(LibclangIndexOptionsTest, GlobalOptions) {
  EXPECT_EQ(clang_CXIndex_getGlobalOptions(Index), CXGlobalOpt_None);
}

class LibclangIndexingEnabledIndexOptionsTest
    : public LibclangIndexOptionsTest {
  void AdjustOptions(CXIndexOptions &Opts) override {
    Opts.ThreadBackgroundPriorityForIndexing = CXChoice_Enabled;
  }
};

TEST_F(LibclangIndexingEnabledIndexOptionsTest, GlobalOptions) {
  EXPECT_EQ(clang_CXIndex_getGlobalOptions(Index),
            CXGlobalOpt_ThreadBackgroundPriorityForIndexing);
}

class LibclangIndexingDisabledEditingEnabledIndexOptionsTest
    : public LibclangIndexOptionsTest {
  void AdjustOptions(CXIndexOptions &Opts) override {
    Opts.ThreadBackgroundPriorityForIndexing = CXChoice_Disabled;
    Opts.ThreadBackgroundPriorityForEditing = CXChoice_Enabled;
  }
};

TEST_F(LibclangIndexingDisabledEditingEnabledIndexOptionsTest, GlobalOptions) {
  EXPECT_EQ(clang_CXIndex_getGlobalOptions(Index),
            CXGlobalOpt_ThreadBackgroundPriorityForEditing);
}

class LibclangBothEnabledIndexOptionsTest : public LibclangIndexOptionsTest {
  void AdjustOptions(CXIndexOptions &Opts) override {
    Opts.ThreadBackgroundPriorityForIndexing = CXChoice_Enabled;
    Opts.ThreadBackgroundPriorityForEditing = CXChoice_Enabled;
  }
};

TEST_F(LibclangBothEnabledIndexOptionsTest, GlobalOptions) {
  EXPECT_EQ(clang_CXIndex_getGlobalOptions(Index),
            CXGlobalOpt_ThreadBackgroundPriorityForAll);
}

class LibclangPreambleStorageTest : public LibclangParseTest {
  std::string Main = "main.cpp";

protected:
  std::string PreambleDir;
  void InitializePreambleDir() {
    llvm::SmallString<128> PathBuffer(TestDir);
    llvm::sys::path::append(PathBuffer, "preambles");
    namespace fs = llvm::sys::fs;
    ASSERT_FALSE(fs::create_directory(PathBuffer, false, fs::perms::owner_all));

    PreambleDir = static_cast<std::string>(PathBuffer);
    FilesAndDirsToRemove.insert(PreambleDir);
  }

public:
  void CountPreamblesInPreambleDir(int PreambleCount) {
    // For some reason, the preamble is not created without '\n' before `int`.
    WriteFile(Main, "\nint main() {}");

    TUFlags |= CXTranslationUnit_CreatePreambleOnFirstParse;
    ClangTU = clang_parseTranslationUnit(Index, Main.c_str(), nullptr, 0,
                                         nullptr, 0, TUFlags);

    int FileCount = 0;

    namespace fs = llvm::sys::fs;
    std::error_code EC;
    for (fs::directory_iterator File(PreambleDir, EC), FileEnd;
         File != FileEnd && !EC; File.increment(EC)) {
      ++FileCount;

      EXPECT_EQ(File->type(), fs::file_type::regular_file);

      const auto Filename = llvm::sys::path::filename(File->path());
      EXPECT_EQ(Filename.size(), std::strlen("preamble-%%%%%%.pch"));
      EXPECT_TRUE(Filename.starts_with("preamble-"));
      EXPECT_TRUE(Filename.ends_with(".pch"));

      const auto Status = File->status();
      ASSERT_TRUE(Status);
      if (false) {
        // The permissions assertion below fails, because the .pch.tmp file is
        // created with default permissions and replaces the .pch file along
        // with its permissions. Therefore the permissions set in
        // TempPCHFile::create() don't matter in the end.
        EXPECT_EQ(Status->permissions(), fs::owner_read | fs::owner_write);
      }
    }

    EXPECT_EQ(FileCount, PreambleCount);
  }
};

class LibclangNotOverriddenPreambleStoragePathTest
    : public LibclangPreambleStorageTest {
protected:
  void CreateIndex() override {
    InitializePreambleDir();
    LibclangPreambleStorageTest::CreateIndex();
  }
};

class LibclangSetPreambleStoragePathTest : public LibclangPreambleStorageTest {
  virtual bool StorePreamblesInMemory() { return false; }
  virtual const char *PreambleStoragePath() = 0;

protected:
  void CreateIndex() override {
    InitializePreambleDir();

    CXIndexOptions Opts{};
    Opts.Size = sizeof(CXIndexOptions);
    Opts.StorePreamblesInMemory = StorePreamblesInMemory();
    Opts.PreambleStoragePath = PreambleStoragePath();
    Index = clang_createIndexWithOptions(&Opts);
    ASSERT_TRUE(Index);
  }
};

class LibclangNullPreambleStoragePathTest
    : public LibclangSetPreambleStoragePathTest {
  const char *PreambleStoragePath() override { return nullptr; }
};
class LibclangEmptyPreambleStoragePathTest
    : public LibclangSetPreambleStoragePathTest {
  const char *PreambleStoragePath() override { return ""; }
};
class LibclangPreambleDirPreambleStoragePathTest
    : public LibclangSetPreambleStoragePathTest {
  const char *PreambleStoragePath() override { return PreambleDir.c_str(); }
};

class LibclangStoreInMemoryNullPreambleStoragePathTest
    : public LibclangNullPreambleStoragePathTest {
  bool StorePreamblesInMemory() override { return true; }
};
class LibclangStoreInMemoryEmptyPreambleStoragePathTest
    : public LibclangEmptyPreambleStoragePathTest {
  bool StorePreamblesInMemory() override { return true; }
};
class LibclangStoreInMemoryPreambleDirPreambleStoragePathTest
    : public LibclangPreambleDirPreambleStoragePathTest {
  bool StorePreamblesInMemory() override { return true; }
};

TEST_F(LibclangNotOverriddenPreambleStoragePathTest, CountPreambles) {
  CountPreamblesInPreambleDir(0);
}
TEST_F(LibclangNullPreambleStoragePathTest, CountPreambles) {
  CountPreamblesInPreambleDir(0);
}
TEST_F(LibclangEmptyPreambleStoragePathTest, CountPreambles) {
  CountPreamblesInPreambleDir(0);
}
TEST_F(LibclangPreambleDirPreambleStoragePathTest, CountPreambles) {
  CountPreamblesInPreambleDir(1);
}
TEST_F(LibclangStoreInMemoryNullPreambleStoragePathTest, CountPreambles) {
  CountPreamblesInPreambleDir(0);
}
TEST_F(LibclangStoreInMemoryEmptyPreambleStoragePathTest, CountPreambles) {
  CountPreamblesInPreambleDir(0);
}
TEST_F(LibclangStoreInMemoryPreambleDirPreambleStoragePathTest,
       CountPreambles) {
  CountPreamblesInPreambleDir(0);
}

TEST_F(LibclangParseTest, AllSkippedRanges) {
  std::string Header = "header.h", Main = "main.cpp";
  WriteFile(Header,
    "#ifdef MANGOS\n"
    "printf(\"mmm\");\n"
    "#endif");
  WriteFile(Main,
    "#include \"header.h\"\n"
    "#ifdef KIWIS\n"
    "printf(\"mmm!!\");\n"
    "#endif");

  ClangTU = clang_parseTranslationUnit(Index, Main.c_str(), nullptr, 0,
                                       nullptr, 0, TUFlags);

  CXSourceRangeList *Ranges = clang_getAllSkippedRanges(ClangTU);
  EXPECT_EQ(2U, Ranges->count);
  
  CXSourceLocation cxl;
  unsigned line;
  cxl = clang_getRangeStart(Ranges->ranges[0]);
  clang_getSpellingLocation(cxl, nullptr, &line, nullptr, nullptr);
  EXPECT_EQ(1U, line);
  cxl = clang_getRangeEnd(Ranges->ranges[0]);
  clang_getSpellingLocation(cxl, nullptr, &line, nullptr, nullptr);
  EXPECT_EQ(3U, line);

  cxl = clang_getRangeStart(Ranges->ranges[1]);
  clang_getSpellingLocation(cxl, nullptr, &line, nullptr, nullptr);
  EXPECT_EQ(2U, line);
  cxl = clang_getRangeEnd(Ranges->ranges[1]);
  clang_getSpellingLocation(cxl, nullptr, &line, nullptr, nullptr);
  EXPECT_EQ(4U, line);

  clang_disposeSourceRangeList(Ranges);
}

TEST_F(LibclangParseTest, EvaluateChildExpression) {
  std::string Main = "main.m";
  WriteFile(Main, "#define kFOO @\"foo\"\n"
                  "void foobar(void) {\n"
                  " {kFOO;}\n"
                  "}\n");
  ClangTU = clang_parseTranslationUnit(Index, Main.c_str(), nullptr, 0, nullptr,
                                       0, TUFlags);

  CXCursor C = clang_getTranslationUnitCursor(ClangTU);
  clang_visitChildren(
      C,
      [](CXCursor cursor, CXCursor parent,
         CXClientData client_data) -> CXChildVisitResult {
        if (clang_getCursorKind(cursor) == CXCursor_FunctionDecl) {
          int numberedStmt = 0;
          clang_visitChildren(
              cursor,
              [](CXCursor cursor, CXCursor parent,
                 CXClientData client_data) -> CXChildVisitResult {
                int &numberedStmt = *((int *)client_data);
                if (clang_getCursorKind(cursor) == CXCursor_CompoundStmt) {
                  if (numberedStmt) {
                    CXEvalResult RE = clang_Cursor_Evaluate(cursor);
                    EXPECT_NE(RE, nullptr);
                    EXPECT_EQ(clang_EvalResult_getKind(RE),
                              CXEval_ObjCStrLiteral);
                    clang_EvalResult_dispose(RE);
                    return CXChildVisit_Break;
                  }
                  numberedStmt++;
                }
                return CXChildVisit_Recurse;
              },
              &numberedStmt);
          EXPECT_EQ(numberedStmt, 1);
        }
        return CXChildVisit_Continue;
      },
      nullptr);
}

class LibclangReparseTest : public LibclangParseTest {
public:
  void DisplayDiagnostics() {
    unsigned NumDiagnostics = clang_getNumDiagnostics(ClangTU);
    for (unsigned i = 0; i < NumDiagnostics; ++i) {
      auto Diag = clang_getDiagnostic(ClangTU, i);
      LLVM_DEBUG(llvm::dbgs()
                 << clang_getCString(clang_formatDiagnostic(
                        Diag, clang_defaultDiagnosticDisplayOptions()))
                 << "\n");
      clang_disposeDiagnostic(Diag);
    }
  }
  bool ReparseTU(unsigned num_unsaved_files, CXUnsavedFile* unsaved_files) {
    if (clang_reparseTranslationUnit(ClangTU, num_unsaved_files, unsaved_files,
                                     clang_defaultReparseOptions(ClangTU))) {
      LLVM_DEBUG(llvm::dbgs() << "Reparse failed\n");
      return false;
    }
    DisplayDiagnostics();
    return true;
  }
};

TEST_F(LibclangReparseTest, FileName) {
  std::string CppName = "main.cpp";
  WriteFile(CppName, "int main() {}");
  ClangTU = clang_parseTranslationUnit(Index, CppName.c_str(), nullptr, 0,
                                       nullptr, 0, TUFlags);
  CXFile cxf = clang_getFile(ClangTU, CppName.c_str());

  CXString cxname = clang_getFileName(cxf);
  ASSERT_STREQ(clang_getCString(cxname), CppName.c_str());
  clang_disposeString(cxname);

  cxname = clang_File_tryGetRealPathName(cxf);
  ASSERT_TRUE(llvm::StringRef(clang_getCString(cxname)).ends_with("main.cpp"));
  clang_disposeString(cxname);
}

TEST_F(LibclangReparseTest, Reparse) {
  const char *HeaderTop = "#ifndef H\n#define H\nstruct Foo { int bar;";
  const char *HeaderBottom = "\n};\n#endif\n";
  const char *CppFile = "#include \"HeaderFile.h\"\nint main() {"
                         " Foo foo; foo.bar = 7; foo.baz = 8; }\n";
  std::string HeaderName = "HeaderFile.h";
  std::string CppName = "CppFile.cpp";
  WriteFile(CppName, CppFile);
  WriteFile(HeaderName, std::string(HeaderTop) + HeaderBottom);

  ClangTU = clang_parseTranslationUnit(Index, CppName.c_str(), nullptr, 0,
                                       nullptr, 0, TUFlags);
  EXPECT_EQ(1U, clang_getNumDiagnostics(ClangTU));
  DisplayDiagnostics();

  // Immedaitely reparse.
  ASSERT_TRUE(ReparseTU(0, nullptr /* No unsaved files. */));
  EXPECT_EQ(1U, clang_getNumDiagnostics(ClangTU));

  std::string NewHeaderContents =
      std::string(HeaderTop) + "int baz;" + HeaderBottom;
  WriteFile(HeaderName, NewHeaderContents);

  // Reparse after fix.
  ASSERT_TRUE(ReparseTU(0, nullptr /* No unsaved files. */));
  EXPECT_EQ(0U, clang_getNumDiagnostics(ClangTU));
}

TEST_F(LibclangReparseTest, ReparseWithModule) {
  const char *HeaderTop = "#ifndef H\n#define H\nstruct Foo { int bar;";
  const char *HeaderBottom = "\n};\n#endif\n";
  const char *MFile = "#include \"HeaderFile.h\"\nint main() {"
                         " struct Foo foo; foo.bar = 7; foo.baz = 8; }\n";
  const char *ModFile = "module A { header \"HeaderFile.h\" }\n";
  std::string HeaderName = "HeaderFile.h";
  std::string MName = "MFile.m";
  std::string ModName = "module.modulemap";
  WriteFile(MName, MFile);
  WriteFile(HeaderName, std::string(HeaderTop) + HeaderBottom);
  WriteFile(ModName, ModFile);

  // Removing recursively is necessary to delete the module cache.
  RemoveTestDirRecursivelyDuringTeardown = true;
  std::string ModulesCache = std::string("-fmodules-cache-path=") + TestDir;
  const char *Args[] = { "-fmodules", ModulesCache.c_str(),
                         "-I", TestDir.c_str() };
  int NumArgs = std::size(Args);
  ClangTU = clang_parseTranslationUnit(Index, MName.c_str(), Args, NumArgs,
                                       nullptr, 0, TUFlags);
  EXPECT_EQ(1U, clang_getNumDiagnostics(ClangTU));
  DisplayDiagnostics();

  // Immedaitely reparse.
  ASSERT_TRUE(ReparseTU(0, nullptr /* No unsaved files. */));
  EXPECT_EQ(1U, clang_getNumDiagnostics(ClangTU));

  std::string NewHeaderContents =
      std::string(HeaderTop) + "int baz;" + HeaderBottom;
  WriteFile(HeaderName, NewHeaderContents);

  // Reparse after fix.
  ASSERT_TRUE(ReparseTU(0, nullptr /* No unsaved files. */));
  EXPECT_EQ(0U, clang_getNumDiagnostics(ClangTU));
}

TEST_F(LibclangReparseTest, clang_parseTranslationUnit2FullArgv) {
  // Provide a fake GCC 99.9.9 standard library that always overrides any local
  // GCC installation.
  std::string EmptyFiles[] = {"lib/gcc/arm-linux-gnueabi/99.9.9/crtbegin.o",
                              "include/arm-linux-gnueabi/.keep",
                              "include/c++/99.9.9/vector"};

  for (auto &Name : EmptyFiles)
    WriteFile(Name, "\n");

  std::string Filename = "test.cc";
  WriteFile(Filename, "#include <vector>\n");

  std::string Clang = "bin/clang";
  WriteFile(Clang, "");

  const char *Argv[] = {Clang.c_str(), "-target", "arm-linux-gnueabi",
                        "-stdlib=libstdc++", "--gcc-toolchain="};

  EXPECT_EQ(CXError_Success,
            clang_parseTranslationUnit2FullArgv(Index, Filename.c_str(), Argv,
                                                std::size(Argv),
                                                nullptr, 0, TUFlags, &ClangTU));
  EXPECT_EQ(0U, clang_getNumDiagnostics(ClangTU));
  DisplayDiagnostics();
}

class LibclangPrintingPolicyTest : public LibclangParseTest {
public:
  CXPrintingPolicy Policy = nullptr;

  void SetUp() override {
    LibclangParseTest::SetUp();
    std::string File = "file.cpp";
    WriteFile(File, "int i;\n");
    ClangTU = clang_parseTranslationUnit(Index, File.c_str(), nullptr, 0,
                                         nullptr, 0, TUFlags);
    CXCursor TUCursor = clang_getTranslationUnitCursor(ClangTU);
    Policy = clang_getCursorPrintingPolicy(TUCursor);
  }
  void TearDown() override {
    clang_PrintingPolicy_dispose(Policy);
    LibclangParseTest::TearDown();
  }
};

TEST_F(LibclangPrintingPolicyTest, SetAndGetProperties) {
  for (unsigned Value = 0; Value < 2; ++Value) {
    for (int I = 0; I < CXPrintingPolicy_LastProperty; ++I) {
      auto Property = static_cast<enum CXPrintingPolicyProperty>(I);

      clang_PrintingPolicy_setProperty(Policy, Property, Value);
      EXPECT_EQ(Value, clang_PrintingPolicy_getProperty(Policy, Property));
    }
  }
}

TEST_F(LibclangReparseTest, PreprocessorSkippedRanges) {
  std::string Header = "header.h", Main = "main.cpp";
  WriteFile(Header,
    "#ifdef MANGOS\n"
    "printf(\"mmm\");\n"
    "#endif");
  WriteFile(Main,
    "#include \"header.h\"\n"
    "#ifdef GUAVA\n"
    "#endif\n"
    "#ifdef KIWIS\n"
    "printf(\"mmm!!\");\n"
    "#endif");

  for (int i = 0; i != 3; ++i) {
    unsigned flags = TUFlags | CXTranslationUnit_PrecompiledPreamble;
    if (i == 2)
      flags |= CXTranslationUnit_CreatePreambleOnFirstParse;

    if (i != 0)
       clang_disposeTranslationUnit(ClangTU);  // dispose from previous iter

    // parse once
    ClangTU = clang_parseTranslationUnit(Index, Main.c_str(), nullptr, 0,
                                         nullptr, 0, flags);
    if (i != 0) {
      // reparse
      ASSERT_TRUE(ReparseTU(0, nullptr /* No unsaved files. */));
    }

    // Check all ranges are there
    CXSourceRangeList *Ranges = clang_getAllSkippedRanges(ClangTU);
    EXPECT_EQ(3U, Ranges->count);

    CXSourceLocation cxl;
    unsigned line;
    cxl = clang_getRangeStart(Ranges->ranges[0]);
    clang_getSpellingLocation(cxl, nullptr, &line, nullptr, nullptr);
    EXPECT_EQ(1U, line);
    cxl = clang_getRangeEnd(Ranges->ranges[0]);
    clang_getSpellingLocation(cxl, nullptr, &line, nullptr, nullptr);
    EXPECT_EQ(3U, line);

    cxl = clang_getRangeStart(Ranges->ranges[1]);
    clang_getSpellingLocation(cxl, nullptr, &line, nullptr, nullptr);
    EXPECT_EQ(2U, line);
    cxl = clang_getRangeEnd(Ranges->ranges[1]);
    clang_getSpellingLocation(cxl, nullptr, &line, nullptr, nullptr);
    EXPECT_EQ(3U, line);

    cxl = clang_getRangeStart(Ranges->ranges[2]);
    clang_getSpellingLocation(cxl, nullptr, &line, nullptr, nullptr);
    EXPECT_EQ(4U, line);
    cxl = clang_getRangeEnd(Ranges->ranges[2]);
    clang_getSpellingLocation(cxl, nullptr, &line, nullptr, nullptr);
    EXPECT_EQ(6U, line);

    clang_disposeSourceRangeList(Ranges);

    // Check obtaining ranges by each file works
    CXFile cxf = clang_getFile(ClangTU, Header.c_str());
    Ranges = clang_getSkippedRanges(ClangTU, cxf);
    EXPECT_EQ(1U, Ranges->count);
    cxl = clang_getRangeStart(Ranges->ranges[0]);
    clang_getSpellingLocation(cxl, nullptr, &line, nullptr, nullptr);
    EXPECT_EQ(1U, line);
    clang_disposeSourceRangeList(Ranges);

    cxf = clang_getFile(ClangTU, Main.c_str());
    Ranges = clang_getSkippedRanges(ClangTU, cxf);
    EXPECT_EQ(2U, Ranges->count);
    cxl = clang_getRangeStart(Ranges->ranges[0]);
    clang_getSpellingLocation(cxl, nullptr, &line, nullptr, nullptr);
    EXPECT_EQ(2U, line);
    cxl = clang_getRangeStart(Ranges->ranges[1]);
    clang_getSpellingLocation(cxl, nullptr, &line, nullptr, nullptr);
    EXPECT_EQ(4U, line);
    clang_disposeSourceRangeList(Ranges);
  }
}

class LibclangSerializationTest : public LibclangParseTest {
public:
  bool SaveAndLoadTU(const std::string &Filename) {
    unsigned options = clang_defaultSaveOptions(ClangTU);
    if (clang_saveTranslationUnit(ClangTU, Filename.c_str(), options) !=
        CXSaveError_None) {
      LLVM_DEBUG(llvm::dbgs() << "Saving failed\n");
      return false;
    }

    clang_disposeTranslationUnit(ClangTU);

    ClangTU = clang_createTranslationUnit(Index, Filename.c_str());

    if (!ClangTU) {
      LLVM_DEBUG(llvm::dbgs() << "Loading failed\n");
      return false;
    }

    return true;
  }
};

TEST_F(LibclangSerializationTest, TokenKindsAreCorrectAfterLoading) {
  // Ensure that "class" is recognized as a keyword token after serializing
  // and reloading the AST, as it is not a keyword for the default LangOptions.
  std::string HeaderName = "test.h";
  WriteFile(HeaderName, "enum class Something {};");

  const char *Argv[] = {"-xc++-header", "-std=c++11"};

  ClangTU = clang_parseTranslationUnit(Index, HeaderName.c_str(), Argv,
                                       std::size(Argv), nullptr,
                                       0, TUFlags);

  auto CheckTokenKinds = [=]() {
    CXSourceRange Range =
        clang_getCursorExtent(clang_getTranslationUnitCursor(ClangTU));

    CXToken *Tokens;
    unsigned int NumTokens;
    clang_tokenize(ClangTU, Range, &Tokens, &NumTokens);

    ASSERT_EQ(6u, NumTokens);
    EXPECT_EQ(CXToken_Keyword, clang_getTokenKind(Tokens[0]));
    EXPECT_EQ(CXToken_Keyword, clang_getTokenKind(Tokens[1]));
    EXPECT_EQ(CXToken_Identifier, clang_getTokenKind(Tokens[2]));
    EXPECT_EQ(CXToken_Punctuation, clang_getTokenKind(Tokens[3]));
    EXPECT_EQ(CXToken_Punctuation, clang_getTokenKind(Tokens[4]));
    EXPECT_EQ(CXToken_Punctuation, clang_getTokenKind(Tokens[5]));

    clang_disposeTokens(ClangTU, Tokens, NumTokens);
  };

  CheckTokenKinds();

  std::string ASTName = "test.ast";
  WriteFile(ASTName, "");

  ASSERT_TRUE(SaveAndLoadTU(ASTName));

  CheckTokenKinds();
}

TEST_F(LibclangParseTest, clang_getVarDeclInitializer) {
  std::string Main = "main.cpp";
  WriteFile(Main, "int foo() { return 5; }; const int a = foo();");
  ClangTU = clang_parseTranslationUnit(Index, Main.c_str(), nullptr, 0, nullptr,
                                       0, TUFlags);

  CXCursor C = clang_getTranslationUnitCursor(ClangTU);
  clang_visitChildren(
      C,
      [](CXCursor cursor, CXCursor parent,
         CXClientData client_data) -> CXChildVisitResult {
        if (clang_getCursorKind(cursor) == CXCursor_VarDecl) {
          const CXCursor Initializer = clang_Cursor_getVarDeclInitializer(cursor);
          EXPECT_FALSE(clang_Cursor_isNull(Initializer));
          CXString Spelling = clang_getCursorSpelling(Initializer);
          const char* const SpellingCSstr = clang_getCString(Spelling);
          EXPECT_TRUE(SpellingCSstr);
          EXPECT_EQ(std::string(SpellingCSstr), std::string("foo"));
          clang_disposeString(Spelling);
          return CXChildVisit_Break;
        }
        return CXChildVisit_Continue;
      },
      nullptr);
}

TEST_F(LibclangParseTest, clang_hasVarDeclGlobalStorageFalse) {
  std::string Main = "main.cpp";
  WriteFile(Main, "void foo() { int a; }");
  ClangTU = clang_parseTranslationUnit(Index, Main.c_str(), nullptr, 0, nullptr,
                                       0, TUFlags);

  CXCursor C = clang_getTranslationUnitCursor(ClangTU);
  clang_visitChildren(
      C,
      [](CXCursor cursor, CXCursor parent,
         CXClientData client_data) -> CXChildVisitResult {
        if (clang_getCursorKind(cursor) == CXCursor_VarDecl) {
          EXPECT_FALSE(clang_Cursor_hasVarDeclGlobalStorage(cursor));
          return CXChildVisit_Break;
        }
        return CXChildVisit_Continue;
      },
      nullptr);
}

TEST_F(LibclangParseTest, clang_Cursor_hasVarDeclGlobalStorageTrue) {
  std::string Main = "main.cpp";
  WriteFile(Main, "int a;");
  ClangTU = clang_parseTranslationUnit(Index, Main.c_str(), nullptr, 0, nullptr,
                                       0, TUFlags);

  CXCursor C = clang_getTranslationUnitCursor(ClangTU);
  clang_visitChildren(
      C,
      [](CXCursor cursor, CXCursor parent,
         CXClientData client_data) -> CXChildVisitResult {
        if (clang_getCursorKind(cursor) == CXCursor_VarDecl) {
          EXPECT_TRUE(clang_Cursor_hasVarDeclGlobalStorage(cursor));
          return CXChildVisit_Break;
        }
        return CXChildVisit_Continue;
      },
      nullptr);
}

TEST_F(LibclangParseTest, clang_Cursor_hasVarDeclExternalStorageFalse) {
  std::string Main = "main.cpp";
  WriteFile(Main, "int a;");
  ClangTU = clang_parseTranslationUnit(Index, Main.c_str(), nullptr, 0, nullptr,
                                       0, TUFlags);

  CXCursor C = clang_getTranslationUnitCursor(ClangTU);
  clang_visitChildren(
      C,
      [](CXCursor cursor, CXCursor parent,
         CXClientData client_data) -> CXChildVisitResult {
        if (clang_getCursorKind(cursor) == CXCursor_VarDecl) {
          EXPECT_FALSE(clang_Cursor_hasVarDeclExternalStorage(cursor));
          return CXChildVisit_Break;
        }
        return CXChildVisit_Continue;
      },
      nullptr);
}

TEST_F(LibclangParseTest, clang_Cursor_hasVarDeclExternalStorageTrue) {
  std::string Main = "main.cpp";
  WriteFile(Main, "extern int a;");
  ClangTU = clang_parseTranslationUnit(Index, Main.c_str(), nullptr, 0, nullptr,
                                       0, TUFlags);

  CXCursor C = clang_getTranslationUnitCursor(ClangTU);
  clang_visitChildren(
      C,
      [](CXCursor cursor, CXCursor parent,
         CXClientData client_data) -> CXChildVisitResult {
        if (clang_getCursorKind(cursor) == CXCursor_VarDecl) {
          EXPECT_TRUE(clang_Cursor_hasVarDeclExternalStorage(cursor));
          return CXChildVisit_Break;
        }
        return CXChildVisit_Continue;
      },
      nullptr);
}

TEST_F(LibclangParseTest, clang_getUnqualifiedTypeRemovesQualifiers) {
  std::string Header = "header.h";
  WriteFile(Header, "void foo1(const int);\n"
                    "void foo2(volatile int);\n"
                    "void foo3(const volatile int);\n"
                    "void foo4(int* const);\n"
                    "void foo5(int* volatile);\n"
                    "void foo6(int* restrict);\n"
                    "void foo7(int* const volatile);\n"
                    "void foo8(int* volatile restrict);\n"
                    "void foo9(int* const restrict);\n"
                    "void foo10(int* const volatile restrict);\n");

  auto is_qualified = [](CXType type) -> bool {
    return clang_isConstQualifiedType(type) ||
           clang_isVolatileQualifiedType(type) ||
           clang_isRestrictQualifiedType(type);
  };

  ClangTU = clang_parseTranslationUnit(Index, Header.c_str(), nullptr, 0,
                                       nullptr, 0, TUFlags);

  Traverse([&is_qualified](CXCursor cursor, CXCursor) {
    if (clang_getCursorKind(cursor) == CXCursor_FunctionDecl) {
      CXType arg_type = clang_getArgType(clang_getCursorType(cursor), 0);
      EXPECT_TRUE(is_qualified(arg_type))
          << "Input data '" << fromCXString(clang_getCursorSpelling(cursor))
          << "' first argument does not have a qualified type.";

      CXType unqualified_arg_type = clang_getUnqualifiedType(arg_type);
      EXPECT_FALSE(is_qualified(unqualified_arg_type))
          << "The type '" << fromCXString(clang_getTypeSpelling(arg_type))
          << "' was not unqualified after a call to clang_getUnqualifiedType.";
    }

    return CXChildVisit_Continue;
  });
}

TEST_F(LibclangParseTest, clang_getNonReferenceTypeRemovesRefQualifiers) {
  std::string Header = "header.h";
  WriteFile(Header, "void foo1(int&);\n"
                    "void foo2(int&&);\n");

  auto is_ref_qualified = [](CXType type) -> bool {
    return (type.kind == CXType_LValueReference) ||
           (type.kind == CXType_RValueReference);
  };

  const char *Args[] = {"-xc++"};
  ClangTU = clang_parseTranslationUnit(Index, Header.c_str(), Args, 1, nullptr,
                                       0, TUFlags);

  Traverse([&is_ref_qualified](CXCursor cursor, CXCursor) {
    if (clang_getCursorKind(cursor) == CXCursor_FunctionDecl) {
      CXType arg_type = clang_getArgType(clang_getCursorType(cursor), 0);
      EXPECT_TRUE(is_ref_qualified(arg_type))
          << "Input data '" << fromCXString(clang_getCursorSpelling(cursor))
          << "' first argument does not have a ref-qualified type.";

      CXType non_reference_arg_type = clang_getNonReferenceType(arg_type);
      EXPECT_FALSE(is_ref_qualified(non_reference_arg_type))
          << "The type '" << fromCXString(clang_getTypeSpelling(arg_type))
          << "' ref-qualifier was not removed after a call to "
             "clang_getNonReferenceType.";
    }

    return CXChildVisit_Continue;
  });
}

TEST_F(LibclangParseTest, VisitUsingTypeLoc) {
  const char testSource[] = R"cpp(
namespace ns1 {
class Class1
{
    void fun();
};
}

using ns1::Class1;

void Class1::fun() {}
)cpp";
  std::string fileName = "main.cpp";
  WriteFile(fileName, testSource);
  const char *Args[] = {"-xc++"};
  ClangTU = clang_parseTranslationUnit(Index, fileName.c_str(), Args, 1,
                                       nullptr, 0, TUFlags);

  std::optional<CXCursor> typeRefCsr;
  Traverse([&](CXCursor cursor, CXCursor parent) -> CXChildVisitResult {
    if (cursor.kind == CXCursor_TypeRef) {
      typeRefCsr.emplace(cursor);
    }
    return CXChildVisit_Recurse;
  });
  ASSERT_TRUE(typeRefCsr.has_value());
  EXPECT_EQ(fromCXString(clang_getCursorSpelling(*typeRefCsr)),
            "class ns1::Class1");
}

TEST_F(LibclangParseTest, BinaryOperator) {
  std::string Main = "main.cpp";
  WriteFile(Main, "int foo() { return 5 + 9; }");
  ClangTU = clang_parseTranslationUnit(Index, Main.c_str(), nullptr, 0, nullptr,
                                       0, TUFlags);

  Traverse([](CXCursor cursor, CXCursor parent) -> CXChildVisitResult {
    if (cursor.kind == CXCursor_BinaryOperator) {
      EXPECT_EQ(clang_getCursorBinaryOperatorKind(cursor),
                CXBinaryOperator_Add);
      return CXChildVisit_Break;
    }

    return CXChildVisit_Recurse;
  });
}

TEST_F(LibclangParseTest, UnaryOperator) {
  std::string Main = "main.cpp";
  WriteFile(Main, "int foo() { int a = 5; return a++; }");
  ClangTU = clang_parseTranslationUnit(Index, Main.c_str(), nullptr, 0, nullptr,
                                       0, TUFlags);

  Traverse([](CXCursor cursor, CXCursor parent) -> CXChildVisitResult {
    if (cursor.kind == CXCursor_UnaryOperator) {
      EXPECT_EQ(clang_getCursorUnaryOperatorKind(cursor),
                CXUnaryOperator_PostInc);
      return CXChildVisit_Break;
    }

    return CXChildVisit_Recurse;
  });
}

TEST_F(LibclangParseTest, VisitStaticAssertDecl_noMessage) {
  const char testSource[] = R"cpp(static_assert(true))cpp";
  std::string fileName = "main.cpp";
  WriteFile(fileName, testSource);
  const char *Args[] = {"-xc++"};
  ClangTU = clang_parseTranslationUnit(Index, fileName.c_str(), Args, 1,
                                       nullptr, 0, TUFlags);

  std::optional<CXCursor> staticAssertCsr;
  Traverse([&](CXCursor cursor, CXCursor parent) -> CXChildVisitResult {
    if (cursor.kind == CXCursor_StaticAssert) {
      staticAssertCsr.emplace(cursor);
      return CXChildVisit_Break;
    }
    return CXChildVisit_Recurse;
  });
  ASSERT_TRUE(staticAssertCsr.has_value());
  Traverse(*staticAssertCsr, [](CXCursor cursor, CXCursor parent) {
    EXPECT_EQ(cursor.kind, CXCursor_CXXBoolLiteralExpr);
    return CXChildVisit_Break;
  });
  EXPECT_EQ(fromCXString(clang_getCursorSpelling(*staticAssertCsr)), "");
}

TEST_F(LibclangParseTest, VisitStaticAssertDecl_exprMessage) {
  const char testSource[] = R"cpp(
template <unsigned s>
constexpr unsigned size(const char (&)[s])
{
    return s - 1;
}

struct Message {
    static constexpr char message[] = "Hello World!";
    constexpr const char* data() const { return message;}
    constexpr unsigned size() const
    {
        return ::size(message);
    }
};
Message message;
static_assert(true, message);
)cpp";
  std::string fileName = "main.cpp";
  WriteFile(fileName, testSource);
  const char *Args[] = {"-xc++", "-std=c++26"};
  ClangTU = clang_parseTranslationUnit(Index, fileName.c_str(), Args,
                                       std::size(Args), nullptr, 0, TUFlags);
  ASSERT_EQ(clang_getNumDiagnostics(ClangTU), 0u);
  std::optional<CXCursor> staticAssertCsr;
  Traverse([&](CXCursor cursor, CXCursor parent) -> CXChildVisitResult {
    if (cursor.kind == CXCursor_StaticAssert) {
      staticAssertCsr.emplace(cursor);
    }
    return CXChildVisit_Continue;
  });
  ASSERT_TRUE(staticAssertCsr.has_value());
  int argCnt = 0;
  Traverse(*staticAssertCsr, [&argCnt](CXCursor cursor, CXCursor parent) {
    switch (argCnt) {
    case 0:
      EXPECT_EQ(cursor.kind, CXCursor_CXXBoolLiteralExpr);
      break;
    case 1:
      EXPECT_EQ(cursor.kind, CXCursor_DeclRefExpr);
      break;
    }
    ++argCnt;
    return CXChildVisit_Continue;
  });
  ASSERT_EQ(argCnt, 2);
  EXPECT_EQ(fromCXString(clang_getCursorSpelling(*staticAssertCsr)), "");
}

TEST_F(LibclangParseTest, ExposesAnnotateArgs) {
  const char testSource[] = R"cpp(
[[clang::annotate("category", 42)]]
void func() {}
)cpp";
  std::string fileName = "main.cpp";
  WriteFile(fileName, testSource);

  const char *Args[] = {"-xc++"};
  ClangTU = clang_parseTranslationUnit(Index, fileName.c_str(), Args, 1,
                                       nullptr, 0, TUFlags);

  int attrCount = 0;

  Traverse(
      [&attrCount](CXCursor cursor, CXCursor parent) -> CXChildVisitResult {
        if (cursor.kind == CXCursor_AnnotateAttr) {
          int childCount = 0;
          clang_visitChildren(
              cursor,
              [](CXCursor child, CXCursor,
                 CXClientData data) -> CXChildVisitResult {
                int *pcount = static_cast<int *>(data);

                // we only expect one argument here, so bail otherwise
                EXPECT_EQ(*pcount, 0);

                auto *result = clang_Cursor_Evaluate(child);
                EXPECT_NE(result, nullptr);
                EXPECT_EQ(clang_EvalResult_getAsInt(result), 42);
                clang_EvalResult_dispose(result);

                ++*pcount;

                return CXChildVisit_Recurse;
              },
              &childCount);
          attrCount++;
          return CXChildVisit_Continue;
        }
        return CXChildVisit_Recurse;
      });

  EXPECT_EQ(attrCount, 1);
}

TEST_F(LibclangParseTest, clang_getSpellingLocation) {
  std::string fileName = "main.c";
  WriteFile(fileName, "#define X(value) int x = value;\nX(42)\n");

  ClangTU = clang_parseTranslationUnit(Index, fileName.c_str(), nullptr, 0,
                                       nullptr, 0, TUFlags);

  int declarationCount = 0;
  Traverse([&declarationCount](CXCursor cursor,
                               CXCursor parent) -> CXChildVisitResult {
    if (cursor.kind == CXCursor_VarDecl) {
      declarationCount++;

      CXSourceLocation cxl = clang_getCursorLocation(cursor);
      unsigned line;

      // We expect clang_getFileLocation to return the expansion location,
      // whereas clang_getSpellingLocation should resolve the macro expansion
      // and return the location of the macro definition.
      clang_getFileLocation(cxl, nullptr, &line, nullptr, nullptr);
      EXPECT_EQ(line, 2U);
      clang_getSpellingLocation(cxl, nullptr, &line, nullptr, nullptr);
      EXPECT_EQ(line, 1U);
    }

    return CXChildVisit_Recurse;
  });

  EXPECT_EQ(declarationCount, 1);
}

class LibclangRewriteTest : public LibclangParseTest {
public:
  CXRewriter Rew = nullptr;
  std::string Filename;
  CXFile File = nullptr;

  void SetUp() override {
    LibclangParseTest::SetUp();
    Filename = "file.cpp";
    WriteFile(Filename, "int main() { return 0; }");
    ClangTU = clang_parseTranslationUnit(Index, Filename.c_str(), nullptr, 0,
                                         nullptr, 0, TUFlags);
    Rew = clang_CXRewriter_create(ClangTU);
    File = clang_getFile(ClangTU, Filename.c_str());
  }
  void TearDown() override {
    clang_CXRewriter_dispose(Rew);
    LibclangParseTest::TearDown();
  }
};

static std::string getFileContent(const std::string& Filename) {
  std::ifstream RewrittenFile(Filename);
  std::string RewrittenFileContent;
  std::string Line;
  while (std::getline(RewrittenFile, Line)) {
    if (RewrittenFileContent.empty())
      RewrittenFileContent = Line;
    else {
      RewrittenFileContent += "\n" + Line;
    }
  }
  return RewrittenFileContent;
}

TEST_F(LibclangRewriteTest, RewriteReplace) {
  CXSourceLocation B = clang_getLocation(ClangTU, File, 1, 5);
  CXSourceLocation E = clang_getLocation(ClangTU, File, 1, 9);
  CXSourceRange Rng	= clang_getRange(B, E);

  clang_CXRewriter_replaceText(Rew, Rng, "MAIN");

  ASSERT_EQ(clang_CXRewriter_overwriteChangedFiles(Rew), 0);
  EXPECT_EQ(getFileContent(Filename), "int MAIN() { return 0; }");
}

TEST_F(LibclangRewriteTest, RewriteReplaceShorter) {
  CXSourceLocation B = clang_getLocation(ClangTU, File, 1, 5);
  CXSourceLocation E = clang_getLocation(ClangTU, File, 1, 9);
  CXSourceRange Rng	= clang_getRange(B, E);

  clang_CXRewriter_replaceText(Rew, Rng, "foo");

  ASSERT_EQ(clang_CXRewriter_overwriteChangedFiles(Rew), 0);
  EXPECT_EQ(getFileContent(Filename), "int foo() { return 0; }");
}

TEST_F(LibclangRewriteTest, RewriteReplaceLonger) {
  CXSourceLocation B = clang_getLocation(ClangTU, File, 1, 5);
  CXSourceLocation E = clang_getLocation(ClangTU, File, 1, 9);
  CXSourceRange Rng	= clang_getRange(B, E);

  clang_CXRewriter_replaceText(Rew, Rng, "patatino");

  ASSERT_EQ(clang_CXRewriter_overwriteChangedFiles(Rew), 0);
  EXPECT_EQ(getFileContent(Filename), "int patatino() { return 0; }");
}

TEST_F(LibclangRewriteTest, RewriteInsert) {
  CXSourceLocation Loc = clang_getLocation(ClangTU, File, 1, 5);

  clang_CXRewriter_insertTextBefore(Rew, Loc, "ro");

  ASSERT_EQ(clang_CXRewriter_overwriteChangedFiles(Rew), 0);
  EXPECT_EQ(getFileContent(Filename), "int romain() { return 0; }");
}

TEST_F(LibclangRewriteTest, RewriteRemove) {
  CXSourceLocation B = clang_getLocation(ClangTU, File, 1, 5);
  CXSourceLocation E = clang_getLocation(ClangTU, File, 1, 9);
  CXSourceRange Rng	= clang_getRange(B, E);

  clang_CXRewriter_removeText(Rew, Rng);

  ASSERT_EQ(clang_CXRewriter_overwriteChangedFiles(Rew), 0);
  EXPECT_EQ(getFileContent(Filename), "int () { return 0; }");
}