From 619def44c1cca9f3cdf63544d5f24f2c7a7d9b77 Mon Sep 17 00:00:00 2001 From: Klaus Aehlig Date: Tue, 22 Feb 2022 17:03:21 +0100 Subject: Initial self-hosting commit This is the initial version of our tool that is able to build itself. In can be bootstrapped by ./bin/bootstrap.py Co-authored-by: Oliver Reiche Co-authored-by: Victor Moreno --- .../build_engine/base_maps/expression_map.test.cpp | 208 +++++++++++++++++++++ 1 file changed, 208 insertions(+) create mode 100644 test/buildtool/build_engine/base_maps/expression_map.test.cpp (limited to 'test/buildtool/build_engine/base_maps/expression_map.test.cpp') diff --git a/test/buildtool/build_engine/base_maps/expression_map.test.cpp b/test/buildtool/build_engine/base_maps/expression_map.test.cpp new file mode 100644 index 00000000..e8068475 --- /dev/null +++ b/test/buildtool/build_engine/base_maps/expression_map.test.cpp @@ -0,0 +1,208 @@ +#include +#include + +#include "catch2/catch.hpp" +#include "src/buildtool/build_engine/base_maps/expression_map.hpp" +#include "src/buildtool/build_engine/base_maps/json_file_map.hpp" +#include "src/buildtool/common/repository_config.hpp" +#include "src/buildtool/multithreading/task_system.hpp" +#include "test/buildtool/build_engine/base_maps/test_repo.hpp" + +namespace { + +using namespace BuildMaps::Base; // NOLINT + +void SetupConfig(bool use_git) { + auto root = FileRoot{kBasePath / "data_expr"}; + if (use_git) { + auto repo_path = CreateTestRepo(); + REQUIRE(repo_path); + auto git_root = FileRoot::FromGit(*repo_path, kExprTreeId); + REQUIRE(git_root); + root = std::move(*git_root); + } + RepositoryConfig::Instance().Reset(); + RepositoryConfig::Instance().SetInfo( + "", RepositoryConfig::RepositoryInfo{root}); +} + +auto ReadExpressionFunction(EntityName const& id, + ExpressionFunctionMap::Consumer value_checker, + bool use_git = false) -> bool { + SetupConfig(use_git); + auto expr_file_map = CreateExpressionFileMap(0); + auto expr_func_map = CreateExpressionMap(&expr_file_map); + + bool success{true}; + { + TaskSystem ts; + expr_func_map.ConsumeAfterKeysReady( + &ts, + {id}, + std::move(value_checker), + [&success](std::string const& /*unused*/, bool /*unused*/) { + success = false; + }); + } + return success; +} + +} // namespace + +TEST_CASE("Simple expression object literal", "[expression_map]") { + auto name = EntityName{"", ".", "test_expression_literal"}; + auto consumer = [](auto values) { + REQUIRE(*values[0]); + auto expr = (*values[0])->Evaluate({}, {}); + + REQUIRE(expr); + REQUIRE(expr->IsString()); + CHECK(expr == Expression::FromJson(R"("foo")"_json)); + }; + + SECTION("via file") { + CHECK(ReadExpressionFunction(name, consumer, /*use_git=*/false)); + } + + SECTION("via git tree") { + CHECK(ReadExpressionFunction(name, consumer, /*use_git=*/true)); + } +} + +TEST_CASE("Simple read of variable", "[expression_map]") { + auto name = EntityName{"", ".", "test_read_vars"}; + auto consumer = [](auto values) { + REQUIRE(*values[0]); + auto expr = (*values[0]) + ->Evaluate(Configuration{Expression::FromJson( + R"({"FOO": "bar"})"_json)}, + {}); + + REQUIRE(expr); + REQUIRE(expr->IsString()); + CHECK(expr == Expression{std::string{"bar"}}); + }; + + SECTION("via file") { + CHECK(ReadExpressionFunction(name, consumer, /*use_git=*/false)); + } + + SECTION("via git tree") { + CHECK(ReadExpressionFunction(name, consumer, /*use_git=*/true)); + } +} + +TEST_CASE("Simple call of imported expression", "[expression_map]") { + auto name = EntityName{"", ".", "test_call_import"}; + auto consumer = [](auto values) { + REQUIRE(*values[0]); + auto expr = (*values[0]) + ->Evaluate(Configuration{Expression::FromJson( + R"({"FOO": "bar"})"_json)}, + {}); + + REQUIRE(expr); + REQUIRE(expr->IsString()); + CHECK(expr == Expression{std::string{"bar"}}); + }; + + SECTION("via file") { + CHECK(ReadExpressionFunction(name, consumer, /*use_git=*/false)); + } + + SECTION("via git tree") { + CHECK(ReadExpressionFunction(name, consumer, /*use_git=*/true)); + } +} + +TEST_CASE("Overwrite import in nested expression", "[expression_map]") { + auto name = EntityName{"", ".", "test_overwrite_import"}; + auto consumer = [](auto values) { + REQUIRE(*values[0]); + auto expr = (*values[0]) + ->Evaluate(Configuration{Expression::FromJson( + R"({"FOO": "bar"})"_json)}, + {}); + + REQUIRE(expr); + REQUIRE(expr->IsString()); + CHECK(expr == Expression{std::string{"bar"}}); + }; + + SECTION("via file") { + CHECK(ReadExpressionFunction(name, consumer, /*use_git=*/false)); + } + + SECTION("via git tree") { + CHECK(ReadExpressionFunction(name, consumer, /*use_git=*/true)); + } +} + +TEST_CASE("Fail due to unkown ID", "[expression_map]") { + auto name = EntityName{"", ".", "does_not_exist"}; + auto consumer = [](auto /*values*/) { + CHECK(false); // should never be called + }; + + SECTION("via file") { + CHECK_FALSE(ReadExpressionFunction(name, consumer, /*use_git=*/false)); + } + + SECTION("via git tree") { + CHECK_FALSE(ReadExpressionFunction(name, consumer, /*use_git=*/true)); + } +} + +TEST_CASE("Fail due to missing vars", "[expression_map]") { + CHECK( + ReadExpressionFunction({"", ".", "test_missing_vars"}, [](auto values) { + REQUIRE(*values[0]); + auto expr = (*values[0]) + ->Evaluate(Configuration{Expression::FromJson( + R"({"FOO": "bar"})"_json)}, + {}); + + CHECK(expr == Expression::FromJson(R"(null)"_json)); + })); +} + +TEST_CASE("Fail due to missing imports", "[expression_map]") { + CHECK(ReadExpressionFunction( + {"", ".", "test_missing_imports"}, [](auto values) { + REQUIRE(*values[0]); + auto expr = (*values[0]) + ->Evaluate(Configuration{Expression::FromJson( + R"({"FOO": "bar"})"_json)}, + {}); + + CHECK_FALSE(expr); + })); +} + +TEST_CASE("Malformed function", "[expression_map]") { + CHECK_FALSE(ReadExpressionFunction( + {"", ".", "test_malformed_function"}, [](auto /*values*/) { + CHECK(false); // should never be called + })); +} + +TEST_CASE("Malformed expression", "[expression_map]") { + CHECK_FALSE(ReadExpressionFunction( + {"", ".", "test_malformed_expression"}, [](auto /*values*/) { + CHECK(false); // should never be called + })); +} + +TEST_CASE("Malformed vars", "[expression_map]") { + CHECK_FALSE(ReadExpressionFunction( + {"", ".", "test_malformed_vars"}, [](auto /*values*/) { + CHECK(false); // should never be called + })); +} + +TEST_CASE("Malformed imports", "[expression_map]") { + CHECK_FALSE(ReadExpressionFunction( + {"", ".", "test_malformed_imports"}, [](auto /*values*/) { + CHECK(false); // should never be called + })); +} -- cgit v1.2.3