shrinkray 25.12.27.3__tar.gz → 25.12.29.0__tar.gz

{shrinkray-25.12.27.3/src/shrinkray.egg-info → shrinkray-25.12.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shrinkray
-Version: 25.12.27.3
+Version: 25.12.29.0
 Summary: Shrink Ray
 Author-email: "David R. MacIver" <david@drmaciver.com>
 License: MIT
@@ -16,6 +16,7 @@ Requires-Dist: click>=8.0.1
 Requires-Dist: chardet>=5.2.0
 Requires-Dist: trio>=0.28.0
 Requires-Dist: textual>=0.47.0
+Requires-Dist: textual-plotext>=0.2.0
 Requires-Dist: humanize>=4.9.0
 Requires-Dist: libcst>=1.1.0
 Requires-Dist: exceptiongroup>=1.2.0
@@ -28,6 +29,8 @@ Requires-Dist: hypothesmith>=0.3.1; extra == "dev"
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-trio>=0.8.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.5.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
 Requires-Dist: syrupy>=5.0.0; extra == "dev"
 Requires-Dist: jinja2>=3.0.0; extra == "dev"
 Requires-Dist: coverage[toml]>=7.4.0; extra == "dev"
@@ -78,7 +81,12 @@ shrinkray (or any other test-case reducer) then systematically tries smaller and
 
 While it runs, you will see the following user interface:
 
-![Demo of shrink ray running](demo.png)
+<video controls poster="gallery/enterprise-hello/hello.png">
+  <source src="https://drmaciver.github.io/shrinkray/assets/hello.mp4" type="video/mp4">
+  Your browser doesn't support video. <a href="gallery/enterprise-hello/hello.gif">View the GIF instead</a>.
+</video>
+
+(This is a toy example based on reducing a ridiculously bad version of hello world)
 
 When it finishes you will be left with the reduced test case in `mytestcase.py`.
 

{shrinkray-25.12.27.3 → shrinkray-25.12.29.0}/README.md

@@ -38,7 +38,12 @@ shrinkray (or any other test-case reducer) then systematically tries smaller and
 
 While it runs, you will see the following user interface:
 
-![Demo of shrink ray running](demo.png)
+<video controls poster="gallery/enterprise-hello/hello.png">
+  <source src="https://drmaciver.github.io/shrinkray/assets/hello.mp4" type="video/mp4">
+  Your browser doesn't support video. <a href="gallery/enterprise-hello/hello.gif">View the GIF instead</a>.
+</video>
+
+(This is a toy example based on reducing a ridiculously bad version of hello world)
 
 When it finishes you will be left with the reduced test case in `mytestcase.py`.
 

{shrinkray-25.12.27.3 → shrinkray-25.12.29.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shrinkray"
-version = "25.12.27.3"
+version = "25.12.29.0"
 description = "Shrink Ray"
 authors = [
     {name = "David R. MacIver", email = "david@drmaciver.com"}
@@ -16,6 +16,7 @@ dependencies = [
     "chardet>=5.2.0",
     "trio>=0.28.0",
     "textual>=0.47.0",
+    "textual-plotext>=0.2.0",
     "humanize>=4.9.0",
     "libcst>=1.1.0",
     "exceptiongroup>=1.2.0",
@@ -41,6 +42,8 @@ dev = [
     "pytest>=8.0.0",
     "pytest-trio>=0.8.0",
     "pytest-asyncio>=0.21.0",
+    "pytest-xdist>=3.5.0",
+    "pytest-cov>=4.1.0",
     # pytest-textual-snapshot is vendored in tests/pytest_textual_snapshot.py
     # to fix syrupy 5.0 compatibility. These are its dependencies:
     "syrupy>=5.0.0",
@@ -67,7 +70,7 @@ core = "ctrace"
 
 [tool.coverage.report]
 show_missing = true
-fail_under = 100
+# fail_under is enforced in justfile to allow split parallel/serial runs
 
 [tool.ruff]
 line-length = 88

{shrinkray-25.12.27.3 → shrinkray-25.12.29.0}/src/shrinkray/passes/bytes.py

@@ -28,26 +28,6 @@ from shrinkray.passes.patching import Cuts, Patches, apply_patches
 from shrinkray.problem import Format, ReductionProblem
 
 
-@define(frozen=True)
-class Encoding(Format[bytes, str]):
-    """Format that decodes/encodes bytes using a character encoding."""
-
-    encoding: str
-
-    def __repr__(self) -> str:
-        return f"Encoding({repr(self.encoding)})"
-
-    @property
-    def name(self) -> str:
-        return self.encoding
-
-    def parse(self, input: bytes) -> str:
-        return input.decode(self.encoding)
-
-    def dumps(self, input: str) -> bytes:
-        return input.encode(self.encoding)
-
-
 @define(frozen=True)
 class Split(Format[bytes, list[bytes]]):
     """Format that splits bytes by a delimiter.
@@ -165,9 +145,6 @@ def tokenize(text: bytes) -> list[bytes]:
     return result
 
 
-MAX_DELETE_INTERVAL = 8
-
-
 async def lexeme_based_deletions(
     problem: ReductionProblem[bytes], min_size: int = 8
 ) -> None:
@@ -601,108 +578,6 @@ async def lower_individual_bytes(problem: ReductionProblem[bytes]) -> None:
     await apply_patches(problem, IndividualByteReplacement(), patches)
 
 
-RegionReplacementPatch = list[tuple[int, int, int]]
-
-
-class RegionReplacement(Patches[RegionReplacementPatch, bytes]):
-    @property
-    def empty(self) -> RegionReplacementPatch:
-        return []
-
-    def combine(self, *patches: RegionReplacementPatch) -> RegionReplacementPatch:
-        result: RegionReplacementPatch = []
-        for p in patches:
-            result.extend(p)
-        return result
-
-    def apply(self, patch: RegionReplacementPatch, target: bytes) -> bytes:
-        result = bytearray(target)
-        for i, j, d in patch:
-            if d < result[i]:
-                for k in range(i, j):
-                    result[k] = d
-        return bytes(result)
-
-    def size(self, patch: RegionReplacementPatch) -> int:
-        return 0
-
-
-async def short_replacements(problem: ReductionProblem[bytes]) -> None:
-    """Replace short regions with uniform byte values.
-
-    Tries replacing 1-4 byte regions with uniform values like 0, 1,
-    space, newline, or period. Useful for simplifying small sequences.
-    """
-    target = problem.current_test_case
-    patches = [
-        [(i, j, c)]
-        for c in [0, 1] + list(b"01 \t\n\r.")
-        for i in range(len(target))
-        if target[i] > c
-        for j in range(i + 1, min(i + 5, len(target) + 1))
-    ]
-
-    await apply_patches(problem, RegionReplacement(), patches)
-
-
-WHITESPACE = b" \t\r\n"
-
-
-async def sort_whitespace(problem: ReductionProblem[bytes]) -> None:
-    """NB: This is a stupid pass that we only really need for artificial
-    test cases, but it's helpful for allowing those artificial test cases
-    to expose other issues."""
-
-    whitespace_up_to = 0
-    while (
-        whitespace_up_to < len(problem.current_test_case)
-        and problem.current_test_case[whitespace_up_to] not in WHITESPACE
-    ):
-        whitespace_up_to += 1
-    while (
-        whitespace_up_to < len(problem.current_test_case)
-        and problem.current_test_case[whitespace_up_to] in WHITESPACE
-    ):
-        whitespace_up_to += 1
-
-    # If the initial whitespace ends with a newline we want to keep it doing
-    # that. This is mostly for Python purposes.
-    if (
-        whitespace_up_to > 0
-        and problem.current_test_case[whitespace_up_to - 1] == b"\n"[0]
-    ):
-        whitespace_up_to -= 1
-
-    i = whitespace_up_to + 1
-
-    while i < len(problem.current_test_case):
-        if problem.current_test_case[i] not in WHITESPACE:
-            i += 1
-            continue
-
-        async def can_move_to_whitespace(k: int) -> bool:
-            if i + k > len(problem.current_test_case):
-                return False
-
-            base = problem.current_test_case
-            target = base[i : i + k]
-
-            if any(c not in WHITESPACE for c in target):
-                return False
-
-            prefix = base[:whitespace_up_to]
-            attempt = prefix + target + base[whitespace_up_to:i] + base[i + k :]
-            return await problem.is_interesting(attempt)
-
-        k = await problem.work.find_large_integer(can_move_to_whitespace)
-        whitespace_up_to += k
-        i += k + 1
-    test_case = problem.current_test_case
-    await problem.is_interesting(
-        bytes(sorted(test_case[:whitespace_up_to])) + test_case[whitespace_up_to:]
-    )
-
-
 # These are some cheat substitutions that are sometimes helpful, but mostly
 # for passing stupid tests.
 STANDARD_SUBSTITUTIONS = [(b"\0\0", b"\1"), (b"\0\0", b"\xff")]

{shrinkray-25.12.27.3 → shrinkray-25.12.29.0}/src/shrinkray/passes/clangdelta.py

@@ -1,6 +1,5 @@
 import os
 import subprocess
-from functools import lru_cache
 from glob import glob
 from shutil import which
 from tempfile import NamedTemporaryFile
@@ -26,29 +25,6 @@ def find_clang_delta():
     return clang_delta
 
 
-@lru_cache(maxsize=1)
-def clang_delta_works() -> bool:
-    """Check if clang_delta can actually execute.
-
-    This verifies not just that the binary exists, but that it can run.
-    On some systems (e.g., Ubuntu 24.04), creduce is installed but
-    clang_delta fails at runtime due to shared library issues.
-    """
-    clang_delta = find_clang_delta()
-    if not clang_delta:
-        return False
-    try:
-        # Run a simple test to verify clang_delta works
-        result = subprocess.run(
-            [clang_delta, "--help"],
-            capture_output=True,
-            timeout=5,
-        )
-        return result.returncode == 0
-    except (OSError, subprocess.TimeoutExpired):
-        return False
-
-
 TRANSFORMATIONS: list[str] = [
     "aggregate-to-scalar",
     "binop-simplification",

{shrinkray-25.12.27.3 → shrinkray-25.12.29.0}/src/shrinkray/passes/genericlanguages.py

@@ -9,7 +9,6 @@ from string import ascii_lowercase, ascii_uppercase
 from typing import AnyStr
 
 import trio
-from attr import define
 
 from shrinkray.passes.bytes import ByteReplacement, delete_intervals
 from shrinkray.passes.definitions import ReductionPass
@@ -24,25 +23,6 @@ from shrinkray.problem import (
 from shrinkray.work import NotFound
 
 
-@define(frozen=True)
-class Substring(Format[AnyStr, AnyStr]):
-    prefix: AnyStr
-    suffix: AnyStr
-
-    @property
-    def name(self) -> str:
-        return f"Substring({len(self.prefix)}, {len(self.suffix)})"
-
-    def parse(self, input: AnyStr) -> AnyStr:
-        if input.startswith(self.prefix) and input.endswith(self.suffix):
-            return input[len(self.prefix) : len(input) - len(self.suffix)]
-        else:
-            raise ParseError()
-
-    def dumps(self, input: AnyStr) -> AnyStr:
-        return self.prefix + input + self.suffix
-
-
 class RegionReplacingPatches(Patches[dict[int, AnyStr], AnyStr]):
     def __init__(self, regions: list[tuple[int, int]]):
         assert regions

{shrinkray-25.12.27.3 → shrinkray-25.12.29.0}/src/shrinkray/passes/json.py

@@ -9,14 +9,6 @@ from shrinkray.passes.patching import Patches, apply_patches
 from shrinkray.problem import Format, ParseError, ReductionProblem
 
 
-def is_json(s: bytes) -> bool:
-    try:
-        json.loads(s)
-        return True
-    except ValueError:
-        return False
-
-
 @define(frozen=True)
 class _JSON(Format[bytes, Any]):
     def __repr__(self) -> str:

{shrinkray-25.12.27.3 → shrinkray-25.12.29.0}/src/shrinkray/passes/patching.py

@@ -1,7 +1,5 @@
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Iterable, Sequence
-from enum import Enum
-from random import Random
 from typing import Any, TypeVar, cast
 
 import trio
@@ -52,27 +50,6 @@ class SetPatches[T, TargetType](Patches[frozenset[T], TargetType]):
         return len(patch)
 
 
-class ListPatches[T, TargetType](Patches[list[T], TargetType]):
-    def __init__(self, apply: Callable[[list[T], TargetType], TargetType]):
-        self.__apply = apply
-
-    @property
-    def empty(self):
-        return []
-
-    def combine(self, *patches: list[T]) -> list[T]:
-        result = []
-        for p in patches:
-            result.extend(p)
-        return result
-
-    def apply(self, patch: list[T], target: TargetType) -> TargetType:
-        return self.__apply(patch, target)
-
-    def size(self, patch: list[T]) -> int:
-        return len(patch)
-
-
 class PatchApplier[PatchType, TargetType]:
     def __init__(
         self,
@@ -174,15 +151,6 @@ class PatchApplier[PatchType, TargetType]:
             return await receive_merge_result.receive()
 
 
-class Direction(Enum):
-    LEFT = 0
-    RIGHT = 1
-
-
-class Completed(Exception):
-    pass
-
-
 async def apply_patches[PatchType, TargetType](
     problem: ReductionProblem[TargetType],
     patch_info: Patches[PatchType, TargetType],
@@ -220,37 +188,6 @@ async def apply_patches[PatchType, TargetType](
                     await applier.try_apply_patch(patch)
 
 
-class LazyMutableRange:
-    def __init__(self, n: int):
-        self.__size = n
-        self.__mask: dict[int, int] = {}
-
-    def __getitem__(self, i: int) -> int:
-        return self.__mask.get(i, i)
-
-    def __setitem__(self, i: int, v: int) -> None:
-        self.__mask[i] = v
-
-    def __len__(self) -> int:
-        return self.__size
-
-    def pop(self) -> int:
-        i = len(self) - 1
-        result = self[i]
-        self.__size = i
-        self.__mask.pop(i, None)
-        return result
-
-
-def lazy_shuffle[T](seq: Sequence[T], rnd: Random) -> Iterable[T]:
-    indices = LazyMutableRange(len(seq))
-    while indices:
-        j = len(indices) - 1
-        i = rnd.randrange(0, len(indices))
-        indices[i], indices[j] = indices[j], indices[i]
-        yield seq[indices.pop()]
-
-
 CutPatch = list[tuple[int, int]]
 
 

{shrinkray-25.12.27.3 → shrinkray-25.12.29.0}/src/shrinkray/passes/sequences.py

@@ -18,31 +18,6 @@ async def delete_elements[Seq: Sequence[Any]](problem: ReductionProblem[Seq]) ->
     )
 
 
-def merged_intervals(intervals: list[tuple[int, int]]) -> list[tuple[int, int]]:
-    normalized: list[list[int]] = []
-    for start, end in sorted(map(tuple, intervals)):
-        if normalized and normalized[-1][-1] >= start:
-            normalized[-1][-1] = max(normalized[-1][-1], end)
-        else:
-            normalized.append([start, end])
-    return list(map(tuple, normalized))  # type: ignore
-
-
-def with_deletions[Seq: Sequence[Any]](
-    target: Seq, deletions: list[tuple[int, int]]
-) -> Seq:
-    result: list[Any] = []
-    prev = 0
-    total_deleted = 0
-    for start, end in deletions:
-        total_deleted += end - start
-        result.extend(target[prev:start])
-        prev = end
-    result.extend(target[prev:])
-    assert len(result) + total_deleted == len(target)
-    return type(target)(result)  # type: ignore
-
-
 def block_deletion[Seq: Sequence[Any]](
     min_block: int, max_block: int
 ) -> ReductionPass[Seq]:

{shrinkray-25.12.27.3 → shrinkray-25.12.29.0}/src/shrinkray/reducer.py

@@ -99,50 +99,6 @@ class Reducer[T](ABC):
         """Skip the currently running pass. Override in subclasses for pass control."""
 
 
-@define
-class BasicReducer[T](Reducer[T]):
-    reduction_passes: Iterable[ReductionPass[T]]
-    pumps: Iterable[ReductionPump[T]] = ()
-    _status: str = "Starting up"
-
-    def __attrs_post_init__(self) -> None:
-        self.reduction_passes = list(self.reduction_passes)
-
-    @property
-    def status(self) -> str:
-        return self._status
-
-    @status.setter
-    def status(self, value: str) -> None:
-        self._status = value
-
-    async def run_pass(self, rp: ReductionPass[T]) -> None:
-        await rp(self.target)
-
-    async def run(self) -> None:
-        await self.target.setup()
-
-        while True:
-            prev = self.target.current_test_case
-            for rp in self.reduction_passes:
-                self.status = f"Running reduction pass {rp.__name__}"
-                await self.run_pass(rp)
-            for pump in self.pumps:
-                self.status = f"Pumping with {pump.__name__}"
-                pumped = await pump(self.target)
-                if pumped != self.target.current_test_case:
-                    with self.backtrack(pumped):
-                        for rp in self.reduction_passes:
-                            self.status = f"Running reduction pass {rp.__name__} under pump {pump.__name__}"
-                            await self.run_pass(rp)
-            if prev == self.target.current_test_case:
-                return
-
-
-class RestartPass(Exception):
-    pass
-
-
 @define
 class PassStats:
     """Statistics for a single reduction pass."""
@@ -181,12 +137,6 @@ class PassStatsTracker:
         return list(self._stats.values())
 
 
-class SkipPass(Exception):
-    """Raised to skip the current pass."""
-
-    pass
-
-
 @define
 class ShrinkRay(Reducer[bytes]):
     clang_delta: ClangDelta | None = None

{shrinkray-25.12.27.3 → shrinkray-25.12.29.0}/src/shrinkray/state.py

@@ -11,7 +11,7 @@ from abc import ABC, abstractmethod
 from collections import deque
 from datetime import timedelta
 from tempfile import TemporaryDirectory
-from typing import Any, TypeVar
+from typing import Any
 
 import humanize
 import trio
@@ -28,9 +28,6 @@ from shrinkray.reducer import DirectoryShrinkRay, Reducer, ShrinkRay
 from shrinkray.work import Volume, WorkContext
 
 
-T = TypeVar("T")
-
-
 class TimeoutExceededOnInitial(InvalidInitialExample):
     def __init__(self, runtime: float, timeout: float) -> None:
         self.runtime = runtime
@@ -60,7 +57,7 @@ def compute_dynamic_timeout(runtime: float) -> float:
 
 
 @define
-class TestOutputManager:
+class OutputCaptureManager:
     """Manages temporary files for test output capture.
 
     Allocates unique files for each test's stdout/stderr output,
@@ -77,7 +74,8 @@ class TestOutputManager:
 
     _sequence: int = 0
     _active_outputs: dict[int, str] = {}
-    _completed_outputs: deque[tuple[int, str, float]] = deque()
+    # Completed outputs: (test_id, file_path, completion_time, return_code)
+    _completed_outputs: deque[tuple[int, str, float, int]] = deque()
 
     def __attrs_post_init__(self) -> None:
         # Initialize mutable defaults
@@ -92,11 +90,13 @@ class TestOutputManager:
         self._active_outputs[test_id] = file_path
         return test_id, file_path
 
-    def mark_completed(self, test_id: int) -> None:
+    def mark_completed(self, test_id: int, return_code: int = 0) -> None:
         """Mark a test as completed and move to completed queue."""
         if test_id in self._active_outputs:
             file_path = self._active_outputs.pop(test_id)
-            self._completed_outputs.append((test_id, file_path, time.time()))
+            self._completed_outputs.append(
+                (test_id, file_path, time.time(), return_code)
+            )
             self._cleanup_old_files()
 
     def _cleanup_old_files(self) -> None:
@@ -107,65 +107,55 @@ class TestOutputManager:
             self._completed_outputs
             and now - self._completed_outputs[0][2] > self.max_age_seconds
         ):
-            _, file_path, _ = self._completed_outputs.popleft()
+            _, file_path, _, _ = self._completed_outputs.popleft()
             self._safe_delete(file_path)
         # Remove excess files beyond max_files
         while len(self._completed_outputs) > self.max_files:
-            _, file_path, _ = self._completed_outputs.popleft()
+            _, file_path, _, _ = self._completed_outputs.popleft()
             self._safe_delete(file_path)
 
-    def _should_show_completed(self) -> tuple[int, str] | None:
-        """Check if we should show a completed test's output.
-
-        Note: This method is only called when there are no active tests.
-        It returns the completed test info if within the display window
-        (min_display_seconds + grace_period).
-        """
-        if not self._completed_outputs:
-            return None
-        test_id, file_path, completion_time = self._completed_outputs[-1]
-        elapsed = time.time() - completion_time
-
-        # Show completed test during the full display window
-        if elapsed < self.min_display_seconds + self.grace_period_seconds:
-            return test_id, file_path
+    @staticmethod
+    def _file_has_content(path: str) -> bool:
+        """Check if a file exists and has non-zero size."""
+        try:
+            return os.path.getsize(path) > 0
+        except OSError:
+            return False
 
-        return None
+    def get_current_output(self) -> tuple[str | None, int | None, int | None]:
+        """Get the current output to display.
 
-    def get_current_output_path(self) -> str | None:
-        """Get the most relevant output file path.
+        Returns (file_path, test_id, return_code) where:
+        - file_path: path to the output file to display
+        - test_id: the test ID (for display in header)
+        - return_code: the return code (None if test is still running)
 
-        Active tests always take priority. If no active test, shows
-        recently completed test output for min_display_seconds, plus
-        an additional grace_period if no new test has started.
+        Active tests take priority only if they have produced output.
+        Otherwise, shows recently completed test output for min_display_seconds,
+        plus an additional grace_period if no new test has started.
         """
-        # Active tests always take priority
+        # Active tests take priority only if they have content
         if self._active_outputs:
             max_id = max(self._active_outputs.keys())
-            return self._active_outputs[max_id]
-        # Then check for recently completed test that should stay visible
-        recent = self._should_show_completed()
-        if recent is not None:
-            return recent[1]
-        # Fall back to most recent completed (even if past display window)
+            active_path = self._active_outputs[max_id]
+            if self._file_has_content(active_path):
+                # Active test with output - no return code yet
+                return active_path, max_id, None
+            # Active test has no output yet - fall through to show previous output
+
+        # Check for recently completed test that should stay visible,
+        # or fall back to most recent completed (even if past display window)
         if self._completed_outputs:
-            return self._completed_outputs[-1][1]
-        return None
-
-    def get_active_test_id(self) -> int | None:
-        """Get the currently running test ID, if any.
+            test_id, file_path, _, return_code = self._completed_outputs[-1]
+            return file_path, test_id, return_code
 
-        Returns the active test ID if one is running, None otherwise.
-        """
-        if self._active_outputs:
-            return max(self._active_outputs.keys())
-        return None
+        return None, None, None
 
     def cleanup_all(self) -> None:
         """Clean up all output files (called on shutdown)."""
         for file_path in self._active_outputs.values():
             self._safe_delete(file_path)
-        for _, file_path, _ in self._completed_outputs:
+        for _, file_path, _, _ in self._completed_outputs:
             self._safe_delete(file_path)
         self._active_outputs.clear()
         self._completed_outputs.clear()
@@ -212,7 +202,7 @@ class ShrinkRayState[TestCase](ABC):
     _last_debug_output: str = ""
 
     # Optional output manager for capturing test output (TUI mode)
-    output_manager: TestOutputManager | None = None
+    output_manager: OutputCaptureManager | None = None
 
     def __attrs_post_init__(self):
         self.is_interesting_limiter = trio.CapacityLimiter(max(self.parallelism, 1))
@@ -301,6 +291,7 @@ class ShrinkRayState[TestCase](ABC):
         # Determine output handling
         test_id: int | None = None
         output_file_handle = None
+        exit_code: int | None = None  # Track for output manager
 
         if self.output_manager is not None:
             # Capture output to a file for TUI display
@@ -369,6 +360,7 @@ class ShrinkRayState[TestCase](ABC):
 
                 result: int | None = sp.returncode
                 assert result is not None
+                exit_code = result
 
                 return result
         finally:
@@ -376,7 +368,7 @@ class ShrinkRayState[TestCase](ABC):
             if output_file_handle is not None:
                 output_file_handle.close()
             if test_id is not None and self.output_manager is not None:
-                self.output_manager.mark_completed(test_id)
+                self.output_manager.mark_completed(test_id, exit_code or 0)
 
     async def run_for_exit_code(self, test_case: TestCase, debug: bool = False) -> int:
         # Lazy import