425 lines
18 KiB
C++
425 lines
18 KiB
C++
// Emitter golden tests (byte-exact strings derived from TRACE_FORMAT.md section 4 and the
|
|
// mkfixture.py reference emitter) + a fixture file that oracle_emit.py regenerates with
|
|
// mkfixture's own emit_record() and compares byte for byte.
|
|
#include "shim/trace/emitter.h"
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <cstdio>
|
|
#include <limits>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "check.h"
|
|
#include "harness.h"
|
|
|
|
using namespace shim::trace;
|
|
|
|
static std::string esc(const std::string& s) {
|
|
Buf b;
|
|
emit_esc(b, s);
|
|
return b.str();
|
|
}
|
|
static std::string escw(std::vector<std::uint16_t> u) {
|
|
Buf b;
|
|
emit_esc_w(b, u.data(), u.size());
|
|
return b.str();
|
|
}
|
|
static std::string tvs(const Tv& v) { return canonical(v); }
|
|
|
|
static const char* kSha512 = "110009dcee21620b166f3abfecb5eff7a873be729d1c2d53822e7acc5f34eb9b";
|
|
|
|
static void golden_strings() {
|
|
// section 4 rule 2; the same inputs test_tracecmp.py feeds mkfixture.esc()
|
|
CHECK_STR(esc("plain"), "\"plain\"");
|
|
CHECK_STR(esc("R\xe9sum\xe9"), "\"R\\u00e9sum\\u00e9\"");
|
|
CHECK_STR(esc("Tab\tKey"), "\"Tab\\tKey\"");
|
|
CHECK_STR(esc("Quote\"d"), "\"Quote\\\"d\"");
|
|
CHECK_STR(esc("Back\\slash"), "\"Back\\\\slash\"");
|
|
CHECK_STR(esc("nl\nx"), "\"nl\\nx\"");
|
|
CHECK_STR(esc("cr\rx"), "\"cr\\rx\"");
|
|
CHECK_STR(esc("\x01\x7f\xff\x80"), "\"\\u0001\\u007f\\u00ff\\u0080\"");
|
|
CHECK_STR(esc("\x08\x0c"), "\"\\u0008\\u000c\"");
|
|
CHECK_STR(esc(std::string("a\0b", 3)), "\"a\\u0000b\"");
|
|
CHECK_STR(escw({0x41, 0x20ac, 0x7e, 0x7f, 0xffff, 0x0a}), "\"A\\u20ac~\\u007f\\uffff\\n\"");
|
|
}
|
|
|
|
static void golden_numbers() {
|
|
CHECK_STR(tvs(tv::f32(1.5f)), "{\"t\":\"f32\",\"v\":1.5}");
|
|
CHECK_STR(tvs(tv::f32(0.1f)), "{\"t\":\"f32\",\"v\":0.100000001}");
|
|
CHECK_STR(tvs(tv::f32(-2.5e-7f)), "{\"t\":\"f32\",\"v\":-2.49999999e-07}");
|
|
CHECK_STR(tvs(tv::f32(1e30f)), "{\"t\":\"f32\",\"v\":1.00000002e+30}");
|
|
CHECK_STR(tvs(tv::f32(3.0f)), "{\"t\":\"f32\",\"v\":3}");
|
|
CHECK_STR(tvs(tv::f32(123456789.0f)), "{\"t\":\"f32\",\"v\":123456792}");
|
|
CHECK_STR(tvs(tv::f32(std::numeric_limits<float>::quiet_NaN())), "{\"t\":\"f32\",\"v\":\"nan\"}");
|
|
CHECK_STR(tvs(tv::f32(-std::numeric_limits<float>::infinity())), "{\"t\":\"f32\",\"v\":\"-inf\"}");
|
|
CHECK_STR(tvs(tv::f64(std::numeric_limits<double>::infinity())), "{\"t\":\"f64\",\"v\":\"inf\"}");
|
|
CHECK_STR(tvs(tv::f64(0.1)), "{\"t\":\"f64\",\"v\":0.10000000000000001}");
|
|
CHECK_STR(tvs(tv::f64(1e300)), "{\"t\":\"f64\",\"v\":1.0000000000000001e+300}");
|
|
CHECK_STR(tvs(tv::f64(0.0)), "{\"t\":\"f64\",\"v\":0}");
|
|
CHECK_STR(tvs(tv::f64(-0.0)), "{\"t\":\"f64\",\"v\":-0}");
|
|
|
|
CHECK_STR(tvs(tv::u64(18446744073709551615ull)), "{\"t\":\"u64\",\"v\":\"18446744073709551615\"}");
|
|
CHECK_STR(tvs(tv::u64(9007199254740992ull)), "{\"t\":\"u64\",\"v\":\"9007199254740992\"}"); // 2^53 -> string
|
|
CHECK_STR(tvs(tv::u64(9007199254740991ull)), "{\"t\":\"u64\",\"v\":9007199254740991}"); // 2^53-1 -> int
|
|
CHECK_STR(tvs(tv::i64(-9007199254740992ll)), "{\"t\":\"i64\",\"v\":\"-9007199254740992\"}");
|
|
CHECK_STR(tvs(tv::i64(-9007199254740991ll)), "{\"t\":\"i64\",\"v\":-9007199254740991}");
|
|
CHECK_STR(tvs(tv::i8(-128)), "{\"t\":\"i8\",\"v\":-128}");
|
|
CHECK_STR(tvs(tv::i16(32767)), "{\"t\":\"i16\",\"v\":32767}");
|
|
CHECK_STR(tvs(tv::i32(-3).named("value")), "{\"t\":\"i32\",\"v\":-3,\"n\":\"value\"}");
|
|
CHECK_STR(tvs(tv::u8(255)), "{\"t\":\"u8\",\"v\":255}");
|
|
CHECK_STR(tvs(tv::u16(65535)), "{\"t\":\"u16\",\"v\":65535}");
|
|
CHECK_STR(tvs(tv::u32(4294967295u)), "{\"t\":\"u32\",\"v\":4294967295}");
|
|
CHECK_STR(tvs(tv::boolean(true)), "{\"t\":\"bool\",\"v\":true}");
|
|
CHECK_STR(tvs(tv::null()), "{\"t\":\"null\",\"v\":null}");
|
|
CHECK_STR(tvs(tv::ptr(static_cast<std::uintptr_t>(0xa36fd0)).named("table")), "{\"t\":\"ptr\",\"v\":\"0x00a36fd0\",\"n\":\"table\"}");
|
|
CHECK_STR(tvs(tv::ptr(static_cast<std::uintptr_t>(0))), "{\"t\":\"ptr\",\"v\":\"0x00000000\"}");
|
|
CHECK_STR(tvs(tv::enum_(2, "MF_0").named("f")), "{\"t\":\"enum\",\"v\":2,\"name\":\"MF_0\",\"n\":\"f\"}");
|
|
CHECK_STR(tvs(tv::enum_(-1)), "{\"t\":\"enum\",\"v\":-1}");
|
|
CHECK_STR(tvs(tv::str("R\xe9sum\xe9").named("key")), "{\"t\":\"str\",\"v\":\"R\\u00e9sum\\u00e9\",\"n\":\"key\"}");
|
|
CHECK_STR(tvs(tv::str(nullptr)), "{\"t\":\"ptr\",\"v\":\"0x00000000\"}");
|
|
const std::uint16_t w[] = {0x41, 0x20ac};
|
|
CHECK_STR(tvs(tv::wstr(w, 2)), "{\"t\":\"wstr\",\"v\":\"A\\u20ac\"}");
|
|
CHECK_STR(tvs(tv::json("{\"a\":[1,2.5,\"x\"]}")), "{\"t\":\"json\",\"v\":{\"a\":[1,2.5,\"x\"]}}");
|
|
}
|
|
|
|
static void golden_bytes_and_containers() {
|
|
CHECK_STR(tvs(tv::bytes("\x00\xff", 2, 256)),
|
|
"{\"t\":\"bytes\",\"n\":2,\"sha256\":\"06eb7d6a69ee19e5fbdf749018d3d2abfa04bcbd1365db312eb86dc7169389b8\",\"hex\":\"00ff\"}");
|
|
CHECK_STR(tvs(tv::bytes("", 0, 256)),
|
|
"{\"t\":\"bytes\",\"n\":0,\"sha256\":\"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\",\"hex\":\"\"}");
|
|
std::vector<std::uint8_t> big;
|
|
for (int k = 0; k < 2; ++k)
|
|
for (int i = 0; i < 256; ++i) big.push_back(static_cast<std::uint8_t>(i));
|
|
CHECK_STR(tvs(tv::bytes(big.data(), big.size(), 256)),
|
|
std::string("{\"t\":\"bytes\",\"n\":512,\"sha256\":\"") + kSha512 +
|
|
"\",\"head\":\"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f\"}");
|
|
// exactly inline_max stays inline; inline_max+1 does not
|
|
CHECK(tvs(tv::bytes(big.data(), 256, 256)).find("\"hex\"") != std::string::npos);
|
|
CHECK(tvs(tv::bytes(big.data(), 257, 256)).find("\"head\"") != std::string::npos);
|
|
// bytes never carry a name even if one is set
|
|
CHECK_STR(tvs(tv::bytes("", 0, 256).named("x")),
|
|
"{\"t\":\"bytes\",\"n\":0,\"sha256\":\"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\",\"hex\":\"\"}");
|
|
|
|
std::vector<Tv> items;
|
|
items.push_back(tv::i32(1));
|
|
items.push_back(tv::str("a"));
|
|
CHECK_STR(tvs(tv::list(items)), "{\"t\":\"list\",\"v\":[{\"t\":\"i32\",\"v\":1},{\"t\":\"str\",\"v\":\"a\"}]}");
|
|
CHECK_STR(tvs(tv::set(items).named("s")), "{\"t\":\"set\",\"v\":[{\"t\":\"i32\",\"v\":1},{\"t\":\"str\",\"v\":\"a\"}],\"n\":\"s\"}");
|
|
CHECK_STR(tvs(tv::list({})), "{\"t\":\"list\",\"v\":[]}");
|
|
Tv st = tv::struct_();
|
|
st.add("id", tv::u32(7)).add("na\"me", tv::str("w7"));
|
|
CHECK_STR(tvs(st), "{\"t\":\"struct\",\"v\":{\"id\":{\"t\":\"u32\",\"v\":7},\"na\\\"me\":{\"t\":\"str\",\"v\":\"w7\"}}}");
|
|
CHECK_STR(tvs(tv::struct_()), "{\"t\":\"struct\",\"v\":{}}");
|
|
}
|
|
|
|
static void golden_records() {
|
|
Record r;
|
|
r.ts = 1;
|
|
r.hook = "X";
|
|
r.mode = Mode::Trace;
|
|
r.call_id = 900;
|
|
r.thread = 1;
|
|
Buf b;
|
|
emit_record(b, r);
|
|
// == mkfixture.invalid_lines()[0], the harness's own minimal valid record
|
|
CHECK_STR(b.str(), "{\"ts\":1,\"hook\":\"X\",\"mode\":\"trace\",\"call_id\":900,\"thread\":1,\"args\":[],\"ret\":null,\"side\":{}}\n");
|
|
|
|
Record c;
|
|
c.ts = 1;
|
|
c.hook = "X";
|
|
c.mode = Mode::Compare;
|
|
c.call_id = 4;
|
|
c.thread = 1;
|
|
c.depth = 0;
|
|
c.args.push_back(tv::i32(1).named("a"));
|
|
c.ret = tv::boolean(true);
|
|
SideEntry se;
|
|
se.name = "r";
|
|
se.before_kind = SideEntry::Value;
|
|
se.before = tv::null();
|
|
se.after = tv::i32(2);
|
|
c.side.push_back(se);
|
|
SideEntry sn;
|
|
sn.name = "q";
|
|
sn.before_kind = SideEntry::IsNull;
|
|
sn.after = tv::i32(0);
|
|
c.side.push_back(sn);
|
|
c.has_ours = true;
|
|
c.ours_ret = tv::boolean(false);
|
|
c.ours_side.push_back({"r", tv::i32(3)});
|
|
c.ours_side.push_back({"q", tv::i32(0)});
|
|
c.diverged = 1;
|
|
c.has_diff = true;
|
|
DiffEntry d;
|
|
d.path = "ret";
|
|
d.why = "exact";
|
|
d.orig = tv::boolean(true);
|
|
d.ours = tv::boolean(false);
|
|
c.diff.push_back(d);
|
|
DiffEntry d2;
|
|
d2.path = "side.r.after";
|
|
d2.why = "hash";
|
|
d2.first_diff_offset = 1;
|
|
d2.note = "x";
|
|
c.diff.push_back(d2);
|
|
DiffEntry d3;
|
|
d3.path = "side.x.after";
|
|
d3.why = "len";
|
|
d3.orig_raw = "3";
|
|
d3.ours_raw = "2";
|
|
c.diff.push_back(d3);
|
|
c.err = "e";
|
|
c.note = "n\xe9";
|
|
Buf cb;
|
|
emit_record(cb, c);
|
|
CHECK_STR(cb.str(),
|
|
"{\"ts\":1,\"hook\":\"X\",\"mode\":\"compare\",\"call_id\":4,\"thread\":1,\"depth\":0,"
|
|
"\"args\":[{\"t\":\"i32\",\"v\":1,\"n\":\"a\"}],\"ret\":{\"t\":\"bool\",\"v\":true},"
|
|
"\"side\":{\"r\":{\"before\":{\"t\":\"null\",\"v\":null},\"after\":{\"t\":\"i32\",\"v\":2}},"
|
|
"\"q\":{\"before\":null,\"after\":{\"t\":\"i32\",\"v\":0}}},"
|
|
"\"ours\":{\"ret\":{\"t\":\"bool\",\"v\":false},\"side\":{\"r\":{\"after\":{\"t\":\"i32\",\"v\":3}},"
|
|
"\"q\":{\"after\":{\"t\":\"i32\",\"v\":0}}}},\"diverged\":true,"
|
|
"\"diff\":[{\"path\":\"ret\",\"why\":\"exact\",\"orig\":{\"t\":\"bool\",\"v\":true},\"ours\":{\"t\":\"bool\",\"v\":false}},"
|
|
"{\"path\":\"side.r.after\",\"why\":\"hash\",\"orig\":null,\"ours\":null,\"first_diff_offset\":1,\"note\":\"x\"},"
|
|
"{\"path\":\"side.x.after\",\"why\":\"len\",\"orig\":3,\"ours\":2}],"
|
|
"\"err\":\"e\",\"note\":\"n\\u00e9\"}\n");
|
|
|
|
// replace record: no ours/diverged/diff; empty diff list still emits "diff":[] when flagged
|
|
Record p;
|
|
p.ts = 22;
|
|
p.hook = "Mars::ParseBlock";
|
|
p.mode = Mode::Replace;
|
|
p.call_id = 7;
|
|
p.thread = 3;
|
|
p.has_diff = true;
|
|
p.diverged = 0;
|
|
Buf pb;
|
|
emit_record(pb, p);
|
|
CHECK_STR(pb.str(), "{\"ts\":22,\"hook\":\"Mars::ParseBlock\",\"mode\":\"replace\",\"call_id\":7,\"thread\":3,\"args\":[],\"ret\":null,\"side\":{},\"diverged\":false,\"diff\":[]}\n");
|
|
|
|
Meta m;
|
|
m.build = "sots-engine test";
|
|
m.exe_sha256 = std::string(64, '0');
|
|
m.started = "2026-09-07T00:00:00Z";
|
|
m.inline_max = 256;
|
|
HookPolicy pa;
|
|
HookPolicy pb2;
|
|
pb2.ftol = 1e-6;
|
|
pb2.ftol_kind = "rel";
|
|
pb2.ptr_exact = true;
|
|
pb2.unordered = {"ret.v.items"};
|
|
m.hooks.emplace_back("Hook::A", pa);
|
|
m.hooks.emplace_back("Mars::ParseBlock", pb2);
|
|
Buf mb;
|
|
emit_meta(mb, m);
|
|
CHECK_STR(mb.str(),
|
|
"{\"meta\":{\"format\":1,\"build\":\"sots-engine test\",\"exe_sha256\":\"" + std::string(64, '0') +
|
|
"\",\"started\":\"2026-09-07T00:00:00Z\",\"inline_max\":256,\"hooks\":{"
|
|
"\"Hook::A\":{\"ftol\":0,\"ftol_kind\":\"abs\",\"ptr\":\"ignore\"},"
|
|
"\"Mars::ParseBlock\":{\"ftol\":9.9999999999999995e-07,\"ftol_kind\":\"rel\",\"ptr\":\"exact\",\"unordered\":[\"ret.v.items\"]}}}}\n");
|
|
Meta m0;
|
|
Buf m0b;
|
|
emit_meta(m0b, m0);
|
|
CHECK_STR(m0b.str(), "{\"meta\":{\"format\":1,\"build\":\"\",\"exe_sha256\":\"\",\"started\":\"\",\"inline_max\":256,\"hooks\":{}}}\n");
|
|
}
|
|
|
|
static void buf_growth() {
|
|
Buf b;
|
|
std::string big(100000, 'z');
|
|
b.put(big.data(), big.size());
|
|
b.printf("%s", big.c_str()); // > 128 chars: takes the grow path
|
|
CHECK_EQ(b.size(), static_cast<std::size_t>(200000));
|
|
CHECK(b.ok());
|
|
b.clear();
|
|
CHECK_EQ(b.size(), static_cast<std::size_t>(0));
|
|
// a 1 MiB bytes value inlines only when inline_max allows
|
|
std::vector<std::uint8_t> mb(1 << 20, 7);
|
|
Buf big1;
|
|
emit_tv(big1, tv::bytes(mb.data(), mb.size(), 1 << 20));
|
|
CHECK_EQ(big1.size(), static_cast<std::size_t>(2 * (1 << 20)) + std::string("{\"t\":\"bytes\",\"n\":1048576,\"sha256\":\"\",\"hex\":\"\"}").size() + 64);
|
|
CHECK(big1.ok());
|
|
}
|
|
|
|
// ---- oracle fixture: mirrored line for line in oracle_emit.py ----------------------------------
|
|
|
|
static std::vector<std::uint8_t> range_bytes(int n) {
|
|
std::vector<std::uint8_t> v;
|
|
for (int i = 0; i < n; ++i) v.push_back(static_cast<std::uint8_t>(i));
|
|
return v;
|
|
}
|
|
|
|
static void write_oracle_fixture(const std::string& path) {
|
|
Buf out;
|
|
Meta m;
|
|
m.build = "shim-trace test";
|
|
m.exe_sha256 = std::string(64, '0');
|
|
m.started = "2026-09-07T00:00:00Z";
|
|
m.inline_max = 256;
|
|
HookPolicy pa;
|
|
HookPolicy pb;
|
|
pb.ftol = 1e-6;
|
|
pb.ftol_kind = "rel";
|
|
pb.ptr_exact = true;
|
|
pb.unordered = {"ret.v.items"};
|
|
m.hooks.emplace_back("Hook::A", pa);
|
|
m.hooks.emplace_back("Mars::ParseBlock", pb);
|
|
emit_meta(out, m);
|
|
|
|
{ // rec0: str/i32/ptr args, bool ret, inline bytes region before/after
|
|
Record r;
|
|
r.ts = 1000; r.hook = "CfgVar_RegisterKey"; r.mode = Mode::Trace; r.call_id = 0; r.thread = 4120; r.depth = 0;
|
|
r.args.push_back(tv::str("R\xe9sum\xe9").named("key"));
|
|
r.args.push_back(tv::i32(-3).named("value"));
|
|
r.args.push_back(tv::ptr(static_cast<std::uintptr_t>(0x00a36fd0)).named("table"));
|
|
r.ret = tv::boolean(true);
|
|
auto fwd = range_bytes(16);
|
|
auto rev = fwd;
|
|
std::reverse(rev.begin(), rev.end());
|
|
SideEntry s;
|
|
s.name = "cfg_table"; s.before_kind = SideEntry::Value;
|
|
s.before = tv::bytes(fwd.data(), fwd.size(), 256);
|
|
s.after = tv::bytes(rev.data(), rev.size(), 256);
|
|
r.side.push_back(s);
|
|
emit_record(out, r);
|
|
}
|
|
{ // rec1: struct / list / set / enum / big ints / null / wstr
|
|
Record r;
|
|
r.ts = 1037; r.hook = "Manifest_Load"; r.mode = Mode::Trace; r.call_id = 1; r.thread = 4120;
|
|
r.args.push_back(tv::str("Weapons/_weapons.txt").named("path"));
|
|
r.ret = tv::i32(2).named("count");
|
|
Tv reg = tv::struct_();
|
|
std::vector<Tv> entries;
|
|
for (unsigned id : {7u, 9u}) {
|
|
Tv e = tv::struct_();
|
|
e.add("id", tv::u32(id));
|
|
e.add("name", tv::str(("w" + std::to_string(id) + ".weapon").c_str()));
|
|
entries.push_back(e);
|
|
}
|
|
reg.add("entries", tv::list(entries));
|
|
reg.add("deleted", tv::set({tv::u32(501), tv::u32(550), tv::u32(599)}));
|
|
reg.add("flags", tv::enum_(2, "MF_0"));
|
|
reg.add("big", tv::u64((1ull << 60) + 1));
|
|
reg.add("small", tv::u64(5));
|
|
reg.add("edge", tv::u64(1ull << 53));
|
|
reg.add("neg", tv::i64(-(1ll << 60)));
|
|
reg.add("nothing", tv::null());
|
|
const std::uint16_t w[] = {0x41, 0x20ac, 0x0000};
|
|
reg.add("w", tv::wstr(w, 3));
|
|
SideEntry s;
|
|
s.name = "registry";
|
|
s.after = reg;
|
|
r.side.push_back(s);
|
|
emit_record(out, r);
|
|
}
|
|
{ // rec2: every escape, json ret, f32/f64 lists, nan, before:null, hashed region
|
|
Record r;
|
|
r.ts = 1074; r.hook = "Mars::ParseBlock"; r.mode = Mode::Trace; r.call_id = 2; r.thread = 4124; r.depth = 1;
|
|
r.args.push_back(tv::str("Tab\tKey Quote\"d Back\\slash nl\nx cr\rx \x01\x7f\xff \x80").named("text"));
|
|
r.args.push_back(tv::u32(2).named("len"));
|
|
r.ret = tv::json("{\"weapon\":{\"count\":3,\"damage\":1.5,\"name\":\"Laser\\u00e9\",\"ok\":true,\"range\":2.25,\"tags\":[\"a\",\"b\"]}}");
|
|
SideEntry sc;
|
|
sc.name = "scratch";
|
|
sc.after = tv::list({tv::f32(1.5f), tv::f32(0.1f), tv::f32(-2.5e-7f), tv::f32(1e30f)});
|
|
r.side.push_back(sc);
|
|
SideEntry nb;
|
|
nb.name = "nanbox";
|
|
nb.after = tv::f32(std::numeric_limits<float>::quiet_NaN());
|
|
r.side.push_back(nb);
|
|
SideEntry inf;
|
|
inf.name = "infs";
|
|
inf.after = tv::list({tv::f64(std::numeric_limits<double>::infinity()), tv::f64(-std::numeric_limits<double>::infinity()),
|
|
tv::f64(0.1), tv::f64(1e300), tv::f64(0.0)});
|
|
r.side.push_back(inf);
|
|
auto big = range_bytes(256);
|
|
big.insert(big.end(), big.begin(), big.end());
|
|
SideEntry bl;
|
|
bl.name = "blob"; bl.before_kind = SideEntry::IsNull;
|
|
bl.after = tv::bytes(big.data(), big.size(), 256);
|
|
r.side.push_back(bl);
|
|
emit_record(out, r);
|
|
}
|
|
{ // rec3: compare, clean, small ints
|
|
Record r;
|
|
r.ts = 1111; r.hook = "CfgVar_RegisterKey"; r.mode = Mode::Compare; r.call_id = 3; r.thread = 4120;
|
|
r.args = {tv::i8(-128), tv::i16(32767), tv::u8(255), tv::u16(65535), tv::u64((1ull << 53) - 1)};
|
|
r.ret = tv::null();
|
|
r.has_ours = true;
|
|
r.ours_ret = tv::null();
|
|
r.diverged = 0;
|
|
r.has_diff = true;
|
|
emit_record(out, r);
|
|
}
|
|
{ // rec4: compare with divergences + note
|
|
Record r;
|
|
r.ts = 1148; r.hook = "Manifest_Load"; r.mode = Mode::Compare; r.call_id = 4; r.thread = 1;
|
|
r.ret = tv::i32(1);
|
|
SideEntry s;
|
|
s.name = "r";
|
|
s.after = tv::bytes("\x01\x02", 2, 256);
|
|
r.side.push_back(s);
|
|
r.has_ours = true;
|
|
r.ours_ret = tv::i32(2);
|
|
r.ours_side.push_back({"r", tv::bytes("\x01\x03", 2, 256)});
|
|
r.diverged = 1;
|
|
r.has_diff = true;
|
|
DiffEntry d1;
|
|
d1.path = "ret"; d1.why = "exact"; d1.orig = tv::i32(1); d1.ours = tv::i32(2);
|
|
r.diff.push_back(d1);
|
|
DiffEntry d2;
|
|
d2.path = "side.r.after"; d2.why = "hash"; d2.orig = tv::bytes("\x01\x02", 2, 256); d2.ours = tv::bytes("\x01\x03", 2, 256);
|
|
d2.first_diff_offset = 1;
|
|
r.diff.push_back(d2);
|
|
r.note = "hello";
|
|
emit_record(out, r);
|
|
}
|
|
{ // rec5: compare err (no ours)
|
|
Record r;
|
|
r.ts = 1185; r.hook = "X"; r.mode = Mode::Compare; r.call_id = 5; r.thread = 1;
|
|
r.diverged = 1;
|
|
r.has_diff = true;
|
|
DiffEntry d;
|
|
d.path = "call"; d.why = "err"; d.ours_raw = "\"ours threw\"";
|
|
r.diff.push_back(d);
|
|
r.err = "ours threw";
|
|
emit_record(out, r);
|
|
}
|
|
{ // rec6: replace
|
|
Record r;
|
|
r.ts = 1222; r.hook = "Y"; r.mode = Mode::Replace; r.call_id = 6; r.thread = 2;
|
|
r.args.push_back(tv::boolean(false).named("flag"));
|
|
r.ret = tv::ptr(static_cast<std::uintptr_t>(0));
|
|
emit_record(out, r);
|
|
}
|
|
CHECK(out.ok());
|
|
std::FILE* f = std::fopen(path.c_str(), "wb");
|
|
CHECK(f != nullptr);
|
|
if (f) {
|
|
std::fwrite(out.data(), 1, out.size(), f);
|
|
std::fclose(f);
|
|
}
|
|
}
|
|
|
|
int main(int argc, char** argv) {
|
|
golden_strings();
|
|
golden_numbers();
|
|
golden_bytes_and_containers();
|
|
golden_records();
|
|
buf_growth();
|
|
|
|
const std::string fixture = argc > 1 ? argv[1] : "emitter_oracle.jsonl";
|
|
write_oracle_fixture(fixture);
|
|
std::printf("oracle fixture: %s\n", fixture.c_str());
|
|
if (tracetest::harness_present()) {
|
|
// byte-exact against mkfixture.emit_record / emit_meta
|
|
const std::string script = argc > 2 ? argv[2] : "oracle_emit.py";
|
|
const int rc = tracetest::run_python(script, tracetest::harness_dir() + " " + fixture);
|
|
CHECK_EQ(rc, 0);
|
|
// and the harness reads it back as valid, with the injected divergence counted
|
|
const int tc = tracetest::run_tracecmp(fixture);
|
|
CHECK_EQ(tc, 1);
|
|
} else {
|
|
std::printf(" SKIP python oracle (harness absent)\n");
|
|
}
|
|
return tracetest::finish("shim_trace_emitter");
|
|
}
|