Upload folder using huggingface_hub

README.md

@@ -0,0 +1,192 @@
+---
+license: cc-by-4.0
+language:
+- en
+task_categories:
+- text-generation
+tags:
+- code
+- software-engineering
+- test-evolution
+- unit-testing
+- benchmark
+- java
+- coding-agents
+size_categories:
+- n<1K
+pretty_name: TEBench
+configs:
+- config_name: default
+  data_files:
+  - split: test
+    path: data/test.parquet
+---
+
+# TEBench: Project-Level Test Evolution Benchmark
+
+> **TODO before publishing:** set the final `license:` (see *Licensing*), fill in
+> the BibTeX authors, and add the harness / Docker links.
+
+**TEBench** is the first **project-level** benchmark for *test evolution*: given a
+project repository and a commit that changes production code, a system must
+**autonomously** (1) identify which existing tests need to be modified and where
+new tests are needed, and (2) produce the corresponding test patch. Unlike prior
+method-level benchmarks that pre-pair a changed method with its test
+(`⟨m, m', t⟩`), TEBench requires reasoning across the whole project.
+
+The benchmark contains **314 task instances from 10 real-world Java/Maven
+projects** in the Defects4J ecosystem, each annotated with one or more of three
+evolution types and accompanied by **developer-written ground-truth test
+patches**.
+
+## Evolution Types
+
+| Type | Definition |
+|------|------------|
+| **Breaking** | An existing test fails to compile/run after the code change; the developer modifies it to restore correctness. |
+| **Stale** | An existing test still passes after the change but no longer meaningfully validates the new behavior; the developer updates it anyway. |
+| **Missing** | The developer adds a **new** test to cover behavior introduced/exposed by the change. |
+
+A task may carry multiple types simultaneously.
+
+## The Three-Version Structure
+
+Each instance is built around three versions of the project:
+
+- **V−1** (`base_commit`) — parent commit, before any change.
+- **V−0.5** — V−1 **plus all non-test changes** from the commit (production code,
+  build config, resources), with the **original tests untouched**. This is the
+  state given to the system: *the source has moved on, the tests have not.*
+- **V0** (`commit`) — the full commit including the developer's actual test
+  changes. This is the **ground truth**.
+
+In this dataset:
+
+- `source_patch` applies to **V−1** and reconstructs **V−0.5** (the agent's input).
+- `test_patch` is the **gold answer**: the developer's test changes (V−0.5 → V0).
+
+Both patches were generated with `git diff --binary --full-index` and are verified
+to apply cleanly to `base_commit` with `git apply` (see `validate_patches.py`):
+**314/314 source patches and 314/314 test patches apply.**
+
+## Data Fields
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `instance_id` | string | Stable id, `<project>__<short_hash>`. |
+| `project` | string | Project name. |
+| `repo` | string | Upstream GitHub slug (e.g. `apache/commons-lang`). |
+| `base_commit` | string | V−1 commit hash (parent). |
+| `commit` | string | V0 commit hash (ground-truth commit). |
+| `commit_date` | string | V0 commit date. |
+| `commit_message` | string | V0 commit message. |
+| `type` | string | Internal source category (`type 1`/`type 2`). |
+| `difficulty` | string | Curated difficulty label. |
+| `labels` | list[string] | Evolution types: `breaking` / `stale` / `missing`. |
+| `test_change_type` | string | Primary test-change category. |
+| `changed_test_methods` | list[string] | GT modified/added test methods (`Class.method`). |
+| `new_test_files` | list[string] | Test files where GT adds new methods. |
+| `new_test_methods` | string | JSON map `{TestClass: [methods]}` of GT-added methods. |
+| `num_changed_files` | int | Files changed in the commit. |
+| `src_changed_lines` | int | Production lines changed. |
+| `test_changed_lines` | int | Test lines changed. |
+| `source_patch` | string | **V−1 → V−0.5** diff (non-test; given to the system). |
+| `test_patch` | string | **V−0.5 → V0** diff (gold test changes). |
+| `label_reasoning` | string | Rationale for the assigned labels. |
+
+There is a single **`test`** split with 314 instances.
+
+## Usage
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("iSEngLab/TEBench", split="test")
+ex = ds[0]
+print(ex["instance_id"], ex["labels"])
+```
+
+Reconstruct the agent input (V−0.5) for an instance:
+
+```bash
+git clone https://github.com/<repo>.git && cd <repo>
+git checkout <base_commit>
+git apply source.patch       # now at V-0.5: new source, old tests
+# ... system produces test changes ...
+git apply test.patch         # gold V0 test changes, for reference/eval
+```
+
+## Evaluation
+
+TEBench evaluates two dimensions (full harness and Docker image referenced below):
+
+- **Identification** — Precision / Recall / F1 of the test methods the system
+  modifies/adds vs. the ground truth. Modified/deleted tests are matched at
+  **method** granularity; newly added tests at **file** granularity.
+- **Update** — a composite of **executability** (compiles & passes),
+  **coverage overlap** with GT on the changed production methods (line + branch),
+  and **modification similarity** (token Jaccard vs. GT). Executability gates the
+  score: non-compiling updates score 0.
+
+## Dataset Statistics
+
+| Project | Tasks | Breaking | Stale | Missing |
+|---------|------:|---------:|------:|--------:|
+| commons-cli | 18 | 8 | 12 | 9 |
+| commons-codec | 19 | 12 | 11 | 12 |
+| commons-collections | 23 | 10 | 14 | 15 |
+| commons-compress | 86 | 34 | 58 | 53 |
+| commons-csv | 31 | 22 | 18 | 16 |
+| commons-lang | 69 | 28 | 46 | 40 |
+| commons-math | 8 | 8 | 3 | 2 |
+| gson | 1 | 1 | 0 | 1 |
+| jfreechart | 3 | 1 | 3 | 1 |
+| jsoup | 56 | 48 | 42 | 50 |
+| **Total** | **314** | **172** | **207** | **199** |
+
+- **Multi-label:** 219 tasks (69.7%) carry ≥2 types; 45 (14.3%) carry all three;
+  95 (30.3%) are single-type.
+- **Complexity (median):** 4 changed files, 34 source lines, ~32 test lines changed.
+
+## Construction
+
+Built via a four-stage filtering pipeline over the Defects4J ecosystem:
+67,670 commits (14 Maven projects) → static filtering (post-2019, co-modification
+of `src/main` and `src/test`, real method-body changes) → 6,169 → execution-based
+validation (isolated worktrees, Maven Surefire + JaCoCo) → 561 → quality filtering
+(no merges, 5–200 test lines changed, method-level dedup) → **314 instances / 10
+projects**.
+
+## Companion Artifacts
+
+- **Evaluation harness:** *(GitHub repo — TODO link)* — identification & update
+  scoring, baselines.
+- **Reproducible environment:** a Docker image bundling all 10 projects, Maven
+  3.6.3, JDK 8/11/17, and the evaluated agents. *(registry — TODO link)*
+
+## Licensing
+
+- **Annotations / patches metadata in this dataset:** CC-BY-4.0 *(proposed — confirm)*.
+- **Embedded source code** inside `source_patch` / `test_patch` remains under the
+  **original license of each upstream project** and must be used accordingly:
+
+| Project(s) | License |
+|------------|---------|
+| commons-* (cli, codec, collections, compress, csv, lang, math), gson | Apache-2.0 |
+| jsoup | MIT |
+| jfreechart | LGPL-2.1 *(verify before redistribution)* |
+
+Attribution to the original authors is preserved through commit hashes and the
+`repo` field. Redistribution of the Docker image (which contains full source
+trees) must likewise honor these licenses.
+
+## Citation
+
+```bibtex
+@inproceedings{tebench,
+  title     = {TEBench: Benchmarking LLM Agents on Project-Level Test Evolution},
+  author    = {TODO},
+  booktitle = {TODO},
+  year      = {2026}
+}
+```

build_dataset.py

@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+"""Export TEBench into a self-contained, SWE-bench-style HuggingFace dataset.
+
+Reads the existing task spine and label table plus the local git repositories,
+and materializes one parquet file where every one of the 314 task instances
+carries its own ``source_patch`` (V-1 -> V-0.5, the production/non-test delta
+already applied for the agent) and ``test_patch`` (V-0.5 -> V0, the developer
+ground-truth test changes). Nothing under the existing TEBench tree is modified;
+all output lands in this ``hf_release/`` directory.
+"""
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+# Repo dir -> canonical upstream GitHub slug (for the ``repo`` field).
+REPO_SLUG = {
+    "commons-cli": "apache/commons-cli",
+    "commons-codec": "apache/commons-codec",
+    "commons-collections": "apache/commons-collections",
+    "commons-compress": "apache/commons-compress",
+    "commons-csv": "apache/commons-csv",
+    "commons-lang": "apache/commons-lang",
+    "commons-math": "apache/commons-math",
+    "gson": "google/gson",
+    "jfreechart": "jfree/jfreechart",
+    "jsoup": "jhy/jsoup",
+}
+
+# new_labels token -> canonical evolution type.
+LABEL_MAP = {
+    "test_breaking": "breaking",
+    "test_stale": "stale",
+    "test_missing": "missing",
+}
+
+HERE = Path(__file__).resolve().parent
+TEBENCH = HERE.parent
+TESTUPDATE = TEBENCH.parent
+
+
+def git(repo: Path, *args: str) -> str:
+    """Run a git command in ``repo`` and return stdout.
+
+    Captured as bytes and decoded without newline translation so that CRLF
+    line endings in patches (some repos store files with CRLF) are preserved
+    verbatim; otherwise the emitted patch would no longer apply to the blob.
+    """
+    out = subprocess.run(
+        ["git", "-C", str(repo), "--no-pager", *args], capture_output=True,
+    )
+    if out.returncode != 0:
+        raise RuntimeError(
+            f"git {' '.join(args)} failed in {repo}: {out.stderr.decode('utf-8', 'replace').strip()}")
+    return out.stdout.decode("utf-8", "replace")
+
+
+def is_test_file(path: str) -> bool:
+    return "/src/test/" in path or path.startswith("src/test/")
+
+
+def split_patch(repo: Path, base: str, head: str):
+    """Return (source_patch, test_patch, n_src_files, n_test_files)."""
+    names = [p for p in git(repo, "diff", "--name-only", base, head).splitlines() if p]
+    test_files = [p for p in names if is_test_file(p)]
+    src_files = [p for p in names if not is_test_file(p)]
+
+    def diff(files):
+        if not files:
+            return ""
+        # --binary --full-index keep binary hunks and full blob hashes so the
+        # patch applies standalone with `git apply` (no repo objects needed).
+        return git(repo, "diff", "--no-color", "--no-ext-diff",
+                   "--binary", "--full-index", base, head, "--", *files)
+
+    return diff(src_files), diff(test_files), len(src_files), len(test_files)
+
+
+def to_list(cell) -> list:
+    if cell is None or (isinstance(cell, float) and pd.isna(cell)):
+        return []
+    return [x.strip() for x in str(cell).split("|") if x.strip()]
+
+
+def load_labels(labels_csv: Path) -> dict:
+    """Map (project, short_hash) -> {labels, reasoning, new_test_methods, new_test_files}."""
+    df = pd.read_csv(labels_csv, dtype=str).fillna("")
+    out = {}
+    for _, r in df.iterrows():
+        key = (r["project"], r["v_0_commit"])
+        labels = [LABEL_MAP[t] for t in to_list(r.get("new_labels")) if t in LABEL_MAP]
+        out[key] = {
+            "labels": labels,
+            "label_reasoning": r.get("reasoning", ""),
+            "new_test_methods": r.get("new_test_methods", ""),
+            "new_test_files": to_list(r.get("new_test_files")),
+        }
+    return out
+
+
+SCHEMA = pa.schema([
+    ("instance_id", pa.string()),
+    ("project", pa.string()),
+    ("repo", pa.string()),
+    ("base_commit", pa.string()),       # V-1 (parent)
+    ("commit", pa.string()),            # V0  (ground-truth commit)
+    ("commit_date", pa.string()),
+    ("commit_message", pa.string()),
+    ("type", pa.string()),
+    ("difficulty", pa.string()),
+    ("labels", pa.list_(pa.string())),  # breaking / stale / missing
+    ("test_change_type", pa.string()),
+    ("changed_test_methods", pa.list_(pa.string())),
+    ("new_test_files", pa.list_(pa.string())),
+    ("new_test_methods", pa.string()),  # JSON blob from source table
+    ("num_changed_files", pa.int64()),
+    ("src_changed_lines", pa.int64()),
+    ("test_changed_lines", pa.int64()),
+    ("source_patch", pa.string()),      # V-1 -> V-0.5 (non-test, given to agent)
+    ("test_patch", pa.string()),        # V-0.5 -> V0  (gold test changes)
+    ("label_reasoning", pa.string()),
+])
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--spine", type=Path,
+                    default=TEBENCH / "data" / "filtered_commits_step2_full.csv")
+    ap.add_argument("--labels", type=Path,
+                    default=TESTUPDATE / "classification_results_v2.csv")
+    ap.add_argument("--repos", type=Path,
+                    default=TESTUPDATE / "TUDataset" / "defects4j-projects")
+    ap.add_argument("--out", type=Path, default=HERE / "data" / "test.parquet")
+    args = ap.parse_args()
+
+    spine = pd.read_excel(args.spine, engine="openpyxl")
+    labels = load_labels(args.labels)
+    print(f"spine rows={len(spine)}  label rows={len(labels)}")
+
+    records, errors, missing_labels = [], [], 0
+    for i, row in enumerate(spine.itertuples(index=False), 1):
+        project = row.Project
+        short = str(row.CommitID)
+        full = str(row.FullHash)
+        repo = args.repos / project
+        try:
+            base = git(repo, "rev-parse", "--verify", f"{full}^").strip()
+            msg = git(repo, "log", "-1", "--format=%B", full).strip()
+            src_patch, test_patch, n_src, n_test = split_patch(repo, base, full)
+        except Exception as e:  # noqa: BLE001
+            errors.append(f"{project}/{short}: {e}")
+            continue
+
+        lab = labels.get((project, short))
+        if lab is None:
+            missing_labels += 1
+            lab = {"labels": [], "label_reasoning": "", "new_test_methods": "", "new_test_files": []}
+
+        records.append({
+            "instance_id": f"{project}__{short}",
+            "project": project,
+            "repo": REPO_SLUG.get(project, project),
+            "base_commit": base,
+            "commit": full,
+            "commit_date": str(row.Date),
+            "commit_message": msg,
+            "type": str(row.Type),
+            "difficulty": str(row.Difficulty),
+            "labels": lab["labels"],
+            "test_change_type": str(row.TestChangeType),
+            "changed_test_methods": to_list(row.ChangedTestMethods),
+            "new_test_files": lab["new_test_files"],
+            "new_test_methods": lab["new_test_methods"],
+            "num_changed_files": int(row.ChangedFiles),
+            "src_changed_lines": int(row.SrcChangedLines),
+            "test_changed_lines": int(row.TestChangedLines),
+            "source_patch": src_patch,
+            "test_patch": test_patch,
+            "label_reasoning": lab["label_reasoning"],
+        })
+        if i % 50 == 0:
+            print(f"  ...{i}/{len(spine)}")
+
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    table = pa.Table.from_pylist(records, schema=SCHEMA)
+    pq.write_table(table, args.out)
+
+    # ---- validation summary ----
+    b = sum("breaking" in r["labels"] for r in records)
+    s = sum("stale" in r["labels"] for r in records)
+    m = sum("missing" in r["labels"] for r in records)
+    empty_src = sum(not r["source_patch"] for r in records)
+    empty_test = sum(not r["test_patch"] for r in records)
+    print("\n==== summary ====")
+    print(f"instances written : {len(records)}")
+    print(f"errors            : {len(errors)}")
+    print(f"missing labels    : {missing_labels}")
+    print(f"labels  B/S/M     : {b}/{s}/{m}   (paper: 172/207/199)")
+    print(f"empty source_patch: {empty_src}")
+    print(f"empty test_patch  : {empty_test}")
+    print(f"written to        : {args.out}")
+    if errors:
+        print("\nfirst errors:")
+        for e in errors[:10]:
+            print("  ", e)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

data/test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bfd6fbe724bd7a56f6c32fe7f8c1f91603528e6d9dc4d075657f62833a190434
+size 5204033

validate_patches.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""Check that every instance's source_patch + test_patch apply cleanly.
+
+For each task we create an isolated detached worktree at ``base_commit``, apply
+``source_patch`` (recreating V-0.5), then apply ``test_patch`` (the gold V0 test
+changes). Failures are reported per instance. Requires the local repos under
+``defects4j-projects``; only used for verification, not for dataset consumption.
+"""
+import argparse, os, shutil, subprocess, tempfile
+from pathlib import Path
+import pandas as pd
+
+HERE = Path(__file__).resolve().parent
+REPOS = HERE.parent.parent / "TUDataset" / "defects4j-projects"
+
+
+def apply_check(wt, patch):
+    if not patch.strip():
+        return True, ""
+    p = subprocess.run(["git", "-C", wt, "-c", "core.autocrlf=false",
+                        "apply", "--check", "-"],
+                       input=patch, text=True, capture_output=True)
+    return p.returncode == 0, p.stderr.strip()
+
+
+def apply(wt, patch):
+    if not patch.strip():
+        return
+    subprocess.run(["git", "-C", wt, "-c", "core.autocrlf=false", "apply", "-"],
+                   input=patch, text=True, capture_output=True)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--parquet", type=Path, default=HERE / "data" / "test.parquet")
+    ap.add_argument("--repos", type=Path, default=REPOS)
+    ap.add_argument("--limit", type=int, default=0, help="0 = all")
+    args = ap.parse_args()
+
+    df = pd.read_parquet(args.parquet)
+    if args.limit:
+        df = df.head(args.limit)
+
+    ok_src = ok_test = 0
+    fails = []
+    for n, (_, r) in enumerate(df.iterrows(), 1):
+        repo = args.repos / r["project"]
+        wt = tempfile.mkdtemp(prefix="teb_wt_")
+        try:
+            subprocess.run(["git", "-C", str(repo), "worktree", "add", "-q",
+                            "--detach", wt, r["base_commit"]], capture_output=True)
+            s_ok, s_err = apply_check(wt, r["source_patch"])
+            if s_ok:
+                ok_src += 1
+                apply(wt, r["source_patch"])
+                t_ok, t_err = apply_check(wt, r["test_patch"])
+            else:
+                t_ok, t_err = False, "(source failed first)"
+            if t_ok:
+                ok_test += 1
+            if not (s_ok and t_ok):
+                fails.append((r["instance_id"], s_ok, t_ok,
+                              (s_err or t_err).splitlines()[-1][:120] if (s_err or t_err) else ""))
+        finally:
+            subprocess.run(["git", "-C", str(repo), "worktree", "remove",
+                            "--force", wt], capture_output=True)
+            shutil.rmtree(wt, ignore_errors=True)
+        if n % 50 == 0:
+            print(f"  ...{n}/{len(df)}")
+
+    print(f"\nsource_patch apply ok: {ok_src}/{len(df)}")
+    print(f"test_patch   apply ok: {ok_test}/{len(df)}")
+    if fails:
+        print(f"\n{len(fails)} failures:")
+        for iid, s, t, msg in fails:
+            print(f"  {iid:34s} src={s} test={t}  {msg}")
+
+
+if __name__ == "__main__":
+    main()