Files
aevolution/tests/cellular_plan_census_tests.cpp
T
dingo dc7c0e1fa1
Foundation / checks (tsan) (push) Canceled after 0s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (checks) (push) Canceled after 1m13s
Foundation / checks (client) (push) Canceled after 1m14s
Foundation / checks (postgres) (push) Canceled after 1m7s
Foundation / checks (deploy) (push) Canceled after 1m13s
Foundation / checks (ecs) (push) Canceled after 1m13s
Foundation / checks (network) (push) Canceled after 1m14s
feat(ecology): distinguish inherited plans in verified census
2026-10-19 15:06:47 -04:00

189 lines
9.5 KiB
C++

#include "evo/server/lifecycle/cellular_census_set.hpp"
#include "fixtures/cellular_ecology.hpp"
namespace {
using namespace evo;
using namespace evo::server;
using namespace evo::fixture;
using Kind = CellularCensusKind;
using Scope = CellularCensusScope;
std::size_t at(Kind kind) {
return static_cast<std::size_t>(kind);
}
std::vector<CellularLifeIntent> inputs(const CellularLives& state, bool bud = false,
bool frozen = false, bool move = false) {
std::vector<CellularLifeIntent> result;
for (const auto& life : state.lives()) {
CellularLifeIntent input{life.identity.life, {}};
if (life.account != LifeAccount{}) {
input.intent.bud = bud && !frozen;
input.intent.frozen = frozen;
if (move && !frozen)
input.intent.movement = {1000, 0};
}
result.push_back(input);
}
return result;
}
Owner regional(std::uint64_t region) {
auto state = opening(7, true, 1, false, region);
checked(state->advance_tick({}), "regional census clock");
LifeAccount account{};
account.back() = static_cast<std::uint8_t>(region);
const auto id = region * 100;
state = checked(state->birth_candidate({account, 1}, {id, id, id, id, {state->tick()}}),
"census founder");
state = checked(state->migration_upgrade_candidate(), "census boundary");
state = checked(state->maturation_upgrade_candidate(), "census maturation");
return state;
}
void choose(Owner& state, std::uint64_t successor) {
for (unsigned tick = 0; tick < 60'000; ++tick) {
const auto cell = state->lives().front();
if (cell.mutation.offer) {
const auto& offer = *cell.mutation.offer;
const auto structural =
std::ranges::find_if(offer.candidates, [](const auto& candidate) {
return candidate.target == biology::Capability::membrane ||
candidate.target == biology::Capability::target_size;
});
const CellularMutationSelection selection{
cell.identity.life, cell.mutation.event_index, cell.mutation.offer_tick, successor,
structural == offer.candidates.end() ? std::uint16_t{0} : structural->operator_id};
checked(state->advance_tick_with_mutations(inputs(*state), std::span{&selection, 1}),
"census plan selection");
if (structural != offer.candidates.end())
return;
} else
checked(state->advance_tick(inputs(*state)), "census earned offer");
}
throw std::runtime_error("finite food did not earn census structural plan");
}
CellularCensusTotals query(const CellularCensus& census, std::uint64_t genome) {
return checked(census.query(genome, Scope::exact_genome), "plan census query");
}
void verify(const CellularLives& state) {
const auto before = state.snapshot();
const auto census = checked(CellularCensus::observe(state), "plan census observation");
require(census.boundary().projection_version == 2 && state.snapshot() == before,
"wrong projection or changed owner");
Inventory body{}, reserve{};
std::uint64_t residents = 0, holders = 0, dead = 0;
for (const auto& row : census.rows()) {
for (std::size_t kind = 0; kind < cellular_census_kind_count; ++kind) {
const auto& stock = row.totals.resident[kind];
residents += stock.count;
holders += row.totals.living_plan_holders[kind];
body.energy.value += stock.body.energy.value;
reserve.energy.value += stock.reserve.energy.value;
for (std::size_t channel = 0; channel < body.matter.size(); ++channel) {
body.matter[channel].value += stock.body.matter[channel].value;
reserve.matter[channel].value += stock.reserve.matter[channel].value;
}
}
dead += row.totals.retained_dead_plan_records;
}
Inventory actual_body{}, actual_reserve{};
for (const auto& life : state.lives()) {
actual_body.energy.value += life.body.energy.value;
actual_reserve.energy.value += life.reserve.energy.value;
for (std::size_t channel = 0; channel < body.matter.size(); ++channel) {
actual_body.matter[channel].value += life.body.matter[channel].value;
actual_reserve.matter[channel].value += life.reserve.matter[channel].value;
}
}
require(residents == state.lives().size() && holders == state.lives().size() &&
dead == state.corpses().size() && body == actual_body && reserve == actual_reserve,
"plan references invented organisms/inventory or lost holder history");
require(std::ranges::equal(
census.rows(),
checked(CellularCensus::observe(*restore(state)), "restored census").rows()),
"restore changed plan observation");
}
void family_and_history() {
auto state = regional(1);
const auto old = checked(CellularCensus::observe(*state), "old projection");
require(old.boundary().projection_version == 1 &&
query(old, 100).living_plan_holders == std::array<std::uint64_t, 5>{},
"old projection silently gained plan measures");
state = checked(state->inheritance_upgrade_candidate(), "inherited census upgrade");
choose(state, 1'000'000);
const auto unexpressed = checked(CellularCensus::observe(*state), "unexpressed plan");
const auto plan = query(unexpressed, 1'000'000);
require(plan.living_plan_holders[at(Kind::active_controlled)] == 1 &&
plan.resident == std::array<CellularCensusStock, 5>{} &&
checked(state->archive().living_carriers(1'000'000), "unborn archive carriers") ==
0,
"unexpressed retained plan was erased or counted as tissue");
const auto descendants =
checked(unexpressed.query(100, Scope::descendants), "plan descendants");
require(descendants.resident[at(Kind::active_controlled)].count == 1 &&
descendants.living_plan_holders[at(Kind::active_controlled)] == 1,
"ancestry query double-counted the parent's plan as another organism");
bool born = false;
for (unsigned tick = 0; tick < 30'000 && !born; ++tick) {
checked(state->advance_tick(inputs(*state, true)), "census funded child");
born = std::ranges::any_of(state->lives(),
[](const auto& life) { return life.parent_life == 100; });
}
require(born, "census family had no funded child");
verify(*state);
choose(state, 500'000); // Sparse descendant IDs need not follow ancestry order.
verify(*state);
for (unsigned tick = 0; tick <= cellular_linger_ticks; ++tick)
checked(state->advance_tick(inputs(*state, false, true)), "census suspended plan");
const auto suspended = checked(CellularCensus::observe(*state), "suspended plan observation");
require(query(suspended, 500'000).living_plan_holders[at(Kind::suspended_controlled)] == 1 &&
query(unexpressed, 1'000'000).living_plan_holders[at(Kind::active_controlled)] == 1,
"logout erased a plan or rewrote detached history");
verify(*state);
bool died = false;
for (unsigned tick = 0; tick < 100'000 && !died; ++tick) {
checked(state->advance_tick(inputs(*state, false, false, true)), "census ecological death");
died = std::ranges::any_of(state->corpses(),
[](const auto& corpse) { return corpse.life_id == 100; });
}
require(died, "census parent did not die after leaving finite food");
verify(*state);
const auto dead = query(checked(CellularCensus::observe(*state), "dead plan census"), 500'000);
require(dead.retained_dead_plan_records == 1 &&
dead.living_plan_holders == std::array<std::uint64_t, 5>{} &&
dead.resident == std::array<CellularCensusStock, 5>{},
"dead plan history became current viability or stock");
}
void scoped() {
auto a = regional(1), b = regional(2);
a = checked(a->inheritance_upgrade_candidate(), "scope A upgrade");
b = checked(b->inheritance_upgrade_candidate(), "scope B upgrade");
const auto ca = checked(CellularCensus::observe(*a), "scope A");
const auto cb = checked(CellularCensus::observe(*b), "scope B");
const auto& cut = ca.boundary();
CellularCensusSetBoundary boundary{cut.world,
cut.frame,
cut.tick,
cut.owner_format,
cut.rules,
cut.quantum_microseconds,
cut.projection_version};
const std::array<std::uint64_t, 2> required{1, 2};
const std::array observations{cb, ca};
const auto set =
checked(CellularCensusSet::observe(boundary, required, observations), "scoped plans");
require(set.boundary().projection_version == 2 &&
checked(set.query(100, Scope::exact_genome), "scope founder A") == query(ca, 100) &&
checked(set.query(200, Scope::descendants), "scope founder B") == query(cb, 200),
"scoped plan observation lost independent measures");
boundary.projection_version = 1;
require(!CellularCensusSet::observe(boundary, required, observations),
"mixed projection admitted");
}
} // namespace
int main() try {
family_and_history();
scoped();
return 0;
} catch (const std::exception& error) {
std::cerr << error.what() << '\n';
return 1;
}