okooooooo/EVEngine
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
92109ae643f5ba4e08d1c9325f6038dcce39778b
EVEngine/test/procgen_pointset.cpp
T

532 lines
22 KiB
C++
Raw Blame History

#include "procgen/PointSet.h"
#include "procgen/Procgen.h"
#include "procgen/heightmap/Heightmap.h"
#include "zeroerr/assert.h"
#include "zeroerr/unittest.h"
using namespace eve::procgen;
namespace {
using PointSetHandle = ProcgenPointSetHandleRef;
using ContextHandle = ProcgenContextHandleRef;
/** @brief Owns one module point-set handle for the duration of a test. */
struct PointSetLease {
Procgen* owner = nullptr;
PointSetHandle handle{};
PointSetLease() = default;
PointSetLease(Procgen& proc, PointSetHandle value) : owner(&proc), handle(value) {}
PointSetLease(const PointSetLease&) = delete;
PointSetLease& operator=(const PointSetLease&) = delete;
PointSetLease(PointSetLease&& other) noexcept : owner(other.owner), handle(other.handle) {
other.owner = nullptr;
other.handle = {};
}
PointSetLease& operator=(PointSetLease&& other) noexcept {
if (this == &other) return *this;
reset();
owner = other.owner;
handle = other.handle;
other.owner = nullptr;
other.handle = {};
return *this;
}
~PointSetLease() { reset(); }
void reset() noexcept {
if (!owner || !handle.isValid()) return;
auto result = owner->releasePointSet(handle);
result.ignore("test point-set lease cleanup");
owner = nullptr;
handle = {};
}
[[nodiscard]] eve::script::Borrowed<PointSet> view() const noexcept {
return owner ? owner->resolvePointSet(handle) : eve::script::Borrowed<PointSet>();
}
};
/** @brief Converts a successful point-set allocation into an owned test lease. */
PointSetLease requirePointSet(Procgen& proc, eve::Result<PointSetHandle>&& result) {
const bool ok = result.ok();
if (!ok) {
const eve::Diagnostic* diagnostic = result.error();
REQUIRE(diagnostic != nullptr);
if (diagnostic) CHECK(diagnostic->isError());
}
REQUIRE(ok);
return PointSetLease(proc, std::move(result).takeValue());
}
/** @brief Converts a successful rebuild-context allocation into a test lease. */
struct ContextLease {
Procgen* owner = nullptr;
ContextHandle handle{};
ContextLease() = default;
ContextLease(Procgen& proc, ContextHandle value) : owner(&proc), handle(value) {}
ContextLease(const ContextLease&) = delete;
ContextLease& operator=(const ContextLease&) = delete;
ContextLease(ContextLease&& other) noexcept : owner(other.owner), handle(other.handle) {
other.owner = nullptr;
other.handle = {};
}
ContextLease& operator=(ContextLease&& other) noexcept {
if (this == &other) return *this;
reset();
owner = other.owner;
handle = other.handle;
other.owner = nullptr;
other.handle = {};
return *this;
}
~ContextLease() { reset(); }
void reset() noexcept {
if (!owner || !handle.isValid()) return;
auto result = Procgen::release(handle);
result.ignore("test context lease cleanup");
owner = nullptr;
handle = {};
}
[[nodiscard]] eve::script::Borrowed<ProcgenContext> view() const noexcept {
return owner ? Procgen::resolve(handle) : eve::script::Borrowed<ProcgenContext>();
}
};
ContextLease requireContext(Procgen& proc, eve::Result<ContextHandle>&& result) {
const bool ok = result.ok();
if (!ok) {
const eve::Diagnostic* diagnostic = result.error();
REQUIRE(diagnostic != nullptr);
if (diagnostic) CHECK(diagnostic->isError());
}
REQUIRE(ok);
return ContextLease(proc, std::move(result).takeValue());
}
template <typename T>
void checkResult(const eve::Result<T>& result, eve::DiagnosticCode expected = eve::DiagnosticCode::None) {
const bool ok = result.ok();
CHECK(ok);
if (!ok) {
const eve::Diagnostic* diagnostic = result.error();
REQUIRE(diagnostic != nullptr);
if (diagnostic && expected != eve::DiagnosticCode::None) CHECK_EQ(diagnostic->code(), expected);
}
}
} // namespace
TEST_CASE("procgen.pointSet.composableDeterministicPipeline") {
Procgen proc;
const uint32_t forestSeed = proc.deriveSeed(42, "forest");
CHECK_NE(forestSeed, proc.deriveSeed(42, "rocks"));
CHECK_EQ(forestSeed, proc.deriveSeed(42, "forest"));
auto source = requirePointSet(proc, proc.sampleGridHandle(8, 6, 2.f, forestSeed, 0.f));
auto sourceView = source.view();
REQUIRE(sourceView.isBound());
PointSet* sourcePtr = sourceView.get();
CHECK_EQ(sourcePtr->getCount(), 48);
CHECK_EQ(sourcePtr->getX(1), 2.f);
CHECK_EQ(sourcePtr->getZ(8), 2.f);
for (int i = 0; i < sourcePtr->getCount(); ++i) {
sourcePtr->setPosition(i, sourcePtr->getX(i), float(i % 4), sourcePtr->getZ(i));
sourcePtr->setDensity(i, float(i % 5) / 4.f);
sourcePtr->setStringAttribute(i, "biome", "forest");
}
auto height = requirePointSet(proc, proc.filterHeightHandle(source.handle, 1.f, 2.f));
auto heightView = height.view();
REQUIRE(heightView.isBound());
CHECK_EQ(heightView->getCount(), 24);
auto dense = requirePointSet(proc, proc.filterDensityHandle(height.handle, 0.5f, 1.f));
auto denseView = dense.view();
REQUIRE(denseView.isBound());
CHECK(denseView->getCount() < heightView->getCount());
CHECK(denseView->getCount() > 0);
CHECK_EQ(denseView->getStringAttribute(0, "biome", ""), std::string("forest"));
auto excluded = requirePointSet(proc, proc.excludeRadiusHandle(dense.handle, 0.f, 0.f, 3.f));
auto excludedView = excluded.view();
REQUIRE(excludedView.isBound());
auto pruned = requirePointSet(proc, proc.selfPruneHandle(excluded.handle, 2.1f));
auto prunedView = pruned.view();
REQUIRE(prunedView.isBound());
CHECK(prunedView->getCount() <= excludedView->getCount());
const uint32_t jitterSeed = proc.deriveSeed(forestSeed, "jitter");
auto jitterA = requirePointSet(proc, proc.jitterPointsHandle(pruned.handle, jitterSeed, 0.5f, 0.5f));
auto jitterB = requirePointSet(proc, proc.jitterPointsHandle(pruned.handle, jitterSeed, 0.5f, 0.5f));
auto jitterAView = jitterA.view();
auto jitterBView = jitterB.view();
REQUIRE(jitterAView.isBound());
REQUIRE(jitterBView.isBound());
CHECK_EQ(jitterAView->getCount(), jitterBView->getCount());
for (int i = 0; i < jitterAView->getCount(); ++i) {
CHECK_EQ(jitterAView->getX(i), jitterBView->getX(i));
CHECK_EQ(jitterAView->getZ(i), jitterBView->getZ(i));
}
}
TEST_CASE("procgen.pointSet.invalidInputIsReported") {
Procgen proc;
auto failed = proc.filterHeightHandle({}, 0.f, 1.f);
CHECK(!failed.ok());
const eve::Diagnostic* diagnostic = failed.error();
REQUIRE(diagnostic != nullptr);
CHECK_EQ(diagnostic->code(), eve::DiagnosticCode::StaleHandle);
}
TEST_CASE("procgen.pointSet.spatialFiltersAndHeightmapProjection") {
Procgen proc;
PointSet source;
source.add(0.f, 0.f, 0.f);
source.add(1.f, 0.f, 1.f);
source.add(2.f, 0.f, 2.f);
auto sourceResult = proc.newPointSetHandle();
auto sourceHandle = std::move(sourceResult).takeValue();
auto sourceView = proc.resolvePointSet(sourceHandle);
REQUIRE(sourceView.isBound());
*sourceView = source;
auto inside = requirePointSet(proc, proc.filterBoxHandle(sourceHandle, 0.5f, -1.f, 0.5f, 1.5f, 1.f, 1.5f));
auto insideView = inside.view();
REQUIRE(insideView.isBound());
CHECK_EQ(insideView->getCount(), 1);
auto outside = requirePointSet(proc, proc.filterBoxHandle(sourceHandle, 0.5f, -1.f, 0.5f, 1.5f, 1.f, 1.5f, true));
auto outsideView = outside.view();
REQUIRE(outsideView.isBound());
CHECK_EQ(outsideView->getCount(), 2);
Heightmap heightmap(3, 3);
for (int z = 0; z < 3; ++z)
for (int x = 0; x < 3; ++x) heightmap.setHeight(x, z, float(x));
auto heightmapResult = proc.newHeightmapHandle(3, 3);
REQUIRE(heightmapResult.ok());
auto heightmapHandle = std::move(heightmapResult).takeValue();
auto heightmapView = proc.resolveHeightmap(heightmapHandle);
REQUIRE(heightmapView.isBound());
for (int z = 0; z < 3; ++z)
for (int x = 0; x < 3; ++x) heightmapView->setHeight(x, z, float(x));
auto projected =
requirePointSet(proc, proc.projectToHeightmapHandle(sourceHandle, heightmapHandle, 0.f, 0.f, 1.f, 2.f));
auto projectedView = projected.view();
REQUIRE(projectedView.isBound());
CHECK_EQ(projectedView->getY(0), 0.f);
CHECK_EQ(projectedView->getY(1), 2.f);
CHECK_EQ(projectedView->getY(2), 4.f);
CHECK(projectedView->getNormalX(1) < 0.f);
CHECK(projectedView->getNormalY(1) > 0.f);
auto gentle = requirePointSet(proc, proc.filterSlopeHandle(projected.handle, 0.f, 80.f));
auto gentleView = gentle.view();
REQUIRE(gentleView.isBound());
CHECK_EQ(gentleView->getCount(), 3);
auto flat = requirePointSet(proc, proc.filterSlopeHandle(projected.handle, 0.f, 1.f));
auto flatView = flat.view();
REQUIRE(flatView.isBound());
CHECK_EQ(flatView->getCount(), 0);
auto heightmapRelease = proc.releaseHeightmap(heightmapHandle);
heightmapRelease.ignore("test heightmap cleanup");
auto sourceCleanup = proc.releasePointSet(sourceHandle);
sourceCleanup.ignore("test point-set setup cleanup");
}
TEST_CASE("procgen.pointSet.polygonAndSplineQueries") {
Procgen proc;
PointSet polygon;
polygon.add(0.f, 0.f, 0.f);
polygon.add(10.f, 0.f, 0.f);
polygon.add(10.f, 0.f, 10.f);
polygon.add(0.f, 0.f, 10.f);
PointSet candidates;
candidates.add(5.f, 0.f, 5.f);
candidates.add(15.f, 0.f, 5.f);
auto polygonResult = proc.newPointSetHandle();
REQUIRE(polygonResult.ok());
auto polygonHandle = std::move(polygonResult).takeValue();
auto polygonView = proc.resolvePointSet(polygonHandle);
REQUIRE(polygonView.isBound());
*polygonView = polygon;
auto candidatesResult = proc.newPointSetHandle();
REQUIRE(candidatesResult.ok());
auto candidatesHandle = std::move(candidatesResult).takeValue();
auto candidatesView = proc.resolvePointSet(candidatesHandle);
REQUIRE(candidatesView.isBound());
*candidatesView = candidates;
auto inside = requirePointSet(proc, proc.filterPolygonHandle(candidatesHandle, polygonHandle));
auto outside = requirePointSet(proc, proc.filterPolygonHandle(candidatesHandle, polygonHandle, true));
auto insideView = inside.view();
auto outsideView = outside.view();
REQUIRE(insideView.isBound());
REQUIRE(outsideView.isBound());
CHECK_EQ(insideView->getCount(), 1);
CHECK_EQ(outsideView->getCount(), 1);
CHECK_EQ(insideView->getX(0), 5.f);
CHECK_EQ(outsideView->getX(0), 15.f);
PointSet control;
control.add(0.f, 0.f, 0.f);
control.add(10.f, 0.f, 0.f);
control.add(10.f, 0.f, 10.f);
auto controlResult = proc.newPointSetHandle();
REQUIRE(controlResult.ok());
auto controlHandle = std::move(controlResult).takeValue();
auto controlView = proc.resolvePointSet(controlHandle);
REQUIRE(controlView.isBound());
*controlView = control;
auto samples = requirePointSet(proc, proc.sampleSplineHandle(controlHandle, 5.f, 42, 0.f));
auto samplesView = samples.view();
REQUIRE(samplesView.isBound());
CHECK_EQ(samplesView->getCount(), 5);
CHECK_EQ(samplesView->getX(1), 5.f);
CHECK_EQ(samplesView->getZ(3), 5.f);
CHECK_EQ(samplesView->getYaw(0), 0.f);
CHECK_EQ(samplesView->getYaw(3), 90.f);
PointSet nearby;
nearby.add(5.f, 0.f, 2.f);
nearby.add(5.f, 0.f, 5.f);
nearby.add(12.f, 0.f, 5.f);
auto nearbyResult = proc.newPointSetHandle();
REQUIRE(nearbyResult.ok());
auto nearbyHandle = std::move(nearbyResult).takeValue();
auto nearbyView = proc.resolvePointSet(nearbyHandle);
REQUIRE(nearbyView.isBound());
*nearbyView = nearby;
auto corridor = requirePointSet(proc, proc.filterSplineDistanceHandle(nearbyHandle, controlHandle, 0.f, 2.1f));
auto corridorView = corridor.view();
REQUIRE(corridorView.isBound());
CHECK_EQ(corridorView->getCount(), 2);
auto polygonCleanup = proc.releasePointSet(polygonHandle);
polygonCleanup.ignore("test polygon cleanup");
auto candidatesCleanup = proc.releasePointSet(candidatesHandle);
candidatesCleanup.ignore("test candidates cleanup");
auto controlCleanup = proc.releasePointSet(controlHandle);
controlCleanup.ignore("test control cleanup");
auto nearbyCleanup = proc.releasePointSet(nearbyHandle);
nearbyCleanup.ignore("test nearby cleanup");
}
TEST_CASE("procgen.system.commitIsAtomicAndFailureKeepsPreviousSnapshot") {
// Static handle factories resolve against the manager-owned singleton.
// Keep commit/read operations on that same owner and epoch.
Procgen& proc = *Procgen::create();
PointSet first;
first.add(1.f, 2.f, 3.f);
auto initial = requireContext(proc, Procgen::beginSystemHandle("forest", 42));
auto initialView = initial.view();
REQUIRE(initialView.isBound());
CHECK(initialView->publish("trees", &first));
CHECK(initialView->captureDebug("candidates", &first));
CHECK_EQ(initialView->getDebugStageCount(), 1);
CHECK_EQ(initialView->getDebugStageName(0), std::string("candidates"));
initialView->trace("sample", 0, 1, 0.25f);
auto initialCommit = proc.commitSystem(initial.handle);
CHECK(initialCommit.ok());
CHECK(proc.hasSystem("forest"));
CHECK_EQ(proc.getSystemRevision("forest"), uint64_t(1));
CHECK_EQ(proc.getSystemDebugStageCount("forest"), 1);
CHECK_EQ(proc.getSystemDebugStageName("forest", 0), std::string("candidates"));
auto debug = requirePointSet(proc, proc.getSystemDebugStageHandle("forest", "candidates"));
auto debugView = debug.view();
REQUIRE(debugView.isBound());
CHECK_EQ(debugView->getCount(), 1);
auto committed = requirePointSet(proc, proc.getSystemOutputHandle("forest", "trees"));
auto committedView = committed.view();
REQUIRE(committedView.isBound());
CHECK_EQ(committedView->getCount(), 1);
PointSet replacement;
replacement.add(9.f, 9.f, 9.f);
replacement.add(8.f, 8.f, 8.f);
auto failed = requireContext(proc, Procgen::beginSystemHandle("forest", 99));
auto failedView = failed.view();
REQUIRE(failedView.isBound());
CHECK(failedView->publish("trees", &replacement));
failedView->fail("script error");
auto failedCommit = proc.commitSystem(failed.handle);
CHECK(!failedCommit.ok());
const eve::Diagnostic* failure = failedCommit.error();
REQUIRE(failure != nullptr);
CHECK(failure->isError());
CHECK_EQ(proc.getSystemRevision("forest"), uint64_t(1));
CHECK_EQ(proc.getSystemSeed("forest"), uint32_t(42));
CHECK_EQ(proc.getSystemDebugStageCount("forest"), 1);
auto committedAgain = requirePointSet(proc, proc.getSystemOutputHandle("forest", "trees"));
auto committedAgainView = committedAgain.view();
REQUIRE(committedAgainView.isBound());
CHECK_EQ(committedAgainView->getCount(), 1);
CHECK(proc.getSystemDebugReport("forest").find("sample") != std::string::npos);
}
TEST_CASE("procgen.system.cachedBuildReusesCommittedSnapshot") {
Procgen proc;
PointSet points;
points.add(1.f, 0.f, 2.f);
auto miss = requireContext(proc, Procgen::beginCachedSystemHandle("rocks", 7, "layout-v1:size=32"));
auto missView = miss.view();
REQUIRE(missView.isBound());
CHECK(!missView->isCacheHit());
CHECK(missView->isActive());
CHECK_EQ(missView->getBuildKey(), std::string("layout-v1:size=32"));
CHECK(missView->publish("rocks", &points));
auto missCommit = proc.commitSystem(miss.handle);
CHECK(missCommit.ok());
CHECK_EQ(proc.getSystemRevision("rocks"), uint64_t(1));
CHECK_EQ(proc.getSystemBuildKey("rocks"), std::string("layout-v1:size=32"));
auto hit = requireContext(proc, Procgen::beginCachedSystemHandle("rocks", 7, "layout-v1:size=32"));
auto hitView = hit.view();
REQUIRE(hitView.isBound());
CHECK(hitView->isCacheHit());
CHECK(!hitView->isActive());
CHECK_EQ(proc.getSystemRevision("rocks"), uint64_t(1));
auto changed = requireContext(proc, Procgen::beginCachedSystemHandle("rocks", 7, "layout-v1:size=64"));
auto changedView = changed.view();
REQUIRE(changedView.isBound());
CHECK(!changedView->isCacheHit());
CHECK(changedView->isActive());
}
TEST_CASE("procgen.system.stageCacheIsTransactional") {
Procgen& proc = *Procgen::create();
PointSet first;
first.add(3.f, 0.f, 4.f);
auto initial = requireContext(proc, Procgen::beginSystemHandle("village", 11));
auto initialView = initial.view();
REQUIRE(initialView.isBound());
CHECK(initialView->cacheStage("lots", "lots-v1:size=16", &first));
CHECK(initialView->publish("lots", &first));
auto initialCommit = proc.commitSystem(initial.handle);
CHECK(initialCommit.ok());
auto rebuild = requireContext(proc, Procgen::beginSystemHandle("village", 11));
auto rebuildView = rebuild.view();
REQUIRE(rebuildView.isBound());
PointSet* reused = rebuildView->reuseStage("lots", "lots-v1:size=16");
REQUIRE(bool(reused));
CHECK_EQ(reused->getCount(), 1);
CHECK_EQ(rebuildView->getStageCacheHitCount(), 1);
CHECK(!rebuildView->reuseStage("lots", "lots-v1:size=32"));
CHECK_EQ(rebuildView->getStageCacheMissCount(), 1);
PointSet replacement;
replacement.add(8.f, 0.f, 8.f);
replacement.add(9.f, 0.f, 9.f);
CHECK(rebuildView->cacheStage("lots", "lots-v1:size=32", &replacement));
rebuildView->fail("downstream failed");
auto rebuildCommit = proc.commitSystem(rebuild.handle);
CHECK(!rebuildCommit.ok());
auto retry = requireContext(proc, Procgen::beginSystemHandle("village", 11));
auto retryView = retry.view();
REQUIRE(retryView.isBound());
PointSet* preserved = retryView->reuseStage("lots", "lots-v1:size=16");
REQUIRE(bool(preserved));
CHECK_EQ(preserved->getCount(), 1);
CHECK(!retryView->reuseStage("lots", "lots-v1:size=32"));
}
TEST_CASE("procgen.system.automaticTraceTimingIsBalanced") {
Procgen proc;
PointSet points;
points.add(1.f, 0.f, 1.f);
auto measured = requireContext(proc, Procgen::beginSystemHandle("timed", 5));
auto measuredView = measured.view();
REQUIRE(measuredView.isBound());
CHECK(measuredView->beginTrace("outer", 0));
CHECK(measuredView->beginTrace("inner", 1));
CHECK_EQ(measuredView->getOpenTraceCount(), 2);
CHECK(measuredView->endTrace(1));
CHECK(measuredView->endTrace(2));
CHECK_EQ(measuredView->getOpenTraceCount(), 0);
CHECK_EQ(measuredView->getTraceCount(), 2);
CHECK_EQ(measuredView->getTraceName(0), std::string("inner"));
CHECK(measuredView->getTraceMilliseconds(0) >= 0.f);
CHECK(measuredView->publish("points", &points));
auto measuredCommit = proc.commitSystem(measured.handle);
CHECK(measuredCommit.ok());
auto unfinished = requireContext(proc, Procgen::beginSystemHandle("timed", 5));
auto unfinishedView = unfinished.view();
REQUIRE(unfinishedView.isBound());
CHECK(unfinishedView->beginTrace("forgotten", 1));
CHECK(unfinishedView->publish("points", &points));
auto unfinishedCommit = proc.commitSystem(unfinished.handle);
CHECK(!unfinishedCommit.ok());
const eve::Diagnostic* unfinishedDiagnostic = unfinishedCommit.error();
REQUIRE(unfinishedDiagnostic != nullptr);
CHECK_EQ(unfinishedDiagnostic->code(), eve::DiagnosticCode::PreconditionViolation);
CHECK_EQ(proc.getSystemRevision("timed"), uint64_t(1));
auto unmatched = requireContext(proc, Procgen::beginSystemHandle("unmatched", 5));
auto unmatchedView = unmatched.view();
REQUIRE(unmatchedView.isBound());
CHECK(!unmatchedView->endTrace(0));
CHECK_EQ(unmatchedView->getError(), std::string("endTrace: no stage timer is active"));
}
TEST_CASE("procgen.system.previousRevisionSupportsHotReloadDiffs") {
Procgen& proc = *Procgen::create();
PointSet first;
first.add(1.f, 0.f, 1.f);
auto revision1 = requireContext(proc, Procgen::beginSystemHandle("diff", 1));
auto revision1View = revision1.view();
REQUIRE(revision1View.isBound());
CHECK(revision1View->captureDebug("trees", &first));
auto revision1Commit = proc.commitSystem(revision1.handle);
CHECK(revision1Commit.ok());
CHECK_EQ(proc.getPreviousSystemRevision("diff"), uint64_t(0));
auto missingPrevious = proc.getPreviousSystemDebugStageHandle("diff", "trees");
CHECK(!missingPrevious.ok());
const eve::Diagnostic* missingDiagnostic = missingPrevious.error();
REQUIRE(missingDiagnostic != nullptr);
CHECK_EQ(missingDiagnostic->code(), eve::DiagnosticCode::NotFound);
PointSet second = first;
second.add(2.f, 0.f, 2.f);
auto revision2 = requireContext(proc, Procgen::beginSystemHandle("diff", 2));
auto revision2View = revision2.view();
REQUIRE(revision2View.isBound());
CHECK(revision2View->captureDebug("trees", &second));
CHECK(revision2View->captureDebug("roads", &first));
auto revision2Commit = proc.commitSystem(revision2.handle);
CHECK(revision2Commit.ok());
CHECK_EQ(proc.getPreviousSystemRevision("diff"), uint64_t(1));
auto previousTrees = requirePointSet(proc, proc.getPreviousSystemDebugStageHandle("diff", "trees"));
auto previousTreesView = previousTrees.view();
REQUIRE(previousTreesView.isBound());
CHECK_EQ(previousTreesView->getCount(), 1);
const std::string report = proc.getSystemDebugDiffReport("diff");
CHECK(report.find("revision=1 -> 2") != std::string::npos);
CHECK(report.find("debug trees points=2 delta=+1") != std::string::npos);
CHECK(report.find("debug roads points=1 delta=+1") != std::string::npos);
auto failed = requireContext(proc, Procgen::beginSystemHandle("diff", 3));
auto failedView = failed.view();
REQUIRE(failedView.isBound());
failedView->fail("broken reload");
auto failedCommit = proc.commitSystem(failed.handle);
CHECK(!failedCommit.ok());
CHECK_EQ(proc.getPreviousSystemRevision("diff"), uint64_t(1));
auto removeResult = proc.removeSystem("diff");
CHECK(removeResult.ok());
CHECK_EQ(proc.getPreviousSystemRevision("diff"), uint64_t(0));
}
Reference in new issue View Git Blame Copy Permalink