fix(qa): unblock CI/bench Docker, repair tests, address SonarCloud

- Dockerfile.bench: copy diffctx/tests so cargo manifest parses
- ci.yml: split rust tests — unit in dev, yaml_cases in release (panic=abort)
- runner.py: extract _run_serial/_run_parallel (S3516 BLOCKER, S3776)
- build_splits.py: drop redundant int return (S3516 BLOCKER)
- test_benchmark_runner: align resume contract with replay-for-aggregation
- _idents.py: extract _emit_query_idents helper (S3776)
- tokens.py: validate encoding instead of accepting unused arg (S1172)
- aider_subprocess: docstring stubs + del silent (S1186, S1172)
- splits.py: extract _TWO_COL_DIVIDER constant (S1192)
- pin_revisions.py: flatten nested ternary (S3358)
- sensitivity_check.py: regex {2} quantifier (S6326)
- merge implicit string concats across bm25/run_final_eval/multi_swebench/tests (S5799)
- tests: pytest.approx for float equality assertions (S1244)

Author: nikolay-e

.github/workflows/ci.yml

@@ -104,8 +104,9 @@ jobs:
         env:
           DIFFCTX_YAML_CASES_LIMIT: "20"
         run: |
-          cargo test --release
+          cargo test --lib
           cargo build --release
+          cargo test --release --test yaml_cases
 
       - name: Run diffctx YAML test suite
         working-directory: diffctx

Dockerfile.bench

@@ -53,6 +53,7 @@ WORKDIR /build/diffctx
 COPY diffctx/Cargo.toml diffctx/Cargo.lock diffctx/pyproject.toml ./
 COPY diffctx/src ./src
 COPY diffctx/python ./python
+COPY diffctx/tests ./tests
 
 RUN set -eux; \
     TGT=$(cat /target_triple); \

benchmarks/adapters/multi_swebench.py

@@ -90,7 +90,7 @@ def _load_raw(self) -> Iterator[dict]:
                 break
             except (DatasetGenerationError, TypeError, ValueError) as e:
                 print(
-                    f"[WARN] {self.name}: stream stopped early at row {n} " f"({type(e).__name__}: {str(e)[:200]})",
+                    f"[WARN] {self.name}: stream stopped early at row {n} ({type(e).__name__}: {str(e)[:200]})",
                     file=sys.stderr,
                 )
                 break

benchmarks/adapters/runner.py

@@ -163,17 +163,36 @@ def _record(r: EvalResult) -> None:
         if checkpoint_path is not None:
             append_checkpoint(checkpoint_path, r)
 
-    if not pending:
-        return results
+    if pending:
+        if workers <= 1 or len(pending) <= 1:
+            _run_serial(pending, eval_fn, params, _record)
+        else:
+            _run_parallel(pending, eval_fn, params, workers, timeout_per_instance, _record)
 
-    if workers <= 1 or len(pending) <= 1:
-        for inst in pending:
-            try:
-                _record(eval_fn(inst, params))
-            except Exception as e:
-                _record(_failure_result(inst, params, "error", f"{type(e).__name__}: {e}"))
-        return results
+    return results
+
+
+def _run_serial(
+    pending: list[BenchmarkInstance],
+    eval_fn: EvalFn,
+    params: RunParams,
+    record: Callable[[EvalResult], None],
+) -> None:
+    for inst in pending:
+        try:
+            record(eval_fn(inst, params))
+        except Exception as e:
+            record(_failure_result(inst, params, "error", f"{type(e).__name__}: {e}"))
 
+
+def _run_parallel(
+    pending: list[BenchmarkInstance],
+    eval_fn: EvalFn,
+    params: RunParams,
+    workers: int,
+    timeout_per_instance: float,
+    record: Callable[[EvalResult], None],
+) -> None:
     from concurrent.futures import (
         ThreadPoolExecutor,
         as_completed,
@@ -184,8 +203,6 @@ def _record(r: EvalResult) -> None:
 
     with ThreadPoolExecutor(max_workers=workers) as pool:
         futures = {pool.submit(eval_fn, inst, params): inst for inst in pending}
-        # Generous outer deadline: timeout * ceil(len/workers) covers the
-        # serialised case if workers all hang together.
         outer_deadline = time.monotonic() + timeout_per_instance * max(1, (len(pending) + workers - 1) // workers)
         completed: set[str] = set()
         try:
@@ -198,12 +215,9 @@ def _record(r: EvalResult) -> None:
                 except Exception as e:
                     r = _failure_result(inst, params, "error", f"{type(e).__name__}: {e}")
                 completed.add(inst.instance_id)
-                _record(r)
+                record(r)
         except FuturesTimeoutError:
             for inst in futures.values():
                 if inst.instance_id not in completed:
-                    _record(_failure_result(inst, params, "timeout", "exceeded global deadline"))
-        # Cancel any pending futures; running threads are abandoned.
+                    record(_failure_result(inst, params, "timeout", "exceeded global deadline"))
         pool.shutdown(wait=False, cancel_futures=True)
-
-    return results

benchmarks/adapters/splits.py

@@ -9,6 +9,8 @@
 from benchmarks.adapters.base import BenchmarkAdapter, BenchmarkInstance
 from benchmarks.adapters.contamination import ContaminationDetector
 
+_TWO_COL_DIVIDER = "|---|---|"
+
 
 @dataclass(frozen=True)
 class SplitConfig:
@@ -152,15 +154,15 @@ def render_split_report(config: SplitConfig, result: SplitResult, today: str = "
     lines.append("## Totals")
     lines.append("")
     lines.append("| Split | Count |")
-    lines.append("|---|---|")
+    lines.append(_TWO_COL_DIVIDER)
     lines.append(f"| Test | {result.stats.test_total} |")
     lines.append(f"| Validation | {result.stats.validation_total} |")
     lines.append(f"| Calibration | {result.stats.calibration_total} |")
     lines.append("")
     lines.append("## Test set per benchmark")
     lines.append("")
     lines.append("| Benchmark | Count |")
-    lines.append("|---|---|")
+    lines.append(_TWO_COL_DIVIDER)
     for name in sorted(result.stats.test_per_benchmark):
         lines.append(f"| {name} | {result.stats.test_per_benchmark[name]} |")
     lines.append("")
@@ -181,7 +183,7 @@ def render_split_report(config: SplitConfig, result: SplitResult, today: str = "
     lines.append("## Pinned dataset revisions")
     lines.append("")
     lines.append("| Adapter | Revision |")
-    lines.append("|---|---|")
+    lines.append(_TWO_COL_DIVIDER)
     for name in sorted(result.stats.dataset_revisions):
         lines.append(f"| {name} | `{result.stats.dataset_revisions[name]}` |")
     lines.append("")

benchmarks/baselines/_idents.py

@@ -84,6 +84,18 @@
 )
 
 
+def _emit_query_idents(tok: str, out: set[str]) -> None:
+    if len(tok) < 3 or tok.isdigit() or tok.lower() in _KEYWORDS:
+        return
+    out.add(tok.lower())
+    for part in _CAMEL_SPLIT_RE.split(tok):
+        if len(part) >= 3 and part.lower() not in _KEYWORDS:
+            out.add(part.lower())
+    for part in tok.split("_"):
+        if len(part) >= 3 and part.lower() not in _KEYWORDS:
+            out.add(part.lower())
+
+
 def extract_idents_from_patch(patch: str) -> set[str]:
     """Extract retrieval-query identifiers from a unified diff.
 
@@ -100,15 +112,7 @@ def extract_idents_from_patch(patch: str) -> set[str]:
             continue
         body = raw[1:] if raw[:1] in ("+", "-", " ") else raw
         for tok in _TOKEN_RE.findall(body):
-            if len(tok) < 3 or tok.isdigit() or tok.lower() in _KEYWORDS:
-                continue
-            idents.add(tok.lower())
-            for part in _CAMEL_SPLIT_RE.split(tok):
-                if len(part) >= 3 and part.lower() not in _KEYWORDS:
-                    idents.add(part.lower())
-            for part in tok.split("_"):
-                if len(part) >= 3 and part.lower() not in _KEYWORDS:
-                    idents.add(part.lower())
+            _emit_query_idents(tok, idents)
     return idents
 
 

benchmarks/baselines/aider_subprocess.py

@@ -51,20 +51,23 @@ class _SilentIO:
     """Duck-typed `io` substitute for RepoMap. No prompts, no console."""
 
     def read_text(self, fname, silent=False):
+        # `silent` is part of Aider's IO contract; ignored here because we
+        # never log anyway.
+        del silent
         try:
             with open(fname, encoding="utf-8", errors="replace") as f:
                 return f.read()
         except Exception:
             return None
 
     def tool_output(self, *args, **kwargs):
-        pass
+        """No-op: stub that swallows Aider tool output to keep the bench quiet."""
 
     def tool_warning(self, *args, **kwargs):
-        pass
+        """No-op: stub that swallows Aider tool warnings."""
 
     def tool_error(self, *args, **kwargs):
-        pass
+        """No-op: stub that swallows Aider tool errors."""
 
 
 _CODE_EXT_RE = __import__("re").compile(

benchmarks/baselines/bm25_baseline.py

@@ -48,7 +48,7 @@ def make_bm25_eval_fn(repos_dir: Path):
         from rank_bm25 import BM25Okapi
     except ImportError as e:
         raise RuntimeError(
-            "rank-bm25 not installed; expected to be in requirements-bench.lock. " "Run: pip install rank-bm25"
+            "rank-bm25 not installed; expected to be in requirements-bench.lock. Run: pip install rank-bm25"
         ) from e
 
     evaluator = UniversalEvaluator()

benchmarks/build_splits.py

@@ -66,7 +66,7 @@ def default_calibration_pool_adapters() -> tuple[BenchmarkAdapter, ...]:
     )
 
 
-def main() -> int:
+def main() -> None:
     p = argparse.ArgumentParser(description=__doc__)
     p.add_argument(
         "--out",
@@ -108,7 +108,7 @@ def main() -> int:
         print("=== SPLIT_REPORT.md (dry-run, NOT written) ===\n")
         print(report)
         print("\n--dry-run: no manifests written. Re-run without the flag to freeze.")
-        return 0
+        return
 
     written = write_manifests(result, args.out)
     report_path = args.out / "SPLIT_REPORT.md"
@@ -117,8 +117,7 @@ def main() -> int:
     for name, path in sorted(written.items()):
         print(f"  {name}: {path}")
     print(f"Report: {report_path}")
-    return 0
 
 
 if __name__ == "__main__":
-    raise SystemExit(main())
+    main()

benchmarks/pin_revisions.py

@@ -72,7 +72,8 @@ def main() -> int:
             "fetched_at": now,
             "hf_path": hf_path,
         }
-        marker = "(unchanged)" if prev == sha else f"(was {prev[:12] if prev else 'main'})"
+        prev_marker = f"was {prev[:12]}" if prev else "was main"
+        marker = "(unchanged)" if prev == sha else f"({prev_marker})"
         print(f"  OK   {hf_path:<45} {sha[:12]} {marker}")
 
     save_pins(pins)