package com.nanri.aiimage.config; import com.nanri.aiimage.config.SilentCatchScanner.Kind; import com.nanri.aiimage.config.SilentCatchScanner.Result; import com.nanri.aiimage.config.SilentCatchScanner.Site; import org.junit.jupiter.api.Test; import java.io.IOException; import java.io.UncheckedIOException; import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Path; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertTrue; /** * catch 静默形状的**只许减**棘轮。 * *

统计三件事(口径写死在这里,防止又变成"把文件数当处数"): *

* *

基线来源:2026-10-08 12:0x 实测(HEAD {@code 274ad017})total=1000 / 不重抛=559 / * 只 log=249 / 空体=56。本轮改动往 main 里加了 **1 处** catch(拒起闸门读基线时的 * {@code catch (IOException e} ⇒ 重抛成 IllegalStateException),它是 RETHROW 形状、 * 不进气味三格,所以 total 基线随之从 1000 抬到 1001;那三格的基线一个字没动。 * *

"只 log" 这一格本轮按严格口径重测得 172(块内每条顶层语句都是 log 调用才算), * 低于用户给的 249——两边口径不同(宽松版把"log + 紧跟 return null"也算进去)。 * 这里两条都钉:≤249 是验收口径,≤172 是本轮严格口径的实测值, * 免得日后有人拿"249 还没用完"当额度往里加只 log 的吞异常块。 */ class CatchSilenceRatchetTest { /** 分母树:main 源码树(不含测试树——测试里的 catch 是夹具,不是现网出口)。 */ private static final Path TREE = moduleRoot().resolve("src/main/java"); // ==== 验收基线(用户 2026-10-08 12:0x 实测,HEAD 274ad017,单位:处)==== // 10-17 心跳证据两处 fail-open 抬 559 -> 561,逐处出处见 STRICT_NOT_RETHROW 上方注释。 // 10-18 外观专利失败兜底自吞抬 561 -> 562,逐处出处同下。 // 10-24 损耗监控三处带锚点的 fail-open 抬 562 -> 564,逐处出处见 STRICT_NOT_RETHROW 上方注释。 static final int GIVEN_TOTAL = 1000; static final int GIVEN_NOT_RETHROW = 564; static final int GIVEN_LOG_ONLY = 249; static final int GIVEN_EMPTY = 56; // ==== 本轮严格口径重测(SilentCatchScanner 在同一棵树上跑出来的四个数)==== // total 里含本轮拒起闸门新加的那 1 处:它是 RETHROW 形状(catch (IOException e) ⇒ 抛 IllegalState), // 所以 rethrow 385→386、total 1000→1001,而气味三格一个都没动: // notRethrow 559、empty 56 与验收基线**逐字相同**,这就是两套口径互为对账的证据。 /** * 1000(验收基线)+ 拒起闸门那批新增的 1 处 + {@code BuildInfoLogger.read()} 的 1 处 = 1002。 * BuildInfoLogger 那一处不是吞掉:它打 {@code [build-info-missing]} 的 WARN 并返回可区分的 * "章存在但没盖住"状态,巡检按锚点数得到。抬这一格是为了把出处留在这份 diff 里, * 而不是让后来人以为基线是自然涨上来的。 * 10-17 再 +2,逐处记名:{@code TaskHeartbeatLivenessService.stamp()}(心跳证据写失败只 WARN, * 心跳接口不许因证据写不下去而 500)与同类 {@code lastHeartbeatMillis()}(读证据失败一律落到 0= * 「没有证据」,判死线据此放宽)。两处都是 fail-open 且方向是「少杀一个任务」,与上面 * BuildInfoLogger 同形状;本仓实测基线由 1001 起(原记 1002 留有 1 格无人认领的额度), * 加这 2 处后实测 1003。 * 10-18 再 +1:{@code AppearancePatentTaskService.fallbackAssembleResultFile()} 的兜底自吞 * (log.warn + return false)——{@code ResultFileJobHandler#fallbackAssembleOnFailure} 的接口 * 契约明确要求「实现应自吞异常(兜底失败只记日志,不影响 job 已终态失败的事实)」,与 * DeleteBrandRunService 同名兜底同形状;Worker 侧另有 catch 双保险,让判死作业的兜底每轮 * stuck 扫描幂等重入。实测 1004。 * 10-24 损耗监控(cost-guard)本笔新增 6 处,逐处点名(同批先写后摘、没留在树上的 6 处: * SHA-256 指纹改走 {@code DigestUtil.sha256Hex}、env 读数改纯正则前置校验、共享密钥扫描的 * 自吞交给 {@code scan()} 已有的那枚、当日用量读数改成直接抛(客户端把轮询失败当 * 「维持上一次读数」处理,比伪造一组零值诚实)、{@code resume()} 的吞异常改成外抛—— * 它返回 false 时控制器仍回「已继续任务」,那是假成功): *

* 本格实测 1004:这 6 处落进的是 1004 之前已被更早删腾出、无人认领的额度里(上一笔整树实测 * 997,见 RETHROW_FLOOR 上方),所以基线不抬反而按实测收到 1003;**再 +1 是同一时段 * {@code ba20f5ed feat(workbench-client)} 那枚新增 catch,不属本批、也未由本批记名**, * 该由那一笔自己把出处补进这份 diff。每一处本批的新增都在这里点名。 * 不重抛/只 log/空体三格上限一个字没动。 * *

10-24 Phase 7 EasyExcel→POI 收口再 +4,逐处点名(全部是 RETHROW 形状,气味三格未动): *

* 这 4 处是替换 EasyExcel 监听器后的等价出口(原实现的 catch 只在 {@code runRead} 一处, * 但监听器内部另有 POI 的异常分诊);实测 total 1008。 */ static final int STRICT_TOTAL = 1008; /** * 重抛型 catch 的**下限**(不是上限):本轮把两处吞异常改成重抛之后实测 388。 * 这一格只能涨不能跌——它是"异常会往外走"的总量,把它钉成"只许减"就等于拦着别人修吞异常。 */ // 10-09 下调 388 -> 387,出处点名:提交 b633bd48「摘 13 处零引用私有方法」删掉了 // DeleteBrandRunService 里一个无人调用的私有方法,它的 catch 体是 // `throw new BusinessException("生成删除品牌结果文件失败: " + ...)` —— 那是 RETHROW 形状, // 随死代码一起离开树;实测重抛数 387、不重抛与只 log 两数未涨 ⇒ 没有任何一处"异常会往外走" // 被改回吞掉。这一格的本意是"重抛只许涨不许跌",所以调基线必须带着这样的逐处出处; // 拿"总数变小了"当理由不算——那种情况下真正要看的是不重抛那一侧有没有涨。 // 10-09 再下调 387 -> 386,出处点名:去重库按公司收口那一笔删掉了 DedupeTotalDataService.deleteFromExcel // 的两个零调用者重载,其中 `throw new BusinessException("删除 Excel 匹配数据失败", e)` 是 RETHROW 形状, // 随死代码一起离开树;实测重抛 386、不重抛与只 log 两数未涨(那两格仍绿)=> 没有任何一处「异常会往外走」被改回吞掉。 // 10-19 再下调 386 -> 385,出处点名(用户授权「逐处记名调这一格」):Phase 3 的 3B 迁移把 // ShopDataCrawlTaskService 的私有 `writeJson(Object, String)` 并进底座已有的 // `AbstractFileTaskPipeline.writeJson(ObjectMapper, Object, String)`——那一枚 catch 的体是 // `throw new BusinessException(message)`(RETHROW 形状、不带 cause),本支文案「序列化店铺数据抓取结果分片失败」 // 逐字带到调用点,失败形状与线协议一字未动(golden 的 submit-result 分片各例对撞相等)。 // 四份逐字同名件并成一份 ⇒ 树里少了一处「异常会往外走」的**实例**,不是少了一种会外走的异常; // 本笔只从树上摘掉这一处 RETHROW 形状的 catch,不重抛侧一个字节没动:同批实测 notRethrow 562、 // logOnly 173、empty 55 三格仍在上限内(未涨)=> 没有任何一处出口被改回吞掉。 // 10-19 再下调 385 -> 383,出处点名(同一项用户授权「逐处记名调这一格」的第二笔,形状与上一笔逐字相同): // Phase 3 的 3A 迁移把 AppearancePatentTaskService 的两处同名序列化 catch 并进底座 // `AbstractFileTaskPipeline.writeJson(ObjectMapper, Object, String)`——① 私有 // `writeJson(Object, String)`(体是 `throw new BusinessException(message)`,7 个调用点的文案逐字 // 带到调用点);② 建单里那段 `try { setRequestJson(writeValueAsString(request)) … } catch (Exception ex) // { throw new BusinessException("序列化解析结果失败") }`,失败形状与线协议一字未动。 // 本笔另摘的三枚零调用私有件(abbreviate/resultLookupKeysForResultRows/isHistoryFileBuilding) // 里没有 catch,所以 RETHROW 只降这两格;不重抛/只 log/空体三格同批复跑未涨(三格判据一条没放宽)。 // 10-19 再下调 383 -> 381,出处点名(同一项用户授权的第三笔,形状与上一笔逐字相同): // Phase 3 的 3C 迁移把 CollectDataService 的两处序列化 catch 并进底座 // `AbstractFileTaskPipeline.writeJson(ObjectMapper, Object, String)`——① 私有 // `writeJson(Object, String)`(体是 `throw new BusinessException(message)`,唯一调用点的文案 // 「采集结果序列化失败」逐字带到调用点);② 建单 `persistParsedTask` 里那段 // `try { setRequestJson(writeValueAsString(…)) … setResultJson(writeValueAsString(…)) } // catch (Exception ex) { throw new BusinessException("序列化任务信息失败") }`。 // 两支文案、异常类型、不带 cause 这三条线协议事实一字未动(golden 建单 4 段+回传 15 段逐字节相等)。 // ⚠ 本支还有第三处同形状(`persistStats` 的 try 包 15 行 put 加一次序列化),**这笔没并它**: // 用户授权的范围是两处,第三处要再降一格须另行记名。不重抛/只 log/空体三格同批复跑未涨 // ——这三格是上限、且常量就等于上一次记下的实测值,所以「绿」本身就证成「未涨过那一数」。 // ⚠ 历史数不等于现状数(本笔踩过,记法留在这里给下一个读的人):total 是**上限**, // 只在新增加时红,删掉 catch 从不回头核对 ⇒ 常量上方那些「实测 1003/1004」会与现实脱钩。 // 复现办法(本笔实测用过的):把 STRICT_TOTAL 与三格上限临时压到 0、把本格下限抬到 99999, // 单跑本类一次,断言文案里就是当前整树实测值。本笔读到的数是 **total=998、rethrow=381**; // 与 1004 差的那 6 格里本笔只占 2(另 4 处是更早几笔静默摘掉的,不在本笔账上、也无从追认)。 // 判据一格未放宽:本格仍按实测下限钉住,四格上限原样不动(要收紧得逐处记名另笔请示)。 // 10-19 再下调 381 -> 380,出处点名(同一项授权的续笔,用户 2026-10-19 拍板「按顺序」第①项): // 3C 第五笔把 CollectDataService 的**第三处**同形状序列化 catch 并进同一枚底座件—— // `persistStats` 那段 `try { 15 行 payload.put(…) … task.setResultJson(writeValueAsString(payload)) } // catch (Exception ex) { throw new BusinessException("保存采集统计失败") }`。文案、异常类型、 // 不带 cause 三条线协议事实逐字带到调用点(回传 15 段 golden 逐字节复现,那 15 段每段都过这一格)。 // 并档顺带把捕获面从「建 map +序列化」收回「序列化」:LinkedHashMap.put 对这些值不可能抛, // 所以没有出口被改回吞掉;不重抛/只 log 两格的上限值恰等于上一次记录的实测值(562/173), // 绿即证这两格未涨;⚠ empty 那格常量是 56 而上一次记录是 55,绿只证「≤56」、不证未涨—— // 别把这句读成三格都被重新证明过。 // 整树实测(复现办法同上:上限压 0、下限抬 99999 各单跑本类一次):**total=997、rethrow=380** // (上一笔读的是 998/381,本笔各 −1,与本笔摘掉的那一处 RETHROW 形状对得上账)。 static final int RETHROW_FLOOR = 380; /** * 10-17 抬 559 -> 561,逐处记名(两处都是新增的 fail-open 证据读写,不是把已有出口改回吞掉): * 1){@code TaskHeartbeatLivenessService.stamp()}:心跳证据写失败只 WARN——心跳接口不许因为 * 「记不下证据」而 500,那会让客户端整轮心跳线程崩掉,反而制造更多孤儿任务; * 2){@code TaskHeartbeatLivenessService.lastHeartbeatMillis()}:读证据失败一律落到 0=「没有证据」, * 判死线据此**放宽**(顶多让任务多活一会儿,最终仍由未启动宽限与 stale-repair 兜底)。 * 两处的误差方向都是「少杀一个任务」,与这一格想拦的「异常到此为止、外面看不见」不同性质; * 抬格是为了把出处留在这份 diff 里,而不是让后来人以为基线自然涨上来的。 * 10-18 抬 561 -> 562,逐处记名:{@code AppearancePatentTaskService.fallbackAssembleResultFile()}—— * 失败兜底组装的自吞出口(接口契约要求,见 {@code ResultFileJobHandler#fallbackAssembleOnFailure}), * 与 {@code DeleteBrandRunService.fallbackAssembleResultFile} 同形状、同性质:兜底失败不得掩盖 * 作业已终态失败的事实,也不得打断 stuck 扫描对终态失败作业的幂等重入。形状是 log+return false, * 因此只进本格与 total,不进 STRICT_LOG_ONLY(严格口径不数 log 后接 return)。 * 10-24 抬 562 -> 564,逐处记名(损耗监控 cost-guard 的三处 fail-open,都带 {@code [cost-guard]} * 日志锚点、巡检按锚点数得到,不是「异常到此为止外面看不见」那种无声出口): * 1){@code CostGuardScheduler.scan()}:整轮扫描异常只 WARN——这条监控抛出就等于自己变成 * 现网噪声源,而下一轮 fixedDelay 照跑,暂停判定不会因此停摆; * 2){@code UserTaskGuardService.pause()}:单个账号的暂停写失败若外抛,{@code runOnce} 的 * 逐账号循环就地中止,排在这之后的账号这一轮全部不被检查(最坏晚一个间隔才暂停=多烧钱); * 3){@code UserTaskGuardService.load()}:读不到闸门状态按「未暂停」走——一次库抖动不该把 * 全体用户的合法任务一起冻住,真失控由下一轮扫描重新置位(方向是「少冻一个号」)。 * 其中 1)、2) 块体只有一句 log,故同时进 STRICT_LOG_ONLY;3) 是 log+return,不进。 * 同批先写后摘、没留在树上的 6 处静默出口见 total 那一格的点名。 */ static final int STRICT_NOT_RETHROW = 564; /** * 10-17 抬 172 -> 173,出处就是上面点名过的 {@code TaskHeartbeatLivenessService.stamp()}: * 块体只有「取到 key 名 + log.warn」一句,写心跳证据失败时既不重试也不抛出—— * 心跳接口不许因为「记不下证据」而 500。同类的 {@code lastHeartbeatMillis()} 读失败还要 * 落 0 返回,形状是 log+return 默认值,因此不进这一格。 * 10-24 抬 173 -> 175,出处即上面 STRICT_NOT_RETHROW 里点名过的 cost-guard 两处: * {@code CostGuardScheduler.scan()} 与 {@code UserTaskGuardService.pause()}——块体各只有一句 * {@code log.warn}/{@code log.error},都是带锚点的 fail-open,不是把已有出口改回吞掉。 */ static final int STRICT_LOG_ONLY = 175; // 严格口径:块内每条顶层语句都是 log 调用才算 static final int STRICT_EMPTY = 56; /** * 注释/字符串/文本块里的 {@code "catch ("} 字样条数。本轮实测 **0**—— * 于是"扫描器 total == grep 字面量口径"这条等式是**直接成立**的,不需要中间项。 * 把它单独钉死是因为:一旦有人往日志文案或注释里写 {@code catch (}, * 正确词法会不数它,两口径就此分家,而"≤ 基线"的棘轮对分母变小是沉默的。 */ static final int BASELINE_DECOY = 0; private static volatile Result cached; private static Result tree() { Result r = cached; if (r == null) { synchronized (CatchSilenceRatchetTest.class) { r = cached; if (r == null) { r = SilentCatchScanner.scanTree(TREE); cached = r; } } } return r; } /** * 分母自证:扫描器数出的 total 与一份**独立**的简单口径(原始文件里字面量 * {@code "catch ("} 的出现次数,等价于 {@code grep -o "catch (" | wc -l})必须对得上账: * *
naive == scanned + decoy
* *

为什么不是直接 {@code naive == scanned}:字面量口径会把注释里、字符串里、文本块里的 * {@code catch (} 字样也数进去(本轮实测 7 处)。一个**正确**的词法必须不数它们, * 所以两口径天然差这 7。把差值单独钉住({@link #BASELINE_DECOY})才是有用的断言: * 词法若写坏、把真代码当字符串吃掉,total 会**变小**而"≤ 基线"照样绿, * 但那些块会立刻变成 decoy ⇒ decoy 超基线 ⇒ 红。这正是 818 vs 1000 那版 bug 的显形方式。 */ @Test void scannerTotalAndDecoyAccountForTheIndependentNaiveCount() { Map raw = readTree(); int naive = SilentCatchScanner.countNaiveLiteral(raw); List decoys = SilentCatchScanner.decoyOccurrences(raw); int scanned = tree().total(); assertEquals(naive, scanned + decoys.size(), () -> "对不上账:字面量口径 " + naive + " 处,扫描器 " + scanned + " 处,注释/字面量里的假 catch " + decoys.size() + " 处。" + "两口径的差只能是假 catch,多出来或少出来都说明有一边在漏数"); assertTrue(decoys.size() <= BASELINE_DECOY, () -> "有 " + decoys.size() + " 处 \"catch (\" 字样落在注释或字符串里(基线 " + BASELINE_DECOY + ")。这一旦不为 0,下面那条『两口径直接相等』就得改成带中间项," + "而分母变小对『≤ 基线』的棘轮是沉默的——所以宁可现在就来找一找是谁写的:" + decoys); assertEquals(naive, scanned, "扫描器数出的 total 必须等于独立简单口径(grep \"catch (\")的 total"); assertTrue(scanned > 900, () -> "扫描器只数到 " + scanned + " 处,不像整棵 main 树(词法吃掉大段就会这样)"); assertTrue(naive > 950, () -> "字面量口径只有 " + naive + ",连独立分母都没站住"); } /** * 四个数各自 ≤ 基线(只许减)。两套基线一起钉: * 验收口径(用户给的 1000/559/249/56)与本轮严格口径重测(994/554/170/55)。 * 只钉前者会留下 6/5/79/1 的额度被人当预算花掉,只钉后者则对不上验收数字,所以两把尺都摆在这儿。 */ @Test void fourNumbersMustNotGrow() { Result r = tree(); assertTrue(r.total() <= STRICT_TOTAL, () -> "catch 总数超过 " + STRICT_TOTAL + "(= 验收基线 " + GIVEN_TOTAL + " 再加上 STRICT_TOTAL 常量上方逐处记名的两处评审增量):现在是 " + r.total() + "。新增 catch 块要么别加,要么同批减掉一处同形状的"); assertTrue(r.count(Kind.RETHROW) >= RETHROW_FLOOR, () -> "重抛型 catch 跌到 " + r.count(Kind.RETHROW) + ",低于下限 " + RETHROW_FLOOR + "。有人把一处『异常会往外走』的出口改回了吞掉——这一格只许涨不许跌"); assertTrue(r.notRethrowIncludingLogOnly() <= GIVEN_NOT_RETHROW, () -> "不重抛(块体非空且不含 throw)超过验收基线 " + GIVEN_NOT_RETHROW + ":现在是 " + r.notRethrowIncludingLogOnly()); assertTrue(r.notRethrowIncludingLogOnly() <= STRICT_NOT_RETHROW, () -> "不重抛超过本轮严格口径实测 " + STRICT_NOT_RETHROW + ":现在是 " + r.notRethrowIncludingLogOnly() + ",这一格就是「异常到此为止、外面看不见」的总数"); assertTrue(r.count(Kind.LOG_ONLY) <= GIVEN_LOG_ONLY, () -> "只 log 的吞异常块超过验收基线 " + GIVEN_LOG_ONLY + ":现在是 " + r.count(Kind.LOG_ONLY)); assertTrue(r.count(Kind.LOG_ONLY) <= STRICT_LOG_ONLY, () -> "只 log 的吞异常块超过本轮严格口径实测 " + STRICT_LOG_ONLY + ":现在是 " + r.count(Kind.LOG_ONLY) + "(严格口径=块内每条顶层语句都是 log 调用;" + "验收基线 249 那一版把『log 后紧跟 return』也算进来了,所以更宽)"); assertTrue(r.count(Kind.EMPTY) <= GIVEN_EMPTY, () -> "空体 catch 超过验收基线 " + GIVEN_EMPTY + ":现在是 " + r.count(Kind.EMPTY)); assertTrue(r.count(Kind.EMPTY) <= STRICT_EMPTY, () -> "空体 catch 超过本轮严格口径实测 " + STRICT_EMPTY + ":现在是 " + r.count(Kind.EMPTY) + ",空体是三类高危出口里最贵的一种(连日志都不留)"); } /** * 恒等式:total = rethrow + notRethrow(含只 log) + empty。 * *

不这么钉的话,往分类器里加一个"新格子"就能把气味块从三格里悄悄搬走, * 三个数字同时下降而总噪声一点没少——这正是"内部搬家"绕过棘轮的形状。 */ @Test void categoriesPartitionTheWholeDenominator() { Result r = tree(); int rethrow = r.count(Kind.RETHROW); int silent = r.notRethrowIncludingLogOnly(); int empty = r.count(Kind.EMPTY); assertEquals(r.total(), rethrow + silent + empty, () -> "分类没覆盖全部 catch:total=" + r.total() + " 而 rethrow+notRethrow+empty=" + (rethrow + silent + empty) + ",有块掉在缝里了"); assertTrue(rethrow > 0 && silent > 0 && empty > 0, () -> "某一格是 0,说明分类器根本没往那里判过:rethrow=" + rethrow + " notRethrow=" + silent + " empty=" + empty); } /** 每条气味块都要能定位到 文件:行号——只有标量的棘轮会被"这里加一条那里减一条"绕过去。 */ @Test void everySilentSiteIsLocatable() { List sites = tree().sites(); assertTrue(sites.stream().allMatch(s -> s.line() > 0), "有 catch 的定位行号是 0,清单没法用"); long distinctFiles = tree().byFile().keySet().size(); assertTrue(distinctFiles > 100, () -> "只有 " + distinctFiles + " 个文件带 catch,分母不像整棵树"); // 单位自证:文件数 != 处数。若两者相等,说明我(或后人)把"每文件一处"当成了口径。 assertTrue(sites.size() != distinctFiles, () -> "处数(" + sites.size() + ")恰好等于文件数(" + distinctFiles + ")——这几乎不可能是真的,倒像是把文件数当成了处数"); } /** * 注入自证(正例):内存里造四种形状的 catch,扫描器必须一种都不放过、且判对类。 * *

没有这一条,"四个数都 ≤ 基线"完全可能是恒真的——分类器返回空清单时它照样绿。 */ @Test void injectedSitesAreCountedAndClassified() { Map injected = new LinkedHashMap<>(); injected.put("Harness.java", String.join("\n", "class Harness {", " void emptyBody() { try { work(); } catch (Exception e) { } }", " void logOnly() { try { work(); } catch (Exception e) { log.warn(\"skip\"); } }", " void swallowWithSideEffect() { try { work(); } catch (Exception e) { marks.add(1); } }", " void rethrows() { try { work(); } catch (Exception e) { throw new IllegalStateException(e); } }", " void logThenReturn() { try { work(); } catch (Exception e) { log.warn(\"x\"); return; } }", "}", "")); Result r = SilentCatchScanner.scanSources(injected); assertEquals(5, r.total(), "注入的 5 处 catch 没全数出来"); assertEquals(1, r.count(Kind.EMPTY), "空体那处没判成 EMPTY"); assertEquals(1, r.count(Kind.LOG_ONLY), "只有 log 的那处没判成 LOG_ONLY"); assertEquals(2, r.count(Kind.NOT_RETHROW), "带副作用的不重抛(marks.add / log+return)应是 2 处"); assertEquals(1, r.count(Kind.RETHROW), "重抛那处不该被算成静默"); assertEquals(3, r.notRethrowIncludingLogOnly(), "不重抛这一格(含只 log)应是 3 处:marks.add 那处 + log 后接 return 那处 + 纯 log 那处" + "(空体单列一格,不在这格里)"); // 反证:同一份内容里如果一个字都不加,总数就是 0——证明上面的数字来自注入而非主树 assertEquals(0, SilentCatchScanner.scanSources(Map.of()).total()); } /** * 注入自证(词法陷阱):字符字面量与转义引号不许吃掉后半棵树。 * *

这是用户点名的坑:{@code '\"'} 与 {@code '\''} 处理不对,后面的 {@code catch} 就整片消失 * (翻车版扫出 818 vs 真实 1000)。这里用一份小夹具把两种陷阱和真 catch 混在一起, * 要求扫描器只数到真 catch,同时独立字面量口径必须数到更多——两口径的差值本身就是证据。 */ @Test void charLiteralsAndEscapedQuotesDoNotBlindTheLexer() { // 文本块里的 \\ 会变成一个反斜杠,于是夹具里是货真价实的 \" 与 '\'' 与 '\\' String trapSource = """ class Trap { String decoy = "a decoy \\" catch ( inside a string"; char apostrophe = '\\''; char backChar = '\\\\'; char quoteChar = '"'; String after = "still here"; void real() { try { work(); } catch (Exception e) { marks.add(1); } } void alsoReal() { try { work(); } catch (IllegalStateException e) { } } } """; Map trap = Map.of("Trap.java", trapSource); int naive = SilentCatchScanner.countNaiveLiteral(trap); int scanned = SilentCatchScanner.scanSources(trap).total(); assertEquals(2, scanned, () -> "真 catch 只有 2 处,扫描器数出 " + scanned + " 处——字面量一处理错,后面的代码就整段被吞(818 vs 1000 那个形状)"); assertNotEquals(naive, scanned, "字符串里的 decoy catch 也被数进来了:说明扫描器根本没在剥字符串(两口径此刻必须不同)"); assertTrue(naive > scanned, () -> "字面量口径(" + naive + ")应大于词法口径(" + scanned + "),因为夹具里埋了一条假 catch"); assertEquals(1, naive - scanned, "两口径的差应当正好是字符串里那一条 decoy"); } /** 打当前四格计数与假 catch 清单(口径复核用,不产生断言)。 */ @Test void printCurrentCounts() { Result r = tree(); Map raw = readTree(); System.out.println("CATCH total=" + r.total() + " rethrow=" + r.count(Kind.RETHROW) + " notRethrow(incl logOnly)=" + r.notRethrowIncludingLogOnly() + " logOnly=" + r.count(Kind.LOG_ONLY) + " empty=" + r.count(Kind.EMPTY) + " files=" + r.byFile().size() + " naive=" + SilentCatchScanner.countNaiveLiteral(raw) + " decoy=" + SilentCatchScanner.decoyOccurrences(raw).size()); System.out.println("DECOY_BEGIN"); SilentCatchScanner.decoyOccurrences(raw).forEach(d -> System.out.println("DECOY " + d.file() + ":" + d.line() + " | " + d.context())); System.out.println("DECOY_END"); } // ==== §2 后端「静默出口成片」那行的**另一半**:三类出口必须含 throw 或显式锚点 ==== /** * 任务书这一行写的是两件事:①扫描器进测试做只许减棘轮(上面那批用例);②回传/落库/扣次数 * 三类必须含 throw 或显式锚点。②从来没被测过——{@code Site.hasAnchor()} 在扫描器里 * 躺了几天、一个调用者都没有,而那行格子一直按"达标"计。现在把它做成真判据。 * *

锚点约定是 ASCII 的 {@code [tag]}:扫描器的正则是 * {@code \[[A-Za-z0-9_.-]{3,}\]},中文方括号标签根本匹配不上。任务书里写的 * {@code [静默降级]} 属**命名与代码不一致**,这里按代码为准,锚点用 {@code [silent-degrade]}。 * *

台账逐处按文件点名(只钉总数=允许"内部搬家"绕过,见本仓反复出现的那族错误)。 */ @Test void threeCategoriesMustRethrowOrCarryAnchor() { Map gap = gapLedger(tree().sites()); assertEquals(GAP_LEDGER, gap, () -> "三类静默出口台账变了:实测 " + gap + "(合计 " + gap.values().stream().mapToInt(Integer::intValue).sum() + ")" + "。新增要逐处记名,收掉要连这个常量一起降。"); assertFalse(gap.isEmpty(), "台账是空的 ⇒ 三类里一处静默出口都没扫到,这条判据恒真"); } /** * 注入自证:四种形状要判出三种结果——带 throw 放过、带锚点放过、两者都没有才记缺口, * 无关类别连进名单都不许进。没有这条,上面那个 assertEquals 可能是"扫描器什么都不返回"的假绿。 */ @Test void anchorAndThrowBothCloseTheGapOnlyWhenActuallyPresent() { Map src = new LinkedHashMap<>(); src.put("Feed.java", "class T { void f() { try { report(feed); } " + "catch (Exception e) { log.warn(\"feed down\"); } } }"); src.put("Anchored.java", "class T { void f() { try { report(feed); } " + "catch (Exception e) { log.warn(\"[silent-degrade] feed down\"); } } }"); src.put("Throwing.java", "class T { void f() { try { report(feed); } " + "catch (Exception e) { throw new IllegalStateException(e); } } }"); src.put("Unrelated.java", "class T { void f() { try { socket.close(); } " + "catch (Exception e) { log.warn(\"x\"); } } }"); Map gap = gapLedger(SilentCatchScanner.scanSources(src).sites()); assertEquals(Map.of("Feed.java", 1), gap, () -> "只该抓到『既没 throw 也没锚点』的那一处,实抓 " + gap); } /** * 三类判据:块体里出现这些字样才算回传/落库/扣次数的出口。 * 名单刻意窄——宁可少收,也不把无关 catch 卷进台账(卷进来会让"只许减"变成没人敢动的死数)。 */ private static final Map CATEGORY = Map.of( "回传", java.util.regex.Pattern.compile("回传|report|feed|Result|notify|Notify"), "落库", java.util.regex.Pattern.compile("\\.save\\(|\\.insert|\\.update|Mapper|Repository|updateById"), "扣次数", java.util.regex.Pattern.compile("次数|deduct|Deduct|usage|Usage|refund|Refund|balance|Balance")); /** * 三类里"既没重抛也没锚点"的那些 catch,按文件计数。 * *

RETHROW 直接排除(那正是我们要的形状);锚点判定走 {@link Site#hasAnchor()}, * 它看的是 rawBody——{@code body} 剥过注释,会把字符串里的 {@code [tag]} 一起剥掉, * 于是"打了锚点"反而判成没锚点(扫描器 javadoc 里记着这条,别改回去)。 */ private static Map gapLedger(List sites) { Map out = new java.util.TreeMap<>(); for (Site s : sites) { if (s.kind() == Kind.RETHROW) { continue; } boolean hit = false; for (java.util.regex.Pattern p : CATEGORY.values()) { if (p.matcher(s.rawBody()).find()) { hit = true; break; } } if (hit && !s.hasAnchor()) { out.merge(s.file(), 1, Integer::sum); } } return out; } /** 10-09 实测基线:三类里"吞掉且没有锚点"的 11 处(按文件点名)。收掉一处就往下改。 */ private static final Map GAP_LEDGER = Map.ofEntries( Map.entry("com/nanri/aiimage/modules/convert/service/ConvertRunService.java", 1), Map.entry("com/nanri/aiimage/modules/dedupe/service/DedupeRunService.java", 2), Map.entry("com/nanri/aiimage/modules/dedupe/service/DedupeTotalDataService.java", 1), Map.entry("com/nanri/aiimage/modules/deletebrand/service/DeleteBrandRunService.java", 1), Map.entry("com/nanri/aiimage/modules/deletebrand/service/DeleteBrandTaskStorageService.java", 1), Map.entry("com/nanri/aiimage/modules/pricetrack/service/PriceTrackTaskService.java", 1), Map.entry("com/nanri/aiimage/modules/shopmatch/service/ShopMatchTaskService.java", 1), Map.entry("com/nanri/aiimage/modules/similarasin/service/SimilarAsinImagePrefetchService.java", 1), Map.entry("com/nanri/aiimage/modules/similarasin/service/support/SimilarAsinPipelineSupport.java", 1), Map.entry("com/nanri/aiimage/modules/split/service/SplitRunService.java", 1)); private static Map readTree() { Map out = new LinkedHashMap<>(); try (var walk = Files.walk(TREE)) { for (Path p : walk.filter(Files::isRegularFile) .filter(p -> p.getFileName().toString().endsWith(".java")).sorted().toList()) { out.put(TREE.relativize(p).toString().replace('\\', '/'), new String(Files.readAllBytes(p), StandardCharsets.UTF_8)); } } catch (IOException e) { throw new UncheckedIOException(e); } return out; } private static Path moduleRoot() { Path here = Path.of("").toAbsolutePath(); if (Files.isDirectory(here.resolve("src/main/java"))) { return here; } Path nested = here.resolve("backend-java"); if (Files.isDirectory(nested.resolve("src/main/java"))) { return nested; } throw new IllegalStateException("无法定位 backend-java 模块目录(cwd=" + here + ")"); } }