perf(iec104): 参数区按 17 项真实消费者收窄并接上真实定值模型

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 项的出厂默认
值与点表字面量不同,主站读到的是真实模型的值;绑定真实源后定值区
切换一律拒绝(单套活跃值无原子整区事务)。
This commit is contained in:
2026-11-19 15:48:21 +08:00
parent a40d52a116
commit 7d1db02164
22 changed files with 1235 additions and 328 deletions
+507
View File
@@ -23,6 +23,21 @@
* 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)
@@ -321,6 +336,486 @@ static void tc_of_uf_meta(void) {
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();
@@ -334,6 +829,18 @@ int main(void) {
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);