530 lines
22 KiB
C++
530 lines
22 KiB
C++
// mars::stream unit tests on hand-built byte fixtures (no game data).
|
|
#include <algorithm>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "mars/stream/dump.h"
|
|
#include "mars/stream/gzip.h"
|
|
#include "mars/stream/reader.h"
|
|
#include "mars/stream/save.h"
|
|
#include "mars/stream/writer.h"
|
|
|
|
using namespace mars::stream;
|
|
|
|
static int fails = 0;
|
|
#define CHECK(cond) \
|
|
do { \
|
|
if (!(cond)) { \
|
|
std::printf("FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); \
|
|
++fails; \
|
|
} \
|
|
} while (0)
|
|
#define CHECK_EQ(a, b) \
|
|
do { \
|
|
auto _a = (a); \
|
|
auto _b = (b); \
|
|
if (!(_a == _b)) { \
|
|
std::printf("FAIL %s:%d: %s == %s\n", __FILE__, __LINE__, #a, #b); \
|
|
++fails; \
|
|
} \
|
|
} while (0)
|
|
|
|
static Bytes B(std::initializer_list<int> v) {
|
|
Bytes b;
|
|
for (int x : v) b.push_back(uint8_t(x));
|
|
return b;
|
|
}
|
|
static Bytes cat(std::initializer_list<Bytes> parts) {
|
|
Bytes b;
|
|
for (const Bytes& p : parts) b.insert(b.end(), p.begin(), p.end());
|
|
return b;
|
|
}
|
|
static size_t count(const std::vector<Issue>& v, Issue::Level l) {
|
|
size_t n = 0;
|
|
for (const Issue& i : v) n += i.level == l;
|
|
return n;
|
|
}
|
|
|
|
// --- 1. primitive encodings and joint padding (bytes written by hand) -----------
|
|
static void test_primitives_bytes() {
|
|
// [len][name][value][pad to 4], padding computed over the whole item
|
|
const Bytes turn = B({4, 0, 0, 0, 'T', 'u', 'r', 'n', 1, 0, 0, 0}); // 12: no pad
|
|
const Bytes haltv = B({5, 0, 0, 0, 'h', 'a', 'l', 't', 'v', 1, 0, 0}); // 10 -> 12
|
|
const Bytes vnh = B({3, 0, 0, 0, 'v', 'n', 'h', 0}); // 8: no pad
|
|
const Bytes name = B({4, 0, 0, 0, 'N', 'a', 'm', 'e', 3, 0, 0, 0, 'S', 'o', 'l', 0}); // 15 -> 16
|
|
const Bytes key = B({3, 0, 0, 0, 'K', 'e', 'y', 0, 0, 0, 0, 0}); // empty string = 4 zero bytes
|
|
const Bytes incmod = B({6, 0, 0, 0, 'I', 'n', 'c', 'M', 'o', 'd', 0, 0, 0x80, 0x3f, 0, 0}); // float 1.0, 14 -> 16
|
|
const Bytes bats2 = B({5, 0, 0, 0, 'B', 'a', 't', 's', '2', 0x2a, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}); // int64 42: 17 -> 20
|
|
const Bytes dot = B({1, 0, 0, 0, '.', 7, 0, 0, 0, 0, 0, 0}); // "." int 7: 9 -> 12
|
|
|
|
Writer w;
|
|
w.int32("Turn", 1);
|
|
w.boolean("haltv", true);
|
|
w.boolean("vnh", false);
|
|
w.string("Name", "Sol");
|
|
w.string("Key", "");
|
|
w.float32("IncMod", 1.0f);
|
|
w.int64("Bats2", 42);
|
|
w.int32(".", 7);
|
|
CHECK(w.bytes() == cat({turn, haltv, vnh, name, key, incmod, bats2, dot}));
|
|
|
|
std::vector<Issue> issues;
|
|
Stats st;
|
|
Node root = read_tree(w.bytes(), &issues, &st); // with the save registry: all tags hinted
|
|
CHECK_EQ(root.children.size(), size_t(8));
|
|
const auto& c = root.children;
|
|
CHECK(c[0].name == "Turn" && c[0].kind == Kind::Int && c[0].as_int() == 1 && c[0].hinted);
|
|
CHECK(c[0].offset == 0 && c[0].size == 12);
|
|
CHECK(c[1].name == "haltv" && c[1].kind == Kind::Bool && c[1].as_bool() && c[1].size == 12);
|
|
CHECK(c[2].name == "vnh" && c[2].kind == Kind::Bool && !c[2].as_bool() && c[2].size == 8);
|
|
CHECK(c[3].name == "Name" && c[3].kind == Kind::String && c[3].as_string() == "Sol" && c[3].size == 16);
|
|
CHECK(c[4].name == "Key" && c[4].kind == Kind::String && c[4].as_string().empty() && c[4].size == 12);
|
|
CHECK(c[5].name == "IncMod" && c[5].kind == Kind::Float && c[5].as_float() == 1.0f && c[5].size == 16);
|
|
CHECK(c[6].name == "Bats2" && c[6].kind == Kind::Int64 && c[6].as_int64() == 42 && c[6].size == 20);
|
|
CHECK(c[7].name == "." && c[7].kind == Kind::Int && c[7].as_int() == 7 && !c[7].hinted);
|
|
CHECK_EQ(st.resyncs, 0u);
|
|
CHECK_EQ(count(issues, Issue::Warn), size_t(0));
|
|
CHECK_EQ(count(issues, Issue::Error), size_t(0));
|
|
|
|
// without any registry everything is guessed by layout + bit pattern
|
|
Node g = read_tree(w.bytes(), nullptr, nullptr, nullptr);
|
|
CHECK(g.children[0].kind == Kind::Int && !g.children[0].hinted);
|
|
CHECK(g.children[1].kind == Kind::Bool);
|
|
CHECK(g.children[3].kind == Kind::String);
|
|
CHECK(g.children[4].kind == Kind::Int && g.children[4].as_int() == 0); // empty string looks like int 0
|
|
CHECK(g.children[5].kind == Kind::Float); // 0x3f800000 is not a small int
|
|
CHECK(g.children[6].kind == Kind::Int64);
|
|
|
|
// round trip: the tree re-emits byte-identically
|
|
CHECK(write_tree(root) == w.bytes());
|
|
CHECK(write_tree(g) == w.bytes());
|
|
}
|
|
|
|
// --- 2. frames: nesting, tagless frame, empty frame, "." arrays ------------------
|
|
static void test_frames() {
|
|
Writer w;
|
|
w.begin("Summary");
|
|
w.string("GameName", "x");
|
|
w.begin("Players"); // VectorHelper: "." count + "." elements
|
|
w.int32(".", 2);
|
|
w.begin(".");
|
|
w.int32("Rank", 1);
|
|
w.end();
|
|
w.begin(".");
|
|
w.int32("Rank", 2);
|
|
w.end();
|
|
w.end();
|
|
w.begin("Empty");
|
|
w.end();
|
|
w.begin_tagless();
|
|
w.float32(".", 2.5f);
|
|
w.end();
|
|
w.end();
|
|
// expected framing bytes for the head: [7]"Summary"[pad] BEEFBEEF
|
|
const Bytes head = B({7, 0, 0, 0, 'S', 'u', 'm', 'm', 'a', 'r', 'y', 0, 0xef, 0xbe, 0xef, 0xbe});
|
|
CHECK(std::equal(head.begin(), head.end(), w.bytes().begin()));
|
|
const Bytes tail = B({0x10, 0x41, 0x10, 0x41});
|
|
CHECK(std::equal(tail.begin(), tail.end(), w.bytes().end() - 4));
|
|
|
|
std::vector<Issue> issues;
|
|
Stats st;
|
|
Node root = read_tree(w.bytes(), &issues, &st);
|
|
CHECK_EQ(root.children.size(), size_t(1));
|
|
const Node& s = root.children[0];
|
|
CHECK(s.is_complex() && s.name == "Summary" && s.offset == 0 && s.size == w.size());
|
|
CHECK_EQ(s.children.size(), size_t(4));
|
|
const Node& players = s.children[1];
|
|
CHECK(players.is_complex() && players.children.size() == 3);
|
|
CHECK(players.children[0].name == "." && players.children[0].as_int() == 2);
|
|
CHECK(players.children[1].is_complex() && players.children[1].name == ".");
|
|
CHECK(players.children[2].children[0].name == "Rank" && players.children[2].children[0].as_int() == 2);
|
|
CHECK(s.children[2].is_complex() && s.children[2].children.empty());
|
|
CHECK(s.children[3].is_complex() && !s.children[3].tagged && s.children[3].children.size() == 1);
|
|
CHECK(s.children[3].children[0].as_float() == 2.5f);
|
|
CHECK_EQ(st.frames, 6u);
|
|
CHECK_EQ(st.resyncs, 0u);
|
|
CHECK(write_tree(root) == w.bytes());
|
|
|
|
// the dump prints frames with item count and size, tagless as <tagless>
|
|
auto lines = dump_tree(root);
|
|
CHECK(lines.size() == 17);
|
|
CHECK(lines[0] == "@00000000 Summary { # 4 items, " + std::to_string(w.size()) + " bytes");
|
|
CHECK(lines[1] == "@00000010 GameName string \"x\"");
|
|
CHECK(lines[13].find("<tagless> {") != std::string::npos);
|
|
}
|
|
|
|
// --- 3. resync: garbage inside a frame becomes raw; the walk continues ----------
|
|
// (both fixtures were checked against the reference reader: same tree, same
|
|
// stats, one warning each)
|
|
static void test_resync() {
|
|
Bytes tail;
|
|
{
|
|
Writer t;
|
|
t.begin("B");
|
|
t.int32("z", 2);
|
|
t.end();
|
|
tail = t.take();
|
|
}
|
|
// case A: no tag at all after a nested frame -> unnamed raw, resync to the next plausible tag
|
|
{
|
|
Writer w;
|
|
w.begin("A");
|
|
w.begin("C");
|
|
w.end();
|
|
Bytes s = w.take();
|
|
s.insert(s.end(), 12, 0xff);
|
|
Writer y;
|
|
y.string("y", std::string(80, 'y'));
|
|
y.end();
|
|
Bytes yb = y.take();
|
|
s = cat({s, yb, tail});
|
|
std::vector<Issue> issues;
|
|
Stats st;
|
|
Node root = read_tree(s, &issues, &st);
|
|
CHECK_EQ(root.children.size(), size_t(2));
|
|
const Node& a = root.children[0];
|
|
CHECK(a.name == "A" && a.children.size() == 3 && a.size == 136);
|
|
CHECK(a.children[0].name == "C" && a.children[0].children.empty() && a.children[0].size == 16);
|
|
const Node& r = a.children[1];
|
|
CHECK(r.kind == Kind::Raw && !r.tagged && r.raw.size() == 12 && r.offset == 0x1c);
|
|
CHECK(a.children[2].name == "y" && a.children[2].kind == Kind::String && a.children[2].as_string().size() == 80);
|
|
CHECK(root.children[1].name == "B" && root.children[1].children[0].as_int() == 2);
|
|
CHECK_EQ(st.resyncs, 1u);
|
|
CHECK_EQ(st.raw_bytes, 12u);
|
|
CHECK_EQ(count(issues, Issue::Warn), size_t(1));
|
|
CHECK(write_tree(root) == s); // raw nodes re-emit exactly
|
|
auto lines = dump_tree(root);
|
|
CHECK(lines[3] == "@0000001c <tagless> raw[12] ffffffffffffffffffffffff");
|
|
}
|
|
// case B: a fine-looking tag whose value fits no layout -> tagged raw up to the next tag
|
|
{
|
|
Bytes s = B({3, 0, 0, 0, 'a', 'b', 'c', 5});
|
|
s.insert(s.end(), 12, 0xff);
|
|
Writer w;
|
|
w.int32("y", 2);
|
|
w.end();
|
|
Bytes head;
|
|
{
|
|
Writer h;
|
|
h.begin("A");
|
|
head = h.take();
|
|
}
|
|
s = cat({head, s, w.take(), tail});
|
|
std::vector<Issue> issues;
|
|
Stats st;
|
|
Node root = read_tree(s, &issues, &st);
|
|
const Node& a = root.children[0];
|
|
CHECK(a.children.size() == 2 && a.size == 48);
|
|
CHECK(a.children[0].name == "abc" && a.children[0].kind == Kind::Raw && a.children[0].tagged);
|
|
CHECK(a.children[0].raw.size() == 13 && a.children[0].raw[0] == 5);
|
|
CHECK(a.children[1].name == "y" && a.children[1].as_int() == 2 && a.children[1].offset == 0x20);
|
|
CHECK_EQ(st.resyncs, 1u);
|
|
CHECK_EQ(st.raw_bytes, 13u);
|
|
CHECK_EQ(count(issues, Issue::Warn), size_t(1));
|
|
CHECK(issues[0].msg.find("no value layout fits; skipped 13 bytes to tag") != std::string::npos);
|
|
CHECK(write_tree(root) == s);
|
|
}
|
|
|
|
// unnamed 12-byte payload right before END is only an info (Vector3 fallback)
|
|
Bytes v3;
|
|
{
|
|
Writer t;
|
|
t.begin("Pos");
|
|
t.end();
|
|
v3 = t.take();
|
|
Bytes body = B({0, 0, 0x80, 0x3f, 0, 0, 0, 0x40, 0, 0, 0x40, 0x40});
|
|
v3.insert(v3.end() - 4, body.begin(), body.end());
|
|
}
|
|
std::vector<Issue> issues;
|
|
Stats st;
|
|
Node r3 = read_tree(v3, &issues, &st);
|
|
CHECK(r3.children[0].children.size() == 1 && r3.children[0].children[0].kind == Kind::Raw);
|
|
CHECK_EQ(count(issues, Issue::Info), size_t(1));
|
|
CHECK_EQ(count(issues, Issue::Warn), size_t(0));
|
|
// and the shape layer reads it as a vec3
|
|
std::vector<Issue> si;
|
|
ReadArchive ar(r3.children, si, "");
|
|
Vec3 v;
|
|
ar.vec3(A("Pos"), v);
|
|
CHECK(v.x == 1.f && v.y == 2.f && v.z == 3.f);
|
|
|
|
// a stray END at top level and trailing bytes are reported, not fatal
|
|
Bytes stray = B({0x10, 0x41, 0x10, 0x41, 1, 2});
|
|
issues.clear();
|
|
Node r4 = read_tree(stray, &issues, &st);
|
|
CHECK(r4.children.size() == 2);
|
|
CHECK(count(issues, Issue::Warn) >= 2);
|
|
CHECK(write_tree(r4) == stray);
|
|
}
|
|
|
|
// --- 4. cp1252 string values never veto layout when the tag is known ------------
|
|
static void test_cp1252() {
|
|
Writer w;
|
|
w.boolean("haltv", true);
|
|
w.string("Name", std::string("Kor\x92Voth")); // 0x92 = right single quote
|
|
w.int32("VFlags", 3);
|
|
std::vector<Issue> issues;
|
|
Stats st;
|
|
Node root = read_tree(w.bytes(), &issues, &st);
|
|
CHECK_EQ(root.children.size(), size_t(3));
|
|
CHECK(root.children[0].kind == Kind::Bool && root.children[0].hinted);
|
|
CHECK(root.children[1].kind == Kind::String && root.children[1].as_string() == "Kor\x92Voth");
|
|
CHECK(root.children[2].kind == Kind::Int && root.children[2].as_int() == 3);
|
|
CHECK_EQ(st.hint_failures, 0u);
|
|
auto lines = dump_tree(root);
|
|
CHECK(lines[1] == "@0000000c Name string \"Kor\\u2019Voth\"");
|
|
// guessing an unknown tag still accepts every cp1252-defined byte
|
|
Writer g;
|
|
g.string("zz", std::string("caf\xe9"));
|
|
g.int32("q", 1);
|
|
Node r2 = read_tree(g.bytes(), nullptr, nullptr, nullptr);
|
|
CHECK(r2.children[0].kind == Kind::String);
|
|
}
|
|
|
|
// --- 5. hints: registry types Summary children positionally and by name ---------
|
|
static void test_hints() {
|
|
Writer w;
|
|
w.begin("Summary");
|
|
w.string("GameName", "g");
|
|
w.int32("Turn", 0); // 0 either way
|
|
w.int32("NumSys", 0);
|
|
w.int32("Checksum", 0);
|
|
w.begin("Players");
|
|
w.int32(".", 0);
|
|
w.end();
|
|
w.begin("Session");
|
|
w.begin("TMRS");
|
|
w.float32("TSTL", 0.0f); // 0.0f: guessed would be int 0
|
|
w.end();
|
|
w.end();
|
|
w.int32("MapShape", 0);
|
|
w.float32("IncMod", 0.0f);
|
|
w.end();
|
|
Node root = read_tree(w.bytes());
|
|
const Node& s = root.children[0];
|
|
CHECK(s.hinted);
|
|
CHECK(s.children[0].kind == Kind::String && s.children[0].hinted);
|
|
CHECK(s.children[4].hinted); // Players CArr
|
|
CHECK(s.children[4].children[0].kind == Kind::Int && s.children[4].children[0].hinted);
|
|
const Node& tstl = s.children[5].children[0].children[0];
|
|
CHECK(tstl.kind == Kind::Float && tstl.hinted && tstl.as_float() == 0.f);
|
|
CHECK(s.children[7].kind == Kind::Float && s.children[7].hinted); // IncMod by name
|
|
// the registry knows the top-level shapes and the RNG raw frame
|
|
const Registry& reg = save_registry();
|
|
CHECK(reg.shape("Summary") && reg.shape("Sim") && reg.shape("Sys") && reg.shape("Player"));
|
|
CHECK(reg.shape("RNG") && reg.shape("RNG")->type == Desc::Raw);
|
|
CHECK(reg.kind("GameName") == Prim::String && reg.kind("Bats2") == Prim::Int64 && reg.kind("haltv") == Prim::Bool);
|
|
CHECK(reg.kind(".") == Prim::None);
|
|
CHECK(reg.kind("Team") == Prim::Int); // int in Slot and Player; the frame is a separate shape entry
|
|
CHECK(reg.shape("Team") != nullptr);
|
|
CHECK(reg.kind("pop") == Prim::Int64 && reg.shape("pop") != nullptr); // int64 in stats, Population frame in Ship
|
|
}
|
|
|
|
// --- 6. RNG raw frame: body read straight to the END marker ---------------------
|
|
static void test_raw_frame() {
|
|
Bytes blob(2500, 0xAB);
|
|
Writer w;
|
|
w.begin("RNG");
|
|
w.raw(".", blob);
|
|
w.end();
|
|
w.int32("Map", 1);
|
|
std::vector<Issue> issues;
|
|
Stats st;
|
|
Node root = read_tree(w.bytes(), &issues, &st);
|
|
CHECK(root.children[0].children.size() == 1);
|
|
const Node& r = root.children[0].children[0];
|
|
CHECK(r.kind == Kind::Raw && r.name == "." && r.raw.size() == 2503); // 2500 + 3 joint-padding bytes
|
|
CHECK_EQ(st.raw_bytes, 2503u);
|
|
CHECK(root.children[1].as_int() == 1);
|
|
CHECK(write_tree(root) == w.bytes());
|
|
}
|
|
|
|
// --- 7. typed shapes: Summary write -> bytes -> read; and hand-checked bytes ------
|
|
static void test_typed_summary() {
|
|
shapes::Summary s;
|
|
s.gameName = "Test";
|
|
s.turn = 7;
|
|
s.numSys = 3;
|
|
s.checksum = 99;
|
|
shapes::PlayerInfo p;
|
|
p.slot.isPlay = true;
|
|
p.slot.fxNm = "re";
|
|
p.slot.fxCrID.idx = -1;
|
|
p.slot.fxCrID.r = 10;
|
|
p.slot.fxCrID.g = 20;
|
|
p.slot.fxCrID.b = 30;
|
|
p.slot.tag = 1466349286;
|
|
p.slot.team = -1;
|
|
p.slot.settings.treasury = 50000;
|
|
p.rank = 2;
|
|
s.players.push_back(p);
|
|
s.session.tmrs.tctl = 240.f;
|
|
s.incMod = 1.f;
|
|
s.resMod = 1.f;
|
|
s.alliances = true;
|
|
s.encounters = true;
|
|
|
|
Writer w;
|
|
WriteArchive wa(w);
|
|
wa.obj(A("Summary"), s);
|
|
Bytes bytes = w.take();
|
|
|
|
// spot-check the head bytes by hand: frame tag, GameName, Turn
|
|
Bytes head = B({7, 0, 0, 0, 'S', 'u', 'm', 'm', 'a', 'r', 'y', 0, 0xef, 0xbe, 0xef, 0xbe,
|
|
8, 0, 0, 0, 'G', 'a', 'm', 'e', 'N', 'a', 'm', 'e', 4, 0, 0, 0, 'T', 'e', 's', 't',
|
|
4, 0, 0, 0, 'T', 'u', 'r', 'n', 7, 0, 0, 0});
|
|
CHECK(bytes.size() > head.size() && std::equal(head.begin(), head.end(), bytes.begin()));
|
|
|
|
std::vector<Issue> issues;
|
|
Stats st;
|
|
Node root = read_tree(bytes, &issues, &st);
|
|
CHECK_EQ(st.resyncs, 0u);
|
|
CHECK_EQ(st.hint_failures, 0u);
|
|
shapes::Summary back;
|
|
ReadArchive ra(root.children, issues, "");
|
|
ra.obj(A("Summary"), back);
|
|
CHECK_EQ(count(issues, Issue::Error), size_t(0));
|
|
CHECK_EQ(count(issues, Issue::Warn), size_t(0));
|
|
CHECK(back.gameName == "Test" && back.turn == 7 && back.numSys == 3 && back.checksum == 99);
|
|
CHECK(back.players.size() == 1 && back.players[0].rank == 2);
|
|
CHECK(back.players[0].slot.fxNm == "re" && back.players[0].slot.tag == 1466349286);
|
|
CHECK(back.players[0].slot.fxCrID.idx == -1 && back.players[0].slot.fxCrID.b == 30);
|
|
CHECK(back.players[0].slot.settings.treasury == 50000);
|
|
CHECK(back.session.tmrs.tctl == 240.f && back.incMod == 1.f && back.alliances && !back.teams);
|
|
CHECK(back.scenario.empty());
|
|
|
|
// and back out: byte-identical
|
|
Writer w2;
|
|
WriteArchive wa2(w2);
|
|
wa2.obj(A("Summary"), back);
|
|
CHECK(w2.bytes() == bytes);
|
|
|
|
// the "." positional items are reported as info, never warn
|
|
CHECK(count(issues, Issue::Info) >= 4); // FxCrID idx/r/g/b, Settings x4, Players count/elements
|
|
|
|
// a missing confirmed field is an error; an unexpected item before it a warning
|
|
Writer w3;
|
|
w3.begin("Summary");
|
|
w3.string("GameName", "g");
|
|
w3.int32("Bogus", 1);
|
|
w3.int32("Turn", 2);
|
|
w3.end();
|
|
Node r3 = read_tree(w3.bytes());
|
|
std::vector<Issue> i3;
|
|
shapes::Summary s3;
|
|
ReadArchive ra3(r3.children, i3, "");
|
|
ra3.obj(A("Summary"), s3);
|
|
CHECK(s3.turn == 2);
|
|
CHECK(count(i3, Issue::Warn) >= 1);
|
|
CHECK(count(i3, Issue::Error) >= 1); // NumSys and the rest are missing
|
|
}
|
|
|
|
// --- 8. conditionals, optionals and inline arrays through the archives ------------
|
|
static void test_typed_conditionals() {
|
|
shapes::Ship ship;
|
|
ship.desID = 5;
|
|
ship.hbq = true;
|
|
shapes::BuildOrder o;
|
|
o.desID = 9;
|
|
ship.bq2.orders.push_back(o);
|
|
ship.hsp = false;
|
|
ship.prisH.prMax = 2;
|
|
ship.prisH.prisoners.push_back({3, 4});
|
|
ship.thrusters.push_back({1.5f, 2.5f});
|
|
Writer w;
|
|
WriteArchive wa(w);
|
|
wa.obj(A("Ship"), ship);
|
|
Node root = read_tree(w.bytes());
|
|
std::vector<Issue> issues;
|
|
shapes::Ship back;
|
|
ReadArchive ra(root.children, issues, "");
|
|
ra.obj(A("Ship"), back);
|
|
CHECK_EQ(count(issues, Issue::Error), size_t(0));
|
|
CHECK_EQ(count(issues, Issue::Warn), size_t(0));
|
|
CHECK(back.hbq && back.bq2.orders.size() == 1 && back.bq2.orders[0].desID == 9);
|
|
CHECK(!back.hsp && back.pop.groups.empty());
|
|
CHECK(back.prisH.prMax == 2 && back.prisH.prisoners.size() == 1 && back.prisH.prisoners[0].prNum == 4);
|
|
CHECK(back.thrusters.size() == 1 && back.thrusters[0].thm == 2.5f);
|
|
Writer w2;
|
|
WriteArchive wa2(w2);
|
|
wa2.obj(A("Ship"), back);
|
|
CHECK(w2.bytes() == w.bytes());
|
|
|
|
// Fleet: optional legacy tags absent, HFPlan false -> no FPlan; Sys: vnh gate
|
|
shapes::Fleet f;
|
|
f.ftName = "Fleet 1";
|
|
f.hfPlan = true;
|
|
shapes::Waypoint wp;
|
|
wp.wpt = 272;
|
|
f.fplan.wpts.push_back(wp);
|
|
Writer w3;
|
|
WriteArchive wa3(w3);
|
|
wa3.obj(A("Flt"), f);
|
|
Node r3 = read_tree(w3.bytes());
|
|
shapes::Fleet fb;
|
|
ReadArchive ra3(r3.children, issues, "");
|
|
ra3.obj(A("Flt"), fb);
|
|
CHECK(fb.hfPlan && fb.fplan.wpts.size() == 1 && fb.fplan.wpts[0].wpt == 272 && fb.fplan.wpts[0].nrtFramed);
|
|
CHECK(!fb.sysID && !fb.caps);
|
|
CHECK(fb.ftName == "Fleet 1");
|
|
Writer w4;
|
|
WriteArchive wa4(w4);
|
|
wa4.obj(A("Flt"), fb);
|
|
CHECK(w4.bytes() == w3.bytes());
|
|
CHECK_EQ(count(issues, Issue::Error), size_t(0));
|
|
}
|
|
|
|
// --- 9. gzip container ---------------------------------------------------------------
|
|
static void test_gzip() {
|
|
Bytes data;
|
|
for (int i = 0; i < 5000; ++i) data.push_back(uint8_t(i * 7));
|
|
Bytes gz = gzip(data.data(), data.size());
|
|
CHECK(is_gzip(gz.data(), gz.size()));
|
|
CHECK(gunzip(gz.data(), gz.size()) == data);
|
|
CHECK(inflate_container(data.data(), data.size()) == data); // not gzip: passthrough
|
|
bool threw = false;
|
|
try {
|
|
Bytes bad = gz;
|
|
bad[bad.size() / 2] ^= 0xff;
|
|
gunzip(bad.data(), bad.size());
|
|
} catch (const GzipError&) {
|
|
threw = true;
|
|
}
|
|
CHECK(threw);
|
|
}
|
|
|
|
// --- 10. dump formatting: Python float repr and JSON quoting ---------------------------
|
|
static void test_dump_format() {
|
|
CHECK_EQ(py_float_repr(240.0), std::string("240.0"));
|
|
CHECK_EQ(py_float_repr(1.0), std::string("1.0"));
|
|
CHECK_EQ(py_float_repr(0.0), std::string("0.0"));
|
|
CHECK_EQ(py_float_repr(double(3.4028235e38f)), std::string("3.4028234663852886e+38"));
|
|
CHECK_EQ(py_float_repr(double(bits_f32(0x0000002a))), std::string("5.885453550164232e-44"));
|
|
CHECK_EQ(py_float_repr(1e-05), std::string("1e-05"));
|
|
CHECK_EQ(py_float_repr(0.0001), std::string("0.0001"));
|
|
CHECK_EQ(py_float_repr(1e16), std::string("1e+16"));
|
|
CHECK_EQ(py_float_repr(1234567890123456.0), std::string("1234567890123456.0"));
|
|
CHECK_EQ(py_float_repr(double(-0.18487215f)), std::string("-0.18487215042114258"));
|
|
CHECK_EQ(py_float_repr(double(2.4307494f)), std::string("2.4307494163513184"));
|
|
CHECK_EQ(json_quote_cp1252("a\"b\\c\n"), std::string("\"a\\\"b\\\\c\\n\""));
|
|
CHECK_EQ(json_quote_cp1252(std::string("Kor\x92Voth")), std::string("\"Kor\\u2019Voth\""));
|
|
CHECK_EQ(json_quote_cp1252(std::string("\x81")), std::string("\"\\ufffd\""));
|
|
CHECK_EQ(json_quote_cp1252(std::string("caf\xe9")), std::string("\"caf\\u00e9\""));
|
|
}
|
|
|
|
int main() {
|
|
test_primitives_bytes();
|
|
test_frames();
|
|
test_resync();
|
|
test_cp1252();
|
|
test_hints();
|
|
test_raw_frame();
|
|
test_typed_summary();
|
|
test_typed_conditionals();
|
|
test_gzip();
|
|
test_dump_format();
|
|
std::printf("test_stream: %s (%d failures)\n", fails ? "FAILED" : "ok", fails);
|
|
return fails ? 1 : 0;
|
|
}
|