wandering1/STM32F4-Base
1
0
Fork 0
Code Issues 30 Pull Requests Actions Packages Projects 2 Releases Wiki Activity

主机单测：新增卷锁与时间同步两套用例（33+80 项）并登记钩子

Browse Source 
- vol_lock（App/fs/vol_lock.c）：33 用例。核心不变量是 fail-open——
  互斥量创建失败时 vol_lock_wait() 必须返回 1 且绝不阻塞，因为调用者
  defaultTask 是看门狗喂狗点；板端该路径只在内存耗尽时才可能走到。
- time_sync（App/sync/time_sync.c）：80 用例。本模块是 N-17 看门狗风险的
  全部逻辑贡献者，用例钉死分片喂狗节奏、监听退避、报文重组（半包/粘连/
  EOF/真错/预算耗尽/tick 回绕）、重听门控；用 longjmp 跳出 for(;;) 任务循环。
- 两套均为纯逻辑主机侧测试，MSVC 离线编译真实源文件（#include 纳入）。
- 新增钩子 vol-lock-unit-test、time-sync-unit-test（7f/7g）。
- 全量主机单测：watchdog 39 + sys_clock 100 + cfg_file 149 + phasor 57
  + adc_input 70 + vol_lock 33 + time_sync 80 = 528 项，全绿。
This commit is contained in:
Wanderingss
2026-10-10 18:03:31 +08:00
parent 3715f8a34c
commit a2f5d1397a
13 changed files with 1430 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/host/time_sync/run_unit_test.py
+58
View File
@@ -0,0 +1,58 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""时间同步（time_sync）的主机侧单元测试运行器（L0.5，纯标准库）。
做什么：
用本机 MSVC 编译 test/host/time_sync/time_sync_test.c（它以 #include 纳入
**生产源文件** App/sync/time_sync.c），在 PC 上离线跑：
分片延时（心跳节奏）/ 监听建立与退避 / 时间包重组状态机（分段 + 30s 预算 +
tick 回绕）/ 任务主循环（就绪屏障、accept 轮询、代次变化重监听）。
失败即非 0 退出。零硬件、零烧录、毫秒级。
工具链探测 / INCLUDE-LIB 拼接 / 编译运行 / 退出码判定全部委托给通用 harness
`test/host/common/unit_test_harness.py`（本文件只做声明）。
为什么要主机侧单测（而不是只用板端套件）：
本模块是登记簿 N-17 的当事方——"监听重建期间心跳缺口 800ms~1s，距 IWDG 最坏
超时 1701ms 余量仅 ~0.7s"。缺口成因全是本模块的**纯逻辑**（分片延时的喂狗
节奏、500/2000ms 监听退避、200ms accept 退避、50ms 收尾、屏障等待态喂心跳）。
真机上只能"跑起来看复位不复位"，主机侧可**逐片断言**。时间包重组状态机
（分段送达 / 预算耗尽 / EOF / 真错误 / tick 回绕）同理。
用法（仓库根目录）：
python test/host/time_sync/run_unit_test.py
或统一用 .venv： & '.venv\\Scripts\\python.exe' test/host/time_sync/run_unit_test.py
退出码：0=PASS / 1=测试失败 / 2=环境错误（找不到编译器 / 编译失败 / 无汇总行）。
设计依据：App/sync/time_sync.c 文件头注释 + docs/待处理内容.md N-17；
创建日期：2026-10-10
"""
import os
import sys
HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(os.path.dirname(os.path.dirname(HERE)))
# harness 位于 test/host/common/
sys.path.insert(0, os.path.join(ROOT, "test", "host", "common"))
from unit_test_harness import TestBuild, run_host_unit_test # noqa: E402
# 顺序敏感：stub 目录必须**先于**生产目录，才能覆盖 FreeRTOS.h / task.h /
# net_socket.h / sys_events.h / sys_clock.h / dbg_log.h（真实头会拖入整套
# FreeRTOS / CMSIS-RTOS / HAL）。task_watchdog.h 用**真实头**（App/util，只依赖
# stdint.h），time_sync.h 用真实头（接口契约原汁）。
BUILD = TestBuild(
name="Time Sync Tests",
src=os.path.join(HERE, "time_sync_test.c"),
include_dirs=[
os.path.join(HERE, "stub"),
os.path.join(ROOT, "App", "util"),
os.path.join(ROOT, "App", "sync"),
HERE,
],
summary_marker="=== Time Sync Tests:",
)
if __name__ == "__main__":
sys.exit(run_host_unit_test(BUILD))
test/host/time_sync/stub/FreeRTOS.h
+34
View File
@@ -0,0 +1,34 @@
/*
* 主机侧单测桩：FreeRTOS.h
* 模块功能：为 App/sync/time_sync.c 提供主机可编译的最小 FreeRTOS 时基类型与宏。
*
* ⚠ 仅供 test/host/time_sync/ 使用，不参与 MCU 构建。
* 真实头在 Middlewares/Third_Party/FreeRTOS/Source/include/，会拖入 portmacro /
* projdefs / portable 层，主机侧不引入。
*
* 保真点：TickType_t = uint32_t；configTICK_RATE_HZ = 1000（Inc/FreeRTOSConfig.h）
* → pdMS_TO_TICKS(ms) == ms。被断言"片长 = 50ms"的用例依赖此等式。
*
* 创建日期：2026-10-10
*/
#ifndef FREERTOS_H
#define FREERTOS_H
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef uint32_t TickType_t;
/* 与 Inc/FreeRTOSConfig.h 一致：1000 Hz → 1 tick = 1 ms */
#define configTICK_RATE_HZ 1000U
#define pdMS_TO_TICKS(ms) ((TickType_t)((uint32_t)(ms) * (1000U / configTICK_RATE_HZ)))
#ifdef __cplusplus
}
#endif
#endif /* FREERTOS_H */
test/host/time_sync/stub/cmsis_os2.h
+59
View File
@@ -0,0 +1,59 @@
/*
* 主机侧单测桩：cmsis_os2.h
* 模块功能：为 App/sync/time_sync.c（经 sys_events.h）提供主机可编译的 CMSIS-RTOS v2
* 事件标志接口与类型。
*
* ⚠ 仅供 test/host/time_sync/ 使用，不参与 MCU 构建。
* 真实头在 Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2/，会拖入整套
* FreeRTOS + CMSIS 内核对象，主机侧不引入。
*
* 保真点（对齐 cmsis_os2.h）：
* - osEventFlagsId_t = void*（:195）、osMutexId_t = void*（:198）；
* - osStatus_t 枚举含 osOK = 0；
* - 标志位 osFlagsWaitAny=0 / osFlagsNoClear=0x2 / osFlagsError=0x80000000
* / osFlagsErrorTimeout=0xFFFFFFFE（:153~164）；
* - uint32_t osEventFlagsWait(id, flags, options, timeout)（:539）。
* osEventFlagsWait 由测试单元给强符号桩（可注入"未就绪/超时"并驱动屏障循环）。
*
* 创建日期：2026-10-10
*/
#ifndef CMSIS_OS2_H
#define CMSIS_OS2_H
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
/* 不透明句柄 */
typedef void *osEventFlagsId_t;
typedef void *osMutexId_t;
/* 状态码（只保留被测代码用到的子集） */
typedef enum {
osOK = 0,
osError = -1,
osErrorTimeout = -2,
osErrorResource = -3,
osErrorParameter = -4
} osStatus_t;
/* 事件标志选项（cmsis_os2.h:153~164） */
#define osFlagsWaitAny 0x00000000U
#define osFlagsWaitAll 0x00000001U
#define osFlagsNoClear 0x00000002U
#define osFlagsError 0x80000000U
#define osFlagsErrorUnknown 0xFFFFFFFFU
#define osFlagsErrorTimeout 0xFFFFFFFEU
#define osFlagsErrorResource 0xFFFFFFFDU
#define osFlagsErrorParameter 0xFFFFFFFCU
uint32_t osEventFlagsWait(osEventFlagsId_t ef_id, uint32_t flags, uint32_t options, uint32_t timeout);
#ifdef __cplusplus
}
#endif
#endif /* CMSIS_OS2_H */
test/host/time_sync/stub/dbg_log.h
+31
View File
@@ -0,0 +1,31 @@
/*
* 主机侧单测桩：dbg_log.h
* 模块功能：为 App/sync/time_sync.c 提供主机可编译的日志宏（映射到计数）。
*
* ⚠ 仅供 test/host/time_sync/ 使用，不参与 MCU 构建。
*
* 注意：time_sync.c 在 `#include "dbg_log.h"` 之前自行 `#define` 了
* DBG_LINE_BUF_MAX 与 DBG_TAG（真实头会用到它们），故本桩**不得**再定义这两个宏，
* 否则触发 C4005 宏重定义告警（/W4）。
*
* DBG_ERROR / DBG_INFO 计入计数器，供单测断言：
* - "net_socket/bind/listen FAIL"、"open listener FAIL, retry later" → ERROR
* - "no TIME packet in 30s, drop conn"、"wall clock updated"、"network re-init" → INFO
*
* 创建日期：2026-10-10
*/
#ifndef DBG_LOG_H
#define DBG_LOG_H
#include <stdio.h>
/* 计数（在 time_sync_test.c 实现） */
extern int g_tstest_err_count;
extern int g_tstest_info_count;
#define DBG_INFO(fmt, ...) do { g_tstest_info_count++; } while (0)
#define DBG_DEBUG(fmt, ...) do { } while (0)
#define DBG_ERROR(fmt, ...) do { g_tstest_err_count++; } while (0)
#endif /* DBG_LOG_H */
test/host/time_sync/stub/net_socket.h
+71
View File
@@ -0,0 +1,71 @@
/*
* 主机侧单测桩：net_socket.h（含内联 net_types.h 子集）
* 模块功能：为 App/sync/time_sync.c 提供主机可编译的网络 Socket API 声明与类型。
*
* ⚠ 仅供 test/host/time_sync/ 使用，不参与 MCU 构建。
* 真实头（Drivers/BSP/NET/net_socket.h）包含 net_types.h → net_config.h，并经
* FreeRTOS.h / task.h 拖入整套 FreeRTOS；本桩改为包含同名桩头。
*
* 保真点：
* - 地址族/类型/特殊地址常量与 Drivers/BSP/NET/net_types.h 逐字一致；
* - struct net_sockaddr / net_in_addr / net_sockaddr_in 字段与真实头一致
* （被测代码写 sin_family / sin_port / sin_addr.s_addr，桩按同布局读取）；
* - 7 个被测代码调用的接口签名与真实头一致（net_socket / net_bind / net_listen /
* net_accept / net_close / net_recv_to / net_get_generation / net_htons）。
* 全部由测试单元给强符号桩（脚本化返回值 + 调用记录）。
*
* 创建日期：2026-10-10
*/
#ifndef NET_SOCKET_H
#define NET_SOCKET_H
#include <stdint.h>
#include "FreeRTOS.h"
#include "task.h"
#ifdef __cplusplus
extern "C" {
#endif
/* ===== 以下取自 Drivers/BSP/NET/net_types.h（逐字） ===== */
#define NET_AF_INET 2 /* IPv4 */
#define NET_SOCK_STREAM 1 /* TCP */
#define NET_SOCK_DGRAM 2 /* UDP */
#define NET_INADDR_ANY 0 /* 任意地址 */
#define NET_INADDR_NONE 0xFFFFFFFF /* 无效地址 */
struct net_sockaddr {
uint16_t sa_family; /* 地址族 */
char sa_data[14]; /* 地址数据 */
};
struct net_in_addr {
uint32_t s_addr; /* IP 地址（网络字节序） */
};
struct net_sockaddr_in {
uint16_t sin_family; /* 地址族，必须为 AF_INET */
uint16_t sin_port; /* 端口号（网络字节序） */
struct net_in_addr sin_addr; /* IP 地址（网络字节序） */
char sin_zero[8]; /* 填充字节 */
};
/* ===== 被测代码用到的 Socket API（签名与真实头一致） ===== */
int net_socket(int domain, int type);
int net_bind(int sockfd, const struct net_sockaddr *addr, int addrlen);
int net_listen(int sockfd);
int net_accept(int sockfd, struct net_sockaddr *addr, int *addrlen);
int net_close(int sockfd);
int net_recv_to(int sockfd, void *buf, int len, uint32_t timeout_ms);
uint32_t net_get_generation(void);
uint16_t net_htons(uint16_t hostshort);
#ifdef __cplusplus
}
#endif
#endif /* NET_SOCKET_H */
test/host/time_sync/stub/sys_clock.h
+29
View File
@@ -0,0 +1,29 @@
/*
* 主机侧单测桩：sys_clock.h
* 模块功能：为 App/sync/time_sync.c 提供主机可编译的墙钟设置接口声明。
*
* ⚠ 仅供 test/host/time_sync/ 使用，不参与 MCU 构建。
* 真实头（App/util/sys_clock.h）含日历/闰年等无关声明；本桩只保留被测代码
* 真正调用的那一个（签名与真实头逐字一致：int sys_clock_set_unix(uint32_t)）。
*
* 由测试单元给强符号桩，记录"是否被调用"与"最后一次的 epoch"。
*
* 创建日期：2026-10-10
*/
#ifndef SYS_CLOCK_H
#define SYS_CLOCK_H
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
int sys_clock_set_unix(uint32_t unix_secs);
#ifdef __cplusplus
}
#endif
#endif /* SYS_CLOCK_H */
test/host/time_sync/stub/sys_events.h
+39
View File
@@ -0,0 +1,39 @@
/*
* 主机侧单测桩：sys_events.h
* 模块功能：为 App/sync/time_sync.c 提供主机可编译的系统就绪事件组句柄与事件位。
*
* ⚠ 仅供 test/host/time_sync/ 使用，不参与 MCU 构建。
* 真实头（App/app/sys_events.h）包含 cmsis_os2.h；本桩改为包含同名桩，
* 避免拖入整套 CMSIS-RTOS/FreeRTOS。
*
* 事件位取值与真实头逐位一致（本模块只用到 SYS_EVT_NET_READY）。
*
* 创建日期：2026-10-10
*/
#ifndef SYS_EVENTS_H
#define SYS_EVENTS_H
#include "cmsis_os2.h"
#ifdef __cplusplus
extern "C" {
#endif
/* 系统就绪事件组句柄（真实工程由 MX_FREERTOS_Init 创建；主机侧由测试单元定义） */
extern osEventFlagsId_t sys_evtHandle;
/* 各子系统"就绪"事件位（与 App/app/sys_events.h 一致） */
#define SYS_EVT_NET_READY (1u << 0)
#define SYS_EVT_STORAGE_READY (1u << 1)
#define SYS_EVT_FTP_READY (1u << 2)
#define SYS_EVT_TIMESYNC_READY (1u << 3)
#define SYS_EVT_NET_RECONFIG (1u << 4)
#define SYS_EVT_CFG_SAVE (1u << 5)
#define SYS_EVT_CONSOLE_TX (1u << 6)
#ifdef __cplusplus
}
#endif
#endif /* SYS_EVENTS_H */
test/host/time_sync/stub/task.h
+29
View File
@@ -0,0 +1,29 @@
/*
* 主机侧单测桩：task.h
* 模块功能：为 App/sync/time_sync.c 提供主机可编译的 FreeRTOS 任务时基接口声明。
*
* ⚠ 仅供 test/host/time_sync/ 使用，不参与 MCU 构建。
*
* 两个接口由测试单元给强符号桩：vTaskDelay 记录每片睡眠时长（断言"≤50ms 分片"），
* xTaskGetTickCount 由测试单元提供可控时钟（驱动 30s 预算耗尽与 32 位回绕用例）。
*
* 创建日期：2026-10-10
*/
#ifndef TASK_H
#define TASK_H
#include "FreeRTOS.h"
#ifdef __cplusplus
extern "C" {
#endif
void vTaskDelay(TickType_t xTicksToDelay);
TickType_t xTaskGetTickCount(void);
#ifdef __cplusplus
}
#endif
#endif /* TASK_H */
test/host/time_sync/time_sync_test.c
+717
View File
@@ -0,0 +1,717 @@
/*
* 模块名称：Time Sync（PC 本地时间推送接收）主机侧单元测试
* 模块功能：在 PC 上对 App/sync/time_sync.c 做离线验证（4 个函数全覆盖：
* time_sync_delay_fed / time_sync_open_listener / time_sync_handle_conn /
* time_sync_task）。
*
* 被测对象：真实源文件 ../../../App/sync/time_sync.c（以 #include 原样纳入，
* 保证测的是生产代码而非副本）。平台依赖由本文件提供的**可注入桩**实现：
* - FreeRTOS/task.h -> vTaskDelay / xTaskGetTickCount（可控时钟）
* - net_socket.h -> socket/bind/listen/accept/close/recv_to/
* get_generation/htons（全部脚本化）
* - sys_events.h -> osEventFlagsWait（可注入"未就绪"）
* - sys_clock.h -> sys_clock_set_unix（记录 epoch）
* - task_watchdog.h -> task_wd_beat / task_wd_bind（记录心跳节奏）
* - dbg_log.h -> DBG_ERROR/DBG_INFO 计数
*
* 为什么要主机侧单测（而不是只用板端套件）：
* 1. **本模块是 N-17 的当事方**：登记簿 N-17 记录"time_sync 监听重建期间心跳缺口
* 800ms~1s，距 IWDG 最坏超时 1701ms 余量仅 ~0.7s"。缺口的成因全部是本模块的
* **纯逻辑**——分片延时（delay_fed）的心跳节奏、监听重试退避（500/2000ms）、
* accept 轮询退避（200ms）、收尾延时（50ms）、以及"屏障等待态也要喂心跳"。
* 这些在真机上只能靠"跑起来看复位不复位"间接观察，主机侧可**逐片断言**。
* 2. **时间包重组状态机**（handle_conn）是纯逻辑：累积到 8 字节才解析、30s 总预算
* 随 tick 推进耗尽、TCP 分段送达、EOF/真错误/超时三种返回码分支——板端套件
* 无法精确构造"分段 + 预算耗尽 + tick 回绕"的组合。
* 3. 不占 MCU 的 RAM，毫秒级完成。
*
* 覆盖点（TC-TS-xxx）：
* —— time_sync_delay_fed（可喂心跳的分片延时）——
* TC-TS-001 0ms 不睡眠不喂狗
* TC-TS-002 恰好一片（50ms）
* TC-TS-003 非整片（120ms）切成 50/50/20，每片喂心跳
* TC-TS-004 长延时（2000ms）= 40 片 × 50ms，每片喂心跳
* TC-TS-005 不足一片（49ms）单片处理
* TC-TS-006 总预算 30s = 600 片（片长上限恒 50ms）
* —— time_sync_open_listener（监听建立与重试）——
* TC-TS-010 首次成功：socket/bind/listen 各一次，端口经 net_htons，无退避
* TC-TS-011 bind 失败 -> 关 socket + 退避 2000ms + 留痕，随后重试成功
* TC-TS-012 listen 失败 -> 关 socket + 退避 2000ms，随后重试成功
* TC-TS-013 socket 连续失败 -> 5 次后返回 -1（5 条 ERROR，5×500ms 退避）
* TC-TS-014 第 3 次重试成功并返回新描述符
* TC-TS-015 每次重试前 + 每片延时各喂一次心跳，且心跳位恒为 TIMESYNC
* —— time_sync_handle_conn（时间包重组状态机）——
* TC-TS-020 8 字节一次收齐 -> 大端解析 epoch + 更新墙钟 + 关连接
* TC-TS-021 分段送达（4+4）-> 累积后解析；第二次只请求剩余 12 字节
* TC-TS-022 一次到达 16 字节 -> 只取前 8 字节
* TC-TS-023 前缀非 "TIME" -> 不更新墙钟，但仍关连接
* TC-TS-024 对端关闭（n==0）-> 立即退出、不解析
* TC-TS-025 真错误（n==-1）-> 立即退出、不解析
* TC-TS-026 只收到 4 字节后 EOF -> 不足 8 字节不解析
* TC-TS-027 30s 预算耗尽 -> 留痕 "no TIME packet in 30s, drop conn"
* TC-TS-028 剩余预算不足一片 -> 末片按剩余（20ms）切分
* TC-TS-029 32 位 tick 回绕 -> 预算计算仍正确
* —— time_sync_task（任务主循环）——
* TC-TS-040 sys_evtHandle==NULL：跳过就绪屏障；accept 轮询->成功->处理->收尾
* TC-TS-041 就绪屏障：100ms 分片等待 NET_READY（osFlagsNoClear 不消费就绪位）
* TC-TS-042 屏障未就绪期间持续喂心跳（2026-10-02 台架根因的回归防线）
* TC-TS-043 网络代次变化 -> 关闭旧监听并重监听
* TC-TS-044 监听建立失败 -> 5 次重试后放弃并退避 2000ms
*
* 通过：全部 TC PASS（main 返回 0）。
* 入口：int main(void)，返回 0=PASS / 1=FAIL（由 run 脚本判读）。
*
* 创建日期：2026-10-10
*/
#include <setjmp.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
/* ===================== 平台桩（先纳入，覆盖真实头） ===================== */
#include "FreeRTOS.h"
#include "task.h"
#include "net_socket.h"
#include "sys_clock.h"
#include "sys_events.h"
#include "task_watchdog.h" /* 真实头（App/util）：task_wd_id_t / TASK_WD_TIMESYNC */
/* ===================== FreeRTOS 桩 ===================== */
static TickType_t s_tick;
#define DELAY_LOG_MAX 800
static uint32_t s_delays[DELAY_LOG_MAX];
static int s_delay_calls;
void vTaskDelay(TickType_t xTicksToDelay) {
if (s_delay_calls < DELAY_LOG_MAX) {
s_delays[s_delay_calls] = (uint32_t)xTicksToDelay;
}
s_delay_calls++;
}
TickType_t xTaskGetTickCount(void) {
return s_tick;
}
/* ===================== CMSIS-RTOS 事件标志桩 ===================== */
osEventFlagsId_t sys_evtHandle = NULL;
static uint32_t s_evt_seq[8];
static int s_evt_seq_n;
static uint32_t s_evt_default = 0xFFFFFFFFu; /* 未脚本化时的返回值（默认：就绪） */
static int s_evt_calls;
static int s_evt_longjmp_at = -1; /* >0 时第 N 次调用触发 longjmp */
static uint32_t s_evt_last_flags;
static uint32_t s_evt_last_options;
static uint32_t s_evt_last_timeout;
static jmp_buf s_jmp;
uint32_t osEventFlagsWait(osEventFlagsId_t ef_id, uint32_t flags, uint32_t options, uint32_t timeout) {
int i = s_evt_calls;
(void)ef_id;
s_evt_last_flags = flags;
s_evt_last_options = options;
s_evt_last_timeout = timeout;
s_evt_calls++;
if (s_evt_longjmp_at > 0 && (i + 1) >= s_evt_longjmp_at) {
longjmp(s_jmp, 2); /* 跳出 time_sync_task 的屏障循环（用例收尾） */
}
if (i < s_evt_seq_n) {
return s_evt_seq[i];
}
return s_evt_default;
}
/* ===================== 看门狗桩 ===================== */
static int s_beat_calls;
static int s_beat_id_bad;
/* ⚠ 命名必须与 net_socket 桩的 net_bind 计数区分开：C 的"暂定定义"规则下，
* 同一编译单元里两个 `static int x;` 会被**静默合并为同一个对象**（不报错），
* 于是 task_wd_bind 与 net_bind 会共用计数器，断言全部失真（2026-10-10 踩过）。 */
static int s_wd_bind_calls;
static int s_wd_bind_id_bad;
void task_wd_beat(task_wd_id_t id) {
s_beat_calls++;
if (id != TASK_WD_TIMESYNC) {
s_beat_id_bad++;
}
}
void task_wd_bind(task_wd_id_t id) {
s_wd_bind_calls++;
if (id != TASK_WD_TIMESYNC) {
s_wd_bind_id_bad++;
}
}
/* ===================== sys_clock 桩 ===================== */
static int s_set_unix_calls;
static uint32_t s_set_unix_last;
int sys_clock_set_unix(uint32_t unix_secs) {
s_set_unix_calls++;
s_set_unix_last = unix_secs;
return 0;
}
/* ===================== net_socket 桩 ===================== */
static uint16_t s_htons_last;
static int s_socket_calls;
static int s_socket_seq[8];
static int s_socket_seq_n;
static int s_socket_default = 5;
static int s_bind_calls;
static int s_bind_seq[8];
static int s_bind_seq_n;
static uint16_t s_bind_port;
static uint16_t s_bind_family;
static int s_listen_calls;
static int s_listen_seq[8];
static int s_listen_seq_n;
static int s_accept_calls;
static int s_accept_seq[16];
static int s_accept_seq_n;
static int s_close_calls;
static int s_close_socks[32];
static uint32_t s_gen_seq[8];
static int s_gen_seq_n;
static uint32_t s_gen_default = 1u;
static int s_gen_calls;
static int s_gen_longjmp_at = -1; /* >0 时第 N 次调用触发 longjmp */
uint16_t net_htons(uint16_t hostshort) {
s_htons_last = hostshort;
return (uint16_t)(((hostshort & 0xFFu) << 8) | (hostshort >> 8));
}
int net_socket(int domain, int type) {
int i = s_socket_calls++;
(void)domain;
(void)type;
return (i < s_socket_seq_n) ? s_socket_seq[i] : s_socket_default;
}
int net_bind(int sockfd, const struct net_sockaddr *addr, int addrlen) {
const struct net_sockaddr_in *a = (const struct net_sockaddr_in *)addr;
int i = s_bind_calls++;
(void)sockfd;
(void)addrlen;
s_bind_family = a->sin_family;
s_bind_port = a->sin_port;
return (i < s_bind_seq_n) ? s_bind_seq[i] : 0;
}
int net_listen(int sockfd) {
int i = s_listen_calls++;
(void)sockfd;
return (i < s_listen_seq_n) ? s_listen_seq[i] : 0;
}
int net_accept(int sockfd, struct net_sockaddr *addr, int *addrlen) {
int i = s_accept_calls++;
(void)sockfd;
(void)addr;
(void)addrlen;
return (i < s_accept_seq_n) ? s_accept_seq[i] : -1;
}
int net_close(int sockfd) {
if (s_close_calls < 32) {
s_close_socks[s_close_calls] = sockfd;
}
s_close_calls++;
return 0;
}
uint32_t net_get_generation(void) {
int i = s_gen_calls++;
if (s_gen_longjmp_at > 0 && (i + 1) >= s_gen_longjmp_at) {
longjmp(s_jmp, 1); /* 跳出 time_sync_task 的主循环（用例收尾） */
}
return (i < s_gen_seq_n) ? s_gen_seq[i] : s_gen_default;
}
/* ---- net_recv_to：脚本化返回码 + 可推进 tick ---- */
typedef struct {
int n; /* 返回码：>0 字节数 / 0 EOF / -1 错误 / -2 超时无数据 */
uint8_t data[16]; /* 要"送达"的字节 */
int len; /* data 有效长度 */
uint32_t tick_adv; /* 返回前把假时钟推进多少 ms */
} recv_step_t;
static recv_step_t s_recv_seq[16];
static int s_recv_seq_n;
static int s_recv_idx;
static int s_recv_calls;
static int s_recv_default = 0; /* 脚本用尽后的返回码（0=EOF，保证循环终止） */
static uint32_t s_recv_to_log[64];
static int s_recv_len_log[64];
int net_recv_to(int sockfd, void *buf, int len, uint32_t timeout_ms) {
int i = s_recv_calls;
(void)sockfd;
if (i < 64) {
s_recv_to_log[i] = timeout_ms;
s_recv_len_log[i] = len;
}
s_recv_calls++;
if (s_recv_idx >= s_recv_seq_n) {
return s_recv_default;
}
{
const recv_step_t *st = &s_recv_seq[s_recv_idx];
int copy;
s_recv_idx++;
s_tick += st->tick_adv;
if (st->n <= 0) {
return st->n;
}
copy = (st->n <= len) ? st->n : len;
if (copy > st->len) {
copy = st->len;
}
if ((copy > 0) && (buf != NULL)) {
memcpy(buf, st->data, (size_t)copy);
}
return st->n;
}
}
/* ===================== 断言 ===================== */
static int s_total = 0, s_passed = 0, s_failed = 0;
int g_tstest_err_count = 0;
int g_tstest_info_count = 0;
#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)
/* ===================== 被测代码（原样纳入生产源） ===================== */
#include "time_sync.c"
/* ===================== 工具 ===================== */
/*
* 函数功能：把全部桩复位到"健康"初值
* 入口参数：无
* 返 回 值：无
* 限定条件：无
* 函数说明：默认 = 网络全成功、gen 恒为 1、recv 脚本为空（脚本用尽返回 EOF）、
* 事件标志恒就绪。各用例按需覆盖。
*/
static void fakes_reset(void) {
s_tick = 0;
s_delay_calls = 0;
sys_evtHandle = NULL;
s_evt_seq_n = 0;
s_evt_default = SYS_EVT_NET_READY; /* 健康默认：就绪 */
s_evt_calls = 0;
s_evt_longjmp_at = -1;
s_evt_last_flags = 0;
s_evt_last_options = 0;
s_evt_last_timeout = 0;
s_beat_calls = 0;
s_beat_id_bad = 0;
s_wd_bind_calls = 0;
s_wd_bind_id_bad = 0;
s_set_unix_calls = 0;
s_set_unix_last = 0;
s_htons_last = 0;
s_socket_calls = 0;
s_socket_seq_n = 0;
s_socket_default = 5;
s_bind_calls = 0;
s_bind_seq_n = 0;
s_bind_port = 0;
s_bind_family = 0;
s_listen_calls = 0;
s_listen_seq_n = 0;
s_accept_calls = 0;
s_accept_seq_n = 0;
s_close_calls = 0;
s_gen_seq_n = 0;
s_gen_default = 1u;
s_gen_calls = 0;
s_gen_longjmp_at = -1;
s_recv_seq_n = 0;
s_recv_idx = 0;
s_recv_calls = 0;
s_recv_default = 0;
g_tstest_err_count = 0;
g_tstest_info_count = 0;
}
/* 装配一个 recv 脚本步 */
static void recv_set(int idx, int n, const uint8_t *data, int len, uint32_t tick_adv) {
memset(&s_recv_seq[idx], 0, sizeof(s_recv_seq[idx]));
s_recv_seq[idx].n = n;
s_recv_seq[idx].len = len;
s_recv_seq[idx].tick_adv = tick_adv;
if ((data != NULL) && (len > 0)) {
int copy = (len > 16) ? 16 : len;
memcpy(s_recv_seq[idx].data, data, (size_t)copy);
}
}
/* 装配一个 "TIME" + uint32 大端 时间包 */
static void make_time_packet(uint8_t *out, uint32_t epoch) {
out[0] = (uint8_t)'T';
out[1] = (uint8_t)'I';
out[2] = (uint8_t)'M';
out[3] = (uint8_t)'E';
out[4] = (uint8_t)(epoch >> 24);
out[5] = (uint8_t)(epoch >> 16);
out[6] = (uint8_t)(epoch >> 8);
out[7] = (uint8_t)(epoch);
}
/* 检查 s_delays[0..n) 是否全部等于 v */
static int delays_all(uint32_t v, int n) {
int k;
for (k = 0; k < n; k++) {
if (s_delays[k] != v) {
return 0;
}
}
return 1;
}
/* ===================== TC-TS-001..006：delay_fed ===================== */
static void tc_delay_fed(void) {
fakes_reset();
time_sync_delay_fed(0U);
CHECK((s_beat_calls == 0) && (s_delay_calls == 0), "TC-TS-001 delay_fed(0) 不睡眠不喂狗");
fakes_reset();
time_sync_delay_fed(50U);
CHECK((s_beat_calls == 1) && (s_delay_calls == 1) && (s_delays[0] == 50U),
"TC-TS-002 delay_fed(50) = 1 片 50ms + 1 次心跳");
fakes_reset();
time_sync_delay_fed(120U);
CHECK((s_beat_calls == 3) && (s_delay_calls == 3), "TC-TS-003 delay_fed(120) 切成 3 片");
CHECK((s_delays[0] == 50U) && (s_delays[1] == 50U) && (s_delays[2] == 20U),
"TC-TS-003b 片长 50/50/20（末片为余数）");
fakes_reset();
time_sync_delay_fed(2000U);
CHECK((s_delay_calls == 40) && (s_beat_calls == 40) && delays_all(50U, 40),
"TC-TS-004 delay_fed(2000) = 40 片 × 50ms，每片喂一次心跳");
fakes_reset();
time_sync_delay_fed(49U);
CHECK((s_beat_calls == 1) && (s_delays[0] == 49U), "TC-TS-005 不足一片（49ms）单片处理");
fakes_reset();
time_sync_delay_fed(30000U);
CHECK(s_delay_calls == 600, "TC-TS-006 总预算 30s = 600 片（片长上限恒 50ms）");
}
/* ===================== TC-TS-010..015：open_listener ===================== */
static void tc_open_listener(void) {
fakes_reset();
{
int s = time_sync_open_listener();
CHECK(s == 5, "TC-TS-010 open_listener 成功返回 socket 描述符");
CHECK((s_socket_calls == 1) && (s_bind_calls == 1) && (s_listen_calls == 1),
"TC-TS-010b socket / bind / listen 各一次");
CHECK(s_htons_last == (uint16_t)TIME_SYNC_PORT, "TC-TS-010c 端口经 net_htons(8888)");
CHECK(s_bind_port == net_htons((uint16_t)TIME_SYNC_PORT), "TC-TS-010d sin_port 为网络序");
CHECK(s_bind_family == (uint16_t)NET_AF_INET, "TC-TS-010e sin_family = NET_AF_INET");
CHECK(s_delay_calls == 0, "TC-TS-010f 成功路径无退避延时");
}
fakes_reset();
s_bind_seq[0] = -1;
s_bind_seq_n = 1;
{
int s = time_sync_open_listener();
CHECK(s == 5, "TC-TS-011 bind 失败一次后重试成功");
CHECK((s_close_calls == 1) && (s_close_socks[0] == 5), "TC-TS-011b bind 失败关闭该 socket");
CHECK(s_delay_calls == 40, "TC-TS-011c bind 失败退避 2000ms（40 片）");
CHECK(g_tstest_err_count == 1, "TC-TS-011d bind 失败留痕 DBG_ERROR");
}
fakes_reset();
s_listen_seq[0] = -1;
s_listen_seq_n = 1;
{
int s = time_sync_open_listener();
CHECK(s == 5, "TC-TS-012 listen 失败一次后重试成功");
CHECK((s_close_calls == 1) && (s_close_socks[0] == 5), "TC-TS-012b listen 失败关闭该 socket");
CHECK(s_delay_calls == 40, "TC-TS-012c listen 失败退避 2000ms");
}
fakes_reset();
s_socket_default = -1;
{
int s = time_sync_open_listener();
CHECK(s == -1, "TC-TS-013 socket 连续失败 -> 返回 -1");
CHECK(s_socket_calls == 5, "TC-TS-013b 重试上限 5 次");
CHECK(g_tstest_err_count == 5, "TC-TS-013c 每次失败各留痕一条（5 条 DBG_ERROR）");
CHECK(s_delay_calls == 50, "TC-TS-013d 每次失败退避 500ms（5 × 10 片）");
}
fakes_reset();
s_socket_seq[0] = -1;
s_socket_seq[1] = -1;
s_socket_seq[2] = 9;
s_socket_seq_n = 3;
{
int s = time_sync_open_listener();
CHECK(s == 9, "TC-TS-014 第 3 次重试成功并返回新描述符");
CHECK(s_socket_calls == 3, "TC-TS-014b 恰好尝试 3 次");
CHECK(s_delay_calls == 20, "TC-TS-014c 两次失败退避 500ms × 2");
}
fakes_reset();
s_socket_default = -1;
(void)time_sync_open_listener();
CHECK(s_beat_calls == 55, "TC-TS-015 每轮重试(5) + 每片延时(50) 各喂一次心跳");
CHECK(s_beat_id_bad == 0, "TC-TS-015b 心跳位恒为 TASK_WD_TIMESYNC");
}
/* ===================== TC-TS-020..029：handle_conn ===================== */
static void tc_handle_conn(void) {
uint8_t pkt[16];
/* 1) 8 字节一次收齐 */
fakes_reset();
make_time_packet(pkt, 0x12345678u);
recv_set(0, 8, pkt, 8, 0U);
s_recv_seq_n = 1;
s_tick = 100U;
time_sync_handle_conn(7);
CHECK(s_set_unix_calls == 1, "TC-TS-020 TIME 包一次收齐 -> 更新墙钟一次");
CHECK(s_set_unix_last == 0x12345678u, "TC-TS-020b epoch 按大端解析");
CHECK((s_recv_calls == 1) && (s_recv_len_log[0] == 16), "TC-TS-020c 首次请求 16 字节");
CHECK(s_recv_to_log[0] == 50U, "TC-TS-020d 单次等待片长 = 50ms");
CHECK((s_close_calls == 1) && (s_close_socks[0] == 7), "TC-TS-020e 处理完关闭连接");
CHECK(g_tstest_info_count == 1, "TC-TS-020f 留痕 wall clock updated");
/* 2) 分段送达：4 + 4 */
fakes_reset();
make_time_packet(pkt, 10u);
recv_set(0, 4, pkt, 4, 10U);
recv_set(1, 4, pkt + 4, 4, 10U);
s_recv_seq_n = 2;
time_sync_handle_conn(3);
CHECK((s_set_unix_calls == 1) && (s_set_unix_last == 10u), "TC-TS-021 分段送达累积后解析正确");
CHECK(s_recv_calls == 2, "TC-TS-021b 读了两次");
CHECK((s_recv_len_log[0] == 16) && (s_recv_len_log[1] == 12),
"TC-TS-021c 第二次只请求剩余 12 字节");
CHECK((s_recv_to_log[0] == 50U) && (s_recv_to_log[1] == 50U), "TC-TS-021d 每片 50ms（预算充裕）");
/* 3) 16 字节一次到达（只取前 8） */
fakes_reset();
make_time_packet(pkt, 5u);
recv_set(0, 16, pkt, 16, 0U);
s_recv_seq_n = 1;
time_sync_handle_conn(4);
CHECK((s_set_unix_calls == 1) && (s_set_unix_last == 5u), "TC-TS-022 超长包只取前 8 字节");
CHECK(s_recv_calls == 1, "TC-TS-022b 一次读够即停");
/* 4) 前缀不是 TIME */
fakes_reset();
pkt[0] = (uint8_t)'X';
pkt[1] = (uint8_t)'X';
pkt[2] = (uint8_t)'X';
pkt[3] = (uint8_t)'X';
pkt[4] = 0U;
pkt[5] = 0U;
pkt[6] = 0U;
pkt[7] = 1U;
recv_set(0, 8, pkt, 8, 0U);
s_recv_seq_n = 1;
time_sync_handle_conn(4);
CHECK(s_set_unix_calls == 0, "TC-TS-023 非 TIME 前缀不更新墙钟");
CHECK(s_close_calls == 1, "TC-TS-023b 仍关闭连接");
/* 5) 对端关闭（EOF） */
fakes_reset();
recv_set(0, 0, NULL, 0, 0U);
s_recv_seq_n = 1;
time_sync_handle_conn(6);
CHECK((s_set_unix_calls == 0) && (s_recv_calls == 1), "TC-TS-024 对端关闭(EOF)立即退出不解析");
CHECK(s_close_calls == 1, "TC-TS-024b 关闭连接");
/* 6) 真错误 */
fakes_reset();
recv_set(0, -1, NULL, 0, 0U);
s_recv_seq_n = 1;
time_sync_handle_conn(6);
CHECK((s_recv_calls == 1) && (s_set_unix_calls == 0), "TC-TS-025 真错误立即退出不解析");
/* 7) 4 字节后 EOF */
fakes_reset();
make_time_packet(pkt, 7u);
recv_set(0, 4, pkt, 4, 0U);
recv_set(1, 0, NULL, 0, 0U);
s_recv_seq_n = 2;
time_sync_handle_conn(6);
CHECK(s_set_unix_calls == 0, "TC-TS-026 不足 8 字节不解析");
CHECK(s_recv_calls == 2, "TC-TS-026b 继续等待后续字节");
/* 8) 30s 预算耗尽 */
fakes_reset();
recv_set(0, -2, NULL, 0, 30000U);
s_recv_seq_n = 1;
time_sync_handle_conn(6);
CHECK(s_recv_calls == 1, "TC-TS-027 预算耗尽后不再读（只读 1 次）");
CHECK(g_tstest_info_count == 1, "TC-TS-027b 留痕 no TIME packet in 30s, drop conn");
CHECK(s_close_calls == 1, "TC-TS-027c 仍关闭连接");
/* 9) 剩余预算不足一片 */
fakes_reset();
recv_set(0, -2, NULL, 0, 29980U);
s_recv_seq_n = 1;
time_sync_handle_conn(6);
CHECK(s_recv_calls == 2, "TC-TS-028 两次等待后结束");
CHECK((s_recv_to_log[0] == 50U) && (s_recv_to_log[1] == 20U),
"TC-TS-028b 第二次片长 = 剩余 20ms");
/* 10) 32 位 tick 回绕 */
fakes_reset();
s_tick = 0xFFFFFF00U;
recv_set(0, -2, NULL, 0, 512U); /* 推进后回绕到 0x00000100 */
s_recv_seq_n = 1;
time_sync_handle_conn(6);
CHECK((s_recv_calls == 2) && (s_recv_to_log[0] == 50U) && (s_recv_to_log[1] == 50U),
"TC-TS-029 32 位 tick 回绕后预算计算仍正确");
}
/* ===================== TC-TS-040..044：time_sync_task ===================== */
static void tc_task(void) {
uint8_t pkt[16];
/* A) 无就绪屏障（sys_evtHandle == NULL）：accept 轮询 2 次失败后成功 */
fakes_reset();
make_time_packet(pkt, 9u);
recv_set(0, 8, pkt, 8, 0U);
s_recv_seq_n = 1;
s_accept_seq[0] = -1;
s_accept_seq[1] = -1;
s_accept_seq[2] = 7;
s_accept_seq_n = 3;
/* gen 调用序：iter1 顶部(1) + accept 两次失败各一次(2,3) + iter2 顶部(4) → 第 4 次跳出 */
s_gen_longjmp_at = 4;
if (setjmp(s_jmp) == 0) {
time_sync_task(NULL);
}
CHECK((s_wd_bind_calls == 1) && (s_wd_bind_id_bad == 0),
"TC-TS-040 任务入口登记心跳位（task_wd_bind 一次）");
CHECK(s_evt_calls == 0, "TC-TS-040b sys_evtHandle==NULL 时跳过就绪屏障");
CHECK(s_accept_calls == 3, "TC-TS-040c accept 轮询 3 次（2 次无连接 + 1 次成功）");
CHECK((s_set_unix_calls == 1) && (s_set_unix_last == 9u), "TC-TS-040d 收到时间包并更新墙钟");
CHECK(s_close_calls == 1, "TC-TS-040e 连接被关闭一次");
CHECK(s_delay_calls == 9, "TC-TS-040f 延时片数 = 4+4+1（200+200+50ms）");
CHECK(delays_all(50U, 9), "TC-TS-040g 所有延时均按 50ms 分片");
CHECK(s_beat_calls == 13, "TC-TS-040h 心跳次数 = 主循环1 + 退避8 + 收连接1 + 收尾1 + 次轮1");
CHECK(s_beat_id_bad == 0, "TC-TS-040i 所有心跳均打 TIMESYNC 位");
/* B) 就绪屏障：2 次未就绪 + 1 次就绪 */
fakes_reset();
sys_evtHandle = (osEventFlagsId_t)0x55;
s_evt_seq[0] = osFlagsErrorTimeout;
s_evt_seq[1] = osFlagsErrorTimeout;
s_evt_seq[2] = SYS_EVT_NET_READY;
s_evt_seq_n = 3;
s_gen_longjmp_at = 1;
if (setjmp(s_jmp) == 0) {
time_sync_task(NULL);
}
CHECK(s_evt_calls == 3, "TC-TS-041 就绪屏障轮询 3 次（2 次未就绪 + 1 次就绪）");
CHECK(s_evt_last_timeout == 100U, "TC-TS-041b 屏障等待按 100ms 分片");
CHECK(s_evt_last_flags == SYS_EVT_NET_READY, "TC-TS-041c 等待 NET_READY 位");
CHECK(s_evt_last_options == (osFlagsWaitAny | osFlagsNoClear), "TC-TS-041d 就绪位不被消费");
CHECK(s_beat_calls == 3, "TC-TS-041e 未就绪的两次各喂一次心跳（+主循环 1 次）");
CHECK(s_wd_bind_calls == 1, "TC-TS-041f 仍先登记心跳路由");
/* C) 屏障期间持续喂心跳（就绪位长期不置位） */
fakes_reset();
sys_evtHandle = (osEventFlagsId_t)0x55;
s_evt_default = osFlagsErrorTimeout;
s_evt_longjmp_at = 4;
if (setjmp(s_jmp) == 0) {
time_sync_task(NULL);
}
CHECK(s_evt_calls == 4, "TC-TS-042 屏障等待 4 次均未就绪（循环未挂死）");
CHECK(s_beat_calls == 3, "TC-TS-042b 每次未就绪后各喂一次心跳（第 4 次跳出前）");
/* D) 网络代次变化 -> 关闭旧监听并重监听 */
fakes_reset();
s_gen_seq[0] = 1u;
s_gen_seq[1] = 2u;
s_gen_seq_n = 2;
s_gen_default = 2u;
s_gen_longjmp_at = 4;
if (setjmp(s_jmp) == 0) {
time_sync_task(NULL);
}
CHECK((s_close_calls == 1) && (s_close_socks[0] == 5), "TC-TS-043 代次变化时关闭旧监听");
/* INFO 三条：两次 open_listener 成功各一条 "TCP listen on" + 一条 "network re-init, relisten" */
CHECK(g_tstest_info_count == 3, "TC-TS-043b 留痕 network re-init, relisten（另含 2 条 listen 成功）");
CHECK(s_accept_calls == 2, "TC-TS-043c 每次循环只轮询一次 accept 即放弃");
CHECK((s_socket_calls == 2) && (s_bind_calls == 2) && (s_listen_calls == 2),
"TC-TS-043d 第二次循环重建了监听");
/* E) 监听建立失败 -> 5 次重试后放弃并退避 2000ms */
fakes_reset();
s_socket_default = -1;
s_gen_longjmp_at = 2;
if (setjmp(s_jmp) == 0) {
time_sync_task(NULL);
}
CHECK(s_socket_calls == 5, "TC-TS-044 open_listener 内部重试 5 次后放弃");
CHECK(g_tstest_err_count == 6, "TC-TS-044b 5 条 net_socket FAIL + 1 条 retry later");
CHECK(s_delay_calls == 90, "TC-TS-044c 退避 5×500ms + 2000ms = 90 片");
CHECK(s_beat_calls == 97, "TC-TS-044d 心跳次数 = 2 + 5 + 50 + 40");
CHECK(s_beat_id_bad == 0, "TC-TS-044e 所有心跳均打 TIMESYNC 位");
}
/* ===================== main ===================== */
int main(void) {
printf("=== Time Sync Tests ===\n");
printf("-- delay_fed (heartbeat-fed slicing) --\n");
tc_delay_fed();
printf("-- open_listener (retry / backoff) --\n");
tc_open_listener();
printf("-- handle_conn (packet reassembly / budget) --\n");
tc_handle_conn();
printf("-- time_sync_task (barrier / accept / relisten) --\n");
tc_task();
printf("\n=== Time Sync Tests: %d/%d PASSED (failed=%d) ===\n",
s_passed, s_total, s_failed);
return (s_failed == 0) ? 0 : 1;
}
test/host/vol_lock/run_unit_test.py
+53
View File
@@ -0,0 +1,53 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""卷锁（vol_lock）的主机侧单元测试运行器（L0.5，纯标准库）。
做什么：
用本机 MSVC 编译 test/host/vol_lock/vol_lock_test.c（它以 #include 纳入
**生产源文件** App/fs/vol_lock.c），在 PC 上离线跑创建/幂等/等待/超时/
**fail-open**/释放，失败即非 0 退出。零硬件、零烧录、毫秒级。
工具链探测 / INCLUDE-LIB 拼接 / 编译运行 / 退出码判定全部委托给通用 harness
`test/host/common/unit_test_harness.py`（本文件只做声明）。
为什么要主机侧单测（而不是只用板端套件）：
本模块最要紧的语义是 **fail-open**——锁创建失败时 vol_lock_wait 必须返回 1
且**绝不阻塞**（defaultTask 是看门狗喂狗点，等锁 = 停喂 = IWDG 误复位）。
真机上 osMutexNew 失败几乎不可复现（需堆耗尽），板端套件无法构造；主机侧
一次钉死。幂等性 / 超时透传 / 未创建时 release 无害 同属纯状态逻辑。
用法（仓库根目录）：
python test/host/vol_lock/run_unit_test.py
或统一用 .venv： & '.venv\\Scripts\\python.exe' test/host/vol_lock/run_unit_test.py
退出码：0=PASS / 1=测试失败 / 2=环境错误（找不到编译器 / 编译失败 / 无汇总行）。
设计依据：App/fs/vol_lock.h 文件头「使用约定（铁律）」；
创建日期：2026-10-10
"""
import os
import sys
HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(os.path.dirname(os.path.dirname(HERE)))
# harness 位于 test/host/common/
sys.path.insert(0, os.path.join(ROOT, "test", "host", "common"))
from unit_test_harness import TestBuild, run_host_unit_test # noqa: E402
# 顺序敏感：stub 目录必须**先于**生产目录，才能覆盖 cmsis_os.h
# （真实头在 Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2/，会拖入整套
# FreeRTOS）。vol_lock.h 用真实头（接口契约原汁）；三个 osMutex* 由测试单元给强符号桩。
BUILD = TestBuild(
name="Volume Lock Tests",
src=os.path.join(HERE, "vol_lock_test.c"),
include_dirs=[
os.path.join(HERE, "stub"),
os.path.join(ROOT, "App", "fs"),
HERE,
],
summary_marker="=== Volume Lock Tests:",
)
if __name__ == "__main__":
sys.exit(run_host_unit_test(BUILD))
test/host/vol_lock/stub/cmsis_os.h
+56
View File
@@ -0,0 +1,56 @@
/*
* 主机侧单测桩：cmsis_os.h（CMSIS-RTOS v1 兼容层）
* 模块功能：为 App/fs/vol_lock.c 提供主机可编译的 CMSIS-RTOS 互斥量接口。
*
* ⚠ 仅供 test/host/vol_lock/ 使用，不参与 MCU 构建。
* 真实头来自 Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2/cmsis_os.h，
* 会拖入整套 FreeRTOS（FreeRTOS.h / task.h / queue.h / semphr.h …），主机侧不引入。
*
* 保真点（对齐 cmsis_os.h + cmsis_os2.h）：
* - osMutexId_t = void*（cmsis_os2.h:198）；
* - osMutexNew(const osMutexAttr_t *attr)（cmsis_os2.h:552）；
* - osMutexWait(osMutexId_t, uint32_t) —— 真实头是 `#define osMutexWait osMutexAcquire`，
* 两者签名一致（cmsis_os.h:617）；
* - osMutexRelease(osMutexId_t)（cmsis_os.h:626）；
* - osStatus_t 枚举含 osOK = 0（cmsis_os.h:204）。
* 三个接口由测试单元给强符号桩（可注入"创建失败 / 等待超时"）。
*
* 创建日期：2026-10-10
*/
#ifndef CMSIS_OS_H
#define CMSIS_OS_H
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
/* 不透明句柄（真实定义见 cmsis_os2.h:195/198） */
typedef void *osMutexId_t;
typedef void *osEventFlagsId_t;
/* 状态码（cmsis_os.h:204 起的枚举；此处只保留被测代码用到的子集） */
typedef enum {
osOK = 0, /* 成功 */
osError = -1, /* 通用错误 */
osErrorTimeout = -2, /* 超时 */
osErrorResource = -3, /* 资源不可用 */
osErrorParameter = -4 /* 参数错误 */
} osStatus_t;
/* 互斥量属性：被测代码只传 NULL，故仅占位 */
typedef struct {
uint32_t attr_bits;
} osMutexAttr_t;
osMutexId_t osMutexNew(const osMutexAttr_t *attr);
osStatus_t osMutexWait(osMutexId_t mutex_id, uint32_t millisec);
osStatus_t osMutexRelease(osMutexId_t mutex_id);
#ifdef __cplusplus
}
#endif
#endif /* CMSIS_OS_H */
test/host/vol_lock/vol_lock_test.c
+224
View File
@@ -0,0 +1,224 @@
/*
* 模块名称：Volume Lock（卷锁）主机侧单元测试
* 模块功能：在 PC 上对 App/fs/vol_lock.c 做离线验证（3 个公开函数全覆盖）。
*
* 被测对象：真实源文件 ../../../App/fs/vol_lock.c（以 #include 原样纳入，
* 保证测的是生产代码而非副本）。平台依赖由本文件提供的**可注入桩**实现：
* - cmsis_os.h -> osMutexNew / osMutexWait / osMutexRelease
* （可注入 创建失败 / 等待超时 / 获取成功）
*
* 为什么要主机侧单测（而不是只用板端套件）：
* 1. 本模块最要紧的语义是 **fail-open**（锁创建失败时 `vol_lock_wait` 必须返回 1
* 且**绝不阻塞**）——这是"defaultTask 喂狗点绝不能因等锁而停摆"的最后一道保险。
* 真机上 `osMutexNew` 失败几乎不可能复现（需堆耗尽），板端套件无法构造。
* 2. 幂等性（重复 `vol_lock_init` 不得重复创建）、等待超时透传、未创建时 release 无害，
* 都是纯状态逻辑，主机侧一次钉死。
* 3. 不占 MCU 的 RAM，毫秒级完成。
*
* 覆盖点：
* TC-VL-001 init 首次调用创建互斥量并返回 0
* TC-VL-002 init 幂等（重复调用不再创建）
* TC-VL-003 init 在 osMutexNew 失败时返回 -1
* TC-VL-004 init 失败后可重试成功（s_lock 未被污染）
* TC-VL-005 wait 成功后返回 1，且把 timeout 原样透传给 osMutexWait
* TC-VL-006 wait 超时（osMutexWait != osOK）返回 0
* TC-VL-007 wait 在锁未创建时自动 init，再正常获取
* TC-VL-008 ⭐ fail-open：锁未创建且创建失败 -> 返回 1 且**不调用** osMutexWait
* TC-VL-009 fail-open 之后 release 无害（s_lock 仍为 NULL，不调用 osMutexRelease）
* TC-VL-010 已创建时 wait 不再调用 osMutexNew
* TC-VL-011 release 在已持锁时调用 osMutexRelease 一次
* TC-VL-012 release 在锁未创建时静默返回（不崩溃、不调用）
* TC-VL-013 完整周期 init -> wait -> release -> wait -> release
* TC-VL-014 wait(0) 的 timeout 透传为 0（defaultTask 的 try 语义）
*
* 通过：全部 TC PASS（main 返回 0）。
* 入口：int main(void)，返回 0=PASS / 1=FAIL（由 run 脚本判读）。
*
* 创建日期：2026-10-10
*/
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
/* ===================== 平台桩（先纳入，覆盖真实头） ===================== */
#include "cmsis_os.h"
/* ===================== CMSIS-RTOS 互斥量桩 =====================
* s_new_fail osMutexNew 返回 NULL（注入创建失败）
* s_wait_ok 0 -> osMutexWait 返回 osErrorTimeout（注入超时）
* s_fake_mutex 成功创建时返回的伪句柄（非 NULL 即可）
* s_last_timeout 记录 osMutexWait 收到的 millisec（断言透传）
*/
static int s_new_calls;
static int s_new_fail;
static int s_wait_calls;
static int s_wait_ok;
static int s_release_calls;
static uint32_t s_last_timeout;
static void *s_fake_mutex = (void *)0x1234;
osMutexId_t osMutexNew(const osMutexAttr_t *attr) {
(void)attr;
s_new_calls++;
return s_new_fail ? NULL : (osMutexId_t)s_fake_mutex;
}
osStatus_t osMutexWait(osMutexId_t mutex_id, uint32_t millisec) {
(void)mutex_id;
s_wait_calls++;
s_last_timeout = millisec;
return s_wait_ok ? osOK : osErrorTimeout;
}
osStatus_t osMutexRelease(osMutexId_t mutex_id) {
(void)mutex_id;
s_release_calls++;
return osOK;
}
/* ===================== 断言 ===================== */
static int s_total = 0, s_passed = 0, s_failed = 0;
#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)
/* ===================== 被测代码（原样纳入生产源） ===================== */
#include "vol_lock.c"
/* ===================== 工具 ===================== */
/*
* 函数功能：把全部桩与模块静态态复位到"刚上电"初值
* 入口参数：无
* 返 回 值：无
* 限定条件：无
* 函数说明：`s_lock` 是 vol_lock.c 的文件静态量（源文件已被纳入同一编译单元），
* 直接置 NULL 等价于"未初始化过"——这是白盒单测的可接受代价。
*/
static void fakes_reset(void) {
s_new_calls = 0;
s_new_fail = 0;
s_wait_calls = 0;
s_wait_ok = 1;
s_release_calls = 0;
s_last_timeout = 0xFFFFFFFFu;
s_fake_mutex = (void *)0x1234;
s_lock = NULL;
}
/* ===================== TC-VL-001..004：vol_lock_init ===================== */
static void tc_init(void) {
fakes_reset();
CHECK(vol_lock_init() == 0, "TC-VL-001 init 首次调用返回 0");
CHECK(s_new_calls == 1, "TC-VL-001b init 创建互斥量一次（osMutexNew）");
CHECK(s_lock != NULL, "TC-VL-001c 模块静态态已持有句柄");
CHECK(vol_lock_init() == 0, "TC-VL-002 init 重复调用仍返回 0（幂等）");
CHECK(s_new_calls == 1, "TC-VL-002b 幂等：不再创建第二个互斥量");
fakes_reset();
s_new_fail = 1;
CHECK(vol_lock_init() == -1, "TC-VL-003 osMutexNew 失败 -> init 返回 -1");
CHECK(s_lock == NULL, "TC-VL-003b 失败时不留下半初始化句柄");
s_new_fail = 0;
CHECK(vol_lock_init() == 0, "TC-VL-004 失败后重试可成功（返回 0）");
CHECK(s_new_calls == 2, "TC-VL-004b 重试确实再次调用 osMutexNew");
}
/* ===================== TC-VL-005..010：vol_lock_wait ===================== */
static void tc_wait(void) {
/* --- 已创建：超时值原样透传 --- */
fakes_reset();
(void)vol_lock_init();
CHECK(vol_lock_wait(100U) == 1, "TC-VL-005 wait 获取成功返回 1");
CHECK(s_wait_calls == 1, "TC-VL-005b osMutexWait 被调用一次");
CHECK(s_last_timeout == 100U, "TC-VL-005c timeout 原样透传给 osMutexWait");
fakes_reset();
(void)vol_lock_init();
CHECK(vol_lock_wait(0U) == 1, "TC-VL-014 wait(0) 获取成功返回 1（try 语义）");
CHECK(s_last_timeout == 0U, "TC-VL-014b wait(0) 的 timeout 透传为 0");
/* --- 超时：osMutexWait != osOK -> 返回 0 --- */
fakes_reset();
(void)vol_lock_init();
s_wait_ok = 0;
CHECK(vol_lock_wait(50U) == 0, "TC-VL-006 osMutexWait 非 osOK -> wait 返回 0");
CHECK(s_wait_calls == 1, "TC-VL-006b 超时路径确实尝试过等待");
/* --- 锁未创建：自动 init 后正常获取 --- */
fakes_reset();
CHECK(vol_lock_wait(10U) == 1, "TC-VL-007 锁未创建时 wait 自动 init 并获取");
CHECK(s_new_calls == 1, "TC-VL-007b 自动 init 创建了互斥量");
CHECK(s_wait_calls == 1, "TC-VL-007c 随后执行了一次等待");
/* --- ⭐ fail-open：创建失败必须返回 1 且绝不阻塞 --- */
fakes_reset();
s_new_fail = 1;
CHECK(vol_lock_wait(0U) == 1, "TC-VL-008 fail-open：锁创建失败仍返回 1（不阻塞喂狗点）");
CHECK(s_wait_calls == 0, "TC-VL-008b fail-open 时**不调用** osMutexWait（零阻塞）");
CHECK(s_lock == NULL, "TC-VL-008c fail-open 后仍无句柄");
/* --- fail-open 之后 release 无害 --- */
vol_lock_release();
CHECK(s_release_calls == 0, "TC-VL-009 fail-open 后 release 不调用 osMutexRelease（判空静默）");
/* --- 已创建时 wait 不再创建 --- */
fakes_reset();
(void)vol_lock_init();
(void)vol_lock_wait(0U);
(void)vol_lock_wait(0U);
CHECK(s_new_calls == 1, "TC-VL-010 多次 wait 不重复创建互斥量");
CHECK(s_wait_calls == 2, "TC-VL-010b 每次 wait 各等待一次");
}
/* ===================== TC-VL-011..013：vol_lock_release ===================== */
static void tc_release(void) {
/* --- 已持锁：释放一次 --- */
fakes_reset();
(void)vol_lock_init();
(void)vol_lock_wait(0U);
vol_lock_release();
CHECK(s_release_calls == 1, "TC-VL-011 已持锁时 release 调用 osMutexRelease 一次");
/* --- 锁未创建：静默返回 --- */
fakes_reset();
vol_lock_release();
CHECK(s_release_calls == 0, "TC-VL-012 锁未创建时 release 静默返回（不调用、不崩溃）");
/* --- 完整周期 --- */
fakes_reset();
CHECK(vol_lock_init() == 0, "TC-VL-013 周期：init -> 0");
CHECK(vol_lock_wait(0U) == 1, "TC-VL-013b 周期：wait -> 1");
vol_lock_release();
CHECK(vol_lock_wait(100U) == 1, "TC-VL-013c 周期：再 wait -> 1（可重复获取）");
vol_lock_release();
CHECK(s_new_calls == 1, "TC-VL-013d 周期：全程只创建一次互斥量");
CHECK(s_release_calls == 2, "TC-VL-013e 周期：释放两次");
CHECK(s_last_timeout == 100U, "TC-VL-013f 周期：第二次 wait 的 timeout 透传正确");
}
/* ===================== main ===================== */
int main(void) {
printf("=== Volume Lock Tests ===\n");
printf("-- vol_lock_init --\n");
tc_init();
printf("-- vol_lock_wait (incl. fail-open) --\n");
tc_wait();
printf("-- vol_lock_release --\n");
tc_release();
printf("\n=== Volume Lock Tests: %d/%d PASSED (failed=%d) ===\n",
s_passed, s_total, s_failed);
return (s_failed == 0) ? 0 : 1;
}