tests.cpp

#include <cstdio>
#include <cstring>
#include <cinttypes>
#include "codec.h"
#include "protocol.h"
#include "visualizer.h"

static int tests_run = 0;
static int tests_passed = 0;

#define TEST(name)                          \
    void name();                            \
    static struct name##_register           \
    {                                       \
        name##_register()                   \
        {                                   \
            printf("\n[TEST] %s\n", #name); \
            ++tests_run;                    \
            name();                         \
        }                                   \
    } name##_instance;                      \
    void name()

#define ASSERT(cond)                                           \
    do                                                         \
    {                                                          \
        if (!(cond))                                           \
        {                                                      \
            printf("  FAIL: %s (line %d)\n", #cond, __LINE__); \
            return;                                            \
        }                                                      \
    } while (0)

#define PASS()              \
    do                      \
    {                       \
        ++tests_passed;     \
        printf("  PASS\n"); \
    } while (0)

// ===========================================================================
// Basic Encode/Decode Test
// ===========================================================================
TEST(test_encode_decode_roundtrip)
{
    uint8_t buffer[32] = {0};

    Order input = {
        .order_id = 123456789,
        .price = 50000,
        .quantity = 100,
        .side = protocol::SIDE_BUY};

    size_t written = encode_order(buffer, sizeof(buffer), input);
    ASSERT(written == protocol::ORDER_MSG_SIZE);

    Order output = {};
    CodecResult result = decode_order(buffer, sizeof(buffer), output);
    ASSERT(result == CodecResult::OK);

    ASSERT(output.order_id == input.order_id);
    ASSERT(output.price == input.price);
    ASSERT(output.quantity == input.quantity);
    ASSERT(output.side == input.side);

    PASS();
}

// ===========================================================================
// Buffer Too Small Test
// ===========================================================================
TEST(test_buffer_too_small_encode)
{
    uint8_t buffer[10]; // Too small
    Order input = {1, 100, 10, protocol::SIDE_SELL};

    size_t written = encode_order(buffer, sizeof(buffer), input);
    ASSERT(written == 0);

    PASS();
}

TEST(test_buffer_too_small_decode)
{
    uint8_t buffer[10] = {0};
    Order output = {};

    CodecResult result = decode_order(buffer, sizeof(buffer), output);
    ASSERT(result == CodecResult::BUFFER_TOO_SMALL);

    PASS();
}

// ===========================================================================
// Invalid Message Type Test
// ===========================================================================
TEST(test_invalid_message_type)
{
    uint8_t buffer[32] = {0};
    Order input = {1, 100, 10, protocol::SIDE_BUY};

    encode_order(buffer, sizeof(buffer), input);

    // Corrupt message type
    buffer[0] = 0xFF;
    buffer[1] = 0xFF;

    Order output = {};
    CodecResult result = decode_order(buffer, sizeof(buffer), output);
    ASSERT(result == CodecResult::INVALID_MSG_TYPE);

    PASS();
}

// ===========================================================================
// Checksum Validation Test
// ===========================================================================
TEST(test_checksum_mismatch)
{
    uint8_t buffer[32] = {0};
    Order input = {42, 1000, 5, protocol::SIDE_SELL};

    encode_order(buffer, sizeof(buffer), input);

    // Corrupt a payload byte
    buffer[10] ^= 0xFF;

    Order output = {};
    CodecResult result = decode_order(buffer, sizeof(buffer), output);
    ASSERT(result == CodecResult::CHECKSUM_MISMATCH);

    PASS();
}

// ===========================================================================
// Edge Cases
// ===========================================================================
TEST(test_max_values)
{
    uint8_t buffer[32] = {0};

    Order input = {
        .order_id = UINT64_MAX,
        .price = UINT32_MAX,
        .quantity = UINT32_MAX,
        .side = protocol::SIDE_SELL};

    size_t written = encode_order(buffer, sizeof(buffer), input);
    ASSERT(written == protocol::ORDER_MSG_SIZE);

    Order output = {};
    CodecResult result = decode_order(buffer, sizeof(buffer), output);
    ASSERT(result == CodecResult::OK);

    ASSERT(output.order_id == UINT64_MAX);
    ASSERT(output.price == UINT32_MAX);
    ASSERT(output.quantity == UINT32_MAX);

    PASS();
}

TEST(test_zero_values)
{
    uint8_t buffer[32] = {0};

    Order input = {0, 0, 0, protocol::SIDE_BUY};

    size_t written = encode_order(buffer, sizeof(buffer), input);
    ASSERT(written == protocol::ORDER_MSG_SIZE);

    Order output = {};
    CodecResult result = decode_order(buffer, sizeof(buffer), output);
    ASSERT(result == CodecResult::OK);

    ASSERT(output.order_id == 0);
    ASSERT(output.price == 0);
    ASSERT(output.quantity == 0);

    PASS();
}

// ===========================================================================
// Visual Demonstration
// ===========================================================================
void run_visual_demo()
{
    printf("\n");
    printf("##############################################################\n");
    printf("#                 BINARY PROTOCOL VISUALIZER                 #\n");
    printf("##############################################################\n");

    uint8_t buffer[32] = {0};

    Order order = {
        .order_id = 42,
        .price = 15000, // $150.00
        .quantity = 100,
        .side = protocol::SIDE_BUY};

    printf("\nCreating order: id=%" PRIu64 ", price=%u, qty=%u, side=%s\n",
           order.order_id, order.price, order.quantity,
           order.side == protocol::SIDE_BUY ? "BUY" : "SELL");

    size_t written = encode_order(buffer, sizeof(buffer), order);
    printf("Encoded %zu bytes\n", written);

    // Show raw hex dump
    viz::hex_dump(buffer, written);

    // Show annotated format
    viz::annotate_order_message(buffer, written);

    // Show encoding process
    viz::show_encoding_process(buffer, written,
                               order.order_id, order.price,
                               order.quantity, order.side);

    // Show decoding process
    viz::show_decoding_process(buffer, written);

    // Decode and verify
    Order decoded = {};
    CodecResult result = decode_order(buffer, written, decoded);

    printf("\n");
    printf("=== FINAL VERIFICATION ");
    for (int i = 0; i < 38; ++i)
        printf("=");
    printf("\n\n");

    printf("Decode result: %s\n\n", codec_result_str(result));
    printf("  Original  ->  Decoded\n");
    printf("  --------      --------\n");
    printf("  order_id:  %" PRIu64 "  ->  %" PRIu64 "  %s\n",
           order.order_id, decoded.order_id,
           order.order_id == decoded.order_id ? "[OK]" : "[MISMATCH]");
    printf("  price:     %u  ->  %u  %s\n",
           order.price, decoded.price,
           order.price == decoded.price ? "[OK]" : "[MISMATCH]");
    printf("  quantity:  %u  ->  %u  %s\n",
           order.quantity, decoded.quantity,
           order.quantity == decoded.quantity ? "[OK]" : "[MISMATCH]");
    printf("  side:      %s  ->  %s  %s\n",
           order.side == protocol::SIDE_BUY ? "BUY" : "SELL",
           decoded.side == protocol::SIDE_BUY ? "BUY" : "SELL",
           order.side == decoded.side ? "[OK]" : "[MISMATCH]");
}

// ===========================================================================
// Main
// ===========================================================================
int main(int argc, char *argv[])
{
    printf("Binary Protocol Test Suite\n");
    printf("==========================\n");

    // Tests run automatically via static initialization

    printf("\n---------------------------\n");
    printf("Results: %d/%d tests passed\n", tests_passed, tests_run);

    if (argc > 1 && strcmp(argv[1], "--visual") == 0)
    {
        run_visual_demo();
    }
    else
    {
        printf("\nRun with --visual flag to see byte-level visualization\n");
    }

    return (tests_passed == tests_run) ? 0 : 1;
}