differential-coverage 1.1.2__tar.gz → 1.2.0__tar.gz

{differential_coverage-1.1.2 → differential_coverage-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: differential_coverage
-Version: 1.1.2
+Version: 1.2.0
 Summary: Compute differential coverage, a better way of comparing testing tools.
 Author-email: Valentin Huber <contact@valentinhuber.me>
 License-Expression: MIT
@@ -43,7 +43,11 @@ For more precise definitions, including formulas, look at [DEFINITIONS.md](./DEF
 
 ## How?
 
-Campaign data lives in one directory per approach, with one file per trial. Two input formats are supported:
+Campaign data lives in one directory per approach, with one file per trial. Three input formats are supported.
+
+**All approaches in one campaign must use the same input format and the same edge ID scheme.** afl-showmap edge IDs (numeric bitmap indices), libFuzzer merge COV indices (PC-table indices), and llvm-cov edge IDs (source locations) are not comparable — do not mix them in one campaign. Format is detected from file content (`auto`, default). Override with `--input-format` if needed.
+
+For **afl-showmap** and **libfuzzer-merge**, edge IDs are opaque indices into the instrumented binary, so every trial must use the **same binary** (same build/instrumentation). **llvm-cov** uses source locations instead, so the binary may differ as long as source paths are consistent across exports (I think™).
 
 ### afl-showmap
 
@@ -88,6 +92,8 @@ llvm-cov export \
 
 Run once per trial (merge profdata first if a trial replays multiple inputs). Use `--granularity branch` or `block` for llvm-cov exports; afl-showmap uses `edge` (selected automatically with `--granularity auto`).
 
+On macOS, use Homebrew LLVM rather than Apple Clang: `brew install llvm`, then either add `$(brew --prefix llvm)/bin` to your `PATH` or call tools by full path (e.g. `$(brew --prefix llvm)/bin/clang`). Built-in `clang` _may_ work, but is untested.
+
 **All trials in a campaign must use the same input format, granularity, and consistent source paths (llvm-cov).** If paths differ between machines, re-export with `llvm-cov export -path-equivalence=<build-path>,<local-path>`.
 
 #### cov-analysis
@@ -101,11 +107,28 @@ cov-analysis -d /path/to/fuzzer-out/ -e "./cov @@"
 
 Copy one `coverage.json` per trial into your campaign directory (same layout as above). The format matches `llvm-cov export -format=text`.
 
-### Edge IDs and mixing formats
+### libFuzzer merge control files
+
+Same layout, with merge control files from libFuzzer's `-merge=1` mode:
 
-**All approaches in one campaign must use the same input format and the same edge ID scheme.** afl-showmap edge IDs (numeric bitmap indices) and llvm-cov edge IDs (source locations) are not comparable — do not mix them in one campaign.
+```
+coverage_data
+|-- approach_1
+|   |-- trial_1.merge
+|   `-- trial_2.merge
+`-- seeds
+    `-- seeds.merge
+```
+
+Generate each trial file by merging a seeds corpus with trial inputs and keeping the control file:
+
+```bash
+empty=$(mktemp -d)
+./my_fuzzer -merge=1 -merge_control_file=trial_1.merge "$empty" CORPUS_DIR
+rmdir "$empty"
+```
 
-Format is detected from file content (`auto`, default). Override with `--input-format` if needed.
+Use an empty first corpus so every input is recorded. The reader unions all `COV` lines (PC-table indices; `--granularity edge`). Same binary across trials; LLVM 10+.
 
 ### Installation
 
@@ -123,7 +146,7 @@ pip install differential-coverage[latex]
 Generally, the command line interface follows the following structure:
 
 ```bash
-differential-coverage {relcov,relscore} [--input-format {auto,afl-showmap,llvm-cov}] [--granularity {auto,branch,block,edge}] <campaign-dir>
+differential-coverage {relcov,relscore} [--input-format {auto,afl-showmap,llvm-cov,libfuzzer-merge}] [--granularity {auto,branch,block,edge}] <campaign-dir>
 ```
 
 Examples:

{differential_coverage-1.1.2 → differential_coverage-1.2.0}/README.md

@@ -19,7 +19,11 @@ For more precise definitions, including formulas, look at [DEFINITIONS.md](./DEF
 
 ## How?
 
-Campaign data lives in one directory per approach, with one file per trial. Two input formats are supported:
+Campaign data lives in one directory per approach, with one file per trial. Three input formats are supported.
+
+**All approaches in one campaign must use the same input format and the same edge ID scheme.** afl-showmap edge IDs (numeric bitmap indices), libFuzzer merge COV indices (PC-table indices), and llvm-cov edge IDs (source locations) are not comparable — do not mix them in one campaign. Format is detected from file content (`auto`, default). Override with `--input-format` if needed.
+
+For **afl-showmap** and **libfuzzer-merge**, edge IDs are opaque indices into the instrumented binary, so every trial must use the **same binary** (same build/instrumentation). **llvm-cov** uses source locations instead, so the binary may differ as long as source paths are consistent across exports (I think™).
 
 ### afl-showmap
 
@@ -64,6 +68,8 @@ llvm-cov export \
 
 Run once per trial (merge profdata first if a trial replays multiple inputs). Use `--granularity branch` or `block` for llvm-cov exports; afl-showmap uses `edge` (selected automatically with `--granularity auto`).
 
+On macOS, use Homebrew LLVM rather than Apple Clang: `brew install llvm`, then either add `$(brew --prefix llvm)/bin` to your `PATH` or call tools by full path (e.g. `$(brew --prefix llvm)/bin/clang`). Built-in `clang` _may_ work, but is untested.
+
 **All trials in a campaign must use the same input format, granularity, and consistent source paths (llvm-cov).** If paths differ between machines, re-export with `llvm-cov export -path-equivalence=<build-path>,<local-path>`.
 
 #### cov-analysis
@@ -77,11 +83,28 @@ cov-analysis -d /path/to/fuzzer-out/ -e "./cov @@"
 
 Copy one `coverage.json` per trial into your campaign directory (same layout as above). The format matches `llvm-cov export -format=text`.
 
-### Edge IDs and mixing formats
+### libFuzzer merge control files
+
+Same layout, with merge control files from libFuzzer's `-merge=1` mode:
 
-**All approaches in one campaign must use the same input format and the same edge ID scheme.** afl-showmap edge IDs (numeric bitmap indices) and llvm-cov edge IDs (source locations) are not comparable — do not mix them in one campaign.
+```
+coverage_data
+|-- approach_1
+|   |-- trial_1.merge
+|   `-- trial_2.merge
+`-- seeds
+    `-- seeds.merge
+```
+
+Generate each trial file by merging a seeds corpus with trial inputs and keeping the control file:
+
+```bash
+empty=$(mktemp -d)
+./my_fuzzer -merge=1 -merge_control_file=trial_1.merge "$empty" CORPUS_DIR
+rmdir "$empty"
+```
 
-Format is detected from file content (`auto`, default). Override with `--input-format` if needed.
+Use an empty first corpus so every input is recorded. The reader unions all `COV` lines (PC-table indices; `--granularity edge`). Same binary across trials; LLVM 10+.
 
 ### Installation
 
@@ -99,7 +122,7 @@ pip install differential-coverage[latex]
 Generally, the command line interface follows the following structure:
 
 ```bash
-differential-coverage {relcov,relscore} [--input-format {auto,afl-showmap,llvm-cov}] [--granularity {auto,branch,block,edge}] <campaign-dir>
+differential-coverage {relcov,relscore} [--input-format {auto,afl-showmap,llvm-cov,libfuzzer-merge}] [--granularity {auto,branch,block,edge}] <campaign-dir>
 ```
 
 Examples:

{differential_coverage-1.1.2 → differential_coverage-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "differential_coverage"
-version = "1.1.2"
+version = "1.2.0"
 description = "Compute differential coverage, a better way of comparing testing tools."
 readme = "README.md"
 license = "MIT"

{differential_coverage-1.1.2 → differential_coverage-1.2.0}/src/differential_coverage/cli.py

@@ -12,7 +12,8 @@ from differential_coverage.output import print_relcov_corpus_table, print_scores
 # All subcommands expect this directory layout (one campaign dir, no moving files).
 CAMPAIGN_DIR_HELP = (
     "Campaign directory: one subdirectory per approach, each containing "
-    "trial coverage files (afl-showmap id:count files or llvm-cov export JSON)."
+    "trial coverage files (afl-showmap id:count files, llvm-cov export JSON, "
+    "or libFuzzer merge control files)."
 )
 
 try:
@@ -133,11 +134,12 @@ def build_parser() -> argparse.ArgumentParser:
 
     parser.add_argument(
         "--input-format",
-        choices=["auto", "afl-showmap", "llvm-cov"],
+        choices=["auto", "afl-showmap", "llvm-cov", "libfuzzer-merge"],
         default="auto",
         help=(
             "Input format for trial files: auto (default) detects from file "
-            "extensions, afl-showmap for id:count files, llvm-cov for export JSON."
+            "content; afl-showmap for id:count files; llvm-cov for export JSON; "
+            "libfuzzer-merge for -merge=1 control files."
         ),
     )
     parser.add_argument(
@@ -155,8 +157,8 @@ def build_parser() -> argparse.ArgumentParser:
         default="auto",
         help=(
             "Coverage granularity: auto (default) uses edge for afl-showmap and "
-            "branch for llvm-cov; branch/block for llvm-cov exports; edge for "
-            "afl-showmap bitmap tuples."
+            "libfuzzer-merge, branch for llvm-cov; branch/block for llvm-cov "
+            "exports; edge for afl-showmap bitmap tuples and libFuzzer COV lines."
         ),
     )
     parser.add_argument(

{differential_coverage-1.1.2 → differential_coverage-1.2.0}/src/differential_coverage/readers/__init__.py

@@ -1,4 +1,4 @@
-from differential_coverage.readers import afl_showmap, llvm_cov
+from differential_coverage.readers import afl_showmap, libfuzzer_merge, llvm_cov
 from differential_coverage.readers.registry import (
     Granularity,
     GranularityArg,
@@ -15,4 +15,4 @@ __all__ = [
     "resolve_reader",
 ]
 
-_ = (afl_showmap, llvm_cov)
+_ = (afl_showmap, libfuzzer_merge, llvm_cov)

differential_coverage-1.2.0/src/differential_coverage/readers/libfuzzer_merge.py

@@ -0,0 +1,41 @@
+from pathlib import Path
+
+from differential_coverage.readers.registry import (
+    Granularity,
+    TrialReader,
+    register_reader,
+)
+
+
+def read(path: Path, *, granularity: Granularity) -> set[str]:
+    if granularity != "edge":
+        raise ValueError("libfuzzer-merge only supports --granularity edge")
+    edges: set[str] = set()
+    for line in path.read_text().splitlines():
+        parts = line.split()
+        if len(parts) < 3 or parts[0] != "COV":
+            continue
+        edges.update(parts[2:])
+    if not edges:
+        raise ValueError(f"No covered edges in {path}")
+    return edges
+
+
+def detect(path: Path) -> bool:
+    lines = [line.strip() for line in path.read_text().splitlines() if line.strip()]
+    if len(lines) < 3:
+        return False
+    try:
+        num_files = int(lines[0])
+        num_first = int(lines[1])
+    except ValueError:
+        return False
+    if num_files <= 0 or num_first > num_files:
+        return False
+    has_marker = any(
+        line.startswith("STARTED ") or line.startswith("COV ") for line in lines
+    )
+    return has_marker
+
+
+register_reader(TrialReader(name="libfuzzer-merge", read=read, detect=detect))

{differential_coverage-1.1.2 → differential_coverage-1.2.0}/src/differential_coverage/readers/registry.py

@@ -3,18 +3,20 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Literal, Protocol
 
-ReaderName = Literal["afl-showmap", "llvm-cov"]
-InputFormat = Literal["auto", "afl-showmap", "llvm-cov"]
+ReaderName = Literal["afl-showmap", "llvm-cov", "libfuzzer-merge"]
+InputFormat = Literal["auto", "afl-showmap", "llvm-cov", "libfuzzer-merge"]
 Granularity = Literal["branch", "block", "edge"]
 GranularityArg = Literal["auto", "branch", "block", "edge"]
 
 _SUPPORTED: dict[ReaderName, frozenset[Granularity]] = {
     "afl-showmap": frozenset({"edge"}),
     "llvm-cov": frozenset({"branch", "block"}),
+    "libfuzzer-merge": frozenset({"edge"}),
 }
 _DEFAULT: dict[ReaderName, Granularity] = {
     "afl-showmap": "edge",
     "llvm-cov": "branch",
+    "libfuzzer-merge": "edge",
 }
 
 

{differential_coverage-1.1.2 → differential_coverage-1.2.0}/src/differential_coverage.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: differential_coverage
-Version: 1.1.2
+Version: 1.2.0
 Summary: Compute differential coverage, a better way of comparing testing tools.
 Author-email: Valentin Huber <contact@valentinhuber.me>
 License-Expression: MIT
@@ -43,7 +43,11 @@ For more precise definitions, including formulas, look at [DEFINITIONS.md](./DEF
 
 ## How?
 
-Campaign data lives in one directory per approach, with one file per trial. Two input formats are supported:
+Campaign data lives in one directory per approach, with one file per trial. Three input formats are supported.
+
+**All approaches in one campaign must use the same input format and the same edge ID scheme.** afl-showmap edge IDs (numeric bitmap indices), libFuzzer merge COV indices (PC-table indices), and llvm-cov edge IDs (source locations) are not comparable — do not mix them in one campaign. Format is detected from file content (`auto`, default). Override with `--input-format` if needed.
+
+For **afl-showmap** and **libfuzzer-merge**, edge IDs are opaque indices into the instrumented binary, so every trial must use the **same binary** (same build/instrumentation). **llvm-cov** uses source locations instead, so the binary may differ as long as source paths are consistent across exports (I think™).
 
 ### afl-showmap
 
@@ -88,6 +92,8 @@ llvm-cov export \
 
 Run once per trial (merge profdata first if a trial replays multiple inputs). Use `--granularity branch` or `block` for llvm-cov exports; afl-showmap uses `edge` (selected automatically with `--granularity auto`).
 
+On macOS, use Homebrew LLVM rather than Apple Clang: `brew install llvm`, then either add `$(brew --prefix llvm)/bin` to your `PATH` or call tools by full path (e.g. `$(brew --prefix llvm)/bin/clang`). Built-in `clang` _may_ work, but is untested.
+
 **All trials in a campaign must use the same input format, granularity, and consistent source paths (llvm-cov).** If paths differ between machines, re-export with `llvm-cov export -path-equivalence=<build-path>,<local-path>`.
 
 #### cov-analysis
@@ -101,11 +107,28 @@ cov-analysis -d /path/to/fuzzer-out/ -e "./cov @@"
 
 Copy one `coverage.json` per trial into your campaign directory (same layout as above). The format matches `llvm-cov export -format=text`.
 
-### Edge IDs and mixing formats
+### libFuzzer merge control files
+
+Same layout, with merge control files from libFuzzer's `-merge=1` mode:
 
-**All approaches in one campaign must use the same input format and the same edge ID scheme.** afl-showmap edge IDs (numeric bitmap indices) and llvm-cov edge IDs (source locations) are not comparable — do not mix them in one campaign.
+```
+coverage_data
+|-- approach_1
+|   |-- trial_1.merge
+|   `-- trial_2.merge
+`-- seeds
+    `-- seeds.merge
+```
+
+Generate each trial file by merging a seeds corpus with trial inputs and keeping the control file:
+
+```bash
+empty=$(mktemp -d)
+./my_fuzzer -merge=1 -merge_control_file=trial_1.merge "$empty" CORPUS_DIR
+rmdir "$empty"
+```
 
-Format is detected from file content (`auto`, default). Override with `--input-format` if needed.
+Use an empty first corpus so every input is recorded. The reader unions all `COV` lines (PC-table indices; `--granularity edge`). Same binary across trials; LLVM 10+.
 
 ### Installation
 
@@ -123,7 +146,7 @@ pip install differential-coverage[latex]
 Generally, the command line interface follows the following structure:
 
 ```bash
-differential-coverage {relcov,relscore} [--input-format {auto,afl-showmap,llvm-cov}] [--granularity {auto,branch,block,edge}] <campaign-dir>
+differential-coverage {relcov,relscore} [--input-format {auto,afl-showmap,llvm-cov,libfuzzer-merge}] [--granularity {auto,branch,block,edge}] <campaign-dir>
 ```
 
 Examples:

{differential_coverage-1.1.2 → differential_coverage-1.2.0}/src/differential_coverage.egg-info/SOURCES.txt

@@ -15,12 +15,14 @@ src/differential_coverage.egg-info/requires.txt
 src/differential_coverage.egg-info/top_level.txt
 src/differential_coverage/readers/__init__.py
 src/differential_coverage/readers/afl_showmap.py
+src/differential_coverage/readers/libfuzzer_merge.py
 src/differential_coverage/readers/llvm_cov.py
 src/differential_coverage/readers/registry.py
 tests/test_api.py
 tests/test_approach_data.py
 tests/test_cli.py
 tests/test_docs.py
+tests/test_libfuzzer_merge.py
 tests/test_llvm_cov.py
 tests/test_output.py
 tests/test_readers.py

differential_coverage-1.2.0/tests/test_libfuzzer_merge.py

@@ -0,0 +1,121 @@
+"""Unit tests for libFuzzer merge control file input."""
+
+import io
+import re
+import sys
+from pathlib import Path
+
+import pytest
+
+from differential_coverage.api import DifferentialCoverage
+from differential_coverage.cli import main
+from differential_coverage.fs import read_approach_dir, read_campaign_dir
+from differential_coverage.readers import libfuzzer_merge
+from differential_coverage.readers.registry import detect_reader, resolve_granularity
+
+_DONE_COV_RE = re.compile(r"^\#\d+\s+DONE\s+cov:\s+(\d+)", re.MULTILINE)
+
+
+def _run_cli(argv: list[str]) -> tuple[int | str, str]:
+    out = io.StringIO()
+    old_stdout = sys.stdout
+    try:
+        sys.stdout = out
+        code = main(argv)
+    except SystemExit as exc:
+        code = int(exc.code) if exc.code is not None else 1
+    finally:
+        sys.stdout = old_stdout
+    return code, out.getvalue()
+
+
+def _calc_merge(calc_merge_dir: Path, *parts: str) -> Path:
+    return calc_merge_dir.joinpath(*parts)
+
+
+def _parse_libfuzzer_done_cov(log_text: str) -> int:
+    matches = _DONE_COV_RE.findall(log_text)
+    if not matches:
+        raise ValueError("no DONE cov line in libFuzzer merge output")
+    return int(matches[-1])
+
+
+def test_read_cov_matches_libfuzzer_merge_output(
+    calc_build_dir: Path, calc_merge_dir: Path
+) -> None:
+    merge_logs = calc_build_dir / "build" / "merge_logs"
+    for merge_file in sorted(calc_merge_dir.rglob("*.merge")):
+        rel = merge_file.relative_to(calc_merge_dir)
+        log_file = merge_logs / rel.parent / f"{merge_file.stem}.log"
+        assert log_file.is_file(), f"missing libFuzzer log for {merge_file}"
+        expected_cov = _parse_libfuzzer_done_cov(log_file.read_text())
+        edges = libfuzzer_merge.read(merge_file, granularity="edge")
+        assert len(edges) == expected_cov, (
+            f"{rel}: reader found {len(edges)} edges, "
+            f"libFuzzer reported cov: {expected_cov}"
+        )
+
+
+def test_read_detect_and_read(calc_merge_dir: Path) -> None:
+    merge_file = _calc_merge(calc_merge_dir, "approach_a", "t1.merge")
+    assert libfuzzer_merge.detect(merge_file)
+    edges = libfuzzer_merge.read(merge_file, granularity="edge")
+    assert edges
+    assert all(edge.isdigit() for edge in edges)
+
+
+def test_detect_reader(calc_merge_dir: Path) -> None:
+    merge_file = _calc_merge(calc_merge_dir, "approach_a", "t1.merge")
+    assert detect_reader(merge_file) == "libfuzzer-merge"
+
+
+def test_granularity_rejects_non_edge(calc_merge_dir: Path) -> None:
+    merge_file = _calc_merge(calc_merge_dir, "approach_a", "t1.merge")
+    with pytest.raises(ValueError, match="does not support --granularity branch"):
+        resolve_granularity("libfuzzer-merge", "branch")
+    with pytest.raises(ValueError, match="only supports --granularity edge"):
+        libfuzzer_merge.read(merge_file, granularity="block")
+
+
+def test_read_raises_without_cov_lines(tmp_path: Path) -> None:
+    merge_file = tmp_path / "empty.merge"
+    merge_file.write_text("1\n1\n/input\n")
+    with pytest.raises(ValueError, match="No covered edges"):
+        libfuzzer_merge.read(merge_file, granularity="edge")
+
+
+def test_read_approach_dir(calc_merge_dir: Path) -> None:
+    trials = read_approach_dir(
+        calc_merge_dir / "approach_a",
+        input_format="libfuzzer-merge",
+    )
+    assert trials
+    assert all(edges for edges in trials.values())
+
+
+def test_read_campaign_dir(calc_merge_dir: Path) -> None:
+    campaign = read_campaign_dir(
+        calc_merge_dir,
+        input_format="libfuzzer-merge",
+    )
+    assert {"seeds", "approach_a", "approach_b", "approach_c"} <= set(campaign.keys())
+
+
+def test_relcov_from_merge_campaign(calc_merge_dir: Path) -> None:
+    dc = DifferentialCoverage.from_campaign_dir(
+        calc_merge_dir,
+        input_format="libfuzzer-merge",
+    )
+    approach_c = dc.approaches["approach_c"]
+    for approach in ("approach_a", "approach_b", "seeds"):
+        assert approach_c.relcov(dc.approaches[approach]) == 1.0
+
+
+def test_cli_relscore(calc_merge_dir: Path) -> None:
+    code, out = _run_cli(
+        ["--input-format", "libfuzzer-merge", "relscore", str(calc_merge_dir)]
+    )
+    assert code == 0
+    lines = [line.strip() for line in out.strip().splitlines()]
+    assert any(line.startswith("approach_c:") for line in lines)
+    assert any(line.startswith("approach_a:") for line in lines)

{differential_coverage-1.1.2 → differential_coverage-1.2.0}/tests/test_llvm_cov.py

@@ -30,6 +30,52 @@ def _calc_export(calc_coverage_dir: Path, *parts: str) -> Path:
     return calc_coverage_dir.joinpath(*parts)
 
 
+def _covered_code_region_keys(export: Path) -> list[str]:
+    """Covered CodeRegion location keys (may include duplicates)."""
+    data = json.loads(export.read_text())
+    keys: list[str] = []
+    for item in data.get("data", []):
+        for function in item.get("functions", []):
+            filenames = function["filenames"]
+            for region in function.get("regions", []):
+                # CountedRegion: exec=4, file_id=5, kind=7; CodeRegion kind=0
+                if region[4] <= 0 or region[7] != 0:
+                    continue
+                file_id = region[5]
+                keys.append(
+                    f"fn:{function['name']}@{filenames[file_id]}:"
+                    f"{region[0]}:{region[1]}-{region[2]}:{region[3]}"
+                )
+    return keys
+
+
+def test_read_cov_matches_llvm_cov_summary(
+    calc_build_dir: Path, calc_coverage_dir: Path
+) -> None:
+    summaries = calc_build_dir / "build" / "llvm_summaries"
+    for export in sorted(calc_coverage_dir.rglob("*.json")):
+        rel = export.relative_to(calc_coverage_dir)
+        summary_file = summaries / rel.parent / f"{export.stem}.json"
+        assert summary_file.is_file(), f"missing llvm-cov summary for {export}"
+        totals = json.loads(summary_file.read_text())["data"][0]["totals"]
+        branch_edges = llvm_cov.read(export, granularity="branch")
+        block_edges = llvm_cov.read(export, granularity="block")
+        assert len(branch_edges) == totals["branches"]["covered"], (
+            f"{rel} branch: reader found {len(branch_edges)}, "
+            f"llvm-cov reported {totals['branches']['covered']}"
+        )
+        # Summary counts CodeRegion hits with multiplicity; the reader dedupes
+        # by source location (same as differential-coverage edge identity).
+        region_keys = _covered_code_region_keys(export)
+        assert len(region_keys) == totals["regions"]["covered"], (
+            f"{rel} regions: export has {len(region_keys)} covered CodeRegions, "
+            f"llvm-cov reported {totals['regions']['covered']}"
+        )
+        assert block_edges == set(region_keys), (
+            f"{rel} block: reader set does not match unique covered CodeRegions"
+        )
+
+
 def test_read_llvm_cov_branch_uses_function_scope(calc_coverage_dir: Path) -> None:
     export = _calc_export(calc_coverage_dir, "approach_a", "t1.json")
     edges = llvm_cov.read(export, granularity="branch")

{differential_coverage-1.1.2 → differential_coverage-1.2.0}/tests/test_readers.py

@@ -4,7 +4,7 @@ from pathlib import Path
 
 import pytest
 
-from differential_coverage.readers import afl_showmap, llvm_cov
+from differential_coverage.readers import afl_showmap, libfuzzer_merge, llvm_cov
 from differential_coverage.readers.registry import detect_reader, resolve_reader
 
 AFL_FIXTURE = Path(__file__).parent / "fixtures" / "afl_showmap" / "t1.txt"
@@ -14,6 +14,10 @@ def _llvm_export(calc_coverage_dir: Path) -> Path:
     return next((calc_coverage_dir / "approach_a").glob("*.json"))
 
 
+def _merge_export(calc_merge_dir: Path) -> Path:
+    return calc_merge_dir / "approach_a" / "t1.merge"
+
+
 def test_afl_showmap_detect_and_read() -> None:
     assert afl_showmap.detect(AFL_FIXTURE)
     assert not llvm_cov.detect(AFL_FIXTURE)
@@ -24,27 +28,45 @@ def test_llvm_cov_detect_and_read(calc_coverage_dir: Path) -> None:
     export = _llvm_export(calc_coverage_dir)
     assert llvm_cov.detect(export)
     assert not afl_showmap.detect(export)
+    assert not libfuzzer_merge.detect(export)
     assert llvm_cov.read(export, granularity="branch")
 
 
-def test_detect_reader(calc_coverage_dir: Path) -> None:
+def test_libfuzzer_merge_detect_and_read(calc_merge_dir: Path) -> None:
+    merge_file = _merge_export(calc_merge_dir)
+    assert libfuzzer_merge.detect(merge_file)
+    assert not afl_showmap.detect(merge_file)
+    assert not llvm_cov.detect(merge_file)
+    edges = libfuzzer_merge.read(merge_file, granularity="edge")
+    assert edges
+    assert all(edge.isdigit() for edge in edges)
+
+
+def test_detect_reader(calc_coverage_dir: Path, calc_merge_dir: Path) -> None:
     export = _llvm_export(calc_coverage_dir)
+    merge_file = _merge_export(calc_merge_dir)
     assert detect_reader(AFL_FIXTURE) == "afl-showmap"
     assert detect_reader(export) == "llvm-cov"
+    assert detect_reader(merge_file) == "libfuzzer-merge"
 
 
-def test_resolve_reader_auto(calc_coverage_dir: Path) -> None:
+def test_resolve_reader_auto(calc_coverage_dir: Path, calc_merge_dir: Path) -> None:
     export = _llvm_export(calc_coverage_dir)
+    merge_file = _merge_export(calc_merge_dir)
     reader = resolve_reader([AFL_FIXTURE], "auto")
     assert reader.name == "afl-showmap"
     reader = resolve_reader([export], "auto")
     assert reader.name == "llvm-cov"
+    reader = resolve_reader([merge_file], "auto")
+    assert reader.name == "libfuzzer-merge"
 
 
-def test_resolve_reader_forced(calc_coverage_dir: Path) -> None:
+def test_resolve_reader_forced(calc_coverage_dir: Path, calc_merge_dir: Path) -> None:
     export = _llvm_export(calc_coverage_dir)
+    merge_file = _merge_export(calc_merge_dir)
     assert resolve_reader([export], "llvm-cov").name == "llvm-cov"
     assert resolve_reader([AFL_FIXTURE], "afl-showmap").name == "afl-showmap"
+    assert resolve_reader([merge_file], "libfuzzer-merge").name == "libfuzzer-merge"
 
 
 def test_afl_showmap_rejects_block_granularity() -> None:
@@ -59,6 +81,7 @@ def test_resolve_granularity_auto(calc_coverage_dir: Path) -> None:
 
     assert resolve_granularity("llvm-cov", "auto") == "branch"
     assert resolve_granularity("afl-showmap", "auto") == "edge"
+    assert resolve_granularity("libfuzzer-merge", "auto") == "edge"
     assert resolve_granularity("llvm-cov", "block") == "block"
     with pytest.raises(ValueError, match="does not support --granularity edge"):
         resolve_granularity("llvm-cov", "edge")