607 lines
16 KiB
C++
607 lines
16 KiB
C++
#include "test/temp_dir.h"
|
|
#include "test/test.h"
|
|
#include "command/command.h"
|
|
#include "support/path_pool.h"
|
|
#include "syntax/dependency_graph.h"
|
|
|
|
namespace clice::testing {
|
|
namespace {
|
|
|
|
TEST_SUITE(DependencyGraph) {
|
|
|
|
// ============================================================================
|
|
// Module mapping tests
|
|
// ============================================================================
|
|
|
|
TEST_CASE(LookupModuleEmpty) {
|
|
clice::DependencyGraph graph;
|
|
EXPECT_TRUE(graph.lookup_module("foo.bar").empty());
|
|
}
|
|
|
|
TEST_CASE(AddAndLookupModule) {
|
|
clice::DependencyGraph graph;
|
|
graph.add_module("foo.bar", 42);
|
|
|
|
auto result = graph.lookup_module("foo.bar");
|
|
ASSERT_EQ(result.size(), 1u);
|
|
EXPECT_EQ(result[0], 42u);
|
|
}
|
|
|
|
TEST_CASE(DuplicateModuleDedup) {
|
|
clice::DependencyGraph graph;
|
|
// Same module name, same path_id — should dedup.
|
|
graph.add_module("foo", 10);
|
|
graph.add_module("foo", 10);
|
|
ASSERT_EQ(graph.lookup_module("foo").size(), 1u);
|
|
|
|
// Same module name, different path_id — multiple candidates.
|
|
graph.add_module("foo", 20);
|
|
auto result = graph.lookup_module("foo");
|
|
ASSERT_EQ(result.size(), 2u);
|
|
EXPECT_EQ(result[0], 10u);
|
|
EXPECT_EQ(result[1], 20u);
|
|
}
|
|
|
|
TEST_CASE(MultipleModules) {
|
|
clice::DependencyGraph graph;
|
|
graph.add_module("mod.a", 1);
|
|
graph.add_module("mod.b", 2);
|
|
graph.add_module("mod.c:part", 3);
|
|
|
|
ASSERT_EQ(graph.lookup_module("mod.a").size(), 1u);
|
|
EXPECT_EQ(graph.lookup_module("mod.a")[0], 1u);
|
|
ASSERT_EQ(graph.lookup_module("mod.b").size(), 1u);
|
|
EXPECT_EQ(graph.lookup_module("mod.b")[0], 2u);
|
|
ASSERT_EQ(graph.lookup_module("mod.c:part").size(), 1u);
|
|
EXPECT_EQ(graph.lookup_module("mod.c:part")[0], 3u);
|
|
EXPECT_TRUE(graph.lookup_module("mod.d").empty());
|
|
}
|
|
|
|
TEST_CASE(ModuleCount) {
|
|
clice::DependencyGraph graph;
|
|
EXPECT_EQ(graph.module_count(), 0u);
|
|
|
|
graph.add_module("a", 1);
|
|
EXPECT_EQ(graph.module_count(), 1u);
|
|
|
|
graph.add_module("b", 2);
|
|
EXPECT_EQ(graph.module_count(), 2u);
|
|
|
|
// Second candidate for "a" doesn't increase module name count.
|
|
graph.add_module("a", 3);
|
|
EXPECT_EQ(graph.module_count(), 2u);
|
|
}
|
|
|
|
// ============================================================================
|
|
// Include edge tests
|
|
// ============================================================================
|
|
|
|
TEST_CASE(EmptyGraphIncludes) {
|
|
clice::DependencyGraph graph;
|
|
auto includes = graph.get_includes(0, 0);
|
|
EXPECT_TRUE(includes.empty());
|
|
}
|
|
|
|
TEST_CASE(SetAndGetIncludes) {
|
|
clice::DependencyGraph graph;
|
|
llvm::SmallVector<std::uint32_t> ids = {10, 20, 30};
|
|
graph.set_includes(1, 0, ids);
|
|
|
|
auto result = graph.get_includes(1, 0);
|
|
ASSERT_EQ(result.size(), 3u);
|
|
EXPECT_EQ(result[0], 10u);
|
|
EXPECT_EQ(result[1], 20u);
|
|
EXPECT_EQ(result[2], 30u);
|
|
}
|
|
|
|
TEST_CASE(IncludesPerConfig) {
|
|
clice::DependencyGraph graph;
|
|
|
|
// Same file, different configs.
|
|
graph.set_includes(1, 0, {10, 20});
|
|
graph.set_includes(1, 1, {20, 30});
|
|
|
|
auto config0 = graph.get_includes(1, 0);
|
|
ASSERT_EQ(config0.size(), 2u);
|
|
EXPECT_EQ(config0[0], 10u);
|
|
EXPECT_EQ(config0[1], 20u);
|
|
|
|
auto config1 = graph.get_includes(1, 1);
|
|
ASSERT_EQ(config1.size(), 2u);
|
|
EXPECT_EQ(config1[0], 20u);
|
|
EXPECT_EQ(config1[1], 30u);
|
|
}
|
|
|
|
TEST_CASE(GetAllIncludesUnion) {
|
|
clice::DependencyGraph graph;
|
|
|
|
graph.set_includes(1, 0, {10, 20});
|
|
graph.set_includes(1, 1, {20, 30});
|
|
|
|
auto all = graph.get_all_includes(1);
|
|
// Union of {10, 20} and {20, 30} = {10, 20, 30}.
|
|
ASSERT_EQ(all.size(), 3u);
|
|
}
|
|
|
|
TEST_CASE(ConditionalFlag) {
|
|
clice::DependencyGraph graph;
|
|
|
|
constexpr auto FLAG = clice::DependencyGraph::CONDITIONAL_FLAG;
|
|
constexpr auto MASK = clice::DependencyGraph::PATH_ID_MASK;
|
|
|
|
// PathID 5 unconditional, PathID 7 conditional.
|
|
llvm::SmallVector<std::uint32_t> ids = {5, 7 | FLAG};
|
|
graph.set_includes(1, 0, ids);
|
|
|
|
auto result = graph.get_includes(1, 0);
|
|
ASSERT_EQ(result.size(), 2u);
|
|
|
|
// First: unconditional.
|
|
EXPECT_EQ(result[0] & MASK, 5u);
|
|
EXPECT_EQ(result[0] & FLAG, 0u);
|
|
|
|
// Second: conditional.
|
|
EXPECT_EQ(result[1] & MASK, 7u);
|
|
EXPECT_NE(result[1] & FLAG, 0u);
|
|
}
|
|
|
|
TEST_CASE(FileCount) {
|
|
clice::DependencyGraph graph;
|
|
EXPECT_EQ(graph.file_count(), 0u);
|
|
|
|
graph.set_includes(1, 0, {10});
|
|
EXPECT_EQ(graph.file_count(), 1u);
|
|
|
|
// Same file, different config.
|
|
graph.set_includes(1, 1, {20});
|
|
EXPECT_EQ(graph.file_count(), 1u);
|
|
|
|
// Different file.
|
|
graph.set_includes(2, 0, {30});
|
|
EXPECT_EQ(graph.file_count(), 2u);
|
|
}
|
|
|
|
TEST_CASE(EdgeCount) {
|
|
clice::DependencyGraph graph;
|
|
EXPECT_EQ(graph.edge_count(), 0u);
|
|
|
|
graph.set_includes(1, 0, {10, 20});
|
|
EXPECT_EQ(graph.edge_count(), 2u);
|
|
|
|
graph.set_includes(2, 0, {30});
|
|
EXPECT_EQ(graph.edge_count(), 3u);
|
|
}
|
|
|
|
TEST_CASE(EmptyIncludes) {
|
|
clice::DependencyGraph graph;
|
|
graph.set_includes(1, 0, {});
|
|
|
|
auto result = graph.get_includes(1, 0);
|
|
EXPECT_TRUE(result.empty());
|
|
EXPECT_EQ(graph.file_count(), 1u);
|
|
EXPECT_EQ(graph.edge_count(), 0u);
|
|
}
|
|
|
|
}; // TEST_SUITE(DependencyGraph)
|
|
|
|
// ============================================================================
|
|
// scan_dependency_graph() integration tests
|
|
// ============================================================================
|
|
|
|
/// Write a compile_commands.json into the temp dir and load it into the given CDB.
|
|
void write_cdb(TempDir& tmp, CompilationDatabase& cdb, llvm::StringRef json_content) {
|
|
tmp.touch("compile_commands.json", json_content);
|
|
cdb.load(tmp.path("compile_commands.json"));
|
|
}
|
|
|
|
/// Helper: build a compile_commands.json array from entries.
|
|
/// Uses "arguments" array form to avoid platform-specific tokenization issues
|
|
/// (e.g. TokenizeGNUCommandLine treating backslashes as escape characters).
|
|
struct CDBEntry {
|
|
llvm::StringRef dir;
|
|
std::string file;
|
|
std::vector<std::string> extra_args;
|
|
};
|
|
|
|
/// Escape backslashes and quotes for JSON string values.
|
|
std::string json_escape(llvm::StringRef s) {
|
|
std::string result;
|
|
result.reserve(s.size());
|
|
for(char c: s) {
|
|
if(c == '\\' || c == '"') {
|
|
result += '\\';
|
|
}
|
|
result += c;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::string build_cdb_json(llvm::ArrayRef<CDBEntry> entries) {
|
|
std::string json = "[\n";
|
|
for(std::size_t i = 0; i < entries.size(); ++i) {
|
|
auto& e = entries[i];
|
|
if(i > 0) {
|
|
json += ",\n";
|
|
}
|
|
json += R"( {"directory": ")";
|
|
json += json_escape(e.dir);
|
|
json += R"(", "file": ")";
|
|
json += json_escape(e.file);
|
|
json += R"(", "arguments": ["clang++", "-std=c++20")";
|
|
for(auto& arg: e.extra_args) {
|
|
json += R"(, ")";
|
|
json += json_escape(arg);
|
|
json += R"(")";
|
|
}
|
|
json += R"(, ")";
|
|
json += json_escape(e.file);
|
|
json += R"("]})";
|
|
}
|
|
json += "\n]";
|
|
return json;
|
|
}
|
|
|
|
TEST_SUITE(ScanDependencyGraph) {
|
|
|
|
TEST_CASE(EmptyCDB) {
|
|
CompilationDatabase cdb;
|
|
PathPool pool;
|
|
DependencyGraph graph;
|
|
|
|
scan_dependency_graph(cdb, pool, graph);
|
|
|
|
EXPECT_EQ(graph.file_count(), 0u);
|
|
EXPECT_EQ(graph.module_count(), 0u);
|
|
EXPECT_EQ(graph.edge_count(), 0u);
|
|
}
|
|
|
|
TEST_CASE(SingleFileNoIncludes) {
|
|
TempDir tmp;
|
|
tmp.touch("src/main.cpp", R"(int main() { return 0; })");
|
|
|
|
CompilationDatabase cdb;
|
|
PathPool pool;
|
|
DependencyGraph graph;
|
|
|
|
auto json = build_cdb_json({
|
|
{tmp.root, tmp.path("src/main.cpp"), {}}
|
|
});
|
|
write_cdb(tmp, cdb, json);
|
|
scan_dependency_graph(cdb, pool, graph);
|
|
|
|
EXPECT_EQ(graph.file_count(), 1u);
|
|
EXPECT_EQ(graph.edge_count(), 0u);
|
|
EXPECT_EQ(graph.module_count(), 0u);
|
|
}
|
|
|
|
TEST_CASE(SingleFileWithInclude) {
|
|
TempDir tmp;
|
|
tmp.touch("include/header.h", R"(int x = 1;)");
|
|
tmp.touch("src/main.cpp", R"(
|
|
#include "header.h"
|
|
int main() { return x; }
|
|
)");
|
|
|
|
CompilationDatabase cdb;
|
|
PathPool pool;
|
|
DependencyGraph graph;
|
|
|
|
auto json = build_cdb_json({
|
|
{tmp.root, tmp.path("src/main.cpp"), {"-I", tmp.path("include")}}
|
|
});
|
|
write_cdb(tmp, cdb, json);
|
|
scan_dependency_graph(cdb, pool, graph);
|
|
|
|
EXPECT_GE(graph.file_count(), 1u);
|
|
EXPECT_GE(graph.edge_count(), 1u);
|
|
}
|
|
|
|
TEST_CASE(TransitiveIncludes) {
|
|
TempDir tmp;
|
|
tmp.touch("inc/a.h", R"(#include "b.h")");
|
|
tmp.touch("inc/b.h", R"(#include "c.h")");
|
|
tmp.touch("inc/c.h", R"(int c = 3;)");
|
|
tmp.touch("src/main.cpp", R"(
|
|
#include "a.h"
|
|
int main() {}
|
|
)");
|
|
|
|
CompilationDatabase cdb;
|
|
PathPool pool;
|
|
DependencyGraph graph;
|
|
|
|
auto json = build_cdb_json({
|
|
{tmp.root, tmp.path("src/main.cpp"), {"-I", tmp.path("inc")}}
|
|
});
|
|
write_cdb(tmp, cdb, json);
|
|
scan_dependency_graph(cdb, pool, graph);
|
|
|
|
// main->a, a->b, b->c across 4 waves.
|
|
EXPECT_GE(graph.file_count(), 3u);
|
|
EXPECT_GE(graph.edge_count(), 3u);
|
|
}
|
|
|
|
TEST_CASE(MultipleSourceFiles) {
|
|
TempDir tmp;
|
|
tmp.touch("inc/shared.h", R"(int shared = 1;)");
|
|
tmp.touch("src/a.cpp", R"(
|
|
#include "shared.h"
|
|
void a() {}
|
|
)");
|
|
tmp.touch("src/b.cpp", R"(
|
|
#include "shared.h"
|
|
void b() {}
|
|
)");
|
|
|
|
CompilationDatabase cdb;
|
|
PathPool pool;
|
|
DependencyGraph graph;
|
|
|
|
std::vector<std::string> inc = {"-I", tmp.path("inc")};
|
|
auto json = build_cdb_json({
|
|
{tmp.root, tmp.path("src/a.cpp"), inc},
|
|
{tmp.root, tmp.path("src/b.cpp"), inc},
|
|
});
|
|
write_cdb(tmp, cdb, json);
|
|
scan_dependency_graph(cdb, pool, graph);
|
|
|
|
EXPECT_GE(graph.file_count(), 2u);
|
|
EXPECT_GE(graph.edge_count(), 2u);
|
|
}
|
|
|
|
TEST_CASE(ConditionalIncludes) {
|
|
TempDir tmp;
|
|
tmp.touch("inc/always.h", R"(// always)");
|
|
tmp.touch("inc/maybe.h", R"(// maybe)");
|
|
tmp.touch("src/main.cpp", R"(
|
|
#include "always.h"
|
|
#ifdef FOO
|
|
#include "maybe.h"
|
|
#endif
|
|
)");
|
|
|
|
CompilationDatabase cdb;
|
|
PathPool pool;
|
|
DependencyGraph graph;
|
|
|
|
auto json = build_cdb_json({
|
|
{tmp.root, tmp.path("src/main.cpp"), {"-I", tmp.path("inc")}}
|
|
});
|
|
write_cdb(tmp, cdb, json);
|
|
scan_dependency_graph(cdb, pool, graph);
|
|
|
|
// Both headers discovered (over-approximate).
|
|
EXPECT_GE(graph.edge_count(), 2u);
|
|
|
|
// Verify conditional flag.
|
|
bool found_unconditional = false;
|
|
bool found_conditional = false;
|
|
auto includes = graph.get_includes(pool.cache[tmp.path("src/main.cpp")], 0);
|
|
for(auto id: includes) {
|
|
if(id & DependencyGraph::CONDITIONAL_FLAG) {
|
|
found_conditional = true;
|
|
} else {
|
|
found_unconditional = true;
|
|
}
|
|
}
|
|
EXPECT_TRUE(found_unconditional);
|
|
EXPECT_TRUE(found_conditional);
|
|
}
|
|
|
|
TEST_CASE(ModuleExtraction) {
|
|
TempDir tmp;
|
|
tmp.touch("src/mymod.cpp", R"(
|
|
export module my.module;
|
|
export int foo() { return 42; }
|
|
)");
|
|
|
|
CompilationDatabase cdb;
|
|
PathPool pool;
|
|
DependencyGraph graph;
|
|
|
|
auto json = build_cdb_json({
|
|
{tmp.root, tmp.path("src/mymod.cpp"), {}}
|
|
});
|
|
write_cdb(tmp, cdb, json);
|
|
scan_dependency_graph(cdb, pool, graph);
|
|
|
|
auto result = graph.lookup_module("my.module");
|
|
ASSERT_EQ(result.size(), 1u);
|
|
|
|
auto path = pool.resolve(result[0]);
|
|
EXPECT_TRUE(llvm::sys::fs::equivalent(path, tmp.path("src/mymod.cpp")));
|
|
}
|
|
|
|
TEST_CASE(ModulePartition) {
|
|
TempDir tmp;
|
|
tmp.touch("src/mod.cpp", R"(
|
|
export module my.mod:part;
|
|
void impl() {}
|
|
)");
|
|
|
|
CompilationDatabase cdb;
|
|
PathPool pool;
|
|
DependencyGraph graph;
|
|
|
|
auto json = build_cdb_json({
|
|
{tmp.root, tmp.path("src/mod.cpp"), {}}
|
|
});
|
|
write_cdb(tmp, cdb, json);
|
|
scan_dependency_graph(cdb, pool, graph);
|
|
|
|
ASSERT_EQ(graph.lookup_module("my.mod:part").size(), 1u);
|
|
}
|
|
|
|
TEST_CASE(DiamondIncludes) {
|
|
TempDir tmp;
|
|
tmp.touch("inc/common.h", R"(int common = 1;)");
|
|
tmp.touch("inc/a.h", R"(
|
|
#include "common.h"
|
|
int a = 1;
|
|
)");
|
|
tmp.touch("inc/b.h", R"(
|
|
#include "common.h"
|
|
int b = 1;
|
|
)");
|
|
tmp.touch("src/main.cpp", R"(
|
|
#include "a.h"
|
|
#include "b.h"
|
|
int main() {}
|
|
)");
|
|
|
|
CompilationDatabase cdb;
|
|
PathPool pool;
|
|
DependencyGraph graph;
|
|
|
|
auto json = build_cdb_json({
|
|
{tmp.root, tmp.path("src/main.cpp"), {"-I", tmp.path("inc")}}
|
|
});
|
|
write_cdb(tmp, cdb, json);
|
|
scan_dependency_graph(cdb, pool, graph);
|
|
|
|
// main->a, main->b, a->common, b->common.
|
|
EXPECT_GE(graph.edge_count(), 4u);
|
|
EXPECT_GE(graph.file_count(), 3u);
|
|
}
|
|
|
|
TEST_CASE(AngledVsQuoted) {
|
|
TempDir tmp;
|
|
tmp.touch("quoted/header.h", R"(int q = 1;)");
|
|
tmp.touch("angled/header.h", R"(int a = 1;)");
|
|
tmp.touch("src/main.cpp", R"(
|
|
#include "header.h"
|
|
#include <header.h>
|
|
int main() {}
|
|
)");
|
|
|
|
CompilationDatabase cdb;
|
|
PathPool pool;
|
|
DependencyGraph graph;
|
|
|
|
auto json = build_cdb_json({
|
|
{tmp.root,
|
|
tmp.path("src/main.cpp"),
|
|
{"-iquote", tmp.path("quoted"), "-I", tmp.path("angled")}}
|
|
});
|
|
write_cdb(tmp, cdb, json);
|
|
scan_dependency_graph(cdb, pool, graph);
|
|
|
|
EXPECT_GE(graph.edge_count(), 2u);
|
|
}
|
|
|
|
TEST_CASE(MissingInclude) {
|
|
TempDir tmp;
|
|
tmp.touch("src/main.cpp", R"(
|
|
#include "nonexistent.h"
|
|
int main() {}
|
|
)");
|
|
|
|
CompilationDatabase cdb;
|
|
PathPool pool;
|
|
DependencyGraph graph;
|
|
|
|
auto json = build_cdb_json({
|
|
{tmp.root, tmp.path("src/main.cpp"), {}}
|
|
});
|
|
write_cdb(tmp, cdb, json);
|
|
scan_dependency_graph(cdb, pool, graph);
|
|
|
|
EXPECT_EQ(graph.file_count(), 1u);
|
|
EXPECT_EQ(graph.edge_count(), 0u);
|
|
}
|
|
|
|
TEST_CASE(MultipleModules) {
|
|
TempDir tmp;
|
|
tmp.touch("src/mod_a.cpp", R"(
|
|
export module mod.a;
|
|
void a() {}
|
|
)");
|
|
tmp.touch("src/mod_b.cpp", R"(
|
|
export module mod.b;
|
|
void b() {}
|
|
)");
|
|
tmp.touch("src/impl.cpp", R"(
|
|
module mod.a;
|
|
void a_impl() {}
|
|
)");
|
|
|
|
CompilationDatabase cdb;
|
|
PathPool pool;
|
|
DependencyGraph graph;
|
|
|
|
auto json = build_cdb_json({
|
|
{tmp.root, tmp.path("src/mod_a.cpp"), {}},
|
|
{tmp.root, tmp.path("src/mod_b.cpp"), {}},
|
|
{tmp.root, tmp.path("src/impl.cpp"), {}},
|
|
});
|
|
write_cdb(tmp, cdb, json);
|
|
scan_dependency_graph(cdb, pool, graph);
|
|
|
|
EXPECT_EQ(graph.module_count(), 2u);
|
|
ASSERT_FALSE(graph.lookup_module("mod.a").empty());
|
|
ASSERT_FALSE(graph.lookup_module("mod.b").empty());
|
|
}
|
|
|
|
TEST_CASE(DeepIncludeChain) {
|
|
TempDir tmp;
|
|
tmp.touch("inc/h4.h", R"(int h4 = 4;)");
|
|
tmp.touch("inc/h3.h", R"(#include "h4.h")");
|
|
tmp.touch("inc/h2.h", R"(#include "h3.h")");
|
|
tmp.touch("inc/h1.h", R"(#include "h2.h")");
|
|
tmp.touch("inc/h0.h", R"(#include "h1.h")");
|
|
tmp.touch("src/main.cpp", R"(
|
|
#include "h0.h"
|
|
int main() {}
|
|
)");
|
|
|
|
CompilationDatabase cdb;
|
|
PathPool pool;
|
|
DependencyGraph graph;
|
|
|
|
auto json = build_cdb_json({
|
|
{tmp.root, tmp.path("src/main.cpp"), {"-I", tmp.path("inc")}}
|
|
});
|
|
write_cdb(tmp, cdb, json);
|
|
scan_dependency_graph(cdb, pool, graph);
|
|
|
|
// main->h0->h1->h2->h3->h4 across 5 waves.
|
|
EXPECT_GE(graph.edge_count(), 5u);
|
|
EXPECT_GE(graph.file_count(), 5u);
|
|
}
|
|
|
|
TEST_CASE(ModuleWithIncludes) {
|
|
TempDir tmp;
|
|
tmp.touch("inc/util.h", R"(int util = 1;)");
|
|
tmp.touch("src/mymod.cpp", R"(
|
|
module;
|
|
#include "util.h"
|
|
export module my.lib;
|
|
export int value() { return util; }
|
|
)");
|
|
|
|
CompilationDatabase cdb;
|
|
PathPool pool;
|
|
DependencyGraph graph;
|
|
|
|
auto json = build_cdb_json({
|
|
{tmp.root, tmp.path("src/mymod.cpp"), {"-I", tmp.path("inc")}}
|
|
});
|
|
write_cdb(tmp, cdb, json);
|
|
scan_dependency_graph(cdb, pool, graph);
|
|
|
|
ASSERT_FALSE(graph.lookup_module("my.lib").empty());
|
|
EXPECT_GE(graph.edge_count(), 1u);
|
|
}
|
|
|
|
// TODO: add tests for:
|
|
// - Circular includes (A→B→A) to verify BFS terminates correctly
|
|
// - ScanCache warm runs (pass ScanCache* to scan_dependency_graph twice)
|
|
// - get_all_includes flag merge: same header conditional in one config,
|
|
// unconditional in another — unconditional should win
|
|
// - set_includes overwrite: calling twice with same (path_id, config_id)
|
|
|
|
}; // TEST_SUITE(ScanDependencyGraph)
|
|
|
|
} // namespace
|
|
} // namespace clice::testing
|