ADR-0062 adds a canonical LineageArchive codec (parents before children, organisms by id, FNV) that decodes by replaying admit/record_birth/ record_death and requires byte-identical re-encoding; it never overwrites an existing archive. LineageRegion binds the environmental producer and consumer accounts to archived organisms with identity high-waters, enforces closure (lifecycle vs deaths, exact living set, tick bounds) and records deaths in the tick that causes them. Checkpoint profile 2 (environmental-lineage-v1, history profile 1) publishes that container; schema v4 admits it with a 4,268,144-byte cap and requires each commit to keep its predecessor's profile, RNG, history and durability declarations. Linux adds provision/publish/recover for the profile on the shared publication path. Qualification found WSL2 stepping CLOCK_REALTIME back ~0.5 s every ~32 s, which made two 1 s-lease tests flaky under ASan. Tests now wait on database-time expiry; ADR-0060 records the slewed-clock requirement. Validated: Windows CTest 57/57; Linux GCC Debug/Release, clang-tidy and ASan/UBSan CTest 57/57 each; PostgreSQL suites 2x Release, 2x analysis, 5x ASan; SQL and C++ mutations each caught. No Docker/Gitea CI, remote store, process kill or deployment. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
419 lines
20 KiB
C++
419 lines
20 KiB
C++
#include "evo/biology/lineage.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <iostream>
|
|
#include <map>
|
|
#include <source_location>
|
|
#include <span>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <tuple>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
namespace {
|
|
using namespace evo::biology;
|
|
void check(bool condition, std::source_location location = std::source_location::current()) {
|
|
if (!condition) {
|
|
throw std::runtime_error("lineage line " + std::to_string(location.line()));
|
|
}
|
|
}
|
|
#define CHECK(expression) check(static_cast<bool>(expression))
|
|
Genome descend(std::uint64_t id, std::uint64_t parent, std::uint32_t conversion = 400) {
|
|
GenomeDraft source;
|
|
source.id = id;
|
|
source.origin_event = id;
|
|
source.development_version = 1;
|
|
if (parent != 0) {
|
|
source.parents = {parent};
|
|
}
|
|
source.capabilities = {{Capability::energy_conversion, conversion, 0},
|
|
{Capability::membrane, 120, 0},
|
|
{Capability::target_size, 8'000'000, 0}};
|
|
const auto genome = Genome::create(source);
|
|
check(genome.has_value());
|
|
return *genome;
|
|
}
|
|
// A founder with two branches, one of which branches again:
|
|
// 1 -> 2 -> 4, 5
|
|
// -> 3
|
|
LineageArchive branching() {
|
|
LineageArchive archive;
|
|
check(archive.admit(descend(1, 0, 400)).has_value());
|
|
check(archive.admit(descend(2, 1, 409)).has_value());
|
|
check(archive.admit(descend(3, 1, 391)).has_value());
|
|
check(archive.admit(descend(4, 2, 418)).has_value());
|
|
check(archive.admit(descend(5, 2, 400)).has_value());
|
|
return archive;
|
|
}
|
|
|
|
void a_genome_outlives_every_organism_that_carried_it() {
|
|
auto archive = branching();
|
|
CHECK(archive.record_birth(100, 4, evo::Tick{10}));
|
|
CHECK(archive.record_birth(101, 4, evo::Tick{12}));
|
|
CHECK(archive.living_carriers(4) && *archive.living_carriers(4) == 2);
|
|
CHECK(*archive.status(4) == LineageStatus::living);
|
|
CHECK(archive.record_death(100, evo::Tick{30}));
|
|
CHECK(*archive.living_carriers(4) == 1 && *archive.status(4) == LineageStatus::living);
|
|
CHECK(archive.record_death(101, evo::Tick{31}));
|
|
// No organism carries it now. Everything about the genome is still here.
|
|
CHECK(*archive.living_carriers(4) == 0);
|
|
CHECK(*archive.status(4) == LineageStatus::absent);
|
|
const auto kept = archive.find(4);
|
|
CHECK(kept && kept->id() == 4 && kept->parents()[0] == 2);
|
|
CHECK(*kept == descend(4, 2, 418));
|
|
const auto line = archive.ancestry(4);
|
|
CHECK(line && (*line == std::vector<std::uint64_t>{1, 2, 4}));
|
|
CHECK(archive.children(2) && archive.children(2)->size() == 2);
|
|
// The organisms themselves are still on record, with their terminal ticks.
|
|
const auto first = archive.organism(100);
|
|
CHECK(first && !first->alive && first->genome == 4);
|
|
CHECK(first->born.value == 10 && first->died.value == 30);
|
|
}
|
|
|
|
void ancestry_and_descendants_resolve_through_a_dead_middle() {
|
|
auto archive = branching();
|
|
// Every carrier of the middle genome dies; its children are untouched.
|
|
CHECK(archive.record_birth(200, 2, evo::Tick{5}));
|
|
CHECK(archive.record_birth(201, 4, evo::Tick{6}));
|
|
CHECK(archive.record_death(200, evo::Tick{20}));
|
|
CHECK(*archive.status(2) == LineageStatus::absent);
|
|
CHECK(*archive.status(4) == LineageStatus::living);
|
|
const auto through = archive.ancestry(4);
|
|
CHECK(through && (*through == std::vector<std::uint64_t>{1, 2, 4}));
|
|
const auto kids = archive.children(2);
|
|
CHECK(kids && (*kids == std::vector<std::uint64_t>{4, 5}));
|
|
// The founder has no living carrier either, and is equally intact.
|
|
CHECK(*archive.status(1) == LineageStatus::absent);
|
|
CHECK(archive.find(1) && archive.find(1)->parents().empty());
|
|
CHECK(archive.ancestry(1) && archive.ancestry(1)->size() == 1);
|
|
}
|
|
|
|
void branching_lineages_resolve_their_divergence() {
|
|
auto archive = branching();
|
|
CHECK(archive.common_ancestor(4, 5) && *archive.common_ancestor(4, 5) == 2);
|
|
CHECK(*archive.common_ancestor(4, 3) == 1);
|
|
CHECK(*archive.common_ancestor(2, 3) == 1);
|
|
CHECK(*archive.common_ancestor(4, 2) == 2); // An ancestor of itself.
|
|
CHECK(*archive.common_ancestor(4, 4) == 4);
|
|
CHECK(*archive.common_ancestor(1, 5) == 1);
|
|
// A separate founder shares nothing.
|
|
CHECK(archive.admit(descend(9, 0, 500)));
|
|
CHECK(archive.common_ancestor(4, 9) && *archive.common_ancestor(4, 9) == 0);
|
|
const auto unknown = archive.common_ancestor(4, 77);
|
|
CHECK(!unknown && unknown.error() == HistoryError::unknown_genome);
|
|
}
|
|
|
|
void admission_refuses_duplicates_and_dangling_parents() {
|
|
LineageArchive archive;
|
|
CHECK(archive.admit(descend(1, 0)));
|
|
// Re-admitting an ID would destroy the earlier record.
|
|
const auto repeated = archive.admit(descend(1, 0, 500));
|
|
CHECK(!repeated && repeated.error() == HistoryError::duplicate_genome);
|
|
CHECK(archive.find(1) && archive.find(1)->content_digest() == descend(1, 0).content_digest());
|
|
// A child before its parent would leave ancestry dangling, and would be the
|
|
// only way to build a cycle.
|
|
const auto orphan = archive.admit(descend(5, 4));
|
|
CHECK(!orphan && orphan.error() == HistoryError::unknown_parent);
|
|
CHECK(archive.archived() == 1);
|
|
const auto missing = archive.ancestry(4);
|
|
CHECK(!missing && missing.error() == HistoryError::unknown_genome);
|
|
// Admitting in order is fine, and the graph stays acyclic by that order.
|
|
CHECK(archive.admit(descend(4, 1)));
|
|
CHECK(archive.admit(descend(5, 4)));
|
|
CHECK(archive.ancestry(5) && (*archive.ancestry(5) == std::vector<std::uint64_t>{1, 4, 5}));
|
|
}
|
|
|
|
void death_is_terminal_and_births_are_unique() {
|
|
auto archive = branching();
|
|
const auto nobody = archive.record_death(500, evo::Tick{1});
|
|
CHECK(!nobody && nobody.error() == HistoryError::unknown_organism);
|
|
const auto nowhere = archive.record_birth(300, 77, evo::Tick{1});
|
|
CHECK(!nowhere && nowhere.error() == HistoryError::unknown_genome);
|
|
const auto anonymous = archive.record_birth(0, 1, evo::Tick{1});
|
|
CHECK(!anonymous && anonymous.error() == HistoryError::invalid_identity);
|
|
CHECK(archive.record_birth(300, 3, evo::Tick{8}));
|
|
// An identity is never reused, whether its holder lives or not.
|
|
const auto twice = archive.record_birth(300, 5, evo::Tick{9});
|
|
CHECK(!twice && twice.error() == HistoryError::duplicate_organism);
|
|
const auto backwards = archive.record_death(300, evo::Tick{7});
|
|
CHECK(!backwards && backwards.error() == HistoryError::invalid_tick);
|
|
CHECK(archive.record_death(300, evo::Tick{40}));
|
|
const auto again = archive.record_death(300, evo::Tick{41});
|
|
CHECK(!again && again.error() == HistoryError::already_dead);
|
|
// Nothing brings it back, and its record keeps the first terminal tick.
|
|
const auto reborn = archive.record_birth(300, 3, evo::Tick{50});
|
|
CHECK(!reborn && reborn.error() == HistoryError::duplicate_organism);
|
|
const auto record = archive.organism(300);
|
|
CHECK(record && !record->alive && record->died.value == 40);
|
|
CHECK(*archive.status(3) == LineageStatus::absent);
|
|
}
|
|
|
|
void absence_is_never_reported_as_extinction() {
|
|
auto archive = branching();
|
|
// Nothing was ever born: every lineage is absent, and none is extinct.
|
|
// Unsigned literals: a bare list deduces initializer_list<int>, and the
|
|
// sign-changing conversion to each element fails Clang's -Wconversion.
|
|
for (const std::uint64_t genome : {1U, 2U, 3U, 4U, 5U}) {
|
|
CHECK(*archive.status(genome) == LineageStatus::absent);
|
|
CHECK(*archive.living_carriers(genome) == 0);
|
|
CHECK(archive.find(genome)); // Still retained regardless.
|
|
}
|
|
// The enumeration itself offers no way to say extinct.
|
|
CHECK(static_cast<int>(LineageStatus::living) != static_cast<int>(LineageStatus::absent));
|
|
// A lineage can return from absence: absence is about carriers, not the
|
|
// record, and the archive never claimed the lineage was finished.
|
|
CHECK(archive.record_birth(400, 5, evo::Tick{1}));
|
|
CHECK(*archive.status(5) == LineageStatus::living);
|
|
CHECK(archive.record_death(400, evo::Tick{2}));
|
|
CHECK(*archive.status(5) == LineageStatus::absent);
|
|
CHECK(archive.record_birth(401, 5, evo::Tick{3}));
|
|
CHECK(*archive.status(5) == LineageStatus::living);
|
|
}
|
|
|
|
// Retention is a property of the interface: the type offers no removal
|
|
// operation, so no caller can choose to delete a record. Written as concepts
|
|
// rather than bare requires-expressions so the check is a substitution failure
|
|
// instead of a hard error.
|
|
template <typename Archive>
|
|
concept erases = requires(Archive& archive, std::uint64_t id) { archive.erase(id); };
|
|
template <typename Archive>
|
|
concept removes = requires(Archive& archive, std::uint64_t id) { archive.remove(id); };
|
|
template <typename Archive>
|
|
concept clears = requires(Archive& archive) { archive.clear(); };
|
|
template <typename Archive>
|
|
concept prunes = requires(Archive& archive) { archive.prune(); };
|
|
// Forgetting has forms that are not named like removal. Replacing an archive
|
|
// wholesale discards every record it held, and swapping needs the same
|
|
// assignment that makes replacement possible.
|
|
template <typename Archive>
|
|
concept replaceable = requires(Archive& archive) { archive = Archive{}; };
|
|
template <typename Archive>
|
|
concept exchangeable = requires(Archive& left, Archive& right) { std::swap(left, right); };
|
|
|
|
void the_archive_cannot_be_replaced_or_rewound() {
|
|
static_assert(!replaceable<LineageArchive>);
|
|
static_assert(!exchangeable<LineageArchive>);
|
|
static_assert(!std::is_copy_assignable_v<LineageArchive>);
|
|
static_assert(!std::is_move_assignable_v<LineageArchive>);
|
|
// These checks are live: an ordinary container admits all of them.
|
|
static_assert(replaceable<std::vector<std::uint64_t>>);
|
|
static_assert(exchangeable<std::vector<std::uint64_t>>);
|
|
// Copying stays available, because a clone takes nothing from the original.
|
|
static_assert(std::is_copy_constructible_v<LineageArchive>);
|
|
auto archive = branching();
|
|
CHECK(archive.record_birth(800, 3, evo::Tick{1}));
|
|
const auto taken_while_living = archive; // A copy from before the death.
|
|
CHECK(archive.record_death(800, evo::Tick{9}));
|
|
CHECK(!archive.organism(800)->alive);
|
|
// The copy is a separate archive. Nothing can write it back over the
|
|
// original, so the terminal record stands.
|
|
CHECK(taken_while_living.organism(800)->alive);
|
|
CHECK(!archive.organism(800)->alive);
|
|
// A move decays to a copy, so the source still holds every record rather
|
|
// than being emptied the way a moved-from container would be.
|
|
// NOLINTNEXTLINE(performance-move-const-arg)
|
|
const auto moved = std::move(archive);
|
|
// NOLINTNEXTLINE(bugprone-use-after-move): the point of the check.
|
|
CHECK(archive.archived() == moved.archived() && archive.recorded() == 1);
|
|
// NOLINTNEXTLINE(bugprone-use-after-move)
|
|
CHECK(archive.find(1) && !archive.organism(800)->alive);
|
|
}
|
|
|
|
void the_archive_offers_no_way_to_forget() {
|
|
static_assert(!erases<LineageArchive>);
|
|
static_assert(!removes<LineageArchive>);
|
|
static_assert(!clears<LineageArchive>);
|
|
static_assert(!prunes<LineageArchive>);
|
|
// The check itself is live: a container that does erase by key is detected.
|
|
static_assert(erases<std::map<std::uint64_t, std::uint64_t>>);
|
|
static_assert(clears<std::map<std::uint64_t, std::uint64_t>>);
|
|
auto archive = branching();
|
|
const auto before = archive.archived();
|
|
CHECK(archive.record_birth(700, 1, evo::Tick{1}));
|
|
CHECK(archive.record_death(700, evo::Tick{2}));
|
|
// Death changed nothing about how much is retained.
|
|
CHECK(archive.archived() == before && archive.recorded() == 1);
|
|
}
|
|
|
|
void capacity_refuses_loudly_rather_than_dropping() {
|
|
LineageArchive archive;
|
|
CHECK(archive.admit(descend(1, 0)));
|
|
for (std::uint64_t id = 2; id <= max_archived_genomes; ++id) {
|
|
CHECK(archive.admit(descend(id, id - 1)));
|
|
}
|
|
CHECK(archive.archived() == max_archived_genomes);
|
|
const auto overflowing = archive.admit(descend(max_archived_genomes + 1, max_archived_genomes));
|
|
CHECK(!overflowing && overflowing.error() == HistoryError::archive_full);
|
|
// Refusing to record is not deleting: everything admitted is still here.
|
|
CHECK(archive.archived() == max_archived_genomes);
|
|
CHECK(archive.find(1) && archive.find(max_archived_genomes));
|
|
const auto deep = archive.ancestry(max_archived_genomes);
|
|
CHECK(deep && deep->size() == max_archived_genomes);
|
|
CHECK(deep->front() == 1 && deep->back() == max_archived_genomes);
|
|
CHECK(*archive.common_ancestor(max_archived_genomes, 1) == 1);
|
|
}
|
|
std::uint64_t field(const std::vector<std::uint8_t>& b, std::size_t at, unsigned width) {
|
|
std::uint64_t value{};
|
|
for (unsigned i = 0; i < width; ++i)
|
|
value |= static_cast<std::uint64_t>(b[at + i]) << (8U * i);
|
|
return value;
|
|
}
|
|
void set(std::vector<std::uint8_t>& b, std::size_t at, std::uint64_t value, unsigned width) {
|
|
for (unsigned i = 0; i < width; ++i)
|
|
b[at + i] = static_cast<std::uint8_t>((value >> (8U * i)) & 0xFFU);
|
|
}
|
|
// Recomputes the trailing FNV so a test reaches the check it is aimed at.
|
|
void reseal(std::vector<std::uint8_t>& b) {
|
|
std::uint64_t h = 14695981039346656037ULL;
|
|
for (std::size_t i = 0; i + 8 < b.size(); ++i)
|
|
h = (h ^ b[i]) * 1099511628211ULL;
|
|
set(b, b.size() - 8, h, 8);
|
|
}
|
|
LineageArchive with_history() {
|
|
auto archive = branching();
|
|
CHECK(archive.record_birth(100, 4, evo::Tick{10}));
|
|
CHECK(archive.record_birth(101, 5, evo::Tick{12}));
|
|
CHECK(archive.record_birth(90, 1, evo::Tick{0}));
|
|
CHECK(archive.record_death(90, evo::Tick{0}));
|
|
CHECK(archive.record_death(100, evo::Tick{30}));
|
|
return archive;
|
|
}
|
|
|
|
void the_archive_round_trips_canonically() {
|
|
const auto archive = with_history();
|
|
const auto bytes = archive.encode();
|
|
CHECK(field(bytes, 0, 8) == 0x3152414C4F564541ULL && field(bytes, 8, 4) == 1);
|
|
CHECK(field(bytes, 16, 4) == 5 && field(bytes, 20, 4) == 3 &&
|
|
field(bytes, 24, 8) == bytes.size());
|
|
const auto decoded = LineageArchive::decode(bytes);
|
|
CHECK(decoded && decoded->encode() == bytes);
|
|
CHECK(decoded->archived() == 5 && decoded->recorded() == 3);
|
|
CHECK(*decoded->find(4) == *archive.find(4));
|
|
const auto dead = decoded->organism(100);
|
|
CHECK(dead && !dead->alive && dead->died.value == 30 && dead->born.value == 10);
|
|
CHECK(decoded->ancestry(4) == archive.ancestry(4));
|
|
CHECK(decoded->living_organisms() == std::vector<std::uint64_t>{101});
|
|
CHECK(decoded->highest_genome() == 5 && decoded->highest_organism() == 101);
|
|
// A clone decodes into a new archive; the original is untouched.
|
|
CHECK(archive.recorded() == 3 && archive.encode() == bytes);
|
|
// Admission order does not change the bytes, only the content does.
|
|
LineageArchive reordered;
|
|
for (const auto& [id, parent, c] :
|
|
{std::tuple{1, 0, 400U}, std::tuple{3, 1, 391U}, std::tuple{2, 1, 409U},
|
|
std::tuple{5, 2, 400U}, std::tuple{4, 2, 418U}})
|
|
CHECK(reordered.admit(
|
|
descend(static_cast<std::uint64_t>(id), static_cast<std::uint64_t>(parent), c)));
|
|
CHECK(reordered.record_birth(90, 1, evo::Tick{0}));
|
|
CHECK(reordered.record_birth(101, 5, evo::Tick{12}));
|
|
CHECK(reordered.record_birth(100, 4, evo::Tick{10}));
|
|
CHECK(reordered.record_death(100, evo::Tick{30}));
|
|
CHECK(reordered.record_death(90, evo::Tick{0}));
|
|
CHECK(reordered.encode() == bytes);
|
|
// A child with a smaller identity than its parent still follows its parent.
|
|
LineageArchive inverted;
|
|
CHECK(inverted.admit(descend(50, 0)) && inverted.admit(descend(7, 50)));
|
|
const auto inverted_bytes = inverted.encode();
|
|
CHECK(LineageArchive::decode(inverted_bytes));
|
|
LineageArchive empty;
|
|
CHECK(LineageArchive::decode(empty.encode()) && empty.encode().size() == 40);
|
|
}
|
|
|
|
void the_archive_decoder_refuses_damage_and_disorder() {
|
|
const auto bytes = with_history().encode();
|
|
const auto refused = [&](auto change, ArchiveCodecError error, bool seal = true) {
|
|
auto b = bytes;
|
|
change(b);
|
|
if (seal)
|
|
reseal(b);
|
|
const auto d = LineageArchive::decode(b);
|
|
return !d && d.error() == error;
|
|
};
|
|
CHECK(refused([](auto& b) { b[40] ^= 1U; }, ArchiveCodecError::checksum, false));
|
|
CHECK(refused([](auto& b) { b[0] ^= 1U; }, ArchiveCodecError::format));
|
|
CHECK(refused([](auto& b) { b[8] = 2; }, ArchiveCodecError::version));
|
|
CHECK(refused([](auto& b) { b[12] = 2; }, ArchiveCodecError::version));
|
|
CHECK(refused([](auto& b) { set(b, 16, max_archived_genomes + 1, 4); },
|
|
ArchiveCodecError::bounds));
|
|
CHECK(refused([](auto& b) { set(b, 20, max_archived_organisms + 1, 4); },
|
|
ArchiveCodecError::bounds));
|
|
CHECK(refused([](auto& b) { set(b, 24, b.size() + 1, 8); }, ArchiveCodecError::format));
|
|
CHECK(refused(
|
|
[](auto& b) {
|
|
b.insert(b.end() - 8, 0);
|
|
set(b, 24, b.size(), 8);
|
|
},
|
|
ArchiveCodecError::format));
|
|
CHECK(refused([](auto& b) { set(b, 20, 2, 4); }, ArchiveCodecError::format));
|
|
// Genome body damage (its own digest), then an organism record naming no genome.
|
|
CHECK(refused([](auto& b) { b[40] ^= 1U; }, ArchiveCodecError::genome));
|
|
const auto organisms = bytes.size() - 8 - (3 * archived_organism_bytes);
|
|
CHECK(refused([&](auto& b) { set(b, organisms + 8, 77, 8); }, ArchiveCodecError::history));
|
|
CHECK(refused([&](auto& b) { b[organisms + 32] = 2; }, ArchiveCodecError::format));
|
|
// Alive with a death tick; death before birth; organisms out of order.
|
|
const auto alive = organisms + (2 * archived_organism_bytes); // Organism 101.
|
|
CHECK(refused([&](auto& b) { set(b, alive + 24, 5, 8); }, ArchiveCodecError::format));
|
|
const auto dead = organisms + archived_organism_bytes; // Organism 100.
|
|
CHECK(refused([&](auto& b) { set(b, dead + 24, 9, 8); }, ArchiveCodecError::history));
|
|
CHECK(refused(
|
|
[&](auto& b) {
|
|
std::swap_ranges(b.begin() + static_cast<std::ptrdiff_t>(organisms),
|
|
b.begin() + static_cast<std::ptrdiff_t>(organisms + 33),
|
|
b.begin() + static_cast<std::ptrdiff_t>(dead));
|
|
},
|
|
ArchiveCodecError::noncanonical));
|
|
// A child encoded before its parent is refused by admission itself.
|
|
LineageArchive pair;
|
|
CHECK(pair.admit(descend(1, 0)) && pair.admit(descend(2, 1)));
|
|
auto swapped = pair.encode();
|
|
const auto first = field(swapped, 32, 2);
|
|
std::vector<std::uint8_t> parent(swapped.begin() + 32,
|
|
swapped.begin() + 34 + static_cast<std::ptrdiff_t>(first));
|
|
std::vector<std::uint8_t> child(swapped.begin() + 34 + static_cast<std::ptrdiff_t>(first),
|
|
swapped.end() - 8);
|
|
std::ranges::copy(child, swapped.begin() + 32);
|
|
std::ranges::copy(parent, swapped.begin() + 32 + static_cast<std::ptrdiff_t>(child.size()));
|
|
reseal(swapped);
|
|
const auto dangling = LineageArchive::decode(swapped);
|
|
CHECK(!dangling && dangling.error() == ArchiveCodecError::history);
|
|
CHECK(!LineageArchive::decode(std::span{bytes}.first(39)));
|
|
}
|
|
|
|
void a_full_archive_round_trips() {
|
|
LineageArchive archive;
|
|
CHECK(archive.admit(descend(1, 0)));
|
|
for (std::uint64_t id = 2; id <= max_archived_genomes; ++id)
|
|
CHECK(archive.admit(descend(id, id - 1)));
|
|
for (std::uint64_t o = 1; o <= max_archived_organisms; ++o) {
|
|
CHECK(archive.record_birth(o, 1 + (o % max_archived_genomes), evo::Tick{o}));
|
|
if (o % 3 == 0)
|
|
CHECK(archive.record_death(o, evo::Tick{o + 1}));
|
|
}
|
|
const auto bytes = archive.encode();
|
|
CHECK(bytes.size() <= max_archive_bytes);
|
|
const auto decoded = LineageArchive::decode(bytes);
|
|
CHECK(decoded && decoded->encode() == bytes && decoded->recorded() == max_archived_organisms);
|
|
std::cout << "lineage_archive_full_bytes=" << bytes.size() << " max=" << max_archive_bytes
|
|
<< '\n';
|
|
}
|
|
} // namespace
|
|
int main() try {
|
|
a_genome_outlives_every_organism_that_carried_it();
|
|
ancestry_and_descendants_resolve_through_a_dead_middle();
|
|
branching_lineages_resolve_their_divergence();
|
|
admission_refuses_duplicates_and_dangling_parents();
|
|
death_is_terminal_and_births_are_unique();
|
|
absence_is_never_reported_as_extinction();
|
|
the_archive_cannot_be_replaced_or_rewound();
|
|
the_archive_offers_no_way_to_forget();
|
|
capacity_refuses_loudly_rather_than_dropping();
|
|
the_archive_round_trips_canonically();
|
|
the_archive_decoder_refuses_damage_and_disorder();
|
|
a_full_archive_round_trips();
|
|
std::cout << "PASS lineage retention, branching ancestry and provisional absence\n";
|
|
return 0;
|
|
} catch (...) {
|
|
return 1;
|
|
}
|