代码只改了几行,为什么可能需要重跑几千条测试?

def select_tests(change):
    must_run   = coverage_hits(change) | owner_tests(change)        # 确定性证据,必须跑
    history    = history_cofail(change)                              # 历史共同失败,必须跑
    ai_extra   = ai_suggest(change, min_confidence=0.6)              # AI只能在此基础上追加
    selected   = must_run | history | ai_extra
    if uncertainty(change) >= THRESHOLD:                             # 不确定性高,升级全量
        return ALL_TESTS
    return selected

"""
变更影响分析与测试选择:模拟代码库实验(可复现)
说明:这是一个构造的模拟环境,所有参数写在 PARAMS 中,结论只反映这些假设下的现象,
不代表任何真实项目的统计数据。这里没有调用任何大模型,模拟的是"依赖图+覆盖率+历史"
这一层确定性信号;AI 层应基于同一份回放数据替换"选择器"后再对比。
"""
import numpy as np, sys

PARAMS = dict(
    N_MOD=80, F=12, N_LAYER=8,          # 80个模块,每个12个函数,共960个函数,分8层(第0层为公共基础层)
    N_TEST=3000,                         # 3000条测试
    EDGE_TAKEN=0.75,                     # 集成测试执行时,每条调用边被走到的概率
    INT_FRAC=0.3,                        # 集成测试占比;其余为单元测试(依赖被mock,只执行本模块内函数)
    MAX_OUT=6,                           # 每个函数最多调用几个其他函数(0~MAX_OUT-1)
    HIDDEN_EDGE=0.08,                    # 静态分析看不到的调用边(反射/事件/配置驱动)占比
    COV_STALE=0.04,                      # 覆盖率记录与真实执行不一致的比例(数据陈旧)
    COUPLE=0.10,                         # 函数存在"非调用耦合"(共享配置/表/开关)的概率
    COUPLE_KNOWN=0.5,                    # 其中被历史缺陷记录学到的比例
    N_COMMIT=2000, BUG_RATE=0.10,        # 每个提交含缺陷的概率
    P_DET_UNIT=0.6, P_DET_INT=0.25,      # 单元/集成测试执行到缺陷函数时,断言真正失败的概率
    P_DET_COUPLE=0.5,                    # 执行到耦合函数的测试,因共享状态失败的概率
    ESCALATE_FRAC=0.35,                  # 筛选结果超过该比例直接升级全量
)

def build(seed, P):
    rng = np.random.default_rng(seed)
    NM, F = P["N_MOD"], P["F"]; NF = NM*F; per_layer = NM//P["N_LAYER"]
    mod_of = np.arange(NF)//F; layer_of_mod = np.arange(NM)//per_layer
    edges = []  # (src,dst,hidden)
    def zipf(n): w = 1/(np.arange(n)+1)**0.8; return w/w.sum()
    for f in range(NF):
        m = mod_of[f]; L = layer_of_mod[m]; loc = f % F
        for _ in range(rng.integers(0,P["MAX_OUT"])):
            if (L == 0 or rng.random() < 0.35):
                if loc == 0: continue
                g = m*F + rng.integers(0,loc)
            else:
                lw = np.array([2.0]+[1.0]*(L-1))[:L]; lw/=lw.sum()
                tl = rng.choice(L, p=lw)
                tm = tl*per_layer + rng.choice(per_layer, p=zipf(per_layer))
                g = tm*F + rng.choice(F, p=zipf(F))
            edges.append((f,g,rng.random()<P["HIDDEN_EDGE"]))
    out = [[] for _ in range(NF)]; sinc = [[] for _ in range(NF)]
    for s,d,h in edges:
        out[s].append(d)
        if not h: sinc[d].append(s)
    # 静态反向传递闭包规模(谁会直接或间接调用我)
    reach = np.zeros(NF, int)
    for f in range(NF):
        seen={f}; st=[f]
        while st:
            x=st.pop()
            for c in sinc[x]:
                if c not in seen: seen.add(c); st.append(c)
        reach[f]=len(seen)-1
    # 测试
    T = P["N_TEST"]
    lay_w = np.array([0.5,0.5,0.8,1,1.2,1.5,1.8,2.0])[:P["N_LAYER"]]
    mw = lay_w[layer_of_mod]; mw = mw/mw.sum()
    is_int = rng.random(T) < P["INT_FRAC"]
    owner = rng.choice(NM, size=T, p=mw)
    hi_mods = np.where(layer_of_mod>=3)[0]
    owner[is_int] = rng.choice(hi_mods, size=is_int.sum())
    cov = np.zeros((T,NF), bool)
    for t in range(T):
        entries = rng.choice(np.arange(owner[t]*F,(owner[t]+1)*F), size=rng.integers(1,4), replace=False)
        seen=set(entries); st=list(entries)
        while st:
            x=st.pop()
            for c in out[x]:
                if c in seen: continue
                if is_int[t]:
                    if rng.random()<P["EDGE_TAKEN"]: seen.add(c); st.append(c)
                elif mod_of[c]==owner[t] and rng.random()<0.8:
                    seen.add(c); st.append(c)
        cov[t,list(seen)] = True
    dur = rng.lognormal(0,0.9,T)
    cov_rec = cov & (rng.random(cov.shape) > P["COV_STALE"])
    coupled = np.full(NF,-1)
    for f in range(NF):
        if rng.random()<P["COUPLE"]:
            h=rng.integers(0,NF)
            if mod_of[h]!=mod_of[f]: coupled[f]=h
    known = np.array([coupled[f]>=0 and rng.random()<P["COUPLE_KNOWN"] for f in range(NF)])
    return dict(is_int=is_int,rng=rng,NF=NF,mod_of=mod_of,layer_of_mod=layer_of_mod,reach=reach,owner=owner,
                cov=cov,cov_rec=cov_rec,dur=dur,coupled=coupled,known=known,T=T)

def run(seed, P, verbose=False):
    W = build(seed,P); rng=W["rng"]; T=W["T"]; cov=W["cov"]; rec=W["cov_rec"]
    owner=W["owner"]; mod_of=W["mod_of"]; dur=W["dur"]; coupled=W["coupled"]; known=W["known"]
    thr = np.percentile(W["reach"],85)
    S = {k:dict(n=0,d=0.0,det=0,miss=0) for k in ["全量回归","规则筛选(目录映射)","依赖+覆盖+历史","依赖+覆盖+历史+风险兜底"]}
    bugs=0; undetectable=0; esc=0; sizeC=[]; by_layer={}; examples=[]
    for _ in range(P["N_COMMIT"]):
        k = rng.choice([1,2,3],p=[.5,.3,.2]); ch = rng.choice(W["NF"],k,replace=False)
        has_bug = rng.random()<P["BUG_RATE"]; b = rng.choice(ch)
        # 各策略选中的测试
        full = np.ones(T,bool)
        B = np.isin(owner, np.unique(mod_of[ch]))
        C = B | rec[:,ch].any(1)
        for f in ch:
            if known[f]: C |= rec[:,coupled[f]]
        risk = (W["reach"][ch]>=thr).any() or known[ch].any() or C.mean()>P["ESCALATE_FRAC"]
        D = full if risk else C
        esc += int(risk)
        sizeC.append(C.mean())
        lay = W["layer_of_mod"][mod_of[ch].min()]
        by_layer.setdefault(lay,[]).append(C.mean())
        if k==1: examples.append((lay,int(C.sum()),int(ch[0]),int(W["reach"][ch[0]])))
        sel = {"全量回归":full,"规则筛选(目录映射)":B,"依赖+覆盖+历史":C,"依赖+覆盖+历史+风险兜底":D}
        for name,s in sel.items():
            S[name]["n"]+=s.sum(); S[name]["d"]+=dur[s].sum()
        if has_bug:
            bugs+=1
            pdet = np.where(W["is_int"],P["P_DET_INT"],P["P_DET_UNIT"])
            Dset = (cov[:,b] & (rng.random(T)<pdet))
            if coupled[b]>=0: Dset |= (cov[:,coupled[b]] & (rng.random(T)<P["P_DET_COUPLE"]))
            if not Dset.any(): undetectable+=1; continue
            for name,s in sel.items():
                if (s&Dset).any(): S[name]["det"]+=1
                else: S[name]["miss"]+=1
    detectable = bugs-undetectable
    res = {n:dict(test_frac=v["n"]/(T*P["N_COMMIT"]), dur_frac=v["d"]/(dur.sum()*P["N_COMMIT"]),
                  recall=v["det"]/max(detectable,1), miss=v["miss"]) for n,v in S.items()}
    sizeC=np.array(sizeC)
    extra = dict(bugs=bugs,detectable=detectable,esc_rate=esc/P["N_COMMIT"],
                 medC=np.median(sizeC)*T,p90C=np.percentile(sizeC,90)*T,maxC=sizeC.max()*T,
                 gt50=(sizeC>0.5).mean(), by_layer={l:np.mean(v)*T for l,v in sorted(by_layer.items())},
                 examples=examples, T=T)
    return res, extra

if __name__=="__main__":
    P=dict(PARAMS)
    agg={}; ex=None
    for seed in range(10):
        r,e = run(seed,P)
        for n,v in r.items(): agg.setdefault(n,[]).append(v)
        if seed==0: ex=e
        agg.setdefault("_bugs",[]).append(e["detectable"]); agg.setdefault("_esc",[]).append(e["esc_rate"])
    print("== 10个随机种子汇总(每个种子2000次提交)==")
    print("可发现缺陷总数(10种子合计):", sum(agg["_bugs"]), " 风险兜底升级为全量的提交占比: %.1f%%"%(100*np.mean(agg["_esc"])))
    for n in ["全量回归","规则筛选(目录映射)","依赖+覆盖+历史","依赖+覆盖+历史+风险兜底"]:
        v=agg[n]
        tf=np.mean([x["test_frac"] for x in v]); df=np.mean([x["dur_frac"] for x in v])
        rc=[x["recall"] for x in v]; ms=sum(x["miss"] for x in v)
        print(f"{n}: 平均执行测试占比 {tf*100:.1f}% | 耗时占比 {df*100:.1f}% | 提交前缺陷检出率 均值 {np.mean(rc)*100:.1f}% (范围 {min(rc)*100:.1f}%~{max(rc)*100:.1f}%) | 漏到夜间全量的缺陷数 {ms}")
    print("\n== 种子0:选中规模分布(依赖+覆盖+历史,未兜底) ==")
    print(f"中位数 {ex['medC']:.0f} 条, P90 {ex['p90C']:.0f} 条, 最大 {ex['maxC']:.0f} 条, 选中超过一半用例的提交占比 {ex['gt50']*100:.1f}%")
    print("按被改函数所在层(0=公共基础层)的平均选中条数:", {l:round(v) for l,v in ex["by_layer"].items()})
    one=[x for x in ex["examples"]]
    hi=max(one,key=lambda x:x[1]); lo=min([x for x in one if x[0]==7] or one,key=lambda x:x[1])
    print("单函数改动里选中最多:",f"层{hi[0]}, 选中{hi[1]}条, 静态上游调用方{hi[3]}个")
    print("第7层单函数改动里选中最少:",f"选中{lo[1]}条, 静态上游调用方{lo[3]}个")
    print("\n== 敏感性:非调用耦合概率 COUPLE 对 提交前缺陷检出率 的影响(5种子均值) ==")
    for c in [0.0,0.1,0.2,0.3]:
        Q=dict(P); Q["COUPLE"]=c
        rs=[run(s,Q)[0] for s in range(5)]
        for n in ["规则筛选(目录映射)","依赖+覆盖+历史","依赖+覆盖+历史+风险兜底"]:
            print(f"COUPLE={c}: {n}: 检出率 {np.mean([r[n]['recall'] for r in rs])*100:.1f}%  耗时占比 {np.mean([r[n]['dur_frac'] for r in rs])*100:.1f}%")