293 lines
12 KiB
C++
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;
|
|
}
|
|
}
|