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

refactor(编号): 16 个测试模块码单词化 + 门禁识别面连带放宽

Browse Source 
批 2（用户授权改名 + 「新名要一眼看懂」裁定）
- 16 个有歧义模块码单词化，共 1,146 处随 scripts/rename_ids.py 改写：
  AI→ADCIN、AH→ADCHEALTH、PS→PROTSET、PE→PROTELEM、PH→PHASOR、
  TS→TIMESYNC、VL→VOLLOCK、NP→NANDPORT、CFG→CONFIG、CLK→SYSCLK、
  WD→WATCHDOG、STO→STORAGE、SH→SHA256、FA→FTPAUTH、FR→FREQ、104→IEC104
- 不动 NET/GD5F/RTC/SOE/UI/ADC/LOG/RS485/TOOL（已是单词、芯片名或业界通用词，
  改了纯属 churn）
- 别名按全局登记：这批字面量已完全限定（TC-<码>-<nnn>），不存在裸形多义
- 映射表存档 scripts/rename_maps/batch2.json 作审计轨迹；§6 模块码表同步

连带修门禁（关键教训）
- 模块码涨到 9 位（ADCHEALTH/WATCHDOG）后，候选正则与族正则的 {0,4} 上界
  会让改名后的号**整批从门禁眼里消失**：实测编号字面量从 8271 掉到 7315、
  悬空假降 490 处。已放宽到 {0,9} 并写进 §6 注记
- 结论：改名批次必须连带复核识别面，只改数据不改判据 = 静默放行；
  这次是靠「可判定比例跌破基线即失败」那条线拦下来的

现状与遗留
- 校验 1 未登记前缀 0 处；可判定比例 82.71%（基线 82.6%，只涨不跌成立）
- 遗留：7 个模块的「单元测试说明.md」仍缺（PROTSET 116、NANDPORT 109、
  PROTELEM 65、FREQ 48、FTPAUTH 45、SHA256 25、SOE 14 处悬空）——改名不解决
  缺文档，处置方式待议
- 遗留：T-2/T-3/T-4/T-6 历史任务号悬空（别名表未收全，属本工具批次漏项）
- 未改任何 C/H 可编译语义（仅注释与宏名内的编号），故不需 @build
This commit is contained in:
Wanderingss
2026-10-21 09:53:28 +08:00
parent 301c3e5183
commit bda7ab2b50
45 changed files with 3706 additions and 1295 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/host/time_sync/time_sync_test.c
+114 -114
View File
@@ -27,36 +27,36 @@
*
* 覆盖点（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）
* TC-TIMESYNC-001 0ms 不睡眠不喂狗
* TC-TIMESYNC-002 恰好一片（50ms）
* TC-TIMESYNC-003 非整片（120ms）切成 50/50/20，每片喂心跳
* TC-TIMESYNC-004 长延时（2000ms）= 40 片 × 50ms，每片喂心跳
* TC-TIMESYNC-005 不足一片（49ms）单片处理
* TC-TIMESYNC-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
* TC-TIMESYNC-010 首次成功：socket/bind/listen 各一次，端口经 net_htons，无退避
* TC-TIMESYNC-011 bind 失败 -> 关 socket + 退避 2000ms + 留痕，随后重试成功
* TC-TIMESYNC-012 listen 失败 -> 关 socket + 退避 2000ms，随后重试成功
* TC-TIMESYNC-013 socket 连续失败 -> 5 次后返回 -1（5 条 ERROR，5×500ms 退避）
* TC-TIMESYNC-014 第 3 次重试成功并返回新描述符
* TC-TIMESYNC-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 回绕 -> 预算计算仍正确
* TC-TIMESYNC-020 8 字节一次收齐 -> 大端解析 epoch + 更新墙钟 + 关连接
* TC-TIMESYNC-021 分段送达（4+4）-> 累积后解析；第二次只请求剩余 12 字节
* TC-TIMESYNC-022 一次到达 16 字节 -> 只取前 8 字节
* TC-TIMESYNC-023 前缀非 "TIME" -> 不更新墙钟，但仍关连接
* TC-TIMESYNC-024 对端关闭（n==0）-> 立即退出、不解析
* TC-TIMESYNC-025 真错误（n==-1）-> 立即退出、不解析
* TC-TIMESYNC-026 只收到 4 字节后 EOF -> 不足 8 字节不解析
* TC-TIMESYNC-027 30s 预算耗尽 -> 留痕 "no TIME packet in 30s, drop conn"
* TC-TIMESYNC-028 剩余预算不足一片 -> 末片按剩余（20ms）切分
* TC-TIMESYNC-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-TIMESYNC-040 sys_evtHandle==NULL：跳过就绪屏障；accept 轮询->成功->处理->收尾
* TC-TIMESYNC-041 就绪屏障：100ms 分片等待 NET_READY（osFlagsNoClear 不消费就绪位）
* TC-TIMESYNC-042 屏障未就绪期间持续喂心跳（2026-10-02 台架根因的回归防线）
* TC-TIMESYNC-043 网络代次变化 -> 关闭旧监听并重监听
* TC-TIMESYNC-044 监听建立失败 -> 5 次重试后放弃并退避 2000ms
*
* 通过：全部 TC PASS（main 返回 0）。
* 入口：int main(void)，返回 0=PASS / 1=FAIL（由 run 脚本判读）。
@@ -413,51 +413,51 @@ static int delays_all(uint32_t v, int n) {
return 1;
}
/* ===================== TC-TS-001..006：delay_fed ===================== */
/* ===================== TC-TIMESYNC-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) 不睡眠不喂狗");
CHECK((s_beat_calls == 0) && (s_delay_calls == 0), "TC-TIMESYNC-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 次心跳");
"TC-TIMESYNC-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_beat_calls == 3) && (s_delay_calls == 3), "TC-TIMESYNC-003 delay_fed(120) 切成 3 片");
CHECK((s_delays[0] == 50U) && (s_delays[1] == 50U) && (s_delays[2] == 20U),
"TC-TS-003b 片长 50/50/20（末片为余数）");
"TC-TIMESYNC-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，每片喂一次心跳");
"TC-TIMESYNC-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）单片处理");
CHECK((s_beat_calls == 1) && (s_delays[0] == 49U), "TC-TIMESYNC-005 不足一片（49ms）单片处理");
fakes_reset();
time_sync_delay_fed(30000U);
CHECK(s_delay_calls == 600, "TC-TS-006 总预算 30s = 600 片（片长上限恒 50ms）");
CHECK(s_delay_calls == 600, "TC-TIMESYNC-006 总预算 30s = 600 片（片长上限恒 50ms）");
}
/* ===================== TC-TS-010..015：open_listener ===================== */
/* ===================== TC-TIMESYNC-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 == 5, "TC-TIMESYNC-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 成功路径无退避延时");
"TC-TIMESYNC-010b socket / bind / listen 各一次");
CHECK(s_htons_last == (uint16_t)TIME_SYNC_PORT, "TC-TIMESYNC-010c 端口经 net_htons(8888)");
CHECK(s_bind_port == net_htons((uint16_t)TIME_SYNC_PORT), "TC-TIMESYNC-010d sin_port 为网络序");
CHECK(s_bind_family == (uint16_t)NET_AF_INET, "TC-TIMESYNC-010e sin_family = NET_AF_INET");
CHECK(s_delay_calls == 0, "TC-TIMESYNC-010f 成功路径无退避延时");
}
fakes_reset();
@@ -465,10 +465,10 @@ static void tc_open_listener(void) {
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");
CHECK(s == 5, "TC-TIMESYNC-011 bind 失败一次后重试成功");
CHECK((s_close_calls == 1) && (s_close_socks[0] == 5), "TC-TIMESYNC-011b bind 失败关闭该 socket");
CHECK(s_delay_calls == 40, "TC-TIMESYNC-011c bind 失败退避 2000ms（40 片）");
CHECK(g_tstest_err_count == 1, "TC-TIMESYNC-011d bind 失败留痕 DBG_ERROR");
}
fakes_reset();
@@ -476,19 +476,19 @@ static void tc_open_listener(void) {
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");
CHECK(s == 5, "TC-TIMESYNC-012 listen 失败一次后重试成功");
CHECK((s_close_calls == 1) && (s_close_socks[0] == 5), "TC-TIMESYNC-012b listen 失败关闭该 socket");
CHECK(s_delay_calls == 40, "TC-TIMESYNC-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 片）");
CHECK(s == -1, "TC-TIMESYNC-013 socket 连续失败 -> 返回 -1");
CHECK(s_socket_calls == 5, "TC-TIMESYNC-013b 重试上限 5 次");
CHECK(g_tstest_err_count == 5, "TC-TIMESYNC-013c 每次失败各留痕一条（5 条 DBG_ERROR）");
CHECK(s_delay_calls == 50, "TC-TIMESYNC-013d 每次失败退避 500ms（5 × 10 片）");
}
fakes_reset();
@@ -498,23 +498,23 @@ static void tc_open_listener(void) {
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");
CHECK(s == 9, "TC-TIMESYNC-014 第 3 次重试成功并返回新描述符");
CHECK(s_socket_calls == 3, "TC-TIMESYNC-014b 恰好尝试 3 次");
CHECK(s_delay_calls == 20, "TC-TIMESYNC-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");
CHECK(s_beat_calls == 55, "TC-TIMESYNC-015 每轮重试(5) + 每片延时(50) 各喂一次心跳");
CHECK(s_beat_id_bad == 0, "TC-TIMESYNC-015b 心跳位恒为 TASK_WD_TIMESYNC");
}
/* ===================== TC-TS-020..029：handle_conn =====================
/* ===================== TC-TIMESYNC-020..029：handle_conn =====================
* ⚠ 契约变更：handle_conn **不再** net_close
* （单连接模式下 conn==listen，close 会连监听一起毁）；会话收尾只返回外层，
* 由 time_sync_task 在 `conn != ls`（模拟器多连接后端）时才关数据 fd。
* 故本组断言一律为 s_close_calls == 0；任务级关闭见 TC-TS-040e。 */
* 故本组断言一律为 s_close_calls == 0；任务级关闭见 TC-TIMESYNC-040e。 */
static void tc_handle_conn(void) {
uint8_t pkt[16];
@@ -526,13 +526,13 @@ static void tc_handle_conn(void) {
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 == 0, "TC-TS-020e 处理完**不**关闭连接（close 交外层 conn!=ls 分支）");
CHECK(s_drop_calls == 0, "TC-TS-020g 成功会话不拆（drop 只用于放弃路径）");
CHECK(g_tstest_info_count == 1, "TC-TS-020f 留痕 wall clock updated");
CHECK(s_set_unix_calls == 1, "TC-TIMESYNC-020 TIME 包一次收齐 -> 更新墙钟一次");
CHECK(s_set_unix_last == 0x12345678u, "TC-TIMESYNC-020b epoch 按大端解析");
CHECK((s_recv_calls == 1) && (s_recv_len_log[0] == 16), "TC-TIMESYNC-020c 首次请求 16 字节");
CHECK(s_recv_to_log[0] == 50U, "TC-TIMESYNC-020d 单次等待片长 = 50ms");
CHECK(s_close_calls == 0, "TC-TIMESYNC-020e 处理完**不**关闭连接（close 交外层 conn!=ls 分支）");
CHECK(s_drop_calls == 0, "TC-TIMESYNC-020g 成功会话不拆（drop 只用于放弃路径）");
CHECK(g_tstest_info_count == 1, "TC-TIMESYNC-020f 留痕 wall clock updated");
/* 2) 分段送达：4 + 4 */
fakes_reset();
@@ -541,11 +541,11 @@ static void tc_handle_conn(void) {
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_set_unix_calls == 1) && (s_set_unix_last == 10u), "TC-TIMESYNC-021 分段送达累积后解析正确");
CHECK(s_recv_calls == 2, "TC-TIMESYNC-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（预算充裕）");
"TC-TIMESYNC-021c 第二次只请求剩余 12 字节");
CHECK((s_recv_to_log[0] == 50U) && (s_recv_to_log[1] == 50U), "TC-TIMESYNC-021d 每片 50ms（预算充裕）");
/* 3) 16 字节一次到达（只取前 8） */
fakes_reset();
@@ -553,8 +553,8 @@ static void tc_handle_conn(void) {
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 一次读够即停");
CHECK((s_set_unix_calls == 1) && (s_set_unix_last == 5u), "TC-TIMESYNC-022 超长包只取前 8 字节");
CHECK(s_recv_calls == 1, "TC-TIMESYNC-022b 一次读够即停");
/* 4) 前缀不是 TIME */
fakes_reset();
@@ -569,23 +569,23 @@ static void tc_handle_conn(void) {
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 == 0, "TC-TS-023b 非 TIME 前缀也不关闭连接");
CHECK(s_set_unix_calls == 0, "TC-TIMESYNC-023 非 TIME 前缀不更新墙钟");
CHECK(s_close_calls == 0, "TC-TIMESYNC-023b 非 TIME 前缀也不关闭连接");
/* 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 == 0, "TC-TS-024b EOF 也不关闭连接（net 层 auto_relisten 收口监听）");
CHECK((s_set_unix_calls == 0) && (s_recv_calls == 1), "TC-TIMESYNC-024 对端关闭(EOF)立即退出不解析");
CHECK(s_close_calls == 0, "TC-TIMESYNC-024b EOF 也不关闭连接（net 层 auto_relisten 收口监听）");
/* 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 真错误立即退出不解析");
CHECK((s_recv_calls == 1) && (s_set_unix_calls == 0), "TC-TIMESYNC-025 真错误立即退出不解析");
/* 7) 4 字节后 EOF */
fakes_reset();
@@ -594,27 +594,27 @@ static void tc_handle_conn(void) {
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 继续等待后续字节");
CHECK(s_set_unix_calls == 0, "TC-TIMESYNC-026 不足 8 字节不解析");
CHECK(s_recv_calls == 2, "TC-TIMESYNC-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 == 0, "TC-TS-027c 预算耗尽也不关闭连接");
CHECK(s_drop_calls == 1, "TC-TS-027d 预算耗尽主动拆会话（E-02 收口：net_drop_conn 拆连接保监听）");
CHECK(s_recv_calls == 1, "TC-TIMESYNC-027 预算耗尽后不再读（只读 1 次）");
CHECK(g_tstest_info_count == 1, "TC-TIMESYNC-027b 留痕 no TIME packet in 30s, drop conn");
CHECK(s_close_calls == 0, "TC-TIMESYNC-027c 预算耗尽也不关闭连接");
CHECK(s_drop_calls == 1, "TC-TIMESYNC-027d 预算耗尽主动拆会话（E-02 收口：net_drop_conn 拆连接保监听）");
/* 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_calls == 2, "TC-TIMESYNC-028 两次等待后结束");
CHECK((s_recv_to_log[0] == 50U) && (s_recv_to_log[1] == 20U),
"TC-TS-028b 第二次片长 = 剩余 20ms");
"TC-TIMESYNC-028b 第二次片长 = 剩余 20ms");
/* 10) 32 位 tick 回绕 */
fakes_reset();
@@ -623,10 +623,10 @@ static void tc_handle_conn(void) {
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-TIMESYNC-029 32 位 tick 回绕后预算计算仍正确");
}
/* ===================== TC-TS-040..044：time_sync_task ===================== */
/* ===================== TC-TIMESYNC-040..044：time_sync_task ===================== */
static void tc_task(void) {
uint8_t pkt[16];
@@ -646,15 +646,15 @@ static void tc_task(void) {
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 位");
"TC-TIMESYNC-040 任务入口登记心跳位（task_wd_bind 一次）");
CHECK(s_evt_calls == 0, "TC-TIMESYNC-040b sys_evtHandle==NULL 时跳过就绪屏障");
CHECK(s_accept_calls == 3, "TC-TIMESYNC-040c accept 轮询 3 次（2 次无连接 + 1 次成功）");
CHECK((s_set_unix_calls == 1) && (s_set_unix_last == 9u), "TC-TIMESYNC-040d 收到时间包并更新墙钟");
CHECK(s_close_calls == 1, "TC-TIMESYNC-040e 连接被关闭一次");
CHECK(s_delay_calls == 9, "TC-TIMESYNC-040f 延时片数 = 4+4+1（200+200+50ms）");
CHECK(delays_all(50U, 9), "TC-TIMESYNC-040g 所有延时均按 50ms 分片");
CHECK(s_beat_calls == 13, "TC-TIMESYNC-040h 心跳次数 = 主循环1 + 退避8 + 收连接1 + 收尾1 + 次轮1");
CHECK(s_beat_id_bad == 0, "TC-TIMESYNC-040i 所有心跳均打 TIMESYNC 位");
/* B) 就绪屏障：2 次未就绪 + 1 次就绪 */
fakes_reset();
@@ -667,12 +667,12 @@ static void tc_task(void) {
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 仍先登记心跳路由");
CHECK(s_evt_calls == 3, "TC-TIMESYNC-041 就绪屏障轮询 3 次（2 次未就绪 + 1 次就绪）");
CHECK(s_evt_last_timeout == 100U, "TC-TIMESYNC-041b 屏障等待按 100ms 分片");
CHECK(s_evt_last_flags == SYS_EVT_NET_READY, "TC-TIMESYNC-041c 等待 NET_READY 位");
CHECK(s_evt_last_options == (osFlagsWaitAny | osFlagsNoClear), "TC-TIMESYNC-041d 就绪位不被消费");
CHECK(s_beat_calls == 3, "TC-TIMESYNC-041e 未就绪的两次各喂一次心跳（+主循环 1 次）");
CHECK(s_wd_bind_calls == 1, "TC-TIMESYNC-041f 仍先登记心跳路由");
/* C) 屏障期间持续喂心跳（就绪位长期不置位） */
fakes_reset();
@@ -682,8 +682,8 @@ static void tc_task(void) {
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 次跳出前）");
CHECK(s_evt_calls == 4, "TC-TIMESYNC-042 屏障等待 4 次均未就绪（循环未挂死）");
CHECK(s_beat_calls == 3, "TC-TIMESYNC-042b 每次未就绪后各喂一次心跳（第 4 次跳出前）");
/* D) 网络代次变化 -> 关闭旧监听并重监听 */
fakes_reset();
@@ -695,12 +695,12 @@ static void tc_task(void) {
if (setjmp(s_jmp) == 0) {
time_sync_task(NULL);
}
CHECK((s_close_calls == 1) && (s_close_socks[0] == 5), "TC-TS-043 代次变化时关闭旧监听");
CHECK((s_close_calls == 1) && (s_close_socks[0] == 5), "TC-TIMESYNC-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(g_tstest_info_count == 3, "TC-TIMESYNC-043b 留痕 network re-init, relisten（另含 2 条 listen 成功）");
CHECK(s_accept_calls == 2, "TC-TIMESYNC-043c 每次循环只轮询一次 accept 即放弃");
CHECK((s_socket_calls == 2) && (s_bind_calls == 2) && (s_listen_calls == 2),
"TC-TS-043d 第二次循环重建了监听");
"TC-TIMESYNC-043d 第二次循环重建了监听");
/* E) 监听建立失败 -> 5 次重试后放弃并退避 2000ms */
fakes_reset();
@@ -709,11 +709,11 @@ static void tc_task(void) {
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 位");
CHECK(s_socket_calls == 5, "TC-TIMESYNC-044 open_listener 内部重试 5 次后放弃");
CHECK(g_tstest_err_count == 6, "TC-TIMESYNC-044b 5 条 net_socket FAIL + 1 条 retry later");
CHECK(s_delay_calls == 90, "TC-TIMESYNC-044c 退避 5×500ms + 2000ms = 90 片");
CHECK(s_beat_calls == 97, "TC-TIMESYNC-044d 心跳次数 = 2 + 5 + 50 + 40");
CHECK(s_beat_id_bad == 0, "TC-TIMESYNC-044e 所有心跳均打 TIMESYNC 位");
}
/* ===================== main ===================== */