gen_fixtures.cpp

Go to the documentation of this file.

// Golden DataMessage fixtures from the C++ CMSDK: the reference encoder for non-C++ codecs.
//
// The Kotlin codec's tests decode every fixture and check header fields and entries against
// expected.json; for the 'compact' fixtures (no deleted or shrunk slots) they also re-encode and
// require byte-for-byte equality with these files. Regenerate after any DataMessage change:
//
//     make -C kotlin/tools        (from CMSDK/, after `make` / `make ssl`)
//
// Writes kotlin/fixtures/<name>.bin, expected.json and layout.json (via the layout tool).
#include "DataMessage.h"
#include "ObjectIDs.h"
#include "PsyTime.h"
#include <cstdio>
#include <string>
#include <vector>
 
using namespace cmlabs;
 
static const uint64 T0 = 63960700000000000ULL;  // fixed PsyTime (us since year 0): reproducible files
 
struct Entry { std::string key, kind, json; };
struct Fixture { std::string name; DataMessage* msg; bool compact; std::vector<Entry> entries; };
 
static std::string Esc(const std::string& s) {
    std::string o;
    for (unsigned char c : s) {
        if (c == '"' || c == '\\') { o += '\\'; o += (char)c; }
        else if (c < 0x20) { char b[8]; snprintf(b, sizeof(b), "\\u%04x", c); o += b; }
        else o += (char)c;
    }
    return o;
}
static std::string Hex(const char* d, uint32 n) {
    static const char* h = "0123456789abcdef";
    std::string o;
    for (uint32 i = 0; i < n; i++) { o += h[((uint8)d[i]) >> 4]; o += h[((uint8)d[i]) & 15]; }
    return o;
}
static DataMessage* Base() {
    DataMessage* m = new DataMessage();
    m->setCreatedTime(T0);
    m->setSendTime(T0 + 10);
    m->setRecvTime(T0 + 20);
    return m;
}
static Entry S(const char* k, const char* v) { return Entry{ k, "string", "\"" + Esc(v) + "\"" }; }
static Entry I(const char* k, int64 v) { return Entry{ k, "int", std::to_string((long long)v) }; }
 
int main(int argc, char** argv) {
    std::string out = argc > 1 ? argv[1] : "kotlin/fixtures";
    std::vector<Fixture> fx;
 
    fx.push_back({ "empty", Base(), true, {} });
 
    DataMessage* m = Base();
    m->setString("Text", "hello");
    m->setInt("Serial", 4242);
    m->setInt("Negative", -7);
    m->setDouble("Gain", 0.75);
    m->setTime("TCap", T0 + 123456);
    fx.push_back({ "scalars", m, true, { S("Text", "hello"), I("Serial", 4242), I("Negative", -7),
        Entry{ "Gain", "double", "0.75" }, Entry{ "TCap", "time", std::to_string((unsigned long long)(T0 + 123456)) } } });
 
    m = Base();
    char pcm[320];
    for (int i = 0; i < 320; i++) pcm[i] = (char)(i < 256 ? i : 0); // includes NULs on purpose
    m->setString("PsyPost", "AudioFrame");
    m->setString("PsyDevice", "phone-s25");
    m->setData("pcm", pcm, 320);
    m->setString("Unicode", "M\xC3\xADmir \xE2\x80\x93 \xC3\xA6\xC3\xB8\xC3\xA5 \xE2\x9C\x93");
    fx.push_back({ "audio_frame", m, true, { S("PsyPost", "AudioFrame"), S("PsyDevice", "phone-s25"),
        Entry{ "pcm", "data", "\"" + Hex(pcm, 320) + "\"" },
        S("Unicode", "M\xC3\xADmir \xE2\x80\x93 \xC3\xA6\xC3\xB8\xC3\xA5 \xE2\x9C\x93") } });
 
    m = Base();
    PsyType t; t.fromString("16.34.35");
    m->setType(t);
    PsyContext c; c.fromString("3.7");
    m->setContextChange(c);
    m->setTag(77);
    m->setSerial(9001);
    m->setReference(123456789012ULL);
    m->setTTL(3000000);
    m->setPriority(9);
    m->setPolicy(1);
    m->setFrom(12);
    m->setTo(34);
    m->setStatus(5);
    // Every remaining header field gets a distinct non-zero value through the struct itself, so a
    // codec with a wrong offset reads a wrong value (zeros would hide it).
    m->data->cenc = 0x0102;
    m->data->memid = 0x1112131415161718ULL;
    m->data->origin = 0x2122;
    m->data->destination = 0x2324;
    m->data->cyclecputime = 0x31323334;
    m->data->cyclewalltime = 0x35363738;
    m->data->chaincputime = 0x41424344;
    m->data->chainwalltime = 0x45464748;
    m->data->chaincount = 0x51525354;
    m->data->systemid = 0x61626364;
    m->setString("k", "v");
    fx.push_back({ "header_fields", m, true, { S("k", "v") } });
 
    DataMessage* inner = Base();
    inner->setString("Inner", "yes");
    inner->setInt("N", 3);
    m = Base();
    m->setAttachedMessage("Attached", inner);
    m->setString("After", "tail");
    fx.push_back({ "attached", m, true, { Entry{ "Attached", "message", "{\"Inner\":\"yes\",\"N\":3}" }, S("After", "tail") } });
    delete inner;
 
    // Not compact: a shrinking overwrite (slot keeps its old size) and a deleted slot (UNUSEDID).
    // Decoders must step by the KEY header's size and skip UNUSED slots.
    m = Base();
    m->setString("Long", "a fairly long original value");
    m->setString("Long", "short");
    m->setString("Gone", "to be deleted");
    m->deleteEntry("Gone");
    m->setInt("Kept", 1);
    fx.push_back({ "overwrite_delete", m, false, { S("Long", "short"), I("Kept", 1) } });
 
    std::string js = "{\n \"generator\": \"kotlin/tools/gen_fixtures.cpp (C++ CMSDK)\",\n \"fixtures\": [\n";
    for (size_t i = 0; i < fx.size(); i++) {
        DataMessage* d = fx[i].msg;
        std::string path = out + "/" + fx[i].name + ".bin";
        FILE* f = fopen(path.c_str(), "wb");
        if (!f) { fprintf(stderr, "cannot write %s\n", path.c_str()); return 1; }
        fwrite(d->data, 1, d->data->size, f);
        fclose(f);
        DataMessageHeader* h = d->data;
        char hdr[2048];
        snprintf(hdr, sizeof(hdr),
            "\"header\": {\"size\":%u,\"time\":%llu,\"sendtime\":%llu,\"recvtime\":%llu,\"ttl\":%llu,"
            "\"priority\":%u,\"policy\":%u,\"from\":%u,\"to\":%u,\"tag\":%u,\"status\":%u,\"reference\":%llu,"
            "\"serial\":%llu,\"type\":\"%s\",\"contextchange\":\"%s\",\"userCount\":%u,\"userSize\":%u,"
            "\"cenc\":%u,\"memid\":%llu,\"origin\":%u,\"destination\":%u,\"cyclecputime\":%u,\"cyclewalltime\":%u,"
            "\"chaincputime\":%u,\"chainwalltime\":%u,\"chaincount\":%u,\"systemid\":%u}",
            h->size, (unsigned long long)h->time, (unsigned long long)h->sendtime, (unsigned long long)h->recvtime,
            (unsigned long long)h->ttl, h->priority, h->policy, h->from, h->to, h->tag, h->status,
            (unsigned long long)h->reference, (unsigned long long)h->serial, h->type.toString().c_str(),
            h->contextchange.toString().c_str(), h->userCount, h->userSize,
            h->cenc, (unsigned long long)h->memid, h->origin, h->destination, h->cyclecputime, h->cyclewalltime,
            h->chaincputime, h->chainwalltime, h->chaincount, h->systemid);
        js += "  {\"name\":\"" + fx[i].name + "\",\"compact\":" + (fx[i].compact ? "true" : "false") + ",\n   " + hdr + ",\n   \"entries\": [";
        for (size_t e = 0; e < fx[i].entries.size(); e++)
            js += (e ? "," : "") + std::string("\n    {\"key\":\"") + fx[i].entries[e].key + "\",\"kind\":\"" +
                fx[i].entries[e].kind + "\",\"value\":" + fx[i].entries[e].json + "}";
        js += "]}" + std::string(i + 1 < fx.size() ? ",\n" : "\n");
        printf("%-18s %5u bytes  compact=%s\n", fx[i].name.c_str(), h->size, fx[i].compact ? "yes" : "no");
        delete d;
    }
    js += " ]\n}\n";
    FILE* f = fopen((out + "/expected.json").c_str(), "wb");
    if (!f) return 1;
    fwrite(js.data(), 1, js.size(), f);
    fclose(f);
    return 0;
}