Files
aevolution/tests/environment_transfers_tests.cpp
T

293 lines
12 KiB
C++

#include "evo/world/transfers.hpp"
#include <array>
#include <cstdio>
#include <limits>
#include <source_location>
#include <stdexcept>
#include <string>
#include <vector>
namespace {
using namespace evo::world;
constexpr WorldIdentity id{7, 9};
constexpr std::array<VoxelAddress, 2> voxels{{{0, 0, -16000}, {1, 0, -16000}}};
void check(bool ok, std::source_location at = std::source_location::current()) {
if (!ok)
throw std::runtime_error("transfers line " + std::to_string(at.line()));
}
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
template <class T> bool refused(const std::expected<T, TransferError>& r, TransferError e) {
return !r && r.error() == e;
}
struct Parts {
std::unique_ptr<FieldStore> fields;
std::unique_ptr<ChunkStore> terrain;
std::array<OrganismResources, 2> accounts;
};
Parts parts(bool loaded = true, bool all = true, std::size_t field_budget = 2000000) {
const std::array<FieldSite, 2> sites{{{voxels[0], {{0}, {0}, {0}, {10}, {20}, {3}}, {1}},
{voxels[1], {{0}, {0}, {0}, {10}, {20}, {3}}, {1}}}};
const std::uint64_t stock = 10;
std::array<FieldOpening, field_count> openings;
for (std::size_t k = 0; k < field_count; ++k)
openings[k] = {static_cast<Field>(k), {&stock, 1}};
const FieldDefaults defaults{{evo::accounting::Femtograms{0}, evo::accounting::Femtograms{20},
evo::accounting::Femtograms{20}}};
auto f = FieldStore::create(id, 1, defaults, sites,
std::span{openings}.first(all ? field_count : 1), field_budget);
CHECK(f);
auto t = ChunkStore::create({}, 2, 2000000, {{VolumeUnits{100}, VolumeUnits{100}}});
CHECK(t);
if (loaded)
CHECK((*t)->load({0, 0, -1000}));
Parts p{std::move(*f), std::move(*t), {}};
for (std::size_t i = 0; i < 2; ++i) {
p.accounts[i].id = {i + 1};
p.accounts[i].capacities.fill(100);
}
return p;
}
auto adopt(Parts p, std::size_t budget = 4000000, WorldIdentity identity = id) {
return EnvironmentalTransfers::create(identity, std::move(p.fields), std::move(p.terrain),
p.accounts, budget);
}
auto owner() {
auto r = adopt(parts());
CHECK(r);
return std::move(*r);
}
EnvironmentView view(const EnvironmentalTransfers& o, std::uint64_t tick = 1,
std::uint32_t mask = 1023) {
auto v = query_environment(o.fields(), o.terrain(), tick, voxels, mask);
CHECK(v);
return std::move(*v);
}
EnvironmentalLeg leg(Field f = Field::nitrogen, std::uint64_t amount = 10) {
return {voxels[0], {1}, f, ResourceDirection::to_organism, amount};
}
struct State {
WorldBytes fields;
std::vector<OrganismResources> accounts;
auto operator<=>(const State&) const = default;
};
State state(const EnvironmentalTransfers& o) {
return {o.fields().snapshot(), {o.organisms().begin(), o.organisms().end()}};
}
void atomicity() {
auto o = owner();
auto v = view(*o);
auto a = leg();
const auto total = o->totals();
const auto receipt = o->commit({1, 1, {&a, 1}}, v, 1);
CHECK(receipt);
const auto committed = state(*o);
CHECK(o->organisms()[0].balances[1] == 10 && *o->fields().read(0, Field::nitrogen) == 0);
CHECK(o->totals() == total);
CHECK(o->commit({1, 1, {&a, 1}}, v, 999) == receipt);
CHECK(state(*o) == committed);
a.organism = {2};
CHECK(refused(o->commit({1, 1, {&a, 1}}, v, 1), TransferError::conflict));
CHECK(refused(o->commit({2, 1, {&a, 1}}, v, 1), TransferError::stale_view));
auto fresh = view(*o);
CHECK(refused(o->commit({2, 1, {&a, 1}}, fresh, 1), TransferError::insufficient));
CHECK(state(*o) == committed);
a = leg(Field::water, 3);
std::array batch{a, leg(Field::nitrogen, 1)};
CHECK(refused(o->commit({2, 1, batch}, fresh, 1), TransferError::insufficient));
CHECK(state(*o) == committed);
batch[1] = leg(Field::organic_other, 4);
CHECK(o->commit({2, 1, batch}, fresh, 1));
CHECK(o->organisms()[0].balances[0] == 3 && o->organisms()[0].balances[6] == 4);
CHECK(o->totals() == total);
auto next = view(*o);
for (auto& b : batch)
b.direction = ResourceDirection::to_environment;
CHECK(o->commit({3, 1, batch}, next, 1));
CHECK(o->organisms()[0].balances[0] == 0);
CHECK(o->totals() == total);
}
void rejection() {
auto o = owner();
auto v = view(*o);
auto a = leg();
const auto before = state(*o);
auto other = owner();
auto alien = view(*other);
CHECK(refused(o->commit({1, 1, {&a, 1}}, alien, 1), TransferError::wrong_owner));
CHECK(refused(o->commit({1, 2, {&a, 1}}, v, 2), TransferError::stale_view));
CHECK(refused(o->commit({0, 1, {&a, 1}}, v, 1), TransferError::invalid_request));
CHECK(refused(o->commit({1, 1, {}}, v, 1), TransferError::invalid_request));
std::array<EnvironmentalLeg, 33> many{};
CHECK(refused(o->commit({1, 1, many}, v, 1), TransferError::invalid_request));
a.organism = {3};
CHECK(refused(o->commit({1, 1, {&a, 1}}, v, 1), TransferError::unknown_organism));
a = leg();
a.voxel.x = 3;
CHECK(refused(o->commit({1, 1, {&a, 1}}, v, 1), TransferError::uncovered));
a = leg();
auto limited = view(*o, 1, 1);
CHECK(refused(o->commit({1, 1, {&a, 1}}, limited, 1), TransferError::uncovered));
a.amount = 0;
CHECK(refused(o->commit({1, 1, {&a, 1}}, v, 1), TransferError::invalid_request));
CHECK(state(*o) == before);
auto missing = adopt(parts(true, false));
CHECK(missing);
auto mv = view(**missing);
a = leg();
CHECK(refused((*missing)->commit({1, 1, {&a, 1}}, mv, 1), TransferError::missing));
auto p = parts();
p.accounts[0].capacities[1] = 1;
auto small = adopt(std::move(p));
CHECK(small);
auto sv = view(**small);
CHECK(refused((*small)->commit({1, 1, {&a, 1}}, sv, 1), TransferError::capacity));
p = parts();
p.accounts[0].balances[0] = 20;
auto water = adopt(std::move(p));
CHECK(water);
auto wv = view(**water);
a = leg(Field::water, 11);
a.direction = ResourceDirection::to_environment;
const auto wb = state(**water);
CHECK(refused((*water)->commit({1, 1, {&a, 1}}, wv, 1), TransferError::capacity));
CHECK(state(**water) == wb);
}
void admission_budget() {
CHECK(refused(adopt(parts(false)), TransferError::terrain_binding));
CHECK(refused(adopt(parts(), 4000000, {8, 9}), TransferError::identity));
auto p = parts();
p.accounts[1].id = {1};
CHECK(refused(adopt(std::move(p)), TransferError::config));
p = parts();
p.accounts[0].id = {0};
CHECK(refused(adopt(std::move(p)), TransferError::config));
p = parts();
p.accounts[0].balances[0] = 101;
CHECK(refused(adopt(std::move(p)), TransferError::capacity));
p = parts();
p.accounts[0].balances[1] = std::numeric_limits<std::uint64_t>::max();
p.accounts[0].capacities[1] = p.accounts[0].balances[1];
CHECK(refused(adopt(std::move(p)), TransferError::overflow));
auto o = owner();
const auto tight = o->accounted_bytes() + EnvironmentalTransfers::scratch_bytes;
auto bounded = adopt(parts(), tight);
CHECK(bounded);
auto v = view(**bounded);
auto a = leg();
const auto before = state(**bounded);
CHECK(refused((*bounded)->commit({1, 1, {&a, 1}}, v, 1), TransferError::budget));
CHECK(state(**bounded) == before);
p = parts();
const auto fb = p.fields->accounted_bytes() + FieldStore::scratch_bytes;
bounded = adopt(parts(true, true, fb));
CHECK(bounded);
v = view(**bounded);
CHECK(refused((*bounded)->commit({1, 1, {&a, 1}}, v, 1), TransferError::budget));
}
void codec() {
auto o = owner();
for (std::uint64_t c = 1; c <= 66; ++c) {
auto v = view(*o, c);
auto a = leg(Field::water, 1);
if (c % 2 == 0)
a.direction = ResourceDirection::to_environment;
CHECK(o->commit({c, c, {&a, 1}}, v, c));
}
auto saved = o->snapshot();
CHECK(saved);
auto restored = EnvironmentalTransfers::restore(*saved, id, 4000000, 2000000, 2000000);
CHECK(restored);
CHECK((*restored)->snapshot() == saved);
CHECK(state(**restored) == state(*o));
auto v = view(**restored, 67);
auto a = leg(Field::water, 1);
a.direction = ResourceDirection::to_environment;
CHECK((*restored)->commit({66, 66, {&a, 1}}, v, 67));
a.amount = 2;
CHECK(refused((*restored)->commit({66, 66, {&a, 1}}, v, 67), TransferError::conflict));
CHECK(refused((*restored)->commit({1, 1, {&a, 1}}, v, 67), TransferError::stale_command));
a = leg(Field::nitrogen, 2);
auto original_view = view(*o, 67);
CHECK(o->commit({67, 67, {&a, 1}}, original_view, 67));
CHECK((*restored)->commit({67, 67, {&a, 1}}, v, 67));
CHECK(o->snapshot() == (*restored)->snapshot());
CHECK(refused(EnvironmentalTransfers::restore(*saved, {8, 9}, 4000000, 2000000, 2000000),
TransferError::identity));
CHECK(refused(EnvironmentalTransfers::restore(*saved, id, 1, 2000000, 2000000),
TransferError::budget));
CHECK(refused(EnvironmentalTransfers::restore(*saved, id, 4000000, 1, 2000000),
TransferError::budget));
CHECK(refused(EnvironmentalTransfers::restore(*saved, id, 4000000, 2000000, 1),
TransferError::budget));
auto empty = owner();
auto initial = empty->snapshot();
CHECK(initial);
auto fresh = EnvironmentalTransfers::restore(*initial, id, 4000000, 2000000, 2000000);
CHECK(fresh);
CHECK((*fresh)->snapshot() == initial);
for (std::size_t n = 0; n < saved->size(); ++n)
CHECK(!EnvironmentalTransfers::restore(std::span{*saved}.first(n), id, 4000000, 2000000,
2000000));
auto bad = *saved;
bad[60] ^= 1;
CHECK(refused(EnvironmentalTransfers::restore(bad, id, 4000000, 2000000, 2000000),
TransferError::checksum));
auto fix_hash = [](WorldBytes& bytes) {
std::uint64_t h = 14695981039346656037ULL;
for (auto b : std::span{bytes}.first(bytes.size() - 8))
h = (h ^ b) * 1099511628211ULL;
for (unsigned i = 0; i < 8; ++i)
bytes[bytes.size() - 8 + i] = static_cast<std::uint8_t>((h >> (8U * i)) & 255U);
};
for (auto offset : {std::size_t{8}, std::size_t{40}, std::size_t{44}, saved->size() - 9}) {
bad = *saved;
bad[offset] = 255;
fix_hash(bad);
CHECK(!EnvironmentalTransfers::restore(bad, id, 4000000, 2000000, 2000000));
}
CHECK((*restored)->snapshot() == o->snapshot());
}
void conservation_history() {
auto o = owner();
const auto total = o->totals();
for (std::uint64_t command = 1; command <= 100; ++command) {
auto v = view(*o, command);
std::array<EnvironmentalLeg, field_count> batch;
for (std::size_t k = 0; k < field_count; ++k) {
batch[k] = leg(static_cast<Field>(k), 1);
if (command % 2 == 0)
batch[k].direction = ResourceDirection::to_environment;
}
auto r = o->commit({command, command, batch}, v, command);
CHECK(r);
CHECK(o->totals() == total);
for (std::size_t k = 0; k < field_count; ++k) {
CHECK(o->organisms()[0].balances[k] == command % 2);
CHECK(*o->fields().read(0, static_cast<Field>(k)) == 10 - command % 2);
}
CHECK(o->commit({command, command, batch}, v, command + 1) == r);
batch[0].amount = 2;
CHECK(refused(o->commit({command, command, batch}, v, command), TransferError::conflict));
}
auto v = view(*o, 101);
auto a = leg(Field::water, 1);
CHECK(refused(o->commit({1, 1, {&a, 1}}, v, 101), TransferError::stale_command));
CHECK(o->commit({std::numeric_limits<std::uint64_t>::max(), 101, {&a, 1}}, v, 101));
CHECK(o->commit({std::numeric_limits<std::uint64_t>::max(), 101, {&a, 1}}, v, 102));
}
} // namespace
int main() {
try {
codec();
atomicity();
rejection();
admission_budget();
conservation_history();
return 0;
} catch (const std::exception& e) {
std::fprintf(stderr, "%s\n", e.what());
return 1;
} catch (...) {
return 1;
}
}