#include "evo/biology/lineage.hpp" #include #include #include #include #include #include #include #include #include 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(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{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{1, 2, 4})); const auto kids = archive.children(2); CHECK(kids && (*kids == std::vector{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{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, 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(LineageStatus::living) != static_cast(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 concept erases = requires(Archive& archive, std::uint64_t id) { archive.erase(id); }; template concept removes = requires(Archive& archive, std::uint64_t id) { archive.remove(id); }; template concept clears = requires(Archive& archive) { archive.clear(); }; template 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 concept replaceable = requires(Archive& archive) { archive = Archive{}; }; template concept exchangeable = requires(Archive& left, Archive& right) { std::swap(left, right); }; void the_archive_cannot_be_replaced_or_rewound() { static_assert(!replaceable); static_assert(!exchangeable); static_assert(!std::is_copy_assignable_v); static_assert(!std::is_move_assignable_v); // These checks are live: an ordinary container admits all of them. static_assert(replaceable>); static_assert(exchangeable>); // Copying stays available, because a clone takes nothing from the original. static_assert(std::is_copy_constructible_v); 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); static_assert(!removes); static_assert(!clears); static_assert(!prunes); // The check itself is live: a container that does erase by key is detected. static_assert(erases>); static_assert(clears>); 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); } } // 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(); std::cout << "PASS lineage retention, branching ancestry and provisional absence\n"; return 0; } catch (...) { return 1; }