probatio 0.0.0-stage → 0.0.2

package/dist/mutate/patch.js

@@ -0,0 +1,135 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+export function readHeader(raw) {
+    const lines = raw.split(/\r?\n/);
+    let direction = null;
+    let index = 0;
+    while (index < lines.length && !lines[index].startsWith("---") && !lines[index].startsWith("diff ")) {
+        const match = lines[index].match(/direction=(forward|reverse)/);
+        if (match)
+            direction = match[1];
+        index++;
+    }
+    const body = lines.slice(index).join("\n");
+    return { direction, body: body.endsWith("\n") || body.length === 0 ? body : `${body}\n` };
+}
+/** `diff -u` patch that applies onto the original and produces the mutant. */
+export function forwardDiff(rel, original, mutated) {
+    const dir = mkdtempSync(path.join(tmpdir(), "probatio-diff-"));
+    try {
+        const before = path.join(dir, "before");
+        const after = path.join(dir, "after");
+        writeFileSync(before, original);
+        writeFileSync(after, mutated);
+        const diff = spawnSync("diff", ["-u", "-L", `a/${rel}`, "-L", `b/${rel}`, before, after], { encoding: "utf8" });
+        if (diff.status === 0)
+            return "";
+        if (diff.status !== 1)
+            throw new Error(diff.stderr.trim() || "diff failed");
+        const body = diff.stdout.endsWith("\n") ? diff.stdout : `${diff.stdout}\n`;
+        return `# probatio-mutant direction=forward meaning=apply-to-introduce-the-bug\n${body}`;
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+export function filesInDiff(raw) {
+    const body = readHeader(raw).body;
+    const files = [];
+    const chunks = body.split(/^diff --git .*$/m);
+    const pieces = chunks.length > 1 ? chunks.slice(1) : [body];
+    for (const piece of pieces) {
+        const plus = piece.match(/^\+\+\+ ([^\t\n]+)/m);
+        const hunk = piece.match(/^@@ -\d+(?:,\d+)? \+(\d+)/m);
+        if (!plus)
+            continue;
+        let file = plus[1];
+        if (file === "/dev/null")
+            continue;
+        // git diff -R swaps the labels, so the path may be a/ or b/.
+        if (file.startsWith("a/") || file.startsWith("b/"))
+            file = file.slice(2);
+        files.push({ file, line: hunk ? Number(hunk[1]) : 1 });
+    }
+    return files;
+}
+/**
+ * Original lines a patch removes or replaces.
+ * A unified hunk starts on context, so the hunk header is not the edited line.
+ */
+export function changedLines(raw) {
+    const body = readHeader(raw).body;
+    const chunks = body.split(/^diff --git .*$/m);
+    const pieces = chunks.length > 1 ? chunks.slice(1) : [body];
+    const found = [];
+    for (const piece of pieces) {
+        const plus = piece.match(/^\+\+\+ ([^\t\n]+)/m);
+        if (!plus)
+            continue;
+        let file = plus[1];
+        if (file === "/dev/null")
+            continue;
+        if (file.startsWith("a/") || file.startsWith("b/"))
+            file = file.slice(2);
+        let oldLine = 0;
+        let inHunk = false;
+        for (const line of piece.split(/\r?\n/)) {
+            const hunk = /^@@ -(\d+)(?:,\d+)? \+\d+/.exec(line);
+            if (hunk) {
+                oldLine = Number(hunk[1]);
+                inHunk = true;
+                continue;
+            }
+            if (!inHunk)
+                continue;
+            if (line.startsWith("+") || line.startsWith("\\"))
+                continue;
+            if (line.startsWith("-")) {
+                found.push({ file, line: oldLine });
+                oldLine += 1;
+                continue;
+            }
+            if (line.startsWith(" ")) {
+                oldLine += 1;
+                continue;
+            }
+            inHunk = false;
+        }
+    }
+    return found;
+}
+export function git(repo, args, input) {
+    const result = spawnSync("git", ["-C", repo, ...args], { encoding: "utf8", input });
+    const stderr = [result.stderr ?? "", result.error?.message ?? ""].filter((part) => part.length > 0).join("\n");
+    return { status: result.status ?? 1, stdout: result.stdout ?? "", stderr };
+}
+export function patchApplies(repo, raw, direction) {
+    const args = ["apply", "--check", "--whitespace=nowarn", ...(direction === "reverse" ? ["-R"] : []), "-"];
+    return git(repo, args, readHeader(raw).body).status === 0;
+}
+export function chooseDirection(repo, raw, requested) {
+    if (requested !== "auto")
+        return requested;
+    const header = readHeader(raw).direction;
+    if (header)
+        return header;
+    if (patchApplies(repo, raw, "forward"))
+        return "forward";
+    if (patchApplies(repo, raw, "reverse"))
+        return "reverse";
+    return null;
+}
+export function applyPatch(repo, raw, direction) {
+    const args = ["apply", "--whitespace=nowarn", ...(direction === "reverse" ? ["-R"] : []), "-"];
+    const result = git(repo, args, readHeader(raw).body);
+    if (result.status === 0)
+        return { ok: true };
+    return { ok: false, error: (result.stderr || result.stdout).trim() || "apply failed" };
+}
+/** Put a throwaway worktree back. A diff label is not trusted for the path list. */
+export function restoreTree(repo) {
+    git(repo, ["checkout", "--", "."]);
+    git(repo, ["clean", "-fd", "-e", "node_modules"]);
+}

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

@@ -0,0 +1,81 @@
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.nio.file.Files;
+import java.util.List;
+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.ExecutionDataReader;
+import org.jacoco.core.data.ExecutionDataStore;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Request;
+
+/** One JaCoCo dump per JUnit 4 method. Prints "HIT <file> <line>" lines. */
+public class ProbatioJacocoRun {
+  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]);
+    File root = new File(args[3]);
+    IAgent agent = RT.getAgent();
+    StringBuilder text = new StringBuilder();
+    for (String spec : tests) {
+      int hash = spec.lastIndexOf('#');
+      if (hash <= 0) continue;
+      String className = spec.substring(0, hash);
+      String method = spec.substring(hash + 1);
+      agent.getExecutionData(true);
+      try {
+        new JUnitCore().run(Request.method(Class.forName(className), method));
+      } catch (Throwable ignored) {
+        continue;
+      }
+      byte[] data = agent.getExecutionData(false);
+      ExecutionDataStore store = new ExecutionDataStore();
+      ExecutionDataReader reader = new ExecutionDataReader(new ByteArrayInputStream(data));
+      reader.setExecutionDataVisitor(store);
+      reader.setSessionInfoVisitor(info -> { });
+      reader.read();
+      String testName = className + "." + method;
+      text.append("TEST ").append(testName).append('\n');
+      for (String dir : classDirs) {
+        if (dir.isEmpty()) continue;
+        File classes = new File(dir);
+        if (!classes.isDirectory()) continue;
+        CoverageBuilder builder = new CoverageBuilder();
+        Analyzer analyzer = new Analyzer(store, builder);
+        analyzer.analyzeAll(classes);
+        for (IClassCoverage cc : builder.getClasses()) {
+          String source = cc.getSourceFileName();
+          if (source == null) continue;
+          File file = sourceFile(classes, cc.getPackageName(), source);
+          if (file == null || !file.isFile()) continue;
+          String rel = root.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');
+          }
+        }
+      }
+    }
+    Files.writeString(out.toPath(), text.toString());
+  }
+
+  static File sourceFile(File classes, String pkg, String source) {
+    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/py-pytest-reporter.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""Run pytest and print one Probatio report as a single JSON line.
+
+When PROBATIO_COVERAGE_MAP is set and coverage.py imports, also write a
+per-test line map. A missing coverage module leaves the map unwritten.
+"""
+import json
+import os
+import sys
+
+# The sysmon core on this interpreter drops dynamic context switches.
+os.environ.setdefault("COVERAGE_CORE", "ctrace")
+
+import pytest
+
+
+class Collector:
+    def __init__(self):
+        self.names = []
+        self.failed = []
+
+    def pytest_collectreport(self, report):
+        if not report.failed:
+            return
+        self._add(getattr(report, "nodeid", "") or "pytest", report)
+
+    def pytest_runtest_logreport(self, report):
+        if report.when not in ("setup", "call"):
+            return
+        if report.when == "setup" and not report.failed:
+            return
+        name = report.nodeid
+        if report.when == "call" and name not in self.names:
+            self.names.append(name)
+        if report.failed:
+            self._add(name, report)
+
+    def _add(self, name, report):
+        if any(item["name"] == name for item in self.failed):
+            return
+        location = getattr(report, "location", None) or ("", 0, "")
+        self.failed.append({"name": name, "file": str(location[0] or ""), "line": int(location[1] or 0)})
+
+
+class ContextSwitch:
+    def __init__(self, cov):
+        self.cov = cov
+
+    def pytest_runtest_setup(self, item):
+        self.cov.switch_context(item.nodeid)
+
+
+def start_coverage():
+    dest = os.environ.get("PROBATIO_COVERAGE_MAP")
+    if not dest:
+        return None, None
+    try:
+        import coverage
+    except ImportError:
+        return None, None
+    data_file = dest + ".data"
+    try:
+        cov = coverage.Coverage(cover_pylib=False, data_file=data_file)
+        cov.start()
+        return cov, dest
+    except Exception:
+        return None, None
+
+
+def write_coverage(cov, dest):
+    try:
+        cov.stop()
+        cov.save()
+    except Exception:
+        return
+    try:
+        data = cov.get_data()
+    except Exception:
+        return
+    root = os.path.realpath(os.getcwd())
+    files = {}
+    for filename in data.measured_files():
+        full = os.path.realpath(filename)
+        if not full.startswith(root + os.sep):
+            continue
+        if "/site-packages/" in full or "/node_modules/" in full:
+            continue
+        rel = full[len(root) + 1 :]
+        try:
+            by_line = data.contexts_by_lineno(filename) or {}
+        except Exception:
+            continue
+        lines = {}
+        for lineno, contexts in by_line.items():
+            names = [item for item in contexts if item]
+            if names:
+                lines[str(lineno)] = names
+        if lines:
+            files[rel] = lines
+    with open(dest, "w", encoding="utf-8") as handle:
+        json.dump({"files": files}, handle)
+        handle.write("\n")
+
+
+def main():
+    args = []
+    index = 1
+    while index < len(sys.argv):
+        if sys.argv[index] == "--pattern":
+            args.extend(["-k", sys.argv[index + 1]])
+            index += 2
+            continue
+        args.append(sys.argv[index])
+        index += 1
+    cov, dest = start_coverage()
+    collector = Collector()
+    plugins = [collector]
+    if cov is not None:
+        plugins.append(ContextSwitch(cov))
+    code = 1
+    try:
+        code = pytest.main([*args, "-p", "no:cacheprovider", "--tb=no", "-q"], plugins=plugins) or 0
+    except BaseException:
+        code = 1
+    finally:
+        if cov is not None and dest:
+            write_coverage(cov, dest)
+    names = collector.names or [item["name"] for item in collector.failed]
+    failed = collector.failed
+    # Exit 4 is a usage error (a bad -k expression). No test ran, so this is not a kill.
+    if not names and code != 0:
+        names = []
+        failed = []
+    report = {
+        "tests": len(names),
+        "pass": len(names) - len(failed),
+        "fail": len(failed),
+        "failed": failed,
+        "names": names,
+    }
+    sys.stdout.write(json.dumps(report) + "\n")
+
+
+if __name__ == "__main__":
+    main()

package/dist/mutate/py-reporter.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""Run unittest modules and print one Probatio report as a single JSON line."""
+import importlib.util
+import json
+import os
+import re
+import sys
+import unittest
+from pathlib import Path
+
+
+def load(path: Path):
+    name = f"probatio_{path.stem}"
+    spec = importlib.util.spec_from_file_location(name, path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"cannot load {path}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def walk(suite):
+    for item in suite:
+        if isinstance(item, unittest.TestSuite):
+            yield from walk(item)
+        else:
+            yield item
+
+
+def parse_args(argv):
+    pattern = None
+    files = []
+    index = 0
+    while index < len(argv):
+        if argv[index] == "--pattern":
+            pattern = argv[index + 1]
+            index += 2
+            continue
+        files.append(argv[index])
+        index += 1
+    return pattern, files
+
+
+def main():
+    pattern, files = parse_args(sys.argv[1:])
+    sys.path.insert(0, str(Path.cwd()))
+    loader = unittest.TestLoader()
+    suite = unittest.TestSuite()
+    compiled = re.compile(pattern) if pattern else None
+    for file in files:
+        loaded = loader.loadTestsFromModule(load(Path(file)))
+        if compiled is None:
+            suite.addTest(loaded)
+        else:
+            for case in walk(loaded):
+                if compiled.fullmatch(case.id()):
+                    suite.addTest(case)
+    cases = [case for case in walk(suite) if case is not None]
+    names = [case.id() for case in cases]
+    with open(os.devnull, "w") as stream:
+        result = unittest.TextTestRunner(stream=stream, verbosity=0).run(suite)
+    failed = []
+    for case, tb in list(result.failures) + list(result.errors):
+        frames = re.findall(r'File "([^"]+)", line (\d+)', tb)
+        file, line = frames[-1] if frames else ("", "0")
+        failed.append({"name": case.id(), "file": file, "line": int(line)})
+    report = {
+        "tests": len(names),
+        "pass": len(names) - len(failed),
+        "fail": len(failed),
+        "failed": failed,
+        "names": names,
+    }
+    sys.stdout.write(json.dumps(report) + "\n")
+
+
+if __name__ == "__main__":
+    main()