150 lines
9.1 KiB
JavaScript
150 lines
9.1 KiB
JavaScript
/**
|
||
* test_motor_refresh.mjs — 刷新速度「每链路一份」的自测（Node，无浏览器、无服务）
|
||
*
|
||
* 跑法：node scripts/test_motor_refresh.mjs
|
||
*
|
||
* 测什么：**真的 import 生产代码** js/motor/refresh-rate.js。
|
||
* 这里唯一值得测的是"值会不会串到另一条链路上" —— 那是共用单个变量时
|
||
* 会出的 bug（ECAT 的 50ms 带到 WiFi 上会让 HTTP 请求排队卡顿），
|
||
* 也是旧数据迁移最容易搞错的地方。
|
||
*
|
||
* 覆盖：
|
||
* 1 默认值：wifi 250 / ecat 50，且 defaultRefreshMap 每次给新对象
|
||
* 2 归一 + 钳制：脏值/越界/字符串，**下限按链路**（wifi 50 / ecat 6）
|
||
* 3 旧数据迁移：单个 refreshRate → 只进 wifi，ecat 保持默认
|
||
* 4 取值：缺失/脏值回落该链路默认，不回落成另一条链路的值
|
||
* 5 隔离：改一条链路不影响另一条（这就是本次改动的全部意义）
|
||
* 6 不限速谓词：6ms 档要关掉卡顿黄标与理论 Hz 显示（6ms ≠ 166Hz）
|
||
*/
|
||
import {
|
||
REFRESH_DEFAULTS, REFRESH_MIN_MS, REFRESH_MAX_MS, REFRESH_MIN_BY_TP,
|
||
UNTHROTTLED_MAX_MS, minRefreshFor, isUnthrottled,
|
||
defaultRefreshMap, normalizeRefreshMap, pickRefresh
|
||
} from "../js/motor/refresh-rate.js";
|
||
|
||
let pass = 0, fail = 0;
|
||
const out = [];
|
||
function check(name, cond, detail) {
|
||
if (cond) { pass++; out.push(` \u2713 ${name}`); }
|
||
else { fail++; out.push(` \u2717 ${name}${detail ? " \u2014 " + detail : ""}`); }
|
||
}
|
||
function section(t) { out.push(`\n${t}`); }
|
||
|
||
/* ── 1. 默认值 ── */
|
||
section("[1] 每链路默认值");
|
||
check("wifi 默认 250ms（无线 + ESP32 HTTP 往返）", REFRESH_DEFAULTS.wifi === 250,
|
||
`实际 ${REFRESH_DEFAULTS.wifi}`);
|
||
check("ecat 默认 50ms（本机快照，实测 p90≈22ms）", REFRESH_DEFAULTS.ecat === 50,
|
||
`实际 ${REFRESH_DEFAULTS.ecat}`);
|
||
check("两个默认值不相等（否则这次改动没意义）", REFRESH_DEFAULTS.wifi !== REFRESH_DEFAULTS.ecat);
|
||
check("上限 5000ms 与 #refreshRate 的 max 一致", REFRESH_MAX_MS === 5000);
|
||
const m1 = defaultRefreshMap(), m2 = defaultRefreshMap();
|
||
m1.wifi = 999;
|
||
check("defaultRefreshMap 每次返回新对象（改一份不污染另一份）", m2.wifi === 250);
|
||
check("defaultRefreshMap 不污染 REFRESH_DEFAULTS 常量", REFRESH_DEFAULTS.wifi === 250);
|
||
|
||
/* ── 1b. 下限也按链路 ── */
|
||
section("[1b] 每链路最小间隔");
|
||
check("ecat 下限 6ms（≈160Hz，与本机 160Hz 屏的绘制上限对齐）",
|
||
REFRESH_MIN_BY_TP.ecat === 6, `实际 ${REFRESH_MIN_BY_TP.ecat}`);
|
||
check("wifi 下限仍 50ms（每拍是一次无线 HTTP 往返，再快只会积压）",
|
||
REFRESH_MIN_BY_TP.wifi === 50, `实际 ${REFRESH_MIN_BY_TP.wifi}`);
|
||
check("minRefreshFor('ecat') = 6", minRefreshFor("ecat") === 6);
|
||
check("minRefreshFor('wifi') = 50", minRefreshFor("wifi") === 50);
|
||
check("未知链路回落到兜底下限 50（防御）", minRefreshFor("nope") === REFRESH_MIN_MS);
|
||
|
||
/* ── 2. 归一 + 钳制（下限按链路） ── */
|
||
section("[2] 归一与钳制（下限按链路）");
|
||
const norm = normalizeRefreshMap({ wifi: 400, ecat: 20 });
|
||
check("正常值原样保留", norm.wifi === 400);
|
||
check("ecat 的 20ms 合法（下限 6ms，不再被抬到 50）", norm.ecat === 20, `实际 ${norm.ecat}`);
|
||
check("ecat 可以设到 6ms", normalizeRefreshMap({ ecat: 6 }).ecat === 6);
|
||
/* 存量缓存里还留着旧的 1ms 档：读到就按新下限抬起来，不能原样放行 */
|
||
check("存量 1ms 被抬到 6ms（绘制上限之上没有消费者）",
|
||
normalizeRefreshMap({ ecat: 1 }).ecat === 6,
|
||
`实际 ${normalizeRefreshMap({ ecat: 1 }).ecat}`);
|
||
check("ecat 的 0/负数被抬到 6ms", normalizeRefreshMap({ ecat: 0 }).ecat === 6);
|
||
check("ecat 的 -5 被抬到 6ms", normalizeRefreshMap({ ecat: -5 }).ecat === 6);
|
||
check("wifi 的 1ms 仍被抬到 50（无线往返撑不住）",
|
||
normalizeRefreshMap({ wifi: 1 }).wifi === 50, `实际 ${normalizeRefreshMap({ wifi: 1 }).wifi}`);
|
||
check("wifi 的 20ms 也被抬到 50", normalizeRefreshMap({ wifi: 20 }).wifi === 50);
|
||
check("高于上限被压到 5000", normalizeRefreshMap({ wifi: 99999 }).wifi === REFRESH_MAX_MS);
|
||
check("ecat 高于上限同样压到 5000", normalizeRefreshMap({ ecat: 99999 }).ecat === REFRESH_MAX_MS);
|
||
check("字符串数字可用（localStorage 里存的是字符串）",
|
||
normalizeRefreshMap({ wifi: "300" }).wifi === 300);
|
||
check("ecat 字符串 \"8\" 可用", normalizeRefreshMap({ ecat: "8" }).ecat === 8);
|
||
const dirty = normalizeRefreshMap({ wifi: "abc", ecat: null });
|
||
check("脏值回落该链路默认（wifi）", dirty.wifi === 250, `实际 ${dirty.wifi}`);
|
||
check("脏值回落该链路默认（ecat）", dirty.ecat === 50, `实际 ${dirty.ecat}`);
|
||
check("未知链路 key 被丢弃（不在 localStorage 里攒垃圾）",
|
||
normalizeRefreshMap({ wifi: 300, bogus: 111 }).bogus === undefined);
|
||
const empty = normalizeRefreshMap(undefined, undefined);
|
||
check("完全没有历史数据 → 全用默认", empty.wifi === 250 && empty.ecat === 50);
|
||
check("传入非对象（数组/字符串）不炸且回落默认",
|
||
normalizeRefreshMap("garbage").wifi === 250);
|
||
|
||
/* ── 3. 旧数据迁移 ──
|
||
* 旧版只存单个 refreshRate（那时只有 WiFi 链路，值是为无线调的）。
|
||
* 迁到 wifi 才对；套到 ecat 上等于让用户平白继承一个不合适的值。 */
|
||
section("[3] 旧版单值迁移");
|
||
const mig = normalizeRefreshMap(undefined, 500);
|
||
check("旧单值迁进 wifi", mig.wifi === 500, `实际 ${mig.wifi}`);
|
||
check("ecat **不**继承旧单值，保持 50ms 默认", mig.ecat === 50, `实际 ${mig.ecat}`);
|
||
const migClamp = normalizeRefreshMap(undefined, "10");
|
||
check("旧单值也走 wifi 的下限钳制（10 → 50）", migClamp.wifi === 50);
|
||
const both = normalizeRefreshMap({ wifi: 300, ecat: 80 }, 500);
|
||
check("已有新格式时忽略旧字段（不被旧值覆盖）", both.wifi === 300 && both.ecat === 80);
|
||
|
||
/* ── 4. 取值 ── */
|
||
section("[4] pickRefresh 取当前链路的生效值");
|
||
check("正常取值", pickRefresh({ wifi: 300, ecat: 60 }, "ecat") === 60);
|
||
check("缺该链路 → 回落该链路默认（不是另一条的值）",
|
||
pickRefresh({ wifi: 300 }, "ecat") === 50);
|
||
check("map 为 null 不炸", pickRefresh(null, "wifi") === 250);
|
||
check("ecat 取出 8ms 原样保留（不再被抬到 50）", pickRefresh({ ecat: 8 }, "ecat") === 8);
|
||
check("ecat 取出旧的 1ms 抬到下限 6ms", pickRefresh({ ecat: 1 }, "ecat") === 6);
|
||
check("wifi 取出 1ms 被抬到 50", pickRefresh({ wifi: 1 }, "wifi") === 50);
|
||
check("未知链路 id 回落到 wifi 默认（防御，不应出现）",
|
||
pickRefresh({}, "somethingnew") === 250);
|
||
|
||
/* ── 5. 隔离：本次改动的核心 ── */
|
||
section("[5] 两条链路互不污染");
|
||
const map = defaultRefreshMap();
|
||
/* 模拟：用户在 ECAT 下把刷新速度拉到下限 6ms（applyRefreshRate 只写当前链路那一份） */
|
||
map.ecat = 6;
|
||
check("改 ecat 到 6ms 后 wifi 仍是 250（不会把 WiFi 链路拖垮）", map.wifi === 250);
|
||
/* 模拟：切回 WiFi，装载的应是 wifi 那一份 */
|
||
check("切回 wifi 装载 250 而非 6", pickRefresh(map, "wifi") === 250);
|
||
/* 模拟：在 WiFi 下改成 1000ms，再切去 ECAT */
|
||
map.wifi = 1000;
|
||
check("改 wifi 后 ecat 仍是 6ms（WiFi 的慢值不会浪费 ECAT 的低延迟）", map.ecat === 6);
|
||
check("切到 ecat 装载 6 而非 1000", pickRefresh(map, "ecat") === 6);
|
||
/* 存盘 → 读回一圈后仍各自独立（saveUiState/loadUiState 的往返） */
|
||
const roundTrip = normalizeRefreshMap(JSON.parse(JSON.stringify(map)));
|
||
check("存盘再读回：wifi 保留 1000", roundTrip.wifi === 1000);
|
||
check("存盘再读回：ecat 保留 6ms（不被 wifi 的下限 50 顺手抬高）",
|
||
roundTrip.ecat === 6, `实际 ${roundTrip.ecat}`);
|
||
|
||
/* ── 6. 不限速谓词 ──
|
||
* 下限档（6ms）贴着往返耗时，节拍源仍会比请求完成得快，撞上"上一拍还在飞"是
|
||
* 预期行为，所以要据此关掉卡顿黄标；6ms 硬算成 166Hz 也偏乐观（实测 ≈160Hz）。 */
|
||
section("[6] 不限速谓词（关黄标 + 不谎报 Hz）");
|
||
check("阈值 20ms（50Hz）：比浏览器实测每拍耗时(~8ms)宽裕，又远小于常用档",
|
||
UNTHROTTLED_MAX_MS === 20, `实际 ${UNTHROTTLED_MAX_MS}`);
|
||
check("1ms 属不限速", isUnthrottled(1) === true);
|
||
check("10ms 属不限速", isUnthrottled(10) === true);
|
||
check("19ms 属不限速（边界内）", isUnthrottled(19) === true);
|
||
check("20ms 不属不限速（边界外）", isUnthrottled(20) === false);
|
||
check("ECAT 默认 50ms 是正常限速档（黄标与 Hz 显示都保留）",
|
||
isUnthrottled(REFRESH_DEFAULTS.ecat) === false);
|
||
check("WiFi 默认 250ms 是正常限速档", isUnthrottled(REFRESH_DEFAULTS.wifi) === false);
|
||
check("WiFi 下限 50ms 永远不进不限速区（该链路无此档）",
|
||
isUnthrottled(REFRESH_MIN_BY_TP.wifi) === false);
|
||
check("ECAT 下限 6ms 一定在不限速区", isUnthrottled(REFRESH_MIN_BY_TP.ecat) === true);
|
||
check("非数字不炸且判 false", isUnthrottled(undefined) === false && isUnthrottled(NaN) === false);
|
||
|
||
console.log(out.join("\n"));
|
||
console.log("\n" + "=".repeat(56));
|
||
console.log(`通过 ${pass} 项，失败 ${fail} 项`);
|
||
process.exit(fail === 0 ? 0 : 1);
|