tests.cpp

/*
 * Part of tivars_lib_cpp
 * (C) 2015-2026 Adrien "Adriweb" Bertrand
 * https://github.com/adriweb/tivars_lib_cpp
 * License: MIT
 */

#include <cassert>
#include <cstring>
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <array>
#include <vector>
#include <tuple>
#include <utility>
#include <iterator>

#ifndef _WIN32
    #include <sys/stat.h>
#endif

#include "src/TIModels.h"
#include "src/TIVarTypes.h"
#include "src/BinaryFile.h"
#include "src/TIVarFile.h"
#include "src/TIFlashFile.h"
#include "src/TypeHandlers/TypeHandlers.h"
#include "src/tivarslib_utils.h"
#include "src/json.hpp"
#include "scripts/tests/activitygrapher_bounds_tests.h"
#include "scripts/tests/activitygrapher_collection_tests.h"
#include "scripts/tests/activitygrapher_flash_tests.h"
#include "scripts/tests/activitygrapher_metadata_tests.h"
#include "scripts/tests/numeric_regression.h"
#include "scripts/tests/model_numeric_tests.h"

using namespace std;
using namespace std::string_literals;
using namespace tivars;
using namespace tivars::TypeHandlers;
using TypeHandlers::TH_Tokenized;
using json = nlohmann::ordered_json;

static bool compare_token_posinfo(const TH_Tokenized::token_posinfo& tp1, const TH_Tokenized::token_posinfo& tp2)
{
    return tp1.column == tp2.column && tp1.line == tp2.line && tp1.len == tp2.len;
}

struct ScopedStderrCapture
{
    std::ostringstream buffer;
    std::streambuf* previous = nullptr;

    ScopedStderrCapture()
    {
        previous = std::cerr.rdbuf(buffer.rdbuf());
    }

    ~ScopedStderrCapture()
    {
        std::cerr.rdbuf(previous);
    }

    std::string str() const
    {
        return buffer.str();
    }
};

static bool contains_numeric_token_escape(const std::string& source)
{
    const auto is_hex_digit = [](char c)
    {
        return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f');
    };

    for (size_t i = 0; i + 3 < source.size(); ++i)
    {
        if (source[i] != '\\')
        {
            continue;
        }
        if (source[i + 1] == 'x' && is_hex_digit(source[i + 2]) && is_hex_digit(source[i + 3]))
        {
            return true;
        }
        if (i + 5 < source.size() && source[i + 1] == 'u'
            && is_hex_digit(source[i + 2]) && is_hex_digit(source[i + 3])
            && is_hex_digit(source[i + 4]) && is_hex_digit(source[i + 5]))
        {
            return true;
        }
    }
    return false;
}

static const std::vector<uint16_t>& forceable_named_legacy_tokens()
{
    static const std::vector<uint16_t> tokens = []
    {
        std::vector<uint16_t> result;
        for (uint32_t tokenValue = 1; tokenValue <= 0xFFFF; ++tokenValue)
        {
            const uint16_t token = static_cast<uint16_t>(tokenValue);
            const std::string name = TH_Tokenized::oneTokenBytesToString(token);
            if (name.empty())
            {
                continue;
            }

            const std::string candidate = "\\" + name;
            const auto scanned = TH_Tokenized::scanSourceTokens("\"" + candidate);
            if (scanned.size() == 2)
            {
                const auto& [sourceText, scannedToken, matched] = scanned.back();
                if (matched && sourceText == candidate && scannedToken == token)
                {
                    result.push_back(token);
                }
            }
        }
        return result;
    }();
    return tokens;
}

static data_t legacy_string_token_data(uint16_t token)
{
    data_t rawBytes = {0x2A}; // opening quote
    if (token > 0xFF)
    {
        rawBytes.push_back(static_cast<uint8_t>(token >> 8));
    }
    rawBytes.push_back(static_cast<uint8_t>(token & 0xFF));
    rawBytes.push_back(0x58); // X disambiguates tokens whose names end in spaces or letters

    data_t data = {
        static_cast<uint8_t>(rawBytes.size() & 0xFF),
        static_cast<uint8_t>((rawBytes.size() >> 8) & 0xFF),
    };
    data.insert(data.end(), rawBytes.begin(), rawBytes.end());
    return data;
}

static void assert_roundtrip_from_readable(TIVarFile& original, const options_t& readableOptions = options_t{})
{
    assert(original.hasMultipleEntries() == false);

    const auto& entry = original.getVarEntries()[0];
    TIVarFile recreated = TIVarFile::createNew(entry._type, entry_name_to_string(entry._type, entry.varname), original.getCalcModel());
    recreated.setContentFromString(original.getReadableContent(readableOptions));
    assert(recreated.getRawContent() == original.getRawContent());
}

static data_t decode_base64(const std::string& encoded)
{
    const auto base64_value = [](char c) -> int
    {
        if (c >= 'A' && c <= 'Z') return c - 'A';
        if (c >= 'a' && c <= 'z') return c - 'a' + 26;
        if (c >= '0' && c <= '9') return c - '0' + 52;
        if (c == '+') return 62;
        if (c == '/') return 63;
        return -1;
    };

    data_t decoded;
    int val = 0;
    int bits = -8;
    for (char c : encoded)
    {
        if (c == '=')
        {
            break;
        }

        const int v = base64_value(c);
        if (v < 0)
        {
            continue;
        }

        val = (val << 6) | v;
        bits += 6;
        if (bits >= 0)
        {
            decoded.push_back(static_cast<uint8_t>((val >> bits) & 0xFF));
            bits -= 8;
        }
    }

    return decoded;
}

static uint32_t read_le32_at(const data_t& data, size_t offset)
{
    assert(offset + 3 < data.size());
    return static_cast<uint32_t>(data[offset])
         | (static_cast<uint32_t>(data[offset + 1]) << 8)
         | (static_cast<uint32_t>(data[offset + 2]) << 16)
         | (static_cast<uint32_t>(data[offset + 3]) << 24);
}

static void write_binary_file(const std::string& path, const data_t& data)
{
    std::ofstream file(path, std::ios::binary);
    assert(file.good());
    file.write(reinterpret_cast<const char*>(data.data()), static_cast<std::streamsize>(data.size()));
    assert(file.good());
}

static data_t read_binary_file(const std::string& path)
{
    std::ifstream file(path, std::ios::binary);
    assert(file.good());
    return data_t(std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>());
}

static void assert_preview_bmp_data_url(const std::string& url, uint32_t width, uint32_t height)
{
    const std::string prefix = "data:image/bmp;base64,";
    assert(url.rfind(prefix, 0) == 0);

    const data_t bmp = decode_base64(url.substr(prefix.size()));
    assert(bmp.size() >= 54);
    assert(bmp[0] == 'B' && bmp[1] == 'M');
    const uint32_t dibHeaderSize = read_le32_at(bmp, 14);
    assert(dibHeaderSize == 40 || dibHeaderSize == 124);
    assert(read_le32_at(bmp, 18) == width);
    assert(read_le32_at(bmp, 22) == height);
}

static std::array<uint8_t, 4> read_preview_bmp_pixel_rgba(const std::string& url, uint32_t x, uint32_t y)
{
    const std::string prefix = "data:image/bmp;base64,";
    assert(url.rfind(prefix, 0) == 0);

    const data_t bmp = decode_base64(url.substr(prefix.size()));
    assert(bmp.size() >= 54);

    const uint32_t width = read_le32_at(bmp, 18);
    const uint32_t height = read_le32_at(bmp, 22);
    const uint32_t pixelOffset = read_le32_at(bmp, 10);
    const uint16_t bitsPerPixel = static_cast<uint16_t>(bmp[28]) | (static_cast<uint16_t>(bmp[29]) << 8);
    const uint32_t rowStride = bitsPerPixel == 32 ? width * 4U : ((width * 3U + 3U) & ~3U);
    assert(x < width);
    assert(y < height);
    assert(pixelOffset + rowStride * height <= bmp.size());

    const uint32_t row = height - 1 - y;
    const size_t offset = static_cast<size_t>(pixelOffset) + static_cast<size_t>(row) * rowStride + static_cast<size_t>(x) * (bitsPerPixel == 32 ? 4U : 3U);
    if (bitsPerPixel == 32)
    {
        return {bmp[offset + 2], bmp[offset + 1], bmp[offset], bmp[offset + 3]};
    }
    return {bmp[offset + 2], bmp[offset + 1], bmp[offset], 0xFF};
}

static const json* find_flash_field_by_id(const json& fields, int id)
{
    if (!fields.is_array())
    {
        return nullptr;
    }

    for (const json& field : fields)
    {
        if (field.is_object() && field.value("id", -1) == id)
        {
            return &field;
        }

        if (field.is_object() && field.contains("fields"))
        {
            if (const json* nested = find_flash_field_by_id(field["fields"], id); nested != nullptr)
            {
                return nested;
            }
        }
    }

    return nullptr;
}

int main(int argc, char** argv)
{
    (void)argc;
    (void)argv;

    setlocale(LC_ALL, ".UTF-8");

    /* Tests */

    activitygrapher_tests::test_activitygrapher_bounds();

    activitygrapher_tests::test_activitygrapher_collections();

    activitygrapher_tests::test_activitygrapher_flash();

    activitygrapher_tests::test_activitygrapher_metadata();

    tivars::numeric_regression::check_fp_exponent_regressions();

    tivars::numeric_regression::check_fraction_input_regressions();

    tivars::numeric_regression::check_fraction_roundtrip_regressions();
    tivars::numeric_regression::check_model_numeric_regressions();

    assert(TIVarType{"ExactRealPi"}.getId() == 32);
    assert(dec2frac(0.25) == "1/4");
    assert(dec2frac(1.0 / 100001.0, "", 1e-12) != "0");

    {
        TIFlashFile flashOs = TIFlashFile::loadFromFile("testData/TI-84_Plus_CE-Python-OS-5.8.0.0022.8eu");
        assert(flashOs.hasMultipleHeaders() == false);
        const json flashOsJSON = json::parse(flashOs.getReadableContent());
        assert(flashOsJSON["typeName"] == "OperatingSystem");
        assert(flashOsJSON["name"] == "basecode");
        assert(flashOsJSON["revision"] == "5.8");
        assert(flashOsJSON["revisionMajor"] == 5);
        assert(flashOsJSON["revisionMinor"] == 8);
        assert(flashOsJSON["binaryFlag"] == 0);
        assert(flashOsJSON["objectType"] == 0);
        assert(flashOsJSON["date"][0] == 26);
        assert(flashOsJSON["date"][1] == 4);
        assert(flashOsJSON["date"][2] == 2022);
        assert(flashOsJSON["devices"][0]["deviceType"] == 0x73);
        assert(flashOsJSON["devices"][0]["typeId"] == 0x23);
        assert(flashOsJSON["productId"] == 0x13);
        assert(flashOsJSON["calcDataSize"] == 644962);
        assert(flashOsJSON.contains("fields"));
        assert(flashOsJSON["fields"].is_array());
        assert(flashOsJSON["fields"].size() >= 2);
        assert(flashOsJSON["fields"][0]["idHex"] == "800");
        assert(flashOsJSON["fields"][0]["name"] == "Master");
        assert(flashOsJSON["fields"][0].contains("fields"));
        assert(flashOsJSON["fields"][0]["fields"][1]["idHex"] == "802");
        assert(flashOsJSON["fields"][0]["fields"][1]["name"] == "Revision");
        assert(flashOsJSON["fields"][0]["fields"][1]["rawDataHex"] == "05");
        assert(flashOsJSON["fields"][1]["idHex"] == "023");
        assert(flashOsJSON["fields"][1]["name"] == "CE signature");
        assert(!flashOsJSON.contains("fieldsError"));
        assert(flashOsJSON["certificateVersion"]["major"] == 5);
        assert(flashOsJSON["certificateVersion"]["minor"] == 8);
        assert(flashOsJSON["certificateVersion"]["patch"] == 0);
        assert(flashOsJSON["certificateVersion"]["build"] == 22);
        assert(flashOsJSON["certificateVersion"]["string"] == "5.8.0.22");
    }

    {
        TIFlashFile flashOs = TIFlashFile::loadFromFile("testData/TI-83_Premium_CE-OS-5.8.4.0058.8pu");
        assert(flashOs.hasMultipleHeaders() == false);
        const json flashOsJSON = json::parse(flashOs.getReadableContent());
        assert(flashOsJSON["typeName"] == "OperatingSystem");
        assert(flashOsJSON["name"] == "basecode");
        assert(flashOsJSON["revision"] == "5.8");
        assert(flashOsJSON["revisionMajor"] == 5);
        assert(flashOsJSON["revisionMinor"] == 8);
        assert(flashOsJSON["binaryFlag"] == 0);
        assert(flashOsJSON["objectType"] == 0);
        assert(flashOsJSON["date"][0] == 25);
        assert(flashOsJSON["date"][1] == 7);
        assert(flashOsJSON["date"][2] == 2025);
        assert(flashOsJSON["devices"][0]["deviceType"] == 0x73);
        assert(flashOsJSON["devices"][0]["typeId"] == 0x23);
        assert(flashOsJSON["productId"] == 0x13);
        assert(flashOsJSON["calcDataSize"] == 662018);
        assert(flashOsJSON.contains("fields"));
        assert(flashOsJSON["fields"].is_array());
        assert(flashOsJSON["fields"].size() >= 2);
        assert(flashOsJSON["fields"][0]["idHex"] == "800");
        assert(flashOsJSON["fields"][0]["name"] == "Master");
        assert(flashOsJSON["fields"][0].contains("fields"));
        assert(flashOsJSON["fields"][0]["fields"][1]["idHex"] == "802");
        assert(flashOsJSON["fields"][0]["fields"][1]["name"] == "Revision");
        assert(flashOsJSON["fields"][0]["fields"][1]["rawDataHex"] == "05");
        assert(flashOsJSON["fields"][1]["idHex"] == "023");
        assert(flashOsJSON["fields"][1]["name"] == "CE signature");
        assert(flashOsJSON["certificateVersion"]["major"] == 5);
        assert(flashOsJSON["certificateVersion"]["minor"] == 8);
        assert(flashOsJSON["certificateVersion"]["patch"] == 4);
        assert(flashOsJSON["certificateVersion"]["build"] == 58);
        assert(flashOsJSON["certificateVersion"]["string"] == "5.8.4.58");

        TIFlashFile flashApp = TIFlashFile::loadFromFile("testData/smartpad.8xk");
        const json flashAppJSON = json::parse(flashApp.getReadableContent());
        assert(flashAppJSON["typeName"] == "FlashApp");
        assert(flashAppJSON["name"] == "SmartPad");
        assert(flashAppJSON["revision"] == "1.1");
        assert(flashAppJSON["revisionMajor"] == 1);
        assert(flashAppJSON["revisionMinor"] == 1);
        assert(flashAppJSON["binaryFlag"] == 1);
        assert(flashAppJSON["objectType"] == 0x88);
        assert(flashAppJSON["blocks"].size() == 78);
        assert(flashAppJSON["blocks"][0]["address"] == "0000");
        assert(flashAppJSON["blocks"][0]["blockType"] == "02");
        assert(flashAppJSON["blocks"][0]["rawDataHex"] == "0000");

        TIFlashFile flashAppCE = TIFlashFile::loadFromFile("testData/SmartPad.8ek");
        const json flashAppCEJSON = json::parse(flashAppCE.getReadableContent());
        assert(flashAppCEJSON["typeName"] == "FlashApp");
        assert(flashAppCEJSON["name"] == "SmartPad");
        assert(flashAppCEJSON["revision"] == "5.3");
        assert(flashAppCEJSON["revisionMajor"] == 5);
        assert(flashAppCEJSON["revisionMinor"] == 3);
        assert(flashAppCEJSON["binaryFlag"] == 0);
        assert(flashAppCEJSON["objectType"] == 0);
        assert(flashAppCEJSON["productId"] == 19);
        assert(flashAppCEJSON.contains("fields"));
        assert(!flashAppCEJSON.contains("fieldsError"));
        assert(flashAppCEJSON["certificateVersion"]["major"] == 5);
        assert(flashAppCEJSON["certificateVersion"]["minor"] == 3);
        assert(flashAppCEJSON["certificateVersion"]["patch"] == 0);
        assert(flashAppCEJSON["certificateVersion"]["build"] == 42);
        assert(flashAppCEJSON["certificateVersion"]["source"] == "812");
        assert(flashAppCEJSON["certificateVersion"]["string"] == "5.3.0.42");
        assert(find_flash_field_by_id(flashAppCEJSON["fields"], 0x811) != nullptr);
        assert((*find_flash_field_by_id(flashAppCEJSON["fields"], 0x811))["keyId"] == 0x130F);
        assert((*find_flash_field_by_id(flashAppCEJSON["fields"], 0x811))["keyIdHex"] == "130F");
        assert((*find_flash_field_by_id(flashAppCEJSON["fields"], 0x812))["value"] == "5.3.0.0042");
        assert((*find_flash_field_by_id(flashAppCEJSON["fields"], 0x813))["value"] == 42);
        assert((*find_flash_field_by_id(flashAppCEJSON["fields"], 0x814))["value"] == "SmartPad");
        assert((*find_flash_field_by_id(flashAppCEJSON["fields"], 0x81A))["value"] == 0x07);
        assert((*find_flash_field_by_id(flashAppCEJSON["fields"], 0x81A))["valueName"] == "TI-83 Premium CE / TI-84 Plus CE");
        assert((*find_flash_field_by_id(flashAppCEJSON["fields"], 0x032))["timestamp"] == 648855953);
        assert((*find_flash_field_by_id(flashAppCEJSON["fields"], 0x032))["timestampUtc"] == "2017-07-24 21:45:53 UTC");
        assert((*find_flash_field_by_id(flashAppCEJSON["fields"], 0x090))["timestamp"] == 648855953);
        assert((*find_flash_field_by_id(flashAppCEJSON["fields"], 0x090))["timestampUtc"] == "2017-07-24 21:45:53 UTC");
        assert((*find_flash_field_by_id(flashAppCEJSON["fields"], 0x817))["extended"]["format"] == "eZ80");
        assert((*find_flash_field_by_id(flashAppCEJSON["fields"], 0x817))["extended"]["name"] == "SmartPad");
        assert((*find_flash_field_by_id(flashAppCEJSON["fields"], 0x817))["extended"]["mainOffset"] == 0x366);
        assert((*find_flash_field_by_id(flashAppCEJSON["fields"], 0x817))["extended"]["entryPoint"] == 0x366);
        assert((*find_flash_field_by_id(flashAppCEJSON["fields"], 0x817))["extended"]["copyright"] == "(c)  2006-2017   TEXAS   INSTRUMENTS ");
        assert((*find_flash_field_by_id(flashAppCEJSON["fields"], 0x817))["extended"]["relocationTableEntries"] == 138);

        TIFlashFile multiFlash = TIFlashFile::createNew(TIVarType{"FlashApp"}, "APP", TIModel{"84+"});
        multiFlash.setContentFromString(R"({
    "typeName": "FlashApp",
    "revision": "1.1",
    "binaryFlag": 1,
    "objectType": 136,
    "date": [1, 12, 2006],
    "name": "APP",
    "devices": [{"deviceType": 115, "typeId": 36}],
    "productId": 10,
    "hasChecksum": true,
    "blocks": [
        {"address": "0000", "blockType": "02", "rawDataHex": "0000"},
        {"address": "4000", "blockType": "00", "rawDataHex": "01020304"},
        {"address": "0000", "blockType": "01", "rawDataHex": ""}
    ]
})");
        multiFlash.addHeader(TIVarType{"OperatingSystem"}, "BASE", TIModel{"84+CE"}, true);
        multiFlash.setContentFromString(R"({
    "typeName": "OperatingSystem",
    "revision": "1.0",
    "binaryFlag": 0,
    "objectType": 0,
    "date": [2, 3, 2024],
    "name": "BASE",
    "devices": [{"deviceType": 115, "typeId": 35}],
    "productId": 19,
    "hasChecksum": true,
    "rawDataHex": "01020304A0"
})", 1);
        const std::string multiFlashPath = multiFlash.saveToFile("/tmp/tivars_lib_cpp_multi_flash.8ek");
        TIFlashFile reloadedMultiFlash = TIFlashFile::loadFromFile(multiFlashPath);
        assert(reloadedMultiFlash.hasMultipleHeaders() == true);
        assert(reloadedMultiFlash.getHeaders().size() == 2);
        assert(reloadedMultiFlash.makeBinData() == multiFlash.makeBinData());
        assert(remove(multiFlashPath.c_str()) == 0);

        TIFlashFile truncatedFlash = TIFlashFile::createNew(TIVarType{"FlashApp"}, "CUT", TIModel{"84+"});
        data_t truncatedFlashBytes = truncatedFlash.makeBinData();
        truncatedFlashBytes.pop_back();
        const std::string truncatedFlashPath = "/tmp/tivars_lib_cpp_truncated_flash.8xk";
        write_binary_file(truncatedFlashPath, truncatedFlashBytes);
        bool truncatedFlashRejected = false;
        try
        {
            (void)TIFlashFile::loadFromFile(truncatedFlashPath);
        }
        catch (const std::runtime_error&)
        {
            truncatedFlashRejected = true;
        }
        assert(truncatedFlashRejected);
        assert(remove(truncatedFlashPath.c_str()) == 0);
    }

    {
        const std::vector<std::string> schemaPaths = {
            "schemas/backup.schema.json",
            "schemas/cabrijr-appvar.schema.json",
            "schemas/cellsheet-appvar.schema.json",
            "schemas/cellsheet-state-appvar.schema.json",
            "schemas/flash.schema.json",
            "schemas/gdb.schema.json",
            "schemas/group.schema.json",
            "schemas/image.schema.json",
            "schemas/notefolio-appvar.schema.json",
            "schemas/picture.schema.json",
            "schemas/python-appvar.schema.json",
            "schemas/python-image-appvar.schema.json",
            "schemas/python-module-appvar.schema.json",
            "schemas/recall-window.schema.json",
            "schemas/studycards-appvar.schema.json",
            "schemas/studycards-setgs-appvar.schema.json",
            "schemas/table-range.schema.json",
            "schemas/window-settings.schema.json"
        };

        for (const auto& path : schemaPaths)
        {
            std::ifstream schemaFile(path);
            assert(schemaFile.is_open());

            const json schemaJSON = json::parse(schemaFile);
            assert(schemaJSON.is_object());
            assert(schemaJSON.contains("$schema"));
            assert(schemaJSON.contains("title"));

            if (path == "schemas/flash.schema.json")
            {
                assert(schemaJSON.contains("definitions"));
                assert(schemaJSON["definitions"].contains("flashExtendedField"));
                assert(schemaJSON["definitions"]["flashExtendedField"]["properties"].contains("relocationTableEntries"));
                assert(schemaJSON["definitions"]["flashExtendedField"]["properties"].contains("bodyHex"));
                assert(schemaJSON["definitions"]["flashField"]["properties"]["extended"]["$ref"] == "#/definitions/flashExtendedField");
            }
        }
    }

    {
        TIVarFile testReal = TIVarFile::createNew("Real", "A");
        for (const auto& str : { "0.0", "0", "+0.0", "+0" })
        {
            testReal.setContentFromString(str);
            assert(testReal.getRawContent() == data_t({ 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }));
            assert(testReal.getReadableContent() == "0");
        }
    }

    {
        const data_t undefinedReal = TH_GenericReal::makeDataFromString("1", {{"_type", 0x0E}});
        assert(undefinedReal[0] == 0x0E);
        assert(TH_GenericReal::makeStringFromData(undefinedReal) == "1");
        assert(TH_GenericReal::getMinVersionFromData(undefinedReal) == 0x00);
    }

    {
        assert(TIModels::fromName("82A").getMinVersion() == VER_84P_255MP);
        assert(TIModels::fromName("84+CE").getMinVersion() == VER_CE_ALL);
        assert(TIModels::fromName("84+CEPy").getMinVersion() == VER_CE_530);
        assert(TIModels::fromName("83PCE").getMinVersion() == VER_CE_ALL);
        assert(TIModels::fromName("83PCEEP").getMinVersion() == VER_CE_530);
        assert(TIModels::fromName("82AEP").getMinVersion() == VER_CE_530);
    }

    {
        assert(TH_GenericReal::getMinVersionFromData(data_t{0x00}) == VER_NONE);
        assert(TH_GenericReal::getMinVersionFromData(data_t{0x18}) == VER_84P_253MP);
        assert(TH_GenericReal::getMinVersionFromData(data_t{0x1C}) == VER_CE_EXACTONLY);

        data_t complexData(18, 0x00);
        complexData[0] = 0x0C;
        complexData[9] = 0x0C;
        assert(TH_GenericComplex::getMinVersionFromData(complexData) == VER_NONE);
        complexData[0] = 0x1B;
        complexData[9] = 0x0C;
        assert(TH_GenericComplex::getMinVersionFromData(complexData) == VER_CE_ALL);
        complexData[0] = 0x1E;
        complexData[9] = 0x0C;
        assert(TH_GenericComplex::getMinVersionFromData(complexData) == VER_CE_EXACTONLY);

        const auto makeCollectionData = [](uint8_t internalType)
        {
            data_t data(11, 0x00);
            data[2] = internalType;
            return data;
        };

        assert(TH_GenericList::getMinVersionFromData(makeCollectionData(0x0C)) == VER_NONE);
        assert(TH_GenericList::getMinVersionFromData(makeCollectionData(0x18)) == VER_84P_253MP);
        assert(TH_GenericList::getMinVersionFromData(makeCollectionData(0x1B)) == VER_CE_ALL);
        assert(TH_GenericList::getMinVersionFromData(makeCollectionData(0x1C)) == VER_CE_EXACTONLY);

        assert(TH_Matrix::getMinVersionFromData(makeCollectionData(0x0C)) == VER_NONE);
        assert(TH_Matrix::getMinVersionFromData(makeCollectionData(0x18)) == VER_84P_253MP);
        assert(TH_Matrix::getMinVersionFromData(makeCollectionData(0x1B)) == VER_CE_ALL);
        assert(TH_Matrix::getMinVersionFromData(makeCollectionData(0x1C)) == VER_CE_EXACTONLY);
    }

    {
        // TH_TempEqu error handling: too short and inconsistent lengths
        try {
            TH_TempEqu::makeStringFromData(data_t{});
            assert(false);
        } catch (const std::invalid_argument&) {}
        try {
            // length says 1 but only size fields provided
            TH_TempEqu::makeStringFromData(data_t{0x01,0x00});
            assert(false);
        } catch (const std::invalid_argument&) {}
    }

    {
        // Alias tokenization: arcsin/asin variants should map to sin⁻¹(
        TIVarFile p = TIVarFile::createNew("Program", "ALIAS1");
        p.setContentFromString("arcsin(1)+asin(1)");
        const std::string detok = p.getReadableContent();
        // Both variants should detokenize to the preferred form ending with '('
        assert(detok == "sin⁻¹(1)+sin⁻¹(1)");
    }

    {
        // Alias tokenization for ►Frac/FRAC (and ensure detokenization chooses canonical)
        TIVarFile p = TIVarFile::createNew("Program", "ALIAS2");
        p.setContentFromString("FRAC:►Frac");
        assert(p.getReadableContent() == "FRAC-APPROX:►Frac");
        // Retokenize detokenized output should yield same bytes
        TIVarFile p2 = TIVarFile::createNew("Program", "ALIAS3");
        p2.setContentFromString(p.getReadableContent());
        assert(p.getRawContentHexStr() == p2.getRawContentHexStr());
    }

    {
        // tokenToString incr correctness for 1-byte and 2-byte tokens
        int incr = 0;
        // Single-byte '(' is 0x10, should increment by 1
        std::string s1 = TH_Tokenized::tokenToString(data_t{0x10}, &incr, {});
        assert(s1 == "(");
        assert(incr == 1);
        // Two-byte token: 0xEF97 is toString( per earlier test
        std::string s2 = TH_Tokenized::tokenToString(data_t{0xEF,0x97}, &incr, {});
        assert(s2 == "toString(");
        assert(incr == 2);
    }

    {
        TIVarFile toksPrgm = TIVarFile::loadFromFile("testData/ALLTOKS.8Xp");
        const std::string readable = toksPrgm.getReadableContent();
        assert(readable.find("\\CubicReg ") != std::string::npos);
        assert(readable.find("[???]") == std::string::npos);
        cout << readable << "\n" << endl;
    }

    {
        ScopedStderrCapture goodTokenStderr;
        assert(TH_Tokenized::makeStringFromData(data_t{0x2E}, {{"fromRawBytes", 1}}) == "CubicReg ");
        assert(goodTokenStderr.str().empty());
    }

    {
        ScopedStderrCapture prefixDivergenceStderr;
        const std::string readable = TH_Tokenized::makeStringFromData(data_t{0x2A, 0x2B, 0x2C, 0x2D, 0x2E}, {{"fromRawBytes", 1}});
        assert(readable == "\",𝑖!\\CubicReg ");
        assert(prefixDivergenceStderr.str().empty());
        assert(TH_Tokenized::makeDataFromString(readable) == data_t({0x05, 0x00, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E}));
    }

    {
        ScopedStderrCapture prettifiedPrefixDivergenceStderr;
        const std::string readable = TH_Tokenized::makeStringFromData(data_t{0x2A, 0x2B, 0x2C, 0x2D, 0x2E}, {{"fromRawBytes", 1}, {"prettify", 1}});
        assert(readable == "\",𝑖!CubicReg ");
        assert(prettifiedPrefixDivergenceStderr.str().find("non-roundtrippable") == std::string::npos);
        assert(prettifiedPrefixDivergenceStderr.str().find("could not be detokenized in a roundtrippable way") == std::string::npos);
    }

    {
        ScopedStderrCapture intrinsicBadTokenStderr;
        const std::string readable = TH_Tokenized::makeStringFromData(data_t{0x5E, 0x80}, {{"fromRawBytes", 1}});
        assert(readable == "|u");
        assert(intrinsicBadTokenStderr.str().empty());
        assert(TH_Tokenized::makeDataFromString(readable) == data_t({0x02, 0x00, 0x5E, 0x80}));
    }

    {
        ScopedStderrCapture prettifiedIntrinsicBadTokenStderr;
        const std::string readable = TH_Tokenized::makeStringFromData(data_t{0x5E, 0x80}, {{"fromRawBytes", 1}, {"prettify", 1}});
        assert(readable == "u");
        assert(prettifiedIntrinsicBadTokenStderr.str().find("roundtrippable way") == std::string::npos);
    }

    {
        ScopedStderrCapture variantBeforeAccessibleStderr;
        const data_t greekPiToken = {0xBB, 0xA7};
        const std::string readable = TH_Tokenized::makeStringFromData(greekPiToken, {{"fromRawBytes", 1}});
        assert(readable == "|π");
        assert(variantBeforeAccessibleStderr.str().empty());
        assert(TH_Tokenized::makeDataFromString(readable) == data_t({0x02, 0x00, 0xBB, 0xA7}));
        assert(TH_Tokenized::makeDataFromString("greek_pi") == data_t({0x02, 0x00, 0xBB, 0xA7}));
        assert(TH_Tokenized::makeDataFromString("π") == data_t({0x01, 0x00, 0xAC}));
        assert(TH_Tokenized::makeStringFromData(greekPiToken, {{"fromRawBytes", 1}, {"accessible", 1}}) == "greek_pi");
    }

    {
        ScopedStderrCapture stringVariantBeforeAccessibleStderr;
        const data_t rawString = {0x2A, 0x51, 0xBB, 0xA7, 0x2A};
        const std::string readable = TH_Tokenized::makeStringFromData(rawString, {{"fromRawBytes", 1}});
        assert(readable == "\"Q|π\"");
        assert(stringVariantBeforeAccessibleStderr.str().empty());
        assert(TH_Tokenized::makeDataFromString(readable) == data_t({0x05, 0x00, 0x2A, 0x51, 0xBB, 0xA7, 0x2A}));
    }

    {
        struct SingleLetterTokenCase
        {
            uint8_t prefix;
            uint8_t secondByte;
            const char* displayStr;
            const char* fallbackStr;
        };

        const std::array<SingleLetterTokenCase, 11> troublesomeSingleLetterTokens = {{
            {0x62, 0x02, "n", "[n]"},
            {0x62, 0x12, "r", "[r]"},
            {0x62, 0x16, "a", "[|a]"},
            {0x62, 0x17, "b", "[|b]"},
            {0x62, 0x18, "c", "[|c]"},
            {0x62, 0x19, "d", "[|d]"},
            {0x62, 0x1A, "e", "[|e]"},
            {0x62, 0x22, "p", "[p]"},
            {0x62, 0x23, "z", "[z]"},
            {0x62, 0x34, "s", "[s]"},
            {0x5E, 0x80, "u", "|u"},
        }};

        for (const auto& [prefix, secondByte, displayStr, fallbackStr] : troublesomeSingleLetterTokens)
        {
            const data_t rawBytes = {prefix, secondByte};

            {
                ScopedStderrCapture nonPrettifiedStderr;
                const std::string readable = TH_Tokenized::makeStringFromData(rawBytes, {{"fromRawBytes", 1}});
                assert(readable == fallbackStr);
                assert(nonPrettifiedStderr.str().empty());
            }

            {
                ScopedStderrCapture prettifiedStderr;
                const std::string readable = TH_Tokenized::makeStringFromData(rawBytes, {{"fromRawBytes", 1}, {"prettify", 1}});
                assert(readable == displayStr);
                assert(prettifiedStderr.str().empty());
            }
        }
    }

    {
        assert(TH_Tokenized::makeDataFromString(R"(\CubicReg )") == data_t({0x01, 0x00, 0x2E}));
        assert(TH_Tokenized::makeDataFromString(R"(\x2E)") == data_t({0x01, 0x00, 0x2E}));
        assert(TH_Tokenized::makeDataFromString(R"(\\x2E)") == data_t({0x06, 0x00, 0xBB, 0xD7, 0xBB, 0xC8, 0x32, 0x45}));
        assert(TH_Tokenized::makeDataFromString(R"(\\uF00D)") == data_t({0x08, 0x00, 0xBB, 0xD7, 0xBB, 0xC5, 0x46, 0x30, 0x30, 0x44}));
        assert(TH_Tokenized::makeStringFromData(data_t({0xBB, 0xD7, 0xBB, 0xC8, 0x32, 0x45}), {{"fromRawBytes", 1}}) == R"(\\x2E)");
        assert(TH_Tokenized::makeStringFromData(data_t({0xBB, 0xD7, 0xBB, 0xC5, 0x46, 0x30, 0x30, 0x44}), {{"fromRawBytes", 1}}) == R"(\\uF00D)");
    }

    {
        const data_t functionInString = {0xDE, 0x2A, 0xC2, 0x58};
        const std::string readableFunction = TH_Tokenized::makeStringFromData(functionInString, {{"fromRawBytes", 1}});
        assert(readableFunction == R"(Disp "\sin(X)");
        assert(!contains_numeric_token_escape(readableFunction));
        assert(TH_Tokenized::makeDataFromString(readableFunction)
               == data_t({0x04, 0x00, 0xDE, 0x2A, 0xC2, 0x58}));

        const data_t spacedAndInString = {0xDE, 0x2A, 0x41, 0x40, 0x42, 0x2A};
        const std::string readableAnd = TH_Tokenized::makeStringFromData(spacedAndInString, {{"fromRawBytes", 1}});
        assert(readableAnd == R"(Disp "A\ and B")");
        assert(!contains_numeric_token_escape(readableAnd));
        assert(TH_Tokenized::makeDataFromString(readableAnd)
               == data_t({0x06, 0x00, 0xDE, 0x2A, 0x41, 0x40, 0x42, 0x2A}));
    }

    {
        ScopedStderrCapture exhaustiveNamedEscapeStderr;
        size_t checkedNamedTokenCount = 0;
        for (const uint16_t token : forceable_named_legacy_tokens())
        {
            const data_t original = legacy_string_token_data(token);
            const data_t rawBytes(original.begin() + 2, original.end());
            const std::string readable = TH_Tokenized::makeStringFromData(rawBytes, {{"fromRawBytes", 1}});
            assert(!contains_numeric_token_escape(readable));
            assert(TH_Tokenized::makeDataFromString(readable) == original);
            ++checkedNamedTokenCount;
        }
        assert(checkedNamedTokenCount > 500);
    }

    {
        const std::string sourceWithNumericEscapes = R"TI(Disp "\xC2X"
Disp "\x41\x40\x42")TI";
        const std::string expectedReadable = R"TI(Disp "\sin(X"
Disp "A\ and B")TI";
        const std::string path = "/tmp/tivars_named_escape_preference.8xp";

        TIVarFile program = TIVarFile::createNew("Program", "NAMED", "84+CE");
        program.setContentFromString(sourceWithNumericEscapes);
        const data_t originalRaw = program.getRawContent();
        assert(program.getReadableContent() == expectedReadable);
        assert(!contains_numeric_token_escape(program.getReadableContent()));
        program.saveVarToFile(path);

        TIVarFile reloaded = TIVarFile::loadFromFile(path);
        assert(reloaded.getReadableContent() == expectedReadable);
        assert(!contains_numeric_token_escape(reloaded.getReadableContent()));
        assert(reloaded.getRawContent() == originalRaw);
        assert_roundtrip_from_readable(reloaded);
        assert(remove(path.c_str()) == 0);
    }

    {
        assert(TH_Tokenized::makeStringFromData(data_t({0x3F}), {{"fromRawBytes", 1}}) == "\n");
        assert(TH_Tokenized::makeDataFromString("\n") == data_t({0x01, 0x00, 0x3F}));
    }

    {
        const std::string readable = TH_Tokenized::makeStringFromData(data_t({0x5F, 0xAA, 0x08}), {{"fromRawBytes", 1}});
        assert(readable == R"(prgm\Str9)");
        assert(TH_Tokenized::makeDataFromString(readable) == data_t({0x03, 0x00, 0x5F, 0xAA, 0x08}));
    }

    {
        const std::string menuSource = R"lit(Menu(Str8,"k(a+b)",1,"k(a-b)",1S,"",A,"",A,"",A,"",A,"",A,Str9,F,Str7,Q)lit";
        TIVarFile menuPrgm = TIVarFile::createNew("Program", "MENU");
        menuPrgm.setContentFromString(menuSource);
        assert(menuPrgm.getReadableContent({{"accessible", true}, {"prettify", true}, {"reindent", false}}) == menuSource);
        assert(menuPrgm.getReadableContent({{"accessible", true}, {"prettify", false}, {"reindent", false}}) == menuSource);
        assert(menuPrgm.getReadableContent({{"prettify", true}, {"reindent", false}}) == menuSource);
        assert(menuPrgm.getReadableContent({{"prettify", false}, {"reindent", false}}) == menuSource);
    }

    {
        const std::string menuSource = R"lit(Menu(Str8,"k(a…b)",A," (a…b)ʳ",B,"k(a…b)ʳ",D," (a…b)(c…d)",5,"k(a…b)(c…d)",6,"",F,"",F,"",F,Str7,Q)lit";
        const std::string accessibleMenuSource = R"lit(Menu(Str8,"k(a...b)",A," (a...b)^^r",B,"k(a...b)^^r",D," (a...b)(c...d)",5,"k(a...b)(c...d)",6,"",F,"",F,"",F,Str7,Q)lit";
        TIVarFile menuPrgm = TIVarFile::createNew("Program", "MENU2");
        menuPrgm.setContentFromString(menuSource);
        const auto& tmp = menuPrgm.getReadableContent({{"accessible", true}, {"reindent", false}});
        assert(menuPrgm.getReadableContent({{"accessible", true}, {"reindent", false}}) == accessibleMenuSource);
        assert(menuPrgm.getReadableContent({{"accessible", true}, {"prettify", true}, {"reindent", false}}) == accessibleMenuSource);
        assert(menuPrgm.getReadableContent({{"prettify", true}, {"reindent", false}}) == menuSource);
    }

    {
        ScopedStderrCapture unknownTokenStderr;
        const std::string readable = TH_Tokenized::makeStringFromData(data_t{0xBB, 0xD0}, {{"fromRawBytes", 1}});
        assert(readable == "\\uBBD0");
        assert(unknownTokenStderr.str().find("Unknown token 0xBBD0 detokenized as \\uBBD0!") != std::string::npos);
    }

#ifndef _WIN32
    {
        const std::string path = "/tmp/tivars_lib_cpp_readonly_test.8xp";
        TIVarFile readonlyPrgm = TIVarFile::createNew("Program", "READONLY");
        readonlyPrgm.setContentFromString("Disp 42");
        readonlyPrgm.saveVarToFile(path);
        assert(chmod(path.c_str(), 0444) == 0);

        TIVarFile readonlyLoaded = TIVarFile::loadFromFile(path);
        assert(readonlyLoaded.getReadableContent() == "Disp 42");

        assert(chmod(path.c_str(), 0644) == 0);
        assert(remove(path.c_str()) == 0);
    }
#endif

    {
        TIVarFile testPrgmStr1 = TIVarFile::createNew("Program", "asdf");
        for (const auto& str : { "\"42→Str1:Str2:123", "\"42->Str1:Str2:123" }) // those should tokenize as the same
        {
            testPrgmStr1.setContentFromString(str);
            assert(trim(testPrgmStr1.getReadableContent({{"prettify", true}, {"reindent", true}})) == "\"42→Str1\nStr2\n123");
            assert(trim(testPrgmStr1.getReadableContent({{"prettify", false}, {"reindent", true}})) == "\"42→Str1\nStr2\n123");
            assert(trim(testPrgmStr1.getReadableContent({{"prettify", true}, {"reindent", false}})) == "\"42→Str1:Str2:123");
            assert(trim(testPrgmStr1.getReadableContent({{"prettify", false}, {"reindent", false}})) == "\"42→Str1:Str2:123");
            assert(trim(testPrgmStr1.getReadableContent()) == "\"42→Str1:Str2:123");
        }

        testPrgmStr1.setContentFromString("\"42-\\>Str1:Str2:123");
        const std::string readable = testPrgmStr1.getReadableContent({{"prettify", true}, {"reindent", true}});
        assert(trim(testPrgmStr1.getReadableContent({{"prettify", true}, {"reindent", true}})) == "\"42->Str1\nStr2\n123");
        assert(trim(testPrgmStr1.getReadableContent({{"prettify", false}, {"reindent", true}})) == "\"42-\\>Str1:Str2:123");
        assert(trim(testPrgmStr1.getReadableContent({{"prettify", true}, {"reindent", false}})) == "\"42->Str1:Str2:123");
        assert(trim(testPrgmStr1.getReadableContent({{"prettify", false}, {"reindent", false}})) == "\"42-\\>Str1:Str2:123");
        assert(trim(testPrgmStr1.getReadableContent()) == "\"42-\\>Str1:Str2:123");

        testPrgmStr1.setContentFromString("42->Str1:Str2:123");
        assert(trim(testPrgmStr1.getReadableContent({{"prettify", true}, {"reindent", true}})) == "42→Str1\nStr2\n123");
        assert(trim(testPrgmStr1.getReadableContent({{"prettify", false}, {"reindent", true}})) == "42→Str1\nStr2\n123");
        assert(trim(testPrgmStr1.getReadableContent({{"prettify", true}, {"reindent", false}})) == "42→Str1:Str2:123");
        assert(trim(testPrgmStr1.getReadableContent({{"prettify", false}, {"reindent", false}})) == "42→Str1:Str2:123");
        assert(trim(testPrgmStr1.getReadableContent()) == "42→Str1:Str2:123");

        testPrgmStr1.setContentFromString("AUTO:chi^2pdf(:a+bi:42->Str1");
        assert(trim(testPrgmStr1.getReadableContent({{"reindent", false}})) == "AUTO:χ²pdf(:a+b𝑖:42→Str1");
        assert(trim(testPrgmStr1.getReadableContent({{"accessible", true}, {"reindent", false}})) == "AUTO:chi^2pdf(:a+bi:42->Str1");
    }

    {
        TIVarFile testPrgm = TIVarFile::createNew("Program", "asdf");

        // all these are equivalent
        for (const auto& str : { R"(A and B)", R"(A\ and B)", R"(A␟ and B)", R"(A  and B)", R"(A‌ and B)" })
        {
            testPrgm.setContentFromString(str);
            string detok_fr = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_FR}});
            string detok_en = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_EN}});
            string hex = testPrgm.getRawContentHexStr();
            assert(hex == "0300""414042");
            assert(detok_en == R"(A and B)");
            assert(detok_fr == R"(A et B)");
        }

        assert(!TH_Tokenized::isTwoByteTokenPrefix(0x40));
        assert(TH_Tokenized::isTwoByteTokenPrefix(0xBB));

        const json legacyTokenJSON = json::parse(TH_Tokenized::tokenDataToJson({0x04, 0x00, 0x40, 0xBB, 0x97, 0x3F}));
        assert(legacyTokenJSON["metadata"]["format"] == "legacy");
        assert(legacyTokenJSON["metadata"]["payloadByteLength"] == 4);
        assert(legacyTokenJSON["metadata"]["tokenCount"] == 3);
        assert(legacyTokenJSON["data"][0]["bytes"] == "40");
        assert(!legacyTokenJSON["data"][0].contains("legacyBytes"));
        assert(legacyTokenJSON["data"][0]["en"] == " and ");
        assert(legacyTokenJSON["data"][0]["fr"] == " et ");
        assert(legacyTokenJSON["data"][1]["bytes"] == "BB97");
        assert(legacyTokenJSON["data"][2]["en"] == "↵");
        assert(legacyTokenJSON["data"][2]["lineBreak"] == true);

        bool rejectedUnfinishedLegacyToken = false;
        try
        {
            (void)TH_Tokenized::tokenDataToJson({0x01, 0x00, 0xBB});
        }
        catch (const std::invalid_argument&)
        {
            rejectedUnfinishedLegacyToken = true;
        }
        assert(rejectedUnfinishedLegacyToken);

        const json fileTokenJSON = json::parse(testPrgm.getTokenDataJson());
        assert(fileTokenJSON["metadata"]["variableName"] == "ASDF");
        assert(fileTokenJSON["metadata"]["variableType"] == "Program");
        assert(fileTokenJSON["metadata"]["calculatorModel"] == "84+CE");

        // all these are equivalent
        for (const auto& str : { R"(A \and B)", R"(A a\nd B)", R"(A an\d B)", R"(A and\ B)" })
        {
            testPrgm.setContentFromString(str);
            string detok_fr = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_FR}});
            string detok_en = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_EN}});
            string pretty_detok_fr = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_FR}, {"prettify", true}});
            string pretty_detok_en = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_EN}, {"prettify", true}});
            string hex = testPrgm.getRawContentHexStr();
            assert(hex == "0a00""4129bbb0bbbebbb32942");
            assert(detok_en == R"(A and\ B)");
            assert(detok_fr == R"(A and\ B)");
            assert(pretty_detok_en == R"(A and B)");
            assert(pretty_detok_fr == R"(A and B)");
        }
    }

    {
        TIVarFile testPrgm = TIVarFile::createNew("Program", "asdf");
        testPrgm.setContentFromString("{2,3→dim([A]");
        assert(trim(testPrgm.getReadableContent({{"prettify", true}, {"reindent", true}})) == "{2,3→dim([A]");
        string hex = testPrgm.getRawContentHexStr();
        assert(hex == "0800""08322b3304b55c00");
    }

    {
        TIVarFile eightCharPrgm = TIVarFile::createNew("Program", "ABCDEFGH");
        eightCharPrgm.setContentFromString("piecewise(");
        const std::string savePath = eightCharPrgm.saveVarToFile("/tmp", "");
        assert(savePath == "/tmp/ABCDEFGH.8xp");

        TIVarFile reloadedEightCharPrgm = TIVarFile::loadFromFile(savePath);
        const std::string resavedPath = reloadedEightCharPrgm.saveVarToFile("/tmp", "");
        assert(resavedPath == savePath);
        assert(remove(savePath.c_str()) == 0);
    }

    {
        TIVarFile archivedPrgm = TIVarFile::createNew("Program", "ARCHIVE");
        archivedPrgm.setContentFromString("Disp 42");
        archivedPrgm.setArchived(true);
        const std::string savePath = archivedPrgm.saveVarToFile("/tmp", "ARCHIVE");

        TIVarFile reloadedArchivedPrgm = TIVarFile::loadFromFile(savePath);
        assert(reloadedArchivedPrgm.getReadableContent() == "Disp 42");
        assert(reloadedArchivedPrgm.getVarEntries()[0].archivedFlag == 0x80);
        assert(remove(savePath.c_str()) == 0);
    }

    {
        // See https://wikiti.brandonw.net/index.php?title=83Plus:OS:Variable_Versions
        TIVarFile testPrgmStr1 = TIVarFile::createNew("Program", "asdf");
        const auto& ver = testPrgmStr1.getVarEntries()[0].version;
        assert(ver == VER_NONE);
        testPrgmStr1.setContentFromString("Disp 41+1");
        assert((ver & ~0x20) == VER_NONE);
        testPrgmStr1.setContentFromString("Archive A");
        assert((ver & ~0x20) == VER_83P_ALL);
        testPrgmStr1.setContentFromString("GarbageCollect");
        assert((ver & ~0x20) == VER_83P_ALL);
        testPrgmStr1.setContentFromString("Disp 42%");
        assert((ver & ~0x20) == VER_83P_115);
        testPrgmStr1.setContentFromString("~A");
        assert((ver & ~0x20) == 0x00);
        testPrgmStr1.setContentFromString("|~A");
        assert((ver & ~0x20) == VER_83P_115);
        testPrgmStr1.setContentFromString("Disp \"…\"");
        assert((ver & ~0x20) == VER_83P_116);
        testPrgmStr1.setContentFromString("Disp \"⌸\"");
        assert((ver & ~0x20) == VER_83P_116);
        testPrgmStr1.setContentFromString("setDate(A,B,C)");
        assert((ver & ~0x20) == VER_84P_ALL);
        testPrgmStr1.setContentFromString("ExecLib \"A\"");
        assert((ver & ~0x20) == VER_84P_ALL);
        testPrgmStr1.setContentFromString("Manual-Fit ");
        assert((ver & ~0x20) == VER_84P_230);
        testPrgmStr1.setContentFromString("ZQuadrant1");
        assert((ver & ~0x20) == VER_84P_253MP);
        testPrgmStr1.setContentFromString("FRAC");
        assert((ver & ~0x20) == VER_84P_253MP);
        testPrgmStr1.setContentFromString("STATWIZARD ON");
        assert((ver & ~0x20) == VER_84P_255MP);
        testPrgmStr1.setContentFromString("STATWIZARD OFF");
        assert((ver & ~0x20) == VER_84P_255MP);
        testPrgmStr1.setContentFromString("BLUE");
        assert((ver & ~0x20) == VER_84CSE_ALL);
        testPrgmStr1.setContentFromString("Dot-Thin");
        assert((ver & ~0x20) == VER_84CSE_ALL);
        testPrgmStr1.setContentFromString("TraceStep");
        assert((ver & ~0x20) == VER_NONE); // 63** token ranges are not considered by a calculator when it generates the version.
        testPrgmStr1.setContentFromString("Asm84CEPrgm:C9");
        assert((ver & ~0x20) == VER_CE_ALL);
        testPrgmStr1.setContentFromString("Disp eval(Str1");
        assert((ver & ~0x20) == VER_CE_ALL); // 0Bh is used for all of TI-84 Plus CE OS 5.0 through 5.2, despite tokens being added between them.
        testPrgmStr1.setContentFromString("Quartiles Setting…");
        assert((ver & ~0x20) == VER_CE_ALL);
        testPrgmStr1.setContentFromString("Execute Program");
        assert((ver & ~0x20) == VER_CE_530);
        testPrgmStr1.setContentFromString("piecewise(");
        assert((ver & ~0x20) == VER_CE_530);
    }

    {
        assert(TH_Tokenized::oneTokenBytesToString(0x00) == "");
        assert(TH_Tokenized::oneTokenBytesToString(0x10) == "(");
        assert(TH_Tokenized::oneTokenBytesToString(0x11) == ")");
        assert(TH_Tokenized::oneTokenBytesToString(0xBB) == "");
        assert(TH_Tokenized::oneTokenBytesToString(0x3F) == "\n");
        assert(TH_Tokenized::oneTokenBytesToString(0xAD) == "getKey");
        assert(TH_Tokenized::oneTokenBytesToString(0xEF97) == "toString(");
        assert(TH_Tokenized::oneTokenBytesToString(0x40, {{"lang", TH_Tokenized::LANG_EN}}) == " and ");
        assert(TH_Tokenized::oneTokenBytesToString(0x40, {{"lang", TH_Tokenized::LANG_FR}}) == " et ");
    }

    {
        TIVarFile asmProgram = TIVarFile::createNew("Program", "ASMHDR");
        asmProgram.setContentFromString(R"({
    "rawDataHex": "BB6DC90100000000000000000000000000000000000000000000000000000000000048656C6C6F00"
})");
        const json asmMetadata = json::parse(asmProgram.getReadableContent({{"metadata", true}}));
        assert(asmMetadata["isAssembly"] == true);
        assert(asmMetadata["shell"] == "MirageOS");
        assert(asmMetadata["description"] == "Hello");
        assert(asmMetadata["typeName"] == "Program");

        TIVarFile metadataProgram = TIVarFile::createNew("Program", "JSONASM");
        metadataProgram.setContentFromString(R"({
    "rawDataHex": "BB6DC901000000000000000000000000000000000000000000000000000000000000486900"
})");
        const json metadataProgramJSON = json::parse(metadataProgram.getReadableContent({{"metadata", true}}));
        assert(metadataProgramJSON["isAssembly"] == true);
        assert(metadataProgramJSON["shell"] == "MirageOS");
    }

    {
        TIVarFile basicProgram = TIVarFile::createNew("Program", "META");
        basicProgram.setContentFromString("Disp 42");
        const json basicMetadata = json::parse(basicProgram.getReadableContent({{"metadata", true}}));
        assert(basicMetadata["isAssembly"] == false);
        assert(basicMetadata["code"] == "Disp 42");
    }

    {
        TH_Tokenized::token_posinfo actual{}, expected{};
        const data_t data = { 0x12,0x00,0x41,0x40,0x42,0x3f,0xde,0x2a,0x41,0x29,0xbb,0xb0,0xbb,0xbe,0xbb,0xb3,0x29,0x42,0x2a,0x3f };
        actual = TH_Tokenized::getPosInfoAtOffset(data, 2);
        expected = { 0, 0, 1 };
        assert(compare_token_posinfo(actual, expected) == true);
        actual = TH_Tokenized::getPosInfoAtOffset(data, 3);
        expected = { 0, 1, 5 };
        assert(compare_token_posinfo(actual, expected) == true);
        actual = TH_Tokenized::getPosInfoAtOffset(data, 6);
        expected = { 1, 0, 5 };
        assert(compare_token_posinfo(actual, expected) == true);
    }

    {
        // getPosInfoAtOffset with prettify on/off
        // bytes: size(ignored here), then: '\n' (3F), then EF97 (toString(), len 9), then ':' (3E)
        data_t data = {0x00,0x00, 0x3F, 0xEF,0x97, 0x3E};
        auto pi_plain = TH_Tokenized::getPosInfoAtOffset(data, 3, {});
        auto pi_pretty = TH_Tokenized::getPosInfoAtOffset(data, 3, {{"prettify",1}});
        // After a newline, column resets to 0; token length should be length of "toString("
        TH_Tokenized::token_posinfo expected_plain{ 1, 0, (uint8_t)std::string("toString(").size() };
        assert(compare_token_posinfo(pi_plain, expected_plain));
        assert(compare_token_posinfo(pi_pretty, expected_plain));
    }

    {
        TH_Tokenized::token_posinfo actual{}, expected{};
        const std::string hexStr = "12004140423fde2a4129bbb0bbbebbb329422a3f";
        actual = TH_Tokenized::getPosInfoAtOffsetFromHexStr(hexStr, 2);
        expected = { 0, 0, 1 };
        assert(compare_token_posinfo(actual, expected) == true);
        actual = TH_Tokenized::getPosInfoAtOffsetFromHexStr(hexStr, 3);
        expected = { 0, 1, 5 };
        assert(compare_token_posinfo(actual, expected) == true);
        actual = TH_Tokenized::getPosInfoAtOffsetFromHexStr(hexStr, 6);
        expected = { 1, 0, 5 };
        assert(compare_token_posinfo(actual, expected) == true);
    }

    {
        TH_Tokenized::token_posinfo actual{}, expected{};
        const std::string hexStr = "0700DEEF983170323F";
        actual = TH_Tokenized::getPosInfoAtOffsetFromHexStr(hexStr, 2);
        expected = { 0, 0, 5 };
        assert(compare_token_posinfo(actual, expected) == true);
        actual = TH_Tokenized::getPosInfoAtOffsetFromHexStr(hexStr, 3);
        expected = { 0, 5, 5 };
        assert(compare_token_posinfo(actual, expected) == true);
    }

    {
        TH_Tokenized::token_posinfo actual{}, expected{};
        const std::string hexStr = "010004";
        actual = TH_Tokenized::getPosInfoAtOffsetFromHexStr(hexStr, 2);
        expected = { 0, 0, 1 };
        assert(compare_token_posinfo(actual, expected) == true);
    }

    {
        TH_Tokenized::token_posinfo actual{}, expected{};
        actual = TH_Tokenized::getPosInfoAtOffsetInSourceString("1->A", 4);
        expected = { 0, 3, 1 };
        assert(compare_token_posinfo(actual, expected) == true);

        actual = TH_Tokenized::getPosInfoAtOffsetInSourceString("1→A", 4);
        expected = { 0, 2, 1 };
        assert(compare_token_posinfo(actual, expected) == true);

        actual = TH_Tokenized::getPosInfoAtOffsetInSourceString("1->A", 3);
        expected = { 0, 1, 2 };
        assert(compare_token_posinfo(actual, expected) == true);
    }

    {
        const data_t arrow = TH_Tokenized::makeDataFromString("1->A");
        assert(arrow == data_t({0x03, 0x00, 0x31, 0x04, 0x41}));

        const data_t escapedArrow = TH_Tokenized::makeDataFromString("1-\\>A");
        data_t expectedEscapedArrow = { 0x04, 0x00 };
        expectedEscapedArrow.push_back(TH_Tokenized::makeDataFromString("1")[2]);
        expectedEscapedArrow.push_back(TH_Tokenized::makeDataFromString("-")[2]);
        expectedEscapedArrow.push_back(TH_Tokenized::makeDataFromString(">")[2]);
        expectedEscapedArrow.push_back(TH_Tokenized::makeDataFromString("A")[2]);
        assert(escapedArrow == expectedEscapedArrow);

        const data_t invisibleSeparator = TH_Tokenized::makeDataFromString("\\");
        assert(invisibleSeparator == data_t({0x00, 0x00}));

        const data_t literalBackslash = TH_Tokenized::makeDataFromString("\\\\");
        data_t expectedLiteralBackslash = { 0x02, 0x00, 0xBB, 0xD7 };
        assert(literalBackslash == expectedLiteralBackslash);

        for (const std::string& separator : { std::string("␟"), std::string(" "), std::string("‌") })
        {
            const data_t separatedArrow = TH_Tokenized::makeDataFromString("1-" + separator + ">A");
            assert(separatedArrow == expectedEscapedArrow);
        }
    }

    {
        TH_Tokenized::token_posinfo actual{}, expected{};

        actual = TH_Tokenized::getPosInfoAtOffsetInSourceString("1-\\>A", 4);
        expected = { 0, 3, 1 };
        assert(compare_token_posinfo(actual, expected) == true);

        actual = TH_Tokenized::getPosInfoAtOffsetInSourceString("\\\\", 2);
        expected = { 0, 0, 2 };
        assert(compare_token_posinfo(actual, expected) == true);

        for (const std::string& separator : { std::string("␟"), std::string(" "), std::string("‌") })
        {
            actual = TH_Tokenized::getPosInfoAtOffsetInSourceString("1-" + separator + ">A", 4);
            expected = { 0, 3, 1 };
            assert(compare_token_posinfo(actual, expected) == true);
        }
    }

    {
        const auto raw = [](const std::string& source)
        {
            return TH_Tokenized::makeDataFromString(source);
        };
        const auto hasForcedNamedToken = [](const std::string& source, const std::string& expectedText)
        {
            const auto scanned = TH_Tokenized::scanSourceTokens(source);
            return std::any_of(scanned.begin(), scanned.end(), [&](const auto& item)
            {
                return item.matched && item.text == expectedText;
            });
        };

        // Named escapes only change the ordinary-string min-munch context.
        assert(raw(R"(sin(X)") == raw(R"(\sin(X)"));
        assert(raw(R"(Disp "sin(X)") != raw(R"(Disp "\sin(X)"));
        assert(hasForcedNamedToken(R"(Disp "\sin(X)", R"(\sin()"));
        assert(!hasForcedNamedToken(R"(\sin(X)", R"(\sin()"));

        // Evaluated and equation strings already use maximal munch; backslash
        // keeps acting as a zero-width token boundary in those contexts.
        assert(raw(R"TI(Send("sin(X"))TI") == raw(R"TI(Send("\sin(X"))TI"));
        assert(raw(R"TI(expr("sin(X"))TI") == raw(R"TI(expr("\sin(X"))TI"));
        assert(raw(R"TI("sin(X"→Y₁)TI") == raw(R"TI("\sin(X"→Y₁)TI"));
        assert(raw(R"TI(String►Equ("sin(X",Y₁))TI") == raw(R"TI(String►Equ("\sin(X",Y₁))TI"));
        assert(!hasForcedNamedToken(R"TI(Send("\sin(X"))TI", R"(\sin()"));
        assert(!hasForcedNamedToken(R"TI("\sin(X"→Y₁)TI", R"(\sin()"));

        // A separator before a structural token must still let that token
        // update the quote/store state instead of consuming it early.
        assert(raw(R"TI(Disp \"sin(X)TI") == raw(R"TI(Disp "sin(X)TI"));
        assert(raw(R"TI(Disp "A\→sin(X)TI") == raw(R"TI(Disp "A→sin(X)TI"));
        assert(raw(R"TI(Disp "A\->sin(X)TI") == raw(R"TI(Disp "A→sin(X)TI"));

        // Readable token names may include their surrounding spaces. The
        // first slash forces the complete " and " token in an ordinary
        // string; the second slash is just a boundary before the quote.
        const std::string forcedSpacedAnd = R"TI(Disp "A\ and \")TI";
        const data_t expectedSpacedAnd = { 0x05, 0x00, 0xDE, 0x2A, 0x41, 0x40, 0x2A };
        assert(raw(forcedSpacedAnd) == expectedSpacedAnd);
        assert(hasForcedNamedToken(forcedSpacedAnd, R"(\ and )"));
        assert(!hasForcedNamedToken(forcedSpacedAnd, R"(\")"));
        for (const std::string& separatedAnd : {
                 R"TI(A\ and B)TI", R"TI(A and \B)TI", R"TI(A\ and \B)TI" })
        {
            assert(raw(separatedAnd) == raw(R"TI(A and B)TI"));
        }
        assert(raw(R"TI(Disp "A\ and B")TI") == raw(R"TI(Disp "\x41\x40\x42")TI"));
        assert(raw(R"TI(Send("A\ and \B"))TI") == raw(R"TI(Send("A and B"))TI"));
        assert(raw(R"TI("A\ and \B"→Y₁)TI") == raw(R"TI("A and B"→Y₁)TI"));

        // Existing raw/literal escape precedence remains unchanged.
        assert(raw(R"TI(Disp "\xC2X)TI") == raw(R"TI(Disp "\sin(X)TI"));
        assert(raw(R"(\\sin(X)") != raw(R"(\sin(X)"));
        assert(raw(R"(sin(X\)") == raw(R"(sin(X)"));
        assert(raw(R"(prgmABC\sin(X)") == raw("prgmABC␟sin(X"));
    }

    {
        // Make sure \r\n is tokenized the same as \n (because \r is just ignored as it's not a known token)
        TIVarFile testPrgm = TIVarFile::createNew("Program", "TEST1");
        testPrgm.setContentFromString("Pause 1\nPause 1");
        TIVarFile testPrgm2 = TIVarFile::createNew("Program", "TEST2");
        testPrgm2.setContentFromString("Pause 1\r\nPause 1");
        assert(testPrgm.getRawContentHexStr() == testPrgm2.getRawContentHexStr());
    }

    {
        // Test lower alpha being the expected lowercase tokens, not special-meaning ones
        TIVarFile testPrgm = TIVarFile::createNew("Program", "INTERP");
        testPrgm.setContentFromString("Disp \"abcdefghijklmnopqrstuvwxyz\"");
        string detok_fr = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_FR}});
        string detok_en = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_EN}});
        string hex = testPrgm.getRawContentHexStr();
        assert(detok_fr == "Disp \"abcdefghijklmnopqrstuvwxyz\"");
        assert(detok_en == "Disp \"abcdefghijklmnopqrstuvwxyz\"");
        assert(hex == "3700de2abbb0bbb1bbb2bbb3bbb4bbb5bbb6bbb7bbb8bbb9bbbabbbcbbbdbbbebbbfbbc0bbc1bbc2bbc3bbc4bbc5bbc6bbc7bbc8bbc9bbca2a");
    }

    {
        // Test string interpolation behaviour
        TIVarFile testPrgm = TIVarFile::createNew("Program", "INTERP");
        testPrgm.setContentFromString(R"(A and B:Disp "A and B":Send("SET SOUND eval(A and B) TIME 2)");
        string detok_fr = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_FR}});
        string detok_en = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_EN}});
        assert(detok_en == R"(A and B:Disp "A and B":Send("SET SOUND eval(A and B) TIME 2)");
        assert(detok_fr == R"(A et B:Disp "A and B":Envoi("SET SOUND eval(A et B) TIME 2)");
    }

    {
        // Test tokenization exceptions
        TIVarFile testPrgm = TIVarFile::createNew("Program", "FOOBAR");
        testPrgm.setContentFromString(R"(Disp "WHITE,ʟWHITE,prgmWHITE",WHITE,ʟWHITE:prgmWHITE:prgmABCDEF)");
        string detok_fr = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_FR}});
        string detok_en = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_EN}});
        assert(detok_en == R"(Disp "WHITE,ʟWHITE,prgmWHITE",WHITE,ʟWHITE:prgmWHITE:prgmABCDEF)");
        assert(detok_fr == R"(Disp "WHITE,ʟWHITE,prgmWHITE",BLANC,ʟWHITE:prgmWHITE:prgmABCDEF)");
        // While this is visually fine, the "prgm" inside the token should probably be the token, not p r g m ...
    }

    {
        // Test tokenization exceptions in an interpolated string
        TIVarFile testPrgm = TIVarFile::createNew("Program", "FOOBAR");
        testPrgm.setContentFromString(R"(Send("SET SOUND eval(A and prgmWHITE) TIME 2)");
        string detok_fr = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_FR}});
        string detok_en = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_EN}});
        assert(detok_en == R"(Send("SET SOUND eval(A and prgmWHITE) TIME 2)");
        assert(detok_fr == R"(Envoi("SET SOUND eval(A et prgmWHITE) TIME 2)");

        testPrgm.setContentFromString(R"(Send("A and prgmWHITE)");
        detok_fr = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_FR}});
        detok_en = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_EN}});
        assert(detok_en == R"(Send("A and prgmWHITE)");
        assert(detok_fr == R"(Envoi("A et prgmWHITE)");

        testPrgm.setContentFromString(R"(Send("A \and prgmWHITE)");
        detok_fr = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_FR}});
        detok_en = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_EN}});
        assert(detok_en == R"(Send("A and\ prgmWHITE)");
        assert(detok_fr == R"(Envoi("A and\ prgmWHITE)");

        testPrgm.setContentFromString(R"(Send("A and\ prgmWHITE)");
        detok_fr = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_FR}});
        detok_en = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_EN}});
        assert(detok_en == R"(Send("A and\ prgmWHITE)");
        assert(detok_fr == R"(Envoi("A and\ prgmWHITE)");
    }

    {
        TIVarFile clibs = TIVarFile::loadFromFile("testData/clibs.8xg");
        const auto& entries = clibs.getVarEntries();
        assert(entries.size() == 9);
        for (int i=0; i<9; i++) {
            assert(entries[i].typeID == TIVarType{"AppVar"}.getId());
        }
        assert((char*)entries[1].varname == "GRAPHX"s);
        cout << clibs.getReadableContent() << "\n" << endl;
    }

    {
        TIVarFile groupObject = TIVarFile::createNew("GroupObject", "GROUP");
        groupObject.setContentFromString(R"({
    "entries": [
        {
            "typeName": "String",
            "name": "Str1",
            "readableContent": "Hello Group"
        },
        {
            "typeName": "AppVar",
            "name": "DATA",
            "readableContent": "ABCD1234"
        },
        {
            "typeName": "Real",
            "name": "A",
            "readableContent": "42"
        }
    ]
})");

        const json groupObjectJSON = json::parse(groupObject.getReadableContent());
        assert(groupObjectJSON["entries"].size() == 3);
        assert(groupObjectJSON["entries"][0]["typeName"] == "String");
        assert(groupObjectJSON["entries"][0]["name"] == "Str1");
        assert(groupObjectJSON["entries"][0]["readableContent"] == "Hello Group");
        assert(groupObjectJSON["entries"][1]["typeName"] == "AppVar");
        assert(groupObjectJSON["entries"][1]["name"] == "DATA");
        assert(groupObjectJSON["entries"][1]["readableContent"] == "ABCD1234");
        assert(groupObjectJSON["entries"][2]["typeName"] == "Real");
        assert(groupObjectJSON["entries"][2]["name"] == "A");
        assert(groupObjectJSON["entries"][2]["readableContent"] == 42);

        TIVarFile recreatedGroupObject = TIVarFile::createNew("GroupObject", "GROUP");
        recreatedGroupObject.setContentFromString(groupObject.getReadableContent());
        assert(recreatedGroupObject.getRawContent() == groupObject.getRawContent());

        const std::string groupObjectPath = groupObject.saveVarToFile("/tmp", "GROUPOBJ");
        TIVarFile reloadedGroupObject = TIVarFile::loadFromFile(groupObjectPath);
        assert(reloadedGroupObject.getReadableContent() == groupObject.getReadableContent());
        assert(reloadedGroupObject.getRawContent() == groupObject.getRawContent());
        assert(remove(groupObjectPath.c_str()) == 0);

        TIVarFile artifi82 = TIVarFile::loadFromFile("testData/ARTIFI82.8cg");
        const json artifi82JSON = json::parse(artifi82.getReadableContent());
        assert(artifi82JSON["entries"].size() == 570);
        assert(artifi82JSON["entries"][0]["typeName"] == "PythonAppVar");
        assert(artifi82JSON["entries"][0]["name"] == "00");
        assert(artifi82JSON["entries"][1]["name"] == "01");
        assert(artifi82JSON["entries"][37].contains("name") == false);
        assert(artifi82JSON["entries"][569]["nameHex"] == "4380000000000000");
    }

    {
        TIVarFile testAppVar = TIVarFile::createNew("AppVar", "TEST");
        testAppVar.setContentFromString("ABCD1234C9C8C7C6"); // random but valid hex string
        assert(testAppVar.getReadableContent() == "ABCD1234C9C8C7C6");
        assert(testAppVar.getRawContent().size() == strlen("ABCD1234C9C8C7C6") / 2 + 2);
        testAppVar.saveVarToFile("testData", "testAVnew");
        bool rejectedNonTokenized = false;
        try
        {
            (void)testAppVar.getTokenDataJson();
        }
        catch (const std::invalid_argument&)
        {
            rejectedNonTokenized = true;
        }
        assert(rejectedNonTokenized);
    }

    {
        TIVarFile testString = TIVarFile::loadFromFile("testData/String.8xs");
        assert(testString.getReadableContent() == "Hello World");
        assert(json::parse(testString.getTokenDataJson())["metadata"]["variableType"] == "String");
        assert_roundtrip_from_readable(testString);
    }

    {
        TIVarFile testPrgmQuotes = TIVarFile::loadFromFile("testData/testPrgmQuotes.8xp");
        cout << "testPrgmQuotes.getReadableContent() : " << testPrgmQuotes.getReadableContent() << endl;
        assert(testPrgmQuotes.getReadableContent() == "Pause \"2 SECS\",2");
        assert_roundtrip_from_readable(testPrgmQuotes);
    }

    {
        TIVarFile testEquation = TIVarFile::loadFromFile("testData/Equation_Y1T.8xy");
        assert(testEquation.getReadableContent() == "3sin(T)+4");
        assert_roundtrip_from_readable(testEquation);
    }

    {
        TIVarFile testReal = TIVarFile::loadFromFile("testData/Real.8xn");
        assert(testReal.getRawContent() == data_t({0x80,0x81,0x42,0x13,0x37,0x00,0x00,0x00,0x00}));
        assert(testReal.getRawContentHexStr() == "808142133700000000");
        assert(testReal.getReadableContent() == "-42.1337");
        assert_roundtrip_from_readable(testReal);
        testReal.setContentFromString("5");
        cout << "testReal.getReadableContent() : " << testReal.getReadableContent() << endl;
        assert(testReal.getRawContent() == data_t({0x00,0x80,0x50,0x00,0x00,0x00,0x00,0x00,0x00}));
        assert(testReal.getReadableContent() == "5");
        testReal.setContentFromString(".5");
        cout << "testReal.getReadableContent() : " << testReal.getReadableContent() << endl;
        assert(testReal.getRawContent() == data_t({0x00,0x7F,0x50,0x00,0x00,0x00,0x00,0x00,0x00}));
        assert(testReal.getReadableContent() == "0.5");
        testReal.setContentFromString(".000000999999999999999e105");
        cout << "testReal.getReadableContent() : " << testReal.getReadableContent() << endl;
        assert(testReal.getRawContent() == data_t({0x00,0x80+99,0x10,0x00,0x00,0x00,0x00,0x00,0x00}));
        assert(testReal.getReadableContent() == "1e99");
        testReal.setContentFromString("3.14159265358979323846264");
        cout << "testReal.getReadableContent() : " << testReal.getReadableContent() << endl;
        assert(testReal.getRawContent() == data_t({0x00,0x80   ,0x31,0x41,0x59,0x26,0x53,0x58,0x98}));
        assert(testReal.getReadableContent() == "3.1415926535898");
        testReal.setContentFromString("-1234567890123456789e+12");
        cout << "testReal.getReadableContent() : " << testReal.getReadableContent() << endl;
        assert(testReal.getRawContent() == data_t({0x80,0x80+30,0x12,0x34,0x56,0x78,0x90,0x12,0x35}));
        assert(testReal.getReadableContent() == "-1.2345678901235e30");
    }

    {
        try
        {
            data_t bad_real = data_t({1, 0, 0, 0, 0, 0, 0, 0, 0});
            TH_GenericReal::makeStringFromData(bad_real);
            assert(false);
        }
        catch (exception& e)
        {
            cout << "Caught expected exception: " << e.what() << endl;
        }
    }

    {
        TIVarFile testReal42 = TIVarFile::createNew("Real", "R");
        testReal42.setCalcModel("84+");
        testReal42.setContentFromString("9001.42");
        cout << "testReal42.getReadableContent() : " << testReal42.getReadableContent() << endl;
        assert(testReal42.getReadableContent() == "9001.42");
        testReal42.setContentFromString("-0.00000008");
        cout << "testReal42.getReadableContent() : " << testReal42.getReadableContent() << endl;
        assert(atof(testReal42.getReadableContent().c_str()) == -8e-08);
        testReal42.saveVarToFile("testData", "Real_new");
    }

    {
        string test = "Disp 42\nInput A,\"?\":For(I,1,10)\nThen\nDisp I:For(J,1,10)\nThen\nDisp J\nEnd\nEnd";
        const std::string reindented = TH_Tokenized::reindentCodeString(test);
        cout << "Indented code:" << endl << reindented << endl;
        const std::string expected = R"(Disp 42
Input A,"?"
For(I,1,10)
Then
   Disp I
   For(J,1,10)
   Then
      Disp J
   End
End)";
        assert(reindented == expected);
    }

    {
        string test = "If A:Then\nDisp 1\nEnd";
        const std::string reindented = TH_Tokenized::reindentCodeString(test);
        cout << "Indented code:" << endl << reindented << endl;
        const std::string expected = R"(If A
Then
   Disp 1
End)";
        assert(reindented == expected);
    }

    {
        string test = "u(𝒏-2):³√(9";
        const std::string reindented = TH_Tokenized::reindentCodeString(test);
        cout << "Indented code:" << endl << reindented << endl;
        const std::string expected = R"(u(𝒏-2)
³√(9)";
        assert(reindented == expected);
    }

    {
        // Reindent complex structure including ElseIf and Else/End
        const std::string src = "If A:Then:B:If C:Then:D:Else:E:End:ElseIf F:Then:G:End:End";
        const std::string indented = TH_Tokenized::reindentCodeString(src);
        // Don't enforce exact whitespace formatting; assert structural lines are present and ordered
        assert(indented.find("If A\n") == 0);
        assert(indented.find("Then\n") != std::string::npos);
        assert(indented.find("If C\n") != std::string::npos);
        assert(indented.find("Then\n") != std::string::npos);
        assert(indented.find("Else\n") != std::string::npos);
        assert(indented.find("End\n") != std::string::npos || indented.rfind("\nEnd") == indented.size()-4);
        // Ensure token order preserved when removing colons
        assert(indented.find("B\n") != std::string::npos);
        assert(indented.find("D\n") != std::string::npos);
        assert(indented.find("E\n") != std::string::npos);
        assert(indented.find("ElseIf F\n") != std::string::npos);
        assert(indented.find("G\n") != std::string::npos);
    }

    {
        string test = "   Disp 42\nInput A,\"?\":  For(I,1,10)\n Then\n \xA0 Disp I:For(J,1,10)\nThen\n Disp J\nEnd\nEnd";
        const std::string reindented = TH_Tokenized::reindentCodeString(test);
        cout << "Indented code:" << endl << reindented << endl;
        const std::string expected = R"(Disp 42
Input A,"?"
For(I,1,10)
Then
   Disp I
   For(J,1,10)
   Then
      Disp J
   End
End)";
        assert(reindented == expected);
    }

    {
        string test = "Disp 42\nInput A,\"?\":For(I,1,10)\nThen\nDisp I:For(J,1,10)\nThen\nDisp J\nEnd\nEnd";
        const std::string reindented = TH_Tokenized::reindentCodeString(test, {{"indent_n", 8}});
        cout << "Indented code:" << endl << reindented << endl;
        const std::string expected = R"(Disp 42
Input A,"?"
For(I,1,10)
Then
        Disp I
        For(J,1,10)
        Then
                Disp J
        End
End)";
        assert(reindented == expected);
    }

{
    string test = "Disp 42\nInput A,\"?\":For(I,1,10)\nThen\nDisp I:For(J,1,10)\nThen\nDisp J\nEnd\nEnd";
    const std::string reindented = TH_Tokenized::reindentCodeString(test, {{"indent_char", TH_Tokenized::INDENT_CHAR_TAB}});
    cout << "Indented code:" << endl << reindented << endl;
    const std::string expected = R"(Disp 42
Input A,"?"
For(I,1,10)
Then
	Disp I
	For(J,1,10)
	Then
		Disp J
	End
End)";
    assert(reindented == expected);
}

    {
        TIVarFile testPrgmReindent = TIVarFile::createNew("Program", "asdf");
        testPrgmReindent.setContentFromString("\"http://TIPlanet.org");
        assert(trim(testPrgmReindent.getReadableContent({{"prettify", true}, {"reindent", true}})) == "\"http://TIPlanet.org");
    }

    {
        try
        {
            auto goodTypeForCalc = TIVarFile::createNew("Program", "Bla", "83PCE");
        } catch (exception& e) {
            cout << "Caught unexpected exception: " << e.what() << endl;
            assert(false);
        }
        try
        {
            auto badTypeForCalc = TIVarFile::createNew("ExactComplexFrac", "Bla", "84+");
            assert(false);
        } catch (exception& e) {
            cout << "Caught expected exception: " << e.what() << endl;
        }
    }

    assert(TIVarType{"ExactRealPi"}.getId() == 32);

    {
        TIVarFile testPrgm = TIVarFile::loadFromFile("testData/Program.8xp");
        cout << "testPrgm.getHeader().entries_len = " << testPrgm.getHeader().entries_len
             << "\t testPrgm.size() - 57 == " << (testPrgm.size() - 57) << endl;
        assert(testPrgm.getHeader().entries_len == testPrgm.size() - 57);
        string testPrgmcontent = testPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_FR}});

        TIVarFile newPrgm = TIVarFile::createNew("Program");
        newPrgm.setContentFromString(testPrgmcontent);
        string newPrgmcontent = newPrgm.getReadableContent({{"lang", TH_Tokenized::LANG_FR}});

        assert(testPrgmcontent == newPrgmcontent);
        assert(newPrgm.getRawContent() == testPrgm.getRawContent());
        newPrgm.saveVarToFile("testData", "Program_new");

        cout << endl << "testPrgmcontent : " << endl << testPrgmcontent << endl;
        cout << "\n\n\n" << endl;
    }

    {
        TIVarFile testPrgm42 = TIVarFile::createNew("Program", "asdf");
        testPrgm42.setCalcModel("82A");
        testPrgm42.setContentFromString("Grande blabla:Disp \"Grande blabla");
        testPrgm42.setVarName("MyProgrm");
        assert(testPrgm42.getReadableContent() == "Grande blabla:Disp \"Grande blabla");
        testPrgm42.saveVarToFile("testData", "testMinTok_new");
        testPrgm42.setArchived(true);
        testPrgm42.saveVarToFile("testData", "testMinTok_archived_new");
    }

    {
        TIVarFile testPrgm = TIVarFile::createNew("Program", "asdf");
        testPrgm.setContentFromString("Pause 42:Pause 43:Disp \"\",\"Bouh la =/*: déf\",\"suite :\",\" OK");
        string testPrgmcontent = testPrgm.getReadableContent({{"prettify", true},  {"reindent", true}});
        assert(trim(testPrgmcontent) == "Pause 42\nPause 43\nDisp \"\",\"Bouh la =/*: déf\",\"suite :\",\" OK");
    }

    {
        TIVarFile testPrgm = TIVarFile::createNew("Program", "asdf");
        testPrgm.setContentFromString("   Pause 42:Pause 43:\tDisp \"\",\"Bouh la =/*: déf\",\"suite :\",\" OK", { {"deindent", true} });
        string testPrgmcontent = testPrgm.getReadableContent({{"prettify", true},  {"reindent", true}});
        assert(testPrgmcontent == "Pause 42\nPause 43\nDisp \"\",\"Bouh la =/*: déf\",\"suite :\",\" OK");
    }

    {
        TIVarFile testPrgm = TIVarFile::createNew("Program", "asdf");
        testPrgm.setContentFromString("   Pause 42:Pause 43", { {"deindent", false} });
        string testPrgmcontent = testPrgm.getReadableContent();
        assert(testPrgmcontent == "   Pause 42:Pause 43");
    }

    {
        TIVarFile testPrgm = TIVarFile::createNew("Program", "asdf");
        options_t options;
        options["detect_strings"] = true;
        testPrgm.setContentFromString("\"prgm", options);
        assert(testPrgm.getRawContent() == data_t({0x09, 0x00, 0x2A, 0xBB, 0xC0, 0xBB, 0xC2, 0xBB, 0xB6, 0xBB, 0xBD}));
    }

    {
        TIVarFile testPrgm = TIVarFile::createNew("Program", "asdf");
        options_t options;
        options["detect_strings"] = false;
        testPrgm.setContentFromString("\"prgm", options);
        assert(testPrgm.getRawContent() == data_t({0x02, 0x00, 0x2A, 0x5F}));
    }

    {
        const std::array<std::pair<uint16_t, uint16_t>, 4> equationTokenRanges = {{
            {0x5E10, 0x5E19},
            {0x5E20, 0x5E2B},
            {0x5E40, 0x5E45},
            {0x5E80, 0x5E82},
        }};

        for (const auto& [firstToken, lastToken] : equationTokenRanges)
        {
            for (uint16_t targetToken = firstToken; targetToken <= lastToken; targetToken++)
            {
                std::string targetSource = TH_Tokenized::oneTokenBytesToString(targetToken);
                if (targetToken >= 0x5E80)
                {
                    targetSource = "|" + targetSource;
                }

                TIVarFile equationStore = TIVarFile::createNew("Program", "EQSTORE");
                equationStore.setContentFromString("\"sin(X→" + targetSource);
                assert(equationStore.getRawContent() == data_t({
                    0x06, 0x00, 0x2A, 0xC2, 0x58, 0x04,
                    static_cast<uint8_t>(targetToken >> 8), static_cast<uint8_t>(targetToken),
                }));

                const std::string readable = equationStore.getReadableContent();
                assert(readable.starts_with("\"sin(X→"));
                assert(readable.find("\\sin(") == std::string::npos);
                assert(!contains_numeric_token_escape(readable));
                TIVarFile roundtripped = TIVarFile::createNew("Program", "EQROUND");
                roundtripped.setContentFromString(readable);
                assert(roundtripped.getRawContent() == equationStore.getRawContent());
            }
        }

        TIVarFile asciiStore = TIVarFile::createNew("Program", "EQASCII");
        asciiStore.setContentFromString("\"sin(X->Y₁");
        assert(asciiStore.getRawContent() == data_t({0x06, 0x00, 0x2A, 0xC2, 0x58, 0x04, 0x5E, 0x10}));

        TIVarFile closedStringStore = TIVarFile::createNew("Program", "EQCLOSE");
        closedStringStore.setContentFromString("\"sin(X\"→Y₁");
        assert(closedStringStore.getRawContent() == data_t({0x07, 0x00, 0x2A, 0xC2, 0x58, 0x2A, 0x04, 0x5E, 0x10}));
        assert_roundtrip_from_readable(closedStringStore);

        TIVarFile spacedStringStore = TIVarFile::createNew("Program", "EQSPACE");
        spacedStringStore.setContentFromString(R"TI("sin(X" →Y₁)TI");
        assert(spacedStringStore.getRawContent() == data_t({
            0x0E, 0x00, 0x2A, 0xBB, 0xC3, 0xBB, 0xB8, 0xBB, 0xBE,
            0x10, 0x58, 0x2A, 0x29, 0x04, 0x5E, 0x10,
        }));

        TIVarFile stringToEquation = TIVarFile::createNew("Program", "STREQ");
        stringToEquation.setContentFromString("String►Equ(\"sin(X\",Y₁)");
        assert(stringToEquation.getRawContent() == data_t({
            0x0A, 0x00, 0xBB, 0x56, 0x2A, 0xC2, 0x58, 0x2A, 0x2B, 0x5E, 0x10, 0x11,
        }));
        assert(stringToEquation.getReadableContent() == "String►Equ(\"sin(X\",Y₁)");
        assert(stringToEquation.getReadableContent().find("\\sin(") == std::string::npos);
        assert(!contains_numeric_token_escape(stringToEquation.getReadableContent()));
        assert_roundtrip_from_readable(stringToEquation);

        TIVarFile ordinaryString = TIVarFile::createNew("Program", "STRING");
        ordinaryString.setContentFromString("\"sin(X→Str1");
        assert(ordinaryString.getRawContent() == data_t({
            0x0C, 0x00, 0x2A, 0xBB, 0xC3, 0xBB, 0xB8, 0xBB, 0xBE, 0x10, 0x58, 0x04, 0xAA, 0x00,
        }));
        assert_roundtrip_from_readable(ordinaryString);

        TIVarFile forcedTokenString = TIVarFile::createNew("Program", "FORCETOK");
        forcedTokenString.setContentFromString(R"("\sin(X)");
        assert(forcedTokenString.getRawContent() == data_t({0x03, 0x00, 0x2A, 0xC2, 0x58}));
        assert(forcedTokenString.getReadableContent() == R"("\sin(X)");
        assert_roundtrip_from_readable(forcedTokenString);

        TIVarFile rawEscapedTokenString = TIVarFile::createNew("Program", "RAWTOK");
        rawEscapedTokenString.setContentFromString(R"("\xC2X)");
        assert(rawEscapedTokenString.getRawContent() == forcedTokenString.getRawContent());
    }

    {
        TIVarFile testRealList = TIVarFile::loadFromFile("testData/RealList.8xl");
        assert_roundtrip_from_readable(testRealList);
        cout << "Before: " << testRealList.getReadableContent() << "\n   Now: ";
        testRealList.setContentFromString("{9, 0, .5, -6e-8}");
        cout << testRealList.getReadableContent() << "\n";
        testRealList.saveVarToFile("testData", "RealList_new");
    }

    {
        TIVarFile testRealList = TIVarFile::createNew("RealList", "\x5D\x00"); // L₁
        assert(testRealList.getRawContent().empty());
        const std::string content = "{9,0,0.5,-6e-8}";
        testRealList.setContentFromString(content);
        assert(testRealList.getReadableContent() == content);
        testRealList.setContentFromString("{1,2}\n");
        assert(testRealList.getReadableContent() == "{1,2}");
        testRealList.setContentFromString("{1E2,3}");
        assert(testRealList.getReadableContent() == "{100,3}");
    }

    {
        TIVarFile testStandardMatrix = TIVarFile::loadFromFile("testData/Matrix_3x3_standard.8xm");
        assert_roundtrip_from_readable(testStandardMatrix);
        cout << "Before: " << testStandardMatrix.getReadableContent() << "\n   Now: ";
        testStandardMatrix.setContentFromString("[[1,2,3][4,5,6][-7,-8,-9]]");
        testStandardMatrix.setContentFromString("[[1,2,3][4,5,6][-7.5,-8,-9][1,2,3][4,5,6][-0.002,-8,-9]]");
        cout << testStandardMatrix.getReadableContent() << "\n";
        testStandardMatrix.saveVarToFile("testData", "Matrix_new");

        TIVarFile matrixWithNewline = TIVarFile::createNew("Matrix", "A");
        matrixWithNewline.setContentFromString("[[1,2][3,4]]\n");
        assert(matrixWithNewline.getReadableContent() == "[[1,2][3,4]]");
    }

    {
        try
        {
            TIVarFile::createNew("Program", "1BADNAME");
            assert(false);
        }
        catch (const invalid_argument&)
        {
        }

        try
        {
            TIVarFile badMatrix = TIVarFile::createNew("Matrix", "\x5C\x00");
            badMatrix.setContentFromString("[[1,2][3]]");
            assert(false);
        }
        catch (const invalid_argument&)
        {
        }

        try
        {
            TH_Tokenized::getPosInfoAtOffsetFromHexStr("123", 0);
            assert(false);
        }
        catch (const invalid_argument&)
        {
        }
    }

    {
        TIVarFile testComplex = TIVarFile::loadFromFile("testData/Complex.8xc"); // -5 + 2i
        cout << "Before: " << testComplex.getReadableContent() << "\n   Now: ";
        assert(testComplex.getReadableContent() == "-5+2i");
        assert_roundtrip_from_readable(testComplex);
        TIVarFile newComplex = TIVarFile::createNew("Complex", "C");
        newComplex.setContentFromString("-5+2i");
        assert(newComplex.getRawContent() == testComplex.getRawContent());
        newComplex.setContentFromString("2.5+0.001i");
        assert_roundtrip_from_readable(newComplex);
        cout << "After: " << newComplex.getReadableContent() << endl;
        testComplex.saveVarToFile("testData", "Complex_new");
    }

    {
        TIVarFile testComplexList = TIVarFile::loadFromFile("testData/ComplexList.8xl");
        assert_roundtrip_from_readable(testComplexList);
        cout << "Before: " << testComplexList.getReadableContent() << "\n   Now: ";
        testComplexList.setContentFromString("{9+2i, 0i, .5, -0.5+6e-8i}");
        assert_roundtrip_from_readable(testComplexList);
        cout << testComplexList.getReadableContent() << "\n";
        testComplexList.saveVarToFile("testData", "ComplexList_new");
    }

    {
        TIVarFile testExact_RealRadical = TIVarFile::loadFromFile("testData/Exact_RealRadical.8xn");
        assert((testExact_RealRadical.getCalcModel().getFlags() & hasExactMath) != 0);
        assert(testExact_RealRadical.getCalcModel().supportsType(testExact_RealRadical.getVarEntries()[0]._type));
        assert_roundtrip_from_readable(testExact_RealRadical);
        cout << "Before: " << testExact_RealRadical.getReadableContent() << endl;
        assert(testExact_RealRadical.getReadableContent() == "(41*√(789)+14*√(654))/259");
        TIVarFile newExact_RealRadical = TIVarFile::createNew("ExactRealRadical", "A", "83PCE");
        newExact_RealRadical.setContentFromString("(41*√(789)+14*√(654))/259");
        assert_roundtrip_from_readable(newExact_RealRadical);
        assert(testExact_RealRadical.getRawContent() == newExact_RealRadical.getRawContent());
        assert(newExact_RealRadical.getVarEntries()[0].version == 0x10);
    }

    {
        TIVarFile testExactComplexFrac = TIVarFile::loadFromFile("testData/Exact_ComplexFrac.8xc");
        cout << "Before: " << testExactComplexFrac.getReadableContent() << endl;
        assert(testExactComplexFrac.getReadableContent() == "1/5-2/5i");
        TIVarFile newExactComplexFrac = TIVarFile::createNew("ExactComplexFrac", "A", "83PCE");
        newExactComplexFrac.setContentFromString("1/5-2/5i");
        assert_roundtrip_from_readable(newExactComplexFrac);
        assert(testExactComplexFrac.getRawContent() == newExactComplexFrac.getRawContent());
        assert(newExactComplexFrac.getVarEntries()[0].version == 0x0B);
    }


    {
        TIVarFile testExactComplexPi = TIVarFile::loadFromFile("testData/Exact_ComplexPi.8xc");
        cout << "Before: " << testExactComplexPi.getReadableContent() << endl;
        assert(testExactComplexPi.getReadableContent() == "1/5-3πi");
        TIVarFile newExactComplexPi = TIVarFile::createNew("ExactComplexPi", "A", "83PCE");
        newExactComplexPi.setContentFromString("1/5-3πi");
        assert(testExactComplexPi.getRawContent() == newExactComplexPi.getRawContent());
        assert(newExactComplexPi.getVarEntries()[0].version == 0x10);
    }

    {
        TIVarFile testExactComplexPiFrac = TIVarFile::loadFromFile("testData/Exact_ComplexPiFrac.8xc");
        cout << "Before: " << testExactComplexPiFrac.getReadableContent() << endl;
        assert(testExactComplexPiFrac.getReadableContent() == "2π/7i");
        TIVarFile newExactComplexPiFrac = TIVarFile::createNew("ExactComplexPiFrac", "A", "83PCE");
        newExactComplexPiFrac.setContentFromString("2π/7i");
        assert(testExactComplexPiFrac.getRawContent() == newExactComplexPiFrac.getRawContent());
        assert(newExactComplexPiFrac.getVarEntries()[0].version == 0x10);
    }

    {
        TIVarFile testExactComplexRadical = TIVarFile::loadFromFile("testData/Exact_ComplexRadical.8xc");
        cout << "Before: " << testExactComplexRadical.getReadableContent() << endl;

        assert(testExactComplexRadical.getReadableContent() == "(√(6)+√(2))/4+(√(6)-√(2))/4i");
        TIVarFile newExactComplexRadical = TIVarFile::createNew("ExactComplexRadical", "A", "83PCE");
        newExactComplexRadical.setContentFromString("(√(6)+√(2))/4+(√(6)-√(2))/4i");
        assert(testExactComplexRadical.getRawContent() == newExactComplexRadical.getRawContent());
        assert(newExactComplexRadical.getVarEntries()[0].version == 0x10);
    }

    {
        TIVarFile testExactRealPi = TIVarFile::loadFromFile("testData/Exact_RealPi.8xn");
        cout << "Before: " << testExactRealPi.getReadableContent() << endl;
        assert(testExactRealPi.getReadableContent() == "30π");
        TIVarFile newExactRealPi = TIVarFile::createNew("ExactRealPi", "A", "83PCE");
        newExactRealPi.setContentFromString("30π");
        assert(testExactRealPi.getRawContent() == newExactRealPi.getRawContent());
        assert(newExactRealPi.getVarEntries()[0].version == 0x10);
    }

    {
        TIVarFile testExactRealPiFrac = TIVarFile::loadFromFile("testData/Exact_RealPiFrac.8xn");
        cout << "Before: " << testExactRealPiFrac.getReadableContent() << endl;
        assert(testExactRealPiFrac.getReadableContent() == "2π/7");
        TIVarFile newExactRealPiFrac = TIVarFile::createNew("ExactRealPiFrac", "A", "83PCE");
        newExactRealPiFrac.setContentFromString("2π/7");
        assert(testExactRealPiFrac.getRawContent() == newExactRealPiFrac.getRawContent());
        assert(newExactRealPiFrac.getVarEntries()[0].version == 0x10);
    }

    {
        //                   ...size...  prgm  #name   C     O     U     R     A     G     E   ..offset..    D     <     2
        data_t tmp = data_t({0x0e, 0x00, 0x05, 0x07, 0x43, 0x4f, 0x55, 0x52, 0x41, 0x47, 0x45, 0x43, 0x02, 0x44, 0x6b, 0x32});
        std::string tempEquIfCond = TH_TempEqu::makeStringFromData(tmp);
        assert(tempEquIfCond == "prgmCOURAGE:579:D<2");
    }

    {
        TIVarFile appvarTest = TIVarFile::loadFromFile("testData/AppVar.8xv");
        cout << "appvarTest.getReadableContent() : " << appvarTest.getReadableContent() << endl;
    }

    {
        TIVarFile pythonModule = TIVarFile::createNew("PythonModuleAppVar", "PYMOD", "83PCE");
        pythonModule.setContentFromString(R"({
    "typeName": "PythonModuleAppVar",
    "menuDefinitions": "#MENULABEL Demo\n#MENUITEM sin|sin(\n",
    "compiledDataHex": "4D500300"
})");
        const json pythonModuleJSON = json::parse(pythonModule.getReadableContent());
        assert(pythonModuleJSON["typeName"] == "PythonModuleAppVar");
        assert(pythonModuleJSON["subtype"] == "PythonModule");
        assert(!pythonModuleJSON.contains("version"));
        assert(pythonModuleJSON["metadataRecordCount"] == 1);
        assert(pythonModuleJSON["metadataRecords"][0]["type"] == 2);
        assert(pythonModuleJSON["menuDefinitions"] == "#MENULABEL Demo\n#MENUITEM sin|sin(\n");
        assert(pythonModuleJSON["menuDefinitionsNullTerminated"] == false);
        assert(pythonModuleJSON["menuDefinitionsLength"] == pythonModuleJSON["menuDefinitions"].get<std::string>().size());
        assert(pythonModuleJSON["compiledDataHex"] == "4D500300");
        assert(pythonModule.getVarEntries()[0].version == VER_CE_PYTHONMOD);
        assert(TH_StructuredAppVar::getMinVersionFromData(pythonModule.getRawContent()) == VER_CE_PYTHONMOD);

        const std::string modulePath = pythonModule.saveVarToFile("/tmp", "PYMOD");
        TIVarFile reloadedModule = TIVarFile::loadFromFile(modulePath);
        assert(reloadedModule.getVarEntries()[0]._type.getName() == "PythonModuleAppVar");
        assert(reloadedModule.getVarEntries()[0].version == VER_CE_PYTHONMOD);
        assert(reloadedModule.getRawContent() == pythonModule.getRawContent());
        assert(remove(modulePath.c_str()) == 0);
    }

    {
        const auto wrapModule = [](const data_t& payload)
        {
            data_t data = {static_cast<uint8_t>(payload.size()), static_cast<uint8_t>(payload.size() >> 8)};
            data.insert(data.end(), payload.begin(), payload.end());
            return data;
        };
        const auto assertModuleRoundtrip = [&](const data_t& payload)
        {
            const data_t data = wrapModule(payload);
            json readable = json::parse(TH_StructuredAppVar::makeStringFromData(data));
            readable.erase("rawDataHex");
            assert(TH_StructuredAppVar::makeDataFromString(readable.dump()) == data);
            return readable;
        };

        // Record lengths include the type byte; zero terminates the records before compiled data.
        const data_t recordsPayload = {
            'P', 'Y', 'M', 'P',
            0x05, 0x01, 'm', '.', 'p', 'y',
            0x04, 0x02, 'A', '\n', 0x00,
            0x03, 0x7F, 0x00, 0xFF,
            0x02, 0x01, 'z',
            0x02, 0x02, 'B',
            0x01, 0x02,
            0x01, 0x01,
            0x01, 0x00,
            0x00, 0x4D, 0x50, 0x03, 0x00, 0xFF,
        };
        json recordsJSON = assertModuleRoundtrip(recordsPayload);
        assert(!recordsJSON.contains("version"));
        assert(recordsJSON["metadataRecordCount"] == 8);
        assert(recordsJSON["metadataRecords"][0]["length"] == 5);
        assert(recordsJSON["metadataRecords"][0]["name"] == "m.py");
        assert(recordsJSON["metadataRecords"][1]["text"] == std::string("A\n\0", 3));
        assert(recordsJSON["metadataRecords"][1]["length"] == 4);
        assert(recordsJSON["metadataRecords"][2]["type"] == 0x7F);
        assert(recordsJSON["metadataRecords"][2]["rawDataHex"] == "00FF");
        assert(recordsJSON["metadataRecords"][5]["length"] == 1);
        assert(recordsJSON["metadataRecords"][5]["text"] == "");
        assert(recordsJSON["metadataRecords"][6]["name"] == "");
        assert(recordsJSON["metadataRecords"][7]["type"] == 0);
        assert(recordsJSON["filename"] == "m.py");
        assert(recordsJSON["menuDefinitions"] == "A\n");
        assert(recordsJSON["menuDefinitionsHex"] == "410A00");
        assert(recordsJSON["menuDefinitionsLength"] == 3);
        assert(recordsJSON["menuDefinitionsNullTerminated"] == true);
        assert(recordsJSON["compiledDataHex"] == "4D500300FF");

        // Explicit records take precedence over the top-level convenience fields.
        recordsJSON["filename"] = "ignored.py";
        recordsJSON["menuDefinitionsHex"] = "FF";
        recordsJSON["menuDefinitions"] = "ignored";
        assert(TH_StructuredAppVar::makeDataFromString(recordsJSON.dump()) == wrapModule(recordsPayload));
        for (json& record : recordsJSON["metadataRecords"])
        {
            if (record["type"] == 1 || record["type"] == 2)
            {
                record.erase("rawDataHex");
            }
        }
        assert(TH_StructuredAppVar::makeDataFromString(recordsJSON.dump()) == wrapModule(recordsPayload));

        json convenienceJSON = {
            {"typeName", "PythonModuleAppVar"}, {"filename", "m.py"},
            {"menuDefinitions", "ABC"}, {"compiledDataHex", "4D500300"},
        };
        assert(TH_StructuredAppVar::makeDataFromString(convenienceJSON.dump()) == wrapModule({
            'P', 'Y', 'M', 'P', 0x05, 0x01, 'm', '.', 'p', 'y',
            0x04, 0x02, 'A', 'B', 'C', 0x00, 0x4D, 0x50, 0x03, 0x00,
        }));
        convenienceJSON["menuDefinitionsNullTerminated"] = true;
        assert(TH_StructuredAppVar::makeDataFromString(convenienceJSON.dump()) == wrapModule({
            'P', 'Y', 'M', 'P', 0x05, 0x01, 'm', '.', 'p', 'y',
            0x05, 0x02, 'A', 'B', 'C', 0x00, 0x00, 0x4D, 0x50, 0x03, 0x00,
        }));

        const json emptyJSON = assertModuleRoundtrip({'P', 'Y', 'M', 'P', 0x00, 0x4D, 0x03, 0x02, 0x1F});
        assert(emptyJSON["metadataRecordCount"] == 0);
        assert(emptyJSON["metadataRecords"].empty());
        assert(emptyJSON["compiledDataHex"] == "4D03021F");
        assert(!emptyJSON.contains("menuDefinitions"));
        assert(assertModuleRoundtrip({'P', 'Y', 'M', 'P', 0x00})["compiledDataHex"] == "");

        // 128 menu bytes plus the record type need a two-byte ULEB128 length (129).
        data_t longPayload = {'P', 'Y', 'M', 'P', 0x81, 0x01, 0x02};
        longPayload.insert(longPayload.end(), 128, 'A');
        longPayload.insert(longPayload.end(), {0x00, 0x4D, 0x50, 0x03, 0x00});
        const json longJSON = assertModuleRoundtrip(longPayload);
        assert(longJSON["metadataRecords"][0]["length"] == 129);
        assert(longJSON["menuDefinitionsLength"] == 128);
        assert(longJSON["menuDefinitions"] == std::string(128, 'A'));
        assert(longJSON["menuDefinitionsNullTerminated"] == false);
        assert(longJSON["compiledDataHex"] == "4D500300");

        for (const data_t& invalidPayload : std::vector<data_t>{
            {'P', 'Y', 'M', 'P'}, // Missing record-stream terminator.
            {'P', 'Y', 'M', 'P', 0x80}, // Truncated ULEB128 length.
            {'P', 'Y', 'M', 'P', 0x01}, // Missing record type.
            {'P', 'Y', 'M', 'P', 0x03, 0x02, 'A'}, // Truncated record data.
            {'P', 'Y', 'M', 'P', 0x01, 0x02}, // Complete record without terminator.
            {'P', 'Y', 'M', 'P', 0xFF, 0xFF, 0xFF, 0xFF, 0x10}, // Length overflow.
        })
        {
            bool rejected = false;
            try
            {
                (void)TH_StructuredAppVar::makeStringFromData(wrapModule(invalidPayload));
            }
            catch (const std::invalid_argument&)
            {
                rejected = true;
            }
            assert(rejected);
        }
    }

    {
        TIVarFile realPythonModule = TIVarFile::loadFromFile("testData/TISTEMFR.8xv");
        assert(realPythonModule.getVarEntries()[0]._type.getName() == "PythonModuleAppVar");
        assert(realPythonModule.getVarEntries()[0].version == VER_CE_PYTHONMOD);
        assert((realPythonModule.getCalcModel().getFlags() & hasPython) != 0);
        assert(realPythonModule.getCalcModel().supportsType(realPythonModule.getVarEntries()[0]._type));

        json realPythonModuleJSON = json::parse(realPythonModule.getReadableContent());
        assert(realPythonModuleJSON["typeName"] == "PythonModuleAppVar");
        assert(realPythonModuleJSON["subtype"] == "PythonModule");
        assert(!realPythonModuleJSON.contains("version"));
        assert(realPythonModuleJSON["metadataRecordCount"] == 1);
        assert(realPythonModuleJSON["metadataRecords"][0]["length"] == 2276);
        assert(realPythonModuleJSON["menuDefinitionsLength"] == 2275);
        assert(realPythonModuleJSON["menuDefinitionsNullTerminated"] == false);
        assert(realPythonModuleJSON["menuDefinitions"].get<std::string>().find("MENULABEL") != std::string::npos);
        assert(realPythonModuleJSON["compiledDataHex"].get<std::string>().size() == 52 * 2);
        assert_roundtrip_from_readable(realPythonModule);
        realPythonModuleJSON.erase("rawDataHex");
        assert(TH_StructuredAppVar::makeDataFromString(realPythonModuleJSON.dump()) == realPythonModule.getRawContent());

        TIVarFile noMenuPythonModule = TIVarFile::loadFromFile("testData/MB_NEOPX.8xv");
        json noMenuJSON = json::parse(noMenuPythonModule.getReadableContent());
        assert(noMenuJSON["typeName"] == "PythonModuleAppVar");
        assert(noMenuJSON["metadataRecordCount"] == 0);
        assert(noMenuJSON["metadataRecords"].empty());
        assert(noMenuJSON["compiledDataHex"].get<std::string>().starts_with("4D03021F"));
        assert(noMenuJSON["compiledDataHex"].get<std::string>().size() == 2081 * 2);
        noMenuJSON.erase("rawDataHex");
        assert(TH_StructuredAppVar::makeDataFromString(noMenuJSON.dump()) == noMenuPythonModule.getRawContent());
    }

    {
        TIVarFile pythonImage = TIVarFile::createNew("PythonImageAppVar", "PYIMG", "83PCE");
        pythonImage.setContentFromString(R"({
    "typeName": "PythonImageAppVar",
    "width": 16,
    "height": 8,
    "palette": {
        "hasAlpha": true,
        "transparentIndex": 1,
        "entries": [31, 63488, 2016]
    },
    "imageDataHex": "fe01"
})");
        const json pythonImageJSON = json::parse(pythonImage.getReadableContent());
        assert(pythonImageJSON["typeName"] == "PythonImageAppVar");
        assert(pythonImageJSON["width"] == 16);
        assert(pythonImageJSON["height"] == 8);
        assert(pythonImageJSON["palette"]["entryCount"] == 3);
        assert(pythonImageJSON["palette"]["hasAlpha"] == true);
        assert(pythonImageJSON["palette"]["entries"][1] == 63488);
        assert(pythonImageJSON["imageDataLength"] == 2);
        assert(pythonImageJSON["imageDataHex"] == "FE01");
        assert_preview_bmp_data_url(pythonImageJSON["previewImageDataUrl"], 16, 8);
        assert((read_preview_bmp_pixel_rgba(pythonImageJSON["previewImageDataUrl"], 0, 0) == std::array<uint8_t, 4>{0x00, 0x00, 0x00, 0x00}));
        assert((read_preview_bmp_pixel_rgba(pythonImageJSON["previewImageDataUrl"], 8, 0) == std::array<uint8_t, 4>{0x00, 0x00, 0x00, 0x00}));

        const std::string imagePath = pythonImage.saveVarToFile("/tmp", "PYIMG");
        TIVarFile reloadedImage = TIVarFile::loadFromFile(imagePath);
        assert(reloadedImage.getVarEntries()[0]._type.getName() == "PythonImageAppVar");
        assert(reloadedImage.getRawContent() == pythonImage.getRawContent());
        assert(remove(imagePath.c_str()) == 0);

        TIVarFile realPythonImage = TIVarFile::loadFromFile("testData/TESTIM8C.8xv");
        assert(realPythonImage.getVarEntries()[0]._type.getName() == "PythonImageAppVar");
        assert((realPythonImage.getCalcModel().getFlags() & hasPython) != 0);
        const json realPythonImageJSON = json::parse(realPythonImage.getReadableContent());
        assert(realPythonImageJSON["width"] == 154);
        assert(realPythonImageJSON["height"] == 42);
        assert(realPythonImageJSON["palette"]["marker"] == 1);
        assert(realPythonImageJSON["palette"]["entryCount"] == realPythonImageJSON["palette"]["entries"].size());
        assert(realPythonImageJSON["imageDataLength"] > 0);
        assert_preview_bmp_data_url(realPythonImageJSON["previewImageDataUrl"], 154, 42);
        assert((read_preview_bmp_pixel_rgba(realPythonImageJSON["previewImageDataUrl"], 0, 0) == std::array<uint8_t, 4>{222, 61, 74, 0xFF}));
        assert((read_preview_bmp_pixel_rgba(realPythonImageJSON["previewImageDataUrl"], 20, 10) == std::array<uint8_t, 4>{66, 65, 66, 0xFF}));
        assert((read_preview_bmp_pixel_rgba(realPythonImageJSON["previewImageDataUrl"], 100, 20) == std::array<uint8_t, 4>{255, 251, 247, 0xFF}));

        TIVarFile rebuiltRealImage = TIVarFile::createNew("PythonImageAppVar", "TESTIM8C", "83PCE");
        rebuiltRealImage.setContentFromString(realPythonImage.getReadableContent());
        assert(rebuiltRealImage.getRawContent() == realPythonImage.getRawContent());

        TIVarFile girlNoAlphaImage = TIVarFile::loadFromFile("testData/GIRL_150_noalpha.8xv");
        assert(girlNoAlphaImage.getVarEntries()[0]._type.getName() == "PythonImageAppVar");
        const json girlNoAlphaJSON = json::parse(girlNoAlphaImage.getReadableContent());
        assert(girlNoAlphaJSON["width"] == 114);
        assert(girlNoAlphaJSON["height"] == 150);
        assert(girlNoAlphaJSON["palette"]["hasAlpha"] == false);
        assert(girlNoAlphaJSON["palette"]["transparentIndex"] == 0);
        assert_preview_bmp_data_url(girlNoAlphaJSON["previewImageDataUrl"], 114, 150);
        assert((read_preview_bmp_pixel_rgba(girlNoAlphaJSON["previewImageDataUrl"], 20, 20) == std::array<uint8_t, 4>{255, 210, 0, 0xFF}));
        assert((read_preview_bmp_pixel_rgba(girlNoAlphaJSON["previewImageDataUrl"], 50, 40) == std::array<uint8_t, 4>{255, 190, 165, 0xFF}));
        assert_roundtrip_from_readable(girlNoAlphaImage);

        TIVarFile girlAlphaImage = TIVarFile::loadFromFile("testData/GIRL_150_alpha.8xv");
        assert(girlAlphaImage.getVarEntries()[0]._type.getName() == "PythonImageAppVar");
        const json girlAlphaJSON = json::parse(girlAlphaImage.getReadableContent());
        assert(girlAlphaJSON["width"] == 114);
        assert(girlAlphaJSON["height"] == 150);
        assert(girlAlphaJSON["palette"]["hasAlpha"] == true);
        assert(girlAlphaJSON["palette"]["transparentIndex"] == 0);
        assert_preview_bmp_data_url(girlAlphaJSON["previewImageDataUrl"], 114, 150);
        assert((read_preview_bmp_pixel_rgba(girlAlphaJSON["previewImageDataUrl"], 0, 0) == std::array<uint8_t, 4>{0, 0, 0, 0}));
        assert((read_preview_bmp_pixel_rgba(girlAlphaJSON["previewImageDataUrl"], 20, 20) == std::array<uint8_t, 4>{247, 210, 0, 0xFF}));
        assert((read_preview_bmp_pixel_rgba(girlAlphaJSON["previewImageDataUrl"], 50, 40) == std::array<uint8_t, 4>{255, 202, 173, 0xFF}));
        assert_roundtrip_from_readable(girlAlphaImage);
    }

    {
        TIVarFile genericStructuredAppVar = TIVarFile::createNew("AppVar", "SCSET", "83PCE");
        genericStructuredAppVar.setContentFromString(R"({
    "typeName": "StudyCardsSetgsAppVar",
    "keepKnownCards": true,
    "reintroduceCards": false,
    "shuffleCards": true,
    "ignoreLevels": true,
    "animateFlip": false,
    "boxMode5": true,
    "currentAppVar": "CARDS"
})");
        assert(genericStructuredAppVar.getVarEntries()[0]._type.getName() == "StudyCardsSetgsAppVar");
        const json studyCardsSettingsJSON = json::parse(genericStructuredAppVar.getReadableContent());
        assert(studyCardsSettingsJSON["typeName"] == "StudyCardsSetgsAppVar");
        assert(studyCardsSettingsJSON["keepKnownCards"] == true);
        assert(studyCardsSettingsJSON["shuffleCards"] == true);
        assert(studyCardsSettingsJSON["ignoreLevels"] == true);
        assert(studyCardsSettingsJSON["currentAppVar"] == "CARDS");
    }

    {
        TIVarFile cellSheet = TIVarFile::createNew("CellSheetAppVar", "SHEET", "83PCE");
        cellSheet.setContentFromString(R"({
    "typeName": "CellSheetAppVar",
    "name": "CELLS",
    "displayHelp": false,
    "displayEquEvalInPreview": true,
    "number": 7,
    "payloadHex": "AABBCCDD"
})");
        const json cellSheetJSON = json::parse(cellSheet.getReadableContent());
        assert(cellSheetJSON["typeName"] == "CellSheetAppVar");
        assert(cellSheetJSON["name"] == "CELLS");
        assert(cellSheetJSON["displayHelp"] == false);
        assert(cellSheetJSON["displayEquEvalInPreview"] == true);
        assert(cellSheetJSON["number"] == 7);
        assert(cellSheetJSON["payloadHex"] == "AABBCCDD");
    }

    {
        TIVarFile cellSheet = TIVarFile::loadFromFile("testData/TICSfile.8xv");
        const json cellSheetJSON = json::parse(cellSheet.getReadableContent());
        assert(cellSheetJSON["typeName"] == "CellSheetStateAppVar");
        assert(cellSheetJSON["name"] == "S01");
        assert(cellSheetJSON["displayHelp"] == true);
        assert(cellSheetJSON["displayEquEvalInPreview"] == false);
        assert(cellSheetJSON["number"] == 0);
        assert(cellSheetJSON["payloadHex"] == "");
        assert_roundtrip_from_readable(cellSheet);
    }

    {
        TIVarFile cabriFile = TIVarFile::createNew("CabriJrAppVar", "CABF", "83PCE");
        cabriFile.setContentFromString(R"({
    "typeName": "CabriJrAppVar",
    "variant": "File",
    "structure": 4,
    "unknownBeforeWordHex": "AA",
    "unknownWord": 4660,
    "unknownAfterWordHex": "BB",
    "nameOffsetUnits": 3,
    "rawDataHex": "01020304"
})");
        const json cabriFileJSON = json::parse(cabriFile.getReadableContent());
        assert(cabriFileJSON["typeName"] == "CabriJrAppVar");
        assert(cabriFileJSON["variant"] == "File");
        assert(cabriFileJSON["compressed"] == false);
        assert(cabriFileJSON["structure"] == 4);
        assert(cabriFileJSON["unknownBeforeWordHex"] == "AA");
        assert(cabriFileJSON["unknownWord"] == 4660);
        assert(cabriFileJSON["unknownAfterWordHex"] == "BB");
        assert(cabriFileJSON["nameOffsetUnits"] == 3);
        assert(cabriFileJSON["nameOffset"] == 63);
        assert(cabriFileJSON["rawDataHex"] == "01020304");

        TIVarFile genericCabriFile = TIVarFile::createNew("AppVar", "GCBF", "83PCE");
        genericCabriFile.setContentFromString(cabriFile.getReadableContent());
        assert(genericCabriFile.getVarEntries()[0]._type.getName() == "CabriJrAppVar");
        assert(genericCabriFile.getRawContent() == cabriFile.getRawContent());
    }

    {
        TIVarFile cabriCompressed = TIVarFile::createNew("CabriJrAppVar", "CABC", "83PCE");
        cabriCompressed.setContentFromString(R"({
    "typeName": "CabriJrAppVar",
    "variant": "File",
    "structure": 3,
    "unreadHex": "99",
    "nameOffsetUnits": 4,
    "entryOffsetUnits": 32,
    "blocksHex": ["000102030405060708090A0B0C0D0E0F1011"],
    "trailingWord": 48879,
    "trailingDataHex": "AA55"
})");
        const json cabriCompressedJSON = json::parse(cabriCompressed.getReadableContent());
        assert(cabriCompressedJSON["variant"] == "File");
        assert(cabriCompressedJSON["compressed"] == true);
        assert(cabriCompressedJSON["structure"] == 3);
        assert(cabriCompressedJSON["unreadHex"] == "99");
        assert(cabriCompressedJSON["nameOffsetUnits"] == 4);
        assert(cabriCompressedJSON["entryOffsetUnits"] == 32);
        assert(cabriCompressedJSON["blockCount"] == 1);
        assert(cabriCompressedJSON["blocksHex"][0] == "000102030405060708090A0B0C0D0E0F1011");
        assert(cabriCompressedJSON["trailingWord"] == 48879);
        assert(cabriCompressedJSON["trailingDataHex"] == "AA55");
    }

    {
        TIVarFile cabriLanguage = TIVarFile::createNew("CabriJrAppVar", "CABL", "83PCE");
        cabriLanguage.setContentFromString(R"({
    "typeName": "CabriJrAppVar",
    "variant": "Language",
    "languageId": "ENG",
    "lines": ["MAIN,SUB", "HELP LINE", ""]
})");
        const json cabriLanguageJSON = json::parse(cabriLanguage.getReadableContent());
        assert(cabriLanguageJSON["variant"] == "Language");
        assert(cabriLanguageJSON["unknownHex"] == "015F");
        assert(cabriLanguageJSON["languageId"] == "ENG");
        assert(cabriLanguageJSON["text"] == "MAIN,SUB\rHELP LINE\r");
        assert(cabriLanguageJSON["lines"].size() == 3);
        assert(cabriLanguageJSON["lines"][0] == "MAIN,SUB");
        assert(cabriLanguageJSON["lines"][2] == "");
    }

    {
        TIVarFile studyCards = TIVarFile::createNew("StudyCardsAppVar", "STUDY", "84+");
        studyCards.setContentFromString(R"({
    "typeName": "StudyCardsAppVar",
    "rawDataHex": "F347BFA7010000001400160018001A00010203004100420043004400"
})");
        const json studyCardsJSON = json::parse(studyCards.getReadableContent());
        assert(studyCardsJSON["typeName"] == "StudyCardsAppVar");
        assert(studyCardsJSON["version"] == 1);
        assert(studyCardsJSON["cardCount"] == 0);
        assert(studyCardsJSON["titles"][0] == "A");
        assert(studyCardsJSON["titles"][3] == "D");
    }

    {
        TIVarFile notefolio = TIVarFile::createNew("NotefolioAppVar", "NOTES", "83+");
        notefolio.setContentFromString(R"({
    "typeName": "NotefolioAppVar",
    "reservedHex": "00000000",
    "name": "NOTES",
    "headerUnknownHex": "010203040506",
    "text": "Hello NoteFolio",
    "textNullTerminated": true,
    "trailingDataHex": "AA55"
})");
        assert(notefolio.getVarEntries()[0]._type.getName() == "NotefolioAppVar");
        const json notefolioJSON = json::parse(notefolio.getReadableContent());
        assert(notefolioJSON["typeName"] == "NotefolioAppVar");
        assert(notefolioJSON["subtype"] == "Notefolio");
        assert(notefolioJSON["magic"] == "F347BFAF");
        assert(notefolioJSON["reservedHex"] == "00000000");
        assert(notefolioJSON["name"] == "NOTES");
        assert(notefolioJSON["storedTextLength"] == 16);
        assert(notefolioJSON["headerUnknownHex"] == "010203040506");
        assert(notefolioJSON["text"] == "Hello NoteFolio");
        assert(notefolioJSON["textNullTerminated"] == true);
        assert(notefolioJSON["textDataHex"] == "48656C6C6F204E6F7465466F6C696F00");
        assert(notefolioJSON["trailingDataHex"] == "AA55");

        TIVarFile genericNotefolio = TIVarFile::createNew("AppVar", "NFGEN", "83+");
        genericNotefolio.setContentFromString(notefolio.getReadableContent());
        assert(genericNotefolio.getVarEntries()[0]._type.getName() == "NotefolioAppVar");
        assert(genericNotefolio.getRawContent() == notefolio.getRawContent());

        TIVarFile rawNotefolio = TIVarFile::createNew("NotefolioAppVar", "RAWNOTES", "83+");
        rawNotefolio.setContentFromString(R"({
    "typeName": "NotefolioAppVar",
    "rawDataHex": "F347BFAF000000004E4F544553000000100001020304050648656C6C6F204E6F7465466F6C696F00AA55"
})");
        assert(rawNotefolio.getRawContent() == notefolio.getRawContent());
    }

    {
        TIVarFile testPython = TIVarFile::createNew("PythonAppVar", "TEST123", "83PCE");
        testPython.setContentFromString("from math import *\nprint(math)\n\n# plop");
        testPython.saveVarToFile("testData", "Pythontest_new");

        TIVarFile pythonFromTest = TIVarFile::loadFromFile("testData/Pythontest_new.8xv");
        cout << "pythonFromTest.getReadableContent() : " << pythonFromTest.getReadableContent() << endl;
        assert(pythonFromTest.getReadableContent() == "from math import *\nprint(math)\n\n# plop");

        TIVarFile pythonFromTest2 = TIVarFile::loadFromFile("testData/python_HELLO.8xv");
        cout << "pythonFromTest2.getReadableContent() : " << pythonFromTest2.getReadableContent() << endl;
        assert(pythonFromTest2.getReadableContent() == "import sys\nprint(sys.version)\n");
        assert((pythonFromTest2.getCalcModel().getFlags() & hasPython) != 0);
        assert(pythonFromTest2.getCalcModel().supportsType(pythonFromTest2.getVarEntries()[0]._type));

        const json pythonMetadata = json::parse(pythonFromTest2.getReadableContent({{"metadata", true}}));
        assert(pythonMetadata["typeName"] == "PythonAppVar");
        assert(pythonMetadata["magic"] == "PYCD");
        assert(pythonMetadata["metadataRecordCount"] == 0);
        assert(pythonMetadata["code"] == "import sys\nprint(sys.version)\n");
        assert(pythonMetadata["rawDataHex"] == "5059434400696D706F7274207379730A7072696E74287379732E76657273696F6E290A");
        assert_roundtrip_from_readable(pythonFromTest2, {{"metadata", true}});
    }

    {
        TIVarFile pythonBom = TIVarFile::createNew("PythonAppVar", "BOMTEST", "83PCE");
        pythonBom.setContentFromString(std::string("\xEF\xBB\xBF") + "print(42)\n");
        assert(pythonBom.getReadableContent() == "print(42)\n");

        TIVarFile pythonWithMetadata = TIVarFile::createNew("PythonAppVar", "METAPY", "83PCE");
        pythonWithMetadata.setContentFromString(R"({
    "typeName": "PythonAppVar",
    "filename": "hello.py",
    "code": "print(\"hi\")\n",
    "appendTrailingCRLF": true
})");
        const json pythonWithMetadataJSON = json::parse(pythonWithMetadata.getReadableContent({{"metadata", true}}));
        assert(pythonWithMetadataJSON["filename"] == "hello.py");
        assert(pythonWithMetadataJSON["metadataRecordCount"] == 1);
        assert(pythonWithMetadataJSON["metadataRecords"][0]["type"] == 1);
        assert(pythonWithMetadataJSON["metadataRecords"][0]["name"] == "hello.py");
        assert(pythonWithMetadataJSON["code"] == "print(\"hi\")\n");

        const std::string pythonWithoutMetadata = pythonWithMetadata.getReadableContent({{"metadata", false}});
        assert(pythonWithoutMetadata == "print(\"hi\")\n");

        TIVarFile pythonFromMetadataJSON = TIVarFile::createNew("PythonAppVar", "METAPY", "83PCE");
        pythonFromMetadataJSON.setContentFromString(pythonWithMetadataJSON.dump());
        assert(pythonFromMetadataJSON.getRawContent() == pythonWithMetadata.getRawContent());

        TIVarFile oversizedPython = TIVarFile::createNew("PythonAppVar", "BIGPY", "83PCE");
        oversizedPython.setContentFromString(std::string(70000, 'A'));
        assert(oversizedPython.getRawContent().size() == 65514);
        assert(oversizedPython.getReadableContent().size() == 65507);
        assert(oversizedPython.getReadableContent() == std::string(65507, 'A'));

        TIVarFile oversizedPythonMetadata = TIVarFile::createNew("PythonAppVar", "BIGMETA", "83PCE");
        oversizedPythonMetadata.setContentFromString(R"({
    "typeName": "PythonAppVar",
    "filename": "really_long_name.py",
    "code": ")"s + std::string(70000, 'B') + R"(",
    "appendTrailingCRLF": true
})");
        const json oversizedPythonMetadataJSON = json::parse(oversizedPythonMetadata.getReadableContent({{"metadata", true}}));
        assert(oversizedPythonMetadata.getRawContent().size() == 65514);
        assert(oversizedPythonMetadataJSON["filename"] == "really_long_name.py");
        assert(oversizedPythonMetadataJSON["code"].get<std::string>().back() == '\n');
        assert(oversizedPythonMetadataJSON["code"].get<std::string>().size() == 65485);
    }

    {
        TIVarFile backupVar = TIVarFile::createNew("Backup", "BACKUP", "84+");
        backupVar.setContentFromString(R"({
    "typeName": "Backup",
    "addressOfData2": 4660,
    "data1Hex": "01020304",
    "data2Hex": "A0B0",
    "data3Hex": "C1D2E3"
})");
        const json backupJSON = json::parse(backupVar.getReadableContent());
        assert(backupJSON["typeName"] == "Backup");
        assert(backupJSON["segmentCount"] == 3);
        assert(backupJSON["addressOfData2"] == 4660);
        assert(backupJSON["data1Hex"] == "01020304");
        assert(backupJSON["data2Hex"] == "A0B0");
        assert(backupJSON["data3Hex"] == "C1D2E3");

        const std::string backupPath = backupVar.saveVarToFile("/tmp", "BACKUP");
        TIVarFile reloadedBackup = TIVarFile::loadFromFile(backupPath);
        assert(reloadedBackup.getVarEntries()[0]._type.getName() == "Backup");
        assert(reloadedBackup.getReadableContent() == backupVar.getReadableContent());
        assert(reloadedBackup.getRawContent() == backupVar.getRawContent());
        assert(remove(backupPath.c_str()) == 0);
    }

    {
        TIVarFile testTheta = TIVarFile::createNew("Program", "θΘϴᶿ");
        uint8_t testThetaVarName[8] = {0x5B, 0x5B, 0x5B, 0x5B};
        const auto& firstVarEntry = testTheta.getVarEntries()[0];
        cout << "testTheta firstVarEntry varname : " << firstVarEntry.varname << endl;
        assert(std::equal(firstVarEntry.varname, firstVarEntry.varname + 8, testThetaVarName));
        assert(entry_name_to_string(firstVarEntry._type, firstVarEntry.varname) == "θθθθ");
        assert(sanitize_for_host_filename("θ/Y₀") == "θ_Y0T");
    }

    {
        TIVarFile realDefaultVar = TIVarFile::createNew("Real");
        const uint8_t expectedScalarDefault[8] = {'A'};
        assert(std::equal(realDefaultVar.getVarEntries()[0].varname, realDefaultVar.getVarEntries()[0].varname + 8, expectedScalarDefault));

        TIVarFile complexDefaultVar = TIVarFile::createNew("Complex");
        assert(std::equal(complexDefaultVar.getVarEntries()[0].varname, complexDefaultVar.getVarEntries()[0].varname + 8, expectedScalarDefault));

        TIVarFile exactDefaultVar = TIVarFile::createNew("ExactRealPi", "", "83PCE");
        assert(std::equal(exactDefaultVar.getVarEntries()[0].varname, exactDefaultVar.getVarEntries()[0].varname + 8, expectedScalarDefault));

        TIVarFile listDefaultVar = TIVarFile::createNew("RealList");
        const auto& listDefault = listDefaultVar.getVarEntries()[0];
        const uint8_t expectedListDefault[8] = {TH_GenericList::listNameMarker, 0x00};
        assert(std::equal(listDefault.varname, listDefault.varname + 8, expectedListDefault));

        TIVarFile customList = TIVarFile::createNew("RealList", "abcde");
        const uint8_t expectedCustomList[8] = {TH_GenericList::listNameMarker, 'A', 'B', 'C', 'D', 'E'};
        assert(std::equal(customList.getVarEntries()[0].varname, customList.getVarEntries()[0].varname + 8, expectedCustomList));

        TIVarFile stdList = TIVarFile::createNew("RealList", "L6");
        const uint8_t expectedStdList[8] = {TH_GenericList::listNameMarker, 0x05};
        assert(std::equal(stdList.getVarEntries()[0].varname, stdList.getVarEntries()[0].varname + 8, expectedStdList));

        TIVarFile idList = TIVarFile::createNew("RealList", "IDList");
        const uint8_t expectedIdList[8] = {TH_GenericList::listNameMarker, 0x40};
        assert(std::equal(idList.getVarEntries()[0].varname, idList.getVarEntries()[0].varname + 8, expectedIdList));

        TIVarFile customDigitList = TIVarFile::createNew("RealList", "A1B2C");
        const uint8_t expectedCustomDigitList[8] = {TH_GenericList::listNameMarker, 'A', '1', 'B', '2', 'C'};
        assert(std::equal(customDigitList.getVarEntries()[0].varname, customDigitList.getVarEntries()[0].varname + 8, expectedCustomDigitList));

        TIVarFile customThetaList = TIVarFile::createNew("RealList", "θA");
        const uint8_t expectedCustomThetaList[8] = {TH_GenericList::listNameMarker, 0x5B, 'A'};
        assert(std::equal(customThetaList.getVarEntries()[0].varname, customThetaList.getVarEntries()[0].varname + 8, expectedCustomThetaList));
        assert(entry_name_to_string(customThetaList.getVarEntries()[0]._type, customThetaList.getVarEntries()[0].varname) == "θA");

        TIVarFile namedComplexList = TIVarFile::createNew("ComplexList", "AB12");
        const uint8_t expectedNamedComplexList[8] = {TH_GenericList::listNameMarker, 'A', 'B', '1', '2'};
        assert(std::equal(namedComplexList.getVarEntries()[0].varname, namedComplexList.getVarEntries()[0].varname + 8, expectedNamedComplexList));

        bool threwInvalidList = false;
        try
        {
            (void)TIVarFile::createNew("RealList", "1ABC");
        }
        catch (const std::invalid_argument&)
        {
            threwInvalidList = true;
        }
        assert(threwInvalidList);

        bool threwTooLongList = false;
        try
        {
            (void)TIVarFile::createNew("RealList", "ABCDEF");
        }
        catch (const std::invalid_argument&)
        {
            threwTooLongList = true;
        }
        assert(threwTooLongList);
    }

    {
        TIVarFile namedListFromFile = TIVarFile::loadFromFile("testData/LISTABC.8xl");
        const uint8_t expectedNamedList[8] = {TH_GenericList::listNameMarker, 'A', 'B', 'C'};
        assert(std::equal(namedListFromFile.getVarEntries()[0].varname, namedListFromFile.getVarEntries()[0].varname + 8, expectedNamedList));
        assert(namedListFromFile.saveVarToFile("/tmp", "") == "/tmp/ABC.8xl");
        assert(remove("/tmp/ABC.8xl") == 0);

        TIVarFile recreatedNamedList = TIVarFile::createNew("RealList", "ABC");
        recreatedNamedList.setContentFromString(namedListFromFile.getReadableContent());
        assert(recreatedNamedList.getRawContent() == namedListFromFile.getRawContent());

        const std::string savedNamedListPath = recreatedNamedList.saveVarToFile("/tmp", "");
        assert(savedNamedListPath == "/tmp/ABC.8xl");
        TIVarFile reloadedNamedList = TIVarFile::loadFromFile(savedNamedListPath);
        assert(reloadedNamedList.getRawContent() == namedListFromFile.getRawContent());
        assert(remove(savedNamedListPath.c_str()) == 0);
    }

    {
        TIVarFile complexList = TIVarFile::createNew("ComplexList", "DEF");
        complexList.setContentFromString("{9i,8,1+7i}");

        const std::string malformedPath = complexList.saveVarToFile("/tmp", "DEF_MISSING_LIST_MARKER");
        data_t malformed = read_binary_file(malformedPath);
        const size_t nameOffset = TIVarFile::firstVarEntryOffset + sizeof(uint16_t) + sizeof(uint16_t) + sizeof(uint8_t);
        assert(malformed[nameOffset] == TH_GenericList::listNameMarker);

        malformed[nameOffset] = 'D';
        malformed[nameOffset + 1] = 'E';
        malformed[nameOffset + 2] = 'F';
        std::fill(malformed.begin() + static_cast<ptrdiff_t>(nameOffset + 3), malformed.begin() + static_cast<ptrdiff_t>(nameOffset + 8), 0);

        uint16_t checksum = 0;
        for (size_t i = TIVarFile::firstVarEntryOffset; i < malformed.size() - 2; i++)
        {
            checksum += malformed[i];
        }
        malformed[malformed.size() - 2] = static_cast<uint8_t>(checksum & 0xFF);
        malformed[malformed.size() - 1] = static_cast<uint8_t>((checksum >> 8) & 0xFF);
        write_binary_file(malformedPath, malformed);

        TIVarFile malformedComplexList = TIVarFile::loadFromFile(malformedPath);
        const uint8_t expectedComplexListName[8] = {TH_GenericList::listNameMarker, 'D', 'E', 'F'};
        const auto& malformedEntry = malformedComplexList.getVarEntries()[0];
        assert(!malformedComplexList.isCorrupt());
        assert(std::equal(malformedEntry.varname, malformedEntry.varname + 8, expectedComplexListName));
        assert(entry_name_to_string(malformedEntry._type, malformedEntry.varname) == "DEF");
        assert(entry_name_to_string(TIVarType{"ComplexList"}, &malformed[nameOffset]) == "DEF");
        const uint8_t malformedThetaName[8] = {0x5B, 'E', 'F'};
        assert(entry_name_to_string(TIVarType{"ComplexList"}, malformedThetaName) == "θEF");
        assert(malformedComplexList.getReadableContent() == "{9i,8,1+7i}");

        const std::string resavedPath = malformedComplexList.saveVarToFile("/tmp", "");
        assert(resavedPath == "/tmp/DEF.8xl");
        const data_t resaved = read_binary_file(resavedPath);
        assert(resaved[nameOffset] == TH_GenericList::listNameMarker);
        assert(resaved[nameOffset + 1] == 'D');
        assert(resaved[nameOffset + 2] == 'E');
        assert(resaved[nameOffset + 3] == 'F');
        assert(remove(malformedPath.c_str()) == 0);
        assert(remove(resavedPath.c_str()) == 0);
    }

    {
        TIVarFile matrixDefaultVar = TIVarFile::createNew("Matrix");
        const auto& matrixDefault = matrixDefaultVar.getVarEntries()[0];
        const uint8_t expectedMatrixDefault[8] = {0x5C, 0x00};
        assert(std::equal(matrixDefault.varname, matrixDefault.varname + 8, expectedMatrixDefault));

        TIVarFile matrixB = TIVarFile::createNew("Matrix", "[b]");
        const uint8_t expectedMatrixB[8] = {0x5C, 0x01};
        assert(std::equal(matrixB.getVarEntries()[0].varname, matrixB.getVarEntries()[0].varname + 8, expectedMatrixB));

        TIVarFile exactMatrix = TIVarFile::loadFromFile("testData/Matrix_2x2_exact.8xm");
        assert(!exactMatrix.getReadableContent().empty());
        assert(exactMatrix.getVarEntries()[0].version >= 0x06);
    }

    {
        TIVarFile equationDefaultVar = TIVarFile::createNew("Equation");
        const auto& equationDefault = equationDefaultVar.getVarEntries()[0];
        const uint8_t expectedEquationDefault[8] = {0x5E, 0x10};
        assert(std::equal(equationDefault.varname, equationDefault.varname + 8, expectedEquationDefault));

        TIVarFile equationY0 = TIVarFile::createNew("Equation", "Y0");
        const uint8_t expectedEquationY0[8] = {0x5E, 0x19};
        assert(std::equal(equationY0.getVarEntries()[0].varname, equationY0.getVarEntries()[0].varname + 8, expectedEquationY0));

        TIVarFile equationX3T = TIVarFile::createNew("Equation", "{x3t}");
        const uint8_t expectedEquationX3T[8] = {0x5E, 0x24};
        assert(std::equal(equationX3T.getVarEntries()[0].varname, equationX3T.getVarEntries()[0].varname + 8, expectedEquationX3T));

        TIVarFile equationR4 = TIVarFile::createNew("Equation", "r4");
        const uint8_t expectedEquationR4[8] = {0x5E, 0x43};
        assert(std::equal(equationR4.getVarEntries()[0].varname, equationR4.getVarEntries()[0].varname + 8, expectedEquationR4));

        TIVarFile equationU = TIVarFile::createNew("Equation", "u");
        const uint8_t expectedEquationU[8] = {0x5E, 0x80};
        assert(std::equal(equationU.getVarEntries()[0].varname, equationU.getVarEntries()[0].varname + 8, expectedEquationU));

        const std::pair<const char*, const char*> equationSamples[] = {
            {"testData/Equation_Y1.8xy", "Y1"},
            {"testData/Equation_X1T.8xy", "X1T"},
            {"testData/Equation_r1.8xy", "R1"},
            {"testData/Equation_u.8xy", "U"},
        };
        for (const auto& [path, expectedName] : equationSamples)
        {
            TIVarFile equationSample = TIVarFile::loadFromFile(path);
            assert(entry_name_to_string(equationSample.getVarEntries()[0]._type, equationSample.getVarEntries()[0].varname) == expectedName);

            TIVarFile recreatedEquation = TIVarFile::createNew("Equation", expectedName);
            recreatedEquation.setContentFromString(equationSample.getReadableContent());
            assert(recreatedEquation.getRawContent() == equationSample.getRawContent());
        }

        const uint8_t altEquationY1T[8] = {'Y', 0x81};
        assert(entry_name_to_string(TIVarType{"Equation"}, altEquationY1T) == "Y1T");
        const uint8_t altEquationX3T[8] = {'X', 0x83};
        assert(entry_name_to_string(TIVarType{"Equation"}, altEquationX3T) == "X3T");
        const uint8_t altEquationR6[8] = {'r', 0x86};
        assert(entry_name_to_string(TIVarType{"Equation"}, altEquationR6) == "R6");
        const uint8_t altEquationU[8] = {'U', 0x00};
        assert(entry_name_to_string(TIVarType{"Equation"}, altEquationU) == "U");
        const uint8_t altEquationV[8] = {'V', 0x00};
        assert(entry_name_to_string(TIVarType{"Equation"}, altEquationV) == "V");
        const uint8_t altEquationW[8] = {'W', 0x00};
        assert(entry_name_to_string(TIVarType{"Equation"}, altEquationW) == "W");
    }

    {
        TIVarFile stringDefaultVar = TIVarFile::createNew("String");
        const auto& stringDefault = stringDefaultVar.getVarEntries()[0];
        const uint8_t expectedStringDefault[8] = {0xAA, 0x00};
        assert(std::equal(stringDefault.varname, stringDefault.varname + 8, expectedStringDefault));

        TIVarFile string0 = TIVarFile::createNew("String", "str0");
        const uint8_t expectedString0[8] = {0xAA, 0x09};
        assert(std::equal(string0.getVarEntries()[0].varname, string0.getVarEntries()[0].varname + 8, expectedString0));
    }

    {
        TIVarFile picDefaultVar = TIVarFile::createNew("Picture");
        const auto& picDefault = picDefaultVar.getVarEntries()[0];
        const uint8_t expectedPicDefault[8] = {0x60, 0x00};
        assert(std::equal(picDefault.varname, picDefault.varname + 8, expectedPicDefault));

        TIVarFile pic0 = TIVarFile::createNew("Picture", "pic0");
        const uint8_t expectedPic0[8] = {0x60, 0x09};
        assert(std::equal(pic0.getVarEntries()[0].varname, pic0.getVarEntries()[0].varname + 8, expectedPic0));
    }

    {
        TIVarFile imageDefaultVar = TIVarFile::createNew("Image");
        const auto& imageDefault = imageDefaultVar.getVarEntries()[0];
        const uint8_t expectedImageDefault[8] = {0x3C, 0x00};
        assert(std::equal(imageDefault.varname, imageDefault.varname + 8, expectedImageDefault));

        TIVarFile image0 = TIVarFile::createNew("Image", "image0");
        const uint8_t expectedImage0[8] = {0x3C, 0x09};
        assert(std::equal(image0.getVarEntries()[0].varname, image0.getVarEntries()[0].varname + 8, expectedImage0));
    }

    {
        const auto raw_to_hex = [](const data_t& data)
        {
            std::string hex;
            hex.reserve(data.size() * 2);
            for (const uint8_t byte : data)
            {
                hex += dechex(byte);
            }
            return hex;
        };

        TIVarFile monoPicture = TIVarFile::loadFromFile("testData/BartSimpson.8xi");
        const json monoPictureJSON = json::parse(monoPicture.getReadableContent());
        assert(monoPictureJSON["kind"] == "MonoPicture");
        assert(monoPictureJSON["typeName"] == "Picture");
        assert(monoPictureJSON["width"] == 96);
        assert(monoPictureJSON["height"] == 63);
        assert(monoPictureJSON["hasColor"] == false);
        assert(monoPictureJSON["dataLength"] == 758);
        assert(monoPictureJSON["storage"]["encoding"] == "L1");
        assert(monoPictureJSON["storage"]["pixelsPerByte"] == 8);
        assert_preview_bmp_data_url(monoPictureJSON["previewImageDataUrl"], 96, 63);

        TIVarFile colorPicture = TIVarFile::loadFromFile("testData/Pic1.8ci");
        const json colorPictureJSON = json::parse(colorPicture.getReadableContent());
        assert(colorPictureJSON["kind"] == "ColorPicture");
        assert(colorPictureJSON["typeName"] == "Picture");
        assert(colorPictureJSON["width"] == 266);
        assert(colorPictureJSON["height"] == 165);
        assert(colorPictureJSON["hasColor"] == true);
        assert(colorPictureJSON["dataLength"] == 21947);
        assert(colorPictureJSON["storage"]["encoding"] == "RGBPalette");
        assert(colorPictureJSON["storage"]["paletteSize"] == 15);
        assert(colorPicture.getVarEntries()[0].version == 0x0A);
        assert_preview_bmp_data_url(colorPictureJSON["previewImageDataUrl"], 266, 165);

        TIVarFile image = TIVarFile::loadFromFile("testData/Image1.8ca");
        const json imageJSON = json::parse(image.getReadableContent());
        assert(imageJSON["kind"] == "Image");
        assert(imageJSON["typeName"] == "Image");
        assert(imageJSON["width"] == 133);
        assert(imageJSON["height"] == 83);
        assert(imageJSON["hasColor"] == true);
        assert(imageJSON["dataLength"] == 22247);
        assert(imageJSON["storage"]["encoding"] == "RGB565");
        assert(imageJSON["storage"]["imageMagic"] == "81");
        assert(imageJSON["storage"]["rowPaddingBytes"] == 2);
        assert_preview_bmp_data_url(imageJSON["previewImageDataUrl"], 133, 83);

        TIVarFile recreatedMonoPicture = TIVarFile::createNew("Picture", "Pic1");
        recreatedMonoPicture.setContentFromString(R"({
    "typeName": "Picture",
    "rawDataHex": ")" + raw_to_hex(monoPicture.getRawContent()) + R"("
})");
        assert(recreatedMonoPicture.getRawContent() == monoPicture.getRawContent());

        TIVarFile recreatedColorPicture = TIVarFile::createNew("Picture", "Pic1");
        recreatedColorPicture.setContentFromString(R"({
    "typeName": "Picture",
    "rawDataHex": ")" + raw_to_hex(colorPicture.getRawContent()) + R"("
})");
        assert(recreatedColorPicture.getRawContent() == colorPicture.getRawContent());

        TIVarFile recreatedImage = TIVarFile::createNew("Image", "Image1");
        recreatedImage.setContentFromString(R"({
    "typeName": "Image",
    "rawDataHex": ")" + raw_to_hex(image.getRawContent()) + R"("
})");
        assert(recreatedImage.getRawContent() == image.getRawContent());

        TIVarFile colorPictureCopy = TIVarFile::loadFromFile("testData/Pic1 copy.8ci");
        const json colorPictureCopyJSON = json::parse(colorPictureCopy.getReadableContent());
        assert(colorPictureCopyJSON["kind"] == "ColorPicture");
        assert(colorPictureCopyJSON["typeName"] == "Picture");
        assert(colorPictureCopyJSON["width"] == colorPictureJSON["width"]);
        assert(colorPictureCopyJSON["height"] == colorPictureJSON["height"]);
        assert(colorPictureCopyJSON["storage"]["encoding"] == colorPictureJSON["storage"]["encoding"]);

        TIVarFile imageCopy = TIVarFile::loadFromFile("testData/Image1 copy.8ca");
        const json imageCopyJSON = json::parse(imageCopy.getReadableContent());
        assert(imageCopyJSON["kind"] == "Image");
        assert(imageCopyJSON["typeName"] == "Image");
        assert(imageCopyJSON["width"] == imageJSON["width"]);
        assert(imageCopyJSON["height"] == imageJSON["height"]);
        assert(imageCopyJSON["storage"]["encoding"] == imageJSON["storage"]["encoding"]);

        bool pictureWriteFailed = false;
        try
        {
            monoPicture.setContentFromString("{}");
        }
        catch (const std::runtime_error&)
        {
            pictureWriteFailed = true;
        }
        assert(pictureWriteFailed);
    }

    {
        TIVarFile gdbDefaultVar = TIVarFile::createNew("GraphDataBase");
        const auto& gdbDefault = gdbDefaultVar.getVarEntries()[0];
        const uint8_t expectedGdbDefault[8] = {0x61, 0x00};
        assert(std::equal(gdbDefault.varname, gdbDefault.varname + 8, expectedGdbDefault));

        TIVarFile gdb0 = TIVarFile::createNew("GraphDataBase", "gdb0");
        const uint8_t expectedGdb0[8] = {0x61, 0x09};
        assert(std::equal(gdb0.getVarEntries()[0].varname, gdb0.getVarEntries()[0].varname + 8, expectedGdb0));
    }

    {
        const auto expected_save_path = [](const TIVarFile& file, const char* ext)
        {
            const auto& entry = file.getVarEntries()[0];
            return "/tmp/"s + entry_name_to_string(entry._type, entry.varname) + "." + ext;
        };
        const auto expected_sanitized_save_path = [](const TIVarFile& file, const char* ext)
        {
            const auto& entry = file.getVarEntries()[0];
            return "/tmp/"s + sanitize_for_host_filename(entry_name_to_string(entry._type, entry.varname)) + "." + ext;
        };
        const auto raw_to_hex = [](const data_t& data)
        {
            std::string hex;
            hex.reserve(data.size() * 2);
            for (const uint8_t byte : data)
            {
                hex += dechex(byte);
            }
            return hex;
        };

        TIVarFile namedProgram = TIVarFile::createNew("Program", "A1B2C3");
        namedProgram.setContentFromString("Disp 42");
        const std::string namedProgramPath = expected_save_path(namedProgram, "8xp");
        assert(namedProgram.saveVarToFile("/tmp", "") == namedProgramPath);
        assert(remove(namedProgramPath.c_str()) == 0);

        TIVarFile namedAppVar = TIVarFile::createNew("AppVar", "DATA123", "83PCE");
        namedAppVar.setContentFromString("DEADBEEF");
        const std::string namedAppVarPath = expected_save_path(namedAppVar, "8xv");
        assert(namedAppVar.saveVarToFile("/tmp", "") == namedAppVarPath);
        assert(remove(namedAppVarPath.c_str()) == 0);

        TIVarFile thetaReal = TIVarFile::createNew("Real", "θ");
        thetaReal.setContentFromString("1");
        const std::string thetaRealPath = expected_sanitized_save_path(thetaReal, "8xn");
        assert(thetaReal.saveVarToFile("/tmp", "") == thetaRealPath);
        assert(remove(thetaRealPath.c_str()) == 0);

        TIVarFile thetaProgram = TIVarFile::createNew("Program", "θA");
        thetaProgram.setContentFromString("Disp 42");
        const std::string thetaProgramPath = expected_sanitized_save_path(thetaProgram, "8xp");
        assert(thetaProgramPath == "/tmp/θA.8xp");
        assert(thetaProgram.saveVarToFile("/tmp", "") == thetaProgramPath);
        assert(remove(thetaProgramPath.c_str()) == 0);

        TIVarFile thetaAppVar = TIVarFile::createNew("AppVar", "θDATA", "83PCE");
        thetaAppVar.setContentFromString("DEADBEEF");
        const std::string thetaAppVarPath = expected_sanitized_save_path(thetaAppVar, "8xv");
        assert(thetaAppVarPath == "/tmp/θDATA.8xv");
        assert(thetaAppVar.saveVarToFile("/tmp", "") == thetaAppVarPath);
        assert(remove(thetaAppVarPath.c_str()) == 0);

        const uint8_t thetaGroupName[8] = {0x5B, 'G', 'R', 'P'};
        assert(entry_name_to_string(TIVarType{"GroupObject"}, thetaGroupName) == "θGRP");

        const uint8_t thetaIdListName[8] = {0x5B, 'I', 'D'};
        assert(entry_name_to_string(TIVarType{"AppIDList"}, thetaIdListName) == "θID");

        TIVarFile namedGroup = TIVarFile::createNew("GroupObject", "GROUP123", "83PCE");
        namedGroup.setContentFromString(R"({
    "entries": [
        {
            "typeName": "Real",
            "name": "A",
            "readableContent": "1"
        }
    ]
})");
        const std::string namedGroupPath = expected_save_path(namedGroup, "8cg");
        assert(namedGroup.saveVarToFile("/tmp", "") == namedGroupPath);
        assert(remove(namedGroupPath.c_str()) == 0);

        TIVarFile newPicture = TIVarFile::loadFromFile("testData/BartSimpson.8xi");
        const std::string defaultPicturePath = expected_save_path(newPicture, "8xi");
        assert(newPicture.saveVarToFile("/tmp", "") == defaultPicturePath);
        assert(remove(defaultPicturePath.c_str()) == 0);

        TIVarFile sourceImage = TIVarFile::loadFromFile("testData/Image1.8ca");
        TIVarFile newImage = TIVarFile::createNew("Image", "Image0", "83PCE");
        newImage.setContentFromString(R"({
    "typeName": "Image",
    "rawDataHex": ")"s + raw_to_hex(sourceImage.getRawContent()) + R"("
})");
        const std::string defaultImagePath = expected_save_path(newImage, "8ca");
        assert(newImage.saveVarToFile("/tmp", "") == defaultImagePath);
        assert(remove(defaultImagePath.c_str()) == 0);

        TIVarFile newGDB = TIVarFile::createNew("GraphDataBase", "GDB1", "83PCE");
        TIVarFile sourceGDB = TIVarFile::loadFromFile("testData/GraphDataBase_Func.8xd");
        newGDB.setContentFromString(sourceGDB.getReadableContent());
        const std::string defaultGdbPath = expected_save_path(newGDB, "8xd");
        assert(newGDB.getRawContent() == sourceGDB.getRawContent());
        assert(newGDB.saveVarToFile("/tmp", "") == defaultGdbPath);
        assert(remove(defaultGdbPath.c_str()) == 0);

        TIVarFile newWindowSettings = TIVarFile::createNew("WindowSettings");
        TIVarFile oldWindowSettings = TIVarFile::loadFromFile("testData/Window.8xw");
        newWindowSettings.setContentFromString(oldWindowSettings.getReadableContent());
        const std::string defaultWindowPath = expected_save_path(newWindowSettings, "8xw");
        assert(newWindowSettings.getRawContent() == oldWindowSettings.getRawContent());
        assert(newWindowSettings.saveVarToFile("/tmp", "") == defaultWindowPath);
        assert(remove(defaultWindowPath.c_str()) == 0);

        TIVarFile newRecallWin = TIVarFile::createNew("RecallWindow");
        TIVarFile sourceRecallWin = TIVarFile::loadFromFile("testData/RecallWindow.8xz");
        newRecallWin.setContentFromString(sourceRecallWin.getReadableContent());
        const std::string defaultRecallPath = expected_save_path(newRecallWin, "8xz");
        assert(newRecallWin.getRawContent() == sourceRecallWin.getRawContent());
        assert(newRecallWin.saveVarToFile("/tmp", "") == defaultRecallPath);
        assert(remove(defaultRecallPath.c_str()) == 0);

        TIVarFile protectedProgram = TIVarFile::loadFromFile("testData/ProtectedProgram.8xp");
        assert(protectedProgram.getVarEntries()[0]._type.getName() == "ProtectedProgram");
        const std::string protectedName = entry_name_to_string(protectedProgram.getVarEntries()[0]._type, protectedProgram.getVarEntries()[0].varname);
        assert(!protectedName.empty());
        const std::string protectedPath = "/tmp/"s + protectedName + ".8xp";
        assert(protectedProgram.saveVarToFile("/tmp", "") == protectedPath);
        assert(remove(protectedPath.c_str()) == 0);

        TIVarFile longProtectedProgram = TIVarFile::loadFromFile("testData/ProtectedProgram_long.8xp");
        assert(longProtectedProgram.getVarEntries()[0]._type.getName() == "ProtectedProgram");
        const std::string longProtectedName = entry_name_to_string(longProtectedProgram.getVarEntries()[0]._type, longProtectedProgram.getVarEntries()[0].varname);
        assert(!longProtectedName.empty());
        {
            ScopedStderrCapture longProtectedDetokenizeStderr;
            const std::string longProtectedReadable = longProtectedProgram.getReadableContent();
            assert(longProtectedDetokenizeStderr.str().find("non-roundtrippable") == std::string::npos);
            assert(longProtectedReadable.find("\"Q|ui[t][t][|e][r]→Str7") != std::string::npos);
            assert(longProtectedReadable.find("\"R[|e][t]o|u[r]→Str9") != std::string::npos);
            assert(longProtectedReadable.find("\\u5E80") == std::string::npos);
            assert(longProtectedReadable.find("\\u621A") == std::string::npos);
            assert(longProtectedReadable.find("\\u6212") == std::string::npos);
            assert(longProtectedReadable.find("\\u6224") == std::string::npos);
            TIVarFile recreatedLongProtectedProgram = TIVarFile::createNew("ProtectedProgram", longProtectedName);
            recreatedLongProtectedProgram.setContentFromString(longProtectedReadable);
            assert(recreatedLongProtectedProgram.getRawContent() == longProtectedProgram.getRawContent());
        }
        const std::string longProtectedPath = "/tmp/"s + longProtectedName + ".8xp";
        assert(longProtectedProgram.saveVarToFile("/tmp", "") == longProtectedPath);
        assert(remove(longProtectedPath.c_str()) == 0);

        TIVarFile newTableRng1 = TIVarFile::createNew("TableRange");
        TIVarFile tableRange = TIVarFile::loadFromFile("testData/TableRange.8xt");
        newTableRng1.setContentFromString(tableRange.getReadableContent());
        const std::string defaultTablePath = expected_save_path(newTableRng1, "8xt");
        assert(newTableRng1.getRawContent() == tableRange.getRawContent());
        assert(newTableRng1.saveVarToFile("/tmp", "") == defaultTablePath);
        assert(remove(defaultTablePath.c_str()) == 0);
        const json tableRangeJSON = json::parse(tableRange.getReadableContent());
        assert(tableRangeJSON["TblMin"] == 0);
        assert(tableRangeJSON["DeltaTbl"] == 1);

        TIVarFile newTableRng2 = TIVarFile::createNew("TableRange");
        const uint8_t expectedName[8] = {'T', 'b', 'l', 'S', 'e', 't'};
        assert(std::equal(newTableRng2.getVarEntries()[0].varname, newTableRng2.getVarEntries()[0].varname + 8, expectedName));
        newTableRng2.setContentFromString(tableRange.getReadableContent());
        assert(newTableRng2.getRawContent() == tableRange.getRawContent());
    }

    {
        TIVarFile windowSettings = TIVarFile::loadFromFile("testData/Window.8xw");
        const json windowSettingsJSON = json::parse(windowSettings.getReadableContent());
        assert(windowSettingsJSON["Xmin"] == -10.0);
        assert(windowSettingsJSON["Ymin"] == -20.0);
        assert(windowSettingsJSON["Xres"] == 2);
        assert(windowSettingsJSON["Thetamax"] == "6.283185307");
        assert(windowSettingsJSON["Thetastep"] == "0.13089969389957");

        TIVarFile newWindowSettings = TIVarFile::createNew("WindowSettings");
        const uint8_t expectedName[8] = {'W', 'i', 'n', 'd', 'o', 'w'};
        assert(std::equal(newWindowSettings.getVarEntries()[0].varname, newWindowSettings.getVarEntries()[0].varname + 8, expectedName));
        newWindowSettings.setContentFromString(windowSettings.getReadableContent());
        assert(newWindowSettings.getRawContent() == windowSettings.getRawContent());
    }

    {
        TIVarFile recallWindow = TIVarFile::loadFromFile("testData/RecallWindow.8xz");
        assert(entry_name_to_string(recallWindow.getVarEntries()[0]._type, recallWindow.getVarEntries()[0].varname) == "RclWindw");
        const json recallWindowJSON = json::parse(recallWindow.getReadableContent());
        assert(recallWindowJSON["Xmin"] == -10.0);
        assert(recallWindowJSON["Xmax"] == 10.0);
        assert(recallWindowJSON["Xres"] == 1);
        assert(recallWindowJSON["Thetamax"] == "6.283185307");
        assert(recallWindowJSON["Thetastep"] == "0.13089969389957");

        TIVarFile newRecallWindow = TIVarFile::createNew("RecallWindow");
        const uint8_t expectedName[8] = {'R', 'c', 'l', 'W', 'i', 'n', 'd', 'w'};
        assert(std::equal(newRecallWindow.getVarEntries()[0].varname, newRecallWindow.getVarEntries()[0].varname + 8, expectedName));
        newRecallWindow.setContentFromString(recallWindow.getReadableContent());
        assert(newRecallWindow.getRawContent() == recallWindow.getRawContent());
    }

#if TH_GDB_SUPPORT
/*
    {
        TIVarFile GDB1 = TIVarFile::loadFromFile("testData/GraphDataBase_Func.8xd");
        const std::string gdb1JSON = GDB1.getReadableContent();
        cout << "GDB1.getReadableContent() : " << gdb1JSON << endl;

        TIVarFile GDB_new = TIVarFile::createNew("GraphDataBase", "a");
        GDB_new.setContentFromString(gdb1JSON);
        GDB_new.saveVarToFile("testData", "GraphDataBase_Func_new");
        assert(GDB1.getRawContent() == GDB_new.getRawContent());
        assert(gdb1JSON == GDB_new.getReadableContent());
    }
*/
    {
        TIVarFile GDB1 = TIVarFile::loadFromFile("testData/GraphDataBase_Param.8xd");
        const std::string gdb2JSON = GDB1.getReadableContent();

        std::ifstream jsonFile("testData/GDB_Parametric.json");
        std::stringstream gdbJSON;
        gdbJSON << jsonFile.rdbuf();

        TIVarFile paramGDB = TIVarFile::createNew("GraphDataBase", "\x61\x00"); // GDB0
        paramGDB.setContentFromString(gdbJSON.str());
        cout << "paramGDB.getReadableContent() : " << paramGDB.getReadableContent() << endl;
        paramGDB.saveVarToFile("testData", "GraphDataBase_Param_new");
        assert(GDB1.getRawContent() == paramGDB.getRawContent());
    }
#else
    cout << "GDB tests skipped (not built with C++20-capable compiler)" << endl;
#endif

    return 0;
}