pytest-threadpool 0.3.0__tar.gz → 0.3.3__tar.gz

{pytest_threadpool-0.3.0 → pytest_threadpool-0.3.3}/.github/workflows/ci.yml

@@ -5,12 +5,15 @@ on:
     branches: [main]
   pull_request:
     branches: [main]
+  workflow_call:
 
 jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
       - uses: astral-sh/setup-uv@v6
       - run: uv sync --python 3.14t --group dev
       - run: uv run ruff format --check src/ tests/
@@ -25,6 +28,8 @@ jobs:
         python: ["3.13t", "3.14t", "3.15t"]
     steps:
       - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
       - uses: astral-sh/setup-uv@v6
       - run: uv python install ${{ matrix.python }}
       - run: uv sync --python ${{ matrix.python }} --group dev

pytest_threadpool-0.3.3/.github/workflows/publish.yml

@@ -0,0 +1,25 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  ci:
+    uses: ./.github/workflows/ci.yml
+    secrets: inherit
+
+  publish:
+    needs: ci
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: astral-sh/setup-uv@v6
+      - run: uv build
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

{pytest_threadpool-0.3.0 → pytest_threadpool-0.3.3}/.gitignore

@@ -163,3 +163,6 @@ cython_debug/
 .idea/
 uv.lock
 
+# hatch-vcs generated version file
+src/pytest_threadpool/_version.py
+

{pytest_threadpool-0.3.0 → pytest_threadpool-0.3.3}/CONTRIBUTING.md

@@ -40,10 +40,13 @@ Any mutable state needed across tests or across a test run must be held as
 class attributes or instance attributes — never as module-level variables.
 
 ```python
+import threading
+
 # Good
 class TestState:
-    log = {}
-    barrier = threading.Barrier(3, timeout=10)
+  log = {}
+  barrier = threading.Barrier(3, timeout=10)
+
 
 # Bad
 _log = {}
@@ -67,9 +70,11 @@ subprocess with the exact thread count needed. Use explicit thread counts for
 barrier-based tests (not `auto`) to avoid deadlocks on low-core machines.
 
 ```python
+import threading
+
 # Good — isolated subprocess via ftdir, explicit thread count
 def test_children_run_concurrently(self, ftdir):
-    ftdir.makepyfile("""
+  ftdir.makepyfile("""
         import threading, pytest
         @pytest.mark.parallelizable("children")
         class TestBarrier:
@@ -77,16 +82,25 @@ def test_children_run_concurrently(self, ftdir):
             def test_a(self): self.barrier.wait()
             def test_b(self): self.barrier.wait()
     """)
-    result = ftdir.run_pytest("--threadpool", "2")
-    result.assert_outcomes(passed=2)
+  result = ftdir.run_pytest("--threadpool", "2")
+  result.assert_outcomes(passed=2)
+
 
 # Bad — depends on outer runner flags
 class TestBarrier:
-    barrier = threading.Barrier(2, timeout=10)
-    def test_a(self): self.barrier.wait()
-    def test_b(self): self.barrier.wait()
+  barrier = threading.Barrier(2, timeout=10)
+
+  def test_a(self): self.barrier.wait()
+
+  def test_b(self): self.barrier.wait()
 ```
 
+### Use `pytest.fail()` for intentional failures
+
+In test cases that need to intentionally fail (e.g., verifying teardown after
+failure), use `pytest.fail("reason")` instead of `assert False, "reason"`.
+The latter triggers ruff PT015 and B011.
+
 ### Constants over strings
 
 Use `ParallelScope` enum and `_constants` module instead of bare string
@@ -128,18 +142,19 @@ Every commit message starts with one or more tags in brackets:
 
 ### Tags
 
-| Tag | Scope |
-|-----|-------|
-| `[Runner]` | Core parallel execution engine (`_runner.py`, `_fixtures.py`) |
-| `[Markers]` | Marker resolution and grouping (`_markers.py`, `_grouping.py`, `_constants.py`) |
-| `[Report]` | Terminal reporting and display (`_LiveReporter`) |
-| `[Plugin]` | Plugin hooks and CLI options (`plugin.py`) |
-| `[API]` | Public API changes (`_api.py`, `__init__.py`) |
-| `[Test]` | Test additions or changes only |
-| `[Tooling]` | Ruff, pyright, pre-commit, CI, scripts |
-| `[Docs]` | README, CONTRIBUTING, docstrings |
-| `[Refactor]` | Internal restructuring, no behavior change |
-| `[Fix]` | Bug fix — must include issue number if fixing a known issue |
+| Tag          | Scope                                                                           |
+|--------------|---------------------------------------------------------------------------------|
+| `[Runner]`   | Core parallel execution engine (`_runner.py`, `_fixtures.py`)                   |
+| `[Markers]`  | Marker resolution and grouping (`_markers.py`, `_grouping.py`, `_constants.py`) |
+| `[Report]`   | Terminal reporting and display (`_LiveReporter`)                                |
+| `[Plugin]`   | Plugin hooks and CLI options (`plugin.py`)                                      |
+| `[API]`      | Public API changes (`_api.py`, `__init__.py`)                                   |
+| `[Test]`     | Test additions or changes only                                                  |
+| `[Build]`    | CI/CD pipelines, publishing, versioning                                         |
+| `[Tooling]`  | Ruff, pyright, pre-commit, scripts                                              |
+| `[Docs]`     | README, CONTRIBUTING, docstrings                                                |
+| `[Refactor]` | Internal restructuring, no behavior change                                      |
+| `[Fix]`      | Bug fix — must include issue number if fixing a known issue                     |
 
 ### Combining tags
 

{pytest_threadpool-0.3.0 → pytest_threadpool-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-threadpool
-Version: 0.3.0
+Version: 0.3.3
 Summary: Parallel test execution for free-threaded Python builds
 License-Expression: MIT
 License-File: LICENSE
@@ -13,13 +13,12 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.13
 Requires-Dist: pytest>=9.0.2
-Requires-Dist: selenium>=4.41.0
 Description-Content-Type: text/markdown
 
 # pytest-threadpool
 
-![PyPI - Version](https://img.shields.io/pypi/v/pytest-threadpool)
-![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pytest-threadpool)
+[![PyPI - Version](https://img.shields.io/pypi/v/pytest-threadpool)](https://pypi.org/project/pytest-threadpool/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pytest-threadpool)](https://pypi.org/project/pytest-threadpool/)
 [![License](https://img.shields.io/github/license/pytest-threadpool/pytest-threadpool)](https://github.com/pytest-threadpool/pytest-threadpool/blob/main/LICENSE)
 [![GitHub](https://img.shields.io/badge/GitHub-pytest--threadpool-blue?logo=github)](https://github.com/pytest-threadpool/pytest-threadpool)
 [![CI](https://github.com/pytest-threadpool/pytest-threadpool/actions/workflows/ci.yml/badge.svg)](https://github.com/pytest-threadpool/pytest-threadpool/actions/workflows/ci.yml)
@@ -27,9 +26,9 @@ Description-Content-Type: text/markdown
 
 **Status: Beta** · Parallel test execution for free-threaded Python builds (3.13t+).
 
-Runs test *bodies* and function-scoped fixture setup concurrently in a thread
-pool while keeping shared fixtures (module/class/session scope) and teardown
-sequential.
+Runs test *bodies*, function-scoped fixture setup, and function-scoped fixture
+teardown concurrently in a thread pool while keeping shared fixtures
+(module/class/session scope) sequential.
 
 ## Installation
 
@@ -88,12 +87,12 @@ sequentially before workers launch and served from cache to all items.
 
 | Scope      | Behavior                                        |
 |------------|-------------------------------------------------|
-| `function` | Cloned per-item, set up in parallel workers     |
-| `class`    | Resolved once, cached, shared across items      |
-| `module`   | Resolved once, cached, shared across items      |
-| `session`  | Resolved once, cached, shared across items      |
+| `function` | Cloned per-item, setup and teardown in parallel workers |
+| `class`    | Resolved once, cached, shared across items              |
+| `module`   | Resolved once, cached, shared across items              |
+| `session`  | Resolved once, cached, shared across items              |
 
-Teardown for all scopes runs sequentially after the parallel group completes.
+Shared fixture teardown runs sequentially after the parallel group completes.
 
 ## Marker levels
 

{pytest_threadpool-0.3.0 → pytest_threadpool-0.3.3}/README.md

@@ -1,7 +1,7 @@
 # pytest-threadpool
 
-![PyPI - Version](https://img.shields.io/pypi/v/pytest-threadpool)
-![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pytest-threadpool)
+[![PyPI - Version](https://img.shields.io/pypi/v/pytest-threadpool)](https://pypi.org/project/pytest-threadpool/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pytest-threadpool)](https://pypi.org/project/pytest-threadpool/)
 [![License](https://img.shields.io/github/license/pytest-threadpool/pytest-threadpool)](https://github.com/pytest-threadpool/pytest-threadpool/blob/main/LICENSE)
 [![GitHub](https://img.shields.io/badge/GitHub-pytest--threadpool-blue?logo=github)](https://github.com/pytest-threadpool/pytest-threadpool)
 [![CI](https://github.com/pytest-threadpool/pytest-threadpool/actions/workflows/ci.yml/badge.svg)](https://github.com/pytest-threadpool/pytest-threadpool/actions/workflows/ci.yml)
@@ -9,9 +9,9 @@
 
 **Status: Beta** · Parallel test execution for free-threaded Python builds (3.13t+).
 
-Runs test *bodies* and function-scoped fixture setup concurrently in a thread
-pool while keeping shared fixtures (module/class/session scope) and teardown
-sequential.
+Runs test *bodies*, function-scoped fixture setup, and function-scoped fixture
+teardown concurrently in a thread pool while keeping shared fixtures
+(module/class/session scope) sequential.
 
 ## Installation
 
@@ -70,12 +70,12 @@ sequentially before workers launch and served from cache to all items.
 
 | Scope      | Behavior                                        |
 |------------|-------------------------------------------------|
-| `function` | Cloned per-item, set up in parallel workers     |
-| `class`    | Resolved once, cached, shared across items      |
-| `module`   | Resolved once, cached, shared across items      |
-| `session`  | Resolved once, cached, shared across items      |
+| `function` | Cloned per-item, setup and teardown in parallel workers |
+| `class`    | Resolved once, cached, shared across items              |
+| `module`   | Resolved once, cached, shared across items              |
+| `session`  | Resolved once, cached, shared across items              |
 
-Teardown for all scopes runs sequentially after the parallel group completes.
+Shared fixture teardown runs sequentially after the parallel group completes.
 
 ## Marker levels
 

{pytest_threadpool-0.3.0 → pytest_threadpool-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pytest-threadpool"
-version = "0.3.0"
+dynamic = ["version"]
 description = "Parallel test execution for free-threaded Python builds"
 requires-python = ">=3.13"
 license = "MIT"
@@ -16,7 +16,6 @@ classifiers = [
 ]
 dependencies = [
     "pytest>=9.0.2",
-    "selenium>=4.41.0",
 ]
 
 [project.entry-points.pytest11]
@@ -30,24 +29,32 @@ dev = [
 ]
 
 [build-system]
-requires = ["hatchling"]
+requires = ["hatchling", "hatch-vcs"]
 build-backend = "hatchling.build"
 
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/pytest_threadpool/_version.py"
+
 [tool.hatch.build.targets.wheel]
 packages = ["src/pytest_threadpool"]
 
 [tool.pytest.ini_options]
 addopts = ["--threadpool", "auto"]
+norecursedirs = ["cases"]
 
 [tool.pyright]
 pythonVersion = "3.13"
 include = ["src", "tests"]
 typeCheckingMode = "standard"
 reportPrivateUsage = false
-ignore = ["tests/unit_tests"]
+ignore = ["tests/unit_tests", "src/pytest_threadpool/_version.py"]
 
 [tool.ruff]
 target-version = "py313"
+exclude = ["src/pytest_threadpool/_version.py"]
 src = ["src", "tests"]
 line-length = 99
 

{pytest_threadpool-0.3.0 → pytest_threadpool-0.3.3}/src/pytest_threadpool/_runner.py

@@ -394,7 +394,7 @@ class ParallelRunner:
                 ihook.pytest_runtest_logreport(report=setup_reports[item])
                 if setup_passed[item] and session.config.getoption("setupshow", False):
                     show_test_item(item)
-            self._teardown_all(items, per_item_fixture_fins, saved_collector_fins)
+            self._teardown_all(items, per_item_fixture_fins, {}, saved_collector_fins)
             return
 
         # Phase 1+2: fire hooks for all items, populate shared fixture caches,
@@ -470,8 +470,8 @@ class ParallelRunner:
 
         cancelled = threading.Event()
 
-        def _do_setup_and_call(test_item):
-            """Setup + call worker (for items with cloned FixtureDefs).
+        def _do_setup_call_teardown(test_item):
+            """Setup + call + teardown worker (for items with cloned FixtureDefs).
 
             Fixture setup uses cloned function-scoped FixtureDefs so each
             worker creates independent fixture instances without racing
@@ -479,13 +479,17 @@ class ParallelRunner:
             from the first item's sequential setup, so their FixtureDef.execute()
             is a cache-hit read.
 
+            Function-scoped fixture teardown (yield cleanup, addfinalizer
+            callbacks, xunit teardown_method) also runs in the worker since
+            each item's finalizers are independent.
+
             addfinalizer is redirected to a per-item list to avoid the
             setupstate stack assertion (the item IS in the stack, but
             list.append on the stack entry is also safe on free-threaded Python;
             the redirect simply avoids coupling to setupstate internals).
             """
             if cancelled.is_set():
-                return test_item, None, None, []
+                return test_item, None, None, None
 
             # Redirect node.addfinalizer to per-item list
             original_addfinalizer = test_item.addfinalizer
@@ -499,16 +503,35 @@ class ParallelRunner:
 
             if setup_info.excinfo is None:
                 fixture_fins = FixtureManager.save_and_clear_function_fixtures(test_item)
+                call_info = None
                 if not cancelled.is_set():
                     live.mark_running(test_item)
                     call_info = CallInfo.from_call(lambda: test_item.runtest(), when="call")
                     if not cancelled.is_set():
                         live.mark_call_done(test_item, call_info.excinfo)
-                    return test_item, setup_info, call_info, fixture_fins
-                return test_item, setup_info, None, fixture_fins
+
+                # Run function-scoped fixture teardown in the worker.
+                # Includes yield cleanup, addfinalizer callbacks, and
+                # node-level finalizers captured during setup.
+                all_fins = list(node_fins) + fixture_fins
+
+                def _run_fins(fns=all_fins):
+                    exceptions = []
+                    for fn in reversed(fns):
+                        try:
+                            fn()
+                        except BaseException as e:
+                            exceptions.append(e)
+                    if len(exceptions) == 1:
+                        raise exceptions[0]
+                    if exceptions:
+                        raise BaseExceptionGroup("errors during fixture teardown", exceptions)
+
+                teardown_info = CallInfo.from_call(_run_fins, when="teardown")
+                return test_item, setup_info, call_info, teardown_info
 
             FixtureManager.clear_function_fixture_caches(test_item)
-            return test_item, setup_info, None, []
+            return test_item, setup_info, None, None
 
         def _report_item(item):
             """Report a single item — live cursor mode or plain fallback."""
@@ -536,6 +559,8 @@ class ParallelRunner:
 
             reported.add(item)
 
+        teardown_infos = {}
+
         interrupted = False
         if workers > 1 and len(parallel_items) > 1:
             work_queue = queue.SimpleQueue()
@@ -547,14 +572,15 @@ class ParallelRunner:
                     if work_item is None or cancelled.is_set():
                         return
                     try:
-                        item, setup_info, call_info, fixture_fins = _do_setup_and_call(work_item)
-                        per_item_fixture_fins[item] = fixture_fins
+                        item, setup_info, call_info, td_info = _do_setup_call_teardown(work_item)
                         if setup_info is not None:
                             setup_rep = item.ihook.pytest_runtest_makereport(
                                 item=item, call=setup_info
                             )
                             setup_reports[item] = setup_rep
                             setup_passed[item] = setup_info.excinfo is None
+                        if td_info is not None:
+                            teardown_infos[item] = td_info
                         result_queue.put((item, call_info))
                     except BaseException as exc:
                         call_info = CallInfo.from_call(
@@ -569,7 +595,7 @@ class ParallelRunner:
                 t.start()
                 threads.append(t)
 
-            # Submit all parallel items (setup + call)
+            # Submit all parallel items (setup + call + teardown)
             for item in parallel_items:
                 work_queue.put(item)
 
@@ -591,17 +617,18 @@ class ParallelRunner:
                 for t in threads:
                     t.join()
         else:
-            # Single worker fallback: sequential setup + call
+            # Single worker fallback
             try:
                 for item in parallel_items:
-                    item, setup_info, call_info, fixture_fins = _do_setup_and_call(item)
-                    per_item_fixture_fins[item] = fixture_fins
+                    item, setup_info, call_info, td_info = _do_setup_call_teardown(item)
                     if setup_info is not None:
                         setup_rep = item.ihook.pytest_runtest_makereport(
                             item=item, call=setup_info
                         )
                         setup_reports[item] = setup_rep
                         setup_passed[item] = setup_info.excinfo is None
+                    if td_info is not None:
+                        teardown_infos[item] = td_info
                     if call_info is not None:
                         call_results[item] = call_info
                     _report_item(item)
@@ -622,33 +649,46 @@ class ParallelRunner:
             if item in session._setupstate.stack:  # pyright: ignore[reportPrivateUsage]
                 session._setupstate.stack.pop(item)  # pyright: ignore[reportPrivateUsage]
 
-        # Teardown (always runs, even after interrupt)
-        self._teardown_all(items, per_item_fixture_fins, saved_collector_fins)
+        # Teardown reporting + collector teardown (always runs, even after interrupt)
+        self._teardown_all(items, per_item_fixture_fins, teardown_infos, saved_collector_fins)
 
         if interrupted:
             raise KeyboardInterrupt
 
-    def _teardown_all(self, items, per_item_fixture_fins, saved_collector_fins) -> None:
-        """Run per-item function-level finalizers, saved collector finalizers,
-        then tear down remaining collectors."""
+    def _teardown_all(
+        self, items, per_item_fixture_fins, teardown_infos, saved_collector_fins
+    ) -> None:
+        """Report teardown results, run any remaining finalizers, and tear down
+        collectors.
+
+        For items with pre-computed teardown_infos (from parallel workers),
+        only reporting happens here.  For items without (setuponly mode),
+        finalizers from per_item_fixture_fins are executed sequentially.
+        """
         session = self._session
 
         for item in items:
-            fins = per_item_fixture_fins.get(item, [])
+            if item in teardown_infos:
+                # Teardown already ran in the worker — just report.
+                teardown_info = teardown_infos[item]
+            else:
+                # Fallback: run finalizers now (setuponly mode).
+                fins = per_item_fixture_fins.get(item, [])
+
+                def _run_fins(fns=fins):
+                    exceptions = []
+                    for fn in reversed(fns):
+                        try:
+                            fn()
+                        except BaseException as e:
+                            exceptions.append(e)
+                    if len(exceptions) == 1:
+                        raise exceptions[0]
+                    if exceptions:
+                        raise BaseExceptionGroup("errors during fixture teardown", exceptions)
+
+                teardown_info = CallInfo.from_call(_run_fins, when="teardown")
 
-            def _run_fins(fns=fins):
-                exceptions = []
-                for fn in reversed(fns):
-                    try:
-                        fn()
-                    except BaseException as e:
-                        exceptions.append(e)
-                if len(exceptions) == 1:
-                    raise exceptions[0]
-                if exceptions:
-                    raise BaseExceptionGroup("errors during fixture teardown", exceptions)
-
-            teardown_info = CallInfo.from_call(_run_fins, when="teardown")
             rep = item.ihook.pytest_runtest_makereport(item=item, call=teardown_info)
             item.ihook.pytest_runtest_logreport(report=rep)
 

pytest_threadpool-0.3.3/src/pytest_threadpool/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.3.3'
+__version_tuple__ = version_tuple = (0, 3, 3)
+
+__commit_id__ = commit_id = None

pytest_threadpool-0.3.3/tests/integration_tests/cases/collected_count.py

@@ -0,0 +1,23 @@
+"""Verify collected count matches actual test count (not inflated by cloning)."""
+
+import threading
+
+import pytest
+
+
+@pytest.mark.parallelizable("children")
+class TestExactCount:
+    barrier = threading.Barrier(3, timeout=10)
+
+    def test_a(self):
+        self.barrier.wait()
+
+    def test_b(self):
+        self.barrier.wait()
+
+    def test_c(self):
+        self.barrier.wait()
+
+
+def test_standalone():
+    assert True

pytest_threadpool-0.3.3/tests/integration_tests/cases/teardown_after_test_failure.py

@@ -0,0 +1,38 @@
+"""Teardown runs even when the test call fails."""
+
+import threading
+from typing import ClassVar
+
+import pytest
+
+
+class TestState:
+    teardown_log: ClassVar[list] = []
+    lock: ClassVar[threading.Lock] = threading.Lock()
+
+
+@pytest.fixture
+def resource_with_cleanup(request):
+    name = request.node.name
+    yield name
+    with TestState.lock:
+        TestState.teardown_log.append(name)
+
+
+@pytest.mark.parallelizable("children")
+class TestTeardownAfterFailure:
+    def test_pass(self, resource_with_cleanup):
+        assert True
+
+    def test_fail(self, resource_with_cleanup):
+        pytest.fail("intentional failure")
+
+    def test_raise(self, resource_with_cleanup):
+        raise RuntimeError("intentional")
+
+
+def test_verify():
+    expected = {"test_pass", "test_fail", "test_raise"}
+    assert expected == set(TestState.teardown_log), (
+        f"teardown must run for all tests including failures: {TestState.teardown_log}"
+    )

pytest_threadpool-0.3.3/tests/integration_tests/cases/teardown_parallel_timing.py

@@ -0,0 +1,55 @@
+"""Verify function-scoped fixture teardown runs in parallel, not sequentially."""
+
+import threading
+import time
+from typing import ClassVar
+
+import pytest
+
+
+class TestState:
+    teardown_end_times: ClassVar[list] = []
+    call_end_times: ClassVar[list] = []
+    lock: ClassVar[threading.Lock] = threading.Lock()
+
+
+@pytest.fixture
+def slow_teardown_resource():
+    yield "value"
+    # Each teardown takes 0.2s; if sequential that's 0.6s total
+    time.sleep(0.2)
+    with TestState.lock:
+        TestState.teardown_end_times.append(time.monotonic())
+
+
+@pytest.mark.parallelizable("children")
+class TestParallelTeardown:
+    barrier = threading.Barrier(3, timeout=10)
+
+    def _record_call(self):
+        with TestState.lock:
+            TestState.call_end_times.append(time.monotonic())
+
+    def test_a(self, slow_teardown_resource):
+        self.barrier.wait()
+        self._record_call()
+
+    def test_b(self, slow_teardown_resource):
+        self.barrier.wait()
+        self._record_call()
+
+    def test_c(self, slow_teardown_resource):
+        self.barrier.wait()
+        self._record_call()
+
+
+def test_verify():
+    assert len(TestState.teardown_end_times) == 3
+    assert len(TestState.call_end_times) == 3
+    # Measure from when tests finished to when all teardowns completed
+    teardown_duration = max(TestState.teardown_end_times) - max(TestState.call_end_times)
+    # 3 x 0.2s sequential = 0.6s; parallel should complete in ~0.2s + overhead
+    assert teardown_duration < 0.45, (
+        f"Teardown appears sequential: {teardown_duration:.2f}s "
+        f"(3 x 0.2s = 0.6s sequential, expected < 0.45s parallel)"
+    )