306 lines
15 KiB
C++
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;
|
|
}
|