#include "evo/persistence/region_batch.hpp" #include "fixtures/environmental_region.hpp" #include #include #include #include #include namespace { using namespace evo::persistence; using evo::processes::EnvironmentalCommunity; using evo::processes::LineageRegion; using evo::test::region_input; void check(bool ok, std::source_location at = std::source_location::current()) { if (!ok) throw std::runtime_error("region batch line " + std::to_string(at.line())); } #define CHECK(...) check(static_cast(__VA_ARGS__)) template std::array filled(std::uint8_t value) { std::array out{}; out.fill(value); return out; } TraceHeader header(std::uint64_t begin, std::uint64_t end) { return {1, {7, 3}, filled<16>(1), filled<32>(2), begin, end}; } void recorder_seals_at_outcomes_and_capacity() { auto state = evo::test::region_community(); RegionBatch batch{*state}; CHECK(batch.begin_tick() == 0 && !batch.sealed()); CHECK(!batch.confirm(0)); // Nothing to confirm. for (std::uint64_t tick = 1; tick <= 19; ++tick) CHECK(batch.advance(region_input(tick, true))); CHECK(!batch.sealed() && batch.end_tick() == 19); auto death = batch.advance(region_input(20, true)); CHECK(death && death->consumer_transition == 1); // A permanent outcome pauses the region until durable confirmation. CHECK(batch.sealed() && batch.advance(region_input(21)).error() == BatchError::sealed); CHECK(state->progress().tick == 20); const auto decisions = derive_decisions(batch.steps(), 0, 0); CHECK(decisions.size() == 1 && decisions[0] == BatchDecision{20, Actor::consumer}); CHECK(!batch.confirm(19) && batch.sealed()); CHECK(batch.confirm(20) && !batch.sealed() && batch.begin_tick() == 20); CHECK(batch.steps().empty()); // 64 ticks without an outcome also seals; an early flush is explicit. for (std::uint64_t i = 0; i < 64; ++i) CHECK(batch.advance(region_input(21 + i))); CHECK(batch.sealed() && batch.steps().size() == 64); CHECK(batch.confirm(84)); CHECK(batch.advance(region_input(85))); batch.seal(); CHECK(batch.sealed() && batch.confirm(85)); // A refused tick records nothing. evo::processes::EnvironmentalInput bad = region_input(86); bad.terminal[1] = 1; // The consumer is already dead. CHECK(batch.advance(bad).error() == BatchError::state && batch.steps().empty()); } void lineage_recorder_uses_archived_organisms() { auto region = evo::test::lineage_region(); RegionBatch batch{*region}; for (std::uint64_t tick = 1; tick <= 20; ++tick) CHECK(batch.advance(region_input(tick, true))); CHECK(batch.sealed()); const auto d = derive_decisions(batch.steps(), region->binding().producer, region->binding().consumer); CHECK(d.size() == 1 && d[0].organism == 11 && d[0].tick == 20); CHECK(!region->archive().organism(11)->alive); } void traces_round_trip_and_bind_their_place() { auto state = evo::test::region_community(); RegionBatch batch{*state}; for (std::uint64_t tick = 1; tick <= 20; ++tick) CHECK(batch.advance(region_input(tick, true))); auto bytes = encode_trace(header(0, 20), batch.steps()); CHECK(bytes && bytes->size() == trace_bytes_for(20) && bytes->size() == 96 + (20 * 304)); auto decoded = decode_trace(*bytes); CHECK(decoded && decoded->header == header(0, 20)); CHECK(std::ranges::equal(decoded->steps, batch.steps())); CHECK(trace_bytes_for(64) == 19552); const auto refused = [&](TraceHeader h, std::size_t count) { return !encode_trace(h, batch.steps().first(count)); }; CHECK(refused(header(0, 19), 20)); // Count disagrees with the range. CHECK(refused(header(1, 21), 20)); // Reports are for ticks 1..20. auto h = header(0, 20); h.predecessor_digest = {}; CHECK(refused(h, 20)); h = header(0, 20); h.key.region = 0; CHECK(refused(h, 20)); CHECK(!encode_trace(header(0, 0), {})); auto damaged = *bytes; damaged[0] ^= 1U; CHECK(!decode_trace(damaged)); damaged = *bytes; damaged.pop_back(); CHECK(!decode_trace(damaged)); damaged = *bytes; damaged[96 + 72] = 7; // First report's tick: no longer contiguous. CHECK(!decode_trace(damaged)); damaged = *bytes; damaged[88] = 21; // End tick 21 with 20 steps: size check. CHECK(!decode_trace(damaged)); } void decisions_are_canonical() { const BatchDecision producer{5, Actor::producer, Outcome::death, 10}; const BatchDecision consumer{5, Actor::consumer, Outcome::death, 11}; const std::array ok{producer, consumer}; auto bytes = encode_decisions(ok, 0, 5); CHECK(bytes && bytes->size() == 2 * decision_bytes); auto back = decode_decisions(*bytes, 0, 5); CHECK(back && std::ranges::equal(*back, ok)); CHECK(encode_decisions({}, 0, 5) && encode_decisions({}, 0, 5)->empty()); const std::array reversed{consumer, producer}; CHECK(!encode_decisions(reversed, 0, 5)); const std::array twice{producer, BatchDecision{6, Actor::producer}}; CHECK(!encode_decisions(twice, 0, 6)); // An actor dies once. CHECK(!encode_decisions(std::array{producer}, 5, 9)); // Tick not in (begin, end]. CHECK(!encode_decisions(std::array{producer}, 0, 4)); auto damaged = *bytes; damaged[8] = 2; // Unknown actor. CHECK(!decode_decisions(damaged, 0, 5)); damaged = *bytes; damaged[12] = 2; // Unknown outcome. CHECK(!decode_decisions(damaged, 0, 5)); damaged = *bytes; damaged[9] = 1; // Actor 256: never truncated onto a known actor. CHECK(!decode_decisions(damaged, 0, 5)); CHECK(!decode_decisions(std::span{*bytes}.first(23), 0, 5)); std::vector nine(9 * decision_bytes); CHECK(!decode_decisions(nine, 0, 5)); } } // namespace int main() { try { recorder_seals_at_outcomes_and_capacity(); lineage_recorder_uses_archived_organisms(); traces_round_trip_and_bind_their_place(); decisions_are_canonical(); std::puts("region batch contracts passed"); return 0; } catch (const std::exception& e) { std::fprintf(stderr, "%s\n", e.what()); return 1; } }