Files
aevolution/tests/world_fields_tests.cpp

306 lines
15 KiB
C++

#include "evo/world/fields.hpp"
#include <algorithm>
#include <array>
#include <cstdio>
#include <limits>
#include <source_location>
#include <stdexcept>
#include <string>
#include <vector>
namespace {
using namespace evo::world;
constexpr WorldIdentity identity{7, 9};
constexpr std::size_t budget = 2'000'000;
constexpr auto maximum = std::numeric_limits<std::uint64_t>::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<bool>(__VA_ARGS__))
template <typename T> bool refused(const std::expected<T, FieldError>& result, FieldError error) {
return !result && result.error() == error;
}
std::vector<FieldSite> sites(std::size_t count) {
std::vector<FieldSite> out(count);
for (std::size_t i = 0; i < count; ++i)
out[i] = {{static_cast<std::int64_t>(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<FieldStore> make(std::span<const FieldSite> mapping,
std::span<const FieldOpening> 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<std::uint8_t>(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<std::uint64_t> 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<Field>(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<std::uint64_t, 3>{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<std::size_t>(mutation[0]), mutation[1],
static_cast<unsigned>(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<std::uint8_t>(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<std::vector<std::uint64_t>, field_count> values;
std::array<FieldOpening, field_count> 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<Field>(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<Field>(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<std::size_t>(command % field_count);
const auto from = static_cast<std::size_t>((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<Field>(k), from, to, amount));
values[k][from] = 0;
values[k][to] += amount;
CHECK((*restored)->read(from, static_cast<Field>(k)) == 0);
CHECK((*restored)->read(to, static_cast<Field>(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<Field>(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;
}