Files
aevolution/tests/lineage_tests.cpp
T
dingoandClaude Opus 5 fdaed3e4f5 Use unsigned literals where the element type is unsigned
A bare {1, 2, 3, 4, 5} deduces initializer_list<int>, and the
sign-changing conversion to each std::uint64_t element trips Clang's
-Wconversion under -Werror, failing the Linux analysis build.

MSVC /W4 /WX does not diagnose this, and GCC's -Wconversion does not warn
when a constant value is known to fit, so the local checks and the GCC
Release job both passed. Only Clang caught it.

Reproducing Clang's diagnostic locally was not possible: clang-tidy does
not honour the warning flags in its cl driver mode and no clang driver is
installed on this host. The tree was audited by hand for the pattern
instead. Every other range-for over a braced literal list either deduces
through auto or already carries suffixes matching its declared type, so
this was the only instance. That audit catches this one, not the next
one, and the standing gap is recorded in the validation report: no Clang
or GCC compile happens here before a push.

Native Release, clang-tidy analysis and format checks pass 21/21.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-23 20:42:21 -04:00

271 lines
13 KiB
C++

#include "evo/biology/lineage.hpp"
#include <algorithm>
#include <iostream>
#include <map>
#include <source_location>
#include <stdexcept>
#include <string>
#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);
}
} // 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;
}