STM32F4-Base/test/host/ftp_cfg/ftp_cfg_test.c

/*
 * 模块名称：FTP 鉴权配置（[ftp] 段）主机侧单元测试
 * 模块功能：在 PC 上离线验证 Drivers/BSP/NETCFG/ftp_cfg.c 的注册契约与
 *           "出厂默认口令是否在用"的判定（大小写不敏感）。
 *
 * 被测对象：真实源文件 ../../../Drivers/BSP/NETCFG/ftp_cfg.c（#include 原样纳入）。
 *           桩只有一个：真实头 App/cfg/cfg_file.h + 本文件给出的 cfg_file_register
 *           可控实现（按值留档注册描述符）。本模块**零 stub 目录**——ftp_cfg.c 不
 *           包含 dbg_log.h，也没有别的平台依赖。
 *
 * 为什么要主机侧单测（而不是只靠台架）：
 *   1. 这个模块是 **FTP 的门禁**（N-19）：pwd_hash 存的是 SHA-256(user‖password)，
 *      判定写成大小写敏感就会在"用户手输大写 hex"时把正确口令当错误；写成敏感于
 *      默认值大小写则会误报"已改口令"，让出厂默认口令的启动告警**静默失效**——
 *      现场表现是"以为改了口令"。
 *   2. [ftp] 段刻意**不挂变更回调**（口令在下次登录 PASS 时才生效）：哪天有人"顺手
 *      补一个回调"，poll 重载会去重建网络——这条契约只能靠断言钉住（TC-FTPCFG-004）。
 *   3. write_en 出厂 = 1 是刻意的（FTP 推 config.ini 是既有维护工作流），改成 0
 *      会让现场升级流程直接失败；同样需要一个显式断言（TC-FTPCFG-005）。
 *   ⚠ DEF_HASH 这个常量本身的正确性由 test/host/sha256/ 的 TC-SHA256-008 钉
 *     （它算 SHA256("adminadmin") 并与 FTP_CFG_DEF_HASH 比对），本模块不重复算。
 *
 * 覆盖点：
 *   TC-FTPCFG-001a get 返回恒非空（静态常驻，load 前后都可用）
 *   TC-FTPCFG-001  未注册即可 get：user=admin（出厂默认口令在用）
 *   TC-FTPCFG-002 pwd_hash 初值 = FTP_CFG_DEF_HASH，write_en 初值 = 1
 *   TC-FTPCFG-003 注册幂等：重复 register 只向引擎登记一次
 *   TC-FTPCFG-004 注册内容：段名 ftp / 三键 / 尺寸 / 默认值指针 / **p_cb 必须为 NULL**
 *   TC-FTPCFG-005 键表逐项：user(STR,16) / pwd_hash(STR,65) / write(UINT,1)
 *   TC-FTPCFG-006 出厂态 is_default_pwd = 1
 *   TC-FTPCFG-007 改了口令 → is_default_pwd = 0
 *   TC-FTPCFG-008 哈希存成**大写** hex 仍判"默认口令在用"（大小写不敏感）
 *   TC-FTPCFG-009 空哈希不是默认口令（且不读越界）
 *   TC-FTPCFG-010 混入非字母字符的串按逐字符比较（数字/下划线不被折叠改写）
 *   TC-FTPCFG-011 前缀关系不算相等（"abc" vs "abcd"）
 *   TC-FTPCFG-012 任一参数为 NULL 判不等（is_default_pwd 走不到，故直测静态函数）
 *   TC-FTPCFG-013 两串都为 NULL 也判不等（fail-closed，不许"都为空=相等"）
 *   TC-FTPCFG-014 缓冲尺寸契约：user 16 / hash 65（64 hex + NUL）
 *
 * 用例顺序有依赖：001/002/006 必须在任何"改写 RAM 副本"的用例之前跑。
 *
 * 通过：全部 TC PASS（main 返回 0）。
 * 入口：int main(void)，返回 0=PASS / 1=FAIL（由 run 脚本判读）。
 *
 * 创建日期：2026-10-23
 */

#include <stdio.h>
#include <string.h>

#include "cfg_file.h"
#include "ftp_cfg.h"

#include "ftp_cfg.c"

/* ===================== 断言框架 ===================== */

static int s_total;
static int s_passed;
static int s_failed;

#define CHECK(cond, name) do { \
    s_total++; \
    if (cond) { s_passed++; printf("  PASS %s\n", name); } \
    else { s_failed++; printf("  FAIL %s (line %d)\n", name, __LINE__); } \
} while (0)

/* ===================== 假引擎：只留注册记录 ===================== */

typedef struct {
    char        name[CFG_FILE_MAX_NAME_LEN + 1u];
    const void *p_data;
    const void *p_defaults;
    size_t      data_size;
    uint8_t     key_count;
    void      (*p_cb)(void);
    const cfg_key_def_t *p_keys;
} fake_reg_t;

static fake_reg_t g_reg;
static int g_reg_n;

static void fake_copy_name(char *dst, const char *src, size_t cap)
{
    size_t i;

    for (i = 0u; (i + 1u < cap) && (src[i] != '\0'); i++) {
        dst[i] = src[i];
    }
    dst[i] = '\0';
}

int cfg_file_register(const cfg_section_reg_t *p_reg)
{
    if ((p_reg == NULL) || (p_reg->name == NULL)) {
        return -1;
    }
    fake_copy_name(g_reg.name, p_reg->name, sizeof(g_reg.name));
    g_reg.p_data     = p_reg->p_data;
    g_reg.p_defaults = p_reg->p_defaults;
    g_reg.data_size  = p_reg->data_size;
    g_reg.key_count  = p_reg->key_count;
    g_reg.p_cb       = p_reg->p_cb;
    g_reg.p_keys     = p_reg->p_keys;
    g_reg_n++;
    return 0;
}

static void fake_reset(void)
{
    (void)memset(&g_reg, 0, sizeof(g_reg));
    g_reg_n = 0;
}

/* 把 s_cfg.pwd_hash 写成任意串（白盒：引擎就是这么原地更新 RAM 副本的） */
static void set_hash(const char *p_src)
{
    size_t i;

    for (i = 0u; (i + 1u < FTP_CFG_HASH_MAX) && (p_src[i] != '\0'); i++) {
        s_cfg.pwd_hash[i] = p_src[i];
    }
    s_cfg.pwd_hash[i] = '\0';
}

/* 把出厂哈希原样写成大写形态（引擎写入的 hex 大小写不可控，判定必须容忍） */
static void set_hash_upper(void)
{
    size_t i;

    for (i = 0u; i + 1u < FTP_CFG_HASH_MAX; i++) {
        char ch = FTP_CFG_DEF_HASH[i];

        if ((ch >= 'a') && (ch <= 'z')) {
            ch = (char)(ch - 32);
        }
        s_cfg.pwd_hash[i] = ch;
        if (ch == '\0') {
            break;
        }
    }
}

/* ===================== 注册契约 ===================== */

static void tc_register(void)
{
    printf("-- TC-FTPCFG-003..005 register --\n");
    fake_reset();
    ftp_cfg_register();
    CHECK(g_reg_n == 1, "TC-FTPCFG-003a first register adds exactly one entry");
    ftp_cfg_register();
    CHECK(g_reg_n == 1, "TC-FTPCFG-003 repeated register never duplicates the entry (idempotent)");

    CHECK((strcmp(g_reg.name, "ftp") == 0) &&
          (g_reg.data_size == sizeof(ftp_cfg_t)) &&
          (g_reg.key_count == 3u) &&
          (g_reg.p_defaults != NULL) &&
          (g_reg.p_data == (const void *)&s_cfg) &&
          (g_reg.p_cb == NULL),
          "TC-FTPCFG-004 section name/size/key count/defaults/**p_cb must be NULL**");

    CHECK((strcmp(g_reg.p_keys[0].name, "user") == 0) &&
          (g_reg.p_keys[0].type == CFG_VAL_STR) &&
          (g_reg.p_keys[0].len == FTP_CFG_USER_MAX) &&
          (g_reg.p_keys[0].offset == offsetof(ftp_cfg_t, user)) &&
          (strcmp(g_reg.p_keys[1].name, "pwd_hash") == 0) &&
          (g_reg.p_keys[1].type == CFG_VAL_STR) &&
          (g_reg.p_keys[1].len == FTP_CFG_HASH_MAX) &&
          (strcmp(g_reg.p_keys[2].name, "write") == 0) &&
          (g_reg.p_keys[2].type == CFG_VAL_UINT) &&
          (g_reg.p_keys[2].len == 1u),
          "TC-FTPCFG-005 key table item by item: user(STR,16)/pwd_hash(STR,65)/write(UINT,1)");
}

/* ===================== 出厂默认与只读访问 ===================== */

static void tc_defaults(void)
{
    const ftp_cfg_t *p = ftp_cfg_get();

    printf("-- TC-FTPCFG-001..002,014 defaults --\n");
    /* 契约就是"恒非空"（静态常驻），单独一条断言；随后的显式守卫既让
     * test-cppcheck 不再报"冗余或空指针二选一"，也让真出问题时报在 001a 上 */
    CHECK(p != NULL, "TC-FTPCFG-001a ftp_cfg_get never NULL (statically resident)");
    if (p == NULL) {
        return;
    }
    CHECK(strcmp(p->user, "admin") == 0, "TC-FTPCFG-001 get works even unregistered, user = admin");
    CHECK((strcmp(p->pwd_hash, FTP_CFG_DEF_HASH) == 0) && (p->write_en == 1u),
          "TC-FTPCFG-002 initial value = factory hash + write_en=1 (maintenance workflow relies on it)");
    CHECK((FTP_CFG_USER_MAX == 16u) && (FTP_CFG_HASH_MAX == 65u) &&
          (sizeof(p->user) == FTP_CFG_USER_MAX) &&
          (sizeof(p->pwd_hash) == FTP_CFG_HASH_MAX),
          "TC-FTPCFG-014 buffer size contract: user 16 / hash 65 (64 hex + NUL)");
}

/* ===================== 默认口令判定（启动告警的依据） ===================== */

static void tc_default_pwd(void)
{
    printf("-- TC-FTPCFG-006..009 default-password detection --\n");
    CHECK(ftp_cfg_is_default_pwd() == 1, "TC-FTPCFG-006 factory state judged as default password");

    set_hash("0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef");
    CHECK(ftp_cfg_is_default_pwd() == 0, "TC-FTPCFG-007 password changed -> no longer default");

    set_hash_upper();
    CHECK(ftp_cfg_is_default_pwd() == 1,
          "TC-FTPCFG-008 uppercase hex still judged default (comparison must be case-insensitive)");

    set_hash("");
    CHECK(ftp_cfg_is_default_pwd() == 0, "TC-FTPCFG-009 empty hash is not the default password");
}

/* ===================== 静态比较函数（NULL / 折叠 / 前缀） ===================== */

static void tc_ci_eq(void)
{
    printf("-- TC-FTPCFG-010..013 case-insensitive compare --\n");
    CHECK(s_str_ci_eq("A_b1!Z", "a_b1!z") == 1,
          "TC-FTPCFG-010 only folds A-Z; digits/underscore/symbols compared as-is");
    CHECK(s_str_ci_eq("abc", "abcd") == 0, "TC-FTPCFG-011 prefix relation is not equality");
    CHECK((s_str_ci_eq(NULL, "x") == 0) && (s_str_ci_eq("x", NULL) == 0),
          "TC-FTPCFG-012 either side NULL -> not equal");
    CHECK(s_str_ci_eq(NULL, NULL) == 0,
          "TC-FTPCFG-013 both NULL also judged not equal (fail-closed)");
}

/* ===================== 入口 ===================== */

int main(void)
{
    printf("=== FTP Auth Config Tests ===\n");

    tc_defaults();          /* 必须最先：之后会改写 RAM 副本 */
    tc_register();
    tc_default_pwd();
    tc_ci_eq();

    printf("\n=== FTP Auth Config Tests: %d/%d PASSED (failed=%d) ===\n",
           s_passed, s_total, s_failed);
    return (s_failed == 0) ? 0 : 1;
}