#include "evo/biology/lineage.hpp" #include "evo/ecology/cohort.hpp" #include #include #include #include #include #include #include #include #include namespace { using namespace evo::ecology; using namespace evo::accounting; using evo::Tick; void check(bool condition, std::source_location location = std::source_location::current()) { if (!condition) { throw std::runtime_error("cohort line " + std::to_string(location.line())); } } // Variadic so a braced initializer containing a comma stays one argument. #define CHECK(...) check(static_cast(__VA_ARGS__)) // Asserting on .error() alone is undefined when the call unexpectedly succeeded, // which would let a broken guard pass quietly. This checks the failure first. template [[nodiscard]] bool refused(const std::expected& result, CohortError expected) { return !result.has_value() && result.error() == expected; } Inventory held(std::uint64_t value) { return {{value}, {Femtograms{value}, Femtograms{value}, Femtograms{value}, Femtograms{value}}}; } CohortDraft draft() { CohortDraft source; source.representation_version = cohort_representation_version; source.habitat = {7}; source.genome = 3; source.owner = {11, 2}; source.last_tick = Tick{900}; source.conversion = 5; source.classes = {{0, 100, 40, held(400), 0}, {100, 200, 25, held(900), 250'000}, {200, 300, 10, held(1'000), 999'999}}; source.bound = {2, held(30)}; return source; } Cohort valid() { const auto cohort = Cohort::create(draft()); check(cohort.has_value()); return *cohort; } Cohort built(const CohortDraft& source) { const auto cohort = Cohort::create(source); check(cohort.has_value()); return *cohort; } void a_cohort_keeps_exactly_what_it_was_given() { const auto cohort = valid(); CHECK(cohort.representation_version() == cohort_representation_version); CHECK(cohort.habitat() == HabitatId{7}); CHECK(cohort.genome() == 3); CHECK(cohort.owner() == Owner{11, 2}); CHECK(cohort.last_tick() == Tick{900}); CHECK(cohort.conversion() == 5); CHECK(cohort.bound().count == 2); CHECK(cohort.bound().inventory == held(30)); CHECK(cohort.classes().size() == 3); // Totals are derived from the classes, so they cannot disagree with them. CHECK(cohort.count() == 75); CHECK(cohort.reserve() == held(2'300)); CHECK(cohort.residual() == 1'249'999); std::uint64_t counted = 0; Inventory reserved{}; for (const auto& age : cohort.classes()) { counted += age.count; reserved.energy.value += age.reserve.energy.value; for (std::size_t channel = 0; channel < reserved.matter.size(); ++channel) { reserved.matter[channel].value += age.reserve.matter[channel].value; } } CHECK(counted == cohort.count()); CHECK(reserved == cohort.reserve()); // Summed across classes the residual may exceed a member; the per-class bound // is what is invariant, and a fraction is never counted as a member. CHECK(cohort.residual() > residual_scale); CHECK(cohort.count() == 75); } void the_record_keeps_a_distribution_and_not_an_average() { // Two cohorts with identical totals but different structure: one where every // member is provisioned and one where a young class holds nothing at all. A // record storing a count and a mean reserve could not tell these apart, which // is exactly how an average hides whether anyone would survive. auto spread = draft(); spread.classes = {{0, 100, 50, held(500), 0}, {100, 200, 50, held(500), 0}}; auto skewed = draft(); skewed.classes = {{0, 100, 50, held(0), 0}, {100, 200, 50, held(1'000), 0}}; const auto even = built(spread); const auto uneven = built(skewed); CHECK(even.count() == uneven.count()); CHECK(even.reserve() == uneven.reserve()); CHECK(even != uneven); // The totals agree; the records do not. CHECK(even.classes()[0].reserve != uneven.classes()[0].reserve); // A class with members but no reserve is a legitimate state, not an error: // it is precisely the outlier an average would have dissolved. CHECK(uneven.classes()[0].count == 50); CHECK(uneven.classes()[0].reserve == Inventory{}); } void every_invariant_is_rejected_by_name() { auto wrong_version = draft(); wrong_version.representation_version = cohort_representation_version + 1; CHECK(refused(Cohort::create(wrong_version), CohortError::unsupported_version)); // Each identity a cohort names has to name something, including its owner: // a record nobody is responsible for integrating has no owner at all. for (auto missing : {0U, 1U, 2U, 3U, 4U}) { auto blank = draft(); if (missing == 0) { blank.habitat = {}; } else if (missing == 1) { blank.genome = 0; } else if (missing == 2) { blank.owner.worker = 0; } else if (missing == 3) { blank.owner.epoch = 0; } else { blank.conversion = 0; } CHECK(refused(Cohort::create(blank), CohortError::invalid_identity)); } auto none = draft(); none.classes.clear(); CHECK(refused(Cohort::create(none), CohortError::no_age_classes)); auto too_many = draft(); too_many.classes.clear(); for (std::uint64_t index = 0; index <= max_age_classes; ++index) { too_many.classes.push_back({index * 10, index * 10 + 10, 1, held(1), 0}); } CHECK(refused(Cohort::create(too_many), CohortError::overflow)); // An empty range makes a member's class impossible, an inverted one likewise, // and an overlap or a descending order makes it ambiguous. auto empty_range = draft(); empty_range.classes[1].age_high = empty_range.classes[1].age_low; CHECK(refused(Cohort::create(empty_range), CohortError::unordered_age_classes)); auto inverted = draft(); inverted.classes[1].age_high = inverted.classes[1].age_low - 1; CHECK(refused(Cohort::create(inverted), CohortError::unordered_age_classes)); auto overlapping = draft(); overlapping.classes[1].age_low = overlapping.classes[0].age_high - 1; CHECK(refused(Cohort::create(overlapping), CohortError::unordered_age_classes)); auto descending = draft(); std::swap(descending.classes[0], descending.classes[2]); CHECK(refused(Cohort::create(descending), CohortError::unordered_age_classes)); // A class with neither members nor a fraction owed is a boundary, not a class. auto hollow = draft(); hollow.classes[1].count = 0; hollow.classes[1].residual = 0; hollow.classes[1].reserve = {}; CHECK(refused(Cohort::create(hollow), CohortError::empty_age_class)); // Reserve belongs to members; with none it would be biomass owned by nobody. auto orphaned = draft(); orphaned.classes[1].count = 0; orphaned.classes[1].residual = 1; CHECK(refused(Cohort::create(orphaned), CohortError::unowned_reserve)); // A class owed a fraction and holding nothing is valid: nothing is unowned. auto owed = draft(); owed.classes[1].count = 0; owed.classes[1].residual = 1; owed.classes[1].reserve = {}; CHECK(Cohort::create(owed).has_value()); // At a whole member a fraction is a member, so the bound is strict. auto whole = draft(); whole.classes[1].residual = residual_scale; CHECK(refused(Cohort::create(whole), CohortError::residual_out_of_range)); auto just_under = draft(); just_under.classes[1].residual = residual_scale - 1; CHECK(Cohort::create(just_under).has_value()); // Summation rejects rather than wrapping, on counts and on every channel. constexpr auto most = std::numeric_limits::max(); auto counts = draft(); counts.classes[0].count = most; counts.classes[1].count = 1; CHECK(refused(Cohort::create(counts), CohortError::overflow)); auto energy = draft(); energy.classes[0].reserve.energy.value = most; energy.classes[1].reserve.energy.value = 1; CHECK(refused(Cohort::create(energy), CohortError::overflow)); for (std::size_t channel = 0; channel < 4; ++channel) { auto matter = draft(); matter.classes[0].reserve.matter[channel].value = most; matter.classes[1].reserve.matter[channel].value = 1; CHECK(refused(Cohort::create(matter), CohortError::overflow)); } // No negative reserve is representable, because every quantity here is // unsigned. What is rejected is a declared state that would require one. static_assert(!std::is_signed_v); static_assert(!std::is_signed_v); static_assert(!std::is_signed_v); } void one_habitat_and_genome_holds_one_cohort() { CohortRegistry registry; CHECK(registry.install(valid()).has_value()); CHECK(registry.size() == 1); // A second record of the same genome in the same habitat would be a second // place the same biomass could be spent, whoever claims to own it. CHECK(refused(registry.install(valid()), CohortError::duplicate_cohort)); auto differing_owner = draft(); differing_owner.owner = {99, 4}; CHECK(refused(registry.install(built(differing_owner)), CohortError::duplicate_cohort)); CHECK(registry.size() == 1); // Another genome, or the same genome elsewhere, is a different record. auto other_genome = draft(); other_genome.genome = 4; auto other_habitat = draft(); other_habitat.habitat = {8}; CHECK(registry.install(built(other_genome)).has_value()); CHECK(registry.install(built(other_habitat)).has_value()); CHECK(registry.size() == 3); // Every record stays findable whatever order they arrived in. CHECK(registry.find(HabitatId{7}, 3)->owner() == Owner{11, 2}); CHECK(registry.find(HabitatId{7}, 4)->genome() == 4); CHECK(registry.find(HabitatId{8}, 3)->habitat() == HabitatId{8}); CHECK(refused(registry.find(HabitatId{7}, 5), CohortError::unknown_cohort)); CHECK(refused(registry.find(HabitatId{9}, 3), CohortError::unknown_cohort)); } void only_the_recorded_owner_may_replace_a_cohort() { CohortRegistry registry; CHECK(registry.install(valid()).has_value()); // A different worker is refused however current its epoch. auto intruder = draft(); intruder.owner = {12, 99}; CHECK(refused(registry.replace(built(intruder)), CohortError::wrong_owner)); // A writer holding an older view of its own cohort is refused too. auto stale = draft(); stale.owner = {11, 1}; CHECK(refused(registry.replace(built(stale)), CohortError::stale_epoch)); CHECK(registry.find(HabitatId{7}, 3)->last_tick() == Tick{900}); // The owner rewriting its own epoch, or advancing it, succeeds. auto same = draft(); same.last_tick = Tick{1'000}; CHECK(registry.replace(built(same)).has_value()); CHECK(registry.find(HabitatId{7}, 3)->last_tick() == Tick{1'000}); auto advanced = draft(); advanced.owner = {11, 3}; advanced.last_tick = Tick{1'100}; CHECK(registry.replace(built(advanced)).has_value()); CHECK(registry.find(HabitatId{7}, 3)->owner() == Owner{11, 3}); // Having advanced, the previously current epoch is now the stale one. CHECK(refused(registry.replace(built(same)), CohortError::stale_epoch)); CHECK(registry.find(HabitatId{7}, 3)->last_tick() == Tick{1'100}); // A record naming a different habitat or genome is not a newer view of this // one, and replacing a cohort never installed is refused outright. auto elsewhere = draft(); elsewhere.habitat = {8}; CHECK(refused(registry.replace(built(elsewhere)), CohortError::unknown_cohort)); auto another = draft(); another.genome = 4; CHECK(refused(registry.replace(built(another)), CohortError::unknown_cohort)); CHECK(registry.size() == 1); // A refused replacement installs nothing. } void lineage_stays_the_archives_answer() { // A cohort names a genome and never stores its ancestry, so it cannot claim a // parentage the archive would contradict, and invents none from membership. using namespace evo::biology; GenomeDraft founder; founder.id = 3; founder.origin_event = 1; founder.development_version = 1; founder.capabilities = {{Capability::energy_conversion, 400, 0}, {Capability::membrane, 120, 0}, {Capability::target_size, 2'000, 0}}; const auto ancestor = Genome::create(founder); CHECK(ancestor.has_value()); auto descended = founder; descended.id = 9; descended.origin_event = 2; descended.parents = {3}; const auto child = Genome::create(descended); CHECK(child.has_value()); LineageArchive archive; CHECK(archive.admit(*ancestor).has_value()); CHECK(archive.admit(*child).has_value()); auto carrying = draft(); carrying.genome = 9; const auto cohort = built(carrying); // The cohort contributes the identity; the archive contributes the ancestry. const auto line = archive.ancestry(cohort.genome()); CHECK(line.has_value()); CHECK(line->size() == 2); CHECK(line->front() == 3); CHECK(line->back() == 9); CHECK(archive.find(cohort.genome()).has_value()); // Distinct genomes are never averaged into one, so each keeps its own record. CohortRegistry registry; CHECK(registry.install(cohort).has_value()); auto sibling = draft(); sibling.genome = 3; CHECK(registry.install(built(sibling)).has_value()); CHECK(registry.size() == 2); CHECK(registry.find(HabitatId{7}, 3)->genome() != registry.find(HabitatId{7}, 9)->genome()); } } // namespace int main() try { a_cohort_keeps_exactly_what_it_was_given(); the_record_keeps_a_distribution_and_not_an_average(); every_invariant_is_rejected_by_name(); one_habitat_and_genome_holds_one_cohort(); only_the_recorded_owner_may_replace_a_cohort(); lineage_stays_the_archives_answer(); std::cout << "PASS cohort state, declared resolution and exclusive ownership\n"; return 0; } catch (...) { return 1; }