package com.nanri.aiimage.testutil; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; import java.io.IOException; import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Path; import java.util.List; import java.util.Set; import java.util.stream.Collectors; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; /** * {@link SourceScan} 自己的护栏(2026-10-16,plan 01 N4 起)。 * *

N4 点名普查台账(由 {@code census_sourceText调用点总数不少于10} 那格机器复算,不是手抄):

*
 * 被点名裸名(10 个唯一)           字面量调用点  出处
 * ---------------------------------------------------------------------------
 * PublishController.java                  3      PublishOwnershipGuardrailTest:42 :82 :96
 * AdminApiGuardFilter.java                2      AdminGuardSwitchConfigTest:107 :254
 * AdminDeviceLogController.java           2      DeviceLogServiceTest:412 :428
 * LockSkipWitness.java                    2      LockSkipWitnessTest:178 + LockSkipSilentExitGuardrailTest:153
 * AppearancePatentTaskService.java        1      PublishOwnershipGuardrailTest:111
 * PublishTaskService.java                 1      PublishOwnershipGuardrailTest:109
 * SimilarAsinTaskService.java             1      PublishOwnershipGuardrailTest:112
 * ClientVersionGuardFilter.java           1      ClientVersionFloorConfigTest:249
 * PermissionMenuService.java              1      MenuWriteOutletOperatorTest:30
 * ShopManageController.java               1      ShopManageServiceTest:185
 * ---------------------------------------------------------------------------
 * 合计                                   15      落在 8 支调用方文件里
 * 
* *

一处与 plan 原文不符的读数,按"先怀疑尺子"的流程处理并留在脸上:plan/AGENTS §1 记的是「9 支文件」, * 那条数是 {@code grep -rl 'sourceText('} 数出来的,而第 9 支是 {@code SourceScan.java:22} 里 * {@code public static String sourceText(String fileName)} 这行被调方自己的声明——它不是调用点。 * 所以真实形状是 15 个调用点/8 支调用方/9 支引用方文件。下面第 3 格把这三个数同时钉住, * 免得下一个人拿 {@code grep} 再数一遍又把声明算进去。

*/ class SourceScanTest { /** 台账里登记过的 10 个被点名裸名,逐字对撞用。 */ private static final Set REGISTERED_BARE_NAMES = Set.of( "PublishController.java", "PublishTaskService.java", "AppearancePatentTaskService.java", "SimilarAsinTaskService.java", "AdminApiGuardFilter.java", "AdminDeviceLogController.java", "ClientVersionGuardFilter.java", "LockSkipWitness.java", "PermissionMenuService.java", "ShopManageController.java"); @TempDir Path tmp; @Test void census_sourceText调用点总数不少于10() { List sites = SourceScan.censusSourceTextCallSites(); assertThat(sites) .as("普查扫到的字面量调用点总数——下限判据:扫到 0 会被误读成「已经没人点名单文件了」," + "而真相往往是语料根没找对") .hasSizeGreaterThanOrEqualTo(10); } @Test void census_唯一裸名恰为10且与已登记集合相等() { Set found = SourceScan.censusSourceTextCallSites().stream() .map(SourceScan.CallSite::bareName) .collect(Collectors.toSet()); assertThat(found) .as("唯一裸名集合必须与类头台账逐字相等——多一个说明有人新引了单文件口径,少一个说明尺子漏扫") .isEqualTo(REGISTERED_BARE_NAMES) .hasSize(10); } @Test void census_涉及文件恰为9() { List sites = SourceScan.censusSourceTextCallSites(); Set callerFiles = sites.stream() .map(SourceScan.CallSite::relativeFile) .collect(Collectors.toSet()); String declarationFile = "src/test/java/com/nanri/aiimage/testutil/SourceScan.java"; assertThat(callerFiles) .as("真实字面量调用点落在 8 支调用方文件里") .hasSize(8); assertThat(callerFiles) .as("plan 原文记的「9 支」= grep -rl 'sourceText(' 的条数,第 9 支是被调方自己的声明行" + "(SourceScan.java:22 的 `public static String sourceText(String fileName)`)," + "它不是调用点。这里把「声明件必须落在调用方集合之外」钉成机器判," + "免得下一个人再拿 grep 数一遍把声明算进分母") .doesNotContain(declarationFile); assertThat(Path.of(declarationFile)).exists(); } @Test void census_空语料目录返回空而非抛() throws IOException { Path empty = Files.createDirectories(tmp.resolve("empty_corpus")); assertThat(SourceScan.censusSourceTextCallSites(empty)) .as("目录存在且确实是空的 ⇒ 返回空表。这与「目录不存在必须抛」是两回事," + "前者是语料真的没了,后者是尺子架错了地方") .isEmpty(); } @Test void census_中文路径文件被计入不丢失() throws IOException { Path corpus = Files.createDirectories(tmp.resolve("语料根")); Path chineseDir = Files.createDirectories(corpus.resolve("中文语料")); Files.writeString(chineseDir.resolve("点名中文件.java"), "class A { void x() { SourceScan.sourceText(\"PublishController.java\"); } }", StandardCharsets.UTF_8); List sites = SourceScan.censusSourceTextCallSites(corpus); assertThat(sites) .as("本仓有几百支中文名的测试件;遍历若按非 UTF-8 出口处理就会静默漏掉它们") .singleElement() .satisfies(site -> { assertThat(site.bareName()).isEqualTo("PublishController.java"); assertThat(site.relativeFile()).contains("中文语料"); }); } @Test void census_同名多次调用逐条计数不合并() { List publishController = SourceScan.censusSourceTextCallSites().stream() .filter(site -> site.bareName().equals("PublishController.java")) .toList(); assertThat(publishController) .as("同一个裸名被点 3 次就必须是 3 条,按名去重会把「三格钉同一方法」这族形状抹平") .hasSize(3) .extracting(SourceScan.CallSite::line) .containsExactlyInAnyOrder(42, 82, 96); } @Test void census_非法正则模式不影响解析() throws IOException { Path corpus = Files.createDirectories(tmp.resolve("混淆语料")); Files.writeString(corpus.resolve("Mixed.java"), String.join("\n", "class Mixed {", " // 有人在注释里写 SourceScan.sourceText(\"CommentFake.java\") —— 这不算点名", " static final String DOC = \"别学这个 sourceText(\\\"LiteralFake.java\\\") 的写法\";", " void real() { SourceScan.sourceText(\"RealOne.java\"); }", "}", ""), StandardCharsets.UTF_8); List sites = SourceScan.censusSourceTextCallSites(corpus); assertThat(sites) .as("真点名 1 条:注释里的那条要被判掉(护栏数的是代码不是文字)," + "字符串字面量里那条带转义引号,正则不该配上") .singleElement() .satisfies(site -> assertThat(site.bareName()).isEqualTo("RealOne.java")); } @Test void census_扫不到源码根时抛并回显cwd() { Path wrong = tmp.resolve("少爬了一层"); assertThatThrownBy(() -> SourceScan.censusSourceTextCallSites(wrong)) .as("根目录不存在时必须炸,不许返回空表——「扫不到」被读成「没人在用」是本族护栏的标准死法") .isInstanceOf(IllegalStateException.class) .hasMessageContaining("cwd=") .hasMessageContaining(wrong.toAbsolutePath().toString()); } // ---------------------------------------------------------------- N5 同名面普查 @Test void duplicateNames_实测三组且不多不少() { assertThat(SourceScan.duplicateMainSourceNames().keySet()) .as("src/main/java 下同名 >1 的裸文件名——实测就这三组,多一组说明有新落点,少一组说明有人搬走了") .containsExactlyInAnyOrder( "BoundedImageCache.java", "GroupDeletionGuard.java", "SkipPriceAsinPageVo.java"); } @Test void duplicateNames_与点名单交集为空() { Set duplicates = SourceScan.duplicateMainSourceNames().keySet(); assertThat(duplicates) .as("这是 N20 把 sourceText 收紧成「歧义即抛」的前提证明:今天被点名的 10 个裸名" + "全部单命中,所以当场不会打红。若未来第 11 个点名撞上这三组之一," + "N20 会当场红——那是正确行为,不是回归") .doesNotContainAnyElementsOf(REGISTERED_BARE_NAMES); } @Test void duplicateNames_全树java数不少于900() { assertThat(SourceScan.mainSourceFiles()) .as("分母下限:扫到 0 支必须被读成尺子坏了,而不是「主源码空了」") .hasSizeGreaterThanOrEqualTo(900); } @Test void duplicateNames_唯一名数小于总文件数() { List all = SourceScan.mainSourceFiles(); long uniqueNames = all.stream() .map(p -> p.getFileName().toString()) .distinct() .count(); assertThat(uniqueNames) .as("973 支文件 / 970 个唯一名 ⇒ 确有 3 组同名。相等就说明同名面被搬空了,N5 的台账要同步改") .isLessThan((long) all.size()); } @Test void duplicateNames_空目录返回空集合() throws IOException { Path empty = Files.createDirectories(tmp.resolve("空树")); assertThat(SourceScan.duplicateSourceNames(empty)) .as("目录存在且没有 .java ⇒ 空 Map(与 N4 的「语料真空」同一条口径)") .isEmpty(); } @Test void duplicateNames_同名恰好三支时计数为3() throws IOException { for (String dir : new String[] {"a", "b/c", "d/e/f"}) { Path sub = Files.createDirectories(tmp.resolve("三支").resolve(dir)); Files.writeString(sub.resolve("Trio.java"), "class Trio {}", StandardCharsets.UTF_8); } assertThat(SourceScan.duplicateSourceNames(tmp.resolve("三支"))) .as("三支同名必须聚成一组、值为 3 条路径;分组写成「每对相邻比较」就会数出 3 组") .containsEntry("Trio.java", List.of( "a/Trio.java", "b/c/Trio.java", "d/e/f/Trio.java")); } @Test void duplicateNames_忽略非java文件同名() throws IOException { Path tree = Files.createDirectories(tmp.resolve("混放树")); Files.createDirectories(tree.resolve("docs")); Files.writeString(tree.resolve("Foo.java"), "class Foo {}", StandardCharsets.UTF_8); Files.writeString(tree.resolve("docs").resolve("Foo.md"), "# Foo", StandardCharsets.UTF_8); assertThat(SourceScan.duplicateSourceNames(tree)) .as("`Foo.md` 与 `Foo.java` 不同名——只按裸名分组会把文档也算成同名,聚合面就多吃一支") .isEmpty(); } @Test void duplicateNames_路径不可读时抛不静默跳过() throws IOException { Path notADirectory = Files.writeString(tmp.resolve("我是文件不是目录"), "x", StandardCharsets.UTF_8); assertThatThrownBy(() -> SourceScan.duplicateSourceNames(notADirectory)) .as("传进来的是文件而非目录 ⇒ 必须抛。静默返回空 Map 会被读成「主源码没有同名件」") .isInstanceOf(IllegalStateException.class) .hasMessageContaining("cwd="); } // ---------------------------------------------------------------- N6 moduleSources @Test void moduleSources_appearancepatent返回30支含拆分后的support件() { List files = SourceScan.moduleSources("modules/appearancepatent"); assertThat(files) .as("真实集成:对真仓目录求值。30 支=1 controller+1 client+1 service 主件+3 spi/cache+" + "7 service/support+16 model(dto7/vo9),与 find 实测同号") .hasSize(30); assertThat(files.stream().map(p -> p.toString().replace('\\', '/')).toList()) .as("support 目录里的既有件必须在面里——聚合入口存在的理由就是拆分后的新文件要自动被看到") .anyMatch(rel -> rel.endsWith("service/support/AppearancePatentRowNormalizer.java")); } @Test void moduleSources_返回列表不可变() { List files = SourceScan.moduleSources("modules/appearancepatent"); assertThatThrownBy(() -> files.add(Path.of("塞一支进去.java"))) .as("调用方改坏面 ⇒ 同一轮里后一格读到的就不是真面了") .isInstanceOf(UnsupportedOperationException.class); } @Test void moduleSources_相对路径与绝对路径两种写法都接受() { List plain = SourceScan.moduleSources("modules/appearancepatent"); assertThat(SourceScan.moduleSources("/modules/appearancepatent")) .as("前导斜杠写法与裸相对写法必须同面,否则同一个模块会有两种口径") .isEqualTo(plain); assertThat(SourceScan.moduleSources("modules/appearancepatent/")) .as("尾斜杠同理") .isEqualTo(plain); assertThat(SourceScan.moduleSources("modules\\appearancepatent")) .as("Windows 反斜杠写法") .isEqualTo(plain); } @Test void moduleSources_空目录场景留给N11本task先返回空() throws IOException { Path javaRoot = Files.createDirectories(tmp.resolve("N6空场景树/src/main/java")); Files.createDirectories(javaRoot.resolve("modules/zzz_empty")); assertThat(SourceScan.moduleSources(javaRoot, "modules/zzz_empty")) .as("N6 只定「正常返回」:目录存在且为空 ⇒ 先返回空表不抛。" + "N11 会把这条改成抛(零文件绝不许读成零违规),届时更新本例") .isEmpty(); } @Test void moduleSources_深层相对路径越界到src外时拒绝() { assertThatThrownBy(() -> SourceScan.moduleSources("modules/../../../Windows")) .as("`..` 逃逸出 src/main/java ⇒ 必须挡。挡不住就等于聚合面能把整台机器读进来") .isInstanceOf(IllegalArgumentException.class) .hasMessageContaining("越界"); } @Test void moduleSources_路径含中文时正确解析() throws IOException { Path javaRoot = Files.createDirectories(tmp.resolve("N6中文树/src/main/java")); Path module = Files.createDirectories(javaRoot.resolve("modules/模块中文")); Files.writeString(module.resolve("中文件.java"), "class A {}", StandardCharsets.UTF_8); List chinese = SourceScan.moduleSources(javaRoot, "modules/模块中文"); assertThat(chinese) .as("主源码树今天没有中文名件,但语料根与相对目录都得过 UTF-8 这条道:这里用合成树把它钉住") .hasSize(1); assertThat(chinese.get(0).getFileName().toString()).isEqualTo("中文件.java"); } @Test void moduleSources_返回类型是Path不是字符串() { List files = SourceScan.moduleSources("modules/appearancepatent"); assertThat(files).allSatisfy(p -> assertThat(p).isInstanceOf(Path.class)); assertThat(files).allSatisfy(p -> assertThat(p.isAbsolute()).isTrue()); assertThat(files).allSatisfy(p -> assertThat(Files.isRegularFile(p)).isTrue()); } @Test void moduleSources_找不到源码根时抛并回显cwd() { Path wrong = tmp.resolve("少爬了一层/src/main/java"); assertThatThrownBy(() -> SourceScan.moduleSources(wrong, "modules/appearancepatent")) .as("根目录不存在必须抛并回显 cwd——静默返回空表会让整条聚合护栏恒绿") .isInstanceOf(IllegalStateException.class) .hasMessageContaining("cwd=") .hasMessageContaining(Path.of("").toAbsolutePath().toString()); } // ---------------------------------------------------------------- N7 递归语义 @Test void recursive_包含service下的直接件() { assertThat(SourceScan.moduleSources("modules/appearancepatent")) .as("模块根下第一层的 service/ 直接件必须在面里") .anyMatch(p -> p.toString().replace('\\', '/').endsWith( "service/AppearancePatentTaskService.java")); } @Test void recursive_包含service_support下的既有7件() { List support = SourceScan.moduleSources("modules/appearancepatent").stream() .map(p -> p.toString().replace('\\', '/')) .filter(rel -> rel.contains("/service/support/")) .toList(); assertThat(support) .as("真实集成:对真仓 modules/appearancepatent/service/support 求值,实测 7 支(3A 拆薄把归属谓词与陈旧扫描抽成两枚 support 件,5→7)。" + "这一格就是聚合入口存在的理由——拆分出去的新文件必须自动进面") .hasSize(7); } @Test void recursive_包含model下两层dto与vo() { List rel = SourceScan.moduleSources("modules/appearancepatent").stream() .map(p -> p.toString().replace('\\', '/')) .toList(); assertThat(rel.stream().filter(p -> p.contains("/model/dto/")).count()) .as("model/dto 一层嵌套") .isEqualTo(7); assertThat(rel.stream().filter(p -> p.contains("/model/vo/")).count()) .as("model/vo 一层嵌套") .isEqualTo(9); } @Test void recursive_深度为1的目录不出现在面里() throws IOException { Path module = Files.createDirectories(tmp.resolve("N7深度树/src/main/java/modules/deep")); Path deep = Files.createDirectories(module.resolve("a/b/c")); Files.writeString(deep.resolve("D.java"), "class D {}", StandardCharsets.UTF_8); Files.writeString(module.resolve("Root.java"), "class Root {}", StandardCharsets.UTF_8); List files = SourceScan.moduleSources(tmp.resolve("N7深度树/src/main/java"), "modules/deep"); assertThat(files) .as("三层嵌套里的 a/b/c/D.java 必须被计入:只爬一层的实现会静默漏掉它," + "而 support/ 恰恰就是这一层以下的位置") .extracting(p -> p.getFileName().toString()) .containsExactlyInAnyOrder("D.java", "Root.java"); assertThat(files) .as("面里只许有文件——目录本身不是元素,否则聚合文本会多出无内容条目") .allMatch(Files::isRegularFile); } @Test void recursive_隐藏目录件被排除() throws IOException { Path module = Files.createDirectories(tmp.resolve("N7隐藏树/src/main/java/modules/vis")); Path hidden = Files.createDirectories(module.resolve(".git")); Files.writeString(hidden.resolve("Ghost.java"), "class Ghost {}", StandardCharsets.UTF_8); Files.writeString(module.resolve("Real.java"), "class Real {}", StandardCharsets.UTF_8); assertThat(SourceScan.moduleSources(tmp.resolve("N7隐藏树/src/main/java"), "modules/vis")) .as(".git / .idea 这类目录里的 .java(IDE 与工具生成的副本)不许进面——" + "否则同一份代码会被算两遍,精确计数格(publish 恰 1)当场失真") .extracting(p -> p.getFileName().toString()) .containsExactly("Real.java"); } @Test void recursive_符号链接目录不被重复计入() throws IOException, InterruptedException { Path javaRoot = Files.createDirectories(tmp.resolve("N7链树/src/main/java")); Path real = Files.createDirectories(javaRoot.resolve("modules/linkreal")); Files.writeString(real.resolve("One.java"), "class One {}", StandardCharsets.UTF_8); // Windows 上建符号链接要特权,junction 不用:mklink /J 是本机的可复现路径。 // ⚠ 这里刻意不用 Assumptions 跳过——跳过会新增一格 Skipped,直接违反 N99「一个新 skip 都不许有」, // 那是拿跳过换绿。建不出来就判红并点名环境缺口(plan N3 第 9 例同一条口径)。 Process mk = new ProcessBuilder("cmd.exe", "/c", "mklink", "/J", javaRoot.resolve("modules").resolve("linkalias").toString(), real.toString()) .redirectErrorStream(true).start(); String out; try (var in = mk.getInputStream()) { out = new String(in.readAllBytes(), StandardCharsets.UTF_8); } int mklink = mk.waitFor(); assertThat(mklink) .as("junction 建不出来 ⇒ 本机环境不支持,这格判红而不是跳过(跳过会新增 Skipped," + "违反 N99「一个新 skip 都不许有」)。cmd 输出:%s", out) .isZero(); List files = SourceScan.moduleSources(javaRoot, "modules"); assertThat(files) .as("目录联接指回同一棵树:本机实测 Files.walk 会照钻 junction(改之前读出 [One.java, One.java])," + "所以「默认不 FOLLOW_LINKS 就安全」这条假设已被证伪。实现按 toRealPath() 折叠同一份文件" + "(公开 NIO 读不到重解析点标志);重复计入会让精确计数格(publish 恰 1)假绿") .extracting(p -> p.getFileName().toString()) .containsExactly("One.java"); } @Test void recursive_目录内全是非java时命中为空() throws IOException { Path module = Files.createDirectories(tmp.resolve("N7非java树/src/main/java/modules/docs")); Files.writeString(module.resolve("README.md"), "# 迁移说明", StandardCharsets.UTF_8); Files.createDirectories(module.resolve("sub")); Files.writeString(module.resolve("sub").resolve("notes.txt"), "x", StandardCharsets.UTF_8); assertThat(SourceScan.moduleSources(tmp.resolve("N7非java树/src/main/java"), "modules/docs")) .as("整棵树没有 .java ⇒ 空表(N11 会把这条改成抛;本格先钉「非 java 不进面」)") .isEmpty(); } @Test void recursive_遍历失败抛IllegalStateException不吞() throws IOException { Path vanished = tmp.resolve("N7消失树"); // 刻意不创建:walk 必须在第一步就抛 IOException // 正对照:先证明这里真的会抛 IOException —— 否则「没吞」这条断言是空的 try (var raw = java.nio.file.Files.walk(vanished)) { raw.toList(); org.junit.jupiter.api.Assertions.fail("JDK 的 Files.walk 在这条路径上没抛,正对照失效"); } catch (java.io.IOException expected) { assertThat(expected).isInstanceOf(java.nio.file.NoSuchFileException.class); } assertThatThrownBy(() -> SourceScan.collectJavaFiles(vanished)) .as("遍历抛 IOException 时必须包成 IllegalStateException 并点名路径,不许吞成空表——" + "「扫不到」被读成「没违规」是本族护栏的标准死法(10-15 §12 第一条)") .isInstanceOf(IllegalStateException.class) .hasMessageContaining("遍历") .hasMessageContaining(vanished.getFileName().toString()); } // ---------------------------------------------------------------- N8 只吃 .java @Test void exclude_java只计java扩展() { assertThat(SourceScan.moduleSources("modules/appearancepatent")) .as("面内每一支都必须以小写 {@code .java} 结尾——大小写策略见 exclude_大写JAVA后缀被计入") .allMatch(p -> p.getFileName().toString().endsWith(".java")); } @Test void exclude_同目录md文件不进面() throws IOException { Path module = Files.createDirectories(tmp.resolve("N8混放/src/main/java/modules/mixed")); Files.writeString(module.resolve("Keep.java"), "class Keep {}", StandardCharsets.UTF_8); Files.writeString(module.resolve("MIGRATION.md"), "# 拆分说明", StandardCharsets.UTF_8); Files.writeString(module.resolve("mapper.xml"), "", StandardCharsets.UTF_8); Files.writeString(module.resolve("notes.txt"), "x", StandardCharsets.UTF_8); assertThat(SourceScan.moduleSources(tmp.resolve("N8混放/src/main/java"), "modules/mixed")) .as("真集成同款场景:SourceScan.java:35-39 记过同类事故——注释类文本会把「被禁写法」喂成假绿。" + "正反双向一起断言:留 1 支 .java,同时排除 3 支非 java") .extracting(p -> p.getFileName().toString()) .containsExactly("Keep.java"); } @Test void exclude_大写JAVA后缀被计入() throws IOException { Path module = Files.createDirectories(tmp.resolve("N8大小写/src/main/java/modules/case")); Files.writeString(module.resolve("Lower.java"), "class Lower {}", StandardCharsets.UTF_8); Files.writeString(module.resolve("UPPER.JAVA"), "class UPPER {}", StandardCharsets.UTF_8); // 本 task 定口径:**大写 .JAVA 不计**(与仓内现状一致)。正反两条同时钉: // 谁把它改成大小写不敏感匹配,下面那条「不含 UPPER.JAVA」立刻红——这格因此不是恒绿格。 List names = SourceScan.moduleSources(tmp.resolve("N8大小写/src/main/java"), "modules/case") .stream().map(p -> p.getFileName().toString()).toList(); assertThat(names).contains("Lower.java"); assertThat(names) .as("口径选择:只认小写 .java。仓内 973 支主源码件实测全是小写后缀," + "把 .JAVA 也收进来等于给「同一份代码换个大小写再放一遍」开绿灯") .doesNotContain("UPPER.JAVA"); } @Test void exclude_以java结尾的目录名不误判() throws IOException { Path module = Files.createDirectories(tmp.resolve("N8怪目录/src/main/java/modules/weird")); Path fakeDir = Files.createDirectories(module.resolve("foo.java")); Files.writeString(fakeDir.resolve("Bar.java"), "class Bar {}", StandardCharsets.UTF_8); List files = SourceScan.moduleSources(tmp.resolve("N8怪目录/src/main/java"), "modules/weird"); assertThat(Files.isDirectory(fakeDir)) .as("正对照:这个目录确实叫 foo.java,否则下面那条断言是空的") .isTrue(); assertThat(files) .as("目录不是源文件:后缀判定必须先过 isRegularFile(walkFileTree 的 visitFile 天然只给文件," + "但这条换实现就容易踩,所以钉住)") .extracting(p -> p.getFileName().toString()) .containsExactly("Bar.java"); } @Test // plan 原文这格叫「exclude_隐藏文件.java不计入」——含点号做 Java 方法名不合法,改名并在此留痕 void exclude_隐藏文件不计入() throws IOException { Path module = Files.createDirectories(tmp.resolve("N8隐藏件/src/main/java/modules/dot")); Files.writeString(module.resolve("Real.java"), "class Real {}", StandardCharsets.UTF_8); Files.writeString(module.resolve(".Shadow.java"), "class Shadow {}", StandardCharsets.UTF_8); assertThat(SourceScan.moduleSources(tmp.resolve("N8隐藏件/src/main/java"), "modules/dot")) .as("以点开头的 .java 是编辑器备份(.Foo.java、Foo.java.orig 一族),进面就会把计数喂大。" + "正反双向:真件在、影子件不在") .extracting(p -> p.getFileName().toString()) .containsExactly("Real.java"); } @Test void exclude_空文件被计入但读为空串() throws IOException { Path module = Files.createDirectories(tmp.resolve("N8空件/src/main/java/modules/zero")); Path empty = Files.createFile(module.resolve("Empty.java")); Files.writeString(module.resolve("Kept.java"), "class Kept {}", StandardCharsets.UTF_8); List files = SourceScan.moduleSources(tmp.resolve("N8空件/src/main/java"), "modules/zero"); assertThat(Files.size(empty)) .as("正对照:这支确实是 0 字节") .isZero(); assertThat(files) .as("有文件但内容为空 ≠ 零文件——这条与 N11「目录里 0 支 .java 才抛」必须分得开," + "否则 N11 会把「全是空件」的模块误判成「没有文件」") .extracting(p -> p.getFileName().toString()) .containsExactlyInAnyOrder("Empty.java", "Kept.java"); } @Test void exclude_不可读文件抛不静默跳过() throws IOException, InterruptedException { Path root = tmp.resolve("N8不可读/src/main/java"); Path module = Files.createDirectories(root.resolve("modules/locked")); Path noList = Files.createDirectories(module.resolve("nolist")); Files.writeString(noList.resolve("Hidden.java"), "class Hidden {}", StandardCharsets.UTF_8); Process icacls = new ProcessBuilder("icacls", noList.toString(), "/deny", "*S-1-1-0:(OI)(CI)RX") .redirectErrorStream(true).start(); String out; try (var in = icacls.getInputStream()) { out = new String(in.readAllBytes(), StandardCharsets.UTF_8); } int code = icacls.waitFor(); try { assertThat(code) .as("icacls 造不出「不可列举目录」⇒ 环境缺口,判红而不是跳过(跳过会新增 Skipped,违反 N99)。" + "输出:%s", out) .isZero(); assertThat(Files.isReadable(noList)) .as("反证前提:拒绝授权必须真的生效,否则后面那条断言是恒绿的") .isFalse(); assertThatThrownBy(() -> SourceScan.moduleSources(root, "modules/locked")) .as("列举失败的目录必须把异常冒出来(visitFileFailed ⇒ IllegalStateException)," + "静默跳过 = 那个子树里的被禁写法永远不会被读到") .isInstanceOf(IllegalStateException.class) .hasMessageContaining("遍历"); } finally { // 撤销拒绝授权,否则 JUnit 清 @TempDir 会因无删除权限卡住,把一次性件留在机器上 new ProcessBuilder("icacls", noList.toString(), "/remove:d", "*S-1-1-0") .redirectErrorStream(true).start().waitFor(); } } @Test void exclude_面内全部元素isRegularFile为真() { assertThat(SourceScan.moduleSources("modules/shopdatacrawl")) .as("真实集成:51 支的模块里逐支都必须是regular file,形状契约") .isNotEmpty() .allMatch(Files::isRegularFile); } }