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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: differential_coverage
-Version: 1.2.0
+Version: 1.3.0
 Summary: Compute differential coverage, a better way of comparing testing tools.
 Author-email: Valentin Huber <contact@valentinhuber.me>
 License-Expression: MIT
@@ -38,6 +38,7 @@ In principle, differential coverage measures how much of approach $a_2$'s covera
 
 - `relcov` does exactly this. It is an *asymetrical* measure between coverage of two approaches. If the approach relies on randomness (such as most fuzzers), it can aggregate over multiple trials of these.
 - `relscore` aggregates all this data to an order of all approaches. This measure, compared to simple coverage numbers, takes into account and values higher approaches that can cover code that no other approach covers. However, compared to `relcov`, this hides a lot of information in this aggregation.
+- `count` just reports absolute coverage counts (union of covered edges/blocks/branches across trials) per approach — useful as a baseline, but without the differential comparison.
 
 For more precise definitions, including formulas, look at [DEFINITIONS.md](./DEFINITIONS.md).
 
@@ -146,13 +147,14 @@ 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,libfuzzer-merge}] [--granularity {auto,branch,block,edge}] <campaign-dir>
+differential-coverage {relcov,relscore,count} [--input-format {auto,afl-showmap,llvm-cov,libfuzzer-merge}] [--granularity {auto,branch,block,edge}] <campaign-dir>
 ```
 
 Examples:
 
 ```bash
 differential-coverage relscore ./coverage_data
+differential-coverage count ./coverage_data
 differential-coverage --input-format llvm-cov relcov ./coverage_data
 differential-coverage --output csv relscore ./coverage_data
 ```
@@ -206,6 +208,10 @@ relscores: dict[str, float] = dc.relscores()
 for approach_name, relscore in relscores.items():
     print(f"relscore {approach_name}: {relscore}")
 
+counts: dict[str, int] = dc.coverage_counts()
+for approach_name, count in counts.items():
+    print(f"coverage {approach_name}: {count}")
+
 ```
 
 ### Hints

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

@@ -14,6 +14,7 @@ In principle, differential coverage measures how much of approach $a_2$'s covera
 
 - `relcov` does exactly this. It is an *asymetrical* measure between coverage of two approaches. If the approach relies on randomness (such as most fuzzers), it can aggregate over multiple trials of these.
 - `relscore` aggregates all this data to an order of all approaches. This measure, compared to simple coverage numbers, takes into account and values higher approaches that can cover code that no other approach covers. However, compared to `relcov`, this hides a lot of information in this aggregation.
+- `count` just reports absolute coverage counts (union of covered edges/blocks/branches across trials) per approach — useful as a baseline, but without the differential comparison.
 
 For more precise definitions, including formulas, look at [DEFINITIONS.md](./DEFINITIONS.md).
 
@@ -122,13 +123,14 @@ 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,libfuzzer-merge}] [--granularity {auto,branch,block,edge}] <campaign-dir>
+differential-coverage {relcov,relscore,count} [--input-format {auto,afl-showmap,llvm-cov,libfuzzer-merge}] [--granularity {auto,branch,block,edge}] <campaign-dir>
 ```
 
 Examples:
 
 ```bash
 differential-coverage relscore ./coverage_data
+differential-coverage count ./coverage_data
 differential-coverage --input-format llvm-cov relcov ./coverage_data
 differential-coverage --output csv relscore ./coverage_data
 ```
@@ -182,6 +184,10 @@ relscores: dict[str, float] = dc.relscores()
 for approach_name, relscore in relscores.items():
     print(f"relscore {approach_name}: {relscore}")
 
+counts: dict[str, int] = dc.coverage_counts()
+for approach_name, count in counts.items():
+    print(f"coverage {approach_name}: {count}")
+
 ```
 
 ### Hints

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "differential_coverage"
-version = "1.2.0"
+version = "1.3.0"
 description = "Compute differential coverage, a better way of comparing testing tools."
 readme = "README.md"
 license = "MIT"
@@ -38,5 +38,10 @@ where = ["src"]
 [tool.pytest.ini_options]
 pythonpath = ["src"]
 
+[tool.ruff.lint]
+ignore = [
+  "UP045", # Optional[X] -> X | None
+]
+
 [project.scripts]
 differential-coverage = "differential_coverage:main"

{differential_coverage-1.2.0 → differential_coverage-1.3.0}/src/differential_coverage/__init__.py

@@ -1,24 +1,23 @@
-#!/usr/bin/env python3
-from differential_coverage.cli import main
 from differential_coverage.api import DifferentialCoverage
 from differential_coverage.approach_data import ApproachData
+from differential_coverage.cli import main
 from differential_coverage.types import (
-    EdgeId,
     ApproachId,
+    CollectionReducer,
+    EdgeId,
     TrialId,
     ValueReducer,
-    CollectionReducer,
 )
 
 __all__ = [
-    "main",
-    "DifferentialCoverage",
     "ApproachData",
-    "EdgeId",
     "ApproachId",
+    "CollectionReducer",
+    "DifferentialCoverage",
+    "EdgeId",
     "TrialId",
     "ValueReducer",
-    "CollectionReducer",
+    "main",
 ]
 
 if __name__ == "__main__":

{differential_coverage-1.2.0 → differential_coverage-1.3.0}/src/differential_coverage/api.py

@@ -1,14 +1,15 @@
+import warnings
+from collections.abc import Collection, Mapping
 from functools import reduce
 from pathlib import Path
-from typing import Collection, Generic, Mapping
-import warnings
+from typing import Generic
 
-from differential_coverage.readers import GranularityArg, InputFormat
-from differential_coverage.fs import read_campaign_dir
 from differential_coverage.approach_data import ApproachData
+from differential_coverage.fs import read_campaign_dir
+from differential_coverage.readers import GranularityArg, InputFormat
 from differential_coverage.types import (
-    EdgeId,
     ApproachId,
+    EdgeId,
     TrialId,
 )
 
@@ -76,6 +77,13 @@ class DifferentialCoverage(Generic[ApproachId, TrialId, EdgeId]):
     def approaches(self) -> Mapping[ApproachId, ApproachData[TrialId, EdgeId]]:
         return self._approaches
 
+    def coverage_counts(self) -> dict[ApproachId, int]:
+        """Absolute coverage count per approach: size of the union of all trial edges."""
+        return {
+            approach_name: len(approach_data.edges_union)
+            for approach_name, approach_data in self._approaches.items()
+        }
+
     def relscores(self) -> dict[ApproachId, float]:
         all_edges = reduce(
             lambda x, y: x.union(y),

{differential_coverage-1.2.0 → differential_coverage-1.3.0}/src/differential_coverage/approach_data.py

@@ -1,5 +1,7 @@
+from collections.abc import Collection, Mapping
 from functools import reduce
-from typing import Collection, Generic, Mapping
+from typing import Generic
+
 from differential_coverage.types import CollectionReducer, EdgeId, TrialId, ValueReducer
 
 

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

@@ -1,13 +1,17 @@
 import argparse
 import re
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 from importlib import metadata
 from pathlib import Path
-from typing import Optional, Sequence
+from typing import Optional
 
 from differential_coverage.api import DifferentialCoverage
 from differential_coverage.fs import read_campaign_dir
-from differential_coverage.output import print_relcov_corpus_table, print_scores
+from differential_coverage.output import (
+    print_counts,
+    print_relcov_corpus_table,
+    print_scores,
+)
 
 # All subcommands expect this directory layout (one campaign dir, no moving files).
 CAMPAIGN_DIR_HELP = (
@@ -87,8 +91,22 @@ def cmd_relscore(args: argparse.Namespace) -> int:
     print_scores(
         scores,
         output=args.output,
-        colormap=getattr(args, "colormap", "viridis"),
-        latex_enable_color=getattr(args, "latex_enable_color", False),
+        colormap=args.colormap,
+        latex_enable_color=args.latex_enable_color,
+        digits=args.digits,
+    )
+    return 0
+
+
+def cmd_count(args: argparse.Namespace) -> int:
+    campaign = _load_campaign(args)
+    dc = DifferentialCoverage(campaign)
+    counts = dc.coverage_counts()
+    print_counts(
+        counts,
+        output=args.output,
+        colormap=args.colormap,
+        latex_enable_color=args.latex_enable_color,
     )
     return 0
 
@@ -97,11 +115,6 @@ def cmd_relcov_performance_over_approach(args: argparse.Namespace) -> int:
     campaign = _load_campaign(args)
 
     dc = DifferentialCoverage(campaign)
-    output = args.output
-    colormap = getattr(args, "colormap", "viridis")
-    latex_rotate_headers = getattr(args, "latex_rotate_headers", None)
-    latex_enable_color = getattr(args, "latex_enable_color", False)
-
     ref_approaches = list(dc.approaches.keys())
     table = {
         f: {ref: dc.approaches[f].relcov(dc.approaches[ref]) for ref in ref_approaches}
@@ -110,10 +123,11 @@ def cmd_relcov_performance_over_approach(args: argparse.Namespace) -> int:
     print_relcov_corpus_table(
         ref_approaches,
         table,
-        output=output,
-        colormap=colormap,
-        latex_rotate_headers=latex_rotate_headers,
-        latex_enable_color=latex_enable_color,
+        output=args.output,
+        colormap=args.colormap,
+        latex_rotate_headers=args.latex_rotate_headers,
+        latex_enable_color=args.latex_enable_color,
+        digits=args.digits,
     )
     return 0
 
@@ -192,6 +206,15 @@ def build_parser() -> argparse.ArgumentParser:
             'latex for LaTeX tabular (requires "latex" optional dependencies)'
         ),
     )
+    parser.add_argument(
+        "--digits",
+        type=int,
+        default=3,
+        metavar="N",
+        help=(
+            "Number of digits after the decimal point for numeric results (default: 3)."
+        ),
+    )
     parser.add_argument(
         "--latex-rotate-headers",
         type=float,
@@ -246,6 +269,16 @@ def build_parser() -> argparse.ArgumentParser:
     p_relscore.add_argument("dir", type=Path, help=CAMPAIGN_DIR_HELP)
     p_relscore.set_defaults(func=cmd_relscore)
 
+    p_count = subparsers.add_parser(
+        "count",
+        help=(
+            "Print absolute coverage counts (union of covered edges/blocks/branches "
+            "across trials) for each approach. Does not compute differential coverage."
+        ),
+    )
+    p_count.add_argument("dir", type=Path, help=CAMPAIGN_DIR_HELP)
+    p_count.set_defaults(func=cmd_count)
+
     return parser
 
 

{differential_coverage-1.2.0 → differential_coverage-1.3.0}/src/differential_coverage/output.py

@@ -6,7 +6,6 @@ import csv
 from collections.abc import Callable, Mapping, Sequence
 from typing import Literal, Optional
 
-
 from differential_coverage.types import ApproachId
 
 OutputFormat = Literal["stdout", "csv", "latex"]
@@ -23,58 +22,95 @@ class _PrinterIO:
         # and avoid printing empty chunks.
         if not s:
             return 0
-        if s.endswith("\n"):
-            s = s[:-1]
+        s = s.removesuffix("\n")
         if s:
             self._printer(s)
         return len(s)
 
 
+# Default decimal places for numeric output.
+_DEFAULT_DIGITS = 3
+
+
+def _format_float(value: float, digits: int) -> str:
+    """Format a float with a fixed number of digits after the decimal point."""
+    return f"{value:.{digits}f}"
+
+
 def print_scores(
     scores: Mapping[ApproachId, float],
     *,
     output: OutputFormat = "stdout",
     colormap: str = "viridis",
     latex_enable_color: bool = False,
+    digits: int = _DEFAULT_DIGITS,
+    value_label: str = "score",
     printer: Callable[[str], None] = print,
 ) -> None:
-    """Print one score per approach, in the requested output format."""
+    """Print one numeric value per approach, in the requested output format."""
     name_sorted = sorted(scores.items(), key=lambda x: x[0])
     performance_sorted = sorted(name_sorted, key=lambda x: x[1], reverse=True)
 
     if output == "stdout":
-        _print_scores_plain(performance_sorted, printer=printer)
+        _print_scores_plain(performance_sorted, digits=digits, printer=printer)
     elif output == "csv":
-        _print_scores_csv(performance_sorted, printer=printer)
+        _print_scores_csv(
+            performance_sorted, digits=digits, value_label=value_label, printer=printer
+        )
     elif output == "latex":
         _print_scores_latex(
             performance_sorted,
             enable_color=latex_enable_color,
             colormap=colormap,
+            digits=digits,
+            value_label=value_label,
             printer=printer,
         )
     else:
         raise ValueError(f"Invalid output format: {output}")
 
 
+def print_counts(
+    counts: Mapping[ApproachId, int],
+    *,
+    output: OutputFormat = "stdout",
+    colormap: str = "viridis",
+    latex_enable_color: bool = False,
+    printer: Callable[[str], None] = print,
+) -> None:
+    """Print one absolute coverage count per approach, in the requested output format."""
+    print_scores(
+        {name: float(count) for name, count in counts.items()},
+        output=output,
+        colormap=colormap,
+        latex_enable_color=latex_enable_color,
+        digits=0,
+        value_label="coverage",
+        printer=printer,
+    )
+
+
 def _print_scores_plain(
     performance_sorted: Sequence[tuple[ApproachId, float]],
     *,
+    digits: int,
     printer: Callable[[str], None],
 ) -> None:
     for approach, score in performance_sorted:
-        printer(f"{approach}: {score:.2f}")
+        printer(f"{approach}: {_format_float(score, digits)}")
 
 
 def _print_scores_csv(
     performance_sorted: Sequence[tuple[ApproachId, float]],
     *,
+    digits: int,
+    value_label: str,
     printer: Callable[[str], None],
 ) -> None:
     writer = csv.writer(_PrinterIO(printer))
-    writer.writerow(("approach", "score"))
+    writer.writerow(("approach", value_label))
     for approach, score in performance_sorted:
-        writer.writerow((approach, f"{score:.2f}"))
+        writer.writerow((approach, _format_float(score, digits)))
 
 
 def _norm_minmax(values: Sequence[float]) -> tuple[float, float]:
@@ -96,11 +132,13 @@ def _print_scores_latex(
     *,
     enable_color: bool = False,
     colormap: str = "viridis",
+    digits: int,
+    value_label: str,
     printer: Callable[[str], None],
 ) -> None:
-    """LaTeX table (optionally with score cells colored by value)."""
+    """LaTeX table (optionally with value cells colored by value)."""
     printer(r"\begin{tabular}{lr}")
-    printer(r"approach & score \\")
+    printer(rf"approach & {value_label} \\")
     if not performance_sorted:
         printer(r"\end{tabular}")
         return
@@ -110,12 +148,13 @@ def _print_scores_latex(
         values = [s for _, s in performance_sorted]
         min_v, max_v = _norm_minmax(values)
     for approach, score in performance_sorted:
+        formatted = _format_float(score, digits)
         if enable_color:
             n = _norm_value(score, min_v, max_v)
             hex_color = _colormap_light_hex(n, colormap=colormap)
-            printer(rf"{approach} & \cellcolor[HTML]{{{hex_color}}}{{{score:.2f}}} \\")
+            printer(rf"{approach} & \cellcolor[HTML]{{{hex_color}}}{{{formatted}}} \\")
         else:
-            printer(f"{approach} & {score:.2f} \\\\")
+            printer(f"{approach} & {formatted} \\\\")
     printer(r"\end{tabular}")
 
 
@@ -127,6 +166,7 @@ def print_relcov_corpus_table(
     colormap: str = "viridis",
     latex_rotate_headers: Optional[float] = None,
     latex_enable_color: bool = False,
+    digits: int = _DEFAULT_DIGITS,
     printer: Callable[[str], None] = print,
 ) -> None:
     """Print a table of relcov performance: rows = approaches, columns = corpus approaches."""
@@ -138,12 +178,14 @@ def print_relcov_corpus_table(
         _print_relcov_corpus_table_plain(
             corpus_approaches,
             table,
+            digits=digits,
             printer=printer,
         )
     elif output == "csv":
         _print_relcov_corpus_table_csv(
             corpus_approaches,
             table,
+            digits=digits,
             printer=printer,
         )
     elif output == "latex":
@@ -153,6 +195,7 @@ def print_relcov_corpus_table(
             rotate_headers=latex_rotate_headers,
             enable_color=latex_enable_color,
             colormap=colormap,
+            digits=digits,
             printer=printer,
         )
     else:
@@ -163,6 +206,7 @@ def _print_relcov_corpus_table_plain(
     corpus_approaches: Sequence[ApproachId],
     table: Mapping[ApproachId, Mapping[ApproachId, float]],
     *,
+    digits: int,
     printer: Callable[[str], None],
 ) -> None:
     row_labels = sorted(table.keys())
@@ -171,7 +215,8 @@ def _print_relcov_corpus_table_plain(
         (len(str(c)) for c in col_labels + ["approach"]),
         default=7,
     )
-    num_width = 10  # e.g. " 1.00"
+    # Width for aligned numeric columns: sign + integer digit + '.' + fraction + padding.
+    num_width = max(10, digits + 4)
     header = "approach".ljust(col_width)
     for c in col_labels:
         header += str(c).rjust(num_width)
@@ -181,7 +226,7 @@ def _print_relcov_corpus_table_plain(
         for c in col_labels:
             val = table[row].get(c)
             if val is not None:
-                line += f"{val:>{num_width}.5f}"
+                line += f"{val:>{num_width}.{digits}f}"
             else:
                 line += " " * num_width
         printer(line)
@@ -191,6 +236,7 @@ def _print_relcov_corpus_table_csv(
     corpus_approaches: Sequence[ApproachId],
     table: Mapping[ApproachId, Mapping[ApproachId, float]],
     *,
+    digits: int,
     printer: Callable[[str], None],
 ) -> None:
     row_labels = sorted(table.keys())
@@ -201,7 +247,7 @@ def _print_relcov_corpus_table_csv(
         cells: list[str] = [str(row)]
         for c in col_labels:
             val = table[row].get(c)
-            cells.append(f"{val:.3f}" if val is not None else "")
+            cells.append(_format_float(val, digits) if val is not None else "")
         writer.writerow(cells)
 
 
@@ -255,10 +301,13 @@ def _print_relcov_corpus_table_latex(
     rotate_headers: Optional[float] = None,
     enable_color: bool = False,
     colormap: str = "viridis",
+    digits: int,
     printer: Callable[[str], None],
 ) -> None:
     try:
-        from pylatex.utils import escape_latex  # type: ignore[import-untyped] # does not provide types
+        from pylatex.utils import (  # type: ignore[import-untyped] # does not provide types
+            escape_latex,
+        )
     except ImportError:
         raise ImportError('latex support requires the "latex" optional dependencies')
 
@@ -288,9 +337,11 @@ def _print_relcov_corpus_table_latex(
             elif enable_color:
                 n = _norm_value(val, min_v, max_v)
                 hex_color = _colormap_light_hex(n, colormap=colormap)
-                cells.append(rf"\cellcolor[HTML]{{{hex_color}}}{{{val:.3f}}}")
+                cells.append(
+                    rf"\cellcolor[HTML]{{{hex_color}}}{{{_format_float(val, digits)}}}"
+                )
             else:
-                cells.append(f"{val:.3f}")
+                cells.append(_format_float(val, digits))
         printer("\t" + " & ".join(cells) + r" \\")
     printer(r"\end{tabular}")
 
@@ -311,7 +362,7 @@ def _colormap_light_hex(t: float, *, colormap: str = "viridis") -> str:
     if colormap not in colormaps:
         raise ValueError(f"Invalid colormap: {colormap}")
     cmap = colormaps[colormap]
-    [r, g, b, a] = cmap(t)
+    [r, g, b, _a] = cmap(t)
     [r, g, b] = [1 - ((1 - e) * 0.3) for e in [r, g, b]]
 
     return mcolors.to_hex((r, g, b), keep_alpha=False)[1:].upper()

{differential_coverage-1.2.0 → differential_coverage-1.3.0}/src/differential_coverage/readers/libfuzzer_merge.py

@@ -32,9 +32,7 @@ def detect(path: Path) -> bool:
         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
-    )
+    has_marker = any(line.startswith(("STARTED ", "COV ")) for line in lines)
     return has_marker
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: differential_coverage
-Version: 1.2.0
+Version: 1.3.0
 Summary: Compute differential coverage, a better way of comparing testing tools.
 Author-email: Valentin Huber <contact@valentinhuber.me>
 License-Expression: MIT
@@ -38,6 +38,7 @@ In principle, differential coverage measures how much of approach $a_2$'s covera
 
 - `relcov` does exactly this. It is an *asymetrical* measure between coverage of two approaches. If the approach relies on randomness (such as most fuzzers), it can aggregate over multiple trials of these.
 - `relscore` aggregates all this data to an order of all approaches. This measure, compared to simple coverage numbers, takes into account and values higher approaches that can cover code that no other approach covers. However, compared to `relcov`, this hides a lot of information in this aggregation.
+- `count` just reports absolute coverage counts (union of covered edges/blocks/branches across trials) per approach — useful as a baseline, but without the differential comparison.
 
 For more precise definitions, including formulas, look at [DEFINITIONS.md](./DEFINITIONS.md).
 
@@ -146,13 +147,14 @@ 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,libfuzzer-merge}] [--granularity {auto,branch,block,edge}] <campaign-dir>
+differential-coverage {relcov,relscore,count} [--input-format {auto,afl-showmap,llvm-cov,libfuzzer-merge}] [--granularity {auto,branch,block,edge}] <campaign-dir>
 ```
 
 Examples:
 
 ```bash
 differential-coverage relscore ./coverage_data
+differential-coverage count ./coverage_data
 differential-coverage --input-format llvm-cov relcov ./coverage_data
 differential-coverage --output csv relscore ./coverage_data
 ```
@@ -206,6 +208,10 @@ relscores: dict[str, float] = dc.relscores()
 for approach_name, relscore in relscores.items():
     print(f"relscore {approach_name}: {relscore}")
 
+counts: dict[str, int] = dc.coverage_counts()
+for approach_name, count in counts.items():
+    print(f"coverage {approach_name}: {count}")
+
 ```
 
 ### Hints

{differential_coverage-1.2.0 → differential_coverage-1.3.0}/tests/test_api.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+
 import pytest
 
 from differential_coverage.api import DifferentialCoverage
@@ -68,3 +69,13 @@ def test_relscores_multiple_approaches() -> None:
             "approach_c": 0.5,  # 3 is not hit by approach_a, but only hit in half of the trials
         }
     )
+
+
+def test_coverage_counts() -> None:
+    dc = DifferentialCoverage(SAMPLE_CAMPAIGN_CONTENT)
+    assert dc.coverage_counts() == {
+        "approach_a": 3,  # union of {1,2} and {1,3}
+        "approach_b": 2,  # union of {1,3}, {1,3}, {1}
+        "approach_c": 3,  # union of {1,2,3} and {1,2,3}
+        "seeds": 1,  # {1}
+    }

{differential_coverage-1.2.0 → differential_coverage-1.3.0}/tests/test_approach_data.py

@@ -1,9 +1,11 @@
 from copy import deepcopy
 from typing import Any
+
+import pytest
+from test_api import SAMPLE_CAMPAIGN_CONTENT
+
 from differential_coverage.approach_data import ApproachData
 from differential_coverage.types import CollectionReducer, ValueReducer
-from test_api import SAMPLE_CAMPAIGN_CONTENT
-import pytest
 
 
 def test_constructor() -> None:
@@ -52,7 +54,7 @@ def test_edges_by_trial(trials: dict[str, set[int]]) -> None:
 
 def test_eq() -> None:
     approach_data = ApproachData({"t1": {1, 2}})
-    assert approach_data == approach_data  # eq to self
+    assert approach_data == approach_data  # eq to self # noqa: PLR0124
     assert approach_data == deepcopy(approach_data)  # eq to deepcopy
     assert approach_data == ApproachData({"t1": {1, 2}})  # eq to same data
     assert approach_data != ApproachData({"t1": {1, 2, 3}})  # different data
@@ -162,7 +164,7 @@ def test_relcov_value_reducer() -> None:
         else:
             return original_getattr(self, name)
 
-    setattr(ValueReducer, "__getattribute__", spy_getattr)
+    setattr(ValueReducer, "__getattribute__", spy_getattr)  # noqa: B010
 
     res = lhs.relcov(rhs, value_reducer=ValueReducer.MEDIAN)
     assert res == 0.5  # default median from superclass
@@ -189,7 +191,7 @@ def test_relcov_collection_reducer() -> None:
         else:
             return original_getattr(self, name)
 
-    setattr(CollectionReducer, "__getattribute__", spy_getattr)
+    setattr(CollectionReducer, "__getattribute__", spy_getattr)  # noqa: B010
 
     res = lhs.relcov(rhs, collection_reducer=CollectionReducer.UNION)
     assert res == 0.5  # default: union of rhs, so half is reached

{differential_coverage-1.2.0 → differential_coverage-1.3.0}/tests/test_cli.py

@@ -3,6 +3,7 @@
 import io
 import sys
 from pathlib import Path
+
 import pytest
 
 from differential_coverage.cli import main
@@ -275,3 +276,58 @@ def test_cli_latex_color_no_cell_colors() -> None:
     assert any(line.startswith(r"\begin{tabular}") for line in lines)
     # Table should not contain any colored cells
     assert not any(r"\cellcolor" in line for line in lines)
+
+
+def test_cli_digits_relscore() -> None:
+    """CLI --digits controls decimal places in relscore output."""
+    code, out, _ = _run_cli(["--digits", "4", "relscore", str(SAMPLE_SHOWMAP_DIR)])
+    assert code == 0
+    lines = [s.strip() for s in out.strip().splitlines()]
+    # Each score should have exactly 4 digits after the decimal point
+    for line in lines:
+        score = line.split(":", 1)[1].strip()
+        assert "." in score
+        assert len(score.split(".", 1)[1]) == 4
+
+
+def test_cli_count() -> None:
+    """CLI count prints absolute coverage counts sorted descending."""
+    code, out, _ = _run_cli(["count", str(SAMPLE_SHOWMAP_DIR)])
+    assert code == 0
+    lines = [s.strip() for s in out.strip().splitlines()]
+    assert len(lines) == 4
+    # Sample: approach_a=3, approach_c=3, approach_b=2, seeds=1
+    counts = {}
+    for line in lines:
+        name, count = line.split(":", 1)
+        counts[name.strip()] = int(count.strip())
+    assert counts == {
+        "approach_a": 3,
+        "approach_b": 2,
+        "approach_c": 3,
+        "seeds": 1,
+    }
+    # Sorted by count descending; ties broken by name ascending
+    assert lines[0].startswith("approach_a:") or lines[0].startswith("approach_c:")
+    assert lines[-1].startswith("seeds:")
+
+
+def test_cli_csv_count() -> None:
+    """CLI --output csv with count outputs CSV with header approach,coverage."""
+    code, out, _ = _run_cli(["--output", "csv", "count", str(SAMPLE_SHOWMAP_DIR)])
+    assert code == 0
+    lines = out.strip().splitlines()
+    assert lines[0] == "approach,coverage"
+    assert len(lines) == 5  # header + 4 approaches
+    assert any(line.startswith("approach_a,3") for line in lines[1:])
+    assert any(line.startswith("seeds,1") for line in lines[1:])
+
+
+def test_cli_latex_count() -> None:
+    """CLI --output latex with count outputs LaTeX tabular."""
+    code, out, _ = _run_cli(["--output", "latex", "count", str(SAMPLE_SHOWMAP_DIR)])
+    assert code == 0
+    lines = out.strip().splitlines()
+    assert any(line.startswith(r"\begin{tabular}") for line in lines)
+    assert any("coverage" in line for line in lines)
+    assert lines[-1] == r"\end{tabular}"

{differential_coverage-1.2.0 → differential_coverage-1.3.0}/tests/test_docs.py

@@ -4,9 +4,9 @@ from typing import Any
 
 def test_docs() -> None:
     from differential_coverage import (
-        DifferentialCoverage,
         ApproachData,
         CollectionReducer,
+        DifferentialCoverage,
         ValueReducer,
     )
 
@@ -44,3 +44,7 @@ def test_docs() -> None:
     relscores: dict[str, float] = dc.relscores()
     for approach_name, relscore in relscores.items():
         print(f"relscore {approach_name}: {relscore}")
+
+    counts: dict[str, int] = dc.coverage_counts()
+    for approach_name, count in counts.items():
+        print(f"coverage {approach_name}: {count}")

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

@@ -95,7 +95,7 @@ def test_read_llvm_cov_block_reads_calc_export(calc_coverage_dir: Path) -> None:
     export = _calc_export(calc_coverage_dir, "approach_a", "t1.json")
     edges = llvm_cov.read(export, granularity="block")
     assert edges
-    assert not any(edge.endswith(":true") or edge.endswith(":false") for edge in edges)
+    assert not any(edge.endswith((":true", ":false")) for edge in edges)
 
 
 def test_read_llvm_cov_expansion_branches(llvm_exports: dict[str, Path]) -> None:

{differential_coverage-1.2.0 → differential_coverage-1.3.0}/tests/test_output.py

@@ -2,9 +2,13 @@
 
 import csv
 import io
-from typing import Callable
+from collections.abc import Callable
 
-from differential_coverage.output import print_relcov_corpus_table, print_scores
+from differential_coverage.output import (
+    print_counts,
+    print_relcov_corpus_table,
+    print_scores,
+)
 
 # Deliberately unsorted order for both corpus (columns) and table (rows)
 _UNSORTED_CORPUS = ["z_approach", "a_approach", "m_approach"]
@@ -75,8 +79,8 @@ def test_print_scores_uses_printer_stdout() -> None:
 
     # Scores should be sorted by value descending, then by name
     joined = "\n".join(captured)
-    assert "a: 1.00" in joined
-    assert "b: 0.10" in joined
+    assert "a: 1.000" in joined
+    assert "b: 0.100" in joined
     # Ensure our custom printer was used (no direct writes to sys.stdout here)
     assert joined.count("\n") >= 0
 
@@ -97,3 +101,56 @@ def test_print_scores_uses_printer_csv() -> None:
     # Order should be by score descending
     assert rows[1][0] == "a"
     assert rows[2][0] == "b"
+
+
+def test_print_scores_respects_digits() -> None:
+    """print_scores formats scores with the requested number of digits."""
+    scores = {"a": 1.0 / 3.0}
+    captured, printer = _capture_printer()
+
+    print_scores(scores, output="stdout", digits=4, printer=printer)
+
+    assert captured == ["a: 0.3333"]
+
+
+def test_print_counts_uses_printer_stdout() -> None:
+    """print_counts writes integer coverage counts via the provided printer."""
+    counts = {"b": 2, "a": 5}
+    captured, printer = _capture_printer()
+
+    print_counts(counts, output="stdout", printer=printer)
+
+    assert captured == ["a: 5", "b: 2"]
+
+
+def test_print_counts_uses_printer_csv() -> None:
+    """print_counts CSV output is routed through the provided printer."""
+    counts = {"b": 2, "a": 5}
+    captured, printer = _capture_printer()
+
+    print_counts(counts, output="csv", printer=printer)
+
+    csv_text = "\n".join(captured)
+    reader = csv.reader(io.StringIO(csv_text))
+    rows = list(reader)
+
+    assert rows[0] == ["approach", "coverage"]
+    assert rows[1] == ["a", "5"]
+    assert rows[2] == ["b", "2"]
+
+
+def test_relcov_table_respects_digits_csv() -> None:
+    """Relcov CSV cells use the requested digit precision."""
+    captured, printer = _capture_printer()
+    print_relcov_corpus_table(
+        ["a"],
+        {"a": {"a": 1.0 / 3.0}},
+        output="csv",
+        digits=4,
+        printer=printer,
+    )
+
+    csv_text = "\n".join(captured)
+    reader = csv.reader(io.StringIO(csv_text))
+    rows = list(reader)
+    assert rows[1][1] == "0.3333"

{differential_coverage-1.2.0 → differential_coverage-1.3.0}/tests/test_reducers.py

@@ -1,6 +1,7 @@
+import pytest
+
 from differential_coverage.approach_data import ApproachData
 from differential_coverage.types import CollectionReducer, ValueReducer
-import pytest
 
 
 @pytest.mark.parametrize(

{differential_coverage-1.2.0 → differential_coverage-1.3.0}/src/differential_coverage/types.py

@@ -1,7 +1,7 @@
 from collections.abc import Callable, Iterable
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Protocol, TypeVar
 from statistics import mean, median
+from typing import TYPE_CHECKING, Any, Protocol, TypeVar
 
 if TYPE_CHECKING:
     from differential_coverage.approach_data import ApproachData