#include "evo/world/fields.hpp" #include #include #include #include #include #include #include #include namespace { using namespace evo::world; constexpr WorldIdentity identity{7, 9}; constexpr std::size_t budget = 2'000'000; constexpr auto maximum = std::numeric_limits::max(); void check(bool ok, std::source_location at = std::source_location::current()) { if (!ok) throw std::runtime_error("world fields line " + std::to_string(at.line())); } #define CHECK(...) check(static_cast(__VA_ARGS__)) template bool refused(const std::expected& result, FieldError error) { return !result && result.error() == error; } std::vector sites(std::size_t count) { std::vector out(count); for (std::size_t i = 0; i < count; ++i) out[i] = {{static_cast(i), 0, -1}, {{0}, {0}, {0}, {10}, {20}, {3}}, {1}}; return out; } FieldDefaults defaults() { return {{evo::accounting::Femtograms{0}, evo::accounting::Femtograms{1000}, evo::accounting::Femtograms{2000}}}; } std::unique_ptr make(std::span mapping, std::span opening, std::size_t limit = budget) { auto out = FieldStore::create(identity, 11, defaults(), mapping, opening, limit); CHECK(out); return std::move(*out); } void put(WorldBytes& bytes, std::size_t offset, std::uint64_t value, unsigned width) { for (unsigned i = 0; i < width; ++i) { bytes.at(offset + i) = static_cast(value & 255U); value >>= 8U; } } void seal(WorldBytes& bytes) { put(bytes, 12, bytes.size(), 4); std::uint64_t h = 14695981039346656037ULL; for (std::size_t i = 0; i < bytes.size() - 8; ++i) h = (h ^ bytes[i]) * 1099511628211ULL; put(bytes, bytes.size() - 8, h, 8); } void storage_and_exhaustion() { const auto mapping = sites(130); const std::uint64_t zero = 0, seven = 7; auto absent = make(mapping, {}); const FieldOpening uniform[]{{Field::water, {&seven, 1}}, {Field::nitrogen, {&zero, 1}}}; auto compact = make(mapping, uniform); CHECK(absent->accounted_bytes() == compact->accounted_bytes()); CHECK(refused(absent->read(0, Field::water), FieldError::missing)); CHECK(compact->read(129, Field::nitrogen) == 0); CHECK(compact->read(129, Field::water) == 7); std::vector values(130, seven); values.back() = 9; const FieldOpening sparse_input[]{{Field::water, values}}; auto sparse = make(mapping, sparse_input); CHECK(sparse->accounted_bytes() == compact->accounted_bytes() + 512); for (std::size_t i = 0; i < values.size(); ++i) CHECK(sparse->read(i, Field::water) == values[i]); for (std::size_t i = 0; i < values.size(); ++i) values[i] = i; auto varied = make(mapping, sparse_input); CHECK(varied->accounted_bytes() == compact->accounted_bytes() + 1536); CHECK(varied->snapshot().size() == 96 + 130 * (74 + 8)); std::printf("field bytes: uniform=%zu sparse=%zu varying=%zu\n", compact->accounted_bytes(), sparse->accounted_bytes(), varied->accounted_bytes()); const auto prior = varied->snapshot(); CHECK(refused(varied->transfer(1, Field::water, 64, 63, 65), FieldError::insufficient)); CHECK(varied->snapshot() == prior); CHECK(varied->transfer(1, Field::water, 64, 63, 64)); CHECK(varied->read(64, Field::water) == 0); CHECK(varied->read(63, Field::water) == 127); const auto depleted = varied->snapshot(); CHECK(refused(varied->transfer(2, Field::water, 64, 63, 1), FieldError::insufficient)); CHECK(refused(varied->transfer(1, Field::water, 64, 63, 64), FieldError::stale_command)); CHECK(varied->snapshot() == depleted); auto restored = FieldStore::restore(depleted, identity, budget); CHECK(restored && (*restored)->snapshot() == depleted); CHECK((*restored)->read(64, Field::water) == 0); CHECK((*restored)->transfer(2, Field::water, 63, 64, 64)); CHECK(varied->transfer(2, Field::water, 63, 64, 64)); CHECK((*restored)->snapshot() == varied->snapshot()); std::uint64_t total{}; for (std::size_t i = 0; i < 130; ++i) { CHECK(varied->read(i, Field::water) == i); total += *varied->read(i, Field::water); } CHECK(total == 8385); CHECK(compact->transfer(1, Field::water, 128, 129, 7)); CHECK(compact->accounted_bytes() == absent->accounted_bytes() + 512); CHECK(compact->transfer(2, Field::water, 129, 128, 7)); CHECK(compact->accounted_bytes() == absent->accounted_bytes()); const auto tight_budget = compact->accounted_bytes() + FieldStore::scratch_bytes; auto tight = make(mapping, uniform, tight_budget); const auto before = tight->snapshot(); CHECK(refused(tight->transfer(1, Field::water, 0, 1, 1), FieldError::budget)); CHECK(tight->snapshot() == before); CHECK(refused(FieldStore::restore(before, identity, tight_budget - 1), FieldError::budget)); auto absent_copy = FieldStore::restore(absent->snapshot(), identity, budget); CHECK(absent_copy && refused((*absent_copy)->read(1, Field::water), FieldError::missing)); auto zero_copy = FieldStore::restore(compact->snapshot(), identity, budget); CHECK(zero_copy && (*zero_copy)->read(1, Field::nitrogen) == 0); } void invalid_openings_and_transfers() { auto mapping = sites(2); const std::uint64_t zero = 0, full = 1000, one = 1; const FieldOpening water[]{{Field::water, {&full, 1}}}; auto store = make(mapping, water); const auto before = store->snapshot(); CHECK(refused(store->transfer(1, Field::water, 0, 1, 1), FieldError::capacity)); CHECK(refused(store->transfer(1, Field::water, 0, 0, 1), FieldError::invalid_transfer)); CHECK(refused(store->transfer(1, Field::water, 0, 1, 0), FieldError::invalid_transfer)); CHECK(refused(store->transfer(0, Field::water, 0, 1, 1), FieldError::stale_command)); CHECK(refused(store->transfer(1, Field::water, 0, 2, 1), FieldError::site)); CHECK(refused(store->transfer(1, Field::nitrogen, 0, 1, 1), FieldError::missing)); // Fixed uint8_t underlying type permits hostile raw enum values; validate at the API. // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange) CHECK(refused(store->read(0, static_cast(255)), FieldError::channel)); CHECK(store->snapshot() == before); CHECK(refused(FieldStore::create(identity, 0, defaults(), mapping, water, budget), FieldError::config)); CHECK(refused(FieldStore::create({}, 11, defaults(), mapping, water, budget), FieldError::config)); const FieldOpening duplicate[]{{Field::water, {&zero, 1}}, {Field::water, {&zero, 1}}}; CHECK(refused(FieldStore::create(identity, 11, defaults(), mapping, duplicate, budget), FieldError::channel)); const FieldOpening invalid[]{{Field::water, {}}}; CHECK(refused(FieldStore::create(identity, 11, defaults(), mapping, invalid, budget), FieldError::channel)); mapping[1].voxel = mapping[0].voxel; CHECK(refused(FieldStore::create(identity, 11, defaults(), mapping, water, budget), FieldError::mapping)); mapping = sites(2); mapping[0].box.depth.value = 0; CHECK(refused(FieldStore::create(identity, 11, defaults(), mapping, water, budget), FieldError::mapping)); mapping = sites(2); mapping[0].substrate = {3}; CHECK(refused(FieldStore::create(identity, 11, defaults(), mapping, water, budget), FieldError::mapping)); mapping = sites(2); const FieldOpening repeated_overflow[]{{Field::nitrogen, {&maximum, 1}}}; CHECK(refused(FieldStore::create(identity, 11, defaults(), mapping, repeated_overflow, budget), FieldError::overflow)); const std::uint64_t max_once[]{maximum, 0}; for (const auto pair : {std::array{Field::nitrogen, Field::organic_nitrogen}, std::array{Field::phosphorus, Field::organic_phosphorus}, std::array{Field::organic_energy, Field::heat}}) { const FieldOpening overflow[]{{pair[0], max_once}, {pair[1], {&one, 1}}}; CHECK(refused(FieldStore::create(identity, 11, defaults(), mapping, overflow, budget), FieldError::overflow)); } const FieldOpening organic[]{{Field::organic_other, {&one, 1}}}; auto isolated = make(mapping, organic); CHECK(refused(isolated->read(0, Field::water), FieldError::missing)); } void codec_validation() { const auto mapping = sites(2); const std::uint64_t amount = 4; const FieldOpening input[]{{Field::water, {&amount, 1}}}; auto store = make(mapping, input); const auto bytes = store->snapshot(); CHECK(bytes.size() == 260); for (std::size_t length = 0; length < bytes.size(); ++length) CHECK(!FieldStore::restore(std::span{bytes}.first(length), identity, budget)); CHECK(refused(FieldStore::restore(bytes, {7, 10}, budget), FieldError::identity)); auto changed = bytes; changed[200] ^= 1; CHECK(refused(FieldStore::restore(changed, identity, budget), FieldError::checksum)); for (const auto offset : {8U, 32U, 36U}) { for (const auto version : {0U, 2U}) { changed = bytes; put(changed, offset, version, 4); seal(changed); CHECK(refused(FieldStore::restore(changed, identity, budget), FieldError::version)); } } for (const auto mutation : {std::array{40, 0, 8}, // opening ID {56, 4097, 4}, {60, 1024, 4}, // count/mask {88, 1048576, 8}, {112, 1000000, 8}, // address/box {160, 3, 2}, {236, 1001, 8}}) { // material/water changed = bytes; put(changed, static_cast(mutation[0]), mutation[1], static_cast(mutation[2])); seal(changed); CHECK(!FieldStore::restore(changed, identity, budget)); } changed = bytes; std::copy_n(changed.begin() + 88, 24, changed.begin() + 162); seal(changed); CHECK(refused(FieldStore::restore(changed, identity, budget), FieldError::mapping)); changed = bytes; changed.push_back(0); seal(changed); CHECK(!FieldStore::restore(changed, identity, budget)); // Repaired checksums reach semantic parsing. Accepted inputs must be canonical. for (std::size_t n = 0; n < 256; ++n) { changed = bytes; changed[(n * 37) % (bytes.size() - 8)] ^= static_cast(1U << (n % 8)); seal(changed); auto decoded = FieldStore::restore(changed, identity, budget); if (decoded) CHECK((*decoded)->snapshot() == changed); } // Independent byte construction of an absent-field, single-site fixture. const auto one = sites(1); auto empty = make(one, {}); WorldBytes expected(170, 0); const std::string magic = "AEVOFLD1"; std::copy(magic.begin(), magic.end(), expected.begin()); put(expected, 8, 1, 4); put(expected, 16, 7, 8); put(expected, 24, 9, 8); put(expected, 32, 1, 4); put(expected, 36, 1, 4); put(expected, 40, 11, 8); put(expected, 56, 1, 4); put(expected, 72, 1000, 8); put(expected, 80, 2000, 8); put(expected, 104, maximum, 8); put(expected, 136, 10, 8); put(expected, 144, 20, 8); put(expected, 152, 3, 8); put(expected, 160, 1, 2); seal(expected); CHECK(empty->snapshot() == expected); } void all_channels_and_limits() { const auto mapping = sites(FieldStore::max_sites); std::array, field_count> values; std::array openings; for (std::size_t k = 0; k < field_count; ++k) { values[k].resize(mapping.size()); for (std::size_t i = 0; i < mapping.size(); ++i) values[k][i] = (i + k) % 100; openings[k] = {static_cast(k), values[k]}; } auto store = make(mapping, openings); const auto encoded = store->snapshot(); CHECK(encoded.size() == 630880); auto restored = FieldStore::restore(encoded, identity, budget); CHECK(restored && (*restored)->snapshot() == encoded); for (std::size_t k = 0; k < field_count; ++k) for (std::size_t i = 0; i < mapping.size(); ++i) CHECK((*restored)->read(i, static_cast(k)) == values[k][i]); // Independent dense model across page seams and all compartment types. for (std::uint64_t command = 1; command <= 100; ++command) { const auto k = static_cast(command % field_count); const auto from = static_cast((command * 63) % mapping.size()); const auto to = (from + 1) % mapping.size(); const auto amount = values[k][from]; if (amount == 0) continue; CHECK((*restored)->transfer(command, static_cast(k), from, to, amount)); values[k][from] = 0; values[k][to] += amount; CHECK((*restored)->read(from, static_cast(k)) == 0); CHECK((*restored)->read(to, static_cast(k)) == values[k][to]); } auto continued = FieldStore::restore((*restored)->snapshot(), identity, budget); CHECK(continued && (*continued)->last_command() == (*restored)->last_command()); for (std::size_t k = 0; k < field_count; ++k) for (std::size_t i = 0; i < mapping.size(); ++i) CHECK((*continued)->read(i, static_cast(k)) == values[k][i]); const auto too_many = sites(FieldStore::max_sites + 1); CHECK(refused(FieldStore::create(identity, 11, defaults(), too_many, {}, budget), FieldError::config)); CHECK( refused(FieldStore::create(identity, 11, defaults(), {}, {}, budget), FieldError::config)); WorldBytes oversized(FieldStore::max_snapshot_bytes + 1); CHECK(refused(FieldStore::restore(oversized, identity, budget), FieldError::format)); // Global overflow below a valid checksum and structurally correct shape. auto corrupt = encoded; const auto data_start = std::size_t{88} + mapping.size() * 74; put(corrupt, data_start + mapping.size() * 8, maximum, 8); // nitrogen[0] seal(corrupt); CHECK(refused(FieldStore::restore(corrupt, identity, budget), FieldError::overflow)); } } // namespace int main() try { storage_and_exhaustion(); invalid_openings_and_transfers(); codec_validation(); all_channels_and_limits(); return 0; } catch (const std::exception& e) { std::fprintf(stderr, "%s\n", e.what()); return 1; } catch (...) { return 1; }