7d1db02164
104 协议侧参数通道此前镜像了厂商点表的全部 430 条参数(697 槽), 但其中 413 条在本设备上没有任何消费者——104 与设备侧真实定值模型 prot_set 之间零调用,主站改定值只落在无人读的 RAM 镜像里,保护功能 毫无感知。本次按"严格按消费者收窄"口径收口: 可见性以 iec104_dtu_protection_mapping() 语义桥表为唯一判据,只放行 三段过流投退/定值/延时(9 项)、低压与过压定值/延时(4 项)、PT 与 CT 一次/二次额定(4 项)。其余参数在位表枚举层即不可见,主站读取 得到 COT=47 + P/N=1 的显式否定确认,不静默丢弃。values[697]→values[53]、 staged[264]→staged[17],并删除生成式 iec104_source_ranks.h。 桥表接真实源:iec104_serv 的 parameter_read/apply 从 NULL 改为直读 prot_set 与整批原子提交,Q10 量化后一次事务落地,持久化仍由 defaultTask 的脏标志闭环负责。 prot_set 因此出现两个运行时写者(netTask 的 104 与 uiTask 的本地整 定),原"写者靠启动时序串行"的约定失效。加入写事务互斥与 seqlock 序号:四个写入口全部进锁,校验与提前返回一律在 enter 之前;序号卡 奇数连续 8 拍即判保护闭锁,避免自检被永久跳过而静默失去防篡改能力。 锁的安装在 defaultTask 的存储 bring-up 阶段,不在 app_main_init—— 后者早于 osKernelInitialize,内核启动前禁止任何 RTOS 创建类 API。 实测:RW_IRAM1 117,304→113,720 B(−3,584 B,89.50%→86.76%); ER_IROM1 413,392→411,668 B(−1,724 B);iec104_source.o 5,656→2,056 B; prot_set.o 344→352 B(+8 B,写事务序号与锁句柄)。Keil 构建 0 错误 0 警告;主机侧 prot_set 175/175、iec104_dtu 7/7;真实 TCP 验收 13/13;暂存口径门禁 18 项全通过。 已知边界:模拟器不链接 iec104_serv.c,TCP 验收不覆盖 prot_set 绑定, 板端需实机确认主站写入能反映到本地定值页;17 项中 15 项的出厂默认 值与点表字面量不同,主站读到的是真实模型的值;绑定真实源后定值区 切换一律拒绝(单套活跃值无原子整区事务)。
849 lines
37 KiB
C
849 lines
37 KiB
C
/*
|
||
* 模块名称:保护定值模型(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 <stdint.h>
|
||
#include <stdio.h>
|
||
|
||
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;
|
||
}
|