Foundation / checks (checks) (push) Successful in 5s
Foundation / checks (client) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 4s
Foundation / checks (network) (push) Successful in 5s
Foundation / checks (postgres) (push) Successful in 4s
Foundation / checks (tsan) (push) Successful in 4s
Foundation / checks (deploy) (push) Successful in 4m24s
Foundation / postgres-tools (push) Successful in 1m31s
Foundation / server-image (push) Successful in 4m25s
Foundation / image (push) Successful in 4m50s
A mutation choice's reserved tick is now the earliest tick it may bind at, not the only one (ADR-0121 amendment). With write-behind commits, a choice reserved for head + 1 landed in ticks already being simulated or committed: the batch was refused, or the reservation was orphaned for a past tick and stalled the region. Schema 59: a bound record carries the tick it applied at and the rest of its input must equal the reservation's; the "omits a reserved mutation" refusals are removed. Existing rows are unchanged, so an orphaned reservation binds at the next commit that carries it. The host keeps every unbound reservation queued and the open batch binds those the commit in flight does not carry, at its next tick; the earlier hold on new choices is removed. A choice that outlives its life binds as life_died (owner, trace matching and recovery accept it when no life with that ID remains). Recovery takes a bound choice's tick from its trace. Tests: a choice skipped by one checkpoint binds a tick late and recovers; builder late binding, refusal before the earliest tick, and a departed life's life_died outcome. Full local PostgreSQL qualification passes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
424 lines
21 KiB
C++
424 lines
21 KiB
C++
#include "evo/server/cellular_session_batch.hpp"
|
|
|
|
#include <array>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <source_location>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace {
|
|
using namespace evo;
|
|
using namespace evo::server;
|
|
|
|
void check(bool value, std::source_location at = std::source_location::current()) {
|
|
if (!value)
|
|
throw std::runtime_error("cellular session batch line " + std::to_string(at.line()));
|
|
}
|
|
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
|
|
|
|
accounting::Inventory founder_price(std::uint64_t count) {
|
|
const auto endowment = biology::primitive_endowment();
|
|
CHECK(endowment);
|
|
auto funding = endowment->body;
|
|
funding.energy.value = endowment->reserve.energy.value + endowment->construction.value;
|
|
funding.energy.value *= count;
|
|
for (auto& channel : funding.matter)
|
|
channel.value *= count;
|
|
return funding;
|
|
}
|
|
|
|
void actions_bind_to_owned_life_and_preserve_other_inputs() {
|
|
auto primitive = PrimitiveLives::create({90, 1, 7, 17, founder_price(2), {{0, 0}, {20, 0}}});
|
|
CHECK(primitive);
|
|
LifeRequest request{};
|
|
request.account.back() = 1;
|
|
request.action = 1;
|
|
CHECK((*primitive)->spawn(request, {1, 101, 201, 301, {1}}));
|
|
request.account.back() = 2;
|
|
CHECK((*primitive)->spawn(request, {2, 102, 202, 302, {1}}));
|
|
|
|
biology::CellularHabitatConfig habitat_config{
|
|
90,
|
|
1,
|
|
7,
|
|
20'000,
|
|
20'000,
|
|
{{{0, 0}, 29, {{10}, {{{10}, {10}, {10}, {10}}}}},
|
|
{{15'000, 15'000}, 30, {{10}, {{{10}, {10}, {10}, {10}}}}}}};
|
|
auto habitat = biology::CellularHabitat::create(std::move(habitat_config));
|
|
CHECK(habitat);
|
|
auto state =
|
|
CellularLives::create(**primitive, std::move(*habitat), {{20'000, 20'000}, 1, 293'150});
|
|
CHECK(state && (*state)->lives().size() == 2);
|
|
|
|
const auto& controlled = (*state)->lives()[0];
|
|
const auto& other = (*state)->lives()[1];
|
|
const auto visible = (*state)->perceive(controlled.identity.life);
|
|
CHECK(visible && visible->size() == 1 &&
|
|
visible->front().address == (biology::CellularPatchAddress{0, 0}));
|
|
const std::array baseline{CellularLifeIntent{controlled.identity.life, {{5, 6}, {}}},
|
|
CellularLifeIntent{other.identity.life, {{7, 8}, {}}}};
|
|
const auto input = network::encode_cellular_action_input({2, -3, 4, true, 0, 0});
|
|
network::CarriedAction action{network::AccountId{controlled.account}, 77, 2,
|
|
network::ActionKind::cellular, input};
|
|
const std::array actions{action};
|
|
const auto prepared = prepare_cellular_session_tick(**state, 2, baseline, actions);
|
|
CHECK(prepared && prepared->intents.lives.size() == 2 && prepared->actions.size() == 1);
|
|
CHECK(prepared->intents.lives[0] ==
|
|
CellularLifeIntent{controlled.identity.life,
|
|
{{-3, 4}, biology::CellularPatchAddress{0, 0}}});
|
|
CHECK(prepared->intents.lives[1] == baseline[1]);
|
|
CHECK(prepared->actions[0] == CellularActionRecord{controlled.account, 77, input});
|
|
|
|
const auto guessed_input =
|
|
network::encode_cellular_action_input({2, 0, 0, true, 15'000, 15'000});
|
|
const network::CarriedAction guessed{network::AccountId{controlled.account}, 78, 2,
|
|
network::ActionKind::cellular, guessed_input};
|
|
const std::array guessed_actions{guessed};
|
|
CHECK(prepare_cellular_session_tick(**state, 2, baseline, guessed_actions).error() ==
|
|
CellularSessionBatchError::unperceived_target);
|
|
|
|
// ADR-0124: an engulf action becomes the life's engulf intent, and the trace keeps it.
|
|
const auto engulf_input = network::encode_cellular_action_input({2, 1, 0, false, 0, 0, true});
|
|
const network::CarriedAction engulf_action{network::AccountId{controlled.account}, 79, 2,
|
|
network::ActionKind::cellular, engulf_input};
|
|
const std::array engulf_actions{engulf_action};
|
|
const auto engulfing = prepare_cellular_session_tick(**state, 2, baseline, engulf_actions);
|
|
CHECK(engulfing && engulfing->intents.lives[0].intent.engulf &&
|
|
!engulfing->intents.lives[0].intent.intake_target);
|
|
CellularBatch engulf_batch;
|
|
engulf_batch.header = {(*state)->world(), (*state)->region(), (*state)->frame(), {}, {}, 1, 2};
|
|
engulf_batch.header.predecessor.fill(1);
|
|
engulf_batch.header.predecessor_digest.fill(2);
|
|
engulf_batch.ticks.push_back(engulfing->intents);
|
|
CHECK(match_cellular_actions_to_trace(**state, engulf_batch, engulfing->actions));
|
|
const auto engulf_bytes = encode_cellular_batch(engulf_batch);
|
|
CHECK(engulf_bytes);
|
|
const auto engulf_decoded = decode_cellular_batch(*engulf_bytes);
|
|
CHECK(engulf_decoded && *engulf_decoded == engulf_batch);
|
|
auto stripped = engulf_batch;
|
|
stripped.ticks[0].lives[0].intent.engulf = false;
|
|
CHECK(!match_cellular_actions_to_trace(**state, stripped, engulfing->actions));
|
|
|
|
// ADR-0125: a bud action becomes the life's bud intent, kept as kind 3 in the trace.
|
|
const auto bud_input =
|
|
network::encode_cellular_action_input({2, 0, 0, false, 0, 0, false, true});
|
|
const network::CarriedAction bud_action{network::AccountId{controlled.account}, 80, 2,
|
|
network::ActionKind::cellular, bud_input};
|
|
const std::array bud_actions{bud_action};
|
|
const auto budding = prepare_cellular_session_tick(**state, 2, baseline, bud_actions);
|
|
CHECK(budding && budding->intents.lives[0].intent.bud &&
|
|
!budding->intents.lives[0].intent.engulf &&
|
|
!budding->intents.lives[0].intent.intake_target);
|
|
auto bud_batch = engulf_batch;
|
|
bud_batch.ticks[0] = budding->intents;
|
|
CHECK(match_cellular_actions_to_trace(**state, bud_batch, budding->actions));
|
|
const auto bud_bytes = encode_cellular_batch(bud_batch);
|
|
CHECK(bud_bytes);
|
|
const auto bud_decoded = decode_cellular_batch(*bud_bytes);
|
|
CHECK(bud_decoded && *bud_decoded == bud_batch);
|
|
auto unbudded = bud_batch;
|
|
unbudded.ticks[0].lives[0].intent.bud = false;
|
|
CHECK(!match_cellular_actions_to_trace(**state, unbudded, budding->actions));
|
|
CellularBatch batch;
|
|
batch.header = {(*state)->world(), (*state)->region(), (*state)->frame(), {}, {}, 1, 2};
|
|
batch.header.predecessor.fill(1);
|
|
batch.header.predecessor_digest.fill(2);
|
|
batch.ticks.push_back(prepared->intents);
|
|
CHECK(match_cellular_actions_to_trace(**state, batch, prepared->actions));
|
|
|
|
persistence::RegionHead head{};
|
|
head.frame = (*state)->frame();
|
|
head.sequence = 4;
|
|
head.end_tick = (*state)->tick();
|
|
head.commit.fill(1);
|
|
head.digest.fill(2);
|
|
auto builder = CellularSessionBatchBuilder::create(**state, head);
|
|
CHECK(builder);
|
|
CHECK(builder->append(2, baseline, actions));
|
|
std::vector<CellularLifeIntent> next_baseline;
|
|
for (const auto& life : builder->candidate().lives())
|
|
next_baseline.push_back({life.identity.life, {}});
|
|
CHECK(builder->append(3, next_baseline, {}));
|
|
CHECK(builder->batch().header.begin_tick == 1 && builder->batch().header.end_tick == 3 &&
|
|
builder->batch().ticks.size() == 2);
|
|
CHECK(builder->actions().size() == 1 && builder->actions()[0] == prepared->actions[0]);
|
|
const auto replayed = replay_cellular_batch(**state, builder->batch());
|
|
CHECK(replayed && (*replayed)->snapshot() == builder->candidate().snapshot());
|
|
const auto repeated_input = network::encode_cellular_action_input({4, 0, 0, false, 0, 0});
|
|
const network::CarriedAction repeated{network::AccountId{controlled.account}, 77, 4,
|
|
network::ActionKind::cellular, repeated_input};
|
|
const std::array repeated_actions{repeated};
|
|
CHECK(builder->append(4, next_baseline, repeated_actions).error() ==
|
|
CellularSessionBatchError::duplicate_action);
|
|
CHECK(builder->append(5, next_baseline, {}).error() == CellularSessionBatchError::tick);
|
|
|
|
auto wrong_head = head;
|
|
++wrong_head.end_tick;
|
|
CHECK(CellularSessionBatchBuilder::create(**state, wrong_head).error() ==
|
|
CellularSessionBatchError::head);
|
|
|
|
auto altered = baseline;
|
|
altered[1].intent.movement.x = 10;
|
|
const auto preserved = prepare_cellular_session_tick(**state, 2, altered, actions);
|
|
CHECK(preserved && preserved->intents.lives[1].intent.movement.x == 10);
|
|
|
|
CHECK(prepare_cellular_session_tick(**state, 3, baseline, actions).error() ==
|
|
CellularSessionBatchError::tick);
|
|
CHECK(
|
|
prepare_cellular_session_tick(**state, 2, std::span{baseline}.first(1), actions).error() ==
|
|
CellularSessionBatchError::intents);
|
|
|
|
const std::array duplicate{action, action};
|
|
CHECK(prepare_cellular_session_tick(**state, 2, baseline, duplicate).error() ==
|
|
CellularSessionBatchError::duplicate_action);
|
|
auto unknown = action;
|
|
unknown.account.bytes.back() = 3;
|
|
const std::array unknown_actions{unknown};
|
|
CHECK(prepare_cellular_session_tick(**state, 2, baseline, unknown_actions).error() ==
|
|
CellularSessionBatchError::life);
|
|
auto malformed = action;
|
|
malformed.cellular_input = std::array<std::uint8_t, network::cellular_action_input_bytes>{};
|
|
const std::array malformed_actions{malformed};
|
|
CHECK(prepare_cellular_session_tick(**state, 2, baseline, malformed_actions).error() ==
|
|
CellularSessionBatchError::action);
|
|
}
|
|
|
|
void durable_mutation_reservations_bind_to_the_exact_offer() {
|
|
auto primitive = PrimitiveLives::create({93, 1, 1, 17, founder_price(1), {{0, 0}}});
|
|
CHECK(primitive);
|
|
LifeRequest request{};
|
|
request.account.back() = 3;
|
|
request.action = 1;
|
|
CHECK((*primitive)->spawn(request, {1, 101, 201, 301, {1}}));
|
|
accounting::Inventory stock{{1'000'000'000'000ULL},
|
|
{{{1'000'000'000'000ULL},
|
|
{1'000'000'000'000ULL},
|
|
{1'000'000'000'000ULL},
|
|
{1'000'000'000'000ULL}}}};
|
|
auto habitat =
|
|
biology::CellularHabitat::create({93, 1, 1, 1'000, 1'000, {{{0, 0}, 29, stock}}});
|
|
CHECK(habitat);
|
|
auto created =
|
|
CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 1, 293'150});
|
|
CHECK(created && (*created)->lives().size() == 1);
|
|
auto& owner = **created;
|
|
const auto life_id = owner.lives()[0].identity.life;
|
|
bool offered = false;
|
|
for (std::size_t tick = 0; tick < 10'000 && !offered; ++tick) {
|
|
const std::array intent{CellularLifeIntent{life_id, {{0, 0}, {{0, 0}}}}};
|
|
CHECK(owner.advance_tick(intent));
|
|
const auto current_offer = owner.mutation_offer(life_id);
|
|
CHECK(current_offer);
|
|
offered = current_offer->has_value();
|
|
}
|
|
CHECK(offered);
|
|
auto revision_owner = owner.migrate_to_v3();
|
|
CHECK(revision_owner);
|
|
const auto offer = (*revision_owner)->mutation_offer(life_id);
|
|
CHECK(offer && offer->has_value());
|
|
const auto offered_candidates = offer->value_or(biology::MutationOffer{});
|
|
CHECK(!offered_candidates.candidates.empty());
|
|
const auto& live = (*revision_owner)->lives()[0];
|
|
const auto action_tick = (*revision_owner)->tick() + 1;
|
|
const auto& candidate = offered_candidates.candidates.front();
|
|
persistence::CellularMutationReservation reservation;
|
|
reservation.account = live.account;
|
|
reservation.action_id = 42;
|
|
reservation.region = (*revision_owner)->region();
|
|
reservation.generation = 7;
|
|
reservation.target_tick = action_tick;
|
|
reservation.successor_identity = 999;
|
|
const auto put_field = [&](std::size_t offset, std::uint64_t value, std::size_t bytes) {
|
|
for (std::size_t i = 0; i < bytes; ++i)
|
|
reservation.input[offset + i] = static_cast<std::uint8_t>(value >> (i * 8U));
|
|
};
|
|
put_field(0, action_tick, 8);
|
|
put_field(8, life_id, 8);
|
|
put_field(16, live.mutation.event_index, 8);
|
|
put_field(24, live.mutation.offer_tick, 8);
|
|
put_field(32, candidate.operator_id, 2);
|
|
|
|
persistence::RegionHead head{};
|
|
head.frame = (*revision_owner)->frame();
|
|
head.sequence = 3;
|
|
head.end_tick = (*revision_owner)->tick();
|
|
head.commit.fill(0x31);
|
|
head.digest.fill(0x41);
|
|
auto builder = CellularSessionBatchBuilder::create(**revision_owner, head);
|
|
CHECK(builder);
|
|
const std::array baseline{CellularLifeIntent{life_id, {}}};
|
|
const std::array reservations{reservation};
|
|
CHECK(builder->append(action_tick, baseline, {}, {}, reservations));
|
|
const CellularMutationActionRecord expected_action{
|
|
live.account,
|
|
reservation.action_id,
|
|
action_tick,
|
|
{life_id, live.mutation.event_index, live.mutation.offer_tick, candidate.operator_id}};
|
|
const CellularMutationSelection expected_selection{
|
|
life_id, live.mutation.event_index, live.mutation.offer_tick,
|
|
reservation.successor_identity, candidate.operator_id};
|
|
CHECK(builder->batch().ticks.back().mutations.size() == 1 &&
|
|
builder->batch().ticks.back().mutations.front() == expected_selection &&
|
|
builder->mutation_actions().size() == 1 &&
|
|
builder->mutation_actions().front() == expected_action &&
|
|
match_cellular_mutation_actions_to_trace(**revision_owner, builder->batch(),
|
|
builder->mutation_actions()));
|
|
const auto replayed = replay_cellular_batch(**revision_owner, builder->batch());
|
|
CHECK(replayed && (*replayed)->snapshot() == builder->candidate().snapshot());
|
|
|
|
auto stale_builder = CellularSessionBatchBuilder::create(**revision_owner, head);
|
|
CHECK(stale_builder);
|
|
auto stale = reservation;
|
|
stale.input[24] ^= 1U;
|
|
const std::array stale_reservations{stale};
|
|
CHECK(stale_builder->append(action_tick, baseline, {}, {}, stale_reservations).error() ==
|
|
CellularSessionBatchError::mutation);
|
|
CHECK(stale_builder->candidate().snapshot() == (*revision_owner)->snapshot());
|
|
|
|
// ADR-0121 amendment (schema 59): the queue is durable. A choice binds at a tick after
|
|
// its reservation's, recording the tick it bound at; it may not bind before it.
|
|
auto late_builder = CellularSessionBatchBuilder::create(**revision_owner, head);
|
|
CHECK(late_builder);
|
|
auto early = reservation;
|
|
early.target_tick = action_tick + 1;
|
|
early.input[0] = static_cast<std::uint8_t>(early.target_tick);
|
|
for (std::size_t i = 1; i < 8; ++i)
|
|
early.input[i] = static_cast<std::uint8_t>(early.target_tick >> (i * 8U));
|
|
const std::array early_reservations{early};
|
|
CHECK(late_builder->append(action_tick, baseline, {}, {}, early_reservations).error() ==
|
|
CellularSessionBatchError::mutation);
|
|
CHECK(late_builder->append(action_tick, baseline, {}, {}, {}));
|
|
CHECK(late_builder->append(action_tick + 1, baseline, {}, {}, reservations));
|
|
CHECK(late_builder->mutation_actions().size() == 1 &&
|
|
late_builder->mutation_actions().front().tick == action_tick + 1 &&
|
|
late_builder->batch().ticks.back().mutations.size() == 1 &&
|
|
match_cellular_mutation_actions_to_trace(**revision_owner, late_builder->batch(),
|
|
late_builder->mutation_actions()));
|
|
const auto late_replay = replay_cellular_batch(**revision_owner, late_builder->batch());
|
|
CHECK(late_replay && (*late_replay)->snapshot() == late_builder->candidate().snapshot());
|
|
|
|
// A choice whose life has ended binds as life_died and changes nothing.
|
|
auto departed_builder = CellularSessionBatchBuilder::create(**revision_owner, head);
|
|
CHECK(departed_builder);
|
|
auto departed = reservation;
|
|
const auto gone = life_id + 1'000;
|
|
for (std::size_t i = 0; i < 8; ++i)
|
|
departed.input[8 + i] = static_cast<std::uint8_t>(gone >> (i * 8U));
|
|
const std::array departed_reservations{departed};
|
|
CHECK(departed_builder->append(action_tick, baseline, {}, {}, departed_reservations));
|
|
CHECK(departed_builder->mutation_actions().size() == 1 &&
|
|
departed_builder->mutation_actions().front().input.life_id == gone &&
|
|
match_cellular_mutation_actions_to_trace(**revision_owner, departed_builder->batch(),
|
|
departed_builder->mutation_actions()));
|
|
std::vector<CellularMutationOutcome> departed_outcomes;
|
|
const auto departed_replay =
|
|
replay_cellular_batch(**revision_owner, departed_builder->batch(), departed_outcomes);
|
|
CHECK(departed_replay &&
|
|
(*departed_replay)->snapshot() == departed_builder->candidate().snapshot() &&
|
|
departed_outcomes.size() == 1 && departed_outcomes.front().life_id == gone &&
|
|
departed_outcomes.front().result == CellularMutationResult::life_died &&
|
|
(*departed_replay)->lives()[0].mutation.offer.has_value());
|
|
}
|
|
|
|
void builder_batches_reserved_birth_after_empty_tick() {
|
|
auto primitive = PrimitiveLives::create({93, 1, 1, 17, founder_price(1), {{0, 0}}});
|
|
CHECK(primitive);
|
|
auto habitat = biology::CellularHabitat::create({93, 1, 1, 1'000, 1'000, {}});
|
|
CHECK(habitat);
|
|
auto state =
|
|
CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 0, 293'150});
|
|
CHECK(state && (*state)->lives().empty());
|
|
persistence::RegionHead head{};
|
|
head.frame = 1;
|
|
head.commit.fill(1);
|
|
head.digest.fill(2);
|
|
auto builder = CellularSessionBatchBuilder::create(**state, head);
|
|
CHECK(builder);
|
|
|
|
CellularTickIntents::Birth birth{};
|
|
birth.account.back() = 8;
|
|
birth.request = 13;
|
|
birth.generation = 4;
|
|
birth.identity = 901;
|
|
const std::array births{birth};
|
|
const std::span<const CellularLifeIntent> no_lives{};
|
|
CHECK(builder->append(1, no_lives, {}, births));
|
|
CHECK(builder->candidate().tick() == 1 && builder->candidate().lives().size() == 1 &&
|
|
builder->batch().ticks[0].births == std::vector{birth} && (*state)->lives().empty());
|
|
const auto replayed = replay_cellular_batch(**state, builder->batch());
|
|
CHECK(replayed && (*replayed)->snapshot() == builder->candidate().snapshot());
|
|
const auto snapshot = builder->candidate().snapshot();
|
|
const std::array next_lives{CellularLifeIntent{901, {}}};
|
|
CHECK(builder->append(2, next_lives, {}, births).error() ==
|
|
CellularSessionBatchError::duplicate_birth);
|
|
CHECK(builder->candidate().snapshot() == snapshot && builder->batch().ticks.size() == 1);
|
|
}
|
|
void unavailable_birth_does_not_freeze_the_tick() {
|
|
for (const bool funded : {false, true}) {
|
|
auto primitive =
|
|
PrimitiveLives::create({94, 1, 1, 17, founder_price(funded ? 2 : 1), {{0, 0}}});
|
|
CHECK(primitive);
|
|
LifeRequest request{};
|
|
request.account.back() = 1;
|
|
request.action = 1;
|
|
CHECK((*primitive)->spawn(request, {101, 101, 101, 101, {1}}));
|
|
auto habitat = biology::CellularHabitat::create({94, 1, 1, 1000, 1000, {}});
|
|
CHECK(habitat);
|
|
auto state =
|
|
CellularLives::create(**primitive, std::move(*habitat), {{1000, 1000}, 1, 293150});
|
|
CHECK(state);
|
|
persistence::RegionHead head{};
|
|
head.frame = 1;
|
|
head.end_tick = 1;
|
|
head.commit.fill(1);
|
|
head.digest.fill(2);
|
|
CellularTickIntents::Birth birth{};
|
|
birth.account.back() = 2;
|
|
birth.request = 1;
|
|
birth.generation = 1;
|
|
birth.identity = 102;
|
|
const std::array births{birth};
|
|
// Movement vacates the nursery in the underfunded case, isolating each refusal.
|
|
const std::array baseline{
|
|
CellularLifeIntent{101, {{static_cast<std::int16_t>(funded ? 0 : 1000), 0}, {}}}};
|
|
// A founder moves only a few um per tick: first move it fully away from the site.
|
|
if (!funded) {
|
|
for (int i = 0; i < 100; ++i)
|
|
CHECK((*state)->advance_tick(baseline));
|
|
head.end_tick = (*state)->tick();
|
|
}
|
|
auto strict = CellularSessionBatchBuilder::create(**state, head);
|
|
CHECK(strict);
|
|
CHECK(strict->append(head.end_tick + 1, baseline, {}, births).error() ==
|
|
CellularSessionBatchError::invalid_birth);
|
|
CHECK(strict->candidate().tick() == head.end_tick);
|
|
auto builder = CellularSessionBatchBuilder::create(**state, head);
|
|
CHECK(builder &&
|
|
builder->append_with_birth_refusals(head.end_tick + 1, baseline, {}, births));
|
|
CHECK(builder->refused_births().size() == 1 && builder->refused_births()[0].birth == birth);
|
|
CHECK(
|
|
builder->refused_births()[0].reason ==
|
|
(funded ? CellularLivesError::no_placement : CellularLivesError::insufficient_funding));
|
|
CHECK(builder->candidate().tick() == head.end_tick + 1 &&
|
|
builder->candidate().lives().size() == 1);
|
|
CHECK(builder->batch().ticks.back().births.empty());
|
|
const auto replay = replay_cellular_batch(**state, builder->batch());
|
|
CHECK(replay && (*replay)->snapshot() == builder->candidate().snapshot());
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
int main() try {
|
|
actions_bind_to_owned_life_and_preserve_other_inputs();
|
|
durable_mutation_reservations_bind_to_the_exact_offer();
|
|
builder_batches_reserved_birth_after_empty_tick();
|
|
unavailable_birth_does_not_freeze_the_tick();
|
|
std::puts("cellular session batch: ok");
|
|
} catch (const std::exception& e) {
|
|
std::fprintf(stderr, "%s\n", e.what());
|
|
return 1;
|
|
}
|