probatio 0.0.1 → 0.0.3

package/dist/mutate/probatio-jacoco-run.java

@@ -0,0 +1,507 @@
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.lang.reflect.Array;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Proxy;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import org.jacoco.agent.rt.IAgent;
+import org.jacoco.agent.rt.RT;
+import org.jacoco.core.analysis.Analyzer;
+import org.jacoco.core.analysis.CoverageBuilder;
+import org.jacoco.core.analysis.IClassCoverage;
+import org.jacoco.core.analysis.ILine;
+import org.jacoco.core.data.ExecutionData;
+import org.jacoco.core.data.ExecutionDataReader;
+import org.jacoco.core.data.ExecutionDataStore;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+import org.junit.runner.Result;
+
+/**
+ * One JaCoCo dump per test method.
+ * JUnit 4 uses Request.method. JUnit 5 uses one platform launch for the whole list.
+ */
+public class ProbatioJacocoRun {
+  static Object jupiterLauncher;
+  static boolean jupiterMissing;
+  static String lastNote = "";
+  static IAgent agent;
+  static StringBuilder text;
+  static Map<String, Indexed> classFiles;
+  static File packageRoot;
+  static Map<String, String> jupiterNames = new HashMap<>();
+  static int executed;
+  static int recorded;
+
+  static final class Indexed {
+    final File file;
+    final File root;
+    Indexed(File file, File root) {
+      this.file = file;
+      this.root = root;
+    }
+  }
+
+  public static void main(String[] args) throws Exception {
+    if (args.length != 4) {
+      System.err.println("usage: ProbatioJacocoRun classDirs testsFile outFile packageRoot");
+      System.exit(2);
+    }
+    String[] classDirs = args[0].split(File.pathSeparator);
+    List<String> tests = Files.readAllLines(new File(args[1]).toPath());
+    File out = new File(args[2]);
+    packageRoot = new File(args[3]);
+    classFiles = indexClasses(classDirs);
+    agent = RT.getAgent();
+    text = new StringBuilder();
+    List<String> jupiter = new ArrayList<>();
+    int requested = 0;
+    for (String spec : tests) {
+      int hash = spec.lastIndexOf('#');
+      if (hash <= 0) continue;
+      requested++;
+      String className = spec.substring(0, hash);
+      String method = spec.substring(hash + 1);
+      agent.getExecutionData(true);
+      if (runJUnit4(className, method)) {
+        executed++;
+        dump(className + "." + method);
+        continue;
+      }
+      jupiter.add(spec);
+    }
+    if (!jupiter.isEmpty()) runJupiter(jupiter);
+    Files.writeString(out.toPath(), text.toString());
+    if (requested > 0 && executed == 0) {
+      System.err.println("java coverage: no test executed " + lastNote);
+      System.exit(1);
+    }
+    if (executed > 0 && recorded == 0) {
+      System.err.println("java coverage: tests ran but JaCoCo recorded no classes");
+      System.exit(1);
+    }
+    // jsoup's integration tests leave Netty loops running. A normal return would
+    // wait on those threads until the parent clock kills the dump.
+    System.exit(0);
+  }
+
+  static Map<String, Indexed> indexClasses(String[] classDirs) {
+    Map<String, Indexed> found = new HashMap<>();
+    for (String dir : classDirs) {
+      if (dir.isEmpty()) continue;
+      File root = new File(dir);
+      if (root.isDirectory()) indexDir(root, root, found);
+    }
+    return found;
+  }
+
+  static void indexDir(File root, File dir, Map<String, Indexed> found) {
+    File[] kids = dir.listFiles();
+    if (kids == null) return;
+    for (File kid : kids) {
+      if (kid.isDirectory()) {
+        indexDir(root, kid, found);
+        continue;
+      }
+      String name = kid.getName();
+      if (!name.endsWith(".class")) continue;
+      String rel = root.toPath().relativize(kid.toPath()).toString().replace('\\', '/');
+      found.put(rel.substring(0, rel.length() - ".class".length()), new Indexed(kid, root));
+    }
+  }
+
+  static void dump(String testName) throws Exception {
+    byte[] data = agent.getExecutionData(false);
+    ExecutionDataStore store = new ExecutionDataStore();
+    ExecutionDataReader reader = new ExecutionDataReader(new ByteArrayInputStream(data));
+    reader.setExecutionDataVisitor(store);
+    reader.setSessionInfoVisitor(info -> { });
+    reader.read();
+    if (!store.getContents().isEmpty()) recorded++;
+    text.append("TEST ").append(testName).append('\n');
+    CoverageBuilder builder = new CoverageBuilder();
+    Analyzer analyzer = new Analyzer(store, builder);
+    for (ExecutionData exec : store.getContents()) {
+      if (!exec.hasHits()) continue;
+      Indexed indexed = classFiles.get(exec.getName());
+      if (indexed == null) continue;
+      analyzer.analyzeAll(indexed.file);
+    }
+    for (IClassCoverage cc : builder.getClasses()) {
+      String source = cc.getSourceFileName();
+      if (source == null) continue;
+      Indexed indexed = classFiles.get(cc.getName());
+      File file = sourceFile(indexed == null ? null : indexed.root, cc.getPackageName(), source);
+      if (file == null || !file.isFile()) continue;
+      String rel = packageRoot.toPath().relativize(file.toPath()).toString().replace('\\', '/');
+      int first = cc.getFirstLine();
+      int last = cc.getLastLine();
+      for (int line = first; line <= last; line++) {
+        ILine cov = cc.getLine(line);
+        if (cov.getInstructionCounter().getCoveredCount() <= 0) continue;
+        text.append("HIT ").append(rel).append(' ').append(line).append(' ').append(testName).append('\n');
+      }
+    }
+  }
+
+  /** JUnit 4 only. A Jupiter method has no org.junit.Test, and Request.method must not count as a run. */
+  static boolean runJUnit4(String className, String method) {
+    // Read the class file. Class.forName would initialize every Jupiter test before the batch.
+    if (!classFileMentionsJUnit4(className)) return false;
+    try {
+      Class<?> type = Class.forName(className);
+      if (!hasJUnit4Test(type, method)) return false;
+      Result result = new JUnitCore().run(Request.method(type, method));
+      if (result.getRunCount() <= 0) return false;
+      for (org.junit.runner.notification.Failure failure : result.getFailures()) {
+        String message = String.valueOf(failure.getMessage());
+        if (message.contains("No tests found") || message.contains("No runnable methods") || message.contains("initializationError")) {
+          return false;
+        }
+      }
+      return true;
+    } catch (Throwable ignored) {
+      return false;
+    }
+  }
+
+  static boolean classFileMentionsJUnit4(String className) {
+    String resource = className.replace('.', '/') + ".class";
+    try (java.io.InputStream in = ClassLoader.getSystemResourceAsStream(resource)) {
+      if (in == null) return false;
+      byte[] bytes = in.readAllBytes();
+      String latin = new String(bytes, java.nio.charset.StandardCharsets.ISO_8859_1);
+      return latin.contains("Lorg/junit/Test;");
+    } catch (java.io.IOException error) {
+      return false;
+    }
+  }
+
+  static boolean hasJUnit4Test(Class<?> type, String method) {
+    String simple = jupiterMethod(method);
+    for (java.lang.reflect.Method candidate : type.getDeclaredMethods()) {
+      if (!candidate.getName().equals(simple)) continue;
+      for (java.lang.annotation.Annotation ann : candidate.getDeclaredAnnotations()) {
+        if (ann.annotationType().getName().equals("org.junit.Test")) return true;
+      }
+    }
+    return false;
+  }
+
+  /** Simple method name. A unique id may append "()" or "(java.lang.String)". */
+  static String jupiterMethod(String method) {
+    int end = 0;
+    while (end < method.length()) {
+      char c = method.charAt(end);
+      if (Character.isLetterOrDigit(c) || c == '_' || c == '$') end++;
+      else break;
+    }
+    return end == 0 ? method : method.substring(0, end);
+  }
+
+  /**
+   * Surefire names a parameterized invocation "method(String)[1]".
+   * selectMethod(class, name) leaves the parameter list empty, and JUnit 5.14
+   * then runs nothing if any one selector fails. Keep the parameter types, and
+   * leave out a name that does not resolve.
+   */
+  static final class JupiterSpec {
+    final String className;
+    final String simple;
+    final Class<?>[] types;
+    JupiterSpec(String className, String simple, Class<?>[] types) {
+      this.className = className;
+      this.simple = simple;
+      this.types = types;
+    }
+  }
+
+  static final Map<String, Class<?>> loadedTests = new HashMap<>();
+
+  static void runJupiter(List<String> specs) {
+    if (jupiterMissing) {
+      lastNote = "jupiter launcher missing";
+      return;
+    }
+    try {
+      Map<String, JupiterSpec> unique = new LinkedHashMap<>();
+      int skipped = 0;
+      for (String spec : specs) {
+        JupiterSpec parsed = parseJupiterSpec(spec);
+        if (parsed == null) {
+          skipped++;
+          continue;
+        }
+        String key = parsed.className + "#" + parsed.simple + "#" + typeKey(parsed.types);
+        unique.putIfAbsent(key, parsed);
+        jupiterNames.put(parsed.className + "#" + parsed.simple, parsed.className + "." + parsed.simple);
+      }
+      if (unique.isEmpty()) {
+        lastNote = "jupiter no resolvable methods skipped=" + skipped;
+        return;
+      }
+      if (jupiterLauncher == null) {
+        Class<?> factory = Class.forName("org.junit.platform.launcher.core.LauncherFactory");
+        jupiterLauncher = factory.getMethod("create").invoke(null);
+      }
+      Class<?> selectorType = Class.forName("org.junit.platform.engine.DiscoverySelector");
+      Class<?> selectorsType = Class.forName("org.junit.platform.engine.discovery.DiscoverySelectors");
+      java.lang.reflect.Method select = selectMethodWithTypes(selectorsType);
+      Object selectors = Array.newInstance(selectorType, unique.size());
+      int index = 0;
+      for (JupiterSpec spec : unique.values()) {
+        Class<?> type = loadTestClass(spec.className);
+        Object selector = select.invoke(null, new Object[] { type, spec.simple, spec.types });
+        Array.set(selectors, index++, selector);
+      }
+      Class<?> builderType = Class.forName("org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder");
+      Object builder = builderType.getMethod("request").invoke(null);
+      builderType.getMethod("configurationParameter", String.class, String.class)
+        .invoke(builder, "junit.jupiter.execution.parallel.enabled", "false");
+      builderType.getMethod("selectors", Array.newInstance(selectorType, 0).getClass()).invoke(builder, selectors);
+      Object request = builderType.getMethod("build").invoke(builder);
+      Class<?> listenerType = Class.forName("org.junit.platform.launcher.TestExecutionListener");
+      Object listener = Proxy.newProxyInstance(listenerType.getClassLoader(), new Class<?>[] { listenerType }, new JupiterDump());
+      Object listeners = Array.newInstance(listenerType, 1);
+      Array.set(listeners, 0, listener);
+      Class<?> requestType = Class.forName("org.junit.platform.launcher.LauncherDiscoveryRequest");
+      Class<?> launcherType = Class.forName("org.junit.platform.launcher.Launcher");
+      launcherType.getMethod("execute", requestType, listenerType.arrayType()).invoke(jupiterLauncher, request, listeners);
+      if (executed == 0) lastNote = "jupiter started=0 resolved=" + unique.size() + " skipped=" + skipped;
+    } catch (ClassNotFoundException missing) {
+      String missingName = String.valueOf(missing.getMessage());
+      if (missingName.contains("org.junit.platform")) jupiterMissing = true;
+      lastNote = "jupiter missing " + missingName;
+    } catch (Throwable error) {
+      Throwable cause = error.getCause() == null ? error : error.getCause();
+      lastNote = "jupiter " + cause.getClass().getSimpleName() + " " + cause.getMessage();
+    }
+  }
+
+  static JupiterSpec parseJupiterSpec(String spec) {
+    int hash = spec.lastIndexOf('#');
+    if (hash <= 0) return null;
+    String className = spec.substring(0, hash).trim();
+    String method = spec.substring(hash + 1).trim();
+    while (method.endsWith("]")) {
+      int open = method.lastIndexOf('[');
+      if (open <= 0) return null;
+      method = method.substring(0, open).trim();
+    }
+    String simple;
+    String params;
+    int paren = method.indexOf('(');
+    if (paren < 0) {
+      simple = method;
+      params = null;
+    } else if (method.endsWith(")")) {
+      simple = method.substring(0, paren).trim();
+      params = method.substring(paren + 1, method.length() - 1).trim();
+    } else {
+      return null;
+    }
+    if (!isJavaIdentifier(simple) || className.isEmpty()) return null;
+    Class<?>[] types = parameterTypes(className, simple, params);
+    if (types == null) return null;
+    return new JupiterSpec(className, simple, types);
+  }
+
+  static boolean isJavaIdentifier(String name) {
+    if (name.isEmpty()) return false;
+    if (!Character.isJavaIdentifierStart(name.charAt(0))) return false;
+    for (int i = 1; i < name.length(); i++) {
+      if (!Character.isJavaIdentifierPart(name.charAt(i))) return false;
+    }
+    return true;
+  }
+
+  /** params is null when the report gave no signature. An empty string is "()". */
+  static Class<?>[] parameterTypes(String className, String simple, String params) {
+    Class<?> type = loadTestClass(className);
+    if (type == null) return null;
+    List<java.lang.reflect.Method> named = new ArrayList<>();
+    for (Class<?> cursor = type; cursor != null && cursor != Object.class; cursor = cursor.getSuperclass()) {
+      java.lang.reflect.Method[] methods;
+      try {
+        methods = cursor.getDeclaredMethods();
+      } catch (Throwable error) {
+        continue;
+      }
+      for (java.lang.reflect.Method candidate : methods) {
+        if (candidate.isBridge() || candidate.isSynthetic()) continue;
+        if (candidate.getName().equals(simple)) named.add(candidate);
+      }
+    }
+    if (named.isEmpty()) return null;
+    if (params == null) {
+      java.lang.reflect.Method noArg = null;
+      for (java.lang.reflect.Method candidate : named) {
+        if (candidate.getParameterCount() == 0) noArg = candidate;
+      }
+      if (noArg != null) return noArg.getParameterTypes();
+      return named.size() == 1 ? named.get(0).getParameterTypes() : null;
+    }
+    String[] wanted = splitParams(params);
+    java.lang.reflect.Method match = null;
+    for (java.lang.reflect.Method candidate : named) {
+      if (!paramsMatch(candidate.getParameterTypes(), wanted)) continue;
+      if (match != null) return null;
+      match = candidate;
+    }
+    return match == null ? null : match.getParameterTypes();
+  }
+
+  static Class<?> loadTestClass(String className) {
+    if (loadedTests.containsKey(className)) return loadedTests.get(className);
+    try {
+      Class<?> type = Class.forName(className);
+      loadedTests.put(className, type);
+      return type;
+    } catch (Throwable error) {
+      loadedTests.put(className, null);
+      return null;
+    }
+  }
+
+  static String[] splitParams(String params) {
+    if (params.isEmpty()) return new String[0];
+    List<String> parts = new ArrayList<>();
+    int depth = 0;
+    int start = 0;
+    for (int i = 0; i < params.length(); i++) {
+      char c = params.charAt(i);
+      if (c == '<' || c == '(') depth++;
+      else if (c == '>' || c == ')') depth = Math.max(0, depth - 1);
+      else if (c == ',' && depth == 0) {
+        parts.add(params.substring(start, i).trim());
+        start = i + 1;
+      }
+    }
+    String tail = params.substring(start).trim();
+    if (!tail.isEmpty()) parts.add(tail);
+    return parts.toArray(new String[0]);
+  }
+
+  static boolean paramsMatch(Class<?>[] actual, String[] wanted) {
+    if (actual.length != wanted.length) return false;
+    for (int i = 0; i < actual.length; i++) {
+      if (!typeMatches(actual[i], wanted[i])) return false;
+    }
+    return true;
+  }
+
+  static boolean typeMatches(Class<?> actual, String wanted) {
+    String name = wanted.trim();
+    if (name.endsWith("...")) name = name.substring(0, name.length() - 3).trim() + "[]";
+    int dims = 0;
+    while (name.endsWith("[]")) {
+      dims++;
+      name = name.substring(0, name.length() - 2).trim();
+    }
+    Class<?> cursor = actual;
+    for (int i = 0; i < dims; i++) {
+      if (cursor == null || !cursor.isArray()) return false;
+      cursor = cursor.getComponentType();
+    }
+    if (cursor == null || cursor.isArray() || name.isEmpty()) return false;
+    if (name.equals(cursor.getSimpleName()) || name.equals(cursor.getName())) return true;
+    String binary = cursor.getName().replace('$', '.');
+    if (name.equals(binary) || binary.endsWith("." + name)) return true;
+    String canon = cursor.getCanonicalName();
+    return canon != null && (name.equals(canon) || canon.endsWith("." + name));
+  }
+
+  static String typeKey(Class<?>[] types) {
+    StringBuilder key = new StringBuilder();
+    for (Class<?> type : types) {
+      if (key.length() > 0) key.append(',');
+      key.append(type.getName());
+    }
+    return key.toString();
+  }
+
+  static java.lang.reflect.Method selectMethodWithTypes(Class<?> selectorsType) throws NoSuchMethodException {
+    for (java.lang.reflect.Method candidate : selectorsType.getMethods()) {
+      if (!candidate.getName().equals("selectMethod")) continue;
+      Class<?>[] params = candidate.getParameterTypes();
+      if (params.length == 3 && params[0] == Class.class && params[1] == String.class && params[2].isArray() && params[2].getComponentType() == Class.class) {
+        return candidate;
+      }
+    }
+    throw new NoSuchMethodException("selectMethod(Class, String, Class[])");
+  }
+
+  static final class JupiterDump implements InvocationHandler {
+    public Object invoke(Object proxy, java.lang.reflect.Method method, Object[] args) {
+      if (method.getDeclaringClass() == Object.class) {
+        if (method.getName().equals("toString")) return "ProbatioJupiterDump";
+        if (method.getName().equals("hashCode")) return System.identityHashCode(proxy);
+        if (method.getName().equals("equals")) return args != null && args.length > 0 && proxy == args[0];
+      }
+      if (args == null || args.length == 0) return null;
+      try {
+        if (method.getName().equals("executionStarted")) noteStart(args[0]);
+        else if (method.getName().equals("executionFinished")) noteFinish(args[0]);
+      } catch (Throwable error) {
+        lastNote = "jupiter dump " + error.getClass().getSimpleName();
+      }
+      return null;
+    }
+  }
+
+  static String activeTest;
+
+  static void noteStart(Object identifier) throws Exception {
+    String name = testName(identifier);
+    if (name == null) return;
+    activeTest = name;
+    agent.getExecutionData(true);
+  }
+
+  static void noteFinish(Object identifier) throws Exception {
+    String name = testName(identifier);
+    if (name == null || !name.equals(activeTest)) return;
+    dump(name);
+    executed++;
+    activeTest = null;
+  }
+
+  static String testName(Object identifier) throws Exception {
+    if (!Boolean.TRUE.equals(identifier.getClass().getMethod("isTest").invoke(identifier))) return null;
+    Object uid = identifier.getClass().getMethod("getUniqueId").invoke(identifier);
+    String text = String.valueOf(uid);
+    String className = lastSegment(text, "nested-class");
+    if (className == null) className = lastSegment(text, "class");
+    String method = lastSegment(text, "method");
+    if (method == null) method = lastSegment(text, "test-template");
+    if (className == null || method == null) return null;
+    if (className.indexOf('.') < 0) {
+      String outer = lastSegment(text, "class");
+      if (outer != null && outer.indexOf('.') >= 0) className = outer + "$" + className;
+    }
+    return jupiterNames.get(className + "#" + jupiterMethod(method));
+  }
+
+  static String lastSegment(String uid, String kind) {
+    String token = "[" + kind + ":";
+    int start = uid.lastIndexOf(token);
+    if (start < 0) return null;
+    int end = uid.indexOf(']', start);
+    if (end < 0) return null;
+    return uid.substring(start + token.length(), end);
+  }
+
+  static File sourceFile(File classes, String pkg, String source) {
+    if (classes == null) return null;
+    File target = classes.getParentFile();
+    File module = target == null ? null : target.getParentFile();
+    if (module == null) return null;
+    String rel = (pkg == null || pkg.isEmpty() ? "" : pkg + "/") + source;
+    return new File(module, "src/main/java/" + rel);
+  }
+}

package/dist/mutate/run.js

@@ -6,9 +6,11 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { affectedTests } from "./affected.js";
 import { binaryFromCommand, readCoverageMap, selectionFor, writeLlvmCoverage } from "./coverage-map.js";
+import { writeGoCoverage } from "./go-coverage.js";
+import { writeJavaCoverage } from "./java-coverage.js";
 import { applyPatch, changedLines, chooseDirection, filesInDiff, git, restoreTree } from "./patch.js";
 import { killLabel } from "./kill-label.js";
-import { TIMEOUT_FLOOR_MS, TIMEOUT_MULTIPLE, TIMEOUT_NEXT, WHOLE_PROGRAM_TEST, WHOLE_SUITE_NEXT, decideSuite, noCoverageNext, resumeNext, scaleStop, timeoutLimitMs, } from "./suite-decision.js";
+import { TIMEOUT_FLOOR_MS, TIMEOUT_MULTIPLE, TIMEOUT_NEXT, WHOLE_PROGRAM_TEST, WHOLE_SUITE_NEXT, campaignSummary, decideSuite, hasLineMap, noCoverageNext, resumeNext, scaleStop, timeoutLimitMs, } from "./suite-decision.js";
 import { commandSuite, discoverSuite, runDiscoveredSuite, sourceCandidates } from "./suites.js";
 import { duplicateTitles } from "./titles.js";
 export const reporterPath = fileURLToPath(new URL("./fail-reporter.mjs", import.meta.url));
@@ -71,7 +73,9 @@ export async function runMutants(options) {
         if (!prep.ok)
             return failReport(options.outDir, run.id, commit, prep.error, prep.baselineFailed, prep.next, prep.suiteCommand);
         // The baseline already ran. A slow suite with no line map does not start the batch.
-        const scale = scaleStop({ kind: prep.spec.kind, baselineMs: prep.baselineMs, pending: pending.length });
+        // A kind that can collect a map still refuses when that map was not written.
+        const mapped = prep.coverage !== null && Object.keys(prep.coverage.files).length > 0 && hasLineMap(prep.spec.kind);
+        const scale = scaleStop({ kind: mapped ? prep.spec.kind : "unmapped", baselineMs: prep.baselineMs, pending: pending.length });
         if (scale.action === "stop") {
             const ids = pending.map((file) => path.basename(file, ".patch"));
             return failReport(options.outDir, run.id, commit, scale.summary, undefined, scale.next, prep.spec.command, prep.baselineMs, ids);
@@ -189,14 +193,28 @@ async function prepare(pkg, options, progress) {
         writeFileSync(baselineFile, `${JSON.stringify({ ok: baselineFailed.length === 0, tests: baseline.report.tests, failed: baselineFailed, command: spec.command, durationMs: baselineMs }, null, 2)}\n`);
         progress(`suite report tests=${baseline.report.tests}`);
         progress(baselineFailed.length > 0 ? `baseline failing ${baselineFailed.length}` : "baseline pass");
+        if (baselineFailed.length > 0) {
+            return { ok: false, error: "baseline already failing", baselineFailed, suiteCommand: spec.command };
+        }
+        if (collect && !existsSync(mapPath) && (spec.kind === "go" || spec.kind === "maven")) {
+            progress(spec.kind === "go" ? "go line map" : "java line map");
+            const written = spec.kind === "go"
+                ? writeGoCoverage(pkg, baseline.report.names, mapPath)
+                : writeJavaCoverage(pkg, baseline.report.names, mapPath);
+            if (!written.ok)
+                writeFileSync(path.join(options.outDir, "coverage-error.txt"), `${written.detail}\n`);
+        }
     }
     else {
         const stored = JSON.parse(readFileSync(baselineFile, "utf8"));
-        baselineFailed = stored.ok === false ? stored.failed ?? [] : [];
         baselineMs = typeof stored.durationMs === "number" ? stored.durationMs : null;
+        if (stored.ok !== true) {
+            const failed = Array.isArray(stored.failed) ? stored.failed.filter((name) => typeof name === "string") : [];
+            return { ok: false, error: "baseline already failing", baselineFailed: failed, suiteCommand: spec.command };
+        }
     }
     const affectedMap = options.affected ? affectedTests(pkg, { testsDir: options.testsDir }) : null;
-    return { ok: true, tests, affectedMap, baselineFailed, baselineMs, spec, coverage: readCoverageMap(mapPath) };
+    return { ok: true, tests, affectedMap, baselineMs, spec, coverage: readCoverageMap(mapPath) };
 }
 async function runOne(worktree, pkg, patchPath, options, commit, runId, prep) {
     const id = path.basename(patchPath, ".patch");
@@ -268,15 +286,8 @@ async function runOne(worktree, pkg, patchPath, options, commit, runId, prep) {
             return finishMutant(killed(base, direction, [main.compileToken]), pkg, commands.join(" | "), false, []);
         if (!main.report)
             return { ...base(), direction, error: "test reporter returned nothing", command: commands.join(" | ") };
-        const now = main.report.failed.map((item) => item.name);
         const whole = main.wholeSuite || forceWhole;
         const chosen = main.selectedTests;
-        if (prep.baselineFailed.length > 0) {
-            if (sameNames(now, prep.baselineFailed))
-                return finishMutant({ ...base(), direction, outcome: "survived" }, pkg, commands.join(" | "), whole, chosen);
-            const noticed = [...new Set([...now.filter((name) => !prep.baselineFailed.includes(name)), ...prep.baselineFailed.filter((name) => !now.includes(name))])];
-            return finishMutant(killed(base, direction, noticed.slice(0, 20)), pkg, commands.join(" | "), whole, chosen);
-        }
         if (main.report.failed.length === 0)
             return finishMutant({ ...base(), direction, outcome: "survived" }, pkg, commands.join(" | "), whole, chosen);
         if (!options.confirm)
@@ -342,10 +353,10 @@ async function rerunGroup(pkg, options, file, failures, counts, pattern, prep, t
     const files = file === "*" ? listTestFiles(pkg, options.testsDir, prep.spec) : [testArg(pkg, file, options.testsDir)];
     const isolated = { ...options, concurrency: 1 };
     let wholeSuite = false;
-    // Pytest confirms by node id. A regex fed to -k is a usage error, not a second look at the failure.
-    const pytestNames = prep.spec.kind === "pytest" ? failures.map((item) => item.name) : null;
+    // Pytest confirms by node id. Maven confirms by class#method. A regex is not a test name for either.
+    const directNames = prep.spec.kind === "pytest" || prep.spec.kind === "maven" ? failures.map((item) => item.name) : null;
     for (let attempt = 0; attempt < 2; attempt++) {
-        const rerun = await runSuite(pkg, files, isolated, pytestNames ? null : pattern, pytestNames, prep.spec, timeoutMs, false, null, null);
+        const rerun = await runSuite(pkg, files, isolated, directNames ? null : pattern, directNames, prep.spec, timeoutMs, false, null, null);
         if (rerun.wholeSuite)
             wholeSuite = true;
         if (rerun.command)
@@ -391,13 +402,6 @@ async function runSuite(pkg, files, options, pattern, names, spec, timeoutMs, fo
         selectedTests: result.selectedTests,
     };
 }
-function sameNames(left, right) {
-    if (left.length !== right.length)
-        return false;
-    const a = [...left].sort();
-    const b = [...right].sort();
-    return a.every((name, index) => name === b[index]);
-}
 function isNodeTestFile(file) {
     const base = path.posix.basename(file);
     return /\.(test|spec)\.(ts|tsx|mts|js|mjs|cjs)$/.test(base) || /_test\.(ts|tsx|js|mjs)$/.test(base);
@@ -623,21 +627,21 @@ function reportOf(results, context) {
         return { id: result.id, file, line, ...(known?.op ? { op: known.op } : {}) };
     });
     const budgetHit = context.budgetHit || context.pendingLeft > 0;
-    const summary = `${killed} killed, ${survived} survived, ${noCoverage} no coverage, ${flaky} flaky, ${timeouts} timed out, ${errors} errored, of ${results.length} finished.`;
+    const summary = campaignSummary({ noCoverage, survived, killed, flaky, timeouts, errors, finished: results.length });
     const notes = [];
-    if (budgetHit)
-        notes.push(resumeNext(context.notStarted));
-    if (timeouts > 0)
-        notes.push(TIMEOUT_NEXT);
     const uncovered = results.find((result) => result.outcome === "no coverage");
     if (uncovered?.next)
         notes.push(uncovered.next);
+    if (gapResults.length > 0)
+        notes.push(`First gap is ${gaps[0].id} at ${gaps[0].file}:${gaps[0].line}. A survivor is not a pass.`);
+    if (timeouts > 0)
+        notes.push(TIMEOUT_NEXT);
+    if (budgetHit)
+        notes.push(resumeNext(context.notStarted));
     if (results.some((result) => result.wholeSuite))
         notes.push(WHOLE_SUITE_NEXT);
-    if (!budgetHit && gapResults.length > 0 && timeouts === 0)
-        notes.push(`First gap is ${gaps[0].id} at ${gaps[0].file}:${gaps[0].line}.`);
     if (notes.length === 0)
-        notes.push(gapResults.length > 0 ? `First gap is ${gaps[0].id} at ${gaps[0].file}:${gaps[0].line}.` : "No survivor in this batch.");
+        notes.push("No survivor in this batch.");
     return {
         ok: true,
         summary,

package/dist/mutate/suite-decision.js

@@ -17,13 +17,20 @@ export function resumeNext(ids) {
 export function noCoverageNext(file, line) {
     return `No coverage for ${file}:${line}. No test executed that line.`;
 }
+/** Every agent-facing count starts with unseen lines, then survivors. */
+export function leadSummary(noCoverage, survivors, survivorWord, rest) {
+    return `${noCoverage} no coverage, ${survivors} ${survivorWord}, ${rest}`;
+}
+export function campaignSummary(counts) {
+    return leadSummary(counts.noCoverage, counts.survived, "survived", `${counts.killed} killed, ${counts.flaky} flaky, ${counts.timeouts} timed out, ${counts.errors} errored, of ${counts.finished} finished.`);
+}
 export function timeoutLimitMs(baselineMs, multiple, floorMs) {
     const floor = Math.max(1, floorMs);
     const scaled = Math.ceil(Math.max(0, baselineMs) * Math.max(1, multiple));
     return Math.max(floor, scaled);
 }
 /** Kinds that collect a per-line map on the baseline. Other kinds pay the whole suite. */
-const LINE_MAP_KINDS = new Set(["node", "pytest", "c"]);
+const LINE_MAP_KINDS = new Set(["node", "pytest", "c", "go", "maven"]);
 /** A baseline this long, with no line map, is too expensive to repeat for a large batch. */
 export const SLOW_BASELINE_MS = 5_000;
 /** Pending mutants above this count, on a slow unmapped suite, are not started. */