#include <gtest/gtest.h>

import std;

import mcpp.modgraph.graph;

import mcpp.modgraph.scanner;

import mcpp.modgraph.validate;

import mcpp.manifest;

using namespace mcpp::modgraph;

namespace {

std::filesystem::path make_tempdir(std::string_view prefix) {

auto tmp = std::filesystem::temp_directory_path();

auto dir = tmp / std::format("{}-{}", prefix, std::random_device{}() );

std::filesystem::create_directories(dir);

return dir;

}

void write(const std::filesystem::path& p, std::string_view content) {

std::filesystem::create_directories(p.parent_path());

std::ofstream os(p);

os << content;

}

} // namespace

TEST(Scanner, ProvidesAndRequires) {

auto dir = make_tempdir("mcpp-scanner");

// NOTE: avoid raw string literal for module source — clang-scan-deps

// on Windows may false-positive on `import bar;` inside R"(...)".

write(dir / "src" / "foo.cppm",

"export module foo;\n"

"import std;\n"

"import bar;\n"

"export int answer();\n");

auto u = scan_file(dir / "src" / "foo.cppm", "pkg");

ASSERT_TRUE(u.has_value()) << u.error().format();

ASSERT_TRUE(u->provides.has_value());

EXPECT_EQ(u->provides->logicalName, "foo");

ASSERT_EQ(u->requires_.size(), 2u);

EXPECT_EQ(u->requires_[0].logicalName, "std");

EXPECT_EQ(u->requires_[1].logicalName, "bar");

std::filesystem::remove_all(dir);

}

TEST(Scanner, RecordsPackageLocalIncludeDirs) {

auto dir = make_tempdir("mcpp-scanner-includes");

write(dir / "src" / "foo.cpp",

"int answer() { return 42; }\n");

std::filesystem::create_directories(dir / "include");

std::filesystem::create_directories(dir / "private" / "nested");

mcpp::manifest::Manifest m;

m.package.name = "pkg";

m.modules.sources = {"src/*.cpp"};

m.buildConfig.includeDirs = {"include", "private/*"};

auto r = scan_packages({PackageRoot{dir, m}});

ASSERT_TRUE(r.errors.empty());

ASSERT_EQ(r.graph.units.size(), 1u);

auto const& dirs = r.graph.units[0].localIncludeDirs;

ASSERT_EQ(dirs.size(), 2u);

EXPECT_EQ(dirs[0], dir / "include");

EXPECT_EQ(dirs[1], dir / "private" / "nested");

std::filesystem::remove_all(dir);

}

TEST(Scanner, UsesResolvedPackagePrivateBuildIncludeDirs) {

auto dir = make_tempdir("mcpp-scanner-resolved-includes");

write(dir / "src" / "foo.cpp",

"int answer() { return 42; }\n");

std::filesystem::create_directories(dir / "legacy");

std::filesystem::create_directories(dir / "resolved");

mcpp::manifest::Manifest m;

m.package.name = "pkg";

m.modules.sources = {"src/*.cpp"};

m.buildConfig.includeDirs = {"legacy"};

PackageRoot p{dir, m};

p.usageResolved = true;

p.privateBuild.includeDirs = {dir / "resolved"};

auto r = scan_packages({p});

ASSERT_TRUE(r.errors.empty());

ASSERT_EQ(r.graph.units.size(), 1u);

auto const& dirs = r.graph.units[0].localIncludeDirs;

ASSERT_EQ(dirs.size(), 1u);

EXPECT_EQ(dirs[0], dir / "resolved");

std::filesystem::remove_all(dir);

}

TEST(Scanner, PartitionImportFromPrimaryInterface) {

// Primary module interface: `export module foo;` → logicalName = "foo".

// `import :tls;` resolves to "foo:tls".

auto dir = make_tempdir("mcpp-scanner");

write(dir / "src" / "foo.cppm",

"export module foo;\n"

"import :tls;\n");

auto u = scan_file(dir / "src" / "foo.cppm", "pkg");

ASSERT_TRUE(u.has_value()) << u.error().format();

ASSERT_EQ(u->requires_.size(), 1u);

EXPECT_EQ(u->requires_[0].logicalName, "foo:tls");

std::filesystem::remove_all(dir);

}

TEST(Scanner, PartitionImportFromAnotherPartition) {

// Partition interface: `export module foo:http;` → logicalName = "foo:http".

// `import :tls;` must resolve to "foo:tls" (the sibling partition),

// NOT "foo:http:tls" (which is what a naive prepend produces).

auto dir = make_tempdir("mcpp-scanner");

write(dir / "src" / "http.cppm",

"export module foo:http;\n"

"import :tls;\n"

"import :socket;\n");

auto u = scan_file(dir / "src" / "http.cppm", "pkg");

ASSERT_TRUE(u.has_value()) << u.error().format();

ASSERT_TRUE(u->provides.has_value());

EXPECT_EQ(u->provides->logicalName, "foo:http");

ASSERT_EQ(u->requires_.size(), 2u);

EXPECT_EQ(u->requires_[0].logicalName, "foo:tls");

EXPECT_EQ(u->requires_[1].logicalName, "foo:socket");

std::filesystem::remove_all(dir);

}

TEST(Scanner, PartitionImportWithDottedModuleName) {

// Dotted module names (xpkg-style, e.g. `mcpplibs.tinyhttps:http`)

// — only the colon-prefixed partition suffix is what we strip.

auto dir = make_tempdir("mcpp-scanner");

write(dir / "src" / "http.cppm",

"export module mcpplibs.tinyhttps:http;\n"

"import :tls;\n");

auto u = scan_file(dir / "src" / "http.cppm", "pkg");

ASSERT_TRUE(u.has_value()) << u.error().format();

ASSERT_EQ(u->requires_.size(), 1u);

EXPECT_EQ(u->requires_[0].logicalName, "mcpplibs.tinyhttps:tls");

std::filesystem::remove_all(dir);

}

TEST(Scanner, RejectsConditionalImport) {

auto dir = make_tempdir("mcpp-scanner");

write(dir / "main.cpp",

"import std;\n"

"#ifdef WANT_X\n"

"import x;\n"

"#endif\n"

"int main(){}");

auto r = scan_file(dir / "main.cpp", "pkg");

EXPECT_FALSE(r.has_value());

EXPECT_NE(r.error().message.find("conditional"), std::string::npos);

std::filesystem::remove_all(dir);

}

TEST(Scanner, RejectsHeaderUnit) {

auto dir = make_tempdir("mcpp-scanner");

write(dir / "main.cpp",

"import std;\n"

"import \"x.h\";\n"

"int main(){}");

auto r = scan_file(dir / "main.cpp", "pkg");

EXPECT_FALSE(r.has_value());

EXPECT_NE(r.error().message.find("header units"), std::string::npos);

std::filesystem::remove_all(dir);

}

TEST(Scanner, ObjectiveCSourceIsCLike) {

auto dir = make_tempdir("mcpp-scanner-objc");

write(dir / "src" / "window.m",

"import Cocoa;\n"

"int answer(void) { return 42; }\n");

auto u = scan_file(dir / "src" / "window.m", "pkg");

ASSERT_TRUE(u.has_value()) << u.error().format();

EXPECT_FALSE(u->provides.has_value());

EXPECT_TRUE(u->requires_.empty());

std::filesystem::remove_all(dir);

}

TEST(Validate, ModuleNameNotRequiredToMatchPackageName) {

// 0.0.10+: module name does NOT need to be prefixed by package name.

// The library author decides the module naming convention.

Graph g;

SourceUnit u;

u.path = "/x/foo.cppm";

u.packageName = "myorg.foo";

u.provides = ModuleId{"completely.different.name"};

g.units.push_back(u);

g.producerOf["completely.different.name"] = 0;

mcpp::manifest::Manifest m;

m.package.name = "myorg.foo";

auto rep = validate(g, m);

EXPECT_TRUE(rep.ok()) << "module name mismatch should not be an error";

}

TEST(Validate, ForbiddenTopName) {

Graph g;

SourceUnit u;

u.path = "/x/foo.cppm";

u.packageName = "myorg.foo";

u.provides = ModuleId{"util"};

g.units.push_back(u);

g.producerOf["util"] = 0;

mcpp::manifest::Manifest m;

m.package.name = "myorg.foo";

auto rep = validate(g, m);

EXPECT_FALSE(rep.ok());

}

TEST(Validate, LibRootHappyPath) {

// Project: lib target "tinyhttps", convention puts the lib root at

// src/tinyhttps.cppm exporting `mcpplibs.tinyhttps`. Two partition

// siblings sit alongside.

Graph g;

SourceUnit root;

root.path = "src/tinyhttps.cppm";

root.packageName = "mcpplibs.tinyhttps";

root.provides = ModuleId{"mcpplibs.tinyhttps"};

g.units.push_back(root);

g.producerOf["mcpplibs.tinyhttps"] = 0;

SourceUnit p1;

p1.path = "src/tls.cppm";

p1.packageName = "mcpplibs.tinyhttps";

p1.provides = ModuleId{"mcpplibs.tinyhttps:tls"};

g.units.push_back(p1);

g.producerOf["mcpplibs.tinyhttps:tls"] = 1;

mcpp::manifest::Manifest m;

m.package.name = "mcpplibs.tinyhttps";

mcpp::manifest::Target t;

t.name = "tinyhttps";

t.kind = mcpp::manifest::Target::Library;

m.targets.push_back(t);

auto rep = validate(g, m); // empty projectRoot → on-disk check skipped

EXPECT_TRUE(rep.ok()) << "errors:" << [&]{

std::string s; for (auto& e : rep.errors) s += "\n " + e.message; return s;

}();

}

TEST(Validate, LibRootExportsPartitionIsError) {

// Lib root file at the conventional path exports `:foo` (a partition

// suffix) — must be rejected: lib root must be the primary module.

Graph g;

SourceUnit u;

u.path = "src/tinyhttps.cppm";

u.packageName = "mcpplibs.tinyhttps";

u.provides = ModuleId{"mcpplibs.tinyhttps:something"};

g.units.push_back(u);

g.producerOf["mcpplibs.tinyhttps:something"] = 0;

mcpp::manifest::Manifest m;

m.package.name = "mcpplibs.tinyhttps";

mcpp::manifest::Target t;

t.name = "tinyhttps";

t.kind = mcpp::manifest::Target::Library;

m.targets.push_back(t);

auto rep = validate(g, m);

EXPECT_FALSE(rep.ok());

bool found = false;

for (auto& e : rep.errors) {

if (e.message.find("partition") != std::string::npos

&& e.message.find("primary module") != std::string::npos) { found = true; break; }

}

EXPECT_TRUE(found) << "expected lib-root partition error";

}

TEST(Validate, LibRootDifferentModuleNameIsAllowed) {

// 0.0.10+: lib root module name does NOT need to match [package].name.

// The library author decides the module name; the build tool auto-detects.

Graph g;

SourceUnit u;

u.path = "src/tinyhttps.cppm";

u.packageName = "mcpplibs.tinyhttps";

u.provides = ModuleId{"some.other.module"};

g.units.push_back(u);

g.producerOf["some.other.module"] = 0;

mcpp::manifest::Manifest m;

m.package.name = "mcpplibs.tinyhttps";

mcpp::manifest::Target t;

t.name = "tinyhttps";

t.kind = mcpp::manifest::Target::Library;

m.targets.push_back(t);

auto rep = validate(g, m);

EXPECT_TRUE(rep.ok()) << "module name mismatch should not be an error";

}

TEST(Validate, LibRootNotEnforcedForBinaryProject) {

// Pure-binary project: no lib target → no lib-root checks. Even if a

// file at src/<tail>.cppm exists exporting an unrelated module, no

// error should fire.

Graph g;

mcpp::manifest::Manifest m;

m.package.name = "myapp";

mcpp::manifest::Target t;

t.name = "myapp";

t.kind = mcpp::manifest::Target::Binary;

t.main = "src/main.cpp";

m.targets.push_back(t);

auto rep = validate(g, m);

EXPECT_TRUE(rep.ok());

}

TEST(Validate, LibRootMissingFileWithExplicitPathIsError) {

Graph g;

mcpp::manifest::Manifest m;

m.package.name = "myorg.foo";

m.lib.path = "src/does-not-exist.cppm";

mcpp::manifest::Target t;

t.name = "foo";

t.kind = mcpp::manifest::Target::Library;

m.targets.push_back(t);

// Pass a non-empty projectRoot so the on-disk check is enabled.

auto rep = validate(g, m, std::filesystem::current_path());

EXPECT_FALSE(rep.ok());

bool found = false;

for (auto& e : rep.errors) {

if (e.message.find("does not exist") != std::string::npos) { found = true; break; }

}

EXPECT_TRUE(found) << "expected explicit-path-missing error";

}

TEST(TopoSort, DetectsCycle) {

Graph g;

g.units.resize(2);

g.units[0].provides = ModuleId{"a"};

g.units[1].provides = ModuleId{"b"};

g.units[0].requires_.push_back({"b"});

g.units[1].requires_.push_back({"a"});

g.producerOf["a"] = 0;

g.producerOf["b"] = 1;

g.edges.push_back({0, 1}); // a->b

g.edges.push_back({1, 0}); // b->a

auto r = topo_sort(g);

EXPECT_FALSE(r.has_value());

}

TEST(IsPublicPackage, DotMarksPublic) {

EXPECT_TRUE(is_public_package_name("myorg.foo"));

EXPECT_FALSE(is_public_package_name("foo"));

}

TEST(IsForbiddenTopModule, KnownNames) {

EXPECT_TRUE(is_forbidden_top_module("core"));

EXPECT_TRUE(is_forbidden_top_module("util.x"));

EXPECT_FALSE(is_forbidden_top_module("myorg.foo"));

}