mirror of
https://github.com/torlando-tech/pyxis.git
synced 2026-08-19 00:59:54 +00:00
322 lines
18 KiB
C++
322 lines
18 KiB
C++
#include "Hardware/TDeck/MapTilePack.h"
|
|
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <iostream>
|
|
#include <new>
|
|
|
|
using Hardware::TDeck::MapTilePack;
|
|
using Hardware::TDeck::MapTilePackResult;
|
|
using Hardware::TDeck::MapTilePackStatus;
|
|
using Hardware::TDeck::MapTileStorage;
|
|
using Hardware::TDeck::TileKey;
|
|
using Hardware::TDeck::TileStoreResult;
|
|
using Pyxis::MapPackManifest;
|
|
|
|
namespace {
|
|
std::size_t allocations = 0U;
|
|
std::size_t tests_run = 0U;
|
|
void fail(const char* expression, int line) {
|
|
std::cerr << "line " << line << ": " << expression << '\n';
|
|
std::exit(1);
|
|
}
|
|
#define CHECK(expression) do { if (!(expression)) fail(#expression, __LINE__); } while (false)
|
|
void beginTest() { ++tests_run; }
|
|
}
|
|
|
|
void* operator new(std::size_t size) {
|
|
++allocations;
|
|
void* memory = std::malloc(size);
|
|
if (memory == NULL) throw std::bad_alloc();
|
|
return memory;
|
|
}
|
|
void* operator new[](std::size_t size) {
|
|
++allocations;
|
|
void* memory = std::malloc(size);
|
|
if (memory == NULL) throw std::bad_alloc();
|
|
return memory;
|
|
}
|
|
void operator delete(void* memory) noexcept { std::free(memory); }
|
|
void operator delete[](void* memory) noexcept { std::free(memory); }
|
|
|
|
namespace {
|
|
struct File {
|
|
char path[MapTilePack::PATH_CAPACITY];
|
|
std::uint8_t bytes[MapPackManifest::MAX_SERIALIZED_SIZE];
|
|
std::size_t size;
|
|
std::uint32_t declared_size;
|
|
};
|
|
|
|
class FakeStorage : public MapTileStorage {
|
|
public:
|
|
FakeStorage()
|
|
: available(true), file_count(0U), open_file(NULL), position(0U),
|
|
read_calls(0U), end_calls(0U), fail_read_call(0U), zero_read_call(0U) {}
|
|
|
|
void clear() { file_count = 0U; open_file = NULL; position = 0U; }
|
|
void add(const char* path, const std::uint8_t* bytes, std::size_t size) {
|
|
CHECK(file_count < 8U);
|
|
CHECK(std::strlen(path) < sizeof(files[0].path));
|
|
CHECK(size <= sizeof(files[0].bytes));
|
|
File& file = files[file_count++];
|
|
std::strcpy(file.path, path);
|
|
if (size != 0U) std::memcpy(file.bytes, bytes, size);
|
|
file.size = size;
|
|
file.declared_size = static_cast<std::uint32_t>(size);
|
|
}
|
|
void addText(const char* path, const char* text) {
|
|
add(path, reinterpret_cast<const std::uint8_t*>(text), std::strlen(text));
|
|
}
|
|
void setDeclaredSize(const char* path, std::uint32_t size) {
|
|
File* file = find(path); CHECK(file != NULL); file->declared_size = size;
|
|
}
|
|
File* find(const char* path) {
|
|
for (std::size_t index = 0U; index < file_count; ++index) {
|
|
if (std::strcmp(files[index].path, path) == 0) return &files[index];
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
virtual bool isAvailable() const { return available; }
|
|
virtual TileStoreResult beginRead(const char* path, std::uint32_t& size) {
|
|
if (!available) return TileStoreResult::STORAGE_UNAVAILABLE;
|
|
if (open_file != NULL) return TileStoreResult::BUSY;
|
|
File* file = find(path);
|
|
if (file == NULL) return TileStoreResult::MISS;
|
|
open_file = file; position = 0U; read_calls = 0U; size = file->declared_size;
|
|
return TileStoreResult::OK;
|
|
}
|
|
virtual TileStoreResult readChunk(std::uint8_t* output, std::size_t capacity, std::size_t& count) {
|
|
count = 0U;
|
|
if (open_file == NULL) return TileStoreResult::NOT_INITIALIZED;
|
|
++read_calls;
|
|
if (fail_read_call != 0U && read_calls == fail_read_call) return TileStoreResult::IO_ERROR;
|
|
if (zero_read_call != 0U && read_calls == zero_read_call) return TileStoreResult::OK;
|
|
const std::size_t remaining = open_file->size - position;
|
|
const std::size_t amount = remaining < capacity ? remaining : capacity;
|
|
if (amount != 0U) std::memcpy(output, open_file->bytes + position, amount);
|
|
position += amount; count = amount;
|
|
return TileStoreResult::OK;
|
|
}
|
|
virtual void endRead() { if (open_file != NULL) { open_file = NULL; ++end_calls; } }
|
|
virtual TileStoreResult beginWrite(const char*) { return TileStoreResult::IO_ERROR; }
|
|
virtual TileStoreResult writeChunk(const std::uint8_t*, std::size_t, std::size_t&) { return TileStoreResult::IO_ERROR; }
|
|
virtual TileStoreResult commitWrite() { return TileStoreResult::IO_ERROR; }
|
|
virtual void abortWrite() {}
|
|
virtual TileStoreResult remove(const char*) { return TileStoreResult::IO_ERROR; }
|
|
virtual TileStoreResult rename(const char*, const char*) { return TileStoreResult::IO_ERROR; }
|
|
virtual TileStoreResult stat(const char*, std::uint32_t&) { return TileStoreResult::IO_ERROR; }
|
|
virtual TileStoreResult beginList() { return TileStoreResult::IO_ERROR; }
|
|
virtual TileStoreResult nextList(char*, std::size_t, bool&) { return TileStoreResult::IO_ERROR; }
|
|
virtual void endList() {}
|
|
|
|
bool available;
|
|
File files[8];
|
|
std::size_t file_count;
|
|
File* open_file;
|
|
std::size_t position;
|
|
std::size_t read_calls;
|
|
std::size_t end_calls;
|
|
std::size_t fail_read_call;
|
|
std::size_t zero_read_call;
|
|
};
|
|
|
|
MapPackManifest manifestFor(const char* id) {
|
|
MapPackManifest manifest = {};
|
|
std::strcpy(manifest.pack_id, id);
|
|
std::strcpy(manifest.name, "Test Pack");
|
|
std::strcpy(manifest.attribution, "Test attribution");
|
|
std::strcpy(manifest.source, "local-test");
|
|
std::strcpy(manifest.license, "CC0");
|
|
manifest.min_zoom = 2U; manifest.max_zoom = 2U; manifest.extent_count = 1U;
|
|
manifest.tile_count = 4U;
|
|
manifest.extents[0].zoom = 2U; manifest.extents[0].interval_count = 1U;
|
|
manifest.extents[0].x[0].minimum = 1U; manifest.extents[0].x[0].maximum = 2U;
|
|
manifest.extents[0].y_minimum = 1U; manifest.extents[0].y_maximum = 2U;
|
|
return manifest;
|
|
}
|
|
|
|
void addSelection(FakeStorage& storage, const char* marker_id, const MapPackManifest& manifest) {
|
|
storage.addText(MapTilePack::ACTIVE_PACK_PATH, marker_id);
|
|
std::uint8_t bytes[MapPackManifest::MAX_SERIALIZED_SIZE];
|
|
std::size_t written = 0U;
|
|
CHECK(MapPackManifest::serialize(manifest, bytes, sizeof(bytes), written) == Pyxis::ManifestResult::OK);
|
|
char path[MapTilePack::PATH_CAPACITY];
|
|
CHECK(MapTilePack::manifestPath(marker_id, path, sizeof(path)) == MapTilePackResult::OK);
|
|
storage.add(path, bytes, written);
|
|
}
|
|
|
|
void testNoSelection() {
|
|
beginTest(); FakeStorage storage; MapTilePack pack(storage);
|
|
CHECK(pack.initialize() == MapTilePackResult::NO_SELECTION);
|
|
CHECK(pack.status() == MapTilePackStatus::NO_SELECTION); CHECK(!pack.hasSelection());
|
|
storage.add(MapTilePack::ACTIVE_PACK_PATH, NULL, 0U);
|
|
CHECK(pack.initialize() == MapTilePackResult::NO_SELECTION);
|
|
}
|
|
void testInvalidAndTraversalIds() {
|
|
beginTest(); const char* bad[] = {"../bad", "bad/id", "UPPER", "a.b", "abcdefghijklmnopqrstuvwxyzabcdef"};
|
|
for (std::size_t index = 0U; index < sizeof(bad) / sizeof(bad[0]); ++index) {
|
|
FakeStorage storage; storage.addText(MapTilePack::ACTIVE_PACK_PATH, bad[index]); MapTilePack pack(storage);
|
|
CHECK(pack.initialize() == MapTilePackResult::INVALID_PACK_ID);
|
|
CHECK(pack.status() == MapTilePackStatus::INVALID_SELECTION);
|
|
}
|
|
}
|
|
void testMissingManifest() {
|
|
beginTest(); FakeStorage storage; storage.addText(MapTilePack::ACTIVE_PACK_PATH, "one"); MapTilePack pack(storage);
|
|
CHECK(pack.initialize() == MapTilePackResult::MANIFEST_MISSING);
|
|
CHECK(pack.status() == MapTilePackStatus::INVALID_SELECTION);
|
|
}
|
|
void testCorruptAndOversizedManifest() {
|
|
beginTest();
|
|
FakeStorage corrupt; corrupt.addText(MapTilePack::ACTIVE_PACK_PATH, "one"); corrupt.addText("/pyxis-map/packs/one/manifest.pmp", "bad");
|
|
MapTilePack first(corrupt); CHECK(first.initialize() == MapTilePackResult::INVALID_MANIFEST); CHECK(corrupt.end_calls == 2U);
|
|
FakeStorage large; large.addText(MapTilePack::ACTIVE_PACK_PATH, "one"); large.addText("/pyxis-map/packs/one/manifest.pmp", "x");
|
|
large.setDeclaredSize("/pyxis-map/packs/one/manifest.pmp", static_cast<std::uint32_t>(MapPackManifest::MAX_SERIALIZED_SIZE + 1U));
|
|
MapTilePack second(large); CHECK(second.initialize() == MapTilePackResult::MANIFEST_TOO_LARGE); CHECK(large.end_calls == 2U);
|
|
}
|
|
void testMarkerManifestMismatch() {
|
|
beginTest(); FakeStorage storage; addSelection(storage, "one", manifestFor("two")); MapTilePack pack(storage);
|
|
CHECK(pack.initialize() == MapTilePackResult::PACK_ID_MISMATCH); CHECK(!pack.hasSelection());
|
|
}
|
|
void testUncoveredKey() {
|
|
beginTest(); FakeStorage storage; addSelection(storage, "one", manifestFor("one")); MapTilePack pack(storage);
|
|
CHECK(pack.initialize() == MapTilePackResult::OK); std::uint32_t size = 99U;
|
|
CHECK(pack.beginGet(TileKey{2U, 0U, 0U}, size) == MapTilePackResult::UNCOVERED); CHECK(size == 99U);
|
|
}
|
|
void testCoveredMissingFile() {
|
|
beginTest(); FakeStorage storage; addSelection(storage, "one", manifestFor("one")); MapTilePack pack(storage);
|
|
CHECK(pack.initialize() == MapTilePackResult::OK); std::uint32_t size = 0U;
|
|
CHECK(pack.beginGet(TileKey{2U, 1U, 1U}, size) == MapTilePackResult::TILE_MISSING);
|
|
}
|
|
void testCanonicalPathsAndCapacity() {
|
|
beginTest(); char path[MapTilePack::PATH_CAPACITY]; const char* id = "abcdefghijklmnopqrstuvwxyz12345";
|
|
CHECK(MapTilePack::manifestPath(id, path, sizeof(path)) == MapTilePackResult::OK);
|
|
CHECK(std::strcmp(path, "/pyxis-map/packs/abcdefghijklmnopqrstuvwxyz12345/manifest.pmp") == 0);
|
|
CHECK(MapTilePack::tilePath(id, TileKey{22U, 4194303U, 4194303U}, path, sizeof(path)) == MapTilePackResult::OK);
|
|
CHECK(std::strcmp(path, "/pyxis-map/packs/abcdefghijklmnopqrstuvwxyz12345/tiles/22/4194303/4194303.png") == 0);
|
|
char short_path[77]; std::memset(short_path, 'q', sizeof(short_path));
|
|
CHECK(MapTilePack::tilePath(id, TileKey{22U, 4194303U, 4194303U}, short_path, sizeof(short_path)) == MapTilePackResult::PATH_TOO_LONG);
|
|
CHECK(short_path[0] == 'q');
|
|
CHECK(MapTilePack::tilePath("../x", TileKey{2U, 1U, 1U}, path, sizeof(path)) == MapTilePackResult::INVALID_PACK_ID);
|
|
}
|
|
void testStorageUnavailable() {
|
|
beginTest(); FakeStorage storage; storage.available = false; MapTilePack pack(storage);
|
|
CHECK(pack.initialize() == MapTilePackResult::STORAGE_UNAVAILABLE); CHECK(pack.status() == MapTilePackStatus::STORAGE_UNAVAILABLE);
|
|
}
|
|
void testChunkReadAndAutomaticEnd() {
|
|
beginTest(); FakeStorage storage; addSelection(storage, "one", manifestFor("one"));
|
|
const std::uint8_t tile[] = {1U, 2U, 3U}; storage.add("/pyxis-map/packs/one/tiles/2/1/1.png", tile, sizeof(tile));
|
|
MapTilePack pack(storage); CHECK(pack.initialize() == MapTilePackResult::OK); const std::size_t before = storage.end_calls;
|
|
std::uint32_t size = 0U; CHECK(pack.beginGet(TileKey{2U, 1U, 1U}, size) == MapTilePackResult::OK); CHECK(size == 3U);
|
|
std::uint8_t output[2] = {}; std::size_t count = 0U;
|
|
CHECK(pack.readGetChunk(output, sizeof(output), count) == MapTilePackResult::OK); CHECK(count == 2U && output[0] == 1U && output[1] == 2U);
|
|
CHECK(pack.readGetChunk(output, sizeof(output), count) == MapTilePackResult::OK); CHECK(count == 1U && output[0] == 3U);
|
|
CHECK(storage.end_calls == before + 1U);
|
|
CHECK(pack.readGetChunk(output, sizeof(output), count) == MapTilePackResult::NOT_STREAMING); CHECK(count == 0U);
|
|
}
|
|
void testReadErrorClosesAndArgumentsAreBounded() {
|
|
beginTest(); FakeStorage storage; addSelection(storage, "one", manifestFor("one")); const std::uint8_t tile[] = {1U};
|
|
storage.add("/pyxis-map/packs/one/tiles/2/1/1.png", tile, sizeof(tile)); MapTilePack pack(storage); CHECK(pack.initialize() == MapTilePackResult::OK);
|
|
std::uint32_t size = 0U; CHECK(pack.beginGet(TileKey{2U, 1U, 1U}, size) == MapTilePackResult::OK); storage.fail_read_call = 1U;
|
|
std::uint8_t output = 0U; std::size_t count = 55U; const std::size_t before = storage.end_calls;
|
|
CHECK(pack.readGetChunk(&output, 1U, count) == MapTilePackResult::IO_ERROR); CHECK(count == 0U); CHECK(storage.end_calls == before + 1U);
|
|
CHECK(pack.readGetChunk(&output, 1U, count) == MapTilePackResult::NOT_STREAMING);
|
|
storage.fail_read_call = 0U;
|
|
CHECK(pack.beginGet(TileKey{2U, 1U, 1U}, size) == MapTilePackResult::OK);
|
|
const std::size_t argument_before = storage.end_calls;
|
|
CHECK(pack.readGetChunk(NULL, 1U, count) == MapTilePackResult::INVALID_ARGUMENT);
|
|
CHECK(storage.end_calls == argument_before + 1U);
|
|
CHECK(pack.readGetChunk(&output, 1U, count) == MapTilePackResult::NOT_STREAMING);
|
|
}
|
|
void testPrematureEndCloses() {
|
|
beginTest(); FakeStorage storage; addSelection(storage, "one", manifestFor("one")); const std::uint8_t tile[] = {1U, 2U};
|
|
storage.add("/pyxis-map/packs/one/tiles/2/1/1.png", tile, sizeof(tile)); MapTilePack pack(storage); CHECK(pack.initialize() == MapTilePackResult::OK);
|
|
std::uint32_t size = 0U; CHECK(pack.beginGet(TileKey{2U, 1U, 1U}, size) == MapTilePackResult::OK); storage.zero_read_call = 1U;
|
|
std::uint8_t output[2]; std::size_t count = 0U; const std::size_t before = storage.end_calls;
|
|
CHECK(pack.readGetChunk(output, sizeof(output), count) == MapTilePackResult::IO_ERROR); CHECK(storage.end_calls == before + 1U);
|
|
}
|
|
void testReinitializeSelectionChange() {
|
|
beginTest(); FakeStorage storage; addSelection(storage, "one", manifestFor("one")); MapTilePack pack(storage);
|
|
CHECK(pack.initialize() == MapTilePackResult::OK); CHECK(std::strcmp(pack.metadata().pack_id, "one") == 0);
|
|
storage.clear(); addSelection(storage, "two", manifestFor("two"));
|
|
CHECK(pack.initialize() == MapTilePackResult::OK); CHECK(std::strcmp(pack.metadata().pack_id, "two") == 0);
|
|
}
|
|
void testFailedReinitializeIsTransactional() {
|
|
beginTest(); FakeStorage storage; addSelection(storage, "one", manifestFor("one")); MapTilePack pack(storage);
|
|
CHECK(pack.initialize() == MapTilePackResult::OK); storage.clear(); storage.addText(MapTilePack::ACTIVE_PACK_PATH, "bad/../id");
|
|
CHECK(pack.initialize() == MapTilePackResult::INVALID_PACK_ID); CHECK(pack.status() == MapTilePackStatus::READY);
|
|
CHECK(pack.hasSelection()); CHECK(std::strcmp(pack.metadata().pack_id, "one") == 0);
|
|
}
|
|
void testReinitializeAndDestructorCloseStreams() {
|
|
beginTest(); FakeStorage storage; addSelection(storage, "one", manifestFor("one")); const std::uint8_t tile[] = {1U};
|
|
storage.add("/pyxis-map/packs/one/tiles/2/1/1.png", tile, sizeof(tile));
|
|
{
|
|
MapTilePack pack(storage); CHECK(pack.initialize() == MapTilePackResult::OK); std::uint32_t size = 0U;
|
|
CHECK(pack.beginGet(TileKey{2U, 1U, 1U}, size) == MapTilePackResult::OK); const std::size_t before = storage.end_calls;
|
|
CHECK(pack.initialize() == MapTilePackResult::OK); CHECK(storage.end_calls > before);
|
|
CHECK(pack.beginGet(TileKey{2U, 1U, 1U}, size) == MapTilePackResult::OK);
|
|
}
|
|
CHECK(storage.open_file == NULL);
|
|
}
|
|
void testDeclaredLengthsAndEmbeddedNulFailClosed() {
|
|
beginTest();
|
|
FakeStorage marker_storage;
|
|
const std::uint8_t bad_marker[] = {'o', 'n', 'e', 0U, 'x'};
|
|
marker_storage.add(MapTilePack::ACTIVE_PACK_PATH, bad_marker, sizeof(bad_marker));
|
|
MapTilePack marker_pack(marker_storage);
|
|
CHECK(marker_pack.initialize() == MapTilePackResult::INVALID_PACK_ID);
|
|
|
|
FakeStorage short_marker;
|
|
addSelection(short_marker, "one", manifestFor("one"));
|
|
short_marker.setDeclaredSize(MapTilePack::ACTIVE_PACK_PATH, 2U);
|
|
MapTilePack short_marker_pack(short_marker);
|
|
CHECK(short_marker_pack.initialize() == MapTilePackResult::IO_ERROR);
|
|
|
|
FakeStorage trailing_manifest;
|
|
addSelection(trailing_manifest, "one", manifestFor("one"));
|
|
File* manifest = trailing_manifest.find("/pyxis-map/packs/one/manifest.pmp"); CHECK(manifest != NULL);
|
|
CHECK(manifest->size + 1U <= sizeof(manifest->bytes));
|
|
manifest->bytes[manifest->size++] = 0xa5U;
|
|
MapTilePack trailing_manifest_pack(trailing_manifest);
|
|
CHECK(trailing_manifest_pack.initialize() == MapTilePackResult::IO_ERROR);
|
|
}
|
|
void testTileDeclaredLengthCapsWritesAndProbesEof() {
|
|
beginTest(); FakeStorage storage; addSelection(storage, "one", manifestFor("one"));
|
|
const std::uint8_t tile[] = {1U, 2U};
|
|
storage.add("/pyxis-map/packs/one/tiles/2/1/1.png", tile, sizeof(tile));
|
|
storage.setDeclaredSize("/pyxis-map/packs/one/tiles/2/1/1.png", 1U);
|
|
MapTilePack pack(storage); CHECK(pack.initialize() == MapTilePackResult::OK);
|
|
std::uint32_t size = 0U; CHECK(pack.beginGet(TileKey{2U, 1U, 1U}, size) == MapTilePackResult::OK); CHECK(size == 1U);
|
|
std::uint8_t output[2] = {0xa5U, 0xa5U}; std::size_t count = 99U;
|
|
CHECK(pack.readGetChunk(output, sizeof(output), count) == MapTilePackResult::IO_ERROR);
|
|
CHECK(count == 0U); CHECK(output[1] == 0xa5U); CHECK(storage.open_file == NULL);
|
|
|
|
FakeStorage empty_storage; addSelection(empty_storage, "one", manifestFor("one"));
|
|
empty_storage.add("/pyxis-map/packs/one/tiles/2/1/1.png", NULL, 0U);
|
|
MapTilePack empty_pack(empty_storage); CHECK(empty_pack.initialize() == MapTilePackResult::OK);
|
|
size = 99U; CHECK(empty_pack.beginGet(TileKey{2U, 1U, 1U}, size) == MapTilePackResult::OK); CHECK(size == 0U);
|
|
count = 99U; CHECK(empty_pack.readGetChunk(output, sizeof(output), count) == MapTilePackResult::OK);
|
|
CHECK(count == 0U); CHECK(empty_storage.open_file == NULL);
|
|
}
|
|
void testCoreDoesNotAllocate() {
|
|
beginTest(); FakeStorage storage; addSelection(storage, "one", manifestFor("one")); const std::uint8_t tile[] = {7U};
|
|
storage.add("/pyxis-map/packs/one/tiles/2/1/1.png", tile, sizeof(tile)); const std::size_t before = allocations;
|
|
MapTilePack pack(storage); CHECK(pack.initialize() == MapTilePackResult::OK); std::uint32_t size = 0U;
|
|
CHECK(pack.beginGet(TileKey{2U, 1U, 1U}, size) == MapTilePackResult::OK); std::uint8_t output = 0U; std::size_t count = 0U;
|
|
CHECK(pack.readGetChunk(&output, 1U, count) == MapTilePackResult::OK); pack.endGet(); CHECK(allocations == before);
|
|
}
|
|
} // namespace
|
|
|
|
int main() {
|
|
testNoSelection(); testInvalidAndTraversalIds(); testMissingManifest(); testCorruptAndOversizedManifest();
|
|
testMarkerManifestMismatch(); testUncoveredKey(); testCoveredMissingFile(); testCanonicalPathsAndCapacity();
|
|
testStorageUnavailable(); testChunkReadAndAutomaticEnd(); testReadErrorClosesAndArgumentsAreBounded();
|
|
testPrematureEndCloses(); testReinitializeSelectionChange(); testFailedReinitializeIsTransactional();
|
|
testReinitializeAndDestructorCloseStreams(); testDeclaredLengthsAndEmbeddedNulFailClosed();
|
|
testTileDeclaredLengthCapsWritesAndProbesEof(); testCoreDoesNotAllocate();
|
|
std::cout << "map tile pack: " << tests_run << " tests passed\n";
|
|
return 0;
|
|
}
|