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

fix(编号): 批 6 追溯器分档 + 板级 NET 用例号标注归一

Browse Source 
步骤 1：追溯器分两档（不改数据，改判据）
- BENCH：文档**定义行**（标题行或表格首格）带「（硬件层）」或其所属章节带的号 →
  人工台架用例，不期望有 C 代码载体；NOTIMPL：定义行标了未实现/待补/暂缓/已取消
- 两档**单列示数恒打印**、明细进 --verbose，不是静默豁免；也不等于"已验证"
- 两个实测坑写在脚本注释里：① 按"任意行出现即算"实现时 BENCH 收 14 个号却只消掉
  1 处差异（同一号被别处引用一次就复活）→ 改为只认定义行 + 从文档全集整体减档；
  ② 载体类型必须由定义处决定，引用行不影响判断
- 另把 has_intent() 收窄到同号所在行（原先整文件任意位置有人话就算过关）

步骤 2：板级 NET 用例标注归一（真债，改名 109 处 / 5 文件）
- 取证发现"文档声明却无载体"绝大多数是**标注形态烂**：实现体里写的是
  TC204 / TC-201 / TC 703 / TC1501 / TC1502b（三种畸形），文档写 TC-NET-204 等
- 序号一位不改、只补模块码（§7.1）；作用域限定 5 个真载体文件：
  test/board/ch395f_test_task.c(67) net_test_task.c(37) net_test_task.h(1)
  test/host/ch395f_socket_test.py(3) Drivers/BSP/CH395F/ch395f.c(1)
- 审计轨迹 scripts/rename_maps/batch6-net-annotate.json；别名自动登记（scoped）

实测
- DOC-ONLY 29 → 15：701~704 的 NET 层实现体一直存在（net_test_task.c），
  此前因裸形标注被误判成"未实现"；1501~1503 属硬件层人工 + 同样裸形
- 交集 260 不变、代码侧 578 不减（识别面没缩）；BENCH 14 个号 / NOTIMPL 1 个
- 台账 --prune-backlog 还清 6 条（只减不增）；@build 0 错误 0 警告
  （Program Size 与改前逐字节相同：Code=213356 RO=18580 RW=1184 ZI=131480
   → 证实只动了注释与日志串）；7 个改动文件 BOM/CR/U+FFFD 与 HEAD 逐项一致

剩余 15 处 DOC-ONLY 的组成（步骤 3 未完，下轮处理）
- 4 处文档侧无模块码形态（TC-1003/206/501/704）→ 属 ② 大批
- TC-NET-607 一条是历史指称（原文"原 607/608/609，现 701/702/703"）
- 真未实现 10 条：TC-NET-101/102/601/606/801/802/901/902/1006/1101
  ——其中 801/802/901/902 曾在 2026-08 的代码里有载体、后被重构丢掉，最值得补
This commit is contained in:
Wanderingss
2026-10-21 13:53:06 +08:00
parent 43fbfa140b
commit fca414102e
9 changed files with 478 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Drivers/BSP/CH395F/ch395f.c
+1 -1
View File
@@ -1671,7 +1671,7 @@ int ch395f_sock_reset_poll(uint8_t sn) {
p->state = CH395F_RST_ST_IDLE;
return 0;
}
/* 二段关闭实证（TC1501 台架 2026-10-13）：LISTEN 态 Socket 的 CLOSE 返
/* 二段关闭实证（TC-NET-1501 台架 2026-10-13）：LISTEN 态 Socket 的 CLOSE 返
* SUCCESS 但只拆监听（TCP 01->00），byte0 恒 05；需再发一次 CLOSE 才落
* 00（生产 net 层靠 TRAP-NET-09 open 重试吸收此行为）。复位状态机自行补发，
* 补发标记=drain 字段置 0xF（本阶段已用尽，复用安全）。 */
scripts/check_test_traceability.py
+44 -1
View File
@@ -27,6 +27,7 @@
② 代码有、母号不在文档、**且号旁边没写人话意图** → CODE-ONLY（真未登记）；
③ 代码有、靠"旁边有意图"放过 → 单独打印为 IN-CODE，**弱于文档**，不算已登记。
小写子项后缀（`TC-XXX-003b`）按母号算（`subitem_ok`），与编号门禁同口径。
**批 6 再分两档**：硬件层人工用例（标题/章节含「（硬件层）」）记为 `BENCH`、文档已标未实现/待补/暂缓/已取消的记为 `NOTIMPL`，两者**单列示数**不进差异——但也不是「已覆盖」，只是「不该在这里期望代码」。
**2026-10-21 第二次口径修正（批 5）**：变更记录行与 `[示例]`/`[计划]` 行**不参与比对**
（冻结历史按编号规范 §8.1 不回改，旧号靠 `id_aliases.json` 解析；这条豁免另三支脚本早有，本脚本是最后缺它的一个，`DOC-ONLY` 因此 38 → 29、交集不变）；被豁免的号存进 `frozen_ids`，`--verbose` 全量列出——**豁免不等于已对应**，别拿它当收敛。
@@ -74,6 +75,22 @@ PLACEHOLDER_PREFIXES = {"XXX"}
# 该号在批 2 已随代码改名成 TC-ADCIN-*，历史行不该回改，拿它去代码里找同号必然落空。
SKIP_LINE = re.compile(r"\[示例\]|\[计划\]|^\s*\|\s*20\d\d-\d\d-\d\d\s*\|")
frozen_ids: set = set() # 只在 --verbose 里列：被豁免的号（历史/示例），不是"已对应"
# 2026-10-21 批 6：`DOC-ONLY` 里混着两种"不是缺口"的号，一律**单列示数**而不是塞进差异，
# 也**不静默消失**——数量恒打印，明细 `--verbose` 可查：
# BENCH 硬件层人工用例（标题或所属章节含「（硬件层）」）：本来就没有代码载体，
# 属主是人工台架步骤，不是 C 代码（例：§12.5 阶段 15「自愈驱动原语（硬件层，无需 PC）」）。
# NOTIMPL 文档已显式标了状态词（未实现 / 待补 / 暂缓 / 已取消）：是**已登记的欠账**，
# 不是"查无此号"的假警报。
# ⚠ 反过来别把 BENCH 当"已覆盖"：它只说明"不该期望代码里有"，不证明人工真做过。
BENCH_RX = re.compile(r"[（(]\s*硬件层")
NOTIMPL_RX = re.compile(r"未实现|待补|暂缓|已取消")
# 定义行（决定这个号的**载体类型**）：markdown 标题行，或表格里号在**首格**的行。
# 引用行（正文里"同 TC-NET-601"、"参见 TC-NET-302"）不改变载体判断——否则一个人工
# 用例只要在别处被提一次，就又被要求"代码里必须有"（2026-10-21 实测：按"任意行都算"
# 实现时，BENCH 收了 16 个号却只消掉 1 处差异，等于没生效）。
DEF_LINE_RX = re.compile(r"^(?:#{2,6}\s|\|\s*\*{0,2}\s*TC-)")
bench_ids: set = set()
notimpl_ids: set = set()
def _prefix(tc: str) -> str:
@@ -110,7 +127,8 @@ def collect(paths, label, want_intent=False):
"""返回 (ids_set, per_prefix_counts[, intent_set])。逐文件扫描，缺文件不致命。"""
ids = set()
intents = set()
global frozen_ids
global frozen_ids, bench_ids, notimpl_ids
in_bench_section = False
for p in paths:
try:
text = p.read_text(encoding="utf-8", errors="replace")
@@ -118,6 +136,11 @@ def collect(paths, label, want_intent=False):
print(f"[ERR] 无法读取 {p}: {e}", file=sys.stderr)
return (None, None, None) if want_intent else (None, None)
for line in text.splitlines():
if re.match(r"^#{2,6}\s+\S", line): # markdown 章节：记住是否硬件层
in_bench_section = bool(BENCH_RX.search(line))
is_def = bool(DEF_LINE_RX.search(line))
bench = bool(BENCH_RX.search(line)) or (in_bench_section and is_def)
notimpl = bool(NOTIMPL_RX.search(line))
skip = bool(SKIP_LINE.search(line))
for m in TC_RE.findall(line):
if _prefix(m) in PLACEHOLDER_PREFIXES:
@@ -125,6 +148,13 @@ def collect(paths, label, want_intent=False):
if skip: # 冻结历史 / 示例行：不参与双向比对，只留痕
frozen_ids.add(m)
continue
if label == "doc" and is_def:
# 只对文档侧分类：载体类型由**文档里的定义行**说了算，
# 且必须从全集里整体减掉（见上面注释的实测坑）
if bench:
bench_ids.add(m) # 硬件层人工 → 不期望代码载体
if notimpl:
notimpl_ids.add(m) # 已标未实现/待补 → 已登记的欠账
ids.add(m)
if want_intent and has_intent(line, m):
intents.add(m)
@@ -173,6 +203,9 @@ def main():
if code_ids is None or doc_ids is None:
return 2
# 文档侧的两个单列档整体从文档全集里减掉后再比差异（数量已在上面打印，
# --verbose 有明细）：BENCH = 人工台架定义，NOTIMPL = 已显式登记未实现
doc_ids -= bench_ids | notimpl_ids
doc_bases = {_base(i) for i in doc_ids}
# 真差异定义（B 层口径 2026-10-21，docs/编号规范.md §8.1）：
# ① 文档声明了、代码里没有 → 未实现/未标注（保留，这是硬断链）；
@@ -189,7 +222,11 @@ def main():
print(f"代码侧：{len(code_files)} 个文件，{len(code_ids)} 个 TC")
print(f"文档侧：{len(doc_files)} 个文件，{len(doc_ids)} 个 TC")
print(f"交集：{len(code_ids & doc_ids)}")
# 注意：交集/文档侧计数在减档之前打印，这里补一行减档后的口径
print(f"（减 BENCH/NOTIMPL 后参与比对：文档 {len(doc_ids)}、交集 {len(code_ids & doc_ids)}）")
print(f"豁免：变更记录/[示例]/[计划] 行的号 {len(frozen_ids)} 个（口径同 check_ids.py，见 §8.1）")
print(f"单列 BENCH（硬件层人工用例，不期望有代码载体）：{len(bench_ids)} 个")
print(f"单列 NOTIMPL（文档已标未实现/待补/暂缓/已取消）：{len(notimpl_ids)} 个")
if args.verbose:
print("--- 各前缀 TC 计数（代码 / 文档）---")
@@ -211,6 +248,12 @@ def main():
for i in code_only_in_code:
print(f" {i}")
for name, bag in (("BENCH 硬件层人工", bench_ids), ("NOTIMPL 已登记未实现", notimpl_ids)):
if args.verbose and bag:
print("--- %s：不参与差异比对，但**不等于已验证**（共 %d 个）---" % (name, len(bag)))
for i in sorted(bag):
print(" ", i)
if args.verbose and frozen_ids:
print("--- 被豁免的号（变更记录 / [示例] / [计划] 行，共 %d 个）**不是已对应**，"
"历史旧号靠 id_aliases.json 解析 ---" % len(frozen_ids))
scripts/id_aliases.json
+265 -1
View File
@@ -1,7 +1,7 @@
{
"schema": 1,
"generated_from": "docs/编号规范.md §7 迁移映射 + §4.3 冻结前缀；本表只登记**仓库里已实际出现**的旧字面量 → 现行字面量，不做尚未落地的批量改写（§7.2 阶段 1 一律保留存量）",
"note": "旧号引用不因本表而改写：本表只让门禁把「旧号引用」判成可解析（校验 3 悬空引用 / 校验 4 重复定义）。批量改写属 §9 阶段 1，须逐批 dry-run + 三重复核（§7.3）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。",
"note": "旧号引用不因本表而改写：本表只让门禁把「旧号引用」判成可解析（校验 3 悬空引用 / 校验 4 重复定义）。批量改写属 §9 阶段 1，须逐批 dry-run + 三重复核（§7.3）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。 带 scope 的条目只在所列文件内生效（同一裸形字面量可能属多族，全局别名会把真撞号洗成已解析）。",
"aliases": {
"N-31": {
"to": null,
@@ -2829,6 +2829,270 @@
"MDK-ARM/retracted_bench_20260922/README.txt",
"scripts/README.md"
]
},
"TC-201": {
"to": "TC-NET-201",
"status": "renamed",
"note": "阶段 2 芯片层 TCP Client 用例 201~204 的裸形标注（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC-203": {
"to": "TC-NET-203",
"status": "renamed",
"note": "阶段 2 芯片层 TCP Client 用例 201~204 的裸形标注（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC201": {
"to": "TC-NET-201",
"status": "renamed",
"note": "阶段 2 芯片层 TCP Client 用例 201~204 的裸形标注（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC202": {
"to": "TC-NET-202",
"status": "renamed",
"note": "阶段 2 芯片层 TCP Client 用例 201~204 的裸形标注（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC203": {
"to": "TC-NET-203",
"status": "renamed",
"note": "阶段 2 芯片层 TCP Client 用例 201~204 的裸形标注（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC204": {
"to": "TC-NET-204",
"status": "renamed",
"note": "阶段 2 芯片层 TCP Client 用例 201~204 的裸形标注（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC 701": {
"to": "TC-NET-701",
"status": "renamed",
"note": "阶段 7 NET 层 TCP Client 用例 701~704（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC 702": {
"to": "TC-NET-702",
"status": "renamed",
"note": "阶段 7 NET 层 TCP Client 用例 701~704（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC 703": {
"to": "TC-NET-703",
"status": "renamed",
"note": "阶段 7 NET 层 TCP Client 用例 701~704（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC 704": {
"to": "TC-NET-704",
"status": "renamed",
"note": "阶段 7 NET 层 TCP Client 用例 701~704（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC701": {
"to": "TC-NET-701",
"status": "renamed",
"note": "阶段 7 NET 层 TCP Client 用例 701~704（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC702": {
"to": "TC-NET-702",
"status": "renamed",
"note": "阶段 7 NET 层 TCP Client 用例 701~704（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC703": {
"to": "TC-NET-703",
"status": "renamed",
"note": "阶段 7 NET 层 TCP Client 用例 701~704（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC704": {
"to": "TC-NET-704",
"status": "renamed",
"note": "阶段 7 NET 层 TCP Client 用例 701~704（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC-1501": {
"to": "TC-NET-1501",
"status": "renamed",
"note": "阶段 15 自愈驱动原语 1501/1502/1502b/1503（含 b 子项后缀，序号原样保留）（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC-1502": {
"to": "TC-NET-1502",
"status": "renamed",
"note": "阶段 15 自愈驱动原语 1501/1502/1502b/1503（含 b 子项后缀，序号原样保留）（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC-1502b": {
"to": "TC-NET-1502b",
"status": "renamed",
"note": "阶段 15 自愈驱动原语 1501/1502/1502b/1503（含 b 子项后缀，序号原样保留）（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC-1503": {
"to": "TC-NET-1503",
"status": "renamed",
"note": "阶段 15 自愈驱动原语 1501/1502/1502b/1503（含 b 子项后缀，序号原样保留）（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC1501": {
"to": "TC-NET-1501",
"status": "renamed",
"note": "阶段 15 自愈驱动原语 1501/1502/1502b/1503（含 b 子项后缀，序号原样保留）（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC1502": {
"to": "TC-NET-1502",
"status": "renamed",
"note": "阶段 15 自愈驱动原语 1501/1502/1502b/1503（含 b 子项后缀，序号原样保留）（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC1502b": {
"to": "TC-NET-1502b",
"status": "renamed",
"note": "阶段 15 自愈驱动原语 1501/1502/1502b/1503（含 b 子项后缀，序号原样保留）（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
},
"TC1503": {
"to": "TC-NET-1503",
"status": "renamed",
"note": "阶段 15 自愈驱动原语 1501/1502/1502b/1503（含 b 子项后缀，序号原样保留）（scripts/rename_ids.py 批：族 TC）｜旧号仅在本批 scope 内指向新号；scope 外同字面量属其它族，不受本条影响",
"scope": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
]
}
},
"id_aliases": {}
scripts/id_known_backlog.json
+2 -38
View File
@@ -2,8 +2,8 @@
"schema": 1,
"note": "编号债务台账（docs/编号规范.md §8.4）：--strict 只对**台账之外**的新错误级问题拦提交。台账只许减不许增——还清的用 --prune-backlog 收掉；确需新增一条必须写 reason 字段说明这笔债为什么该存在，默认禁止顺手加行（否则一周后台账就变成第二个 backlog）。指纹 = 文件 + 校验号 + 字面量，不含行号（行号会漂，用它台账天天假新增）。",
"generated_by": "scripts/check_ids.py --write-backlog",
"total_error_findings": 632,
"decidable_ratio_at_generation": 82.99,
"total_error_findings": 626,
"decidable_ratio_at_generation": 83.26,
"entries": [
{
"file": ".dsh/skills/serial-assistant/scripts/serial_tool.py",
@@ -1139,42 +1139,6 @@
"literal": "DP-04",
"count": 3
},
{
"file": "test/board/ch395f_test_task.c",
"code": 2,
"literal": "TC-1501",
"count": 1
},
{
"file": "test/board/ch395f_test_task.c",
"code": 2,
"literal": "TC-1502",
"count": 1
},
{
"file": "test/board/ch395f_test_task.c",
"code": 2,
"literal": "TC-1502b",
"count": 1
},
{
"file": "test/board/ch395f_test_task.c",
"code": 2,
"literal": "TC-1503",
"count": 1
},
{
"file": "test/board/ch395f_test_task.c",
"code": 2,
"literal": "TC-201",
"count": 1
},
{
"file": "test/board/ch395f_test_task.c",
"code": 2,
"literal": "TC-203",
"count": 1
},
{
"file": "test/board/ch395f_test_task.c",
"code": 2,
scripts/rename_maps/batch6-net-annotate.json
+61
View File
@@ -0,0 +1,61 @@
{
"schema": 1,
"batch": "批 6（2026-10-21 板级 NET 用例号标注）",
"applied_by": "scripts/rename_ids.py",
"record": "docs/编号规范.md §8.3",
"note": "追溯器分档后暴露的真问题：板级 NET 用例的**实现体里标的是裸形**（TC204 / TC-201 / TC1501 / TC1502b…），文档侧写的是合规号 TC-NET-204 等 → 双向追溯对不上，看上去像「文档声明了没实现」，实际是**标注形态烂**。本批只补模块码、序号一位不改（§7.1），作用域限定 5 个真载体文件；改完 @build 验证（改到 test/board 与 Drivers/BSP/CH395F 注释）。刻意不含别的模块（host 侧 TC-00x 那批属另一个模块，另批处理）。",
"batches": [
{
"family": "TC",
"old": "\\bTC[- ]?(?P<n>20[1-4])\\b",
"new": "TC-NET-{n}",
"files": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
],
"note": "阶段 2 芯片层 TCP Client 用例 201~204 的裸形标注"
},
{
"family": "TC",
"old": "\\bTC[- ]?(?P<n>70[1-4])\\b",
"new": "TC-NET-{n}",
"files": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
],
"note": "阶段 7 NET 层 TCP Client 用例 701~704"
},
{
"family": "TC",
"old": "\\bTC[- ]?(?P<n>15\\d{2}b?)\\b",
"new": "TC-NET-{n}",
"files": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
],
"note": "阶段 15 自愈驱动原语 1501/1502/1502b/1503（含 b 子项后缀，序号原样保留）"
},
{
"family": "TC",
"old": "\\bTC[- ]?(?P<n>60[16]|80[12]|90[12]|1006|110[01])\\b",
"new": "TC-NET-{n}",
"files": [
"test/board/ch395f_test_task.c",
"test/board/net_test_task.c",
"test/board/net_test_task.h",
"test/host/ch395f_socket_test.py",
"Drivers/BSP/CH395F/ch395f.c"
],
"note": "阶段 6/8/9/11/12 的 601/606/801/802/901/902/1006/1100/1101 裸形（有则补，无则 0 命中）"
}
]
}
test/board/ch395f_test_task.c
+67 -67
View File
@@ -277,7 +277,7 @@ static void phase1_run(void) {
#define PHASE2_TIMEOUT_MS 10000
#endif
#ifndef PHASE2_TC203_TIMEOUT_MS
#define PHASE2_TC203_TIMEOUT_MS 30000 /* TC-203 连接超时窗（指南规定 30s） */
#define PHASE2_TC203_TIMEOUT_MS 30000 /* TC-NET-203 连接超时窗（指南规定 30s） */
#endif
/* TCP Client 单次会话：对应 TC-NET-201 步 2~7 与 TC-NET-202 每轮 6 步。
@@ -309,7 +309,7 @@ static void phase2_tc201(void)
ch395f_set_des_port(sock, PHASE2_REMOTE_PORT);
ch395f_set_sour_port(sock, (uint16_t)PHASE2_LOCAL_PORT);
TEST_CHECK(ch395f_get_cmd_status() == CH395F_ERR_SUCCESS,
"TC201 step1 cfg proto/ip/port");
"TC-NET-201 step1 cfg proto/ip/port");
if (ch395f_get_cmd_status() != CH395F_ERR_SUCCESS) return;
/* 构造 64 字节递增模式数据 0x00..0x3F */
@@ -319,12 +319,12 @@ static void phase2_tc201(void)
/* 步2：OPEN Socket 0 */
r = ch395f_open_socket(sock);
TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC201 step2 open");
TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC-NET-201 step2 open");
if (r != CH395F_ERR_SUCCESS) return;
/* 步3：CONNECT */
r = ch395f_tcp_connect(sock);
TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC201 step3 connect");
TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC-NET-201 step3 connect");
if (r != CH395F_ERR_SUCCESS) { ch395f_close_socket(sock); return; }
/* 步4：等待 CONNECT 中断
@@ -349,7 +349,7 @@ static void phase2_tc201(void)
* 继续下一轮轮询等 CONNECT */
HAL_Delay(10); /* 10ms 轮询周期，直至 CONNECT 或超时退出 */
}
TEST_CHECK(ok, "TC201 step4 connected");
TEST_CHECK(ok, "TC-NET-201 step4 connected");
if (!ok) {
ch395f_close_socket(sock);
return;
@@ -367,7 +367,7 @@ static void phase2_tc201(void)
}
HAL_Delay(10);
}
TEST_CHECK(ok, "TC201 step5 sendbuf_free");
TEST_CHECK(ok, "TC-NET-201 step5 sendbuf_free");
if (!ok) {
ch395f_close_socket(sock);
return;
@@ -419,7 +419,7 @@ static void phase2_tc201(void)
break;
}
}
TEST_CHECK(match, "TC201 step6 echo verify");
TEST_CHECK(match, "TC-NET-201 step6 echo verify");
ok = 1; /* 标记"收到过数据"，循环外的 echo rcvd 检查不再重复报错 */
break; /* 校验结论已得出，无论 PASS/FAIL 都跳出 */
@@ -442,7 +442,7 @@ static void phase2_tc201(void)
* ok==1：收到过数据，结果已由循环内 "echo verify" 记录；
* ok==0：10s 内什么都没收到 / 中途断开 —— 在此补一条 FAIL。 */
if (!ok) {
TEST_CHECK(0, "TC201 step6 echo rcvd");
TEST_CHECK(0, "TC-NET-201 step6 echo rcvd");
}
/* 步7：关闭 Socket 并等待状态回到 CLOSED（CH395F_SOCKET_CLOSED = 0x00） */
@@ -458,7 +458,7 @@ static void phase2_tc201(void)
}
HAL_Delay(50);
}
TEST_CHECK(ok, "TC201 step7 closed");
TEST_CHECK(ok, "TC-NET-201 step7 closed");
HAL_Delay(200);
}
@@ -483,12 +483,12 @@ static void phase2_tc202_once(uint8_t sock, uint16_t local_port)
/* 步1：设置本地端口并 OPEN Socket 0 */
ch395f_set_sour_port(sock, local_port);
r = ch395f_open_socket(sock);
TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC202 step1 open");
TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC-NET-202 step1 open");
if (r != CH395F_ERR_SUCCESS) return;
/* 步2：CONNECT */
r = ch395f_tcp_connect(sock);
TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC202 step2 connect");
TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC-NET-202 step2 connect");
if (r != CH395F_ERR_SUCCESS) { ch395f_close_socket(sock); return; }
/* 步3：等待 CONNECT 中断 */
@@ -498,7 +498,7 @@ static void phase2_tc202_once(uint8_t sock, uint16_t local_port)
if (ch395f_get_sock_int_status(sock) & CH395F_SINT_STAT_CONNECT) { ok = 1; break; }
HAL_Delay(10);
}
TEST_CHECK(ok, "TC202 step3 connected");
TEST_CHECK(ok, "TC-NET-202 step3 connected");
if (!ok) { ch395f_close_socket(sock); return; }
HAL_Delay(100);
@@ -510,7 +510,7 @@ static void phase2_tc202_once(uint8_t sock, uint16_t local_port)
if (ch395f_get_sock_int_status(sock) & CH395F_SINT_STAT_SENBUF_FREE) { ok = 1; break; }
HAL_Delay(10);
}
TEST_CHECK(ok, "TC202 step4 sendbuf_free");
TEST_CHECK(ok, "TC-NET-202 step4 sendbuf_free");
if (!ok) { ch395f_close_socket(sock); return; }
/* 步5：等待回显并验证 */
@@ -527,7 +527,7 @@ static void phase2_tc202_once(uint8_t sock, uint16_t local_port)
for (p = 0; p < n; p++) {
if (rx[p] != tx[p]) { match = 0; break; }
}
TEST_CHECK(match, "TC202 step5 echo verify");
TEST_CHECK(match, "TC-NET-202 step5 echo verify");
ok = 1;
break;
}
@@ -535,7 +535,7 @@ static void phase2_tc202_once(uint8_t sock, uint16_t local_port)
(CH395F_SINT_STAT_DISCONNECT | CH395F_SINT_STAT_SOCK_TIMEOUT)) break;
HAL_Delay(50);
}
if (!ok) TEST_CHECK(0, "TC202 step5 echo rcvd");
if (!ok) TEST_CHECK(0, "TC-NET-202 step5 echo rcvd");
/* 步6：关闭 + 等待 CLOSED */
ch395f_close_socket(sock);
@@ -547,7 +547,7 @@ static void phase2_tc202_once(uint8_t sock, uint16_t local_port)
if (st[0] == CH395F_SOCKET_CLOSED) { ok = 1; break; }
HAL_Delay(50);
}
TEST_CHECK(ok, "TC202 step6 closed");
TEST_CHECK(ok, "TC-NET-202 step6 closed");
HAL_Delay(200);
}
@@ -629,12 +629,12 @@ static uint8_t tc204_session(uint8_t sock, uint16_t lport, uint8_t mode, uint8_t
ch395f_set_sour_port(sock, lport);
r = ch395f_open_socket(sock);
if (r != CH395F_ERR_SUCCESS) {
DBG_INFO("TC204 m%u r%u open ret=0x%02X", (unsigned)mode, (unsigned)round, r);
DBG_INFO("TC-NET-204 m%u r%u open ret=0x%02X", (unsigned)mode, (unsigned)round, r);
return 0;
}
r = ch395f_tcp_connect(sock);
if (r != CH395F_ERR_SUCCESS) {
DBG_INFO("TC204 m%u r%u connect cmd ret=0x%02X", (unsigned)mode, (unsigned)round, r);
DBG_INFO("TC-NET-204 m%u r%u connect cmd ret=0x%02X", (unsigned)mode, (unsigned)round, r);
ch395f_close_socket(sock);
return 0;
}
@@ -648,14 +648,14 @@ static uint8_t tc204_session(uint8_t sock, uint16_t lport, uint8_t mode, uint8_t
break;
}
if (si != 0U) {
DBG_INFO("TC204 m%u r%u stale-int=0x%02X at +%ums",
DBG_INFO("TC-NET-204 m%u r%u stale-int=0x%02X at +%ums",
(unsigned)mode, (unsigned)round, si,
(unsigned)(HAL_GetTick() - tick));
}
HAL_Delay(10);
}
if (!ok) {
DBG_INFO("TC204 m%u r%u no CONNECT within %ums", (unsigned)mode, (unsigned)round,
DBG_INFO("TC-NET-204 m%u r%u no CONNECT within %ums", (unsigned)mode, (unsigned)round,
(unsigned)PHASE2_TIMEOUT_MS);
ch395f_close_socket(sock);
return 0;
@@ -674,7 +674,7 @@ static uint8_t tc204_session(uint8_t sock, uint16_t lport, uint8_t mode, uint8_t
HAL_Delay(10);
}
if (!ok) {
DBG_INFO("TC204 m%u r%u no SENBUF_FREE", (unsigned)mode, (unsigned)round);
DBG_INFO("TC-NET-204 m%u r%u no SENBUF_FREE", (unsigned)mode, (unsigned)round);
ch395f_close_socket(sock);
return 0;
}
@@ -694,14 +694,14 @@ static uint8_t tc204_session(uint8_t sock, uint16_t lport, uint8_t mode, uint8_t
}
}
if (!match) {
DBG_INFO("TC204 m%u r%u echo MISMATCH (rlen=%u)", (unsigned)mode,
DBG_INFO("TC-NET-204 m%u r%u echo MISMATCH (rlen=%u)", (unsigned)mode,
(unsigned)round, (unsigned)rlen);
}
return match;
}
HAL_Delay(20);
}
DBG_INFO("TC204 m%u r%u echo NOT rcvd", (unsigned)mode, (unsigned)round);
DBG_INFO("TC-NET-204 m%u r%u echo NOT rcvd", (unsigned)mode, (unsigned)round);
ch395f_close_socket(sock);
return 0;
}
@@ -724,11 +724,11 @@ static uint8_t tc204_close_seq(uint8_t sock, uint8_t mode, uint8_t round)
if (mode >= 1U) {
uint8_t r = ch395f_tcp_disconnect(sock);
DBG_INFO("TC204 m%u r%u disconnect ret=0x%02X", (unsigned)mode, (unsigned)round, r);
DBG_INFO("TC-NET-204 m%u r%u disconnect ret=0x%02X", (unsigned)mode, (unsigned)round, r);
}
if (mode <= 1U) {
uint8_t r = ch395f_close_socket(sock);
DBG_INFO("TC204 m%u r%u close ret=0x%02X", (unsigned)mode, (unsigned)round, r);
DBG_INFO("TC-NET-204 m%u r%u close ret=0x%02X", (unsigned)mode, (unsigned)round, r);
}
tick = HAL_GetTick();
@@ -736,7 +736,7 @@ static uint8_t tc204_close_seq(uint8_t sock, uint8_t mode, uint8_t round)
ch395f_get_socket_status(sock, st);
el = (uint32_t)(HAL_GetTick() - tick);
while ((mi < n_marks) && (el >= s_marks[mi])) {
DBG_INFO("TC204 m%u r%u poll +%ums st=0x%02X/0x%02X", (unsigned)mode,
DBG_INFO("TC-NET-204 m%u r%u poll +%ums st=0x%02X/0x%02X", (unsigned)mode,
(unsigned)round, (unsigned)s_marks[mi], st[0], st[1]);
mi++;
}
@@ -749,10 +749,10 @@ static uint8_t tc204_close_seq(uint8_t sock, uint8_t mode, uint8_t round)
/* 判定瞬间再读一次：byte0 已 CLOSED 时 byte1 按 §5.22/官方注释属"无意义"区 */
ch395f_get_socket_status(sock, st);
if (closed != 0U) {
DBG_INFO("TC204 m%u r%u CLOSED at +%ums (byte0=0x%02X byte1=0x%02X)",
DBG_INFO("TC-NET-204 m%u r%u CLOSED at +%ums (byte0=0x%02X byte1=0x%02X)",
(unsigned)mode, (unsigned)round, (unsigned)el, st[0], st[1]);
} else {
DBG_INFO("TC204 m%u r%u NOT-CLOSED within %ums (byte0=0x%02X byte1=0x%02X)",
DBG_INFO("TC-NET-204 m%u r%u NOT-CLOSED within %ums (byte0=0x%02X byte1=0x%02X)",
(unsigned)mode, (unsigned)round, (unsigned)PHASE204_CLOSE_WAIT_MS,
st[0], st[1]);
}
@@ -761,7 +761,7 @@ static uint8_t tc204_close_seq(uint8_t sock, uint8_t mode, uint8_t round)
/* 轮末收尾：关闭本轮第二条连接并等回 CLOSED
* 说明：芯片不允许对已 OPEN 的 Socket 再 open（返回 0x20 FAIL）——不收尾则下一轮
* 首轮 open 必失败并级联（2026-10-11 TC204 首跑实测踩过）。 */
* 首轮 open 必失败并级联（2026-10-11 TC-NET-204 首跑实测踩过）。 */
static void tc204_round_teardown(uint8_t sock)
{
uint8_t st[2] = { 0, 0 };
@@ -788,12 +788,12 @@ static void phase2_tc204_once(uint8_t mode, uint8_t round)
uint8_t s2;
uint8_t closed;
DBG_INFO("TC204 === m%u r%u lport %u ===", (unsigned)mode, (unsigned)round,
DBG_INFO("TC-NET-204 === m%u r%u lport %u ===", (unsigned)mode, (unsigned)round,
(unsigned)lport);
/* 1. 建立真实连接（有连接才谈得上 FIN_WAIT_*） */
s1 = tc204_session(sock, lport, mode, round);
TEST_CHECK(s1, "TC204 m%u r%u session1 (connect+echo)", (unsigned)mode, (unsigned)round);
TEST_CHECK(s1, "TC-NET-204 m%u r%u session1 (connect+echo)", (unsigned)mode, (unsigned)round);
if (!s1) {
tc204_round_teardown(sock);
return;
@@ -803,24 +803,24 @@ static void phase2_tc204_once(uint8_t mode, uint8_t round)
closed = tc204_close_seq(sock, mode, round);
if (mode == 2U) {
/* 模式 C 的预期恰恰相反：bit3=1（§5.52 ②）下芯片不得自行关闭 Socket */
TEST_CHECK(!closed, "TC204 m2 r%u stays OPEN after disconnect (FUN_PARA bit3)",
TEST_CHECK(!closed, "TC-NET-204 m2 r%u stays OPEN after disconnect (FUN_PARA bit3)",
(unsigned)round);
if (!closed) {
/* TRAP-NET-07 的"无法重新打开"现场：不 close 直接 open，看芯片返回什么 */
uint8_t r = ch395f_open_socket(sock);
DBG_INFO("TC204 m2 r%u open-without-close ret=0x%02X", (unsigned)round, r);
DBG_INFO("TC-NET-204 m2 r%u open-without-close ret=0x%02X", (unsigned)round, r);
/* 收尾：显式 close 并测耗时（证明 close 才是把 Socket 拉回 CLOSED 的动作） */
(void)tc204_close_seq(sock, 0U, round);
}
} else {
TEST_CHECK(closed, "TC204 m%u r%u back to CLOSED within %ums", (unsigned)mode,
TEST_CHECK(closed, "TC-NET-204 m%u r%u back to CLOSED within %ums", (unsigned)mode,
(unsigned)round, (unsigned)PHASE204_CLOSE_WAIT_MS);
}
/* 3. 重开 + 重连 + 回显（TRAP-NET-07 的"无法重新打开"判据；TRAP-NET-09 沉降 200ms） */
HAL_Delay(200);
s2 = tc204_session(sock, (uint16_t)(lport + 64U), mode, round);
TEST_CHECK(s2, "TC204 m%u r%u reopen+reconnect+echo OK", (unsigned)mode, (unsigned)round);
TEST_CHECK(s2, "TC-NET-204 m%u r%u reopen+reconnect+echo OK", (unsigned)mode, (unsigned)round);
tc204_round_teardown(sock);
}
@@ -847,7 +847,7 @@ static void phase2_tc204(void)
/* TC-NET-203（硬件层）：TCP Client 连接超时（负向测试，P1）
*
* 前置环境：PC 未在 192.168.1.2:8081 提供服务（与 TC-201/202 互斥，
* 前置环境：PC 未在 192.168.1.2:8081 提供服务（与 TC-NET-201/202 互斥，
* 需先关闭 PC 端 tcp_server）。固件自行辨别环境错误：
* 若等待期间误收到 CONNECT，说明 PC 服务未关，判 FAIL 并给出指引。
*
@@ -884,7 +884,7 @@ static void phase2_tc203(void)
ch395f_set_des_port(sock, (uint16_t)PHASE2_REMOTE_PORT);
ch395f_set_sour_port(sock, sour_port);
TEST_CHECK(ch395f_get_cmd_status() == CH395F_ERR_SUCCESS,
"TC203 step1 cfg proto/ip/port");
"TC-NET-203 step1 cfg proto/ip/port");
if (ch395f_get_cmd_status() != CH395F_ERR_SUCCESS) return;
/* 预清陈旧事件（TRAP-NET-12）：上一会话 close 的 DISCONNECT 可能滞后锁存
@@ -896,11 +896,11 @@ static void phase2_tc203(void)
/* 步2：OPEN + CONNECT。命令为异步下发，此时均应立即返回成功，
* 真正的失败结果由步 3 的中断体现 */
r = ch395f_open_socket(sock);
TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC203 step2 open");
TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC-NET-203 step2 open");
if (r != CH395F_ERR_SUCCESS) return;
r = ch395f_tcp_connect(sock);
TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC203 step2 connect");
TEST_CHECK(r == CH395F_ERR_SUCCESS, "TC-NET-203 step2 connect");
if (r != CH395F_ERR_SUCCESS) { ch395f_close_socket(sock); return; }
/* 步3：30s 直读本 Socket SINT 轮询（读即清），等"连不上"的证据。
@@ -963,12 +963,12 @@ static void phase2_tc203(void)
short_tag = "T/O-slow(silence)";
}
DBG_INFO(" negative event @%lums: %s", elapsed, why);
TEST_CHECK(1, "TC203 step3 no-connect OK (%lums %s)", elapsed, short_tag);
TEST_CHECK(1, "TC-NET-203 step3 no-connect OK (%lums %s)", elapsed, short_tag);
} else if (ev == 2) {
DBG_ERROR(" CONNECT received -> PC 8081 server is still running!");
TEST_CHECK(0, "TC203 step3 connected?! stop PC server and retry");
TEST_CHECK(0, "TC-NET-203 step3 connected?! stop PC server and retry");
} else {
TEST_CHECK(0, "TC203 step3 no interrupt in %dms (state machine hang?)",
TEST_CHECK(0, "TC-NET-203 step3 no interrupt in %dms (state machine hang?)",
PHASE2_TC203_TIMEOUT_MS);
}
@@ -982,7 +982,7 @@ static void phase2_tc203(void)
if (st[0] == CH395F_SOCKET_CLOSED) { ev = 1; break; }
HAL_Delay(50);
}
TEST_CHECK(ev == 1, "TC203 step4 closed");
TEST_CHECK(ev == 1, "TC-NET-203 step4 closed");
HAL_Delay(200);
}
@@ -1599,7 +1599,7 @@ static void phase15_run(void) {
DBG_INFO("=== CH395F Phase 15 Tests (self-heal phase-2 primitives) ===");
/* ---- TC-1501: 状态回读一致性 + cmd_done 语义（E2/E3 定案形态） ---- */
/* ---- TC-NET-1501: 状态回读一致性 + cmd_done 语义（E2/E3 定案形态） ---- */
ch395f_set_proto_type(sn, CH395F_PROTO_TYPE_TCP);
ch395f_set_sour_port(sn, 5107U);
(void)ch395f_open_socket(sn);
@@ -1609,7 +1609,7 @@ static void phase15_run(void) {
if (ch395f_cmd_done(sn, CH395F_DONE_OPEN) == 1) { done = 1; break; }
HAL_Delay(1);
}
TEST_CHECK(done == 1, "TC1501 open done within 50ms");
TEST_CHECK(done == 1, "TC-NET-1501 open done within 50ms");
(void)ch395f_tcp_listen(sn);
t0 = HAL_GetTick();
@@ -1619,11 +1619,11 @@ static void phase15_run(void) {
HAL_Delay(1);
}
/* E2 矩阵：LISTEN 可见延迟 100% <=10ms（24 轮无长尾） */
TEST_CHECK(done == 1, "TC1501 listen done within 20ms (E2: 100 pct <=10ms)");
TEST_CHECK(ch395f_sock_is_listening(sn) == 1, "TC1501 cached is_listening");
TEST_CHECK(done == 1, "TC-NET-1501 listen done within 20ms (E2: 100 pct <=10ms)");
TEST_CHECK(ch395f_sock_is_listening(sn) == 1, "TC-NET-1501 cached is_listening");
st = ch395f_sock_state_cached(sn);
TEST_CHECK(st.open == CH395F_SOCKET_OPEN && st.tcp_state == CH395F_TCP_LISTEN,
"TC1501 cached state 05/01 (got %02X/%02X)", st.open, st.tcp_state);
"TC-NET-1501 cached state 05/01 (got %02X/%02X)", st.open, st.tcp_state);
/* 二段关闭实证（2026-10-13 本 TC 二跑定案）：LISTEN 态 Socket 的
* CLOSE_SOCKET 返 SUCCESS 但只拆监听（TCP 01->00），byte0 恒 05；
@@ -1631,10 +1631,10 @@ static void phase15_run(void) {
* sock_reset 状态机在 WAIT_CLOSE 阶段自行补发（见 ch395f.c）。 */
uint8_t close_st = ch395f_close_socket(sn);
TEST_CHECK(close_st == CH395F_ERR_SUCCESS,
"TC1501 close cmd st=0x%02X (expect 00)", close_st);
"TC-NET-1501 close cmd st=0x%02X (expect 00)", close_st);
st = ch395f_get_sock_state(sn);
TEST_CHECK(st.open == CH395F_SOCKET_OPEN && st.tcp_state == CH395F_TCP_CLOSED,
"TC1501 listen-close stage1: 05/00 listen torn down (got %02X/%02X)",
"TC-NET-1501 listen-close stage1: 05/00 listen torn down (got %02X/%02X)",
st.open, st.tcp_state);
(void)ch395f_close_socket(sn);
t0 = HAL_GetTick();
@@ -1643,20 +1643,20 @@ static void phase15_run(void) {
if (ch395f_cmd_done(sn, CH395F_DONE_CLOSE) == 1) { done = (int)(HAL_GetTick() - t0); break; }
HAL_Delay(1);
}
TEST_CHECK(done >= 0, "TC1501 listen-close stage2: byte0=00 in %dms (win 500)", done);
TEST_CHECK(done >= 0, "TC-NET-1501 listen-close stage2: byte0=00 in %dms (win 500)", done);
st = ch395f_get_sock_state(sn);
TEST_CHECK(st.tcp_state == CH395F_SOCK_STATE_NONE,
"TC1501 tcp_state sentinel 0xFF when closed (got %02X)", st.tcp_state);
"TC-NET-1501 tcp_state sentinel 0xFF when closed (got %02X)", st.tcp_state);
st = ch395f_get_sock_state(8U);
TEST_CHECK(st.open == CH395F_SOCKET_CLOSED && st.tcp_state == CH395F_SOCK_STATE_NONE,
"TC1501 sn=8 boundary -> CLOSED+sentinel");
"TC-NET-1501 sn=8 boundary -> CLOSED+sentinel");
/* ---- TC-1502: sock_reset 非阻塞状态机跑通（E4 定案序列） ---- */
/* ---- TC-NET-1502: sock_reset 非阻塞状态机跑通（E4 定案序列） ---- */
(void)ch395f_open_socket(sn);
rc = ch395f_sock_reset_begin(sn, CH395F_RESET_QUARANTINE);
TEST_CHECK(rc == 0, "TC1502 begin accepted (rc=%d)", rc);
TEST_CHECK(rc == 0, "TC-NET-1502 begin accepted (rc=%d)", rc);
TEST_CHECK(ch395f_sock_reset_begin(sn, CH395F_RESET_QUARANTINE) == -1,
"TC1502 busy reject on second begin");
"TC-NET-1502 busy reject on second begin");
t0 = HAL_GetTick();
rc = 1;
while (rc == 1 && (uint32_t)(HAL_GetTick() - t0) < 3000U) {
@@ -1664,15 +1664,15 @@ static void phase15_run(void) {
HAL_Delay(1);
}
/* QUARANTINE 最短等待 400ms + 各阶段，3s 窗内必落定 */
TEST_CHECK(rc == 0, "TC1502 reset done within 3000ms (rc=%d)", rc);
TEST_CHECK(ch395f_cmd_done(sn, CH395F_DONE_CLOSE) == 1, "TC1502 chip CLOSED after reset");
TEST_CHECK(ch395f_sock_reset_poll(sn) == 0, "TC1502 poll idempotent after done");
TEST_CHECK(rc == 0, "TC-NET-1502 reset done within 3000ms (rc=%d)", rc);
TEST_CHECK(ch395f_cmd_done(sn, CH395F_DONE_CLOSE) == 1, "TC-NET-1502 chip CLOSED after reset");
TEST_CHECK(ch395f_sock_reset_poll(sn) == 0, "TC-NET-1502 poll idempotent after done");
/* 复位后可重开（复位语义 = 回到可用态） */
(void)ch395f_open_socket(sn);
TEST_CHECK(ch395f_cmd_done(sn, CH395F_DONE_OPEN) == 1, "TC1502 reopen after reset OK");
TEST_CHECK(ch395f_cmd_done(sn, CH395F_DONE_OPEN) == 1, "TC-NET-1502 reopen after reset OK");
(void)ch395f_close_socket(sn);
/* TC-1502b: LISTEN 态 Socket 复位（走 WAIT_CLOSE 二段补发路径，GRACEFUL） */
/* TC-NET-1502b: LISTEN 态 Socket 复位（走 WAIT_CLOSE 二段补发路径，GRACEFUL） */
(void)ch395f_open_socket(sn);
(void)ch395f_tcp_listen(sn);
rc = ch395f_sock_reset_begin(sn, CH395F_RESET_GRACEFUL);
@@ -1682,16 +1682,16 @@ static void phase15_run(void) {
rc = ch395f_sock_reset_poll(sn);
HAL_Delay(1);
}
TEST_CHECK(rc == 0, "TC1502b reset on LISTEN socket done (rc=%d, two-stage absorbed)", rc);
TEST_CHECK(ch395f_cmd_done(sn, CH395F_DONE_CLOSE) == 1, "TC1502b chip CLOSED after listen-reset");
TEST_CHECK(rc == 0, "TC-NET-1502b reset on LISTEN socket done (rc=%d, two-stage absorbed)", rc);
TEST_CHECK(ch395f_cmd_done(sn, CH395F_DONE_CLOSE) == 1, "TC-NET-1502b chip CLOSED after listen-reset");
/* ---- TC-1503: 链路态缓存 + 事件护栏边界 ---- */
/* ---- TC-NET-1503: 链路态缓存 + 事件护栏边界 ---- */
uint16_t c0 = ch395f_link_change_count();
ch395f_glob_event_feed(CH395F_GINT_STAT_PHY_CHANGE); /* 首次 feed 建档 */
ch395f_glob_event_feed(CH395F_GINT_STAT_PHY_CHANGE); /* 链路稳定：不应虚增计数 */
TEST_CHECK(ch395f_link_change_count() == c0, "TC1503 no spurious link change on stable link");
TEST_CHECK(ch395f_link_up_cached() == 1U, "TC1503 link_up cached (bench link present)");
TEST_CHECK(ch395f_sock_events(8U) == 0U, "TC1503 sock_events sn=8 boundary -> 0");
TEST_CHECK(ch395f_link_change_count() == c0, "TC-NET-1503 no spurious link change on stable link");
TEST_CHECK(ch395f_link_up_cached() == 1U, "TC-NET-1503 link_up cached (bench link present)");
TEST_CHECK(ch395f_sock_events(8U) == 0U, "TC-NET-1503 sock_events sn=8 boundary -> 0");
(void)ch395f_sock_events(sn); /* 读即清护栏：合法调用不崩 */
TEST_REPORT("Phase 15");
test/board/net_test_task.c
+34 -34
View File
@@ -118,8 +118,8 @@ static void phase6_run(int32_t sockfd) {
* 4. 连接超时负向用例（PC 服务关闭时 connect 不应成功）
*
* 入口条件：PC 运行 `python test/ch395f_socket_test.py tcp_server --port 8081`
* （TC 703 需先关闭该服务）。
* TC 映射：TC 701（连接 + 回显）/ TC 702（关闭重连）/ TC 703（连接超时）。
* （TC-NET-703 需先关闭该服务）。
* TC 映射：TC-NET-701（连接 + 回显）/ TC-NET-702（关闭重连）/ TC-NET-703（连接超时）。
* 通过：回显逐字节一致且 32 位 checksum 匹配；重连全部成功；超时用例未建连。
* 失败：连接失败 / 回显不一致 / 重连中断 / 超时用例误建连。
* =================================================================== */
@@ -146,7 +146,7 @@ static void phase6_run(int32_t sockfd) {
#define PHASE7_CONN_TIMEOUT_MS 10000
#endif
#ifndef PHASE7_TIMEOUT_TEST_MS
#define PHASE7_TIMEOUT_TEST_MS 30000 /* TC 703 连接超时窗（指南规定 30s） */
#define PHASE7_TIMEOUT_TEST_MS 30000 /* TC-NET-703 连接超时窗（指南规定 30s） */
#endif
/* 32 位累加和：足以发现丢字节/错位，比 CRC32 便宜 */
@@ -156,14 +156,14 @@ static uint32_t phase7_cksum(const uint8_t *p, uint32_t n) {
return s;
}
/* 单次 TCP Client 会话：对应 TC 701 主体 / TC 702 单轮。
/* 单次 TCP Client 会话：对应 TC-NET-701 主体 / TC-NET-702 单轮。
* 每轮使用不同本地端口 local_port 规避 TIME_WAIT。
* 返回 1 表示全流程通过，0 表示中途失败（已记录 TEST_CHECK）。 */
static int32_t phase7_session(uint16_t local_port)
{
int32_t sockfd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
if (sockfd < 0) {
TEST_CHECK(0, "TC701 socket create");
TEST_CHECK(0, "TC-NET-701 socket create");
return 0;
}
@@ -174,7 +174,7 @@ static int32_t phase7_session(uint16_t local_port)
laddr.sin_family = NET_AF_INET;
laddr.sin_port = net_htons(local_port);
if (net_bind(sockfd, (struct net_sockaddr *)&laddr, sizeof(laddr)) < 0) {
TEST_CHECK(0, "TC701 bind port %d", local_port);
TEST_CHECK(0, "TC-NET-701 bind port %d", local_port);
net_close(sockfd);
return 0;
}
@@ -187,10 +187,10 @@ static int32_t phase7_session(uint16_t local_port)
raddr.sin_port = net_htons((uint16_t)PHASE7_REMOTE_PORT);
raddr.sin_addr.s_addr = net_inet_addr(PHASE7_REMOTE_IP);
DBG_INFO("TC701 connecting %s:%d (local port %d)",
DBG_INFO("TC-NET-701 connecting %s:%d (local port %d)",
PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT, local_port);
int32_t rc = net_connect(sockfd, (struct net_sockaddr *)&raddr, sizeof(raddr));
TEST_CHECK(rc == 0, "TC701 connect issued (ret=%d)", rc);
TEST_CHECK(rc == 0, "TC-NET-701 connect issued (ret=%d)", rc);
if (rc != 0) { net_close(sockfd); return 0; }
/* 等待连接建立：轮询 socket 状态（ESTABLISHED）。
@@ -208,7 +208,7 @@ static int32_t phase7_session(uint16_t local_port)
}
osDelay(100); /* 仅作等待/让出 CPU；连接状态由 netTask 的 net_poll 每 10ms 刷新 */
}
TEST_CHECK(connected, "TC701 connected within %dms", PHASE7_CONN_TIMEOUT_MS);
TEST_CHECK(connected, "TC-NET-701 connected within %dms", PHASE7_CONN_TIMEOUT_MS);
if (!connected) { net_close(sockfd); return 0; }
}
@@ -218,7 +218,7 @@ static int32_t phase7_session(uint16_t local_port)
for (int32_t i = 0; i < PHASE7_EXCH_SIZE; i++) tx[i] = (uint8_t)i;
int32_t sent = net_send(sockfd, tx, PHASE7_EXCH_SIZE, 0);
TEST_CHECK(sent == PHASE7_EXCH_SIZE, "TC701 send %dB (sent=%d)", PHASE7_EXCH_SIZE, sent);
TEST_CHECK(sent == PHASE7_EXCH_SIZE, "TC-NET-701 send %dB (sent=%d)", PHASE7_EXCH_SIZE, sent);
if (sent != PHASE7_EXCH_SIZE) { net_close(sockfd); return 0; }
int32_t recvd = 0;
@@ -245,23 +245,23 @@ static int32_t phase7_session(uint16_t local_port)
for (int32_t i = 0; i < PHASE7_EXCH_SIZE; i++) {
if (rx[i] != (uint8_t)i) { bad = 1; break; }
}
TEST_CHECK(!bad, "TC701 byte-compare %dB", PHASE7_EXCH_SIZE);
TEST_CHECK(1, "TC701 recv %dB, cksum=0x%08X", recvd, phase7_cksum(rx, PHASE7_EXCH_SIZE));
TEST_CHECK(!bad, "TC-NET-701 byte-compare %dB", PHASE7_EXCH_SIZE);
TEST_CHECK(1, "TC-NET-701 recv %dB, cksum=0x%08X", recvd, phase7_cksum(rx, PHASE7_EXCH_SIZE));
} else {
TEST_CHECK(0, "TC701 recv %dB (expect %d)", recvd, PHASE7_EXCH_SIZE);
TEST_CHECK(0, "TC-NET-701 recv %dB (expect %d)", recvd, PHASE7_EXCH_SIZE);
}
net_close(sockfd);
return ok;
}
/* TC 703（负向）：连接超时。PC 未在 REMOTE_IP:REMOTE_PORT 提供服务时，
* connect 不应成功建立。本用例需先关闭 PC 端 tcp_server（与 TC 701/702 互斥环境：
/* TC-NET-703（负向）：连接超时。PC 未在 REMOTE_IP:REMOTE_PORT 提供服务时，
* connect 不应成功建立。本用例需先关闭 PC 端 tcp_server（与 TC-NET-701/702 互斥环境：
* 701/702 要求服务端在线，703 要求服务端离线，故 703 应在独立的一轮中运行）。 */
static void phase7_test_timeout(void)
{
int32_t sockfd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
if (sockfd < 0) { TEST_CHECK(0, "TC703 socket create"); return; }
if (sockfd < 0) { TEST_CHECK(0, "TC-NET-703 socket create"); return; }
struct net_sockaddr_in raddr;
memset(&raddr, 0, sizeof(raddr));
@@ -269,10 +269,10 @@ static void phase7_test_timeout(void)
raddr.sin_port = net_htons((uint16_t)PHASE7_REMOTE_PORT);
raddr.sin_addr.s_addr = net_inet_addr(PHASE7_REMOTE_IP);
DBG_INFO("TC703 connecting %s:%d (expect TIMEOUT, PC server must be OFF)",
DBG_INFO("TC-NET-703 connecting %s:%d (expect TIMEOUT, PC server must be OFF)",
PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT);
int32_t rc = net_connect(sockfd, (struct net_sockaddr *)&raddr, sizeof(raddr));
TEST_CHECK(rc == 0, "TC703 connect issued (ret=%d)", rc);
TEST_CHECK(rc == 0, "TC-NET-703 connect issued (ret=%d)", rc);
if (rc != 0) { net_close(sockfd); return; }
int32_t established = 0;
@@ -284,14 +284,14 @@ static void phase7_test_timeout(void)
osDelay(100); /* 仅作等待/让出 CPU；连接状态由 netTask 的 net_poll 每 10ms 刷新 */
}
if (established) {
TEST_CHECK(0, "TC703 connected?! stop PC server and retry");
TEST_CHECK(0, "TC-NET-703 connected?! stop PC server and retry");
} else {
TEST_CHECK(1, "TC703 no-connect within %dms (timeout as expected)", PHASE7_TIMEOUT_TEST_MS);
TEST_CHECK(1, "TC-NET-703 no-connect within %dms (timeout as expected)", PHASE7_TIMEOUT_TEST_MS);
}
net_close(sockfd);
}
/* TC 704：多 Socket 并发 TCP Client。
/* TC-NET-704：多 Socket 并发 TCP Client。
* 并发上限 = NET_MAX_SOCKETS(8) − 3 个常驻监听（FTP / 对时 / 远显）= 5；
* 本用例同时打开 Socket 0~4，各自连 PC echo server，每路独立收发
* PHASE7_EXCH_SIZE 字节回显并比对，验证 5 个 Socket 均能独立工作。
@@ -315,7 +315,7 @@ static int32_t phase7_session_multi(void)
for (int32_t i = 0; i < PHASE7_MULTI_COUNT; i++) {
sockfd[i] = net_socket(NET_AF_INET, NET_SOCK_STREAM);
if (sockfd[i] < 0) {
TEST_CHECK(0, "TC704 socket create #%d", i);
TEST_CHECK(0, "TC-NET-704 socket create #%d", i);
for (int32_t j = 0; j < i; j++) net_close(sockfd[j]);
return 0;
}
@@ -324,7 +324,7 @@ static int32_t phase7_session_multi(void)
laddr.sin_family = NET_AF_INET;
laddr.sin_port = net_htons((uint16_t)(PHASE7_MULTI_BASE_PORT + i));
if (net_bind(sockfd[i], (struct net_sockaddr *)&laddr, sizeof(laddr)) < 0) {
TEST_CHECK(0, "TC704 bind #%d port %d", i, PHASE7_MULTI_BASE_PORT + i);
TEST_CHECK(0, "TC-NET-704 bind #%d port %d", i, PHASE7_MULTI_BASE_PORT + i);
net_close(sockfd[i]);
for (int32_t j = 0; j < i; j++) net_close(sockfd[j]);
return 0;
@@ -335,7 +335,7 @@ static int32_t phase7_session_multi(void)
raddr.sin_port = net_htons((uint16_t)PHASE7_REMOTE_PORT);
raddr.sin_addr.s_addr = net_inet_addr(PHASE7_REMOTE_IP);
int32_t rc = net_connect(sockfd[i], (struct net_sockaddr *)&raddr, sizeof(raddr));
TEST_CHECK(rc == 0, "TC704 connect #%d issued (ret=%d)", i, rc);
TEST_CHECK(rc == 0, "TC-NET-704 connect #%d issued (ret=%d)", i, rc);
if (rc != 0) {
net_close(sockfd[i]);
for (int32_t j = 0; j < i; j++) net_close(sockfd[j]);
@@ -356,11 +356,11 @@ static int32_t phase7_session_multi(void)
if (all_up) break;
osDelay(100);
}
TEST_CHECK(all_up, "TC704 all %d sockets established within %dms", PHASE7_MULTI_COUNT, PHASE7_CONN_TIMEOUT_MS);
TEST_CHECK(all_up, "TC-NET-704 all %d sockets established within %dms", PHASE7_MULTI_COUNT, PHASE7_CONN_TIMEOUT_MS);
if (!all_up) {
for (int32_t i = 0; i < PHASE7_MULTI_COUNT; i++) {
net_sock_t *sk = net_get_sock(sockfd[i]);
if (sk) DBG_ERROR("TC704 socket #%d state=%d", i, sk->state);
if (sk) DBG_ERROR("TC-NET-704 socket #%d state=%d", i, sk->state);
net_close(sockfd[i]);
}
return 0;
@@ -372,7 +372,7 @@ static int32_t phase7_session_multi(void)
for (int32_t i = 0; i < PHASE7_MULTI_COUNT; i++) {
int32_t sent = net_send(sockfd[i], tx, PHASE7_EXCH_SIZE, 0);
if (sent != PHASE7_EXCH_SIZE) {
TEST_CHECK(0, "TC704 socket #%d send %dB (sent=%d)", i, PHASE7_EXCH_SIZE, sent);
TEST_CHECK(0, "TC-NET-704 socket #%d send %dB (sent=%d)", i, PHASE7_EXCH_SIZE, sent);
ok = 0;
continue;
}
@@ -393,9 +393,9 @@ static int32_t phase7_session_multi(void)
if (sock_ok) {
int32_t bad = 0;
for (int32_t k = 0; k < PHASE7_EXCH_SIZE; k++) if (rx[k] != (uint8_t)k) { bad = 1; break; }
TEST_CHECK(!bad, "TC704 socket #%d echo %dB OK", i, PHASE7_EXCH_SIZE);
TEST_CHECK(!bad, "TC-NET-704 socket #%d echo %dB OK", i, PHASE7_EXCH_SIZE);
} else {
TEST_CHECK(0, "TC704 socket #%d recv %dB (expect %d)", i, recvd, PHASE7_EXCH_SIZE);
TEST_CHECK(0, "TC-NET-704 socket #%d recv %dB (expect %d)", i, recvd, PHASE7_EXCH_SIZE);
ok = 0;
}
}
@@ -410,23 +410,23 @@ void net_layer_client_test_main(void)
{
DBG_INFO("=== CH395F Phase 7 Tests (NET TCP Client) ===");
DBG_INFO("--- TC 701: connect + %dB echo exchange ---", PHASE7_EXCH_SIZE);
DBG_INFO("--- TC-NET-701: connect + %dB echo exchange ---", PHASE7_EXCH_SIZE);
phase7_session((uint16_t)PHASE7_LOCAL_PORT);
DBG_INFO("--- TC 702: close/reconnect x%d ---", PHASE7_LOOP_COUNT);
DBG_INFO("--- TC-NET-702: close/reconnect x%d ---", PHASE7_LOOP_COUNT);
{
int32_t all_ok = 1;
for (int32_t i = 0; i < PHASE7_LOOP_COUNT; i++) {
if (!phase7_session((uint16_t)(PHASE7_LOCAL_PORT + 1 + i))) all_ok = 0;
}
TEST_CHECK(all_ok, "TC702 reconnect x%d all passed", PHASE7_LOOP_COUNT);
TEST_CHECK(all_ok, "TC-NET-702 reconnect x%d all passed", PHASE7_LOOP_COUNT);
}
DBG_INFO("--- TC 704: %d-socket concurrent client (PC %s:%d MUST be ON) ---",
DBG_INFO("--- TC-NET-704: %d-socket concurrent client (PC %s:%d MUST be ON) ---",
PHASE7_MULTI_COUNT, PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT);
phase7_session_multi();
DBG_INFO("--- TC 703: connect timeout (PC %s:%d MUST be OFF) ---",
DBG_INFO("--- TC-NET-703: connect timeout (PC %s:%d MUST be OFF) ---",
PHASE7_REMOTE_IP, PHASE7_REMOTE_PORT);
phase7_test_timeout();
test/board/net_test_task.h
+1 -1
View File
@@ -12,7 +12,7 @@ void net_layer_test_main(void);
/* NET 层 TCP Client 测试入口（定义于 net_test_task.c）。
* 由 ch395fTestTask 在 NET 层构建模式下（ENABLE_PHASE7_TESTS）调用，
* MCU 作为 TCP Client 主动连接 PC 回显服务器，覆盖 TC 701/702/703。 */
* MCU 作为 TCP Client 主动连接 PC 回显服务器，覆盖 TC-NET-701/702/703。 */
void net_layer_client_test_main(void);
#ifdef __cplusplus
test/host/ch395f_socket_test.py
+3 -3
View File
@@ -158,8 +158,8 @@ def _echo_conn_handler(conn_idx, client_socket, counters, lock):
def tcp_server_test(args):
"""TCP 回显服务器测试（测试 CH395F TCP Client）
与固件 TC701/702/704 配套：MCU 连接后发送数据并等待原样回显。
每个连接由独立线程处理，支持多 Socket 并发（TC704 一次打开 8 个）。
与固件 TC-NET-701/702/704 配套：MCU 连接后发送数据并等待原样回显。
每个连接由独立线程处理，支持多 Socket 并发（TC-NET-704 一次打开 8 个）。
首个连接等待 args.timeout 秒；之后每个连接间最多等待 INTER_ACCEPT_TIMEOUT 秒；
若指定 --max-conn（>0），达到连接数上限后停止接受并等待全部线程结束。
@@ -1267,7 +1267,7 @@ def main():
parser.add_argument('--op', choices=['send', 'recv', 'echo'], default='recv',
help='tcp_file 方向: send=读文件发往 MCU, recv=从 MCU 收文件落盘, echo=连 MCU 回显')
parser.add_argument('--file', default=None, help='tcp_file 文件路经（send: 读取; recv: 写入）')
parser.add_argument('--max-conn', type=int, default=0, help='最大并发连接数（默认0=不限；按并发计数，非累计，TC704 并发测试用 8）')
parser.add_argument('--max-conn', type=int, default=0, help='最大并发连接数（默认0=不限；按并发计数，非累计，TC-NET-704 并发测试用 8）')
parser.add_argument('--dhcp-iface', default='192.168.1.2', help='DHCP 服务器网卡 IP')
parser.add_argument('--dhcp-mask', default='255.255.255.0', help='DHCP 分配的子网掩码')
parser.add_argument('--dhcp-gw', default='192.168.1.1', help='DHCP 分配的网关')