Files
aevolution/tests/environment_views_tests.cpp

255 lines
12 KiB
C++

#include "evo/world/environment.hpp"
#include <algorithm>
#include <array>
#include <cstdio>
#include <limits>
#include <optional>
#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 std::uint32_t mask = (1U << 0) | (1U << 1) | (1U << 2) | (1U << 7);
void check(bool ok, std::source_location at = std::source_location::current()) {
if (!ok)
throw std::runtime_error("environment view line " + std::to_string(at.line()));
}
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
const EnvironmentQuantity&
required_field(const std::optional<EnvironmentQuantity>& field,
std::source_location at = std::source_location::current()) {
if (!field.has_value())
throw std::runtime_error("missing environment field at line " + std::to_string(at.line()));
return *field;
}
template <typename T, typename E> bool refused(const std::expected<T, E>& r, E e) {
return !r && r.error() == e;
}
struct Fixture {
std::unique_ptr<FieldStore> fields;
std::unique_ptr<ChunkStore> terrain;
std::vector<VoxelAddress> footprint;
};
Fixture fixture() {
Fixture f;
std::vector<FieldSite> sites;
for (const auto x : {-17, -16, -1, 0, 15, 16}) {
f.footprint.push_back({x, 0, -16000});
sites.push_back({f.footprint.back(), {{0}, {0}, {0}, {10}, {20}, {3}}, {1}});
}
sites[1].substrate = {2};
const std::array<std::uint64_t, 6> water{6, 0, 12, 18, 24, 30};
const std::uint64_t zero = 0, energy = 72;
const FieldOpening opening[]{{Field::water, water},
{Field::phosphorus, {&zero, 1}},
{Field::organic_energy, {&energy, 1}}};
const FieldDefaults defaults{{evo::accounting::Femtograms{0}, evo::accounting::Femtograms{100},
evo::accounting::Femtograms{0}}};
auto fields = FieldStore::create(identity, 1, defaults, sites, opening, budget);
CHECK(fields);
f.fields = std::move(*fields);
auto terrain = ChunkStore::create({}, 32, budget, {{VolumeUnits{100}, VolumeUnits{100}}});
CHECK(terrain);
f.terrain = std::move(*terrain);
return f;
}
void load(Fixture& f) {
for (auto address : f.footprint)
CHECK(f.terrain->load(split(address, base_chunk_edge)->chunk));
}
void values_and_order() {
auto f = fixture();
const auto empty = f.terrain->snapshot(identity);
CHECK(refused(query_environment(*f.fields, *f.terrain, 5, f.footprint, mask),
EnvironmentError::missing_chunk));
CHECK(f.terrain->snapshot(identity) == empty); // missing queries never load
load(f);
const auto terrain_before = f.terrain->snapshot(identity);
const auto fields_before = f.fields->snapshot();
auto q = query_environment(*f.fields, *f.terrain, 5, f.footprint, mask);
CHECK(q && validate_environment(*q, *f.fields, *f.terrain, 5));
CHECK(q->identity() == identity && q->tick() == 5 && q->field_revision() == 0);
CHECK(q->requested_mask() == mask && q->terrain_pitch().value == 1000);
CHECK(q->samples().size() == 6);
const std::array<std::int64_t, 6> expected_chunks{-2, -1, -1, 0, 0, 1};
for (std::size_t i = 0; i < 6; ++i) {
const auto& s = q->samples()[i];
CHECK(s.voxel == f.footprint[i] && s.chunk.x == expected_chunks[i]);
CHECK(s.measure == HabitatMeasure{{200}, {600}});
CHECK(s.terrain.material() == MaterialId{1} && s.terrain.fill() == fill_scale);
CHECK(!s.fields[1] && !s.fields[3]); // missing requested N; unrequested organic C
CHECK(std::get<EnvironmentMass>(required_field(s.fields[2])) ==
EnvironmentMass{{0}, {0, 1}});
CHECK(std::get<evo::accounting::Picojoules>(required_field(s.fields[7])).value == 72);
CHECK(s.chunk_revision == f.terrain->view(s.chunk)->revision());
}
CHECK(std::get<EnvironmentMass>(required_field(q->samples()[0].fields[0])) ==
EnvironmentMass{{6}, {1, 100}});
CHECK(q->samples()[0].moisture_status == MoistureStatus::available);
CHECK(q->samples()[0].moisture == WaterSaturation{3, 50});
CHECK(q->samples()[1].habitat.substrate == MaterialId{2}); // no silent substrate reconciliation
CHECK(q->samples()[1].moisture_status == MoistureStatus::zero_capacity &&
!q->samples()[1].moisture);
auto reversed = f.footprint;
std::reverse(reversed.begin(), reversed.end());
auto reverse = query_environment(*f.fields, *f.terrain, 5, reversed, mask);
CHECK(reverse);
for (std::size_t i = 0; i < 6; ++i) {
CHECK(reverse->samples()[i].voxel == q->samples()[i].voxel);
CHECK(reverse->samples()[i].fields == q->samples()[i].fields);
CHECK(reverse->samples()[i].moisture == q->samples()[i].moisture);
}
auto no_water = query_environment(*f.fields, *f.terrain, 5, f.footprint, 1U << 2);
CHECK(no_water && no_water->samples()[0].moisture_status == MoistureStatus::not_requested);
CHECK(f.terrain->snapshot(identity) == terrain_before && f.fields->snapshot() == fields_before);
CHECK(refused(f.fields->water_capacity(6), FieldError::site));
}
void freshness() {
auto f = fixture();
load(f);
auto q = query_environment(*f.fields, *f.terrain, 7, f.footprint, mask);
CHECK(q);
CHECK(
refused(validate_environment(*q, *f.fields, *f.terrain, 8), EnvironmentError::stale_tick));
auto clone = FieldStore::restore(f.fields->snapshot(), identity, budget);
CHECK(clone);
CHECK(refused(validate_environment(*q, **clone, *f.terrain, 7), EnvironmentError::wrong_owner));
auto terrain_clone = ChunkStore::restore(*f.terrain->snapshot(identity), identity, budget);
CHECK(terrain_clone);
CHECK(refused(validate_environment(*q, *f.fields, **terrain_clone, 7),
EnvironmentError::wrong_owner));
CHECK(!f.fields->transfer(1, Field::water, 1, 2, 1));
CHECK(validate_environment(*q, *f.fields, *f.terrain, 7));
auto unrelated =
query_environment(*f.fields, *f.terrain, 7, std::span{f.footprint}.last(1), mask);
CHECK(unrelated);
CHECK(f.fields->transfer(1, Field::water, 0, 2, 6));
CHECK(refused(validate_environment(*q, *f.fields, *f.terrain, 7),
EnvironmentError::stale_fields));
CHECK(refused(validate_environment(*unrelated, *f.fields, *f.terrain, 7),
EnvironmentError::stale_fields));
q = query_environment(*f.fields, *f.terrain, 7, f.footprint, mask);
CHECK(q);
const auto other = f.terrain->load({10, 0, -1000});
CHECK(other && f.terrain->mark_dirty(*other));
CHECK(validate_environment(*q, *f.fields, *f.terrain, 7));
const auto first = f.terrain->view({-2, 0, -1000});
CHECK(first && f.terrain->mark_dirty(*first));
CHECK(refused(validate_environment(*q, *f.fields, *f.terrain, 7),
EnvironmentError::stale_terrain));
q = query_environment(*f.fields, *f.terrain, 7, f.footprint, mask);
CHECK(q);
const auto last = f.terrain->view({1, 0, -1000});
CHECK(last && f.terrain->evict(*last));
CHECK(refused(validate_environment(*q, *f.fields, *f.terrain, 7),
EnvironmentError::stale_terrain));
CHECK(f.terrain->load({1, 0, -1000}));
CHECK(refused(validate_environment(*q, *f.fields, *f.terrain, 7),
EnvironmentError::stale_terrain));
q = query_environment(*f.fields, *f.terrain, 7, f.footprint, mask);
CHECK(q);
const auto revision = f.terrain->view({0, 0, -1000})->revision();
const CellCut cut{{0, 0, -1000}, {0, 0, 0}, revision, 1};
ExcavationRequest edit{1, 1, {&cut, 1}, 0};
edit.digest = *excavation_digest(edit);
CHECK(f.terrain->excavate(edit));
CHECK(refused(validate_environment(*q, *f.fields, *f.terrain, 7),
EnvironmentError::stale_terrain));
auto updated = query_environment(*f.fields, *f.terrain, 7, f.footprint, mask);
CHECK(updated);
CHECK(updated->samples()[3].terrain.fill() == fill_scale - 1);
CHECK(updated->samples()[3].fields == q->samples()[3].fields);
}
void invalid_and_absent() {
auto f = fixture();
load(f);
CHECK(refused(query_environment(*f.fields, *f.terrain, 0, {}, mask),
EnvironmentError::invalid_request));
CHECK(refused(query_environment(*f.fields, *f.terrain, 0, f.footprint, 0),
EnvironmentError::invalid_request));
CHECK(refused(query_environment(*f.fields, *f.terrain, 0, f.footprint, 1U << 10),
EnvironmentError::invalid_request));
const VoxelAddress missing{1, 0, -16000},
invalid{std::numeric_limits<std::int64_t>::min(), 0, 0};
CHECK(refused(query_environment(*f.fields, *f.terrain, 0, {&missing, 1}, mask),
EnvironmentError::missing_site));
CHECK(refused(query_environment(*f.fields, *f.terrain, 0, {&invalid, 1}, mask),
EnvironmentError::invalid_voxel));
auto duplicate = f.footprint;
duplicate.push_back(duplicate[0]);
CHECK(refused(query_environment(*f.fields, *f.terrain, 0, duplicate, mask),
EnvironmentError::invalid_request));
std::vector<VoxelAddress> excess(max_environment_footprint + 1);
CHECK(refused(query_environment(*f.fields, *f.terrain, 0, excess, mask),
EnvironmentError::invalid_request));
auto no_fields = FieldStore::create(identity, 2, {}, f.fields->sites(), {}, budget);
CHECK(no_fields);
auto absent =
query_environment(**no_fields, *f.terrain, 0, f.footprint, all_environment_fields);
CHECK(absent);
for (const auto& s : absent->samples()) {
CHECK(s.moisture_status == MoistureStatus::missing_water && !s.moisture);
for (const auto& value : s.fields)
CHECK(!value);
}
}
void maximum_footprint() {
std::vector<FieldSite> sites;
std::vector<VoxelAddress> footprint;
for (std::int64_t x = -128; x < 128; ++x) {
footprint.push_back({x, 0, -16000});
sites.push_back({footprint.back(), {{0}, {0}, {0}, {1}, {1}, {1}}, {1}});
}
const std::uint64_t amount = 4;
std::array<FieldOpening, field_count> openings;
for (std::size_t k = 0; k < field_count; ++k)
openings[k] = {static_cast<Field>(k), {&amount, 1}};
const FieldDefaults defaults{{evo::accounting::Femtograms{0}, evo::accounting::Femtograms{100},
evo::accounting::Femtograms{0}}};
auto fields = FieldStore::create(identity, 3, defaults, sites, openings, budget);
auto terrain = ChunkStore::create({}, 32, budget);
CHECK(fields && terrain);
for (auto voxel : footprint)
CHECK((*terrain)->load(split(voxel, base_chunk_edge)->chunk));
std::reverse(footprint.begin(), footprint.end());
const auto fields_before = (*fields)->snapshot();
const auto terrain_before = (*terrain)->snapshot(identity);
auto result = query_environment(**fields, **terrain, 0, footprint, all_environment_fields);
CHECK(result && result->samples().size() == max_environment_footprint);
CHECK(validate_environment(*result, **fields, **terrain, 0));
for (std::size_t i = 0; i < sites.size(); ++i) {
const auto& s = result->samples()[i];
CHECK(s.voxel == sites[i].voxel);
for (std::size_t k = 0; k < field_count; ++k) {
CHECK(s.fields[k]);
if (k < 7)
CHECK(std::get<EnvironmentMass>(required_field(s.fields[k])) ==
EnvironmentMass{{4}, {4, 1}});
else
CHECK(std::get<evo::accounting::Picojoules>(required_field(s.fields[k])).value ==
4);
}
CHECK(s.moisture == WaterSaturation{1, 25});
}
CHECK((*fields)->snapshot() == fields_before &&
(*terrain)->snapshot(identity) == terrain_before);
}
} // namespace
int main() try {
values_and_order();
freshness();
invalid_and_absent();
maximum_footprint();
return 0;
} catch (const std::exception& e) {
std::fprintf(stderr, "%s\n", e.what());
return 1;
} catch (...) {
return 1;
}