#include "c_Hex.h"
#include "c_Test.h"
#include <stdlib.h>
#include <stdio.h>

TEST_CASE(test_c_Hex_BinToHex_A) {
    // 🌟【场景 A】：输入包含 0x00 中途截断干扰项的二进制数据密钥流
    // 预期转化为大写十六进制字符串后必须为："4A00FE1B"
    const unsigned char raw_bin_stream[] = { 0x4A, 0x00, 0xFE, 0x1B };
    c_size_t bin_len = sizeof(raw_bin_stream);

    char hex_output_buffer[16];

    // 1. 验证大写形式正向导出
    c_err_t err = c_Hex_BinToHex(raw_bin_stream, bin_len, true, hex_output_buffer, 16);
    ASSERT_INT_EQ(C_ERR_OK, err);
    ASSERT_TRUE(strcmp("4A00FE1B", hex_output_buffer) == 0); // 完美跨越 00 截断并成功输出大写文本

    // 2. 验证小写形式正向导出
    err = c_Hex_BinToHex(raw_bin_stream, bin_len, false, hex_output_buffer, 16);
    ASSERT_INT_EQ(C_ERR_OK, err);
    ASSERT_TRUE(strcmp("4a00fe1b", hex_output_buffer) == 0); // 成功输出小写文本
}

TEST_CASE(test_c_Hex_BinToHex_B) {
    const unsigned char dummy_bin[] = { 0xAA, 0xBB, 0xCC };
    char dummy_hex_out[16];

    // 🌟【场景 B】：外部承接缓冲区分配空间配额严重不足（仅给 5 字节，但 3 字节输入需要 3*2+1=7 字节空间）
    // 预期控制流必须前置高位拦截，原地拒绝并抛出越界异常状态码 C_ERR_OUTOFBOUND，粉碎缓冲区踩踏溢出！
    ASSERT_INT_EQ(C_ERR_OUTOFBOUND, c_Hex_BinToHex(dummy_bin, 3, true, dummy_hex_out, 5));

    // 🌟【场景 C】：验证空仓异常状态码拦截返回
    ASSERT_INT_EQ(C_ERR_EMPTY, c_Hex_BinToHex(dummy_bin, 0, true, dummy_hex_out, 16));
    ASSERT_TRUE(dummy_hex_out[0] == '\0'); // 确保空输入时尾端完好写入空截止符

    // 🌟【场景 D】：验证毒参数非合规强拦截线
    ASSERT_INT_EQ(C_ERR_PARAM, c_Hex_BinToHex(NULL, 5, true, dummy_hex_out, 16));
    ASSERT_INT_EQ(C_ERR_PARAM, c_Hex_BinToHex(dummy_bin, 5, true, NULL, 16));
}

TEST_CASE(test_c_Hex_HexToBin_A) {
    // 🌟【场景 A】：输入一个大小写变长混合、且正中央故意包含 00 以便生成二进制 \0 数据的十六进制文本
    // 预期对应的物理二进制内容： 0x4A, 0x00, 0xFE, 0x1B
    const char* mixed_hex_string = "4a00FE1b";

    unsigned char bin_output_buffer[16];
    c_size_t actual_generated_size = 0;

    c_err_t err = c_Hex_HexToBin(mixed_hex_string, bin_output_buffer, 16, &actual_generated_size);
    ASSERT_INT_EQ(C_ERR_OK, err);

    // 绝对物理长度必须精准卡死导出为 4 字节，不被 00 干扰斩断
    ASSERT_INT_EQ(4, (int)actual_generated_size);

    // 逐字节穿透核验真实的十六进制数字指纹内容
    ASSERT_INT_EQ(0x4A, bin_output_buffer[0]);
    ASSERT_INT_EQ(0x00, bin_output_buffer[1]); // 验证 \0 无损存储
    ASSERT_INT_EQ(0xFE, bin_output_buffer[2]);
    ASSERT_INT_EQ(0x1B, bin_output_buffer[3]);
}

TEST_CASE(test_c_Hex_HexToBin_B) {
    unsigned char dummy_buf[16];
    c_size_t dummy_size = 0;

    // 🌟【场景 B】：输入奇数位残缺字面量（长度 5），无法配对，预期必须爆发 C_ERR_PARAM 拦截
    ASSERT_INT_EQ(C_ERR_PARAM, c_Hex_HexToBin("A0F1B", dummy_buf, 16, &dummy_size));

    // 🌟【场景 C】：注入了非十六进制字母表上限的污染杂质字符 'G'，预期必须原地自毁熔断报错
    ASSERT_INT_EQ(C_ERR_PARAM, c_Hex_HexToBin("A0F1G2", dummy_buf, 16, &dummy_size));
    ASSERT_INT_EQ(0, (int)dummy_size);

    // 🌟【场景 D】：外部缓冲区承接上限过低（仅给 2 字节容量，但需要 3 字节），预期触发越界保护锁
    ASSERT_INT_EQ(C_ERR_OUTOFBOUND, c_Hex_HexToBin("4A00FE", dummy_buf, 2, &dummy_size));
}

// ==========================================
// 5. 主集成入口
// ==========================================
int main(void) {
    TEST_START(C_Hex_BinToHex_TestSuite);
    RUN_TEST(test_c_Hex_BinToHex_A);
    RUN_TEST(test_c_Hex_BinToHex_B);

    RUN_TEST(test_c_Hex_HexToBin_A);
    RUN_TEST(test_c_Hex_HexToBin_B);
    TEST_REPORT();
    return (g_test_registry.failed_count > 0 ? 1 : 0);
}