Files
aevolution/tests/lineage_tests.cpp
T
dingoandClaude Opus 5.5 a2c4543df2 Complete M7.4b lineage checkpoint profile; M7.4 done
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>
2026-09-28 16:43:10 -04:00

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;
}