114 lines
5.1 KiB
C++
114 lines
5.1 KiB
C++
#include "zeroerr/assert.h"
|
|
#include "zeroerr/unittest.h"
|
|
|
|
#include "common/Module.h"
|
|
#include "definitions/Definitions.h"
|
|
|
|
#include <simplesquirrel/simplesquirrel.hpp>
|
|
|
|
#include <string>
|
|
|
|
using namespace eve::definitions;
|
|
|
|
TEST_CASE("definitions.registerCanonicalizeAndResolve") {
|
|
DefinitionRegistry registry;
|
|
REQUIRE(registry.registerDefinition("unit", "tank", 2, "{ \"speed\": 4, \"armor\": 9 }"));
|
|
const auto* value = registry.resolve("unit", "tank");
|
|
REQUIRE(value != nullptr);
|
|
CHECK_EQ(value->version, 2);
|
|
CHECK_EQ(value->generation, uint64_t{1});
|
|
CHECK_EQ(value->json, std::string("{\"armor\":9,\"speed\":4}"));
|
|
CHECK(!registry.registerDefinition("unit", "tank", 3, "{}"));
|
|
CHECK(!registry.registerDefinition("", "tank", 1, "{}"));
|
|
CHECK(!registry.registerDefinition("unit", "bad", 0, "{}"));
|
|
CHECK(!registry.registerDefinition("unit", "bad", 1, "{"));
|
|
}
|
|
|
|
TEST_CASE("definitions.handlesInvalidateButReferencesReload") {
|
|
DefinitionRegistry registry;
|
|
REQUIRE(registry.registerDefinition("unit", "scout", 1, "{\"speed\":5}"));
|
|
const DefinitionHandle oldHandle = registry.handle("unit", "scout");
|
|
const DefinitionRef reference = registry.reference("unit", "scout");
|
|
REQUIRE(registry.resolveHandle(oldHandle) != nullptr);
|
|
|
|
REQUIRE(registry.replaceDefinition("unit", "scout", 2, "{\"speed\":7}"));
|
|
CHECK(registry.resolveHandle(oldHandle) == nullptr);
|
|
REQUIRE(registry.resolveRef(reference) != nullptr);
|
|
CHECK_EQ(registry.resolveRef(reference)->version, 2);
|
|
CHECK_EQ(registry.resolveRef(reference)->generation, uint64_t{2});
|
|
|
|
REQUIRE(registry.remove("unit", "scout"));
|
|
CHECK(registry.resolveRef(reference) == nullptr);
|
|
REQUIRE(registry.registerDefinition("unit", "scout", 3, "{}"));
|
|
CHECK_EQ(registry.resolveRef(reference)->generation, uint64_t{4});
|
|
}
|
|
|
|
TEST_CASE("definitions.enumerationIsTypeThenIdSorted") {
|
|
DefinitionRegistry registry;
|
|
REQUIRE(registry.registerDefinition("weapon", "cannon", 1, "{}"));
|
|
REQUIRE(registry.registerDefinition("unit", "tank", 1, "{}"));
|
|
REQUIRE(registry.registerDefinition("unit", "infantry", 1, "{}"));
|
|
CHECK_EQ(registry.size(), 3);
|
|
CHECK_EQ(registry.countType("unit"), 2);
|
|
CHECK_EQ(registry.at(0)->type, std::string("unit"));
|
|
CHECK_EQ(registry.at(0)->id, std::string("infantry"));
|
|
CHECK_EQ(registry.atType("unit", 1)->id, std::string("tank"));
|
|
CHECK_EQ(registry.at(2)->type, std::string("weapon"));
|
|
}
|
|
|
|
TEST_CASE("definitions.eventsDescribeReloadAndRemoval") {
|
|
DefinitionRegistry registry;
|
|
REQUIRE(registry.registerDefinition("policy", "tax", 1, "{}"));
|
|
REQUIRE(registry.replaceDefinition("policy", "tax", 2, "{}"));
|
|
REQUIRE(registry.remove("policy", "tax"));
|
|
CHECK_EQ(registry.eventCount(), 3);
|
|
CHECK_EQ(registry.eventAt(0)->name, std::string("definition_reloaded"));
|
|
CHECK_EQ(registry.eventAt(1)->generation, uint64_t{2});
|
|
CHECK_EQ(registry.eventAt(2)->name, std::string("definition_removed"));
|
|
CHECK_EQ(registry.eventAt(2)->sequence, uint64_t{3});
|
|
CHECK_EQ(registry.eventAt(2)->generation, uint64_t{3});
|
|
registry.clearEvents();
|
|
REQUIRE(registry.registerDefinition("policy", "tax", 3, "{}"));
|
|
CHECK_EQ(registry.eventAt(0)->sequence, uint64_t{4});
|
|
}
|
|
|
|
TEST_CASE("definitions.snapshotRoundTripsAndRestoreIsTransactional") {
|
|
DefinitionRegistry original;
|
|
REQUIRE(original.registerDefinition("unit", "tank", 1, "{\"b\":2,\"a\":1}"));
|
|
REQUIRE(original.registerDefinition("unit", "obsolete", 1, "{}"));
|
|
REQUIRE(original.remove("unit", "obsolete"));
|
|
const std::string snapshot = original.snapshotJson();
|
|
|
|
DefinitionRegistry restored;
|
|
REQUIRE(restored.restoreJson(snapshot));
|
|
CHECK_EQ(restored.snapshotJson(), snapshot);
|
|
CHECK_EQ(restored.resolve("unit", "tank")->json, std::string("{\"a\":1,\"b\":2}"));
|
|
REQUIRE(restored.registerDefinition("unit", "obsolete", 2, "{}"));
|
|
CHECK_EQ(restored.resolve("unit", "obsolete")->generation, uint64_t{3});
|
|
|
|
const std::string before = restored.snapshotJson();
|
|
CHECK(!restored.restoreJson("{\"version\":1}"));
|
|
CHECK_EQ(restored.snapshotJson(), before);
|
|
}
|
|
|
|
TEST_CASE("definitions.scriptRegisterReplaceEnumerateAndRestore") {
|
|
ssq::VM vm(1024, ssq::Libs::ALL);
|
|
eve::ModuleManager::expose(vm);
|
|
vm.run(vm.compileSource(R"(
|
|
result <- "fail";
|
|
local module = eve.Definitions();
|
|
local registry = module.newRegistry();
|
|
if (registry.registerDefinition("general", "g-1", 1, "{\"rank\":2}") &&
|
|
registry.replaceDefinition("general", "g-1", 2, "{\"rank\":3}")) {
|
|
local snapshot = registry.snapshotJson();
|
|
local copy = module.newRegistry();
|
|
if (copy.restoreJson(snapshot) && copy.countType("general") == 1 &&
|
|
copy.resolve("general", "g-1").getVersion() == 2 &&
|
|
copy.resolveGeneration("general", "g-1", 2).getVersion() == 2 &&
|
|
copy.eventAt(1).getName() == "definition_reloaded")
|
|
result = copy.atType("general", 0).getJson();
|
|
}
|
|
)"));
|
|
CHECK_EQ(vm.find("result").toString(), std::string("{\"rank\":3}"));
|
|
}
|