回归测试有一句被讲了很多年的老话：覆盖要全，用例越多越保险。

这句话在手工写用例的年代基本成立——因为每一条用例都很贵，贵到人不会去写第二条几乎一样的。约束本身就在替你做剪枝。

AI 把这个约束拆了。现在一句「帮我把这个函数的边界都覆盖上」，几十上百条用例几秒就生成出来，回归集从两三百条涨到上千条只用了两周。于是老话突然失灵了：用例是多了，可跑一轮要四十分钟，真出缺陷时它照样漏。

这篇只讲一件事：把「覆盖全」换成「每条用例值不值它那份运行时间」，用变异测试的思路给回归集重新算一遍检出率的账。不聊代码评审，不聊简历怎么写，也不聊 CI 怎么接。

一、业务场景：一千二百条用例，拦不住一个改错的边界
场景钉死。一个计费函数 calc_discount，逻辑不复杂：按订单金额分档打折，再叠一个会员等级的加成，边界条件七八个。上线前 AI 帮着把回归集补到了 1200 条用例【推断】，本地跑一轮 40 分钟【推断】，CI 上因为要拉环境更久。

团队挺安心，直到一次线上事故：有人把分档的 >= 手滑改成了 >，金额刚好卡在档位边界的那批订单少打了一档折扣。这个改动在提交前的全量回归里全绿通过——1200 条用例没有一条真正压在那个边界值上。

问题不在用例不够多，而在多的那一千多条里，绝大多数在重复覆盖同一片区域。它们互相之间高度冗余：删掉任何一条，剩下的用例照样能杀死同一批变异体。它们唯一稳定的贡献，是把运行时间从 8 分钟拉到 40 分钟。

这就是 AI 时代回归集的新型技术债：用例数量的通胀，掩盖了检出能力的停滞。

二、老账和新账：从「覆盖了多少」到「独占领了多少」
传统上我们衡量回归集，看的是覆盖率——语句覆盖、分支覆盖。但覆盖率有个盲区：它只回答「这行代码有没有被执行到」，不回答「这行代码被改错了，有没有用例能发现」。

一条用例可以百分之百覆盖某个分支，却对这个分支里的所有错误都无感——因为它只断言了「不抛异常」，没断言返回值。覆盖率漂亮，检出能力为零。

变异测试补的正是这个盲区。它的逻辑很朴素：故意把代码改错（造一个变异体），看有没有用例能抓到。

衡量维度
覆盖率视角（老账）
变异测试视角（新账）
回答的问题
这行代码被执行到了吗
这行代码改错了，有用例能发现吗
对冗余的态度
冗余用例也贡献覆盖，看着都算数
冗余用例杀不死新变异体，贡献为零
用例价值的单位
覆盖到的行 / 分支数
独占杀死的变异体数
典型盲区
只断言不抛异常，覆盖率满却检不出错
等价变异体需人工甄别，成本高
AI 大量生成后
数字虚高，掩盖检出停滞
直接暴露「只增时间不增检出」的用例
新账里，一条用例的价值不再是「它覆盖了什么」，而是「它独占杀死了几个变异体」——即有几个变异体，只有它能杀死、别的用例都杀不死。独占杀死数为 0 的用例，就是纯冗余：它杀死的每一个变异体，都有别的用例也在杀。

三、变异体怎么造：三类最常见的注入
自研一个最小变异器不用复杂，抓住三类注入就能覆盖大多数真实缺陷形态：

改运算符：> ↔ >=、< ↔ <=、+ ↔ -、* ↔ /、and ↔ or。边界类缺陷几乎都落在这里，比如上文那次 >= 改 > 的事故。
改边界常量：把 100 改成 101 或 99，把 0 改成 1。分档阈值、off-by-one 错误的主要来源。
改返回值 / 取反：把 return x 改成 return -x，把布尔判断取反。抓那种「逻辑走对了但结果算反」的用例。
关键纪律有两条。第一，一次只注入一个变异，否则用例失败了也说不清是哪个改动被抓到的。第二，要能识别等价变异体——有些改动不改变程序行为（比如把 i++ 改成 i = i + 1），任何用例都不可能杀死它，这类要从分母里剔除，否则杀死率永远到不了 100%，账就不准。

四、可运行脚本：给每条用例算检出率
下面是一个教学用的最小变异器，只依赖 Python 标准库，Python 3.8+，pip 都不用装。它做三件事：对被测函数注入变异体、逐个跑用例、统计每条用例杀死了几个变异体、并算出每条用例的独占贡献。

运行方式：把被测函数、变异算子、用例集写在同一文件里，python mutation_score.py 即可。

mutation_score.py 依赖：仅 Python 标准库，无需 pip 安装

运行：python mutation_score.pyimport copy# ---------- 1) 被测函数（示例：分档折扣 + 会员加成）----------def calc_discount(amount, level):if amount >= 1000: # 边界：>= 是关键 base = 0.20elif amount >= 500: base = 0.12else: base = 0.05 bonus = 0.03 levelreturn round(amount (base + bonus), 2)# ---------- 2) 变异算子：对源码字符串做一次替换，生成一个变异体 ----------# 每个算子 = (原片段, 变异片段, 说明)。一次只注入一处。OPERATORS = [ ("amount >= 1000", "amount > 1000", "改边界:>=变>"), ("amount >= 500", "amount > 500", "改边界:>=变>"), ("0.03 level", "0.03 / level", "改运算符:变/"), ("base = 0.05", "base = 0.06", "改常量:0.05变0.06"), ("base + bonus", "base - bonus", "改运算符:+变-"),]def make_mutant(src, old, new):"""把源码里的 old 换成 new，编译成一个可调用的变异体函数。""" mutated = src.replace(old, new, 1) # 只替换第一处，保证单点变异 ns = {} exec(mutated, ns) # 教学演示用 exec；生产请用 ASTreturn ns["calc_discount"]# ---------- 3) 用例集：每条 = (输入, 期望输出)。期望值取自原函数的正确行为 ----------import inspectSRC = inspect.getsource(calc_discount)CASES = [# (amount, level, expected) —— expected 由原函数预先算好写死 ("卡在1000边界", (1000, 2), calc_discount(1000, 2)), ("卡在999", (999, 2), calc_discount(999, 2)), ("卡在500边界", (500, 1), calc_discount(500, 1)), ("小额订单", (100, 0), calc_discount(100, 0)), ("大额高会员", (5000, 5), calc_discount(5000, 5)), ("重复:又一个小额", (120, 0), calc_discount(120, 0)), # 与「小额订单」高度冗余 ("重复:再一个大额", (6000, 5), calc_discount(6000, 5)), # 与「大额高会员」高度冗余]# ---------- 4) 建变异体 + 跑用例，统计杀死矩阵 ----------mutants = []for old, new, desc in OPERATORS:try: mutants.append((desc, make_mutant(SRC, old, new)))except Exception:pass# 注入后语法错误等，视为无效变异体，跳过# kill_matrix[i][j] = True 表示第 i 条用例杀死了第 j 个变异体killmatrix = [[False] * len(mutants) for in CASES]for i, (name, args, expected) in enumerate(CASES):for j, (desc, fn) in enumerate(mutants):try: got = fn(*args) killed = got != expected # 行为与原函数不同 => 杀死except Exception: killed = True# 变异体直接抛异常也算被杀死 kill_matrix[i][j] = killed# ---------- 5) 算每条用例的独占贡献 ----------# 某变异体被多少条用例杀死killed_by_count = [sum(1for i in range(len(CASES)) if kill_matrix[i][j])for j in range(len(mutants))]survived = [j for j, c in enumerate(killed_by_count) if c == 0] # 存活变异体exclusive = [] # 每条用例「独占杀死」的变异体数for i in range(len(CASES)): excl = sum(1for j in range(len(mutants))if kill_matrix[i][j] and killed_by_count[j] == 1) exclusive.append(excl)# ---------- 6) 打印账本 ----------total_mutants = len(mutants)killed_total = total_mutants - len(survived)print(f"有效变异体: {total_mutants} 被杀死: {killed_total} "f"杀死率: {killed_total/totalmutants:.0%}")print(f"存活变异体(没任何用例抓到): {[mutants[j][0] for j in survived]}")print("\n每条用例的检出账：")for i, (name, , _) in enumerate(CASES): kills = sum(kill_matrix[i]) tag = " <== 纯冗余(独占=0)"if exclusive[i] == 0else"" print(f" {name:<16} 杀死 {kills}/{total_mutants} 独占 {exclusive[i]}{tag}")

跑出来的账本大致长这样（数字为本文示例设定值【推断】）：五个变异体里，两条边界用例各独占杀死了 >= 变 > 的变异体，独占贡献为 1；而标了「重复」的两条用例，杀死的变异体全部被别的用例也杀死了，独占贡献为 0——它们就是可以安全删掉的纯冗余。

这段脚本最该记住的不是代码，而是第 5 步那行判断：独占 = 只有你杀死、别人都杀不死的变异体数。 独占为 0 的用例，删了不损失任何检出能力，只省运行时间。

生产环境别用 exec 注入（安全和等价变异体都难控），Java 用 PIT、Python 用 mutmut、JS 用 Stryker，它们把变异算子和等价体处理做得比这个玩具完整得多。但账法是一样的：先拿到杀死矩阵，再按「独占贡献」给每条用例排序。

五、按账本剪枝：砍冗余，补死角
拿到杀死矩阵后，剪枝动作只有两类，方向相反：

砍冗余——独占贡献为 0 的用例。 这批用例杀死的变异体全被别人覆盖，删掉不降杀死率，只降运行时间。上文那两条「重复」用例就是典型。AI 生成的回归集里，这类往往占三四成【推断】，因为它们本质是同一个等价类里换了个数字的重复采样。

补死角——存活变异体对应的输入。 存活变异体意味着「这个改动没有任何用例能抓到」，它精确指出了回归集的盲区。上文那个 >= 改 > 之所以能溜过全量回归，就是因为没有一条用例的输入恰好卡在 1000 这个边界值上。补一条 amount=1000 的用例，这个变异体当场被杀死。

用例类型
独占贡献
对杀死率
对运行时间
处置
边界独占型
≥1
有正贡献
值
保留，重点维护
冗余重复型
0
无贡献
纯增
删除
弱断言型
0（只测不抛异常）
无贡献
纯增
补断言或删
死角未覆盖
存活变异体指向
缺口
——
按存活变异体补新用例
剪枝的目标不是「用例更少」，而是「同样甚至更高的杀死率，用更少的运行时间」。把 1200 条砍到 400 条、杀死率不降反升、跑一轮从 40 分钟回到 8 分钟【推断】——这才是回归集该有的经济学。

六、把这笔账挂进日常
一次算清不够，AI 还在持续往回归集里加用例，账要能反复算。三个轻量做法：

一是新增用例先过独占体检。AI 生成一批用例后，别急着合进回归集，先跑一遍杀死矩阵，独占贡献为 0 的直接不进——从源头掐住通胀。

二是杀死率进 CI 看板，和覆盖率并排放。覆盖率涨、杀死率不涨，就是在堆冗余，这是个很清晰的预警信号。

三是定期重算存活变异体。代码改了，盲区会变，存活变异体清单就是「下一批该补的用例」的待办列表，比凭感觉补用例准得多。

有一点要提醒：这笔账不必每次全量跑。变异测试本身很贵——一个变异体就要把用例集重跑一遍，上千条用例配几十个变异体，全量算一次可能是几十分钟到几小时。日常做法是只对改动过的函数局部算账，把变异体限制在本次 diff 涉及的代码上，既拿到了检出贡献的排序，又把开销压在可接受范围内。全量重算留给大版本前的体检，一个月一次足够。

七、写在最后
用例的价值，不在于它覆盖了什么，而在于它能独占杀死几个错误。

AI 让造用例的成本趋近于零，却也让「用例多 = 保险」这个老等式彻底失效——因为通胀的数量掩盖了停滞的检出能力。回归集真正该被度量的，从来不是它有多大，而是它每花一分钟运行时间，换回了多少别人换不回的检出贡献。把这笔账算清，你会发现要删的和要补的，一样多。