501 lines
17 KiB
C++
501 lines
17 KiB
C++
// A small harness and the tests of breeze_core's logic: text, versions, CMake editing, projects and
|
|
// their settings, modules, argument handling and process running. A test is a function that checks;
|
|
// the program exits with the number of failed checks (0 when all hold).
|
|
|
|
#include <filesystem>
|
|
#include <functional>
|
|
#include <iostream>
|
|
#include <source_location>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "breeze/Arguments.hpp"
|
|
#include "breeze/CMakeText.hpp"
|
|
#include "breeze/Error.hpp"
|
|
#include "breeze/Fs.hpp"
|
|
#include "breeze/Modules.hpp"
|
|
#include "breeze/Process.hpp"
|
|
#include "breeze/Project.hpp"
|
|
#include "breeze/Text.hpp"
|
|
#include "breeze/Version.hpp"
|
|
|
|
namespace
|
|
{
|
|
|
|
int g_failures = 0;
|
|
|
|
void check(bool condition, std::source_location where = std::source_location::current())
|
|
{
|
|
if (!condition)
|
|
{
|
|
++g_failures;
|
|
std::cerr << where.file_name() << ":" << where.line() << ": check failed\n";
|
|
}
|
|
}
|
|
|
|
template <typename A, typename E>
|
|
void checkEq(const A& actual, const E& expected,
|
|
std::source_location where = std::source_location::current())
|
|
{
|
|
if (!(actual == expected))
|
|
{
|
|
++g_failures;
|
|
std::cerr << where.file_name() << ":" << where.line() << ": was '" << actual
|
|
<< "', expected '" << expected << "'\n";
|
|
}
|
|
}
|
|
|
|
template <typename F> bool throwsError(F&& f)
|
|
{
|
|
try
|
|
{
|
|
f();
|
|
}
|
|
catch (const breeze::Error&)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
namespace sfs = std::filesystem;
|
|
|
|
struct TempDir
|
|
{
|
|
TempDir() = default;
|
|
TempDir(const TempDir&) = delete;
|
|
TempDir& operator=(const TempDir&) = delete;
|
|
TempDir(TempDir&&) = delete;
|
|
TempDir& operator=(TempDir&&) = delete;
|
|
sfs::path path = breeze::fs::makeTempDir("breeze-unit");
|
|
~TempDir()
|
|
{
|
|
std::error_code ec;
|
|
sfs::remove_all(path, ec);
|
|
}
|
|
};
|
|
|
|
void write(const sfs::path& file, const std::string& text)
|
|
{
|
|
breeze::fs::writeText(file, text);
|
|
}
|
|
|
|
// A project with the breeze/ layout and these settings and modules.
|
|
sfs::path makeProject(const sfs::path& root)
|
|
{
|
|
write(root / "CMakeLists.txt", "cmake_minimum_required(VERSION 3.25)\n");
|
|
write(root / "breeze" / "cmake" / "Breeze.cmake", "# sdk\n");
|
|
write(root / "breeze" / "cmake" / "BuildHelpers.cmake",
|
|
"macro(add_objects_module NAME)\nendmacro()\n");
|
|
write(root / "breeze" / "VERSION", "1.2.3\n");
|
|
write(root / "project" / "Configuration.cmake",
|
|
"# settings\n"
|
|
"set(PROJECT_TITLE \"Demo\")\n"
|
|
"set(PROJECT_VERSION_NUMBER \"0.1.0\")\n"
|
|
"set(PROJECT_CODE_NAME \"demo\" CACHE STRING\n"
|
|
" \"A machine-friendly name.\")\n");
|
|
return root;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------------------
|
|
// text
|
|
|
|
void textHelpers()
|
|
{
|
|
using namespace breeze::text;
|
|
checkEq(snakeCase("CoreFarewell"), "core_farewell");
|
|
checkEq(snakeCase("HelloApp"), "hello_app");
|
|
checkEq(snakeCase("HTTPServer"), "http_server");
|
|
checkEq(snakeCase("my-app"), "my_app");
|
|
checkEq(snakeCase("already_snake"), "already_snake");
|
|
checkEq(snakeCase("Util"), "util");
|
|
checkEq(normalized("Clang-CL"), "clangcl");
|
|
checkEq(normalized("MinGW64"), "mingw64");
|
|
check(isName("Core"));
|
|
check(isName("my_mod2"));
|
|
check(!isName("9lives"));
|
|
check(!isName("bad name"));
|
|
check(!isName("with-dash"));
|
|
check(isName("with-dash", true));
|
|
check(isTargetId("fmt::fmt"));
|
|
check(isTargetId("core_lib"));
|
|
check(!isTargetId("bad id"));
|
|
checkEq(trim(" x \n"), "x");
|
|
checkEq(join({"a", "b", "c"}, ", "), "a, b, c");
|
|
checkEq(replaceAll("a-b-c", "-", "+"), "a+b+c");
|
|
checkEq(splitLines("one\r\ntwo\nthree\n").size(), std::size_t(3));
|
|
check(startsWith("breeze", "bre"));
|
|
check(endsWith("breeze", "eze"));
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------------
|
|
// versions
|
|
|
|
void versions()
|
|
{
|
|
using namespace breeze;
|
|
checkEq(parseVersion("1.2.3")->toString(), "1.2.3");
|
|
checkEq(parseVersion("v1.2.3")->toString(), "1.2.3");
|
|
checkEq(parseVersion("1.2")->toString(), "1.2.0");
|
|
checkEq(parseVersion("2")->toString(), "2.0.0");
|
|
checkEq(parseVersion("1.0.0-rc1")->toString(), "1.0.0-rc1");
|
|
checkEq(parseVersion("1.0.0+build5")->toString(), "1.0.0");
|
|
check(!parseVersion("a.b.c"));
|
|
check(!parseVersion("1.2.3.4"));
|
|
check(!parseVersion(""));
|
|
check(!parseVersion("notaversion"));
|
|
check(*parseVersion("1.0.0-rc1") < *parseVersion("1.0.0"));
|
|
check(*parseVersion("1.9.0") < *parseVersion("1.10.0"));
|
|
check(*parseVersion("1.2.3") == *parseVersion("v1.2.3"));
|
|
std::vector<Version> all{*parseVersion("1.0.0"), *parseVersion("1.2.0"),
|
|
*parseVersion("2.0.0"), *parseVersion("1.1.5")};
|
|
checkEq(greatest(all)->toString(), "2.0.0");
|
|
checkEq(greatest(all, 1)->toString(), "1.2.0");
|
|
check(!greatest(all, 3));
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------- cmake
|
|
// text
|
|
|
|
void cmakeText()
|
|
{
|
|
using namespace breeze::cmake;
|
|
std::string text = "# add_exe_module(in_a_comment)\n"
|
|
"message(\"add_exe_module(in_a_string)\")\n"
|
|
"#[[ add_exe_module(in_a_bracket_comment) ]]\n"
|
|
"add_exe_module(real_one OUTPUT_NAME \"real\"\n"
|
|
" DEPENDS a # trailing comment\n"
|
|
" b::c)\n"
|
|
"set(NAME \"old value\" CACHE STRING\n"
|
|
" \"doc\")\n";
|
|
auto wanted = [](const std::string& n) { return n == "add_exe_module"; };
|
|
std::vector<Call> calls = findCalls(text, wanted);
|
|
checkEq(calls.size(), std::size_t(1));
|
|
if (calls.size() == 1)
|
|
{
|
|
checkEq(calls[0].args.size(), std::size_t(6));
|
|
checkEq(calls[0].args[0].text, "real_one");
|
|
checkEq(calls[0].args[2].text, "real");
|
|
check(calls[0].args[2].quoted);
|
|
checkEq(calls[0].args[5].text, "b::c");
|
|
}
|
|
|
|
std::optional<Call> set = findSet(text, "NAME");
|
|
check(set.has_value());
|
|
if (set)
|
|
{
|
|
checkEq(set->args[1].text, "old value");
|
|
std::string edited = text;
|
|
replaceToken(edited, set->args[1], quote("new \"value\""));
|
|
check(edited.find("set(NAME \"new \\\"value\\\"\" CACHE STRING\n \"doc\")") !=
|
|
std::string::npos);
|
|
check(edited.find("# add_exe_module(in_a_comment)") !=
|
|
std::string::npos); // everything else untouched
|
|
}
|
|
check(!findSet(text, "MISSING"));
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------ projects
|
|
|
|
void projectDetection()
|
|
{
|
|
using namespace breeze;
|
|
TempDir t;
|
|
makeProject(t.path);
|
|
std::optional<Sdk> sdk = detectSdk(t.path);
|
|
check(sdk.has_value());
|
|
if (sdk)
|
|
{
|
|
check(sdk->layout == SdkLayout::Breeze);
|
|
checkEq(sdk->version->toString(), "1.2.3");
|
|
check(sdk->supportsObjects);
|
|
checkEq(sdk->describe(), "1.2.3");
|
|
}
|
|
write(t.path / "source" / "Mod" / "x.cpp", "");
|
|
std::optional<Project> found = findProject(t.path / "source" / "Mod");
|
|
check(found.has_value());
|
|
if (found)
|
|
check(found->root == sfs::weakly_canonical(t.path));
|
|
TempDir empty;
|
|
check(!detectSdk(empty.path));
|
|
check(throwsError([&] { requireProject(empty.path); }));
|
|
|
|
// the layout before breeze/: scripts/, cmake/ and Configuration.cmake at the root
|
|
TempDir legacy;
|
|
write(legacy.path / "CMakeLists.txt", "project(Old VERSION 3.4.5)\n");
|
|
write(legacy.path / "Configuration.cmake", "set(PROJECT_CODE_NAME \"old\")\n");
|
|
write(legacy.path / "cmake" / "BuildHelpers.cmake", "# no objects\n");
|
|
std::optional<Sdk> old = detectSdk(legacy.path);
|
|
check(old.has_value());
|
|
if (old)
|
|
{
|
|
check(old->layout == SdkLayout::Legacy);
|
|
check(!old->supportsObjects);
|
|
check(!old->version.has_value());
|
|
}
|
|
}
|
|
|
|
void settings()
|
|
{
|
|
using namespace breeze;
|
|
TempDir t;
|
|
makeProject(t.path);
|
|
Project p = *findProject(t.path);
|
|
checkEq(readSetting(p, Setting::Name), "Demo");
|
|
checkEq(readSetting(p, Setting::Version), "0.1.0");
|
|
checkEq(readSetting(p, Setting::Id), "demo");
|
|
writeSetting(p, Setting::Name, "Renamed");
|
|
writeSetting(p, Setting::Version, "2.0.1");
|
|
writeSetting(p, Setting::Id, "renamed_id");
|
|
checkEq(readSetting(p, Setting::Name), "Renamed");
|
|
checkEq(readSetting(p, Setting::Version), "2.0.1");
|
|
checkEq(readSetting(p, Setting::Id), "renamed_id");
|
|
std::string file = fs::readText(p.sdk.settingsFile);
|
|
check(file.find("CACHE STRING\n \"A machine-friendly name.\")") !=
|
|
std::string::npos); // the rest is kept
|
|
check(throwsError([&] { writeSetting(p, Setting::Version, "1.x"); }));
|
|
check(throwsError([&] { writeSetting(p, Setting::Id, "Upper"); }));
|
|
check(throwsError([&] { writeSetting(p, Setting::Name, "bad name"); }));
|
|
|
|
TempDir legacy;
|
|
write(legacy.path / "CMakeLists.txt",
|
|
"cmake_minimum_required(VERSION 3.25)\nproject(Old VERSION 3.4.5 LANGUAGES CXX)\n");
|
|
write(legacy.path / "Configuration.cmake",
|
|
"set(PROJECT_CODE_NAME \"old\" CACHE STRING \"x\")\n");
|
|
write(legacy.path / "cmake" / "BuildHelpers.cmake", "");
|
|
Project lp = *findProject(legacy.path);
|
|
checkEq(readSetting(lp, Setting::Name), "Old");
|
|
checkEq(readSetting(lp, Setting::Version), "3.4.5");
|
|
checkEq(readSetting(lp, Setting::Id), "old");
|
|
writeSetting(lp, Setting::Version, "4.0");
|
|
writeSetting(lp, Setting::Name, "Newer");
|
|
check(fs::readText(legacy.path / "CMakeLists.txt")
|
|
.find("project(Newer VERSION 4.0 LANGUAGES CXX)") != std::string::npos);
|
|
}
|
|
|
|
void defaults()
|
|
{
|
|
using namespace breeze;
|
|
TempDir t;
|
|
makeProject(t.path);
|
|
Project p = *findProject(t.path);
|
|
Defaults d = Defaults::load(p);
|
|
check(!d.build("preset"));
|
|
d.setBuild("preset", "linux-x64-gcc");
|
|
d.setRun("hello_exe");
|
|
d.save(p);
|
|
Defaults again = Defaults::load(p);
|
|
checkEq(*again.build("preset"), "linux-x64-gcc");
|
|
checkEq(*again.run(), "hello_exe");
|
|
again.clearBuild("preset");
|
|
again.clearRun();
|
|
again.save(p);
|
|
check(!sfs::exists(p.defaultsFile())); // nothing left to keep: the file goes
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------ modules
|
|
|
|
void modules()
|
|
{
|
|
using namespace breeze;
|
|
TempDir t;
|
|
makeProject(t.path);
|
|
write(t.path / "source" / "Core" / "CMakeLists.txt",
|
|
"add_lib_module(core_lib TYPE SHARED OUTPUT_NAME \"core\" DEPENDS fmt::fmt "
|
|
"core_pieces)\n");
|
|
write(t.path / "source" / "CorePieces" / "CMakeLists.txt",
|
|
"add_objects_module(core_pieces)\n");
|
|
write(t.path / "source" / "App" / "CMakeLists.txt",
|
|
"add_exe_module(app_exe DEPENDS core_lib)\n");
|
|
write(t.path / "source" / "tests" / "CoreTest" / "CMakeLists.txt",
|
|
"add_test_module(core_test DEPENDS core_pieces)\n");
|
|
Project p = *findProject(t.path);
|
|
|
|
std::vector<Module> mods = scanModules(p);
|
|
checkEq(mods.size(), std::size_t(4));
|
|
const Module* core = findModule(mods, "core_lib");
|
|
check(core != nullptr);
|
|
if (core)
|
|
{
|
|
check(core->kind == ModuleKind::Lib);
|
|
check(core->libType == LibType::Shared);
|
|
checkEq(core->outputName, "core");
|
|
checkEq(core->deps.size(), std::size_t(2));
|
|
}
|
|
check(findModule(mods, "CorePieces") != nullptr); // by directory
|
|
check(findModule(mods, "corepieces") != nullptr); // by directory, another case
|
|
check(findModule(mods, "core_pieces")->kind == ModuleKind::Obj);
|
|
check(findModule(mods, "core_test")->kind == ModuleKind::Test);
|
|
|
|
// dependency queries
|
|
checkEq(dependenciesOf(mods, *findModule(mods, "app_exe"), false).size(), std::size_t(1));
|
|
std::vector<std::string> all = dependenciesOf(mods, *findModule(mods, "app_exe"), true);
|
|
checkEq(all.size(), std::size_t(3)); // core_lib, fmt::fmt, core_pieces
|
|
checkEq(dependentsOf(mods, *findModule(mods, "core_pieces"), false).size(), std::size_t(2));
|
|
checkEq(dependentsOf(mods, *findModule(mods, "core_pieces"), true).size(), std::size_t(3));
|
|
|
|
// adding
|
|
NewModule lib;
|
|
lib.kind = ModuleKind::Lib;
|
|
lib.name = "Strings";
|
|
lib.libType = LibType::Static;
|
|
lib.deps = {"core_pieces", "fmt::fmt"};
|
|
Module made = addModule(p, lib);
|
|
checkEq(made.id, "strings_lib");
|
|
check(sfs::exists(t.path / "source" / "Strings" / "include" / "strings" / "Strings.hpp"));
|
|
check(sfs::exists(t.path / "source" / "Strings" / "src" / "Strings.cpp"));
|
|
NewModule test;
|
|
test.kind = ModuleKind::Test;
|
|
test.name = "StringsTest";
|
|
checkEq(addModule(p, test).id, "strings_test"); // not strings_test_test
|
|
check(sfs::exists(t.path / "source" / "tests" / "StringsTest" / "main.cpp"));
|
|
NewModule noType;
|
|
noType.kind = ModuleKind::Lib;
|
|
noType.name = "NoType";
|
|
check(throwsError([&] { addModule(p, noType); }));
|
|
NewModule duplicate;
|
|
duplicate.kind = ModuleKind::Exec;
|
|
duplicate.name = "Other";
|
|
duplicate.id = "app_exe";
|
|
check(throwsError([&] { addModule(p, duplicate); }));
|
|
NewModule onExe;
|
|
onExe.kind = ModuleKind::Exec;
|
|
onExe.name = "OnExe";
|
|
onExe.deps = {"app_exe"};
|
|
check(throwsError([&] { addModule(p, onExe); }));
|
|
NewModule badName;
|
|
badName.kind = ModuleKind::Exec;
|
|
badName.name = "9bad";
|
|
check(throwsError([&] { addModule(p, badName); }));
|
|
|
|
// renaming: the id, the directory, and the DEPENDS of whoever names it
|
|
RenameResult r =
|
|
renameModule(p, "core_pieces", std::string("Pieces"), std::string("pieces_obj"));
|
|
checkEq(r.newId, "pieces_obj");
|
|
check(sfs::exists(t.path / "source" / "Pieces" / "CMakeLists.txt"));
|
|
check(!sfs::exists(t.path / "source" / "CorePieces"));
|
|
mods = scanModules(p);
|
|
check(findModule(mods, "pieces_obj") != nullptr);
|
|
check(findModule(mods, "core_pieces") == nullptr);
|
|
checkEq(findModule(mods, "core_lib")->deps[1], "pieces_obj");
|
|
checkEq(findModule(mods, "core_test")->deps[0], "pieces_obj");
|
|
checkEq(findModule(mods, "strings_lib")->deps[0], "pieces_obj");
|
|
check(throwsError([&] { renameModule(p, "app_exe", std::nullopt, std::nullopt); }));
|
|
check(throwsError([&]
|
|
{ renameModule(p, "app_exe", std::nullopt, std::string("core_lib")); }));
|
|
|
|
// deleting: refused while something depends on it
|
|
check(throwsError([&] { deleteModule(p, "pieces_obj"); }));
|
|
deleteModule(p, "app_exe");
|
|
check(!sfs::exists(t.path / "source" / "App"));
|
|
check(throwsError([&] { deleteModule(p, "app_exe"); }));
|
|
}
|
|
|
|
void objectsNeedSdkSupport()
|
|
{
|
|
using namespace breeze;
|
|
TempDir t;
|
|
makeProject(t.path);
|
|
write(t.path / "breeze" / "cmake" / "BuildHelpers.cmake",
|
|
"# an SDK from before objects modules\n");
|
|
Project p = *findProject(t.path);
|
|
NewModule obj;
|
|
obj.kind = ModuleKind::Obj;
|
|
obj.name = "Pieces";
|
|
check(throwsError([&] { addModule(p, obj); }));
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------
|
|
// arguments
|
|
|
|
void arguments()
|
|
{
|
|
using breeze::cli::normalizeArguments;
|
|
using V = std::vector<std::string>;
|
|
check(normalizeArguments({"build", "--cargs", "-DA=1", "-DB=2", "-j", "4"}) ==
|
|
V({"build", "--cargs=-DA=1", "--cargs=-DB=2", "-j", "4"}));
|
|
check(normalizeArguments({"run", "hello_exe", "-x", "--verbose", "-q"}) ==
|
|
V({"run", "hello_exe", "--args=--verbose", "--args=-q"}));
|
|
check(normalizeArguments({"build", "--cargs=-DA=1"}) ==
|
|
V({"build", "--cargs=-DA=1"})); // already in the form
|
|
check(normalizeArguments({"build", "--cargs"}) ==
|
|
V({"build", "--cargs"})); // nothing: CLIForge reports it
|
|
check(normalizeArguments({"ls", "--cargs", "-D"}) ==
|
|
V({"ls", "--cargs", "-D"})); // not a build command
|
|
check(normalizeArguments({}).empty());
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------
|
|
// processes
|
|
|
|
void processes()
|
|
{
|
|
#ifndef _WIN32
|
|
using namespace breeze;
|
|
proc::Options o;
|
|
o.capture = true;
|
|
proc::Result r = proc::run({"sh", "-c", "echo out; echo err >&2; exit 3"}, o);
|
|
checkEq(r.exitCode, 3);
|
|
checkEq(r.output, "out\n");
|
|
o.mergeStderr = true;
|
|
r = proc::run({"sh", "-c", "echo out; echo err >&2"}, o);
|
|
check(r.output.find("err") != std::string::npos);
|
|
proc::Options env;
|
|
env.capture = true;
|
|
env.env = {{"BREEZE_TEST_VARIABLE", "present"}};
|
|
checkEq(proc::run({"sh", "-c", "printf %s \"$BREEZE_TEST_VARIABLE\""}, env).output,
|
|
"present");
|
|
TempDir t;
|
|
proc::Options in;
|
|
in.capture = true;
|
|
in.cwd = t.path;
|
|
checkEq(
|
|
sfs::weakly_canonical(
|
|
proc::run({"pwd"}, in).output.substr(0, proc::run({"pwd"}, in).output.size() - 1)),
|
|
sfs::weakly_canonical(t.path));
|
|
proc::Options quiet;
|
|
quiet.silent = true;
|
|
checkEq(proc::run({"sh", "-c", "echo hidden; exit 5"}, quiet).exitCode, 5);
|
|
checkEq(proc::run({"/no/such/program"}).exitCode, 127);
|
|
check(proc::findInPath("sh").has_value());
|
|
check(!proc::findInPath("no-such-program-anywhere").has_value());
|
|
#endif
|
|
}
|
|
|
|
struct Case
|
|
{
|
|
const char* name;
|
|
std::function<void()> run;
|
|
};
|
|
|
|
}
|
|
|
|
int main()
|
|
{
|
|
const std::vector<Case> cases = {
|
|
{"text helpers", textHelpers}, {"versions", versions},
|
|
{"cmake text", cmakeText}, {"project detection", projectDetection},
|
|
{"settings", settings}, {"defaults", defaults},
|
|
{"modules", modules}, {"objects modules need SDK support", objectsNeedSdkSupport},
|
|
{"arguments", arguments}, {"processes", processes},
|
|
};
|
|
for (const Case& c : cases)
|
|
{
|
|
int before = g_failures;
|
|
try
|
|
{
|
|
c.run();
|
|
}
|
|
catch (const std::exception& e)
|
|
{
|
|
++g_failures;
|
|
std::cerr << c.name << ": unexpected exception: " << e.what() << "\n";
|
|
}
|
|
std::cout << (g_failures == before ? "ok " : "FAIL ") << c.name << "\n";
|
|
}
|
|
std::cout << (g_failures == 0 ? "all tests passed"
|
|
: std::to_string(g_failures) + " check(s) failed")
|
|
<< "\n";
|
|
return g_failures == 0 ? 0 : 1;
|
|
}
|