Files
crawler-plugin/backend-java/src/test/java/com/nanri/aiimage/config/CatchSilenceRatchetTest.java
T
huangzd1997 49eee59a13 fix(外观专利): 失败兜底出部分结果文件+WAIT_LLM 停放作业心跳续租(31302/31354)
线上两例死法修复,目标是「任务失败了也能下载」:
- 31354:组装作业在 WAIT_LLM 停放期执行线程已退出、Worker 执行期心跳
  已取消,job 级 stuck 扫描按 updated_at 判陈旧,5 分钟阈值×5 次重试
  耗尽后误判「文件生成任务运行超时」。客户端心跳经
  AppearancePatentTaskHeartbeatSpi#onHeartbeat 按
  dbJobTouchIntervalMillis(默认 60s,远小于 5 分钟阈值)节流续租
  (touchRunningAssembleJobsIfStale,与 SimilarAsin 同口径)。
- 31302:覆盖率闸门判红重试 5 次判死后,1196 行成品零交付且不能下载。
  接通 fallbackAssembleOnFailure 兜底钩子:作业判死后用已有分片出
  部分结果文件(validateCompleteLlmCoverage 加 allowPartial 旁路),
  写上 result.resultFileUrl 后前端下载按钮即恢复;兜底幂等(已有
  结果文件短 路)、不动任务终态、与补传恢复重跑兼容。
- 棘轮尺 STRICT_TOTAL 1003→1004、NOT_RETHROW 561→562 抬格并逐处
  记名(兜底自吞 catch 属接口契约要求的 fail-open 形状)。

全量 mvn -o test 4492 支 0 失败(9 skipped 为既有跳过)。
2026-10-18 23:41:24 +08:00

439 lines
27 KiB
Java
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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 静默形状的**只许减**棘轮。
*
* <p>统计三件事(口径写死在这里,防止又变成"把文件数当处数"):
* <ul>
* <li>统计命令:{@code SilentCatchScanner.scanTree(src/main/java)}(本类的 {@link #TREE});</li>
* <li>分母是哪棵树:{@code crawler-plugin/backend-java/src/main/java} 工作树,只算 {@code *.java};</li>
* <li>单位:处(一个 catch 块 = 一处)。</li>
* </ul>
*
* <p>基线来源: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;那三格的基线一个字没动。
*
* <p>"只 log" 这一格本轮按严格口径重测得 <b>172</b>(块内每条顶层语句都是 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,逐处出处同下。
static final int GIVEN_TOTAL = 1000;
static final int GIVEN_NOT_RETHROW = 562;
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。
*/
static final int STRICT_TOTAL = 1004;
/**
* 重抛型 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 两数未涨(那两格仍绿)=> 没有任何一处「异常会往外走」被改回吞掉。
static final int RETHROW_FLOOR = 386;
/**
* 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)。
*/
static final int STRICT_NOT_RETHROW = 562;
/**
* 10-17 抬 172 -> 173,出处就是上面点名过的 {@code TaskHeartbeatLivenessService.stamp()}:
* 块体只有「取到 key 名 + log.warn」一句,写心跳证据失败时既不重试也不抛出——
* 心跳接口不许因为「记不下证据」而 500。同类的 {@code lastHeartbeatMillis()} 读失败还要
* 落 0 返回,形状是 log+return 默认值,因此不进这一格。
*/
static final int STRICT_LOG_ONLY = 173; // 严格口径:块内每条顶层语句都是 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})必须对得上账:
*
* <pre>naive == scanned + decoy</pre>
*
* <p>为什么不是直接 {@code naive == scanned}:字面量口径会把注释里、字符串里、文本块里的
* {@code catch (} 字样也数进去(本轮实测 7 处)。一个**正确**的词法必须不数它们,
* 所以两口径天然差这 7。把差值单独钉住({@link #BASELINE_DECOY})才是有用的断言:
* 词法若写坏、把真代码当字符串吃掉,total 会**变小**而"≤ 基线"照样绿,
* 但那些块会立刻变成 decoy ⇒ decoy 超基线 ⇒ 红。这正是 818 vs 1000 那版 bug 的显形方式。
*/
@Test
void scannerTotalAndDecoyAccountForTheIndependentNaiveCount() {
Map<String, String> raw = readTree();
int naive = SilentCatchScanner.countNaiveLiteral(raw);
List<SilentCatchScanner.Decoy> 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。
*
* <p>不这么钉的话,往分类器里加一个"新格子"就能把气味块从三格里悄悄搬走,
* 三个数字同时下降而总噪声一点没少——这正是"内部搬家"绕过棘轮的形状。
*/
@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<Site> 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,扫描器必须一种都不放过、且判对类。
*
* <p>没有这一条,"四个数都 ≤ 基线"完全可能是恒真的——分类器返回空清单时它照样绿。
*/
@Test
void injectedSitesAreCountedAndClassified() {
Map<String, String> 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());
}
/**
* 注入自证(词法陷阱):字符字面量与转义引号不许吃掉后半棵树。
*
* <p>这是用户点名的坑:{@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<String, String> 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<String, String> 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 或显式锚点。<b>②从来没被测过</b>——{@code Site.hasAnchor()} 在扫描器里
* 躺了几天、一个调用者都没有,而那行格子一直按"达标"计。现在把它做成真判据。
*
* <p>锚点约定是 ASCII 的 {@code [tag]}:扫描器的正则是
* {@code \[[A-Za-z0-9_.-]{3,}\]},中文方括号标签根本匹配不上。任务书里写的
* {@code [静默降级]} 属**命名与代码不一致**,这里按代码为准,锚点用 {@code [silent-degrade]}。
*
* <p>台账逐处按文件点名(只钉总数=允许"内部搬家"绕过,见本仓反复出现的那族错误)。
*/
@Test
void threeCategoriesMustRethrowOrCarryAnchor() {
Map<String, Integer> 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<String, String> 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<String, Integer> gap = gapLedger(SilentCatchScanner.scanSources(src).sites());
assertEquals(Map.of("Feed.java", 1), gap,
() -> "只该抓到『既没 throw 也没锚点』的那一处,实抓 " + gap);
}
/**
* 三类判据:块体里出现这些字样才算回传/落库/扣次数的出口。
* 名单刻意窄——宁可少收,也不把无关 catch 卷进台账(卷进来会让"只许减"变成没人敢动的死数)。
*/
private static final Map<String, java.util.regex.Pattern> 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,按文件计数。
*
* <p>RETHROW 直接排除(那正是我们要的形状);锚点判定走 {@link Site#hasAnchor()},
* 它看的是 rawBody——{@code body} 剥过注释,会把字符串里的 {@code [tag]} 一起剥掉,
* 于是"打了锚点"反而判成没锚点(扫描器 javadoc 里记着这条,别改回去)。
*/
private static Map<String, Integer> gapLedger(List<Site> sites) {
Map<String, Integer> 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<String, Integer> 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<String, String> readTree() {
Map<String, String> 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 + ")");
}
}