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

test(host): P2 覆盖率批次，5 套主机单测与共享假 FatFs

Browse Source 
P2 五个文件全部进分母（三名队友并行，写范围互斥、零越界）：
  net_socket 420 条 / 881-883=99.8%、52-52 函数（S1~S6 分片）
  sys_log_mcu 75 条 / 310-313=99.0%、12-12
  console_log 104 条 / 188-189=99.5%、15-15
  cfg_file_store_mcu 34 条 / 97-97=100%、10-10
  soe_store 26 条 / 78-79=98.7%、4-4
合计 659 条断言，P2 本体 1554-1561=99.6%、93-93 函数。

账：套件 28→33 全绿；files_tested 32→37；未触及 112→107（.c 34→29，
恒等式 29 = 0(P1剩) + 0(P2) + 29(P3) 咬合，§9 终点判据达成）；分母
4684→6245 插桩行；line 85.8%→89.3%；func 90.1%→92.2%（这批 5 个文件
全都以 ≥98.7% 进分母，故未摊薄）。--update-baseline 前后逐文件比对：
下降 0 个文件。

基建：新建 test/host/common/fatfs_fake.{h,c}（以真实 ff.h 为声明源、只
定义三文件实际调用的 9 个 f_*，缺哪个链接期响；卷忙/短写/FR_DENIED
可注入；短名违规分档）；扩展 ch395f_fake 为纯新增（g_fx/g_fxchip 另开
一份世界 + ext_reset 挂进既有复位，既有三套面一字不动），并按真头修正
两个错值常量（SOCKET_OPEN 0x01→0x05、TCP_ESTABLISHED 0x05→0x04），
另在 net_socket runner 加真头/假件同名常量文本核对闸（负例验证过）。
存量回归：net_listener 34、net_events 34、net_pending 43、net_select 22、
nand_port 149、lftpd_io 33、vol_lock 33、soe 32、cfg_file 151 全绿。

编号：补 TC-HOST-{NETSOCK,SYSLOG,CFGFST,SOESTORE,CONLOG} 五族（22→27，
先补族再引号）；net_socket 模块码由自取的两字母 NS 正名为 NETSOCK；
id-check 增量拦截无台账外新账，可判定比例 83.27%（基线 82.6%）。

文档：覆盖率口径 §9 新增「P2 落地」（含两套分母口径差、10 条现状表、
12 条可复用手法与并发红线），§8 第 1 条改「清单已吃穿」，补变更记录。
本提交未改任何生产代码（App/Drivers/Src/Lib/MDK-ARM 零触碰）。

10 条现状已逐条登记在 §9（含 sys_log_mcu.c:509~537 卷忙整批丢日志、
net_socket.c 同文件两套 IP 字节序、UDP 两 API 绕过 netTask），已获指示
全部修复，另开一轮（含测试字面量统一纯 ASCII）。

gate: pre-commit run --all-files → 39 hooks, 38 Passed; only mem-numbers
Failed（本工作树从未 @build，无 .map 事实源，属分支期已知陷阱）；
mem-budget Passed；test-coverage 与 id-check Passed。RAM/Flash 增量 = 0
（纯测试批次）。按仓内分支约定走 --no-verify，台账回填留待主树合并后。
This commit is contained in:
Wanderingss
2026-10-24 17:54:02 +08:00
parent 4ac869058d
commit 794906cdc8
46 changed files with 10821 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/host/common/ch395f_fake.c
+403 -2
View File
@@ -9,8 +9,13 @@
#include "ch395f_fake.h"
/* 时基：假复位机的最短沉降窗要用（与真实 main.h 同名同签名，各测试 TU 自带实现） */
uint32_t HAL_GetTick(void);
ch395f_fake_world_t g_fake;
ch395f_fake_obs_t g_chip;
ch395f_fake_ext_t g_fx;
ch395f_fake_ext_obs_t g_fxchip;
static void fake_log(char c)
{
@@ -35,6 +40,33 @@ void ch395f_fake_reset(void)
g_fake.open_rc[i] = CH395F_ERR_SUCCESS;
g_fake.listen_rc[i] = CH395F_ERR_SUCCESS;
}
/* 扩展区（net_socket 批次新增）：同一次复位里一并清零，避免场景间残留 */
ch395f_fake_ext_reset();
}
/* 扩展面的复位：默认"芯片在位、复位/协议栈初始化成功、版本够新、复位机全 IDLE" */
void ch395f_fake_ext_reset(void)
{
int i;
(void)memset(&g_fx, 0, sizeof(g_fx));
(void)memset(&g_fxchip, 0, sizeof(g_fxchip));
g_fx.exist_rc = (int)CH395F_STATUS_OK;
g_fx.reset_rc = (int)CH395F_STATUS_OK;
g_fx.init_rc = (int)CH395F_STATUS_OK;
g_fx.version = 0x46U; /* 台架实测芯片版本（版本门控的默认通过值）*/
g_fx.phy_status = 0x08U; /* PHY 100M_FULL（非 DISCONN，glob_event_feed 判 link up）*/
for (i = 0; i < CH395F_FAKE_SOCK_MAX; i++) {
g_fx.connect_rc[i] = CH395F_ERR_SUCCESS;
g_fx.rst_state[i] = (uint8_t)CH395F_FAKE_RST_IDLE;
}
}
void ch395f_fake_push_glob(uint16_t v)
{
if (g_fx.glob_n < CH395F_FAKE_GLOB_QUEUE) {
g_fx.glob_q[g_fx.glob_n++] = v;
}
}
void ch395f_fake_push_recv_len(uint8_t sock, uint16_t v)
@@ -94,7 +126,9 @@ void ch395f_get_socket_status(uint8_t sock, uint8_t *status)
}
}
/* 整体读即清：返回后该 socket 的挂起位图清零（真实芯片没有按位清除手段） */
/* 整体读即清：返回后该 socket 的挂起位图清零（真实芯片没有按位清除手段）。
* 唯一新增：清完立刻回填**电平型**掩码 sint_sticky（默认全 0 → 与既有行为逐字相同，
* net_listener / net_events / net_pending 三套不受影响）。 */
uint8_t ch395f_get_sock_int_status(uint8_t sock)
{
uint8_t v = 0U;
@@ -104,11 +138,37 @@ uint8_t ch395f_get_sock_int_status(uint8_t sock)
fake_log('i');
if (sock < CH395F_FAKE_SOCK_MAX) {
v = g_fake.int_status[sock];
g_fake.int_status[sock] = 0U;
g_fake.int_status[sock] = g_fx.sint_sticky[sock];
}
return v;
}
void ch395f_fake_clear_log(void)
{
(void)memset(g_chip.log, 0, sizeof(g_chip.log));
g_chip.log_n = 0;
}
int ch395f_fake_log_find(char c1)
{
int i;
for (i = 0; i < g_chip.log_n; i++) {
if (g_chip.log[i] == c1) {
return i;
}
}
return -1;
}
void ch395f_fake_set_sint_sticky(uint8_t sock, uint8_t mask)
{
if (sock < CH395F_FAKE_SOCK_MAX) {
g_fx.sint_sticky[sock] = mask;
g_fake.int_status[sock] |= mask;
}
}
uint16_t ch395f_get_recv_len(uint8_t sock)
{
uint16_t v;
@@ -215,3 +275,344 @@ uint16_t ch395f_link_change_count(void)
{
return g_fake.link_change;
}
/* =========================================================================
* 扩展区实现（net_socket 主机单测批次；纯新增，上面既有实现一字未动）
* 签名逐字抄自 Drivers/BSP/CH395F/ch395f.h。
* ========================================================================= */
ch395f_status_t ch395f_check_exist(void)
{
g_fxchip.exist_calls++;
fake_log('E');
return (ch395f_status_t)g_fx.exist_rc;
}
ch395f_status_t ch395f_reset(void)
{
g_fxchip.reset_calls++;
fake_log('Z');
return (ch395f_status_t)g_fx.reset_rc;
}
ch395f_status_t ch395f_init(void)
{
g_fxchip.init_calls++;
fake_log('n');
return (ch395f_status_t)g_fx.init_rc;
}
uint8_t ch395f_get_version(void)
{
return g_fx.version;
}
void ch395f_set_fun_para(uint32_t para)
{
g_fxchip.set_fun_para_calls++;
g_fx.fun_para = para;
fake_log('F');
}
void ch395f_set_tcp_mss(uint16_t mss)
{
g_fxchip.set_mss_calls++;
g_fx.mss = mss;
fake_log('Q');
}
void ch395f_set_retrans_count(uint8_t cnt)
{
g_fxchip.set_retrans_calls++;
g_fx.retrans_cnt = cnt;
}
void ch395f_set_retrans_period(uint16_t period)
{
g_fx.retrans_period = period;
}
void ch395f_set_keepalive_idle(uint32_t time)
{
g_fxchip.set_ka_calls++;
g_fx.ka_idle = time;
}
void ch395f_set_keepalive_intvl(uint32_t time)
{
g_fx.ka_intvl = time;
}
void ch395f_set_keepalive_cnt(uint8_t cnt)
{
g_fx.ka_cnt = cnt;
}
void ch395f_set_dhcp(uint8_t enable)
{
g_fxchip.set_dhcp_calls++;
g_fx.dhcp_enable = enable;
fake_log('D');
}
void ch395f_ping_enable(uint8_t enable)
{
g_fxchip.ping_calls++;
g_fx.ping_enable = enable;
}
void ch395f_set_ip_addr(uint8_t *p_ip)
{
g_fxchip.set_ip_calls++;
fake_log('I');
if (p_ip != NULL) {
(void)memcpy(g_fx.ip, p_ip, 4U);
}
}
void ch395f_set_gwip_addr(uint8_t *p_gwip)
{
g_fxchip.set_gw_calls++;
fake_log('N');
if (p_gwip != NULL) {
(void)memcpy(g_fx.gw, p_gwip, 4U);
}
}
void ch395f_set_mask_addr(uint8_t *p_mask)
{
g_fxchip.set_mask_calls++;
fake_log('K');
if (p_mask != NULL) {
(void)memcpy(g_fx.mask, p_mask, 4U);
}
}
void ch395f_set_mac_addr(uint8_t *p_mac)
{
g_fxchip.set_mac_calls++;
fake_log('M');
if (p_mac != NULL) {
(void)memcpy(g_fx.mac, p_mac, 6U);
}
}
void ch395f_set_send_buf(uint8_t sock, uint8_t start_block, uint8_t block_count)
{
g_fxchip.set_send_buf_calls++;
fake_log('b');
if (sock < CH395F_FAKE_SOCK_MAX) {
g_fx.send_blk_start[sock] = start_block;
g_fx.send_blk_cnt[sock] = block_count;
}
}
void ch395f_set_recv_buf(uint8_t sock, uint8_t start_block, uint8_t block_count)
{
g_fxchip.set_recv_buf_calls++;
fake_log('u');
if (sock < CH395F_FAKE_SOCK_MAX) {
g_fx.recv_blk_start[sock] = start_block;
g_fx.recv_blk_cnt[sock] = block_count;
}
}
void ch395f_set_des_ip(uint8_t sock, uint8_t *p_ip)
{
g_fxchip.set_des_ip_calls++;
fake_log('e');
if ((sock < CH395F_FAKE_SOCK_MAX) && (p_ip != NULL)) {
(void)memcpy(g_fx.des_ip[sock], p_ip, 4U);
}
}
void ch395f_set_des_port(uint8_t sock, uint16_t port)
{
g_fxchip.set_des_port_calls++;
fake_log('q');
if (sock < CH395F_FAKE_SOCK_MAX) {
g_fx.des_port[sock] = port;
}
}
uint8_t ch395f_tcp_connect(uint8_t sock)
{
g_fxchip.connect_calls++;
g_chip.last_sock = sock;
fake_log('T');
return (sock < CH395F_FAKE_SOCK_MAX) ? g_fx.connect_rc[sock] : 0x01U;
}
uint8_t ch395f_get_phy_status(void)
{
fake_log('g');
return g_fx.phy_status;
}
/* 全局中断状态（0x19，2 字节）：**整体读即清**，且含全部 Socket 位——
* 假件按调用序号返回预置值（耗尽后回落最后一个），并单独计数（B3 唯一读者=net_poll） */
uint16_t ch395f_get_glob_int_status_all(void)
{
uint16_t v = 0U;
g_fxchip.glob_calls++;
fake_log('G');
if (g_fx.glob_n == 0) {
v = 0U;
} else if (g_fx.glob_i < g_fx.glob_n) {
v = g_fx.glob_q[g_fx.glob_i++];
} else {
v = g_fx.glob_q[g_fx.glob_n - 1];
}
g_fxchip.glob_bits = (int)v;
return v;
}
/* 与真实驱动同判据：只有 PHY_CHANGE 位才回读 PHY；链路电平变了才计一次变更 */
void ch395f_glob_event_feed(uint16_t glob_bits)
{
uint8_t up;
if ((glob_bits & CH395F_GINT_STAT_PHY_CHANGE) == 0U) {
return;
}
up = (ch395f_get_phy_status() != CH395F_PHY_DISCONN) ? 1U : 0U;
if (up != g_fake.link_up) {
g_fake.link_up = up;
g_fake.link_change++;
}
}
/* 只读本 Socket 的 SINT（读即清），永不碰全局寄存器——与真实护栏原语同语义 */
uint8_t ch395f_sock_events(uint8_t sn)
{
g_fxchip.sock_events_calls++;
return ch395f_get_sock_int_status(sn);
}
/* —— sock_reset 复位机（契约等价：四步 + 最短沉降窗 + 二段 CLOSE 补发）——
* 与驱动一致的**可断言点**：begin 重复启动必须被拒；GRACEFUL 满 100ms、
* QUARANTINE 满 400ms 才继续；quiescent 要连续 2 轮无事件；byte0 回 00H 才算完成；
* 芯片 byte0=05H 且 TCP=00H 时补发第二段 CLOSE。
* 不复制驱动的超时数值细节（那是驱动自己的单测面），本假件不自造失败：
* 想测超时由测试把 cached_open 一直留成 OPEN，由上层 net_sock_reset_sync 的 600ms 收口。 */
int ch395f_sock_reset_begin(uint8_t sn, ch395f_reset_mode_t mode)
{
g_fxchip.rst_begin_calls++;
fake_log('X');
if (sn >= CH395F_FAKE_SOCK_MAX) {
return -1;
}
if (g_fx.rst_state[sn] != (uint8_t)CH395F_FAKE_RST_IDLE) {
g_fxchip.rst_begin_reject++;
return -1;
}
g_fx.rst_state[sn] = (uint8_t)CH395F_FAKE_RST_DRAINED;
g_fx.rst_mode[sn] = (mode == CH395F_RESET_QUARANTINE) ? 1U : 0U;
g_fx.rst_t0[sn] = HAL_GetTick();
g_fx.rst_quiet[sn] = 0U;
return 0;
}
int ch395f_sock_reset_poll(uint8_t sn)
{
uint32_t now;
uint32_t el;
uint32_t need;
g_fxchip.rst_poll_calls++;
fake_log('x');
if (sn >= CH395F_FAKE_SOCK_MAX) {
return -1;
}
if (g_fx.rst_state[sn] == (uint8_t)CH395F_FAKE_RST_IDLE) {
return 0; /* 未启动/已完成：幂等 */
}
now = HAL_GetTick();
el = now - g_fx.rst_t0[sn];
switch (g_fx.rst_state[sn]) {
case CH395F_FAKE_RST_DRAINED:
/* 第 1 步：读空 RX；第 2 步：CLOSE */
if (ch395f_get_recv_len(sn) != 0U) {
uint8_t scratch[8];
g_fxchip.rst_rx_discard_calls++;
ch395f_read_recv_buf(sn, scratch, 8U);
}
g_fxchip.rst_close_calls++;
(void)ch395f_close_socket(sn);
if (g_fx.rst_keep_open[sn] == 0U) {
g_fake.cached_open[sn] = CH395F_SOCKET_CLOSED;
g_fake.cached_tcp[sn] = CH395F_TCP_CLOSED;
}
g_fx.rst_state[sn] = (uint8_t)CH395F_FAKE_RST_MINWAIT;
g_fx.rst_t0[sn] = now;
break;
case CH395F_FAKE_RST_MINWAIT:
need = (g_fx.rst_mode[sn] != 0U) ? 400U : 100U;
if (el >= need) {
g_fx.rst_state[sn] = (uint8_t)CH395F_FAKE_RST_QUIET;
g_fx.rst_t0[sn] = now;
g_fx.rst_quiet[sn] = 0U;
}
break;
case CH395F_FAKE_RST_QUIET:
if (ch395f_sock_events(sn) == 0U) {
g_fx.rst_quiet[sn]++;
if (g_fx.rst_quiet[sn] >= CH395F_FAKE_RST_QUIESCENT) {
g_fx.rst_state[sn] = (uint8_t)CH395F_FAKE_RST_WAITCLS;
g_fx.rst_t0[sn] = now;
}
} else {
g_fx.rst_quiet[sn] = 0U;
}
break;
case CH395F_FAKE_RST_WAITCLS:
if (ch395f_cmd_done(sn, CH395F_DONE_CLOSE) == 1) {
g_fx.rst_state[sn] = (uint8_t)CH395F_FAKE_RST_IDLE;
g_fxchip.rst_done[sn]++;
return 0;
}
/* 二段 CLOSE 补发（LISTEN 态一次 CLOSE 只拆监听，byte0 恒 05H） */
if ((g_fake.cached_open[sn] == CH395F_SOCKET_OPEN) &&
(g_fake.cached_tcp[sn] == CH395F_TCP_CLOSED) &&
(g_fx.rst_quiet[sn] != 0xFFU)) {
g_fx.rst_quiet[sn] = 0xFFU;
g_fxchip.rst_close_calls++;
(void)ch395f_close_socket(sn);
if (g_fx.rst_keep_open[sn] == 0U) {
g_fake.cached_open[sn] = CH395F_SOCKET_CLOSED;
g_fake.cached_tcp[sn] = CH395F_TCP_CLOSED;
}
}
break;
default:
g_fx.rst_state[sn] = (uint8_t)CH395F_FAKE_RST_IDLE;
g_fxchip.rst_fail[sn]++;
return -1;
}
return 1;
}
int ch395f_cmd_done(uint8_t sn, ch395f_done_what_t what)
{
ch395f_sock_state_t st;
g_fxchip.cmd_done_calls++;
g_fxchip.last_cmd_done_what = (uint8_t)what;
fake_log('z');
if (sn >= CH395F_FAKE_SOCK_MAX) {
return -1;
}
st = ch395f_get_sock_state(sn);
switch (what) {
case CH395F_DONE_OPEN:
return (st.open == CH395F_SOCKET_OPEN) ? 1 : 0;
case CH395F_DONE_LISTEN:
return (st.open == CH395F_SOCKET_OPEN && st.tcp_state == CH395F_TCP_LISTEN) ? 1 : 0;
case CH395F_DONE_CLOSE:
return (st.open == CH395F_SOCKET_CLOSED) ? 1 : 0;
default:
return -1;
}
}