Files
aevolution/tests/cellular_environment_tests.cpp
T
dingoandClaude Opus 5.5 2efb01d1a3
Foundation / checks (ecs) (push) Successful in 2m29s
Foundation / checks (deploy) (push) Successful in 5m29s
Foundation / checks (network) (push) Successful in 23m57s
Foundation / checks (client) (push) Successful in 24m50s
Foundation / checks (tsan) (push) Successful in 47m40s
Foundation / checks (postgres) (push) Successful in 1h22m11s
Foundation / checks (checks) (push) Successful in 1h49m20s
Foundation / postgres-tools (push) Successful in 1m13s
Foundation / server-image (push) Successful in 3m45s
Foundation / image (push) Successful in 6m1s
ci: give the checks job headroom and trim producer tests
Run 469 failed only the checks job, at exactly its 90-minute limit; full
checks runs had grown from 67 to 78 minutes through M12 and every step
passes locally. The limit is now 120 minutes. The producer test checks dark
and brighter light on the capture rule instead of growing two extra
histories, and the trace test takes over the grown population.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 23:21:29 -04:00

674 lines
34 KiB
C++

#include "evo/server/lifecycle/cellular_environment.hpp"
#include "fixtures/cellular_ecology.hpp"
#include <cstring>
#include <fstream>
#include <iterator>
namespace {
using namespace evo;
using namespace evo::server;
using namespace evo::fixture;
using Environment = std::unique_ptr<CellularEnvironment>;
std::vector<CellularLifeIntent> controlled(const CellularLives& state, bool bud = false) {
std::vector<CellularLifeIntent> result;
for (const auto& life : state.lives())
if (life.account != LifeAccount{}) {
CellularLifeIntent input{life.identity.life, {}};
input.intent.bud = bud;
result.push_back(input);
}
return result;
}
// A real rules-9/owner-7 region: four funded founders on finite contact food.
Owner founders(std::uint64_t seed = 7) {
auto state = opening(seed, true);
state = checked(state->migration_upgrade_candidate(), "boundary upgrade");
return checked(state->maturation_upgrade_candidate(), "maturation upgrade");
}
Inventory energy_and_carbon(std::uint64_t energy, std::uint64_t carbon) {
Inventory value{{energy}, {}};
value.matter[0].value = carbon;
return value;
}
CellularInfallSource source(std::uint64_t id, std::uint32_t x, std::uint64_t interval,
Inventory entitlement, std::uint64_t start = 1,
std::uint64_t end = std::numeric_limits<std::uint64_t>::max()) {
CellularInfallSource made;
made.id = id;
made.x_um = x;
made.y_um = 0;
made.width_um = 3'000;
made.height_um = 6'000;
made.start_tick = start;
made.end_tick = end;
made.mean_interval_ticks = interval;
made.per_bubble = energy_and_carbon(400'000, 40'000);
made.entitlement = entitlement;
return made;
}
CellularEnvironmentConfig config(std::vector<CellularInfallSource> sources = {},
std::uint64_t radiation = 0) {
CellularEnvironmentConfig made;
made.geometry.voxel = {3, -2, 5};
made.geometry.box = {{1'000}, {2'000}, {0}, {6'000}, {6'000}, {10}};
made.water = {{5'000'000}, {70'000}, {9'000}};
made.sources = std::move(sources);
made.radiation_cap = {radiation};
return made;
}
Environment environment(Owner state, CellularEnvironmentConfig made) {
auto population =
checked(CellularPopulation::create(std::move(state), {false, 900, 1'600}), "population");
return checked(CellularEnvironment::create(std::move(population), std::move(made)),
"environment");
}
Environment copy(const CellularEnvironment& value) {
return checked(CellularEnvironment::restore(value.snapshot(), value.state().world(),
value.state().region(), value.state().frame(),
value.tick()),
"environment copy");
}
void step(CellularEnvironment& value, bool bud = false) {
checked(value.advance_tick(controlled(value.state(), bud)), "joint tick");
}
// Every channel: current == opening + incoming - outgoing, and the environment's own
// flows are the complete ledger here (no migration).
void audit(const CellularEnvironment& value) {
const auto& state = value.state();
const auto& ledger = state.boundary_ledger();
auto expected = state.opening_total();
expected.energy.value += ledger.incoming.energy.value;
expected.energy.value -= ledger.outgoing.energy.value;
for (std::size_t channel = 0; channel < expected.matter.size(); ++channel)
expected.matter[channel].value +=
ledger.incoming.matter[channel].value - ledger.outgoing.matter[channel].value;
require(state.current_total() == expected, "joint owner broke open-boundary closure");
auto environmental = value.imported();
environmental.energy.value += state.captured_light().value; // A rules-11 owner's light.
require(ledger.incoming == environmental && ledger.outgoing == Inventory{value.exported(), {}},
"environment flows differ from the nested boundary ledger");
for (std::size_t index = 0; index < value.sources().size(); ++index) {
const auto& made = value.sources()[index];
const auto& done = value.infall()[index];
require(done.imported.energy <= made.entitlement.energy &&
done.imported.matter[0] <= made.entitlement.matter[0],
"infall exceeded its entitlement");
}
require(value.water() == CellularWaterColumn{{5'000'000}, {70'000}, {9'000}},
"rules 1 changed tagged water or dissolved nutrients");
}
// Source-off and closed regions keep the original biology exactly; a plain population
// advanced without the composite agrees byte for byte.
void closed_and_source_off() {
auto closed = environment(founders(), config());
const auto next = founders()->tick() + 1;
auto off = environment(
founders(), config({source(1, 0, 1, energy_and_carbon(1 << 30, 1 << 30), next, next + 1)}));
auto plain =
checked(CellularPopulation::create(founders(), {false, 900, 1'600}), "plain population");
// Tick 1 is inside the off source's interval; advance past it first without events.
for (unsigned tick = 0; tick < 1'000; ++tick) {
step(*closed, tick % 100 == 0);
if (tick == 0) {
const auto report = off->advance_tick(controlled(off->state(), true));
require(report && report->events == 1 && report->credited_bubbles > 0,
"every-tick source missed its only active tick");
} else {
step(*off, tick % 100 == 0);
}
checked(plain->advance_tick(controlled(plain->state(), tick % 100 == 0)), "plain tick");
audit(*closed);
audit(*off);
require(closed->population().snapshot() == plain->snapshot(),
"closed joint owner changed biology");
}
require(closed->imported() == Inventory{} && closed->exported().value == 0 &&
closed->state().current_total() == closed->state().opening_total(),
"closed region crossed its boundary");
require(off->infall()[0].events == 1 && off->imported() != Inventory{} &&
off->state().current_total() != off->state().opening_total(),
"source interval did not end after one tick");
}
// Open infall exhausts a finite entitlement exactly, then imports nothing.
void exhaustion() {
const auto entitlement = energy_and_carbon(4'000'000, 400'000); // Ten bubbles each.
auto open = environment(founders(), config({source(1, 0, 40, entitlement)}));
std::uint64_t exhausted_at = 0;
for (unsigned tick = 0; tick < 2'000; ++tick) {
step(*open, tick % 100 == 0);
audit(*open);
if (exhausted_at == 0 && open->imported() == entitlement)
exhausted_at = open->tick();
}
const auto& done = open->infall()[0];
require(exhausted_at != 0 && open->imported() == entitlement && done.exhausted_events > 0 &&
done.credited_bubbles == 20 && done.skipped_bubbles > 0,
"finite infall entitlement was not consumed exactly once");
std::cout << "exhaustion: entitlement consumed at tick " << exhausted_at << ", events "
<< done.events << ", credited " << done.credited_bubbles << ", skipped "
<< done.skipped_bubbles << ", exhausted events " << done.exhausted_events << '\n';
const auto after = open->imported();
for (unsigned tick = 0; tick < 500; ++tick)
step(*open);
require(open->imported() == after, "exhausted source imported more stock");
}
// Radiative export removes retained heat only: biology is unchanged against closed.
void radiation() {
auto closed = environment(founders(), config());
auto radiating = environment(founders(), config({}, 50));
for (unsigned tick = 0; tick < 1'500; ++tick) {
step(*closed, tick % 100 == 0);
step(*radiating, tick % 100 == 0);
audit(*radiating);
const auto& a = closed->state();
const auto& b = radiating->state();
require(std::ranges::equal(a.lives(), b.lives()) &&
std::ranges::equal(a.corpses(), b.corpses()) &&
a.habitat().snapshot() == b.habitat().snapshot() &&
a.heat().energy.value == b.heat().energy.value + radiating->exported().value,
"radiated heat changed biology or was not removed exactly");
}
require(radiating->exported().value > 0, "no heat was radiated");
std::cout << "radiation: exported " << radiating->exported().value << " pJ, retained "
<< radiating->state().heat().energy.value << " of "
<< closed->state().heat().energy.value << " pJ closed\n";
}
// A refused tick on an infall tick changes nothing; restore continues exactly.
void atomic_and_restore() {
// Every tick of the first 25 imports, so the refused tick carries an exchange.
const auto next = founders()->tick() + 1;
auto value = environment(
founders(),
config({source(1, 0, 1, energy_and_carbon(1 << 30, 1 << 30), next, next + 25)}, 7));
for (unsigned tick = 0; tick < 20; ++tick)
step(*value);
const auto before = value->snapshot();
const auto patches = value->state().habitat().patches().size();
require(!value->advance_tick({}).has_value() && value->snapshot() == before &&
value->state().habitat().patches().size() == patches,
"refused joint tick kept a torn exchange");
auto restored = copy(*value);
require(restored->snapshot() == before, "restore changed the joint envelope");
const auto retried = checked(value->advance_tick(controlled(value->state())), "retried tick");
require(retried.credited_bubbles > 0 && retried.imported != Inventory{},
"the refused tick carried no exchange");
step(*restored);
require(value->snapshot() == restored->snapshot(), "retry differed from the restored owner");
for (unsigned tick = 0; tick < 200; ++tick) {
step(*value, tick % 50 == 0);
step(*restored, tick % 50 == 0);
require(value->snapshot() == restored->snapshot(), "restored owner diverged");
}
audit(*restored);
}
// Exact cohorts of real wildlife see the same environment and biology as individuals.
void raw_and_cohort() {
auto raw = environment(
founders(), config({source(1, 0, 60, energy_and_carbon(1ULL << 40, 1ULL << 40))}, 20));
std::uint64_t genome = 0;
for (unsigned tick = 0; tick < 30'000 && genome == 0; ++tick) {
step(*raw, true);
for (const auto& life : raw->state().lives())
if (life.account == LifeAccount{})
genome = life.identity.genome;
}
require(genome != 0, "no real wildlife for cohort comparison");
auto cohort = copy(*raw);
require(checked(cohort->collapse(genome), "collapse wildlife") > 0, "empty cohort");
for (unsigned tick = 0; tick < 1'500; ++tick) {
const auto a = checked(raw->advance_tick(controlled(raw->state(), tick % 40 == 0)), "raw");
const auto b =
checked(cohort->advance_tick(controlled(cohort->state(), tick % 40 == 0)), "cohort");
require(a.imported == b.imported && a.exported == b.exported &&
a.biology.buds == b.biology.buds &&
raw->state().snapshot() == cohort->state().snapshot(),
"cohort and individual representations diverged");
}
audit(*cohort);
require(raw->infall()[0].events > 0, "comparison saw no infall");
std::cout << "raw/cohort: " << cohort->population().members().size() << " tagged of "
<< raw->state().lives().size() << " lives, infall events " << raw->infall()[0].events
<< ", imported energy " << raw->imported().energy.value << " pJ, radiated "
<< raw->exported().value << " pJ at tick " << raw->tick() << '\n';
}
// ADR-0175: a rules-11 region whose founder is born after the upgrade (founder 4).
Owner producer_region(std::uint64_t irradiance) {
auto state = opening(7, true, 1, false);
checked(state->advance_tick({}), "producer genesis tick");
state = checked(state->migration_upgrade_candidate(), "boundary upgrade");
state = checked(state->maturation_upgrade_candidate(), "maturation upgrade");
state = checked(state->inheritance_upgrade_candidate(), "inheritance upgrade");
const CellularLight light{irradiance, 1, {irradiance == 0 ? 0 : 1ULL << 50}};
require(!state->photosynthesis_upgrade_candidate({1, 0, {1}}) &&
!state->photosynthesis_upgrade_candidate({1, 1, {0}}),
"invalid light declared");
state = checked(state->photosynthesis_upgrade_candidate(light), "photosynthesis upgrade");
require(state->rules_version() == cellular_lives_photosynthesis_rules &&
state->format_version() == cellular_lives_light_format && state->light() == light &&
!state->photosynthesis_upgrade_candidate(light),
"photosynthesis upgrade repeated, wrong versions or lost light");
LifeAccount account{};
account.back() = 1;
state = checked(state->birth_candidate({account, 1}, {100, 100, 100, 100, {state->tick()}}),
"founder 4 birth");
const auto genome = state->archive().find(100);
require(genome && genome->schema_version() == biology::genome_schema_v5 &&
!genome->carries(biology::Capability::photosynthesis),
"founder 4 is not schema 5 without photosynthesis");
return state;
}
bool photosynthetic(const CellularLives& state, std::uint64_t genome) {
const auto found = state.archive().find(genome);
return found && found->carries(biology::Capability::photosynthesis);
}
void closed(const CellularLives& state) {
const auto& ledger = state.boundary_ledger();
auto expected = state.opening_total();
expected.energy.value += ledger.incoming.energy.value - ledger.outgoing.energy.value;
require(state.current_total() == expected && ledger.incoming.energy == state.captured_light(),
"lit region broke closure or booked light outside the ledger");
}
struct Producers {
std::unique_ptr<CellularPopulation> population;
std::uint64_t plan{}, child{}, captured{}, lit_ticks{}, still{};
};
// The founder earns photosynthesis as its offspring plan (rules 10+), buds a child that
// expresses it, and that child captures light inside the owner's own tick.
Producers grow_producers(std::uint64_t irradiance) {
Producers out;
out.population = checked(
CellularPopulation::create(producer_region(irradiance), {false, 900, 1'600}), "producers");
auto& population = *out.population;
for (unsigned tick = 0; tick < 80'000 && out.plan == 0; ++tick) {
const auto& life = population.state().lives().front();
if (!life.mutation.offer) {
checked(population.advance_tick(controlled(population.state())), "feed");
continue;
}
const auto& offer = *life.mutation.offer;
const auto found = std::ranges::find_if(offer.candidates, [](const auto& candidate) {
return candidate.target == biology::Capability::photosynthesis &&
candidate.effect == biology::MutationEffect::acquire;
});
const auto successor = 2'000'000 + tick;
// Decided before the tick: the tick replaces the state the offer lives in.
const bool acquire = found != offer.candidates.end();
const CellularMutationSelection selection{100, life.mutation.event_index,
life.mutation.offer_tick, successor,
acquire ? found->operator_id : std::uint16_t{0}};
checked(population.advance_tick(controlled(population.state()), std::span{&selection, 1}),
"selection tick");
if (acquire)
out.plan = successor;
}
require(
out.plan != 0 && photosynthetic(population.state(), out.plan) &&
!photosynthetic(population.state(), population.state().lives().front().identity.genome),
"founder never planned photosynthesis or expressed it itself");
for (unsigned tick = 0; tick < 40'000 && out.child == 0; ++tick) {
checked(population.advance_tick(controlled(population.state(), true)), "bud");
for (const auto& life : population.state().lives())
if (life.parent_life == 100 && photosynthetic(population.state(), life.identity.genome))
out.child = life.identity.life;
}
require(out.child != 0, "no child expressed the photosynthesis plan");
for (unsigned tick = 0; tick < 400; ++tick) {
const auto before = population.state().captured_light().value;
const auto intents =
checked(wildlife_intents(population.state(), population.state().tick() + 1), "intents");
for (const auto& intent : intents) {
const auto life = std::ranges::find(population.state().lives(), intent.life_id,
[](const auto& l) { return l.identity.life; });
if (photosynthetic(population.state(), life->identity.genome) &&
intent.intent == biology::CellularStepIntent{})
++out.still;
}
checked(population.advance_tick(controlled(population.state())), "lit tick");
const auto gained = population.state().captured_light().value - before;
out.captured += gained;
out.lit_ticks += gained > 0 ? 1 : 0;
closed(population.state());
}
return out;
}
void producers() {
auto trial = grow_producers(cellular_light_trial_irradiance);
require(trial.captured > 0 && trial.lit_ticks > 0, "a photosynthetic child captured no light");
const auto& state = trial.population->state();
const auto bytes = state.snapshot();
require(bytes.size() > 8 && bytes[7] == '9', "lit region not owner format 9");
auto restored =
checked(CellularPopulation::restore(trial.population->snapshot(), state.world(),
state.region(), state.frame(), state.tick()),
"lit restore");
for (unsigned tick = 0; tick < 200; ++tick) {
checked(trial.population->advance_tick(controlled(trial.population->state())), "a");
checked(restored->advance_tick(controlled(restored->state())), "b");
require(trial.population->snapshot() == restored->snapshot(),
"lit region diverged after restore");
}
// A joint owner nests the lit owner: its own infall stays separate from the light.
const auto& lit_state = trial.population->state();
auto joint_config = config({}, 9);
joint_config.geometry.box.width = {lit_state.area().width_um};
joint_config.geometry.box.height = {lit_state.area().height_um};
auto joint = checked(CellularEnvironment::create(std::move(restored), std::move(joint_config)),
"lit joint");
for (unsigned tick = 0; tick < 200; ++tick) {
step(*joint);
audit(*joint);
}
require(joint->state().captured_light().value > 0, "nested owner stopped capturing");
// Dark and brighter light are checked on the capture rule itself
// (photosynthesis-contracts); a third grown history would only repeat it here.
std::cout << "producers: plan " << trial.plan << ", child " << trial.child << ", captured "
<< trial.captured << " pJ over " << trial.lit_ticks << " lit ticks\n";
}
// A full habitat refuses new deposits: bubbles are counted skipped, never deferred.
void capacity() {
auto value = environment(founders(),
config({source(1, 0, 1, energy_and_carbon(1ULL << 40, 1ULL << 40))}));
for (unsigned tick = 0;
tick < 1'000 && value->state().habitat().patches().size() < biology::max_cellular_patches;
++tick)
step(*value);
require(value->state().habitat().patches().size() == biology::max_cellular_patches,
"every-tick infall did not reach the deposit limit");
const auto before = value->imported();
const auto report = checked(value->advance_tick(controlled(value->state())), "full tick");
require(report.events == 1 && report.skipped_bubbles > 0 &&
report.credited_bubbles + report.skipped_bubbles >=
cellular_infall_trial_bubbles_min &&
value->state().habitat().patches().size() <= biology::max_cellular_patches,
"full habitat accepted or lost infall bubbles");
require(report.credited_bubbles > 0 || value->imported() == before,
"skipped bubbles were imported");
audit(*value);
}
// Unattended joint intervals: recording equals live joint ticks, encoding is canonical,
// replay re-derives every flow and refuses tampered evidence.
CellularBatchHeader header(const CellularEnvironment& value, std::uint64_t ticks) {
CellularBatchHeader made{
value.state().world(), value.state().region(), value.state().frame(), {}, {},
value.tick(), value.tick() + ticks};
made.predecessor.fill(7);
made.predecessor_digest.fill(9);
return made;
}
std::vector<CellularLifeIntent> frozen(const CellularLives& state) {
auto inputs = controlled(state);
for (auto& input : inputs)
input.intent.frozen = true;
return inputs;
}
// Budding founders until real wildlife exists; returns its genome (zero if none).
std::uint64_t first_wildlife(CellularEnvironment& value) {
for (unsigned tick = 0; tick < 30'000; ++tick) {
step(value, true);
for (const auto& life : value.state().lives())
if (life.account == LifeAccount{})
return life.identity.genome;
}
return 0;
}
void traces() {
// A closed region grows the first wildlife; the traced owner then takes over that exact
// population with a source starting on its next tick, so infall neither changes that
// history nor fills the habitat beforehand.
auto probe = environment(founders(), config());
const auto genome = first_wildlife(*probe);
require(genome != 0, "no wildlife for joint traces");
const auto& grown = probe->state();
auto value = environment(
checked(CellularLives::restore(grown.snapshot(), grown.world(), grown.region(),
grown.frame(), grown.tick()),
"grown copy"),
config({source(1, 0, 15, energy_and_carbon(1ULL << 40, 1ULL << 40), probe->tick() + 1)},
13));
require(value->state().snapshot() == grown.snapshot() && value->tick() == probe->tick(),
"the traced owner did not take over the grown history");
require(!prepare_environment_interval(*value, header(*value, 8)),
"active controlled cells entered an unattended interval");
for (unsigned tick = 0; tick < cellular_linger_ticks + 10; ++tick)
checked(value->advance_tick(frozen(value->state())), "suspend controlled");
require(population_interval_safe(value->state()), "controlled cells did not suspend");
const auto base = value->snapshot();
auto prepared = checked(prepare_environment_interval(*value, header(*value, 64)), "record");
require(value->snapshot() == base, "recording changed its source");
auto live = copy(*value);
for (std::uint64_t tick = 0; tick < 64; ++tick)
checked(live->advance_tick(frozen(live->state())), "live joint tick");
require(live->snapshot() == prepared.state->snapshot(),
"recorded interval differs from live joint ticks");
const auto bytes = checked(encode_environment_batch(prepared.batch), "encode");
const auto decoded = checked(decode_environment_batch(bytes), "decode");
require(decoded == prepared.batch, "batch round trip changed evidence");
const auto replayed = checked(replay_environment_batch(*value, decoded), "replay");
require(replayed->snapshot() == prepared.state->snapshot(), "replay diverged");
Inventory crossed{};
std::uint64_t radiated = 0;
for (const auto& flow : prepared.batch.flows) {
crossed.energy.value += flow.imported.energy.value;
crossed.matter[0].value += flow.imported.matter[0].value;
radiated += flow.exported.value;
}
require(crossed.energy.value + value->imported().energy.value ==
prepared.state->imported().energy.value &&
radiated + value->exported().value == prepared.state->exported().value &&
crossed != Inventory{} && radiated > 0,
"flows are not the interval's complete crossing");
auto forged = decoded;
forged.flows[3].exported.value += 1;
require(replay_environment_batch(*value, forged).error() ==
CellularEnvironmentError::conservation,
"forged radiation accepted");
forged = decoded;
forged.population.boundaries[5].sequence += 1;
require(!replay_environment_batch(*value, forged), "forged population boundary accepted");
forged = decoded;
forged.flows.pop_back();
require(!encode_environment_batch(forged) && !replay_environment_batch(*value, forged),
"missing flow accepted");
require(replay_environment_batch(*prepared.state, decoded).error() ==
CellularEnvironmentError::identity,
"batch replayed from the wrong cut");
auto truncated = bytes;
truncated.pop_back();
require(!decode_environment_batch(truncated), "truncated batch accepted");
auto future = bytes;
future[8] = 2;
require(decode_environment_batch(future).error() == CellularEnvironmentError::unsupported,
"future batch accepted");
// Whole-group conversion, then a cohort interval that matches the individual one.
auto conversion = checked(
prepare_environment_conversion(*prepared.state, header(*prepared.state, 0), {genome, true}),
"record conversion");
require(conversion.batch.flows.empty() && conversion.state->population().members().size() > 0 &&
conversion.state->state().snapshot() == prepared.state->state().snapshot(),
"conversion changed biology or crossed the boundary");
const auto converted =
checked(replay_environment_batch(
*prepared.state, checked(decode_environment_batch(checked(
encode_environment_batch(conversion.batch), "c")),
"decode conversion")),
"replay conversion");
require(converted->snapshot() == conversion.state->snapshot(), "conversion replay diverged");
auto individual =
checked(prepare_environment_interval(*prepared.state, header(*prepared.state, 64)),
"individual interval");
auto cohort =
checked(prepare_environment_interval(*conversion.state, header(*conversion.state, 64)),
"cohort interval");
require(cohort.state->state().snapshot() == individual.state->state().snapshot() &&
cohort.batch.flows == individual.batch.flows &&
cohort.batch.population.biology == individual.batch.population.biology,
"cohort interval changed biology or environmental flows");
std::cout << "traces: " << bytes.size() << " bytes for 64 ticks, imported "
<< crossed.energy.value << " pJ, radiated " << radiated << " pJ, cohort "
<< conversion.state->population().members().size() << " members\n";
}
std::vector<std::uint8_t> resealed(std::vector<std::uint8_t> bytes) {
std::uint64_t hash = 14695981039346656037ULL;
for (std::size_t i = 0; i + 8 < bytes.size(); ++i)
hash = (hash ^ bytes[i]) * 1099511628211ULL;
for (std::size_t i = 0; i < 8; ++i)
bytes[bytes.size() - 8 + i] = static_cast<std::uint8_t>(hash >> (8U * i));
return bytes;
}
void refusals() {
auto value = environment(founders(), config({source(1, 0, 1, energy_and_carbon(800'000, 1))}));
for (unsigned tick = 0; tick < 5; ++tick)
step(*value);
const auto bytes = value->snapshot();
const auto world = value->state().world(), region = value->state().region(),
frame = value->state().frame(), tick = value->tick();
auto corrupt = bytes;
corrupt[200] ^= 1U;
require(CellularEnvironment::restore(corrupt, world, region, frame, tick).error() ==
CellularEnvironmentError::checksum,
"corruption accepted");
require(CellularEnvironment::restore(bytes, world, region, frame, tick + 1).error() ==
CellularEnvironmentError::identity,
"wrong tick accepted");
auto version = bytes;
version[8] = 2;
require(CellularEnvironment::restore(resealed(version), world, region, frame, tick).error() ==
CellularEnvironmentError::unsupported,
"future envelope accepted");
// The first source's cumulative energy import (after id, rect, ticks, interval,
// bubble bounds, per-bubble and entitlement) above its entitlement.
auto excess = bytes;
const auto imported = cellular_environment_header_bytes + 8 + 16 + 24 + 8 + 40 + 40;
excess[imported + 7] = 0x7F;
require(CellularEnvironment::restore(resealed(excess), world, region, frame, tick).error() ==
CellularEnvironmentError::conservation,
"import above entitlement accepted");
auto nested = bytes;
nested[cellular_environment_header_bytes - 8] ^= 1U; // Nested length.
require(!CellularEnvironment::restore(resealed(nested), world, region, frame, tick),
"nested length accepted");
const auto refused = [](CellularEnvironmentConfig made, CellularEnvironmentError error,
Owner state = founders()) {
auto population = checked(CellularPopulation::create(std::move(state), {false, 900, 1'600}),
"refusal population");
const auto result = CellularEnvironment::create(std::move(population), std::move(made));
return !result && result.error() == error;
};
auto atmosphere = config();
atmosphere.atmosphere_species = 1;
require(refused(atmosphere, CellularEnvironmentError::unsupported),
"atmosphere treated as zero or unlimited");
auto flat = config();
flat.geometry.box.depth = {0};
require(refused(flat, CellularEnvironmentError::invalid_geometry), "zero depth accepted");
auto camera = config();
camera.geometry.box.width = {5'000};
require(refused(camera, CellularEnvironmentError::invalid_geometry),
"box disagreed with the cellular area");
auto outside = config();
outside.geometry.box.x = {996'000};
require(refused(outside, CellularEnvironmentError::invalid_geometry),
"habitat crossed its voxel");
const auto plenty = energy_and_carbon(1 << 20, 1 << 20);
require(refused(config({source(1, 0, 1, plenty), source(2, 2'000, 1, plenty)}),
CellularEnvironmentError::invalid_source),
"overlapping entitlements accepted");
require(refused(config({source(2, 0, 1, plenty), source(1, 3'000, 1, plenty)}),
CellularEnvironmentError::invalid_source),
"unsorted sources accepted");
auto empty = source(1, 0, 1, plenty);
empty.per_bubble = {};
require(refused(config({empty}), CellularEnvironmentError::invalid_source),
"stockless source accepted");
require(
refused(config({source(1, 4'000, 1, plenty)}), CellularEnvironmentError::invalid_source),
"source outside the habitat accepted");
require(refused(config(), CellularEnvironmentError::unsupported, opening(7, true)),
"owner without a boundary ledger accepted");
}
constexpr std::uint64_t restart_ticks = 400;
Environment restart_fixture() {
auto value =
environment(founders(), config({source(1, 0, 25, energy_and_carbon(1ULL << 40, 1ULL << 40)),
source(4, 3'000, 30, energy_and_carbon(1ULL << 40, 9))},
11));
for (std::uint64_t tick = 0; tick < restart_ticks; ++tick)
step(*value, tick % 50 == 0);
return value;
}
void write(const char* path, const std::vector<std::uint8_t>& bytes) {
std::ofstream out(path, std::ios::binary);
out.write(reinterpret_cast<const char*>(bytes.data()),
static_cast<std::streamsize>(bytes.size()));
require(out.good(), "write failed");
}
std::vector<std::uint8_t> read(const char* path) {
std::ifstream in(path, std::ios::binary);
return {std::istreambuf_iterator<char>(in), {}};
}
void continue_fixture(CellularEnvironment& value) {
for (std::uint64_t tick = 0; tick < restart_ticks; ++tick)
step(value, tick % 50 == 0);
}
} // namespace
int main(int argc, char** argv) {
try {
if (argc == 4 && std::strcmp(argv[1], "--checkpoint") == 0) {
auto value = restart_fixture();
write(argv[2], value->snapshot());
continue_fixture(*value);
audit(*value);
write(argv[3], value->snapshot());
return 0;
}
if (argc == 4 && std::strcmp(argv[1], "--resume") == 0) {
const auto bytes = read(argv[2]);
// Identity is trusted input, never taken from the envelope it checks.
const auto origin = founders();
auto value = checked(CellularEnvironment::restore(bytes, origin->world(),
origin->region(), origin->frame(),
origin->tick() + restart_ticks),
"fresh-process restore");
continue_fixture(*value);
write(argv[3], value->snapshot());
return 0;
}
closed_and_source_off();
exhaustion();
radiation();
atomic_and_restore();
raw_and_cohort();
capacity();
producers();
traces();
refusals();
auto value = restart_fixture();
audit(*value);
require(value->infall()[0].events > 0 && value->infall()[1].events > 0 &&
value->exported().value > 0,
"restart fixture crossed no boundary");
std::cout << "cellular environment contracts passed\n";
return 0;
} catch (const std::exception& error) {
std::cerr << error.what() << '\n';
return 1;
}
}