/* * 模块名称:保护定值模型(P1)主机侧单元测试 * 模块功能:在 PC 上对 App/algo/prot_set.c 做离线验证。 * * 被测对象:真实源文件(#include 原样纳入)。纯逻辑,无需桩。 * * 覆盖点(docs/算法/继电保护功能复现规划.md §5.2 / §3.4 定值校验和): * TC-PROTSET-001 init:默认值装载、越界位图 0、selfcheck 通过、未闭锁 * TC-PROTSET-002 set:范围内写入生效;越界拒写且原值不动 * TC-PROTSET-003 校验和封存语义:set 后未 seal → selfcheck 失败并闭锁; * seal → 通过并解锁(定值校验和 核心闭环) * TC-PROTSET-004 load_raw:合法整表装载并封存;含越界项 → 整表不装载 + * bad_mask 指认越界项(定值一致性:宁可全旧不可半新) * TC-PROTSET-005 Q10 往返精度(±1 LSB) * TC-PROTSET-006 元数据表自检:min<=max、投退项 0..1、非零通讯地址不重复 * TC-PROTSET-007 越界编号守卫(get/set) * TC-PROTSET-008 全局软压板 PS_GLOBAL_EN(B7):默认投入、set_sealed 原子写 * 不破坏 selfcheck、脏标志三件套(peek/take/mark) * TC-PROTSET-009 持久化 blob 往返:serialize → init 清场 → parse 恢复 * (位精确 + 封存自洽 + parse 不置脏) * TC-PROTSET-010 损坏 blob 整表拒绝(all-or-nothing):值区位翻转/坏 magic/ * 截断/超长/坏版本/伪造自洽越界 → 全部拒绝且活跃值区一字不动 * TC-PROTSET-011 OF/UF 定值行(B8):40 项 / blob 版本 2 / 本地项地址 0 / * 默认值与范围 / 返回系数独立性 / 64 位 bad_mask(bit 39)/ * B7 旧档(32 项)换代拒绝 * 批量原子写与写事务锁(104 定值下发接线): * tc_batch_write_and_seal 整批写 3 项 → 读回 / 自检通过 / 未闭锁 / 置脏 * tc_batch_reject_is_all_or_nothing 一项越界 → 整批拒且值区一字未改 * tc_batch_reject_duplicate_id 同批重复 id → 拒 * tc_batch_reject_over_limit 项数超上限 → 拒 * tc_validate_only_has_no_side_effect 预检全合法 → 值区/脏位/锁位/钩子全不动 * tc_validate_only_reports_bad_item 预检有越界 → 拒且全不动 * tc_read_batch_guards 正常读回;越界 id / n 为 0 / 空指针 → 拒 * tc_write_lock_pairs 成功写 enter/exit 各一次;预检与失败分支不进钩子 * tc_selfcheck_tolerates_commit_window 提交窗口内自检只跳过、不误锁 * tc_lock_uninstall 卸载钩子后仍能正常写 * tc_selfcheck_odd_streak_failsafe 写者永久停在提交窗口内 → 8 拍宽限后闭锁 * (fail-safe;用故意漏 exit 的缺陷写者样本驱动) * tc_bad_mask_tracks_whole_table_only 位图只跟整表装载/解析走,增量写入 * 既不置也不清(契约钉死) * * 通过:全部 TC PASS(main 返回 0)。 * 创建日期:2026-10-11;2026-10-12 扩 OF/UF(B8) */ #include #include 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 "prot_set.c" /* TC-PROTSET-001 */ static void tc_init(void) { prot_set_init(); CHECK(prot_set_bad_mask() == 0u, "TC-PROTSET-001 init: no bad items"); CHECK(prot_set_selfcheck() == 0, "TC-PROTSET-001 init: selfcheck pass"); CHECK(prot_set_locked() == 0u, "TC-PROTSET-001 init: not locked"); CHECK(prot_set_get_f(PS_OC1_CUR) > 9.99f && prot_set_get_f(PS_OC1_CUR) < 10.01f, "TC-PROTSET-001 default OC1 current = 10.0 A"); CHECK(prot_set_get_ctl(PS_OC3_TRIP) == 0u, "TC-PROTSET-001 default OC3 = alarm (trip off)"); } /* TC-PROTSET-002 */ static void tc_set_range(void) { prot_set_init(); CHECK(prot_set_set(PS_OC2_CUR, PROT_SET_Q10(7.5)) == 0, "TC-PROTSET-002 in-range set accepted"); CHECK(prot_set_get_f(PS_OC2_CUR) > 7.49f && prot_set_get_f(PS_OC2_CUR) < 7.51f, "TC-PROTSET-002 value readable after set"); CHECK(prot_set_set(PS_OC2_CUR, PROT_SET_Q10(101.0)) == -1, "TC-PROTSET-002 over-max set rejected"); CHECK(prot_set_get_f(PS_OC2_CUR) > 7.49f && prot_set_get_f(PS_OC2_CUR) < 7.51f, "TC-PROTSET-002 rejected set leaves value unchanged"); CHECK(prot_set_set(PS_OC1_EN, PROT_SET_Q10(2)) == -1, "TC-PROTSET-002 ctl item rejects value 2"); } /* TC-PROTSET-003 */ static void tc_seal_selfcheck(void) { prot_set_init(); CHECK(prot_set_set(PS_OC1_CUR, PROT_SET_Q10(8.0)) == 0, "TC-PROTSET-003 set ok"); CHECK(prot_set_selfcheck() == -1, "TC-PROTSET-003 set-without-seal => selfcheck FAIL (tamper detect)"); CHECK(prot_set_locked() == 1u, "TC-PROTSET-003 selfcheck failure latches lock"); prot_set_seal(); CHECK(prot_set_selfcheck() == 0, "TC-PROTSET-003 seal => selfcheck pass"); CHECK(prot_set_locked() == 0u, "TC-PROTSET-003 seal clears lock"); } /* TC-PROTSET-004 */ static void tc_load_raw(void) { int32_t tbl[PS_ID_COUNT]; uint32_t i; prot_set_init(); for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) { tbl[i] = prot_set_get((prot_set_id_t)i); } tbl[PS_OL_CUR] = PROT_SET_Q10(1.5); CHECK(prot_set_load_raw(tbl) == 0, "TC-PROTSET-004 valid table loads"); CHECK(prot_set_get_f(PS_OL_CUR) > 1.49f && prot_set_get_f(PS_OL_CUR) < 1.51f, "TC-PROTSET-004 loaded value visible"); CHECK(prot_set_selfcheck() == 0, "TC-PROTSET-004 load_raw auto-seals"); tbl[PS_OC3_DLY] = PROT_SET_Q10(60001.0); /* 越上限 */ tbl[PS_OL_CUR] = PROT_SET_Q10(2.5); /* 合法改动 */ CHECK(prot_set_load_raw(tbl) == -1, "TC-PROTSET-004 bad table rejected"); CHECK(prot_set_bad_mask() == (1uLL << PS_OC3_DLY), "TC-PROTSET-004 bad_mask points at the offending item"); CHECK(prot_set_get_f(PS_OL_CUR) > 1.49f && prot_set_get_f(PS_OL_CUR) < 1.51f, "TC-PROTSET-004 rejected load keeps OLD table (all-or-nothing)"); CHECK(prot_set_load_raw(0) == -1, "TC-PROTSET-004 NULL table rejected"); } /* TC-PROTSET-005 */ static void tc_q10_roundtrip(void) { float v = 12.345f; int32_t q; prot_set_init(); q = PROT_SET_Q10(v); CHECK(prot_set_set(PS_OC1_CUR, q) == 0, "TC-PROTSET-005 set ok"); { float back = prot_set_get_f(PS_OC1_CUR); float err = back - v; if (err < 0.0f) { err = -err; } CHECK(err < 0.001f, "TC-PROTSET-005 Q10 roundtrip error < 1 LSB"); } } /* TC-PROTSET-006 */ static void tc_meta_sanity(void) { uint32_t i, j; int ok_range = 1, ok_ctl = 1, ok_addr = 1; for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) { const prot_set_meta_t *m = &g_prot_set_meta[i]; if (m->min > m->max) { ok_range = 0; } if ((m->def < m->min) || (m->def > m->max)) { ok_range = 0; } if ((m->is_ctl != 0u) && ((m->min != 0) || (m->max != PROT_SET_Q10(1)))) { ok_ctl = 0; } if (m->comm_addr == 0u) { continue; } for (j = i + 1u; j < (uint32_t)PS_ID_COUNT; j++) { if (g_prot_set_meta[j].comm_addr == m->comm_addr) { ok_addr = 0; } } } CHECK(ok_range, "TC-PROTSET-006 meta: min<=def<=max for all items"); CHECK(ok_ctl, "TC-PROTSET-006 meta: ctl items are 0..1"); CHECK(ok_addr, "TC-PROTSET-006 meta: comm addresses unique"); CHECK((uint32_t)PS_ID_COUNT <= 64u, "TC-PROTSET-006 item count fits 64-bit bad_mask (B8: 40)"); } /* TC-PROTSET-007 */ static void tc_id_guard(void) { prot_set_init(); CHECK(prot_set_get(PS_ID_COUNT) == 0, "TC-PROTSET-007 get out-of-range id -> 0"); CHECK(prot_set_set(PS_ID_COUNT, 0) == -1, "TC-PROTSET-007 set out-of-range id -> -1"); CHECK(prot_set_set_sealed(PS_ID_COUNT, 0) == -1, "TC-PROTSET-007 set_sealed id guard"); } /* TC-PROTSET-008(B7:全局软压板 + 原子写 + 脏标志) */ static void tc_global_plate_dirty(void) { prot_set_init(); CHECK(prot_set_dirty_peek() == 0u, "TC-PROTSET-008 init not dirty"); CHECK(prot_set_get_ctl(PS_GLOBAL_EN) == 1u, "TC-PROTSET-008 global plate default IN"); CHECK(prot_set_set(PS_GLOBAL_EN, PROT_SET_Q10(2)) == -1, "TC-PROTSET-008 plate rejects 2"); CHECK(prot_set_set_sealed(PS_GLOBAL_EN, 0) == 0, "TC-PROTSET-008 plate OUT via set_sealed"); CHECK(prot_set_get_ctl(PS_GLOBAL_EN) == 0u, "TC-PROTSET-008 plate OUT readable"); CHECK(prot_set_selfcheck() == 0, "TC-PROTSET-008 set_sealed leaves selfcheck PASS (no unsealed window)"); CHECK(prot_set_locked() == 0u, "TC-PROTSET-008 set_sealed no lock"); CHECK(prot_set_dirty_peek() == 1u, "TC-PROTSET-008 set_sealed marks dirty"); CHECK(prot_set_dirty_take() == 1u, "TC-PROTSET-008 dirty take consumes"); CHECK(prot_set_dirty_peek() == 0u, "TC-PROTSET-008 dirty cleared after take"); prot_set_dirty_mark(); CHECK(prot_set_dirty_peek() == 1u, "TC-PROTSET-008 dirty mark re-arms (write-fail retry)"); CHECK(prot_set_set_sealed(PS_GLOBAL_EN, PROT_SET_Q10(2)) == -1, "TC-PROTSET-008 set_sealed range check"); CHECK(prot_set_get_ctl(PS_GLOBAL_EN) == 0u, "TC-PROTSET-008 rejected set_sealed keeps value"); } /* TC-PROTSET-009(B7:blob 往返) */ static void tc_store_roundtrip(void) { uint8_t blob[PROT_SET_BLOB_SZ]; uint32_t len = 0u; int32_t cur; prot_set_init(); (void)prot_set_set_sealed(PS_OC1_CUR, PROT_SET_Q10(12.5)); (void)prot_set_set_sealed(PS_GLOBAL_EN, 0); (void)prot_set_dirty_take(); cur = prot_set_get(PS_OC1_CUR); CHECK(prot_set_store_serialize(blob, sizeof(blob), &len) == 0, "TC-PROTSET-009 serialize ok"); CHECK(len == (uint32_t)PROT_SET_BLOB_SZ, "TC-PROTSET-009 blob exact size"); prot_set_init(); CHECK(prot_set_get(PS_OC1_CUR) != cur, "TC-PROTSET-009 init wiped to defaults"); CHECK(prot_set_store_parse(blob, len) == 0, "TC-PROTSET-009 parse ok"); CHECK(prot_set_get(PS_OC1_CUR) == cur, "TC-PROTSET-009 value round-trip bit-exact"); CHECK(prot_set_get_ctl(PS_GLOBAL_EN) == 0u, "TC-PROTSET-009 plate state round-trip"); CHECK(prot_set_selfcheck() == 0, "TC-PROTSET-009 parsed table sealed"); CHECK(prot_set_dirty_peek() == 0u, "TC-PROTSET-009 parse does not mark dirty"); } /* 伪造辅助:按 blob 值区重算尾部 sum/sumn(构造"自洽但越界"的对抗样本) */ static void s_forge_tail(uint8_t *b, uint32_t len) { uint32_t sum = 0u; uint32_t inv; uint32_t i; for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) { sum += s_get32(b + PROT_SET_BLOB_HDR_SZ + 4u * i); } inv = ~sum; s_put32(b + len - 8u, sum); s_put32(b + len - 4u, inv); } /* TC-PROTSET-010(B7:损坏 blob 整表拒绝,all-or-nothing) */ static void tc_store_corrupt(void) { uint8_t blob[PROT_SET_BLOB_SZ]; uint32_t len = 0u; int32_t keep; prot_set_init(); (void)prot_set_set_sealed(PS_OC2_CUR, PROT_SET_Q10(6.0)); keep = prot_set_get(PS_OC2_CUR); CHECK(prot_set_store_serialize(blob, sizeof(blob), &len) == 0, "TC-PROTSET-010 serialize ok"); blob[PROT_SET_BLOB_HDR_SZ] ^= 0x01u; /* 值区一位翻转:sum 对不符 */ CHECK(prot_set_store_parse(blob, len) == -1, "TC-PROTSET-010 flipped value byte rejected (sum pair)"); CHECK(prot_set_get(PS_OC2_CUR) == keep, "TC-PROTSET-010 reject leaves values untouched"); (void)prot_set_store_serialize(blob, sizeof(blob), &len); blob[0] ^= 0xFFu; /* magic 破坏 */ CHECK(prot_set_store_parse(blob, len) == -1, "TC-PROTSET-010 bad magic rejected"); (void)prot_set_store_serialize(blob, sizeof(blob), &len); CHECK(prot_set_store_parse(blob, len - 4u) == -1, "TC-PROTSET-010 truncated blob rejected"); CHECK(prot_set_store_parse(blob, len + 4u) == -1, "TC-PROTSET-010 oversized blob rejected"); (void)prot_set_store_serialize(blob, sizeof(blob), &len); blob[5] ^= 0x02u; /* version 高字节:1 -> 0x200 */ CHECK(prot_set_store_parse(blob, len) == -1, "TC-PROTSET-010 version mismatch rejected"); /* 对抗样本:越限定值 + 重算 sum 对(校验全过、范围必拦) */ (void)prot_set_store_serialize(blob, sizeof(blob), &len); s_put32(blob + PROT_SET_BLOB_HDR_SZ + 4u * (uint32_t)PS_OC1_CUR, (uint32_t)(g_prot_set_meta[PS_OC1_CUR].max + 1)); s_forge_tail(blob, len); CHECK(prot_set_store_parse(blob, len) == -1, "TC-PROTSET-010 forged consistent out-of-range rejected"); CHECK(prot_set_bad_mask() == (1uLL << PS_OC1_CUR), "TC-PROTSET-010 bad_mask points at item"); CHECK(prot_set_get(PS_OC1_CUR) == PROT_SET_Q10(10.0), "TC-PROTSET-010 defaults still intact"); CHECK(prot_set_selfcheck() == 0, "TC-PROTSET-010 active table still self-consistent after all rejects"); } /* TC-PROTSET-011(B8:OF/UF 定值行 + 40 项 + 64 位 bad_mask + 换代拒绝) */ static void tc_of_uf_meta(void) { uint8_t blob[PROT_SET_BLOB_SZ]; uint32_t len = 0u; prot_set_init(); /* 结构:40 项、blob 版本 2、尺寸随项数自适应 */ CHECK((uint32_t)PS_ID_COUNT == 40u, "TC-PROTSET-011 PS_ID_COUNT == 40 (32 + 8 OF/UF)"); CHECK(PROT_SET_BLOB_VER == 2u, "TC-PROTSET-011 blob version bumped to 2 (B8)"); CHECK((uint32_t)PROT_SET_BLOB_SZ == (PROT_SET_BLOB_HDR_SZ + 4u * 40u + 8u), "TC-PROTSET-011 blob size = hdr + 4*40 + tail"); /* 地址:参考逐项地址不在本仓库 -> 8 项全部本地项(comm_addr=0,104 不可寻址) */ CHECK((g_prot_set_meta[PS_OF_EN].comm_addr == 0u) && (g_prot_set_meta[PS_OF_HZ].comm_addr == 0u) && (g_prot_set_meta[PS_OF_DLY].comm_addr == 0u) && (g_prot_set_meta[PS_UF_EN].comm_addr == 0u) && (g_prot_set_meta[PS_UF_HZ].comm_addr == 0u) && (g_prot_set_meta[PS_UF_DLY].comm_addr == 0u) && (g_prot_set_meta[PS_RET_OF].comm_addr == 0u) && (g_prot_set_meta[PS_RET_UF].comm_addr == 0u), "TC-PROTSET-011 OF/UF items all local (comm_addr=0, pending reference table)"); /* 投退 = ctl 项(0/1),其余 = 模拟量 Q10 */ CHECK((g_prot_set_meta[PS_OF_EN].is_ctl == 1u) && (g_prot_set_meta[PS_UF_EN].is_ctl == 1u) && (g_prot_set_meta[PS_OF_HZ].is_ctl == 0u) && (g_prot_set_meta[PS_RET_UF].is_ctl == 0u), "TC-PROTSET-011 EN items are ctl, HZ/DLY/RET are Q10 analog"); /* 出厂默认(拟定值)与范围 */ CHECK(prot_set_get(PS_OF_EN) == PROT_SET_Q10(1.0), "TC-PROTSET-011 OF EN default 1"); CHECK(prot_set_get(PS_UF_EN) == PROT_SET_Q10(1.0), "TC-PROTSET-011 UF EN default 1"); CHECK(prot_set_get(PS_OF_HZ) == PROT_SET_Q10(51.0), "TC-PROTSET-011 OF default 51.0 Hz"); CHECK(prot_set_get(PS_UF_HZ) == PROT_SET_Q10(49.0), "TC-PROTSET-011 UF default 49.0 Hz"); CHECK(prot_set_get(PS_OF_DLY) == PROT_SET_Q10(1000.0), "TC-PROTSET-011 OF default 1000 ms"); CHECK(prot_set_get(PS_UF_DLY) == PROT_SET_Q10(1000.0), "TC-PROTSET-011 UF default 1000 ms"); CHECK(prot_set_get(PS_RET_OF) == PROT_SET_Q10(0.99), "TC-PROTSET-011 RET_OF default 0.99"); CHECK(prot_set_get(PS_RET_UF) == PROT_SET_Q10(1.01), "TC-PROTSET-011 RET_UF default 1.01"); CHECK((g_prot_set_meta[PS_OF_HZ].min == PROT_SET_Q10(50.0)) && (g_prot_set_meta[PS_OF_HZ].max == PROT_SET_Q10(55.0)), "TC-PROTSET-011 OF range 50.0~55.0 Hz"); CHECK((g_prot_set_meta[PS_UF_HZ].min == PROT_SET_Q10(45.0)) && (g_prot_set_meta[PS_UF_HZ].max == PROT_SET_Q10(50.0)), "TC-PROTSET-011 UF range 45.0~50.0 Hz"); /* 频率返回系数与电气量系数独立:返回**门槛** = 定值×系数(Q10 乘积 * /1024)——OF 门槛 < 动作门槛、UF 门槛 > 动作门槛(方向相反) */ CHECK(((int64_t)prot_set_get(PS_OF_HZ) * (int64_t)prot_set_get(PS_RET_OF)) / 1024 < (int64_t)prot_set_get(PS_OF_HZ), "TC-PROTSET-011 OF return threshold (set x 0.99) below pickup"); CHECK(((int64_t)prot_set_get(PS_UF_HZ) * (int64_t)prot_set_get(PS_RET_UF)) / 1024 > (int64_t)prot_set_get(PS_UF_HZ), "TC-PROTSET-011 UF return threshold (set x 1.01) above pickup"); /* 投退可经 set_sealed 投/退(YK 口径同 GLOBAL_EN;Q10(2)=2048 越界拒) */ CHECK(prot_set_set_sealed(PS_OF_EN, 0) == 0, "TC-PROTSET-011 OF EN set_sealed OK"); CHECK(prot_set_get_ctl(PS_OF_EN) == 0u, "TC-PROTSET-011 OF EN readable after seal"); CHECK(prot_set_set_sealed(PS_OF_EN, PROT_SET_Q10(2)) == -1, "TC-PROTSET-011 OF EN rejects Q10(2)"); CHECK(prot_set_selfcheck() == 0, "TC-PROTSET-011 no lock after OF/UF seal ops"); /* 64 位 bad_mask:末项(bit 39 > 31)越界可指认 */ (void)prot_set_set_sealed(PS_OC1_CUR, PROT_SET_Q10(11.0)); (void)prot_set_dirty_take(); CHECK(prot_set_store_serialize(blob, sizeof(blob), &len) == 0, "TC-PROTSET-011 serialize ok"); s_put32(blob + PROT_SET_BLOB_HDR_SZ + 4u * (uint32_t)PS_RET_UF, (uint32_t)(g_prot_set_meta[PS_RET_UF].max + 1)); s_forge_tail(blob, len); CHECK(prot_set_store_parse(blob, len) == -1, "TC-PROTSET-011 out-of-range RET_UF rejected"); CHECK(prot_set_bad_mask() == (1uLL << PS_RET_UF), "TC-PROTSET-011 bad_mask bit 39 addressable (64-bit mask, B8)"); CHECK(prot_set_get(PS_RET_UF) == PROT_SET_Q10(1.01), "TC-PROTSET-011 default RET_UF intact"); /* 换代语义:B7 旧档(ver=1 / 32 项 = 144 B)在新固件必被拒 -> 出厂默认 */ CHECK(prot_set_store_parse(blob, 8u + 4u * 32u + 8u) == -1, "TC-PROTSET-011 legacy 32-item blob length rejected"); CHECK(prot_set_selfcheck() == 0, "TC-PROTSET-011 active table intact after legacy reject"); } /* 整表快照:值区 + 脏位 + 闭锁位("一字未改"与"零副作用"的比对基准) */ typedef struct { int32_t vals[PS_ID_COUNT]; uint8_t dirty; uint8_t locked; } tc_snapshot_t; /* * 函数功能:把当前定值状态拍成快照 * 入口参数:s - 输出快照 * 返 回 值:无 */ static void tc_snapshot(tc_snapshot_t *s) { uint32_t i; for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) { s->vals[i] = prot_set_get((prot_set_id_t)i); } s->dirty = prot_set_dirty_peek(); s->locked = prot_set_locked(); } /* * 函数功能:比对两份快照是否逐字相同 * 入口参数:a/b - 待比快照 * 返 回 值:1 完全相同 / 0 有差异 */ static int tc_snapshot_same(const tc_snapshot_t *a, const tc_snapshot_t *b) { uint32_t i; if ((a->dirty != b->dirty) || (a->locked != b->locked)) { return 0; } for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) { if (a->vals[i] != b->vals[i]) { return 0; } } return 1; } /* 计数版写事务钩子:证明"哪条分支真的进了临界区" */ static int s_hook_enter = 0; static int s_hook_exit = 0; /* * 函数功能:计数钩子——进入写事务 * 入口参数:无 * 返 回 值:无 */ static void tc_hook_enter(void) { s_hook_enter++; } /* * 函数功能:计数钩子——退出写事务 * 入口参数:无 * 返 回 值:无 */ static void tc_hook_exit(void) { s_hook_exit++; } static const prot_set_lock_t s_test_lock = { tc_hook_enter, tc_hook_exit }; /* * 函数功能:装钩子并清零计数 * 入口参数:无 * 返 回 值:无 */ static void tc_lock_on(void) { s_hook_enter = 0; s_hook_exit = 0; prot_set_lock_install(&s_test_lock); } /* 批量写:正常整批提交的闭环(值/自检/闭锁/脏位) */ static void tc_batch_write_and_seal(void) { prot_set_change_t chg[3]; prot_set_id_t ids[3]; int32_t got[3]; prot_set_init(); prot_set_lock_install(0); CHECK(prot_set_dirty_peek() == 0u, "batch write: clean table before commit"); chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(7.5); chg[1].id = PS_OC2_DLY; chg[1].q10 = PROT_SET_Q10(250.0); chg[2].id = PS_GLOBAL_EN; chg[2].q10 = 0; CHECK(prot_set_apply_batch(chg, 3u, 0) == 0, "batch write: three items committed"); CHECK(prot_set_get(PS_OC1_CUR) == PROT_SET_Q10(7.5), "batch write: OC1 current updated"); CHECK(prot_set_get(PS_OC2_DLY) == PROT_SET_Q10(250.0), "batch write: OC2 delay updated"); CHECK(prot_set_get_ctl(PS_GLOBAL_EN) == 0u, "batch write: global plate switched out"); CHECK(prot_set_selfcheck() == 0, "batch write: selfcheck passes right after commit"); CHECK(prot_set_locked() == 0u, "batch write: no lock after commit"); CHECK(prot_set_dirty_peek() == 1u, "batch write: commit marks dirty for persistence"); ids[0] = PS_OC1_CUR; ids[1] = PS_OC2_DLY; ids[2] = PS_GLOBAL_EN; CHECK(prot_set_read_batch(ids, 3u, got) == 0, "batch write: read back same three items"); CHECK((got[0] == PROT_SET_Q10(7.5)) && (got[1] == PROT_SET_Q10(250.0)) && (got[2] == 0), "batch write: read-back values match what was written"); } /* 批量写:一项越界 → 整批拒绝且值区一字未改(all-or-nothing) */ static void tc_batch_reject_is_all_or_nothing(void) { prot_set_change_t chg[3]; tc_snapshot_t before; tc_snapshot_t after; prot_set_init(); prot_set_lock_install(0); (void)prot_set_set_sealed(PS_OC1_CUR, PROT_SET_Q10(9.0)); /* 先建立一个非默认现状 */ (void)prot_set_dirty_take(); tc_snapshot(&before); chg[0].id = PS_OC2_CUR; chg[0].q10 = PROT_SET_Q10(6.0); /* 合法 */ chg[1].id = PS_OC3_DLY; chg[1].q10 = PROT_SET_Q10(60001.0); /* 越上限 */ chg[2].id = PS_OL_CUR; chg[2].q10 = PROT_SET_Q10(2.0); /* 合法 */ CHECK(prot_set_apply_batch(chg, 3u, 0) == -1, "batch reject: one bad item rejects the batch"); tc_snapshot(&after); CHECK(tc_snapshot_same(&before, &after), "batch reject: every item, dirty flag and lock state untouched"); CHECK(prot_set_get(PS_OC1_CUR) == PROT_SET_Q10(9.0), "batch reject: pre-existing value survives the rejected batch"); CHECK(prot_set_selfcheck() == 0, "batch reject: table still self-consistent"); } /* 批量写:同批重复编号 → 拒(语义不确定) */ static void tc_batch_reject_duplicate_id(void) { prot_set_change_t chg[2]; tc_snapshot_t before; tc_snapshot_t after; prot_set_init(); prot_set_lock_install(0); tc_snapshot(&before); chg[0].id = PS_OC2_CUR; chg[0].q10 = PROT_SET_Q10(6.0); chg[1].id = PS_OC2_CUR; chg[1].q10 = PROT_SET_Q10(7.0); CHECK(prot_set_apply_batch(chg, 2u, 0) == -1, "batch reject: duplicate id rejected"); tc_snapshot(&after); CHECK(tc_snapshot_same(&before, &after), "batch reject duplicate: table untouched"); } /* 批量写:项数超上限 → 拒(整表只有 40 项,批量接口不接受更多) */ static void tc_batch_reject_over_limit(void) { prot_set_change_t chg[PROT_SET_BATCH_MAX + 1u]; tc_snapshot_t before; tc_snapshot_t after; size_t i; prot_set_init(); prot_set_lock_install(0); tc_snapshot(&before); for (i = 0u; i < (PROT_SET_BATCH_MAX + 1u); i++) { chg[i].id = (prot_set_id_t)(i % (size_t)PS_ID_COUNT); chg[i].q10 = prot_set_get(chg[i].id); /* 值全合法,只考项数 */ } CHECK(prot_set_apply_batch(chg, PROT_SET_BATCH_MAX + 1u, 0) == -1, "batch reject: item count above limit rejected"); CHECK(prot_set_apply_batch(chg, 0u, 0) == -1, "batch reject: empty batch rejected"); CHECK(prot_set_apply_batch(0, 1u, 0) == -1, "batch reject: NULL change list rejected"); tc_snapshot(&after); CHECK(tc_snapshot_same(&before, &after), "batch reject over limit: table untouched"); } /* 预检(validate_only):全合法时零副作用——值区、脏位、闭锁位、钩子全不动 */ static void tc_validate_only_has_no_side_effect(void) { prot_set_change_t chg[2]; tc_snapshot_t before; tc_snapshot_t after; prot_set_init(); (void)prot_set_set_sealed(PS_OC1_CUR, PROT_SET_Q10(8.0)); (void)prot_set_dirty_take(); tc_lock_on(); tc_snapshot(&before); chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(9.0); chg[1].id = PS_UF_HZ; chg[1].q10 = PROT_SET_Q10(47.0); CHECK(prot_set_apply_batch(chg, 2u, 1) == 0, "validate only: valid batch reported OK"); tc_snapshot(&after); CHECK(tc_snapshot_same(&before, &after), "validate only: values, dirty flag and lock state all unchanged"); CHECK(prot_set_get(PS_OC1_CUR) == PROT_SET_Q10(8.0), "validate only: proposed value NOT applied"); CHECK(prot_set_get(PS_UF_HZ) == PROT_SET_Q10(49.0), "validate only: untouched item keeps its old value"); CHECK((s_hook_enter == 0) && (s_hook_exit == 0), "validate only: write lock hook never entered"); prot_set_lock_install(0); } /* 预检(validate_only):有越界项 → 拒,同样全不动 */ static void tc_validate_only_reports_bad_item(void) { prot_set_change_t chg[2]; tc_snapshot_t before; tc_snapshot_t after; prot_set_init(); tc_lock_on(); tc_snapshot(&before); chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(9.0); chg[1].id = PS_UF_HZ; chg[1].q10 = PROT_SET_Q10(44.0); /* 低于下限 45 */ CHECK(prot_set_apply_batch(chg, 2u, 1) == -1, "validate only: out-of-range item reported"); tc_snapshot(&after); CHECK(tc_snapshot_same(&before, &after), "validate only reject: nothing changed"); CHECK((s_hook_enter == 0) && (s_hook_exit == 0), "validate only reject: write lock hook never entered"); prot_set_lock_install(0); } /* 批量读:正常读回;越界编号 / 零项 / 空指针 → 拒 */ static void tc_read_batch_guards(void) { prot_set_id_t ids[2]; prot_set_id_t bad[1]; int32_t got[2]; prot_set_init(); (void)prot_set_set_sealed(PS_OC2_CUR, PROT_SET_Q10(6.5)); ids[0] = PS_OC2_CUR; ids[1] = PS_RET_UF; got[0] = 0; got[1] = 0; CHECK(prot_set_read_batch(ids, 2u, got) == 0, "read batch: two items read"); CHECK(got[0] == PROT_SET_Q10(6.5), "read batch: first value matches"); CHECK(got[1] == PROT_SET_Q10(1.01), "read batch: second value matches"); bad[0] = PS_ID_COUNT; CHECK(prot_set_read_batch(bad, 1u, got) == -1, "read batch: out-of-range id rejected"); CHECK(prot_set_read_batch(ids, 0u, got) == -1, "read batch: zero count rejected"); CHECK(prot_set_read_batch(0, 2u, got) == -1, "read batch: NULL id list rejected"); CHECK(prot_set_read_batch(ids, 2u, 0) == -1, "read batch: NULL output rejected"); } /* 写事务锁:成功写 enter/exit 各一次;预检与失败分支不进钩子 */ static void tc_write_lock_pairs(void) { prot_set_change_t chg[2]; int32_t tbl[PS_ID_COUNT]; uint32_t i; prot_set_init(); tc_lock_on(); chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(7.0); chg[1].id = PS_OL_CUR; chg[1].q10 = PROT_SET_Q10(1.2); CHECK(prot_set_apply_batch(chg, 2u, 0) == 0, "lock pairs: batch commit succeeds"); CHECK((s_hook_enter == 1) && (s_hook_exit == 1), "lock pairs: batch commit enters and exits the write lock exactly once"); s_hook_enter = 0; s_hook_exit = 0; chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(999.0); /* 越界 */ CHECK(prot_set_apply_batch(chg, 1u, 0) == -1, "lock pairs: out-of-range batch rejected"); CHECK((s_hook_enter == 0) && (s_hook_exit == 0), "lock pairs: rejected batch never enters the write lock"); s_hook_enter = 0; s_hook_exit = 0; CHECK(prot_set_set_sealed(PS_OC2_CUR, PROT_SET_Q10(4.0)) == 0, "lock pairs: single item write succeeds"); CHECK((s_hook_enter == 1) && (s_hook_exit == 1), "lock pairs: single item write enters and exits exactly once"); s_hook_enter = 0; s_hook_exit = 0; CHECK(prot_set_set_sealed(PS_ID_COUNT, 0) == -1, "lock pairs: bad id rejected"); CHECK((s_hook_enter == 0) && (s_hook_exit == 0), "lock pairs: rejected single write never enters the write lock"); for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) { tbl[i] = prot_set_get((prot_set_id_t)i); } tbl[PS_OC3_CUR] = PROT_SET_Q10(3.0); s_hook_enter = 0; s_hook_exit = 0; CHECK(prot_set_load_raw(tbl) == 0, "lock pairs: whole table load succeeds"); CHECK((s_hook_enter == 1) && (s_hook_exit == 1), "lock pairs: whole table load enters and exits exactly once"); s_hook_enter = 0; s_hook_exit = 0; tbl[PS_OC3_CUR] = PROT_SET_Q10(999.0); CHECK(prot_set_load_raw(tbl) == -1, "lock pairs: bad table rejected"); CHECK((s_hook_enter == 0) && (s_hook_exit == 0), "lock pairs: rejected table load never enters the write lock"); prot_set_lock_install(0); } /* 提交窗口内自检不得误判失配(多写者引入的安全级风险) */ static void tc_selfcheck_tolerates_commit_window(void) { uint32_t keep_sum; uint32_t keep_sumn; prot_set_init(); /* 模拟"封存对已改、活跃区未交换"的窗口:这是另一写者抢占时的真实中间态, * 巡检撞上它绝不能闭锁整台保护 */ keep_sum = s_sum; keep_sumn = s_sumn; prot_write_enter(); s_sum = prot_sum_buf(s_val[s_act]) + 1u; s_sumn = ~s_sum; CHECK(prot_set_selfcheck() == 0, "commit window: selfcheck skips instead of latching"); CHECK(prot_set_locked() == 0u, "commit window: no lock latched during commit"); s_sum = keep_sum; s_sumn = keep_sumn; prot_write_exit(); CHECK(prot_set_selfcheck() == 0, "commit window: selfcheck passes once commit settles"); /* 无提交在飞时的真失配仍必须闭锁(防篡改语义不许被上述跳过放宽) */ s_val[s_act][(uint32_t)PS_OC1_CUR] ^= 1u; CHECK(prot_set_selfcheck() == -1, "tamper: real mismatch still caught when idle"); CHECK(prot_set_locked() == 1u, "tamper: real mismatch still latches the lock"); prot_set_init(); CHECK(prot_set_selfcheck() == 0, "tamper: re-init clears the lock"); } /* 卸载钩子后仍能正常写(模拟器 / 主机单测的单写者假设) */ static void tc_lock_uninstall(void) { prot_set_change_t chg[1]; prot_set_init(); tc_lock_on(); prot_set_lock_install(0); s_hook_enter = 0; s_hook_exit = 0; chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(6.25); CHECK(prot_set_apply_batch(chg, 1u, 0) == 0, "lock uninstall: batch commit works without hook"); CHECK(prot_set_get(PS_OC1_CUR) == PROT_SET_Q10(6.25), "lock uninstall: value applied"); CHECK(prot_set_selfcheck() == 0, "lock uninstall: table self-consistent"); CHECK((s_hook_enter == 0) && (s_hook_exit == 0), "lock uninstall: hook not called anymore"); } /* * 缺陷写者样本:**故意**在 prot_write_enter() 之后提前 return、忘了 exit。 * 这是 prot_set.c 里明令禁止的形态(四条真实路径都把校验放在 enter 之前), * 但"以后有人加路径时忘了这条纪律"是真实可能——本用例用它把自检的 fail-safe * 兜底钉死:序号一旦永久停在奇数,防篡改自检必须自己发现写者已死、置闭锁, * 而不是永远"本轮跳过"。 */ static int tc_buggy_writer_early_return(const prot_set_change_t *changes, size_t n) { uint32_t cur_act; prot_write_enter(); if ((n == 0u) || (changes == 0)) { return -1; /* 缺陷:锁内提前返回,没有 prot_write_exit() */ } if ((changes[0].q10 < g_prot_set_meta[changes[0].id].min) || (changes[0].q10 > g_prot_set_meta[changes[0].id].max)) { return -1; /* 缺陷同上 */ } cur_act = s_act; prot_copy_buf(s_val[cur_act ^ 1u], s_val[cur_act]); s_val[cur_act ^ 1u][(uint32_t)changes[0].id] = (uint32_t)changes[0].q10; s_sum = prot_sum_buf(s_val[cur_act ^ 1u]); s_sumn = ~s_sum; s_locked = 0u; s_act = (uint8_t)(cur_act ^ 1u); s_dirty = 1u; prot_write_exit(); return 0; } /* 自检 fail-safe:写者永久停在提交窗口内 → 有界宽限后必须闭锁 */ static void tc_selfcheck_odd_streak_failsafe(void) { prot_set_change_t chg[1]; uint32_t i; int early_ok = 1; int all_clear = 1; prot_set_init(); CHECK(prot_set_selfcheck() == 0, "odd streak: healthy table selfchecks clean"); /* 真实缺陷路径:enter 之后越界提前 return → 序号永久停在奇数 */ chg[0].id = PS_OC1_CUR; chg[0].q10 = g_prot_set_meta[PS_OC1_CUR].max + 1; CHECK(tc_buggy_writer_early_return(chg, 1u) == -1, "odd streak: buggy writer returns -1"); CHECK((s_seq & 1u) == 1u, "odd streak: sequence number left permanently odd"); /* ① 宽限期内的前 7 拍:跳过但不误锁 */ for (i = 0u; i < (uint32_t)(PROT_SET_ODD_STREAK_MAX - 1u); i++) { if ((prot_set_selfcheck() != 0) || (prot_set_locked() != 0u)) { early_ok = 0; } } CHECK(early_ok, "odd streak: first seven ticks skip WITHOUT latching the lock"); /* ② 第 8 拍起:判写者已死 → 闭锁并返回 -1 */ CHECK(prot_set_selfcheck() == -1, "odd streak: eighth tick trips the fail-safe lock"); CHECK(prot_set_locked() == 1u, "odd streak: fail-safe latches the protection lock"); CHECK(prot_set_selfcheck() == -1, "odd streak: lock stays latched on later ticks"); /* ③ 恢复偶数(写者"复活")→ 宽限计数归零,但闭锁仍按既有语义保持到 seal/init */ prot_write_exit(); CHECK((s_seq & 1u) == 0u, "odd streak: sequence number back to even after recovery"); CHECK(prot_set_selfcheck() == -1, "odd streak: lock latched until an explicit seal"); CHECK(s_odd_streak == 0u, "odd streak: grace counter cleared once sequence settles even"); /* ④ fail-safe 的闭锁必须是**可恢复**的:写者恢复后走合法封存路径能解锁, * 否则一次写者崩溃就等于设备永久报废,现场只能整机返修 */ prot_set_seal(); CHECK(prot_set_locked() == 0u, "odd streak: seal is the documented unlock path after a fail-safe lock"); CHECK(prot_set_selfcheck() == 0, "odd streak: selfcheck clean after re-seal"); prot_set_init(); CHECK(s_odd_streak == 0u, "odd streak: init also zeroes the grace counter"); CHECK(prot_set_locked() == 0u, "odd streak: init clears the fail-safe lock"); CHECK(prot_set_selfcheck() == 0, "odd streak: selfcheck healthy again after init"); /* 反复"撞一下立刻恢复"的健康抖动不该累积:每拍都能看到偶数就每次归零 */ for (i = 0u; i < (uint32_t)(PROT_SET_ODD_STREAK_MAX * 3u); i++) { prot_write_enter(); prot_write_exit(); if ((prot_set_selfcheck() != 0) || (prot_set_locked() != 0u)) { all_clear = 0; } } CHECK(all_clear, "odd streak: short commit windows never accumulate into a false lock"); } /* 契约:bad_mask 只跟整表装载/解析走,增量写入既不置也不清 */ static void tc_bad_mask_tracks_whole_table_only(void) { int32_t tbl[PS_ID_COUNT]; prot_set_change_t chg[2]; uint64_t bad_before; uint32_t i; prot_set_init(); CHECK(prot_set_bad_mask() == 0u, "bad mask: clean after init"); for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) { tbl[i] = prot_set_get((prot_set_id_t)i); } tbl[PS_OC3_DLY] = PROT_SET_Q10(60001.0); /* 越上限 */ CHECK(prot_set_load_raw(tbl) == -1, "bad mask: whole-table load with a bad item rejected"); CHECK(prot_set_bad_mask() == (1uLL << PS_OC3_DLY), "bad mask: whole-table load reports the offending item"); bad_before = prot_set_bad_mask(); /* 一笔成功的批量提交不碰位图——这是刻意契约(不是漏刷) */ chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(7.0); chg[1].id = PS_OL_CUR; chg[1].q10 = PROT_SET_Q10(1.5); CHECK(prot_set_apply_batch(chg, 2u, 0) == 0, "bad mask: successful batch committed"); CHECK(prot_set_bad_mask() == bad_before, "bad mask: successful batch leaves the stale bitmap untouched (by contract)"); /* 一笔失败的批量提交同样不碰位图 */ chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(999.0); CHECK(prot_set_apply_batch(chg, 1u, 0) == -1, "bad mask: bad batch rejected"); CHECK(prot_set_bad_mask() == bad_before, "bad mask: failed batch does not record anything in the bitmap"); /* 单项写入同理 */ CHECK(prot_set_set_sealed(PS_OC2_CUR, PROT_SET_Q10(3.0)) == 0, "bad mask: single write ok"); CHECK(prot_set_bad_mask() == bad_before, "bad mask: single write leaves the bitmap untouched"); /* 只有整表操作与 init 会覆写它(用各项出厂默认值组一张必然合法的表) */ for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) { tbl[i] = g_prot_set_meta[i].def; } CHECK(prot_set_load_raw(tbl) == 0, "bad mask: all-legal table load accepted"); CHECK(prot_set_bad_mask() == 0u, "bad mask: successful whole-table load rewrites it to clean"); prot_set_init(); CHECK(prot_set_bad_mask() == 0u, "bad mask: init clears it"); } int main(void) { printf("=== Prot Set Tests ===\n"); tc_init(); tc_set_range(); tc_seal_selfcheck(); tc_load_raw(); tc_q10_roundtrip(); tc_meta_sanity(); tc_id_guard(); tc_global_plate_dirty(); tc_store_roundtrip(); tc_store_corrupt(); tc_of_uf_meta(); tc_batch_write_and_seal(); tc_batch_reject_is_all_or_nothing(); tc_batch_reject_duplicate_id(); tc_batch_reject_over_limit(); tc_validate_only_has_no_side_effect(); tc_validate_only_reports_bad_item(); tc_read_batch_guards(); tc_write_lock_pairs(); tc_selfcheck_tolerates_commit_window(); tc_lock_uninstall(); tc_selfcheck_odd_streak_failsafe(); tc_bad_mask_tracks_whole_table_only(); printf("\n=== Prot Set Tests: %d/%d PASSED (failed=%d) ===\n", s_passed, s_total, s_failed); return (s_failed == 0) ? 0 : 1; }